@mcpware/chrome-pilot 0.1.0

package/src/index.ts

@@ -0,0 +1,514 @@
+#!/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: string) {
+  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 as string);
+        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 as string);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Deleted profile "${args!.name}".`,
+            },
+          ],
+        };
+      }
+
+      case "launch": {
+        const { context, page, port } = await launchProfile(
+          args!.profile as string,
+          {
+            url: args?.url as string | undefined,
+            headless: args?.headless as boolean | undefined,
+          }
+        );
+        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 as string);
+        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 as string);
+        await page.goto(args!.url as string, {
+          waitUntil: "domcontentloaded",
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Navigated to ${args!.url}`,
+            },
+          ],
+        };
+      }
+
+      case "screenshot": {
+        const page = getPage(args!.profile as string);
+        const buffer = await page.screenshot();
+        return {
+          content: [
+            {
+              type: "image",
+              data: buffer.toString("base64"),
+              mimeType: "image/png",
+            },
+          ],
+        };
+      }
+
+      case "click": {
+        const page = getPage(args!.profile as string);
+        await page.click(args!.selector as string);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Clicked "${args!.selector}"`,
+            },
+          ],
+        };
+      }
+
+      case "type": {
+        const page = getPage(args!.profile as string);
+        await page.keyboard.type(args!.text as string);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Typed "${(args!.text as string).substring(0, 50)}${(args!.text as string).length > 50 ? "..." : ""}"`,
+            },
+          ],
+        };
+      }
+
+      case "fill": {
+        const page = getPage(args!.profile as string);
+        await page.fill(args!.selector as string, args!.value as string);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Filled "${args!.selector}" with value`,
+            },
+          ],
+        };
+      }
+
+      case "eval": {
+        const page = getPage(args!.profile as string);
+        const result = await page.evaluate(args!.expression as string);
+        return {
+          content: [
+            {
+              type: "text",
+              text:
+                typeof result === "string"
+                  ? result
+                  : JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "snap": {
+        const page = getPage(args!.profile as string);
+        const snapshot = await page.evaluate(() => {
+          function getAccessibilityTree(el: Element, depth = 0): string {
+            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 as string);
+        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 as string);
+        const context = page.context();
+        const newPage = await context.newPage();
+        if (args?.url) {
+          await newPage.goto(args.url as string, {
+            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);
+});