@scp-dev/cli 0.2.4 → 0.3.1

package/dist/opencode-ORLGNHWR.js

@@ -0,0 +1,116 @@
+import {
+  mcpFile,
+  mountedEntry,
+  whichOnPath
+} from "./chunk-2OSUVJ2J.js";
+import {
+  hooksTarget
+} from "./chunk-Q5UI4Z7H.js";
+import {
+  opencodePlugin
+} from "./chunk-QRWQIHV6.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  RelayUsage,
+  gitToplevel
+} from "./chunk-2LIJXXTL.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/opencode.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { CLI_NAME, validHandle } from "@scp-dev/core";
+var OPENCODE_HELP = `${CLI_NAME} opencode [--name N | --as N] [--] [opencode args...]
+  runs OpenCode with your own config and arguments, wake on: the ${CLI_NAME} plugin wakes the session on a new message, and opens
+  one when none is open yet. Refuses to start without the current plugin; ${CLI_NAME} setup --write installs it.
+  $SCP_OPENCODE_BIN picks the opencode binary (default opencode on PATH).`;
+function opencodeLaunch(args, env, bin) {
+  let name;
+  const rest = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      rest.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--name" || arg === "--as") {
+      name = args[++i];
+      if (name === void 0) throw new RelayUsage(`${CLI_NAME} opencode ${arg} takes a name`);
+    } else if (arg.startsWith("--name=") || arg.startsWith("--as=")) name = arg.slice(arg.indexOf("=") + 1);
+    else rest.push(arg);
+  }
+  name = name?.replace(/^me\//, "");
+  if (name !== void 0 && !validHandle(name)) throw new RelayUsage(`${JSON.stringify(name)} is not a valid agent handle`);
+  return {
+    argv: [bin, ...rest],
+    env: { ...env, SCP_HARNESS: "opencode", SCP_WAKE: "1", ...name !== void 0 ? { SCP_NAME: name } : {} }
+  };
+}
+function pluginState(env, cwd) {
+  const current = /* @__PURE__ */ new Set([opencodePlugin({ blockStop: false }), opencodePlugin({ blockStop: true })]);
+  const files = [hooksTarget("opencode", "project", env, cwd), hooksTarget("opencode", "user", env, cwd)].filter((file) => existsSync(file));
+  for (const file of files) {
+    try {
+      if (current.has(readFileSync(file, "utf8"))) return { file, current: true };
+    } catch {
+    }
+  }
+  return { ...files[0] ? { file: files[0] } : {}, current: false };
+}
+function pluginProblem(env, cwd) {
+  const plugin = pluginState(env, cwd);
+  if (plugin.current) return void 0;
+  const fix = `run ${CLI_NAME} setup --write (or ${CLI_NAME} hooks install --harness opencode --scope user --write)`;
+  return plugin.file ? `${CLI_NAME} opencode: ${plugin.file} is not this ${CLI_NAME}'s plugin, so wake is not guaranteed; ${fix}` : `${CLI_NAME} opencode: OpenCode has no ${CLI_NAME} plugin, so messages would not wake it; ${fix}`;
+}
+function opencodeMountHint(env, cwd) {
+  const project = gitToplevel(cwd) ?? cwd;
+  const files = [mcpFile("opencode", env), ...["opencode.json", "opencode.jsonc"].map((name) => join(project, name))];
+  for (const file of files) {
+    try {
+      if (existsSync(file) && mountedEntry("opencode", file)) return void 0;
+    } catch {
+    }
+  }
+  return `${CLI_NAME} opencode: OpenCode has no scp MCP mount, so the session has no relay tools; run ${CLI_NAME} setup --write`;
+}
+async function opencodeCommand(args, env = process.env, err = (line) => void process.stderr.write(`${line}
+`), cwd = process.cwd()) {
+  const own = args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
+  if (own.includes("--help") || own.includes("-h")) {
+    process.stdout.write(`${OPENCODE_HELP}
+`);
+    return 0;
+  }
+  const bin = env.SCP_OPENCODE_BIN || whichOnPath("opencode", env);
+  if (!bin) throw new RelayUsage(`opencode is not on PATH: install it with npm i -g opencode-ai, then run ${CLI_NAME} setup --write`);
+  const launch = opencodeLaunch(args, env, bin);
+  const problem = pluginProblem(env, cwd);
+  if (problem) throw new RelayUsage(problem);
+  const hint = opencodeMountHint(env, cwd);
+  if (hint) err(hint);
+  return await new Promise((resolve, reject) => {
+    const child = spawn(launch.argv[0], launch.argv.slice(1), { env: launch.env, stdio: "inherit" });
+    const forward = (signal) => child.kill(signal);
+    const signals = ["SIGTERM", "SIGHUP"];
+    const ignore = () => {
+    };
+    for (const signal of signals) process.on(signal, forward);
+    process.on("SIGINT", ignore);
+    child.once("error", (error) => reject(new RelayUsage(`could not start ${launch.argv[0]}: ${error.message}`)));
+    child.once("exit", (code, signal) => {
+      for (const each of signals) process.off(each, forward);
+      process.off("SIGINT", ignore);
+      resolve(code ?? (signal ? 1 : 0));
+    });
+  });
+}
+export {
+  OPENCODE_HELP,
+  opencodeCommand,
+  opencodeLaunch,
+  opencodeMountHint,
+  pluginProblem,
+  pluginState
+};

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

