@scp-dev/cli 0.6.0 → 0.8.0

package/dist/{main-RA3MP25N.js → main-6BPNG53C.js}

@@ -1,6 +1,6 @@
 import {
   SPAWN_HELP
-} from "./chunk-KN7WEIE4.js";
+} from "./chunk-FPNFRDXG.js";
 import {
   OPTIONS,
   RelayUsage,
@@ -16,7 +16,7 @@ import {
   startDaemon,
   terminalAttached,
   time
-} from "./chunk-BSX24XMZ.js";
+} from "./chunk-6S3V5ZGU.js";
 import {
   FAILED,
   exitFlushed,
@@ -35,7 +35,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.6.0",
+  version: "0.8.0",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -238,13 +238,28 @@ scopes (selectors are comma-separated, e.g. tree:parent,tree:children,group:team
                                                  messages with the relay MCP tools (relay_send, relay_inbox, relay_reply). A
                                                  ${CLI_NAME} command from codex's workspace-write sandbox also needs
                                                  -c sandbox_workspace_write.network_access=true (the relay socket counts as network)
+  ${CLI_NAME} spawn --via R [--name N] [--title T] [--labels K=V,...] [--json] [--] <harness cmd...>
+                                                 hands the spawn to runner R of ~/.config/scp/runners.json ($SCP_RUNNERS_FILE):
+                                                 it gets the spawn as one JSON line on stdin and starts the worker on another
+                                                 machine logged in to your account, whose ${CLI_NAME} spawn --under me/<this
+                                                 machine>/<you> runs it linked under you, without a grant; it hands back as a
+                                                 relay message. Needs this broker linked to a hub; returns once the runner exits 0,
+                                                 naming the worker's address and attach command when the runner prints them
+                                                 (--json: as JSON)
   ${CLI_NAME} pi [--name N] [--] [pi args...]    runs pi with the bundled SCP 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} muse [--name N] [--resume S] [--] [muse serve args...]
+                                                 runs a headless Muse session that relay messages wake, printing its replies
   ${CLI_NAME} opencode [--name N] [--] [opencode args...]
                                                  runs OpenCode with your own config and arguments, wake on: the plugin wakes an
                                                  idle session, or opens one; refuses to start without the current plugin
+  ${CLI_NAME} agy [--name N] [--] [agy args...]
+                                                 runs agy headless: each new message resumes its conversation as a turn;
+                                                 refuses interactive flags and starts only with the scp hooks installed
+  ${CLI_NAME} grok [--name N] [--] [grok args...]
+                                                 runs grok headless: each new message resumes its session as a 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
@@ -315,6 +330,15 @@ agent sessions:
                                                  (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
+  ${CLI_NAME} hibernate --wake <provider> [--ref R] [<endpoint>]   mark this session (or, for the human, <endpoint>) hibernated:
+                                                 suspended but wakeable. A message to it runs the provider's wake hook from
+                                                 ~/.config/scp/wakers.json with R and the message's metadata (never its body),
+                                                 at most once a minute; the session drains its queue once it is back
+  ${CLI_NAME} hibernate --wake none [<endpoint>] the session resumed or is gone: hibernation clears (--gone is the same); it also
+                                                 clears when the session claims its endpoint again
+  ${CLI_NAME} hibernate --all --wake <provider> [--ref R] [--eta S]   the human marks every live agent of this machine hibernated
+                                                 (--eta: how long a wake takes, shown to senders); it waits until the hub has it
+                                                 ("the hub has it"), so the machine can be suspended right after
   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.
 
@@ -326,6 +350,9 @@ relay:
   ${CLI_NAME} logout                             remove the stored credential for the active relay
   ${CLI_NAME} cloud enable [--machine NAME] | disable | status   link the local broker to the hub, or inspect its link
   ${CLI_NAME} machines [rm NAME]                 list the hub's machines, or release one
+  ${CLI_NAME} machine wake-url <url> [--secret-env VAR] | --clear   the URL the hub POSTs to, signed with the secret in $VAR
+                                                 (default $SCP_MACHINE_WAKE_SECRET), when a message reaches a hibernated agent of
+                                                 this machine while its broker is not linked; for the human
   --cloud (or $SCP_TRANSPORT=cloud) sends messaging commands directly to the hub using the active relay's login.
   --machine NAME ($SCP_MACHINE, else the short hostname) names this machine on the hub; it requires --cloud.
 
@@ -402,6 +429,8 @@ var VERBS = {
   link: IDENTITY,
   unlink: IDENTITY,
   leave: [...IDENTITY, "endpoint"],
+  hibernate: [...IDENTITY, "wake", "ref", "gone", "all", "eta"],
+  machine: [...IDENTITY, "secret-env", "clear"],
   name: [...IDENTITY, "endpoint", "take-over"],
   inbox: [...IDENTITY, "wait", "ack", "keep"],
   reply: IDENTITY,
@@ -575,14 +604,16 @@ async function relayMain(argv, cwd = process.cwd()) {
     out(cliVersion());
     return 0;
   }
-  if (verb === "hook") return (await import("./hooks-SWVIDONV.js")).relayHookCommand(rest, startDaemon);
-  if (verb === "setup") return (await import("./setup-O45SE5L7.js")).relaySetupCommand(rest, cwd, out);
-  if (verb === "claude") return (await import("./claude-NCPNZLIX.js")).claudeCommand(rest);
-  if (verb === "pi") return (await import("./pi-XHZAUDP4.js")).piCommand(rest);
-  if (verb === "codex") return (await import("./codex-4GTXURTS.js")).codexCommand(rest);
-  if (verb === "opencode") return (await import("./opencode-CPNR2G3W.js")).opencodeCommand(rest, process.env, void 0, cwd);
+  if (verb === "hook") return (await import("./hooks-DRIUG546.js")).relayHookCommand(rest, startDaemon);
+  if (verb === "setup") return (await import("./setup-NK2HRFZN.js")).relaySetupCommand(rest, cwd, out);
+  if (verb === "claude") return (await import("./claude-7BA4PGK3.js")).claudeCommand(rest);
+  if (verb === "pi") return (await import("./pi-QUW4MSVZ.js")).piCommand(rest);
+  if (verb === "codex") return (await import("./codex-KQNXVGTE.js")).codexCommand(rest);
+  if (verb === "muse") return (await import("./muse-QWCI627T.js")).museCommand(rest);
+  if (verb === "opencode") return (await import("./opencode-7XYA7E3Q.js")).opencodeCommand(rest, process.env, void 0, cwd);
+  if (verb === "agy" || verb === "grok") return (await import("./resume-B5BOZO2G.js")).resumeCommand(verb, rest, process.env, cwd);
   if (verb === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-CJSHYE7E.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-3IYGUBG6.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -590,7 +621,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     }
     return spawnCommand(rest, cwd);
   }
-  if (verb === "mesh") return (await import("./mesh-XTMBRJLR.js")).meshCommand(rest);
+  if (verb === "mesh") return (await import("./mesh-P3EQXYLH.js")).meshCommand(rest);
   const allowed = VERBS[verb];
   if (!allowed) throw new RelayUsage(`unknown command "${verb}"`);
   let parsed;
@@ -610,11 +641,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     return daemon(values.idle, values.policy);
   }
   if (verb === "mcp")
-    return (await import("./mcp-RERRUUIX.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-4VAPXGF6.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-YE7LCGPC.js")).installHooks({
+    return (await import("./install-MZC4PAIC.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -625,27 +656,27 @@ async function relayMain(argv, cwd = process.cwd()) {
       out
     });
   }
-  if (verb === "relay") return (await import("./relay-E4JFR33E.js")).relayVerb(positionals, values.json === true);
-  if (verb === "up") return (await import("./up-O2CMDGXP.js")).up(positionals, values, cwd, relinkBroker);
+  if (verb === "relay") return (await import("./relay-7VBBQCFB.js")).relayVerb(positionals, values.json === true);
+  if (verb === "up") return (await import("./up-QL3FLYUK.js")).up(positionals, values, cwd, relinkBroker);
   if (verb === "login") {
-    const code = await (await import("./relay-E4JFR33E.js")).loginMain(positionals, values);
+    const code = await (await import("./relay-7VBBQCFB.js")).loginMain(positionals, values);
     if (code === 0) await relinkRunning();
     return code;
   }
-  if (verb === "logout") return (await import("./relay-E4JFR33E.js")).logoutMain(positionals, values.json === true);
+  if (verb === "logout") return (await import("./relay-7VBBQCFB.js")).logoutMain(positionals, values.json === true);
   if (verb === "cloud") {
-    const code = await (await import("./remote-3R4GRDGI.js")).cloudMain(positionals, values, cloudStatus);
+    const code = await (await import("./remote-VRVONVET.js")).cloudMain(positionals, values, cloudStatus);
     if (code === 0 && positionals[0] === "enable") await relinkRunning();
     return code;
   }
-  if (verb === "join") return (await import("./join-64BU6SEY.js")).joinCommand(values, positionals, cwd, out);
+  if (verb === "join") return (await import("./join-JW7C2IDC.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 humanAdopt = verb === "adopt" && values.parent !== void 0 && values.as === void 0 && terminalAttached(process, false);
   const opened = humanAdopt ? await openAdoptHuman(cwd, values) : await open(verb, values, cwd, bodyFromStdin);
   const { client } = opened;
   try {
-    if (verb === "machines") return await (await import("./remote-3R4GRDGI.js")).machinesVerb(client, positionals, values.json === true);
+    if (verb === "machines") return await (await import("./remote-VRVONVET.js")).machinesVerb(client, positionals, values.json === true);
     return await runVerb(opened, verb, values, positionals, cwd);
   } finally {
     client.close();
@@ -653,7 +684,7 @@ async function relayMain(argv, cwd = process.cwd()) {
 }
 async function openAdoptHuman(cwd, values) {
   if (values.cloud || process.env.SCP_TRANSPORT === "cloud") {
-    const { openCloud } = await import("./remote-3R4GRDGI.js");
+    const { openCloud } = await import("./remote-VRVONVET.js");
     return { ...await openCloud({ tty: true, ...values.machine !== void 0 ? { machine: values.machine } : {} }), broker: null, bound: "human" };
   }
   if (values.machine !== void 0) throw new RelayUsage("--machine names the machine of the cloud transport: add --cloud");
@@ -838,9 +869,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "peek":
-      return (await import("./peek-GEYQ7SHV.js")).peekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-G6RLQGKO.js")).peekCommand(localClient(client, broker, verb), values, positionals);
     case "set-peek":
-      return (await import("./peek-GEYQ7SHV.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-G6RLQGKO.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>`);
@@ -1103,6 +1134,47 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       else out(`${result.endpoint.address} is a root again (was under ${result.parent})`);
       return 0;
     }
+    case "hibernate": {
+      if (positionals.length > 1) throw new RelayUsage(`${CLI_NAME} hibernate takes at most one endpoint`);
+      if (values.gone === true && values.wake !== void 0) throw new RelayUsage("--gone and --wake: pick one");
+      const wake = values.gone === true ? "none" : values.wake;
+      if (wake === void 0) throw new RelayUsage(`${CLI_NAME} hibernate takes --wake <provider>, or --wake none (--gone) to clear it`);
+      if (wake === "none" && (values.ref !== void 0 || values.eta !== void 0))
+        throw new RelayUsage("--ref and --eta go with a provider, not with --wake none");
+      if (values.all === true && positionals.length) throw new RelayUsage(`${CLI_NAME} hibernate --all names no endpoint`);
+      const eta = values.eta === void 0 ? void 0 : Math.round(parseSeconds(values.eta, "--eta"));
+      const result = await client.request("hibernate", {
+        ...values.all === true ? { all: true } : positionals.length ? { endpoint: positionals[0] } : {},
+        wake,
+        ...values.ref !== void 0 ? { ref: values.ref } : {},
+        ...eta !== void 0 ? { eta_s: eta } : {}
+      });
+      if (asJson) json(result);
+      else {
+        for (const e of result.endpoints ?? (result.endpoint ? [result.endpoint] : []))
+          out(`${e.address} ${presenceText(e)}${e.presence === "hibernated" ? `, woken by ${wakeText(e)}` : ""}`);
+        if (result.mirrored) note("the hub has it: the machine may be suspended now");
+      }
+      return 0;
+    }
+    case "machine": {
+      if (positionals[0] !== "wake-url") throw new RelayUsage(`${CLI_NAME} machine takes wake-url <url> [--secret-env VAR] | wake-url --clear`);
+      if (values.clear === true) {
+        if (positionals.length > 1 || values["secret-env"] !== void 0) throw new RelayUsage(`${CLI_NAME} machine wake-url --clear takes no url`);
+        const result2 = await client.request("machine_wake", { url: null });
+        if (asJson) json(result2);
+        else out("machine waker cleared");
+        return 0;
+      }
+      if (positionals.length !== 2) throw new RelayUsage(`${CLI_NAME} machine wake-url takes one url, or --clear`);
+      const name = values["secret-env"] ?? "SCP_MACHINE_WAKE_SECRET";
+      const secret = process.env[name];
+      if (!secret) throw new RelayUsage(`set $${name} to the waker's secret (16 to 256 characters); it is never read from the command line`);
+      const result = await client.request("machine_wake", { url: positionals[1], secret });
+      if (asJson) json(result);
+      else out("machine waker set; the hub signs each call with the secret");
+      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;
@@ -1337,7 +1409,8 @@ function printSummary(snapshot, me, all) {
   const agents = snapshot.endpoints.filter((e) => e.kind !== "human");
   const count = (presence) => agents.filter((e) => e.presence === presence).length;
   out();
-  out(`agents: ${count("online")} online, ${count("idle")} idle, ${count("offline")} offline`);
+  const hibernated = count("hibernated");
+  out(`agents: ${count("online")} online, ${count("idle")} idle, ${hibernated ? `${hibernated} hibernated, ` : ""}${count("offline")} offline`);
   const counted = all ? agents : agents.filter((e) => e.presence !== "offline");
   const harnesses = /* @__PURE__ */ new Map();
   for (const e of counted) harnesses.set(e.harness ?? "?", [...harnesses.get(e.harness ?? "?") ?? [], e]);
@@ -1464,11 +1537,11 @@ async function daemon(idle, policyFile) {
   });
   let broker;
   try {
-    const { daemonBridge } = await import("./remote-3R4GRDGI.js");
+    const { daemonBridge } = await import("./remote-VRVONVET.js");
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),
-      ...bridge ? { bridge } : await (await import("./mesh-XTMBRJLR.js")).meshBrokerOptions(),
+      ...bridge ? { bridge } : await (await import("./mesh-P3EQXYLH.js")).meshBrokerOptions(),
       bridgeConfig: () => daemonBridge(),
       ...idleMs !== void 0 ? { idleMs } : {},
       ...policyFile ? { policyPath: resolve(policyFile) } : {}

package/dist/{mcp-RERRUUIX.js → mcp-4VAPXGF6.js}

@@ -1,24 +1,25 @@
 import {
   spawnDetached
-} from "./chunk-CVW3INZO.js";
-import "./chunk-KN7WEIE4.js";
-import "./chunk-DEK3TE6T.js";
+} from "./chunk-ZEWZBRVM.js";
+import "./chunk-FPNFRDXG.js";
+import "./chunk-77NUOWQ4.js";
 import {
   mcpInstall
-} from "./chunk-C5PYVRJE.js";
-import "./chunk-GG33NSBW.js";
+} from "./chunk-MHBWDAXO.js";
+import "./chunk-UUFTEXDU.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
   RelayUsage,
   harnessAt,
   harnessPid,
+  launcherPid,
   membership,
   psParent,
   relayIdentity,
   startDaemon,
   writeShimBinding
-} from "./chunk-BSX24XMZ.js";
+} from "./chunk-6S3V5ZGU.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/mcp.ts
@@ -40,7 +41,7 @@ async function relayMcpCommand(values, positionals) {
     fallbackHarness: "mcp",
     cwd: process.cwd(),
     env: process.env,
-    harnessPid: () => harnessPid(),
+    harnessPid: () => launcherPid(process.env) ?? harnessPid(),
     inferHarness: (pid) => harnessAt(pid)
   });
   if (!validHandle(claim.handle)) throw new RelayUsage(`${JSON.stringify(claim.handle)} is not a valid agent handle (me, user and relay are reserved)`);

package/dist/{mesh-XTMBRJLR.js → mesh-P3EQXYLH.js}

@@ -1,6 +1,6 @@
 import {
   RelayUsage
-} from "./chunk-BSX24XMZ.js";
+} from "./chunk-6S3V5ZGU.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/mesh.ts