@scp-dev/cli 0.6.0 → 0.8.0

package/dist/remote-spawn-7Z2FLG33.js

@@ -0,0 +1,309 @@
+import {
+  STDIN_WAIT_MS,
+  agentShell,
+  closedStdin,
+  harnessArgv,
+  harnessOutput,
+  harnessStdin,
+  programAt,
+  runHarness,
+  spawnEnvironment,
+  spawnTitle,
+  stderrOutput,
+  workerName
+} from "./chunk-ZEWZBRVM.js";
+import "./chunk-FPNFRDXG.js";
+import "./chunk-77NUOWQ4.js";
+import "./chunk-MHBWDAXO.js";
+import "./chunk-UUFTEXDU.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  RelayUsage,
+  labelsFor,
+  localClient,
+  normalizeHarness,
+  open,
+  parseLabels,
+  startDaemon
+} from "./chunk-6S3V5ZGU.js";
+import {
+  note
+} from "./chunk-MNTIEWKF.js";
+
+// src/remote-spawn.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { basename, dirname, join } from "path";
+import { constants } from "os";
+import { CLI_NAME, findSecret, handbackOutput, LIMITS, validHandle } from "@scp-dev/core";
+import { connectBroker, policyPath, relayDir } from "@scp-dev/broker";
+var RUNNER_NAME = /^[a-z0-9][a-z0-9-]{0,31}$/;
+var RUNNER_TIMEOUT_S = 60;
+var RUNNER_TIMEOUT_MAX_S = 3600;
+var RUNNER_STDERR_BYTES = 2048;
+var RUNNER_STDOUT_BYTES = 4096;
+var RUNNER_REF = /^[\x21-\x7e]{1,256}$/;
+var RUNNER_ATTACH = /^[^\u0000-\u001f\u007f-\u009f]{1,1024}$/;
+var RUNNER_DRAIN_MS = 500;
+var TITLE_CHARS = 64;
+var MACHINE = "[a-z0-9][a-z0-9-]{0,31}";
+var MACHINE_ADDRESS = new RegExp(`^me/(${MACHINE})/([^/]+)$`);
+var STDERR_LABEL = `stderr (last ${LIMITS.stderrBytes / 1024} KB):`;
+var VIA_FLAGS = ["as", "harness", "name", "title", "labels", "bg", "json", "via"];
+var GRANT_FLAGS = ["scope", "rules", "in", "out", "allow", "group", "ttl", "peek", "no-push", "as", "human", "harness"];
+function runnersPath(env = process.env) {
+  return env.SCP_RUNNERS_FILE || join(dirname(policyPath()), "runners.json");
+}
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseRunners(text, path) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new RelayUsage(`${path} is not JSON`);
+  }
+  if (!isObject(value)) throw new RelayUsage(`${path} maps runner names to {command, timeout_s?}`);
+  const runners = {};
+  for (const [name, entry] of Object.entries(value)) {
+    if (!RUNNER_NAME.test(name))
+      throw new RelayUsage(`${path}: runner ${JSON.stringify(name)} is not a valid name: lowercase letters, digits and -, at most 32`);
+    const command = isObject(entry) ? entry.command : void 0;
+    if (!Array.isArray(command) || !command.length || !command.every((word) => typeof word === "string" && word.length > 0))
+      throw new RelayUsage(`${path}: runner ${name} needs command, a non-empty list of words`);
+    const timeout = entry.timeout_s ?? RUNNER_TIMEOUT_S;
+    if (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout < 1 || timeout > RUNNER_TIMEOUT_MAX_S)
+      throw new RelayUsage(`${path}: runner ${name}'s timeout_s is whole seconds, 1 to ${RUNNER_TIMEOUT_MAX_S}`);
+    runners[name] = { command: [...command], timeout_s: timeout };
+  }
+  return runners;
+}
+function readRunners(path = runnersPath()) {
+  return existsSync(path) ? parseRunners(readFileSync(path, "utf8"), path) : {};
+}
+function runnerFor(name, runners, path) {
+  const runner = Object.hasOwn(runners, name) ? runners[name] : void 0;
+  if (runner) return runner;
+  const known = Object.keys(runners);
+  throw new RelayUsage(`no runner ${JSON.stringify(name)} in ${path}: ${known.length ? `configured: ${known.join(", ")}` : "none is configured"}`);
+}
+function spawnRequest(o) {
+  return {
+    scp: 1,
+    event: "spawn",
+    name: o.name,
+    title: o.title,
+    cmd: o.command,
+    cwd: o.cwd,
+    parent: o.parent,
+    labels: o.labels,
+    join: { under: o.parent, name: o.name, mode: "account" }
+  };
+}
+function tail(from, bytes) {
+  let kept = Buffer.alloc(0);
+  let cut = false;
+  from.on("data", (chunk) => {
+    kept = Buffer.concat([kept, chunk]);
+    if (kept.length > bytes) {
+      kept = kept.subarray(kept.length - bytes);
+      cut = true;
+    }
+  });
+  return { text: () => kept.toString("utf8"), cut: () => cut };
+}
+function runRunner(runner, request, env) {
+  return new Promise((resolve) => {
+    const child = spawn(runner.command[0], runner.command.slice(1), { detached: true, stdio: ["pipe", "pipe", "pipe"], env, cwd: request.cwd });
+    const out = tail(child.stdout, RUNNER_STDOUT_BYTES);
+    const err = tail(child.stderr, RUNNER_STDERR_BYTES);
+    const pipes = [child.stdout, child.stderr];
+    let settled = false;
+    const finish = (code, timedOut = false, message) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const done = () => {
+        for (const pipe of pipes) pipe.destroy();
+        child.unref();
+        const stderr = message ?? handbackOutput(err.text(), err.cut(), RUNNER_STDERR_BYTES);
+        resolve({ code, timedOut, stdout: out.cut() ? "" : out.text(), stderr });
+      };
+      const open2 = pipes.filter((pipe) => !pipe.readableEnded);
+      if (!open2.length || message) return done();
+      const drain = setTimeout(done, RUNNER_DRAIN_MS);
+      let left = open2.length;
+      for (const pipe of open2)
+        pipe.once("end", () => {
+          if (--left > 0) return;
+          clearTimeout(drain);
+          done();
+        });
+    };
+    const timer = setTimeout(() => {
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+      }
+      finish(124, true);
+    }, runner.timeout_s * 1e3);
+    child.once(
+      "error",
+      (error) => finish(error.code === "ENOENT" ? 127 : 126, false, `${runner.command[0]}: ${error.code === "ENOENT" ? "command not found" : error.message}`)
+    );
+    child.once("exit", (code, signal) => finish(code ?? 128 + (signal ? constants.signals[signal] ?? 0 : 0)));
+    child.stdin.on("error", () => {
+    });
+    child.stdin.end(`${JSON.stringify(request)}
+`);
+  });
+}
+function runnerReply(stdout, name) {
+  let value;
+  try {
+    value = JSON.parse(stdout.trim());
+  } catch {
+    return void 0;
+  }
+  if (!isObject(value) || typeof value.machine !== "string" || typeof value.address !== "string") return void 0;
+  const address = MACHINE_ADDRESS.exec(value.address);
+  if (!address || address[1] !== value.machine || address[2] !== name) return void 0;
+  if (value.ref !== void 0 && (typeof value.ref !== "string" || !RUNNER_REF.test(value.ref))) return void 0;
+  if (value.attach !== void 0 && (typeof value.attach !== "string" || !RUNNER_ATTACH.test(value.attach))) return void 0;
+  const ref = typeof value.ref === "string" && !findSecret(value.ref) ? value.ref : void 0;
+  const attach = typeof value.attach === "string" && !findSecret(value.attach) ? value.attach : void 0;
+  return { address: value.address, machine: value.machine, ...ref ? { ref } : {}, ...attach ? { attach } : {} };
+}
+function viaStarted(o) {
+  if (o.json) return [JSON.stringify({ name: o.name, runner: o.runner, parent: o.parent, ...o.reply })];
+  const where = o.reply ? `on machine ${o.reply.machine} and shows under you as ${o.reply.address}` : `on another machine and shows under you as me/<machine>/${o.name}`;
+  return [
+    `${o.name} handed to runner ${o.runner}: it starts ${where}; its result arrives as a relay message by itself`,
+    ...o.reply?.attach ? [`attach: ${o.reply.attach}`] : []
+  ];
+}
+function spawnName(values, command) {
+  const name = typeof values.name === "string" ? values.name.replace(/^me\//, "") : workerName(command);
+  if (!validHandle(name)) throw new RelayUsage(`--name ${JSON.stringify(name)} is not a valid agent handle: lowercase letters, digits, . _ -`);
+  return name;
+}
+async function hubMachine(client, why) {
+  const bridge = await client.request("cloud_status");
+  if (!bridge.enabled || !bridge.machine)
+    throw new RelayUsage(`${why}, but this relay broker is not linked to a hub (${CLI_NAME} login, then ${CLI_NAME} cloud enable)`);
+  return bridge.machine;
+}
+async function viaSpawn(values, command, cwd, out = (line) => console.log(line)) {
+  const via = values.via;
+  const extra = Object.keys(values).find((key) => !VIA_FLAGS.includes(key));
+  if (extra)
+    throw new RelayUsage(
+      `--via starts the worker on another machine under you, without a local grant: it takes --name, --title, --labels and --json, not --${extra}`
+    );
+  const path = runnersPath();
+  const runner = runnerFor(via, readRunners(path), path);
+  const name = spawnName(values, command);
+  const title = typeof values.title === "string" ? values.title : spawnTitle(command) ?? null;
+  if (title !== null && title.length > TITLE_CHARS) throw new RelayUsage(`--title is longer than ${TITLE_CHARS} characters`);
+  const opened = await open("spawn", values, cwd, false);
+  const client = localClient(opened.client, opened.broker, "spawn");
+  let parent;
+  try {
+    const me = opened.me;
+    if (me?.kind !== "agent" || !me.address.startsWith("me/"))
+      throw new RelayUsage(`${CLI_NAME} spawn --via starts a worker under you: run it from an agent's session, or name the agent with --as`);
+    parent = `me/${await hubMachine(client, `${CLI_NAME} spawn --via shows the worker under you through the hub`)}/${me.address.slice(3)}`;
+  } finally {
+    client.close();
+  }
+  const request = spawnRequest({ name, title, command, cwd, parent, labels: parseLabels(values.labels) });
+  const result = await runRunner(runner, request, spawnEnvironment(process.env, {}));
+  if (result.code === 0) {
+    for (const line of viaStarted({ name, runner: via, parent, reply: runnerReply(result.stdout, name), json: values.json === true })) out(line);
+    return 0;
+  }
+  const failed = result.timedOut ? `did not finish within ${runner.timeout_s} s` : `failed (exit ${result.code})`;
+  note(`${CLI_NAME} spawn: runner ${via} ${failed}${result.stderr ? `:
+${result.stderr}` : ""}`);
+  return result.code;
+}
+async function linkedPlan(values, command) {
+  const under = typeof values.under === "string" ? values.under : void 0;
+  const remote = under === void 0 ? null : MACHINE_ADDRESS.exec(under);
+  if (!under || !remote) return null;
+  const dir = relayDir();
+  const client = await connectBroker(dir, () => startDaemon(dir));
+  let machine;
+  try {
+    await client.hello({ observe: true });
+    machine = await hubMachine(client, `--under ${under} names an agent on machine ${remote[1]}`);
+  } finally {
+    client.close();
+  }
+  if (machine === remote[1]) return null;
+  if (values.via !== void 0) throw new RelayUsage("--via and --under an agent on another machine: the runner already starts this spawn there");
+  const granted = Object.keys(values).find((key) => GRANT_FLAGS.includes(key));
+  if (granted) throw new RelayUsage(`a worker under an agent on another machine runs without a grant: --${granted} does not apply`);
+  return {
+    parent: under,
+    machine,
+    name: spawnName(values, command),
+    ...typeof values.title === "string" ? { title: values.title } : {},
+    ...typeof values.labels === "string" ? { labels: values.labels } : {}
+  };
+}
+function linkedHandbackBody(address, code, output, stderr) {
+  const tail2 = code !== 0 && stderr ? `${STDERR_LABEL}
+${stderr}` : "";
+  const kept = tail2 && output ? handbackOutput(output, false, LIMITS.handbackBytes - Buffer.byteLength(tail2) - 2) : output;
+  const head = kept ? `worker ${address} finished (exit ${code})` : `worker ${address} exited without replying (exit ${code})`;
+  return [head, kept, tail2].filter(Boolean).join("\n\n");
+}
+async function linkedSpawn(plan, command, cwd, options) {
+  const env = spawnEnvironment(process.env, { SCP_NAME: plan.name, SCP_UNDER: plan.parent }, plan.labels);
+  const argv = harnessArgv(command, env);
+  const stdin = closedStdin(command) ? await harnessStdin(agentShell(process.env) ? STDIN_WAIT_MS : void 0) : void 0;
+  const run = await runHarness(argv, env, {
+    group: options.group,
+    ...closedStdin(argv) ? { stdin: "ignore" } : {},
+    ...options.started ? { started: options.started } : {},
+    ...stdin ? { stdin } : {}
+  });
+  if (run.started) await linkedHandback(plan, command, cwd, env, run, options.bytes);
+  return run.code;
+}
+async function linkedHandback(plan, command, cwd, env, run, bytes) {
+  const harness = normalizeHarness(basename(command[programAt(command)] ?? ""), "cli");
+  const dir = relayDir();
+  try {
+    const client = await connectBroker(dir, () => startDaemon(dir));
+    try {
+      const hello = await client.hello({ claim: { handle: plan.name, exact: true, harness, cwd, under: plan.parent, labels: labelsFor(env) } });
+      const me = hello.endpoint;
+      const address = `me/${plan.machine}/${me.address.slice(3)}`;
+      if (plan.title && !me.title) await client.request("title", { text: plan.title });
+      const code = Math.min(run.code, 255);
+      await client.request("send", { to: plan.parent, kind: "message", body: linkedHandbackBody(address, code, harnessOutput(run, bytes), stderrOutput(run)) });
+      await client.request("status", { state: "done", note: `exited ${code}` });
+    } finally {
+      client.close();
+    }
+  } catch (error) {
+    note(`${CLI_NAME} spawn: could not hand ${plan.name}'s result back to ${plan.parent}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+export {
+  RUNNER_NAME,
+  RUNNER_TIMEOUT_S,
+  linkedHandbackBody,
+  linkedPlan,
+  linkedSpawn,
+  parseRunners,
+  readRunners,
+  runRunner,
+  runnerFor,
+  runnerReply,
+  runnersPath,
+  spawnRequest,
+  viaSpawn,
+  viaStarted
+};

package/dist/resume-B5BOZO2G.js

@@ -0,0 +1,308 @@
+import {
+  agyNote,
+  messagingAllow
+} from "./chunk-ZEWZBRVM.js";
+import "./chunk-FPNFRDXG.js";
+import {
+  whichOnPath
+} from "./chunk-77NUOWQ4.js";
+import {
+  hooksTarget
+} from "./chunk-MHBWDAXO.js";
+import {
+  AGY_CONVERSATION,
+  AGY_HOOK_SET
+} from "./chunk-UUFTEXDU.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  RelayUsage,
+  relayIdentity,
+  startDaemon
+} from "./chunk-6S3V5ZGU.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-O45SE5L7.js → setup-NK2HRFZN.js}

@@ -15,11 +15,11 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-DEK3TE6T.js";
-import "./chunk-C5PYVRJE.js";
-import "./chunk-GG33NSBW.js";
+} from "./chunk-77NUOWQ4.js";
+import "./chunk-MHBWDAXO.js";
+import "./chunk-UUFTEXDU.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-BSX24XMZ.js";
+import "./chunk-6S3V5ZGU.js";
 import "./chunk-MNTIEWKF.js";
 export {
   SETUP_HARNESSES,

package/dist/{spawn-CJSHYE7E.js → spawn-3IYGUBG6.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-CVW3INZO.js";
+} from "./chunk-ZEWZBRVM.js";
 import {
   SPAWN_HELP
-} from "./chunk-KN7WEIE4.js";
-import "./chunk-DEK3TE6T.js";
-import "./chunk-C5PYVRJE.js";
-import "./chunk-GG33NSBW.js";
+} from "./chunk-FPNFRDXG.js";
+import "./chunk-77NUOWQ4.js";
+import "./chunk-MHBWDAXO.js";
+import "./chunk-UUFTEXDU.js";
 import "./chunk-YYSLYVNZ.js";
-import "./chunk-BSX24XMZ.js";
+import "./chunk-6S3V5ZGU.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,