@@ -2,7 +2,7 @@ import {
   RelayUsage,
   peekGrant,
   stamp
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import {
   note
 } from "./chunk-MNTIEWKF.js";

package/dist/{pi-JZ4DXY7V.js → pi-QEZVFDNR.js}

@@ -1,6 +1,6 @@
 import {
   RelayUsage
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/pi.ts
@@ -10,22 +10,21 @@ import { fileURLToPath } from "url";
 import { CLI_NAME, validHandle } from "@scp-dev/core";
 var PI_HELP = `${CLI_NAME} pi [--name NAME | --as NAME] [--] [pi args...]
   runs pi with the bundled SCP extension: the relay tools, and each new message as a turn, waking the session when idle.
+  pi's own --name and every other argument after the leading launcher flags go to pi untouched.
   $SCP_PI_BIN picks the pi binary (default pi on PATH), $SCP_PI_EXTENSION the extension file.`;
 function piLaunch(args, env, extension) {
   let name;
-  const rest = [];
-  for (let i = 0; i < args.length; i++) {
+  let i = 0;
+  for (; i < args.length; i++) {
     const arg = args[i];
-    if (arg === "--") {
-      rest.push(...args.slice(i + 1));
-      break;
-    }
     if (arg === "--name" || arg === "--as") {
       name = args[++i];
       if (name === void 0) throw new RelayUsage(`${CLI_NAME} pi ${arg} takes a name`);
     } else if (arg.startsWith("--name=") || arg.startsWith("--as=")) name = arg.slice(arg.indexOf("=") + 1);
-    else rest.push(arg);
+    else break;
   }
+  if (args[i] === "--") i++;
+  const rest = args.slice(i);
   name = name?.replace(/^me\//, "");
   if (name !== void 0 && !validHandle(name)) throw new RelayUsage(`${JSON.stringify(name)} is not a valid agent handle`);
   return {
@@ -42,8 +41,7 @@ function extensionPath(env, base = import.meta.url) {
   throw new RelayUsage(`${CLI_NAME} pi found no pi extension next to ${CLI_NAME}: reinstall it, or set $SCP_PI_EXTENSION to the extension file`);
 }
 async function piCommand(args) {
-  const own = args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
-  if (own.includes("--help") || own.includes("-h")) {
+  if (args[0] === "--help" || args[0] === "-h") {
     process.stdout.write(`${PI_HELP}
 `);
     return 0;

package/dist/pi-extension.js

@@ -19,8 +19,14 @@ var McpLink = class {
   pending = /* @__PURE__ */ new Map();
   next = 1;
   closed = false;
+  /** resolves once the shim process is gone */
+  exited;
   constructor(argv, env, onPush, onExit) {
     this.child = spawn(argv[0], argv.slice(1), { env, stdio: ["pipe", "pipe", "ignore"] });
+    this.exited = new Promise((resolve) => {
+      this.child.once("exit", () => resolve());
+      this.child.once("error", () => resolve());
+    });
     this.child.stdin.on("error", () => {
     });
     createInterface({ input: this.child.stdout }).on("line", (line) => {
@@ -66,11 +72,15 @@ var McpLink = class {
     if (!this.closed) this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
   }
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    this.child.stdin.end();
-    this.child.kill();
+  /** ends the shim, resolving once it exited (or after `ms`), so a shim started next never races it for the endpoint */
+  close(ms = 3e3) {
+    if (!this.closed) {
+      this.closed = true;
+      this.child.stdin.end();
+      this.child.kill();
+    }
+    let timer;
+    return Promise.race([this.exited, new Promise((resolve) => timer = setTimeout(resolve, ms))]).finally(() => clearTimeout(timer));
   }
 };
 function toolResult(result) {
@@ -87,7 +97,9 @@ function scp(pi) {
   };
   pi.on("session_start", async (_event, ctx) => {
     if (process.env.SCP_PI === "0") return;
-    link?.close();
+    const previous = link;
+    link = void 0;
+    await previous?.close();
     const current = new McpLink(
       shimArgv(process.env),
       process.env,
@@ -119,13 +131,16 @@ function scp(pi) {
         });
       }
       current.notify("notifications/initialized");
+      const whoami = await current.request("tools/call", { name: "relay_whoami", arguments: {} });
+      if (whoami.isError) warn(ctx, `scp: not on the relay: ${(whoami.content ?? []).map((part) => part.text ?? "").join(" ")}`);
     } catch (error) {
       warn(ctx, `scp: could not start the relay shim: ${error instanceof Error ? error.message : String(error)}`);
     }
   });
   pi.on("session_shutdown", async () => {
-    link?.close();
+    const current = link;
     link = void 0;
+    await current?.close();
   });
 }
 export {

package/dist/{relay-U634RHIJ.js → relay-QWJM372C.js}

@@ -13,7 +13,7 @@ import {
   saveCredential,
   setJoinMode,
   writePrivateJson
-} from "./chunk-E7JG5PJB.js";
+} from "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";
 export {
   DEFAULT_RELAY,

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

@@ -9,8 +9,8 @@ import {
   machinesVerb,
   openCloud,
   readCloudFile
-} from "./chunk-ZDU53ZRF.js";
-import "./chunk-E7JG5PJB.js";
+} from "./chunk-IEFXYBX7.js";
+import "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";
 export {
   CloudRelayClient,

package/dist/{setup-RO7356M4.js → setup-MGDWKCNU.js}

@@ -15,11 +15,11 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-W3VNCRBX.js";
-import "./chunk-ZMVFN6MU.js";
-import "./chunk-X4ZLEM47.js";
+} from "./chunk-2OSUVJ2J.js";
+import "./chunk-Q5UI4Z7H.js";
+import "./chunk-QRWQIHV6.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-E7JG5PJB.js";
+import "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";
 export {
   SETUP_HARNESSES,

package/dist/{spawn-BYU2X46L.js → spawn-GG7VFZA6.js}

@@ -1,4 +1,5 @@
 import {
+  CODEX_VALUED,
   MESSAGING,
   SPAWN_RUNNER,
   STDIN_WAIT_MS,
@@ -27,19 +28,21 @@ import {
   splitSpawn,
   stderrOutput,
   steerArgv,
+  toml,
   transcriptReplies,
   workerName
-} from "./chunk-IXCHAWOL.js";
+} from "./chunk-3SHVJIXP.js";
 import {
   SPAWN_HELP
 } from "./chunk-KN7WEIE4.js";
-import "./chunk-W3VNCRBX.js";
-import "./chunk-ZMVFN6MU.js";
-import "./chunk-X4ZLEM47.js";
+import "./chunk-2OSUVJ2J.js";
+import "./chunk-Q5UI4Z7H.js";
+import "./chunk-QRWQIHV6.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-E7JG5PJB.js";
+import "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";
 export {
+  CODEX_VALUED,
   MESSAGING,
   SPAWN_HELP,
   SPAWN_RUNNER,
@@ -69,6 +72,7 @@ export {
   splitSpawn,
   stderrOutput,
   steerArgv,
+  toml,
   transcriptReplies,
   workerName
 };

package/dist/up-B2NEOOC6.js

@@ -0,0 +1,57 @@
+import {
+  RelayUsage,
+  activeRelay,
+  relayCredential
+} from "./chunk-2LIJXXTL.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/up.ts
+import { CLI_NAME } from "@scp-dev/core";
+var WAKE_LAUNCH = [
+  ["claude", `${CLI_NAME} claude --name <name>     Claude Code with the scp channel: messages wake it`],
+  ["codex", `${CLI_NAME} codex --name <name>      messages start or steer its turns`],
+  ["pi", `${CLI_NAME} pi --name <name>         messages arrive as turns`],
+  ["opencode", "opencode                          its scp plugin wakes an idle session (on by default)"]
+];
+function nextSteps(installed) {
+  const launches = WAKE_LAUNCH.filter(([harness]) => installed.has(harness)).map(([, line]) => `  ${line}`);
+  return [
+    "next: start each agent session wake-enabled:",
+    ...launches,
+    `  ${CLI_NAME} join <name>                 in a session already running: it sees messages only at turn boundaries until relaunched as above`,
+    `  ${CLI_NAME} setup                       checks the hooks and MCP mounts (it lists nothing to do once they are installed)`
+  ];
+}
+async function up(positionals, values, cwd, brokerStatus) {
+  if (positionals.length) throw new RelayUsage(`${CLI_NAME} up takes only flags`);
+  const out = (line) => process.stdout.write(`${line}
+`);
+  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-AUMLI4FS.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-P4GFUIAP.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
+  if (enabled !== 0) return enabled;
+  const setup = (await import("./setup-MGDWKCNU.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}`);
+  else out(`broker linked to ${broker.url ?? url}${broker.connected ? "" : " (connecting)"}`);
+  const { detectHarnesses, whichOnPath } = await import("./setup-MGDWKCNU.js");
+  const which = (name) => whichOnPath(name, process.env);
+  const installed = new Set(detectHarnesses(process.env, which).keys());
+  if (which("pi")) installed.add("pi");
+  out("");
+  for (const line of nextSteps(installed)) out(line);
+  return 0;
+}
+export {
+  nextSteps,
+  up
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scp-dev/cli",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "The swarm command line tool.",
   "license": "Apache-2.0",
   "homepage": "https://scp.dev",
@@ -24,15 +24,15 @@
     "typecheck": "tsc -p ."
   },
   "dependencies": {
-    "@scp-dev/core": "0.1.4",
-    "@scp-dev/broker": "0.1.6",
-    "@scp-dev/hub": "0.4.0",
-    "@scp-dev/mcp": "0.1.6",
+    "@scp-dev/core": "0.1.6",
+    "@scp-dev/broker": "0.2.1",
+    "@scp-dev/hub": "0.5.1",
+    "@scp-dev/mcp": "0.1.8",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
     "@openai/codex": "0.159.0",
-    "@scp-dev/mesh": "0.0.3",
+    "@scp-dev/mesh": "0.0.5",
     "opencode-ai": "1.18.34",
     "tsup": "^8.5.1"
   },

package/dist/claude-JD7WXMAT.js

@@ -1,98 +0,0 @@
-import {
-  entryArgv,
-  mcpFile,
-  mountedEntry,
-  whichOnPath
-} from "./chunk-W3VNCRBX.js";
-import "./chunk-ZMVFN6MU.js";
-import "./chunk-X4ZLEM47.js";
-import "./chunk-YYSLYVNZ.js";
-import {
-  CHANNELS_ENV,
-  RelayUsage,
-  deriveHandle,
-  joinMode
-} from "./chunk-E7JG5PJB.js";
-import "./chunk-MNTIEWKF.js";
-
-// src/claude.ts
-import { spawn } from "child_process";
-import { CLI_NAME, validHandle } from "@scp-dev/core";
-var CHANNEL_FLAGS = ["--dangerously-load-development-channels", "server:scp"];
-function claudeArgv(argv) {
-  let name;
-  let i = 0;
-  if (argv[0] === "--name") {
-    if (argv[1] === void 0) throw new RelayUsage(`${CLI_NAME} claude --name takes a handle`);
-    name = argv[1];
-    i = 2;
-  } else if (argv[0]?.startsWith("--name=")) {
-    name = argv[0].slice("--name=".length);
-    i = 1;
-  }
-  if (argv[i] === "--") i++;
-  if (name !== void 0 && !validHandle(name)) throw new RelayUsage(`--name ${JSON.stringify(name)} is not a valid agent handle`);
-  return { ...name !== void 0 ? { name } : {}, args: argv.slice(i) };
-}
-function namePrompt(name, args, env, cwd) {
-  if (name !== void 0 || joinMode(env) === "manual" || args.some((arg) => /^--(append-)?system-prompt/.test(arg))) return [];
-  const handle = env.SCP_NAME || deriveHandle("claude-code", cwd);
-  return [
-    "--append-system-prompt",
-    `You are on the SCP network as ${handle}. Pick a short descriptive name for yourself with \`${CLI_NAME} name <name>\` when you know what you're working on.`
-  ];
-}
-function mountHint(env) {
-  const file = mcpFile("claude", env);
-  let entry;
-  try {
-    entry = mountedEntry("claude", file);
-  } catch {
-    return `${CLI_NAME} claude: ${file} is unreadable, so the scp mount is unchecked`;
-  }
-  if (!entry) return `${CLI_NAME} claude: Claude Code has no scp MCP mount; run ${CLI_NAME} setup --write`;
-  if (!entryArgv("claude", entry).includes("--channels"))
-    return `${CLI_NAME} claude: the scp mount lacks --channels, so messages will not wake this session; re-run ${CLI_NAME} setup --write`;
-  return void 0;
-}
-async function claudeCommand(argv, env = process.env, err = (line) => void process.stderr.write(`${line}
-`), cwd = process.cwd()) {
-  if (argv[0] === "--help" || argv[0] === "-h") {
-    process.stdout.write(`${CLI_NAME} claude [--name N] [--] [claude args...]   start Claude Code with the scp channel loaded, so peer messages wake it
-`);
-    return 0;
-  }
-  const { name, args } = claudeArgv(argv);
-  const bin = whichOnPath("claude", env);
-  if (!bin) throw new RelayUsage("claude is not on PATH");
-  const hint = mountHint(env);
-  if (hint) err(hint);
-  const child = spawn(bin, [...CHANNEL_FLAGS, ...namePrompt(name, args, env, cwd), ...args], {
-    stdio: "inherit",
-    env: { ...env, ...name !== void 0 ? { SCP_NAME: name } : {}, [CHANNELS_ENV]: String(process.pid) }
-  });
-  const forward = (signal) => () => void child.kill(signal);
-  const handlers = ["SIGTERM", "SIGHUP"].map((signal) => [signal, forward(signal)]);
-  const ignore = () => {
-  };
-  process.on("SIGINT", ignore);
-  for (const [signal, handler] of handlers) process.on(signal, handler);
-  try {
-    return await new Promise((resolve, reject) => {
-      child.once("error", reject);
-      child.once("exit", (code, signal) => resolve(code ?? (signal ? 128 + (signalNumber(signal) ?? 1) : 1)));
-    });
-  } finally {
-    process.off("SIGINT", ignore);
-    for (const [signal, handler] of handlers) process.off(signal, handler);
-  }
-}
-var SIGNALS = { SIGHUP: 1, SIGINT: 2, SIGKILL: 9, SIGTERM: 15 };
-var signalNumber = (signal) => SIGNALS[signal];
-export {
-  CHANNEL_FLAGS,
-  claudeArgv,
-  claudeCommand,
-  mountHint,
-  namePrompt
-};

package/dist/up-GDD24GPL.js

@@ -1,35 +0,0 @@
-import {
-  RelayUsage,
-  activeRelay,
-  relayCredential
-} from "./chunk-E7JG5PJB.js";
-import "./chunk-MNTIEWKF.js";
-
-// src/up.ts
-import { CLI_NAME } from "@scp-dev/core";
-async function up(positionals, values, cwd, brokerStatus) {
-  if (positionals.length) throw new RelayUsage(`${CLI_NAME} up takes only flags`);
-  const out = (line) => process.stdout.write(`${line}
-`);
-  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-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-NTHRHVEP.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
-  if (enabled !== 0) return enabled;
-  const setup = (await import("./setup-RO7356M4.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}`);
-  else out(`broker linked to ${broker.url ?? url}${broker.connected ? "" : " (connecting)"}`);
-  return 0;
-}
-export {
-  up
-};