@opentiny/webmcp-cli 0.0.1-alpha.0

package/dist/webmcp-tools/excalidraw.com.js

@@ -0,0 +1,219 @@
+;(function(){
+"use strict";
+(() => {
+  // webmcp-tools/excalidraw.com/index.ts
+  var _excalidrawMcp = navigator.modelContext;
+  if (!_excalidrawMcp || typeof _excalidrawMcp.registerTool !== "function") {
+    console.warn("[webmcp-tools] excalidraw.com: navigator.modelContext.registerTool \u672A\u5C31\u7EEA\uFF0C\u8DF3\u8FC7\u6CE8\u5165");
+  } else if (!window.__webmcptools_excalidraw) {
+    const mcp = _excalidrawMcp;
+    try {
+      let getExcalidrawAPIFromDOM = function(domElement) {
+        if (!domElement) return null;
+        const reactFiberKey = Object.keys(domElement).find(
+          (key) => key.startsWith("__reactFiber$") || key.startsWith("__reactInternalInstance$")
+        );
+        if (!reactFiberKey) return null;
+        let fiberNode = domElement[reactFiberKey];
+        function isExcalidrawAPI(obj) {
+          return typeof obj === "object" && obj !== null && typeof obj.updateScene === "function" && typeof obj.getSceneElements === "function" && typeof obj.getAppState === "function";
+        }
+        function findApiInObject(objToSearch) {
+          if (isExcalidrawAPI(objToSearch)) return objToSearch;
+          if (typeof objToSearch === "object" && objToSearch !== null) {
+            for (const key in objToSearch) {
+              if (Object.prototype.hasOwnProperty.call(objToSearch, key)) {
+                const found = findApiInObject(objToSearch[key]);
+                if (found) return found;
+              }
+            }
+          }
+          return null;
+        }
+        let excalidrawApi = null;
+        let attempts = 0;
+        const MAX_TRAVERSAL = 25;
+        while (fiberNode && attempts < MAX_TRAVERSAL) {
+          if (fiberNode.stateNode?.props) {
+            const api = findApiInObject(fiberNode.stateNode.props);
+            if (api) {
+              excalidrawApi = api;
+              break;
+            }
+          }
+          if (fiberNode.memoizedProps) {
+            const api = findApiInObject(fiberNode.memoizedProps);
+            if (api) {
+              excalidrawApi = api;
+              break;
+            }
+          }
+          if ([0, 2, 11, 14, 15].includes(fiberNode.tag) && fiberNode.memoizedState) {
+            let hook = fiberNode.memoizedState;
+            let hookAttempts = 0;
+            while (hook && hookAttempts < 15) {
+              const api = findApiInObject(hook.memoizedState);
+              if (api) {
+                excalidrawApi = api;
+                break;
+              }
+              hook = hook.next;
+              hookAttempts++;
+            }
+            if (excalidrawApi) break;
+          }
+          fiberNode = fiberNode.return;
+          attempts++;
+        }
+        if (excalidrawApi) {
+          ;
+          window.excalidrawAPI = excalidrawApi;
+        }
+        return excalidrawApi;
+      }, createFullElement = function(skeleton) {
+        const id = skeleton.id || Math.random().toString(36).substring(2, 9);
+        const el = {
+          seed: Math.floor(Math.random() * 2 ** 31),
+          versionNonce: Math.floor(Math.random() * 2 ** 31),
+          updated: Date.now(),
+          isDeleted: false,
+          fillStyle: "hachure",
+          strokeWidth: 1,
+          strokeStyle: "solid",
+          roughness: 1,
+          opacity: 100,
+          angle: 0,
+          groupIds: [],
+          strokeColor: "#000000",
+          backgroundColor: "transparent",
+          version: 1,
+          locked: false,
+          ...skeleton,
+          id
+        };
+        if (["arrow", "line", "freedraw"].includes(el.type)) {
+          if (!el.points || !Array.isArray(el.points)) {
+            el.points = [[0, 0], [100, 100]];
+          }
+        }
+        return el;
+      };
+      getExcalidrawAPIFromDOM2 = getExcalidrawAPIFromDOM, createFullElement2 = createFullElement;
+      const targetEl = document.querySelector(".excalidraw-app");
+      if (targetEl) getExcalidrawAPIFromDOM(targetEl);
+      const handlers = {
+        getSceneElements: () => {
+          try {
+            return window.excalidrawAPI.getSceneElements();
+          } catch (e) {
+            return { error: true, msg: e.message };
+          }
+        },
+        addElement: (param) => {
+          try {
+            const existing = window.excalidrawAPI.getSceneElements();
+            const newElements = [
+              ...existing,
+              ...param.eles.map((ele, idx) => {
+                const el = createFullElement(ele);
+                el.index = `a${existing.length + idx + 1}`;
+                return el;
+              })
+            ];
+            window.excalidrawAPI.updateScene({ elements: newElements, commitToHistory: true });
+            return { success: true };
+          } catch (e) {
+            return { error: true, msg: e.message };
+          }
+        },
+        deleteElement: (param) => {
+          try {
+            const existing = window.excalidrawAPI.getSceneElements();
+            const idx = existing.findIndex((e) => e.id === param.id);
+            if (idx >= 0) {
+              const newElements = [...existing];
+              newElements.splice(idx, 1);
+              window.excalidrawAPI.updateScene({ elements: newElements, commitToHistory: true });
+              return { success: true };
+            }
+            return { error: true, msg: "element not found" };
+          } catch (e) {
+            return { error: true, msg: e.message };
+          }
+        },
+        updateElement: (param) => {
+          try {
+            const existing = [...window.excalidrawAPI.getSceneElements()];
+            param.forEach((item) => {
+              const idx = existing.findIndex((e) => e.id === item.id);
+              if (idx >= 0) {
+                existing[idx] = {
+                  ...existing[idx],
+                  ...item,
+                  version: (existing[idx].version || 1) + 1,
+                  updated: Date.now()
+                };
+              }
+            });
+            window.excalidrawAPI.updateScene({ elements: existing, commitToHistory: true });
+            return { success: true };
+          } catch (e) {
+            return { error: true, msg: e.message };
+          }
+        },
+        cleanup: () => {
+          try {
+            window.excalidrawAPI.resetScene();
+            return { success: true };
+          } catch (e) {
+            return { error: true, msg: e.message };
+          }
+        }
+      };
+      mcp.registerTool({
+        name: "excalidraw_execute_command",
+        title: "Excalidraw \u753B\u5E03\u64CD\u4F5C",
+        description: "\u6267\u884C\u547D\u4EE4\u4E0E Excalidraw \u753B\u5E03\u4EA4\u4E92\uFF0C\u652F\u6301\u83B7\u53D6/\u6DFB\u52A0/\u66F4\u65B0/\u5220\u9664\u5143\u7D20\u4EE5\u53CA\u6E05\u7A7A\u753B\u5E03\u3002\u4F7F\u7528\u524D\u8BF7\u5148\u9605\u8BFB\u753B\u56FE skill \u6307\u5BFC\u3002",
+        inputSchema: {
+          type: "object",
+          properties: {
+            eventName: {
+              type: "string",
+              description: "\u547D\u4EE4\u7C7B\u578B\uFF1AgetSceneElements-\u83B7\u53D6\u753B\u5E03\u5143\u7D20\uFF0CaddElement-\u6DFB\u52A0\u5143\u7D20\uFF0CupdateElement-\u66F4\u65B0\u5143\u7D20\uFF0CdeleteElement-\u5220\u9664\u5143\u7D20\uFF0Ccleanup-\u6E05\u7A7A\u753B\u5E03"
+            },
+            payload: {
+              type: "string",
+              description: '\u4F20\u7ED9\u547D\u4EE4\u7684\u53C2\u6570\uFF0C\u5FC5\u987B\u662F JSON \u5B57\u7B26\u4E32\u3002addElement \u65F6 payload \u4E3A {"eles": [...\u5143\u7D20\u6570\u7EC4]}\uFF0CupdateElement \u65F6\u4E3A\u5143\u7D20\u6570\u7EC4'
+            }
+          },
+          required: ["eventName"]
+        },
+        execute: async ({ eventName, payload }) => {
+          if (!window.excalidrawAPI) {
+            const el = document.querySelector(".excalidraw-app");
+            if (el) getExcalidrawAPIFromDOM(el);
+          }
+          const handler = handlers[eventName];
+          if (!handler) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({ error: true, msg: `unknown command: ${eventName}. \u53EF\u7528\u547D\u4EE4: ${Object.keys(handlers).join(", ")}` })
+              }]
+            };
+          }
+          const param = JSON.parse(payload || "{}");
+          const result = handler(param);
+          return { content: [{ type: "text", text: JSON.stringify(result) }] };
+        }
+      });
+      window.__webmcptools_excalidraw = true;
+      console.log("[webmcp-tools] excalidraw.com \u5DE5\u5177\u6CE8\u518C\u6210\u529F");
+    } catch (e) {
+      console.error("[webmcp-tools] excalidraw.com \u5DE5\u5177\u6CE8\u518C\u5931\u8D25:", e.message);
+    }
+  }
+  var getExcalidrawAPIFromDOM2;
+  var createFullElement2;
+})();
+})();

