@opentiny/webmcp-cli 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/bin.js

@@ -8,7 +8,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/bin.ts
 import { Command } from "commander";
-import pc3 from "picocolors";
+import pc2 from "picocolors";
 
 // src/browser.ts
 import puppeteer from "puppeteer-core";
@@ -94,31 +94,54 @@ async function killProcessOnPortIfZombie(port) {
   } catch (e) {
   }
 }
-function getDefaultChromePath() {
+function getDefaultBrowserPath() {
   const platform = os.platform();
   if (platform === "darwin") {
-    return "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+    const chromePath = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+    if (fs.existsSync(chromePath)) return { path: chromePath, name: "Chrome" };
+    const edgePath = "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge";
+    if (fs.existsSync(edgePath)) return { path: edgePath, name: "Edge" };
+    return null;
   } else if (platform === "win32") {
-    const paths = [
+    const chromePaths = [
       process.env.LOCALAPPDATA + "\\Google\\Chrome\\Application\\chrome.exe",
       process.env.PROGRAMFILES + "\\Google\\Chrome\\Application\\chrome.exe",
       process.env["PROGRAMFILES(X86)"] + "\\Google\\Chrome\\Application\\chrome.exe"
     ];
-    return paths.find((p) => fs.existsSync(p)) || null;
+    const foundChrome = chromePaths.find((p) => fs.existsSync(p));
+    if (foundChrome) return { path: foundChrome, name: "Chrome" };
+    const edgePaths = [
+      process.env.LOCALAPPDATA + "\\Microsoft\\Edge\\Application\\msedge.exe",
+      process.env.PROGRAMFILES + "\\Microsoft\\Edge\\Application\\msedge.exe",
+      process.env["PROGRAMFILES(X86)"] + "\\Microsoft\\Edge\\Application\\msedge.exe",
+      "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe",
+      "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe"
+    ];
+    const foundEdge = edgePaths.find((p) => fs.existsSync(p));
+    if (foundEdge) return { path: foundEdge, name: "Edge" };
+    return null;
   } else {
-    const paths = ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/chromium", "/usr/bin/chromium-browser"];
-    return paths.find((p) => fs.existsSync(p)) || null;
+    const paths = [
+      { p: "/usr/bin/google-chrome", name: "Chrome" },
+      { p: "/usr/bin/google-chrome-stable", name: "Chrome" },
+      { p: "/usr/bin/chromium", name: "Chromium" },
+      { p: "/usr/bin/chromium-browser", name: "Chromium" },
+      { p: "/usr/bin/microsoft-edge", name: "Edge" },
+      { p: "/usr/bin/microsoft-edge-stable", name: "Edge" }
+    ];
+    const found = paths.find(({ p }) => fs.existsSync(p));
+    return found ? { path: found.p, name: found.name } : null;
   }
 }
-async function startChromeInBackground() {
-  const chromePath = getDefaultChromePath();
-  if (!chromePath || !fs.existsSync(chromePath)) {
-    throw new Error("\u65E0\u6CD5\u5728\u7CFB\u7EDF\u4E2D\u627E\u5230 Chrome \u6D4F\u89C8\u5668\u7684\u9ED8\u8BA4\u5B89\u88C5\u8DEF\u5F84\u3002");
+async function startBrowserInBackground() {
+  const browserInfo = getDefaultBrowserPath();
+  if (!browserInfo || !fs.existsSync(browserInfo.path)) {
+    throw new Error("\u65E0\u6CD5\u5728\u7CFB\u7EDF\u4E2D\u627E\u5230 Chrome \u6216 Edge \u6D4F\u89C8\u5668\u7684\u9ED8\u8BA4\u5B89\u88C5\u8DEF\u5F84\u3002");
   }
-  console.log(pc.yellow(`\u6B63\u5728\u542F\u52A8\u540E\u53F0 Chrome \u5B9E\u4F8B (\u7AEF\u53E3: ${CDP_PORT})...`));
+  console.log(pc.yellow(`\u6B63\u5728\u542F\u52A8\u540E\u53F0 ${browserInfo.name} \u5B9E\u4F8B (\u7AEF\u53E3: ${CDP_PORT})...`));
   const userDataDir = process.env.WEBMCP_WORKSPACE || path.join(os.homedir(), ".webmcp_chrome_profile");
   const child = spawn(
-    chromePath,
+    browserInfo.path,
     [
       `--remote-debugging-port=${CDP_PORT}`,
       `--user-data-dir=${userDataDir}`,
@@ -138,7 +161,7 @@ async function startChromeInBackground() {
         try {
           const response = await fetchWithTimeout(url, 1e3);
           if (response.ok) {
-            console.log(pc.green("Chrome \u542F\u52A8\u5E76\u5C31\u7EEA\u3002"));
+            console.log(pc.green(`${browserInfo.name} \u542F\u52A8\u5E76\u5C31\u7EEA\u3002`));
             return;
           }
         } catch (err) {
@@ -148,7 +171,7 @@ async function startChromeInBackground() {
     }
     await new Promise((resolve) => setTimeout(resolve, 500));
   }
-  throw new Error("Chrome \u542F\u52A8\u8D85\u65F6\uFF0C\u65E0\u6CD5\u8FDE\u63A5\u5230 CDP \u7AEF\u53E3\u3002");
+  throw new Error(`${browserInfo.name} \u542F\u52A8\u8D85\u65F6\uFF0C\u65E0\u6CD5\u8FDE\u63A5\u5230 CDP \u7AEF\u53E3\u3002`);
 }
 async function connectBrowser() {
   const targetFilter = (target) => {
@@ -173,7 +196,7 @@ async function connectBrowser() {
       throw new Error("127.0.0.1 CDP port not responding");
     }
     console.log(pc.yellow("connectBrowser: \u6B63\u5728\u5C1D\u8BD5\u8FDE\u63A5 127.0.0.1:9222..."));
-    const browser = await promiseWithTimeout(
+    const browser2 = await promiseWithTimeout(
       puppeteer.connect({
         browserURL: `http://127.0.0.1:${CDP_PORT}`,
         defaultViewport: null,
@@ -183,7 +206,7 @@ async function connectBrowser() {
       "puppeteer.connect to 127.0.0.1 timed out"
     );
     console.log(pc.green("connectBrowser: \u6210\u529F\u8FDE\u63A5 127.0.0.1:9222"));
-    return browser;
+    return browser2;
   } catch (error) {
     try {
       const isLocalhostReady = await checkCdpReady(`http://localhost:${CDP_PORT}/json/version`, 3);
@@ -191,7 +214,7 @@ async function connectBrowser() {
         throw new Error("localhost CDP port not responding");
       }
       console.log(pc.yellow("connectBrowser: \u6B63\u5728\u5C1D\u8BD5\u8FDE\u63A5 localhost:9222..."));
-      const browser = await promiseWithTimeout(
+      const browser2 = await promiseWithTimeout(
         puppeteer.connect({
           browserURL: `http://localhost:${CDP_PORT}`,
           defaultViewport: null,
@@ -201,19 +224,19 @@ async function connectBrowser() {
         "puppeteer.connect to localhost timed out"
       );
       console.log(pc.green("connectBrowser: \u6210\u529F\u8FDE\u63A5 localhost:9222"));
-      return browser;
+      return browser2;
     } catch (error2) {
       console.log(pc.yellow(`connectBrowser: \u8FDE\u63A5\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u5524\u8D77\u6D4F\u89C8\u5668\u3002\u9519\u8BEF\u539F\u56E0: ${error2 instanceof Error ? error2.message : String(error2)}`));
       try {
         await killProcessOnPortIfZombie(CDP_PORT);
-        await startChromeInBackground();
+        await startBrowserInBackground();
         try {
           const is127Ready = await checkCdpReady(`http://127.0.0.1:${CDP_PORT}/json/version`, 3);
           if (!is127Ready) {
             throw new Error("127.0.0.1 CDP port not responding after launch");
           }
           console.log(pc.yellow("connectBrowser: \u6D4F\u89C8\u5668\u5DF2\u542F\u52A8\uFF0C\u6B63\u5728\u5C1D\u8BD5\u8FDE\u63A5 127.0.0.1:9222..."));
-          const browser = await promiseWithTimeout(
+          const browser2 = await promiseWithTimeout(
             puppeteer.connect({
               browserURL: `http://127.0.0.1:${CDP_PORT}`,
               defaultViewport: null,
@@ -223,14 +246,14 @@ async function connectBrowser() {
             "puppeteer.connect to 127.0.0.1 after launch timed out"
           );
           console.log(pc.green("connectBrowser: \u6210\u529F\u8FDE\u63A5 127.0.0.1:9222"));
-          return browser;
+          return browser2;
         } catch (e) {
           const isLocalhostReady = await checkCdpReady(`http://localhost:${CDP_PORT}/json/version`, 3);
           if (!isLocalhostReady) {
             throw new Error("localhost CDP port not responding after launch");
           }
           console.log(pc.yellow("connectBrowser: \u6B63\u5728\u5C1D\u8BD5\u8FDE\u63A5 localhost:9222..."));
-          const browser = await promiseWithTimeout(
+          const browser2 = await promiseWithTimeout(
             puppeteer.connect({
               browserURL: `http://localhost:${CDP_PORT}`,
               defaultViewport: null,
@@ -240,20 +263,20 @@ async function connectBrowser() {
             "puppeteer.connect to localhost after launch timed out"
           );
           console.log(pc.green("connectBrowser: \u6210\u529F\u8FDE\u63A5 localhost:9222"));
-          return browser;
+          return browser2;
         }
       } catch (launchError) {
         const msg = launchError instanceof Error ? launchError.message : String(launchError);
         console.error(pc.red(`\u65E0\u6CD5\u8FDE\u63A5\u6216\u542F\u52A8\u6D4F\u89C8\u5668: ${msg}`));
-        console.error(pc.yellow(`\u{1F4A1} \u63D0\u793A\uFF1A\u7531\u4E8E\u6211\u4EEC\u8981\u4F7F\u7528\u4F60\u65E5\u5E38\u7684\u9ED8\u8BA4\u6D4F\u89C8\u5668\uFF08\u5305\u542B\u4F60\u7684\u4E66\u7B7E and \u767B\u5F55\u6001\uFF09\uFF0C\u5982\u679C\u4F60\u7684 Chrome \u76EE\u524D\u6B63\u5904\u4E8E\u6253\u5F00\u72B6\u6001\uFF0C\u5B83\u4F1A\u62D2\u7EDD\u4F7F\u7528\u5E26\u6709\u8C03\u8BD5\u7AEF\u53E3\u7684\u65B0\u53C2\u6570\u542F\u52A8\u3002`));
-        console.error(pc.yellow(`\u{1F449} \u89E3\u51B3\u529E\u6CD5\uFF1A\u8BF7\u5148\u5B8C\u5168\u9000\u51FA\u5F53\u524D\u7684 Chrome \u6D4F\u89C8\u5668\uFF08\u5728 Mac \u4E0A\u6309 Cmd+Q\uFF09\uFF0C\u7136\u540E\u518D\u91CD\u65B0\u8FD0\u884C\u547D\u4EE4\u3002`));
+        console.error(pc.yellow(`\u{1F4A1} \u63D0\u793A\uFF1A\u7531\u4E8E\u6211\u4EEC\u8981\u4F7F\u7528\u4F60\u65E5\u5E38\u7684\u9ED8\u8BA4\u6D4F\u89C8\u5668\uFF08\u5305\u542B\u4F60\u7684\u4E66\u7B7E\u548C\u767B\u5F55\u6001\uFF09\uFF0C\u5982\u679C\u4F60\u7684 Chrome/Edge \u76EE\u524D\u6B63\u5904\u4E8E\u6253\u5F00\u72B6\u6001\uFF0C\u5B83\u4F1A\u62D2\u7EDD\u4F7F\u7528\u5E26\u6709\u8C03\u8BD5\u7AEF\u53E3\u7684\u65B0\u53C2\u6570\u542F\u52A8\u3002`));
+        console.error(pc.yellow(`\u{1F449} \u89E3\u51B3\u529E\u6CD5\uFF1A\u8BF7\u5148\u5B8C\u5168\u9000\u51FA\u5F53\u524D\u7684 Chrome \u6216 Edge \u6D4F\u89C8\u5668\uFF08\u5728 Mac \u4E0A\u6309 Cmd+Q\uFF0CWindows \u4E0A\u53F3\u952E\u4EFB\u52A1\u680F\u56FE\u6807\u9000\u51FA\uFF09\uFF0C\u7136\u540E\u518D\u91CD\u65B0\u8FD0\u884C\u547D\u4EE4\u3002`));
         throw new Error("Browser connection failed.");
       }
     }
   }
 }
-async function getPageTargetId(page) {
-  const session = await page.target().createCDPSession();
+async function getPageTargetId(page2) {
+  const session = await page2.target().createCDPSession();
   try {
     const { targetInfo } = await session.send("Target.getTargetInfo");
     return targetInfo.targetId;
@@ -262,9 +285,8 @@ async function getPageTargetId(page) {
     });
   }
 }
-async function getTargetPage(browser, tabid) {
-  const targets = browser.targets();
-  const pageTargets = targets.filter((t) => {
+function getPageTargets(browser2) {
+  return browser2.targets().filter((t) => {
     try {
       const type = (typeof t.type === "function" ? t.type() : t.type) || "";
       const url = (typeof t.url === "function" ? t.url() : t.url) || "";
@@ -273,23 +295,53 @@ async function getTargetPage(browser, tabid) {
       return false;
     }
   });
+}
+function getTargetIdFromTarget(target) {
+  return typeof target._getTargetInfo === "function" ? target._getTargetInfo().targetId : target._targetId || target.targetId || "";
+}
+function findPageTargetByTabId(browser2, tabid2) {
+  const pageTargets = getPageTargets(browser2);
+  return pageTargets.find((t) => {
+    const tid = getTargetIdFromTarget(t);
+    return tid === tabid2 || tid.includes(tabid2);
+  }) ?? null;
+}
+async function activateTabById(browser2, tabid2) {
+  const target = findPageTargetByTabId(browser2, tabid2);
+  if (!target) {
+    throw new Error(`Tab with targetId "${tabid2}" not found.`);
+  }
+  const realTabId = getTargetIdFromTarget(target);
+  const pages = await browser2.pages();
+  let sessionPage = pages.find((p) => !p.url().startsWith("devtools://"));
+  if (!sessionPage && pages.length > 0) {
+    sessionPage = pages[0];
+  }
+  if (!sessionPage) {
+    sessionPage = await browser2.newPage();
+  }
+  const session = await sessionPage.createCDPSession();
+  try {
+    await session.send("Target.activateTarget", { targetId: realTabId });
+  } finally {
+    await session.detach().catch(() => {
+    });
+  }
+}
+async function getTargetPage(browser2, tabid2) {
+  const pageTargets = getPageTargets(browser2);
   if (pageTargets.length === 0) {
-    const newPage = await browser.newPage();
+    const newPage = await browser2.newPage();
     await injectWebMCPPolyfillAndTools(newPage);
     return newPage;
   }
   let targetPage = null;
-  if (tabid !== void 0) {
-    for (const target of pageTargets) {
-      const tid = typeof target._getTargetInfo === "function" ? target._getTargetInfo().targetId : target._targetId || target.targetId || "";
-      if (tid === tabid || tid.includes(tabid)) {
-        targetPage = await target.page();
-        break;
-      }
-    }
-    if (!targetPage) {
-      throw new Error(`Tab with targetId "${tabid}" not found.`);
+  if (tabid2 !== void 0) {
+    const target = findPageTargetByTabId(browser2, tabid2);
+    if (!target) {
+      throw new Error(`Tab with targetId "${tabid2}" not found.`);
     }
+    targetPage = await target.page();
   } else {
     try {
       const urls = [
@@ -313,8 +365,7 @@ async function getTargetPage(browser, tabid) {
       }
       if (activeTargetId) {
         for (const target of pageTargets) {
-          const tid = typeof target._getTargetInfo === "function" ? target._getTargetInfo().targetId : target._targetId || target.targetId || "";
-          if (tid === activeTargetId) {
+          if (getTargetIdFromTarget(target) === activeTargetId) {
             targetPage = await target.page();
             break;
           }
@@ -333,11 +384,11 @@ async function getTargetPage(browser, tabid) {
   await injectWebMCPPolyfillAndTools(targetPage);
   return targetPage;
 }
-async function injectIntoPage(page) {
-  await injectWebMCPPolyfillAndTools(page, true);
+async function injectIntoPage(page2) {
+  await injectWebMCPPolyfillAndTools(page2, true);
 }
-async function injectWebMCPPolyfillAndTools(page, force = false) {
-  const polyfillReady = !force && await page.evaluate(() => {
+async function injectWebMCPPolyfillAndTools(page2, force = false) {
+  const polyfillReady = !force && await page2.evaluate(() => {
     return !!window.__webmcpcli_init;
   }).catch(() => false);
   if (!polyfillReady) {
@@ -348,19 +399,19 @@ async function injectWebMCPPolyfillAndTools(page, force = false) {
     }
     const scriptContent = fs.readFileSync(injectScriptPath, "utf-8");
     try {
-      await page.evaluate(scriptContent);
+      await page2.evaluate(scriptContent);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error("\u81EA\u52A8\u6CE8\u5165\u811A\u672C\u6267\u884C\u5931\u8D25: " + msg);
     }
     await new Promise((resolve) => setTimeout(resolve, 300));
   }
-  await injectDomainTools(page);
+  await injectDomainTools(page2);
 }
-async function injectDomainTools(page) {
+async function injectDomainTools(page2) {
   let hostname;
   try {
-    const url = new URL(page.url());
+    const url = new URL(page2.url());
     hostname = url.hostname;
   } catch {
     return;
@@ -372,7 +423,7 @@ async function injectDomainTools(page) {
   console.log(pc.cyan(`\u68C0\u6D4B\u5230\u57DF\u540D ${hostname} \u6709\u9884\u7F6E\u5DE5\u5177\uFF0C\u6B63\u5728\u6CE8\u5165...`));
   const toolScript = fs.readFileSync(toolBundlePath, "utf-8");
   try {
-    await page.evaluate(toolScript);
+    await page2.evaluate(toolScript);
     console.log(pc.green(`\u5DF2\u4E3A ${hostname} \u6CE8\u5165\u9884\u7F6E\u5DE5\u5177`));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -381,11 +432,12 @@ async function injectDomainTools(page) {
 }
 
 // src/commands/state.ts
-async function stateCommand({ tabid }) {
-  const browser = await connectBrowser();
+async function stateCommand({ tabid: tabid2 }) {
+  const browser2 = await connectBrowser();
   try {
-    const page = await getTargetPage(browser, tabid);
-    const state = await page.evaluate(async () => {
+    const page2 = await getTargetPage(browser2, tabid2);
+    await injectIntoPage(page2);
+    const state = await page2.evaluate(async () => {
       const url = document.URL;
       const title = document.title;
       const mcp = navigator.modelContextTesting || navigator.modelContext;
@@ -433,27 +485,29 @@ async function stateCommand({ tabid }) {
         webmcpTools
       };
     });
-    const pages = await browser.pages();
-    const tabs = await Promise.all(pages.map(async (p) => {
-      const pUrl = p.url();
-      if (pUrl.startsWith("devtools://")) return null;
-      const pTitle = await Promise.race([
-        p.title().catch(() => "Unknown"),
-        new Promise((resolve) => setTimeout(() => resolve("Unknown"), 500))
-      ]);
-      return {
-        // 使用真实的 Chrome target ID，而非数组下标
-        tabid: await getPageTargetId(p).catch(() => pUrl),
-        title: pTitle,
-        url: pUrl
-      };
-    }));
+    const pages = await browser2.pages();
+    const tabs2 = await Promise.all(
+      pages.map(async (p) => {
+        const pUrl = p.url();
+        if (pUrl.startsWith("devtools://")) return null;
+        const pTitle = await Promise.race([
+          p.title().catch(() => "Unknown"),
+          new Promise((resolve) => setTimeout(() => resolve("Unknown"), 500))
+        ]);
+        return {
+          // 使用真实的 Chrome target ID，而非数组下标
+          tabid: await getPageTargetId(p).catch(() => pUrl),
+          title: pTitle,
+          url: pUrl
+        };
+      })
+    );
     return {
       ...state,
-      tabs: tabs.filter(Boolean)
+      tabs: tabs2.filter(Boolean)
     };
   } finally {
-    await browser.disconnect();
+    await browser2.disconnect();
   }
 }
 
@@ -461,17 +515,17 @@ async function stateCommand({ tabid }) {
 async function runCommand({
   toolName,
   argsJson,
-  tabid
+  tabid: tabid2
 }) {
-  const browser = await connectBrowser();
+  const browser2 = await connectBrowser();
   try {
-    const page = await getTargetPage(browser, tabid);
+    const page2 = await getTargetPage(browser2, tabid2);
     try {
       JSON.parse(argsJson);
     } catch (e) {
       throw new Error(`\u53C2\u6570\u4E0D\u662F\u6709\u6548\u7684 JSON: ${e.message}`);
     }
-    const result = await page.evaluate(async (name, inputString) => {
+    const result2 = await page2.evaluate(async (name, inputString) => {
       const mcp = navigator.modelContextTesting || navigator.modelContext;
       if (!mcp || typeof mcp.executeTool !== "function") {
         throw new Error("\u5F53\u524D\u9875\u9762\u6CA1\u6709\u6CE8\u5165 WebMCP \u73AF\u5883 (navigator.modelContextTesting.executeTool \u672A\u627E\u5230)");
@@ -485,69 +539,216 @@ async function runCommand({
       }
       return res;
     }, toolName, argsJson);
-    return result;
+    return result2;
   } finally {
-    await browser.disconnect();
+    await browser2.disconnect();
   }
 }
 
-// src/commands/open.ts
-import pc2 from "picocolors";
-async function openCommand(url, { tabid, newTab }) {
+// src/commands/evaluate.ts
+async function evaluateCommand({
+  jsScript,
+  tabid
+}) {
   const browser = await connectBrowser();
   try {
-    let page;
-    if (newTab) {
-      console.log(pc2.yellow("openCommand: \u6B63\u5728\u521B\u5EFA\u65B0\u9875\u9762..."));
-      page = await browser.newPage();
-    } else {
-      console.log(pc2.yellow("openCommand: \u83B7\u53D6\u6D4F\u89C8\u5668 targets..."));
-      const targets = browser.targets();
-      const pageTargets = targets.filter((t) => {
-        try {
-          const type = (typeof t.type === "function" ? t.type() : t.type) || "";
-          const urlStr = (typeof t.url === "function" ? t.url() : t.url) || "";
-          return type === "page" && !urlStr.startsWith("devtools://");
-        } catch {
-          return false;
+    const page = await getTargetPage(browser, tabid);
+    const result = await page.evaluate(async (script) => {
+      try {
+        const result = eval(script);
+        if (result instanceof Promise) {
+          return await result;
         }
-      });
-      console.log(pc2.yellow(`openCommand: \u666E\u901A\u9875\u9762 targets \u6570\u91CF: ${pageTargets.length}`));
-      let selectedTarget;
-      if (tabid !== void 0) {
-        console.log(pc2.yellow(`openCommand: \u6B63\u5728\u5339\u914D\u6307\u5B9A\u7684 tabid: ${tabid}...`));
-        selectedTarget = pageTargets.find((t) => {
-          const tid = typeof t._getTargetInfo === "function" ? t._getTargetInfo().targetId : t._targetId || t.targetId || "";
-          return tid === tabid || tid.includes(tabid);
-        });
-      }
-      if (selectedTarget) {
-        console.log(pc2.yellow("openCommand: \u6B63\u5728\u5C06\u5339\u914D\u7684 target \u8F6C\u6362\u4E3A page..."));
-        page = await selectedTarget.page();
-      } else if (pageTargets.length > 0) {
-        console.log(pc2.yellow("openCommand: \u6B63\u5728\u5C06\u6700\u540E\u4E00\u4E2A target \u8F6C\u6362\u4E3A page..."));
-        page = await pageTargets[pageTargets.length - 1].page();
-      }
-      if (!page) {
-        console.log(pc2.yellow("openCommand: \u6CA1\u6709\u627E\u5230\u53EF\u7528 page\uFF0C\u6B63\u5728\u521B\u5EFA\u65B0\u9875\u9762..."));
-        page = await browser.newPage();
+        return result;
+      } catch (error) {
+        return {
+          error: true,
+          message: error.message,
+          stack: error.stack
+        };
       }
+    }, jsScript);
+    return result;
+  } finally {
+    await browser.disconnect();
+  }
+}
+
+// src/commands/clipboard.ts
+import clipboard from "clipboardy";
+async function setClipboard(content) {
+  try {
+    await clipboard.write(content);
+  } catch (error) {
+    throw new Error(`\u8BBE\u7F6E\u526A\u8D34\u677F\u5931\u8D25: ${error.message}`);
+  }
+}
+
+// src/commands/tabs.ts
+function normalizeUrl(url) {
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    return "https://" + url;
+  }
+  return url;
+}
+async function tabsOpenCommand(url) {
+  const browser2 = await connectBrowser();
+  try {
+    const page2 = await browser2.newPage();
+    url = normalizeUrl(url);
+    await page2.goto(url, { waitUntil: "domcontentloaded" });
+    await injectIntoPage(page2);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    return {
+      success: true,
+      tabid: await getPageTargetId(page2),
+      url: page2.url(),
+      title: await page2.title()
+    };
+  } finally {
+    await browser2.disconnect();
+  }
+}
+async function tabsCloseCommand(tabid2) {
+  const browser2 = await connectBrowser();
+  try {
+    const target = findPageTargetByTabId(browser2, tabid2);
+    if (!target) {
+      throw new Error(`Tab with targetId "${tabid2}" not found.`);
     }
-    if (!url.startsWith("http://") && !url.startsWith("https://")) {
-      url = "https://" + url;
+    const page2 = await target.page();
+    if (!page2) {
+      throw new Error(`Tab with targetId "${tabid2}" not found.`);
     }
-    console.log(pc2.cyan(`\u6B63\u5728\u6253\u5F00: ${url}`));
-    await page.goto(url, { waitUntil: "domcontentloaded" });
-    await injectIntoPage(page);
+    const closedTabid = await getPageTargetId(page2).catch(() => tabid2);
+    await page2.close();
     return {
       success: true,
-      url: page.url(),
-      title: await page.title()
+      tabid: closedTabid
     };
   } finally {
-    await browser.disconnect();
+    await browser2.disconnect();
+  }
+}
+async function tabsSwitchCommand(tabid2) {
+  const browser2 = await connectBrowser();
+  try {
+    await activateTabById(browser2, tabid2);
+    const page2 = await getTargetPage(browser2, tabid2);
+    return {
+      success: true,
+      tabid: await getPageTargetId(page2),
+      url: page2.url(),
+      title: await page2.title()
+    };
+  } finally {
+    await browser2.disconnect();
+  }
+}
+async function tabsBackCommand(tabid2) {
+  const browser2 = await connectBrowser();
+  try {
+    const page2 = await getTargetPage(browser2, tabid2);
+    const response = await page2.goBack();
+    if (!response) {
+      return {
+        success: false,
+        error: "\u65E0\u6CD5\u540E\u9000\uFF1A\u5DF2\u5728\u5386\u53F2\u8BB0\u5F55\u8D77\u70B9",
+        tabid: await getPageTargetId(page2).catch(() => tabid2),
+        url: page2.url(),
+        title: await page2.title()
+      };
+    }
+    await injectIntoPage(page2);
+    return {
+      success: true,
+      tabid: await getPageTargetId(page2),
+      url: page2.url(),
+      title: await page2.title()
+    };
+  } finally {
+    await browser2.disconnect();
   }
 }
+async function tabsForwardCommand(tabid2) {
+  const browser2 = await connectBrowser();
+  try {
+    const page2 = await getTargetPage(browser2, tabid2);
+    const response = await page2.goForward();
+    if (!response) {
+      return {
+        success: false,
+        error: "\u65E0\u6CD5\u524D\u8FDB\uFF1A\u5DF2\u5728\u5386\u53F2\u8BB0\u5F55\u672B\u5C3E",
+        tabid: await getPageTargetId(page2).catch(() => tabid2),
+        url: page2.url(),
+        title: await page2.title()
+      };
+    }
+    await injectIntoPage(page2);
+    return {
+      success: true,
+      tabid: await getPageTargetId(page2),
+      url: page2.url(),
+      title: await page2.title()
+    };
+  } finally {
+    await browser2.disconnect();
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@opentiny/webmcp-cli",
+  version: "0.0.1-alpha.3",
+  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"
+  ],
+  scripts: {
+    dev: "tsup --watch",
+    "build:inject": "node scripts/build-inject.mjs",
+    build: "tsup && pnpm run build:inject",
+    prepublishOnly: "pnpm run build",
+    "link:global": "npm install -g .",
+    start: "node dist/bin.js"
+  },
+  keywords: [
+    "chrome",
+    "puppeteer",
+    "cli"
+  ],
+  license: "MIT",
+  author: "OpenTiny Team",
+  engines: {
+    node: ">=16"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  dependencies: {
+    "@mcp-b/webmcp-polyfill": "catalog:",
+    "@opentiny/next-sdk": "workspace:^",
+    "@page-agent/page-controller": "catalog:",
+    clipboardy: "^5.3.1",
+    commander: "^11.1.0",
+    picocolors: "^1.0.0",
+    "puppeteer-core": "^22.0.0"
+  },
+  devDependencies: {
+    "@types/node": "^20.0.0",
+    esbuild: "^0.25.0",
+    tsup: "^8.0.2",
+    tsx: "^4.0.0",
+    typescript: "^5.3.3"
+  }
+};
 
 // src/bin.ts
 var program = new Command();
@@ -555,7 +756,12 @@ function parseTabId(id) {
   if (!id) return void 0;
   return id;
 }
-program.name("webmcp-cli").description("WebMCP CLI for interacting with browser via CDP").version("1.0.0").option("-w, --workspace <path>", "\u6307\u5B9A\u81EA\u5B9A\u4E49\u7684\u6D4F\u89C8\u5668\u5DE5\u4F5C\u7A7A\u95F4\uFF08\u7528\u6237\u914D\u7F6E\u76EE\u5F55\uFF09\u8DEF\u5F84").hook("preAction", (thisCommand) => {
+function handleCommandError(error, commandName) {
+  const msg = error instanceof Error ? error.message : String(error);
+  console.error(pc2.red(`Error executing ${commandName} command: ${msg}`));
+  process.exit(1);
+}
+program.name("webmcp-cli").description("WebMCP CLI for interacting with browser via CDP").version(package_default.version).option("-w, --workspace <path>", "\u6307\u5B9A\u81EA\u5B9A\u4E49\u7684\u6D4F\u89C8\u5668\u5DE5\u4F5C\u7A7A\u95F4\uFF08\u7528\u6237\u914D\u7F6E\u76EE\u5F55\uFF09\u8DEF\u5F84").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.workspace) {
     process.env.WEBMCP_WORKSPACE = opts.workspace;
@@ -563,39 +769,82 @@ program.name("webmcp-cli").description("WebMCP CLI for interacting with browser
 });
 program.command("state").description("\u83B7\u53D6\u6D4F\u89C8\u5668\u5F53\u524D\u9875\u7B7E\u6216\u6307\u5B9A\u9875\u7B7E\u7684\u72B6\u6001\uFF08\u5185\u5BB9\u3001\u6240\u6709\u9875\u7B7E\u5217\u8868\u3001\u53EF\u7528 WebMCP \u5DE5\u5177\u5217\u8868\uFF09").option("-t, --tabid <id>", "\u6307\u5B9A\u9875\u7B7E\u7684 ID").action(async (options) => {
   try {
-    const result = await stateCommand({ tabid: parseTabId(options.tabid) });
-    console.log(JSON.stringify(result, null, 2));
+    const result2 = await stateCommand({ tabid: parseTabId(options.tabid) });
+    console.log(JSON.stringify(result2, null, 2));
   } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    console.error(pc3.red(`Error executing state command: ${msg}`));
-    process.exit(1);
+    handleCommandError(error, "state");
   }
 });
 program.command("run <toolName> <argsJson>").description("\u5411\u6307\u5B9A\u9875\u7B7E\u8C03\u7528\u6307\u5B9A\u7684 WebMCP \u5DE5\u5177\u6267\u884C\u64CD\u4F5C").option("-t, --tabid <id>", "\u6307\u5B9A\u9875\u7B7E\u7684 ID").action(async (toolName, argsJson, options) => {
   try {
-    const result = await runCommand({
+    const result2 = await runCommand({
       toolName,
       argsJson,
       tabid: parseTabId(options.tabid)
     });
-    console.log(JSON.stringify(result, null, 2));
+    console.log(JSON.stringify(result2, null, 2));
   } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    console.error(pc3.red(`Error executing run command: ${msg}`));
-    process.exit(1);
+    handleCommandError(error, "run");
   }
 });
-program.command("open <url>").description("\u5728\u5F53\u524D\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u6307\u5B9A\u7F51\u9875").option("-t, --tabid <id>", "\u5728\u6307\u5B9A\u9875\u7B7E\u4E2D\u6253\u5F00").option("-n, --new-tab", "\u5728\u4E00\u4E2A\u5168\u65B0\u7684\u9875\u7B7E\u4E2D\u6253\u5F00").action(async (url, options) => {
+program.command("evaluate <jsScript>").description("\u5411\u5F53\u524D\u7F51\u9875\u6216\u6307\u5B9A\u9875\u7B7E\u6CE8\u5165\u5E76\u6267\u884C JavaScript \u4EE3\u7801").option("-t, --tabid <id>", "\u6307\u5B9A\u9875\u7B7E\u7684 ID").action(async (jsScript2, options) => {
   try {
-    const result = await openCommand(url, {
-      tabid: parseTabId(options.tabid),
-      newTab: options.newTab
+    const result2 = await evaluateCommand({
+      jsScript: jsScript2,
+      tabid: parseTabId(options.tabid)
     });
-    console.log(JSON.stringify(result, null, 2));
+    console.log(JSON.stringify(result2, null, 2));
+  } catch (error) {
+    handleCommandError(error, "evaluate");
+  }
+});
+program.command("clipboard <content>").description("\u5C06\u5185\u5BB9\u8BBE\u7F6E\u5230\u7CFB\u7EDF\u526A\u8D34\u677F").action(async (content) => {
+  try {
+    await setClipboard(content);
+    console.log(JSON.stringify({ success: true, message: "\u5185\u5BB9\u5DF2\u8BBE\u7F6E\u5230\u7CFB\u7EDF\u526A\u8D34\u677F" }, null, 2));
+  } catch (error) {
+    handleCommandError(error, "clipboard");
+  }
+});
+var tabs = program.command("tabs").description("\u7BA1\u7406\u6D4F\u89C8\u5668\u6807\u7B7E\u9875");
+tabs.command("open <url>").description("\u6253\u5F00\u65B0\u7F51\u9875").action(async (url) => {
+  try {
+    const result2 = await tabsOpenCommand(url);
+    console.log(JSON.stringify(result2, null, 2));
+  } catch (error) {
+    handleCommandError(error, "tabs open");
+  }
+});
+tabs.command("close <tabid>").description("\u5173\u95ED\u6307\u5B9A tabid \u7684\u6807\u7B7E\u9875").action(async (tabid2) => {
+  try {
+    const result2 = await tabsCloseCommand(tabid2);
+    console.log(JSON.stringify(result2, null, 2));
+  } catch (error) {
+    handleCommandError(error, "tabs close");
+  }
+});
+tabs.command("switch <tabid>").description("\u6FC0\u6D3B\u5E76\u5207\u6362\u5230\u6307\u5B9A tabid \u7684\u6807\u7B7E\u9875").action(async (tabid2) => {
+  try {
+    const result2 = await tabsSwitchCommand(tabid2);
+    console.log(JSON.stringify(result2, null, 2));
+  } catch (error) {
+    handleCommandError(error, "tabs switch");
+  }
+});
+tabs.command("back [tabid]").description("\u5C06\u5F53\u524D\u6216\u6307\u5B9A\u6807\u7B7E\u9875\u5BFC\u822A\u540E\u9000\u4E00\u6B65").action(async (tabid2) => {
+  try {
+    const result2 = await tabsBackCommand(parseTabId(tabid2));
+    console.log(JSON.stringify(result2, null, 2));
+  } catch (error) {
+    handleCommandError(error, "tabs back");
+  }
+});
+tabs.command("forward [tabid]").description("\u5C06\u5F53\u524D\u6216\u6307\u5B9A\u6807\u7B7E\u9875\u5BFC\u822A\u524D\u8FDB\u4E00\u6B65").action(async (tabid2) => {
+  try {
+    const result2 = await tabsForwardCommand(parseTabId(tabid2));
+    console.log(JSON.stringify(result2, null, 2));
   } catch (error) {
-    const msg = error instanceof Error ? error.message : String(error);
-    console.error(pc3.red(`Error executing open command: ${msg}`));
-    process.exit(1);
+    handleCommandError(error, "tabs forward");
   }
 });
 program.parse(process.argv);