wave-agent-sdk 1.1.4 → 1.2.0

package/dist/managers/aiManager.js

@@ -2,18 +2,15 @@ import * as aiService from "../services/aiService.js";
 import { convertMessagesForAPI } from "../utils/convertMessagesForAPI.js";
 import { supportsVision } from "../utils/modelCapabilities.js";
 import { persistToolImages } from "../utils/toolImagePersistence.js";
-import { parseTaskNotificationXml, taskNotificationToXml, } from "../utils/notificationXml.js";
+import { parseTaskNotificationXml } from "../utils/notificationXml.js";
 import { estimateContextTokens } from "../utils/tokenCalculation.js";
 import { estimateTokens } from "../utils/tokenEstimate.js";
 import { getTaskReminderTurnCounts, maybeInjectTaskReminder, TASK_REMINDER_CONFIG, } from "../utils/taskReminder.js";
-import { createWriteStream, existsSync } from "node:fs";
-import * as os from "node:os";
+import { existsSync } from "node:fs";
 import * as path from "node:path";
 import { buildSystemPrompt, formatCompactSummary, getCompactPrompt, } from "../prompts/index.js";
 import { buildPlanModeReminder, buildPlanModeReEntryReminder, buildExitedPlanModeReminder, wrapInSystemReminder, } from "../prompts/planModeReminders.js";
 import { recoverTruncatedJson } from "../utils/stringUtils.js";
-import { AGENT_TOOL_NAME, TASK_CREATE_TOOL_NAME, TASK_GET_TOOL_NAME, TASK_LIST_TOOL_NAME, TASK_UPDATE_TOOL_NAME, } from "../constants/tools.js";
-import { addConsolidatedAbortListener } from "../utils/abortUtils.js";
 import { logger } from "../utils/globalLogger.js";
 import { startInteractionSpan, endInteractionSpan, startLLMRequestSpan, endLLMRequestSpan, resetTracingState, } from "../telemetry/sessionTracing.js";
 import { logOTelEvent } from "../telemetry/events.js";
@@ -729,182 +726,6 @@ export class AIManager {
         }
         return result;
     }
