wave-agent-sdk 0.7.1 → 0.8.0

package/src/managers/permissionManager.ts

@@ -32,9 +32,33 @@ import {
   LS_TOOL_NAME,
 } from "../constants/tools.js";
 import { Container } from "../utils/container.js";
+import { ConfigurationService } from "../services/configurationService.js";
 
 const SAFE_COMMANDS = ["cd", "ls", "pwd", "true", "false"];
 
+const DEFAULT_ALLOWED_RULES = [
+  "Bash(git status*)",
+  "Bash(git diff*)",
+  "Bash(git log*)",
+  "Bash(git show*)",
+  "Bash(git branch*)",
+  "Bash(git tag*)",
+  "Bash(git remote*)",
+  "Bash(git ls-files*)",
+  "Bash(git rev-parse*)",
+  "Bash(git config --list*)",
+  "Bash(git config -l*)",
+  "Bash(git cat-file*)",
+  "Bash(git count-objects*)",
+  "Bash(echo*)",
+  "Bash(which*)",
+  "Bash(type*)",
+  "Bash(hostname*)",
+  "Bash(whoami*)",
+  "Bash(date*)",
+  "Bash(uptime*)",
+];
+
 import { logger } from "../utils/globalLogger.js";
 
 export interface PermissionManagerOptions {
@@ -93,10 +117,6 @@ export class PermissionManager {
   updateConfiguredDefaultMode(defaultMode?: PermissionMode): void {
     const oldEffectiveMode = this.getCurrentEffectiveMode();
 
-    logger?.debug("Updating configured default permission mode", {
-      previous: this.configuredDefaultMode,
-      new: defaultMode,
-    });
     this.configuredDefaultMode = defaultMode;
 
     const newEffectiveMode = this.getCurrentEffectiveMode();
@@ -104,31 +124,49 @@ export class PermissionManager {
       oldEffectiveMode !== newEffectiveMode &&
       this.onConfiguredDefaultModeChange
     ) {
-      logger?.debug(
-        "Effective permission mode changed due to configuration update",
-        {
-          oldMode: oldEffectiveMode,
-          newMode: newEffectiveMode,
-        },
-      );
       this.onConfiguredDefaultModeChange(newEffectiveMode);
     }
   }
 
   /**
-   * Get all currently allowed rules
+   * Get the configured default mode
+   */
+  public getConfiguredDefaultMode(): PermissionMode | undefined {
+    return this.configuredDefaultMode;
+  }
+
+  /**
+   * Get all currently allowed rules (user-defined)
    */
   public getAllowedRules(): string[] {
     return [...this.allowedRules];
   }
 
+  /**
+   * Get all currently denied rules
+   */
+  public getDeniedRules(): string[] {
+    return [...this.deniedRules];
+  }
+
+  /**
+   * Get all additional directories
+   */
+  public getAdditionalDirectories(): string[] {
+    return [...this.additionalDirectories];
+  }
+
+  /**
+   * Get all default allowed rules
+   */
+  public getDefaultAllowedRules(): string[] {
+    return [...DEFAULT_ALLOWED_RULES];
+  }
+
   /**
    * Update the allowed rules (e.g., when configuration reloads)
    */
   updateAllowedRules(rules: string[]): void {
-    logger?.debug("Updating allowed permission rules", {
-      count: rules.length,
-    });
     this.allowedRules = rules;
   }
 
@@ -136,9 +174,6 @@ export class PermissionManager {
    * Update the denied rules (e.g., when configuration reloads)
    */
   updateDeniedRules(rules: string[]): void {
-    logger?.debug("Updating denied permission rules", {
-      count: rules.length,
-    });
     this.deniedRules = rules;
   }
 
@@ -146,10 +181,6 @@ export class PermissionManager {
    * Add temporary rules for the current session
    */
   public addTemporaryRules(rules: string[]): void {
-    logger?.debug("Adding temporary permission rules", {
-      count: rules.length,
-      rules,
-    });
     this.temporaryRules.push(...rules);
   }
 
@@ -157,7 +188,6 @@ export class PermissionManager {
    * Clear all temporary rules
    */
   public clearTemporaryRules(): void {
-    logger?.debug("Clearing temporary permission rules");
     this.temporaryRules = [];
   }
 
@@ -165,9 +195,6 @@ export class PermissionManager {
    * Update the additional directories (e.g., when configuration reloads)
    */
   updateAdditionalDirectories(directories: string[]): void {
-    logger?.debug("Updating additional directories", {
-      count: directories.length,
-    });
     this.additionalDirectories = directories.map((dir) => {
       if (this.workdir && !path.isAbsolute(dir)) {
         return path.resolve(this.workdir, dir);
@@ -180,9 +207,6 @@ export class PermissionManager {
    * Update the working directory
    */
   updateWorkdir(workdir: string): void {
-    logger?.debug("Updating working directory", {
-      workdir,
-    });
     this.workdir = workdir;
   }
 
@@ -190,7 +214,6 @@ export class PermissionManager {
    * Set the current plan file path
    */
   public setPlanFilePath(path: string | undefined): void {
-    logger?.debug("Setting plan file path", { path });
     this.planFilePath = path;
   }
 
@@ -228,12 +251,6 @@ export class PermissionManager {
       }
     }
 
-    logger?.debug("Path is outside Safe Zone", {
-      absolutePath,
-      workdir: effectiveWorkdir,
-      additionalDirectories: this.additionalDirectories,
-    });
-
     return { isInside: false, resolvedPath: absolutePath };
   }
 
@@ -252,23 +269,15 @@ export class PermissionManager {
   ): PermissionMode {
     // CLI override takes highest precedence
     if (cliPermissionMode !== undefined) {
-      logger?.debug("Using CLI permission mode override", {
-        cliMode: cliPermissionMode,
-        configuredDefault: this.configuredDefaultMode,
-      });
       return cliPermissionMode;
     }
 
     // Use configured default mode if available
     if (this.configuredDefaultMode !== undefined) {
-      logger?.debug("Using configured default permission mode", {
-        configuredDefault: this.configuredDefaultMode,
-      });
       return this.configuredDefaultMode;
     }
 
     // Fall back to system default
-    logger?.debug("Using system default permission mode");
     return "default";
   }
 
@@ -279,12 +288,6 @@ export class PermissionManager {
   async checkPermission(
     context: ToolPermissionContext,
   ): Promise<PermissionDecision> {
-    logger?.debug("Checking permission for tool", {
-      toolName: context.toolName,
-      permissionMode: context.permissionMode,
-      hasCallback: !!context.canUseToolCallback,
-    });
-
     // 0. Check denied rules first - Deny always takes precedence
     for (const rule of this.deniedRules) {
       if (this.matchesRule(context, rule)) {
@@ -301,9 +304,6 @@ export class PermissionManager {
 
     // 1. If bypassPermissions mode, always allow
     if (context.permissionMode === "bypassPermissions") {
-      logger?.debug("Permission bypassed for tool", {
-        toolName: context.toolName,
-      });
       return { behavior: "allow" };
     }
 
@@ -331,12 +331,6 @@ export class PermissionManager {
             );
             // Fall through to normal permission check flow to trigger confirmation prompt
           } else {
-            logger?.debug(
-              "Permission automatically accepted for tool in acceptEdits mode",
-              {
-                toolName: context.toolName,
-              },
-            );
             return { behavior: "allow" };
           }
         }
@@ -345,9 +339,6 @@ export class PermissionManager {
 
     // 1.2 Check if tool call is allowed by persistent or temporary rules
     if (this.isAllowedByRule(context)) {
-      logger?.debug("Permission allowed by persistent rule", {
-        toolName: context.toolName,
-      });
       return { behavior: "allow" };
     }
 
@@ -362,10 +353,6 @@ export class PermissionManager {
           const absolutePlanPath = path.resolve(this.planFilePath);
 
           if (absoluteTargetPath === absolutePlanPath) {
-            logger?.debug("Allowing write to plan file in plan mode", {
-              toolName: context.toolName,
-              targetPath,
-            });
             return { behavior: "allow" };
           }
         }
@@ -379,23 +366,19 @@ export class PermissionManager {
 
     // 2. If not a restricted tool, always allow
     if (!this.isRestrictedTool(context.toolName)) {
-      logger?.debug("Tool is not restricted, allowing", {
-        toolName: context.toolName,
-      });
       return { behavior: "allow" };
     }
 
     // 3. If custom callback provided, call it and return result
     if (context.canUseToolCallback) {
       try {
-        logger?.debug("Calling custom permission callback for tool", {
-          toolName: context.toolName,
-        });
         const decision = await context.canUseToolCallback(context);
-        logger?.debug("Custom callback returned decision", {
-          toolName: context.toolName,
-          decision,
-        });
+        if (decision.behavior !== "allow") {
+          logger?.debug("Custom callback returned decision", {
+            toolName: context.toolName,
+            decision,
+          });
+        }
         return decision;
       } catch (error) {
         const errorMessage =
@@ -429,14 +412,7 @@ export class PermissionManager {
    * Determine if a tool requires permission checks based on its name
    */
   isRestrictedTool(toolName: string): boolean {
-    const isRestricted = (RESTRICTED_TOOLS as readonly string[]).includes(
-      toolName,
-    );
-    logger?.debug("Checking if tool is restricted", {
-      toolName,
-      isRestricted,
-    });
-    return isRestricted;
+    return (RESTRICTED_TOOLS as readonly string[]).includes(toolName);
   }
 
   /**
@@ -521,14 +497,6 @@ export class PermissionManager {
       }
     }
 
-    logger?.debug("Created permission context", {
-      toolName,
-      permissionMode,
-      hasCallback: !!callback,
-      hasToolInput: !!toolInput,
-      suggestedPrefix,
-    });
-
     return context;
   }
 
@@ -562,8 +530,9 @@ export class PermissionManager {
       const regexPattern = pattern
         .replace(/[.+^${}()|[\]\\?]/g, "\\$&") // Escape regex special chars including ?
         .replace(/\*/g, ".*"); // Replace * with .*
-      const regex = new RegExp(`^${regexPattern}$`);
-      return regex.test(processedPart);
+      const regex = new RegExp(`^${regexPattern}$`, "s");
+      const matched = regex.test(processedPart);
+      return matched;
     }
 
     // Handle path-based rules (e.g., "Read(**/*.env)")
@@ -649,9 +618,9 @@ export class PermissionManager {
             ...ctx,
             toolInput: { ...ctx.toolInput, command: processedPart },
           };
-          const allowedByRule = rules.some((rule) =>
-            this.matchesRule(partContext, rule),
-          );
+          const allowedByRule = rules.some((rule) => {
+            return this.matchesRule(partContext, rule);
+          });
 
           if (allowedByRule) return true;
 
@@ -669,7 +638,12 @@ export class PermissionManager {
     }
 
     // Check persistent allowed rules
-    return isAllowedByRuleList(context, this.allowedRules);
+    if (isAllowedByRuleList(context, this.allowedRules)) {
+      return true;
+    }
+
+    // Check default allowed rules
+    return isAllowedByRuleList(context, DEFAULT_ALLOWED_RULES);
   }
 
   /**
@@ -761,4 +735,53 @@ export class PermissionManager {
 
     return rules;
   }
+
+  /**
+   * Add a persistent permission rule
+   * @param rule - The rule to add (e.g., "Bash(ls)")
+   */
+  public async addPermissionRule(rule: string): Promise<void> {
+    if (!this.workdir) {
+      throw new Error("Working directory not set in PermissionManager");
+    }
+
+    // 1. Expand rule if it's a Bash command
+    let rulesToAdd = [rule];
+    const bashMatch = rule.match(/^Bash\((.*)\)$/);
+    if (bashMatch) {
+      const command = bashMatch[1];
+      rulesToAdd = this.expandBashRule(command, this.workdir);
+    }
+
+    const configurationService = this.container.get<ConfigurationService>(
+      "ConfigurationService",
+    );
+
+    for (const ruleToAdd of rulesToAdd) {
+      // 2. Update PermissionManager state
+      const currentRules = this.getAllowedRules();
+      const defaultRules = this.getDefaultAllowedRules();
+      if (
+        !currentRules.includes(ruleToAdd) &&
+        !defaultRules.includes(ruleToAdd)
+      ) {
+        this.updateAllowedRules([...currentRules, ruleToAdd]);
+
+        // 3. Persist to settings.local.json
+        try {
+          if (configurationService) {
+            await configurationService.addAllowedRule(this.workdir, ruleToAdd);
+            this._logger?.debug("Persistent permission rule added", {
+              rule: ruleToAdd,
+            });
+          }
+        } catch (error) {
+          this._logger?.error("Failed to persist permission rule", {
+            rule: ruleToAdd,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
+    }
+  }
 }

package/src/managers/planManager.ts

@@ -4,6 +4,9 @@ import os from "node:os";
 import { generateRandomName } from "../utils/nameGenerator.js";
 
 import { Container } from "../utils/container.js";
+import { MessageManager } from "./messageManager.js";
+import { PermissionManager } from "./permissionManager.js";
+import type { PermissionMode } from "../types/permissions.js";
 
 /**
  * Manages plan files for plan mode
@@ -61,4 +64,27 @@ export class PlanManager {
   public getPlanDir(): string {
     return this.planDir;
   }
+
+  /**
+   * Handle plan mode transition, generating or clearing plan file path
+   * @param mode - The current effective permission mode
+   */
+  public handlePlanModeTransition(mode: PermissionMode): void {
+    const permissionManager =
+      this.container.get<PermissionManager>("PermissionManager");
+    const messageManager = this.container.get<MessageManager>("MessageManager");
+
+    if (mode === "plan") {
+      this.getOrGeneratePlanFilePath(messageManager?.getRootSessionId())
+        .then(({ path }) => {
+          logger?.debug("Plan file path generated", { path });
+          permissionManager?.setPlanFilePath(path);
+        })
+        .catch((error) => {
+          logger?.error("Failed to generate plan file path", error);
+        });
+    } else {
+      permissionManager?.setPlanFilePath(undefined);
+    }
+  }
 }

package/src/managers/skillManager.ts

@@ -11,6 +11,12 @@ import type {
   SkillInvocationContext,
 } from "../types/index.js";
 import { parseSkillFile, formatSkillError } from "../utils/skillParser.js";
+import { substituteCommandParameters } from "../utils/commandArgumentParser.js";
+import {
+  parseBashCommands,
+  replaceBashCommandsWithOutput,
+  executeBashCommands,
+} from "../utils/markdownParser.js";
 
 import { Container } from "../utils/container.js";
 import { logger } from "../utils/globalLogger.js";
@@ -94,6 +100,17 @@ export class SkillManager {
     return Array.from(this.skillMetadata.values());
   }
 
+  /**
+   * Get metadata for a specific skill by name
+   */
+  getSkillMetadata(name: string): SkillMetadata | undefined {
+    if (!this.initialized) {
+      throw new Error("SkillManager not initialized. Call initialize() first.");
+    }
+
+    return this.skillMetadata.get(name);
+  }
+
   /**
    * Load a specific skill by name
    * Returns the skill content that was loaded during initialization
@@ -176,17 +193,14 @@ export class SkillManager {
 
           if (parsed.isValid) {
             // Override the skill type with the collection type
-            const skillMetadata = {
+            const skillMetadata: SkillMetadata = {
               ...parsed.skillMetadata,
               type,
             };
 
             // Create full skill object with content
             const skill: Skill = {
-              name: parsed.skillMetadata.name,
-              description: parsed.skillMetadata.description,
-              type: type, // Use the collection type
-              skillPath: parsed.skillMetadata.skillPath,
+              ...skillMetadata,
               content: parsed.content,
               frontmatter: parsed.frontmatter,
               isValid: parsed.isValid,
@@ -243,12 +257,14 @@ export class SkillManager {
   /**
    * Execute a skill by name
    */
-  async executeSkill(
-    args: SkillToolArgs,
-  ): Promise<{ content: string; context?: SkillInvocationContext }> {
-    const { skill_name } = args;
+  async executeSkill(args: SkillToolArgs): Promise<{
+    content: string;
+    context?: SkillInvocationContext;
+    allowedTools?: string[];
+  }> {
+    const { skill_name, args: skillArgs } = args;
 
-    logger?.debug(`Invoking skill: ${skill_name}`);
+    logger?.debug(`Invoking skill: ${skill_name} with args: ${skillArgs}`);
 
     try {
       // Load the skill
@@ -267,12 +283,19 @@ export class SkillManager {
         };
       }
 
+      // Process skill content with arguments and bash commands
+      const processedContent = await this.processSkillContent(
+        skill,
+        skillArgs || "",
+      );
+
       // Return skill content with context
       return {
-        content: this.formatSkillContent(skill),
+        content: processedContent,
         context: {
           skillName: skill_name,
         },
+        allowedTools: skill.allowedTools,
       };
     } catch (error) {
       logger?.error(`Failed to execute skill '${skill_name}':`, error);
@@ -283,16 +306,29 @@ export class SkillManager {
   }
 
   /**
-   * Format skill content for output
+   * Process skill content with arguments and bash commands
    */
-  private formatSkillContent(skill: Skill): string {
+  private async processSkillContent(
+    skill: Skill,
+    argsString: string,
+  ): Promise<string> {
     const header = `🧠 **${skill.name}** (${skill.type} skill)\n\n`;
     const description = `*${skill.description}*\n\n`;
     const skillPath = `📁 Skill location: \`${skill.skillPath}\`\n\n`;
 
     // Extract content after frontmatter
     const contentMatch = skill.content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
-    const mainContent = contentMatch ? contentMatch[1].trim() : skill.content;
+    let mainContent = contentMatch ? contentMatch[1].trim() : skill.content;
+
+    // 1. Substitute parameters ($1, $ARGUMENTS, etc.)
+    mainContent = substituteCommandParameters(mainContent, argsString);
+
+    // 2. Parse and execute bash commands (!`command`)
+    const { commands } = parseBashCommands(mainContent);
+    if (commands.length > 0) {
+      const results = await executeBashCommands(commands, this.workdir);
+      mainContent = replaceBashCommandsWithOutput(mainContent, results);
+    }
 
     return header + description + skillPath + mainContent;
   }
@@ -324,6 +360,7 @@ export class SkillManager {
         description: skill.description,
         type: skill.type,
         skillPath: skill.skillPath,
+        allowedTools: skill.allowedTools,
       });
       this.skillContent.set(skill.name, skill);
     }