@opentiny/webmcp-cli 0.0.1-alpha.0 → 0.0.1-alpha.2

package/dist/bin.js

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/bin.ts
 import { Command } from "commander";
-import pc3 from "picocolors";
+import pc2 from "picocolors";
 
 // src/browser.ts
 import puppeteer from "puppeteer-core";
@@ -16,6 +22,78 @@ var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 var CDP_PORT = 9222;
 var CDP_URL = `http://localhost:${CDP_PORT}`;
+async function fetchWithTimeout(url, timeoutMs = 1500) {
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(id);
+  }
+}
+function promiseWithTimeout(promise, timeoutMs = 5e3, errorMsg = "Operation timed out") {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(errorMsg));
+    }, timeoutMs);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    clearTimeout(timeoutId);
+  });
+}
+async function checkCdpReady(url, retries = 3) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      const res = await fetchWithTimeout(url, 1500);
+      if (res.ok) return true;
+    } catch {
+    }
+    if (i < retries - 1) {
+      await new Promise((r) => setTimeout(r, 200));
+    }
+  }
+  return false;
+}
+async function killProcessOnPortIfZombie(port) {
+  const isResponding = await checkCdpReady(`http://127.0.0.1:${port}/json/version`, 1);
+  if (isResponding) {
+    console.log(pc.green(`connectBrowser: \u7AEF\u53E3 ${port} \u4E0A\u7684\u6D4F\u89C8\u5668\u5B9E\u4F8B\u4ECD\u5728\u6B63\u5E38\u54CD\u5E94\uFF0C\u8DF3\u8FC7\u5F3A\u6740\uFF0C\u5C1D\u8BD5\u76F4\u63A5\u63A5\u7BA1\u3002`));
+    return;
+  }
+  try {
+    const platform = os.platform();
+    const { execSync } = __require("child_process");
+    if (platform === "darwin" || platform === "linux") {
+      console.log(pc.yellow(`\u6B63\u5728\u68C0\u6D4B\u5E76\u6E05\u7406\u5360\u7528 ${port} \u7AEF\u53E3\u7684\u6B8B\u7559\u50F5\u5C38\u8FDB\u7A0B...`));
+      const pids = execSync(`lsof -t -i :${port}`).toString().trim();
+      if (pids) {
+        console.log(pc.yellow(`\u53D1\u73B0\u50F5\u5C38 PID: ${pids.split("\n").join(", ")}\uFF0C\u6B63\u5728\u5F3A\u5236\u7EC8\u6B62...`));
+        execSync(`kill -9 ${pids.split("\n").join(" ")}`);
+        console.log(pc.green(`\u6210\u529F\u6E05\u7406\u6B8B\u7559\u50F5\u5C38\u8FDB\u7A0B`));
+      }
+    } else if (platform === "win32") {
+      console.log(pc.yellow(`\u6B63\u5728\u68C0\u6D4B\u5E76\u6E05\u7406 Windows \u4E0A\u5360\u7528 ${port} \u7AEF\u53E3\u7684\u6B8B\u7559\u50F5\u5C38\u8FDB\u7A0B...`));
+      const output = execSync(`netstat -ano | findstr :${port}`).toString().trim();
+      if (output) {
+        const lines = output.split("\n");
+        const pids = /* @__PURE__ */ new Set();
+        lines.forEach((line) => {
+          const parts = line.trim().split(/\s+/);
+          const pid = parts[parts.length - 1];
+          if (pid && /^\d+$/.test(pid) && pid !== "0") {
+            pids.add(pid);
+          }
+        });
+        pids.forEach((pid) => {
+          console.log(pc.yellow(`\u53D1\u73B0 Windows \u6B8B\u7559\u50F5\u5C38 PID: ${pid}\uFF0C\u6B63\u5728\u5F3A\u5236\u7EC8\u6B62...`));
+          execSync(`taskkill /F /PID ${pid}`);
+        });
+      }
+    }
+  } catch (e) {
+  }
+}
 function getDefaultChromePath() {
   const platform = os.platform();
   if (platform === "darwin") {
@@ -58,7 +136,7 @@ async function startChromeInBackground() {
       const urls = [`http://localhost:${CDP_PORT}/json/version`, `http://127.0.0.1:${CDP_PORT}/json/version`];
       for (const url of urls) {
         try {
-          const response = await fetch(url);
+          const response = await fetchWithTimeout(url, 1e3);
           if (response.ok) {
             console.log(pc.green("Chrome \u542F\u52A8\u5E76\u5C31\u7EEA\u3002"));
             return;
@@ -90,44 +168,77 @@ async function connectBrowser() {
     }
   };
   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");
+    }
     console.log(pc.yellow("connectBrowser: \u6B63\u5728\u5C1D\u8BD5\u8FDE\u63A5 127.0.0.1:9222..."));
-    const browser = await puppeteer.connect({
-      browserURL: `http://127.0.0.1:${CDP_PORT}`,
-      defaultViewport: null,
-      targetFilter
-    });
+    const browser = await promiseWithTimeout(
+      puppeteer.connect({
+        browserURL: `http://127.0.0.1:${CDP_PORT}`,
+        defaultViewport: null,
+        targetFilter
+      }),
+      1e4,
+      "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;
   } catch (error) {
     try {
+      const isLocalhostReady = await checkCdpReady(`http://localhost:${CDP_PORT}/json/version`, 3);
+      if (!isLocalhostReady) {
+        throw new Error("localhost CDP port not responding");
+      }
       console.log(pc.yellow("connectBrowser: \u6B63\u5728\u5C1D\u8BD5\u8FDE\u63A5 localhost:9222..."));
-      const browser = await puppeteer.connect({
-        browserURL: `http://localhost:${CDP_PORT}`,
-        defaultViewport: null,
-        targetFilter
-      });
+      const browser = await promiseWithTimeout(
+        puppeteer.connect({
+          browserURL: `http://localhost:${CDP_PORT}`,
+          defaultViewport: null,
+          targetFilter
+        }),
+        1e4,
+        "puppeteer.connect to localhost timed out"
+      );
       console.log(pc.green("connectBrowser: \u6210\u529F\u8FDE\u63A5 localhost:9222"));
       return browser;
     } 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();
         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 puppeteer.connect({
-            browserURL: `http://127.0.0.1:${CDP_PORT}`,
-            defaultViewport: null,
-            targetFilter
-          });
+          const browser = await promiseWithTimeout(
+            puppeteer.connect({
+              browserURL: `http://127.0.0.1:${CDP_PORT}`,
+              defaultViewport: null,
+              targetFilter
+            }),
+            1e4,
+            "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;
         } 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 puppeteer.connect({
-            browserURL: `http://localhost:${CDP_PORT}`,
-            defaultViewport: null,
-            targetFilter
-          });
+          const browser = await promiseWithTimeout(
+            puppeteer.connect({
+              browserURL: `http://localhost:${CDP_PORT}`,
+              defaultViewport: null,
+              targetFilter
+            }),
+            1e4,
+            "puppeteer.connect to localhost after launch timed out"
+          );
           console.log(pc.green("connectBrowser: \u6210\u529F\u8FDE\u63A5 localhost:9222"));
           return browser;
         }
@@ -151,9 +262,8 @@ async function getPageTargetId(page) {
     });
   }
 }
-async function getTargetPage(browser, tabid) {
-  const targets = browser.targets();
-  const pageTargets = targets.filter((t) => {
+function getPageTargets(browser) {
+  return browser.targets().filter((t) => {
     try {
       const type = (typeof t.type === "function" ? t.type() : t.type) || "";
       const url = (typeof t.url === "function" ? t.url() : t.url) || "";
@@ -162,6 +272,41 @@ async function getTargetPage(browser, tabid) {
       return false;
     }
   });
+}
+function getTargetIdFromTarget(target) {
+  return typeof target._getTargetInfo === "function" ? target._getTargetInfo().targetId : target._targetId || target.targetId || "";
+}
+function findPageTargetByTabId(browser, tabid) {
+  const pageTargets = getPageTargets(browser);
+  return pageTargets.find((t) => {
+    const tid = getTargetIdFromTarget(t);
+    return tid === tabid || tid.includes(tabid);
+  }) ?? null;
+}
+async function activateTabById(browser, tabid) {
+  const target = findPageTargetByTabId(browser, tabid);
+  if (!target) {
+    throw new Error(`Tab with targetId "${tabid}" not found.`);
+  }
+  const realTabId = getTargetIdFromTarget(target);
+  const pages = await browser.pages();
+  let sessionPage = pages.find((p) => !p.url().startsWith("devtools://"));
+  if (!sessionPage && pages.length > 0) {
+    sessionPage = pages[0];
+  }
+  if (!sessionPage) {
+    sessionPage = await browser.newPage();
+  }
+  const session = await sessionPage.createCDPSession();
+  try {
+    await session.send("Target.activateTarget", { targetId: realTabId });
+  } finally {
+    await session.detach().catch(() => {
+    });
+  }
+}
+async function getTargetPage(browser, tabid) {
+  const pageTargets = getPageTargets(browser);
   if (pageTargets.length === 0) {
     const newPage = await browser.newPage();
     await injectWebMCPPolyfillAndTools(newPage);
@@ -169,16 +314,11 @@ async function getTargetPage(browser, tabid) {
   }
   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) {
+    const target = findPageTargetByTabId(browser, tabid);
+    if (!target) {
       throw new Error(`Tab with targetId "${tabid}" not found.`);
     }
+    targetPage = await target.page();
   } else {
     try {
       const urls = [
@@ -188,7 +328,7 @@ async function getTargetPage(browser, tabid) {
       let activeTargetId = null;
       for (const url of urls) {
         try {
-          const res = await fetch(url);
+          const res = await fetchWithTimeout(url, 1e3);
           if (res.ok) {
             const targetsData = await res.json();
             const active = targetsData.find((t) => t.type === "page" && !t.url.startsWith("devtools://"));
@@ -202,8 +342,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;
           }
@@ -323,7 +462,7 @@ async function stateCommand({ tabid }) {
       };
     });
     const pages = await browser.pages();
-    const tabs = await Promise.all(pages.map(async (p) => {
+    const tabs2 = await Promise.all(pages.map(async (p) => {
       const pUrl = p.url();
       if (pUrl.startsWith("devtools://")) return null;
       const pTitle = await Promise.race([
@@ -339,7 +478,7 @@ async function stateCommand({ tabid }) {
     }));
     return {
       ...state,
-      tabs: tabs.filter(Boolean)
+      tabs: tabs2.filter(Boolean)
     };
   } finally {
     await browser.disconnect();
@@ -380,56 +519,110 @@ async function runCommand({
   }
 }
 
-// src/commands/open.ts
-import pc2 from "picocolors";
-async function openCommand(url, { tabid, newTab }) {
+// src/commands/tabs.ts
+function normalizeUrl(url) {
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    return "https://" + url;
+  }
+  return url;
+}
+async function tabsOpenCommand(url) {
   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;
-        }
-      });
-      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();
-      }
+    const page = await browser.newPage();
+    url = normalizeUrl(url);
+    await page.goto(url, { waitUntil: "domcontentloaded" });
+    await injectIntoPage(page);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    return {
+      success: true,
+      tabid: await getPageTargetId(page),
+      url: page.url(),
+      title: await page.title()
+    };
+  } finally {
+    await browser.disconnect();
+  }
+}
+async function tabsCloseCommand(tabid) {
+  const browser = await connectBrowser();
+  try {
+    const target = findPageTargetByTabId(browser, tabid);
+    if (!target) {
+      throw new Error(`Tab with targetId "${tabid}" not found.`);
     }
-    if (!url.startsWith("http://") && !url.startsWith("https://")) {
-      url = "https://" + url;
+    const page = await target.page();
+    if (!page) {
+      throw new Error(`Tab with targetId "${tabid}" not found.`);
+    }
+    const closedTabid = await getPageTargetId(page).catch(() => tabid);
+    await page.close();
+    return {
+      success: true,
+      tabid: closedTabid
+    };
+  } finally {
+    await browser.disconnect();
+  }
+}
+async function tabsSwitchCommand(tabid) {
+  const browser = await connectBrowser();
+  try {
+    await activateTabById(browser, tabid);
+    const page = await getTargetPage(browser, tabid);
+    return {
+      success: true,
+      tabid: await getPageTargetId(page),
+      url: page.url(),
+      title: await page.title()
+    };
+  } finally {
+    await browser.disconnect();
+  }
+}
+async function tabsBackCommand(tabid) {
+  const browser = await connectBrowser();
+  try {
+    const page = await getTargetPage(browser, tabid);
+    const response = await page.goBack();
+    if (!response) {
+      return {
+        success: false,
+        error: "\u65E0\u6CD5\u540E\u9000\uFF1A\u5DF2\u5728\u5386\u53F2\u8BB0\u5F55\u8D77\u70B9",
+        tabid: await getPageTargetId(page).catch(() => tabid),
+        url: page.url(),
+        title: await page.title()
+      };
+    }
+    await injectIntoPage(page);
+    return {
+      success: true,
+      tabid: await getPageTargetId(page),
+      url: page.url(),
+      title: await page.title()
+    };
+  } finally {
+    await browser.disconnect();
+  }
+}
+async function tabsForwardCommand(tabid) {
+  const browser = await connectBrowser();
+  try {
+    const page = await getTargetPage(browser, tabid);
+    const response = await page.goForward();
+    if (!response) {
+      return {
+        success: false,
+        error: "\u65E0\u6CD5\u524D\u8FDB\uFF1A\u5DF2\u5728\u5386\u53F2\u8BB0\u5F55\u672B\u5C3E",
+        tabid: await getPageTargetId(page).catch(() => tabid),
+        url: page.url(),
+        title: await page.title()
+      };
     }
-    console.log(pc2.cyan(`\u6B63\u5728\u6253\u5F00: ${url}`));
-    await page.goto(url, { waitUntil: "domcontentloaded" });
     await injectIntoPage(page);
     return {
       success: true,
+      tabid: await getPageTargetId(page),
       url: page.url(),
       title: await page.title()
     };
@@ -438,13 +631,71 @@ async function openCommand(url, { tabid, newTab }) {
   }
 }
 
+// package.json
+var package_default = {
+  name: "@opentiny/webmcp-cli",
+  version: "0.0.1-alpha.2",
+  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:",
+    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();
 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;
@@ -455,9 +706,7 @@ program.command("state").description("\u83B7\u53D6\u6D4F\u89C8\u5668\u5F53\u524D
     const result = await stateCommand({ tabid: parseTabId(options.tabid) });
     console.log(JSON.stringify(result, 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) => {
@@ -469,22 +718,48 @@ program.command("run <toolName> <argsJson>").description("\u5411\u6307\u5B9A\u98
     });
     console.log(JSON.stringify(result, 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) => {
+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 result = await openCommand(url, {
-      tabid: parseTabId(options.tabid),
-      newTab: options.newTab
-    });
+    const result = await tabsOpenCommand(url);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    handleCommandError(error, "tabs open");
+  }
+});
+tabs.command("close <tabid>").description("\u5173\u95ED\u6307\u5B9A tabid \u7684\u6807\u7B7E\u9875").action(async (tabid) => {
+  try {
+    const result = await tabsCloseCommand(tabid);
+    console.log(JSON.stringify(result, 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 (tabid) => {
+  try {
+    const result = await tabsSwitchCommand(tabid);
+    console.log(JSON.stringify(result, 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 (tabid) => {
+  try {
+    const result = await tabsBackCommand(parseTabId(tabid));
+    console.log(JSON.stringify(result, 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 (tabid) => {
+  try {
+    const result = await tabsForwardCommand(parseTabId(tabid));
     console.log(JSON.stringify(result, 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);