wave-code 0.19.9 → 1.0.1

package/dist/contexts/useChat.js

@@ -22,27 +22,104 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     const [isExpanded, setIsExpanded] = useState(false);
     const isExpandedRef = useRef(isExpanded);
     const [isTaskListVisible, setIsTaskListVisible] = useState(true);
+    const [isBtwActive, setIsBtwActive] = useState(false);
     const [messages, setMessages] = useState([]);
     const [latestTotalTokens, setLatestTotalTokens] = useState(0);
     const [maxInputTokens, setMaxInputTokens] = useState(200000);
-    const throttledSetMessages = useMemo(() => throttle(() => {
-        if (!isExpandedRef.current && agentRef.current) {
-            const msgs = [...agentRef.current.messages];
-            setMessages(msgs);
-            setLatestTotalTokens(extractLatestTotalTokens(msgs));
-        }
-    }, 500, { leading: true, trailing: true }), []);
+    // Throttled incremental streaming updaters — 500ms leading+trailing, the same interval
+    // as the pre-incremental throttledSetMessages. `stage === "end"` flushes the final
+    // update immediately so completion results are never delayed.
+    const throttledContentUpdate = useMemo(() => throttle((params) => {
+        const { messageId, accumulated, stage } = params;
+        setMessages((prev) => prev.map((m) => {
+            if (m.id !== messageId)
+                return m;
+            const textBlockIndex = m.blocks.findIndex((b) => b.type === "text");
+            if (textBlockIndex === -1) {
+                return {
+                    ...m,
+                    blocks: [
+                        ...m.blocks,
+                        { type: "text", content: accumulated, stage },
+                    ],
+                };
+            }
+            return {
+                ...m,
+                blocks: m.blocks.map((b, idx) => idx === textBlockIndex && b.type === "text"
+                    ? { ...b, content: accumulated, stage }
+                    : b),
+            };
+        }));
+    }, 500), []);
+    const throttledReasoningUpdate = useMemo(() => throttle((params) => {
+        const { messageId, accumulated, stage } = params;
+        setMessages((prev) => prev.map((m) => {
+            if (m.id !== messageId)
+                return m;
+            const reasoningBlockIndex = m.blocks.findIndex((b) => b.type === "reasoning");
+            if (reasoningBlockIndex === -1) {
+                return {
+                    ...m,
+                    blocks: [
+                        ...m.blocks,
+                        { type: "reasoning", content: accumulated, stage },
+                    ],
+                };
+            }
+            return {
+                ...m,
+                blocks: m.blocks.map((b, idx) => idx === reasoningBlockIndex && b.type === "reasoning"
+                    ? { ...b, content: accumulated, stage }
+                    : b),
+            };
+        }));
+    }, 500), []);
+    const throttledToolBlockUpdate = useMemo(() => throttle((params) => {
+        const { messageId, id: toolBlockId, ...updates } = params;
+        setMessages((prev) => prev.map((m) => {
+            if (m.id !== messageId)
+                return m;
+            const toolBlockIndex = m.blocks.findIndex((b) => b.type === "tool" && b.id === toolBlockId);
+            if (toolBlockIndex === -1) {
+                return {
+                    ...m,
+                    blocks: [
+                        ...m.blocks,
+                        {
+                            type: "tool",
+                            id: toolBlockId,
+                            name: updates.name || "",
+                            stage: updates.stage || "start",
+                            parameters: updates.parameters || "",
+                            result: updates.result || "",
+                            ...updates,
+                        },
+                    ],
+                };
+            }
+            return {
+                ...m,
+                blocks: m.blocks.map((b, idx) => idx === toolBlockIndex && b.type === "tool"
+                    ? { ...b, ...updates }
+                    : b),
+            };
+        }));
+    }, 500), []);
     useEffect(() => {
         isExpandedRef.current = isExpanded;
         if (isExpanded) {
-            throttledSetMessages.cancel();
+            // Cancel pending throttled updates so the frozen expanded view isn't overwritten
+            throttledContentUpdate.cancel();
+            throttledReasoningUpdate.cancel();
+            throttledToolBlockUpdate.cancel();
         }
-    }, [isExpanded, throttledSetMessages]);
-    useEffect(() => {
-        return () => {
-            throttledSetMessages.cancel();
-        };
-    }, [throttledSetMessages]);
+    }, [
+        isExpanded,
+        throttledContentUpdate,
+        throttledReasoningUpdate,
+        throttledToolBlockUpdate,
+    ]);
     const [isLoading, setIsLoading] = useState(false);
     const [sessionId, setSessionId] = useState("");
     const [isCommandRunning, setIsCommandRunning] = useState(false);
