sema-cli 0.1.0

package/experiments/spike-shell-stream/bin/start.js

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+
+const { spawn, fork } = require("node:child_process");
+const http = require("node:http");
+const os = require("node:os");
+const path = require("node:path");
+const { generateKeyPair, exportPublicKey, exportPrivateKey } = require(path.join(__dirname, "..", "shared", "crypto"));
+
+const PORT = Number(process.env.PORT || 8787);
+const HOST = process.env.HOST || "0.0.0.0";
+const RELAY_HTTP = `http://127.0.0.1:${PORT}`;
+const SPIKE_DIR = path.resolve(__dirname, "..");
+const RELAY_SCRIPT = path.join(SPIKE_DIR, "relay-server", "server.js");
+const AGENT_SCRIPT = path.join(SPIKE_DIR, "mac-agent", "agent.js");
+
+// CLI arguments: one or more commands to run (e.g., "claude", "claude codex")
+const COMMANDS = process.argv.slice(2);
+const commands = COMMANDS.length > 0 ? COMMANDS : [null]; // [null] = default shell
+
+let relayProcess = null;
+const agentProcesses = []; // { process, command, label, sessionId }
+let shuttingDown = false;
+
+// --- LAN IP Detection ---
+
+function detectLanIp() {
+  const interfaces = os.networkInterfaces();
+  const candidates = [];
+
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    for (const addr of addrs) {
+      if (addr.family !== "IPv4" || addr.internal) continue;
+      if (addr.address.startsWith("169.254.")) continue; // APIPA
+      if (/^172\.(1[6-9]|2\d|3[01])\./.test(addr.address)) continue; // Docker/VPN private
+      candidates.push({ name, address: addr.address });
+    }
+  }
+
+  // Prefer en0/en1 (macOS WiFi/Ethernet)
+  const preferred = candidates.find(
+    (c) => c.name === "en0" || c.name === "en1",
+  );
+  if (preferred) return preferred.address;
+
+  if (candidates.length === 1) return candidates[0].address;
+
+  if (candidates.length > 1) {
+    console.log(
+      `\x1b[33m  Multiple network interfaces found:\x1b[0m`,
+    );
+    for (const c of candidates) {
+      console.log(`    ${c.name}: ${c.address}`);
+    }
+    console.log(`  Using: ${candidates[0].address}\n`);
+    return candidates[0].address;
+  }
+
+  return "127.0.0.1";
+}
+
+// --- HTTP helpers ---
+
+function httpGet(url) {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, { timeout: 2000 }, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () =>
+        resolve({ status: res.statusCode, body: Buffer.concat(chunks).toString() }),
+      );
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+  });
+}
+
+function httpPost(url, body = null) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const payload = body ? JSON.stringify(body) : null;
+    const req = http.request(
+      {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port,
+        path: parsedUrl.pathname,
+        method: "POST",
+        timeout: 5000,
+        headers: payload
+          ? { "content-type": "application/json", "content-length": Buffer.byteLength(payload) }
+          : {},
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          try {
+            resolve({
+              status: res.statusCode,
+              data: JSON.parse(Buffer.concat(chunks).toString()),
+            });
+          } catch {
+            reject(new Error("Invalid JSON from relay"));
+          }
+        });
+      },
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("timeout"));
+    });
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+async function isRelayRunning() {
+  try {
+    const res = await httpGet(`${RELAY_HTTP}/health`);
+    return res.status === 200;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForRelay(maxWait = 10000) {
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    if (await isRelayRunning()) return true;
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  return false;
+}
+
+// --- Relay management ---
+
+function startRelay() {
+  console.log("[start] Starting relay server...");
+
+  relayProcess = fork(RELAY_SCRIPT, [], {
+    env: { ...process.env, PORT: String(PORT), HOST },
+    stdio: "pipe",
+  });
+
+  relayProcess.stdout.on("data", (data) => {
+    const msg = data.toString().trim();
+    if (msg) console.log(`  [relay] ${msg.replace(/^\[relay\] /, "")}`);
+  });
+
+  relayProcess.stderr.on("data", (data) => {
+    const msg = data.toString().trim();
+    if (msg.includes("EADDRINUSE")) {
+      console.error(
+        `\n\x1b[31m✗ Port ${PORT} is already in use.\x1b[0m`,
+      );
+      console.error(
+        `  Run: lsof -ti:${PORT} | xargs kill  (or use PORT=<port> to change)`,
+      );
+      cleanup();
+      process.exit(1);
+    }
+    if (msg) console.error(`  [relay:err] ${msg}`);
+  });
+
+  relayProcess.on("exit", (code) => {
+    if (!shuttingDown) {
+      console.error(
+        `\n\x1b[31m✗ Relay exited unexpectedly (code: ${code}).\x1b[0m`,
+      );
+      cleanup();
+      process.exit(1);
+    }
+  });
+}
+
+// --- Agent management ---
+
+function startAgent(sessionId, macToken, macPrivateKey, macPublicKey, command) {
+  const label = command || "shell";
+  const env = {
+    ...process.env,
+    SESSION_ID: sessionId,
+    SESSION_TOKEN: macToken,
+    RELAY_URL: `ws://127.0.0.1:${PORT}/ws`,
+    MAC_PRIVATE_KEY: macPrivateKey,
+    MAC_PUBLIC_KEY: macPublicKey,
+  };
+
+  if (command) {
+    env.CLI_COMMAND = command;
+  }
+
+  const agent = fork(AGENT_SCRIPT, [], {
+    env,
+    stdio: "pipe",
+  });
+
+  agent.stdout.on("data", (data) => {
+    const msg = data.toString().trim();
+    if (msg) console.log(`  [${label}] ${msg.replace(/^\[mac-agent\] /, "")}`);
+  });
+
+  agent.stderr.on("data", (data) => {
+    const msg = data.toString().trim();
+    if (msg) console.error(`  [${label}:err] ${msg}`);
+  });
+
+  agent.on("exit", (code) => {
+    if (!shuttingDown) {
+      console.log(`\n[start] Agent "${label}" exited (code: ${code || 0}).`);
+      // Remove from agent list
+      const idx = agentProcesses.findIndex((a) => a.process === agent);
+      if (idx >= 0) agentProcesses.splice(idx, 1);
+      // If no agents left, shut down
+      if (agentProcesses.length === 0) {
+        console.log("[start] All agents exited. Shutting down.");
+        cleanup();
+        process.exit(code || 0);
+      }
+    }
+  });
+
+  return agent;
+}
+
+// --- Cleanup ---
+
+const CLEANUP_KILL_MS = 3000;
+
+function cleanup() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+
+  // SIGTERM all agents
+  for (const { process: agent } of agentProcesses) {
+    if (agent && !agent.killed) agent.kill("SIGTERM");
+  }
+
+  // SIGTERM relay
+  if (relayProcess && !relayProcess.killed) {
+    relayProcess.kill("SIGTERM");
+  }
+
+  // SIGKILL after timeout
+  setTimeout(() => {
+    for (const { process: agent } of agentProcesses) {
+      if (agent && !agent.killed) agent.kill("SIGKILL");
+    }
+    if (relayProcess && !relayProcess.killed) relayProcess.kill("SIGKILL");
+  }, CLEANUP_KILL_MS);
+}
+
+process.on("SIGINT", () => {
+  console.log("\n[start] Shutting down...");
+  cleanup();
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  cleanup();
+  process.exit(0);
+});
+
+process.on("uncaughtException", (err) => {
+  console.error(`\n\x1b[31m[start] Uncaught error: ${err.message}\x1b[0m`);
+  cleanup();
+  process.exit(1);
+});
+
+// --- Display ---
+
+function displayMultiSessionInfo(lanIp, sessionInfos) {
+  const qrcode = require("qrcode-terminal");
+  const inboxUrl = `http://${lanIp}:${PORT}/inbox.html`;
+
+  console.log("");
+  console.log("┌─────────────────────────────────────┐");
+  if (sessionInfos.length === 1) {
+    console.log("│     \x1b[1;32mSema Session Ready\x1b[0m       │");
+  } else {
+    console.log(`│   \x1b[1;32mSema — ${sessionInfos.length} Agents Ready\x1b[0m      │`);
+  }
+  console.log("└─────────────────────────────────────┘");
+  console.log("");
+
+  // Single QR code pointing to inbox (works for both single and multi session)
+  qrcode.generate(inboxUrl, { small: true }, (qr) => {
+    console.log(qr);
+    console.log("");
+    console.log(`  \x1b[2mScan with phone camera, or visit:\x1b[0m`);
+    console.log(`  \x1b[1;36m${inboxUrl}\x1b[0m`);
+    console.log("");
+
+    // Compact session list
+    if (sessionInfos.length > 1) {
+      console.log("  Sessions:");
+    }
+    for (let i = 0; i < sessionInfos.length; i++) {
+      const info = sessionInfos[i];
+      const prefix = sessionInfos.length > 1 ? `  ${i + 1}. ` : "  ";
+      const label = info.label.padEnd(12);
+      console.log(`${prefix}\x1b[1m${label}\x1b[0m Code: \x1b[1;36m${info.code}\x1b[0m`);
+    }
+    console.log("");
+    console.log("  \x1b[2mPress Ctrl+C to stop.\x1b[0m");
+    console.log("");
+  });
+}
+
+// --- Main ---
+
+async function main() {
+  console.log("");
+  console.log("  \x1b[1mSema\x1b[0m");
+  console.log("");
+
+  // 1. Start relay if not running
+  const relayWasRunning = await isRelayRunning();
+  if (!relayWasRunning) {
+    startRelay();
+  } else {
+    console.log("[start] Relay already running.");
+  }
+
+  // 2. Wait for relay to be ready
+  const ready = await waitForRelay();
+  if (!ready) {
+    console.error("\x1b[31m✗ Relay did not become ready in time.\x1b[0m");
+    cleanup();
+    process.exit(1);
+  }
+
+  // 3. Detect LAN IP
+  const lanIp = detectLanIp();
+
+  // 4. Create sessions + start agents for each command
+  const sessionInfos = []; // { label, code, sessionId }
+
+  for (const command of commands) {
+    const label = command || "shell";
+
+    // Generate E2E keypair
+    console.log(`[start] Generating keys for ${label}...`);
+    const keyPair = generateKeyPair();
+    const macPublicKey = exportPublicKey(keyPair.publicKey);
+    const macPrivateKey = exportPrivateKey(keyPair.privateKey);
+
+    // Create session
+    console.log(`[start] Creating session for ${label}...`);
+    let sessionData;
+    try {
+      const res = await httpPost(`${RELAY_HTTP}/api/sessions`, {
+        macPublicKey,
+        command: command || null,
+      });
+      if (res.status !== 201) {
+        throw new Error(res.data.error || `HTTP ${res.status}`);
+      }
+      sessionData = res.data;
+    } catch (err) {
+      console.error(`\x1b[31m✗ Failed to create session for ${label}: ${err.message}\x1b[0m`);
+      cleanup();
+      process.exit(1);
+    }
+
+    sessionInfos.push({ label, code: sessionData.code, sessionId: sessionData.sessionId });
+
+    // Start agent
+    const agent = startAgent(
+      sessionData.sessionId, sessionData.macToken,
+      macPrivateKey, macPublicKey, command,
+    );
+    agentProcesses.push({ process: agent, command, label, sessionId: sessionData.sessionId });
+  }
+
+  // 5. Display QR + session list
+  displayMultiSessionInfo(lanIp, sessionInfos);
+}
+
+main().catch((err) => {
+  console.error(`\x1b[31m✗ ${err.message}\x1b[0m`);
+  cleanup();
+  process.exit(1);
+});