wave-agent-sdk 0.0.8 → 0.0.10

package/src/tools/bashTool.ts

@@ -1,5 +1,7 @@
 import { spawn, ChildProcess } from "child_process";
 import { logger } from "../utils/globalLogger.js";
+import { stripAnsiColors } from "../utils/stringUtils.js";
+import { handleLargeOutput } from "../utils/largeOutputHandler.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 
 /**
@@ -45,6 +47,7 @@ export const bashTool: ToolPlugin = {
   ): Promise<ToolResult> => {
     const command = args.command as string;
     const runInBackground = args.run_in_background as boolean | undefined;
+    const description = args.description as string | undefined;
     // Set default timeout: 60s for foreground, no timeout for background
     const timeout =
       (args.timeout as number | undefined) ??
@@ -70,6 +73,45 @@ export const bashTool: ToolPlugin = {
       };
     }
 
+    // Permission check after validation but before real operation
+    if (
+      context.permissionManager &&
+      context.permissionMode &&
+      context.permissionMode !== "bypassPermissions"
+    ) {
+      if (context.permissionManager.isRestrictedTool("Bash")) {
+        try {
+          const permissionContext = context.permissionManager.createContext(
+            "Bash",
+            context.permissionMode,
+            context.canUseToolCallback,
+            {
+              command,
+              description,
+              run_in_background: runInBackground,
+              timeout,
+            },
+          );
+          const permissionResult =
+            await context.permissionManager.checkPermission(permissionContext);
+
+          if (permissionResult.behavior === "deny") {
+            return {
+              success: false,
+              content: "",
+              error: `Bash operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
+            };
+          }
+        } catch {
+          return {
+            success: false,
+            content: "",
+            error: "Permission check failed",
+          };
+        }
+      }
+    }
+
     if (runInBackground) {
       // Background execution
       const backgroundBashManager = context?.backgroundBashManager;
@@ -168,18 +210,21 @@ export const bashTool: ToolPlugin = {
           handleAbort();
           return;
         }
-        context.abortSignal.addEventListener("abort", () => handleAbort());
+        // Use { once: true } to prevent listener accumulation on signal reuse
+        context.abortSignal.addEventListener("abort", () => handleAbort(), {
+          once: true,
+        });
       }
 
       child.stdout?.on("data", (data) => {
         if (!isAborted) {
-          outputBuffer += data.toString();
+          outputBuffer += stripAnsiColors(data.toString());
         }
       });
 
       child.stderr?.on("data", (data) => {
         if (!isAborted) {
-          errorBuffer += data.toString();
+          errorBuffer += stripAnsiColors(data.toString());
         }
       });
 
@@ -193,15 +238,32 @@ export const bashTool: ToolPlugin = {
           const combinedOutput =
             outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
 
-          resolve({
-            success: exitCode === 0,
-            content:
-              combinedOutput || `Command executed with exit code: ${exitCode}`,
-            error:
-              exitCode !== 0
-                ? `Command failed with exit code: ${exitCode}`
-                : undefined,
-          });
+          // Handle large output by writing to temp file if needed
+          const finalOutput =
+            combinedOutput || `Command executed with exit code: ${exitCode}`;
+          handleLargeOutput(finalOutput)
+            .then(({ content, filePath }) => {
+              resolve({
+                success: exitCode === 0,
+                content,
+                filePath,
+                error:
+                  exitCode !== 0
+                    ? `Command failed with exit code: ${exitCode}`
+                    : undefined,
+              });
+            })
+            .catch((error) => {
+              logger.warn(`Error handling large output: ${error}`);
+              resolve({
+                success: exitCode === 0,
+                content: finalOutput,
+                error:
+                  exitCode !== 0
+                    ? `Command failed with exit code: ${exitCode}`
+                    : undefined,
+              });
+            });
         }
       });
 
@@ -220,9 +282,15 @@ export const bashTool: ToolPlugin = {
     });
   },
   formatCompactParams: (params: Record<string, unknown>) => {
+    const description = params.description as string;
     const command = params.command as string;
     const runInBackground = params.run_in_background as boolean;
-    return `${command}${runInBackground ? " background" : ""}`;
+
+    if (description) {
+      return description;
+    }
+
+    return `${command}${runInBackground ? " (background)" : ""}`;
   },
 };
 
@@ -299,15 +367,20 @@ export const bashOutputTool: ToolPlugin = {
 
     let content = "";
     if (output.stdout) {
-      content += output.stdout;
+      content += stripAnsiColors(output.stdout);
     }
     if (output.stderr) {
-      content += (content ? "\n" : "") + output.stderr;
+      content += (content ? "\n" : "") + stripAnsiColors(output.stderr);
     }
 
+    const finalContent = content || "No output available";
+    const { content: processedContent, filePath } =
+      await handleLargeOutput(finalContent);
+
     return {
       success: true,
-      content: content || "No output available",
+      content: processedContent,
+      filePath,
       shortResult: `${bashId}: ${output.status}${shell.exitCode !== undefined ? ` (${shell.exitCode})` : ""}`,
       error: undefined,
     };

package/src/tools/deleteFileTool.ts

@@ -46,6 +46,42 @@ export const deleteFileTool: ToolPlugin = {
     try {
       const filePath = resolvePath(targetFile, context.workdir);
 
+      // Permission check after validation but before real operation
+      if (
+        context.permissionManager &&
+        context.permissionMode &&
+        context.permissionMode !== "bypassPermissions"
+      ) {
+        if (context.permissionManager.isRestrictedTool("Delete")) {
+          try {
+            const permissionContext = context.permissionManager.createContext(
+              "Delete",
+              context.permissionMode,
+              context.canUseToolCallback,
+              { target_file: targetFile },
+            );
+            const permissionResult =
+              await context.permissionManager.checkPermission(
+                permissionContext,
+              );
+
+            if (permissionResult.behavior === "deny") {
+              return {
+                success: false,
+                content: "",
+                error: `Delete operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
+              };
+            }
+          } catch {
+            return {
+              success: false,
+              content: "",
+              error: "Permission check failed",
+            };
+          }
+        }
+      }
+
       // Delete file
       await unlink(filePath);
 

package/src/tools/editTool.ts

@@ -2,7 +2,6 @@ import { readFile, writeFile } from "fs/promises";
 import { logger } from "../utils/globalLogger.js";
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { resolvePath, getDisplayPath } from "../utils/path.js";
-import { diffLines } from "diff";
 
 /**
  * Format compact parameter display
@@ -143,6 +142,47 @@ export const editTool: ToolPlugin = {
         replacementCount = 1;
       }
 
+      // Permission check after validation but before real operation
+      if (
+        context.permissionManager &&
+        context.permissionMode &&
+        context.permissionMode !== "bypassPermissions"
+      ) {
+        if (context.permissionManager.isRestrictedTool("Edit")) {
+          try {
+            const permissionContext = context.permissionManager.createContext(
+              "Edit",
+              context.permissionMode,
+              context.canUseToolCallback,
+              {
+                file_path: filePath,
+                old_string: oldString,
+                new_string: newString,
+                replace_all: replaceAll,
+              },
+            );
+            const permissionResult =
+              await context.permissionManager.checkPermission(
+                permissionContext,
+              );
+
+            if (permissionResult.behavior === "deny") {
+              return {
+                success: false,
+                content: "",
+                error: `Edit operation denied by user, reason: ${permissionResult.message || "No reason provided"}`,
+              };
+            }
+          } catch {
+            return {
+              success: false,
+              content: "",
+              error: "Permission check failed",
+            };
+          }
+        }
+      }
+
       // Write file
       try {
         await writeFile(resolvedPath, newContent, "utf-8");
@@ -154,9 +194,6 @@ export const editTool: ToolPlugin = {
         };
       }
 
-      // Generate diff information
-      const diffResult = diffLines(originalContent, newContent);
-
       const shortResult = replaceAll
         ? `Replaced ${replacementCount} instances`
         : "Text replaced successfully";
@@ -168,9 +205,6 @@ export const editTool: ToolPlugin = {
         content: shortResult,
         shortResult,
         filePath: resolvedPath,
-        originalContent,
-        newContent,
-        diffResult,
       };
     } catch (error) {
       const errorMessage =