wave-code 0.0.6 → 0.0.10

package/src/contexts/useChat.tsx

@@ -13,8 +13,14 @@ import type {
   McpServerStatus,
   BackgroundShell,
   SlashCommand,
+  PermissionDecision,
+  PermissionMode,
+} from "wave-agent-sdk";
+import {
+  Agent,
+  AgentCallbacks,
+  type ToolPermissionContext,
 } from "wave-agent-sdk";
-import { Agent, AgentCallbacks } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
 
@@ -52,6 +58,26 @@ export interface ChatContextType {
   hasSlashCommand: (commandId: string) => boolean;
   // Subagent messages
   subagentMessages: Record<string, Message[]>;
+  // Permission functionality
+  permissionMode: PermissionMode;
+  setPermissionMode: (mode: PermissionMode) => void;
+  // Permission confirmation state
+  isConfirmationVisible: boolean;
+  confirmingTool?: {
+    name: string;
+    input?: Record<string, unknown>;
+    suggestedPrefix?: string;
+    hidePersistentOption?: boolean;
+  };
+  showConfirmation: (
+    toolName: string,
+    toolInput?: Record<string, unknown>,
+    suggestedPrefix?: string,
+    hidePersistentOption?: boolean,
+  ) => Promise<PermissionDecision>;
+  hideConfirmation: () => void;
+  handleConfirmationDecision: (decision: PermissionDecision) => void;
+  handleConfirmationCancel: () => void;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -66,9 +92,13 @@ export const useChat = () => {
 
 export interface ChatProviderProps {
   children: React.ReactNode;
+  bypassPermissions?: boolean;
 }
 
-export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
+export const ChatProvider: React.FC<ChatProviderProps> = ({
+  children,
+  bypassPermissions,
+}) => {
   const { restoreSessionId, continueLastSession } = useAppConfig();
 
   // Message Display State
@@ -99,20 +129,66 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     Record<string, Message[]>
   >({});
 
+  // Permission state
+  const [permissionMode, setPermissionModeState] =
+    useState<PermissionMode>("default");
+
+  // Confirmation state with queue-based architecture
+  const [isConfirmationVisible, setIsConfirmationVisible] = useState(false);
+  const [confirmingTool, setConfirmingTool] = useState<
+    | {
+        name: string;
+        input?: Record<string, unknown>;
+        suggestedPrefix?: string;
+        hidePersistentOption?: boolean;
+      }
+    | undefined
+  >();
+  const [confirmationQueue, setConfirmationQueue] = useState<
+    Array<{
+      toolName: string;
+      toolInput?: Record<string, unknown>;
+      suggestedPrefix?: string;
+      hidePersistentOption?: boolean;
+      resolver: (decision: PermissionDecision) => void;
+      reject: () => void;
+    }>
+  >([]);
+  const [currentConfirmation, setCurrentConfirmation] = useState<{
+    toolName: string;
+    toolInput?: Record<string, unknown>;
+    suggestedPrefix?: string;
+    hidePersistentOption?: boolean;
+    resolver: (decision: PermissionDecision) => void;
+    reject: () => void;
+  } | null>(null);
+
   const agentRef = useRef<Agent | null>(null);
 
-  // Listen for Ctrl+O hotkey to toggle collapse/expand state
-  useInput((input, key) => {
-    if (key.ctrl && input === "o") {
-      // Clear terminal screen when expanded state changes
-      process.stdout.write("\x1Bc", () => {
-        setIsExpanded((prev) => {
-          const newExpanded = !prev;
-          return newExpanded;
-        });
+  // Permission confirmation methods with queue support
+  const showConfirmation = useCallback(
+    async (
+      toolName: string,
+      toolInput?: Record<string, unknown>,
+      suggestedPrefix?: string,
+      hidePersistentOption?: boolean,
+    ): Promise<PermissionDecision> => {
+      return new Promise<PermissionDecision>((resolve, reject) => {
+        const queueItem = {
+          toolName,
+          toolInput,
+          suggestedPrefix,
+          hidePersistentOption,
+          resolver: resolve,
+          reject,
+        };
+
+        setConfirmationQueue((prev) => [...prev, queueItem]);
+        // processNextConfirmation will be called via useEffect
       });
-    }
-  });
+    },
+    [],
+  );
 
   // Initialize AI manager
   useEffect(() => {
@@ -142,19 +218,48 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
           setBackgroundShells([...shells]);
         },
         onSubagentMessagesChange: (subagentId, messages) => {
+          logger.debug("onSubagentMessagesChange", subagentId, messages.length);
           setSubagentMessages((prev) => ({
             ...prev,
             [subagentId]: [...messages],
           }));
         },
+        onPermissionModeChange: (mode) => {
+          setPermissionModeState(mode);
+        },
       };
 
       try {
+        // Create the permission callback inside the try block to access showConfirmation
+        const permissionCallback = bypassPermissions
+          ? undefined
+          : async (
+              context: ToolPermissionContext,
+            ): Promise<PermissionDecision> => {
+              try {
+                return await showConfirmation(
+                  context.toolName,
+                  context.toolInput,
+                  context.suggestedPrefix,
+                  context.hidePersistentOption,
+                );
+              } catch {
+                // If confirmation was cancelled or failed, deny the operation
+                return {
+                  behavior: "deny",
+                  message: "Operation cancelled by user",
+                };
+              }
+            };
+
         const agent = await Agent.create({
           callbacks,
           restoreSessionId,
           continueLastSession,
           logger,
+          permissionMode: bypassPermissions ? "bypassPermissions" : undefined,
+          canUseTool: permissionCallback,
+          stream: false, // 关闭流式模式
         });
 
         agentRef.current = agent;
@@ -167,6 +272,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
         setIsCommandRunning(agent.isCommandRunning);
         setIsCompressing(agent.isCompressing);
         setUserInputHistory(agent.userInputHistory);
+        setPermissionModeState(agent.getPermissionMode());
 
         // Get initial MCP servers state
         const mcpServers = agent.getMcpServers?.() || [];
@@ -181,7 +287,12 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     };
 
     initializeAgent();
-  }, [restoreSessionId, continueLastSession]);
+  }, [
+    restoreSessionId,
+    continueLastSession,
+    bypassPermissions,
+    showConfirmation,
+  ]);
 
   // Cleanup on unmount
   useEffect(() => {
@@ -278,6 +389,17 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     [],
   );
 
+  // Permission management methods
+  const setPermissionMode = useCallback((mode: PermissionMode) => {
+    setPermissionModeState((prev) => {
+      if (prev === mode) return prev;
+      if (agentRef.current && agentRef.current.getPermissionMode() !== mode) {
+        agentRef.current.setPermissionMode(mode);
+      }
+      return mode;
+    });
+  }, []);
+
   // MCP management methods - delegate to Agent
   const connectMcpServer = useCallback(async (serverName: string) => {
     return (await agentRef.current?.connectMcpServer(serverName)) ?? false;
@@ -303,6 +425,68 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     return agentRef.current.hasSlashCommand(commandId);
   }, []);
 
+  // Queue processing helper
+  const processNextConfirmation = useCallback(() => {
+    if (confirmationQueue.length > 0 && !isConfirmationVisible) {
+      const next = confirmationQueue[0];
+      setCurrentConfirmation(next);
+      setConfirmingTool({
+        name: next.toolName,
+        input: next.toolInput,
+        suggestedPrefix: next.suggestedPrefix,
+        hidePersistentOption: next.hidePersistentOption,
+      });
+      setIsConfirmationVisible(true);
+      setConfirmationQueue((prev) => prev.slice(1));
+    }
+  }, [confirmationQueue, isConfirmationVisible]);
+
+  // Process queue when queue changes or confirmation is hidden
+  useEffect(() => {
+    processNextConfirmation();
+  }, [processNextConfirmation]);
+
+  const hideConfirmation = useCallback(() => {
+    setIsConfirmationVisible(false);
+    setConfirmingTool(undefined);
+    setCurrentConfirmation(null);
+  }, []);
+
+  const handleConfirmationDecision = useCallback(
+    (decision: PermissionDecision) => {
+      if (currentConfirmation) {
+        currentConfirmation.resolver(decision);
+      }
+      hideConfirmation();
+    },
+    [currentConfirmation, hideConfirmation],
+  );
+
+  const handleConfirmationCancel = useCallback(() => {
+    if (currentConfirmation) {
+      currentConfirmation.reject();
+    }
+    hideConfirmation();
+  }, [currentConfirmation, hideConfirmation]);
+
+  // Listen for Ctrl+O hotkey to toggle collapse/expand state and ESC to cancel confirmation
+  useInput((input, key) => {
+    if (key.ctrl && input === "o") {
+      // Clear terminal screen when expanded state changes
+      process.stdout.write("\x1Bc", () => {
+        setIsExpanded((prev) => {
+          const newExpanded = !prev;
+          return newExpanded;
+        });
+      });
+    }
+
+    // Handle ESC key to cancel confirmation
+    if (key.escape && isConfirmationVisible) {
+      handleConfirmationCancel();
+    }
+  });
+
   const contextValue: ChatContextType = {
     messages,
     isLoading,
@@ -324,6 +508,14 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     slashCommands,
     hasSlashCommand,
     subagentMessages,
+    permissionMode,
+    setPermissionMode,
+    isConfirmationVisible,
+    confirmingTool,
+    showConfirmation,
+    hideConfirmation,
+    handleConfirmationDecision,
+    handleConfirmationCancel,
   };
 
   return (

package/src/hooks/useInputManager.ts

@@ -6,6 +6,8 @@ import {
   AttachedImage,
 } from "../managers/InputManager.js";
 import { FileItem } from "../components/FileSelector.js";
+import { PermissionMode } from "wave-agent-sdk";
+import { logger } from "../utils/logger.js";
 
 export const useInputManager = (
   callbacks: Partial<InputManagerCallbacks> = {},
@@ -38,6 +40,8 @@ export const useInputManager = (
   });
   const [showBashManager, setShowBashManager] = useState(false);
   const [showMcpManager, setShowMcpManager] = useState(false);
+  const [permissionMode, setPermissionModeState] =
+    useState<PermissionMode>("default");
   const [attachedImages, setAttachedImages] = useState<AttachedImage[]>([]);
 
   // Create InputManager on mount and update callbacks when they change
@@ -45,6 +49,7 @@ export const useInputManager = (
     if (!managerRef.current) {
       // Create InputManager on first mount
       const manager = new InputManager({
+        logger,
         onInputTextChange: setInputText,
         onCursorPositionChange: setCursorPosition,
         onFileSelectorStateChange: (show, files, query, position) => {
@@ -65,6 +70,10 @@ export const useInputManager = (
         onMcpManagerStateChange: (show) => {
           setShowMcpManager(show);
         },
+        onPermissionModeChange: (mode) => {
+          setPermissionModeState(mode);
+          callbacks.onPermissionModeChange?.(mode);
+        },
         onImagesStateChange: setAttachedImages,
         onShowBashManager: () => setShowBashManager(true),
         onShowMcpManager: () => setShowMcpManager(true),
@@ -76,6 +85,7 @@ export const useInputManager = (
     } else {
       // Update callbacks on existing manager
       managerRef.current.updateCallbacks({
+        logger,
         onInputTextChange: setInputText,
         onCursorPositionChange: setCursorPosition,
         onFileSelectorStateChange: (show, files, query, position) => {
@@ -96,6 +106,10 @@ export const useInputManager = (
         onMcpManagerStateChange: (show) => {
           setShowMcpManager(show);
         },
+        onPermissionModeChange: (mode) => {
+          setPermissionModeState(mode);
+          callbacks.onPermissionModeChange?.(mode);
+        },
         onImagesStateChange: setAttachedImages,
         onShowBashManager: () => setShowBashManager(true),
         onShowMcpManager: () => setShowMcpManager(true),
@@ -328,6 +342,7 @@ export const useInputManager = (
     memoryMessage: memoryTypeSelectorState.message,
     showBashManager,
     showMcpManager,
+    permissionMode,
     attachedImages,
     isManagerReady,
 
@@ -384,6 +399,10 @@ export const useInputManager = (
     setShowMcpManager: useCallback((show: boolean) => {
       managerRef.current?.setShowMcpManager(show);
     }, []),
+    setPermissionMode: useCallback((mode: PermissionMode) => {
+      setPermissionModeState(mode);
+      managerRef.current?.setPermissionMode(mode);
+    }, []),
 
     // Image management
     addImage: useCallback((imagePath: string, mimeType: string) => {

package/src/index.ts

@@ -1,7 +1,11 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { startCli } from "./cli.js";
-import { listSessions, getSessionFilePath } from "wave-agent-sdk";
+import {
+  listSessions,
+  getSessionFilePath,
+  getFirstMessageContent,
+} from "wave-agent-sdk";
 
 // Export main function for external use
 export async function main() {
@@ -29,6 +33,11 @@ export async function main() {
       description: "List all available sessions",
       type: "boolean",
     })
+    .option("dangerously-skip-permissions", {
+      description: "Skip all permission checks (dangerous)",
+      type: "boolean",
+      default: false,
+    })
     .version()
     .alias("v", "version")
     .example("$0", "Start CLI with default settings")
@@ -57,20 +66,39 @@ export async function main() {
       console.log(`Available sessions for: ${currentWorkdir}`);
       console.log("==========================================");
 
-      for (const session of sessions) {
-        const startedAt = new Date(session.startedAt).toLocaleString();
+      // Get last 5 sessions
+      const lastSessions = sessions.slice(0, 5);
+
+      for (const session of lastSessions) {
         const lastActiveAt = new Date(session.lastActiveAt).toLocaleString();
         const filePath = await getSessionFilePath(session.id, session.workdir);
 
+        // Get first message content
+        const firstMessageContent = await getFirstMessageContent(
+          session.id,
+          session.workdir,
+        );
+
+        // Truncate content if too long
+        let truncatedContent =
+          firstMessageContent || "No first message content";
+        if (truncatedContent.length > 30) {
+          truncatedContent = truncatedContent.substring(0, 30) + "...";
+        }
+
         console.log(`ID: ${session.id}`);
         console.log(`  Workdir: ${session.workdir}`);
         console.log(`  File Path: ${filePath}`);
-        console.log(`  Started: ${startedAt}`);
         console.log(`  Last Active: ${lastActiveAt}`);
         console.log(`  Last Message Tokens: ${session.latestTotalTokens}`);
+        console.log(`  First Message: ${truncatedContent}`);
         console.log("");
       }
 
+      if (sessions.length > 5) {
+        console.log(`... and ${sessions.length - 5} more sessions`);
+      }
+
       return;
     } catch (error) {
       console.error("Failed to list sessions:", error);
@@ -86,12 +114,14 @@ export async function main() {
       continueLastSession: argv.continue,
       message: argv.print,
       showStats: argv.showStats,
+      bypassPermissions: argv.dangerouslySkipPermissions,
     });
   }
 
   await startCli({
     restoreSessionId: argv.restore,
     continueLastSession: argv.continue,
+    bypassPermissions: argv.dangerouslySkipPermissions,
   });
 }
 

package/src/managers/InputManager.ts

@@ -1,5 +1,9 @@
 import { FileItem } from "../components/FileSelector.js";
-import { searchFiles as searchFilesUtil } from "../utils/fileSearch.js";
+import {
+  searchFiles as searchFilesUtil,
+  PermissionMode,
+  Logger,
+} from "wave-agent-sdk";
 import { readClipboardImage } from "../utils/clipboard.js";
 import type { Key } from "ink";
 
@@ -42,6 +46,8 @@ export interface InputManagerCallbacks {
   onSaveMemory?: (message: string, type: "project" | "user") => Promise<void>;
   onAbortMessage?: () => void;
   onResetHistoryNavigation?: () => void;
+  onPermissionModeChange?: (mode: PermissionMode) => void;
+  logger?: Logger;
 }
 
 export class InputManager {
@@ -93,18 +99,26 @@ export class InputManager {
   private showBashManager: boolean = false;
   private showMcpManager: boolean = false;
 
+  // Permission mode state
+  private permissionMode: PermissionMode = "default";
+
   // Flag to prevent handleInput conflicts when selector selection occurs
   private selectorJustUsed: boolean = false;
 
   private callbacks: InputManagerCallbacks;
+  private logger?: Logger;
 
   constructor(callbacks: InputManagerCallbacks = {}) {
     this.callbacks = callbacks;
+    this.logger = callbacks.logger;
   }
 
   // Update callbacks
   updateCallbacks(callbacks: Partial<InputManagerCallbacks>) {
     this.callbacks = { ...this.callbacks, ...callbacks };
+    if (callbacks.logger) {
+      this.logger = callbacks.logger;
+    }
   }
 
   // Core input methods
@@ -854,6 +868,29 @@ export class InputManager {
     this.callbacks.onMcpManagerStateChange?.(show);
   }
 
+  // Permission mode methods
+  getPermissionMode(): PermissionMode {
+    return this.permissionMode;
+  }
+
+  setPermissionMode(mode: PermissionMode): void {
+    this.permissionMode = mode;
+  }
+
+  cyclePermissionMode(): void {
+    const modes: PermissionMode[] = ["default", "acceptEdits"];
+    const currentIndex = modes.indexOf(this.permissionMode);
+    const nextIndex =
+      currentIndex === -1 ? 0 : (currentIndex + 1) % modes.length;
+    const nextMode = modes[nextIndex];
+    this.logger?.debug("Cycling permission mode", {
+      from: this.permissionMode,
+      to: nextMode,
+    });
+    this.permissionMode = nextMode;
+    this.callbacks.onPermissionModeChange?.(this.permissionMode);
+  }
+
   // Handle submit logic
   async handleSubmit(
     attachedImages: Array<{ id: number; path: string; mimeType: string }>,
@@ -907,7 +944,7 @@ export class InputManager {
 
   // Handle selector input (when any selector is active)
   handleSelectorInput(input: string, key: Key): boolean {
-    if (key.backspace || key.delete) {
+    if (key.backspace || (key.delete && !this.showBashHistorySelector)) {
       if (this.cursorPosition > 0) {
         this.deleteCharAtCursor((newInput, newCursorPosition) => {
           // Check for special character deletion
@@ -1088,6 +1125,13 @@ export class InputManager {
       return true;
     }
 
+    // Handle Shift+Tab for permission mode cycling
+    if (key.tab && key.shift) {
+      this.logger?.debug("Shift+Tab detected, cycling permission mode");
+      this.cyclePermissionMode();
+      return true;
+    }
+
     // Check if any selector is active
     if (
       this.showFileSelector ||

package/src/print-cli.ts

@@ -6,6 +6,7 @@ export interface PrintCliOptions {
   continueLastSession?: boolean;
   message?: string;
   showStats?: boolean;
+  bypassPermissions?: boolean;
 }
 
 function displayTimingInfo(startTime: Date, showStats: boolean): void {
@@ -29,6 +30,7 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
     continueLastSession,
     message,
     showStats = false,
+    bypassPermissions,
   } = options;
 
   if (
@@ -43,14 +45,31 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
   }
 
   let agent: Agent;
+  let isReasoning = false;
+  let isContent = false;
+  const subagentReasoningStates = new Map<string, boolean>();
+  const subagentContentStates = new Map<string, boolean>();
 
   // Setup callbacks for agent
   const callbacks: AgentCallbacks = {
     onAssistantMessageAdded: () => {
+      isReasoning = false;
+      isContent = false;
       // Assistant message started - no content to output yet
       process.stdout.write("\n");
     },
+    onAssistantReasoningUpdated: (chunk: string) => {
+      if (!isReasoning) {
+        process.stdout.write("💭 Reasoning:\n");
+        isReasoning = true;
+      }
+      process.stdout.write(chunk);
+    },
     onAssistantContentUpdated: (chunk: string) => {
+      if (isReasoning && !isContent) {
+        process.stdout.write("\n\n📝 Response:\n");
+        isContent = true;
+      }
       // FR-001: Stream content updates for real-time display - output only the new chunk
       process.stdout.write(chunk);
     },
@@ -87,11 +106,30 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       process.stdout.write(`   ${statusIcon} Subagent status: ${status}\n`);
     },
     // Subagent message callbacks
-    onSubagentAssistantMessageAdded: () => {
+    onSubagentAssistantMessageAdded: (subagentId: string) => {
+      subagentReasoningStates.set(subagentId, false);
+      subagentContentStates.set(subagentId, false);
       // Subagent assistant message started - add indentation
       process.stdout.write("\n   ");
     },
-    onSubagentAssistantContentUpdated: (_subagentId: string, chunk: string) => {
+    onSubagentAssistantReasoningUpdated: (
+      subagentId: string,
+      chunk: string,
+    ) => {
+      if (!subagentReasoningStates.get(subagentId)) {
+        process.stdout.write("💭 Reasoning: ");
+        subagentReasoningStates.set(subagentId, true);
+      }
+      process.stdout.write(chunk);
+    },
+    onSubagentAssistantContentUpdated: (subagentId: string, chunk: string) => {
+      if (
+        subagentReasoningStates.get(subagentId) &&
+        !subagentContentStates.get(subagentId)
+      ) {
+        process.stdout.write("\n   📝 Response: ");
+        subagentContentStates.set(subagentId, true);
+      }
       // Stream subagent content with indentation - output only the new chunk
       process.stdout.write(chunk);
     },
@@ -112,6 +150,8 @@ export async function startPrintCli(options: PrintCliOptions): Promise<void> {
       callbacks,
       restoreSessionId,
       continueLastSession,
+      permissionMode: bypassPermissions ? "bypassPermissions" : undefined,
+      // 保持流式模式以获得更好的命令行用户体验
     });
 
     // Send message if provided and not empty