@@ -50,29 +127,6 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     const [currentModel, setCurrentModelState] = useState("");
     const [configuredModels, setConfiguredModels] = useState([]);
     const [queuedMessages, setQueuedMessages] = useState([]);
-    const [isGoalActive, setIsGoalActive] = useState(false);
-    const [goalElapsed, setGoalElapsed] = useState();
-    const [isGoalEvaluating, setIsGoalEvaluating] = useState(false);
-    const goalStartedAt = useRef(null);
-    // Update goal elapsed time every 30s while active
-    useEffect(() => {
-        if (!isGoalActive || goalStartedAt.current === null)
-            return;
-        const formatElapsed = (ms) => {
-            const minutes = Math.floor(ms / 60000);
-            if (minutes < 1)
-                return "<1m";
-            if (minutes < 60)
-                return `${minutes}m`;
-            const hours = Math.floor(minutes / 60);
-            const remainingMin = minutes % 60;
-            return `${hours}h${remainingMin}m`;
-        };
-        const update = () => setGoalElapsed(formatElapsed(Date.now() - goalStartedAt.current));
-        update();
-        const timer = setInterval(update, 30000);
-        return () => clearInterval(timer);
-    }, [isGoalActive]);
     // MCP State
     const [mcpServerStatuses, setMcpServerStatuses] = useState([]);
     // Background tasks state
@@ -119,6 +173,16 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     // Status metadata state
     const [workingDirectory, setWorkingDirectory] = useState("");
     const agentRef = useRef(null);