-    /**
-     * Fork subagent ("/subtask"): spawn a background agent that inherits the
-     * parent's full conversation context — the same system prompt, tools, model,
-     * and message prefix as the main loop — so the forked request prefix matches
-     * exactly and the prompt cache is reused. The fork runs to completion in the
-     * background via the shared BackgroundTaskManager (visible in /tasks, log at
-     * `os.tmpdir()/wave-subagent-<taskId>.log`); its final response is enqueued
-     * as a task notification carrying the `<result>` tag, so the main agent
-     * picks it up on the next turn and can act on it.
-     *
-     * Recursion is prevented by denying the Agent tool and the Task management
-     * tools (the fork cannot spawn further subagents or mutate the shared task
-     * list), and by honoring the parent's denied rules for everything else.
-     * Gate-approved tools execute locally in the stripped fork context (no
-     * permission prompts), mirroring the other fork paths.
-     *
-     * Returns the background task ID (empty string when no BackgroundTaskManager
-     * is registered, in which case the fork still runs but without task
-     * bookkeeping or notification).
-     */
-    async runForkSubagent(prompt, options, abortSignal) {
-        const modelConfig = this.getModelConfig();
-        // Snapshot the conversation synchronously: the /subtask handler records
-        // the command echo in the transcript after this call, so the fork never
-        // sees its own trigger message duplicated.
-        const historyMessages = convertMessagesForAPI(this.messageManager.getMessages(), { supportsVision: supportsVision(modelConfig.capabilities) });
-        const backgroundTaskManager = this.backgroundTaskManager;
-        const permissionManager = this.permissionManager;
-        const messageQueue = this.container.has("MessageQueue")
-            ? this.container.get("MessageQueue")
-            : undefined;
-        // Combine the caller's signal with an internal one so a task kill
-        // (BackgroundTaskManager.stopTask / cleanup) aborts the in-flight fork.
-        const abortController = new AbortController();
-        let abortCleanup;
-        if (abortSignal) {
-            abortCleanup = addConsolidatedAbortListener(abortSignal, [
-                () => abortController.abort(),
-            ]);
-        }
-        // Recursion prevention: deny the Agent tool and Task tools, then honor the
-        // parent's denied rules for everything else.
-        const deniedTools = new Set([
-            AGENT_TOOL_NAME,
-            TASK_CREATE_TOOL_NAME,
-            TASK_GET_TOOL_NAME,
-            TASK_UPDATE_TOOL_NAME,
-            TASK_LIST_TOOL_NAME,
-        ]);
-        const canUseTool = (name) => {
-            if (deniedTools.has(name))
-                return false;
-            if (permissionManager?.isToolDenied(name))
-                return false;
-            return true;
-        };
-        const deniedToolMessage = "The Agent tool and Task tools are not available in a fork subagent.";
-        // Background task bookkeeping mirrors subagentManager.executeAgent.
-        let taskId = "";
-        let logStream;
-        if (backgroundTaskManager) {
-            taskId = backgroundTaskManager.generateId();
-            const startTime = Date.now();
-            const logPath = path.join(os.tmpdir(), `wave-subagent-${taskId}.log`);
-            logStream = createWriteStream(logPath, { flags: "a" });
-            backgroundTaskManager.addTask({
-                id: taskId,
-                type: "subagent",
-                status: "running",
-                startTime,
-                description: truncateWithMarker(options.description, 1000),
-                stdout: "",
-                stderr: "",
-                outputPath: logPath,
-                onStop: () => {
-                    logStream?.destroy();
-                    logStream = undefined;
-                    abortController.abort();
-                },
-            });
-            logStream.write(`[${new Date().toISOString()}] Fork subagent started: ${options.description}\n`);
-        }
-        const finish = async (status, content) => {
-            if (!backgroundTaskManager || !taskId)
-                return;
-            const task = backgroundTaskManager.getTask(taskId);
-            if (!task)
-                return;
-            const wasAlreadyKilled = task.status === "killed";
-            const endTime = Date.now();
-            if (status === "completed") {
-                task.status = "completed";
-                task.stdout = content;
-                logStream?.write(`[${new Date().toISOString()}] Final response:\n${content}\n`);
-            }
-            else {
-                task.status = "failed";
-                task.stderr = content;
-                logStream?.write(`[${new Date().toISOString()}] Fork subagent failed: ${content}\n`);
-            }
-            task.endTime = endTime;
-            if (task.startTime)
-                task.runtime = endTime - task.startTime;
-            logStream?.end();
-            logStream = undefined;
-            // Skip the notification when the task was already stopped (e.g. by main
-            // agent shutdown) — mirrors subagentManager's wasAlreadyKilled guard.
-            if (!wasAlreadyKilled && messageQueue) {
-                const description = truncateWithMarker(options.description, 1000);
-                const summary = status === "completed"
-                    ? `Subtask "${description}" completed`
-                    : `Subtask "${description}" failed: ${content}`;
-                messageQueue.enqueueNotification(taskNotificationToXml({
-                    type: "task_notification",
-                    taskId,
-                    taskType: "agent",
-                    status,
-                    summary,
-                    ...(status === "completed" && { result: content }),
-                }));
-            }
-        };
-        // Fire-and-forget: the fork runs to completion in the background; the
-        // caller gets the task ID immediately. Tracked in the async work registry
-        // so destroy() drains it before returning (abort via the task's onStop
-        // makes the loop settle).
-        const forkPromise = (async () => {
-            try {
-                const result = await this.runForkLoop(historyMessages, prompt, {
-                    // /subtask aligns with Claude Code's fork subagent
-                    // (forkSubagent.ts:65): a loose upper bound that practically
-                    // never binds.
-                    maxTurns: options.maxTurns ?? 200,
-                    canUseTool,
-                    deniedToolMessage,
-                }, abortController.signal);
-                if (result.usage && this.callbacks?.onUsageAdded) {
-                    this.callbacks.onUsageAdded({
-                        ...result.usage,
-                        model: modelConfig.model,
-                        operation_type: "agent",
-                    });
-                }
-                if (result.content?.trim()) {
-                    await finish("completed", result.content);
-                }
-                else {
-                    await finish("failed", "Fork subagent produced no text response");
-                }
-            }
-            catch (error) {
-                // Abort is the expected exit for a killed task; stopTask has already
-                // marked it "killed", so no notification is sent.
-                if (abortController.signal.aborted) {
-                    const task = backgroundTaskManager?.getTask(taskId);
-                    if (task && task.status === "running") {
-                        task.status = "killed";
-                        task.endTime = Date.now();
-                        if (task.startTime)
-                            task.runtime = task.endTime - task.startTime;
-                    }
-                    logStream?.end();
-                    logStream = undefined;
-                }
-                else {
-                    logger?.error("Fork subagent execution failed:", error);
-                    await finish("failed", error instanceof Error ? error.message : String(error));
-                }
-            }
-            finally {
-                abortCleanup?.();
-            }
-        })();
-        this.asyncWorkRegistry?.track(forkPromise);
-        return taskId;
-    }
     /**
      * Parse a fork tool call's JSON arguments, recovering truncated JSON the
      * same way the main loop does. Unparseable arguments fall back to `{}` and
@@ -1271,6 +1092,18 @@ ${question}`;
                 this.abortController = abortController;
                 toolAbortController = new AbortController();
                 this.toolAbortController = toolAbortController;
+                // Every tool call in a turn wires its own abort listener onto the
+                // shared tool signal (see toolAbortController.signal in executeTool),
+                // so a fan-out of >=11 parallel calls trips Node's default 10-listener
+                // cap and spams MaxListenersExceededWarning. The signal dies with the
+                // turn (toolAbortController is cleared in the tool loop), so there is
+                // no real leak — raise the cap to silence the noise. Optional chaining
+                // keeps this a no-op on Node >=26, which removed the EventTarget
+                // warning mechanism (and the setMaxListeners method) entirely.
+                const toolSignal = toolAbortController.signal;
+                const turnSignal = abortController.signal;
+                toolSignal.setMaxListeners?.(0);
+                turnSignal.setMaxListeners?.(0);
             }
             else {
                 // Reuse existing controllers
@@ -1353,6 +1186,9 @@ ${question}`;
                     // Add streaming callbacks only if streaming is enabled
                     if (this.stream) {
                         callAgentOptions.onContentUpdate = (content) => {
+                            // Agent may have been destroyed mid-stream; ignore in-flight updates.
+                            if (!this.messageManager)
+                                return;
                             // Create assistant message on first chunk if not already created
                             if (!assistantMessageCreated) {
                                 this.messageManager.addAssistantMessage();
@@ -1361,6 +1197,9 @@ ${question}`;
                             this.messageManager.updateCurrentMessageContent(content);
                         };
                         callAgentOptions.onToolUpdate = (toolCall) => {
+                            // Agent may have been destroyed mid-stream; ignore in-flight updates.
+                            if (!this.messageManager)
+                                return;
                             // Create assistant message on first tool update if not already created
                             if (!assistantMessageCreated) {
                                 this.messageManager.addAssistantMessage();
@@ -1383,6 +1222,9 @@ ${question}`;
                             });
                         };
                         callAgentOptions.onReasoningUpdate = (reasoning) => {
+                            // Agent may have been destroyed mid-stream; ignore in-flight updates.
+                            if (!this.messageManager)
+                                return;
                             // Create assistant message on first reasoning update if not already created
                             if (!assistantMessageCreated) {
                                 this.messageManager.addAssistantMessage();

package/dist/managers/bashModeManager.d.ts

@@ -0,0 +1,33 @@
+import { Container } from "../utils/container.js";
+export interface BashModeManagerOptions {
+    workdir: string;
+}
+export interface CommandExecutionResult {
+    exitCode: number;
+    output: string;
+}
+/**
+ * Bash mode (`!command`) execution. The command is surfaced as a user-message
+ * tool block (name: BASH_TOOL_NAME) — the same rendering as fork-skill / `/plan`
+ * outputs (⎿ prefix + markdown, result enters the model context via the
+ * generic `<local-command-stdout>` rule) — and executed through the shared
+ * bash tool engine (shell resolution, CWD tracking, timeout, output handling).
+ */
+export declare class BashModeManager {
+    private container;
+    private workdir;
+    isCommandRunning: boolean;
+    private abortController;
+    onCommandRunningChange?: (running: boolean) => void;
+    constructor(container: Container, options: BashModeManagerOptions);
+    private get messageManager();
+    /**
+     * Merged env (OS env overlaid with this session's settings snapshot) for
+     * bash-mode subprocesses, so settings `env` vars reach them without
+     * polluting other sessions in one `wave --stdio` process.
+     */
+    private get sessionEnv();
+    private setCommandRunning;
+    executeCommand(command: string): Promise<number>;
+    abortCommand(): void;
+}

