@lesscap/baton-cli 0.9.6 → 0.9.7

package/README.md

@@ -1,7 +1,7 @@
 # @lesscap/baton-cli
 
 The baton CLI: register/run a **worker** on a machine and manage
-workspaces/projects/requirements/tasks/sessions against a baton server.
+workspaces/projects/sessions against a baton server.
 
 A worker is the thing that actually runs agent sessions: it listens to the
 server's command stream and, per session, runs Claude or Codex in the worker’s working directory.
@@ -69,7 +69,7 @@ runtime `services/` directory; the run result prints their path.
 
 ## Other commands
 
-`baton init | workspace | project | requirement | task | session` — run
+`baton init | workspace | project | host | session` — run
 `baton <command> --help` for details. The back-office management commands hit
 gated routes; set `BATON_USER` / `BATON_PASS` to log in transparently (the
 worker commands above don't need this).

package/dist/baton.mjs

@@ -5376,10 +5376,10 @@ var toJson = (data) => JSON.stringify(data, null, 2);
 var fmtWorkspace = (w) => `${w.id}  ${w.name}`;
 var fmtWorkerTemplate = (t) => `${t.id}  ${t.name}  [${t.available ? "available" : "unavailable"}]  ${t.agentKinds.join(", ")}`;
 var fmtWorkerCreation = (c) => `${c.id}  [${c.status}/${c.step ?? "pending"}]  ${c.name}  ${c.agentKind}${c.workerId === null ? "" : `  W-${c.workerId}`}${c.error ? `  ${c.error}` : ""}`;
+var fmtHost = (h) => `${h.id}  ${h.name}  [${h.online ? "online" : "offline"}]  workspaces: ${h.workspaceIds.join(",") || "-"}`;
+var fmtHostCredential = ({ host: host2, token }) => `${host2.id}  ${host2.name}
+token: ${token}`;
 var fmtProject = (p) => `${p.id}  ${p.name}`;
-var fmtRequirement = (r) => `${r.code}  [${r.status}]  ${r.title}`;
-var fmtTask = (t) => `${t.code}  [${t.status}]  ${t.title}`;
-var fmtComment = (c) => `${c.workerId !== void 0 ? `worker#${c.workerId}` : "you"}  ${c.body}`;
 var fmtSession = (s) => `${s.id}  ${s.name}  ${s.attached ? "[active]" : "[inactive]"}  ${s.cwd ?? "(pending)"}`;
 var fmtWorker = (w) => {
   const offline = w.connected === false ? "  [offline]" : "";
@@ -5509,6 +5509,15 @@ var filesClient = (baseUrl) => {
   };
 };
 
+// src/client/hosts.ts
+var hostsClient = (baseUrl) => ({
+  create: (name) => request(`${baseUrl}/hosts`, { method: "POST", body: { name } }),
+  list: () => request(`${baseUrl}/hosts`, { method: "GET" }),
+  rotate: (id) => request(`${baseUrl}/hosts/${id}/token`, { method: "POST", body: {} }),
+  assign: (id, workspaceId) => request(`${baseUrl}/hosts/${id}/workspaces/${workspaceId}`, { method: "PUT" }),
+  unassign: (id, workspaceId) => request(`${baseUrl}/hosts/${id}/workspaces/${workspaceId}`, { method: "DELETE" })
+});
+
 // src/client/loops.ts
 var loopsClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
@@ -5535,30 +5544,6 @@ var projectClient = (baseUrl) => {
   };
 };
 
-// src/client/items.ts
-var fetchItemByCode = async (baseUrl, projectId, code, expectKind) => {
-  const r = await request(
-    `${baseUrl}/projects/${projectId}/items/${encodeURIComponent(code)}`,
-    { method: "GET" }
-  );
-  if (r.kind !== expectKind) throw new Error(`expected ${expectKind} but got ${r.kind} for ${code}`);
-  return r.item;
-};
-
-// src/client/requirements.ts
-var requirementClient = (baseUrl) => {
-  const u = (p) => `${baseUrl}${p}`;
-  return {
-    create: (input) => request(u("/requirements"), { method: "POST", body: input }),
-    listByProject: (projectId) => request(u(`/projects/${projectId}/requirements`), { method: "GET" }),
-    get: (id) => request(u(`/requirements/${id}`), { method: "GET" }),
-    getByCode: (projectId, code) => fetchItemByCode(baseUrl, projectId, code, "requirement"),
-    update: (id, patch) => request(u(`/requirements/${id}`), { method: "PATCH", body: patch }),
-    setStatus: (id, status) => request(u(`/requirements/${id}`), { method: "PATCH", body: { status } }),
-    remove: (id) => request(u(`/requirements/${id}`), { method: "DELETE" })
-  };
-};
-
 // src/client/services.ts
 var servicesClient = (baseUrl) => {
   const u = (path) => `${baseUrl}${path}`;
@@ -5693,24 +5678,9 @@ var sessionsClient = (baseUrl) => {
   };
 };
 
