orchestrating 0.1.22 → 0.1.25

package/bin/orch

@@ -178,6 +178,182 @@ if (firstArg === "logout") {
   process.exit(0);
 }
 
+if (firstArg === "daemon") {
+  await handleDaemon();
+  // handleDaemon runs forever (or exits on fatal error)
+}
+
+// --- Daemon mode ---
+async function handleDaemon() {
+  const DIM = "\x1b[2m";
+  const GREEN = "\x1b[32m";
+  const RED = "\x1b[31m";
+  const RESET = "\x1b[0m";
+  const PREFIX = "[daemon]";
+
+  let token = getAuthToken();
+  if (!token) {
+    console.error(`${RED}No credentials found. Run 'orch login' to authenticate.${RESET}`);
+    process.exit(1);
+  }
+  if (isTokenExpired()) {
+    const refreshed = await refreshAuthToken();
+    if (refreshed) {
+      token = refreshed;
+    } else {
+      console.error(`${RED}Session expired. Run 'orch login' to re-authenticate.${RESET}`);
+      process.exit(1);
+    }
+  }
+
+  const hostname = os.hostname().replace(/\.(lan|local|home|internal)$/i, "");
+  const cliVersion = JSON.parse(readFileSync(path.join(__dirname, "..", "package.json"), "utf-8")).version;
+  const serverUrl = process.env.ORC_URL || process.env.CAST_URL || "wss://api.orchestrat.ing/ws";
+  const orchPath = fileURLToPath(import.meta.url);
+
+  const PING_INTERVAL_MS = 30_000;
+  const PONG_TIMEOUT_MS = 10_000;
+  let ws = null;
+  let pingTimer = null;
+  let pongTimer = null;
+  let reconnectTimer = null;
+
+  process.stderr.write(`${GREEN}${PREFIX} Listening for remote sessions as "${hostname}"${RESET}\n`);
+  process.stderr.write(`${DIM}${PREFIX} Tip: Use 'nohup orch daemon &' to run in background${RESET}\n`);
+
+  async function connect() {
+    // Refresh token if needed before connecting
+    if (isTokenExpired()) {
+      const refreshed = await refreshAuthToken();
+      if (refreshed) {
+        token = refreshed;
+        process.stderr.write(`${DIM}${PREFIX} Token refreshed${RESET}\n`);
+      } else {
+        process.stderr.write(`${RED}${PREFIX} Token refresh failed — retrying in 10s${RESET}\n`);
+        reconnectTimer = setTimeout(connect, 10_000);
+        return;
+      }
+    }
+
+    ws = new WebSocket(serverUrl);
+
+    ws.on("open", () => {
+      ws.send(JSON.stringify({
+        type: "register_daemon",
+        token,
+        hostname,
+        cliVersion,
+      }));
+      process.stderr.write(`${GREEN}${PREFIX} Connected${RESET}\n`);
+
+      // Keepalive pings
+      if (pingTimer) clearInterval(pingTimer);
+      if (pongTimer) clearTimeout(pongTimer);
+      pingTimer = setInterval(() => {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.ping();
+          pongTimer = setTimeout(() => {
+            if (ws) ws.terminate();
+          }, PONG_TIMEOUT_MS);
+        }
+      }, PING_INTERVAL_MS);
+    });
+
+    ws.on("pong", () => {
+      if (pongTimer) { clearTimeout(pongTimer); pongTimer = null; }
+    });
+
+    ws.on("message", (raw) => {
+      let msg;
+      try { msg = JSON.parse(raw.toString()); } catch { return; }
+
+      if (msg.type === "error") {
+        process.stderr.write(`${RED}${PREFIX} Server: ${msg.error}${RESET}\n`);
+        if (/unauthorized|auth|token/i.test(msg.error || "")) {
+          refreshAuthToken().then((refreshed) => {
+            if (refreshed) {
+              token = refreshed;
+              connect();
+            } else {
+              process.stderr.write(`${RED}${PREFIX} Auth failed. Run 'orch login'.${RESET}\n`);
+              process.exit(1);
+            }
+          });
+        }
+        return;
+      }
+
+      if (msg.type === "start_session") {
+        const { requestId, command, args, cwd, label, yolo } = msg;
+        const cmdStr = [command, ...args].join(" ");
+        process.stderr.write(`${GREEN}${PREFIX} Spawning: ${cmdStr}${RESET}\n`);
+
+        try {
+          const childArgs = [];
+          if (label) childArgs.push("-l", label);
+          if (yolo) childArgs.push("-y");
+          childArgs.push(command, ...args);
+
+          const child = spawn(process.execPath, [orchPath, ...childArgs], {
+            stdio: "ignore",
+            detached: true,
+            cwd: cwd || process.cwd(),
+            env: { ...process.env },
+          });
+          child.unref();
+
+          if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+              type: "session_started",
+              requestId,
+              success: true,
+            }));
+          }
+        } catch (err) {
+          process.stderr.write(`${RED}${PREFIX} Spawn failed: ${err.message}${RESET}\n`);
+          if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+              type: "session_started",
+              requestId,
+              success: false,
+              error: err.message,
+            }));
+          }
+        }
+      }
+    });
+
+    ws.on("close", () => {
+      ws = null;
+      if (pingTimer) { clearInterval(pingTimer); pingTimer = null; }
+      if (pongTimer) { clearTimeout(pongTimer); pongTimer = null; }
+      process.stderr.write(`${DIM}${PREFIX} Disconnected — reconnecting in 2s${RESET}\n`);
+      reconnectTimer = setTimeout(connect, 2000);
+    });
+
+    ws.on("error", () => {
+      // Will trigger close
+    });
+  }
+
+  connect();
+
+  // Graceful shutdown
+  const shutdown = () => {
+    process.stderr.write(`\n${DIM}${PREFIX} Shutting down${RESET}\n`);
+    if (pingTimer) clearInterval(pingTimer);
+    if (pongTimer) clearTimeout(pongTimer);
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    if (ws) ws.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  // Keep alive forever
+  await new Promise(() => {});
+}
+
 // --- Structured adapters ---
 // Commands that match an adapter key get spawned with structured JSON I/O
 // instead of PTY wrapping. Future adapters (codex, gemini) go here.
