wave-agent-sdk 1.1.4 → 1.2.0

package/dist/managers/mcpManager.js

@@ -1,5 +1,6 @@
 import { promises as fs } from "fs";
 import { join } from "path";
+import { homedir } from "os";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
@@ -73,9 +74,12 @@ export class McpManager {
         this.servers = new Map();
         this.connections = new Map();
         this.configPath = "";
+        this.userConfigPath = "";
         this.workdir = "";
         this.reconnectTimers = new Map();
         this.reconnectAttempts = new Map();
+        /** Explicit disconnectServer teardowns currently in flight */
+        this.disconnecting = new Set();
         this.callbacks = options.callbacks || {};
         this.mcpServers = options.mcpServers;
     }
@@ -94,6 +98,7 @@ export class McpManager {
      */
     async initialize(workdir, autoConnect = false) {
         this.configPath = join(workdir, ".mcp.json");
+        this.userConfigPath = join(homedir(), ".wave", "mcp.json");
         this.workdir = workdir;
         // Register constructor-provided servers before loading .mcp.json
         if (this.mcpServers) {
@@ -141,22 +146,40 @@ export class McpManager {
             return null;
         }
         try {
-            const configContent = await fs.readFile(this.configPath, "utf-8");
-            const rawConfig = JSON.parse(configContent);
-            const workspaceConfig = resolveMcpConfig(rawConfig, this.envSnapshot);
+            // Load user-level (~/.wave/mcp.json) and project-level (<workdir>/.mcp.json)
+            // configs, then merge with project taking precedence over user-level.
+            const userConfig = await this.readConfigFile(this.userConfigPath);
+            const projectConfig = await this.readConfigFile(this.configPath);
+            // Neither file exists: preserve the original null contract (constructor-
+            // provided servers may still be present in this.config).
+            if (!userConfig && !projectConfig) {
+                return this.config;
+            }
+            const userResolved = userConfig
+                ? resolveMcpConfig(userConfig, this.envSnapshot)
+                : null;
+            const projectResolved = projectConfig
+                ? resolveMcpConfig(projectConfig, this.envSnapshot)
+                : null;
             // Extract original (pre-resolution) URLs for safe display
             const originalUrls = {};
-            for (const [name, serverConfig] of Object.entries(rawConfig.mcpServers)) {
+            for (const [name, serverConfig] of Object.entries({
+                ...(userConfig?.mcpServers || {}),
+                ...(projectConfig?.mcpServers || {}),
+            })) {
                 originalUrls[name] = serverConfig.url;
             }
-            // Merge workspace config with any existing config (e.g., from plugins or constructor)
-            // Constructor-provided servers take precedence, then workspace config, then existing config
+            // Merge: existing config (e.g. plugin servers) -> user -> project -> constructor
             const merged = { mcpServers: {} };
             if (this.config) {
                 Object.assign(merged.mcpServers, this.config.mcpServers);
             }
-            Object.assign(merged.mcpServers, workspaceConfig.mcpServers);
-            // Constructor-provided servers override both for same names
+            if (userResolved) {
+                Object.assign(merged.mcpServers, userResolved.mcpServers);
+            }
+            if (projectResolved) {
+                Object.assign(merged.mcpServers, projectResolved.mcpServers);
+            }
             if (this.mcpServers) {
                 Object.assign(merged.mcpServers, this.mcpServers);
             }
@@ -165,12 +188,27 @@ export class McpManager {
             if (this.config) {
                 for (const [name, config] of Object.entries(this.config.mcpServers)) {
                     const existingServer = this.servers.get(name);
+                    // Determine scope: plugin servers registered with pluginRoot keep
+                    // their plugin scope; user-level names come from ~/.wave/mcp.json.
+                    let scope = existingServer?.scope;
+                    if (!scope) {
+                        if (config.pluginRoot) {
+                            scope = "plugin";
+                        }
+                        else if (userConfig?.mcpServers?.[name]) {
+                            scope = "user";
+                        }
+                        else {
+                            scope = "project";
+                        }
+                    }
                     if (existingServer) {
                         // Update config but preserve status and other runtime info
                         this.servers.set(name, {
                             ...existingServer,
                             config, // Update config in case it changed
                             originalUrl: originalUrls[name] ?? existingServer.originalUrl,
+                            scope,
                         });
                     }
                     else {
@@ -179,6 +217,7 @@ export class McpManager {
                             name,
                             config,
                             originalUrl: originalUrls[name],
+                            scope,
                             status: "disconnected",
                         });
                     }
@@ -189,11 +228,41 @@ export class McpManager {
         catch (error) {
             // Only log error if it's not a "file not found" error
             if (error.code !== "ENOENT") {
-                logger?.error("Failed to load .mcp.json:", error);
+                logger?.error("Failed to load MCP config:", error);
             }
             return null;
         }
     }
+    /**
+     * Read a raw MCP config file, tolerating ENOENT and corrupt JSON.
+     */
+    async readConfigFile(configPath) {
+        if (!configPath)
+            return null;
+        try {
+            const content = await fs.readFile(configPath, "utf-8");
+            return JSON.parse(content);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT")
+                return null;
+            logger?.error("Failed to load .mcp.json:", error);
+            return null;
+        }
+    }
+    /**
+     * The user-level MCP config path (~/.wave/mcp.json).
+     */
+    getUserConfigPath() {
+        return this.userConfigPath;
+    }
+    /**
+     * The project-level MCP config path (<workdir>/.mcp.json).
+     */
+    getProjectConfigPath() {
+        return this.configPath;
+    }
     async saveConfig(config) {
         try {
             await fs.writeFile(this.configPath, JSON.stringify(config, null, 2));
@@ -258,6 +327,7 @@ export class McpManager {
             name,
             config: resolvedConfig,
             originalUrl,
+            scope: resolvedConfig.pluginRoot ? "plugin" : undefined,
             status: "disconnected",
         };
         this.servers.set(name, newServer);
@@ -283,6 +353,34 @@ export class McpManager {
         }
         return removed;
     }
+    /**
+     * 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
+     */
+    async removeServerFromConfig(scope, name) {
+        const configPath = scope === "user" ? this.userConfigPath : this.configPath;
+        if (!configPath)
+            return false;
+        const rawConfig = await this.readConfigFile(configPath);
+        if (!rawConfig ||
+            !rawConfig.mcpServers ||
+            !(name in rawConfig.mcpServers)) {
+            return false;
+        }
+        delete rawConfig.mcpServers[name];
+        if (Object.keys(rawConfig.mcpServers).length === 0) {
+            await fs.rm(configPath, { force: true });
+        }
+        else {
+            await fs.writeFile(configPath, JSON.stringify(rawConfig, null, 2));
+        }
+        // Drop from memory (disconnects if connected)
+        this.removeServer(name);
+        return true;
+    }
     // Real MCP connection implementation
     async connectServer(name) {
         const server = this.servers.get(name);
@@ -291,6 +389,11 @@ export class McpManager {
         // Already connected
         if (this.connections.has(name))
             return true;
+        // An explicit disconnectServer teardown is in flight for this server —
+        // don't race it (e.g. an auto-reconnect timer that just fired) by spawning
+        // a fresh process the user asked to stop.
+        if (this.disconnecting.has(name))
+            return false;
         this.updateServerStatus(name, { status: "connecting" });
         try {
             // Create transport - it will manage the process
@@ -454,14 +557,22 @@ export class McpManager {
             };
             transport.onclose = () => {
                 logger?.debug(`MCP Server ${name} transport closed`);
+                // Only the current generation of this server's transport may mutate
+                // state: a stale process 'close' arriving after an auto-reconnect must
+                // not tear down (or schedule a reconnect for) the live connection.
+                const current = this.connections.get(name);
+                if (!current || current.transport !== transport)
+                    return;
                 this.connections.delete(name);
                 this.updateServerStatus(name, {
                     status: "disconnected",
                     tools: [],
                     toolCount: 0,
                 });
-                // Auto-reconnect with exponential backoff (not triggered by explicit disconnect)
-                if (!this.reconnectTimers.has(name)) {
+                // Auto-reconnect with exponential backoff. Skipped while an explicit
+                // disconnectServer teardown is in flight — that close is expected, and
+                // reconnecting would silently undo a user-initiated disconnect.
+                if (!this.disconnecting.has(name) && !this.reconnectTimers.has(name)) {
                     this.scheduleReconnect(name);
                 }
             };
@@ -570,27 +681,64 @@ export class McpManager {
     async disconnectServer(name) {
         // Cancel any pending reconnect attempts
         this.cancelReconnect(name);
+        const server = this.servers.get(name);
         const connection = this.connections.get(name);
-        if (!connection)
+        // Nothing live to tear down. Still reconcile a stale "connected"-style
+        // status (e.g. after an unobserved crash left no connection entry) so the
+        // UI converges instead of staying wedged on a disconnect action.
+        if (!connection) {
+            if (server && server.status !== "disconnected") {
+                this.updateServerStatus(name, {
+                    status: "disconnected",
+                    tools: [],
+                    toolCount: 0,
+                    error: undefined,
+                });
+            }
             return false;
+        }
+        // Idempotent: a teardown is already running for this server.
+        if (this.disconnecting.has(name))
+            return false;
+        // Mark before closing so transport.onclose knows this is an expected,
+        // user-initiated teardown and must not schedule an auto-reconnect.
+        this.disconnecting.add(name);
         try {
             // Close client connection and transport
             await connection.client.close();
             await connection.transport.close();
-            // Remove connection
-            this.connections.delete(name);
+            // Remove connection (transport.onclose may already have done so)
+            if (this.connections.get(name) === connection) {
+                this.connections.delete(name);
+            }
             // updateServerStatus will trigger the callback
             this.updateServerStatus(name, {
                 status: "disconnected",
                 tools: [],
                 toolCount: 0,
+                error: undefined,
             });
             return true;
         }
         catch (error) {
             logger?.error(`Error disconnecting from MCP server ${name}:`, error);
+            // Never leave the server reporting connected after a failed teardown:
+            // drop the connection and push a terminal state so the caller/UI gets a
+            // definitive outcome instead of an endless "disconnecting" spinner.
+            if (this.connections.get(name) === connection) {
+                this.connections.delete(name);
+            }
+            this.updateServerStatus(name, {
+                status: "disconnected",
+                tools: [],
+                toolCount: 0,
+                error: error instanceof Error ? error.message : String(error),
+            });
             return false;
         }
+        finally {
+            this.disconnecting.delete(name);
+        }
     }
     // Get all tools from connected servers.
     // "reconnecting" servers retain their last-known tool snapshot so that

package/dist/managers/messageManager.d.ts

@@ -24,9 +24,6 @@ export interface MessageManagerCallbacks {
     onErrorBlockAdded?: (error: string) => void;
     onCompactBlockAdded?: (content: string) => void;
     onCompactionStateChange?: (isCompacting: boolean) => void;
-    onAddBangMessage?: (command: string, messageId: string) => void;
-    onUpdateBangMessage?: (command: string, output: string, messageId: string) => void;
-    onCompleteBangMessage?: (command: string, exitCode: number, messageId: string, output?: string) => void;
     onInfoBlockAdded?: (content: string) => void;
     onShowRewind?: () => void;
     onFileHistoryBlockAdded?: (snapshots: import("../types/reversion.js").FileSnapshot[]) => void;
@@ -47,6 +44,13 @@ export declare class MessageManager {
     private container;
     private sessionId;
     private messages;
+    /** Full display message stream for the UI. Mirrors `messages` (context) on
+     * every normal change; the two diverge only around compaction, where
+     * `messages` is replaced by [compact, ...last API rounds] for the API
+     * context while `displayMessages` keeps the full history and appends the
+     * compact block (aligned with Claude Code desktop/VS Code: compaction
+     * folds the API context but leaves the UI transcript intact). */
+    private displayMessages;
     private latestTotalTokens;
     private workdir;
     private encodedWorkdir;
@@ -66,6 +70,8 @@ export declare class MessageManager {
     getSessionId(): string;
     getRootSessionId(): string;
     getMessages(): Message[];
+    /** Full UI display message stream (includes pre-compaction history). */
+    getDisplayMessages(): Message[];
     getUsages(): Usage[];
     getLatestTotalTokens(): number;
     getWorkdir(): string;
@@ -110,7 +116,9 @@ export declare class MessageManager {
      * Uses recentFileReads Map populated from Read tool execution.
      */
     hasFileBeenRead(filePath: string): boolean;
-    setMessages(messages: Message[]): void;
+    setMessages(messages: Message[], opts?: {
+        keepDisplay?: boolean;
+    }): void;
     /**
      * Save current session
      */
@@ -145,15 +153,6 @@ export declare class MessageManager {
      */
     compactMessagesAndUpdateSession(compactedContent: string, usage?: Usage): Promise<void>;
     addFileHistoryBlock(snapshots: import("../types/reversion.js").FileSnapshot[]): void;
-    addBangMessage(command: string): void;
-    updateBangMessage(command: string, output: string): void;
-    completeBangMessage(command: string, exitCode: number, output?: string): void;
-    /**
-     * Find the message ID of the most recent message containing a bang block
-     * for the given command. Bang callbacks do not carry a block ID, so the
-     * message is located by matching the command against bang blocks.
-     */
-    private findBangMessageId;
     addNotificationMessage(params: Omit<AddNotificationMessageParams, "messages">): void;
     /**
      * Rebuild usage array from messages containing usage metadata

package/dist/managers/messageManager.js

@@ -1,4 +1,4 @@
-import { addAssistantMessageToMessages, updateToolBlockInMessage, addErrorBlockToMessage, addUserMessageToMessages, updateUserMessageInMessages, addBangMessage, updateBangInMessage, completeBangInMessage, removeLastUserMessage, addToolBlockToMessageInMessages, addNotificationMessageToMessages, generateMessageId, sliceFromLastCompact, } from "../utils/messageOperations.js";
+import { addAssistantMessageToMessages, updateToolBlockInMessage, addErrorBlockToMessage, addUserMessageToMessages, updateUserMessageInMessages, removeLastUserMessage, addToolBlockToMessageInMessages, addNotificationMessageToMessages, generateMessageId, sliceFromLastCompact, } from "../utils/messageOperations.js";
 import { getLastApiRounds } from "../utils/groupMessagesByApiRound.js";
 import { join, isAbsolute, relative } from "path";
 import { appendMessages, createSession, generateSessionId, SESSION_DIR, } from "../services/session.js";
@@ -16,6 +16,13 @@ import { logger } from "../utils/globalLogger.js";
 export class MessageManager {
     constructor(container, options) {
         this.container = container;
+        /** Full display message stream for the UI. Mirrors `messages` (context) on
+         * every normal change; the two diverge only around compaction, where
+         * `messages` is replaced by [compact, ...last API rounds] for the API
+         * context while `displayMessages` keeps the full history and appends the
+         * compact block (aligned with Claude Code desktop/VS Code: compaction
+         * folds the API context but leaves the UI transcript intact). */
+        this.displayMessages = [];
         this.pendingFileReadTriggers = new Set(); // File paths read via Read tool, awaiting rule matching
         this.loadedRuleIds = new Set(); // IDs of conditional rules already injected as meta messages
         this.recentFileReads = new Map(); // Track file read contents
@@ -55,6 +62,10 @@ export class MessageManager {
     getMessages() {
         return [...this.messages];
     }
+    /** Full UI display message stream (includes pre-compaction history). */
+    getDisplayMessages() {
+        return [...this.displayMessages];
+    }
     getUsages() {
         return [...this._usages];
     }
@@ -174,9 +185,35 @@ export class MessageManager {
         return (this.recentFileReads.has(normalizedPath) ||
             this.recentFileReads.has(filePath));
     }
-    setMessages(messages) {
+    setMessages(messages, opts) {
         const oldLength = this.messages.length;
         this.messages = [...messages];
+        // The UI display stream follows the context by default. Compaction /
+        // session restore / rewind pass keepDisplay and manage displayMessages
+        // explicitly (the display stream must keep the full pre-compaction
+        // history while the context folds at the last compact boundary).
+        if (!opts?.keepDisplay) {
+            if (messages.length === 0) {
+                // Clear path — nothing to merge.
+                this.displayMessages = [...messages];
+            }
+            else {
+                // Routine changes (new messages, tool block updates) still touch the
+                // display stream, but after compaction the display holds the full
+                // pre-compaction history while the context is folded. Merge by id so
+                // new messages append to the display stream and updated messages
+                // replace their display copy without dropping that history.
+                const byId = new Map(messages.map((m) => [m.id, m]));
+                const merged = this.displayMessages.map((m) => byId.get(m.id) ?? m);
+                const known = new Set(this.displayMessages.map((m) => m.id));
+                for (const m of messages) {
+                    if (!known.has(m.id)) {
+                        merged.push(m);
+                    }
+                }
+                this.displayMessages = merged;
+            }
+        }
         // Incrementally extract metadata from new messages
         const newMessages = messages.slice(oldLength);
         for (const message of newMessages) {
@@ -250,13 +287,19 @@ export class MessageManager {
     // Initialize state from session data
     initializeFromSession(sessionData) {
         this.setSessionId(sessionData.id);
-        this.setMessages([...sessionData.messages]);
+        // The UI displays the full transcript (pre-compaction history included);
+        // the API context folds at the last compact boundary so the model only
+        // sees messages from the latest summary forward.
+        this.setMessages(sliceFromLastCompact(sessionData.messages), {
+            keepDisplay: true,
+        });
+        this.displayMessages = [...sessionData.messages];
         this.setlatestTotalTokens(sessionData.metadata.latestTotalTokens);
         // Rebuild loadedRuleIds from persisted meta messages (session restore)
         this.rebuildLoadedRuleIds();
         // Set saved message count to the number of loaded messages since they're already saved
         // This must be done after setSessionId which resets it to 0
-        this.savedMessageCount = sessionData.messages.length;
+        this.savedMessageCount = this.messages.length;
     }
     // Encapsulated message operation functions
     addUserMessage(params) {
@@ -398,11 +441,18 @@ export class MessageManager {
         };
         // Build new message array: keep the compacted message and last messages
         const newMessages = [compactMessage, ...lastThreeMessages];
-        // APPEND to the same session file (append-only, like Claude Code)
+        // APPEND only the compact block to the session file (append-only, like
+        // Claude Code). The preserved last API rounds were already written before
+        // compaction (saveSession ran at the start), so re-appending them would
+        // duplicate those lines in the transcript — the loader relies on each
+        // message id appearing exactly once (dedup-skipped, aligned with CC).
         const { appendMessages } = await import("../services/session.js");
-        await appendMessages(this.sessionId, newMessages, this.workdir, this.sessionType);
-        // Update in-memory state
-        this.setMessages(newMessages);
+        await appendMessages(this.sessionId, [compactMessage], this.workdir, this.sessionType);
+        // Update in-memory state: the API context folds to [compact, ...last
+        // rounds], while the UI display stream keeps the full history and appends
+        // the compact block at the end.
+        this.setMessages(newMessages, { keepDisplay: true });
+        this.displayMessages = [...this.displayMessages, compactMessage];
         this.savedMessageCount = newMessages.length;
         // Trim recent file read cache so contents compacted away are released
         this.trimRecentFileReads();
@@ -425,54 +475,6 @@ export class MessageManager {
             this.callbacks.onFileHistoryBlockAdded?.(snapshots);
         }
     }
-    // Bang related message operations
-    addBangMessage(command) {
-        const updatedMessages = addBangMessage({
-            messages: this.messages,
-            command,
-        });
-        this.setMessages(updatedMessages);
-        // The bang message is appended as the last message
-        const messageId = this.messages[this.messages.length - 1]?.id ?? "";
-        this.callbacks.onAddBangMessage?.(command, messageId);
-    }
-    updateBangMessage(command, output) {
-        const updatedMessages = updateBangInMessage({
-            messages: this.messages,
-            command,
-            output,
-        });
-        this.setMessages(updatedMessages);
-        const messageId = this.findBangMessageId(command) ?? "";
-        this.callbacks.onUpdateBangMessage?.(command, output, messageId);
-    }
-    completeBangMessage(command, exitCode, output) {
-        const updatedMessages = completeBangInMessage({
-            messages: this.messages,
-            command,
-            exitCode,
-            output,
-        });
-        this.setMessages(updatedMessages);
-        const messageId = this.findBangMessageId(command) ?? "";
-        this.callbacks.onCompleteBangMessage?.(command, exitCode, messageId, output?.trim());
-    }
-    /**
-     * Find the message ID of the most recent message containing a bang block
-     * for the given command. Bang callbacks do not carry a block ID, so the
-     * message is located by matching the command against bang blocks.
-     */
-    findBangMessageId(command) {
-        for (let i = this.messages.length - 1; i >= 0; i--) {
-            const message = this.messages[i];
-            if (message.role !== "user")
-                continue;
-            const hasBangBlock = message.blocks?.some((block) => block.type === "bang" && block.command === command);
-            if (hasBangBlock)
-                return message.id;
-        }
-        return undefined;
-    }
     addNotificationMessage(params) {
         const newMessages = addNotificationMessageToMessages({
             messages: this.messages,
@@ -737,10 +739,11 @@ export class MessageManager {
         }
         // Rewrite file with truncated messages (full history kept on disk)
         await this.rewriteSessionFile(newMessages);
-        // Fold the in-memory messages at the last compact boundary so the agent
-        // only sees messages from the latest compact summary forward — matching
-        // the compact and resume behaviors (which also fold memory).
-        this.setMessages(sliceFromLastCompact(newMessages));
+        // The UI keeps the full truncated thread; the agent context folds at the
+        // last compact boundary so the agent only sees messages from the latest
+        // compact summary forward — matching the compact and resume behaviors.
+        this.setMessages(sliceFromLastCompact(newMessages), { keepDisplay: true });
+        this.displayMessages = newMessages;
         // savedMessageCount tracks in-memory progress, so it must be the folded
         // length. Using the full disk count here would make saveSession's
         // slice(savedMessageCount) empty after a rewind past a compact boundary

package/dist/managers/permissionManager.d.ts

@@ -8,6 +8,13 @@
 import type { PermissionDecision, ToolPermissionContext, PermissionCallback, PermissionMode } from "../types/permissions.js";
 import type { Logger } from "../types/index.js";
 import { Container } from "../utils/container.js";
+/**
+ * Resolve an additional-directory config entry to an absolute path.
+ * Supports `~` / `~/` prefixes (expanded against the user home directory,
+ * aligned with Claude Code's expandPath) alongside absolute paths and paths
+ * relative to the working directory.
+ */
+export declare function resolveAdditionalDirectory(dir: string, workdir: string | undefined): string;
 export interface PermissionManagerOptions {
     /** Configured permission mode from settings */
     configuredPermissionMode?: PermissionMode;
@@ -192,10 +199,32 @@ export declare class PermissionManager {
      * command substitution, process substitution, or sed -i are auto-allowed.
      */
     private isAutoAllowedPart;
+    /**
+     * Check whether a bash command part takes path arguments (cd or a
+     * path-taking read-only command) that escape the Safe Zone. Used to
+     * disqualify auto-allow via DEFAULT_ALLOWED_RULES and to hide the
+     * "don't ask again" persistence option for out-of-bounds access.
+     */
+    private isOutOfSafeZonePart;
     /**
      * Check if a tool call is allowed by persistent or temporary rules
      */
     private isAllowedByRule;
+    /**
+     * Classify one expanded leaf command. Every leaf of a compound command or
+     * command substitution is judged with the exact rules used for a plain
+     * command, with two structure-aware additions:
+     *
+     *  - a leaf the parser flagged `unsafe` (a bare reference to a variable whose
+     *    value is not statically known, or a command substitution inside the
+     *    leaf's own argument words) is never auto-allowed and never matches the
+     *    built-in default rules — only an explicit allow rule may cover it;
+     *  - `read` (e.g. the condition of `while read …`) only reads stdin, so it
+     *    is treated as safe when it carries no redirection of its own.
+     */
+    private isBashLeafAllowed;
+    /** A context whose Bash command is a single part/leaf text. */
+    private ruleContext;
     /**
      * Expand a bash command into individual permission rules, filtering out safe commands.
      * Used when saving permissions to the allow list.