@vscode/component-explorer-cli 0.1.1-2 → 0.1.1-20

package/dist/mcp/McpServer.js

@@ -1,6 +1,15 @@
 import { z } from 'zod';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import '../external/vscode-observables/observables/dist/observableInternal/index.js';
+import { Disposable } from '../external/vscode-observables/observables/dist/disposables.js';
+import '../external/vscode-observables/observables/dist/observableInternal/debugLocation.js';
+import { autorun } from '../external/vscode-observables/observables/dist/observableInternal/reactions/autorun.js';
+import '../external/vscode-observables/observables/dist/observableInternal/observables/derived.js';
+import '../external/vscode-observables/observables/dist/observableInternal/utils/utils.js';
+import '../external/vscode-observables/observables/dist/observableInternal/observables/observableFromEvent.js';
+import { buildExplorerUrl } from '../utils.js';
+import { TaskManager } from './TaskManager.js';
 
 // ---------------------------------------------------------------------------
 // Client-local state
@@ -40,26 +49,197 @@ class WatchList {
         };
     }
 }
+function noDaemonError(hint) {
+    let text = 'Error: No daemon is currently running.';
+    if (hint) {
+        text += ` ${hint}`;
+    }
+    else {
+        text += ' Please start the Component Explorer daemon first by running:\n\n' +
+            '  component-explorer serve --project <config.json>\n\n' +
+            'Or start it in the background:\n\n' +
+            '  component-explorer serve --project <config.json> --background\n\n' +
+            'The daemon manages dev servers and enables fixture screenshots.';
+    }
+    return {
+        content: [{ type: 'text', text }],
+        isError: true,
+    };
+}
+// ---------------------------------------------------------------------------
+// DaemonConnection - wrapper to avoid Proxy issues with observables
+// ---------------------------------------------------------------------------
+class DaemonConnection {
+    client;
+    _stale = false;
+    constructor(client) {
+        this.client = client;
+    }
+    get isStale() { return this._stale; }
+    markStale() { this._stale = true; }
+}
+function isPipeConnectionError(e) {
+    if (!(e instanceof Error)) {
+        return false;
+    }
+    const code = e.code;
+    if (code === 'ENOENT' || code === 'ECONNREFUSED' || code === 'ECONNRESET' || code === 'EPIPE') {
+        return true;
+    }
+    return /connect ENOENT|ECONNREFUSED|ECONNRESET|EPIPE/.test(e.message);
+}
 // ---------------------------------------------------------------------------
 // ComponentExplorerMcpServer
 // ---------------------------------------------------------------------------
