wave-code 1.0.8 → 1.0.10

package/bin/wave-code.js

@@ -1,5 +1,26 @@
 #!/usr/bin/env node
 
+import { readFileSync, writeSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// `wave -v` / `wave --version` must be fast: editors probe the installed CLI
+// version on every launch (e.g. the desktop app's auto-update check). Loading
+// the full app graph (wave-agent-sdk, ink, highlight.js, ...) just to print
+// the version takes 2-3s+ on a warm machine and can exceed callers' probe
+// timeouts on cold starts (AV scan of freshly installed files), which they
+// misread as "CLI missing/corrupt" → spurious re-installs. Print the version
+// straight from package.json and exit before touching the app graph.
+const versionArgs = ["-v", "--version"];
+if (process.argv.slice(2).some((a) => versionArgs.includes(a))) {
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const packageJson = JSON.parse(
+    readFileSync(path.resolve(__dirname, "../package.json"), "utf-8"),
+  );
+  writeSync(1, `${packageJson.version}\n`);
+  process.exit(0);
+}
+
 // Import and start the CLI
 import("../dist/index.js")
   .then(async ({ main }) => {

package/dist/contexts/useChat.js

@@ -14,6 +14,21 @@ export const useChat = () => {
     }
     return context;
 };
+/**
+ * Snapshot a SDK message for consumer state. The SDK mutates its internal
+ * message blocks in-place BEFORE firing the delta callback (it writes the full
+ * accumulated value to the shared block, then computes the chunk delta by
+ * slicing the new value). A consumer that pushed the SDK message object by
+ * live reference would read the already-updated block and append the delta
+ * again — the first delta is double-counted ("LetLet me think..."), affecting
+ * reasoning and text content alike. See docs/specs/core/stream-content-updates.md.
+ * The clone must be at least one layer deep (message + blocks) so the in-place
+ * block mutation never leaks into consumer state.
+ */
+const snapshotMessage = (message) => ({
+    ...message,
+    blocks: message.blocks.map((block) => ({ ...block })),
+});
 /**
  * Window-concat throttle for pure-delta streaming updates: chunks arriving
  * within the cooldown window are merged so no delta is lost (a dropped delta
@@ -322,7 +337,7 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     // the incremental callbacks in initializeAgent below.
     const refreshMessages = useCallback(() => {
         if (!isExpandedRef.current && agentRef.current) {
-            const msgs = [...agentRef.current.messages];
+            const msgs = agentRef.current.messages.map(snapshotMessage);
             setMessages(msgs);
             setLatestTotalTokens(extractLatestTotalTokens(msgs));
         }
@@ -357,7 +372,9 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 const last = msgs[msgs.length - 1];
                 if (!last || last.role !== "user")
                     return;
-                setMessages((prev) => prev.some((m) => m.id === last.id) ? prev : [...prev, last]);
+                setMessages((prev) => prev.some((m) => m.id === last.id)
+                    ? prev
+                    : [...prev, snapshotMessage(last)]);
             },
             onAssistantMessageAdded: (messageId) => {
                 if (isExpandedRef.current || !agentRef.current)
@@ -365,7 +382,9 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 const msg = agentRef.current.messages.find((m) => m.id === messageId);
                 if (!msg)
                     return;
-                setMessages((prev) => prev.some((m) => m.id === messageId) ? prev : [...prev, msg]);
+                setMessages((prev) => prev.some((m) => m.id === messageId)
+                    ? prev
+                    : [...prev, snapshotMessage(msg)]);
             },
             onAssistantContentUpdated: (params) => {
                 if (isExpandedRef.current)
@@ -388,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,
@@ -562,9 +582,10 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 };
                 agent.setWorktreeSession(session);
             }
-            // Get initial state
+            // Get initial state — snapshot the SDK messages (never hold live
+            // references; see snapshotMessage)
             setSessionId(agent.sessionId);
-            setMessages(agent.messages);
+            setMessages(agent.messages.map(snapshotMessage));
             setIsLoading(agent.isLoading);
             setLatestTotalTokens(extractLatestTotalTokens(agent.messages));
             setIsCommandRunning(agent.isCommandRunning);

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.8",
+  "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.8"
+    "wave-agent-sdk": "1.0.10"
   },
   "devDependencies": {
     "@types/react": "^19.1.8",

package/src/contexts/useChat.tsx

@@ -168,6 +168,22 @@ interface StreamingUpdateParams {
   stage: "streaming" | "end";
 }
 
+/**
+ * Snapshot a SDK message for consumer state. The SDK mutates its internal
+ * message blocks in-place BEFORE firing the delta callback (it writes the full
+ * accumulated value to the shared block, then computes the chunk delta by
+ * slicing the new value). A consumer that pushed the SDK message object by
+ * live reference would read the already-updated block and append the delta
+ * again — the first delta is double-counted ("LetLet me think..."), affecting
+ * reasoning and text content alike. See docs/specs/core/stream-content-updates.md.
+ * The clone must be at least one layer deep (message + blocks) so the in-place
+ * block mutation never leaks into consumer state.
+ */
+const snapshotMessage = (message: Message): Message => ({
+  ...message,
+  blocks: message.blocks.map((block) => ({ ...block })),
+});
+
 /**
  * Window-concat throttle for pure-delta streaming updates: chunks arriving
  * within the cooldown window are merged so no delta is lost (a dropped delta
@@ -605,7 +621,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // the incremental callbacks in initializeAgent below.
   const refreshMessages = useCallback(() => {
     if (!isExpandedRef.current && agentRef.current) {
-      const msgs = [...agentRef.current.messages];
+      const msgs = agentRef.current.messages.map(snapshotMessage);
       setMessages(msgs);
       setLatestTotalTokens(extractLatestTotalTokens(msgs));
     }
@@ -656,7 +672,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           const last = msgs[msgs.length - 1];
           if (!last || last.role !== "user") return;
           setMessages((prev) =>
-            prev.some((m) => m.id === last.id) ? prev : [...prev, last],
+            prev.some((m) => m.id === last.id)
+              ? prev
+              : [...prev, snapshotMessage(last)],
           );
         },
         onAssistantMessageAdded: (messageId: string) => {
@@ -664,7 +682,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           const msg = agentRef.current.messages.find((m) => m.id === messageId);
           if (!msg) return;
           setMessages((prev) =>
-            prev.some((m) => m.id === messageId) ? prev : [...prev, msg],
+            prev.some((m) => m.id === messageId)
+              ? prev
+              : [...prev, snapshotMessage(msg)],
           );
         },
         onAssistantContentUpdated: (params) => {
@@ -683,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,
@@ -889,9 +910,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           agent.setWorktreeSession(session);
         }
 
-        // Get initial state
+        // Get initial state — snapshot the SDK messages (never hold live
+        // references; see snapshotMessage)
         setSessionId(agent.sessionId);
-        setMessages(agent.messages);
+        setMessages(agent.messages.map(snapshotMessage));
         setIsLoading(agent.isLoading);
         setLatestTotalTokens(extractLatestTotalTokens(agent.messages));
         setIsCommandRunning(agent.isCommandRunning);

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);
   }