@vscode/component-explorer-cli 0.1.1-1 → 0.1.1-11

package/dist/mcp/McpServer.js

@@ -0,0 +1,820 @@
+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';
+
+// ---------------------------------------------------------------------------
+// Client-local state
+// ---------------------------------------------------------------------------
+class WatchList {
+    _fixtureIds = new Set();
+    _hashes = new Map();
+    get fixtureIds() { return this._fixtureIds; }
+    add(ids) {
+        for (const id of ids) {
+            this._fixtureIds.add(id);
+        }
+    }
+    remove(ids) {
+        for (const id of ids) {
+            this._fixtureIds.delete(id);
+            this._hashes.delete(id);
+        }
+    }
+    set(ids) {
+        this._fixtureIds.clear();
+        this._hashes.clear();
+        for (const id of ids) {
+            this._fixtureIds.add(id);
+        }
+    }
+    getHash(fixtureId) {
+        return this._hashes.get(fixtureId);
+    }
+    setHash(fixtureId, hash) {
+        this._hashes.set(fixtureId, hash);
+    }
+    toJSON() {
+        return {
+            fixtureIds: [...this._fixtureIds],
+            hashes: Object.fromEntries(this._hashes),
+        };
+    }
+}
+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 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();
+    _pollFn;
+    _noAutostartHint;
+    _multiSessionTools = [];
+    _sessions = [];
+    _eventStreamAbortController;
+    constructor(_daemonConnection, options) {
+        super();
+        this._daemonConnection = _daemonConnection;
+        this._pollFn = options.pollFn;
+        this._noAutostartHint = options.noAutostartHint;
+        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 _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);
+    }
+    async _withDaemon(fn) {
+        const daemon = await this._waitForDaemon();
+        if (!daemon) {
+            return this._noDaemonError();
+        }
+        try {
+            return await fn(daemon);
+        }
+        catch (e) {
+            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') {
+                        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() {
+        return this._sessions[0]?.name ?? 'current';
+    }
+    _defaultBaselineSessionName() {
+        const worktree = this._sessions.find(s => s.sourceKind === 'worktree');
+        return worktree?.name ?? this._sessions[1]?.name ?? this._defaultSessionName();
+    }
+    _defaultCurrentSessionName() {
+        const current = this._sessions.find(s => s.sourceKind === 'current');
+        return current?.name ?? this._defaultSessionName();
+    }
+    _sourceTreeId(sessionName) {
+        const s = this._sessions.find(s => s.name === sessionName);
+        return s && !s.isLoading ? s.sourceTreeId : '';
+    }
+    _updateSessionSourceTreeId(sessionName, sourceTreeId) {
+        const s = this._sessions.find(s => s.name === sessionName);
+        if (s) {
+            s.sourceTreeId = sourceTreeId;
+        }
+    }
+    async _refreshSessions() {
+        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 ---------------------------------------------------
+    _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._registerGetUrl();
+    }
+    _registerListFixtures() {
+        this._mcp.registerTool('list_fixtures', {
+            description: 'List all fixtures from a session',
+            inputSchema: {
+                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: 'list_fixtures', sessionName });
+            return this._withSourceTreeRetry(async () => {
+                const sourceTreeId = args.sourceTreeId ?? this._sourceTreeId(sessionName);
+                const fixtures = await daemon.methods.fixtures.list({ sessionName, sourceTreeId });
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(fixtures, null, 2) }],
+                };
+            });
+        }));
+    }
+    _registerScreenshot() {
+        this._mcp.registerTool('screenshot', {
+            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..'),
+            },
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            const sessionName = args.sessionName ?? this._defaultSessionName();
+            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.errors && r.errors.length > 0) {
+                    info.errors = r.errors;
+                }
+                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 };
+            });
+        }));
+    }
+    _registerCompareScreenshot() {
+        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'),
+                baselineSessionName: z.string().optional().describe('Baseline session name (defaults to worktree session)'),
+                currentSessionName: z.string().optional().describe('Current session name (defaults to current session)'),
+                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)'),
+            },
+            annotations: { readOnlyHint: true },
+        }, async (args) => this._withDaemon(async (daemon) => {
+            const baselineSessionName = args.baselineSessionName ?? this._defaultBaselineSessionName();
+            const currentSessionName = args.currentSessionName ?? this._defaultCurrentSessionName();
+            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,
+                };
+                if (r.baselineErrors && r.baselineErrors.length > 0) {
+                    info.baselineErrors = r.baselineErrors;
+                }
+                if (r.currentErrors && r.currentErrors.length > 0) {
+                    info.currentErrors = r.currentErrors;
+                }
+                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() {
+        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(),
+                originalHash: z.string(),
+                modifiedHash: z.string(),
+                comment: z.string().describe('Reason for approving this diff'),
+            },
+        }, 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', {
+            description: 'Add fixtures to the watch list. Watched fixtures are automatically re-screenshotted when source changes.',
+            inputSchema: {
+                fixtureIds: z.array(z.string()).describe('Fixture IDs to add'),
+            },
+        }, async (args) => {
+            this._watchList.add(args.fixtureIds);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Watch list: ${[...this._watchList.fixtureIds].join(', ') || '(empty)'}`,
+                    }],
+            };
+        });
+    }
+    _registerWatchRemove() {
+        this._mcp.registerTool('watch_remove', {
+            description: 'Remove fixtures from the watch list',
+            inputSchema: {
+                fixtureIds: z.array(z.string()).describe('Fixture IDs to remove'),
+            },
+        }, async (args) => {
+            this._watchList.remove(args.fixtureIds);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Watch list: ${[...this._watchList.fixtureIds].join(', ') || '(empty)'}`,
+                    }],
+            };
+        });
+    }
+    _registerWatchSet() {
+        this._mcp.registerTool('watch_set', {
+            description: 'Replace the watch list entirely',
+            inputSchema: {
+                fixtureIds: z.array(z.string()).describe('Fixture IDs to watch'),
+            },
+        }, async (args) => {
+            this._watchList.set(args.fixtureIds);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Watch list: ${[...this._watchList.fixtureIds].join(', ') || '(empty)'}`,
+                    }],
+            };
+        });
+    }
+    _registerWatchCompare() {
+        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)'),
+                currentSessionName: z.string().optional().describe('Current session name (defaults to current session)'),
+                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)'),
+            },
+            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();
+            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 {
+                    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 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]();
+            try {
+                const timeout = new Promise(resolve => setTimeout(() => resolve('timeout'), 5000));
+                while (true) {
+                    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') {
+                        await this._refreshSessions();
+                    }
+                    const newSourceTreeId = this._sourceTreeId(sessionName);
+                    if (newSourceTreeId && newSourceTreeId !== knownSourceTreeId) {
+                        return this._waitForUpdateResult(daemon, sessionName, newSourceTreeId);
+                    }
+                }
+            }
+            finally {
+                await iterator.return?.();
+            }
+        }));
+    }
+    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 });
+                }
+            }
+            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) }],
+            };
+        }));
+    }
+    _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) }],
+            };
+        });
+    }
+}
+
+export { ComponentExplorerMcpServer, DaemonConnection };
+//# sourceMappingURL=McpServer.js.map