wave-agent-sdk 0.16.9 → 0.16.12

package/src/managers/aiManager.ts

@@ -40,6 +40,7 @@ import { logOTelEvent } from "../telemetry/events.js";
 export interface AIManagerCallbacks {
   onCompactionStateChange?: (isCompacting: boolean) => void;
   onUsageAdded?: (usage: Usage) => void;
+  onCwdChange?: (newCwd: string) => void;
 }
 
 export interface AIManagerOptions {
@@ -64,6 +65,8 @@ export class AIManager {
   private subagentType?: string; // Store subagent type for hook context
   private stream: boolean; // Streaming mode flag
   private modelOverride?: string;
+  private _onCwdChange?: (newCwd: string) => void; // Store callback for CWD changes
+  private originalWorkdir: string;
   private consecutiveCompactionFailures: number = 0;
   private readonly maxTurns?: number;
 
@@ -77,6 +80,8 @@ export class AIManager {
     this.stream = options.stream ?? true; // Default to true if not specified
     this.callbacks = options.callbacks ?? {};
     this.modelOverride = options.modelOverride;
+    this._onCwdChange = options.callbacks?.onCwdChange; // Initialize onCwdChange
+    this.originalWorkdir = options.workdir;
     this.maxTurns = options.maxTurns;
   }
 
@@ -174,6 +179,10 @@ export class AIManager {
     return this.container.get<string>("Workdir") ?? process.cwd();
   }
 
+  public getOriginalWorkdir(): string {
+    return this.originalWorkdir;
+  }
+
   /**
    * Update the working directory mid-session (e.g., when entering/exiting a worktree).
    * Also updates process.chdir() so bash commands use the new directory.
@@ -183,6 +192,10 @@ export class AIManager {
     process.chdir(newWorkdir);
   }
 
+  public setOnCwdChange(callback: (newCwd: string) => void): void {
+    this._onCwdChange = callback;
+  }
+
   private isCompacting: boolean = false;
   private callbacks: AIManagerCallbacks;
 
@@ -248,6 +261,7 @@ export class AIManager {
       if (toolPlugin?.formatCompactParams) {
         const context: ToolContext = {
           workdir: this.getWorkdir(),
+          originalWorkdir: this.originalWorkdir,
           taskManager: this.taskManager,
         };
         return toolPlugin.formatCompactParams(toolArgs, context);
@@ -998,6 +1012,7 @@ export class AIManager {
                 abortSignal: toolAbortController.signal,
                 backgroundTaskManager: this.backgroundTaskManager,
                 workdir: this.getWorkdir(),
+                originalWorkdir: this.originalWorkdir,
                 messageId: this.messageManager.getMessages().slice(-1)[0]?.id,
                 sessionId: this.messageManager.getSessionId(),
                 toolCallId: toolId,
@@ -1016,6 +1031,28 @@ export class AIManager {
                     stage: "running", // Keep it in running stage while updating result
                   });
                 },
+                onCwdChange: async (newCwd: string) => {
+                  const oldCwd = this.getWorkdir();
+                  this.container.register("Workdir", newCwd);
+                  this._onCwdChange?.(newCwd);
+                  if (this.hookManager) {
+                    const sessionId = this.messageManager.getSessionId();
+                    const transcriptPath =
+                      this.messageManager.getTranscriptPath();
+                    const env = Object.fromEntries(
+                      Object.entries(process.env).filter(
+                        (e) => e[1] !== undefined,
+                      ),
+                    ) as Record<string, string>;
+                    await this.hookManager.executeCwdChangedHooks(
+                      oldCwd,
+                      newCwd,
+                      sessionId,
+                      transcriptPath,
+                      env,
+                    );
+                  }
+                },
               };
 
               // Execute tool

package/src/managers/hookManager.ts

@@ -44,23 +44,13 @@ export class HookManager {
   }
 
   /**
-   * Load and merge hook configurations from user and project settings
-   * Project settings take precedence over user settings
+   * Load hook configuration from programmatic source (AgentOptions.hooks)
    */
-  loadConfiguration(
-    userHooks?: PartialHookConfiguration,
-    projectHooks?: PartialHookConfiguration,
-  ): void {
+  loadConfiguration(hooks?: PartialHookConfiguration): void {
     const merged: PartialHookConfiguration = {};
 
-    // Start with user hooks
-    if (userHooks) {
-      this.mergeHooksConfiguration(merged, userHooks);
-    }
-
-    // Override with project hooks (project settings take precedence)
-    if (projectHooks) {
-      this.mergeHooksConfiguration(merged, projectHooks);
+    if (hooks) {
+      this.mergeHooksConfiguration(merged, hooks);
     }
 
     // Validate merged configuration
@@ -654,9 +644,12 @@ export class HookManager {
   ): void {
     for (const [event, configs] of Object.entries(source)) {
       if (isValidHookEvent(event)) {
-        // For now, completely replace event configs rather than merging
-        // This ensures project settings completely override user settings for each event
-        target[event] = [...configs];
+        // Concatenate hook configs so multiple sources (programmatic, file-based, plugins) coexist
+        if (!target[event]) {
+          target[event] = [...configs];
+        } else {
+          target[event] = [...target[event], ...configs];
+        }
       }
     }
   }
@@ -676,6 +669,7 @@ export class HookManager {
       event === "SubagentStop" ||
       event === "WorktreeCreate" ||
       event === "WorktreeRemove" ||
+      event === "CwdChanged" ||
       event === "SessionStart" ||
       event === "SessionEnd"
     ) {
@@ -781,6 +775,7 @@ export class HookManager {
           PermissionRequest: 0,
           WorktreeCreate: 0,
           WorktreeRemove: 0,
+          CwdChanged: 0,
           SessionStart: 0,
           SessionEnd: 0,
         },
@@ -796,6 +791,7 @@ export class HookManager {
       PermissionRequest: 0,
       WorktreeCreate: 0,
       WorktreeRemove: 0,
+      CwdChanged: 0,
       SessionStart: 0,
       SessionEnd: 0,
     };
@@ -822,6 +818,35 @@ export class HookManager {
     };
   }
 
+  /**
+   * Execute CwdChanged hooks.
+   */
+  async executeCwdChangedHooks(
+    oldCwd: string,
+    newCwd: string,
+    sessionId: string,
+    transcriptPath: string,
+    env: Record<string, string>,
+  ): Promise<HookExecutionResult[]> {
+    const context: ExtendedHookExecutionContext = {
+      event: "CwdChanged",
+      projectDir: this.workdir,
+      timestamp: new Date(),
+      sessionId,
+      transcriptPath,
+      cwd: newCwd,
+      oldCwd,
+      newCwd,
+      env,
+    };
+    const results = await this.executeHooks("CwdChanged", context);
+    if (results.length > 0) {
+      // For CwdChanged hooks, we don't block, just log errors
+      this.processHookResults("CwdChanged", results);
+    }
+    return results;
+  }
+
   /**
    * Register hooks provided by a plugin
    */

package/src/managers/mcpManager.ts

@@ -34,27 +34,19 @@ export interface McpManagerOptions {
   logger?: Logger;
   /** Pre-configured MCP servers passed from constructor options */
   mcpServers?: Record<string, McpServerConfig>;
-  /** Wave server URL for resolving ${WAVE_SERVER_URL} templates in MCP configs */
-  serverUrl?: string;
-  /** SSO token for resolving ${WAVE_SSO_TOKEN} templates in MCP configs */
-  ssoToken?: string;
 }
 
 /**
  * Expand environment variables in a string value.
  * Supports ${VAR} and ${VAR:-default} patterns.
  */
-const WAVE_TEMPLATE_VARS = [
-  "WAVE_SERVER_URL",
-  "WAVE_SSO_TOKEN",
-  "WAVE_PLUGIN_ROOT",
-];
+const WAVE_TEMPLATE_VARS = ["WAVE_PLUGIN_ROOT"];
 
 export function expandEnvVars(value: string): string {
   return value.replace(/\$\{([^}]+)\}/g, (_match, expr: string) => {
     const [varName, ...rest] = expr.split(":-");
     const defaultValue = rest.join(":-");
-    // Skip Wave-specific template variables — they are handled by resolveMcpTemplates
+    // Skip Wave-specific template variables — they are handled at spawn time
     if (WAVE_TEMPLATE_VARS.includes(varName)) {
       return _match; // return original ${...} string untouched
     }
@@ -63,81 +55,15 @@ export function expandEnvVars(value: string): string {
 }
 
 /**
- * Context for resolving Wave-specific MCP template variables.
+ * Walk an MCP config and resolve environment variables in all string fields.
+ * Only expands ${VAR} from process.env (skipping WAVE_PLUGIN_ROOT which is
+ * handled at spawn time).
  */
-export interface McpResolverContext {
-  serverUrl?: string; // resolves ${WAVE_SERVER_URL}
-  ssoToken?: string; // resolves ${WAVE_SSO_TOKEN}
-}
-
-/**
- * Walk a single McpServerConfig and replace Wave template variables.
- * Only replaces ${WAVE_SERVER_URL} and ${WAVE_SSO_TOKEN} — does not touch
- * arbitrary env vars (that is what expandEnvVars handles).
- */
-export function resolveMcpTemplates(
-  config: McpServerConfig,
-  ctx: McpResolverContext,
-): McpServerConfig {
-  const resolved: McpServerConfig = { ...config };
-
-  const replace = (value: string): string => {
-    let result = value;
-    if (ctx.serverUrl !== undefined) {
-      result = result.replace(/\$\{WAVE_SERVER_URL\}/g, ctx.serverUrl);
-    }
-    if (ctx.ssoToken !== undefined) {
-      result = result.replace(/\$\{WAVE_SSO_TOKEN\}/g, ctx.ssoToken);
-    }
-    return result;
-  };
-
-  if (resolved.command) {
-    resolved.command = replace(resolved.command);
-  }
-
-  if (resolved.args) {
-    resolved.args = resolved.args.map(replace);
-  }
-
-  if (resolved.env) {
-    const resolvedEnv: Record<string, string> = {};
-    for (const [key, val] of Object.entries(resolved.env)) {
-      resolvedEnv[key] = replace(val);
-    }
-    resolved.env = resolvedEnv;
-  }
-
-  if (resolved.url) {
-    resolved.url = replace(resolved.url);
-  }
-
-  if (resolved.headers) {
-    const resolvedHeaders: Record<string, string> = {};
-    for (const [key, val] of Object.entries(resolved.headers)) {
-      resolvedHeaders[key] = replace(val);
-    }
-    resolved.headers = resolvedHeaders;
-  }
-
-  return resolved;
-}
-
-/**
- * Walk an MCP config and resolve variables in all string fields.
- * Applies two steps in order:
- *   1. expandEnvVars — resolves ${VAR} from process.env
- *   2. resolveMcpTemplates — resolves ${WAVE_SERVER_URL}, ${WAVE_SSO_TOKEN} from context
- */
-export function resolveMcpConfig(
-  config: McpConfig,
-  ctx?: McpResolverContext,
-): McpConfig {
+export function resolveMcpConfig(config: McpConfig): McpConfig {
   const resolved: McpConfig = { mcpServers: {} };
 
   for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-    // Step 1: expand env vars from process.env
-    let resolvedServer: McpServerConfig = { ...serverConfig };
+    const resolvedServer: McpServerConfig = { ...serverConfig };
 
     if (resolvedServer.command) {
       resolvedServer.command = expandEnvVars(resolvedServer.command);
@@ -167,11 +93,6 @@ export function resolveMcpConfig(
       resolvedServer.headers = resolvedHeaders;
     }
 
-    // Step 2: resolve Wave template variables from context
-    if (ctx) {
-      resolvedServer = resolveMcpTemplates(resolvedServer, ctx);
-    }
-
     resolved.mcpServers[name] = resolvedServer;
   }
 
@@ -187,7 +108,6 @@ export class McpManager {
   private callbacks: McpManagerCallbacks;
   private mcpServers: Record<string, McpServerConfig> | undefined;
 
-  private resolverCtx: McpResolverContext | undefined;
   private reconnectTimers: Map<string, NodeJS.Timeout> = new Map();
   private reconnectAttempts: Map<string, number> = new Map();
 
@@ -197,10 +117,6 @@ export class McpManager {
   ) {
     this.callbacks = options.callbacks || {};
     this.mcpServers = options.mcpServers;
-    this.resolverCtx = {
-      serverUrl: options.serverUrl,
-      ssoToken: options.ssoToken,
-    };
   }
 
   /**
@@ -273,7 +189,7 @@ export class McpManager {
     try {
       const configContent = await fs.readFile(this.configPath, "utf-8");
       const rawConfig: McpConfig = JSON.parse(configContent);
-      const workspaceConfig = resolveMcpConfig(rawConfig, this.resolverCtx);
+      const workspaceConfig = resolveMcpConfig(rawConfig);
 
       // Extract original (pre-resolution) URLs for safe display
       const originalUrls: Record<string, string | undefined> = {};
@@ -368,8 +284,8 @@ export class McpManager {
     // Capture original URL before any resolution for safe display
     const originalUrl = config.url;
 
-    // Step 1: expand env vars from process.env (e.g. ${TAVILY_API_KEY})
-    let resolvedConfig: McpServerConfig = { ...config };
+    // Expand env vars from process.env (e.g. ${TAVILY_API_KEY})
+    const resolvedConfig: McpServerConfig = { ...config };
     if (resolvedConfig.command) {
       resolvedConfig.command = expandEnvVars(resolvedConfig.command);
     }
@@ -394,12 +310,6 @@ export class McpManager {
       resolvedConfig.headers = resolvedHeaders;
     }
 
-    // Step 2: resolve Wave template variables (e.g. ${WAVE_SERVER_URL}, ${WAVE_SSO_TOKEN})
-    resolvedConfig = resolveMcpTemplates(
-      resolvedConfig,
-      this.resolverCtx ?? { serverUrl: undefined, ssoToken: undefined },
-    );
-
     const newServer: McpServerStatus = {
       name,
       config: resolvedConfig,
@@ -921,84 +831,6 @@ export class McpManager {
     await Promise.all(disconnectPromises);
   }
 
-  /**
-   * Update credentials and reconnect MCP servers that use template variables.
-   * Called after SSO login to refresh ${WAVE_SSO_TOKEN} and ${WAVE_SERVER_URL}.
-   */
-  async refreshCredentials(
-    serverUrl?: string,
-    ssoToken?: string,
-  ): Promise<void> {
-    // Update resolver context
-    this.resolverCtx = {
-      serverUrl: serverUrl ?? this.resolverCtx?.serverUrl,
-      ssoToken: ssoToken ?? this.resolverCtx?.ssoToken,
-    };
-
-    logger?.info(
-      `MCP refreshCredentials: serverUrl=${serverUrl}, hasToken=${!!ssoToken}`,
-    );
-
-    // Collect servers that need reconnection
-    const serversToReconnect: string[] = [];
-
-    for (const [name, server] of this.servers) {
-      // Re-resolve config with new credentials
-      const originalConfig = server.config;
-      const resolvedConfig = resolveMcpTemplates(
-        originalConfig,
-        this.resolverCtx,
-      );
-
-      // Update the stored config, preserving originalUrl
-      this.servers.set(name, {
-        ...server,
-        config: resolvedConfig,
-      });
-
-      if (this.config && this.config.mcpServers[name]) {
-        this.config.mcpServers[name] = resolvedConfig;
-      }
-
-      // Determine if reconnection is needed
-      const wasConnected = this.connections.has(name);
-      const wasDisconnected =
-        server.status === "disconnected" ||
-        server.status === "error" ||
-        server.status === "reconnecting";
-
-      if (wasConnected) {
-        // Disconnect first, then reconnect with new resolved config
-        await this.disconnectServer(name);
-        serversToReconnect.push(name);
-      } else if (wasDisconnected) {
-        // Was disconnected or errored — try to reconnect now that we have credentials
-        serversToReconnect.push(name);
-      }
-    }
-
-    // Reconnect servers
-    for (const name of serversToReconnect) {
-      logger?.debug(
-        `Reconnecting MCP server after credential refresh: ${name}`,
-      );
-      this.connectServer(name)
-        .then((success) => {
-          if (success) {
-            logger?.info(`Successfully reconnected MCP server: ${name}`);
-          } else {
-            logger?.warn(`Failed to reconnect MCP server: ${name}`);
-          }
-        })
-        .catch((error) => {
-          logger?.error(`Reconnection to MCP server ${name} failed:`, error);
-        });
-    }
-
-    // Trigger state change callback
-    this.callbacks.onMcpServersChange?.(this.getAllServers());
-  }
-
   // ========== Tools Registry Methods ==========
 
   /**