// — minimal agent creation form, POSTs to // swarm-controller's `POST /api/agents`. That endpoint only queues a // `CreateIdentity` job and returns its node id — the identity isn't // guaranteed to exist yet when this gets a response — so this shows // the queued confirmation and links to the Jobs page to watch it // settle, rather than duplicating JobqGraph's per-node polling here. // // Rendered inside a `Dialog` from `AgentsPage`'s own "+ agent" button, not a // standalone route: the roster it feeds is the natural home for the action // that populates it. It is a stepper (see `CreateAgentSteps`): identity, // instructions, permissions, resources and inference, then a summary that // says what will be sent and holds **create**. Every step is gone through, in // order; the header, step tabs and footer stay put while the step scrolls. // // `hive` field added because agent creation had no way to record which // hive an agent runs on. `POST /api/agents` now requires it, so the // roster fetched off `GET /api/hives` backs a required dropdown here // rather than a free-text field — a spawn target has to be one of the // swarm's actual hives, same reasoning `Ident.parse` gets client-side // pattern validation for `name`. // // Its name field, hive select, and submit button all come from the // shared `ui/` form kit (`TextField`/`SelectField`/`Button`) rather than // page-scoped input/button chrome — see that kit's own comments for why. // // Permissions: checkboxes from `GET /api/permissions`, on the default set or the // picked archetype's; sent only when that differs from the default. A caller can // open the form on an archetype with `initialArchetype`. import { useEffect, useRef, useState } from "preact/hooks"; import { Link } from "wouter-preact"; import { ApiErrorPanel } from "@hive/shared/api-error-panel.js"; import { readApiError, type ProblemDetails } from "@hive/shared/api-error.js"; import { Panel } from "../ui/panel/Panel.js"; import { TextField } from "../ui/text-field/TextField.js"; import { SelectField, type SelectOption, } from "../ui/select-field/SelectField.js"; import { TextAreaField } from "../ui/text-area-field/TextAreaField.js"; import { Button } from "../ui/button/Button.js"; import { capsBody, LimitsFields } from "../agent/detail/AgentLimits.js"; import { draftBody, draftProblem, EMPTY_INFERENCE_DRAFT, InferenceFields, type InferenceDraft, } from "../agent/detail/AgentInference.js"; import { CheckboxField } from "../ui/checkbox-field/CheckboxField.js"; import { FormField } from "../ui/form-field/FormField.js"; import { Hint } from "../ui/hint/Hint.js"; import { SectionHeading } from "../ui/section-heading/SectionHeading.js"; import { useSubmit } from "../ui/submit/useSubmit.js"; import { MultiselectFilterOptions } from "../ui/multiselect-filter/MultiselectFilter.js"; import { requestInternet, requestPermissions, togglePermission, } from "./CreateAgentPermissions.js"; import { archetypeKey, findArchetype, prefill, requestArchetype, type ArchetypeList, } from "./CreateAgentArchetype.js"; import { ArchetypePicker } from "./ArchetypePicker.js"; import { agentsMdAfterPick, agentsMdBody, agentsMdRefusal, } from "./CreateAgentAgentsMd.js"; import { NAME_PATTERN, lastReachableStep, nextStep, previousStep, STEP_TITLES, STEPS, stepProblem, summaryRows, type Step, } from "./CreateAgentSteps.js"; import "./CreateAgentForm.css"; // Mirrors swarm-controller's `HiveEntry` — same shape `HivesCard` // consumes off `/api/hives/status`, but this page hits the plain // `/api/hives` roster (no status/freshness needed, just "what hives // exist to spawn into"). interface HiveEntry { name: string; domain: string; } interface CreateAgentResponse { node_id: number; } // Mirrors swarm-controller's `Catalogue` (`GET /api/permissions`). interface PermissionCatalogue { all: string[]; default: string[]; } export function CreateAgentForm({ onClose, initialName = "", initialArchetype, }: { /** The name field's starting value, for a caller that suggests one. */ initialName?: string; /** The archetype the form opens on, once the swarm lists it. */ initialArchetype?: { source: string; name: string }; /** Rendered as the form panel's own close button — this form always * mounts inside a `plain` `Dialog` (see `AgentsPage`), which no longer * floats its own. */ onClose?: () => void; }) { const [step, setStep] = useState("identity"); const [name, setName] = useState(initialName); const [hive, setHive] = useState(""); // `null` = still loading, `[]` = loaded but empty (a real, if unusual, // swarm state) — distinct from "not fetched yet" so the placeholder // option's label can tell the two apart. const [hives, setHives] = useState(null); const [hivesError, setHivesError] = useState(null); // The done value is the queued job's node id. const { state: result, run, reset } = useSubmit(); // The optional settings sections, left empty unless the operator fills them. const [cpu, setCpu] = useState(""); const [memory, setMemory] = useState(""); const [inference, setInference] = useState( EMPTY_INFERENCE_DRAFT, ); const inferenceProblem = draftProblem(inference); // `null` until `/api/permissions` answers; `selected` starts on its default. const [catalogue, setCatalogue] = useState(null); const [catalogueError, setCatalogueError] = useState( null, ); const [selected, setSelected] = useState([]); // Unticked: the server writes `false`, so the agent starts restricted. const [internet, setInternet] = useState(false); // `null` until `/api/archetypes` answers; `archetype` is the picked one's // `archetypeKey`, `""` for none. const [archetypes, setArchetypes] = useState(null); const [archetypesError, setArchetypesError] = useState( null, ); const [archetype, setArchetype] = useState(""); // The text the agent's `AGENTS.md` starts with; empty sends none. const [agentsMd, setAgentsMd] = useState(""); const picked = archetypes?.archetypes.find( (a) => archetypeKey(a) === archetype, ); // Loaded once, not re-fetched on submit: the roster changes rarely // enough (a nix-level swarm config change) that staleness within one // page visit isn't worth a second round-trip per keystroke/submit. useEffect(() => { (async () => { const r = await fetch("/api/hives"); if (!r.ok) { setHivesError(await readApiError(r)); return; } const data = (await r.json()) as HiveEntry[]; setHives(data); // Single-hive swarms are the common case — default it rather than // making the operator pick the only option. Multi-hive swarms get // no default (the placeholder stays selected), so the identity step // cannot be left until one is picked (`stepProblem`), per mara's scope. if (data.length === 1) setHive(data[0].name); })().catch((e: unknown) => setHivesError({ detail: String(e) })); }, []); useEffect(() => { (async () => { const r = await fetch("/api/permissions"); if (!r.ok) { setCatalogueError(await readApiError(r)); return; } const data = (await r.json()) as PermissionCatalogue; setCatalogue(data); setSelected(data.default); })().catch((e: unknown) => setCatalogueError({ detail: String(e) })); }, []); useEffect(() => { (async () => { const r = await fetch("/api/archetypes"); if (!r.ok) { setArchetypesError(await readApiError(r)); return; } setArchetypes((await r.json()) as ArchetypeList); })().catch((e: unknown) => setArchetypesError({ detail: String(e) })); }, []); // Fills permissions, caps, inference and the AGENTS.md text from the picked // archetype; each stays editable, and the request carries only those fields. function pickArchetype(key: string) { setArchetype(key); const next = archetypes?.archetypes.find((a) => archetypeKey(a) === key); const p = prefill(next, catalogue?.default ?? []); setAgentsMd((current) => agentsMdAfterPick(current, picked?.prompt ?? "", next?.prompt ?? ""), ); setSelected(p.permissions); setCpu(p.cpu); setMemory(p.memory); setInference(p.inference); } // Opens on `initialArchetype` once the list and the permission catalogue are // both in, and only once, so a later pick of "none" stays. const seeded = useRef(false); useEffect(() => { if (seeded.current || !initialArchetype || !archetypes || !catalogue) return; seeded.current = true; const found = findArchetype(archetypes.archetypes, initialArchetype); if (found) pickArchetype(archetypeKey(found)); }, [archetypes, catalogue]); const unlisted = initialArchetype !== undefined && archetypes !== null && findArchetype(archetypes.archetypes, initialArchetype) === undefined; const hiveOptions: SelectOption[] = (hives ?? []).map((h) => ({ value: h.name, label: h.name, })); const hivesReady = hives !== null && hives.length > 0; // The controller's size refusal of the AGENTS.md text. It shows under the // instructions box, and `submit` sends the dialog back to that step. const refusal = result.status === "error" ? agentsMdRefusal(result.problem) : null; function submit() { // A section left empty is left out, so the request is the plain // name-and-hive one unless the operator set something. const limits = capsBody(cpu, memory); const settings = draftBody(inference); void run( () => fetch("/api/agents", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ name, hive, ...(Object.keys(limits).length > 0 ? { limits } : {}), ...(Object.keys(settings).length > 0 ? { inference: settings } : {}), permissions: catalogue ? requestPermissions(selected, catalogue.default) : undefined, ...requestInternet(internet), archetype: requestArchetype(picked), ...agentsMdBody(agentsMd), }), }), { parse: async (r) => ((await r.json()) as CreateAgentResponse).node_id, onDone: () => { setName(""); setAgentsMd(""); pickArchetype(""); }, // The text's own refusal shows beside its box, so go back to it. onError: (problem) => { if (agentsMdRefusal(problem) !== null) setStep("instructions"); }, }, ); } const problem = stepProblem(step, { name, hive, permissionsReady: catalogue !== null, inferenceProblem, }); const done = result.status === "done"; const at = STEPS.indexOf(step); // The tabs go forward again as far as the operator has been, as long as the // steps before are still valid. const [reached, setReached] = useState(0); useEffect(() => { setReached((r) => Math.max(r, at)); }, [at]); const firstBad = STEPS.findIndex( (s) => stepProblem(s, { name, hive, permissionsReady: catalogue !== null, inferenceProblem, }) !== null, ); const lastTab = lastReachableStep(reached, firstBad, at); // Why the primary button is off, said in words. const createProblem = step === "summary" && result.status !== "submitting" ? !hivesReady ? "the hive list has not loaded" : !catalogue ? "the permission list has not loaded" : null : null; const shownProblem = problem ?? createProblem; // Enter goes on to the next step, and creates only from the summary. function onSubmit(e: Event) { e.preventDefault(); if (done || result.status === "submitting") return; if (step === "summary") submit(); else if (problem === null) setStep(nextStep(step)); } function createAnother() { reset(); setStep("identity"); } return (
    {STEPS.map((s, i) => (
  1. ))}
{hivesError && ( )} {catalogueError && ( )} {archetypesError && ( )} {done && (

Queued as job node #{result.value} —{" "} watch it in jobs.

)} {!done && step === "identity" && (

A new agent's swarm-level identity: its name, the hive it runs on, and optionally an archetype that fills in the settings of the later steps. A name set up before keeps the settings stored for it.

{unlisted && initialArchetype && ( The swarm does not list the {initialArchetype.name} archetype yet, so this creates a plain agent with the default permissions. The list refreshes every 10 minutes; reopen the form once it has {initialArchetype.name}. )} {archetypes && archetypes.archetypes.length > 0 && ( <> {picked && (

{picked.description} An agent created from an archetype has no config repo: its hive builds it from the archetype's module.

)} )}
)} {!done && step === "instructions" && (

The text the agent's AGENTS.md starts with. Optional: leave it empty and the agent starts without the file. An archetype with a prompt fills the box in; edit it freely.

{refusal !== null && ( {refusal} )}
)} {!done && step === "permissions" && (

What the swarm lets the agent do. Leaving the default set ticked keeps the agent on the default if that changes.

{catalogue ? ( setSelected((s) => togglePermission(s, v)) } /> ) : ( {catalogueError ? "could not load permissions" : "loading…"} )}
)} {!done && step === "resources" && (

Optional: leave a box empty to set nothing, and the hive's or the agent's own value applies.

resource caps inference
)} {!done && step === "summary" && (
{summaryRows({ name, hive, archetype: picked?.name, permissions: catalogue ? requestPermissions(selected, catalogue.default) : undefined, caps: capsBody(cpu, memory), inference: draftBody(inference), agentsMd, }).map((row) => (
{row.label}
{row.value}
))}
{/* Describes the intended end state (a running agent), not today's literal behaviour: mara's call on this copy was to read as finished, not as a running commentary on partial implementation. */} what this creates

Creating queues everything a new agent needs: a swarm-level identity, a config repo on the forge with the operator added as a collaborator, and a container running the agent on the hive above. An agent created from an archetype gets no config repo: its container runs the archetype's module. Watch it all settle on jobs.

{result.status === "error" && refusal === null && ( )}
)}
); }