wave-agent-sdk 0.8.1 → 0.8.3

package/src/managers/hookManager.ts

@@ -80,10 +80,6 @@ export class HookManager {
    */
   loadConfigurationFromWaveConfig(waveConfig: WaveConfiguration | null): void {
     try {
-      logger?.debug(
-        `[HookManager] Loading hooks configuration from pre-loaded config...`,
-      );
-
       this.configuration = waveConfig?.hooks || undefined;
 
       // Validate the loaded configuration if it exists
@@ -96,10 +92,6 @@ export class HookManager {
           );
         }
       }
-
-      logger?.debug(
-        `[HookManager] Hooks configuration loaded successfully with ${Object.keys(waveConfig?.hooks || {}).length} event types`,
-      );
     } catch (error) {
       // If loading fails, start with undefined configuration (no hooks)
       this.configuration = undefined;
@@ -139,24 +131,15 @@ export class HookManager {
     }
 
     if (!this.configuration) {
-      logger?.debug(
-        `[HookManager] No configuration loaded, skipping ${event} hooks`,
-      );
       return [];
     }
 
     const eventConfigs = this.configuration[event];
     if (!eventConfigs || eventConfigs.length === 0) {
-      logger?.debug(`[HookManager] No hooks configured for ${event} event`);
       return [];
     }
 
-    logger?.debug(
-      `[HookManager] Starting ${event} hook execution with ${eventConfigs.length} configurations`,
-    );
-
     const results: HookExecutionResult[] = [];
-    const startTime = Date.now();
 
     for (
       let configIndex = 0;
@@ -167,16 +150,9 @@ export class HookManager {
 
       // Check if this config applies to the current context
       if (!this.configApplies(config, event, context.toolName)) {
-        logger?.debug(
-          `[HookManager] Skipping configuration ${configIndex + 1}: matcher '${config.matcher}' does not match tool '${context.toolName}'`,
-        );
         continue;
       }
 
-      logger?.debug(
-        `[HookManager] Executing configuration ${configIndex + 1} with ${config.hooks.length} commands (matcher: ${config.matcher || "any"})`,
-      );
-
       // Execute all commands for this configuration
       for (
         let commandIndex = 0;
@@ -186,10 +162,6 @@ export class HookManager {
         const hookCommand = config.hooks[commandIndex];
 
         try {
-          logger?.debug(
-            `[HookManager] Executing command ${commandIndex + 1}/${config.hooks.length} in configuration ${configIndex + 1}`,
-          );
-
           const result = await executeCommand(
             hookCommand.command,
             context,
@@ -197,17 +169,6 @@ export class HookManager {
           );
           results.push(result);
 
-          // Report individual command result
-          if (result.success) {
-            logger?.debug(
-              `[HookManager] Command ${commandIndex + 1} completed successfully in ${result.duration}ms`,
-            );
-          } else {
-            logger?.debug(
-              `[HookManager] Command ${commandIndex + 1} failed in ${result.duration}ms (exit code: ${result.exitCode}, timed out: ${result.timedOut})`,
-            );
-          }
-
           // Continue with next command even if this one fails
           // This allows for non-critical hooks to fail without stopping the workflow
         } catch (error) {
@@ -228,15 +189,6 @@ export class HookManager {
       }
     }
 
-    // Generate execution summary
-    const totalDuration = Date.now() - startTime;
-    const summary = this.generateExecutionSummary(
-      event,
-      results,
-      totalDuration,
-    );
-    logger?.debug(`[HookManager] ${event} execution summary: ${summary}`);
-
     return results;
   }
 
@@ -797,9 +749,5 @@ export class HookManager {
     }
 
     this.mergeHooksConfiguration(this.configuration, hooks);
-
-    logger?.debug(
-      `Registered plugin hooks. Total event types: ${Object.keys(this.configuration).length}`,
-    );
   }
 }

package/src/managers/liveConfigManager.ts

@@ -83,8 +83,6 @@ export class LiveConfigManager {
     projectPaths?: string[],
   ): Promise<void> {
     try {
-      logger?.debug("Live Config: Initializing configuration watching...");
-
       this.userConfigPaths = userPaths;
       this.projectConfigPaths = projectPaths;
 
@@ -94,16 +92,9 @@ export class LiveConfigManager {
       // Start watching user configs that exist
       for (const userPath of userPaths) {
         if (existsSync(userPath)) {
-          logger?.debug(
-            `Live Config: Starting to watch user config: ${userPath}`,
-          );
           await this.fileWatcher.watchFile(userPath, (event) =>
             this.handleFileChange(event, "user"),
           );
-        } else {
-          logger?.debug(
-            `Live Config: User config file does not exist: ${userPath}`,
-          );
         }
       }
 
@@ -114,24 +105,14 @@ export class LiveConfigManager {
             if (projectPath.endsWith("settings.local.json")) {
               await ensureGlobalGitIgnore("**/.wave/settings.local.json");
             }
-            logger?.debug(
-              `Live Config: Starting to watch project config: ${projectPath}`,
-            );
             await this.fileWatcher.watchFile(projectPath, (event) =>
               this.handleFileChange(event, "project"),
             );
-          } else {
-            logger?.debug(
-              `Live Config: Project config file does not exist: ${projectPath}`,
-            );
           }
         }
       }
 
       this.isWatching = true;
-      logger?.debug(
-        "Live Config: Configuration watching initialized successfully",
-      );
     } catch (error) {
       const errorMessage = `Failed to initialize configuration watching: ${(error as Error).message}`;
       logger?.error(`Live Config: ${errorMessage}`);
@@ -151,7 +132,6 @@ export class LiveConfigManager {
    */
   async initialize(): Promise<void> {
     if (this.isInitialized) {
-      logger?.debug("Already initialized");
       return;
     }
 
@@ -163,9 +143,6 @@ export class LiveConfigManager {
       await this.initializeWatching(userPaths, projectPaths);
 
       this.isInitialized = true;
-      logger?.debug(
-        "Live configuration management initialized with file watching",
-      );
     } catch (error) {
       logger?.error(`Failed to initialize: ${(error as Error).message}`);
       throw error;
@@ -181,8 +158,6 @@ export class LiveConfigManager {
     }
 
     try {
-      logger?.debug("Live Config: Shutting down configuration manager...");
-
       this.isWatching = false;
 
       // Cleanup file watcher
@@ -193,7 +168,6 @@ export class LiveConfigManager {
       this.lastValidConfiguration = null;
 
       this.isInitialized = false;
-      logger?.debug("Live configuration management shutdown completed");
     } catch (error) {
       logger?.error(`Error during shutdown: ${(error as Error).message}`);
       throw error;
@@ -206,15 +180,12 @@ export class LiveConfigManager {
    */
   private async reloadConfiguration(): Promise<WaveConfiguration> {
     if (this.reloadInProgress) {
-      logger?.debug("Live Config: Reload already in progress, skipping");
       return this.currentConfiguration || {};
     }
 
     this.reloadInProgress = true;
 
     try {
-      logger?.debug("Live Config: Reloading configuration from files...");
-
       // Load merged configuration using ConfigurationService
       const loadResult: ConfigurationLoadResult =
         await this.configurationService.loadMergedConfiguration(this.workdir);
@@ -237,9 +208,6 @@ export class LiveConfigManager {
 
         // Use fallback configuration if available
         if (this.lastValidConfiguration) {
-          logger?.debug(
-            "Live Config: Using previous valid configuration due to loading errors",
-          );
           this.currentConfiguration = this.lastValidConfiguration;
 
           // Apply environment variables to configuration service if configured
@@ -266,24 +234,6 @@ export class LiveConfigManager {
         }
       }
 
-      // Log success with detailed information
-      if (newConfig) {
-        logger?.debug(
-          `Live Config: Configuration loaded successfully from ${loadResult.sourcePath || "merged sources"}`,
-        );
-
-        // Log detailed configuration info
-        const hookCount = Object.keys(newConfig.hooks || {}).length;
-        const envCount = Object.keys(newConfig.env || {}).length;
-        logger?.debug(
-          `Live Config: Loaded ${hookCount} hook events and ${envCount} environment variables`,
-        );
-      } else {
-        logger?.debug(
-          "Live Config: No configuration found (using empty configuration)",
-        );
-      }
-
       // Log warnings from successful loading
       if (loadResult.warnings && loadResult.warnings.length > 0) {
         logger?.warn(
@@ -300,9 +250,6 @@ export class LiveConfigManager {
 
           // Use previous valid configuration for error recovery
           if (this.lastValidConfiguration) {
-            logger?.debug(
-              "Live Config: Using previous valid configuration due to validation errors",
-            );
             this.currentConfiguration = this.lastValidConfiguration;
 
             // Apply environment variables to configuration service if configured
@@ -339,9 +286,6 @@ export class LiveConfigManager {
       // Save as last valid configuration if it's valid and not empty
       if (newConfig && (newConfig.hooks || newConfig.env)) {
         this.lastValidConfiguration = { ...newConfig };
-        logger?.debug(
-          "Live Config: Saved current configuration as last valid backup",
-        );
       }
 
       // Note: Environment variables are already applied by loadMergedConfiguration()
@@ -378,10 +322,6 @@ export class LiveConfigManager {
         }
       }
 
-      logger?.debug(
-        `Live Config: Configuration reload completed successfully with ${Object.keys(newConfig?.hooks || {}).length} event types and ${Object.keys(newConfig?.env || {}).length} environment variables`,
-      );
-
       return this.currentConfiguration;
     } catch (error) {
       const errorMessage = `Configuration reload failed with exception: ${(error as Error).message}`;
@@ -389,9 +329,6 @@ export class LiveConfigManager {
 
       // Use previous valid configuration for error recovery
       if (this.lastValidConfiguration) {
-        logger?.debug(
-          "Live Config: Using previous valid configuration due to reload exception",
-        );
         this.currentConfiguration = this.lastValidConfiguration;
 
         // Apply environment variables to configuration service if configured
@@ -424,7 +361,6 @@ export class LiveConfigManager {
    * Reload configuration from files (public method)
    */
   async reload(): Promise<WaveConfiguration> {
-    logger?.debug("Manually reloading configuration...");
     return await this.reloadConfiguration();
   }
 
@@ -464,16 +400,9 @@ export class LiveConfigManager {
     event: FileWatchEvent,
     source: Scope,
   ): Promise<void> {
-    logger?.debug(
-      `Live Config: File ${event.type} detected for ${source} config: ${event.path}`,
-    );
-
     try {
       // Handle file deletion
       if (event.type === "delete") {
-        logger?.debug(
-          `Live Config: ${source} config file deleted: ${event.path}`,
-        );
         // Reload configuration without the deleted file
         await this.reloadConfiguration();
         return;
@@ -481,10 +410,6 @@ export class LiveConfigManager {
 
       // Handle file creation or modification
       if (event.type === "change" || event.type === "create") {
-        logger?.debug(
-          `Live Config: ${source} config file ${event.type}: ${event.path}`,
-        );
-
         if (
           source === "project" &&
           event.path.endsWith("settings.local.json") &&

package/src/managers/messageManager.ts

@@ -9,6 +9,7 @@ import {
   removeLastUserMessage,
   UserMessageParams,
   type AgentToolBlockUpdateParams,
+  generateMessageId,
 } from "../utils/messageOperations.js";
 import type { Message, Usage, SlashCommand } from "../types/index.js";
 import { join } from "path";
@@ -422,6 +423,7 @@ export class MessageManager {
 
     // Create compressed message
     const compressMessage: Message = {
+      id: generateMessageId(),
       role: "assistant",
       blocks: [
         {

package/src/managers/permissionManager.ts

@@ -20,6 +20,7 @@ import {
   splitBashCommand,
   stripEnvVars,
   stripRedirections,
+  hasWriteRedirections,
   getSmartPrefix,
   DANGEROUS_COMMANDS,
 } from "../utils/bashParser.js";
@@ -464,6 +465,9 @@ export class PermissionManager {
       const parts = splitBashCommand(command);
 
       const isDangerous = parts.some((part) => {
+        if (hasWriteRedirections(part)) {
+          return true;
+        }
         const processedPart = stripRedirections(stripEnvVars(part));
         const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
         if (commandMatch) {
@@ -523,7 +527,17 @@ export class PermissionManager {
     // Handle Bash command rules
     if (toolName === BASH_TOOL_NAME) {
       const command = String(context.toolInput?.command || "");
-      const processedPart = stripRedirections(stripEnvVars(command));
+      const hasWriteInPattern = hasWriteRedirections(pattern);
+      const hasWriteInCommand = hasWriteRedirections(command);
+
+      // If the command has write redirections, it must match a pattern that also has write redirections
+      if (hasWriteInCommand && !hasWriteInPattern) {
+        return false;
+      }
+
+      const processedPart = hasWriteInPattern
+        ? stripEnvVars(command)
+        : stripRedirections(stripEnvVars(command));
       // For Bash commands, we want '*' to match everything including slashes and spaces
       // minimatch's default behavior for '*' is to not match across directory separators
       // We use a regex to replace '*' with '.*' (match anything)
@@ -561,6 +575,7 @@ export class PermissionManager {
     const isAllowedByRuleList = (
       ctx: ToolPermissionContext,
       rules: string[],
+      isDefaultRules: boolean = false,
     ) => {
       if (ctx.toolName === BASH_TOOL_NAME && ctx.toolInput?.command) {
         const command = String(ctx.toolInput.command);
@@ -570,53 +585,60 @@ export class PermissionManager {
         const workdir = ctx.toolInput?.workdir as string | undefined;
 
         return parts.every((part) => {
+          const hasWrite = hasWriteRedirections(part);
           const processedPart = stripRedirections(stripEnvVars(part));
 
           // Check for safe commands
-          const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
-          if (commandMatch) {
-            const cmd = commandMatch[1];
-            const args = commandMatch[2]?.trim() || "";
-
-            if (SAFE_COMMANDS.includes(cmd)) {
-              if (cmd === "pwd" || cmd === "true" || cmd === "false") {
-                return true;
-              }
-
-              if (workdir) {
-                // For cd and ls, check paths
-                const pathArgs =
-                  (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).filter(
-                    (arg) => !arg.startsWith("-"),
-                  ) || [];
-
-                if (pathArgs.length === 0) {
-                  // cd or ls without arguments operates on current dir (workdir)
+          if (!hasWrite) {
+            const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
+            if (commandMatch) {
+              const cmd = commandMatch[1];
+              const args = commandMatch[2]?.trim() || "";
+
+              if (SAFE_COMMANDS.includes(cmd)) {
+                if (cmd === "pwd" || cmd === "true" || cmd === "false") {
                   return true;
                 }
 
-                const allPathsSafe = pathArgs.every((pathArg) => {
-                  // Remove quotes if present
-                  const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
-                  const { isInside } = this.isInsideSafeZone(
-                    cleanPath,
-                    workdir,
-                  );
-                  return isInside;
-                });
-
-                if (allPathsSafe) {
-                  return true;
+                if (workdir) {
+                  // For cd and ls, check paths
+                  const pathArgs =
+                    (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).filter(
+                      (arg) => !arg.startsWith("-"),
+                    ) || [];
+
+                  if (pathArgs.length === 0) {
+                    // cd or ls without arguments operates on current dir (workdir)
+                    return true;
+                  }
+
+                  const allPathsSafe = pathArgs.every((pathArg) => {
+                    // Remove quotes if present
+                    const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
+                    const { isInside } = this.isInsideSafeZone(
+                      cleanPath,
+                      workdir,
+                    );
+                    return isInside;
+                  });
+
+                  if (allPathsSafe) {
+                    return true;
+                  }
                 }
               }
             }
           }
 
           // Check if this specific part is allowed by any rule
+          if (hasWrite && isDefaultRules) {
+            return false;
+          }
+
           // We create a temporary context with just this part of the command
           const partContext = {
             ...ctx,
-            toolInput: { ...ctx.toolInput, command: processedPart },
+            toolInput: { ...ctx.toolInput, command: part },
           };
           const allowedByRule = rules.some((rule) => {
             return this.matchesRule(partContext, rule);
@@ -643,7 +665,7 @@ export class PermissionManager {
     }
 
     // Check default allowed rules
-    return isAllowedByRuleList(context, DEFAULT_ALLOWED_RULES);
+    return isAllowedByRuleList(context, DEFAULT_ALLOWED_RULES, true);
   }
 
   /**
@@ -659,13 +681,14 @@ export class PermissionManager {
     const rules: string[] = [];
 
     for (const part of parts) {
+      const hasWrite = hasWriteRedirections(part);
       const processedPart = stripRedirections(stripEnvVars(part));
 
       // Check for safe commands
       const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
       let isSafe = false;
 
-      if (commandMatch) {
+      if (commandMatch && !hasWrite) {
         const cmd = commandMatch[1];
         const args = commandMatch[2]?.trim() || "";
 
@@ -724,11 +747,11 @@ export class PermissionManager {
           }
         }
 
-        const smartPrefix = getSmartPrefix(processedPart);
+        const smartPrefix = hasWrite ? null : getSmartPrefix(processedPart);
         if (smartPrefix) {
           rules.push(`Bash(${smartPrefix}*)`);
         } else {
-          rules.push(`Bash(${processedPart})`);
+          rules.push(`Bash(${hasWrite ? stripEnvVars(part) : processedPart})`);
         }
       }
     }

package/src/managers/pluginManager.ts

@@ -73,7 +73,45 @@ export class PluginManager {
       }
 
       const marketplaceService = new MarketplaceService();
-      const installedRegistry = await marketplaceService.getInstalledPlugins();
+      let installedRegistry = await marketplaceService.getInstalledPlugins();
+      const knownMarketplaces = await marketplaceService.listMarketplaces();
+
+      // Identify missing enabled plugins and auto-install them if marketplace is known
+      for (const pluginId of Object.keys(this.enabledPlugins)) {
+        if (this.enabledPlugins[pluginId] !== true) continue;
+
+        const [name, marketplaceName] = pluginId.split("@");
+        if (!name || !marketplaceName) continue;
+
+        const isInstalled = installedRegistry.plugins.some(
+          (p) => p.name === name && p.marketplace === marketplaceName,
+        );
+
+        if (!isInstalled) {
+          const isMarketplaceKnown = knownMarketplaces.some(
+            (m) => m.name === marketplaceName,
+          );
+
+          if (isMarketplaceKnown) {
+            logger?.info(`Auto-installing missing plugin: ${pluginId}`);
+            try {
+              await marketplaceService.installPlugin(pluginId);
+            } catch (installError) {
+              logger?.error(
+                `Failed to auto-install plugin ${pluginId}:`,
+                installError,
+              );
+            }
+          } else {
+            logger?.warn(
+              `Plugin ${pluginId} is enabled but marketplace ${marketplaceName} is unknown. Skipping auto-install.`,
+            );
+          }
+        }
+      }
+
+      // Refresh registry after potential auto-installs
+      installedRegistry = await marketplaceService.getInstalledPlugins();
 
       for (const p of installedRegistry.plugins) {
         const pluginId = `${p.name}@${p.marketplace}`;

package/src/managers/skillManager.ts

@@ -355,13 +355,19 @@ export class SkillManager {
    */
   registerPluginSkills(skills: Skill[]): void {
     for (const skill of skills) {
-      this.skillMetadata.set(skill.name, {
+      const metadata: SkillMetadata = {
         name: skill.name,
         description: skill.description,
         type: skill.type,
         skillPath: skill.skillPath,
         allowedTools: skill.allowedTools,
-      });
+        context: skill.context,
+        agent: skill.agent,
+        model: skill.model,
+        disableModelInvocation: skill.disableModelInvocation,
+        userInvocable: skill.userInvocable,
+      };
+      this.skillMetadata.set(skill.name, metadata);
       this.skillContent.set(skill.name, skill);
     }
     logger?.debug(

package/src/services/aiService.ts

@@ -399,6 +399,7 @@ export async function callAgent(
     }
   } catch (error) {
     if ((error as Error).name === "AbortError") {
+      logger.info("OpenAI request aborted");
       throw new Error("Request was aborted");
     }
 
@@ -818,6 +819,7 @@ export async function compressMessages(
     };
   } catch (error) {
     if ((error as Error).name === "AbortError") {
+      logger.info("Compression request was aborted");
       throw new Error("Compression request was aborted");
     }
     logger.error("Failed to compress messages:", error);

package/src/services/fileWatcher.ts

@@ -115,7 +115,6 @@ export class FileWatcherService extends EventEmitter {
       }
 
       this.watchers.delete(path);
-      this.logger?.debug(`Live Config: Stopped watching file: ${path}`);
     } catch (error) {
       this.logger?.warn(
         `Live Config: Error unwatching file ${path}: ${(error as Error).message}`,
@@ -199,8 +198,6 @@ export class FileWatcherService extends EventEmitter {
       entry.watcher = this.globalWatcher;
       entry.isActive = true;
       entry.errorCount = 0;
-
-      this.logger?.debug(`Live Config: Started watching file: ${entry.path}`);
     } catch (error) {
       entry.errorCount++;
       entry.isActive = false;
@@ -215,9 +212,6 @@ export class FileWatcherService extends EventEmitter {
         !entry.config.fallbackPolling &&
         entry.errorCount < entry.config.maxRetries
       ) {
-        this.logger?.debug(
-          `Live Config: Attempting polling fallback for ${entry.path}`,
-        );
         entry.config.fallbackPolling = true;
         await this.initializeWatcher(entry);
       } else {
@@ -281,7 +275,5 @@ export class FileWatcherService extends EventEmitter {
         );
       }
     }
-
-    this.logger?.debug(`Live Config: File ${type} event for ${filePath}`);
   }
 }