package/dist/managers/bashModeManager.js

@@ -0,0 +1,110 @@
+import { bashTool } from "../tools/bashTool.js";
+import { BASH_TOOL_NAME } from "../constants/tools.js";
+/**
+ * Bash mode (`!command`) execution. The command is surfaced as a user-message
+ * tool block (name: BASH_TOOL_NAME) — the same rendering as fork-skill / `/plan`
+ * outputs (⎿ prefix + markdown, result enters the model context via the
+ * generic `<local-command-stdout>` rule) — and executed through the shared
+ * bash tool engine (shell resolution, CWD tracking, timeout, output handling).
+ */
+export class BashModeManager {
+    constructor(container, options) {
+        this.container = container;
+        this.isCommandRunning = false;
+        this.abortController = null;
+        this.workdir = options.workdir;
+    }
+    get messageManager() {
+        return this.container.get("MessageManager");
+    }
+    /**
+     * Merged env (OS env overlaid with this session's settings snapshot) for
+     * bash-mode subprocesses, so settings `env` vars reach them without
+     * polluting other sessions in one `wave --stdio` process.
+     */
+    get sessionEnv() {
+        return (this.container
+            .get("ConfigurationService")
+            ?.getMergedEnv?.() ?? process.env);
+    }
+    setCommandRunning(isRunning) {
+        this.isCommandRunning = isRunning;
+        this.onCommandRunningChange?.(isRunning);
+    }
+    async executeCommand(command) {
+        if (this.isCommandRunning) {
+            throw new Error("Command already running");
+        }
+        this.setCommandRunning(true);
+        try {
+            // User message + running tool block. The user text mirrors the command
+            // itself (`!ls` renders as `!ls`), and incremental toolBlockUpdated
+            // notifications drive the live output on all three hosts.
+            const messageId = this.messageManager.addUserMessage({
+                content: command,
+            });
+            const blockId = this.messageManager.addToolBlockToMessage(messageId, {
+                name: BASH_TOOL_NAME,
+                parameters: command,
+                stage: "running",
+            });
+            this.abortController = new AbortController();
+            const taskManager = this.container.get("TaskManager");
+            // No permissionManager in the context: bash mode is an explicit user
+            // command, it must not be blocked by the permission gate.
+            const result = await bashTool.execute({ command }, {
+                workdir: this.workdir,
+                taskManager,
+                sessionEnv: this.sessionEnv,
+                abortSignal: this.abortController.signal,
+                // Stream realtime output into the running tool block — wired like
+                // aiManager tool execution (aiManager.ts updateToolBlock callbacks).
+                onShortResultUpdate: (shortResult) => {
+                    this.messageManager.updateToolBlock({
+                        id: blockId,
+                        messageId,
+                        shortResult,
+                        stage: "running",
+                        name: BASH_TOOL_NAME,
+                    });
+                },
+                onResultUpdate: (resultText) => {
+                    this.messageManager.updateToolBlock({
+                        id: blockId,
+                        messageId,
+                        result: resultText,
+                        stage: "running",
+                        name: BASH_TOOL_NAME,
+                    });
+                },
+            });
+            const exitCode = typeof result.metadata?.exitCode === "number"
+                ? result.metadata.exitCode
+                : result.success
+                    ? 0
+                    : 1;
+            const resultText = result.success
+                ? result.content
+                : `[exit code: ${exitCode}]` +
+                    (result.content ? `\n\n${result.content}` : "");
+            this.messageManager.updateToolBlock({
+                id: blockId,
+                messageId,
+                result: resultText,
+                shortResult: result.shortResult,
+                stage: "end",
+                success: result.success,
+            });
+            return exitCode;
+        }
+        finally {
+            this.abortController = null;
+            this.setCommandRunning(false);
+        }
+    }
+    abortCommand() {
+        this.abortController?.abort();
+        this.abortController = null;
+        this.isCommandRunning = false;
+    }
+}

