@mcpware/chrome-pilot 0.1.0

package/README.md

@@ -0,0 +1,110 @@
+# chrome-pilot
+
+AI-controlled Chrome with real profile sync. Like Playwright, but with your bookmarks, passwords, and extensions.
+
+## Why?
+
+Playwright is great for browser automation, but every session starts with a **clean browser** — no logins, no cookies, no bookmarks. You have to re-authenticate every time.
+
+**chrome-pilot** solves this by launching your **real Chrome** with persistent profiles. Sign into Google once, and Chrome Sync brings over all your data. Every subsequent launch retains your sessions.
+
+```
+Playwright:      Clean Chromium → re-login every time
+chrome-pilot:    Real Chrome + your profile → sessions persist forever
+```
+
+## Install
+
+```bash
+npm install @mcpware/chrome-pilot
+```
+
+## Quick Start
+
+### As an MCP Server (for Claude, etc.)
+
+Add to your MCP config:
+
+```json
+{
+  "mcpServers": {
+    "chrome-pilot": {
+      "command": "npx",
+      "args": ["@mcpware/chrome-pilot"]
+    }
+  }
+}
+```
+
+Then ask your AI:
+- *"Open my personal Chrome and go to GitHub"*
+- *"Take a screenshot of the current page"*
+- *"List my Chrome profiles"*
+
+### As a Library
+
+```typescript
+import { launchProfile, listProfiles, closeProfile } from "@mcpware/chrome-pilot";
+
+// Launch Chrome with a persistent profile
+const { page, port } = await launchProfile("personal", {
+  url: "https://github.com",
+});
+
+// First time? Chrome sign-in page appears.
+// Sign into Google → Chrome Sync pulls your bookmarks, passwords, extensions.
+// Next time? Everything is already there.
+
+await page.screenshot({ path: "screenshot.png" });
+await closeProfile("personal");
+```
+
+## MCP Tools
+
+### Profile Management
+
+| Tool | Description |
+|------|-------------|
+| `list_profiles` | List all Chrome profiles with linked Google accounts |
+| `create_profile` | Create a new profile |
+| `delete_profile` | Delete a profile and its data |
+| `launch` | Launch Chrome with a profile (auto-creates if needed) |
+| `close` | Close a profile session |
+| `get_active` | List running sessions with CDP ports |
+
+### Browser Control
+
+| Tool | Description |
+|------|-------------|
+| `navigate` | Go to a URL |
+| `screenshot` | Capture the page as PNG |
+| `click` | Click an element by CSS selector |
+| `type` | Type text into focused element |
+| `fill` | Fill a form field by selector |
+| `eval` | Run JavaScript in page context |
+| `snap` | Get accessibility tree of the page |
+
+### Tab Management
+
+| Tool | Description |
+|------|-------------|
+| `list_tabs` | List all open tabs |
+| `new_tab` | Open a new tab |
+
+## How It Works
+
+1. **Uses your real Chrome** (not Playwright's bundled Chromium)
+2. **Persistent profiles** stored in `~/.chrome-pilot/profiles/`
+3. **Chrome Sync** brings your bookmarks, passwords, and extensions
+4. **Multi-profile** support — run personal and work Chrome simultaneously
+5. **MCP interface** — AI agents control Chrome through standard MCP tools
+6. **CDP bridge** — each profile gets its own debugging port
+
+## Requirements
+
+- Google Chrome installed on your system
+- Node.js 20+
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+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 { listProfiles, createProfile, deleteProfile, launchProfile, closeProfile, getActiveSessions, getSessionPage, } from "./profiles.js";
+const server = new Server({
+    name: "chrome-pilot",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// ─── Tool Definitions ───────────────────────────────────────────────
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        // Profile Management
+        {
+            name: "list_profiles",
+            description: "List all Chrome profiles available in chrome-pilot. Shows profile name and linked Google account.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "create_profile",
+            description: "Create a new Chrome profile. After creation, launch it to sign into Google and sync your data.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: 'Profile name (e.g. "personal", "work", "client-abc")',
+                    },
+                },
+                required: ["name"],
+            },
+        },
+        {
+            name: "delete_profile",
+            description: "Delete a Chrome profile and all its data.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string", description: "Profile name to delete" },
+                },
+                required: ["name"],
+            },
+        },
+        {
+            name: "launch",
+            description: "Launch Chrome with a specific profile. First launch opens Chrome sign-in page for Google Sync. All subsequent launches retain your sessions, bookmarks, and passwords.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: {
+                        type: "string",
+                        description: "Profile name to launch",
+                    },
+                    url: {
+                        type: "string",
+                        description: "Optional URL to navigate to after launch",
+                    },
+                    headless: {
+                        type: "boolean",
+                        description: "Run in headless mode (default: false)",
+                    },
+                },
+                required: ["profile"],
+            },
+        },
+        {
+            name: "close",
+            description: "Close a Chrome profile session.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name to close" },
+                },
+                required: ["profile"],
+            },
+        },
+        {
+            name: "get_active",
+            description: "List all currently running Chrome sessions with their profiles and CDP ports.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        // Browser Control
+        {
+            name: "navigate",
+            description: "Navigate to a URL in the active page of a profile.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                    url: { type: "string", description: "URL to navigate to" },
+                },
+                required: ["profile", "url"],
+            },
+        },
+        {
+            name: "screenshot",
+            description: "Take a screenshot of the active page. Returns base64 encoded image.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                },
+                required: ["profile"],
+            },
+        },
+        {
+            name: "click",
+            description: "Click an element on the page by CSS selector.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                    selector: {
+                        type: "string",
+                        description: "CSS selector of element to click",
+                    },
+                },
+                required: ["profile", "selector"],
+            },
+        },
+        {
+            name: "type",
+            description: "Type text into the currently focused element.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                    text: { type: "string", description: "Text to type" },
+                },
+                required: ["profile", "text"],
+            },
+        },
+        {
+            name: "fill",
+            description: "Fill a form field by selector with the given value.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                    selector: {
+                        type: "string",
+                        description: "CSS selector of the input field",
+                    },
+                    value: { type: "string", description: "Value to fill" },
+                },
+                required: ["profile", "selector", "value"],
+            },
+        },
+        {
+            name: "eval",
+            description: "Evaluate JavaScript in the page context.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                    expression: {
+                        type: "string",
+                        description: "JavaScript expression to evaluate",
+                    },
+                },
+                required: ["profile", "expression"],
+            },
+        },
+        {
+            name: "snap",
+            description: "Get the accessibility tree of the current page. Useful for understanding page structure without screenshots.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                },
+                required: ["profile"],
+            },
+        },
+        // Tab Management
+        {
+            name: "list_tabs",
+            description: "List all open tabs in a profile session.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                },
+                required: ["profile"],
+            },
+        },
+        {
+            name: "new_tab",
+            description: "Open a new tab in a profile session.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    profile: { type: "string", description: "Profile name" },
+                    url: { type: "string", description: "URL to open in the new tab" },
+                },
+                required: ["profile"],
+            },
+        },
+    ],
+}));
+// ─── Tool Handlers ──────────────────────────────────────────────────
+function getPage(profile) {
+    const page = getSessionPage(profile);
+    if (!page) {
+        throw new Error(`No active session for profile "${profile}". Use launch() first.`);
+    }
+    return page;
+}
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            // ── Profile Management ──
+            case "list_profiles": {
+                const profiles = listProfiles();
+                if (profiles.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: 'No profiles found. Use create_profile to create one, or launch("profile-name") to auto-create and launch.',
+                            },
+                        ],
+                    };
+                }
+                const active = getActiveSessions();
+                const activeNames = new Set(active.map((s) => s.name));
+                const text = profiles
+                    .map((p) => `${activeNames.has(p.name) ? "🟢" : "⚪"} ${p.name}${p.lastUsed ? ` (${p.lastUsed})` : ""}`)
+                    .join("\n");
+                return { content: [{ type: "text", text }] };
+            }
+            case "create_profile": {
+                const profile = createProfile(args.name);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Created profile "${profile.name}". Use launch("${profile.name}") to open Chrome and sign into Google.`,
+                        },
+                    ],
+                };
+            }
+            case "delete_profile": {
+                deleteProfile(args.name);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Deleted profile "${args.name}".`,
+                        },
+                    ],
+                };
+            }
+            case "launch": {
+                const { context, page, port } = await launchProfile(args.profile, {
+                    url: args?.url,
+                    headless: args?.headless,
+                });
+                const url = page.url();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Launched profile "${args.profile}" on CDP port ${port}.\nCurrent page: ${url}\nPages open: ${context.pages().length}`,
+                        },
+                    ],
+                };
+            }
+            case "close": {
+                await closeProfile(args.profile);
+                return {
+                    content: [
+                        { type: "text", text: `Closed profile "${args.profile}".` },
+                    ],
+                };
+            }
+            case "get_active": {
+                const sessions = getActiveSessions();
+                if (sessions.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "No active sessions." }],
+                    };
+                }
+                const text = sessions
+                    .map((s) => `🟢 ${s.name} — port ${s.port}, ${s.pageCount} tab(s)`)
+                    .join("\n");
+                return { content: [{ type: "text", text }] };
+            }
+            // ── Browser Control ──
+            case "navigate": {
+                const page = getPage(args.profile);
+                await page.goto(args.url, {
+                    waitUntil: "domcontentloaded",
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Navigated to ${args.url}`,
+                        },
+                    ],
+                };
+            }
+            case "screenshot": {
+                const page = getPage(args.profile);
+                const buffer = await page.screenshot();
+                return {
+                    content: [
+                        {
+                            type: "image",
+                            data: buffer.toString("base64"),
+                            mimeType: "image/png",
+                        },
+                    ],
+                };
+            }
+            case "click": {
+                const page = getPage(args.profile);
+                await page.click(args.selector);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Clicked "${args.selector}"`,
+                        },
+                    ],
+                };
+            }
+            case "type": {
+                const page = getPage(args.profile);
+                await page.keyboard.type(args.text);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Typed "${args.text.substring(0, 50)}${args.text.length > 50 ? "..." : ""}"`,
+                        },
+                    ],
+                };
+            }
+            case "fill": {
+                const page = getPage(args.profile);
+                await page.fill(args.selector, args.value);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Filled "${args.selector}" with value`,
+                        },
+                    ],
+                };
+            }
+            case "eval": {
+                const page = getPage(args.profile);
+                const result = await page.evaluate(args.expression);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: typeof result === "string"
+                                ? result
+                                : JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "snap": {
+                const page = getPage(args.profile);
+                const snapshot = await page.evaluate(() => {
+                    function getAccessibilityTree(el, depth = 0) {
+                        const role = el.getAttribute("role") || el.tagName.toLowerCase();
+                        const text = el.textContent?.trim().substring(0, 80) || "";
+                        const label = el.getAttribute("aria-label") || "";
+                        const indent = "  ".repeat(depth);
+                        let line = `${indent}[${role}]`;
+                        if (label)
+                            line += ` "${label}"`;
+                        else if (text && !el.children.length)
+                            line += ` "${text}"`;
+                        const lines = [line];
+                        for (const child of el.children) {
+                            lines.push(...getAccessibilityTree(child, depth + 1).split("\n"));
+                        }
+                        return lines.filter(Boolean).join("\n");
+                    }
+                    return getAccessibilityTree(document.body);
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: snapshot,
+                        },
+                    ],
+                };
+            }
+            // ── Tab Management ──
+            case "list_tabs": {
+                const page = getPage(args.profile);
+                const context = page.context();
+                const tabs = context.pages().map((p, i) => `${i}: ${p.url()}`);
+                return {
+                    content: [{ type: "text", text: tabs.join("\n") }],
+                };
+            }
+            case "new_tab": {
+                const page = getPage(args.profile);
+                const context = page.context();
+                const newPage = await context.newPage();
+                if (args?.url) {
+                    await newPage.goto(args.url, {
+                        waitUntil: "domcontentloaded",
+                    });
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Opened new tab${args?.url ? `: ${args.url}` : ""}`,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// ─── Start Server ───────────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("chrome-pilot MCP server running");
+}
+main().catch((error) => {
+    console.error("Fatal:", error);
+    process.exit(1);
+});

