stoops 0.2.5 → 0.3.2

package/dist/cli/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
-  InMemoryStorage,
+  FileBackedStorage,
   Room,
   randomName,
   randomRoomName
-} from "../chunk-TN56PBF3.js";
+} from "../chunk-XEKY3KEU.js";
 import {
   EventProcessor,
   RemoteRoomDataSource,
@@ -25,6 +25,8 @@ import { createServer } from "http";
 import { spawn, execFileSync } from "child_process";
 import { randomUUID } from "crypto";
 import { createRequire } from "module";
+import { tmpdir } from "os";
+import { join as pathJoin } from "path";
 
 // src/cli/auth.ts
 import { randomBytes } from "crypto";
@@ -123,7 +125,24 @@ async function serve(options) {
   } : logServer;
   let publicUrl = serverUrl;
   let tunnelProcess = null;
-  const storage = new InMemoryStorage();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const savePath = options.save ?? options.load ?? pathJoin(tmpdir(), `stoops-${roomName}-${timestamp}.json`);
+  let storage;
+  if (options.load) {
+    try {
+      storage = await FileBackedStorage.load(options.load);
+      log(`loaded room state from ${options.load}`);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        storage = new FileBackedStorage(options.load);
+        log(`no existing file at ${options.load}, starting fresh`);
+      } else {
+        throw err;
+      }
+    }
+  } else {
+    storage = new FileBackedStorage(savePath);
+  }
   const room = new Room(roomName, storage);
   const tokens = new TokenManager();
   const participants = /* @__PURE__ */ new Map();
@@ -513,7 +532,7 @@ Port ${port} is already in use. Another stoops instance may be running.`);
   const adminToken = tokens.generateShareToken("admin", "admin");
   const memberToken = tokens.generateShareToken("admin", "member");
   if (options.headless) {
-    process.stdout.write(JSON.stringify({ serverUrl, publicUrl, roomName, adminToken, memberToken }) + "\n");
+    process.stdout.write(JSON.stringify({ serverUrl, publicUrl, roomName, adminToken, memberToken, savePath }) + "\n");
   } else if (!options.quiet) {
     let version = process.env.npm_package_version ?? "";
     if (!version) {
@@ -533,10 +552,12 @@ Port ${port} is already in use. Another stoops instance may be running.`);
   Room:    ${roomName}
   Server:  ${serverUrl}${publicUrl !== serverUrl ? `
   Tunnel:  ${publicUrl}` : ""}
+  Saving:  ${savePath}
 
   Join:      stoops join ${joinUrl}
   Admin:     stoops join ${adminUrl}
