@scp-dev/cli 0.6.0 → 0.7.0

package/dist/muse-S7FPY4CL.js

@@ -0,0 +1,429 @@
+import {
+  connectCodexChannel
+} from "./chunk-LWMTZH36.js";
+import {
+  MUSE_MODE,
+  MUSE_MODES_ALLOWED,
+  museModes
+} from "./chunk-RZUQ422C.js";
+import "./chunk-KN7WEIE4.js";
+import {
+  mcpFile,
+  mountedEntry
+} from "./chunk-SNW53KT3.js";
+import "./chunk-LRQP25RI.js";
+import "./chunk-277BAY7J.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  RelayUsage,
+  processKey,
+  relayIdentity,
+  startDaemon,
+  writeMuseLaunch
+} from "./chunk-3SOIVANO.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/muse.ts
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+import { homedir } from "os";
+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 MUSE_HELP = `${CLI_NAME} muse [--name N | --as N] [--resume SESSION] [--approval-mode never|on-request|untrusted] [--] [muse serve args...]
+  runs a headless Muse session (muse serve) that relay messages wake: a message starts a turn on the idle session or steers a running one.
+  every other argument goes to muse serve (--provider, --model, -c, sandbox flags); it runs with --contributor-mode off unless you pass on.
+  prints the agent's messages; approvals the mode leaves to a human are declined. --resume SESSION reopens a stored session.
+  needs the scp mount and plugin ${CLI_NAME} setup --write installs. $SCP_MUSE_BIN picks the muse binary (default muse on PATH).`;
+var APPROVAL = { never: "allowAll", "on-request": "onRequest", untrusted: "promptUnmatched" };
+var NO_USER_INPUT = "--disable-request-user-input";
+function museLaunch(args, env) {
+  let name;
+  let resume;
+  let approval = "on-request";
+  const serveArgs = [];
+  const value = (flag, next) => {
+    if (next === void 0) throw new RelayUsage(`${CLI_NAME} muse ${flag} takes a value`);
+    return next;
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      serveArgs.push(...args.slice(i + 1));
+      break;
+    }
+    const eq = arg.startsWith("--") ? arg.indexOf("=") : -1;
+    const flag = eq > 0 ? arg.slice(0, eq) : arg;
+    const take = () => eq > 0 ? arg.slice(eq + 1) : value(flag, args[++i]);
+    if (flag === "--name" || flag === "--as") name = take();
+    else if (flag === "--resume") resume = take();
+    else if (flag === "--approval-mode") approval = take();
+    else serveArgs.push(arg);
+  }
+  name = name?.replace(/^me\//, "");
+  if (name !== void 0 && !validHandle(name)) throw new RelayUsage(`${JSON.stringify(name)} is not a valid agent handle`);
+  const approvalMode = APPROVAL[approval];
+  if (!approvalMode) throw new RelayUsage(`${CLI_NAME} muse --approval-mode takes never, on-request or untrusted, not ${JSON.stringify(approval)}`);
+  const modes = museModes(serveArgs);
+  for (const mode of modes) {
+    if (mode === void 0 || !MUSE_MODES_ALLOWED.has(mode))
+      throw new RelayUsage(`${CLI_NAME} muse: muse runs with ${MUSE_MODE} off or on, not ${mode === void 0 ? "a bare flag" : JSON.stringify(mode)}`);
+  }
+  const { SCP_SESSION: _session, SCP_PARENT: _parent, ...clean } = env;
+  return {
+    ...name !== void 0 ? { name } : {},
+    ...resume !== void 0 ? { resume } : {},
+    approvalMode,
+    serveArgs: [...modes.length ? [] : [MUSE_MODE, "off"], ...serveArgs.includes(NO_USER_INPUT) ? [] : [NO_USER_INPUT], ...serveArgs],
+    env: { ...clean, SCP_HARNESS: "muse", ...name !== void 0 ? { SCP_NAME: name } : {} }
+  };
+}
+function museBroker(env) {
+  return relayDir({ HOME: env.HOME || homedir() });
+}
+function uuidv7(now = Date.now()) {
+  const bytes = randomBytes(16);
+  for (let i = 0; i < 6; i++) bytes[i] = Math.floor(now / 2 ** (8 * (5 - i))) & 255;
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+var MuseHost = class {
+  constructor(input, output, onMessage = () => {
+  }, timeoutMs = 3e4) {
+    this.input = input;
+    this.onMessage = onMessage;
+    this.timeoutMs = timeoutMs;
+    output.setEncoding("utf8");
+    output.on("data", (chunk) => {
+      this.buffer += chunk;
+      for (; ; ) {
+        const end = this.buffer.indexOf("\n");
+        if (end < 0) break;
+        const line = this.buffer.slice(0, end).trim();
+        this.buffer = this.buffer.slice(end + 1);
+        if (line) this.receive(line);
+      }
+    });
+    output.on("close", () => this.close(new Error("muse serve closed")));
+    input.on("error", (error) => this.close(error));
+  }
+  input;
+  onMessage;
+  timeoutMs;
+  next = 1;
+  buffer = "";
+  closed;
+  pending = /* @__PURE__ */ new Map();
+  receive(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const pending = typeof message.id === "number" && message.method === void 0 ? this.pending.get(message.id) : void 0;
+    if (!pending) {
+      this.onMessage(message);
+      return;
+    }
+    this.pending.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.error) pending.reject(new Error(JSON.stringify(message.error)));
+    else pending.resolve(message.result ?? {});
+  }
+  send(message) {
+    if (this.closed) throw this.closed;
+    this.input.write(`${JSON.stringify({ jsonrpc: "2.0", ...message })}
+`);
+  }
+  request(method, params) {
+    if (this.closed) return Promise.reject(this.closed);
+    const id = this.next++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`muse ${method} timed out`));
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.send({ id, method, params });
+      } catch (error) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(error);
+      }
+    });
+  }
+  close(error = new Error("muse serve closed")) {
+    this.closed ??= error;
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(this.closed);
+    }
+    this.pending.clear();
+  }
+};
+var MuseWaker = class {
+  constructor(transport, sessionId, retryMs = 2e3) {
+    this.transport = transport;
+    this.sessionId = sessionId;
+    this.retryMs = retryMs;
+  }
+  transport;
+  sessionId;
+  retryMs;
+  queue = [];
+  serial;
+  timer;
+  stopped = false;
+  push(text) {
+    this.queue.push(text);
+    void this.flush();
+  }
+  flush() {
+    if (this.serial) return this.serial;
+    if (this.stopped || !this.queue.length) return Promise.resolve();
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    const count = this.queue.length;
+    this.serial = this.transport.request("turn/start", {
+      commandId: uuidv7(),
+      sessionId: this.sessionId,
+      input: [{ type: "text", text: this.queue.slice(0, count).join("\n\n") }],
+      ifBusy: "steer"
+    }).then(
+      (result) => {
+        if (result.status !== "accepted") return false;
+        this.queue.splice(0, count);
+        return true;
+      },
+      () => false
+    ).then((ok) => {
+      this.serial = void 0;
+      if (this.stopped || !this.queue.length) return;
+      if (ok) return this.flush();
+      this.timer ??= setTimeout(() => {
+        this.timer = void 0;
+        void this.flush();
+      }, this.retryMs);
+    });
+    return this.serial;
+  }
+  close() {
+    this.stopped = true;
+    clearTimeout(this.timer);
+  }
+};
+function answerRequest(host, message, log) {
+  const params = message.params ?? {};
+  if (message.method !== "approval/request") {
+    host.send({ id: message.id, error: { code: -32601, message: `${String(message.method)} is unsupported in a headless session` } });
+    return;
+  }
+  host.send({ id: message.id, result: {} });
+  const choices = Array.isArray(params.availableChoices) ? params.availableChoices : [];
+  const choice = choices.find((c) => c.decision === "denied") ?? choices.find((c) => c.decision === "abort");
+  const subject = params.subject ?? {};
+  log(`${CLI_NAME} muse: declined ${String(subject.command ?? subject.kind ?? "an approval")}`);
+  if (!choice) return;
+  void host.request("approval/decide", {
+    approvalId: params.approvalId,
+    choiceId: choice.choiceId,
+    commandId: uuidv7(),
+    requirementId: params.currentRequirementId,
+    sessionId: params.sessionId
+  }).catch((error) => log(`${CLI_NAME} muse: could not decline: ${String(error)}`));
+}
+async function terminate(child) {
+  if (child.exitCode !== null || child.signalCode !== null || !child.pid) return;
+  await new Promise((resolve) => {
+    const timer = setTimeout(() => child.kill("SIGKILL"), 3e3);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    child.kill("SIGTERM");
+  });
+}
+var BIND_TIMEOUT_MS = 3e4;
+async function museCommand(args) {
+  if (args[0] === "--help" || args[0] === "-h") {
+    process.stdout.write(`${MUSE_HELP}
+`);
+    return 0;
+  }
+  const launch = museLaunch(args, process.env);
+  const cwd = process.cwd();
+  const log = (line) => void process.stderr.write(`${line}
+`);
+  try {
+    if (!mountedEntry("muse", mcpFile("muse", launch.env)))
+      throw new RelayUsage(`${CLI_NAME} muse: Muse has no scp MCP mount, so messages cannot wake this session; run ${CLI_NAME} setup --write`);
+  } catch (error) {
+    if (error instanceof RelayUsage) throw error;
+    throw new RelayUsage(
+      `${CLI_NAME} muse: ${mcpFile("muse", launch.env)} is unreadable, so the scp mount is unchecked; fix it or run ${CLI_NAME} setup --write`
+    );
+  }
+  const broker = museBroker(launch.env);
+  if (relayDir(launch.env) !== broker) log(`${CLI_NAME} muse: Muse starts its shim and hooks without SCP_DIR or XDG_STATE_HOME, so this session uses ${broker}`);
+  const env = { ...launch.env, SCP_DIR: broker };
+  const bin = env.SCP_MUSE_BIN || "muse";
+  const server = spawn(bin, ["serve", ...launch.serveArgs], { env: launch.env, stdio: ["pipe", "pipe", "pipe"] });
+  let stderr = Buffer.alloc(0);
+  server.stderr.on("data", (data) => {
+    stderr = Buffer.concat([stderr, data]).subarray(-8192);
+  });
+  let serverError;
+  let died = false;
+  let finish;
+  const done = new Promise((resolve) => {
+    finish = resolve;
+  });
+  server.on("error", (error) => {
+    serverError = error;
+    died = true;
+    finish(1);
+  });
+  server.on("exit", () => {
+    died = true;
+    finish(1);
+  });
+  const failure = () => new RelayUsage(`${CLI_NAME} muse: muse serve failed${serverError ? `: ${serverError.message}` : ""}${stderr.length ? `
+${stderr.toString().trim()}` : ""}`);
+  let waker;
+  let channel;
+  let unlaunch = () => {
+  };
+  const input = new PassThrough();
+  let stopping = false;
+  const stop = () => {
+    stopping = true;
+    finish(0);
+  };
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+  process.on("SIGHUP", stop);
+  const host = new MuseHost(server.stdin, server.stdout, (message) => {
+    if (message.id !== void 0 && typeof message.method === "string") {
+      answerRequest(host, message, log);
+      return;
+    }
+    if (message.method !== "item/completed") return;
+    const item = message.params?.item ?? {};
+    if (item.kind === "agentMessage" && typeof item.text === "string" && item.text) process.stdout.write(`${item.text}
+`);
+  });
+  try {
+    if (!server.pid) await new Promise((resolve) => setImmediate(resolve));
+    if (died || !server.pid) throw failure();
+    const key = processKey(server.pid);
+    unlaunch = writeMuseLaunch(key, { ...env.SCP_NAME ? { name: env.SCP_NAME } : {}, ...env.SCP_GRANT ? { grant: env.SCP_GRANT } : {} }, env);
+    const started = await Promise.race([
+      (async () => {
+        await host.request("initialize", { clientInfo: { name: "scp_waker", version: "0.1.0" } });
+        host.send({ method: "initialized" });
+        const result = launch.resume ? await host.request("session/resume", { commandId: uuidv7(), sessionId: launch.resume, excludeItems: true }) : await host.request("session/start", { commandId: uuidv7(), approvalMode: launch.approvalMode, workspaceRoot: cwd });
+        return result.session.sessionId;
+      })(),
+      done.then(() => void 0)
+    ]);
+    if (stopping) return 0;
+    if (!started || died) throw failure();
+    const claim = relayIdentity({ harness: "muse", fallbackHarness: "muse", cwd, env, harnessPid: () => server.pid });
+    const deadline = Date.now() + BIND_TIMEOUT_MS;
+    const bind = (until) => connectCodexChannel(
+      () => connectBroker(broker, () => startDaemon(broker)),
+      claim,
+      cwd,
+      () => input.writableEnded || until()
+    );
+    let bindError;
+    let first = await Promise.race([
+      bind(() => stopping || died || Date.now() > deadline).catch((error) => {
+        bindError = error;
+        return void 0;
+      }),
+      done.then(() => void 0)
+    ]);
+    if (stopping) return 0;
+    if (died) throw failure();
+    if (!first) {
+      const why = Date.now() > deadline ? "the session's scp shim never joined" : `its channel could not bind (${bindError instanceof Error ? bindError.message : String(bindError)})`;
+      throw new RelayUsage(`${CLI_NAME} muse: ${why}, so messages cannot wake it; check the mount ${CLI_NAME} setup --write installs`);
+    }
+    waker = new MuseWaker(host, started);
+    let lines = "";
+    channel = runRelayMcp({
+      connect: async () => {
+        const client = first ?? await bind(() => false);
+        first = void 0;
+        return client;
+      },
+      claim,
+      channels: true,
+      wake: "muse-serve",
+      input,
+      env,
+      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.method === "notifications/claude/channel") {
+            const content = message.params.content;
+            if (typeof content === "string") waker.push(content);
+          }
+        }
+      },
+      log
+    });
+    void channel.catch((error) => {
+      log(error instanceof Error ? error.message : String(error));
+      finish(1);
+    });
+    input.write(
+      `${JSON.stringify({ id: 1, method: "initialize", params: { protocolVersion: MCP_PROTOCOLS[0], capabilities: { experimental: { "claude/channel": {} } }, clientInfo: { name: "scp-waker", version: "0.1.0" } } })}
+`
+    );
+    input.write(`${JSON.stringify({ method: "notifications/initialized" })}
+`);
+    log(`${CLI_NAME} muse: ${claim.handle} waiting for messages (session ${started})`);
+    const code = await done;
+    if (died && !stopping) {
+      log(failure().message);
+      return 1;
+    }
+    return code;
+  } catch (error) {
+    if (died) throw failure();
+    throw error;
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+    process.off("SIGHUP", stop);
+    waker?.close();
+    input.end();
+    await channel?.catch(() => {
+    });
+    host.close();
+    server.stdin?.end();
+    await terminate(server);
+    unlaunch();
+  }
+}
+export {
+  MUSE_HELP,
+  MuseHost,
+  MuseWaker,
+  answerRequest,
+  museBroker,
+  museCommand,
+  museLaunch,
+  uuidv7
+};

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

@@ -2,18 +2,18 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-DEK3TE6T.js";
+} from "./chunk-SNW53KT3.js";
 import {
   hooksTarget
-} from "./chunk-C5PYVRJE.js";
+} from "./chunk-LRQP25RI.js";
 import {
   opencodePlugin
-} from "./chunk-GG33NSBW.js";
+} from "./chunk-277BAY7J.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,
   gitToplevel
-} from "./chunk-BSX24XMZ.js";
+} from "./chunk-3SOIVANO.js";
 import "./chunk-MNTIEWKF.js";
 
 // src/opencode.ts

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

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

package/dist/{pi-XHZAUDP4.js → pi-5IPU6GA4.js}

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

package/dist/{relay-E4JFR33E.js → relay-7WBNUACH.js}

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

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

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