@scp-dev/cli 0.5.0 → 0.7.0

package/dist/resume-3ZRDXSTX.js

@@ -0,0 +1,308 @@
+import {
+  agyNote,
+  messagingAllow
+} from "./chunk-RZUQ422C.js";
+import "./chunk-KN7WEIE4.js";
+import {
+  whichOnPath
+} from "./chunk-SNW53KT3.js";
+import {
+  hooksTarget
+} from "./chunk-LRQP25RI.js";
+import {
+  AGY_CONVERSATION,
+  AGY_HOOK_SET
+} from "./chunk-277BAY7J.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  RelayUsage,
+  relayIdentity,
+  startDaemon
+} from "./chunk-3SOIVANO.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/resume.ts
+import { spawn } from "child_process";
+import { randomBytes, randomUUID } from "crypto";
+import { mkdtempSync, readFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { PassThrough } from "stream";
+import { connectBroker, relayDir } from "@scp-dev/broker";
+import { CLI_NAME, validHandle } from "@scp-dev/core";
+import { MCP_PROTOCOLS, runRelayMcp } from "@scp-dev/mcp";
+var SPECS = {
+  agy: {
+    bin: "SCP_AGY_BIN",
+    refused: ["-i", "--prompt-interactive", "-c", "--continue", "--input-format", "--remote-control"],
+    prompt: ["-p", "--print", "--prompt"],
+    ids: ["--conversation"]
+  },
+  grok: {
+    bin: "SCP_GROK_BIN",
+    refused: ["-c", "--continue", "--fork-session"],
+    prompt: ["-p", "--single", "--prompt-file", "--prompt-json"],
+    ids: ["-s", "--session-id", "-r", "--resume"]
+  }
+};
+var AGY_HELP = `${CLI_NAME} agy [--name N | --as N] [--] [agy args...]
+  runs agy headless, wake on: a -p prompt is its first turn, and each new message resumes the same conversation as a
+  turn (agy --conversation <id> -p <message>); without a prompt the first message starts it. Refuses -i, -c,
+  --input-format and --remote-control: nothing local starts a turn in an interactive agy, so run plain agy for that
+  (its hooks still deliver before each model call). Refuses to start without the ${CLI_NAME} hooks, which report the
+  conversation; ${CLI_NAME} setup --write installs them.
+  $SCP_AGY_BIN picks the agy binary (default agy on PATH).`;
+var GROK_HELP = `${CLI_NAME} grok [--name N | --as N] [--] [grok args...]
+  runs grok headless, wake on: a -p prompt is its first turn, and each new message resumes the same session as a turn
+  (grok --resume <id> -p <message>); without a prompt the first message starts it. The session id is yours (-s, -r)
+  or a new one. Refuses -c and --fork-session: nothing local starts a turn in an interactive grok, so run plain grok
+  for that. Adds the --allow rules for the relay tools unless you pass your own.
+  $SCP_GROK_BIN picks the grok binary (default grok on PATH).`;
+function insert(args, extra) {
+  const end = args.indexOf("--");
+  return end < 0 ? [...args, ...extra] : [...args.slice(0, end), ...extra, ...args.slice(end)];
+}
+function resumeLaunch(harness, args, env, uuid = randomUUID) {
+  let name;
+  let i = 0;
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--name" || arg === "--as") {
+      name = args[++i];
+      if (name === void 0) throw new RelayUsage(`${CLI_NAME} ${harness} ${arg} takes a name`);
+    } else if (arg.startsWith("--name=") || arg.startsWith("--as=")) name = arg.slice(arg.indexOf("=") + 1);
+    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`);
+  const spec = SPECS[harness];
+  const refusal = (flag) => new RelayUsage(
+    `${CLI_NAME} ${harness}: ${flag} is not supported: nothing local starts a turn in an interactive ${harness} session; run plain ${harness} for that`
+  );
+  if (harness === "agy" && rest[0] === "remote-control") throw refusal("remote-control");
+  const base = [];
+  const ids = /* @__PURE__ */ new Map();
+  let prompt = false;
+  for (let j = 0; j < rest.length; j++) {
+    const arg = rest[j];
+    if (arg === "--") {
+      base.push(...rest.slice(j));
+      break;
+    }
+    const refused = spec.refused.find((flag) => arg === flag || arg.startsWith(`${flag}=`));
+    if (refused) throw refusal(refused);
+    const valued = [...spec.prompt, ...spec.ids].find((flag) => arg === flag || arg.startsWith(`${flag}=`));
+    if (!valued) {
+      base.push(arg);
+      continue;
+    }
+    const value = arg === valued ? rest[++j] : arg.slice(valued.length + 1);
+    if (value === void 0) throw new RelayUsage(`${CLI_NAME} ${harness} ${valued} takes a value`);
+    if (spec.prompt.includes(valued)) prompt = true;
+    else ids.set(valued, value);
+  }
+  const { SCP_SESSION: _session, SCP_PARENT: _parent, SCP_HARNESS_PID: _pid, ...clean } = env;
+  const launchEnv = { ...clean, SCP_HARNESS: harness, SCP_SESSION: randomBytes(16).toString("hex"), ...name !== void 0 ? { SCP_NAME: name } : {} };
+  const named = name !== void 0 ? { name } : {};
+  if (harness === "agy") {
+    const id2 = ids.get("--conversation");
+    return {
+      harness,
+      ...named,
+      ...prompt ? { first: rest } : {},
+      base,
+      opening: id2 === void 0 ? [] : ["--conversation", id2],
+      ...id2 !== void 0 ? { id: id2 } : {},
+      extra: [],
+      env: launchEnv
+    };
+  }
+  const resumed = ids.get("-r") ?? ids.get("--resume");
+  const given = ids.get("-s") ?? ids.get("--session-id");
+  const id = resumed ?? given ?? uuid();
+  const extra = messagingAllow("grok", rest);
+  return {
+    harness,
+    ...named,
+    ...prompt ? { first: insert(rest, [...resumed ?? given ? [] : ["-s", id], ...extra]) } : {},
+    base,
+    opening: resumed !== void 0 ? ["--resume", id] : ["-s", id],
+    id,
+    extra,
+    env: launchEnv
+  };
+}
+function turnArgv(launch, text, id) {
+  const conversation = id === void 0 ? launch.opening : launch.harness === "agy" ? ["--conversation", id] : ["--resume", id];
+  return insert(launch.base, [...conversation, "-p", text, ...launch.extra]);
+}
+function agyHooksProblem(env, cwd) {
+  for (const scope of ["project", "user"]) {
+    try {
+      const set = JSON.parse(readFileSync(hooksTarget("agy", scope, env, cwd), "utf8"))[AGY_HOOK_SET];
+      if (set && set.enabled !== false && Array.isArray(set.SessionStart) && set.SessionStart.length) return void 0;
+    } catch {
+    }
+  }
+  return `${CLI_NAME} agy: agy has no ${CLI_NAME} hooks, so it cannot report the conversation to resume; run ${CLI_NAME} setup --write`;
+}
+function readConversation(file) {
+  if (!file) return void 0;
+  try {
+    const id = readFileSync(file, "utf8").trim();
+    return AGY_CONVERSATION.test(id) ? id : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resumeCommand(harness, args, env = process.env, cwd = process.cwd(), err = (line) => void process.stderr.write(`${line}
+`)) {
+  if (args[0] === "--help" || args[0] === "-h") {
+    process.stdout.write(`${harness === "agy" ? AGY_HELP : GROK_HELP}
+`);
+    return 0;
+  }
+  const launch = resumeLaunch(harness, args, env);
+  const spec = SPECS[harness];
+  const bin = env[spec.bin] || whichOnPath(harness, env);
+  if (!bin) throw new RelayUsage(`${harness} is not on PATH: install it, or set $${spec.bin} to its binary`);
+  if (harness === "agy") {
+    const problem = agyHooksProblem(env, cwd);
+    if (problem) throw new RelayUsage(problem);
+    const note = agyNote(["agy", "-p", "", ...launch.base], env, "agy");
+    if (note) err(note);
+  }
+  const runEnv = { ...launch.env, SCP_HARNESS_PID: String(process.pid) };
+  const claim = relayIdentity({ harness, fallbackHarness: harness, cwd, env: runEnv, harnessPid: () => process.pid });
+  if (!validHandle(claim.handle)) throw new RelayUsage(`${JSON.stringify(claim.handle)} is not a valid agent handle`);
+  const dir = harness === "agy" ? mkdtempSync(join(tmpdir(), "scp-agy-")) : void 0;
+  const file = dir === void 0 ? void 0 : join(dir, "conversation");
+  if (file) runEnv.SCP_AGY_CONVERSATION_FILE = file;
+  const broker = relayDir(runEnv);
+  const input = new PassThrough();
+  const queue = [];
+  let id = launch.id;
+  let opened = false;
+  let ready = false;
+  let stopping = false;
+  let running;
+  let finish;
+  const done = new Promise((resolve) => {
+    finish = resolve;
+  });
+  let joined;
+  const whoami = new Promise((resolve) => {
+    joined = resolve;
+  });
+  const turn = (argv) => {
+    const child = spawn(bin, argv, { env: runEnv, stdio: ["ignore", "inherit", "inherit"] });
+    running = child;
+    let settled = false;
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      running = void 0;
+      err(`${CLI_NAME} ${harness}: could not start ${bin}: ${error.message}`);
+      finish(1);
+    });
+    child.once("exit", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      running = void 0;
+      if (stopping) return finish(0);
+      if (code !== 0) {
+        err(`${CLI_NAME} ${harness}: turn failed (exit ${code ?? signal}); undelivered messages stay unread in relay_inbox`);
+        return finish(code ?? 1);
+      }
+      opened = true;
+      if (harness === "agy") id = readConversation(file) ?? id;
+      if (id === void 0) {
+        err(`${CLI_NAME} agy: agy's ${CLI_NAME} hooks did not report the conversation, so it cannot be resumed; run ${CLI_NAME} setup --write`);
+        return finish(1);
+      }
+      next();
+    });
+  };
+  const next = () => {
+    if (!ready || running || stopping || !queue.length) return;
+    turn(turnArgv(launch, queue.splice(0).join("\n\n"), opened ? id : void 0));
+  };
+  let lines = "";
+  const channel = runRelayMcp({
+    connect: () => connectBroker(broker, () => startDaemon(broker)),
+    claim,
+    channels: true,
+    wake: harness === "agy" ? "agy-resume" : "grok-resume",
+    input,
+    env: runEnv,
+    output: (chunk) => {
+      lines += chunk;
+      for (; ; ) {
+        const end = lines.indexOf("\n");
+        if (end < 0) break;
+        const message = JSON.parse(lines.slice(0, end));
+        lines = lines.slice(end + 1);
+        if (message.id === 2) joined(message.result ?? {});
+        if (message.method === "notifications/claude/channel") {
+          const content = message.params.content;
+          if (typeof content === "string") {
+            queue.push(content);
+            next();
+          }
+        }
+      }
+    },
+    log: err
+  });
+  void channel.catch((error) => {
+    err(`${CLI_NAME} ${harness}: ${String(error)}`);
+    finish(1);
+  });
+  const stop = (signal) => {
+    stopping = true;
+    if (running) running.kill(signal);
+    else finish(0);
+  };
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+  for (const signal of signals) process.on(signal, stop);
+  try {
+    input.write(
+      `${JSON.stringify({ id: 1, method: "initialize", params: { protocolVersion: MCP_PROTOCOLS[0], capabilities: { experimental: { "claude/channel": {} } }, clientInfo: { name: `scp-${harness}`, version: "0.1.0" } } })}
+`
+    );
+    input.write(`${JSON.stringify({ method: "notifications/initialized" })}
+`);
+    input.write(`${JSON.stringify({ id: 2, method: "tools/call", params: { name: "relay_whoami", arguments: {} } })}
+`);
+    const result = await Promise.race([whoami, done.then(() => void 0)]);
+    if (result === void 0) return await done;
+    const text = (result.content ?? []).map((part) => part.text ?? "").join("\n");
+    const address = /^address: (\S+)$/m.exec(text)?.[1];
+    if (result.isError || !address) throw new RelayUsage(`${CLI_NAME} ${harness}: could not join the relay: ${text || "no answer"}`);
+    runEnv.SCP_NAME = address.slice(address.lastIndexOf("/") + 1);
+    ready = true;
+    if (launch.first) turn(launch.first);
+    else {
+      err(`${CLI_NAME} ${harness}: ${address} waiting for messages`);
+      next();
+    }
+    return await done;
+  } finally {
+    for (const signal of signals) process.off(signal, stop);
+    input.end();
+    await channel.catch(() => {
+    });
+    if (running?.exitCode === null && running.signalCode === null) running.kill("SIGTERM");
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+}
+export {
+  AGY_HELP,
+  GROK_HELP,
+  agyHooksProblem,
+  resumeCommand,
+  resumeLaunch,
+  turnArgv
+};

