tuna-agent 0.1.1 → 0.1.2

package/dist/mcp/browser-server.js

@@ -0,0 +1,467 @@
+#!/usr/bin/env node
+/**
+ * Browser MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes browser automation tools to Claude Code.
+ * Uses browserclaw (vendored from OpenClaw) for snapshot+ref browser control.
+ *
+ * Usage:
+ *   node browser-server.js [--headless] [--user-data-dir /path/to/chrome/profile] [--cdp-port 9222]
+ */
+import { BrowserClaw, setStealthEnabled } from '../browser/index.js';
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let headless = false; // Default: visible browser (not headless)
+    let userDataDir;
+    let profileDirectory;
+    let cdpPort;
+    let cdpUrl;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--headless')
+            headless = true;
+        else if (args[i] === '--user-data-dir' && args[i + 1])
+            userDataDir = args[++i];
+        else if (args[i] === '--profile-directory' && args[i + 1])
+            profileDirectory = args[++i];
+        else if (args[i] === '--cdp-port' && args[i + 1])
+            cdpPort = parseInt(args[++i], 10);
+        else if (args[i] === '--cdp-url' && args[i + 1])
+            cdpUrl = args[++i];
+    }
+    // Disable stealth injection for existing Chrome profiles (sites detect it and force logout)
+    if (userDataDir) {
+        setStealthEnabled(false);
+    }
+    return { headless, userDataDir, profileDirectory, cdpPort, cdpUrl };
+}
+// ===== Browser State =====
+let browser = null;
+const pages = new Map(); // targetId → CrawlPage
+async function ensureBrowser(config) {
+    if (browser)
+        return browser;
+    if (config.cdpUrl) {
+        browser = await BrowserClaw.connect(config.cdpUrl);
+    }
+    else {
+        browser = await BrowserClaw.launch({
+            headless: config.headless,
+            userDataDir: config.userDataDir,
+            profileDirectory: config.profileDirectory,
+            cdpPort: config.cdpPort,
+        });
+    }
+    return browser;
+}
+function sendResponse(res) {
+    process.stdout.write(JSON.stringify(res) + '\n');
+}
+function sendResult(id, result) {
+    sendResponse({ jsonrpc: '2.0', id: id ?? null, result });
+}
+function sendError(id, code, message) {
+    sendResponse({ jsonrpc: '2.0', id: id ?? null, error: { code, message } });
+}
+// ===== Tool Definitions =====
+const TOOLS = [
+    {
+        name: 'browser_open',
+        description: 'Open a URL in the browser and return an AI-readable snapshot of the page. Returns a text tree with numbered refs (e1, e2, ...) for interactive elements.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to navigate to (e.g. https://facebook.com)' },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'browser_snapshot',
+        description: 'Take a snapshot of the current page. Returns an accessibility tree with numbered refs for all interactive elements. Use this after any navigation or page change to get fresh refs.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                page_id: { type: 'string', description: 'Target page ID (optional, uses last active page if omitted)' },
+            },
+        },
+    },
+    {
+        name: 'browser_click',
+        description: 'Click an element by its ref number from a snapshot. Run browser_snapshot first to get refs.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Element ref from snapshot (e.g. "e1", "e5")' },
+                page_id: { type: 'string', description: 'Target page ID (optional)' },
+                double_click: { type: 'boolean', description: 'Double-click instead of single click' },
+            },
+            required: ['ref'],
+        },
+    },
+    {
+        name: 'browser_type',
+        description: 'Type text into an element by its ref number. The element is clicked first, then text is typed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Element ref from snapshot (e.g. "e3")' },
+                text: { type: 'string', description: 'Text to type' },
+                submit: { type: 'boolean', description: 'Press Enter after typing to submit' },
+                slowly: { type: 'boolean', description: 'Type slowly with keystroke delays (more human-like)' },
+                page_id: { type: 'string', description: 'Target page ID (optional)' },
+            },
+            required: ['ref', 'text'],
+        },
+    },
+    {
+        name: 'browser_navigate',
+        description: 'Navigate to a different URL on the current page.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to navigate to' },
+                page_id: { type: 'string', description: 'Target page ID (optional)' },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'browser_scroll',
+        description: 'Scroll the page or a specific element into view.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Element ref to scroll into view (optional, scrolls page if omitted)' },
+                direction: { type: 'string', description: 'Scroll direction: "up" or "down" (default: "down")' },
+                page_id: { type: 'string', description: 'Target page ID (optional)' },
+            },
+        },
+    },
+    {
+        name: 'browser_screenshot',
+        description: 'Take a screenshot of the current page. Returns base64-encoded PNG image.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                page_id: { type: 'string', description: 'Target page ID (optional)' },
+                full_page: { type: 'boolean', description: 'Capture the full scrollable page (default: false, viewport only)' },
+            },
+        },
+    },
+    {
+        name: 'browser_tabs',
+        description: 'List all open browser tabs with their IDs, URLs, and titles.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'browser_press',
+        description: 'Press a keyboard key (e.g. Enter, Tab, Escape, ArrowDown).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Key to press (e.g. "Enter", "Tab", "Escape", "ArrowDown")' },
+                page_id: { type: 'string', description: 'Target page ID (optional)' },
+            },
+            required: ['key'],
+        },
+    },
+    {
+        name: 'browser_select',
+        description: 'Select an option from a dropdown/select element.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Element ref of the select/dropdown' },
+                value: { type: 'string', description: 'Value or label to select' },
+                page_id: { type: 'string', description: 'Target page ID (optional)' },
+            },
+            required: ['ref', 'value'],
+        },
+    },
+    {
+        name: 'browser_hover',
+        description: 'Hover over an element by its ref number.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Element ref from snapshot' },
+                page_id: { type: 'string', description: 'Target page ID (optional)' },
+            },
+            required: ['ref'],
+        },
+    },
+    {
+        name: 'browser_close',
+        description: 'Close the browser and clean up resources.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+];
+// ===== Request Handler =====
+const serverConfig = parseArgs();
+let activePageId = null;
+async function handleRequest(req) {
+    try {
+        switch (req.method) {
+            case 'initialize':
+                sendResult(req.id, {
+                    protocolVersion: '2024-11-05',
+                    capabilities: { tools: {} },
+                    serverInfo: { name: 'tuna-browser', version: '1.0.0' },
+                });
+                break;
+            case 'notifications/initialized':
+                break;
+            case 'tools/list':
+                sendResult(req.id, { tools: TOOLS });
+                break;
+            case 'tools/call': {
+                const toolName = req.params?.name ?? '';
+                const args = req.params?.arguments ?? {};
+                const result = await handleToolCall(toolName, args);
+                sendResult(req.id, result);
+                break;
+            }
+            case 'ping':
+                sendResult(req.id, {});
+                break;
+            default:
+                if (req.id !== undefined) {
+                    sendError(req.id, -32601, `Method not found: ${req.method}`);
+                }
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (req.id !== undefined) {
+            sendError(req.id, -32603, message);
+        }
+    }
+}
+function getPageId(args) {
+    return args.page_id || activePageId || undefined;
+}
+async function getPage(args) {
+    const pageId = getPageId(args);
+    if (pageId && pages.has(pageId)) {
+        return pages.get(pageId);
+    }
+    // Return last active page or first available
+    if (activePageId && pages.has(activePageId)) {
+        return pages.get(activePageId);
+    }
+    // No pages open
+    throw new Error('No browser page is open. Use browser_open first to navigate to a URL.');
+}
+async function handleToolCall(toolName, args) {
+    try {
+        switch (toolName) {
+            case 'browser_open': {
+                const url = args.url;
+                if (!url)
+                    return { content: [{ type: 'text', text: 'Error: url is required' }], isError: true };
+                const b = await ensureBrowser(serverConfig);
+                const page = await b.open(url);
+                const pageId = page.id;
+                pages.set(pageId, page);
+                activePageId = pageId;
+                // Auto-snapshot after opening
+                const result = await page.snapshot();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Page opened: ${url}\nPage ID: ${pageId}\n\n--- Snapshot ---\n${result.snapshot}\n\n--- Stats ---\nRefs: ${Object.keys(result.refs).length} interactive elements`,
+                        }],
+                };
+            }
+            case 'browser_snapshot': {
+                const page = await getPage(args);
+                const result = await page.snapshot();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `${result.snapshot}\n\n--- Stats ---\nRefs: ${Object.keys(result.refs).length} interactive elements`,
+                        }],
+                };
+            }
+            case 'browser_click': {
+                const ref = args.ref;
+                if (!ref)
+                    return { content: [{ type: 'text', text: 'Error: ref is required' }], isError: true };
+                const page = await getPage(args);
+                await page.click(ref, {
+                    doubleClick: args.double_click,
+                });
+                // Auto-snapshot after click to show result
+                const result = await page.snapshot();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Clicked "${ref}".\n\n--- Updated Snapshot ---\n${result.snapshot}`,
+                        }],
+                };
+            }
+            case 'browser_type': {
+                const ref = args.ref;
+                const text = args.text;
+                if (!ref || text === undefined)
+                    return { content: [{ type: 'text', text: 'Error: ref and text are required' }], isError: true };
+                const page = await getPage(args);
+                await page.type(ref, text, {
+                    submit: args.submit,
+                    slowly: args.slowly,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Typed "${text}" into "${ref}"${args.submit ? ' and submitted' : ''}.`,
+                        }],
+                };
+            }
+            case 'browser_navigate': {
+                const url = args.url;
+                if (!url)
+                    return { content: [{ type: 'text', text: 'Error: url is required' }], isError: true };
+                const page = await getPage(args);
+                await page.goto(url);
+                const result = await page.snapshot();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Navigated to: ${url}\n\n--- Snapshot ---\n${result.snapshot}`,
+                        }],
+                };
+            }
+            case 'browser_scroll': {
+                const page = await getPage(args);
+                if (args.ref) {
+                    await page.scrollIntoView(args.ref);
+                }
+                else {
+                    // Scroll page via keyboard
+                    const key = args.direction === 'up' ? 'PageUp' : 'PageDown';
+                    await page.press(key);
+                }
+                const result = await page.snapshot();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Scrolled ${args.direction || 'down'}.\n\n--- Updated Snapshot ---\n${result.snapshot}`,
+                        }],
+                };
+            }
+            case 'browser_screenshot': {
+                const page = await getPage(args);
+                const buf = await page.screenshot({
+                    fullPage: args.full_page,
+                });
+                return {
+                    content: [{
+                            type: 'image',
+                            data: buf.toString('base64'),
+                            mimeType: 'image/png',
+                        }],
+                };
+            }
+            case 'browser_tabs': {
+                const b = await ensureBrowser(serverConfig);
+                const tabs = await b.tabs();
+                if (tabs.length === 0) {
+                    return { content: [{ type: 'text', text: 'No tabs open.' }] };
+                }
+                const listing = tabs.map((t) => `- ${t.title || 'Untitled'} (ID: ${t.targetId})\n  URL: ${t.url}`).join('\n');
+                return { content: [{ type: 'text', text: `Open tabs:\n${listing}` }] };
+            }
+            case 'browser_press': {
+                const key = args.key;
+                if (!key)
+                    return { content: [{ type: 'text', text: 'Error: key is required' }], isError: true };
+                const page = await getPage(args);
+                await page.press(key);
+                return { content: [{ type: 'text', text: `Pressed "${key}".` }] };
+            }
+            case 'browser_select': {
+                const ref = args.ref;
+                const value = args.value;
+                if (!ref || !value)
+                    return { content: [{ type: 'text', text: 'Error: ref and value are required' }], isError: true };
+                const page = await getPage(args);
+                await page.select(ref, value);
+                return { content: [{ type: 'text', text: `Selected "${value}" in "${ref}".` }] };
+            }
+            case 'browser_hover': {
+                const ref = args.ref;
+                if (!ref)
+                    return { content: [{ type: 'text', text: 'Error: ref is required' }], isError: true };
+                const page = await getPage(args);
+                await page.hover(ref);
+                return { content: [{ type: 'text', text: `Hovered over "${ref}".` }] };
+            }
+            case 'browser_close': {
+                if (browser) {
+                    await browser.stop();
+                    browser = null;
+                    pages.clear();
+                    activePageId = null;
+                }
+                return { content: [{ type: 'text', text: 'Browser closed.' }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${toolName}` }], isError: true };
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+}
+// ===== Stdio Transport =====
+function startServer() {
+    process.stderr.write(`[browser-mcp] Starting (headless: ${serverConfig.headless})\n`);
+    let buffer = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => {
+        buffer += chunk;
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const req = JSON.parse(trimmed);
+                handleRequest(req).catch((err) => {
+                    process.stderr.write(`[browser-mcp] Error handling ${req.method}: ${err}\n`);
+                });
+            }
+            catch {
+                process.stderr.write(`[browser-mcp] Failed to parse JSON: ${trimmed.slice(0, 100)}\n`);
+            }
+        }
+    });
+    process.stdin.on('end', async () => {
+        process.stderr.write('[browser-mcp] stdin closed, cleaning up browser\n');
+        if (browser) {
+            await browser.stop().catch(() => { });
+        }
+        process.exit(0);
+    });
+    // Cleanup on process exit
+    process.on('SIGTERM', async () => {
+        if (browser)
+            await browser.stop().catch(() => { });
+        process.exit(0);
+    });
+    process.on('SIGINT', async () => {
+        if (browser)
+            await browser.stop().catch(() => { });
+        process.exit(0);
+    });
+}
+// ===== Main =====
+startServer();

