@opentiny/webmcp-cli 0.0.1-alpha.6 → 0.0.3

package/dist/bin.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 
 // src/bin.ts
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
 import { Command } from "commander";
 import pc2 from "picocolors";
 import { readFileSync as readFileSync2 } from "fs";
@@ -237,6 +240,31 @@ async function checkCdpReady(url, retries = 3) {
   }
   return false;
 }
+async function findAvailableCdpUrl(addresses, retries = 2) {
+  for (const addr of addresses) {
+    if (await checkCdpReady(addr, retries)) {
+      return addr.replace("/json/version", "");
+    }
+  }
+  return null;
+}
+async function connectPuppeteer(browserBaseUrl, attempt = 1, maxAttempts = 3) {
+  try {
+    return await promiseWithTimeout(
+      puppeteer.connect({ browserURL: browserBaseUrl, defaultViewport: null }),
+      1e4,
+      `puppeteer.connect to ${browserBaseUrl} timed out`
+    );
+  } catch (err) {
+    if (attempt >= maxAttempts) {
+      throw err;
+    }
+    const delayMs = 500 * attempt;
+    console.log(pc.yellow(`connectBrowser: \u7B2C ${attempt} \u6B21\u8FDE\u63A5\u5931\u8D25\uFF0C${delayMs}ms \u540E\u91CD\u8BD5...`));
+    await new Promise((resolve3) => setTimeout(resolve3, delayMs));
+    return connectPuppeteer(browserBaseUrl, attempt + 1, maxAttempts);
+  }
+}
 function getDefaultBrowserPath() {
   const platform = os.platform();
   if (platform === "darwin") {
@@ -283,72 +311,56 @@ async function startBrowserInBackground() {
   }
   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 launchArgs = [
+    `--remote-debugging-port=${CDP_PORT}`,
+    `--user-data-dir=${userDataDir}`,
+    "--no-first-run",
+    "--no-default-browser-check"
+  ];
+  if (os.platform() === "win32") {
+    launchArgs.push("--remote-debugging-address=127.0.0.1");
+  }
   const child = spawn(
     browserInfo.path,
-    [
-      `--remote-debugging-port=${CDP_PORT}`,
-      `--user-data-dir=${userDataDir}`,
-      "--no-first-run",
-      "--no-default-browser-check"
-    ],
+    launchArgs,
     {
       detached: true,
       stdio: "ignore"
     }
   );
   child.unref();
-  for (let i = 0; i < 20; i++) {
-    try {
-      const urls = [`http://127.0.0.1:${CDP_PORT}/json/version`, `http://localhost:${CDP_PORT}/json/version`];
-      for (const url of urls) {
-        try {
-          await httpGet(url, 1e3);
-          console.log(pc.green(`${browserInfo.name} \u542F\u52A8\u5E76\u5C31\u7EEA\u3002`));
-          return;
-        } catch (err) {
-        }
+  const pollUrls = [`http://127.0.0.1:${CDP_PORT}/json/version`, `http://localhost:${CDP_PORT}/json/version`];
+  for (let i = 0; i < 30; i++) {
+    for (const url of pollUrls) {
+      try {
+        await httpGet(url, 1e3);
+        console.log(pc.green(`${browserInfo.name} \u542F\u52A8\u5E76\u5C31\u7EEA\u3002`));
+        await new Promise((resolve3) => setTimeout(resolve3, 500));
+        return;
+      } catch {
       }
-    } catch (e) {
     }
     await new Promise((resolve3) => setTimeout(resolve3, 500));
   }
   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) => {
-    try {
-      const info = typeof target._getTargetInfo === "function" ? target._getTargetInfo() : target;
-      const type = info.type || "";
-      const url = info.url || "";
-      if (type === "service_worker" || type === "shared_worker" || type === "iframe" || type === "other" || type === "webview" || type === "background_page") {
-        return false;
-      }
-      if (url.startsWith("devtools://") || url.startsWith("chrome-extension://")) {
-        return false;
-      }
-      return true;
-    } catch (e) {
-      return false;
-    }
-  };
-  const portAddresses = [
+  const versionAddresses = [
     `http://127.0.0.1:${CDP_PORT}/json/version`,
     `http://localhost:${CDP_PORT}/json/version`
   ];
-  for (const addr of portAddresses) {
-    const isReady = await checkCdpReady(addr, 2);
-    if (!isReady) continue;
-    const browserURL = addr.replace("/json/version", "");
+  const existingUrl = await findAvailableCdpUrl(versionAddresses, 2);
+  if (existingUrl) {
+    console.log(pc.yellow(`connectBrowser: \u68C0\u6D4B\u5230\u7AEF\u53E3 ${CDP_PORT} \u5DF2\u5C31\u7EEA\uFF0C\u6B63\u5728\u8FDE\u63A5 ${existingUrl}...`));
     try {
-      console.log(pc.yellow(`connectBrowser: \u68C0\u6D4B\u5230\u7AEF\u53E3 ${CDP_PORT} \u5DF2\u5C31\u7EEA\uFF0C\u6B63\u5728\u8FDE\u63A5 ${browserURL}...`));
-      const browser2 = await promiseWithTimeout(
-        puppeteer.connect({ browserURL, defaultViewport: null, targetFilter }),
-        1e4,
-        `puppeteer.connect to ${browserURL} timed out`
+      const browser = await connectPuppeteer(existingUrl);
+      console.log(pc.green(`connectBrowser: \u6210\u529F\u8FDE\u63A5 ${existingUrl}`));
+      return browser;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `\u65E0\u6CD5\u8FDE\u63A5\u5230\u5DF2\u5728\u8FD0\u884C\u7684\u6D4F\u89C8\u5668\uFF08${existingUrl}\uFF09\uFF1A${msg}\u3002CDP \u7AEF\u53E3\u53EF\u7528\uFF0C\u8BF7\u52FF\u91CD\u590D\u542F\u52A8\u6D4F\u89C8\u5668\uFF1B\u53EF\u5173\u95ED\u591A\u4F59\u7A97\u53E3\u540E\u91CD\u8BD5\u3002`
       );
-      console.log(pc.green(`connectBrowser: \u6210\u529F\u8FDE\u63A5 ${browserURL}`));
-      return browser2;
-    } catch {
     }
   }
   console.log(pc.yellow(`connectBrowser: \u7AEF\u53E3 ${CDP_PORT} \u65E0\u54CD\u5E94\uFF0C\u6B63\u5728\u542F\u52A8\u65B0\u7684\u6D4F\u89C8\u5668\u5B9E\u4F8B...`));
@@ -359,26 +371,21 @@ async function connectBrowser() {
     console.error(pc.red(`\u65E0\u6CD5\u542F\u52A8\u6D4F\u89C8\u5668: ${msg}`));
     throw new Error("Browser launch failed.");
   }
-  for (const addr of portAddresses) {
-    const isReady = await checkCdpReady(addr, 3);
-    if (!isReady) continue;
-    const browserURL = addr.replace("/json/version", "");
-    try {
-      console.log(pc.yellow(`connectBrowser: \u6D4F\u89C8\u5668\u5DF2\u542F\u52A8\uFF0C\u6B63\u5728\u8FDE\u63A5 ${browserURL}...`));
-      const browser2 = await promiseWithTimeout(
-        puppeteer.connect({ browserURL, defaultViewport: null, targetFilter }),
-        1e4,
-        `puppeteer.connect to ${browserURL} after launch timed out`
-      );
-      console.log(pc.green(`connectBrowser: \u6210\u529F\u8FDE\u63A5 ${browserURL}`));
-      return browser2;
-    } catch {
-    }
+  const launchedUrl = await findAvailableCdpUrl(versionAddresses, 5);
+  if (!launchedUrl) {
+    throw new Error(`\u65E0\u6CD5\u8FDE\u63A5\u5230\u6D4F\u89C8\u5668\uFF08\u7AEF\u53E3 ${CDP_PORT}\uFF09\uFF0C\u8BF7\u68C0\u67E5 Chrome/Edge \u662F\u5426\u5DF2\u5B89\u88C5\u3002`);
+  }
+  try {
+    console.log(pc.yellow(`connectBrowser: \u6D4F\u89C8\u5668\u5DF2\u542F\u52A8\uFF0C\u6B63\u5728\u8FDE\u63A5 ${launchedUrl}...`));
+    const browser = await connectPuppeteer(launchedUrl);
+    console.log(pc.green(`connectBrowser: \u6210\u529F\u8FDE\u63A5 ${launchedUrl}`));
+    return browser;
+  } catch {
+    throw new Error(`\u65E0\u6CD5\u8FDE\u63A5\u5230\u6D4F\u89C8\u5668\uFF08\u7AEF\u53E3 ${CDP_PORT}\uFF09\uFF0C\u8BF7\u68C0\u67E5 Chrome/Edge \u662F\u5426\u5DF2\u5B89\u88C5\u3002`);
   }
-  throw new Error(`\u65E0\u6CD5\u8FDE\u63A5\u5230\u6D4F\u89C8\u5668\uFF08\u7AEF\u53E3 ${CDP_PORT}\uFF09\uFF0C\u8BF7\u68C0\u67E5 Chrome/Edge \u662F\u5426\u5DF2\u5B89\u88C5\u3002`);
 }
-async function getPageTargetId(page2) {
-  const session = await page2.target().createCDPSession();
+async function getPageTargetId(page) {
+  const session = await page.target().createCDPSession();
   try {
     const { targetInfo } = await session.send("Target.getTargetInfo");
     return targetInfo.targetId;
@@ -387,8 +394,8 @@ async function getPageTargetId(page2) {
     });
   }
 }
-function getPageTargets(browser2) {
-  return browser2.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) || "";
@@ -401,26 +408,26 @@ function getPageTargets(browser2) {
 function getTargetIdFromTarget(target) {
   return typeof target._getTargetInfo === "function" ? target._getTargetInfo().targetId : target._targetId || target.targetId || "";
 }
-function findPageTargetByTabId(browser2, tabid2) {
-  const pageTargets = getPageTargets(browser2);
+function findPageTargetByTabId(browser, tabid) {
+  const pageTargets = getPageTargets(browser);
   return pageTargets.find((t) => {
     const tid = getTargetIdFromTarget(t);
-    return tid === tabid2 || tid.includes(tabid2);
+    return tid === tabid || tid.includes(tabid);
   }) ?? null;
 }
-async function activateTabById(browser2, tabid2) {
-  const target = findPageTargetByTabId(browser2, tabid2);
+async function activateTabById(browser, tabid) {
+  const target = findPageTargetByTabId(browser, tabid);
   if (!target) {
-    throw new Error(`Tab with targetId "${tabid2}" not found.`);
+    throw new Error(`Tab with targetId "${tabid}" not found.`);
   }
   const realTabId = getTargetIdFromTarget(target);
-  const pages = await browser2.pages();
+  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 browser2.newPage();
+    sessionPage = await browser.newPage();
   }
   const session = await sessionPage.createCDPSession();
   try {
@@ -430,18 +437,18 @@ async function activateTabById(browser2, tabid2) {
     });
   }
 }
-async function getTargetPage(browser2, tabid2) {
-  const pageTargets = getPageTargets(browser2);
+async function getTargetPage(browser, tabid) {
+  const pageTargets = getPageTargets(browser);
   if (pageTargets.length === 0) {
-    const newPage = await browser2.newPage();
+    const newPage = await browser.newPage();
     await injectWebMCPPolyfillAndTools(newPage);
     return newPage;
   }
   let targetPage = null;
-  if (tabid2 !== void 0) {
-    const target = findPageTargetByTabId(browser2, tabid2);
+  if (tabid !== void 0) {
+    const target = findPageTargetByTabId(browser, tabid);
     if (!target) {
-      throw new Error(`Tab with targetId "${tabid2}" not found.`);
+      throw new Error(`Tab with targetId "${tabid}" not found.`);
     }
     targetPage = await target.page();
   } else {
@@ -484,11 +491,11 @@ async function getTargetPage(browser2, tabid2) {
   await injectWebMCPPolyfillAndTools(targetPage);
   return targetPage;
 }
-async function injectIntoPage(page2) {
-  await injectWebMCPPolyfillAndTools(page2, true);
+async function injectIntoPage(page) {
+  await injectWebMCPPolyfillAndTools(page, true);
 }
-async function injectWebMCPPolyfillAndTools(page2, force = false) {
-  const polyfillReady = !force && await page2.evaluate(() => {
+async function injectWebMCPPolyfillAndTools(page, force = false) {
+  const polyfillReady = !force && await page.evaluate(() => {
     return !!window.__webmcpcli_init;
   }).catch(() => false);
   if (!polyfillReady) {
@@ -499,31 +506,63 @@ async function injectWebMCPPolyfillAndTools(page2, force = false) {
     }
     const scriptContent = fs.readFileSync(injectScriptPath, "utf-8");
     try {
-      await page2.evaluate(scriptContent);
+      await page.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((resolve3) => setTimeout(resolve3, 300));
+    await page.waitForFunction(() => {
+      const mcp = navigator.modelContext;
+      return mcp && typeof mcp.registerTool === "function";
+    }, { timeout: 1e4 }).catch(() => {
+      console.warn("\u7B49\u5F85 WebMCP registerTool \u63A5\u53E3\u5C31\u7EEA\u8D85\u65F6\uFF0C\u6B63\u5728\u7EE7\u7EED\u6CE8\u5165...");
+    });
   }
-  await injectDomainTools(page2);
+  await injectDomainTools(page);
 }
-async function injectDomainTools(page2) {
+function getToolsBundleName(hostname) {
+  const normalized = hostname.split(":")[0].toLowerCase();
+  const toolsDir = path.resolve(__dirname, "webmcp-tools");
+  if (!fs.existsSync(toolsDir)) {
+    return null;
+  }
+  let files = [];
+  try {
+    files = fs.readdirSync(toolsDir);
+  } catch {
+    return null;
+  }
+  const supportedDomains = files.filter((f) => f.endsWith(".js")).map((f) => f.slice(0, -3));
+  if (supportedDomains.includes(normalized)) {
+    return `webmcp-tools/${normalized}.js`;
+  }
+  for (const domain of supportedDomains) {
+    if (normalized.endsWith("." + domain)) {
+      return `webmcp-tools/${domain}.js`;
+    }
+  }
+  return null;
+}
+async function injectDomainTools(page) {
   let hostname;
   try {
-    const url = new URL(page2.url());
+    const url = new URL(page.url());
     hostname = url.hostname;
   } catch {
     return;
   }
-  const toolBundlePath = path.resolve(__dirname, "webmcp-tools", `${hostname}.js`);
+  const bundleName = getToolsBundleName(hostname);
+  if (!bundleName) {
+    return;
+  }
+  const toolBundlePath = path.resolve(__dirname, bundleName);
   if (!fs.existsSync(toolBundlePath)) {
     return;
   }
   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 page2.evaluate(toolScript);
+    await page.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);
@@ -532,60 +571,23 @@ async function injectDomainTools(page2) {
 }
 
 // src/commands/state.ts
-async function stateCommand({ tabid: tabid2 }) {
-  const browser2 = await connectBrowser();
+async function stateCommand({ tabid }) {
+  const browser = await connectBrowser();
   try {
-    const page2 = await getTargetPage(browser2, tabid2);
-    await injectIntoPage(page2);
-    const state = await page2.evaluate(async () => {
+    const page = await getTargetPage(browser, tabid);
+    await injectIntoPage(page);
+    const state = await page.evaluate(async () => {
       const url = document.URL;
       const title = document.title;
       const mcp = navigator.modelContextTesting || navigator.modelContext;
       let webmcpTools = [];
-      let contentData = `\u9875\u9762\u5DF2\u51C6\u5907\u597D: ${title}`;
-      if (mcp) {
-        if (typeof mcp.listTools === "function") {
-          const toolsResult = await mcp.listTools();
-          webmcpTools = toolsResult?.tools || toolsResult || [];
-        }
-        if (typeof mcp.executeTool === "function") {
-          try {
-            const argsString = JSON.stringify({ action: "browserState" });
-            let stateRes = await mcp.executeTool("page-agent-tool", argsString);
-            if (typeof stateRes === "string") {
-              try {
-                stateRes = JSON.parse(stateRes);
-              } catch (e) {
-              }
-            }
-            if (stateRes && stateRes.content && stateRes.content.length > 0) {
-              const textContent = stateRes.content.map((c) => c.text).join("\\n");
-              const prefix = "\u6D4F\u89C8\u5668\u72B6\u6001: ";
-              if (textContent.startsWith(prefix)) {
-                try {
-                  const jsonStr = textContent.substring(prefix.length);
-                  const parsedState = JSON.parse(jsonStr);
-                  contentData = parsedState.content;
-                } catch (e) {
-                  contentData = textContent;
-                }
-              } else {
-                contentData = textContent;
-              }
-            }
-          } catch (e) {
-            console.error("Snapshot error:", e.message);
-          }
-        }
+      if (mcp && typeof mcp.listTools === "function") {
+        const toolsResult = await mcp.listTools();
+        webmcpTools = toolsResult?.tools || toolsResult || [];
       }
-      return {
-        content: contentData,
-        url,
-        title,
-        webmcpTools
-      };
+      return { url, title, webmcpTools };
     });
-    const pages = await browser2.pages();
+    const pages = await browser.pages();
     const tabs2 = await Promise.all(
       pages.map(async (p) => {
         const pUrl = p.url();
@@ -607,7 +609,7 @@ async function stateCommand({ tabid: tabid2 }) {
       tabs: tabs2.filter(Boolean)
     };
   } finally {
-    await browser2.disconnect();
+    await browser.disconnect();
   }
 }
 
@@ -615,13 +617,13 @@ async function stateCommand({ tabid: tabid2 }) {
 async function runCommand({
   toolName,
   argsJson,
-  tabid: tabid2
+  tabid
 }) {
-  const browser2 = await connectBrowser();
+  const browser = await connectBrowser();
   try {
-    const page2 = await getTargetPage(browser2, tabid2);
+    const page = await getTargetPage(browser, tabid);
     const cleanedArgs = argsJson.trim();
-    const result2 = await page2.evaluate(async (name, inputString) => {
+    const result = await page.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)");
@@ -642,35 +644,6 @@ async function runCommand({
       }
       return res;
     }, toolName, cleanedArgs);
-    return result2;
-  } finally {
-    await browser2.disconnect();
-  }
-}
-
-// src/commands/evaluate.ts
-async function evaluateCommand({
-  jsScript,
-  tabid
-}) {
-  const browser = await connectBrowser();
-  try {
-    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;
-        }
-        return result;
-      } catch (error) {
-        return {
-          error: true,
-          message: error.message,
-          stack: error.stack
-        };
-      }
-    }, jsScript);
     return result;
   } finally {
     await browser.disconnect();
@@ -695,114 +668,114 @@ function normalizeUrl(url) {
   return url;
 }
 async function tabsOpenCommand(url) {
-  const browser2 = await connectBrowser();
+  const browser = await connectBrowser();
   try {
-    const page2 = await browser2.newPage();
+    const page = await browser.newPage();
     url = normalizeUrl(url);
-    await page2.goto(url, { waitUntil: "domcontentloaded" });
-    await injectIntoPage(page2);
+    await page.goto(url, { waitUntil: "domcontentloaded" });
+    await injectIntoPage(page);
     await new Promise((resolve3) => setTimeout(resolve3, 500));
     return {
       success: true,
-      tabid: await getPageTargetId(page2),
-      url: page2.url(),
-      title: await page2.title()
+      tabid: await getPageTargetId(page),
+      url: page.url(),
+      title: await page.title()
     };
   } finally {
-    await browser2.disconnect();
+    await browser.disconnect();
   }
 }
-async function tabsCloseCommand(tabid2) {
-  const browser2 = await connectBrowser();
+async function tabsCloseCommand(tabid) {
+  const browser = await connectBrowser();
   try {
-    const target = findPageTargetByTabId(browser2, tabid2);
+    const target = findPageTargetByTabId(browser, tabid);
     if (!target) {
-      throw new Error(`Tab with targetId "${tabid2}" not found.`);
+      throw new Error(`Tab with targetId "${tabid}" not found.`);
     }
-    const page2 = await target.page();
-    if (!page2) {
-      throw new Error(`Tab with targetId "${tabid2}" not found.`);
+    const page = await target.page();
+    if (!page) {
+      throw new Error(`Tab with targetId "${tabid}" not found.`);
     }
-    const closedTabid = await getPageTargetId(page2).catch(() => tabid2);
-    await page2.close();
+    const closedTabid = await getPageTargetId(page).catch(() => tabid);
+    await page.close();
     return {
       success: true,
       tabid: closedTabid
     };
   } finally {
-    await browser2.disconnect();
+    await browser.disconnect();
   }
 }
-async function tabsSwitchCommand(tabid2) {
-  const browser2 = await connectBrowser();
+async function tabsSwitchCommand(tabid) {
+  const browser = await connectBrowser();
   try {
-    await activateTabById(browser2, tabid2);
-    const page2 = await getTargetPage(browser2, tabid2);
+    await activateTabById(browser, tabid);
+    const page = await getTargetPage(browser, tabid);
     return {
       success: true,
-      tabid: await getPageTargetId(page2),
-      url: page2.url(),
-      title: await page2.title()
+      tabid: await getPageTargetId(page),
+      url: page.url(),
+      title: await page.title()
     };
   } finally {
-    await browser2.disconnect();
+    await browser.disconnect();
   }
 }
-async function tabsBackCommand(tabid2) {
-  const browser2 = await connectBrowser();
+async function tabsBackCommand(tabid) {
+  const browser = await connectBrowser();
   try {
-    const page2 = await getTargetPage(browser2, tabid2);
-    const response = await page2.goBack();
+    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(page2).catch(() => tabid2),
-        url: page2.url(),
-        title: await page2.title()
+        tabid: await getPageTargetId(page).catch(() => tabid),
+        url: page.url(),
+        title: await page.title()
       };
     }
-    await injectIntoPage(page2);
+    await injectIntoPage(page);
     return {
       success: true,
-      tabid: await getPageTargetId(page2),
-      url: page2.url(),
-      title: await page2.title()
+      tabid: await getPageTargetId(page),
+      url: page.url(),
+      title: await page.title()
     };
   } finally {
-    await browser2.disconnect();
+    await browser.disconnect();
   }
 }
-async function tabsForwardCommand(tabid2) {
-  const browser2 = await connectBrowser();
+async function tabsForwardCommand(tabid) {
+  const browser = await connectBrowser();
   try {
-    const page2 = await getTargetPage(browser2, tabid2);
-    const response = await page2.goForward();
+    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(page2).catch(() => tabid2),
-        url: page2.url(),
-        title: await page2.title()
+        tabid: await getPageTargetId(page).catch(() => tabid),
+        url: page.url(),
+        title: await page.title()
       };
     }
-    await injectIntoPage(page2);
+    await injectIntoPage(page);
     return {
       success: true,
-      tabid: await getPageTargetId(page2),
-      url: page2.url(),
-      title: await page2.title()
+      tabid: await getPageTargetId(page),
+      url: page.url(),
+      title: await page.title()
     };
   } finally {
-    await browser2.disconnect();
+    await browser.disconnect();
   }
 }
 
 // package.json
 var package_default = {
   name: "@opentiny/webmcp-cli",
-  version: "0.0.1-alpha.6",
+  version: "0.0.3",
   type: "module",
   description: "WebMCP CLI for AI Agents to interact with browser via Puppeteer",
   main: "dist/index.js",
@@ -860,8 +833,97 @@ function parseTabId(id) {
   if (!id) return void 0;
   return id;
 }
-function handleCommandError(error, commandName) {
+function cleanOldLogs(baseDir, logDir) {
+  try {
+    const oldLogFile = path2.join(baseDir, "webmcp-cli.log");
+    if (fs2.existsSync(oldLogFile)) {
+      try {
+        fs2.unlinkSync(oldLogFile);
+      } catch {
+      }
+    }
+    if (fs2.existsSync(baseDir)) {
+      const baseFiles = fs2.readdirSync(baseDir);
+      for (const file of baseFiles) {
+        if (/^webmcp-cli-\d{4}-\d{2}-\d{2}\.log$/.test(file)) {
+          try {
+            fs2.unlinkSync(path2.join(baseDir, file));
+          } catch {
+          }
+        }
+      }
+    }
+    if (!fs2.existsSync(logDir)) return;
+    const files = fs2.readdirSync(logDir);
+    const logFilePattern = /^webmcp-cli-(\d{4}-\d{2}-\d{2})\.log$/;
+    const now = Date.now();
+    const maxAgeMs = 7 * 24 * 60 * 60 * 1e3;
+    for (const file of files) {
+      const match = file.match(logFilePattern);
+      if (match) {
+        const fileDateStr = match[1];
+        const fileDate = new Date(fileDateStr).getTime();
+        if (isNaN(fileDate)) continue;
+        if (now - fileDate > maxAgeMs) {
+          try {
+            fs2.unlinkSync(path2.join(logDir, file));
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (e) {
+  }
+}
+function writeLog(commandName, args, result, error) {
+  try {
+    const baseDir = process.env.WEBMCP_WORKSPACE || path2.join(os2.homedir(), ".webmcp_chrome_profile");
+    const logDir = path2.join(baseDir, "logs");
+    if (!fs2.existsSync(logDir)) {
+      fs2.mkdirSync(logDir, { recursive: true });
+    }
+    const todayStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const logFile = path2.join(logDir, `webmcp-cli-${todayStr}.log`);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    let logText = `========================================
+`;
+    logText += `[${timestamp}] COMMAND: ${commandName}
+`;
+    logText += `ARGS:
+${JSON.stringify(args, null, 2)}
+
+`;
+    if (error) {
+      logText += `ERROR:
+${error instanceof Error ? error.stack : String(error)}
+`;
+    } else if (result) {
+      logText += `RESULT:
+`;
+      try {
+        if (result && typeof result === "object") {
+          logText += JSON.stringify(result, null, 2).split("\n").map((line) => `  ${line}`).join("\n") + "\n";
+        } else {
+          logText += String(result).split("\n").map((line) => `  ${line}`).join("\n") + "\n";
+        }
+      } catch {
+        logText += JSON.stringify(result, null, 2).split("\n").map((line) => `  ${line}`).join("\n") + "\n";
+      }
+    } else {
+      logText += `RESULT: null
+`;
+    }
+    logText += `========================================
+
+`;
+    fs2.appendFileSync(logFile, logText, "utf-8");
+    cleanOldLogs(baseDir, logDir);
+  } catch (e) {
+  }
+}
+function handleCommandError(error, commandName, args) {
   const msg = error instanceof Error ? error.message : String(error);
+  writeLog(commandName, args, null, error);
   console.error(pc2.red(`Error executing ${commandName} command: ${msg}`));
   process.exit(1);
 }
@@ -871,12 +933,14 @@ program.name("webmcp-cli").description("WebMCP CLI for interacting with browser
     process.env.WEBMCP_WORKSPACE = opts.workspace;
   }
 });
-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) => {
+program.command("state").description("\u83B7\u53D6\u6D4F\u89C8\u5668\u5F53\u524D\u9875\u7B7E\u6216\u6307\u5B9A\u9875\u7B7E\u7684\u5BFC\u822A\u5143\u6570\u636E\uFF08url\u3001title\u3001webmcpTools\u3001\u6240\u6709\u9875\u7B7E\u5217\u8868\uFF09").option("-t, --tabid <id>", "\u6307\u5B9A\u9875\u7B7E\u7684 ID").action(async (options) => {
+  const args = { tabid: parseTabId(options.tabid) };
   try {
-    const result2 = await stateCommand({ tabid: parseTabId(options.tabid) });
-    console.log(JSON.stringify(result2, null, 2));
+    const result = await stateCommand(args);
+    writeLog("state", args, result);
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
-    handleCommandError(error, "state");
+    handleCommandError(error, "state", args);
   }
 });
 program.command("run <toolName> [args...]").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").option(
@@ -887,6 +951,8 @@ program.command("run <toolName> [args...]").description("\u5411\u6307\u5B9A\u987
   @base64file:<path> \u8BFB\u53D6\u6587\u4EF6\u5E76 Base64 \u7F16\u7801
 \u793A\u4F8B\uFF1Awebmcp-cli run mytool '{"content":"@base64file:./doc.md"}'`
 ).action(async (toolName, args, options) => {
+  let finalArgsJson = "";
+  const rawArgs = { toolName, args, file: options.file, tabid: options.tabid };
   try {
     let fileContent;
     let fileBaseDir = process.cwd();
@@ -899,75 +965,78 @@ program.command("run <toolName> [args...]").description("\u5411\u6307\u5B9A\u987
         throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 "${filePath}": ${e.message}`);
       }
     }
-    const finalArgsJson = prepareRunArgsJson(args ?? [], fileContent, fileBaseDir);
-    const result2 = await runCommand({
+    finalArgsJson = prepareRunArgsJson(args ?? [], fileContent, fileBaseDir);
+    const result = await runCommand({
       toolName,
       argsJson: finalArgsJson,
       tabid: parseTabId(options.tabid)
     });
-    console.log(JSON.stringify(result2, null, 2));
-  } catch (error) {
-    handleCommandError(error, "run");
-  }
-});
-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 result2 = await evaluateCommand({
-      jsScript: jsScript2,
-      tabid: parseTabId(options.tabid)
-    });
-    console.log(JSON.stringify(result2, null, 2));
+    writeLog("run", { ...rawArgs, finalArgsJson }, result);
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
-    handleCommandError(error, "evaluate");
+    handleCommandError(error, "run", { ...rawArgs, finalArgsJson });
   }
 });
 program.command("clipboard <content>").description("\u5C06\u5185\u5BB9\u8BBE\u7F6E\u5230\u7CFB\u7EDF\u526A\u8D34\u677F").action(async (content) => {
+  const args = { 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));
+    const result = { success: true, message: "\u5185\u5BB9\u5DF2\u8BBE\u7F6E\u5230\u7CFB\u7EDF\u526A\u8D34\u677F" };
+    writeLog("clipboard", args, result);
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
-    handleCommandError(error, "clipboard");
+    handleCommandError(error, "clipboard", args);
   }
 });
 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) => {
+  const args = { url };
   try {
-    const result2 = await tabsOpenCommand(url);
-    console.log(JSON.stringify(result2, null, 2));
+    const result = await tabsOpenCommand(url);
+    writeLog("tabs open", args, result);
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
-    handleCommandError(error, "tabs open");
+    handleCommandError(error, "tabs open", args);
   }
 });
-tabs.command("close <tabid>").description("\u5173\u95ED\u6307\u5B9A tabid \u7684\u6807\u7B7E\u9875").action(async (tabid2) => {
+tabs.command("close <tabid>").description("\u5173\u95ED\u6307\u5B9A tabid \u7684\u6807\u7B7E\u9875").action(async (tabid) => {
+  const args = { tabid };
   try {
-    const result2 = await tabsCloseCommand(tabid2);
-    console.log(JSON.stringify(result2, null, 2));
+    const result = await tabsCloseCommand(tabid);
+    writeLog("tabs close", args, result);
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
-    handleCommandError(error, "tabs close");
+    handleCommandError(error, "tabs close", args);
   }
 });
-tabs.command("switch <tabid>").description("\u6FC0\u6D3B\u5E76\u5207\u6362\u5230\u6307\u5B9A tabid \u7684\u6807\u7B7E\u9875").action(async (tabid2) => {
+tabs.command("switch <tabid>").description("\u6FC0\u6D3B\u5E76\u5207\u6362\u5230\u6307\u5B9A tabid \u7684\u6807\u7B7E\u9875").action(async (tabid) => {
+  const args = { tabid };
   try {
-    const result2 = await tabsSwitchCommand(tabid2);
-    console.log(JSON.stringify(result2, null, 2));
+    const result = await tabsSwitchCommand(tabid);
+    writeLog("tabs switch", args, result);
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
-    handleCommandError(error, "tabs switch");
+    handleCommandError(error, "tabs switch", args);
   }
 });
-tabs.command("back [tabid]").description("\u5C06\u5F53\u524D\u6216\u6307\u5B9A\u6807\u7B7E\u9875\u5BFC\u822A\u540E\u9000\u4E00\u6B65").action(async (tabid2) => {
+tabs.command("back [tabid]").description("\u5C06\u5F53\u524D\u6216\u6307\u5B9A\u6807\u7B7E\u9875\u5BFC\u822A\u540E\u9000\u4E00\u6B65").action(async (tabid) => {
+  const args = { tabid: parseTabId(tabid) };
   try {
-    const result2 = await tabsBackCommand(parseTabId(tabid2));
-    console.log(JSON.stringify(result2, null, 2));
+    const result = await tabsBackCommand(args.tabid);
+    writeLog("tabs back", args, result);
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
-    handleCommandError(error, "tabs back");
+    handleCommandError(error, "tabs back", args);
   }
 });
-tabs.command("forward [tabid]").description("\u5C06\u5F53\u524D\u6216\u6307\u5B9A\u6807\u7B7E\u9875\u5BFC\u822A\u524D\u8FDB\u4E00\u6B65").action(async (tabid2) => {
+tabs.command("forward [tabid]").description("\u5C06\u5F53\u524D\u6216\u6307\u5B9A\u6807\u7B7E\u9875\u5BFC\u822A\u524D\u8FDB\u4E00\u6B65").action(async (tabid) => {
+  const args = { tabid: parseTabId(tabid) };
   try {
-    const result2 = await tabsForwardCommand(parseTabId(tabid2));
-    console.log(JSON.stringify(result2, null, 2));
+    const result = await tabsForwardCommand(args.tabid);
+    writeLog("tabs forward", args, result);
+    console.log(JSON.stringify(result, null, 2));
   } catch (error) {
-    handleCommandError(error, "tabs forward");
+    handleCommandError(error, "tabs forward", args);
   }
 });
 program.parse(process.argv);