-  Claude:    stoops run claude  \u2192  then tell agent to join: ${joinUrl}
+  Claude:    stoops run claude --name MyClaude  \u2192  then tell agent to join: ${joinUrl}
+  Codex:     stoops run codex --name MyCodex   \u2192  then tell agent to join: ${joinUrl}
 `);
   }
   const shutdown = async () => {
@@ -1370,7 +1391,8 @@ ${lines.join("\n")}`);
   if (options.shareUrl) {
     console.log();
     console.log(`  Invite a friend:       npx stoops join "${options.shareUrl}"`);
-    console.log(`  Connect Claude Code:   npx stoops run claude  \u2192  then tell agent to join: ${options.shareUrl}`);
+    console.log(`  Connect Claude Code:   npx stoops run claude --name MyClaude  \u2192  then tell agent to join: ${options.shareUrl}`);
+    console.log(`  Connect Codex:         npx stoops run codex --name MyCodex   \u2192  then tell agent to join: ${options.shareUrl}`);
     console.log();
   }
   const tui = startTUI({
@@ -1572,7 +1594,7 @@ function toDisplayEvent(event, selfId, participantTypes) {
 // src/cli/claude/run.ts
 import { writeFileSync, mkdtempSync, rmSync, chmodSync } from "fs";
 import { join as join2 } from "path";
-import { tmpdir } from "os";
+import { tmpdir as tmpdir2 } from "os";
 
 // src/cli/tmux.ts
 import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
@@ -2176,7 +2198,7 @@ async function runClaude(options) {
     process.exit(1);
   }
   const setup = await setupAgentRuntime({ ...options, joinUrls: void 0 });
-  const tmpDir = mkdtempSync(join2(tmpdir(), "stoops_agent_"));
+  const tmpDir = mkdtempSync(join2(tmpdir2(), "stoops_agent_"));
   const bridgePath = join2(tmpDir, "mcp-bridge.cjs");
   writeFileSync(bridgePath, MCP_STDIO_BRIDGE);
   chmodSync(bridgePath, 493);
@@ -2369,6 +2391,275 @@ async function pollForReady(url, timeoutMs) {
   return false;
 }
 
+// src/cli/codex/run.ts
+import { execFileSync as execFileSync3 } from "child_process";
+import { writeFileSync as writeFileSync2, mkdtempSync as mkdtempSync2, mkdirSync, rmSync as rmSync2 } from "fs";
+import { join as join3 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+
+// src/cli/codex/tmux-bridge.ts
+var SPINNER_CHARS2 = "\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F";
+var APPROVAL_PATTERNS = [
+  "Would you like to",
+  "needs your approval",
+  "Press Enter to confirm or Esc to cancel",
+  "Do you want to approve"
+];
+var STREAMING_PATTERNS = [
+  /Working\s*\(\d+[smh]/,
+  // "Working (12s" or "Working (1m 30s"
+  /Working\s*$/,
+  // "Working" at end of line (just started)
+  /esc to interrupt/
+  // hint text during streaming
+];
+var CodexTmuxBridge = class {
+  session;
+  queue = [];
+  pollTimer = null;
+  pollIntervalMs;
+  pasteDelayMs;
+  keystrokeDelayMs;
+  stopped = false;
+  constructor(session, opts) {
+    this.session = session;
+    this.pollIntervalMs = opts?.pollIntervalMs ?? 200;
+    this.pasteDelayMs = opts?.pasteDelayMs ?? 150;
+    this.keystrokeDelayMs = opts?.keystrokeDelayMs ?? 50;
+  }
+  /**
+   * Delivery callback — drop-in replacement for EventProcessor's deliver.
+   * Pass `bridge.deliver.bind(bridge)` to EventProcessor.run().
+   */
+  async deliver(parts) {
+    const text = contentPartsToString(parts);
+    if (!text.trim()) return;
+    this.inject(text);
+  }
+  /**
+   * Detect the current TUI state by reading the screen.
+   */
+  detectState() {
+    const lines = this.captureScreen();
+    return detectCodexStateFromLines(lines);
+  }
+  /**
+   * Try to inject text, choosing strategy based on TUI state.
+   * Text is flattened to a single line to avoid multi-line paste issues.
+   */
+  inject(text) {
+    const flat = text.replace(/\n/g, " ");
+    const state = this.detectState();
+    switch (state) {
+      case "idle":
+        this.injectIdle(flat);
+        break;
+      case "typing":
+        this.injectWhileTyping(flat);
+        break;
+      default:
+        this.enqueue(flat);
+        break;
+    }
+  }
+  /** Capture the screen via tmux capture-pane. */
+  captureScreen() {
+    return tmuxCapturePane(this.session);
+  }
+  /**
+   * Inject into an idle prompt using bracketed paste.
+   *
+   * Bracketed paste wraps text in ESC[200~...ESC[201~ so crossterm
+   * delivers it as a single Paste event, bypassing the burst detector.
+   * After the paste, we wait for the Enter suppression window (120ms)
+   * to expire, then send Enter to submit.
+   */
+  injectIdle(text) {
+    tmuxInjectText(this.session, "\x1B[200~");
+    tmuxInjectText(this.session, text);
+    tmuxInjectText(this.session, "\x1B[201~");
+    this.sleep(this.pasteDelayMs);
+    tmuxSendEnter(this.session);
+  }
+  /**
+   * Inject while the user is typing:
+   * 1. Ctrl+U — cut to beginning of line (into kill buffer)
+   * 2. Bracketed paste our text + Enter
+   * 3. Ctrl+Y — yank user's text back from kill buffer
+   */
+  injectWhileTyping(text) {
+    tmuxSendKey(this.session, "C-u");
+    this.sleep(this.keystrokeDelayMs);
+    tmuxInjectText(this.session, "\x1B[200~");
+    tmuxInjectText(this.session, text);
+    tmuxInjectText(this.session, "\x1B[201~");
+    this.sleep(this.pasteDelayMs);
+    tmuxSendEnter(this.session);
+    this.sleep(this.keystrokeDelayMs);
+    tmuxSendKey(this.session, "C-y");
+  }
+  /** Add to queue and start polling if not already. */
+  enqueue(text) {
+    this.queue.push(text);
+    this.startPolling();
+  }
+  /** Start the polling timer to drain queued events. */
+  startPolling() {
+    if (this.pollTimer || this.stopped) return;
+    this.pollTimer = setInterval(() => this.drainQueue(), this.pollIntervalMs);
+  }
+  /** Stop the polling timer. */
+  stopPolling() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  /**
+   * Try to drain one queued event if the state is safe.
+   * Drains one at a time — each injection may trigger streaming,
+   * so the next poll re-checks state before injecting more.
+   */
+  drainQueue() {
+    if (this.queue.length === 0) {
+      this.stopPolling();
+      return;
+    }
+    const state = this.detectState();
+    if (state === "idle" || state === "typing") {
+      const text = this.queue.shift();
+      if (state === "idle") {
+        this.injectIdle(text);
+      } else {
+        this.injectWhileTyping(text);
+      }
+      if (this.queue.length === 0) {
+        this.stopPolling();
+      }
+    }
+  }
+  /** Cleanup. */
+  stop() {
+    this.stopped = true;
+    this.stopPolling();
+    this.queue.length = 0;
+  }
+  /** Synchronous sleep — only used for tiny keystroke delays. */
+  sleep(ms) {
+    if (ms <= 0) return;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  }
+};
+function detectCodexStateFromLines(lines) {
+  if (lines.length === 0) return "unknown";
+  const tail = lines.slice(-20);
+  const tailText = tail.join("\n");
+  for (const pattern of APPROVAL_PATTERNS) {
+    if (tailText.includes(pattern)) return "approval";
+  }
+  for (const pattern of STREAMING_PATTERNS) {
+    if (pattern.test(tailText)) return "streaming";
+  }
+  const lastFew = tail.slice(-5).join("");
+  for (const ch of SPINNER_CHARS2) {
+    if (lastFew.includes(ch)) return "streaming";
+  }
+  const nonEmpty = tail.filter((l) => l.trim().length > 0);
+  if (nonEmpty.length > 0) {
+    return "idle";
+  }
+  return "unknown";
+}
+
+// src/cli/codex/run.ts
+function codexAvailable() {
+  try {
+    execFileSync3("codex", ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runCodex(options) {
+  if (options.headless) {
+    const setup2 = await setupAgentRuntime(options);
+    const deliver = async (parts) => {
+      const text = contentPartsToString(parts);
+      if (text.trim()) process.stdout.write(text + "\n");
+    };
+    const eventLoopPromise2 = setup2.processor.run(deliver, setup2.wrappedSource, setup2.initialParts).catch(() => {
+    });
+    process.stderr.write(`MCP server: ${setup2.mcpServer.url}
+`);
+    await new Promise((resolve) => {
+      process.on("SIGINT", resolve);
+      process.on("SIGTERM", resolve);
+    });
+    await setup2.cleanup();
+    await eventLoopPromise2;
+    return;
+  }
+  if (!tmuxAvailable()) {
+    console.error("Error: tmux is required but not found. Install it with: brew install tmux");
+    process.exit(1);
+  }
+  if (!codexAvailable()) {
+    console.error("Error: codex is required but not found. Install it with: npm install -g @openai/codex");
+    process.exit(1);
+  }
+  const setup = await setupAgentRuntime({ ...options, joinUrls: void 0 });
+  const tmpDir = mkdtempSync2(join3(tmpdir3(), "stoops_codex_"));
+  const mcpPort = new URL(setup.mcpServer.url).port;
+  const mcpUrl = `http://127.0.0.1:${mcpPort}/mcp`;
+  const codexConfigDir = join3(tmpDir, ".codex");
+  mkdirSync(codexConfigDir, { recursive: true });
+  const configToml = [
+    "[mcp_servers.stoops]",
+    `url = "${mcpUrl}"`,
+    `startup_timeout_sec = 15`,
+    `tool_timeout_sec = 60`
+  ].join("\n");
+  writeFileSync2(join3(codexConfigDir, "config.toml"), configToml);
+  const tmuxSession = `stoops_${setup.agentName}`;
+  if (tmuxSessionExists(tmuxSession)) {
+    tmuxKillSession(tmuxSession);
+  }
+  console.log("Launching Codex...");
+  tmuxCreateSession(tmuxSession);
+  const extraArgs = options.extraArgs ?? [];
+  const codexCmd = [`CODEX_HOME=${codexConfigDir} codex`, ...extraArgs].join(" ");
+  tmuxSendCommand(tmuxSession, codexCmd);
+  const bridge = new CodexTmuxBridge(tmuxSession);
+  const eventLoopPromise = setup.processor.run(bridge.deliver.bind(bridge), setup.wrappedSource).catch(() => {
+  });
+  for (let i = 0; i < 10; i++) {
+    await new Promise((r) => setTimeout(r, 500));
+    if (!tmuxSessionExists(tmuxSession)) {
+      console.error("Error: Codex exited during startup. Try running again.");
+      bridge.stop();
+      await setup.cleanup();
+      try {
+        rmSync2(tmpDir, { recursive: true });
+      } catch {
+      }
+      return;
+    }
+  }
+  console.log("Attaching to Codex session...\n");
+  try {
+    await tmuxAttach(tmuxSession);
+  } catch {
+  }
+  bridge.stop();
+  await setup.cleanup();
+  tmuxKillSession(tmuxSession);
+  try {
+    rmSync2(tmpDir, { recursive: true });
+  } catch {
+  }
+  console.log("Disconnected.");
+}
+
 // src/cli/index.ts
 var args = process.argv.slice(2);
 function getFlag(name, arr = args) {
@@ -2395,13 +2686,14 @@ function printUsage(stream = console.log) {
   stream("  stoops join <url> [--name <name>] [--guest]                              Join a room");
   stream("  stoops run claude [--name <name>] [--admin] [-- <args>]                  Connect Claude Code");
   stream("  stoops run opencode [--name <name>] [--admin] [-- <args>]                Connect OpenCode");
+  stream("  stoops run codex [--name <name>] [--admin] [-- <args>]                   Connect Codex");
 }
 async function main() {
   if (args.includes("--help") || args.includes("-h")) {
     printUsage();
     return;
   }
-  if (args[0] === "run" && (args[1] === "claude" || args[1] === "opencode")) {
+  if (args[0] === "run" && (args[1] === "claude" || args[1] === "opencode" || args[1] === "codex")) {
     const runtime = args[1];
     const restArgs = args.slice(2);
     const ddIndex = restArgs.indexOf("--");
@@ -2417,8 +2709,10 @@ async function main() {
     };
     if (runtime === "claude") {
       await runClaude(runtimeOptions);
-    } else {
+    } else if (runtime === "opencode") {
       await runOpencode(runtimeOptions);
+    } else {
+      await runCodex(runtimeOptions);
     }
     return;
   }
@@ -2447,7 +2741,9 @@ async function main() {
       room: getFlag("room"),
       port,
       share: args.includes("--share"),
-      headless: args.includes("--headless")
+      headless: args.includes("--headless"),
+      save: getFlag("save"),
+      load: getFlag("load")
     });
     return;
   }
@@ -2462,7 +2758,9 @@ async function main() {
       room: getFlag("room"),
       port,
       share: args.includes("--share"),
-      quiet: true
+      quiet: true,
+      save: getFlag("save"),
+      load: getFlag("load")
     });
     const adminJoinUrl = buildShareUrl(result.serverUrl, result.adminToken);
     const participantShareUrl = buildShareUrl(