wave-code 0.10.4 → 0.11.1

package/src/acp/agent.ts

@@ -9,6 +9,10 @@ import {
   listAllSessions as listAllWaveSessions,
   deleteSession as deleteWaveSession,
   truncateContent,
+  BASH_TOOL_NAME,
+  EDIT_TOOL_NAME,
+  WRITE_TOOL_NAME,
+  EXIT_PLAN_MODE_TOOL_NAME,
 } from "wave-agent-sdk";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -39,6 +43,10 @@ import {
   type SetSessionModeRequest,
   type SetSessionConfigOptionRequest,
   type SetSessionConfigOptionResponse,
+  type TextContent,
+  type ResourceLink,
+  type EmbeddedResource,
+  type ImageContent,
   AGENT_METHODS,
 } from "@agentclientprotocol/sdk";
 
@@ -74,6 +82,12 @@ export class WaveAcpAgent implements AcpAgent {
           name: "Bypass Permissions",
           description: "Automatically accept all tool calls",
         },
+        {
+          id: "dontAsk",
+          name: "Don't Ask",
+          description:
+            "Automatically deny restricted tools unless pre-approved",
+        },
       ],
     };
   }
@@ -91,6 +105,7 @@ export class WaveAcpAgent implements AcpAgent {
           { value: "acceptEdits", name: "Accept Edits" },
           { value: "plan", name: "Plan" },
           { value: "bypassPermissions", name: "Bypass Permissions" },
+          { value: "dontAsk", name: "Don't Ask" },
         ],
       },
     ];
@@ -121,6 +136,10 @@ export class WaveAcpAgent implements AcpAgent {
           list: {},
           close: {},
         },
+        promptCapabilities: {
+          image: true,
+          embeddedContext: true,
+        },
       },
     };
   }
