wave-code 1.0.6 → 1.0.7

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/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,
@@ -96,6 +97,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;
@@ -419,6 +422,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 ||
@@ -627,7 +635,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 +644,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,
                     ),
                   }
@@ -778,6 +792,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 +837,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     setMessages([]);
     setMcpServerStatuses([]);
     setSlashCommands([]);
+    setAgentDefinitions([]);
     setSessionId("");
     setIsLoading(false);
     setLatestTotalTokens(0);
@@ -1205,6 +1225,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     stopBackgroundTask,
     slashCommands,
     hasSlashCommand,
+    agentDefinitions,
     permissionMode,
     setPermissionMode,
     isConfirmationVisible,

package/src/hooks/useInputManager.ts

@@ -242,6 +242,8 @@ export const useInputManager = (
                 });
               } else if (command === "mcp") {
                 dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: true });
+              } else if (command === "agents") {
+                dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: true });
               } else if (command === "rewind") {
                 dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
               } else if (command === "help") {
@@ -493,6 +495,10 @@ export const useInputManager = (
     dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: show });
   }, []);
 
+  const setShowAgentsManager = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: show });
+  }, []);
+
   const setShowRewindManager = useCallback((show: boolean) => {
     dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: show });
   }, []);
@@ -657,6 +663,7 @@ export const useInputManager = (
     historySearchQuery: state.historySearchQuery,
     showBackgroundTaskManager: state.showBackgroundTaskManager,
     showMcpManager: state.showMcpManager,
+    showAgentsManager: state.showAgentsManager,
     showRewindManager: state.showRewindManager,
     showHelp: state.showHelp,
     showStatusCommand: state.showStatusCommand,
@@ -702,6 +709,7 @@ export const useInputManager = (
     // Bash/MCP Manager
     setShowBackgroundTaskManager,
     setShowMcpManager,
+    setShowAgentsManager,
     setShowRewindManager,
     setShowHelp,
     setShowStatusCommand,

package/src/managers/inputHandlers.ts

@@ -367,6 +367,8 @@ export const handleCommandSelect = (
           });
         } else if (command === "mcp") {
           dispatch({ type: "SET_SHOW_MCP_MANAGER", payload: true });
+        } else if (command === "agents") {
+          dispatch({ type: "SET_SHOW_AGENTS_MANAGER", payload: true });
         } else if (command === "rewind") {
           dispatch({ type: "SET_SHOW_REWIND_MANAGER", payload: true });
         } else if (command === "help") {

package/src/managers/inputReducer.ts

@@ -130,6 +130,7 @@ export interface InputState {
   imageIdCounter: number;
   showBackgroundTaskManager: boolean;
   showMcpManager: boolean;
+  showAgentsManager: boolean;
   showRewindManager: boolean;
   showHelp: boolean;
   showStatusCommand: boolean;
@@ -167,6 +168,7 @@ export const initialState: InputState = {
   imageIdCounter: 1,
   showBackgroundTaskManager: false,
   showMcpManager: false,
+  showAgentsManager: false,
   showRewindManager: false,
   showHelp: false,
   showStatusCommand: false,
@@ -400,6 +402,7 @@ export type InputAction =
   | { type: "CLEAR_IMAGES" }
   | { type: "SET_SHOW_BACKGROUND_TASK_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_MCP_MANAGER"; payload: boolean }
+  | { type: "SET_SHOW_AGENTS_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_REWIND_MANAGER"; payload: boolean }
   | { type: "SET_SHOW_HELP"; payload: boolean }
   | { type: "SET_SHOW_STATUS_COMMAND"; payload: boolean }
@@ -589,6 +592,12 @@ export function inputReducer(
         showMcpManager: action.payload,
         selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
       };
+    case "SET_SHOW_AGENTS_MANAGER":
+      return {
+        ...state,
+        showAgentsManager: action.payload,
+        selectorJustUsed: !action.payload ? true : state.selectorJustUsed,
+      };
     case "SET_SHOW_REWIND_MANAGER":
       return {
         ...state,
@@ -970,6 +979,7 @@ export function inputReducer(
           !(
             state.showBackgroundTaskManager ||
             state.showMcpManager ||
+            state.showAgentsManager ||
             state.showRewindManager ||
             state.showHelp ||
             state.showStatusCommand ||

package/src/reducers/agentsManagerReducer.ts

@@ -0,0 +1,91 @@
+import { Key } from "ink";
+
+export type PendingEffect = { type: "CANCEL" };
+
+export interface AgentsManagerState {
+  selectedIndex: number;
+  viewMode: "list" | "detail";
+  pendingEffect: PendingEffect | null;
+}
+
+export type AgentsManagerAction =
+  | { type: "MOVE_UP" }
+  | { type: "MOVE_DOWN"; itemCount: number }
+  | { type: "SET_VIEW_MODE"; viewMode: "list" | "detail" }
+  | {
+      type: "HANDLE_KEY";
+      input: string;
+      key: Key;
+      itemCount: number;
+    }
+  | { type: "CLEAR_PENDING_EFFECT" };
+
+export function agentsManagerReducer(
+  state: AgentsManagerState,
+  action: AgentsManagerAction,
+): AgentsManagerState {
+  switch (action.type) {
+    case "MOVE_UP":
+      return {
+        ...state,
+        selectedIndex: Math.max(0, state.selectedIndex - 1),
+      };
+    case "MOVE_DOWN":
+      return {
+        ...state,
+        selectedIndex: Math.min(
+          Math.max(0, action.itemCount - 1),
+          state.selectedIndex + 1,
+        ),
+      };
+    case "SET_VIEW_MODE":
+      return { ...state, viewMode: action.viewMode };
+    case "HANDLE_KEY": {
+      const { key, itemCount } = action;
+
+      if (key.return) {
+        if (state.viewMode === "list") {
+          return { ...state, viewMode: "detail" };
+        }
+        // Aligned with Claude Code AgentDetail: Enter returns to the list.
+        return { ...state, viewMode: "list" };
+      }
+
+      if (key.escape) {
+        if (state.viewMode === "detail") {
+          return { ...state, viewMode: "list" };
+        }
+        return { ...state, pendingEffect: { type: "CANCEL" } };
+      }
+
+      // Detail view does not respond to arrow keys (aligned with CC
+      // AgentDetail, which only Esc/Enter back to the list).
+      if (state.viewMode === "detail") {
+        return state;
+      }
+
+      if (key.upArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.max(0, state.selectedIndex - 1),
+        };
+      }
+
+      if (key.downArrow) {
+        return {
+          ...state,
+          selectedIndex: Math.min(
+            Math.max(0, itemCount - 1),
+            state.selectedIndex + 1,
+          ),
+        };
+      }
+
+      return state;
+    }
+    case "CLEAR_PENDING_EFFECT":
+      return { ...state, pendingEffect: null };
+    default:
+      return state;
+  }
+}

package/src/stdio/agentBridge.ts

@@ -42,6 +42,8 @@ import {
   PluginCore,
   validateWorktreeRemovalPath,
   type SlashCommand,
+  loadUserConfigEnv,
+  type SubagentConfiguration,
 } from "wave-agent-sdk";
 import {
   type JsonRpcError,
@@ -140,6 +142,15 @@ export class AgentBridge {
 
   constructor(options: AgentBridgeOptions) {
     this.emit = options.emit;
+    // Mirror the user-level settings env WAVE_SERVER_URL into process.env
+    // before any agent initializes. getAuthStatus (webviewReady →
+    // pushInitialState) can run before the first agent, and AuthService falls
+    // back to the default URL otherwise — refreshing a custom-domain token
+    // against the wrong host 401s into a logged-out state.
+    const userEnv = loadUserConfigEnv();
+    if (userEnv.WAVE_SERVER_URL) {
+      process.env.WAVE_SERVER_URL = userEnv.WAVE_SERVER_URL;
+    }
   }
 
   // ── Public API ────────────────────────────────────────────────
@@ -166,6 +177,10 @@ export class AgentBridge {
         return this.listPendingPermissions();
       case "updateConfig":
         return this.updateConfig(p as unknown as UpdateConfigParams, sessionId);
+      case "getConfiguredModels":
+        return this.getConfiguredModels(sessionId);
+      case "setModel":
+        return this.setModel(p.model as string, sessionId);
 
       // ── Messages ──
       case "sendMessage":
@@ -222,6 +237,8 @@ export class AgentBridge {
       // ── Commands ──
       case "getSlashCommands":
         return this.getSlashCommands(sessionId);
+      case "getSubagentConfigurations":
+        return this.getSubagentConfigurations(sessionId);
 
       // ── File / History (global — no session required) ──
       case "searchFiles":
@@ -727,6 +744,27 @@ export class AgentBridge {
     return { sessionId: agent.sessionId };
   }
 
+  private getConfiguredModels(sessionId?: string): {
+    models: string[];
+    currentModel: string | undefined;
+  } {
+    const entry = this.requireSession(sessionId);
+    return {
+      models: entry.agent.getConfiguredModels(),
+      currentModel: entry.agent.getModelConfig().model,
+    };
+  }
+
+  private async setModel(model: string, sessionId?: string): Promise<null> {
+    const entry = this.requireSession(sessionId);
+    entry.agent.setModel(model);
+    // Keep storedConfig in sync: updateConfig recreates the agent from
+    // storedConfig, so without this a later config save would revert the
+    // model chosen here.
+    entry.storedConfig = { ...entry.storedConfig, model };
+    return null;
+  }
+
   // ── Messages ──────────────────────────────────────────────────
 
   private async sendMessage(
@@ -984,6 +1022,13 @@ export class AgentBridge {
     return { commands: entry.agent.getSlashCommands() };
   }
 
+  private getSubagentConfigurations(sessionId?: string): {
+    configurations: SubagentConfiguration[];
+  } {
+    const entry = this.requireSession(sessionId);
+    return { configurations: entry.agent.getSubagentConfigurations() };
+  }
+
   // ── File / History (global) ───────────────────────────────────
 
   private async searchFiles(
@@ -1107,13 +1152,6 @@ export class AgentBridge {
     serverUrl: string;
   }> {
     const authService = AuthService.getInstance();
-    // A stale-but-refreshable token still means "logged in" — the daemon may
-    // have started with an expired access token (hourly expiry) and only
-    // refreshes lazily on the first API call. Without this proactive refresh a
-    // fresh client querying right after daemon start gets a false
-    // isAuthenticated and e.g. the desktop welcome page keeps showing the
-    // login button for an authenticated host. Mirrors the refresh that
-    // createAuthAwareFetch does before every real request.
     await authService.checkAndRefreshTokenIfNeeded();
     return {
       isAuthenticated: authService.isSSOAuthenticated(),
@@ -1424,10 +1462,10 @@ export class AgentBridge {
           ctx.registeredSessionId,
         );
       },
-      onCompleteBangMessage: (command, exitCode, messageId) => {
+      onCompleteBangMessage: (command, exitCode, messageId, output) => {
         this.emit(
           "bangMessageCompleted",
-          { command, exitCode, messageId },
+          { command, exitCode, messageId, output },
           ctx.registeredSessionId,
         );
       },

package/src/stdio/protocol.ts

@@ -75,6 +75,8 @@ export type RequestMethod =
   | "getPromptHistory"
   | "searchPromptHistory"
   | "updateConfig"
+  | "getConfiguredModels"
+  | "setModel"
   // Permissions (daemon attach: re-surface pending approvals after reconnect)
   | "listPendingPermissions"
   // Auth