@scp-dev/cli 0.2.0 → 0.2.2

package/dist/join-RGFHOSLE.js

@@ -0,0 +1,48 @@
+import {
+  RelayUsage,
+  localHandle,
+  relayIdentity,
+  sessionKey,
+  startDaemon,
+  walkNow
+} from "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/join.ts
+import { CLI_NAME } from "@scp-dev/core";
+import { connectBroker, readSessionMarker, relayDir } from "@scp-dev/broker";
+async function joinCommand(values, positionals, cwd, out) {
+  if (positionals.length > 1) throw new RelayUsage(`${CLI_NAME} join takes one handle, or none to keep the session's name`);
+  const handle = positionals[0] === void 0 ? void 0 : localHandle(positionals[0]);
+  const { keys, self } = walkNow();
+  const key = self.at(-1);
+  const match = key === void 0 ? null : /^pid:(\d+):(.+)$/.exec(key);
+  if (!match) throw new RelayUsage(`${CLI_NAME} join runs in an agent session's shell: no harness process runs this shell`);
+  const dir = relayDir();
+  const known = readSessionMarker(dir, sessionKey(process.env, key))?.handle;
+  const claim = relayIdentity({
+    ...known ? { as: known } : {},
+    ...typeof values.harness === "string" ? { harness: values.harness } : {},
+    fallbackHarness: "cli",
+    cwd,
+    env: process.env,
+    harnessPid: () => Number(match[1]),
+    startOf: () => match[2],
+    lineageOf: () => keys.slice(Math.max(0, keys.indexOf(key)))
+  });
+  const client = await connectBroker(dir, () => startDaemon(dir));
+  try {
+    const under = typeof values.under === "string" ? values.under : void 0;
+    const hello = await client.hello({ transient: true, claim, join: { ...handle ? { handle } : {}, ...under ? { under } : {} } });
+    const view = hello.endpoint;
+    if (values.json === true) out(JSON.stringify(view, null, 2));
+    else
+      out(`joined as ${view.address}${view.parent ? ` under ${view.parent}` : ""}: peers can message it, and its hooks hand it new messages at turn boundaries`);
+  } finally {
+    client.close();
+  }
+  return 0;
+}
+export {
+  joinCommand
+};

package/dist/{login-V2WT7QX5.js → login-IPS75GLQ.js}

@@ -1,17 +1,14 @@
 import {
   machineName
-} from "./chunk-U2RSSTNW.js";
+} from "./chunk-ZDU53ZRF.js";
 import {
+  RelayUsage,
   activeRelay,
   saveCredential
-} from "./chunk-3RRPUYTE.js";
-import {
-  RelayUsage
-} from "./chunk-3V3DRXB2.js";
-import "./chunk-E53YHYEP.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   note
-} from "./chunk-M2DCR2J4.js";
+} from "./chunk-MNTIEWKF.js";
 
 // src/login.ts
 import { spawn } from "child_process";

package/dist/{main-HPBTO3JK.js → main-YN3J6MGW.js}

@@ -11,20 +11,18 @@ import {
   open,
   preset,
   selectorList,
+  shortHostname,
   stamp,
   startDaemon,
   time
-} from "./chunk-3V3DRXB2.js";
-import {
-  shortHostname
-} from "./chunk-E53YHYEP.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   FAILED,
   exitFlushed,
   note,
   parseSeconds,
   printTable
-} from "./chunk-M2DCR2J4.js";
+} from "./chunk-MNTIEWKF.js";
 
 // src/main.ts
 import { text as readAll } from "stream/consumers";