package/dist/{setup-UJCIMYU4.js → setup-U7CWN5QP.js}

@@ -15,11 +15,11 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-UKQBH4AQ.js";
-import "./chunk-2342GTME.js";
-import "./chunk-XQHPDNVG.js";
+} from "./chunk-SNW53KT3.js";
+import "./chunk-LRQP25RI.js";
+import "./chunk-277BAY7J.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-AAFHLHXG.js";
+import "./chunk-3SOIVANO.js";
 import "./chunk-MNTIEWKF.js";
 export {
   SETUP_HARNESSES,

package/dist/{spawn-JYD7NCQT.js → spawn-VZK5MD3R.js}

@@ -1,6 +1,8 @@
 import {
   CODEX_VALUED,
   MESSAGING,
+  MUSE_MODE,
+  MUSE_MODES_ALLOWED,
   SPAWN_RUNNER,
   STDIN_WAIT_MS,
   agentShell,
@@ -15,6 +17,8 @@ import {
   harnessArgv,
   harnessOutput,
   harnessStdin,
+  messagingAllow,
+  museModes,
   programAt,
   repliesOutput,
   resumeArgv,
@@ -31,19 +35,21 @@ import {
   toml,
   transcriptReplies,
   workerName
-} from "./chunk-7RA7E5WR.js";
+} from "./chunk-RZUQ422C.js";
 import {
   SPAWN_HELP
 } from "./chunk-KN7WEIE4.js";
-import "./chunk-UKQBH4AQ.js";
-import "./chunk-2342GTME.js";
-import "./chunk-XQHPDNVG.js";
+import "./chunk-SNW53KT3.js";
+import "./chunk-LRQP25RI.js";
+import "./chunk-277BAY7J.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-AAFHLHXG.js";
+import "./chunk-3SOIVANO.js";
 import "./chunk-MNTIEWKF.js";
 export {
   CODEX_VALUED,
   MESSAGING,
+  MUSE_MODE,
+  MUSE_MODES_ALLOWED,
   SPAWN_HELP,
   SPAWN_RUNNER,
   STDIN_WAIT_MS,
@@ -59,6 +65,8 @@ export {
   harnessArgv,
   harnessOutput,
   harnessStdin,
+  messagingAllow,
+  museModes,
   programAt,
   repliesOutput,
   resumeArgv,

package/dist/{up-3YJU7YX6.js → up-S4KJBWI6.js}

@@ -2,7 +2,7 @@ import {
   RelayUsage,
   activeRelay,
   relayCredential
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-3SOIVANO.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/up.ts
@@ -11,7 +11,9 @@ 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)"]
+  ["opencode", "opencode                          its scp plugin wakes an idle session (on by default)"],
+  ["agy", `${CLI_NAME} agy --name <name>        headless: each message resumes its conversation`],
+  ["grok", `${CLI_NAME} grok --name <name>       headless: each message resumes its session`]
 ];
 function nextSteps(installed) {
   const launches = WAKE_LAUNCH.filter(([harness]) => installed.has(harness)).map(([, line]) => `  ${line}`);
@@ -29,21 +31,21 @@ 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-6MVD3VLC.js")).login({
+    const code = await (await import("./login-DCNCC3RS.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-UQJ5YYCC.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
+  const enabled = await (await import("./remote-YO5B2HQI.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
   if (enabled !== 0) return enabled;
-  const setup = (await import("./setup-UJCIMYU4.js")).relaySetupCommand(["--write"], cwd, out);
+  const setup = (await import("./setup-U7CWN5QP.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-UJCIMYU4.js");
+  const { detectHarnesses, whichOnPath } = await import("./setup-U7CWN5QP.js");
   const which = (name) => whichOnPath(name, process.env);
   const installed = new Set(detectHarnesses(process.env, which).keys());
   if (which("pi")) installed.add("pi");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scp-dev/cli",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "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.3.0",
-    "@scp-dev/broker": "0.4.0",
-    "@scp-dev/hub": "0.6.1",
-    "@scp-dev/mcp": "0.2.0",
+    "@scp-dev/core": "0.4.0",
+    "@scp-dev/broker": "0.4.2",
+    "@scp-dev/hub": "0.6.3",
+    "@scp-dev/mcp": "0.2.2",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
     "@openai/codex": "0.159.0",
-    "@scp-dev/mesh": "0.0.7",
+    "@scp-dev/mesh": "0.0.9",
     "opencode-ai": "1.18.34",
     "tsup": "^8.5.1"
   },

package/dist/claude-RNH2E4GU.js

@@ -1,130 +0,0 @@
-import {
-  entryArgv,
-  mcpFile,
-  mountedEntry,
-  whichOnPath
-} from "./chunk-UKQBH4AQ.js";
-import "./chunk-2342GTME.js";
-import "./chunk-XQHPDNVG.js";
-import "./chunk-YYSLYVNZ.js";
-import {
-  CHANNELS_ENV,
-  RelayUsage,
-  deriveHandle,
-  joinMode
-} from "./chunk-AAFHLHXG.js";
-import "./chunk-MNTIEWKF.js";
-
-// src/claude.ts
-import { spawn } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-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;
-  for (; ; ) {
-    const arg = argv[i];
-    if (arg === "--name" || arg === "--as") {
-      if (argv[i + 1] === void 0) throw new RelayUsage(`${CLI_NAME} claude ${arg} takes a handle`);
-      name = argv[i + 1];
-      i += 2;
-    } else if (arg?.startsWith("--name=") || arg?.startsWith("--as=")) {
-      name = arg.slice(arg.indexOf("=") + 1);
-      i++;
-    } else break;
-  }
-  if (argv[i] === "--") i++;
-  name = name?.replace(/^me\//, "");
-  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 claudeLaunchArgs(args, added) {
-  const end = args.indexOf("--");
-  const at = end < 0 ? args.length : end;
-  const channels = args.some((arg, i) => i < at && (arg === "server:scp" || arg === `${CHANNEL_FLAGS[0]}=server:scp`)) ? [] : CHANNEL_FLAGS;
-  return [...args.slice(0, at), ...channels, ...added, ...args.slice(at)];
-}
-var STRICT_HINT = `${CLI_NAME} claude: --strict-mcp-config without --mcp-config drops the scp mount, so messages cannot wake this session`;
-function externalMcp(args) {
-  return args.some((arg) => arg === "--mcp-config" || arg.startsWith("--mcp-config="));
-}
-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, cwd = process.cwd()) {
-  const file = mcpFile("claude", env);
-  const entries = [];
-  try {
-    const user = mountedEntry("claude", file);
-    if (user) entries.push(user);
-    const config = existsSync(file) ? JSON.parse(readFileSync(file, "utf8")) : {};
-    const local = config.projects?.[cwd]?.mcpServers?.scp;
-    if (local && typeof local === "object") entries.push(local);
-  } catch {
-    return `${CLI_NAME} claude: ${file} is unreadable, so the scp mount is unchecked; fix it or run ${CLI_NAME} setup --write`;
-  }
-  const project = join(cwd, ".mcp.json");
-  try {
-    const entry = existsSync(project) ? mountedEntry("claude", project) : void 0;
-    if (entry) entries.push(entry);
-  } catch {
-  }
-  if (!entries.length) return `${CLI_NAME} claude: Claude Code has no scp MCP mount, so messages cannot wake this session; run ${CLI_NAME} setup --write`;
-  if (!entries.some((entry) => entryArgv("claude", entry).includes("--channels")))
-    return `${CLI_NAME} claude: the scp mount lacks --channels, so messages cannot wake this session; 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 | --as 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 external = externalMcp(args);
-  const hint = external ? void 0 : args.includes("--strict-mcp-config") ? STRICT_HINT : mountHint(env, cwd);
-  if (hint) throw new RelayUsage(hint);
-  if (external) err(`${CLI_NAME} claude: using your --mcp-config; it needs the scp server with --channels for messages to wake this session`);
-  const child = spawn(bin, claudeLaunchArgs(args, namePrompt(name, args, env, cwd)), {
-    cwd,
-    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,
-  claudeLaunchArgs,
-  mountHint,
-  namePrompt
-};