-class ComponentExplorerMcpServer {
-    _daemon;
+class ComponentExplorerMcpServer extends Disposable {
+    _daemonConnection;
+    static async create(daemon, options) {
+        const server = new ComponentExplorerMcpServer(daemon, options ?? {});
+        const transport = new StdioServerTransport();
+        await server._mcp.connect(transport);
+        return server;
+    }
     _mcp;
     _watchList = new WatchList();
+    _taskManager = new TaskManager();
+    _taskLastReportedIndex = new Map();
+    _pollFn;
+    _noAutostartHint;
+    _multiSessionTools = [];
     _sessions = [];
-    constructor(_daemon) {
-        this._daemon = _daemon;
+    _eventStreamAbortController;
+    constructor(_daemonConnection, options) {
+        super();
+        this._daemonConnection = _daemonConnection;
+        this._pollFn = options.pollFn;
+        this._noAutostartHint = options.noAutostartHint;
+        this._callTimeoutMs = options.callTimeoutMs ?? ComponentExplorerMcpServer._DEFAULT_CALL_TIMEOUT_MS;
         this._mcp = new McpServer({
             name: 'component-explorer',
             version: '0.1.0',
         });
         this._registerTools();
+        this._store.add(autorun(async (reader) => {
+            const conn = this._daemonConnection.read(reader);
+            await this._onDaemonChanged(conn?.client);
+        }));
     }
-    async connect() {
-        this._sessions = await this._daemon.methods.sessions();
-        const transport = new StdioServerTransport();
-        await this._mcp.connect(transport);
+    async _onDaemonChanged(daemon) {
+        this._eventStreamAbortController?.abort();
+        this._eventStreamAbortController = undefined;
+        if (!daemon) {
+            this._sessions = [];
+            this._log('info', { type: 'daemon-disconnected' });
+            return;
+        }
+        try {
+            this._sessions = await daemon.methods.sessions();
+            this._log('debug', { type: 'daemon-connected', sessions: this._sessions.length });
+            this._updateMultiSessionToolVisibility();
+            this._startEventListener(daemon);
+        }
+        catch (e) {
+            this._log('info', { type: 'daemon-error', error: String(e) });
+            this._sessions = [];
+        }
+    }
+    _getConnection() {
+        const conn = this._daemonConnection.get();
+        if (conn?.isStale) {
+            return undefined;
+        }
+        return conn;
+    }
+    async _waitForDaemon() {
+        let conn = this._getConnection();
+        if (conn) {
+            return conn.client;
+        }
+        if (!this._pollFn) {
+            return undefined;
+        }
+        this._log('debug', { type: 'waiting-for-daemon' });
+        const startTime = Date.now();
+        const timeout = 3000;
+        while (Date.now() - startTime < timeout) {
+            await this._pollFn();
+            conn = this._getConnection();
+            if (conn) {
+                return conn.client;
+            }
+            await new Promise(resolve => setTimeout(resolve, 200));
+        }
+        return undefined;
+    }
+    _handleDisconnect() {
+        const conn = this._daemonConnection.get();
+        if (conn && !conn.isStale) {
+            conn.markStale();
+            this._sessions = [];
+            this._log('debug', { type: 'daemon-connection-lost' });
+        }
+    }
+    _noDaemonError() {
+        return noDaemonError(this._noAutostartHint);
+    }
+    static _DEFAULT_CALL_TIMEOUT_MS = 15_000;
+    _callTimeoutMs;
+    async _withDaemon(fn, options) {
+        const daemon = await this._waitForDaemon();
+        if (!daemon) {
+            return this._noDaemonError();
+        }
+        try {
+            if (options?.noTimeout) {
+                return await fn(daemon);
+            }
+            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error('__mcp_timeout__')), this._callTimeoutMs));
+            return await Promise.race([fn(daemon), timeout]);
+        }
+        catch (e) {
+            if (e instanceof Error && e.message === '__mcp_timeout__') {
+                return {
+                    content: [{ type: 'text', text: `Error: Operation timed out after ${this._callTimeoutMs / 1000}s. Retry, if the error persists, restart the involved session using the restart_session tool and retry.` }],
+                    isError: true,
+                };
+            }
+            if (isPipeConnectionError(e)) {
+                this._log('debug', { type: 'daemon-call-failed', error: String(e) });
+                this._handleDisconnect();
+                return this._noDaemonError();
+            }
+            throw e;
+        }
+    }
+    _log(level, data) {
+        const mcpLevel = level === 'trace' ? 'debug' : level;
+        this._mcp.sendLoggingMessage({ level: mcpLevel, logger: 'daemon', data }).catch(() => { });
+    }
+    _startEventListener(daemon) {
+        const controller = new AbortController();
+        this._eventStreamAbortController = controller;
+        (async () => {
+            try {
+                const stream = await daemon.methods.events();
+                for await (const raw of stream) {
+                    if (controller.signal.aborted)
+                        break;
+                    const event = raw;
+                    if (event.type === 'source-change' && event.sessionName && event.sourceTreeId) {
+                        this._updateSessionSourceTreeId(event.sessionName, event.sourceTreeId);
+                    }
+                    if (event.type === 'ref-change' || event.type === 'session-change') {
+                        await this._refreshSessions();
+                    }
+                    this._log(event.type === 'log' && event.level === 'debug' ? 'debug' : 'info', event);
+                }
+            }
+            catch (e) {
+                if (!controller.signal.aborted) {
+                    this._log('info', { type: 'event-stream-error', error: String(e) });
+                }
+            }
+        })();
     }
     // -- Helpers --------------------------------------------------------------
     _defaultSessionName() {
@@ -75,7 +255,7 @@ class ComponentExplorerMcpServer {
     }
     _sourceTreeId(sessionName) {
         const s = this._sessions.find(s => s.name === sessionName);
-        return s?.sourceTreeId ?? '';
+        return s && !s.isLoading ? s.sourceTreeId : '';
     }
     _updateSessionSourceTreeId(sessionName, sourceTreeId) {
         const s = this._sessions.find(s => s.name === sessionName);
@@ -84,67 +264,192 @@ class ComponentExplorerMcpServer {
         }
     }
     async _refreshSessions() {
-        this._sessions = await this._daemon.methods.sessions();
+        const conn = this._getConnection();
+        if (conn) {
+            try {
+                const prevCount = this._sessions.length;
+                this._sessions = await conn.client.methods.sessions();
+                if (this._sessions.length !== prevCount) {
+                    this._updateMultiSessionToolVisibility();
+                }
+            }
+            catch (e) {
+                if (isPipeConnectionError(e)) {
+                    this._handleDisconnect();
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+    }
+    _updateMultiSessionToolVisibility() {
+        const isMultiSession = this._sessions.length > 1;
+        for (const tool of this._multiSessionTools) {
+            if (isMultiSession) {
+                tool.enable();
+            }
+            else {
+                tool.disable();
+            }
+        }
+    }
+    async _withSourceTreeRetry(fn) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes('Source tree changed')) {
+                await this._refreshSessions();
+                return await fn();
+            }
+            throw e;
+        }
     }
     // -- Tool registration ---------------------------------------------------
+    _filterFixtures(allFixtures, fixtureIdPattern, labelPattern) {
+        let fixtureIdRegex;
+        if (fixtureIdPattern) {
+            try {
+                fixtureIdRegex = new RegExp(fixtureIdPattern);
+            }
+            catch {
+                return { error: `Error: Invalid fixtureIdPattern: ${fixtureIdPattern}` };
+            }
+        }
+        let labelRegex;
+        if (labelPattern) {
+            try {
+                labelRegex = new RegExp(labelPattern);
+            }
+            catch {
+                return { error: `Error: Invalid labelPattern: ${labelPattern}` };
+            }
+        }
+        return {
+            fixtures: allFixtures.filter(f => (!fixtureIdRegex || fixtureIdRegex.test(f.fixtureId)) &&
+                (!labelRegex || f.labels.some(l => labelRegex.test(l)))),
+        };
+    }
     _registerTools() {
         this._registerListFixtures();
         this._registerScreenshot();
         this._registerCompareScreenshot();
         this._registerApproveDiff();
+        this._registerEvaluateJs();
+        this._registerDebugReloadPage();
         this._registerWatchAdd();
         this._registerWatchRemove();
         this._registerWatchSet();
         this._registerWatchCompare();
         this._registerWaitForUpdate();
         this._registerSessions();
+        this._registerRestartSession();
+        this._registerOpenSession();
+        this._registerCloseSession();
+        this._registerUpdateSessionRef();
+        this._registerGetUrl();
+        this._registerCheckStability();
+        this._registerCheckTask();
+        this._registerCancelTask();
     }
     _registerListFixtures() {
         this._mcp.registerTool('list_fixtures', {
             description: 'List all fixtures from a session',
             inputSchema: {
+                fixtureIdPattern: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
+                labelPattern: z.string().optional().describe('RegExp to filter fixtures by label (matched against inherited labels)'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
                 sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
             },
-        }, async (args) => {
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
-            const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
-            const fixtures = await this._daemon.methods.fixtures.list({ sessionName, sourceTreeId });
-            return {
-                content: [{ type: 'text', text: JSON.stringify(fixtures, null, 2) }],
-            };
-        });
+            this._log('debug', { type: 'tool-call', tool: 'list_fixtures', sessionName });
+            return this._withSourceTreeRetry(async () => {
+                const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
+                const allFixtures = await daemon.methods.fixtures.list({ sessionName, sourceTreeId });
+                const filtered = this._filterFixtures(allFixtures, args.fixtureIdPattern, args.labelPattern);
+                if ('error' in filtered) {
+                    return { content: [{ type: 'text', text: filtered.error }], isError: true };
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(filtered.fixtures, null, 2) }],
+                };
+            });
+        }));
     }
     _registerScreenshot() {
         this._mcp.registerTool('screenshot', {
-            description: 'Take a screenshot of a single fixture',
+            description: 'Take a screenshot of a single fixture. ' +
+                'When stabilityCheck is true, the fixture is unmounted and re-mounted, then three screenshots are taken. ',
             inputSchema: {
                 fixtureId: z.string().describe('The fixture ID'),
                 sessionName: z.string().optional().describe('Session name (defaults to first session)'),
                 sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
+                stabilityCheck: z.boolean().optional().describe('If true, takes three screenshots (at render time, ~500ms, ~3000ms) to check visual stability. Expensive (~3s extra) — only use it when you need to verify rendering stability..'),
             },
-        }, async (args) => {
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
             const sessionName = args.sessionName ?? this._defaultSessionName();
-            const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
-            const result = await this._daemon.methods.screenshots.take({
-                fixtureId: args.fixtureId,
-                sessionName,
-                sourceTreeId,
-                includeImage: true,
+            this._log('debug', { type: 'tool-call', tool: 'screenshot', fixtureId: args.fixtureId, sessionName });
+            this._log('trace', { type: 'tool-args', tool: 'screenshot', args });
+            return this._withSourceTreeRetry(async () => {
+                const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
+                const result = await daemon.methods.screenshots.take({
+                    fixtureId: args.fixtureId,
+                    sessionName,
+                    sourceTreeId,
+                    includeImage: true,
+                    stabilityCheck: args.stabilityCheck,
+                });
+                const r = result;
+                this._updateSessionSourceTreeId(sessionName, r.sourceTreeId);
+                const info = {
+                    hash: r.hash,
+                    sourceTreeId: r.sourceTreeId,
+                };
+                if (r.hasError) {
+                    info.hasError = true;
+                }
+                if (r.error) {
+                    info.error = r.error;
+                }
+                if (r.events && r.events.length > 0) {
+                    info.events = r.events;
+                }
+                if (r.resultData !== undefined) {
+                    info.resultData = r.resultData;
+                }
+                if (r.isStable !== undefined) {
+                    info.isStable = r.isStable;
+                }
+                const content = [];
+                if (r.isStable === false && r.stabilityScreenshots) {
+                    // Not stable: return all distinct screenshots
+                    const seenHashes = new Set();
+                    const screenshotDetails = [];
+                    for (const s of r.stabilityScreenshots) {
+                        screenshotDetails.push({ hash: s.hash, delayMs: s.delayMs });
+                        if (!seenHashes.has(s.hash) && s.image) {
+                            seenHashes.add(s.hash);
+                            content.push({ type: 'image', data: s.image, mimeType: 'image/png' });
+                        }
+                    }
+                    info.stabilityScreenshots = screenshotDetails;
+                }
+                else if (r.image) {
+                    // Stable or no stability check: return single image
+                    content.push({ type: 'image', data: r.image, mimeType: 'image/png' });
+                }
+                content.unshift({ type: 'text', text: JSON.stringify(info, null, 2) });
+                return { content };
             });
-            const r = result;
-            this._updateSessionSourceTreeId(sessionName, r.sourceTreeId);
-            const content = [
-                { type: 'text', text: `hash: ${r.hash}\nsourceTreeId: ${r.sourceTreeId}` },
-            ];
-            if (r.image) {
-                content.push({ type: 'image', data: r.image, mimeType: 'image/png' });
-            }
-            return { content };
-        });
+        }));
     }
     _registerCompareScreenshot() {
-        this._mcp.registerTool('compare_screenshot', {
+        const tool = this._mcp.registerTool('compare_screenshot', {
             description: 'Compare a fixture\'s screenshot across two sessions (e.g. baseline vs current)',
             inputSchema: {
                 fixtureId: z.string().describe('The fixture ID'),
@@ -153,42 +458,74 @@ class ComponentExplorerMcpServer {
                 baselineSourceTreeId: z.string().optional().describe('Baseline source tree ID (defaults to latest known)'),
                 currentSourceTreeId: z.string().optional().describe('Current source tree ID (defaults to latest known)'),
             },
-        }, async (args) => {
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
             const baselineSessionName = args.baselineSessionName ?? this._defaultBaselineSessionName();
             const currentSessionName = args.currentSessionName ?? this._defaultCurrentSessionName();
-            const baselineSourceTreeId = args.baselineSourceTreeId ?? this._sourceTreeId(baselineSessionName);
-            const currentSourceTreeId = args.currentSourceTreeId ?? this._sourceTreeId(currentSessionName);
-            const result = await this._daemon.methods.screenshots.compare({
-                fixtureId: args.fixtureId,
-                baselineSessionName,
-                baselineSourceTreeId,
-                currentSessionName,
-                currentSourceTreeId,
-                includeImages: true,
+            this._log('debug', { type: 'tool-call', tool: 'compare_screenshot', fixtureId: args.fixtureId, baselineSessionName, currentSessionName });
+            return this._withSourceTreeRetry(async () => {
+                const baselineSourceTreeId = args.baselineSourceTreeId ?? this._sourceTreeId(baselineSessionName);
+                const currentSourceTreeId = args.currentSourceTreeId ?? this._sourceTreeId(currentSessionName);
+                const result = await daemon.methods.screenshots.compare({
+                    fixtureId: args.fixtureId,
+                    baselineSessionName,
+                    baselineSourceTreeId,
+                    currentSessionName,
+                    currentSourceTreeId,
+                    includeImages: true,
+                });
+                const r = result;
+                const info = {
+                    match: r.match,
+                    baselineHash: r.baselineHash,
+                    currentHash: r.currentHash,
+                    baselineSourceTreeId,
+                    currentSourceTreeId,
+                };
+                if (r.baselineHasError) {
+                    info.baselineHasError = true;
+                }
+                if (r.baselineError) {
+                    info.baselineError = r.baselineError;
+                }
+                if (r.baselineEvents && r.baselineEvents.length > 0) {
+                    info.baselineEvents = r.baselineEvents;
+                }
+                if (r.baselineResultData !== undefined) {
+                    info.baselineResultData = r.baselineResultData;
+                }
+                if (r.currentHasError) {
+                    info.currentHasError = true;
+                }
+                if (r.currentError) {
+                    info.currentError = r.currentError;
+                }
+                if (r.currentEvents && r.currentEvents.length > 0) {
+                    info.currentEvents = r.currentEvents;
+                }
+                if (r.currentResultData !== undefined) {
+                    info.currentResultData = r.currentResultData;
+                }
+                if (r.approval) {
+                    info.approval = r.approval;
+                }
+                const content = [
+                    { type: 'text', text: JSON.stringify(info, null, 2) },
+                ];
+                if (r.baselineImage) {
+                    content.push({ type: 'image', data: r.baselineImage, mimeType: 'image/png' });
+                }
+                if (r.currentImage) {
+                    content.push({ type: 'image', data: r.currentImage, mimeType: 'image/png' });
+                }
+                return { content };
             });
-            const r = result;
-            const info = {
-                match: r.match,
-                baselineHash: r.baselineHash,
-                currentHash: r.currentHash,
-            };
-            if (r.approval) {
-                info.approval = r.approval;
-            }
-            const content = [
-                { type: 'text', text: JSON.stringify(info, null, 2) },
-            ];
-            if (r.baselineImage) {
-                content.push({ type: 'image', data: r.baselineImage, mimeType: 'image/png' });
-            }
-            if (r.currentImage) {
-                content.push({ type: 'image', data: r.currentImage, mimeType: 'image/png' });
-            }
-            return { content };
-        });
+        }));
+        tool.disable();
+        this._multiSessionTools.push(tool);
     }
     _registerApproveDiff() {
-        this._mcp.registerTool('approve_diff', {
+        const tool = this._mcp.registerTool('approve_diff', {
             description: 'Approve a visual diff so it won\'t require re-inspection next time',
             inputSchema: {
                 fixtureId: z.string(),
@@ -196,15 +533,77 @@ class ComponentExplorerMcpServer {
                 modifiedHash: z.string(),
                 comment: z.string().describe('Reason for approving this diff'),
             },
-        }, async (args) => {
-            await this._daemon.methods.approvals.approve(args);
+        }, async (args) => this._withDaemon(async (daemon) => {
+            await daemon.methods.approvals.approve(args);
             return {
                 content: [{
                         type: 'text',
                         text: `Approved diff for ${args.fixtureId}: ${args.originalHash} → ${args.modifiedHash}`,
                     }],
             };
-        });
+        }));
+        tool.disable();
+        this._multiSessionTools.push(tool);
+    }
+    _registerEvaluateJs() {
+        this._mcp.registerTool('evaluate_js', {
+            description: 'Evaluate a JavaScript expression in the browser page where fixtures are rendered, for debugging purposes. ' +
+                'Returns the expression result as JSON. The expression can return a Promise (it will be awaited). ' +
+                'Use this to inspect DOM state, computed styles, element dimensions, or component output. ' +
+                'Do NOT use this to modify the DOM — this tool is for read-only inspection and debugging only.',
+            inputSchema: {
+                expression: z.string().describe('JavaScript expression to evaluate. Can return a Promise. The result must be JSON-serializable.'),
+                fixtureId: z.string().optional().describe('If provided, renders this fixture before evaluating the expression'),
+                sessionName: z.string().optional().describe('Session name (defaults to first session)'),
+                sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
+            },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            const sessionName = args.sessionName ?? this._defaultSessionName();
+            this._log('debug', { type: 'tool-call', tool: 'evaluate_js', sessionName, hasFixtureId: !!args.fixtureId });
+            this._log('trace', { type: 'tool-args', tool: 'evaluate_js', expressionLength: args.expression.length, fixtureId: args.fixtureId });
+            return this._withSourceTreeRetry(async () => {
+                const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
+                const result = await daemon.methods.evaluate({
+                    sessionName,
+                    sourceTreeId,
+                    expression: args.expression,
+                    fixtureId: args.fixtureId,
+                });
+                const r = result;
+                let text;
+                try {
+                    text = JSON.stringify(r.result, null, 2) ?? 'undefined';
+                }
+                catch {
+                    text = String(r.result);
+                }
+                return {
+                    content: [{ type: 'text', text }],
+                };
+            });
+        }));
+    }
+    _registerDebugReloadPage() {
+        this._mcp.registerTool('debug_reload_page', {
+            description: 'Force-reload the browser page used for rendering fixtures. ' +
+                'Only use this as a last resort if screenshots or evaluate_js return stale/broken results ' +
+                'that persist after source changes. Normal HMR updates should handle most cases automatically.',
+            inputSchema: {
+                sessionName: z.string().optional().describe('Session name (defaults to first session)'),
+            },
+            annotations: { destructiveHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            const sessionName = args.sessionName ?? this._defaultSessionName();
+            const sourceTreeId = this._sourceTreeId(sessionName);
+            await daemon.methods.evaluate({
+                sessionName,
+                sourceTreeId,
+                expression: 'location.reload()',
+            });
+            return {
+                content: [{ type: 'text', text: `Reloaded page for session '${sessionName}'.` }],
+            };
+        }));
     }
     _registerWatchAdd() {
         this._mcp.registerTool('watch_add', {
@@ -255,7 +654,7 @@ class ComponentExplorerMcpServer {
         });
     }
     _registerWatchCompare() {
-        this._mcp.registerTool('watch_compare', {
+        const tool = this._mcp.registerTool('watch_compare', {
             description: 'Compare all watched fixtures across two sessions. Takes fresh screenshots from both sessions and reports which fixtures differ.',
             inputSchema: {
                 baselineSessionName: z.string().optional().describe('Baseline session name (defaults to worktree session)'),
@@ -263,124 +662,483 @@ class ComponentExplorerMcpServer {
                 baselineSourceTreeId: z.string().optional().describe('Baseline source tree ID (defaults to latest known)'),
                 currentSourceTreeId: z.string().optional().describe('Current source tree ID (defaults to latest known)'),
             },
-        }, async (args) => {
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
             const ids = [...this._watchList.fixtureIds];
             if (ids.length === 0) {
                 return { content: [{ type: 'text', text: 'Watch list is empty. Use watch_add or watch_set first.' }] };
             }
             const baselineSessionName = args.baselineSessionName ?? this._defaultBaselineSessionName();
             const currentSessionName = args.currentSessionName ?? this._defaultCurrentSessionName();
-            const baselineSourceTreeId = args.baselineSourceTreeId ?? this._sourceTreeId(baselineSessionName);
-            const currentSourceTreeId = args.currentSourceTreeId ?? this._sourceTreeId(currentSessionName);
-            const [baselineResult, currentResult] = await Promise.all([
-                this._daemon.methods.screenshots.takeBatch({
-                    fixtureIds: ids,
-                    sessionName: baselineSessionName,
-                    sourceTreeId: baselineSourceTreeId,
-                }),
-                this._daemon.methods.screenshots.takeBatch({
-                    fixtureIds: ids,
-                    sessionName: currentSessionName,
-                    sourceTreeId: currentSourceTreeId,
-                }),
-            ]);
-            const br = baselineResult;
-            const cr = currentResult;
-            const baselineMap = new Map(br.screenshots.map(s => [s.fixtureId, s.hash]));
-            const currentMap = new Map(cr.screenshots.map(s => [s.fixtureId, s.hash]));
-            const entries = ids.map(id => {
-                const bHash = baselineMap.get(id) ?? '';
-                const cHash = currentMap.get(id) ?? '';
+            return this._withSourceTreeRetry(async () => {
+                const baselineSourceTreeId = args.baselineSourceTreeId ?? this._sourceTreeId(baselineSessionName);
+                const currentSourceTreeId = args.currentSourceTreeId ?? this._sourceTreeId(currentSessionName);
+                const [baselineResult, currentResult] = await Promise.all([
+                    daemon.methods.screenshots.takeBatch({
+                        fixtureIds: ids,
+                        sessionName: baselineSessionName,
+                        sourceTreeId: baselineSourceTreeId,
+                    }),
+                    daemon.methods.screenshots.takeBatch({
+                        fixtureIds: ids,
+                        sessionName: currentSessionName,
+                        sourceTreeId: currentSourceTreeId,
+                    }),
+                ]);
+                const br = baselineResult;
+                const cr = currentResult;
+                const baselineMap = new Map(br.screenshots.map(s => [s.fixtureId, s.hash]));
+                const currentMap = new Map(cr.screenshots.map(s => [s.fixtureId, s.hash]));
+                const entries = ids.map(id => {
+                    const bHash = baselineMap.get(id) ?? '';
+                    const cHash = currentMap.get(id) ?? '';
+                    return {
+                        fixtureId: id,
+                        match: bHash === cHash,
+                        baselineHash: bHash,
+                        currentHash: cHash,
+                    };
+                });
+                // Look up approvals for changed fixtures
+                const results = [];
+                for (const entry of entries) {
+                    let approval = undefined;
+                    if (!entry.match && entry.baselineHash && entry.currentHash) {
+                        approval = await daemon.methods.approvals.lookup({
+                            fixtureId: entry.fixtureId,
+                            originalHash: entry.baselineHash,
+                            modifiedHash: entry.currentHash,
+                        }) ?? undefined;
+                    }
+                    results.push({ ...entry, approval });
+                }
                 return {
-                    fixtureId: id,
-                    match: bHash === cHash,
-                    baselineHash: bHash,
-                    currentHash: cHash,
+                    content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
                 };
             });
-            // Look up approvals for changed fixtures
-            const results = [];
-            for (const entry of entries) {
-                let approval = undefined;
-                if (!entry.match && entry.baselineHash && entry.currentHash) {
-                    approval = await this._daemon.methods.approvals.lookup({
-                        fixtureId: entry.fixtureId,
-                        originalHash: entry.baselineHash,
-                        modifiedHash: entry.currentHash,
-                    }) ?? undefined;
-                }
-                results.push({ ...entry, approval });
-            }
-            return {
-                content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
-            };
-        });
+        }));
+        tool.disable();
+        this._multiSessionTools.push(tool);
     }
     _registerWaitForUpdate() {
         this._mcp.registerTool('wait_for_update', {
-            description: 'Block until the next source change or ref change event. If fixtures are on the watch list, automatically re-screenshots them and reports which changed.',
-        }, async () => {
-            const events = await this._daemon.methods.events();
+            description: 'Block until the source tree changes from the given sourceTreeId. ' +
+                'Pass the sourceTreeId you already observed — resolves immediately if it already differs, ' +
+                'otherwise waits for a source-change or ref-change event. ' +
+                'If fixtures are on the watch list, automatically re-screenshots them and reports which changed.',
+            inputSchema: {
+                sourceTreeId: z.string().describe('The sourceTreeId the client currently knows about. The call resolves once the source tree differs from this value.'),
+                sessionName: z.string().optional().describe('Session name (defaults to first session)'),
+            },
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            const sessionName = args.sessionName ?? this._defaultSessionName();
+            const knownSourceTreeId = args.sourceTreeId;
+            const currentSourceTreeId = this._sourceTreeId(sessionName);
+            if (currentSourceTreeId && currentSourceTreeId !== knownSourceTreeId) {
+                return this._waitForUpdateResult(daemon, sessionName, currentSourceTreeId);
+            }
+            // Wait for an event that changes the source tree (max 5s)
+            const events = await daemon.methods.events();
             const iterator = events[Symbol.asyncIterator]();
-            const { value: event, done } = await iterator.next();
-            // Close the stream after consuming one event
-            await iterator.return?.();
-            if (done || !event) {
-                return { content: [{ type: 'text', text: 'Event stream ended.' }] };
+            try {
+                const deadline = Date.now() + 5000;
+                while (true) {
+                    const remaining = deadline - Date.now();
+                    if (remaining <= 0) {
+                        return { content: [{ type: 'text', text: JSON.stringify({ timeout: true, sessionName, sourceTreeId: knownSourceTreeId }, null, 2) }] };
+                    }
+                    const timeout = new Promise(resolve => setTimeout(() => resolve('timeout'), remaining));
+                    const next = iterator.next();
+                    const result = await Promise.race([next, timeout]);
+                    if (result === 'timeout') {
+                        return { content: [{ type: 'text', text: JSON.stringify({ timeout: true, sessionName, sourceTreeId: knownSourceTreeId }, null, 2) }] };
+                    }
+                    const { value: event, done } = result;
+                    if (done || !event) {
+                        return { content: [{ type: 'text', text: 'Event stream ended.' }] };
+                    }
+                    const ev = event;
+                    if (ev.type === 'source-change' && ev.sourceTreeId) {
+                        this._updateSessionSourceTreeId(ev.sessionName, ev.sourceTreeId);
+                    }
+                    if (ev.type === 'ref-change') {
+                        const refreshResult = await Promise.race([this._refreshSessions(), timeout]);
+                        if (refreshResult === 'timeout') {
+                            return { content: [{ type: 'text', text: JSON.stringify({ timeout: true, sessionName, sourceTreeId: knownSourceTreeId }, null, 2) }] };
+                        }
+                    }
+                    const newSourceTreeId = this._sourceTreeId(sessionName);
+                    if (newSourceTreeId && newSourceTreeId !== knownSourceTreeId) {
+                        return this._waitForUpdateResult(daemon, sessionName, newSourceTreeId);
+                    }
+                }
             }
-            const ev = event;
-            // Update cached session info
-            if (ev.type === 'source-change' && ev.sourceTreeId) {
-                this._updateSessionSourceTreeId(ev.sessionName, ev.sourceTreeId);
+            finally {
+                await iterator.return?.();
             }
-            if (ev.type === 'ref-change') {
-                await this._refreshSessions();
+        }));
+    }
+    async _waitForUpdateResult(daemon, sessionName, sourceTreeId) {
+        const watchedIds = [...this._watchList.fixtureIds];
+        if (watchedIds.length > 0) {
+            const batchResult = await daemon.methods.screenshots.takeBatch({
+                fixtureIds: watchedIds,
+                sessionName,
+                sourceTreeId,
+            });
+            const br = batchResult;
+            const changes = [];
+            for (const s of br.screenshots) {
+                const prevHash = this._watchList.getHash(s.fixtureId);
+                const changed = prevHash !== undefined && prevHash !== s.hash;
+                this._watchList.setHash(s.fixtureId, s.hash);
+                if (changed) {
+                    changes.push({ fixtureId: s.fixtureId, previousHash: prevHash, hash: s.hash });
+                }
             }
-            // If there are watched fixtures and this is a source-change, re-screenshot them
-            const watchedIds = [...this._watchList.fixtureIds];
-            if (ev.type === 'source-change' && watchedIds.length > 0 && ev.sourceTreeId) {
-                const batchResult = await this._daemon.methods.screenshots.takeBatch({
-                    fixtureIds: watchedIds,
-                    sessionName: ev.sessionName,
-                    sourceTreeId: ev.sourceTreeId,
-                });
-                const br = batchResult;
-                const changes = [];
-                for (const s of br.screenshots) {
-                    const prevHash = this._watchList.getHash(s.fixtureId);
-                    const changed = prevHash !== undefined && prevHash !== s.hash;
-                    this._watchList.setHash(s.fixtureId, s.hash);
-                    if (changed) {
-                        changes.push({ fixtureId: s.fixtureId, previousHash: prevHash, hash: s.hash });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            sourceTreeId,
+                            sessionName,
+                            watchedFixtures: br.screenshots.length,
+                            changed: changes,
+                        }, null, 2),
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ sourceTreeId, sessionName }, null, 2),
+                }],
+        };
+    }
+    _registerSessions() {
+        this._mcp.registerTool('sessions', {
+            description: 'List active sessions with their names, URLs, and current sourceTreeIds',
+            annotations: { readOnlyHint: true },
+        }, async () => this._withDaemon(async (_daemon) => {
+            await this._refreshSessions();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(this._sessions, null, 2) }],
+            };
+        }));
+    }
+    _registerRestartSession() {
+        this._mcp.registerTool('restart_session', {
+            description: 'Restart a session by disposing its browser page and dev server, then recreating them. ' +
+                'Use this when a session appears stuck (e.g. after a timeout).',
+            inputSchema: {
+                sessionName: z.string().optional().describe('Session name to restart (defaults to first session)'),
+            },
+            annotations: { destructiveHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            const sessionName = args.sessionName ?? this._defaultSessionName();
+            this._log('info', { type: 'tool-call', tool: 'restart_session', sessionName });
+            const sessions = await daemon.methods.restartSession({ sessionName });
+            this._sessions = sessions;
+            return {
+                content: [{ type: 'text', text: `Session '${sessionName}' restarted.\n` + JSON.stringify(sessions, null, 2) }],
+            };
+        }));
+    }
+    _registerOpenSession() {
+        this._mcp.registerTool('open_session', {
+            description: 'Open a new worktree-backed session at a given git ref. ' +
+                'The ref can be a branch name, tag, commit SHA, or the special value "INDEX" to snapshot staged changes. ' +
+                'The daemon allocates a reusable worktree slot from a fixed pool (max configured in component-explorer.json). ' +
+                'Returns the updated session list on success.',
+            inputSchema: {
+                name: z.string().describe('Unique session name (e.g. "baseline", "bisect")'),
+                ref: z.string().describe('Git ref: branch, tag, commit SHA, or "INDEX" for staged changes'),
+            },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            this._log('info', { type: 'tool-call', tool: 'open_session', name: args.name, ref: args.ref });
+            const result = await daemon.methods.openSession({ name: args.name, ref: args.ref });
+            if ('error' in result) {
+                return { content: [{ type: 'text', text: result.error }], isError: true };
+            }
+            this._sessions = result.sessions;
+            this._updateMultiSessionToolVisibility();
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result.sessions, null, 2) }],
+            };
+        }, { noTimeout: true }));
+    }
+    _registerCloseSession() {
+        this._mcp.registerTool('close_session', {
+            description: 'Close a dynamic worktree session and release its worktree slot back to the pool. ' +
+                'Cannot close static sessions configured in component-explorer.json.',
+            inputSchema: {
+                name: z.string().describe('Session name to close'),
+            },
+            annotations: { destructiveHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            this._log('info', { type: 'tool-call', tool: 'close_session', name: args.name });
+            const result = await daemon.methods.closeSession({ name: args.name });
+            if ('error' in result) {
+                return { content: [{ type: 'text', text: result.error }], isError: true };
+            }
+            this._sessions = result.sessions;
+            this._updateMultiSessionToolVisibility();
+            return {
+                content: [{ type: 'text', text: `Session '${args.name}' closed.\n` + JSON.stringify(result.sessions, null, 2) }],
+            };
+        }));
+    }
+    _registerUpdateSessionRef() {
+        this._mcp.registerTool('update_session_ref', {
+            description: 'Change the git ref of an existing dynamic session. ' +
+                'The worktree is checked out to the new ref and Vite\'s HMR handles the incremental update (no server restart). ' +
+                'Fails if the worktree has uncommitted changes — the error will list the dirty files. ' +
+                'The ref can be a branch, tag, commit SHA, or "INDEX" for staged changes.',
+            inputSchema: {
+                name: z.string().describe('Session name to update'),
+                ref: z.string().describe('New git ref: branch, tag, commit SHA, or "INDEX"'),
+            },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            this._log('info', { type: 'tool-call', tool: 'update_session_ref', name: args.name, ref: args.ref });
+            const result = await daemon.methods.updateSessionRef({ name: args.name, ref: args.ref });
+            if ('error' in result) {
+                return { content: [{ type: 'text', text: result.error }], isError: true };
+            }
+            this._sessions = result.sessions;
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result.sessions, null, 2) }],
+            };
+        }, { noTimeout: true }));
+    }
+    _registerGetUrl() {
+        this._mcp.registerTool('get_url', {
+            description: 'Get URL(s) for viewing fixtures. Returns the Component Explorer UI URL by default, ' +
+                'or the raw render URL for embedding/screenshots when useRawDirectRenderingWithoutExplorerUi is true.',
+            inputSchema: {
+                sessionName: z.string().optional().describe('Session name (defaults to first session)'),
+                fixtureId: z.string().optional().describe('Specific fixture ID. If omitted, returns URL for the explorer root or all fixtures.'),
+                useRawDirectRenderingWithoutExplorerUi: z.boolean().optional().describe('If true, returns the raw rendering URL (for embedding or screenshots) instead of the Explorer UI URL. ' +
+                    'The raw URL renders only the fixture without the explorer chrome. Default: false.'),
+            },
+            annotations: { readOnlyHint: true },
+        }, async (args) => {
+            const sessionName = args.sessionName ?? this._defaultSessionName();
+            let session = this._sessions.find(s => s.name === sessionName);
+            if (!session) {
+                const daemon = await this._waitForDaemon();
+                if (daemon) {
+                    try {
+                        await this._refreshSessions();
                     }
+                    catch (e) {
+                        if (isPipeConnectionError(e)) {
+                            this._handleDisconnect();
+                        }
+                        else {
+                            throw e;
+                        }
+                    }
+                }
+                session = this._sessions.find(s => s.name === sessionName);
+                if (!session) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Error: Session '${sessionName}' not found. Available sessions: ${this._sessions.map(s => s.name).join(', ') || '(none)'}`,
+                            }],
+                        isError: true,
+                    };
                 }
+            }
+            const baseUrl = session && !session.isLoading ? session.serverUrl : undefined;
+            if (!baseUrl) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: Session '${sessionName}' is still loading.`,
+                        }],
+                    isError: true,
+                };
+            }
+            const useRaw = args.useRawDirectRenderingWithoutExplorerUi ?? false;
+            const url = buildExplorerUrl({
+                baseUrl,
+                rawRender: useRaw,
+                fixtureId: args.fixtureId,
+            });
+            const result = {
+                url,
+                sessionName,
+            };
+            if (args.fixtureId) {
+                result.fixtureId = args.fixtureId;
+            }
+            if (useRaw) {
+                result.mode = 'raw-render';
+            }
+            else {
+                result.mode = 'explorer';
+                if (args.fixtureId) {
+                    result.note = 'Fixture selection in the Explorer UI is not URL-based. Navigate to the fixture manually in the tree view.';
+                }
+            }
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        });
+    }
+    _registerCheckStability() {
+        this._mcp.registerTool('check_stability', {
+            description: 'Check rendering stability of fixtures. Each fixture is unmounted, re-mounted, and screenshotted 3 times (~3s per fixture). ' +
+                'Returns results directly if finished within ~10s, otherwise returns a taskId for polling via check_task. ' +
+                'When returning a taskId, includes partial results collected so far.',
+            inputSchema: {
+                fixtureIdPattern: z.string().optional().describe('RegExp to filter fixtures by fixture ID'),
+                labelPattern: z.string().optional().describe('RegExp to filter fixtures by label (matched against inherited labels)'),
+                sessionName: z.string().optional().describe('Session name (defaults to first session)'),
+                sourceTreeId: z.string().optional().describe('Source tree ID (defaults to latest known)'),
+            },
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            const sessionName = args.sessionName ?? this._defaultSessionName();
+            this._log('debug', { type: 'tool-call', tool: 'check_stability', sessionName, fixtureIdPattern: args.fixtureIdPattern, labelPattern: args.labelPattern });
+            return this._withSourceTreeRetry(async () => {
+                const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
+                const allFixtures = await daemon.methods.fixtures.list({ sessionName, sourceTreeId });
+                const filtered = this._filterFixtures(allFixtures, args.fixtureIdPattern, args.labelPattern);
+                if ('error' in filtered) {
+                    return { content: [{ type: 'text', text: filtered.error }], isError: true };
+                }
+                const fixtures = filtered.fixtures;
+                this._log('info', { type: 'check-stability-start', total: fixtures.length, filtered: allFixtures.length - fixtures.length });
+                const task = this._taskManager.startTask(async (report, signal) => {
+                    const results = [];
+                    report({ completed: 0, total: fixtures.length, partialResult: results });
+                    for (let i = 0; i < fixtures.length; i++) {
+                        if (signal.aborted) {
+                            break;
+                        }
+                        const fixture = fixtures[i];
+                        this._log('info', { type: 'check-stability-progress', fixtureId: fixture.fixtureId, index: i + 1, total: fixtures.length });
+                        const result = await daemon.methods.screenshots.take({
+                            fixtureId: fixture.fixtureId,
+                            sessionName,
+                            sourceTreeId,
+                            includeImage: false,
+                            stabilityCheck: true,
+                        });
+                        const r = result;
+                        results.push({
+                            fixtureId: fixture.fixtureId,
+                            isStable: r.isStable ?? true,
+                            screenshots: r.stabilityScreenshots?.map(s => ({ hash: s.hash, delayMs: s.delayMs })) ?? [],
+                        });
+                        report({ completed: i + 1, total: fixtures.length, partialResult: results });
+                    }
+                    const stable = results.filter(r => r.isStable).length;
+                    return {
+                        fixtures: results,
+                        summary: { total: results.length, stable, unstable: results.length - stable },
+                    };
+                });
+                const waited = await this._taskManager.waitForTask(task.id, 10_000);
+                if (!waited) {
+                    return { content: [{ type: 'text', text: 'Error: task disappeared' }], isError: true };
+                }
+                if (waited.done) {
+                    return {
+                        content: [{ type: 'text', text: JSON.stringify(waited.result, null, 2) }],
+                    };
+                }
+                const partial = waited.progress.partialResult;
+                this._taskLastReportedIndex.set(task.id, partial.length);
                 return {
                     content: [{
                             type: 'text',
                             text: JSON.stringify({
-                                event: ev,
-                                watchedFixtures: br.screenshots.length,
-                                changed: changes,
+                                taskId: task.id,
+                                status: 'running',
+                                progress: { completed: waited.progress.completed, total: waited.progress.total },
+                                elapsedMs: waited.elapsedMs,
+                                results: partial,
                             }, null, 2),
                         }],
                 };
+            });
+        }));
+    }
+    _registerCheckTask() {
+        this._mcp.registerTool('check_task', {
+            description: 'Check on a running task. Waits up to ~2s for completion; if still running, returns progress and new results since last check.',
+            inputSchema: {
+                taskId: z.string().describe('The task ID returned by a previous tool call'),
+            },
+            annotations: { readOnlyHint: true },
+        }, async (args) => {
+            const waited = await this._taskManager.waitForTask(args.taskId, 2_000);
+            if (!waited) {
+                this._taskLastReportedIndex.delete(args.taskId);
+                return {
+                    content: [{ type: 'text', text: `Error: No task found with id '${args.taskId}'` }],
+                    isError: true,
+                };
             }
+            if (waited.done) {
+                const lastIndex = this._taskLastReportedIndex.get(args.taskId) ?? 0;
+                this._taskLastReportedIndex.delete(args.taskId);
+                const fullResult = waited.result;
+                const newResults = fullResult.fixtures.slice(lastIndex);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                status: 'done',
+                                newResults,
+                                summary: fullResult.summary,
+                            }, null, 2),
+                        }],
+                };
+            }
+            const partial = waited.progress.partialResult;
+            const lastIndex = this._taskLastReportedIndex.get(args.taskId) ?? 0;
+            const newResults = partial.slice(lastIndex);
+            this._taskLastReportedIndex.set(args.taskId, partial.length);
             return {
-                content: [{ type: 'text', text: JSON.stringify(ev, null, 2) }],
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            taskId: args.taskId,
+                            status: 'running',
+                            progress: { completed: waited.progress.completed, total: waited.progress.total },
+                            elapsedMs: waited.elapsedMs,
+                            newResults,
+                        }, null, 2),
+                    }],
             };
         });
     }
-    _registerSessions() {
-        this._mcp.registerTool('sessions', {
-            description: 'List active sessions with their names, URLs, and current sourceTreeIds',
-        }, async () => {
-            await this._refreshSessions();
+    _registerCancelTask() {
+        this._mcp.registerTool('cancel_task', {
+            description: 'Cancel a running task',
+            inputSchema: {
+                taskId: z.string().describe('The task ID to cancel'),
+            },
+        }, async (args) => {
+            const task = this._taskManager.getTask(args.taskId);
+            if (!task) {
+                return {
+                    content: [{ type: 'text', text: `Error: No task found with id '${args.taskId}'` }],
+                    isError: true,
+                };
+            }
+            this._taskManager.removeTask(args.taskId);
             return {
-                content: [{ type: 'text', text: JSON.stringify(this._sessions, null, 2) }],
+                content: [{ type: 'text', text: `Task '${args.taskId}' cancelled.` }],
             };
         });
     }
 }
 
-export { ComponentExplorerMcpServer };
+export { ComponentExplorerMcpServer, DaemonConnection };
 //# sourceMappingURL=McpServer.js.map