wave-code 1.0.0 → 1.0.1

package/src/contexts/useChat.tsx

@@ -19,6 +19,7 @@ import type {
   PermissionMode,
   QueuedMessage,
   WorkflowRun,
+  ToolBlockUpdateCallbackParams,
 } from "wave-agent-sdk";
 import {
   Agent,
@@ -45,6 +46,9 @@ export interface ChatContextType {
   isExpanded: boolean;
   isTaskListVisible: boolean;
   setIsTaskListVisible: (visible: boolean) => void;
+  // True while the /btw side-question overlay is on display
+  isBtwActive: boolean;
+  setIsBtwActive: (active: boolean) => void;
   queuedMessages: QueuedMessage[];
   // AI functionality
   sessionId: string;
@@ -53,10 +57,13 @@ export interface ChatContextType {
     images?: Array<{ path: string; mimeType: string }>,
     longTextMap?: Record<string, string>,
   ) => Promise<void>;
-  askBtw: (question: string) => Promise<string>;
+  askBtw: (
+    question: string,
+    abortSignal?: AbortSignal,
+    onContent?: (content: string) => void,
+  ) => Promise<string>;
   clearMessages: () => Promise<void>;
   compact: (instructions?: string) => Promise<void>;
-  goalCommand: (args?: string) => Promise<void>;
   abortMessage: () => void;
   recallQueuedMessage: () => QueuedMessage | null;
   removeQueuedMessageById: (id: string) => boolean;
@@ -132,10 +139,6 @@ export interface ChatContextType {
   recreateAgent: () => void;
   // Trigger WorktreeRemove hook BEFORE agent destruction
   triggerWorktreeRemoveHook: (worktreePath: string) => Promise<void>;
-  // Goal state
-  isGoalActive: boolean;
-  goalElapsed?: string;
-  isGoalEvaluating: boolean;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -175,39 +178,150 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const isExpandedRef = useRef(isExpanded);
 
   const [isTaskListVisible, setIsTaskListVisible] = useState(true);
+  const [isBtwActive, setIsBtwActive] = useState(false);
 
   const [messages, setMessages] = useState<Message[]>([]);
   const [latestTotalTokens, setLatestTotalTokens] = useState(0);
   const [maxInputTokens, setMaxInputTokens] = useState(200000);
 
-  const throttledSetMessages = useMemo(
+  // 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(
-        () => {
-          if (!isExpandedRef.current && agentRef.current) {
-            const msgs = [...agentRef.current.messages];
-            setMessages(msgs);
-            setLatestTotalTokens(extractLatestTotalTokens(msgs));
-          }
+        (params: {
+          messageId: string;
+          accumulated: string;
+          stage: "streaming" | "end";
+        }) => {
+          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: {
+          messageId: string;
+          accumulated: string;
+          stage: "streaming" | "end";
+        }) => {
+          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,
-        { leading: true, trailing: true },
       ),
     [],
   );
 
+  const throttledToolBlockUpdate = useMemo(
+    () =>
+      throttle((params: ToolBlockUpdateCallbackParams) => {
+        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("");
@@ -216,28 +330,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [currentModel, setCurrentModelState] = useState("");
   const [configuredModels, setConfiguredModels] = useState<string[]>([]);
   const [queuedMessages, setQueuedMessages] = useState<QueuedMessage[]>([]);
-  const [isGoalActive, setIsGoalActive] = useState(false);
-  const [goalElapsed, setGoalElapsed] = useState<string | undefined>();
-  const [isGoalEvaluating, setIsGoalEvaluating] = useState(false);
-  const goalStartedAt = useRef<number | null>(null);
-
-  // Update goal elapsed time every 30s while active
-  useEffect(() => {
-    if (!isGoalActive || goalStartedAt.current === null) return;
-    const formatElapsed = (ms: number): string => {
-      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, 30_000);
-    return () => clearInterval(timer);
-  }, [isGoalActive]);
 
   // MCP State
   const [mcpServerStatuses, setMcpServerStatuses] = useState<McpServerStatus[]>(
@@ -337,6 +429,17 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   const agentRef = useRef<Agent | null>(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 (
@@ -371,8 +474,129 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         restoreSessionIdOverride ?? restoreSessionId;
 
       const callbacks: AgentCallbacks = {
-        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: string) => {
+          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: 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,
+                );
+              }
+            }
+            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]);
@@ -421,18 +645,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         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 {
@@ -533,7 +745,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       originalCwd,
       model,
       initialPermissionMode,
-      throttledSetMessages,
+      refreshMessages,
+      throttledContentUpdate,
+      throttledReasoningUpdate,
+      throttledToolBlockUpdate,
       mcpServers,
     ],
   );
@@ -571,6 +786,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Cleanup on unmount
   useEffect(() => {
     return () => {
+      throttledContentUpdate.cancel();
+      throttledReasoningUpdate.cancel();
+      throttledToolBlockUpdate.cancel();
       if (agentRef.current) {
         try {
           // Display usage summary before cleanup
@@ -584,7 +802,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         agentRef.current.destroy();
       }
     };
-  }, []);
+  }, [
+    throttledContentUpdate,
+    throttledReasoningUpdate,
+    throttledToolBlockUpdate,
+  ]);
 
   // Trigger WorktreeRemove hook BEFORE agent destruction
   const triggerWorktreeRemoveHook = useCallback(
@@ -637,33 +859,32 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     [],
   );
 
-  const askBtw = useCallback(async (question: string) => {
-    if (!agentRef.current) {
-      throw new Error("Agent not initialized");
-    }
-    return await agentRef.current.askBtw(question);
-  }, []);
+  const askBtw = useCallback(
+    async (
+      question: string,
+      abortSignal?: AbortSignal,
+      onContent?: (content: string) => void,
+    ) => {
+      if (!agentRef.current) {
+        throw new Error("Agent not initialized");
+      }
+      return await agentRef.current.askBtw(question, abortSignal, onContent);
+    },
+    [],
+  );
 
   const clearMessages = useCallback(async () => {
     await agentRef.current?.clearMessages();
-  }, []);
+    refreshMessages();
+  }, [refreshMessages]);
 
-  const compact = useCallback(async (instructions?: string) => {
-    await agentRef.current?.compact(instructions);
-  }, []);
-
-  const goalCommand = useCallback(async (args?: string) => {
-    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);
-    }
-  }, []);
+  const compact = useCallback(
+    async (instructions?: string) => {
+      await agentRef.current?.compact(instructions);
+      refreshMessages();
+    },
+    [refreshMessages],
+  );
 
   // Unified interrupt method, interrupt both AI messages and command execution
   const abortMessage = useCallback(() => {
@@ -773,13 +994,14 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       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 () => {
@@ -827,15 +1049,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
       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
@@ -862,13 +1079,14 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     isExpanded,
     isTaskListVisible,
     setIsTaskListVisible,
+    isBtwActive,
+    setIsBtwActive,
     queuedMessages,
     sessionId,
     sendMessage,
     askBtw,
     clearMessages,
     compact,
-    goalCommand,
     abortMessage,
     recallQueuedMessage,
     removeQueuedMessageById,
@@ -912,9 +1130,6 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     workdir,
     recreateAgent,
     triggerWorktreeRemoveHook,
-    isGoalActive,
-    goalElapsed,
-    isGoalEvaluating,
   };
 
   return (

package/src/daemon-cli.ts

@@ -0,0 +1,17 @@
+/**
+ * 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: string): Promise<void> {
+  const server = new DaemonServer({ socketPath });
+  await server.start();
+  // Ready — any error that follows goes to the daemon log via stderr.
+}