wave-code 1.0.9 → 1.0.10

package/dist/contexts/useChat.js

@@ -407,19 +407,20 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 if (isExpandedRef.current)
                     return;
                 setMessages((prev) => {
-                    // Append to the last assistant message, or create one if none exists
-                    for (let i = prev.length - 1; i >= 0; i--) {
-                        if (prev[i].role === "assistant") {
-                            return prev.map((m, idx) => idx === i
-                                ? {
-                                    ...m,
-                                    blocks: [
-                                        ...m.blocks,
-                                        { type: "error", content: error },
-                                    ],
-                                }
-                                : m);
-                        }
+                    // Append to the LAST message only if it is an assistant message
+                    // (the current turn's in-flight reply). If the last message is a
+                    // user message, the error belongs BELOW it — create a new
+                    // assistant message instead of polluting the stale assistant from
+                    // an earlier turn (which surfaced the error above the latest
+                    // user message and accumulated it there).
+                    const last = prev[prev.length - 1];
+                    if (last && last.role === "assistant") {
+                        return prev.map((m, idx) => idx === prev.length - 1
+                            ? {
+                                ...m,
+                                blocks: [...m.blocks, { type: "error", content: error }],
+                            }
+                            : m);
                     }
                     return [
                         ...prev,

package/dist/stdio/jsonRpcConnection.d.ts

@@ -9,13 +9,22 @@
  */
 import type { Readable, Writable } from "stream";
 import { AgentBridge } from "./agentBridge.js";
+export interface JsonRpcConnectionOptions {
+    /** Called when the input stream reaches EOF (parent closed the pipe). Only
+     * stdio mode passes it — it must exit the process when its client dies;
+     * daemon mode never passes it (a detached client must not kill the daemon,
+     * see daemonServer.ts). */
+    onClose?: () => void;
+}
 export declare class JsonRpcConnection {
     private input;
     private output;
     private bridge;
     private rl;
     private started;
-    constructor(input: Readable, output: Writable, bridge: AgentBridge);
+    private stoppedByOwner;
+    private onClose?;
+    constructor(input: Readable, output: Writable, bridge: AgentBridge, options?: JsonRpcConnectionOptions);
     start(): void;
     stop(): void;
     handleLine(line: string): Promise<void>;

package/dist/stdio/jsonRpcConnection.js

@@ -10,11 +10,13 @@
 import readline from "readline";
 import { PARSE_ERROR, INVALID_REQUEST, INTERNAL_ERROR, isRequest, isNotification, } from "./protocol.js";
 export class JsonRpcConnection {
-    constructor(input, output, bridge) {
+    constructor(input, output, bridge, options = {}) {
         this.input = input;
         this.output = output;
         this.bridge = bridge;
         this.started = false;
+        this.stoppedByOwner = false;
+        this.onClose = options.onClose;
     }
     start() {
         if (this.started)
@@ -39,9 +41,15 @@ export class JsonRpcConnection {
         });
         this.rl.on("close", () => {
             this.started = false;
+            // stdin EOF from the owning client — not a deliberate stop(). stdio
+            // mode reacts by exiting the process (its parent is gone); daemon mode
+            // has no onClose so a detached client reset never kills the daemon.
+            if (!this.stoppedByOwner)
+                this.onClose?.();
         });
     }
     stop() {
+        this.stoppedByOwner = true;
         this.rl?.close();
         this.rl = undefined;
         this.started = false;

package/dist/stdio/stdioServer.d.ts

@@ -19,6 +19,14 @@ export declare class StdioServer {
     get agentBridge(): AgentBridge;
     start(): void;
     stop(): void;
+    /**
+     * The owning client closed stdin (EOF) — it's gone, so this process must
+     * follow it. destroyAll() saves each session's transcript and drains
+     * auto-memory first; a timeout bounds it so a stuck agent can't orphan the
+     * exit. This is the real-world "parent died" path: without it the process
+     * lingers forever whenever an agent keeps event-loop handles alive.
+     */
+    private onConnectionClosed;
     handleLine(line: string): Promise<void>;
     sendResponse(id: number | string | null, result?: unknown, error?: {
         code: number;

package/dist/stdio/stdioServer.js

@@ -13,7 +13,7 @@ export class StdioServer {
             ...options.bridgeOptions,
             emit: (method, params, sessionId) => this.sendNotification(method, params, sessionId),
         });
-        this.conn = new JsonRpcConnection(options.input ?? process.stdin, options.output ?? process.stdout, this.bridge);
+        this.conn = new JsonRpcConnection(options.input ?? process.stdin, options.output ?? process.stdout, this.bridge, { onClose: () => this.onConnectionClosed() });
     }
     get agentBridge() {
         return this.bridge;
@@ -24,6 +24,21 @@ export class StdioServer {
     stop() {
         this.conn.stop();
     }
+    /**
+     * The owning client closed stdin (EOF) — it's gone, so this process must
+     * follow it. destroyAll() saves each session's transcript and drains
+     * auto-memory first; a timeout bounds it so a stuck agent can't orphan the
+     * exit. This is the real-world "parent died" path: without it the process
+     * lingers forever whenever an agent keeps event-loop handles alive.
+     */
+    async onConnectionClosed() {
+        const SHUTDOWN_TIMEOUT_MS = 5000;
+        await Promise.race([
+            this.bridge.destroyAll(),
+            new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),
+        ]);
+        process.exit(0);
+    }
     handleLine(line) {
         return this.conn.handleLine(line);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-code",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "CLI-based code assistant powered by AI, built with React and Ink",
   "repository": {
     "type": "git",
@@ -43,7 +43,7 @@
     "wrap-ansi": "^10.0.0",
     "yargs": "^17.7.2",
     "zod": "^3.23.8",
-    "wave-agent-sdk": "1.0.9"
+    "wave-agent-sdk": "1.0.10"
   },
   "devDependencies": {
     "@types/react": "^19.1.8",

package/src/contexts/useChat.tsx

@@ -703,21 +703,22 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         onErrorBlockAdded: (error: string) => {
           if (isExpandedRef.current) return;
           setMessages((prev) => {
-            // Append to the last assistant message, or create one if none exists
-            for (let i = prev.length - 1; i >= 0; i--) {
-              if (prev[i].role === "assistant") {
-                return prev.map((m, idx) =>
-                  idx === i
-                    ? {
-                        ...m,
-                        blocks: [
-                          ...m.blocks,
-                          { type: "error", content: error },
-                        ],
-                      }
-                    : m,
-                );
-              }
+            // Append to the LAST message only if it is an assistant message
+            // (the current turn's in-flight reply). If the last message is a
+            // user message, the error belongs BELOW it — create a new
+            // assistant message instead of polluting the stale assistant from
+            // an earlier turn (which surfaced the error above the latest
+            // user message and accumulated it there).
+            const last = prev[prev.length - 1];
+            if (last && last.role === "assistant") {
+              return prev.map((m, idx) =>
+                idx === prev.length - 1
+                  ? {
+                      ...m,
+                      blocks: [...m.blocks, { type: "error", content: error }],
+                    }
+                  : m,
+              );
             }
             return [
               ...prev,

package/src/stdio/jsonRpcConnection.ts

@@ -22,15 +22,28 @@ import {
   isNotification,
 } from "./protocol.js";
 
+export interface JsonRpcConnectionOptions {
+  /** Called when the input stream reaches EOF (parent closed the pipe). Only
+   * stdio mode passes it — it must exit the process when its client dies;
+   * daemon mode never passes it (a detached client must not kill the daemon,
+   * see daemonServer.ts). */
+  onClose?: () => void;
+}
+
 export class JsonRpcConnection {
   private rl: readline.Interface | undefined;
   private started = false;
+  private stoppedByOwner = false;
+  private onClose?: () => void;
 
   constructor(
     private input: Readable,
     private output: Writable,
     private bridge: AgentBridge,
-  ) {}
+    options: JsonRpcConnectionOptions = {},
+  ) {
+    this.onClose = options.onClose;
+  }
 
   start(): void {
     if (this.started) return;
@@ -58,10 +71,15 @@ export class JsonRpcConnection {
 
     this.rl.on("close", () => {
       this.started = false;
+      // stdin EOF from the owning client — not a deliberate stop(). stdio
+      // mode reacts by exiting the process (its parent is gone); daemon mode
+      // has no onClose so a detached client reset never kills the daemon.
+      if (!this.stoppedByOwner) this.onClose?.();
     });
   }
 
   stop(): void {
+    this.stoppedByOwner = true;
     this.rl?.close();
     this.rl = undefined;
     this.started = false;

package/src/stdio/stdioServer.ts

@@ -30,6 +30,7 @@ export class StdioServer {
       options.input ?? process.stdin,
       options.output ?? process.stdout,
       this.bridge,
+      { onClose: () => this.onConnectionClosed() },
     );
   }
 
@@ -45,6 +46,22 @@ export class StdioServer {
     this.conn.stop();
   }
 
+  /**
+   * The owning client closed stdin (EOF) — it's gone, so this process must
+   * follow it. destroyAll() saves each session's transcript and drains
+   * auto-memory first; a timeout bounds it so a stuck agent can't orphan the
+   * exit. This is the real-world "parent died" path: without it the process
+   * lingers forever whenever an agent keeps event-loop handles alive.
+   */
+  private async onConnectionClosed(): Promise<void> {
+    const SHUTDOWN_TIMEOUT_MS = 5_000;
+    await Promise.race([
+      this.bridge.destroyAll(),
+      new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),
+    ]);
+    process.exit(0);
+  }
+
   handleLine(line: string): Promise<void> {
     return this.conn.handleLine(line);
   }