wave-agent-sdk 0.0.7 → 0.0.10

package/src/managers/backgroundBashManager.ts

@@ -1,4 +1,6 @@
 import { spawn } from "child_process";
+import { logger } from "../utils/globalLogger.js";
+import { stripAnsiColors } from "../utils/stringUtils.js";
 import type { BackgroundShell } from "../types/index.js";
 
 export interface BackgroundBashManagerCallbacks {
@@ -62,12 +64,12 @@ export class BackgroundBashManager {
     }
 
     child.stdout?.on("data", (data) => {
-      shell.stdout += data.toString();
+      shell.stdout += stripAnsiColors(data.toString());
       this.notifyShellsChange();
     });
 
     child.stderr?.on("data", (data) => {
-      shell.stderr += data.toString();
+      shell.stderr += stripAnsiColors(data.toString());
       this.notifyShellsChange();
     });
 
@@ -86,7 +88,7 @@ export class BackgroundBashManager {
         clearTimeout(timeoutHandle);
       }
       shell.status = "completed";
-      shell.stderr += `\nProcess error: ${error.message}`;
+      shell.stderr += `\nProcess error: ${stripAnsiColors(error.message)}`;
       shell.exitCode = 1;
       shell.runtime = Date.now() - startTime;
       this.notifyShellsChange();
@@ -127,8 +129,8 @@ export class BackgroundBashManager {
           .split("\n")
           .filter((line) => regex.test(line))
           .join("\n");
-      } catch {
-        // logger.warn(`Invalid filter regex: ${filter}`, error);
+      } catch (error) {
+        logger.warn(`Invalid filter regex: ${filter}`, error);
       }
     }
 
@@ -159,8 +161,8 @@ export class BackgroundBashManager {
           ) {
             try {
               process.kill(-shell.process.pid, "SIGKILL");
-            } catch {
-              // logger.error("Failed to force kill process:", error);
+            } catch (error) {
+              logger.error("Failed to force kill process:", error);
             }
           }
         }, 1000);
@@ -183,8 +185,8 @@ export class BackgroundBashManager {
         shell.runtime = Date.now() - shell.startTime;
         this.notifyShellsChange();
         return true;
-      } catch {
-        // logger.error("Failed to kill child process:", directKillError);
+      } catch (directKillError) {
+        logger.error("Failed to kill child process:", directKillError);
         return false;
       }
     }

package/src/managers/hookManager.ts