-// src/client/tasks.ts
-var taskClient = (baseUrl) => {
-  const u = (p) => `${baseUrl}${p}`;
-  return {
-    create: (input) => request(u("/tasks"), { method: "POST", body: input }),
-    listByRequirement: (requirementId) => request(u(`/requirements/${requirementId}/tasks`), { method: "GET" }),
-    get: (id) => request(u(`/tasks/${id}`), { method: "GET" }),
-    getByCode: (projectId, code) => fetchItemByCode(baseUrl, projectId, code, "task"),
-    update: (id, patch) => request(u(`/tasks/${id}`), { method: "PATCH", body: patch }),
-    setStatus: (id, status) => request(u(`/tasks/${id}`), { method: "PATCH", body: { status } }),
-    remove: (id) => request(u(`/tasks/${id}`), { method: "DELETE" }),
-    listComments: (id) => request(u(`/tasks/${id}/comments`), { method: "GET" }),
-    addComment: (id, body, workerId) => request(u(`/tasks/${id}/comments`), { method: "POST", body: { body, workerId } })
-  };
-};
-
 // src/client/worker-creations.ts
 var workerCreationsClient = (baseUrl) => ({
+  hosts: (projectId) => request(`${baseUrl}/projects/${projectId}/hosts`, { method: "GET" }),
   templates: (projectId) => request(`${baseUrl}/projects/${projectId}/worker-templates`, { method: "GET" }),
   create: (projectId, input) => request(`${baseUrl}/projects/${projectId}/worker-creations`, { method: "POST", body: input }),
   listByProject: (projectId) => request(`${baseUrl}/projects/${projectId}/worker-creations`, { method: "GET" }),
@@ -5758,11 +5728,10 @@ var createClient = (baseUrl, opts) => {
 };
 var clientFromBase = (baseUrl) => ({
   workerCreations: workerCreationsClient(baseUrl),
+  hosts: hostsClient(baseUrl),
   artifacts: artifactsClient(baseUrl),
   workspaces: workspaceClient(baseUrl),
   projects: projectClient(baseUrl),
-  requirements: requirementClient(baseUrl),
-  tasks: taskClient(baseUrl),
   sessions: sessionsClient(baseUrl),
   services: servicesClient(baseUrl),
   files: filesClient(baseUrl),
@@ -7114,6 +7083,87 @@ var channel = defineCommand({
   }
 });
 
+// src/commands/host.ts
+var findHost = (hosts, handle) => {
+  const host2 = hosts.find((item) => item.name === handle || String(item.id) === handle);
+  if (!host2) throw new Error(`host not found: ${handle}`);
+  return host2;
+};
+var adminHost = async (c, handle) => findHost(await c.hosts.list(), handle);
+var positiveId = (raw) => {
+  const id = Number(raw);
+  if (!Number.isSafeInteger(id) || id <= 0) throw new Error("workspace must be a positive id");
+  return id;
+};
+var hostArg = {
+  host: { type: "positional", required: true, description: "host name or id" }
+};
+var workspaceArg = {
+  workspace: { type: "string", required: true, description: "workspace id" }
+};
+var host = defineCommand({
+  meta: { name: "host", description: "manage machines and which workspaces can use them (admin)" },
+  subCommands: {
+    add: defineCommand({
+      meta: { name: "add", description: "add a host; prints its Provisioner token once" },
+      args: {
+        name: { type: "positional", required: true, description: "host name" },
+        workspace: { type: "string", description: "also assign it to this workspace id" },
+        ...common
+      },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const workspaceId = args.workspace === void 0 ? null : positiveId(args.workspace);
+        const credential = await c.hosts.create(args.name);
+        console.log(renderOne(credential, fmtHostCredential, Boolean(args.json)));
+        if (workspaceId !== null) await c.hosts.assign(credential.host.id, workspaceId);
+      }
+    }),
+    ls: defineCommand({
+      meta: {
+        name: "ls",
+        description: "list hosts, whether they are online, and their workspaces"
+      },
+      args: { ...common },
+      run: async ({ args }) => {
+        console.log(renderList(await clientFor(args).hosts.list(), fmtHost, Boolean(args.json)));
+      }
+    }),
+    assign: defineCommand({
+      meta: { name: "assign", description: "let a workspace create Workers on this host" },
+      args: { ...hostArg, ...workspaceArg, ...common },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const { id, name } = await adminHost(c, args.host);
+        await c.hosts.assign(id, positiveId(args.workspace));
+        console.log(`assigned ${name} to workspace ${args.workspace}`);
+      }
+    }),
+    unassign: defineCommand({
+      meta: {
+        name: "unassign",
+        description: "stop new Workers on this host for a workspace; existing ones keep running"
+      },
+      args: { ...hostArg, ...workspaceArg, ...common },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const { id, name } = await adminHost(c, args.host);
+        await c.hosts.unassign(id, positiveId(args.workspace));
+        console.log(`unassigned ${name} from workspace ${args.workspace}`);
+      }
+    }),
+    rotate: defineCommand({
+      meta: { name: "rotate", description: "replace a host token; the old one stops working" },
+      args: { ...hostArg, ...common },
+      run: async ({ args }) => {
+        const c = clientFor(args);
+        const { id } = await adminHost(c, args.host);
+        console.log(renderOne(await c.hosts.rotate(id), fmtHostCredential, Boolean(args.json)));
+      }
+    })
+  }
+});
+
 // src/commands/init.ts
 import { existsSync as existsSync2 } from "node:fs";
 import * as readline from "node:readline/promises";