+    // Full-list refresh — one-shot pull from the agent, used only for structural
+    // changes (compact/clear/rewind/collapse/init). Streaming updates flow through
+    // the incremental callbacks in initializeAgent below.
+    const refreshMessages = useCallback(() => {
+        if (!isExpandedRef.current && agentRef.current) {
+            const msgs = [...agentRef.current.messages];
+            setMessages(msgs);
+            setLatestTotalTokens(extractLatestTotalTokens(msgs));
+        }
+    }, []);
     // Permission confirmation methods with queue support
     const showConfirmation = useCallback(async (toolName, toolInput, suggestedPrefix, hidePersistentOption, planContent) => {
         return new Promise((resolve, reject) => {
@@ -139,8 +203,123 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     const initializeAgent = useCallback(async (restoreSessionIdOverride) => {
         const effectiveRestoreSessionId = restoreSessionIdOverride ?? restoreSessionId;
         const callbacks = {
-            onMessagesChange: () => {
-                throttledSetMessages();
+            // ── Incremental message updates (no full-list pushes) ──────
+            onUserMessageAdded: () => {
+                if (isExpandedRef.current || !agentRef.current)
+                    return;
+                const msgs = agentRef.current.messages;
+                const last = msgs[msgs.length - 1];
+                if (!last || last.role !== "user")
+                    return;
+                setMessages((prev) => prev.some((m) => m.id === last.id) ? prev : [...prev, last]);
+            },
+            onAssistantMessageAdded: (messageId) => {
+                if (isExpandedRef.current || !agentRef.current)
+                    return;
+                const msg = agentRef.current.messages.find((m) => m.id === messageId);
+                if (!msg)
+                    return;
+                setMessages((prev) => prev.some((m) => m.id === messageId) ? prev : [...prev, msg]);
+            },
+            onAssistantContentUpdated: (params) => {
+                if (isExpandedRef.current)
+                    return;
+                throttledContentUpdate(params);
+                if (params.stage === "end")
+                    throttledContentUpdate.flush();
+            },
+            onAssistantReasoningUpdated: (params) => {
+                if (isExpandedRef.current)
+                    return;
+                throttledReasoningUpdate(params);
+                if (params.stage === "end")
+                    throttledReasoningUpdate.flush();
+            },
+            onToolBlockUpdated: (params) => {
+                if (isExpandedRef.current)
+                    return;
+                throttledToolBlockUpdate(params);
+                if (params.stage === "end")
+                    throttledToolBlockUpdate.flush();
+            },
+            onErrorBlockAdded: (error) => {
+                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);
+                        }
+                    }
+                    return [
+                        ...prev,
+                        {
+                            id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`,
+                            role: "assistant",
+                            timestamp: new Date().toISOString(),
+                            blocks: [{ type: "error", content: error }],
+                        },
+                    ];
+                });
+            },
+            onAddBangMessage: (command, messageId) => {
+                if (isExpandedRef.current)
+                    return;
+                setMessages((prev) => prev.some((m) => m.id === messageId)
+                    ? prev
+                    : [
+                        ...prev,
+                        {
+                            id: messageId,
+                            role: "user",
+                            timestamp: new Date().toISOString(),
+                            blocks: [
+                                {
+                                    type: "bang",
+                                    command,
+                                    output: "",
+                                    stage: "running",
+                                    exitCode: null,
+                                },
+                            ],
+                        },
+                    ]);
+            },
+            onUpdateBangMessage: (command, output, messageId) => {
+                if (isExpandedRef.current)
+                    return;
+                setMessages((prev) => prev.map((m) => m.id === messageId
+                    ? {
+                        ...m,
+                        blocks: m.blocks.map((b, idx) => idx === m.blocks.length - 1 && b.type === "bang"
+                            ? { ...b, command, output }
+                            : b),
+                    }
+                    : m));
+            },
+            onCompleteBangMessage: (command, exitCode, messageId) => {
+                if (isExpandedRef.current)
+                    return;
+                setMessages((prev) => prev.map((m) => m.id === messageId
+                    ? {
+                        ...m,
+                        blocks: m.blocks.map((b, idx) => idx === m.blocks.length - 1 && b.type === "bang"
+                            ? { ...b, command, exitCode, stage: "end" }
+                            : b),
+                    }
+                    : m));
+            },
+            onLatestTotalTokensChange: (tokens) => {
+                setLatestTotalTokens(tokens);
             },
             onMcpServersChange: (servers) => {
                 setMcpServerStatuses([...servers]);
@@ -185,19 +364,6 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             onQueuedMessagesChange: (messages) => {
                 setQueuedMessages([...messages]);
             },
-            onGoalStateChange: (active, _condition, elapsed) => {
-                setIsGoalActive(active);
-                if (active) {
-                    goalStartedAt.current = Date.now();
-                }
-                else {
-                    goalStartedAt.current = null;
-                }
-                setGoalElapsed(elapsed);
-            },
-            onGoalEvaluating: (evaluating) => {
-                setIsGoalEvaluating(evaluating);
-            },
         };
         try {
             // Create the permission callback inside the try block to access showConfirmation
@@ -283,7 +449,10 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         originalCwd,
         model,
         initialPermissionMode,
-        throttledSetMessages,
+        refreshMessages,
+        throttledContentUpdate,
+        throttledReasoningUpdate,
+        throttledToolBlockUpdate,
         mcpServers,
     ]);
     // Recreate agent (e.g. after plugin install) — destroys current agent and reinitializes
@@ -318,6 +487,9 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
     // Cleanup on unmount
     useEffect(() => {
         return () => {
+            throttledContentUpdate.cancel();
+            throttledReasoningUpdate.cancel();
+            throttledToolBlockUpdate.cancel();
             if (agentRef.current) {
                 try {
                     // Display usage summary before cleanup
@@ -331,7 +503,11 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
                 agentRef.current.destroy();
             }
         };
-    }, []);
+    }, [
+        throttledContentUpdate,
+        throttledReasoningUpdate,
+        throttledToolBlockUpdate,
+    ]);
     // Trigger WorktreeRemove hook BEFORE agent destruction
     const triggerWorktreeRemoveHook = useCallback(async (worktreePath) => {
         await agentRef.current?.triggerWorktreeRemoveHook(worktreePath);
@@ -368,30 +544,20 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             console.error("Failed to send message:", error);
         }
     }, []);
-    const askBtw = useCallback(async (question) => {
+    const askBtw = useCallback(async (question, abortSignal, onContent) => {
         if (!agentRef.current) {
             throw new Error("Agent not initialized");
         }
-        return await agentRef.current.askBtw(question);
+        return await agentRef.current.askBtw(question, abortSignal, onContent);
     }, []);
     const clearMessages = useCallback(async () => {
         await agentRef.current?.clearMessages();
-    }, []);
+        refreshMessages();
+    }, [refreshMessages]);
     const compact = useCallback(async (instructions) => {
         await agentRef.current?.compact(instructions);
-    }, []);
-    const goalCommand = useCallback(async (args) => {
-        const trimmed = args?.trim() ?? "";
-        if (!trimmed) {
-            await agentRef.current?.showGoalStatus();
-        }
-        else if (["clear", "stop", "off", "reset", "none", "cancel"].includes(trimmed)) {
-            await agentRef.current?.clearGoal();
-        }
-        else {
-            await agentRef.current?.setGoal(trimmed);
-        }
-    }, []);
+        refreshMessages();
+    }, [refreshMessages]);
     // Unified interrupt method, interrupt both AI messages and command execution
     const abortMessage = useCallback(() => {
         agentRef.current?.abortMessage();
@@ -484,13 +650,14 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         if (agentRef.current) {
             try {
                 await agentRef.current.truncateHistory(index);
+                refreshMessages();
                 requestRemount();
             }
             catch (error) {
                 logger.error("Failed to rewind:", error);
             }
         }
-    }, [requestRemount]);
+    }, [requestRemount, refreshMessages]);
     const getFullMessageThread = useCallback(async () => {
         if (agentRef.current) {
             return await agentRef.current.getFullMessageThread();
@@ -530,16 +697,11 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
             isExpandedRef.current = nextExpanded;
             if (nextExpanded) {
                 // Transitioning to EXPANDED: Freeze the current view
-                // Cancel any pending throttled updates to avoid overwriting the frozen state
-                throttledSetMessages.cancel();
+                // Incremental updates are skipped while expanded (isExpandedRef guard)
             }
             else {
                 // Transitioning to COLLAPSED: Restore from agent's actual state
-                if (agentRef.current) {
-                    const msgs = [...agentRef.current.messages];
-                    setMessages(msgs);
-                    setLatestTotalTokens(extractLatestTotalTokens(msgs));
-                }
+                refreshMessages();
             }
             // Force remount directly (bypass throttle) to ensure Static items re-render
             // The throttled requestRemount can be dropped if pressed too quickly after
@@ -563,13 +725,14 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         isExpanded,
         isTaskListVisible,
         setIsTaskListVisible,
+        isBtwActive,
+        setIsBtwActive,
         queuedMessages,
         sessionId,
         sendMessage,
         askBtw,
         clearMessages,
         compact,
-        goalCommand,
         abortMessage,
         recallQueuedMessage,
         removeQueuedMessageById,
@@ -612,9 +775,6 @@ export const ChatProvider = ({ children, bypassPermissions, permissionMode: init
         workdir,
         recreateAgent,
         triggerWorktreeRemoveHook,
-        isGoalActive,
-        goalElapsed,
-        isGoalEvaluating,
     };
     return (_jsx(ChatContext.Provider, { value: contextValue, children: children }));
 };

package/dist/daemon-cli.d.ts

@@ -0,0 +1,10 @@
+/**
+ * daemon-cli.ts — Entry point for `wave --daemon <socket-path>` mode.
+ *
+ * Starts a DaemonServer that serves JSON-RPC over a unix socket. The desktop
+ * app launches this on a remote host via nohup/setsid and tunnels the socket
+ * back with `ssh -L`; multiple attach/detach cycles share one process, so
+ * sessions and pending permissions survive client disconnects. The net server
+ * keeps the process alive — there is no stdin to wait on.
+ */
+export declare function startDaemonCli(socketPath: string): Promise<void>;

package/dist/daemon-cli.js

@@ -0,0 +1,15 @@
+/**
+ * daemon-cli.ts — Entry point for `wave --daemon <socket-path>` mode.
+ *
+ * Starts a DaemonServer that serves JSON-RPC over a unix socket. The desktop
+ * app launches this on a remote host via nohup/setsid and tunnels the socket
+ * back with `ssh -L`; multiple attach/detach cycles share one process, so
+ * sessions and pending permissions survive client disconnects. The net server
+ * keeps the process alive — there is no stdin to wait on.
+ */
+import { DaemonServer } from "./stdio/daemonServer.js";
+export async function startDaemonCli(socketPath) {
+    const server = new DaemonServer({ socketPath });
+    await server.start();
+    // Ready — any error that follows goes to the daemon log via stderr.
+}

package/dist/hooks/useInputManager.d.ts

@@ -26,6 +26,7 @@ export declare const useInputManager: (callbacks?: Partial<InputManagerCallbacks
     permissionMode: PermissionMode;
     attachedImages: import("../managers/inputReducer.js").AttachedImage[];
     btwState: import("../managers/inputReducer.js").BtwState;
+    escClearPending: boolean;
     isManagerReady: boolean;
     insertTextAtCursor: (text: string) => void;
     deleteCharAtCursor: () => void;