orchestrating 0.1.6 → 0.1.9

package/bin/orch

@@ -342,7 +342,6 @@ if (adapter) {
 
   // 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: ["ignore", "pipe", "pipe"],
       cwd: process.cwd(),
@@ -350,16 +349,12 @@ if (adapter) {
     });
     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();
@@ -369,41 +364,41 @@ if (adapter) {
       try {
         raw = JSON.parse(line);
       } catch {
-        process.stderr.write(`${DIM}[orch] JSON parse failed for line${RESET}\n`);
         return;
       }
 
       // 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
+        // Yolo mode: auto-approve permission denials — save to settings,
+        // claude will pick it up on respawn via pendingPermissionGrant
         if (yoloMode && event.kind === "permission_denied") {
           process.stderr.write(`${GREEN}[yolo] Auto-approving: ${event.toolName}${RESET}\n`);
           approvePermission(event.toolName, "session");
+          pendingPermissionGrant = event.toolName;
         }
       }
     });
 
-    proc.stdout.on("end", () => {
-      process.stderr.write(`${DIM}[orch] stdout stream ended (${lineCount} lines total)${RESET}\n`);
-    });
-
     proc.stderr.on("data", (buf) => {
-      process.stderr.write(`${DIM}[orch] child stderr: ${RESET}`);
       process.stderr.write(buf);
     });
 
-    proc.on("exit", (code, signal) => {
+    proc.on("exit", (code) => {
       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 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,
@@ -414,7 +409,7 @@ if (adapter) {
 
     proc.on("error", (err) => {
       childRunning = false;
-      process.stderr.write(`${RED}[orch] Spawn error: ${err.message}${RESET}\n`);
+      console.error("Failed to start:", err.message);
       process.exit(1);
     });
 
@@ -468,23 +463,45 @@ if (adapter) {
   }
   spawnClaude(initialArgs);
 
+  // Emit the initial prompt as a user message so the dashboard shows it
+  if (prompt) {
+    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)
       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");
-      }
-      spawnClaude(followUpArgs);
+      respawnWithContinue(msg.text || "continue");
     } 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.`);
+      }
     } else if (msg.type === "agent_permission" && msg.tool && msg.action === "revoke") {
       removePermission(msg.tool);
       broadcastPermissions();
@@ -535,7 +552,18 @@ if (adapter) {
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(false);
     }
-    setTimeout(() => process.exit(exitCode), 200);
+    // Wait for WS to connect and flush buffer before exiting
+    // (fast commands like `ls` may finish before the WS handshake)
+    function tryExit() {
+      if (wsReady && sendBuffer.length === 0) {
+        setTimeout(() => process.exit(exitCode), 100);
+      } else {
+        setTimeout(tryExit, 50);
+      }
+    }
+    // Give up after 3 seconds regardless
+    setTimeout(() => process.exit(exitCode), 3000);
+    tryExit();
   });
 
   child.on("error", (err) => {
@@ -770,8 +798,6 @@ 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,
@@ -816,8 +842,7 @@ function connectWs() {
     } catch {}
   });
 
-  ws.on("close", (code, reason) => {
-    process.stderr.write(`${DIM}[orch] WS closed: code=${code} reason=${reason}${RESET}\n`);
+  ws.on("close", () => {
     wsReady = false;
     ws = null;
     if (!authFailed) {
@@ -825,8 +850,8 @@ function connectWs() {
     }
   });
 
-  ws.on("error", (err) => {
-    process.stderr.write(`${DIM}[orch] WS error: ${err.message}${RESET}\n`);
+  ws.on("error", () => {
+    // Will trigger close
   });
 }
 

package/package.json

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