orchestrating 0.1.3 → 0.1.5

package/bin/orch

@@ -151,7 +151,6 @@ const ADAPTERS = {
     buildArgs(prompt, flags) {
       const args = [
         "--output-format", "stream-json",
-        "--input-format", "stream-json",
         "--verbose",
       ];
       if (flags.continue) {
@@ -307,6 +306,7 @@ if (!adapter) {
 
 let child;
 let handleServerMessage; // set per-mode
+let exitRequested = false;
 
 if (adapter) {
   // ======== STRUCTURED MODE (Claude Code JSON streaming) ========
@@ -328,84 +328,101 @@ if (adapter) {
     process.exit(1);
   }
 
-  const claudeArgs = adapter.buildArgs(prompt, adapterFlags);
-  if (yoloMode) {
-    claudeArgs.push("--dangerously-skip-permissions");
-  }
-  child = spawn(command, claudeArgs, {
-    stdio: ["pipe", "pipe", "pipe"],
-    cwd: process.cwd(),
-    env: (() => {
-      const e = { ...process.env };
-      delete e.CLAUDECODE;
-      delete e.ANTHROPIC_API_KEY;
-      return e;
-    })(),
-  });
-
-  // Parse NDJSON from stdout line-by-line
-  const rl = readline.createInterface({ input: child.stdout });
+  // Confirmation-type tools — these need "yes" response, not permission grants
+  const CONFIRMATION_TOOLS = new Set(["ExitPlanMode", "EnterPlanMode"]);
+  let childRunning = false;
+
+  // Build clean env for child processes (no nesting detection, no leaked keys)
+  const childEnv = (() => {
+    const e = { ...process.env };
+    delete e.CLAUDECODE;
+    delete e.ANTHROPIC_API_KEY;
+    return e;
+  })();
+
+  // Spawn a claude process and wire up output handling
+  function spawnClaude(claudeArgs) {
+    process.stderr.write(`${DIM}[orch] Spawning: ${command} ${claudeArgs.join(" ")}${RESET}\n`);
+    const proc = spawn(command, claudeArgs, {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: process.cwd(),
+      env: childEnv,
+    });
+    childRunning = true;
+    child = proc;
+    process.stderr.write(`${DIM}[orch] Child PID: ${proc.pid}${RESET}\n`);
+
+    // Parse NDJSON from stdout line-by-line
+    const rl = readline.createInterface({ input: proc.stdout });
+    let permissionsSent = false;
+    let lineCount = 0;
+
+    rl.on("line", (line) => {
+      lineCount++;
+      process.stderr.write(`${DIM}[orch] stdout line #${lineCount}: ${line.slice(0, 120)}${RESET}\n`);
+      if (!permissionsSent) {
+        permissionsSent = true;
+        broadcastPermissions();
+      }
+      if (!line.trim()) return;
+      let raw;
+      try {
+        raw = JSON.parse(line);
+      } catch {
+        process.stderr.write(`${DIM}[orch] JSON parse failed for line${RESET}\n`);
+        return;
+      }
 
-  // Broadcast initial permission state once connected
-  let permissionsSent = false;
+      // Normalize and relay each event
+      const events = normalizeClaudeEvent(raw);
+      process.stderr.write(`${DIM}[orch] Normalized ${events.length} events (type=${raw.type})${RESET}\n`);
+      for (const event of events) {
+        printLocalEvent(event);
+        sendToServer({ type: "agent_event", sessionId, event });
+
+        // Yolo mode: auto-approve permission denials immediately
+        if (yoloMode && event.kind === "permission_denied") {
+          process.stderr.write(`${GREEN}[yolo] Auto-approving: ${event.toolName}${RESET}\n`);
+          approvePermission(event.toolName, "session");
+        }
+      }
+    });
 
-  rl.on("line", (line) => {
-    if (!permissionsSent) {
-      permissionsSent = true;
-      broadcastPermissions();
-    }
-    if (!line.trim()) return;
-    let raw;
-    try {
-      raw = JSON.parse(line);
-    } catch {
-      return;
-    }
+    proc.stdout.on("end", () => {
+      process.stderr.write(`${DIM}[orch] stdout stream ended (${lineCount} lines total)${RESET}\n`);
+    });
 
-    // Normalize and relay each event
-    const events = normalizeClaudeEvent(raw);
-    for (const event of events) {
-      printLocalEvent(event);
-      sendToServer({ type: "agent_event", sessionId, event });
+    proc.stderr.on("data", (buf) => {
+      process.stderr.write(`${DIM}[orch] child stderr: ${RESET}`);
+      process.stderr.write(buf);
+    });
 
-      // Yolo mode: auto-approve permission denials immediately
-      if (yoloMode && event.kind === "permission_denied") {
-        process.stderr.write(`${GREEN}[yolo] Auto-approving: ${event.toolName}${RESET}\n`);
-        approvePermission(event.toolName, "session");
+    proc.on("exit", (code, signal) => {
+      childRunning = false;
+      process.stderr.write(`${DIM}[orch] Child exited: code=${code} signal=${signal}${RESET}\n`);
+      const exitCode = code ?? 0;
+      if (exitCode !== 0 || exitRequested) {
+        sendToServer({ type: "exit", sessionId, exitCode });
+        setTimeout(() => process.exit(exitCode), 200);
+      } else {
+        sendToServer({
+          type: "agent_event", sessionId,
+          event: { kind: "status", status: "idle" },
+        });
       }
-    }
-  });
-
-  child.stderr.on("data", (buf) => {
-    process.stderr.write(buf);
-  });
-
-  child.on("exit", (code) => {
-    const exitCode = code ?? 0;
-    sendToServer({ type: "exit", sessionId, exitCode });
-    setTimeout(() => process.exit(exitCode), 200);
-  });
+    });
 
-  child.on("error", (err) => {
-    console.error("Failed to start:", err.message);
-    process.exit(1);
-  });
+    proc.on("error", (err) => {
+      childRunning = false;
+      process.stderr.write(`${RED}[orch] Spawn error: ${err.message}${RESET}\n`);
+      process.exit(1);
+    });
 
-  // Confirmation-type tools — these need "yes" response, not permission grants
-  const CONFIRMATION_TOOLS = new Set(["ExitPlanMode", "EnterPlanMode"]);
+    return proc;
+  }
 
   // Auto-approve a tool permission (used by yolo mode and manual approval)
   function approvePermission(toolName, scope) {
-    // For confirmation prompts, just send "yes" — no settings change needed
-    if (CONFIRMATION_TOOLS.has(toolName)) {
-      const confirmMsg = JSON.stringify({
-        type: "user",
-        message: { role: "user", content: "yes" },
-      });
-      child.stdin.write(confirmMsg + "\n");
-      return;
-    }
-
     let permEntry = toolName;
     const mcpMatch = toolName.match(/^(mcp__[^_]+(?:__[^_]+)?)__/);
     if (mcpMatch) {
@@ -442,41 +459,28 @@ if (adapter) {
     }
 
     broadcastPermissions();
-
-    const retryMsg = JSON.stringify({
-      type: "user",
-      message: { role: "user", content: `Permission granted for ${toolName}. Please retry.` },
-    });
-    child.stdin.write(retryMsg + "\n");
   }
 
-  // No local stdin forwarding in structured mode — input comes from server only
-  // (stdin is reserved for stream-json messages to Claude)
+  // Start the initial claude process
+  const initialArgs = adapter.buildArgs(prompt, adapterFlags);
+  if (yoloMode) {
+    initialArgs.push("--dangerously-skip-permissions");
+  }
+  spawnClaude(initialArgs);
 
   handleServerMessage = (msg) => {
     if (msg.type === "agent_input" && (msg.text || msg.images)) {
-      // Forward user message from dashboard to Claude's stdin as stream-json
-      let content;
-      if (msg.images && msg.images.length > 0) {
-        // Build content array with images + optional text
-        content = [];
-        for (const img of msg.images) {
-          content.push({
-            type: "image",
-            source: { type: "base64", media_type: img.mediaType, data: img.data },
-          });
-        }
-        if (msg.text) {
-          content.push({ type: "text", text: msg.text });
-        }
-      } else {
-        content = msg.text;
+      // Follow-up from dashboard — spawn new claude with -c (continue)
+      if (childRunning) {
+        // Child still running, queue or ignore
+        process.stderr.write(`${DIM}[orch] Ignoring input — claude is still running${RESET}\n`);
+        return;
+      }
+      const followUpArgs = ["--output-format", "stream-json", "--verbose", "-c", "-p", msg.text || "continue"];
+      if (yoloMode) {
+        followUpArgs.push("--dangerously-skip-permissions");
       }
-      const inputMsg = JSON.stringify({
-        type: "user",
-        message: { role: "user", content },
-      });
-      child.stdin.write(inputMsg + "\n");
+      spawnClaude(followUpArgs);
     } else if (msg.type === "agent_permission" && msg.tool && msg.action === "allow") {
       const scope = msg.scope || "session";
       approvePermission(msg.tool, scope);
@@ -766,6 +770,8 @@ function connectWs() {
   ws = new WebSocket(serverUrl);
 
   ws.on("open", () => {
+    process.stderr.write(`${DIM}[orch] WS connected to ${serverUrl}${RESET}\n`);
+    process.stderr.write(`${DIM}[orch] Token: ${authToken ? authToken.slice(0, 20) + "..." : "(none)"}${RESET}\n`);
     ws.send(JSON.stringify({
       type: "register",
       token: authToken,
@@ -810,7 +816,8 @@ function connectWs() {
     } catch {}
   });
 
-  ws.on("close", () => {
+  ws.on("close", (code, reason) => {
+    process.stderr.write(`${DIM}[orch] WS closed: code=${code} reason=${reason}${RESET}\n`);
     wsReady = false;
     ws = null;
     if (!authFailed) {
@@ -818,8 +825,8 @@ function connectWs() {
     }
   });
 
-  ws.on("error", () => {
-    // Will trigger close
+  ws.on("error", (err) => {
+    process.stderr.write(`${DIM}[orch] WS error: ${err.message}${RESET}\n`);
   });
 }
 
@@ -855,6 +862,7 @@ function cleanup() {
 
 process.on("SIGINT", () => {
   if (adapter) {
+    exitRequested = true;
     child.kill("SIGINT");
   } else {
     child.stdin.write("\x03");

package/package.json

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