@@ -8,7 +8,7 @@
 import {
   type HookEvent,
   type HookEventConfig,
-  type HookConfiguration,
+  type WaveConfiguration,
   type PartialHookConfiguration,
   type HookExecutionContext,
   type ExtendedHookExecutionContext,
@@ -19,11 +19,7 @@ import {
   isValidHookEventConfig,
 } from "../types/hooks.js";
 import { HookMatcher } from "../utils/hookMatcher.js";
-import {
-  executeCommand,
-  isCommandSafe,
-  loadMergedHooksConfig,
-} from "../services/hook.js";
+import { executeCommand, isCommandSafe } from "../services/hook.js";
 import type { Logger } from "../types/index.js";
 import { MessageSource } from "../types/index.js";
 import type { MessageManager } from "./messageManager.js";
@@ -77,41 +73,41 @@ export class HookManager {
   }
 
   /**
-   * Load configuration from filesystem settings
-   * Automatically loads and merges user and project hooks configuration
+   * Load hooks configuration from a pre-loaded WaveConfiguration
+   * Configuration loading is now handled by ConfigurationService
    */
-  loadConfigurationFromSettings(): void {
+  loadConfigurationFromWaveConfig(waveConfig: WaveConfiguration | null): void {
     try {
-      this.logger?.debug(`[HookManager] Loading configuration...`);
-      const mergedConfig = loadMergedHooksConfig(this.workdir);
-      this.logger?.debug(`[HookManager] Merged config result:`, mergedConfig);
-      this.configuration = mergedConfig || undefined;
+      this.logger?.debug(
+        `[HookManager] Loading hooks configuration from pre-loaded config...`,
+      );
+
+      this.configuration = waveConfig?.hooks || undefined;
 
       // Validate the loaded configuration if it exists
-      if (mergedConfig) {
-        const validation = this.validatePartialConfiguration(mergedConfig);
+      if (waveConfig?.hooks) {
+        const validation = this.validatePartialConfiguration(waveConfig.hooks);
         if (!validation.valid) {
           throw new HookConfigurationError(
-            "filesystem settings",
+            "provided configuration",
             validation.errors,
           );
         }
       }
 
       this.logger?.debug(
-        `[HookManager] Configuration loaded successfully with ${Object.keys(mergedConfig || {}).length} event types`,
+        `[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;
 
-      // Re-throw configuration errors, but handle file system errors gracefully
+      // Re-throw configuration errors, but handle other errors gracefully
       if (error instanceof HookConfigurationError) {
         throw error;
       } else {
         this.logger?.warn(
-          "Failed to load hooks configuration from settings:",
-          error,
+          `[HookManager] Failed to load configuration, continuing with no hooks: ${(error as Error).message}`,
         );
       }
     }
@@ -194,7 +190,11 @@ export class HookManager {
             `[HookManager] Executing command ${commandIndex + 1}/${config.hooks.length} in configuration ${configIndex + 1}`,
           );
 
-          const result = await executeCommand(hookCommand.command, context);
+          const result = await executeCommand(
+            hookCommand.command,
+            context,
+            undefined,
+          );
           results.push(result);
 
           // Report individual command result
@@ -203,7 +203,7 @@ export class HookManager {
               `[HookManager] Command ${commandIndex + 1} completed successfully in ${result.duration}ms`,
             );
           } else {
-            this.logger?.warn(
+            this.logger?.debug(
               `[HookManager] Command ${commandIndex + 1} failed in ${result.duration}ms (exit code: ${result.exitCode}, timed out: ${result.timedOut})`,
             );
           }
@@ -344,6 +344,7 @@ export class HookManager {
             result: errorMessage,
             success: false,
             error: "Hook blocked tool execution",
+            stage: "end", // Hook blocking results in end stage with error
           });
         }
         return { shouldBlock: true };
@@ -364,6 +365,19 @@ export class HookManager {
         });
         return { shouldBlock: true, errorMessage };
 
+      case "Notification":
+        // For notification hooks with exit code 2, only show stderr in error block
+        messageManager.addErrorBlock(errorMessage);
+        return { shouldBlock: false };
+
+      case "SubagentStop":
+        // Similar to Stop, show error and allow blocking
+        messageManager.addUserMessage({
+          content: errorMessage,
+          source: MessageSource.HOOK,
+        });
+        return { shouldBlock: true, errorMessage };
+
       default:
         return { shouldBlock: false };
     }
@@ -395,46 +409,62 @@ export class HookManager {
   }
 
   /**
-   * Validate hook configuration structure and content
+   * Validate Wave configuration structure and content
    */
-  validateConfiguration(config: HookConfiguration): ValidationResult {
+  validateConfiguration(config: WaveConfiguration): ValidationResult {
     const errors: string[] = [];
 
     if (!config || typeof config !== "object") {
       return { valid: false, errors: ["Configuration must be an object"] };
     }
 
-    if (!config.hooks || typeof config.hooks !== "object") {
-      return {
-        valid: false,
-        errors: ["Configuration must have a hooks property"],
-      };
-    }
+    // Validate hooks if present
+    if (config.hooks) {
+      if (typeof config.hooks !== "object") {
+        errors.push("hooks property must be an object");
+      } else {
+        // Validate each hook event
+        for (const [eventName, eventConfigs] of Object.entries(config.hooks)) {
+          // Validate event name
+          if (!isValidHookEvent(eventName)) {
+            errors.push(`Invalid hook event: ${eventName}`);
+            continue;
+          }
 
-    // Validate each hook event
-    for (const [eventName, eventConfigs] of Object.entries(config.hooks)) {
-      // Validate event name
-      if (!isValidHookEvent(eventName)) {
-        errors.push(`Invalid hook event: ${eventName}`);
-        continue;
-      }
+          // Validate event configurations
+          if (!Array.isArray(eventConfigs)) {
+            errors.push(
+              `Hook event ${eventName} must be an array of configurations`,
+            );
+            continue;
+          }
 
-      // Validate event configurations
-      if (!Array.isArray(eventConfigs)) {
-        errors.push(
-          `Hook event ${eventName} must be an array of configurations`,
-        );
-        continue;
+          eventConfigs.forEach((eventConfig, index) => {
+            const configErrors = this.validateEventConfig(
+              eventName as HookEvent,
+              eventConfig,
+              index,
+            );
+            errors.push(...configErrors);
+          });
+        }
       }
+    }
 
-      eventConfigs.forEach((eventConfig, index) => {
-        const configErrors = this.validateEventConfig(
-          eventName as HookEvent,
-          eventConfig,
-          index,
-        );
-        errors.push(...configErrors);
-      });
+    // Validate environment variables if present
+    if (config.env) {
+      if (typeof config.env !== "object" || Array.isArray(config.env)) {
+        errors.push("env property must be an object");
+      } else {
+        for (const [key, value] of Object.entries(config.env)) {
+          if (typeof key !== "string" || key.trim() === "") {
+            errors.push(`Invalid environment variable key: ${key}`);
+          }
+          if (typeof value !== "string") {
+            errors.push(`Environment variable ${key} must have a string value`);
+          }
+        }
+      }
     }
 
     return {
@@ -544,7 +574,10 @@ export class HookManager {
 
     // Validate non-tool events don't have unexpected tool names
     if (
-      (event === "UserPromptSubmit" || event === "Stop") &&
+      (event === "UserPromptSubmit" ||
+        event === "Stop" ||
+        event === "Notification" ||
+        event === "SubagentStop") &&
       context.toolName !== undefined
     ) {
       this.logger?.warn(
@@ -616,7 +649,12 @@ export class HookManager {
     toolName?: string,
   ): boolean {
     // For events that don't use matchers, config always applies
-    if (event === "UserPromptSubmit" || event === "Stop") {
+    if (
+      event === "UserPromptSubmit" ||
+      event === "Stop" ||
+      event === "Notification" ||
+      event === "SubagentStop"
+    ) {
       return true;
     }
 
@@ -662,7 +700,13 @@ export class HookManager {
     }
 
     // Validate that non-tool events don't have matchers
-    if ((event === "UserPromptSubmit" || event === "Stop") && config.matcher) {
+    if (
+      (event === "UserPromptSubmit" ||
+        event === "Stop" ||
+        event === "Notification" ||
+        event === "SubagentStop") &&
+      config.matcher
+    ) {
       errors.push(`${prefix}: Event ${event} should not have a matcher`);
     }
 
@@ -697,6 +741,8 @@ export class HookManager {
           PostToolUse: 0,
           UserPromptSubmit: 0,
           Stop: 0,
+          SubagentStop: 0,
+          Notification: 0,
         },
       };
     }
@@ -706,6 +752,8 @@ export class HookManager {
       PostToolUse: 0,
       UserPromptSubmit: 0,
       Stop: 0,
+      SubagentStop: 0,
+      Notification: 0,
     };
 
     let totalConfigs = 0;