@@ -139,7 +158,7 @@ export class WaveAcpAgent implements AcpAgent {
     const agent = await WaveAgent.create({
       workdir: cwd,
       restoreSessionId: sessionId,
-      stream: false,
+      stream: true,
       canUseTool: (context) => {
         if (!agentRef.instance) {
           throw new Error("Agent instance not yet initialized");
@@ -274,7 +293,12 @@ export class WaveAcpAgent implements AcpAgent {
     const agent = this.agents.get(sessionId);
     if (!agent) throw new Error(`Session ${sessionId} not found`);
     agent.setPermissionMode(
-      modeId as "default" | "acceptEdits" | "plan" | "bypassPermissions",
+      modeId as
+        | "default"
+        | "acceptEdits"
+        | "plan"
+        | "bypassPermissions"
+        | "dontAsk",
     );
   }
 
@@ -287,7 +311,12 @@ export class WaveAcpAgent implements AcpAgent {
 
     if (configId === "permission_mode") {
       agent.setPermissionMode(
-        value as "default" | "acceptEdits" | "plan" | "bypassPermissions",
+        value as
+          | "default"
+          | "acceptEdits"
+          | "plan"
+          | "bypassPermissions"
+          | "dontAsk",
       );
     }
 
@@ -299,6 +328,7 @@ export class WaveAcpAgent implements AcpAgent {
   async prompt(params: PromptRequest): Promise<PromptResponse> {
     const { sessionId, prompt } = params;
     logger.info(`Received prompt for session ${sessionId}`);
+    logger.debug(`Prompt content for session ${sessionId}:`, prompt);
     const agent = this.agents.get(sessionId);
     if (!agent) {
       logger.error(`Session ${sessionId} not found`);
@@ -306,25 +336,32 @@ export class WaveAcpAgent implements AcpAgent {
     }
 
     // Map ACP prompt to Wave Agent sendMessage
-    const textContent = prompt
-      .filter((block) => block.type === "text")
-      .map((block) => (block as { text: string }).text)
-      .join("\n");
-
-    const images = prompt
-      .filter((block) => block.type === "image")
-      .map((block) => {
-        const img = block as { data: string; mimeType: string };
-        return {
-          path: `data:${img.mimeType};base64,${img.data}`,
+    const textBlocks: string[] = [];
+    const images: { path: string; mimeType: string }[] = [];
+
+    for (const block of prompt) {
+      if (block.type === "text") {
+        textBlocks.push((block as TextContent).text);
+      } else if (block.type === "resource_link") {
+        const link = block as ResourceLink;
+        textBlocks.push(`[${link.name}](${link.uri})`);
+      } else if (block.type === "resource") {
+        const embedded = block as EmbeddedResource;
+        textBlocks.push(`[Resource](${embedded.resource.uri})`);
+      } else if (block.type === "image") {
+        const img = block as ImageContent;
+        images.push({
+          path: img.data.startsWith("data:")
+            ? img.data
+            : `data:${img.mimeType};base64,${img.data}`,
           mimeType: img.mimeType,
-        };
-      });
+        });
+      }
+    }
+
+    const textContent = textBlocks.join("");
 
     try {
-      logger.info(
-        `Sending message to agent: ${textContent.substring(0, 50)}...`,
-      );
       await agent.sendMessage(
         textContent,
         images.length > 0 ? images : undefined,
@@ -354,6 +391,33 @@ export class WaveAcpAgent implements AcpAgent {
     }
   }
 
+  private getAllowAlwaysName(context: ToolPermissionContext): string {
+    if (context.toolName === BASH_TOOL_NAME) {
+      const command = (context.toolInput?.command as string) || "";
+      if (command.startsWith("mkdir")) {
+        return "Yes, and auto-accept edits";
+      }
+      if (context.suggestedPrefix) {
+        const prefix =
+          context.suggestedPrefix.length > 12
+            ? context.suggestedPrefix.substring(0, 9) + "..."
+            : context.suggestedPrefix;
+        return `Yes, always allow ${prefix}`;
+      }
+      return "Yes, always allow this command";
+    }
+    if (
+      context.toolName === EDIT_TOOL_NAME ||
+      context.toolName === WRITE_TOOL_NAME
+    ) {
+      return "Yes, and auto-accept edits";
+    }
+    if (context.toolName === EXIT_PLAN_MODE_TOOL_NAME) {
+      return "Yes, auto-accept edits";
+    }
+    return "Allow Always";
+  }
+
   private async handlePermissionRequest(
     sessionId: string,
     context: ToolPermissionContext,
@@ -390,7 +454,7 @@ export class WaveAcpAgent implements AcpAgent {
         ? `${effectiveName}: ${effectiveCompactParams}`
         : effectiveName || "Tool Call";
 
-    const options: PermissionOption[] = [
+    let options: PermissionOption[] = [
       {
         optionId: "allow_once",
         name: "Allow Once",
@@ -408,6 +472,38 @@ export class WaveAcpAgent implements AcpAgent {
       },
     ];
 
+    if (
+      context.toolName === BASH_TOOL_NAME ||
+      context.toolName === EDIT_TOOL_NAME ||
+      context.toolName === WRITE_TOOL_NAME
+    ) {
+      options = [
+        {
+          optionId: "allow_once",
+          name: "Yes, proceed",
+          kind: "allow_once",
+        },
+        {
+          optionId: "allow_always",
+          name: this.getAllowAlwaysName(context),
+          kind: "allow_always",
+        },
+      ];
+    } else if (context.toolName === EXIT_PLAN_MODE_TOOL_NAME) {
+      options = [
+        {
+          optionId: "allow_once",
+          name: "Yes, manually approve edits",
+          kind: "allow_once",
+        },
+        {
+          optionId: "allow_always",
+          name: "Yes, auto-accept edits",
+          kind: "allow_always",
+        },
+      ];
+    }
+
     const content = context.toolName
       ? await this.getToolContentAsync(
           context.toolName,
@@ -446,11 +542,33 @@ export class WaveAcpAgent implements AcpAgent {
 
       switch (selectedOptionId) {
         case "allow_always":
+          if (context.toolName === BASH_TOOL_NAME) {
+            const command = (context.toolInput?.command as string) || "";
+            const rule = context.suggestedPrefix
+              ? `${context.suggestedPrefix}*`
+              : command;
+            return {
+              behavior: "allow",
+              newPermissionRule: `${BASH_TOOL_NAME}(${rule})`,
+            };
+          }
+          if (
+            context.toolName === EDIT_TOOL_NAME ||
+            context.toolName === WRITE_TOOL_NAME
+          ) {
+            return {
+              behavior: "allow",
+              newPermissionMode: "acceptEdits",
+            };
+          }
           return {
             behavior: "allow",
-            newPermissionRule: `${context.toolName}(*)`,
+            newPermissionRule: context.toolName,
           };
         case "allow_once":
+          if (context.toolName === EXIT_PLAN_MODE_TOOL_NAME) {
+            return { behavior: "allow", newPermissionMode: "default" };
+          }
           return { behavior: "allow" };
         case "reject_once":
           return { behavior: "deny", message: "Rejected by user" };
@@ -564,6 +682,14 @@ export class WaveAcpAgent implements AcpAgent {
           oldText: parameters.old_string as string,
           newText: parameters.new_string as string,
         });
+      } else if (name === EXIT_PLAN_MODE_TOOL_NAME) {
+        contents.push({
+          type: "content",
+          content: {
+            type: "text",
+            text: parameters.plan_content as string,
+          },
+        });
       }
     }
 

package/src/cli.tsx

@@ -18,6 +18,8 @@ export async function startCli(options: CliOptions): Promise<void> {
     permissionMode,
     pluginDirs,
     tools,
+    allowedTools,
+    disallowedTools,
     worktreeSession,
     workdir,
     version,
@@ -41,6 +43,8 @@ export async function startCli(options: CliOptions): Promise<void> {
       permissionMode={permissionMode}
       pluginDirs={pluginDirs}
       tools={tools}
+      allowedTools={allowedTools}
+      disallowedTools={disallowedTools}
       worktreeSession={worktreeSession}
       workdir={workdir}
       version={version}

package/src/components/App.tsx

@@ -26,6 +26,8 @@ const AppWithProviders: React.FC<AppWithProvidersProps> = ({
   permissionMode,
   pluginDirs,
   tools,
+  allowedTools,
+  disallowedTools,
   worktreeSession,
   workdir,
   version,
@@ -98,6 +100,8 @@ const AppWithProviders: React.FC<AppWithProvidersProps> = ({
       permissionMode={permissionMode}
       pluginDirs={pluginDirs}
       tools={tools}
+      allowedTools={allowedTools}
+      disallowedTools={disallowedTools}
       workdir={workdir}
       worktreeSession={worktreeSession}
       version={version}
@@ -162,6 +166,8 @@ export const App: React.FC<AppProps> = ({
   permissionMode,
   pluginDirs,
   tools,
+  allowedTools,
+  disallowedTools,
   worktreeSession,
   workdir,
   version,
@@ -178,6 +184,8 @@ export const App: React.FC<AppProps> = ({
         permissionMode={permissionMode}
         pluginDirs={pluginDirs}
         tools={tools}
+        allowedTools={allowedTools}
+        disallowedTools={disallowedTools}
         worktreeSession={worktreeSession}
         workdir={workdir}
         version={version}

package/src/components/BackgroundTaskManager.tsx

@@ -10,6 +10,7 @@ interface Task {
   startTime: number;
   exitCode?: number;
   runtime?: number;
+  outputPath?: string;
 }
 
 export interface BackgroundTaskManagerProps {
@@ -30,6 +31,7 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
     stdout: string;
     stderr: string;
     status: string;
+    outputPath?: string;
   } | null>(null);
 
   // Convert backgroundTasks to local Task format
@@ -43,6 +45,7 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
         startTime: task.startTime,
         exitCode: task.exitCode,
         runtime: task.runtime,
+        outputPath: task.outputPath,
       })),
     );
   }, [backgroundTasks]);
@@ -189,6 +192,13 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
               )}
             </Text>
           </Box>
+          {task.outputPath && (
+            <Box>
+              <Text>
+                <Text color="blue">Log File:</Text> {task.outputPath}
+              </Text>
+            </Box>
+          )}
         </Box>
 
         {detailOutput.stdout && (
@@ -313,7 +323,13 @@ export const BackgroundTaskManager: React.FC<BackgroundTaskManagerProps> = ({
               {isSelected && (
                 <Box marginLeft={4} flexDirection="column">
                   <Text color="gray" dimColor>
-                    Started: {formatTime(task.startTime)}
+                    {task.outputPath ? (
+                      <Text>
+                        <Text color="blue">Log File:</Text> {task.outputPath}
+                      </Text>
+                    ) : (
+                      `Started: ${formatTime(task.startTime)}`
+                    )}
                     {task.runtime !== undefined &&
                       ` | Runtime: ${formatDuration(task.runtime)}`}
                     {task.exitCode !== undefined && ` | Exit: ${task.exitCode}`}

package/src/components/ChatInterface.tsx

@@ -45,6 +45,8 @@ export const ChatInterface: React.FC = () => {
 
   const model = getModelConfig().model;
 
+  const displayMessages = messages;
+
   const handleDetailsHeightMeasured = useCallback((height: number) => {
     setDetailsHeight(height);
   }, []);
@@ -116,9 +118,10 @@ export const ChatInterface: React.FC = () => {
   return (
     <Box flexDirection="column">
       <MessageList
-        messages={messages}
+        messages={displayMessages}
         isExpanded={isExpanded}
         forceStatic={isConfirmationVisible && isConfirmationTooTall}
+        isFinished={!isLoading && !isCommandRunning && !isCompressing}
         version={version}
         workdir={workdir}
         model={model}

package/src/components/ConfirmationDetails.tsx

@@ -97,7 +97,11 @@ export const ConfirmationDetails: React.FC<ConfirmationDetailsProps> = ({
   );
 
   if (isStatic) {
-    return <Static items={[1]}>{() => content}</Static>;
+    return (
+      <Static items={[1]}>
+        {(item) => <React.Fragment key={item}>{content}</React.Fragment>}
+      </Static>
+    );
   }
 
   return content;

package/src/components/ConfirmationSelector.tsx

@@ -100,11 +100,18 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
       return "Yes, auto-accept edits";
     }
     if (toolName === BASH_TOOL_NAME) {
+      const command = (toolInput?.command as string) || "";
+      if (command.trim().startsWith("mkdir")) {
+        return "Yes, and auto-accept edits";
+      }
       if (suggestedPrefix) {
         return `Yes, and don't ask again for: ${suggestedPrefix}`;
       }
       return "Yes, and don't ask again for this command in this workdir";
     }
+    if (toolName.startsWith("mcp__")) {
+      return `Yes, and don't ask again for: ${toolName}`;
+    }
     return "Yes, and auto-accept edits";
   };
 
@@ -363,10 +370,17 @@ export const ConfirmationSelector: React.FC<ConfirmationSelectorProps> = ({
         }
       } else if (state.selectedOption === "auto") {
         if (toolName === BASH_TOOL_NAME) {
-          const rule = suggestedPrefix
-            ? `Bash(${suggestedPrefix}*)`
-            : `Bash(${toolInput?.command})`;
-          onDecision({ behavior: "allow", newPermissionRule: rule });
+          const command = (toolInput?.command as string) || "";
+          if (command.trim().startsWith("mkdir")) {
+            onDecision({ behavior: "allow", newPermissionMode: "acceptEdits" });
+          } else {
+            const rule = suggestedPrefix
+              ? `Bash(${suggestedPrefix}*)`
+              : `Bash(${toolInput?.command})`;
+            onDecision({ behavior: "allow", newPermissionRule: rule });
+          }
+        } else if (toolName.startsWith("mcp__")) {
+          onDecision({ behavior: "allow", newPermissionRule: toolName });
         } else {
           onDecision({ behavior: "allow", newPermissionMode: "acceptEdits" });
         }

package/src/components/InputBox.tsx

@@ -30,6 +30,7 @@ export interface InputBoxProps {
   sendMessage?: (
     message: string,
     images?: Array<{ path: string; mimeType: string }>,
+    longTextMap?: Record<string, string>,
   ) => void;
   abortMessage?: () => void;
   // MCP related properties
@@ -57,7 +58,6 @@ export const InputBox: React.FC<InputBoxProps> = ({
     backgroundCurrentTask,
     messages,
     getFullMessageThread,
-    clearMessages,
     sessionId,
     workingDirectory,
   } = useChat();
@@ -113,7 +113,6 @@ export const InputBox: React.FC<InputBoxProps> = ({
     onAbortMessage: abortMessage,
     onBackgroundCurrentTask: backgroundCurrentTask,
     onPermissionModeChange: setChatPermissionMode,
-    onClearMessages: clearMessages,
     sessionId,
     workdir: workingDirectory,
     getFullMessageThread,

package/src/components/MessageList.tsx

@@ -8,6 +8,7 @@ export interface MessageListProps {
   messages: Message[];
   isExpanded?: boolean;
   forceStatic?: boolean;
+  isFinished?: boolean;
   version?: string;
   workdir?: string;
   model?: string;
@@ -19,6 +20,7 @@ export const MessageList = React.memo(
     messages,
     isExpanded = false,
     forceStatic = false,
+    isFinished = false,
     version,
     workdir,
     model,
@@ -38,22 +40,15 @@ export const MessageList = React.memo(
       </Box>
     );
 
-    // Limit messages when expanded to prevent long rendering times
-    const maxExpandedMessages = 20;
-    const shouldLimitMessages =
-      isExpanded && messages.length > maxExpandedMessages;
-    const displayMessages = shouldLimitMessages
-      ? messages.slice(-maxExpandedMessages)
-      : messages;
+    // Limit messages to prevent long rendering times
+    const maxMessages = 10;
 
     // Flatten messages into blocks with metadata
-    const allBlocks = displayMessages.flatMap((message, index) => {
-      const messageIndex = shouldLimitMessages
-        ? messages.length - maxExpandedMessages + index
-        : index;
+    const allBlocks = messages.flatMap((message, messageIndex) => {
       return message.blocks.map((block, blockIndex) => ({
         block,
         message,
+        messageIndex,
         isLastMessage: messageIndex === messages.length - 1,
         // Unique key for each block to help Static component
         key: `${message.id}-${blockIndex}`,
@@ -62,12 +57,8 @@ export const MessageList = React.memo(
 
     // Determine which blocks are static vs dynamic
     const blocksWithStatus = allBlocks.map((item) => {
-      const { block, isLastMessage } = item;
-      const isDynamic =
-        !forceStatic &&
-        isLastMessage &&
-        ((block.type === "tool" && block.stage !== "end") ||
-          (block.type === "bang" && block.isRunning));
+      const { isLastMessage } = item;
+      const isDynamic = !forceStatic && !isFinished && isLastMessage;
       return { ...item, isDynamic };
     });
 
@@ -86,7 +77,13 @@ export const MessageList = React.memo(
     }, [dynamicBlocks, isExpanded, onDynamicBlocksHeightMeasured]);
 
     const staticItems = [
-      { isWelcome: true, key: "welcome", block: undefined, message: undefined },
+      {
+        isWelcome: true,
+        key: "welcome",
+        block: undefined,
+        message: undefined,
+        messageIndex: -1,
+      },
       ...staticBlocks.map((b) => ({ ...b, isWelcome: false })),
     ];
 
@@ -103,6 +100,12 @@ export const MessageList = React.memo(
                   </React.Fragment>
                 );
               }
+              if (
+                messages.length > maxMessages &&
+                item.messageIndex < messages.length - maxMessages
+              ) {
+                return null;
+              }
               return (
                 <MessageBlockItem
                   key={item.key}

package/src/constants/commands.ts

@@ -1,12 +1,6 @@
 import type { SlashCommand } from "wave-agent-sdk";
 
 export const AVAILABLE_COMMANDS: SlashCommand[] = [
-  {
-    id: "clear",
-    name: "clear",
-    description: "Clear the chat session and terminal",
-    handler: () => {}, // Handler here won't be used, actual processing is in the hook
-  },
   {
     id: "tasks",
     name: "tasks",