@@ -220,6 +396,7 @@ while (i < args.length) {
     console.error("Usage: orch [-l label] [-y] <command> [args...]");
     console.error("       orch login    — Authenticate with orchestrat.ing");
     console.error("       orch logout   — Clear stored credentials");
+    console.error("       orch daemon   — Run background daemon for remote session launching");
     console.error("");
     console.error("  -l <label>   Optional human-readable session label");
     console.error("  -y, --yolo   Skip all permission prompts (auto-approve everything)");
@@ -229,6 +406,7 @@ while (i < args.length) {
     console.error('  orch -y claude "build a website"');
     console.error('  orch -l "deploy fix" codex');
     console.error("  orch bash");
+    console.error("  orch daemon");
     console.error("");
     console.error("Environment:");
     console.error("  ORC_URL      WebSocket server URL (default: wss://api.orchestrat.ing/ws)");
@@ -268,19 +446,22 @@ if (authToken && isTokenExpired()) {
     authToken = refreshed;
     process.stderr.write(`${DIM}[orch] Token refreshed${RESET}\n`);
   } else {
-    process.stderr.write("\x1b[33mToken expired. Run 'orch login' to re-authenticate.\x1b[0m\n");
+    process.stderr.write(`${RED}Session expired. Run 'orch login' to re-authenticate.${RESET}\n`);
+    process.exit(1);
   }
 }
 
 // Warn if no auth and connecting to remote server
 if (!authToken && !serverUrl.includes("localhost") && !serverUrl.includes("127.0.0.1")) {
-  console.error("\x1b[33mNo credentials found. Run 'orch login' to authenticate.\x1b[0m");
+  console.error(`${RED}No credentials found. Run 'orch login' to authenticate.${RESET}`);
+  process.exit(1);
 }
 
 // --- WebSocket connection with reconnect ---
 const BUFFER_MAX = 50 * 1024; // 50KB reconnect buffer
 const PING_INTERVAL_MS = 30_000; // 30s keepalive ping
 const PONG_TIMEOUT_MS = 10_000; // 10s to receive pong before assuming dead
+const MAX_EVENT_HISTORY = 500; // max events to replay on reconnect
 let ws = null;
 let wsReady = false;
 let reconnectTimer = null;
@@ -289,8 +470,16 @@ let pongTimer = null;
 let authFailed = false;
 const sendBuffer = [];
 let bufferSize = 0;
+const eventHistory = []; // all agent events for replay on reconnect
 
 function sendToServer(msg) {
+  // Track agent events for reconnect replay
+  if (msg.type === "agent_event" && msg.event) {
+    eventHistory.push(msg.event);
+    while (eventHistory.length > MAX_EVENT_HISTORY) {
+      eventHistory.shift();
+    }
+  }
   if (wsReady && ws && ws.readyState === WebSocket.OPEN) {
     ws.send(JSON.stringify(msg));
   } else {
@@ -938,6 +1127,15 @@ async function connectWs() {
       broadcastPermissions();
     }
 
+    // Replay event history so server can rebuild conversation after restarts
+    if (eventHistory.length > 0) {
+      ws.send(JSON.stringify({
+        type: "agent_history_replay",
+        sessionId,
+        events: eventHistory,
+      }));
+    }
+
     // Keepalive: send WebSocket ping frames every 30s to prevent idle disconnects
     if (pingTimer) clearInterval(pingTimer);
     if (pongTimer) clearTimeout(pongTimer);
@@ -970,8 +1168,9 @@ async function connectWs() {
               authFailed = false;
               connectWs();
             } else {
-              process.stderr.write(`${RED}Run 'orch login' to authenticate.${RESET}\n`);
+              process.stderr.write(`${RED}Session expired. Run 'orch login' to re-authenticate.${RESET}\n`);
               authFailed = true;
+              process.exit(1);
             }
           });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchestrating",
-  "version": "0.1.22",
+  "version": "0.1.25",
   "description": "Stream terminal sessions to the orchestrat.ing dashboard",
   "type": "module",
   "bin": {