@scp-dev/cli 0.2.0 → 0.2.1

package/dist/{claude-YJLGFQ2P.js → claude-WTCPUYU3.js}

@@ -3,16 +3,17 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-WV5FINTW.js";
-import "./chunk-5DYFYLAQ.js";
+} from "./chunk-NJLFHBSS.js";
+import "./chunk-KC5AV5NQ.js";
+import "./chunk-HF4KP6AR.js";
+import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
-  RelayUsage
-} from "./chunk-3V3DRXB2.js";
-import "./chunk-RXKBND3T.js";
-import "./chunk-YYSLYVNZ.js";
-import "./chunk-E53YHYEP.js";
-import "./chunk-M2DCR2J4.js";
+  RelayUsage,
+  deriveHandle,
+  joinMode
+} from "./chunk-ZLL5EGI2.js";
+import "./chunk-MNTIEWKF.js";
 
 // src/claude.ts
 import { spawn } from "child_process";
@@ -33,6 +34,14 @@ function claudeArgv(argv) {
   if (name !== void 0 && !validHandle(name)) throw new RelayUsage(`--name ${JSON.stringify(name)} is not a valid agent handle`);
   return { ...name !== void 0 ? { name } : {}, args: argv.slice(i) };
 }
+function namePrompt(name, args, env, cwd) {
+  if (name !== void 0 || joinMode(env) === "manual" || args.some((arg) => /^--(append-)?system-prompt/.test(arg))) return [];
+  const handle = env.SCP_NAME || deriveHandle("claude-code", cwd);
+  return [
+    "--append-system-prompt",
+    `You are on the SCP network as ${handle}. Pick a short descriptive name for yourself with \`${CLI_NAME} name <name>\` when you know what you're working on.`
+  ];
+}
 function mountHint(env) {
   const file = mcpFile("claude", env);
   let entry;
@@ -47,7 +56,7 @@ function mountHint(env) {
   return void 0;
 }
 async function claudeCommand(argv, env = process.env, err = (line) => void process.stderr.write(`${line}
-`)) {
+`), cwd = process.cwd()) {
   if (argv[0] === "--help" || argv[0] === "-h") {
     process.stdout.write(`${CLI_NAME} claude [--name N] [--] [claude args...]   start Claude Code with the scp channel loaded, so peer messages wake it
 `);
@@ -58,7 +67,7 @@ async function claudeCommand(argv, env = process.env, err = (line) => void proce
   if (!bin) throw new RelayUsage("claude is not on PATH");
   const hint = mountHint(env);
   if (hint) err(hint);
-  const child = spawn(bin, [...CHANNEL_FLAGS, ...args], {
+  const child = spawn(bin, [...CHANNEL_FLAGS, ...namePrompt(name, args, env, cwd), ...args], {
     stdio: "inherit",
     env: { ...env, ...name !== void 0 ? { SCP_NAME: name } : {}, [CHANNELS_ENV]: String(process.pid) }
   });
@@ -84,5 +93,6 @@ export {
   CHANNEL_FLAGS,
   claudeArgv,
   claudeCommand,
-  mountHint
+  mountHint,
+  namePrompt
 };

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-HPBTO3JK.js");
+  const { run } = await import("./main-I4F53MMA.js");
   await run(process.argv.slice(2));
 }

package/dist/codex-YZZNH6IQ.js

@@ -0,0 +1,565 @@
+import {
+  codexMount,
+  codexOverrides
+} from "./chunk-25ZVL5LD.js";
+import "./chunk-KN7WEIE4.js";
+import "./chunk-NJLFHBSS.js";
+import "./chunk-KC5AV5NQ.js";
+import "./chunk-HF4KP6AR.js";
+import "./chunk-YYSLYVNZ.js";
+import {
+  RelayUsage,
+  readPsTable,
+  relayIdentity,
+  startDaemon
+} from "./chunk-ZLL5EGI2.js";
+import {
+  SELF
+} from "./chunk-MNTIEWKF.js";
+
+// src/codex.ts
+import { spawn } from "child_process";
+import { createHash, randomBytes } from "crypto";
+import { mkdtempSync, rmSync } from "fs";
+import { connect } from "net";
+import { tmpdir } from "os";
+import { join } from "path";
+import { PassThrough } from "stream";
+import { setTimeout as sleep } from "timers/promises";
+import { connectBroker, relayDir } from "@scp-dev/broker";
+import { CLI_NAME, validHandle } from "@scp-dev/core";
+import { MCP_PROTOCOLS, runRelayMcp } from "@scp-dev/mcp";
+var CODEX_HELP = `${CLI_NAME} codex [--name N | --as N] [--headless] [--resume THREAD] [--] [codex args...]
+  runs codex with relay messages waking an idle thread or steering a running turn; approvals stay with the TUI.
+  --headless runs an ambient worker without a TUI; --resume THREAD reopens its thread.
+  $SCP_CODEX_BIN picks the codex binary (default codex on PATH).`;
+function codexLaunch(args, env, _self) {
+  let name;
+  let headless = false;
+  const codexArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      codexArgs.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--name" || arg === "--as") {
+      name = args[++i];
+      if (name === void 0) throw new RelayUsage(`${CLI_NAME} codex ${arg} takes a name`);
+    } else if (arg.startsWith("--name=") || arg.startsWith("--as=")) name = arg.slice(arg.indexOf("=") + 1);
+    else if (arg === "--headless") headless = true;
+    else codexArgs.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 { SCP_SESSION: _session, SCP_GRANT: _grant, SCP_PARENT: _parent, ...clean } = env;
+  return {
+    ...name !== void 0 ? { name } : {},
+    headless,
+    codexArgs,
+    env: { ...clean, SCP_HARNESS: "codex", ...name !== void 0 ? { SCP_NAME: name } : {} }
+  };
+}
+var CodexSocket = class {
+  constructor(path, onMessage = () => {
+  }) {
+    this.onMessage = onMessage;
+    this.socket = connect(path);
+    this.socket.on("connect", () => {
+      this.socket.write(
+        `GET / HTTP/1.1\r
+Host: localhost\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: ${this.key}\r
+Sec-WebSocket-Version: 13\r
+\r
+`
+      );
+    });
+    this.socket.on("data", (data) => {
+      try {
+        this.feed(typeof data === "string" ? Buffer.from(data) : data);
+      } catch (error) {
+        this.fail(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    this.socket.on("error", (error) => this.fail(error));
+    this.socket.on("close", () => this.fail(new Error("codex socket closed")));
+  }
+  onMessage;
+  socket;
+  buffer = Buffer.alloc(0);
+  opened = false;
+  resolveReady;
+  rejectReady;
+  ready = new Promise((resolve, reject) => {
+    this.resolveReady = resolve;
+    this.rejectReady = reject;
+  });
+  next = 1;
+  pending = /* @__PURE__ */ new Map();
+  key = randomBytes(16).toString("base64");
+  fragments = [];
+  fail(error) {
+    this.rejectReady(error);
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+    this.socket.destroy();
+  }
+  feed(data) {
+    this.buffer = Buffer.concat([this.buffer, data]);
+    if (!this.opened) {
+      const end = this.buffer.indexOf("\r\n\r\n");
+      if (end < 0) return;
+      const header = this.buffer.subarray(0, end).toString();
+      const accept = createHash("sha1").update(`${this.key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+      if (!/^HTTP\/1\.1 101\b/.test(header) || !header.toLowerCase().includes(`sec-websocket-accept: ${accept}`.toLowerCase()))
+        throw new Error("codex WebSocket upgrade failed");
+      this.buffer = this.buffer.subarray(end + 4);
+      this.opened = true;
+      this.resolveReady();
+    }
+    while (this.buffer.length >= 2) {
+      const opcode = this.buffer[0] & 15;
+      const final = (this.buffer[0] & 128) !== 0;
+      const masked = (this.buffer[1] & 128) !== 0;
+      let length = this.buffer[1] & 127;
+      let offset = 2;
+      if (length === 126) {
+        if (this.buffer.length < 4) return;
+        length = this.buffer.readUInt16BE(2);
+        offset = 4;
+      } else if (length === 127) {
+        if (this.buffer.length < 10) return;
+        const size = this.buffer.readBigUInt64BE(2);
+        if (size > 64n * 1024n * 1024n) throw new Error("codex WebSocket frame too large");
+        length = Number(size);
+        offset = 10;
+      }
+      const start = offset + (masked ? 4 : 0);
+      if (this.buffer.length < start + length) return;
+      const payload = Buffer.from(this.buffer.subarray(start, start + length));
+      if (masked) for (let i = 0; i < length; i++) payload[i] = payload[i] ^ this.buffer[offset + i % 4];
+      this.buffer = this.buffer.subarray(start + length);
+      if (opcode === 8) {
+        this.fail(new Error("codex WebSocket closed"));
+        return;
+      }
+      if (opcode === 9) this.frame(10, payload);
+      if (opcode !== 1 && opcode !== 0) continue;
+      this.fragments.push(payload);
+      if (!final) continue;
+      const message = JSON.parse(Buffer.concat(this.fragments).toString());
+      this.fragments = [];
+      const pending = typeof message.id === "number" && !message.method ? this.pending.get(message.id) : void 0;
+      if (pending) {
+        this.pending.delete(message.id);
+        clearTimeout(pending.timer);
+        if (message.error) pending.reject(new Error(JSON.stringify(message.error)));
+        else pending.resolve(message.result ?? {});
+      } else this.onMessage(message);
+    }
+  }
+  frame(opcode, payload) {
+    const length = payload.length;
+    const header = Buffer.alloc(length < 126 ? 2 : length < 65536 ? 4 : 10);
+    header[0] = 128 | opcode;
+    header[1] = 128 | (length < 126 ? length : length < 65536 ? 126 : 127);
+    if (header.length === 4) header.writeUInt16BE(length, 2);
+    if (header.length === 10) header.writeBigUInt64BE(BigInt(length), 2);
+    const mask = randomBytes(4);
+    const body = Buffer.from(payload);
+    for (let i = 0; i < length; i++) body[i] = body[i] ^ mask[i % 4];
+    this.socket.write(Buffer.concat([header, mask, body]));
+  }
+  send(message) {
+    if (this.socket.destroyed) throw new Error("codex socket closed");
+    this.frame(1, Buffer.from(JSON.stringify(message)));
+  }
+  async request(method, params) {
+    await this.ready;
+    const id = this.next++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`codex ${method} timed out`));
+      }, 15e3);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.send({ jsonrpc: "2.0", id, method, params });
+      } catch (error) {
+        this.pending.delete(id);
+        clearTimeout(timer);
+        reject(error);
+      }
+    });
+  }
+  close() {
+    this.fail(new Error("codex socket closed"));
+  }
+};
+var CodexWaker = class {
+  constructor(transport, threadId) {
+    this.transport = transport;
+    this.threadId = threadId;
+  }
+  transport;
+  threadId;
+  status = /* @__PURE__ */ new Map();
+  changed = /* @__PURE__ */ new Map();
+  parents = /* @__PURE__ */ new Map();
+  waiting = /* @__PURE__ */ new Set();
+  queue = [];
+  serial;
+  again = false;
+  timer;
+  stopped = false;
+  clock = 0;
+  push(text) {
+    this.queue.push(text);
+    void this.flush();
+  }
+  notification(message) {
+    if (message.method !== "thread/status/changed") return;
+    const params = message.params;
+    this.status.set(params.threadId, params.status.type);
+    this.changed.set(params.threadId, ++this.clock);
+    if (params.status.type === "idle") this.waiting.delete(params.threadId);
+    void this.flush();
+  }
+  async target() {
+    if (this.threadId) return this.threadId;
+    const result = await this.transport.request("thread/loaded/list", {});
+    const threads = [];
+    for (const id of result.data) {
+      if (!this.parents.has(id)) {
+        const read = await this.transport.request("thread/read", { threadId: id });
+        this.parents.set(id, Boolean(read.thread.parentThreadId));
+      }
+      if (!this.parents.get(id)) threads.push(id);
+    }
+    return threads.reduce((best, id) => !best || (this.changed.get(id) ?? 0) >= (this.changed.get(best) ?? 0) ? id : best, void 0);
+  }
+  flush() {
+    if (this.serial) {
+      this.again = true;
+      return this.serial;
+    }
+    if (this.stopped || !this.queue.length) return Promise.resolve();
+    this.serial = (async () => {
+      do {
+        this.again = false;
+        if (this.stopped || !this.queue.length) break;
+        try {
+          const threadId = await this.target();
+          if (!threadId || this.stopped) break;
+          const status = this.status.get(threadId);
+          if (this.waiting.has(threadId) || status && status !== "idle" && status !== "active") break;
+          const count = this.queue.length;
+          const input = [{ type: "text", text: this.queue.slice(0, count).join("\n\n") }];
+          if (status === "active") {
+            try {
+              const turns = await this.transport.request("thread/turns/list", { threadId });
+              const turn = turns.data.find((turn2) => turn2.status === "inProgress");
+              if (!turn) throw new Error("no running turn");
+              await this.transport.request("turn/steer", { threadId, expectedTurnId: turn.id, input });
+            } catch {
+              if (this.status.get(threadId) === "idle") {
+                this.again = true;
+                continue;
+              }
+              this.waiting.add(threadId);
+              break;
+            }
+          } else {
+            await this.transport.request("turn/start", { threadId, input });
+          }
+          this.queue.splice(0, count);
+        } catch {
+          break;
+        }
+      } while (this.again && this.queue.length);
+    })().finally(() => {
+      this.serial = void 0;
+      if (!this.queue.length) {
+        clearTimeout(this.timer);
+        this.timer = void 0;
+      }
+      if (!this.stopped && this.queue.length && !this.timer) {
+        this.timer = setTimeout(() => {
+          this.timer = void 0;
+          void this.flush();
+        }, 2e3);
+      }
+    });
+    return this.serial;
+  }
+  close() {
+    this.stopped = true;
+    clearTimeout(this.timer);
+  }
+};
+function option(args, ...names) {
+  let value;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (names.includes(arg)) {
+      value = args[++i];
+      if (value === void 0) throw new RelayUsage(`${CLI_NAME} codex ${arg} takes a value`);
+    } else if (names.some((name) => arg.startsWith(`${name}=`))) value = arg.slice(arg.indexOf("=") + 1);
+  }
+  return value;
+}
+function serverOptions(args) {
+  const result = [];
+  const names = ["-c", "--config", "--enable", "--disable"];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (names.includes(arg)) {
+      const value = args[++i];
+      if (value === void 0) throw new RelayUsage(`${CLI_NAME} codex ${arg} takes a value`);
+      result.push(arg, value);
+    } else if (names.some((name) => arg.startsWith(`${name}=`))) result.push(arg);
+  }
+  return result;
+}
+async function terminate(child) {
+  if (child.exitCode !== null || child.signalCode !== null || !child.pid) return;
+  await new Promise((resolve) => {
+    const timer = setTimeout(() => child.kill("SIGKILL"), 2e3);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    child.kill("SIGTERM");
+  });
+}
+function appServerPid(pid) {
+  const table = readPsTable();
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(pid)) {
+    seen.add(pid);
+    const child = [...table ?? []].find(([_, entry]) => entry.ppid === pid && /\sapp-server(?:\s|$)/.test(entry.args));
+    if (!child) break;
+    pid = child[0];
+  }
+  return pid;
+}
+async function codexCommand(args) {
+  const own = args.includes("--") ? args.slice(0, args.indexOf("--")) : args;
+  if (own.includes("--help") || own.includes("-h")) {
+    process.stdout.write(`${CODEX_HELP}
+`);
+    return 0;
+  }
+  const launch = codexLaunch(args, process.env, SELF);
+  const cwd = process.cwd();
+  const bin = launch.env.SCP_CODEX_BIN || "codex";
+  const overrides = [...codexOverrides(launch.env, codexMount(launch.env), SELF), ...serverOptions(launch.codexArgs)];
+  const dir = mkdtempSync(join(tmpdir(), "scp-codex-"));
+  const path = join(dir, "app.sock");
+  const server = spawn(bin, ["app-server", "--listen", `unix://${path}`, ...overrides], { env: launch.env, stdio: ["ignore", "ignore", "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} codex: app-server failed${serverError ? `: ${serverError.message}` : ""}${stderr.length ? `
+${stderr.toString().trim()}` : ""}`
+  );
+  let socket;
+  let waker;
+  let tui;
+  let channel;
+  const input = new PassThrough();
+  const ignore = () => {
+  };
+  let stopping = false;
+  const stop = () => {
+    stopping = true;
+    finish(0);
+  };
+  const forward = (signal) => {
+    if (tui) tui.kill(signal);
+    else stop();
+  };
+  process.on("SIGINT", launch.headless ? stop : ignore);
+  process.on("SIGTERM", launch.headless ? stop : forward);
+  process.on("SIGHUP", launch.headless ? stop : forward);
+  try {
+    const end = Date.now() + 2e4;
+    while (!socket && Date.now() < end && !died && !stopping) {
+      const candidate = new CodexSocket(path, (message) => {
+        waker?.notification(message);
+        if (!launch.headless) return;
+        if (message.id !== void 0 && typeof message.method === "string") {
+          if (message.method.endsWith("/requestApproval")) {
+            process.stderr.write(`${CLI_NAME} codex: declined ${message.method}
+`);
+            candidate.send({ id: message.id, result: { decision: "decline" } });
+          } else candidate.send({ id: message.id, error: { code: -32601, message: "unsupported server request" } });
+        }
+        if (message.method === "item/completed") {
+          const item = message.params.item;
+          if (item.type === "agentMessage" && typeof item.text === "string") process.stdout.write(`${item.text}
+`);
+        }
+      });
+      let timeout;
+      try {
+        await Promise.race([
+          (async () => {
+            await candidate.ready;
+            await candidate.request("initialize", { clientInfo: { name: "scp-waker", version: "0.1.0" } });
+            candidate.send({ method: "initialized" });
+          })(),
+          new Promise((_, reject) => {
+            timeout = setTimeout(() => reject(new Error("initialize timed out")), Math.min(1e3, end - Date.now()));
+          })
+        ]);
+        socket = candidate;
+      } catch {
+        candidate.close();
+        if (!died) await sleep(100);
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    if (stopping) return 0;
+    if (!socket || died) throw failure();
+    let threadId;
+    if (launch.headless) {
+      const resume = option(own, "--resume");
+      const model = option(launch.codexArgs, "-m", "--model");
+      const sandbox = option(launch.codexArgs, "-s", "--sandbox");
+      const result = await socket.request(resume ? "thread/resume" : "thread/start", {
+        ...resume ? { threadId: resume } : { cwd },
+        approvalPolicy: "never",
+        ...model !== void 0 ? { model } : {},
+        ...sandbox !== void 0 ? { sandbox } : {}
+      });
+      threadId = result.thread.id;
+    }
+    if (stopping) return 0;
+    waker = new CodexWaker(socket, threadId);
+    const pid = appServerPid(server.pid);
+    const claim = relayIdentity({ harness: "codex", fallbackHarness: "codex", cwd, env: launch.env, harnessPid: () => pid });
+    const broker = relayDir(launch.env);
+    let lines = "";
+    channel = runRelayMcp({
+      connect: async () => {
+        while (!input.writableEnded) {
+          const client = await connectBroker(broker, () => startDaemon(broker));
+          try {
+            const hello = await client.hello({ observe: true, self: [claim.process], cwd });
+            if (hello.endpoint) {
+              client.hello = async () => hello;
+              return client;
+            }
+          } catch (error) {
+            client.close();
+            throw error;
+          }
+          client.close();
+          await sleep(100);
+        }
+        throw new Error("codex channel stopped");
+      },
+      claim,
+      channels: true,
+      input,
+      env: launch.env,
+      output: (chunk) => {
+        lines += chunk;
+        for (; ; ) {
+          const end2 = lines.indexOf("\n");
+          if (end2 < 0) break;
+          const message = JSON.parse(lines.slice(0, end2));
+          lines = lines.slice(end2 + 1);
+          if (message.method === "notifications/claude/channel") {
+            const content = message.params.content;
+            if (typeof content === "string") waker.push(content);
+          }
+        }
+      },
+      log: (line) => {
+        process.stderr.write(`${line}
+`);
+      }
+    });
+    void channel.catch((error) => {
+      process.stderr.write(`${CLI_NAME} codex: ${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" })}
+`);
+    if (launch.headless) {
+      process.stderr.write(`${CLI_NAME} codex: ${launch.name ?? claim.handle} waiting for messages (thread ${threadId})
+`);
+    } else {
+      tui = spawn(bin, ["--remote", `unix://${path}`, ...launch.codexArgs], { env: launch.env, stdio: "inherit" });
+      tui.once("error", (error) => {
+        process.stderr.write(`${CLI_NAME} codex: ${error.message}
+`);
+        finish(1);
+      });
+      tui.once("exit", (code2, signal) => finish(code2 ?? (signal ? 1 : 0)));
+    }
+    const code = await done;
+    if (died) {
+      process.stderr.write(`${failure().message}
+`);
+      return 1;
+    }
+    return code;
+  } catch (error) {
+    if (died) throw failure();
+    throw error;
+  } finally {
+    process.off("SIGINT", stop);
+    process.off("SIGINT", ignore);
+    process.off("SIGTERM", stop);
+    process.off("SIGHUP", stop);
+    process.off("SIGTERM", forward);
+    process.off("SIGHUP", forward);
+    waker?.close();
+    input.end();
+    await channel?.catch(() => {
+    });
+    socket?.close();
+    if (tui) await terminate(tui);
+    await terminate(server);
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+export {
+  CODEX_HELP,
+  CodexSocket,
+  CodexWaker,
+  codexCommand,
+  codexLaunch
+};

package/dist/{daemon-SUTLTY5U.js → daemon-OMJY7T2F.js}

@@ -1,6 +1,6 @@
 import {
   capture
-} from "./chunk-M2DCR2J4.js";
+} from "./chunk-MNTIEWKF.js";
 
 // src/daemon.ts
 import { readFileSync } from "fs";