@cobo-screenshot/mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// ../../packages/core/dist/index.js
+var DEFAULT_COBO_API_URL = "https://api.cobo.example";
+
+// src/client.ts
+var CoboClient = class {
+  apiUrl;
+  token;
+  fetchImpl;
+  constructor(opts) {
+    this.apiUrl = opts.apiUrl.replace(/\/$/, "");
+    this.token = opts.token;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+  }
+  async req(path, init = {}) {
+    const res = await this.fetchImpl(`${this.apiUrl}${path}`, {
+      ...init,
+      headers: {
+        ...init.body ? { "content-type": "application/json" } : {},
+        Authorization: `Bearer ${this.token}`,
+        ...init.headers ?? {}
+      }
+    });
+    if (!res.ok) {
+      let message = `${init.method ?? "GET"} ${path} -> ${res.status}`;
+      try {
+        const body = await res.json();
+        if (body?.error) message = body.error;
+      } catch {
+      }
+      throw new Error(message);
+    }
+    return await res.json();
+  }
+  getThread(id) {
+    return this.req(`/threads/${id}`);
+  }
+  listThreads(params) {
+    const q = new URLSearchParams({ workspaceId: params.workspaceId });
+    if (params.url) q.set("url", params.url);
+    return this.req(`/threads?${q.toString()}`);
+  }
+  addComment(id, body) {
+    return this.req(`/threads/${id}/comments`, {
+      method: "POST",
+      body: JSON.stringify({ body })
+    });
+  }
+  setStatus(id, status) {
+    return this.req(`/threads/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ status })
+    });
+  }
+};
+
+// src/format.ts
+var AI_PREFIX = "\u{1F916} (via AI) ";
+function withAiPrefix(body) {
+  return AI_PREFIX + body;
+}
+function formatComment(t) {
+  const a = t.anchor;
+  return {
+    nodeId: t.id,
+    url: t.url,
+    status: t.status,
+    version: t.version,
+    element: a.type === "element" ? { cssPath: a.cssPath, tag: a.tag, attrs: a.attrs, text: a.text } : { kind: "region", rect: a.rect },
+    screenshot: t.imageUrl ? { url: t.imageUrl } : null,
+    comments: t.comments.map((c) => ({ author: c.author.name, body: c.body, createdAt: c.createdAt })),
+    createdAt: t.createdAt
+  };
+}
+function formatList(threads) {
+  return threads.map((t) => ({
+    nodeId: t.id,
+    url: t.url,
+    status: t.status,
+    snippet: (t.comments[0]?.body ?? "").slice(0, 140),
+    element: t.anchor.type === "element" ? { tag: t.anchor.tag, text: t.anchor.text } : { tag: "(region)", text: "" },
+    author: t.comments[0]?.author.name ?? "",
+    createdAt: t.createdAt
+  }));
+}
+
+// src/index.ts
+var apiUrl = process.env.COBO_API_URL ?? DEFAULT_COBO_API_URL;
+var token = process.env.COBO_TOKEN;
+if (!token) {
+  console.error("cobo-mcp: COBO_TOKEN must be set. Generate one in the Cobo extension's AI access panel.");
+  process.exit(1);
+}
+var client = new CoboClient({ apiUrl, token });
+var server = new McpServer({ name: "cobo", version: "0.0.0" });
+async function fetchImageBlock(url) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return null;
+    const mimeType = (res.headers.get("content-type") ?? "image/jpeg").split(";")[0].trim();
+    const data = Buffer.from(await res.arrayBuffer()).toString("base64");
+    return { type: "image", data, mimeType };
+  } catch {
+    return null;
+  }
+}
+server.tool(
+  "get_comment",
+  "Fetch a Cobo comment thread by its nodeId: the comments, the page element it points to (cssPath/tag/text), a screenshot, the page URL, and status.",
+  { nodeId: z.string().describe("The comment's nodeId (the Cobo thread id)") },
+  async ({ nodeId }) => {
+    const { thread } = await client.getThread(nodeId);
+    const ctx = formatComment(thread);
+    const content = [
+      { type: "text", text: JSON.stringify(ctx, null, 2) }
+    ];
+    if (ctx.screenshot) {
+      const img = await fetchImageBlock(ctx.screenshot.url);
+      if (img) content.push(img);
+    }
+    return { content };
+  }
+);
+server.tool(
+  "list_comments",
+  "List Cobo comment threads for a workspace, optionally filtered by page url and status.",
+  {
+    workspaceId: z.string().describe("The Cobo workspace id (included in the comment handoff prompt)"),
+    url: z.string().optional(),
+    status: z.enum(["open", "resolved"]).optional()
+  },
+  async ({ workspaceId, url, status }) => {
+    const { threads } = await client.listThreads({ workspaceId, url });
+    let list = formatList(threads);
+    if (status) list = list.filter((t) => t.status === status);
+    return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+  }
+);
+server.tool(
+  "reply_comment",
+  "Post a reply to a Cobo comment thread. The reply is marked as written via AI.",
+  { nodeId: z.string(), body: z.string() },
+  async ({ nodeId, body }) => {
+    const { comment } = await client.addComment(nodeId, withAiPrefix(body));
+    return { content: [{ type: "text", text: `Replied to ${nodeId} (commentId=${comment.id}).` }] };
+  }
+);
+server.tool(
+  "resolve_comment",
+  "Mark a Cobo comment thread resolved, or reopen it.",
+  { nodeId: z.string(), reopen: z.boolean().optional() },
+  async ({ nodeId, reopen }) => {
+    const { thread } = await client.setStatus(nodeId, reopen ? "open" : "resolved");
+    return { content: [{ type: "text", text: `Thread ${thread.id} is now ${thread.status}.` }] };
+  }
+);
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@cobo-screenshot/mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "cobo-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.4",
+    "@cobo/core": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}