wave-code 0.0.6 → 0.0.8

package/src/components/MessageItem.tsx

@@ -2,26 +2,24 @@ import React from "react";
 import { Box, Text } from "ink";
 import type { Message } from "wave-agent-sdk";
 import { MessageSource } from "wave-agent-sdk";
-import { DiffViewer } from "./DiffViewer.js";
 import { CommandOutputDisplay } from "./CommandOutputDisplay.js";
 import { ToolResultDisplay } from "./ToolResultDisplay.js";
 import { MemoryDisplay } from "./MemoryDisplay.js";
 import { CompressDisplay } from "./CompressDisplay.js";
 import { SubagentBlock } from "./SubagentBlock.js";
+import { ReasoningDisplay } from "./ReasoningDisplay.js";
 import { Markdown } from "./Markdown.js";
 
 export interface MessageItemProps {
   message: Message;
   isExpanded: boolean;
   shouldShowHeader: boolean;
-  isStatic?: boolean;
 }
 
 export const MessageItem = ({
   message,
   isExpanded,
   shouldShowHeader,
-  isStatic = true,
 }: MessageItemProps) => {
   if (message.blocks.length === 0) return null;
   return (
@@ -49,11 +47,7 @@ export const MessageItem = ({
                     🔗{" "}
                   </Text>
                 )}
-                {isStatic ? (
-                  <Markdown>{block.content}</Markdown>
-                ) : (
-                  <Text>{block.content.split("\n").slice(-10).join("\n")}</Text>
-                )}
+                <Markdown>{block.content}</Markdown>
               </Box>
             )}
 
@@ -63,10 +57,6 @@ export const MessageItem = ({
               </Box>
             )}
 
-            {block.type === "diff" && (
-              <DiffViewer block={block} isStatic={isStatic} />
-            )}
-
             {block.type === "command_output" && (
               <CommandOutputDisplay block={block} isExpanded={isExpanded} />
             )}
@@ -96,6 +86,8 @@ export const MessageItem = ({
             )}
 
             {block.type === "subagent" && <SubagentBlock block={block} />}
+
+            {block.type === "reasoning" && <ReasoningDisplay block={block} />}
           </Box>
         ))}
       </Box>

package/src/components/MessageList.tsx

@@ -75,7 +75,6 @@ export const MessageList = React.memo(
                 message={message}
                 shouldShowHeader={previousMessage?.role !== message.role}
                 isExpanded={isExpanded}
-                isStatic={true}
               />
             );
           }}
@@ -92,7 +91,6 @@ export const MessageList = React.memo(
                 message={message}
                 shouldShowHeader={previousMessage?.role !== message.role}
                 isExpanded={isExpanded}
-                isStatic={false}
               />
             </Box>
           );

package/src/components/ReasoningDisplay.tsx

@@ -0,0 +1,33 @@
+import React from "react";
+import { Box } from "ink";
+import type { ReasoningBlock } from "wave-agent-sdk";
+import { Markdown } from "./Markdown.js";
+
+interface ReasoningDisplayProps {
+  block: ReasoningBlock;
+}
+
+export const ReasoningDisplay: React.FC<ReasoningDisplayProps> = ({
+  block,
+}) => {
+  const { content } = block;
+
+  if (!content || !content.trim()) {
+    return null;
+  }
+
+  return (
+    <Box
+      borderRight={false}
+      borderTop={false}
+      borderBottom={false}
+      borderStyle="classic"
+      borderColor="blue"
+      paddingLeft={1}
+    >
+      <Box flexDirection="column">
+        <Markdown>{content}</Markdown>
+      </Box>
+    </Box>
+  );
+};

package/src/components/ToolResultDisplay.tsx

@@ -1,6 +1,7 @@
 import React from "react";
 import { Box, Text } from "ink";
 import type { ToolBlock } from "wave-agent-sdk";
+import { DiffDisplay } from "./DiffDisplay.js";
 
 interface ToolResultDisplayProps {
   block: ToolBlock;
@@ -133,6 +134,9 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
           </Text>
         </Box>
       )}
+
+      {/* Diff display - handled by DiffDisplay component */}
+      <DiffDisplay toolBlock={block} />
     </Box>
   );
 };

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,19 @@ 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> };
+  showConfirmation: (
+    toolName: string,
+    toolInput?: Record<string, unknown>,
+  ) => Promise<PermissionDecision>;
+  hideConfirmation: () => void;
+  handleConfirmationDecision: (decision: PermissionDecision) => void;
+  handleConfirmationCancel: () => void;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -66,9 +85,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 +122,52 @@ 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> } | undefined
+  >();
+  const [confirmationQueue, setConfirmationQueue] = useState<
+    Array<{
+      toolName: string;
+      toolInput?: Record<string, unknown>;
+      resolver: (decision: PermissionDecision) => void;
+      reject: () => void;
+    }>
+  >([]);
+  const [currentConfirmation, setCurrentConfirmation] = useState<{
+    toolName: string;
+    toolInput?: Record<string, unknown>;
+    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>,
+    ): Promise<PermissionDecision> => {
+      return new Promise<PermissionDecision>((resolve, reject) => {
+        const queueItem = {
+          toolName,
+          toolInput,
+          resolver: resolve,
+          reject,
+        };
+
+        setConfirmationQueue((prev) => [...prev, queueItem]);
+        // processNextConfirmation will be called via useEffect
       });
-    }
-  });
+    },
+    [],
+  );
 
   // Initialize AI manager
   useEffect(() => {
@@ -142,19 +197,46 @@ 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,
+                );
+              } 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 +249,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 +264,12 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     };
 
     initializeAgent();
-  }, [restoreSessionId, continueLastSession]);
+  }, [
+    restoreSessionId,
+    continueLastSession,
+    bypassPermissions,
+    showConfirmation,
+  ]);
 
   // Cleanup on unmount
   useEffect(() => {
@@ -278,6 +366,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 +402,63 @@ 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 });
+      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 +480,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 ||