package/dist/profiles.d.ts

@@ -0,0 +1,53 @@
+import { type BrowserContext, type Page } from "playwright-core";
+export interface Profile {
+    name: string;
+    path: string;
+    lastUsed?: string;
+}
+/**
+ * Find Chrome executable on the system
+ */
+export declare function findChrome(): string;
+/**
+ * List all available profiles
+ */
+export declare function listProfiles(): Profile[];
+/**
+ * Create a new profile
+ */
+export declare function createProfile(name: string): Profile;
+/**
+ * Delete a profile
+ */
+export declare function deleteProfile(name: string): void;
+/**
+ * Launch Chrome with a profile — the core function
+ *
+ * Uses Playwright's launch_persistent_context with the real Chrome binary.
+ * First launch: user sees Chrome sign-in page → signs into Google → Chrome Sync pulls data.
+ * Subsequent launches: all data persists (cookies, passwords, bookmarks, extensions).
+ */
+export declare function launchProfile(name: string, options?: {
+    url?: string;
+    headless?: boolean;
+}): Promise<{
+    context: BrowserContext;
+    page: Page;
+    port: number;
+}>;
+/**
+ * Get active sessions
+ */
+export declare function getActiveSessions(): Array<{
+    name: string;
+    port: number;
+    pageCount: number;
+}>;
+/**
+ * Get a page from an active session
+ */
+export declare function getSessionPage(name: string): Page | null;
+/**
+ * Close a profile session
+ */
+export declare function closeProfile(name: string): Promise<void>;