package/dist/webmcp-tools/www.baidu.com.js

@@ -0,0 +1,76 @@
+;(function(){
+"use strict";
+(() => {
+  // webmcp-tools/www.baidu.com/index.ts
+  var _baiduMcp = navigator.modelContext;
+  if (!_baiduMcp || typeof _baiduMcp.registerTool !== "function") {
+    console.warn("[webmcp-tools] www.baidu.com: navigator.modelContext.registerTool \u672A\u5C31\u7EEA\uFF0C\u8DF3\u8FC7\u6CE8\u5165");
+  } else if (!window.__webmcptools_baidu) {
+    try {
+      _baiduMcp.registerTool({
+        name: "baidu_search",
+        title: "\u767E\u5EA6\u641C\u7D22",
+        description: "\u5728\u767E\u5EA6\u8F93\u5165\u6846\u4E2D\u8F93\u5165\u5173\u952E\u5B57\u5E76\u6267\u884C\u641C\u7D22\u3002",
+        inputSchema: {
+          type: "object",
+          properties: {
+            keyword: { type: "string", description: "\u8981\u641C\u7D22\u7684\u5173\u952E\u5B57" }
+          },
+          required: ["keyword"]
+        },
+        execute: async ({ keyword }) => {
+          const inputEl = document.querySelector("#kw");
+          const btnEl = document.querySelector("#su");
+          if (!inputEl || !btnEl) {
+            return {
+              content: [{ type: "text", text: "\u672A\u627E\u5230\u767E\u5EA6\u641C\u7D22\u6846\u6216\u641C\u7D22\u6309\u94AE\uFF0C\u53EF\u80FD\u4E0D\u5728\u9996\u9875\u6216\u9875\u9762\u7ED3\u6784\u5DF2\u53D8\u3002" }]
+            };
+          }
+          inputEl.value = keyword;
+          inputEl.dispatchEvent(new Event("input", { bubbles: true }));
+          btnEl.click();
+          return {
+            content: [{ type: "text", text: `\u5DF2\u5728\u767E\u5EA6\u6267\u884C\u641C\u7D22\uFF1A${keyword}` }]
+          };
+        }
+      });
+      _baiduMcp.registerTool({
+        name: "baidu_get_results",
+        title: "\u83B7\u53D6\u767E\u5EA6\u641C\u7D22\u7ED3\u679C",
+        description: "\u83B7\u53D6\u5F53\u524D\u767E\u5EA6\u641C\u7D22\u7ED3\u679C\u9875\u9762\u4E2D\u7684\u641C\u7D22\u7ED3\u679C\u5217\u8868\uFF0C\u5305\u542B\u6807\u9898\u548C\u94FE\u63A5\u3002",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: { type: "string", description: "\u6700\u591A\u8FD4\u56DE\u7684\u7ED3\u679C\u6570\u91CF\uFF0C\u9ED8\u8BA4 10" }
+          },
+          required: []
+        },
+        execute: async ({ limit }) => {
+          const maxCount = parseInt(limit || "10", 10);
+          const results = [];
+          const items = document.querySelectorAll(".result.c-container");
+          items.forEach((item, idx) => {
+            if (idx >= maxCount) return;
+            const titleEl = item.querySelector("h3 a");
+            const summaryEl = item.querySelector(".content-right_8Zs40, .c-abstract, .c-span9");
+            if (titleEl) {
+              results.push({
+                title: titleEl.textContent?.trim() || "",
+                url: titleEl.href || "",
+                summary: summaryEl?.textContent?.trim() || ""
+              });
+            }
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+          };
+        }
+      });
+      window.__webmcptools_baidu = true;
+      console.log("[webmcp-tools] www.baidu.com \u5DE5\u5177\u6CE8\u518C\u6210\u529F");
+    } catch (e) {
+      console.error("[webmcp-tools] www.baidu.com \u5DE5\u5177\u6CE8\u518C\u5931\u8D25:", e.message);
+    }
+  }
+})();
+})();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@opentiny/webmcp-cli",
+  "version": "0.0.1-alpha.0",
+  "type": "module",
+  "description": "WebMCP CLI for AI Agents to interact with browser via Puppeteer",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "webmcp-cli": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "chrome",
+    "puppeteer",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "OpenTiny Team",
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@mcp-b/webmcp-polyfill": "^2.2.0",
+    "@page-agent/page-controller": "^1.7.1",
+    "commander": "^11.1.0",
+    "picocolors": "^1.0.0",
+    "puppeteer-core": "^22.0.0",
+    "@opentiny/next-sdk": "^0.3.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "esbuild": "^0.25.0",
+    "tsup": "^8.0.2",
+    "tsx": "^4.0.0",
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build:inject": "node scripts/build-inject.mjs",
+    "build:tools": "node scripts/build-inject.mjs",
+    "build": "tsup && pnpm run build:inject",
+    "link:global": "npm install -g .",
+    "start": "node dist/bin.js"
+  }
+}