tuna-agent 0.1.0 → 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.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Knowledge MCP Server for Tuna Agent
+ *
+ * Stdio-based MCP server that exposes knowledge tools to Claude Code.
+ * Communicates with the Tuna API using agent token auth.
+ *
+ * Usage:
+ *   node knowledge-server.js --api-url https://api.tuna.ai --token xxx --agent-id abc123
+ */
+export {};