@vibebrowser/cli 0.2.8

package/dist/devtools-fallback.js

@@ -0,0 +1,172 @@
+import { EventEmitter } from 'node:events';
+import { dirname, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+const TOOLS_REFRESH_TIMEOUT_MS = 6_000;
+const TOOL_CALL_TIMEOUT_MS = 30_000;
+const DEVTOOLS_UNAVAILABLE_PREFIX = 'chrome-devtools backend unavailable';
+const DEVTOOLS_NOT_INSTALLED_MESSAGE = `${DEVTOOLS_UNAVAILABLE_PREFIX}: chrome-devtools-mcp is not installed`;
+function normalizeToolName(value) {
+    return value.replace(/[-\s]/g, '_').toLowerCase();
+}
+function toToolDefinition(input) {
+    return {
+        name: input.name,
+        description: input.description ?? '',
+        inputSchema: {
+            type: 'object',
+            properties: input.inputSchema.properties,
+            required: input.inputSchema.required,
+        },
+    };
+}
+export class DevtoolsFallbackConnection extends EventEmitter {
+    debug;
+    client = null;
+    transport = null;
+    tools = [];
+    available = false;
+    unavailableReason;
+    constructor(debug) {
+        super();
+        this.debug = debug;
+    }
+    async start() {
+        const binaryPath = this.resolveBinaryPath();
+        if (!binaryPath) {
+            this.unavailableReason = DEVTOOLS_NOT_INSTALLED_MESSAGE;
+            this.log(this.unavailableReason);
+            return;
+        }
+        const transport = new StdioClientTransport({
+            command: process.execPath,
+            args: [binaryPath, '--autoConnect'],
+            stderr: this.debug ? 'inherit' : 'pipe',
+        });
+        const client = new Client({
+            name: 'vibebrowser-mcp-devtools-fallback',
+            version: '1.0.0',
+        }, { capabilities: {} });
+        try {
+            await client.connect(transport, { timeout: TOOLS_REFRESH_TIMEOUT_MS });
+            this.client = client;
+            this.transport = transport;
+            this.available = true;
+            this.unavailableReason = undefined;
+            await this.refreshTools(TOOLS_REFRESH_TIMEOUT_MS);
+            this.emit('connected');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.unavailableReason = `${DEVTOOLS_UNAVAILABLE_PREFIX}: ${message}`;
+            this.log(this.unavailableReason);
+            this.available = false;
+            this.client = null;
+            this.transport = null;
+            this.tools = [];
+            this.emit('unavailable', this.unavailableReason);
+            try {
+                await transport.close();
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }
+    }
+    async stop() {
+        this.available = false;
+        this.tools = [];
+        if (this.client) {
+            try {
+                await this.client.close();
+            }
+            catch {
+                // ignore shutdown errors
+            }
+            this.client = null;
+        }
+        if (this.transport) {
+            try {
+                await this.transport.close();
+            }
+            catch {
+                // ignore shutdown errors
+            }
+            this.transport = null;
+        }
+    }
+    async refreshTools(timeoutMs = TOOLS_REFRESH_TIMEOUT_MS) {
+        if (!this.client || !this.available) {
+            return this.tools;
+        }
+        try {
+            const listed = await this.client.listTools(undefined, { timeout: timeoutMs });
+            const nextTools = listed.tools.map(toToolDefinition);
+            const previousNames = this.tools.map((tool) => normalizeToolName(tool.name)).join(',');
+            const nextNames = nextTools.map((tool) => normalizeToolName(tool.name)).join(',');
+            this.tools = nextTools;
+            if (previousNames !== nextNames) {
+                this.emit('tools_updated', this.tools);
+            }
+            return this.tools;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.log(`Unable to refresh chrome-devtools tools: ${message}`);
+            return this.tools;
+        }
+    }
+    getTools() {
+        return this.tools;
+    }
+    hasTool(name) {
+        const needle = normalizeToolName(name);
+        return this.tools.some((tool) => normalizeToolName(tool.name) === needle);
+    }
+    async callTool(name, args, timeoutMs = TOOL_CALL_TIMEOUT_MS) {
+        if (!this.client || !this.available) {
+            throw new Error(this.unavailableReason || DEVTOOLS_UNAVAILABLE_PREFIX);
+        }
+        const result = await this.client.callTool({ name, arguments: args }, undefined, { timeout: timeoutMs });
+        const content = Array.isArray(result.content)
+            ? result.content
+            : [{ type: 'text', text: JSON.stringify(result) }];
+        const isError = typeof result.isError === 'boolean' ? result.isError : false;
+        return {
+            success: !isError,
+            isError,
+            content,
+        };
+    }
+    isAvailable() {
+        return this.available;
+    }
+    getUnavailableReason() {
+        return this.unavailableReason;
+    }
+    resolveBinaryPath() {
+        try {
+            const require = createRequire(import.meta.url);
+            const packageJsonPath = require.resolve('chrome-devtools-mcp/package.json');
+            const metadata = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            const bin = typeof metadata.bin === 'string'
+                ? metadata.bin
+                : metadata.bin?.['chrome-devtools-mcp'] ?? metadata.bin?.['chrome-devtools'];
+            if (!bin) {
+                return undefined;
+            }
+            return resolve(dirname(packageJsonPath), bin);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    log(message) {
+        if (this.debug) {
+            console.error(`[vibebrowser-mcp] ${message}`);
+        }
+    }
+}
+//# sourceMappingURL=devtools-fallback.js.map

package/dist/relay-daemon.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Vibe MCP Relay Daemon Entry Point
+ *
+ * This script is spawned as a detached daemon process.
+ */
+import { startRelayDaemon } from './relay.js';
+const debug = process.argv.includes('--debug');
+startRelayDaemon(debug).catch((error) => {
+    console.error(`[relay] Fatal error: ${error.message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=relay-daemon.js.map