@@ -35,7 +33,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.2.0",
+  version: "0.2.2",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -66,6 +64,9 @@ var package_default = {
     "smol-toml": "^1.9.1"
   },
   devDependencies: {
+    "@openai/codex": "0.159.0",
+    "@scp-dev/mesh": "workspace:*",
+    "opencode-ai": "1.18.34",
     tsup: "^8.5.1"
   },
   publishConfig: {
@@ -98,7 +99,9 @@ results back, as with native subagents.
   ${CLI_NAME} reply <id> [text|-]         answer a message in its thread: ${CLI_NAME} reply 5af1f2 "done"
   ${CLI_NAME} ask <to> [text|-] [--wait S]   send a request and wait for its reply: ${CLI_NAME} ask lead "which branch?"
   ${CLI_NAME} inbox [--wait S]            your unread messages, then marked read: ${CLI_NAME} inbox
-  ${CLI_NAME} list [--all]                agents on the relay: address, title, presence, status
+  ${CLI_NAME} list [--all]                agents on the relay: address, title, presence, status; --all adds offline ones
+  ${CLI_NAME} join [name]                 put this session on the relay, named once: ${CLI_NAME} join lead (${CLI_NAME} name renames it)
+  ${CLI_NAME} join --under <parent>       link this session under an orchestrator, as a spawned worker sits: ${CLI_NAME} join --under lead
   ${CLI_NAME} status [id]                 the fleet in short; with the id of a message you sent: who read it when
   ${CLI_NAME} peek <ep>                   a short, redacted view of a peekable agent's last turns: ${CLI_NAME} peek rev
   ${CLI_NAME} set-status <state> [note]   working, waiting, blocked or done: ${CLI_NAME} set-status done "PR open"
@@ -123,8 +126,10 @@ usage:
                                                  sessions nobody spawned that spawned nobody fold into one line, --roots (or --all) lists
                                                  them; --tree nests them by parent; (you) marks your own
   ${CLI_NAME} list --contacts                    the endpoints of other accounts your contacts let you reach: address, harness, presence
-  ${CLI_NAME} send <to> [text|-]                 send a message (- or no text reads stdin); a line per recipient says when it sees it
-        [--reply-to ID] [--thread ID] [--private] [--attach PATH]...   --thread takes a thread id or the <id> of a message in it
+  ${CLI_NAME} send <to> [text|-]                 send a message (- or no text reads stdin); a line per recipient says when it sees it,
+        [--reply-to ID] [--thread ID] [--private] [--attach PATH]... [--live]   and "queued: no live session holds <addr>" for one
+                                                 that is offline; --live refuses those (not_live) and queues nothing;
+                                                 --thread takes a thread id or the <id> of a message in it
   ${CLI_NAME} reply <id> [text|-]                reply to message <id>: to its sender, in its thread, marking it read; <id> may
                                                  also be another's message in a thread you sent or got a message in
   ${CLI_NAME} inbox [--wait S] [--keep]          your unread messages, then marked read (--keep leaves them unread); --wait waits up
@@ -227,6 +232,8 @@ scopes (selectors are comma-separated, e.g. tree:parent,tree:children,group:team
                                                  -c sandbox_workspace_write.network_access=true (the relay socket counts as network)
   ${CLI_NAME} pi [--name N] [--] [pi args...]    runs pi with the @scp-dev/pi extension: the relay tools, and each new
                                                  message as a turn (steering a running one, waking an idle session)
+  ${CLI_NAME} codex [--name N] [--headless] [--] [codex args...]
+                                                 runs codex with relay messages waking an idle thread or steering a running turn
   ${CLI_NAME} peers [--all] [--roots]            who you may message: title, status and the rule that admits each; offline ones and
                                                  sessions nobody spawned that spawned nobody only with --all (--roots: those sessions)
   ${CLI_NAME} why <from> <to>                    whether from may message to, and why
@@ -262,6 +269,30 @@ agent sessions:
   ${CLI_NAME} claude [--name N] [--] [claude args...]   start Claude Code with the scp channel loaded, so peer messages wake
                                                  it while idle (claude --dangerously-load-development-channels server:scp; SCP_NAME=N)
   --channels pushes messages into a Claude Code that ${CLI_NAME} claude started; setup mounts claude's shim with it.
+  Without --name, ${CLI_NAME} claude asks the session to pick its own name with ${CLI_NAME} name <name>.
+  ${CLI_NAME} join [<handle>]                    put the session that runs this shell on the relay (it then shows in list,
+                                                 peers can message it, and its hooks hand it new messages), named <handle>
+                                                 when given; on a joined session it renames it in place. Works for a session
+                                                 started before the hooks were installed too. Tell any session: ${CLI_NAME} join <name>
+  ${CLI_NAME} name [<handle>] [--endpoint EP]    print this session's address, or rename it in place: id, mail, threads, status
+                                                 and title stay; a handle another endpoint holds, live or offline, is refused;
+                                                 a spawned worker is named by its spawner (policy defaults.rename: self lets it);
+                                                 --endpoint renames another agent, for the human at a terminal
+  ${CLI_NAME} join [<handle>] --under <parent>   link the session under the agent <parent> (local, one it may message), as if
+                                                 <parent> had spawned it: it shows under <parent> in list --tree, the dashboard
+                                                 and the graph, and takes on a worker's scope (the policy's child_default: by
+                                                 default it reaches only what <parent> reaches). Narrowing, so always allowed
+  ${CLI_NAME} adopt <child> [--parent <p>]      link a local root agent and its subtree under <p>, for the human at a terminal;
+                                                 from an agent's shell with a terminal attached <p> defaults to that agent.
+                                                 An agent without a terminal is refused: the session joins with --under itself
+  ${CLI_NAME} unlink [<child>]                  put a linked agent back at the root, its subtree along and the child scope off;
+                                                 widening, so the human at a terminal only (policy defaults.unlink: self lets
+                                                 an agent unlink itself). A link that would put a parent under its own child
+                                                 (a cycle) is refused; both are audited, as adopt and unlink
+  ${CLI_NAME} leave [--endpoint EP]              take this session off the relay: offline, no messages pushed, mail kept until
+                                                 ${CLI_NAME} join; a spawned worker stays joined while it runs
+  With setup --join manual a session stays off the relay until it runs ${CLI_NAME} join; the default, auto, joins every
+  hooked session when it starts.
 
 relay:
   ${CLI_NAME} relay use <url> | show            select a relay, or show its source and credential status
@@ -277,7 +308,8 @@ identity:
   --as HANDLE (or --as=HANDLE, anywhere on the line, or $SCP_NAME, a local handle; a leading me/ is dropped) acts as that agent, with --harness H
   ($SCP_HARNESS, default cli), $SCP_LABELS (role=impl,lane=relay) and $SCP_PARENT. An offline
   agent of the same handle and harness is taken back with its inbox; a handle a live session holds is refused, never
-  renamed. Run from that agent's own process, it acts as the agent, narrowing only.
+  suffixed. Run from that agent's own process, it acts as the agent, narrowing only. A session renamed with join or
+  name keeps its new handle: its hooks, its shim and commands with $SCP_NAME from its shell claim that one.
   Without --as, at a terminal or with --human you are your own human inbox (me/); messages sent with --human and no
   terminal are marked tty="false" and get no scope exemption. From an agent's process, --human acts as that agent.
   Without either and without a terminal, a command acts as the agent whose harness process runs this shell (the
@@ -327,7 +359,12 @@ var VERB_OPTIONS = {
 var IDENTITY = ["as", "harness", "human", "json", "cloud", "machine"];
 var VERBS = {
   list: [...IDENTITY, "all", "tree", "roots", "contacts"],
-  send: [...IDENTITY, "reply-to", "thread", "private", "attach"],
+  send: [...IDENTITY, "reply-to", "thread", "private", "attach", "live"],
+  join: ["harness", "json", "under"],
+  adopt: [...IDENTITY, "parent"],
+  unlink: IDENTITY,
+  leave: [...IDENTITY, "endpoint"],
+  name: [...IDENTITY, "endpoint"],
   inbox: [...IDENTITY, "wait", "ack", "keep"],
   reply: IDENTITY,
   ack: [...IDENTITY, "all"],
@@ -498,12 +535,13 @@ async function relayMain(argv, cwd = process.cwd()) {
     out(package_default.version);
     return 0;
   }
-  if (verb === "hook") return (await import("./hooks-EI7M3YKY.js")).relayHookCommand(rest, startDaemon);
-  if (verb === "setup") return (await import("./setup-LXG346FJ.js")).relaySetupCommand(rest, cwd, out);
-  if (verb === "claude") return (await import("./claude-YJLGFQ2P.js")).claudeCommand(rest);
-  if (verb === "pi") return (await import("./pi-HMESQA64.js")).piCommand(rest);
+  if (verb === "hook") return (await import("./hooks-EKGY5O5N.js")).relayHookCommand(rest, startDaemon);
+  if (verb === "setup") return (await import("./setup-H7GGUID2.js")).relaySetupCommand(rest, cwd, out);
+  if (verb === "claude") return (await import("./claude-CVWECMRQ.js")).claudeCommand(rest);
+  if (verb === "pi") return (await import("./pi-R23XR4AC.js")).piCommand(rest);
+  if (verb === "codex") return (await import("./codex-Y7SGLZ64.js")).codexCommand(rest);
   if (verb === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-DLPMAS5M.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-AJAYD6CW.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -511,6 +549,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     }
     return spawnCommand(rest, cwd);
   }
+  if (verb === "mesh") return (await import("./mesh-VNZV3POO.js")).meshCommand(rest);
   const allowed = VERBS[verb];
   if (!allowed) throw new RelayUsage(`unknown command "${verb}"`);
   let parsed;
@@ -530,11 +569,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     return daemon(values.idle, values.policy);
   }
   if (verb === "mcp")
-    return (await import("./mcp-DGAQNFKO.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-BVC4PLZ7.js")).relayMcpCommand(values, positionals);
   if (verb === "hooks") {
     if (positionals[0] !== "install" || positionals.length > 1) throw new RelayUsage(`${CLI_NAME} hooks takes install --harness claude|codex|opencode|agy|muse`);
     if (values.write && values.print) throw new RelayUsage("--print and --write: pick one");
-    return (await import("./install-MYHVFKT4.js")).installHooks({
+    return (await import("./install-4VBSX6RI.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -545,25 +584,26 @@ async function relayMain(argv, cwd = process.cwd()) {
       out
     });
   }
-  if (verb === "relay") return (await import("./relay-5Z7IEXKD.js")).relayVerb(positionals, values.json === true);
-  if (verb === "up") return (await import("./up-GPM4LWY3.js")).up(positionals, values, cwd, relinkBroker);
+  if (verb === "relay") return (await import("./relay-U634RHIJ.js")).relayVerb(positionals, values.json === true);
+  if (verb === "up") return (await import("./up-HZKGURPI.js")).up(positionals, values, cwd, relinkBroker);
   if (verb === "login") {
-    const code = await (await import("./relay-5Z7IEXKD.js")).loginMain(positionals, values);
+    const code = await (await import("./relay-U634RHIJ.js")).loginMain(positionals, values);
     if (code === 0) await relinkRunning();
     return code;
   }
-  if (verb === "logout") return (await import("./relay-5Z7IEXKD.js")).logoutMain(positionals, values.json === true);
+  if (verb === "logout") return (await import("./relay-U634RHIJ.js")).logoutMain(positionals, values.json === true);
   if (verb === "cloud") {
-    const code = await (await import("./remote-FYN5ZXE4.js")).cloudMain(positionals, values, cloudStatus);
+    const code = await (await import("./remote-NTHRHVEP.js")).cloudMain(positionals, values, cloudStatus);
     if (code === 0 && positionals[0] === "enable") await relinkRunning();
     return code;
   }
+  if (verb === "join") return (await import("./join-RGFHOSLE.js")).joinCommand(values, positionals, cwd, out);
   if (verb === "holds") holdsArgs(values, positionals);
   const bodyFromStdin = (verb === "send" || verb === "ask" || verb === "reply") && (positionals[1] === void 0 || positionals[1] === "-");
   const opened = await open(verb, values, cwd, bodyFromStdin);
   const { client } = opened;
   try {
-    if (verb === "machines") return await (await import("./remote-FYN5ZXE4.js")).machinesVerb(client, positionals, values.json === true);
+    if (verb === "machines") return await (await import("./remote-NTHRHVEP.js")).machinesVerb(client, positionals, values.json === true);
     return await runVerb(opened, verb, values, positionals, cwd);
   } finally {
     client.close();
@@ -594,7 +634,7 @@ async function relinkBroker() {
     client.close();
   }
   if (!result.restarting) return result;
-  await (await import("./daemon-SUTLTY5U.js")).exited(pid);
+  await (await import("./daemon-OMJY7T2F.js")).exited(pid);
   return cloudStatus();
 }
 async function relinkRunning() {
@@ -614,7 +654,7 @@ async function daemonControl(positionals, values) {
   if (positionals.length !== 1 || action !== "stop" && action !== "restart" || values.idle !== void 0 || values.policy !== void 0)
     throw new RelayUsage(`${CLI_NAME} daemon takes stop or restart, or --idle and --policy to run in the foreground`);
   const dir = relayDir();
-  const pid = await (await import("./daemon-SUTLTY5U.js")).stopBroker(dir);
+  const pid = await (await import("./daemon-OMJY7T2F.js")).stopBroker(dir);
   if (action === "stop") {
     out(pid === null ? "no relay broker runs" : `stopped the relay broker (pid ${pid}); the next command starts a fresh one`);
     return 0;
@@ -740,9 +780,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "peek":
-      return (await import("./peek-WLG3ZROU.js")).peekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-4D4VGKOW.js")).peekCommand(localClient(client, broker, verb), values, positionals);
     case "set-peek":
-      return (await import("./peek-WLG3ZROU.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-4D4VGKOW.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
     case "why": {
       const [from, to] = positionals;
       if (!from || !to || positionals.length > 2) throw new RelayUsage(`${CLI_NAME} why takes <from> <to>`);
@@ -768,13 +808,13 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
         ...attachments.length ? { attachments } : {}
       };
       if (verb === "send") {
-        const result2 = await client.request("send", params);
+        const result2 = await client.request("send", { ...params, ...values.live ? { live: true } : {} });
         if (asJson) json(result2);
         else if (result2.held) out(heldText(result2.held));
         else {
           const lines = reachLines(result2.deliveries);
           out(`sent ${result2.id} to ${result2.deliveries.map((d) => lines.length ? d.address : deliveryText(d)).join(", ")}${redactedText(result2.redacted)}`);
-          for (const line of lines) out(`  ${line}`);
+          for (const line of [...lines, ...result2.warnings ?? []]) out(`  ${line}`);
           if (result2.deliveries.some((d) => d.state === "running" || d.state === "starting"))
             out(`  ${CLI_NAME} status ${shortId(result2.id)} shows when it is read`);
         }
@@ -943,6 +983,50 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       else out(`${view.address}: ${view.status ? statusText(view.status) : "-"}`);
       return 0;
     }
+    case "name": {
+      if (positionals.length > 1) throw new RelayUsage(`${CLI_NAME} name takes one handle, or none to print your address`);
+      const endpoint = values.endpoint;
+      if (!positionals.length) {
+        if (endpoint !== void 0) throw new RelayUsage(`${CLI_NAME} name --endpoint EP takes the new handle`);
+        if (me?.kind !== "agent") throw new RelayUsage(`${CLI_NAME} name: this shell is no joined session; ${CLI_NAME} join <name> joins it`);
+        if (asJson) json({ address: me.address });
+        else out(me.address);
+        return 0;
+      }
+      const before = endpoint ?? me?.address;
+      const view = await client.request("rename", { handle: positionals[0], ...endpoint !== void 0 ? { endpoint } : {} });
+      if (asJson) json(view);
+      else out(before && before !== view.address ? `${before} is now ${view.address}` : `${view.address}`);
+      return 0;
+    }
+    case "adopt": {
+      if (positionals.length !== 1) throw new RelayUsage(`${CLI_NAME} adopt takes the child to link: ${CLI_NAME} adopt <child> [--parent <p>]`);
+      const parent = values.parent;
+      if (parent === void 0 && me?.kind !== "agent")
+        throw new RelayUsage(`${CLI_NAME} adopt: name the parent with --parent <p> (run from an agent's shell, it defaults to that agent)`);
+      const result = await client.request("adopt", {
+        endpoint: positionals[0],
+        ...parent !== void 0 ? { parent } : {}
+      });
+      if (asJson) json(result);
+      else out(`${result.endpoint.address} now sits under ${result.parent}`);
+      return 0;
+    }
+    case "unlink": {
+      if (positionals.length > 1) throw new RelayUsage(`${CLI_NAME} unlink takes one child, or none for this session`);
+      const result = await client.request("unlink", positionals.length ? { endpoint: positionals[0] } : {});
+      if (asJson) json(result);
+      else out(`${result.endpoint.address} is a root again (was under ${result.parent})`);
+      return 0;
+    }
+    case "leave": {
+      if (positionals.length) throw new RelayUsage(`${CLI_NAME} leave takes no arguments (--endpoint EP for the human at a terminal)`);
+      const endpoint = values.endpoint;
+      const view = await client.request("leave", endpoint !== void 0 ? { endpoint } : {});
+      if (asJson) json(view);
+      else out(`${view.address} left the relay: offline, no messages pushed; its mail is kept until ${CLI_NAME} join`);
+      return 0;
+    }
     case "set-title": {
       if (!positionals.length) throw new RelayUsage(`${CLI_NAME} set-title takes the title text ("" clears it)`);
       const view = await client.request("title", { text: positionals.join(" ") });
@@ -1295,11 +1379,11 @@ async function daemon(idle, policyFile) {
   });
   let broker;
   try {
-    const { daemonBridge } = await import("./remote-FYN5ZXE4.js");
+    const { daemonBridge } = await import("./remote-NTHRHVEP.js");
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),
-      ...bridge ? { bridge } : {},
+      ...bridge ? { bridge } : await (await import("./mesh-VNZV3POO.js")).meshBrokerOptions(),
       bridgeConfig: () => daemonBridge(),
       ...idleMs !== void 0 ? { idleMs } : {},
       ...policyFile ? { policyPath: resolve(policyFile) } : {}

package/dist/{mcp-DGAQNFKO.js → mcp-BVC4PLZ7.js}

@@ -1,24 +1,23 @@
 import {
   spawnDetached
-} from "./chunk-GH7AXFUL.js";
+} from "./chunk-G2SQPY6E.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-WV5FINTW.js";
+import "./chunk-NOYMSD4F.js";
 import {
   mcpInstall
-} from "./chunk-5DYFYLAQ.js";
+} from "./chunk-F5QVHJIT.js";
+import "./chunk-OTO6DBU6.js";
+import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
   RelayUsage,
-  startDaemon
-} from "./chunk-3V3DRXB2.js";
-import "./chunk-RXKBND3T.js";
-import "./chunk-YYSLYVNZ.js";
-import {
   harnessPid,
+  membership,
   psParent,
-  relayIdentity
-} from "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+  relayIdentity,
+  startDaemon
+} from "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
 
 // src/mcp.ts
 import { CLI_NAME, validHandle } from "@scp-dev/core";
@@ -45,6 +44,7 @@ async function relayMcpCommand(values, positionals) {
   await runRelayMcp({
     connect: () => connectBroker(dir, () => startDaemon(dir)),
     claim,
+    membership: () => membership(process.env, claim.session),
     input: process.stdin,
     output: (line) => void process.stdout.write(line),
     env: process.env,

package/dist/mesh-VNZV3POO.js

@@ -0,0 +1,28 @@
+import {
+  RelayUsage
+} from "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/mesh.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { relayDir } from "@scp-dev/broker";
+var MESH_MODULE = "@scp-dev/mesh";
+async function load() {
+  try {
+    return await import(MESH_MODULE);
+  } catch {
+    throw new RelayUsage("swarm mesh is experimental and runs only from a source checkout of the swarm CLI");
+  }
+}
+async function meshCommand(argv) {
+  return (await load()).meshCommand(argv);
+}
+async function meshBrokerOptions() {
+  if (!existsSync(join(relayDir(), "mesh", "mesh.json"))) return {};
+  return (await load()).meshBrokerOptions();
+}
+export {
+  meshBrokerOptions,
+  meshCommand
+};

package/dist/{peek-WLG3ZROU.js → peek-4D4VGKOW.js}

@@ -2,11 +2,10 @@ import {
   RelayUsage,
   peekGrant,
   stamp
-} from "./chunk-3V3DRXB2.js";
-import "./chunk-E53YHYEP.js";
+} from "./chunk-E7JG5PJB.js";
 import {
   note
-} from "./chunk-M2DCR2J4.js";
+} from "./chunk-MNTIEWKF.js";
 
 // src/peek.ts
 import { PREAMBLE, wrapPeek, CLI_NAME } from "@scp-dev/core";

package/dist/{pi-HMESQA64.js → pi-R23XR4AC.js}

@@ -1,8 +1,7 @@
 import {
   RelayUsage
-} from "./chunk-3V3DRXB2.js";
-import "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+} from "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
 
 // src/pi.ts
 import { spawn } from "child_process";

package/dist/{relay-5Z7IEXKD.js → relay-U634RHIJ.js}

@@ -3,6 +3,7 @@ import {
   activeRelay,
   checkRelayUrl,
   configDir,
+  joinMode,
   loginMain,
   logoutMain,
   readCredentials,
@@ -10,16 +11,16 @@ import {
   relayVerb,
   removeCredential,
   saveCredential,
+  setJoinMode,
   writePrivateJson
-} from "./chunk-3RRPUYTE.js";
-import "./chunk-3V3DRXB2.js";
-import "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+} from "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
 export {
   DEFAULT_RELAY,
   activeRelay,
   checkRelayUrl,
   configDir,
+  joinMode,
   loginMain,
   logoutMain,
   readCredentials,
@@ -27,5 +28,6 @@ export {
   relayVerb,
   removeCredential,
   saveCredential,
+  setJoinMode,
   writePrivateJson
 };

package/dist/{remote-FYN5ZXE4.js → remote-NTHRHVEP.js}

@@ -9,11 +9,9 @@ import {
   machinesVerb,
   openCloud,
   readCloudFile
-} from "./chunk-U2RSSTNW.js";
-import "./chunk-3RRPUYTE.js";
-import "./chunk-3V3DRXB2.js";
-import "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+} from "./chunk-ZDU53ZRF.js";
+import "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
 export {
   CloudRelayClient,
   CloudUsage,

package/dist/{setup-LXG346FJ.js → setup-H7GGUID2.js}

@@ -15,13 +15,12 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-WV5FINTW.js";
-import "./chunk-5DYFYLAQ.js";
-import "./chunk-3V3DRXB2.js";
-import "./chunk-RXKBND3T.js";
+} from "./chunk-NOYMSD4F.js";
+import "./chunk-F5QVHJIT.js";
+import "./chunk-OTO6DBU6.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+import "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
 export {
   SETUP_HARNESSES,
   SETUP_HELP,

package/dist/{spawn-DLPMAS5M.js → spawn-AJAYD6CW.js}

@@ -29,17 +29,16 @@ import {
   steerArgv,
   transcriptReplies,
   workerName
-} from "./chunk-GH7AXFUL.js";
+} from "./chunk-G2SQPY6E.js";
 import {
   SPAWN_HELP
 } from "./chunk-KN7WEIE4.js";
-import "./chunk-WV5FINTW.js";
-import "./chunk-5DYFYLAQ.js";
-import "./chunk-3V3DRXB2.js";
-import "./chunk-RXKBND3T.js";
+import "./chunk-NOYMSD4F.js";
+import "./chunk-F5QVHJIT.js";
+import "./chunk-OTO6DBU6.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+import "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
 export {
   MESSAGING,
   SPAWN_HELP,

package/dist/{up-GPM4LWY3.js → up-HZKGURPI.js}

@@ -1,12 +1,9 @@
 import {
+  RelayUsage,
   activeRelay,
   relayCredential
-} from "./chunk-3RRPUYTE.js";
-import {
-  RelayUsage
-} from "./chunk-3V3DRXB2.js";
-import "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+} from "./chunk-E7JG5PJB.js";
+import "./chunk-MNTIEWKF.js";
 
 // src/up.ts
 import { CLI_NAME } from "@scp-dev/core";
@@ -17,16 +14,16 @@ async function up(positionals, values, cwd, brokerStatus) {
   const { url } = activeRelay(process.env);
   const headless = values.token !== void 0 || Boolean(process.env.SCP_TOKEN?.trim());
   if (headless || !relayCredential(process.env, url).token) {
-    const code = await (await import("./login-V2WT7QX5.js")).login({
+    const code = await (await import("./login-IPS75GLQ.js")).login({
       ...values.token !== void 0 ? { token: values.token } : {},
       ...values.label !== void 0 ? { label: values.label } : {},
       ...values["no-browser"] ? { "no-browser": true } : {}
     });
     if (code !== 0) return code;
   } else out(`already logged in to ${url}`);
-  const enabled = await (await import("./remote-FYN5ZXE4.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
+  const enabled = await (await import("./remote-NTHRHVEP.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
   if (enabled !== 0) return enabled;
-  const setup = (await import("./setup-LXG346FJ.js")).relaySetupCommand(["--write"], cwd, out);
+  const setup = (await import("./setup-H7GGUID2.js")).relaySetupCommand(["--write"], cwd, out);
   if (setup !== 0) return setup;
   const broker = await brokerStatus();
   if (!broker.enabled) out(`the broker is still local-only; run \`${CLI_NAME} daemon restart\` to link it to ${url}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scp-dev/cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "The swarm command line tool.",
   "license": "Apache-2.0",
   "homepage": "https://scp.dev",
@@ -24,13 +24,16 @@
     "typecheck": "tsc -p ."
   },
   "dependencies": {
-    "@scp-dev/core": "0.1.1",
-    "@scp-dev/broker": "0.1.2",
-    "@scp-dev/hub": "0.1.1",
-    "@scp-dev/mcp": "0.1.2",
+    "@scp-dev/core": "0.1.3",
+    "@scp-dev/broker": "0.1.4",
+    "@scp-dev/hub": "0.3.0",
+    "@scp-dev/mcp": "0.1.4",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
+    "@openai/codex": "0.159.0",
+    "@scp-dev/mesh": "0.0.1",
+    "opencode-ai": "1.18.34",
     "tsup": "^8.5.1"
   },
   "publishConfig": {