package/dist/managers/hookManager.d.ts

@@ -120,6 +120,11 @@ export declare class HookManager {
      * Register hooks provided by a plugin
      */
     registerPluginHooks(pluginRoot: string, hooks: PartialHookConfiguration): void;
+    /**
+     * Get hooks registered by plugins (read-only view for the settings UI).
+     * Plugin hooks carry pluginRoot on each command and are read-only in the UI.
+     */
+    getPluginHooks(): PartialHookConfiguration;
     /**
      * Execute SessionStart hooks during initialization.
      * Collects additionalContext and initialUserMessage from hook stdout.

package/dist/managers/hookManager.js

@@ -670,6 +670,13 @@ export class HookManager {
         this.mergeHooksConfiguration(this.pluginHooks, stampedHooks);
         this.rebuildConfiguration();
     }
+    /**
+     * Get hooks registered by plugins (read-only view for the settings UI).
+     * Plugin hooks carry pluginRoot on each command and are read-only in the UI.
+     */
+    getPluginHooks() {
+        return this.pluginHooks;
+    }
     /**
      * Execute SessionStart hooks during initialization.
      * Collects additionalContext and initialUserMessage from hook stdout.

package/dist/managers/liveConfigManager.js

@@ -172,15 +172,15 @@ export class LiveConfigManager {
             }
             // Update permission manager if available
             if (this.permissionManager) {
-                this.permissionManager.updateConfiguredPermissionMode(this.currentConfiguration.permissions?.permissionMode);
+                this.permissionManager.updateConfiguredPermissionMode(this.currentConfiguration.permissions?.defaultMode);
                 this.permissionManager.updateAllowedRules(this.currentConfiguration.permissions?.allow || []);
                 this.permissionManager.updateDeniedRules(this.currentConfiguration.permissions?.deny || []);
                 this.permissionManager.updateAdditionalDirectories(this.currentConfiguration.permissions?.additionalDirectories || []);
             }
             // Trigger reload callback. Awaited so fire-and-forget work spawned by the
             // callback (e.g. skill rediscovery) completes before the reload resolves —
-            // otherwise Agent.create() can return with a cleared skill map (see race
-            // where refreshSkills() clears skillMetadata before async discoverSkills).
+            // otherwise Agent.create() can return while a skill rescan is still
+            // running (refreshSkills swaps caches atomically only after the scan).
             await this.options.onReload?.(this.currentConfiguration);
             return this.currentConfiguration;
         }

package/dist/managers/mcpManager.d.ts

@@ -32,11 +32,14 @@ export declare class McpManager {
     private servers;
     private connections;
     private configPath;
+    private userConfigPath;
     private workdir;
     private callbacks;
     private mcpServers;
     private reconnectTimers;
     private reconnectAttempts;
+    /** Explicit disconnectServer teardowns currently in flight */
+    private disconnecting;
     constructor(container: Container, options?: McpManagerOptions);
     /**
      * Merged env for this session: OS env overlaid with the per-session settings
@@ -50,6 +53,18 @@ export declare class McpManager {
     initialize(workdir: string, autoConnect?: boolean): Promise<void>;
     ensureConfigLoaded(): Promise<McpConfig | null>;
     loadConfig(): Promise<McpConfig | null>;
+    /**
+     * Read a raw MCP config file, tolerating ENOENT and corrupt JSON.
+     */
+    private readConfigFile;
+    /**
+     * The user-level MCP config path (~/.wave/mcp.json).
+     */
+    getUserConfigPath(): string;
+    /**
+     * The project-level MCP config path (<workdir>/.mcp.json).
+     */
+    getProjectConfigPath(): string;
     saveConfig(config: McpConfig): Promise<boolean>;
     getConfig(): McpConfig | null;
     getAllServers(): McpServerStatus[];
@@ -57,6 +72,14 @@ export declare class McpManager {
     updateServerStatus(name: string, updates: Partial<McpServerStatus>): void;
     addServer(name: string, config: McpServerConfig): boolean;
     removeServer(name: string): boolean;
+    /**
+     * Remove a server from a persisted config file (user or project scope),
+     * then disconnect and drop it from the in-memory registry.
+     * @param scope - "user" removes from ~/.wave/mcp.json; "project" removes from <workdir>/.mcp.json
+     * @param name - The server name
+     * @returns true if the server was found and removed
+     */
+    removeServerFromConfig(scope: "user" | "project", name: string): Promise<boolean>;
     connectServer(name: string): Promise<boolean>;
     /**
      * Schedule auto-reconnect with exponential backoff.