@scp-dev/cli 0.5.0 → 0.6.0

package/dist/{chunk-AAFHLHXG.js → chunk-BSX24XMZ.js}

@@ -374,6 +374,7 @@ function hookHarnessPid(env, harness, ppid = process.ppid, parentOf = psParent)
   if (Number.isInteger(pid) && pid > 1) return pid;
   return harnessPid(ppid, parentOf);
 }
+var HARNESS_SESSION = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 function relayIdentity(input) {
   const resolved = resolveHarness(input.harness, input.env, input.fallbackHarness);
   const pid = input.harnessPid(resolved);
@@ -382,6 +383,7 @@ function relayIdentity(input) {
   const handle = input.as ?? input.env.SCP_NAME ?? deriveHandle(harness, cwd);
   const harnessProcess = processKey(pid, input.startOf);
   const keys = input.lineageOf ? input.lineageOf(pid) : lineage(pid);
+  const harnessSession = harness === "claude-code" ? [input.harnessSession, input.env.CLAUDE_CODE_SESSION_ID].find((id) => id !== void 0 && HARNESS_SESSION.test(id)) : void 0;
   return {
     handle,
     harness,
@@ -391,7 +393,8 @@ function relayIdentity(input) {
     labels: labelsFor(input.env),
     ...input.env.SCP_PARENT ? { parent: input.env.SCP_PARENT } : {},
     ...keys.length ? { lineage: keys } : {},
-    ...input.env.SCP_GRANT ? { grant: input.env.SCP_GRANT } : {}
+    ...input.env.SCP_GRANT ? { grant: input.env.SCP_GRANT } : {},
+    ...harnessSession ? { harness_session: harnessSession } : {}
   };
 }
 
@@ -466,6 +469,7 @@ var OPTIONS = {
   who: { type: "boolean" },
   peek: { type: "string" },
   endpoint: { type: "string" },
+  "take-over": { type: "boolean" },
   live: { type: "boolean" },
   parent: { type: "string" }
 };
@@ -591,7 +595,7 @@ async function open(verb, values, cwd, bodyFromStdin, walk) {
         `${CLI_NAME2} ${verb} needs an identity: --as HANDLE (or $SCP_NAME) for an agent, or --human for your own inbox me/ (no terminal is attached, so me/ is not assumed)`
       );
     }
-    const { machineName, openCloud } = await import("./remote-UQJ5YYCC.js");
+    const { machineName, openCloud } = await import("./remote-3R4GRDGI.js");
     const handle2 = named ? localHandle(named) : void 0;
     const claim = handle2 ? {
       handle: handle2,
@@ -849,7 +853,7 @@ function relayVerb(positionals, asJson, env = process.env) {
 }
 async function loginMain(positionals, values) {
   if (positionals.length) throw new RelayUsage(`${CLI_NAME3} login takes only flags`);
-  return (await import("./login-6MVD3VLC.js")).login(values);
+  return (await import("./login-4IF26HH5.js")).login(values);
 }
 function logoutMain(positionals, asJson, env = process.env) {
   if (positionals.length) throw new RelayUsage(`${CLI_NAME3} logout takes no arguments`);

package/dist/{chunk-2342GTME.js → chunk-C5PYVRJE.js}

@@ -10,11 +10,11 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-XQHPDNVG.js";
+} from "./chunk-GG33NSBW.js";
 import {
   RelayUsage,
   gitToplevel
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 
 // src/install.ts
 import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";

package/dist/{chunk-H2XQXMZU.js → chunk-C7ZUACP7.js}

@@ -5,7 +5,7 @@ import {
   configDir,
   relayCredential,
   writePrivateJson
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import {
   note,
   printTable

package/dist/{chunk-7RA7E5WR.js → chunk-CVW3INZO.js}

@@ -3,10 +3,10 @@ import {
   agySettingsFile,
   mcpFile,
   mountedEntry
-} from "./chunk-UKQBH4AQ.js";
+} from "./chunk-DEK3TE6T.js";
 import {
   steerPrompt
-} from "./chunk-XQHPDNVG.js";
+} from "./chunk-GG33NSBW.js";
 import {
   OPTIONS,
   RelayUsage,
@@ -18,7 +18,7 @@ import {
   selectorList,
   spawnerKey,
   walkNow
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import {
   SELF,
   note

package/dist/{chunk-UKQBH4AQ.js → chunk-DEK3TE6T.js}

@@ -1,6 +1,6 @@
 import {
   hooksTarget
-} from "./chunk-2342GTME.js";
+} from "./chunk-C5PYVRJE.js";
 import {
   AGY_HOOK_SET,
   BLOCK_STOP,
@@ -12,12 +12,12 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-XQHPDNVG.js";
+} from "./chunk-GG33NSBW.js";
 import {
   RelayUsage,
   gitToplevel,
   setJoinMode
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 
 // src/setup.ts
 import { spawnSync } from "child_process";

package/dist/{chunk-XQHPDNVG.js → chunk-GG33NSBW.js}

@@ -13,7 +13,7 @@ import {
   psStart,
   relayIdentity,
   sessionKey
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 
 // src/hooks.ts
 import { Readable } from "stream";
@@ -445,8 +445,10 @@ async function runHook(args, options) {
     )
   );
   if ("dark" in joined) return;
+  const harnessSession = event.agent ? void 0 : asString(field(payload, "session_id", "sessionId"));
   const claim = relayIdentity({
     ...joined.handle ? { as: joined.handle } : {},
+    ...harnessSession ? { harnessSession } : {},
     harness,
     fallbackHarness: "hook",
     cwd: event.cwd ?? options.cwd,
@@ -556,8 +558,10 @@ async function wakeHook(harnessArg, payload, waitS, options) {
     )
   );
   if ("dark" in joined) return;
+  const harnessSession = asString(field(payload, "session_id", "sessionId"));
   const claim = relayIdentity({
     ...joined.handle ? { as: joined.handle } : {},
+    ...harnessSession ? { harnessSession } : {},
     harness,
     fallbackHarness: "hook",
     cwd: asString(payload.cwd) ?? options.cwd,

package/dist/claude-NCPNZLIX.js

@@ -0,0 +1,290 @@
+import {
+  entryArgv,
+  mcpFile,
+  mountedEntry,
+  whichOnPath
+} from "./chunk-DEK3TE6T.js";
+import "./chunk-C5PYVRJE.js";
+import "./chunk-GG33NSBW.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  CHANNELS_ENV,
+  RelayUsage,
+  deriveHandle,
+  joinMode
+} from "./chunk-BSX24XMZ.js";
+import {
+  SELF
+} from "./chunk-MNTIEWKF.js";
+
+// src/claude.ts
+import { spawn, spawnSync } from "child_process";
+import { randomBytes } from "crypto";
+import { existsSync, readFileSync, symlinkSync, unlinkSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import { privateDir, relayDir } from "@scp-dev/broker";
+import { CLI_NAME, validHandle } from "@scp-dev/core";
+var CHANNEL_FLAGS = ["--dangerously-load-development-channels", "server:scp"];
+function claudeArgv(argv) {
+  let name;
+  let bg = false;
+  let i = 0;
+  for (; ; ) {
+    const arg = argv[i];
+    if (arg === "--bg" || arg === "--background") {
+      bg = true;
+      i++;
+    } else 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`);
+  const args = argv.slice(i);
+  if (!bg) bg = optionsOf(args).some((arg) => arg === "--bg" || arg === "--background");
+  return { ...name !== void 0 ? { name } : {}, ...bg ? { bg: true } : {}, args };
+}
+var optionsOf = (args) => args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
+function beforeDashes(args, added) {
+  const at = optionsOf(args).length;
+  return [...args.slice(0, at), ...added, ...args.slice(at)];
+}
+function claudeLaunchArgs(args, added) {
+  const channels = optionsOf(args).some((arg) => arg === "server:scp" || arg === `${CHANNEL_FLAGS[0]}=server:scp`) ? [] : CHANNEL_FLAGS;
+  return beforeDashes(args, [...channels, ...added]);
+}
+var LAUNCHER_IDENTITY = ["SCP_NAME", "SCP_GRANT", "SCP_SESSION", "SCP_PARENT", "SCP_HARNESS", "SCP_SHIM_BINDING", "SCP_SPAWN_RUNNER", CHANNELS_ENV];
+var SHIM_VARS = ["SCP_LABELS", "SCP_DIR", "XDG_STATE_HOME"];
+var bgDir = (env) => join(relayDir(env), "claude-bg");
+function bgMount(env, name) {
+  let entry;
+  try {
+    entry = mountedEntry("claude", mcpFile("claude", env));
+  } catch {
+  }
+  const mounted = entry ? entryArgv("claude", entry) : [];
+  const argv = mounted.includes("--channels") ? mounted : [...SELF, "mcp", "--harness", "claude", "--channels"];
+  const base = entry?.env && typeof entry.env === "object" ? entry.env : {};
+  const vars = Object.fromEntries(SHIM_VARS.flatMap((key) => env[key] ? [[key, env[key]]] : []));
+  return {
+    type: "stdio",
+    command: argv[0],
+    args: argv.slice(1),
+    env: { ...base, ...vars, ...name !== void 0 ? { SCP_NAME: name } : {}, SCP_GRANT: env.SCP_GRANT ?? "" }
+  };
+}
+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;
+}
+var SHORT_ID = /^[0-9a-f]{8}$/;
+var BACKGROUNDED = /backgrounded\s*\S\s*([0-9a-f]{8})/;
+function liveAgents(bin, env) {
+  const run = spawnSync(bin, ["agents", "--json"], { env, encoding: "utf8", timeout: 15e3 });
+  try {
+    const listed = JSON.parse(run.stdout);
+    return Array.isArray(listed) ? listed.filter((agent) => typeof agent?.id === "string" && agent.state !== "failed") : [];
+  } catch {
+    return [];
+  }
+}
+function resumeTarget(args) {
+  const options = optionsOf(args);
+  for (const [i, arg] of options.entries()) {
+    if (arg.startsWith("--resume=")) return arg.slice("--resume=".length);
+    if ((arg === "--resume" || arg === "-r") && options[i + 1] && !options[i + 1].startsWith("-")) return options[i + 1];
+  }
+  return void 0;
+}
+async function runClaude(bin, args, env, cwd, stdout = "inherit", onOut) {
+  const child = spawn(bin, args, { cwd, stdio: ["inherit", stdout, "inherit"], env });
+  child.stdout?.on("data", (chunk) => {
+    process.stdout.write(chunk);
+    onOut?.(chunk.toString("utf8"));
+  });
+  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("close", (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);
+  }
+}
+async function backgroundCommand(name, args, env, cwd, bin, out) {
+  const handle = name ?? (env.SCP_NAME || void 0);
+  const dir = privateDir(bgDir(env));
+  const file = join(dir, `${randomBytes(8).toString("hex")}.json`);
+  writeFileSync(file, `${JSON.stringify({ mcpServers: { scp: bgMount(env, handle) } }, null, 2)}
+`, { mode: 384 });
+  const options = optionsOf(args);
+  const added = [
+    ...options.includes("--bg") || options.includes("--background") ? [] : ["--bg"],
+    ...handle !== void 0 && !options.some((arg) => arg === "-n" || arg === "--name" || arg.startsWith("--name=")) ? ["--name", handle] : [],
+    ...namePrompt(handle, args, env, cwd),
+    "--mcp-config",
+    file
+  ];
+  const clean = Object.fromEntries(Object.entries(env).filter(([key]) => !LAUNCHER_IDENTITY.includes(key)));
+  let printed = "";
+  const code = await runClaude(bin, beforeDashes(args, added), clean, cwd, "pipe", (text) => {
+    printed += text;
+  });
+  const id = BACKGROUNDED.exec(printed)?.[1];
+  if (!id) {
+    unlinkSync(file);
+    return code || 1;
+  }
+  try {
+    unlinkSync(join(dir, `${id}.json`));
+  } catch {
+  }
+  symlinkSync(basename(file), join(dir, `${id}.json`));
+  const address = `me/${handle ?? deriveHandle("claude-code", cwd)}`;
+  out(`${CLI_NAME} claude: background session ${id} is ${address} on SCP; messages wake it through its inbox. ${CLI_NAME} claude attach ${id} opens it`);
+  return code;
+}
+async function attachCommand(argv, env, err, cwd, bin, deps) {
+  let target;
+  let rename;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--name" || arg === "--as") {
+      rename = argv[++i];
+      if (rename === void 0) throw new RelayUsage(`${CLI_NAME} claude attach ${arg} takes a handle`);
+    } else if (arg.startsWith("--name=") || arg.startsWith("--as=")) rename = arg.slice(arg.indexOf("=") + 1);
+    else if (target === void 0) target = arg;
+    else throw new RelayUsage(`${CLI_NAME} claude attach takes one session: <id|name> [--name N]`);
+  }
+  if (target === void 0) throw new RelayUsage(`${CLI_NAME} claude attach takes a background session: <id|name> [--name N]`);
+  rename = rename?.replace(/^me\//, "");
+  if (rename !== void 0) {
+    if (!validHandle(rename)) throw new RelayUsage(`--name ${JSON.stringify(rename)} is not a valid agent handle`);
+    await renameBackground(target, rename, env, err, bin, deps);
+  }
+  return runClaude(bin, ["attach", target], env, cwd);
+}
+async function renameBackground(target, to, env, err, bin, deps) {
+  const agent = SHORT_ID.test(target) ? void 0 : liveAgents(bin, env).find((a) => a.name === target || a.sessionId === target);
+  const id = SHORT_ID.test(target) ? target : agent?.id;
+  const link = id ? join(bgDir(env), `${id}.json`) : void 0;
+  let config;
+  try {
+    config = link ? JSON.parse(readFileSync(link, "utf8")) : void 0;
+  } catch {
+  }
+  const from = config?.mcpServers?.scp?.env?.SCP_NAME ?? (SHORT_ID.test(target) ? void 0 : target);
+  if (!link || !config?.mcpServers?.scp?.env || from === void 0) {
+    err(`${CLI_NAME} claude: ${target} was not started by ${CLI_NAME} claude --bg --name, so its name is unknown; run ${CLI_NAME} name ${to} in it`);
+    return;
+  }
+  if (from === to) return;
+  const code = await (deps.rename ?? renameEndpoint)(from, to);
+  if (code !== 0) {
+    err(`${CLI_NAME} claude: me/${from} keeps its name`);
+    return;
+  }
+  config.mcpServers.scp.env.SCP_NAME = to;
+  writeFileSync(link, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+}
+async function renameEndpoint(from, to) {
+  return (await import("./main-RA3MP25N.js")).relayMain(["name", "--endpoint", `me/${from}`, to]);
+}
+async function claudeCommand(argv, env = process.env, err = (line) => void process.stderr.write(`${line}
+`), cwd = process.cwd(), deps = {}) {
+  if (argv[0] === "--help" || argv[0] === "-h") {
+    process.stdout.write(CLAUDE_HELP);
+    return 0;
+  }
+  const out = deps.out ?? ((line) => void process.stdout.write(`${line}
+`));
+  const bin = whichOnPath("claude", env);
+  if (argv[0] === "attach") {
+    if (!bin) throw new RelayUsage("claude is not on PATH");
+    return attachCommand(argv.slice(1), env, err, cwd, bin, deps);
+  }
+  const { name, bg, args } = claudeArgv(argv);
+  if (!bin) throw new RelayUsage("claude is not on PATH");
+  if (bg) return backgroundCommand(name, args, env, cwd, bin, out);
+  const resume = resumeTarget(args);
+  const live = resume === void 0 ? void 0 : liveAgents(bin, env).find((agent) => agent.id === resume || agent.sessionId === resume);
+  if (live) {
+    err(`${CLI_NAME} claude: ${resume} is a live background session, already woken through claude-inbox; attaching to it (claude attach ${live.id})`);
+    return runClaude(bin, ["attach", live.id], env, cwd);
+  }
+  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`);
+  return runClaude(
+    bin,
+    claudeLaunchArgs(args, namePrompt(name, args, env, cwd)),
+    { ...env, ...name !== void 0 ? { SCP_NAME: name } : {}, [CHANNELS_ENV]: String(process.pid) },
+    cwd
+  );
+}
+var CLAUDE_HELP = `${CLI_NAME} claude [--name N | --as N] [--] [claude args...]   start Claude Code with the scp channel loaded, so peer messages wake it
+${CLI_NAME} claude --bg [--name N] [--] [claude args...]   start it in the background (claude --bg) with an scp mount that claims N and
+                                                 $SCP_GRANT, so env $(${CLI_NAME} spawn-env --name N) links it under you; messages wake it
+                                                 through its inbox. Prints its short id and address
+${CLI_NAME} claude attach <id|name> [--name N]    claude attach, renaming its endpoint to N first
+  --resume <id> of a live background session attaches to it: it is already woken through claude-inbox
+`;
+var SIGNALS = { SIGHUP: 1, SIGINT: 2, SIGKILL: 9, SIGTERM: 15 };
+var signalNumber = (signal) => SIGNALS[signal];
+export {
+  CHANNEL_FLAGS,
+  bgDir,
+  bgMount,
+  claudeArgv,
+  claudeCommand,
+  claudeLaunchArgs,
+  mountHint,
+  namePrompt,
+  resumeTarget
+};

package/dist/cli.js

@@ -17,6 +17,6 @@ function quietSqliteWarning() {
 // src/cli.ts
 if (!await subagentFastPath(process.argv.slice(2))) {
   quietSqliteWarning();
-  const { run } = await import("./main-F2NFQ2KC.js");
+  const { run } = await import("./main-RA3MP25N.js");
   await run(process.argv.slice(2));
 }

package/dist/{codex-OSGHQMK6.js → codex-4GTXURTS.js}

@@ -3,18 +3,18 @@ import {
   codexMount,
   codexOverrides,
   toml
-} from "./chunk-7RA7E5WR.js";
+} from "./chunk-CVW3INZO.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-UKQBH4AQ.js";
-import "./chunk-2342GTME.js";
-import "./chunk-XQHPDNVG.js";
+import "./chunk-DEK3TE6T.js";
+import "./chunk-C5PYVRJE.js";
+import "./chunk-GG33NSBW.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,
   readPsTable,
   relayIdentity,
   startDaemon
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import {
   SELF
 } from "./chunk-MNTIEWKF.js";

package/dist/{hooks-BZANUJPY.js → hooks-SWVIDONV.js}

@@ -40,11 +40,11 @@ import {
   tldrEvery,
   transcriptTitle,
   unreadPointer
-} from "./chunk-XQHPDNVG.js";
+} from "./chunk-GG33NSBW.js";
 import {
   SUBAGENT
 } from "./chunk-YYSLYVNZ.js";
-import "./chunk-AAFHLHXG.js";
+import "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 export {
   AGY_HOOK_SET,

package/dist/{install-25J5QB63.js → install-YE7LCGPC.js}

@@ -2,10 +2,10 @@ import {
   hooksTarget,
   installHooks,
   mcpInstall
-} from "./chunk-2342GTME.js";
-import "./chunk-XQHPDNVG.js";
+} from "./chunk-C5PYVRJE.js";
+import "./chunk-GG33NSBW.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-AAFHLHXG.js";
+import "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 export {
   hooksTarget,

package/dist/{join-EOLHE3LJ.js → join-64BU6SEY.js}

@@ -7,7 +7,7 @@ import {
   sessionKey,
   startDaemon,
   walkNow
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/join.ts

package/dist/{login-6MVD3VLC.js → login-4IF26HH5.js}

@@ -1,11 +1,11 @@
 import {
   machineName
-} from "./chunk-H2XQXMZU.js";
+} from "./chunk-C7ZUACP7.js";
 import {
   RelayUsage,
   activeRelay,
   saveCredential
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import {
   note
 } from "./chunk-MNTIEWKF.js";

package/dist/{main-F2NFQ2KC.js → main-RA3MP25N.js}

@@ -16,7 +16,7 @@ import {
   startDaemon,
   terminalAttached,
   time
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import {
   FAILED,
   exitFlushed,
@@ -35,7 +35,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.5.0",
+  version: "0.6.0",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -281,6 +281,9 @@ agent sessions:
                                                  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} claude --bg [--name N] [--] [claude args...]   the same in the background (claude --bg): an scp mount claims N and
+                                                 $SCP_GRANT, so under env $(${CLI_NAME} spawn-env --name N) it links under you; prints its short id
+  ${CLI_NAME} claude attach <id|name> [--name N]    claude attach, renaming its endpoint to N first; --resume of a live bg session attaches
   ${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
@@ -289,6 +292,9 @@ agent sessions:
                                                  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} name <handle> --take-over [--endpoint EP]   take the handle from an offline endpoint: it is retired and its
+                                                 children, links and unread mail move over (the same harness session, such as
+                                                 a resumed one, needs no flag); for the human at a terminal
   ${CLI_NAME} join [<handle>] --under <parent>   link the session under the agent <parent> (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
@@ -396,7 +402,7 @@ var VERBS = {
   link: IDENTITY,
   unlink: IDENTITY,
   leave: [...IDENTITY, "endpoint"],
-  name: [...IDENTITY, "endpoint"],
+  name: [...IDENTITY, "endpoint", "take-over"],
   inbox: [...IDENTITY, "wait", "ack", "keep"],
   reply: IDENTITY,
   ack: [...IDENTITY, "all"],
@@ -569,14 +575,14 @@ async function relayMain(argv, cwd = process.cwd()) {
     out(cliVersion());
     return 0;
   }
-  if (verb === "hook") return (await import("./hooks-BZANUJPY.js")).relayHookCommand(rest, startDaemon);
-  if (verb === "setup") return (await import("./setup-UJCIMYU4.js")).relaySetupCommand(rest, cwd, out);
-  if (verb === "claude") return (await import("./claude-RNH2E4GU.js")).claudeCommand(rest);
-  if (verb === "pi") return (await import("./pi-N3DX37PD.js")).piCommand(rest);
-  if (verb === "codex") return (await import("./codex-OSGHQMK6.js")).codexCommand(rest);
-  if (verb === "opencode") return (await import("./opencode-XV33XTL5.js")).opencodeCommand(rest, process.env, void 0, cwd);
+  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 === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-JYD7NCQT.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-CJSHYE7E.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -584,7 +590,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     }
     return spawnCommand(rest, cwd);
   }
-  if (verb === "mesh") return (await import("./mesh-OZILTV5P.js")).meshCommand(rest);
+  if (verb === "mesh") return (await import("./mesh-XTMBRJLR.js")).meshCommand(rest);
   const allowed = VERBS[verb];
   if (!allowed) throw new RelayUsage(`unknown command "${verb}"`);
   let parsed;
@@ -604,11 +610,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     return daemon(values.idle, values.policy);
   }
   if (verb === "mcp")
-    return (await import("./mcp-BH526TOG.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-RERRUUIX.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-25J5QB63.js")).installHooks({
+    return (await import("./install-YE7LCGPC.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -619,27 +625,27 @@ async function relayMain(argv, cwd = process.cwd()) {
       out
     });
   }
-  if (verb === "relay") return (await import("./relay-SF3UWIPM.js")).relayVerb(positionals, values.json === true);
-  if (verb === "up") return (await import("./up-3YJU7YX6.js")).up(positionals, values, cwd, relinkBroker);
+  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 === "login") {
-    const code = await (await import("./relay-SF3UWIPM.js")).loginMain(positionals, values);
+    const code = await (await import("./relay-E4JFR33E.js")).loginMain(positionals, values);
     if (code === 0) await relinkRunning();
     return code;
   }
-  if (verb === "logout") return (await import("./relay-SF3UWIPM.js")).logoutMain(positionals, values.json === true);
+  if (verb === "logout") return (await import("./relay-E4JFR33E.js")).logoutMain(positionals, values.json === true);
   if (verb === "cloud") {
-    const code = await (await import("./remote-UQJ5YYCC.js")).cloudMain(positionals, values, cloudStatus);
+    const code = await (await import("./remote-3R4GRDGI.js")).cloudMain(positionals, values, cloudStatus);
     if (code === 0 && positionals[0] === "enable") await relinkRunning();
     return code;
   }
-  if (verb === "join") return (await import("./join-EOLHE3LJ.js")).joinCommand(values, positionals, cwd, out);
+  if (verb === "join") return (await import("./join-64BU6SEY.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-UQJ5YYCC.js")).machinesVerb(client, positionals, values.json === true);
+    if (verb === "machines") return await (await import("./remote-3R4GRDGI.js")).machinesVerb(client, positionals, values.json === true);
     return await runVerb(opened, verb, values, positionals, cwd);
   } finally {
     client.close();
@@ -647,7 +653,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-UQJ5YYCC.js");
+    const { openCloud } = await import("./remote-3R4GRDGI.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");
@@ -832,9 +838,9 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
       return 0;
     }
     case "peek":
-      return (await import("./peek-LFQR6TCS.js")).peekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-GEYQ7SHV.js")).peekCommand(localClient(client, broker, verb), values, positionals);
     case "set-peek":
-      return (await import("./peek-LFQR6TCS.js")).setPeekCommand(localClient(client, broker, verb), values, positionals);
+      return (await import("./peek-GEYQ7SHV.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>`);
@@ -1058,7 +1064,11 @@ async function runVerb({ client, me, broker, where, bound, harnessPid }, verb, v
         return 0;
       }
       const before = endpoint ?? me?.address;
-      const view = await client.request("rename", { handle: positionals[0], ...endpoint !== void 0 ? { endpoint } : {} });
+      const view = await client.request("rename", {
+        handle: positionals[0],
+        ...endpoint !== void 0 ? { endpoint } : {},
+        ...values["take-over"] === true ? { take_over: true } : {}
+      });
       if (asJson) json(view);
       else out(before && before !== view.address ? `${before} is now ${view.address}` : `${view.address}`);
       return 0;
@@ -1454,11 +1464,11 @@ async function daemon(idle, policyFile) {
   });
   let broker;
   try {
-    const { daemonBridge } = await import("./remote-UQJ5YYCC.js");
+    const { daemonBridge } = await import("./remote-3R4GRDGI.js");
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),
-      ...bridge ? { bridge } : await (await import("./mesh-OZILTV5P.js")).meshBrokerOptions(),
+      ...bridge ? { bridge } : await (await import("./mesh-XTMBRJLR.js")).meshBrokerOptions(),
       bridgeConfig: () => daemonBridge(),
       ...idleMs !== void 0 ? { idleMs } : {},
       ...policyFile ? { policyPath: resolve(policyFile) } : {}

package/dist/{mcp-BH526TOG.js → mcp-RERRUUIX.js}

@@ -1,12 +1,12 @@
 import {
   spawnDetached
-} from "./chunk-7RA7E5WR.js";
+} from "./chunk-CVW3INZO.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-UKQBH4AQ.js";
+import "./chunk-DEK3TE6T.js";
 import {
   mcpInstall
-} from "./chunk-2342GTME.js";
-import "./chunk-XQHPDNVG.js";
+} from "./chunk-C5PYVRJE.js";
+import "./chunk-GG33NSBW.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
@@ -18,7 +18,7 @@ import {
   relayIdentity,
   startDaemon,
   writeShimBinding
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/mcp.ts

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

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

package/dist/{opencode-XV33XTL5.js → opencode-CPNR2G3W.js}

@@ -2,18 +2,18 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-UKQBH4AQ.js";
+} from "./chunk-DEK3TE6T.js";
 import {
   hooksTarget
-} from "./chunk-2342GTME.js";
+} from "./chunk-C5PYVRJE.js";
 import {
   opencodePlugin
-} from "./chunk-XQHPDNVG.js";
+} from "./chunk-GG33NSBW.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,
   gitToplevel
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/opencode.ts

package/dist/{peek-LFQR6TCS.js → peek-GEYQ7SHV.js}

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

package/dist/{pi-N3DX37PD.js → pi-XHZAUDP4.js}

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

package/dist/{relay-SF3UWIPM.js → relay-E4JFR33E.js}

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

package/dist/{remote-UQJ5YYCC.js → remote-3R4GRDGI.js}

@@ -9,8 +9,8 @@ import {
   machinesVerb,
   openCloud,
   readCloudFile
-} from "./chunk-H2XQXMZU.js";
-import "./chunk-AAFHLHXG.js";
+} from "./chunk-C7ZUACP7.js";
+import "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 export {
   CloudRelayClient,

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

@@ -15,11 +15,11 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-UKQBH4AQ.js";
-import "./chunk-2342GTME.js";
-import "./chunk-XQHPDNVG.js";
+} from "./chunk-DEK3TE6T.js";
+import "./chunk-C5PYVRJE.js";
+import "./chunk-GG33NSBW.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-AAFHLHXG.js";
+import "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 export {
   SETUP_HARNESSES,

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

@@ -31,15 +31,15 @@ import {
   toml,
   transcriptReplies,
   workerName
-} from "./chunk-7RA7E5WR.js";
+} from "./chunk-CVW3INZO.js";
 import {
   SPAWN_HELP
 } from "./chunk-KN7WEIE4.js";
-import "./chunk-UKQBH4AQ.js";
-import "./chunk-2342GTME.js";
-import "./chunk-XQHPDNVG.js";
+import "./chunk-DEK3TE6T.js";
+import "./chunk-C5PYVRJE.js";
+import "./chunk-GG33NSBW.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-AAFHLHXG.js";
+import "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 export {
   CODEX_VALUED,

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

@@ -2,7 +2,7 @@ import {
   RelayUsage,
   activeRelay,
   relayCredential
-} from "./chunk-AAFHLHXG.js";
+} from "./chunk-BSX24XMZ.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/up.ts
@@ -29,21 +29,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-4IF26HH5.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-3R4GRDGI.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-O45SE5L7.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-O45SE5L7.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.6.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.3.1",
+    "@scp-dev/broker": "0.4.1",
+    "@scp-dev/hub": "0.6.2",
+    "@scp-dev/mcp": "0.2.1",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
     "@openai/codex": "0.159.0",
-    "@scp-dev/mesh": "0.0.7",
+    "@scp-dev/mesh": "0.0.8",
     "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
-};