@@ -7467,9 +7517,9 @@ var environment = (value) => {
 var templates = (value) => {
   if (!object(value)) throw new Error("templates must be an object");
   return Object.fromEntries(
-    WORKER_TEMPLATES.map((template) => {
+    WORKER_TEMPLATES.filter((template) => value[template.id] !== void 0).map((template) => {
       const raw = value[template.id];
-      if (!object(raw)) throw new Error(`template ${template.id} must be configured`);
+      if (!object(raw)) throw new Error(`template ${template.id} must be an object`);
       const workerEnv2 = environment(raw.workerEnv);
       if (template.id === "mini-codex") {
         if (raw.pi !== void 0) throw new Error("mini-codex does not support pi");
@@ -7674,12 +7724,17 @@ var installProvisionerAgent = async (config, configPath) => startAgent(config, {
 // src/provisioner/worker-template.ts
 import { mkdir as mkdir2, writeFile } from "node:fs/promises";
 import { join as join4 } from "node:path";
-var workerTemplateEnvironment = async (config, creation, state) => {
+var requireWorkerTemplate = (config, creation) => {
   if (!workerTemplateAgentKinds(creation.templateId).includes(creation.agentKind))
     throw new Error("agentKind is not supported by this template");
-  if (creation.templateId === "mini-local") return config.workerEnv;
+  if (creation.templateId === "mini-local") return null;
   const profile = config.templates[creation.templateId];
-  if (!profile) throw new Error(`template ${creation.templateId} is not configured`);
+  if (!profile) throw new Error(`template ${creation.templateId} is not configured on this host`);
+  return profile;
+};
+var workerTemplateEnvironment = async (config, creation, state) => {
+  const profile = requireWorkerTemplate(config, creation);
+  if (!profile) return config.workerEnv;
   if (creation.agentKind !== "pi") return profile.workerEnv;
   if (!profile.pi) throw new Error("Pi provider and model are not configured");
   const agentDir = join4(state, "pi");
@@ -7765,6 +7820,7 @@ var adoptRepository = async (config, creation, repoPath, progress, signal) => {
     throw new Error(`not the root of a Git work tree: ${repoPath}`);
 };
 var provisionWorker = async (config, creation, client, signal) => {
+  requireWorkerTemplate(config, creation);
   const shared = creation.repoPath !== null;
   const repoPath = creation.repoPath ?? join5(config.projectsRoot, `project-${creation.projectId}`, `creation-${creation.id}`);
   const progress = (step) => client.report(creation.id, { status: "running", step, repoPath }, signal);
@@ -8148,118 +8204,6 @@ var relay = defineCommand({
   subCommands: { host: hostCommand, listen: listenCommand2, send: sendCommand2 }
 });
 
-// src/commands/requirement.ts
-var createRequirement = (c, input, json) => c.requirements.create(input).then((r) => renderOne(r, fmtRequirement, json));
-var updateRequirement = (c, id, patch, json) => c.requirements.update(id, patch).then((r) => renderOne(r, fmtRequirement, json));
-var listRequirements = (c, projectId, json) => c.requirements.listByProject(projectId).then((rs) => renderList(rs, fmtRequirement, json));
-var getRequirement = (c, id, json) => c.requirements.get(id).then((r) => renderOne(r, fmtRequirement, json));
-var setRequirementStatus = (c, id, status, json) => c.requirements.setStatus(id, status).then((r) => renderOne(r, fmtRequirement, json));
-var removeRequirement = (c, id, label, json) => c.requirements.remove(id).then(() => removed("requirement", label, json));
-var resolveByCode = async (c, projectId, code) => (await c.requirements.getByCode(projectId, code)).id;
-var requirement = defineCommand({
-  meta: { name: "requirement", description: "manage requirements" },
-  subCommands: {
-    create: defineCommand({
-      meta: { name: "create", description: "create a requirement" },
-      args: {
-        title: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        desc: { type: "string", description: "description" },
-        body: { type: "string", description: "requirement body (markdown)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        console.log(
-          await createRequirement(
-            clientFor(args),
-            {
-              projectId: resolveProjectId(args),
-              title: args.title,
-              description: args.desc,
-              body: args.body
-            },
-            Boolean(args.json)
-          )
-        );
-      }
-    }),
-    update: defineCommand({
-      meta: { name: "update", description: "update a requirement title / body" },
-      args: {
-        code: { type: "positional", required: true, description: "requirement code (R-N)" },
-        title: { type: "string", description: "new title" },
-        body: { type: "string", description: "new body (markdown)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const patch = {
-          ...args.title !== void 0 ? { title: args.title } : {},
-          ...args.body !== void 0 ? { body: args.body } : {}
-        };
-        if (Object.keys(patch).length === 0) throw new Error("pass --title and/or --body");
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(await updateRequirement(c, id, patch, Boolean(args.json)));
-      }
-    }),
-    ls: defineCommand({
-      meta: { name: "ls", description: "list requirements in a project" },
-      args: {
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        console.log(
-          await listRequirements(clientFor(args), resolveProjectId(args), Boolean(args.json))
-        );
-      }
-    }),
-    get: defineCommand({
-      meta: { name: "get", description: "get a requirement by code (R-N)" },
-      args: {
-        code: { type: "positional", required: true, description: "requirement code, e.g. R-1" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(await getRequirement(c, id, Boolean(args.json)));
-      }
-    }),
-    "set-status": defineCommand({
-      meta: { name: "set-status", description: "set requirement status (active|done|cancelled)" },
-      args: {
-        code: { type: "positional", required: true, description: "requirement code (R-N)" },
-        status: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(
-          await setRequirementStatus(c, id, args.status, Boolean(args.json))
-        );
-      }
-    }),
-    rm: defineCommand({
-      meta: { name: "rm", description: "delete a requirement by code" },
-      args: {
-        code: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveByCode(c, resolveProjectId(args), args.code);
-        console.log(await removeRequirement(c, id, args.code, Boolean(args.json)));
-      }
-    })
-  }
-});
-
 // src/commands/service.ts
 import { resolve as resolve2 } from "node:path";
 
@@ -9877,165 +9821,6 @@ var session = defineCommand({
   }
 });
 
-// src/commands/task.ts
-var createTask = (c, input, json) => c.tasks.create(input).then((t) => renderOne(t, fmtTask, json));
-var updateTask = (c, id, patch, json) => c.tasks.update(id, patch).then((t) => renderOne(t, fmtTask, json));
-var listTasks = (c, requirementId, json) => c.tasks.listByRequirement(requirementId).then((ts) => renderList(ts, fmtTask, json));
-var getTask = (c, id, json) => c.tasks.get(id).then((t) => renderOne(t, fmtTask, json));
-var setTaskStatus = (c, id, status, json) => c.tasks.setStatus(id, status).then((t) => renderOne(t, fmtTask, json));
-var removeTask = (c, id, label, json) => c.tasks.remove(id).then(() => removed("task", label, json));
-var addTaskComment = (c, taskId, body, workerId, json) => c.tasks.addComment(taskId, body, workerId).then((x) => renderOne(x, fmtComment, json));
-var listTaskComments = (c, taskId, json) => c.tasks.listComments(taskId).then((xs) => renderList(xs, fmtComment, json));
-var resolveReqByCode = async (c, projectId, code) => (await c.requirements.getByCode(projectId, code)).id;
-var resolveTaskByCode = async (c, projectId, code) => (await c.tasks.getByCode(projectId, code)).id;
-var task = defineCommand({
-  meta: { name: "task", description: "manage tasks" },
-  subCommands: {
-    create: defineCommand({
-      meta: { name: "create", description: "create a task" },
-      args: {
-        title: { type: "positional", required: true },
-        requirement: { type: "string", required: true, description: "requirement code (R-N)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        body: { type: "string", description: "task body (markdown)" },
-        deps: { type: "string", description: "comma-separated dependency task codes (T-N,T-N)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const projectId = resolveProjectId(args);
-        const requirementId = await resolveReqByCode(c, projectId, args.requirement);
-        const depCodes = splitCsv(args.deps) ?? [];
-        const dependsOn = await Promise.all(
-          depCodes.map((code) => resolveTaskByCode(c, projectId, code))
-        );
-        console.log(
-          await createTask(
-            c,
-            {
-              requirementId,
-              title: args.title,
-              body: args.body,
-              dependsOn: dependsOn.length ? dependsOn : void 0
-            },
-            Boolean(args.json)
-          )
-        );
-      }
-    }),
-    update: defineCommand({
-      meta: { name: "update", description: "update a task title / body" },
-      args: {
-        code: { type: "positional", required: true, description: "task code (T-N)" },
-        title: { type: "string", description: "new title" },
-        body: { type: "string", description: "new body (markdown)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const patch = {
-          ...args.title !== void 0 ? { title: args.title } : {},
-          ...args.body !== void 0 ? { body: args.body } : {}
-        };
-        if (Object.keys(patch).length === 0) throw new Error("pass --title and/or --body");
-        const c = clientFor(args);
-        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await updateTask(c, id, patch, Boolean(args.json)));
-      }
-    }),
-    ls: defineCommand({
-      meta: { name: "ls", description: "list tasks in a requirement" },
-      args: {
-        requirement: { type: "string", required: true, description: "requirement code (R-N)" },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const reqId = await resolveReqByCode(c, resolveProjectId(args), args.requirement);
-        console.log(await listTasks(c, reqId, Boolean(args.json)));
-      }
-    }),
-    get: defineCommand({
-      meta: { name: "get", description: "get a task by code (T-N)" },
-      args: {
-        code: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await getTask(c, id, Boolean(args.json)));
-      }
-    }),
-    "set-status": defineCommand({
-      meta: {
-        name: "set-status",
-        description: "set task status (todo|in_progress|blocked|done|failed|cancelled)"
-      },
-      args: {
-        code: { type: "positional", required: true, description: "task code (T-N)" },
-        status: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await setTaskStatus(c, id, args.status, Boolean(args.json)));
-      }
-    }),
-    rm: defineCommand({
-      meta: { name: "rm", description: "delete a task by code" },
-      args: {
-        code: { type: "positional", required: true },
-        project: { type: "string", description: "project id (overrides .baton.json)" },
-        ...common
-      },
-      run: async ({ args }) => {
-        const c = clientFor(args);
-        const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-        console.log(await removeTask(c, id, args.code, Boolean(args.json)));
-      }
-    }),
-    comment: defineCommand({
-      meta: { name: "comment", description: "append-only task comments" },
-      subCommands: {
-        add: defineCommand({
-          meta: { name: "add", description: "add a comment to a task" },
-          args: {
-            code: { type: "positional", required: true, description: "task code (T-N)" },
-            body: { type: "positional", required: true, description: "comment text (markdown)" },
-            worker: { type: "string", description: "attribute to a worker id (omit = human)" },
-            project: { type: "string", description: "project id (overrides .baton.json)" },
-            ...common
-          },
-          run: async ({ args }) => {
-            const c = clientFor(args);
-            const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-            const workerId = args.worker ? Number(args.worker) : void 0;
-            console.log(await addTaskComment(c, id, args.body, workerId, Boolean(args.json)));
-          }
-        }),
-        ls: defineCommand({
-          meta: { name: "ls", description: "list a task\u2019s comments in order" },
-          args: {
-            code: { type: "positional", required: true, description: "task code (T-N)" },
-            project: { type: "string", description: "project id (overrides .baton.json)" },
-            ...common
-          },
-          run: async ({ args }) => {
-            const c = clientFor(args);
-            const id = await resolveTaskByCode(c, resolveProjectId(args), args.code);
-            console.log(await listTaskComments(c, id, Boolean(args.json)));
-          }
-        })
-      }
-    })
-  }
-});
-
 // src/commands/worker/index.ts
 import { hostname as osHostname } from "node:os";
 
@@ -11605,7 +11390,7 @@ var readOrCreateMachineId = (path = machineIdPath()) => {
 var projectArg = {
   project: { type: "string", description: "project id (overrides .baton.json)" }
 };
-var positiveId = (raw) => {
+var positiveId2 = (raw) => {
   const id = Number(raw);
   if (!Number.isSafeInteger(id) || id <= 0) throw new Error("positive id required");
   return id;
@@ -11614,12 +11399,12 @@ var workerTemplatesCommand = defineCommand({
   meta: { name: "templates", description: "list worker creation templates for a project" },
   args: { ...projectArg, ...common },
   run: async ({ args }) => {
-    const list = await clientFor(args).workerCreations.templates(positiveId(resolveProjectId(args)));
+    const list = await clientFor(args).workerCreations.templates(positiveId2(resolveProjectId(args)));
     console.log(renderList(list, fmtWorkerTemplate, Boolean(args.json)));
   }
 });
 var workerCreateCommand = defineCommand({
-  meta: { name: "create", description: "request a worker from the mini template (asynchronous)" },
+  meta: { name: "create", description: "request a worker from a template (asynchronous)" },
   args: {
     ...projectArg,
     ...common,
@@ -11633,6 +11418,10 @@ var workerCreateCommand = defineCommand({
     repoPath: {
       type: "string",
       description: "share an existing worker's directory in this project (default: a new one)"
+    },
+    host: {
+      type: "string",
+      description: "host name or id (default: the workspace's only host)"
     }
   },
   run: async ({ args }) => {
@@ -11643,15 +11432,16 @@ var workerCreateCommand = defineCommand({
       throw new Error("agentKind is not supported by this template");
     const name = args.name.trim();
     if (!name) throw new Error("worker name required");
-    const creation = await clientFor(args).workerCreations.create(
-      positiveId(resolveProjectId(args)),
-      {
-        templateId: args.template,
-        name,
-        agentKind,
-        ...args.repoPath ? { repoPath: args.repoPath } : {}
-      }
-    );
+    const client = clientFor(args);
+    const projectId = positiveId2(resolveProjectId(args));
+    const host2 = args.host ? findHost(await client.workerCreations.hosts(projectId), args.host) : null;
+    const creation = await client.workerCreations.create(projectId, {
+      templateId: args.template,
+      name,
+      agentKind,
+      ...args.repoPath ? { repoPath: args.repoPath } : {},
+      ...host2 ? { hostId: host2.id } : {}
+    });
     console.log(renderOne(creation, fmtWorkerCreation, Boolean(args.json)));
   }
 });
@@ -11662,7 +11452,7 @@ var workerCreationCommand = defineCommand({
       args: { ...projectArg, ...common },
       run: async ({ args }) => {
         const list = await clientFor(args).workerCreations.listByProject(
-          positiveId(resolveProjectId(args))
+          positiveId2(resolveProjectId(args))
         );
         console.log(renderList(list, fmtWorkerCreation, Boolean(args.json)));
       }
@@ -11670,7 +11460,7 @@ var workerCreationCommand = defineCommand({
     get: defineCommand({
       args: { ...common, id: { type: "positional", required: true } },
       run: async ({ args }) => {
-        const creation = await clientFor(args).workerCreations.get(positiveId(args.id));
+        const creation = await clientFor(args).workerCreations.get(positiveId2(args.id));
         console.log(renderOne(creation, fmtWorkerCreation, Boolean(args.json)));
       }
     })
@@ -11962,13 +11752,14 @@ var workspace = defineCommand({
 var main = defineCommand({
   meta: {
     name: "baton",
-    description: "baton \u2014 run a worker daemon; manage projects / requirements / tasks / sessions"
+    description: "baton \u2014 run a worker daemon; manage projects / sessions"
   },
   // Order matters: high-level verbs first so --help shows them on top.
   subCommands: {
     init,
     worker,
     provisioner,
+    host,
     session,
     service,
     artifact,
@@ -11977,9 +11768,7 @@ var main = defineCommand({
     relay,
     channel,
     workspace,
-    project,
-    requirement,
-    task
+    project
   }
 });
 runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lesscap/baton-cli",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "license": "MIT",
   "publishConfig": {
     "access": "public"