@shawnowen/comet-mcp 2.3.0

package/dist/index.js

@@ -0,0 +1,1174 @@
+#!/usr/bin/env node
+// Comet Browser MCP Server
+// Claude Code ↔ Perplexity Comet bidirectional interaction
+// 14 tools: 9 browsing + 1 tab groups + 4 lifecycle
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { cometClient } from "./cdp-client.js";
+import { cometAI } from "./comet-ai.js";
+// @ts-ignore — .mjs adapter for lifecycle event parity (Spec 078 AC-2)
+import { emitLifecycleEvent, createMCPLifecycleEnvelope } from "../../scripts/lifecycle-mcp-adapter.mjs";
+import { appendFileSync, readFileSync } from "fs";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { homedir } from "os";
+import { join } from "path";
+const execFileAsync = promisify(execFile);
+// JSONL outbox for lifecycle events → orchestration layer
+const OUTBOX_PATH = join(homedir(), "equabot", "agent-chat", "outbox-comet.jsonl");
+const INBOX_PATH = join(homedir(), "equabot", "agent-chat", "inbox-comet.jsonl");
+const MANIFEST_PATH = join(homedir(), ".claude", "comet-browser", "session-manifest.json");
+function appendJsonl(path, obj) {
+    try {
+        appendFileSync(path, JSON.stringify(obj) + "\n");
+    }
+    catch { /* graceful degradation — file may not exist */ }
+}
+function readJsonSafe(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+const TOOLS = [
+    {
+        name: "comet_connect",
+        description: "Connect to Comet browser (auto-starts if needed)",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "comet_ask",
+        description: "Send a prompt to Comet/Perplexity and wait for the complete response (blocking). Ideal for tasks requiring real browser interaction (login walls, dynamic content, filling forms) or deep research with agentic browsing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: { type: "string", description: "Question or task for Comet - focus on goals and context" },
+                newChat: { type: "boolean", description: "Start a fresh conversation (default: false)" },
+                timeout: { type: "number", description: "Max wait time in ms (default: 15000 = 15s)" },
+            },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "comet_poll",
+        description: "Check agent status and progress. Call repeatedly to monitor agentic tasks.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "comet_stop",
+        description: "Stop the current agent task if it's going off track",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "comet_screenshot",
+        description: "Capture a screenshot of current page",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "comet_mode",
+        description: "Switch Perplexity search mode. Modes: 'search' (basic), 'research' (deep research), 'labs' (analytics/visualization), 'learn' (educational). Call without mode to see current mode.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                mode: {
+                    type: "string",
+                    enum: ["search", "research", "labs", "learn"],
+                    description: "Mode to switch to (optional - omit to see current mode)",
+                },
+            },
+        },
+    },
+    {
+        name: "comet_tab_groups",
+        description: "Manage Chrome tab groups in Comet browser. Requires the Comet Tab Groups Bridge extension (load unpacked from extension/ dir). " +
+            "Actions: list (all groups), list_tabs (all tabs with group info), create (new group from tab IDs), " +
+            "update (rename/recolor/collapse), move (reorder), ungroup (remove tabs from group), delete (ungroup all tabs in a group), " +
+            "save_group (persist tab URLs to archive), restore_group (reopen tabs from archive), archive_group (save + close tabs), " +
+            "list_archived (show all archived tab groups).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["list", "list_tabs", "create", "update", "move", "ungroup", "delete", "save_group", "restore_group", "archive_group", "list_archived"],
+                    description: "The tab group operation to perform",
+                },
+                tabIds: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tab IDs (for create, ungroup)",
+                },
+                groupId: {
+                    type: "number",
+                    description: "Group ID (for update, move, delete)",
+                },
+                title: {
+                    type: "string",
+                    description: "Group title (for create, update)",
+                },
+                color: {
+                    type: "string",
+                    enum: ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"],
+                    description: "Group color (for create, update)",
+                },
+                collapsed: {
+                    type: "boolean",
+                    description: "Collapse/expand group (for update)",
+                },
+                index: {
+                    type: "number",
+                    description: "Position index (for move)",
+                },
+                taskThreadId: {
+                    type: "string",
+                    description: "Task thread ID (for save_group, restore_group, archive_group)",
+                },
+                closeTabs: {
+                    type: "boolean",
+                    description: "Close tabs after saving (for save_group; archive_group always closes)",
+                },
+            },
+            required: ["action"],
+        },
+    },
+    {
+        name: "comet_shortcut",
+        description: "Trigger a Comet Query Shortcut (e.g. /fact-check, /mailtodo). "
+            + "These are reusable AI prompts with pre-configured modes and sources. "
+            + "Type '/' to discover available shortcuts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                shortcut: {
+                    type: "string",
+                    description: "Shortcut name (e.g. 'fact-check', 'mailtodo', 'prep-next-meeting'). "
+                        + "Omit the leading slash — it will be added automatically.",
+                },
+                context: {
+                    type: "string",
+                    description: "Optional additional context appended after the shortcut command.",
+                },
+                timeout: {
+                    type: "number",
+                    description: "Max wait time in ms (default 30000). Shortcuts often take longer than regular queries.",
+                },
+            },
+            required: ["shortcut"],
+        },
+    },
+    {
+        name: "comet_read_page",
+        description: "Extract content from the current page. Returns structured accessibility tree "
+            + "and/or clean text. Use 'tree' mode for interactive elements (buttons, links, forms), "
+            + "'text' mode for readable content, or 'both' for full extraction.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                mode: {
+                    type: "string",
+                    enum: ["tree", "text", "both"],
+                    description: "Extraction mode: 'tree' = accessibility tree (roles, names, values), "
+                        + "'text' = clean markdown-like text, 'both' = both formats. Default: 'text'.",
+                },
+                maxDepth: {
+                    type: "number",
+                    description: "Max tree depth for 'tree' mode (default: 5). Lower = less tokens.",
+                },
+                maxLength: {
+                    type: "number",
+                    description: "Max character length for output (default: 12000). Truncates if exceeded.",
+                },
+            },
+        },
+    },
+    {
+        name: "comet_wait_for_idle",
+        description: "Wait for the current page's network activity to settle (no pending requests "
+            + "for a specified duration). Use after navigation or triggering dynamic content loads. "
+            + "Returns a summary of network activity observed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                idleTime: {
+                    type: "number",
+                    description: "Milliseconds of network silence required to consider 'idle' (default: 1500).",
+                },
+                timeout: {
+                    type: "number",
+                    description: "Max wait time in ms before giving up (default: 15000).",
+                },
+            },
+        },
+    },
+    {
+        name: "comet_lifecycle_start",
+        description: "Start (register) a new Comet browser run in the command-center-so lifecycle store. " +
+            "Returns the created CometRun record. Set deferred=true to start in pending state.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                runId: { type: "string", description: "Unique run identifier" },
+                taskThreadId: { type: "string", description: "Task-thread identifier" },
+                agentId: { type: "string", description: "Agent identity (optional for single-agent)" },
+                route: { type: "string", enum: ["mcp", "cli", "http"], description: "Execution channel" },
+                deferred: { type: "boolean", description: "Start in pending state (default: false)" },
+            },
+            required: ["runId", "taskThreadId"],
+        },
+    },
+    {
+        name: "comet_lifecycle_complete",
+        description: "Mark a Comet browser run as completed in the lifecycle store.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                runId: { type: "string", description: "Run identifier to complete" },
+            },
+            required: ["runId"],
+        },
+    },
+    {
+        name: "comet_lifecycle_abort",
+        description: "Abort a Comet browser run in the lifecycle store.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                runId: { type: "string", description: "Run identifier to abort" },
+                reason: { type: "string", description: "Reason for aborting (optional)" },
+            },
+            required: ["runId"],
+        },
+    },
+    {
+        name: "comet_lifecycle_update",
+        description: "Update metadata on a running Comet browser run (auditSessionId, tabGroupId, workflowId, or arbitrary metadata).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                runId: { type: "string", description: "Run identifier to update" },
+                auditSessionId: { type: "string", description: "Audit session ID to attach" },
+                tabGroupId: { type: "string", description: "Tab group ID to associate" },
+                workflowId: { type: "string", description: "Workflow ID to associate" },
+                metadata: { type: "object", description: "Arbitrary metadata key-value pairs" },
+            },
+            required: ["runId"],
+        },
+    },
+    {
+        name: "comet_task_status",
+        description: "Get unified status for a Comet browser task. Combines session-manifest.json state, " +
+            "extension ring buffer events, and lifecycle metadata into one response. " +
+            "Query by groupId or threadId.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                groupId: { type: "number", description: "Tab group ID to check" },
+                threadId: { type: "string", description: "Thread ID to check (returns all sessions for thread)" },
+            },
+        },
+    },
+    {
+        name: "comet_delegate",
+        description: "High-level delegation tool: dispatches a task to the Comet browser in one call. " +
+            "Creates a tab group (color-coded by priority), opens task URLs, registers in session manifest, " +
+            "starts lifecycle tracking, and writes to the Comet inbox. Returns groupId and status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                threadId: { type: "string", description: "Task thread identifier" },
+                instruction: { type: "string", description: "What the browser agent should do" },
+                priority: {
+                    type: "string",
+                    enum: ["P1", "P2", "P3", "P4"],
+                    description: "Task priority (determines tab group color). Default: P3",
+                },
+                urls: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "URLs to open in the tab group",
+                },
+                dependsOn: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Task IDs this task depends on",
+                },
+                agentId: { type: "string", description: "Agent identity for tracking" },
+            },
+            required: ["threadId", "instruction"],
+        },
+    },
+];
+const CC_LIFECYCLE_URL = process.env.COMET_CC_LIFECYCLE_URL
+    || "http://localhost:3001/command-center/api/comet/lifecycle";
+async function callLifecycleEndpoint(payload) {
+    const resp = await fetch(CC_LIFECYCLE_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(5000),
+    });
+    const data = await resp.text();
+    if (!resp.ok) {
+        throw new Error(`CC-SO lifecycle ${resp.status}: ${data.substring(0, 200)}`);
+    }
+    return data;
+}
+const server = new Server({ name: "comet-bridge", version: "2.4.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "comet_connect": {
+                // Auto-start Comet with debug port (will restart if running without it)
+                const startResult = await cometClient.startComet(9222);
+                // Get all tabs and clean up - close all except one
+                const targets = await cometClient.listTargets();
+                const pageTabs = targets.filter(t => t.type === 'page');
+                // Close extra tabs, keep only one
+                if (pageTabs.length > 1) {
+                    for (let i = 1; i < pageTabs.length; i++) {
+                        try {
+                            await cometClient.closeTab(pageTabs[i].id);
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
+                // Get fresh tab list
+                const freshTargets = await cometClient.listTargets();
+                const anyPage = freshTargets.find(t => t.type === 'page');
+                if (anyPage) {
+                    await cometClient.connect(anyPage.id);
+                    // Always navigate to Perplexity home for clean state
+                    await cometClient.navigate("https://www.perplexity.ai/", true);
+                    await new Promise(resolve => setTimeout(resolve, 1500));
+                    return { content: [{ type: "text", text: `${startResult}\nConnected to Perplexity (cleaned ${pageTabs.length - 1} old tabs)` }] };
+                }
+                // No tabs at all - create a new one
+                const newTab = await cometClient.newTab("https://www.perplexity.ai/");
+                await new Promise(resolve => setTimeout(resolve, 2000)); // Wait for page load
+                await cometClient.connect(newTab.id);
+                return { content: [{ type: "text", text: `${startResult}\nCreated new tab and navigated to Perplexity` }] };
+            }
+            case "comet_ask": {
+                let prompt = args?.prompt;
+                const timeout = args?.timeout || 15000; // Default 15s, use poll for longer tasks
+                const newChat = args?.newChat || false;
+                // Validate prompt
+                if (!prompt || prompt.trim().length === 0) {
+                    return { content: [{ type: "text", text: "Error: prompt cannot be empty" }] };
+                }
+                // Normalize prompt - convert markdown/bullets to natural text
+                prompt = prompt
+                    .replace(/^[-*•]\s*/gm, '') // Remove bullet points
+                    .replace(/\n+/g, ' ') // Collapse newlines to spaces
+                    .replace(/\s+/g, ' ') // Collapse multiple spaces
+                    .trim();
+                // For newChat: full reset (same as comet_connect) to handle post-agentic state
+                if (newChat) {
+                    // Clean up extra tabs (fixes CDP state after agentic browsing)
+                    const targets = await cometClient.listTargets();
+                    const pageTabs = targets.filter(t => t.type === 'page');
+                    if (pageTabs.length > 1) {
+                        for (let i = 1; i < pageTabs.length; i++) {
+                            try {
+                                await cometClient.closeTab(pageTabs[i].id);
+                            }
+                            catch { /* ignore */ }
+                        }
+                    }
+                    // Fresh connect to remaining tab
+                    const freshTargets = await cometClient.listTargets();
+                    const mainTab = freshTargets.find(t => t.type === 'page');
+                    if (mainTab) {
+                        await cometClient.connect(mainTab.id);
+                    }
+                    // Navigate to Perplexity home
+                    await cometClient.navigate("https://www.perplexity.ai/", true);
+                    await new Promise(resolve => setTimeout(resolve, 1500));
+                }
+                else {
+                    // Not newChat - just ensure we're on Perplexity
+                    const tabs = await cometClient.listTabsCategorized();
+                    if (tabs.main) {
+                        await cometClient.connect(tabs.main.id);
+                    }
+                    const urlResult = await cometClient.evaluate('window.location.href');
+                    const currentUrl = urlResult.result.value;
+                    const isOnPerplexity = currentUrl?.includes('perplexity.ai');
+                    if (!isOnPerplexity) {
+                        await cometClient.navigate("https://www.perplexity.ai/", true);
+                        await new Promise(resolve => setTimeout(resolve, 2000));
+                    }
+                }
+                // Capture old response state BEFORE sending prompt (for follow-up detection)
+                const oldStateResult = await cometClient.evaluate(`
+          (() => {
+            const proseEls = document.querySelectorAll('[class*="prose"]');
+            const lastProse = proseEls[proseEls.length - 1];
+            return {
+              count: proseEls.length,
+              lastText: lastProse ? lastProse.innerText.substring(0, 100) : ''
+            };
+          })()
+        `);
+                const oldState = oldStateResult.result.value;
+                // Send the prompt
+                await cometAI.sendPrompt(prompt);
+                // Wait for completion
+                const startTime = Date.now();
+                const stepsCollected = [];
+                let sawNewResponse = false;
+                while (Date.now() - startTime < timeout) {
+                    await new Promise(resolve => setTimeout(resolve, 2000)); // Poll every 2s
+                    // Check if we have a NEW response (more prose elements or different text)
+                    const currentStateResult = await cometClient.evaluate(`
+            (() => {
+              const proseEls = document.querySelectorAll('[class*="prose"]');
+              const lastProse = proseEls[proseEls.length - 1];
+              return {
+                count: proseEls.length,
+                lastText: lastProse ? lastProse.innerText.substring(0, 100) : ''
+              };
+            })()
+          `);
+                    const currentState = currentStateResult.result.value;
+                    // Detect new response
+                    if (!sawNewResponse) {
+                        if (currentState.count > oldState.count ||
+                            (currentState.lastText && currentState.lastText !== oldState.lastText)) {
+                            sawNewResponse = true;
+                        }
+                    }
+                    const status = await cometAI.getAgentStatus();
+                    // Collect steps
+                    for (const step of status.steps) {
+                        if (!stepsCollected.includes(step)) {
+                            stepsCollected.push(step);
+                        }
+                    }
+                    // Task completed - return result directly (but only if we saw a NEW response)
+                    if (status.status === 'completed' && sawNewResponse) {
+                        return { content: [{ type: "text", text: status.response || 'Task completed (no response text extracted)' }] };
+                    }
+                }
+                // Still working after initial wait - return "in progress" (non-blocking)
+                const finalStatus = await cometAI.getAgentStatus();
+                let inProgressMsg = `Task in progress (${stepsCollected.length} steps so far).\n`;
+                inProgressMsg += `Status: ${finalStatus.status.toUpperCase()}\n`;
+                if (finalStatus.currentStep) {
+                    inProgressMsg += `Current: ${finalStatus.currentStep}\n`;
+                }
+                if (finalStatus.agentBrowsingUrl) {
+                    inProgressMsg += `Browsing: ${finalStatus.agentBrowsingUrl}\n`;
+                }
+                if (stepsCollected.length > 0) {
+                    inProgressMsg += `\nSteps:\n${stepsCollected.map(s => `  • ${s}`).join('\n')}\n`;
+                }
+                inProgressMsg += `\nUse comet_poll to check progress or comet_stop to cancel.`;
+                return { content: [{ type: "text", text: inProgressMsg }] };
+            }
+            case "comet_poll": {
+                const status = await cometAI.getAgentStatus();
+                // If completed, return the response directly (most useful case)
+                if (status.status === 'completed' && status.response) {
+                    return { content: [{ type: "text", text: status.response }] };
+                }
+                // Still working - return progress info
+                let output = `Status: ${status.status.toUpperCase()}\n`;
+                if (status.agentBrowsingUrl) {
+                    output += `Browsing: ${status.agentBrowsingUrl}\n`;
+                }
+                if (status.currentStep) {
+                    output += `Current: ${status.currentStep}\n`;
+                }
+                if (status.steps.length > 0) {
+                    output += `\nSteps:\n${status.steps.map(s => `  • ${s}`).join('\n')}\n`;
+                }
+                if (status.status === 'working') {
+                    output += `\n[Use comet_stop to interrupt, or comet_screenshot to see current page]`;
+                }
+                return { content: [{ type: "text", text: output }] };
+            }
+            case "comet_stop": {
+                const stopped = await cometAI.stopAgent();
+                return {
+                    content: [{
+                            type: "text",
+                            text: stopped ? "Agent stopped" : "No active agent to stop",
+                        }],
+                };
+            }
+            case "comet_screenshot": {
+                const result = await cometClient.screenshot("png");
+                return {
+                    content: [{ type: "image", data: result.data, mimeType: "image/png" }],
+                };
+            }
+            case "comet_mode": {
+                const mode = args?.mode;
+                // If no mode provided, show current mode
+                if (!mode) {
+                    const result = await cometClient.evaluate(`
+            (() => {
+              // Try button group first (wide screen)
+              const modes = ['Search', 'Research', 'Labs', 'Learn'];
+              for (const mode of modes) {
+                const btn = document.querySelector('button[aria-label="' + mode + '"]');
+                if (btn && btn.getAttribute('data-state') === 'checked') {
+                  return mode.toLowerCase();
+                }
+              }
+              // Try dropdown (narrow screen) - look for the mode selector button
+              const dropdownBtn = document.querySelector('button[class*="gap"]');
+              if (dropdownBtn) {
+                const text = dropdownBtn.innerText.toLowerCase();
+                if (text.includes('search')) return 'search';
+                if (text.includes('research')) return 'research';
+                if (text.includes('labs')) return 'labs';
+                if (text.includes('learn')) return 'learn';
+              }
+              return 'search';
+            })()
+          `);
+                    const currentMode = result.result.value;
+                    const descriptions = {
+                        search: 'Basic web search',
+                        research: 'Deep research with comprehensive analysis',
+                        labs: 'Analytics, visualizations, and coding',
+                        learn: 'Educational content and explanations'
+                    };
+                    let output = `Current mode: ${currentMode}\n\nAvailable modes:\n`;
+                    for (const [m, desc] of Object.entries(descriptions)) {
+                        const marker = m === currentMode ? "→" : " ";
+                        output += `${marker} ${m}: ${desc}\n`;
+                    }
+                    return { content: [{ type: "text", text: output }] };
+                }
+                // Switch mode
+                const modeMap = {
+                    search: "Search",
+                    research: "Research",
+                    labs: "Labs",
+                    learn: "Learn",
+                };
+                const ariaLabel = modeMap[mode];
+                if (!ariaLabel) {
+                    return {
+                        content: [{ type: "text", text: `Invalid mode: ${mode}. Use: search, research, labs, learn` }],
+                        isError: true,
+                    };
+                }
+                // Navigate to Perplexity first if not there
+                const state = cometClient.currentState;
+                if (!state.currentUrl?.includes("perplexity.ai")) {
+                    await cometClient.navigate("https://www.perplexity.ai/", true);
+                }
+                // Try both UI patterns: button group (wide) and dropdown (narrow)
+                const result = await cometClient.evaluate(`
+          (() => {
+            // Strategy 1: Direct button (wide screen)
+            const btn = document.querySelector('button[aria-label="${ariaLabel}"]');
+            if (btn) {
+              btn.click();
+              return { success: true, method: 'button' };
+            }
+
+            // Strategy 2: Dropdown menu (narrow screen)
+            // Find and click the dropdown trigger (button with current mode text)
+            const allButtons = document.querySelectorAll('button');
+            for (const b of allButtons) {
+              const text = b.innerText.toLowerCase();
+              if ((text.includes('search') || text.includes('research') ||
+                   text.includes('labs') || text.includes('learn')) &&
+                  b.querySelector('svg')) {
+                b.click();
+                return { success: true, method: 'dropdown-open', needsSelect: true };
+              }
+            }
+
+            return { success: false, error: "Mode selector not found" };
+          })()
+        `);
+                const clickResult = result.result.value;
+                if (clickResult.success && clickResult.needsSelect) {
+                    // Wait for dropdown to open, then select the mode
+                    await new Promise(resolve => setTimeout(resolve, 300));
+                    const selectResult = await cometClient.evaluate(`
+            (() => {
+              // Look for dropdown menu items
+              const items = document.querySelectorAll('[role="menuitem"], [role="option"], button');
+              for (const item of items) {
+                if (item.innerText.toLowerCase().includes('${mode}')) {
+                  item.click();
+                  return { success: true };
+                }
+              }
+              return { success: false, error: "Mode option not found in dropdown" };
+            })()
+          `);
+                    const selectRes = selectResult.result.value;
+                    if (selectRes.success) {
+                        return { content: [{ type: "text", text: `Switched to ${mode} mode` }] };
+                    }
+                    else {
+                        return { content: [{ type: "text", text: `Failed: ${selectRes.error}` }], isError: true };
+                    }
+                }
+                if (clickResult.success) {
+                    return { content: [{ type: "text", text: `Switched to ${mode} mode` }] };
+                }
+                else {
+                    return {
+                        content: [{ type: "text", text: `Failed to switch mode: ${clickResult.error}` }],
+                        isError: true,
+                    };
+                }
+            }
+            case "comet_shortcut": {
+                const shortcut = (args?.shortcut).replace(/^\//, "");
+                const context = args?.context;
+                const timeout = args?.timeout || 30000;
+                // Ensure we're on Perplexity
+                const tabs = await cometClient.listTabsCategorized();
+                if (tabs.main) {
+                    await cometClient.connect(tabs.main.id);
+                }
+                const urlResult = await cometClient.evaluate('window.location.href');
+                const currentUrl = urlResult.result.value;
+                if (!currentUrl?.includes('perplexity.ai')) {
+                    await cometClient.navigate("https://www.perplexity.ai/", true);
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                }
+                // Capture old state for response detection
+                const oldStateResult = await cometClient.evaluate(`
+          (() => {
+            const proseEls = document.querySelectorAll('[class*="prose"]');
+            const lastProse = proseEls[proseEls.length - 1];
+            return {
+              count: proseEls.length,
+              lastText: lastProse ? lastProse.innerText.substring(0, 100) : ''
+            };
+          })()
+        `);
+                const oldState = oldStateResult.result.value;
+                // Send the shortcut
+                await cometAI.sendShortcut(shortcut, context);
+                // Poll for response with timeout
+                const startTime = Date.now();
+                let sawNewResponse = false;
+                while (Date.now() - startTime < timeout) {
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    const currentStateResult = await cometClient.evaluate(`
+            (() => {
+              const proseEls = document.querySelectorAll('[class*="prose"]');
+              const lastProse = proseEls[proseEls.length - 1];
+              return {
+                count: proseEls.length,
+                lastText: lastProse ? lastProse.innerText.substring(0, 100) : ''
+              };
+            })()
+          `);
+                    const currentState = currentStateResult.result.value;
+                    if (!sawNewResponse) {
+                        if (currentState.count > oldState.count ||
+                            (currentState.lastText && currentState.lastText !== oldState.lastText)) {
+                            sawNewResponse = true;
+                        }
+                    }
+                    const status = await cometAI.getAgentStatus();
+                    if (status.status === 'completed' && sawNewResponse) {
+                        return { content: [{ type: "text", text: status.response || 'Shortcut completed (no response text extracted)' }] };
+                    }
+                }
+                // Timed out — return status so user can poll
+                const finalStatus = await cometAI.getAgentStatus();
+                let msg = `Shortcut /${shortcut} in progress (timed out after ${timeout}ms).\n`;
+                msg += `Status: ${finalStatus.status.toUpperCase()}\n`;
+                if (finalStatus.currentStep)
+                    msg += `Current: ${finalStatus.currentStep}\n`;
+                msg += `\nUse comet_poll to check progress.`;
+                return { content: [{ type: "text", text: msg }] };
+            }
+            case "comet_read_page": {
+                const mode = args?.mode || "text";
+                const maxDepth = args?.maxDepth || 5;
+                const maxLength = args?.maxLength || 12000;
+                const parts = [];
+                if (mode === "tree" || mode === "both") {
+                    const tree = await cometClient.getAccessibilityTree(maxDepth, maxLength);
+                    parts.push("## Accessibility Tree\n" + tree);
+                }
+                if (mode === "text" || mode === "both") {
+                    const text = await cometClient.getPageText(maxLength);
+                    parts.push("## Page Text\n" + text);
+                }
+                return { content: [{ type: "text", text: parts.join("\n\n") }] };
+            }
+            case "comet_wait_for_idle": {
+                const idleTime = args?.idleTime || 1500;
+                const timeout = args?.timeout || 15000;
+                const result = await cometClient.waitForNetworkIdle({ idleTime, timeout });
+                const status = result.idle ? "Network idle reached" : "Timeout — network still active";
+                const summary = [
+                    status,
+                    `Waited: ${result.waitedMs}ms`,
+                    `Requests: ${result.totalRequests} total, ${result.totalCompleted} completed, ${result.totalFailed} failed`,
+                    result.pendingRequests > 0 ? `Still pending: ${result.pendingRequests}` : "",
+                ].filter(Boolean).join("\n");
+                return { content: [{ type: "text", text: summary }] };
+            }
+            case "comet_tab_groups": {
+                const { tabGroupsClient } = await import("./tab-groups.js");
+                const action = args?.action;
+                try {
+                    switch (action) {
+                        case "list": {
+                            const groups = await tabGroupsClient.listGroups();
+                            if (groups.length === 0) {
+                                return { content: [{ type: "text", text: "No tab groups found." }] };
+                            }
+                            const lines = groups.map((g) => `[${g.id}] "${g.title || "(untitled)"}" (${g.color}${g.collapsed ? ", collapsed" : ""})`);
+                            return { content: [{ type: "text", text: `Tab groups:\n${lines.join("\n")}` }] };
+                        }
+                        case "list_tabs": {
+                            const tabs = await tabGroupsClient.listTabs();
+                            const lines = tabs.map((t) => `[tab:${t.id}] group:${t.groupId === -1 ? "none" : t.groupId} "${t.title}" ${t.url}`);
+                            return { content: [{ type: "text", text: `Tabs (${tabs.length}):\n${lines.join("\n")}` }] };
+                        }
+                        case "create": {
+                            const tabIds = args?.tabIds;
+                            if (!tabIds || tabIds.length === 0) {
+                                return { content: [{ type: "text", text: "Error: tabIds required for create" }], isError: true };
+                            }
+                            const result = await tabGroupsClient.createGroup({
+                                tabIds,
+                                title: args?.title,
+                                color: args?.color,
+                            });
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: `Created group ${result.groupId}: "${result.group.title || "(untitled)"}" (${result.group.color})`,
+                                    }],
+                            };
+                        }
+                        case "update": {
+                            const groupId = args?.groupId;
+                            if (groupId === undefined) {
+                                return { content: [{ type: "text", text: "Error: groupId required for update" }], isError: true };
+                            }
+                            const group = await tabGroupsClient.updateGroup({
+                                groupId,
+                                title: args?.title,
+                                color: args?.color,
+                                collapsed: args?.collapsed,
+                            });
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: `Updated group ${group.id}: "${group.title || "(untitled)"}" (${group.color}${group.collapsed ? ", collapsed" : ""})`,
+                                    }],
+                            };
+                        }
+                        case "move": {
+                            const groupId = args?.groupId;
+                            const index = args?.index;
+                            if (groupId === undefined || index === undefined) {
+                                return { content: [{ type: "text", text: "Error: groupId and index required for move" }], isError: true };
+                            }
+                            const group = await tabGroupsClient.moveGroup(groupId, index);
+                            return { content: [{ type: "text", text: `Moved group ${group.id} to index ${index}` }] };
+                        }
+                        case "ungroup": {
+                            const tabIds = args?.tabIds;
+                            if (!tabIds || tabIds.length === 0) {
+                                return { content: [{ type: "text", text: "Error: tabIds required for ungroup" }], isError: true };
+                            }
+                            await tabGroupsClient.ungroupTabs(tabIds);
+                            return { content: [{ type: "text", text: `Ungrouped ${tabIds.length} tab(s)` }] };
+                        }
+                        case "delete": {
+                            const groupId = args?.groupId;
+                            if (groupId === undefined) {
+                                return { content: [{ type: "text", text: "Error: groupId required for delete" }], isError: true };
+                            }
+                            const tabs = await tabGroupsClient.listTabs();
+                            const groupTabs = tabs.filter((t) => t.groupId === groupId);
+                            if (groupTabs.length === 0) {
+                                return { content: [{ type: "text", text: `No tabs found in group ${groupId}` }] };
+                            }
+                            await tabGroupsClient.ungroupTabs(groupTabs.map((t) => t.id));
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: `Deleted group ${groupId} (ungrouped ${groupTabs.length} tab(s))`,
+                                    }],
+                            };
+                        }
+                        case "save_group": {
+                            const { archiveStore } = await import("./tab-group-archive.js");
+                            const groupId = args?.groupId;
+                            const taskThreadId = args?.taskThreadId;
+                            const closeTabs = args?.closeTabs;
+                            if (groupId === undefined || !taskThreadId) {
+                                return { content: [{ type: "text", text: "Error: groupId and taskThreadId required for save_group" }], isError: true };
+                            }
+                            const group = await tabGroupsClient.getGroup(groupId);
+                            const allTabs = await tabGroupsClient.listTabs();
+                            const groupTabs = allTabs.filter((t) => t.groupId === groupId);
+                            const entry = {
+                                taskThreadId,
+                                title: group.title,
+                                color: group.color,
+                                collapsed: group.collapsed,
+                                urls: groupTabs.map((t) => ({ url: t.url, title: t.title })),
+                                archivedAt: new Date().toISOString(),
+                                status: closeTabs ? "archived" : "saved",
+                            };
+                            await archiveStore.save(entry);
+                            if (closeTabs) {
+                                for (const t of groupTabs) {
+                                    try {
+                                        await tabGroupsClient.ungroupTabs([t.id]);
+                                    }
+                                    catch { /* tab may already be closed */ }
+                                }
+                            }
+                            return { content: [{ type: "text", text: `Saved ${groupTabs.length} tab(s) for thread ${taskThreadId} (status: ${entry.status})` }] };
+                        }
+                        case "restore_group": {
+                            const { archiveStore } = await import("./tab-group-archive.js");
+                            const taskThreadId = args?.taskThreadId;
+                            if (!taskThreadId) {
+                                return { content: [{ type: "text", text: "Error: taskThreadId required for restore_group" }], isError: true };
+                            }
+                            const entry = await archiveStore.restore(taskThreadId);
+                            if (!entry) {
+                                return { content: [{ type: "text", text: `No archive found for thread ${taskThreadId}` }], isError: true };
+                            }
+                            const tabIds = [];
+                            for (const u of entry.urls) {
+                                const tabId = await tabGroupsClient.createTab(u.url, false);
+                                if (typeof tabId === "number")
+                                    tabIds.push(tabId);
+                            }
+                            if (tabIds.length > 0) {
+                                await tabGroupsClient.createGroup({
+                                    tabIds,
+                                    title: entry.title,
+                                    color: entry.color,
+                                });
+                            }
+                            return { content: [{ type: "text", text: `Restored ${tabIds.length} tab(s) for thread ${taskThreadId}` }] };
+                        }
+                        case "archive_group": {
+                            const { archiveStore } = await import("./tab-group-archive.js");
+                            const groupId = args?.groupId;
+                            const taskThreadId = args?.taskThreadId;
+                            if (groupId === undefined || !taskThreadId) {
+                                return { content: [{ type: "text", text: "Error: groupId and taskThreadId required for archive_group" }], isError: true };
+                            }
+                            const group = await tabGroupsClient.getGroup(groupId);
+                            const allTabs = await tabGroupsClient.listTabs();
+                            const groupTabs = allTabs.filter((t) => t.groupId === groupId);
+                            const entry = {
+                                taskThreadId,
+                                title: group.title,
+                                color: group.color,
+                                collapsed: group.collapsed,
+                                urls: groupTabs.map((t) => ({ url: t.url, title: t.title })),
+                                archivedAt: new Date().toISOString(),
+                                status: "archived",
+                            };
+                            await archiveStore.save(entry);
+                            const tabIdsToClose = groupTabs.map((t) => t.id);
+                            if (tabIdsToClose.length > 0) {
+                                await tabGroupsClient.closeTabs(tabIdsToClose);
+                            }
+                            return { content: [{ type: "text", text: `Archived ${groupTabs.length} tab(s) for thread ${taskThreadId} (tabs closed)` }] };
+                        }
+                        case "list_archived": {
+                            const { archiveStore } = await import("./tab-group-archive.js");
+                            const entries = await archiveStore.loadAll();
+                            if (entries.length === 0) {
+                                return { content: [{ type: "text", text: "No archived tab groups." }] };
+                            }
+                            const lines = entries.map((e) => {
+                                const date = e.archivedAt ? new Date(e.archivedAt).toLocaleDateString() : "unknown";
+                                return `[${e.taskThreadId}] "${e.title || "(untitled)"}" (${e.urls.length} tabs, ${e.status}, archived ${date})`;
+                            });
+                            return { content: [{ type: "text", text: `Archived tab groups (${entries.length}):\n${lines.join("\n")}` }] };
+                        }
+                        default:
+                            return {
+                                content: [{ type: "text", text: `Unknown action: ${action}. Use: list, list_tabs, create, update, move, ungroup, delete, save_group, restore_group, archive_group, list_archived` }],
+                                isError: true,
+                            };
+                    }
+                }
+                catch (tgError) {
+                    const msg = tgError instanceof Error ? tgError.message : String(tgError);
+                    if (msg.includes("extension") || msg.includes("service worker") || msg.includes("Bridge")) {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Tab Groups Bridge extension not connected.\n\n` +
+                                        `To use tab groups:\n` +
+                                        `1. Open comet://extensions in Comet\n` +
+                                        `2. Enable "Developer mode"\n` +
+                                        `3. Click "Load unpacked" and select the extension/ folder from comet-mcp\n` +
+                                        `4. Try again\n\n` +
+                                        `Error: ${msg}`,
+                                }],
+                            isError: true,
+                        };
+                    }
+                    throw tgError;
+                }
+            }
+            case "comet_lifecycle_start": {
+                const result = await callLifecycleEndpoint({
+                    action: "start",
+                    runId: args?.runId,
+                    taskThreadId: args?.taskThreadId,
+                    agentId: args?.agentId,
+                    route: args?.route || "mcp",
+                    deferred: args?.deferred,
+                });
+                try {
+                    const env = createMCPLifecycleEnvelope({
+                        runId: args?.runId,
+                        taskThreadId: args?.taskThreadId,
+                        agentId: args?.agentId,
+                        toolName: "comet_lifecycle_start",
+                    });
+                    emitLifecycleEvent("start", env, { persist: true });
+                }
+                catch { /* graceful degradation — HTTP result already persisted */ }
+                // Bridge to JSONL outbox for orchestration
+                appendJsonl(OUTBOX_PATH, {
+                    ts: Math.floor(Date.now() / 1000),
+                    from: "comet-browser",
+                    to: "orchestration",
+                    type: "update",
+                    task: args?.runId,
+                    thread: args?.taskThreadId,
+                    msg: `Lifecycle started: run=${args?.runId}`,
+                    lifecycle: { action: "start", runId: args?.runId, status: "started" },
+                });
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "comet_lifecycle_complete": {
+                const result = await callLifecycleEndpoint({
+                    action: "complete",
+                    runId: args?.runId,
+                });
+                try {
+                    const env = createMCPLifecycleEnvelope({
+                        runId: args?.runId,
+                        toolName: "comet_lifecycle_complete",
+                    });
+                    emitLifecycleEvent("complete", env, { persist: true });
+                }
+                catch { /* graceful degradation */ }
+                // Bridge to JSONL outbox
+                appendJsonl(OUTBOX_PATH, {
+                    ts: Math.floor(Date.now() / 1000),
+                    from: "comet-browser",
+                    to: "orchestration",
+                    type: "complete",
+                    task: args?.runId,
+                    msg: `Lifecycle completed: run=${args?.runId}`,
+                    lifecycle: { action: "complete", runId: args?.runId, status: "completed" },
+                });
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "comet_lifecycle_abort": {
+                const result = await callLifecycleEndpoint({
+                    action: "abort",
+                    runId: args?.runId,
+                    reason: args?.reason,
+                });
+                try {
+                    const env = createMCPLifecycleEnvelope({
+                        runId: args?.runId,
+                        toolName: "comet_lifecycle_abort",
+                    });
+                    emitLifecycleEvent("abort", env, { persist: true });
+                }
+                catch { /* graceful degradation */ }
+                // Bridge to JSONL outbox
+                appendJsonl(OUTBOX_PATH, {
+                    ts: Math.floor(Date.now() / 1000),
+                    from: "comet-browser",
+                    to: "orchestration",
+                    type: "blocked",
+                    task: args?.runId,
+                    msg: `Lifecycle aborted: run=${args?.runId}${args?.reason ? ` reason=${args.reason}` : ""}`,
+                    lifecycle: { action: "abort", runId: args?.runId, status: "aborted", reason: args?.reason },
+                });
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "comet_lifecycle_update": {
+                const result = await callLifecycleEndpoint({
+                    action: "update",
+                    runId: args?.runId,
+                    auditSessionId: args?.auditSessionId,
+                    tabGroupId: args?.tabGroupId,
+                    workflowId: args?.workflowId,
+                    metadata: args?.metadata,
+                });
+                try {
+                    const env = createMCPLifecycleEnvelope({
+                        runId: args?.runId,
+                        toolName: "comet_lifecycle_update",
+                    });
+                    emitLifecycleEvent("update", env, { persist: true });
+                }
+                catch { /* graceful degradation */ }
+                return { content: [{ type: "text", text: result }] };
+            }
+            case "comet_task_status": {
+                const groupId = args?.groupId;
+                const threadId = args?.threadId;
+                if (!groupId && !threadId) {
+                    return { content: [{ type: "text", text: "Error: provide groupId or threadId" }], isError: true };
+                }
+                const manifest = readJsonSafe(MANIFEST_PATH);
+                const sessions = manifest?.sessions || [];
+                // Filter sessions
+                const matched = sessions.filter((s) => {
+                    if (groupId !== undefined && s.groupId === groupId)
+                        return true;
+                    if (threadId && s.threadId === threadId)
+                        return true;
+                    return false;
+                });
+                if (matched.length === 0) {
+                    return { content: [{ type: "text", text: `No sessions found for ${groupId ? `groupId=${groupId}` : `threadId=${threadId}`}` }] };
+                }
+                // Try to get recent ring buffer events via CDP
+                let recentEvents = [];
+                try {
+                    const { tabGroupsClient } = await import("./tab-groups.js");
+                    // Reuse the tab groups client's CDP path to find service worker
+                    const response = await fetch(`http://127.0.0.1:9222/json/list`);
+                    const targets = (await response.json());
+                    const sw = targets.find((t) => t.type === "service_worker" && t.webSocketDebuggerUrl);
+                    if (sw) {
+                        // We can't easily eval here without ws, so skip ring buffer in MCP context
+                        // Ring buffer events are aggregated by comet-event-aggregator.py instead
+                    }
+                }
+                catch { /* CDP not available */ }
+                const result = matched.map((s) => ({
+                    groupId: s.groupId,
+                    groupName: s.groupName,
+                    groupColor: s.groupColor,
+                    threadId: s.threadId,
+                    status: s.agent?.status || "unknown",
+                    agentId: s.agent?.id || null,
+                    tabs: s.tabs?.length || 0,
+                    metrics: s.metrics || {},
+                    links: s.links || {},
+                    lastActivity: s.metrics?.lastActivityAt || null,
+                }));
+                return { content: [{ type: "text", text: JSON.stringify(result.length === 1 ? result[0] : result, null, 2) }] };
+            }
+            case "comet_delegate": {
+                const threadId = args?.threadId;
+                const instruction = args?.instruction;
+                const priority = args?.priority || "P3";
+                const urls = args?.urls || [];
+                const dependsOn = args?.dependsOn || [];
+                const agentId = args?.agentId || "comet-mcp";
+                if (!threadId || !instruction) {
+                    return { content: [{ type: "text", text: "Error: threadId and instruction are required" }], isError: true };
+                }
+                const taskId = `comet-${Date.now()}`;
+                const priorityColors = { P1: "red", P2: "yellow", P3: "blue", P4: "grey" };
+                const color = priorityColors[priority] || "blue";
+                // 1. Write to inbox-comet.jsonl
+                appendJsonl(INBOX_PATH, {
+                    ts: Math.floor(Date.now() / 1000),
+                    from: "comet-delegate",
+                    to: "comet-browser",
+                    task: taskId,
+                    type: "instruction",
+                    thread: threadId,
+                    priority,
+                    msg: instruction,
+                    browser_task: {
+                        thread_id: threadId,
+                        group_name: threadId.slice(0, 50),
+                        color,
+                        priority,
+                        urls,
+                        depends_on: dependsOn,
+                    },
+                });
+                // 2. Start lifecycle tracking
+                let lifecycleResult = "skipped";
+                try {
+                    lifecycleResult = await callLifecycleEndpoint({
+                        action: "start",
+                        runId: taskId,
+                        taskThreadId: threadId,
+                        agentId,
+                        route: "mcp",
+                    });
+                }
+                catch { /* CC-SO may not be running */ }
+                // 3. Dispatch via session-controller.mjs
+                let dispatchResult = "skipped";
+                const controllerPath = join(homedir(), ".claude", "comet-browser", "session-controller.mjs");
+                try {
+                    const dispatchArgs = ["dispatch", "--thread", threadId];
+                    if (agentId)
+                        dispatchArgs.push("--agent", agentId);
+                    const { stdout } = await execFileAsync("node", [controllerPath, ...dispatchArgs], { timeout: 15000 });
+                    dispatchResult = stdout.trim();
+                }
+                catch (e) {
+                    dispatchResult = `failed: ${e instanceof Error ? e.message : e}`;
+                }
+                // 4. Bridge to outbox
+                appendJsonl(OUTBOX_PATH, {
+                    ts: Math.floor(Date.now() / 1000),
+                    from: "comet-browser",
+                    to: "orchestration",
+                    type: "update",
+                    task: taskId,
+                    thread: threadId,
+                    msg: `Delegated: ${instruction.slice(0, 100)}`,
+                    lifecycle: { action: "start", runId: taskId, status: "dispatched" },
+                });
+                const summary = [
+                    `Task delegated successfully.`,
+                    `  Task ID: ${taskId}`,
+                    `  Thread: ${threadId}`,
+                    `  Priority: ${priority} (color: ${color})`,
+                    `  URLs: ${urls.length > 0 ? urls.join(", ") : "(from thread metadata)"}`,
+                    `  Lifecycle: ${lifecycleResult === "skipped" ? "skipped (CC-SO unavailable)" : "started"}`,
+                    `  Dispatch: ${dispatchResult}`,
+                ].join("\n");
+                return { content: [{ type: "text", text: summary }] };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : error}` }],
+            isError: true,
+        };
+    }
+});
+const transport = new StdioServerTransport();
+server.connect(transport);
+//# sourceMappingURL=index.js.map