orchestrating 0.2.0 → 0.3.1

package/bin/orch

@@ -750,14 +750,14 @@ const ADAPTERS = {
     buildArgs(prompt, flags) {
       const args = [
         "--output-format", "stream-json",
+        "--input-format", "stream-json",
         "--verbose",
       ];
       if (flags.continue) {
         args.push("-c");
-        if (prompt) args.push("-p", prompt);
-      } else {
-        args.push("-p", prompt);
       }
+      // With --input-format stream-json, the initial prompt is sent via stdin
+      // so we don't use -p here. The prompt is sent after spawn.
       return args;
     },
     mode: "structured",
@@ -829,6 +829,7 @@ if (commandArgs.length === 0) {
 }
 
 // Resolve claude binary: prefer bundled @anthropic-ai/claude-code, fall back to system PATH
+const commandName = commandArgs[0]; // original name for adapter lookup
 let command = commandArgs[0];
 let claudeBundled = false;
 if (command === "claude") {
@@ -952,7 +953,7 @@ function removePermission(tool) {
 }
 
 // --- Determine mode: structured adapter or PTY ---
-const adapter = ADAPTERS[command];
+const adapter = ADAPTERS[commandName];
 
 // Check for python3 in PTY mode
 if (!adapter) {
@@ -1016,10 +1017,13 @@ if (adapter) {
     return e;
   })();
 
-  // Spawn a claude process and wire up output handling
+  // Spawn claude with bidirectional stdin/stdout (stream-json mode)
+  // Follow-ups are sent via stdin — no more kill/respawn.
+  let claudeSessionId = null; // Claude's internal session ID (from init event)
+
   function spawnClaude(claudeArgs) {
     const proc = spawn(command, claudeArgs, {
-      stdio: ["ignore", "pipe", "pipe"],
+      stdio: ["pipe", "pipe", "pipe"],
       cwd: process.cwd(),
       env: childEnv,
     });
@@ -1043,18 +1047,28 @@ if (adapter) {
         return;
       }
 
+      // Capture Claude's session ID for follow-ups
+      if (raw.type === "system" && raw.subtype === "init" && raw.session_id) {
+        claudeSessionId = raw.session_id;
+      }
+
+      // Detect turn completion — Claude finished responding, ready for next input
+      if (raw.type === "result") {
+        childRunning = false; // "idle" — accepting input
+      }
+
       // Normalize and relay each event
       const events = normalizeClaudeEvent(raw);
       for (const event of events) {
         printLocalEvent(event);
         sendToServer({ type: "agent_event", sessionId, event });
 
-        // Yolo mode: auto-approve permission denials — save to settings,
-        // claude will pick it up on respawn via pendingPermissionGrant
+        // Yolo mode: auto-approve permission denials
         if (yoloMode && event.kind === "permission_denied") {
           process.stderr.write(`${GREEN}[yolo] Auto-approving: ${event.toolName}${RESET}\n`);
           approvePermission(event.toolName, "session");
-          pendingPermissionGrant = event.toolName;
+          // Send follow-up via stdin to retry (no respawn needed)
+          sendFollowUp(`Permission for ${event.toolName} was granted. Please retry your last action.`);
         }
       }
     });
@@ -1066,21 +1080,8 @@ if (adapter) {
     proc.on("exit", (code) => {
       childRunning = false;
       const exitCode = code ?? 0;
-      if (exitCode !== 0 || exitRequested) {
-        sendToServer({ type: "exit", sessionId, exitCode });
-        setTimeout(() => process.exit(exitCode), 200);
-      } else if (pendingPermissionGrant) {
-        // Permission was granted while claude was running — respawn to retry
-        const tool = pendingPermissionGrant;
-        pendingPermissionGrant = null;
-        process.stderr.write(`${GREEN}Retrying with new permission: ${tool}${RESET}\n`);
-        respawnWithContinue(`Permission for ${tool} was granted. Please retry your last action.`);
-      } else {
-        sendToServer({
-          type: "agent_event", sessionId,
-          event: { kind: "status", status: "idle" },
-        });
-      }
+      sendToServer({ type: "exit", sessionId, exitCode });
+      setTimeout(() => process.exit(exitCode), 200);
     });
 
     proc.on("error", (err) => {
@@ -1092,6 +1093,24 @@ if (adapter) {
     return proc;
   }
 
+  // Send a follow-up message via stdin (no respawn!)
+  function sendFollowUp(text) {
+    if (!child || child.exitCode !== null) return;
+    const msg = {
+      type: "user",
+      message: {
+        role: "user",
+        content: text,
+      },
+    };
+    try {
+      child.stdin.write(JSON.stringify(msg) + "\n");
+      childRunning = true; // Claude is now processing
+    } catch (err) {
+      process.stderr.write(`${RED}[orch] Failed to send via stdin: ${err.message}${RESET}\n`);
+    }
+  }
+
   // Auto-approve a tool permission (used by yolo mode and manual approval)
   function approvePermission(toolName, scope) {
     let permEntry = toolName;
@@ -1194,37 +1213,29 @@ if (adapter) {
     }
   }
 
-  // Start the initial claude process
+  // Start the claude process (single process for entire session — no respawning)
   const initialArgs = adapter.buildArgs(prompt, adapterFlags);
   if (yoloMode) {
     initialArgs.push("--dangerously-skip-permissions");
   }
   spawnClaude(initialArgs);
 
-  // Emit the initial prompt as a user message so the dashboard shows it
+  // Send initial prompt via stdin (not -p flag)
   if (prompt) {
+    sendFollowUp(prompt);
+    // Emit the initial prompt as a user message so the dashboard shows it
     sendToServer({
       type: "agent_event", sessionId,
       event: { kind: "user_message", text: prompt },
     });
   }
 
-  // Respawn claude with -c to continue after permission grants or follow-up
-  function respawnWithContinue(prompt) {
-    const args = ["--output-format", "stream-json", "--verbose", "-c"];
-    if (prompt) args.push("-p", prompt);
-    if (yoloMode) args.push("--dangerously-skip-permissions");
-    spawnClaude(args);
-  }
-
-  // Queue of permission grants received while claude is still running
-  let pendingPermissionGrant = null;
-
   handleServerMessage = (msg) => {
     if (msg.type === "agent_input" && (msg.text || msg.images)) {
-      // Follow-up from dashboard — spawn new claude with -c (continue)
+      // Follow-up from dashboard — send via stdin (no respawn!)
       if (childRunning) {
-        process.stderr.write(`${DIM}[orch] Ignoring input — claude is still running${RESET}\n`);
+        process.stderr.write(`${DIM}[orch] Queuing input — claude is still processing${RESET}\n`);
+        // TODO: queue and send after current turn completes
         return;
       }
       let promptText = msg.text || "continue";
@@ -1241,28 +1252,16 @@ if (adapter) {
         const fileList = imagePaths.map((p) => `[Attached image: ${p} — use Read tool to view]`).join("\n");
         promptText = `${fileList}\n\n${promptText}`;
       }
-      respawnWithContinue(promptText);
+      sendFollowUp(promptText);
     } else if (msg.type === "agent_permission" && msg.tool && msg.action === "allow") {
       const scope = msg.scope || "session";
       approvePermission(msg.tool, scope);
       process.stderr.write(`${GREEN}Permission granted (${scope}): ${msg.tool}${RESET}\n`);
-
-      if (childRunning) {
-        // Claude is still running — remember the grant and respawn when it exits
-        pendingPermissionGrant = msg.tool;
-      } else {
-        // Claude already finished — respawn with -c to retry with new permission
-        respawnWithContinue(`Permission for ${msg.tool} was granted. Please retry your last action.`);
-      }
+      // Send permission grant as follow-up via stdin
+      sendFollowUp(`Permission for ${msg.tool} was granted. Please retry your last action.`);
     } else if (msg.type === "agent_permission" && msg.tool && msg.action === "deny") {
       process.stderr.write(`${RED}Permission denied: ${msg.tool}${RESET}\n`);
-
-      if (childRunning) {
-        // Claude is still running — remember and respawn when it exits
-        pendingPermissionGrant = null;
-      } else {
-        respawnWithContinue(`Permission for ${msg.tool} was denied by the user. Do not retry this tool — find an alternative approach or skip this step.`);
-      }
+      sendFollowUp(`Permission for ${msg.tool} was denied by the user. Do not retry this tool — find an alternative approach or skip this step.`);
     } else if (msg.type === "agent_permission" && msg.tool && msg.action === "revoke") {
       removePermission(msg.tool);
       broadcastPermissions();
@@ -1274,7 +1273,7 @@ if (adapter) {
     } else if (msg.type === "stop_session") {
       process.stderr.write(`${RED}[orch] Stopped from dashboard${RESET}\n`);
       exitRequested = true;
-      if (childRunning) {
+      if (child && child.exitCode === null) {
         child.kill("SIGINT");
       } else {
         cleanup();
@@ -1586,7 +1585,7 @@ async function connectWs() {
       token: authToken,
       sessionId,
       label: effectiveLabel,
-      command,
+      command: commandName,
       args: spawnArgs,
       cwd: process.cwd(),
       hostname,

package/package.json

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