wave-code 1.0.6 → 1.0.8

package/src/components/ConfirmationSelector.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useReducer } from "react";
+import React, { useEffect, useReducer, useRef } from "react";
 import { Box, Text, useInput } from "ink";
 import type {
   PermissionDecision,
@@ -13,6 +13,7 @@ import {
 } from "wave-agent-sdk";
 import { confirmationReducer } from "../reducers/confirmationReducer.js";
 import { questionReducer } from "../reducers/questionReducer.js";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 
 const getHeaderColor = (header: string) => {
   const colors = ["red", "green", "blue", "magenta", "cyan"] as const;
@@ -103,23 +104,37 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
     return "Yes, and auto-accept edits";
   };
 
+  const pasteDetectorRef = useRef(createBracketedPasteDetector());
+
   useInput((input, key) => {
     if (key.escape) {
       onCancel();
       return;
     }
 
+    const result = pasteDetectorRef.current.process(input);
+    if (result.kind === "consume") {
+      // Content of an in-flight bracketed paste: hold it, never submit.
+      return;
+    }
+    let cleanInput: string;
+    if (result.kind === "paste") {
+      cleanInput = (result.leadingInput ?? "") + result.text;
+    } else {
+      cleanInput = result.input;
+    }
+
     if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
       questionDispatch({
         type: "HANDLE_KEY",
-        input,
+        input: cleanInput,
         key,
         questions,
       });
     } else {
       dispatch({
         type: "HANDLE_KEY",
-        input,
+        input: cleanInput,
         key,
         toolName,
         toolInput,

package/src/components/InputBox.tsx

@@ -6,6 +6,7 @@ import { CommandSelector } from "./CommandSelector.js";
 import { HistorySearch } from "./HistorySearch.js";
 import { BackgroundTaskManager } from "./BackgroundTaskManager.js";
 import { McpManager } from "./McpManager.js";
+import { AgentsManager } from "./AgentsManager.js";
 import { RewindCommand } from "./RewindCommand.js";
 import { HelpView } from "./HelpView.js";
 import { StatusCommand } from "./StatusCommand.js";
@@ -89,6 +90,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     recallQueuedMessage,
     queuedMessages,
     setIsBtwActive,
+    agentDefinitions,
   } = useChat();
 
   // Ref to hold setInputText so queue callbacks can access it before useInputManager returns
@@ -133,6 +135,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     // Task/MCP Manager
     showBackgroundTaskManager,
     showMcpManager,
+    showAgentsManager,
     showRewindManager,
     showHelp,
     showStatusCommand,
@@ -142,6 +145,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
     showWorkflowManager,
     setShowBackgroundTaskManager,
     setShowMcpManager,
+    setShowAgentsManager,
     setShowRewindManager,
     setShowHelp,
     setShowStatusCommand,
@@ -211,6 +215,7 @@ export const InputBox: React.FC<InputBoxProps> = ({
       showModelSelector ||
       showBackgroundTaskManager ||
       showMcpManager ||
+      showAgentsManager ||
       showWorkflowManager
     ) {
       return;
@@ -254,51 +259,6 @@ export const InputBox: React.FC<InputBoxProps> = ({
     await handleRewindSelect(index);
   };
 
-  if (showRewindManager) {
-    return (
-      <RewindCommand
-        messages={messages}
-        onSelect={handleRewindSelectWithClose}
-        onCancel={handleRewindCancel}
-        getFullMessageThread={getFullMessageThread}
-      />
-    );
-  }
-
-  if (showHelp) {
-    return (
-      <HelpView onCancel={() => setShowHelp(false)} commands={slashCommands} />
-    );
-  }
-
-  if (showStatusCommand) {
-    return <StatusCommand onCancel={() => setShowStatusCommand(false)} />;
-  }
-
-  if (showLoginCommand) {
-    return <LoginCommand onCancel={() => setShowLoginCommand(false)} />;
-  }
-
-  if (showPluginManager) {
-    return (
-      <PluginManagerShell
-        onCancel={() => setShowPluginManager(false)}
-        onPluginInstalled={recreateAgent}
-      />
-    );
-  }
-
-  if (showModelSelector) {
-    return (
-      <ModelSelector
-        onCancel={() => setShowModelSelector(false)}
-        currentModel={currentModel}
-        configuredModels={configuredModels}
-        onSelectModel={setModel}
-      />
-    );
-  }
-
   return (
     <Box flexDirection="column">
       <BtwDisplay btwState={btwState} />
@@ -345,19 +305,68 @@ export const InputBox: React.FC<InputBoxProps> = ({
         />
       )}
 
+      {showAgentsManager && (
+        <AgentsManager
+          onCancel={() => setShowAgentsManager(false)}
+          agentDefinitions={agentDefinitions}
+        />
+      )}
+
       {showWorkflowManager && (
         <WorkflowManager onCancel={() => setShowWorkflowManager(false)} />
       )}
 
+      {showRewindManager && (
+        <RewindCommand
+          messages={messages}
+          onSelect={handleRewindSelectWithClose}
+          onCancel={handleRewindCancel}
+          getFullMessageThread={getFullMessageThread}
+        />
+      )}
+
+      {showHelp && (
+        <HelpView
+          onCancel={() => setShowHelp(false)}
+          commands={slashCommands}
+        />
+      )}
+
+      {showStatusCommand && (
+        <StatusCommand onCancel={() => setShowStatusCommand(false)} />
+      )}
+
+      {showLoginCommand && (
+        <LoginCommand onCancel={() => setShowLoginCommand(false)} />
+      )}
+
+      {showPluginManager && (
+        <PluginManagerShell
+          onCancel={() => setShowPluginManager(false)}
+          onPluginInstalled={recreateAgent}
+        />
+      )}
+
+      {showModelSelector && (
+        <ModelSelector
+          onCancel={() => setShowModelSelector(false)}
+          currentModel={currentModel}
+          configuredModels={configuredModels}
+          onSelectModel={setModel}
+        />
+      )}
+
       {btwState.question || btwState.answer
         ? null
         : showBackgroundTaskManager ||
           showMcpManager ||
+          showAgentsManager ||
           showRewindManager ||
           showHelp ||
           showStatusCommand ||
           showLoginCommand ||
           showPluginManager ||
+          showModelSelector ||
           showWorkflowManager || (
             <Box flexDirection="column">
               {escClearPending && <Text color="gray">再次按 Esc 清空输入</Text>}

package/src/components/LoginCommand.tsx

@@ -3,6 +3,7 @@ import { Box, Text, useInput } from "ink";
 import { execFile } from "child_process";
 import { promisify } from "util";
 import { authService } from "wave-agent-sdk";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -32,6 +33,12 @@ export const LoginCommand: React.FC<LoginCommandProps> = ({ onCancel }) => {
   const isLoadingRef = useRef(isLoading);
   isLoadingRef.current = isLoading;
 
+  // Detects and strips bracketed paste markers (\x1b[200~ ... \x1b[201~)
+  // that terminals wrap pasted text in. Unlike the main InputBox pipeline,
+  // this overlay's token input goes through raw ink useInput, which only
+  // strips ONE leading ESC, leaving the markers (e.g. "[200~") in the input.
+  const pasteDetectorRef = useRef(createBracketedPasteDetector());
+
   // Resolve/reject refs for the token promise
   const tokenResolveRef = useRef<((token: string) => void) | null>(null);
   const tokenRejectRef = useRef<((err: Error) => void) | null>(null);
@@ -71,9 +78,34 @@ export const LoginCommand: React.FC<LoginCommandProps> = ({ onCancel }) => {
       setTokenInput((prev) => prev.slice(0, -1));
       return;
     }
-    // Regular character input (single or pasted multi-char)
+    // Regular character input (single or pasted multi-char). Run through the
+    // bracketed paste detector: a pasted token arrives wrapped in
+    // \x1b[200~ ... \x1b[201~ markers (possibly split across chunks), which
+    // must be stripped instead of being appended to the token.
     if (input && !key.ctrl && !key.meta && !key.return && input.length > 0) {
-      setTokenInput((prev) => prev + input);
+      const result = pasteDetectorRef.current.process(input);
+
+      if (result.kind === "consume") {
+        // In-flight bracketed paste content: hold it; the final chunk
+        // delivers the complete text.
+        return;
+      }
+
+      if (result.kind === "paste") {
+        // Tokens never contain carriage returns — drop \r (CRLF terminals
+        // send \r, not \n, in pasted text).
+        const leading = result.leadingInput?.replace(/\r/g, "");
+        if (leading) {
+          setTokenInput((prev) => prev + leading);
+        }
+        const text = result.text.replace(/\r/g, "");
+        if (text) {
+          setTokenInput((prev) => prev + text);
+        }
+        return;
+      }
+
+      setTokenInput((prev) => prev + result.input);
     }
   });
 
@@ -93,6 +125,7 @@ export const LoginCommand: React.FC<LoginCommandProps> = ({ onCancel }) => {
     setError("");
     setAuthUrl("");
     setTokenInput("");
+    pasteDetectorRef.current.reset();
     setMessage("Starting authentication...");
 
     // Promise that resolves when user presses Enter with token input

package/src/components/MarketplaceAddForm.tsx

@@ -1,4 +1,4 @@
-import React, { useReducer, useEffect } from "react";
+import React, { useReducer, useEffect, useRef } from "react";
 import { Box, Text, useInput } from "ink";
 import { usePluginManagerContext } from "../contexts/PluginManagerContext.js";
 import {
@@ -6,6 +6,7 @@ import {
   SCOPES,
   type MarketplaceAddFormState,
 } from "../reducers/marketplaceAddFormReducer.js";
+import { createBracketedPasteDetector } from "../utils/bracketedPaste.js";
 
 export const MarketplaceAddForm: React.FC = () => {
   const { state: ctxState, actions } = usePluginManagerContext();
@@ -32,11 +33,25 @@ export const MarketplaceAddForm: React.FC = () => {
     dispatch({ type: "CLEAR_PENDING_ACTION" });
   }, [state.pendingAction, actions]);
 
+  const pasteDetectorRef = useRef(createBracketedPasteDetector());
+
   useInput((input, key) => {
+    const result = pasteDetectorRef.current.process(input);
+    if (result.kind === "consume") {
+      // Content of an in-flight bracketed paste: hold it, never submit.
+      return;
+    }
+    let cleanInput: string;
+    if (result.kind === "paste") {
+      cleanInput = (result.leadingInput ?? "") + result.text;
+    } else {
+      cleanInput = result.input;
+    }
+
     dispatch({
       type: "HANDLE_KEY",
       key,
-      input,
+      input: cleanInput,
       isLoading: ctxState.isLoading,
     });
   });

package/src/components/RewindCommand.tsx

@@ -34,10 +34,16 @@ export const RewindCommand: React.FC<RewindCommandProps> = ({
   }, [getFullMessageThread]);
 
   // Filter user messages as checkpoints, excluding meta messages and
-  // system-generated user-role messages (task notifications, hook injections)
-  const checkpoints = messages
-    .map((msg, index) => ({ msg, index }))
-    .filter(({ msg }) => isUserCheckpointMessage(msg));
+  // system-generated user-role messages (task notifications, hook injections).
+  // Compaction is append-only: the same message id appears twice on the full
+  // thread (pre-compact history + post-compact append), so dedupe by id and
+  // keep the last occurrence (matching the folded view the user sees).
+  const checkpointMap = new Map<string, { msg: Message; index: number }>();
+  messages.forEach((msg, index) => {
+    if (!isUserCheckpointMessage(msg)) return;
+    checkpointMap.set(msg.id ?? `index:${index}`, { msg, index });
+  });
+  const checkpoints = Array.from(checkpointMap.values());
 
   const MAX_VISIBLE_ITEMS = 3;
 

package/src/constants/commands.ts

@@ -13,6 +13,12 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "View and manage MCP servers",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "agents",
+    name: "agents",
+    description: "List available agents and active subagents",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
   {
     id: "rewind",
     name: "rewind",

package/src/contexts/useChat.tsx

@@ -15,6 +15,7 @@ import type {
   BackgroundTask,
   Task,
   SlashCommand,
+  SubagentConfiguration,
   PermissionDecision,
   PermissionMode,
   QueuedMessage,
@@ -30,7 +31,6 @@ import {
   extractLatestTotalTokens,
 } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
-import { throttle } from "../utils/throttle.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
 import { expandLongTextPlaceholders } from "../managers/inputHandlers.js";
 
@@ -96,6 +96,8 @@ export interface ChatContextType {
   // Slash Command functionality
   slashCommands: SlashCommand[];
   hasSlashCommand: (commandId: string) => boolean;
+  // Agent definitions (for /agents overlay)
+  agentDefinitions: SubagentConfiguration[];
   // Permission functionality
   permissionMode: PermissionMode;
   setPermissionMode: (mode: PermissionMode) => void;
@@ -109,6 +111,7 @@ export interface ChatContextType {
     hidePersistentOption?: boolean;
     planContent?: string;
     permissionMode?: PermissionMode;
+    warning?: string;
   };
   showConfirmation: (
     toolName: string,
@@ -117,6 +120,7 @@ export interface ChatContextType {
     hidePersistentOption?: boolean,
     planContent?: string,
     permissionMode?: PermissionMode,
+    warning?: string,
   ) => Promise<PermissionDecision>;
   hideConfirmation: () => void;
   handleConfirmationDecision: (decision: PermissionDecision) => void;
@@ -236,6 +240,99 @@ function createStreamingWindowThrottle(
   return throttled;
 }
 
+/**
+ * Per-tool window-concat throttle for pure-delta tool parameter streaming:
+ * `parametersChunk` deltas are accumulated independently per tool block id
+ * within the cooldown window, so interleaved multi-tool streams lose no delta
+ * (a plain throttle's single last-args slot would drop every earlier tool's
+ * deltas, leaving the first tool without streaming parameters). `start` /
+ * `running` apply immediately (one-shot snapshots); `end` flushes pending
+ * streaming deltas first, then applies the authoritative parameters/result.
+ */
+export function createToolStreamingThrottle(
+  fn: (params: ToolBlockUpdateCallbackParams) => void,
+  wait: number,
+): {
+  (params: ToolBlockUpdateCallbackParams): void;
+  cancel: () => void;
+  flush: () => void;
+} {
+  let timer: NodeJS.Timeout | null = null;
+  let pending: { messageId: string; chunks: Map<string, string> } | null = null;
+
+  const fire = () => {
+    if (pending && pending.chunks.size > 0) {
+      const { messageId, chunks } = pending;
+      pending = null;
+      for (const [id, chunk] of chunks) {
+        fn({ messageId, id, parametersChunk: chunk, stage: "streaming" });
+      }
+    }
+  };
+
+  const throttled = (params: ToolBlockUpdateCallbackParams) => {
+    if (params.stage === "end") {
+      // Flush any deltas still pending inside the cooldown window first
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      fire();
+      fn(params);
+      return;
+    }
+    if (params.stage === "streaming") {
+      if (!pending) {
+        pending = { messageId: params.messageId, chunks: new Map() };
+      }
+      const prev = pending.chunks.get(params.id) || "";
+      pending.chunks.set(params.id, prev + (params.parametersChunk || ""));
+      if (!timer) {
+        timer = setTimeout(() => {
+          timer = null;
+          fire();
+        }, wait);
+      }
+      return;
+    }
+    // start / running — one-shot snapshots applied immediately. Drop this
+    // tool's buffered streaming deltas first: start/running carry the
+    // authoritative parameters, and a pending timer would otherwise fire late
+    // with a stale `streaming` event, regressing this tool block's stage back
+    // to streaming (yellow dot -> gray) mid-execution. Other tools' in-flight
+    // chunks are kept so interleaved multi-tool streaming still accumulates.
+    if (pending) {
+      pending.chunks.delete(params.id);
+      if (pending.chunks.size === 0) {
+        pending = null;
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      }
+    }
+    fn(params);
+  };
+
+  throttled.cancel = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    pending = null;
+  };
+
+  throttled.flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    fire();
+  };
+
+  return throttled;
+}
+
 export const ChatProvider: React.FC<ChatProviderProps> = ({
   children,
   bypassPermissions,
@@ -342,8 +439,13 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   const throttledToolBlockUpdate = useMemo(
     () =>
-      throttle((params: ToolBlockUpdateCallbackParams) => {
-        const { messageId, id: toolBlockId, ...updates } = params;
+      createToolStreamingThrottle((params) => {
+        const {
+          messageId,
+          id: toolBlockId,
+          parametersChunk,
+          ...updates
+        } = params;
         setMessages((prev) =>
           prev.map((m) => {
             if (m.id !== messageId) return m;
@@ -360,7 +462,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
                     id: toolBlockId,
                     name: updates.name || "",
                     stage: updates.stage || "start",
-                    parameters: updates.parameters || "",
+                    parameters:
+                      (updates.parameters || "") + (parametersChunk || ""),
                     result: updates.result || "",
                     ...updates,
                   },
@@ -371,7 +474,18 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
               ...m,
               blocks: m.blocks.map((b, idx) =>
                 idx === toolBlockIndex && b.type === "tool"
-                  ? { ...b, ...updates }
+                  ? {
+                      ...b,
+                      ...updates,
+                      // Streaming carries only the delta; append it to the
+                      // accumulated parameters. start/running/end carry the
+                      // authoritative value and replace wholesale.
+                      parameters: parametersChunk
+                        ? (b.parameters || "") + parametersChunk
+                        : updates.parameters !== undefined
+                          ? updates.parameters
+                          : b.parameters,
+                    }
                   : b,
               ),
             };
@@ -419,6 +533,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Command state
   const [slashCommands, setSlashCommands] = useState<SlashCommand[]>([]);
 
+  // Agent definitions (for /agents overlay)
+  const [agentDefinitions, setAgentDefinitions] = useState<
+    SubagentConfiguration[]
+  >([]);
+
   // Permission state
   const [permissionMode, setPermissionModeState] = useState<PermissionMode>(
     initialPermissionMode ||
@@ -435,6 +554,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         hidePersistentOption?: boolean;
         planContent?: string;
         permissionMode?: PermissionMode;
+        warning?: string;
       }
     | undefined
   >();
@@ -446,6 +566,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       hidePersistentOption?: boolean;
       planContent?: string;
       permissionMode?: PermissionMode;
+      warning?: string;
       resolver: (decision: PermissionDecision) => void;
       reject: () => void;
     }>
@@ -457,6 +578,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     hidePersistentOption?: boolean;
     planContent?: string;
     permissionMode?: PermissionMode;
+    warning?: string;
     resolver: (decision: PermissionDecision) => void;
     reject: () => void;
   } | null>(null);
@@ -498,6 +620,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       hidePersistentOption?: boolean,
       planContent?: string,
       permissionMode?: PermissionMode,
+      warning?: string,
     ): Promise<PermissionDecision> => {
       return new Promise<PermissionDecision>((resolve, reject) => {
         const queueItem = {
@@ -507,6 +630,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           hidePersistentOption,
           planContent,
           permissionMode,
+          warning,
           resolver: resolve,
           reject,
         };
@@ -627,7 +751,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
             ),
           );
         },
-        onCompleteBangMessage: (command, exitCode, messageId) => {
+        onCompleteBangMessage: (command, exitCode, messageId, output) => {
           if (isExpandedRef.current) return;
           setMessages((prev) =>
             prev.map((m) =>
@@ -636,7 +760,13 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
                     ...m,
                     blocks: m.blocks.map((b, idx) =>
                       idx === m.blocks.length - 1 && b.type === "bang"
-                        ? { ...b, command, exitCode, stage: "end" }
+                        ? {
+                            ...b,
+                            command,
+                            exitCode,
+                            stage: "end",
+                            ...(output !== undefined ? { output } : {}),
+                          }
                         : b,
                     ),
                   }
@@ -709,6 +839,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
               context.hidePersistentOption,
               context.planContent,
               context.permissionMode,
+              context.warning,
             );
           } catch {
             // If confirmation was cancelled or failed, deny the operation
@@ -778,6 +909,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         // Get initial commands
         const agentSlashCommands = agent.getSlashCommands?.() || [];
         setSlashCommands(agentSlashCommands);
+
+        // Get initial agent definitions
+        const initialAgentDefinitions =
+          agent.getSubagentConfigurations?.() || [];
+        setAgentDefinitions(initialAgentDefinitions);
       } catch (error) {
         console.error("Failed to initialize AI manager:", error);
       }
@@ -818,6 +954,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     setMessages([]);
     setMcpServerStatuses([]);
     setSlashCommands([]);
+    setAgentDefinitions([]);
     setSessionId("");
     setIsLoading(false);
     setLatestTotalTokens(0);
@@ -1050,6 +1187,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         hidePersistentOption: next.hidePersistentOption,
         planContent: next.planContent,
         permissionMode: next.permissionMode,
+        warning: next.warning,
       });
       setIsConfirmationVisible(true);
       setConfirmationQueue((prev) => prev.slice(1));
@@ -1205,6 +1343,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     stopBackgroundTask,
     slashCommands,
     hasSlashCommand,
+    agentDefinitions,
     permissionMode,
     setPermissionMode,
     isConfirmationVisible,