@roveapi/mcp 1.0.0

package/dist/index.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/config.ts
+function loadConfig(env) {
+  return {
+    apiBaseUrl: env.ROVE_API_BASE_URL ?? "http://127.0.0.1:3001",
+    apiKey: env.ROVE_API_KEY ?? "rvp_live_demo"
+  };
+}
+
+// src/rest-client.ts
+async function parseJson(response) {
+  return await response.json();
+}
+function createRestClient(apiBaseUrl, apiKey) {
+  async function call(path, init) {
+    const response = await fetch(`${apiBaseUrl}${path}`, {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${apiKey}`,
+        ...init?.headers ?? {}
+      }
+    });
+    const body = await parseJson(response).catch(() => ({}));
+    if (!response.ok) {
+      throw new Error(`API ${path} failed (${response.status}): ${JSON.stringify(body)}`);
+    }
+    return body;
+  }
+  return {
+    createSession: (input) => call("/v1/browser/session", { method: "POST", body: JSON.stringify(input ?? {}) }),
+    runAction: (input) => call("/v1/browser/action", { method: "POST", body: JSON.stringify(input) }),
+    standaloneScreenshot: (input) => call("/v1/browser/screenshot", { method: "POST", body: JSON.stringify(input) }),
+    extract: (input) => call("/v1/browser/extract", { method: "POST", body: JSON.stringify(input) }),
+    getArtifacts: (sessionId) => call(`/v1/browser/artifacts/${sessionId}`, { method: "GET" })
+  };
+}
+
+// src/session-store.ts
+var SessionStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  get(clientId) {
+    return this.sessions.get(clientId);
+  }
+  set(clientId, sessionId) {
+    this.sessions.set(clientId, sessionId);
+  }
+  clear(clientId) {
+    this.sessions.delete(clientId);
+  }
+};
+
+// src/tools.ts
+var TOOL_DEFS = [
+  {
+    name: "navigate",
+    description: "Navigate within a browser session, creating one if needed. Explicit session_id becomes the active session for subsequent calls.",
+    inputSchema: { type: "object", properties: { url: { type: "string" }, session_id: { type: "string" } }, required: ["url"] },
+    mappedEndpoint: "POST /v1/browser/action (navigate)"
+  },
+  {
+    name: "interact",
+    description: "Perform click/fill style actions in active session.",
+    inputSchema: {
+      type: "object",
+      properties: { session_id: { type: "string" }, action: { type: "string", enum: ["click", "fill"] }, params: { type: "object" } },
+      required: ["session_id", "action"]
+    },
+    mappedEndpoint: "POST /v1/browser/action (click/fill)"
+  },
+  {
+    name: "extract_schema",
+    description: "Reserved mapping for extraction path.",
+    inputSchema: { type: "object", properties: { url: { type: "string" }, schema: { type: "object" } }, required: ["url", "schema"] },
+    mappedEndpoint: "POST /v1/browser/extract"
+  },
+  {
+    name: "screenshot",
+    description: "Take in-session or standalone screenshot. Explicit session_id is persisted as active session context.",
+    inputSchema: { type: "object", properties: { session_id: { type: "string" }, url: { type: "string" } } },
+    mappedEndpoint: "POST /v1/browser/action (screenshot) or POST /v1/browser/screenshot"
+  },
+  {
+    name: "get_a11y_tree",
+    description: "Get accessibility tree snapshot for active session.",
+    inputSchema: { type: "object", properties: { session_id: { type: "string" } }, required: ["session_id"] },
+    mappedEndpoint: "POST /v1/browser/action (get_a11y_tree)"
+  },
+  {
+    name: "close_session",
+    description: "Close current session and clear MCP state only when closing the currently stored session.",
+    inputSchema: { type: "object", properties: { session_id: { type: "string" } }, required: ["session_id"] },
+    mappedEndpoint: "POST /v1/browser/action (close_session)"
+  }
+];
+function resolveSessionId(input, sessionStore, clientId) {
+  const explicit = input.session_id;
+  if (typeof explicit === "string" && explicit.length > 0) {
+    sessionStore.set(clientId, explicit);
+    return explicit;
+  }
+  const fromStore = sessionStore.get(clientId);
+  if (!fromStore) throw new Error("session_id required and no active session in store");
+  return fromStore;
+}
+async function runTool(toolName, input, deps) {
+  const { rest: rest2, sessions: sessions2, clientId } = deps;
+  switch (toolName) {
+    case "navigate": {
+      const url = input.url;
+      if (typeof url !== "string" || !url) throw new Error("url is required");
+      let sessionId = typeof input.session_id === "string" ? input.session_id : sessions2.get(clientId);
+      if (!sessionId) {
+        const created = await rest2.createSession({});
+        sessionId = created.session_id;
+      }
+      sessions2.set(clientId, sessionId);
+      const result = await rest2.runAction({ session_id: sessionId, action: "navigate", params: { url } });
+      return { session_id: sessionId, ...result };
+    }
+    case "interact": {
+      const action = input.action;
+      if (action !== "click" && action !== "fill") throw new Error("action must be click|fill");
+      const sessionId = resolveSessionId(input, sessions2, clientId);
+      const result = await rest2.runAction({
+        session_id: sessionId,
+        action,
+        params: input.params ?? {}
+      });
+      return { session_id: sessionId, ...result };
+    }
+    case "extract_schema": {
+      const url = input.url;
+      if (typeof url !== "string" || !url) throw new Error("url is required");
+      const schema = input.schema;
+      if (!schema || typeof schema !== "object") throw new Error("schema is required");
+      return rest2.extract({
+        url,
+        schema,
+        wait_for_selector: input.wait_for_selector
+      });
+    }
+    case "screenshot": {
+      const explicit = typeof input.session_id === "string" ? input.session_id : void 0;
+      const stored = sessions2.get(clientId);
+      const sessionId = explicit ?? stored;
+      if (sessionId) {
+        sessions2.set(clientId, sessionId);
+        const result = await rest2.runAction({ session_id: sessionId, action: "screenshot", params: {} });
+        return { session_id: sessionId, ...result };
+      }
+      const url = input.url;
+      if (typeof url !== "string" || !url) throw new Error("url is required for standalone screenshot");
+      return rest2.standaloneScreenshot({ url });
+    }
+    case "get_a11y_tree": {
+      const sessionId = resolveSessionId(input, sessions2, clientId);
+      const result = await rest2.runAction({ session_id: sessionId, action: "get_a11y_tree", params: {} });
+      return { session_id: sessionId, ...result };
+    }
+    case "close_session": {
+      const explicit = input.session_id;
+      const sessionId = typeof explicit === "string" && explicit.length > 0 ? explicit : resolveSessionId(input, sessions2, clientId);
+      const result = await rest2.runAction({ session_id: sessionId, action: "close_session", params: {} });
+      const currentlyStored = sessions2.get(clientId);
+      const cleared = currentlyStored === sessionId;
+      if (cleared) sessions2.clear(clientId);
+      return { session_id: sessionId, ...result, cleanup: { session_store_cleared: cleared } };
+    }
+  }
+}
+
+// src/index.ts
+var config = loadConfig(process.env);
+var rest = createRestClient(config.apiBaseUrl, config.apiKey);
+var sessions = new SessionStore();
+var server = new Server(
+  { name: "rove-browser", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: TOOL_DEFS.map((t) => ({
+    name: t.name,
+    description: t.description,
+    inputSchema: t.inputSchema
+  }))
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    const result = await runTool(
+      name,
+      args ?? {},
+      { rest, sessions, clientId: "mcp" }
+    );
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("MCP server failed to start:", err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@roveapi/mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Rove browser automation API — use from Claude, Cursor, VS Code",
+  "bin": {
+    "rove-mcp": "./dist/index.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "bundle": "esbuild src/index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/index.mjs --packages=external --external:@modelcontextprotocol/sdk",
+    "dev": "tsx watch src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test test/*.test.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": ["mcp", "browser", "automation", "playwright", "a11y", "claude", "cursor"],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1"
+  },
+  "devDependencies": {
+    "@rove/dsl": "workspace:*",
+    "esbuild": "^0.27",
+    "typescript": "^5",
+    "tsx": "^4",
+    "@types/node": "^22"
+  }
+}