package/dist/mcp/knowledge-server.js

@@ -58,10 +58,12 @@ function sendError(id, code, message) {
 const TOOLS = [
     {
         name: 'list_knowledge',
-        description: 'List all knowledge documents accessible to this agent. Returns document names, descriptions, and IDs.',
+        description: 'List knowledge items accessible to this agent. Can list root items or items inside a specific folder.',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                parent_id: { type: 'string', description: 'Folder ID to list children of. Omit to list root-level items.' },
+            },
         },
     },
     {
@@ -77,15 +79,17 @@ const TOOLS = [
     },
     {
         name: 'create_knowledge',
-        description: 'Create a new knowledge document. Content should be in markdown format.',
+        description: 'Create a new knowledge document or folder. Content should be in markdown format for documents.',
         inputSchema: {
             type: 'object',
             properties: {
-                name: { type: 'string', description: 'Name/title of the knowledge document' },
-                content: { type: 'string', description: 'Markdown content of the document' },
-                description: { type: 'string', description: 'Short description of what this document contains' },
+                name: { type: 'string', description: 'Name/title of the knowledge item' },
+                content: { type: 'string', description: 'Markdown content (required for documents, omit for folders)' },
+                description: { type: 'string', description: 'Short description of what this item contains' },
+                kind: { type: 'string', enum: ['document', 'folder'], description: 'Type of knowledge item. Default: document' },
+                parent_id: { type: 'string', description: 'Parent folder ID to create inside. Omit for root level.' },
             },
-            required: ['name', 'content'],
+            required: ['name'],
         },
     },
     {
@@ -147,13 +151,22 @@ async function handleToolCall(config, toolName, args) {
     try {
         switch (toolName) {
             case 'list_knowledge': {
-                const data = await apiCall(config, 'GET', `/agent-knowledge?agent_id=${config.agentId}`);
+                let url = `/agent-knowledge?agent_id=${config.agentId}`;
+                if (args.parent_id)
+                    url += `&parent_id=${args.parent_id}`;
+                const data = await apiCall(config, 'GET', url);
                 const items = data.items || [];
                 if (items.length === 0) {
-                    return { content: [{ type: 'text', text: 'No knowledge documents found for this agent.' }] };
+                    return { content: [{ type: 'text', text: 'No knowledge items found.' }] };
                 }
-                const listing = items.map((k) => `- **${k.name}** (ID: ${k._id})\n  ${k.description || 'No description'}\n  Size: ${k.file_size} bytes | Updated: ${k.updated_at}`).join('\n\n');
-                return { content: [{ type: 'text', text: `Found ${items.length} knowledge document(s):\n\n${listing}` }] };
+                const listing = items.map((k) => {
+                    const icon = k.kind === 'folder' ? '📁' : '📄';
+                    const meta = k.kind === 'folder'
+                        ? `${k.children_count || 0} items`
+                        : `${k.file_size} bytes`;
+                    return `- ${icon} **${k.name}** (ID: ${k._id}) [${k.kind}]\n  ${k.description || 'No description'}\n  ${meta} | Updated: ${k.updated_at}`;
+                }).join('\n\n');
+                return { content: [{ type: 'text', text: `Found ${items.length} knowledge item(s):\n\n${listing}` }] };
             }
             case 'read_knowledge': {
                 if (!args.knowledge_id) {
@@ -168,16 +181,28 @@ async function handleToolCall(config, toolName, args) {
                 };
             }
             case 'create_knowledge': {
-                if (!args.name || !args.content) {
-                    return { content: [{ type: 'text', text: 'Error: name and content are required' }], isError: true };
+                const isFolder = args.kind === 'folder';
+                if (!args.name) {
+                    return { content: [{ type: 'text', text: 'Error: name is required' }], isError: true };
+                }
+                if (!isFolder && !args.content) {
+                    return { content: [{ type: 'text', text: 'Error: content is required for documents' }], isError: true };
                 }
-                const data = await apiCall(config, 'POST', '/agent-knowledge', {
+                const body = {
                     name: args.name,
-                    content: args.content,
-                    description: args.description || '',
                     agent_id: config.agentId,
-                });
-                return { content: [{ type: 'text', text: `Knowledge "${data.name}" created (ID: ${data._id})` }] };
+                };
+                if (args.kind)
+                    body.kind = args.kind;
+                if (args.content)
+                    body.content = args.content;
+                if (args.description)
+                    body.description = args.description;
+                if (args.parent_id)
+                    body.parent_id = args.parent_id;
+                const data = await apiCall(config, 'POST', '/agent-knowledge', body);
+                const label = isFolder ? 'Folder' : 'Knowledge';
+                return { content: [{ type: 'text', text: `${label} "${data.name}" created (ID: ${data._id})` }] };
             }
             case 'update_knowledge': {
                 if (!args.knowledge_id) {

package/dist/mcp/setup.js

@@ -11,6 +11,7 @@ const MCP_CONFIG_PATH = path.join(MCP_CONFIG_DIR, 'mcp-config.json');
  */
 export function setupMcpConfig(config) {
     const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
+    const browserServerPath = path.join(__dirname, 'browser-server.js');
     const mcpConfig = {
         mcpServers: {
             'tuna-knowledge': {
@@ -22,6 +23,10 @@ export function setupMcpConfig(config) {
                     '--agent-id', config.agentId,
                 ],
             },
+            'tuna-browser': {
+                command: process.execPath,
+                args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
+            },
         },
     };
     if (!fs.existsSync(MCP_CONFIG_DIR)) {
@@ -47,6 +52,7 @@ export function getMcpConfigPath() {
  */
 export function writeAgentFolderMcpConfig(agentFolderPath, config) {
     const knowledgeServerPath = path.join(__dirname, 'knowledge-server.js');
+    const browserServerPath = path.join(__dirname, 'browser-server.js');
     try {
         const mcpJsonPath = path.join(agentFolderPath, '.mcp.json');
         // Read existing .mcp.json to preserve other servers (e.g. playwright)
@@ -66,6 +72,10 @@ export function writeAgentFolderMcpConfig(agentFolderPath, config) {
                     '--agent-id', config.agentId,
                 ],
             },
+            'tuna-browser': {
+                command: process.execPath,
+                args: [browserServerPath, '--user-data-dir', path.join(process.env.HOME || '', '.config', 'tuna-browser', 'chrome-profile')],
+            },
         };
         fs.writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2));
         console.log(`[MCP] Agent folder .mcp.json written to ${mcpJsonPath}`);

package/dist/utils/claude-cli.js

@@ -127,18 +127,27 @@ export function runClaude(options) {
             `${process.env.HOME}/.local/bin`,
             `${process.env.HOME}/.nvm/versions/node/v20.10.0/bin`,
         ].filter(Boolean).join(':');
+        // Build env: inherit process.env but strip Claude Code session markers
+        // so the spawned claude process is not blocked by nested-session detection.
+        const spawnEnv = {};
+        for (const [k, v] of Object.entries(process.env)) {
+            if (v !== undefined)
+                spawnEnv[k] = v;
+        }
+        // Remove nested-session markers
+        delete spawnEnv['CLAUDECODE'];
+        delete spawnEnv['CLAUDE_CODE_ENTRYPOINT'];
+        delete spawnEnv['CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING'];
+        spawnEnv['HOME'] = process.env.HOME || '';
+        spawnEnv['PATH'] = spawnPath;
+        if (options.agentTeam) {
+            spawnEnv['CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS'] = '1';
+            spawnEnv['CLAUDE_CODE_TEAMMATE_MODE'] = 'in-process';
+        }
         const proc = spawn(claudeBin, args, {
             cwd: options.cwd,
             stdio: [useInteractiveStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                HOME: process.env.HOME || '',
-                PATH: spawnPath,
-                ...(options.agentTeam ? {
-                    CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
-                    CLAUDE_CODE_TEAMMATE_MODE: 'in-process',
-                } : {}),
-            },
+            env: spawnEnv,
         });
         // 30-minute timeout by default
         const timeoutMs = options.timeoutMs ?? 30 * 60 * 1000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuna-agent",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Tuna Agent - Run AI coding tasks on your machine",
   "bin": {
     "tuna-agent": "dist/cli/index.js"
@@ -16,6 +16,7 @@
   "dependencies": {
     "chalk": "^5.4.0",
     "commander": "^13.0.0",
+    "playwright-core": "^1.58.2",
     "ws": "^8.18.0",
     "zod": "^4.3.6"
   },