@opentiny/webmcp-cli 0.0.3 → 0.0.6

package/dist/bin.js

@@ -3,7 +3,7 @@
 // src/bin.ts
 import fs2 from "fs";
 import path2 from "path";
-import os2 from "os";
+import os3 from "os";
 import { Command } from "commander";
 import pc2 from "picocolors";
 import { readFileSync as readFileSync2 } from "fs";
@@ -161,21 +161,28 @@ ${hint}`);
   }
 }
 function prepareRunArgsJson(args, fileContent, baseDir) {
-  let raw = "";
   if (fileContent !== void 0) {
-    raw = fileContent.trim();
-  } else if (args.length > 0) {
-    const joined = joinShellArgs(args);
-    if (joined.startsWith("{") || looksLikeObjectBody(joined)) {
-      raw = joined;
-    } else if (args.every((arg) => arg.includes("="))) {
-      raw = buildArgsFromKeyValuePairs(args);
-    } else {
-      raw = joined;
+    const trimmed = fileContent.trim();
+    if (!trimmed) {
+      throw new Error("\u901A\u8FC7 -f/--file \u6307\u5B9A\u7684\u53C2\u6570\u6587\u4EF6\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A");
     }
+    const expanded2 = expandFileRefs(trimmed, baseDir);
+    return parseArgsJson(expanded2);
+  }
+  if (args.length === 0) {
+    return "{}";
+  }
+  const joined = joinShellArgs(args);
+  let raw = "";
+  if (joined.startsWith("{") || looksLikeObjectBody(joined)) {
+    raw = joined;
+  } else if (args.every((arg) => arg.includes("="))) {
+    raw = buildArgsFromKeyValuePairs(args);
+  } else {
+    raw = joined;
   }
-  if (!raw) {
-    throw new Error("\u5FC5\u987B\u63D0\u4F9B\u53C2\u6570\u6216\u901A\u8FC7 -f/--file \u6307\u5B9A\u53C2\u6570\u6587\u4EF6");
+  if (!raw.trim()) {
+    throw new Error("\u672A\u63D0\u4F9B\u6709\u6548\u53C2\u6570");
   }
   const expanded = expandFileRefs(raw, baseDir);
   return parseArgsJson(expanded);
@@ -194,6 +201,30 @@ var __filename = fileURLToPath2(import.meta.url);
 var __dirname = path.dirname(__filename);
 var CDP_PORT = 9222;
 var CDP_URL = `http://localhost:${CDP_PORT}`;
+function getWorkspaceDir() {
+  return process.env.WEBMCP_WORKSPACE || path.join(os.homedir(), ".webmcp_chrome_profile");
+}
+function getLastTabIdFilePath() {
+  return path.join(getWorkspaceDir(), ".last-tab-id");
+}
+function setLastActiveTabId(tabid) {
+  try {
+    const dir = getWorkspaceDir();
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(getLastTabIdFilePath(), tabid, "utf-8");
+  } catch {
+  }
+}
+function getLastActiveTabId() {
+  try {
+    const tabid = fs.readFileSync(getLastTabIdFilePath(), "utf-8").trim();
+    return tabid || null;
+  } catch {
+    return null;
+  }
+}
 function httpGet(url, timeoutMs = 1500) {
   return new Promise((resolve3, reject) => {
     const req = http.get(url, { timeout: timeoutMs }, (res) => {
@@ -452,33 +483,42 @@ async function getTargetPage(browser, tabid) {
     }
     targetPage = await target.page();
   } else {
-    try {
-      const urls = [
-        `http://localhost:${CDP_PORT}/json/list`,
-        `http://127.0.0.1:${CDP_PORT}/json/list`
-      ];
-      let activeTargetId = null;
-      for (const url of urls) {
-        try {
-          const body = await httpGet(url, 1e3);
-          const targetsData = JSON.parse(body);
-          const active = targetsData.find((t) => t.type === "page" && !t.url.startsWith("devtools://"));
-          if (active) {
-            activeTargetId = active.id;
-            break;
+    const lastTabId = getLastActiveTabId();
+    if (lastTabId) {
+      const lastTarget = findPageTargetByTabId(browser, lastTabId);
+      if (lastTarget) {
+        targetPage = await lastTarget.page();
+      }
+    }
+    if (!targetPage) {
+      try {
+        const urls = [
+          `http://localhost:${CDP_PORT}/json/list`,
+          `http://127.0.0.1:${CDP_PORT}/json/list`
+        ];
+        let activeTargetId = null;
+        for (const url of urls) {
+          try {
+            const body = await httpGet(url, 1e3);
+            const targetsData = JSON.parse(body);
+            const active = targetsData.find((t) => t.type === "page" && !t.url.startsWith("devtools://"));
+            if (active) {
+              activeTargetId = active.id;
+              break;
+            }
+          } catch {
           }
-        } catch {
         }
-      }
-      if (activeTargetId) {
-        for (const target of pageTargets) {
-          if (getTargetIdFromTarget(target) === activeTargetId) {
-            targetPage = await target.page();
-            break;
+        if (activeTargetId) {
+          for (const target of pageTargets) {
+            if (getTargetIdFromTarget(target) === activeTargetId) {
+              targetPage = await target.page();
+              break;
+            }
           }
         }
+      } catch {
       }
-    } catch {
     }
     if (!targetPage) {
       const lastTarget = pageTargets[pageTargets.length - 1];
@@ -559,6 +599,12 @@ async function injectDomainTools(page) {
   if (!fs.existsSync(toolBundlePath)) {
     return;
   }
+  const bundleKey = bundleName.replace(/^webmcp-tools\//, "").replace(/\.js$/, "");
+  const flagKey = `__webmcptools_${bundleKey.replace(/[^a-zA-Z0-9]/g, "")}`;
+  const alreadyInjected = await page.evaluate((key) => !!window[key], flagKey).catch(() => false);
+  if (alreadyInjected) {
+    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 {
@@ -579,14 +625,15 @@ async function stateCommand({ tabid }) {
     const state = await page.evaluate(async () => {
       const url = document.URL;
       const title = document.title;
-      const mcp = navigator.modelContextTesting || navigator.modelContext;
+      const mcp = document.modelContext;
       let webmcpTools = [];
       if (mcp && typeof mcp.listTools === "function") {
-        const toolsResult = await mcp.listTools();
+        const toolsResult = await mcp.getTools();
         webmcpTools = toolsResult?.tools || toolsResult || [];
       }
       return { url, title, webmcpTools };
     });
+    const activeTabid = await getPageTargetId(page).catch(() => null);
     const pages = await browser.pages();
     const tabs2 = await Promise.all(
       pages.map(async (p) => {
@@ -606,6 +653,7 @@ async function stateCommand({ tabid }) {
     );
     return {
       ...state,
+      activeTabid,
       tabs: tabs2.filter(Boolean)
     };
   } finally {
@@ -613,6 +661,155 @@ async function stateCommand({ tabid }) {
   }
 }
 
+// src/zhihu/create-article.ts
+import os2 from "os";
+
+// src/zhihu/markdown.ts
+import { Marked } from "marked";
+function stripLeadingH1(markdown) {
+  return markdown.replace(/^#\s+[^\n]*\n+/, "");
+}
+function markdownToHtml(markdown) {
+  const marked = new Marked({
+    gfm: true,
+    breaks: false,
+    renderer: {
+      code({ text, lang }) {
+        const langClass = lang ? ` class="language-${lang}"` : "";
+        const escaped = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        return `<pre><code${langClass}>${escaped}</code></pre>`;
+      },
+      codespan({ text }) {
+        const escaped = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        return `<code>${escaped}</code>`;
+      }
+    }
+  });
+  return marked.parse(markdown);
+}
+function decodeBase64Content(content) {
+  return Buffer.from(content, "base64").toString("utf-8");
+}
+var ZHIHU_WRITE_PAGE_RE = /^https:\/\/zhuanlan\.zhihu\.com\/(write|p\/\d+\/edit)/;
+function isZhihuWriteUrl(url) {
+  return ZHIHU_WRITE_PAGE_RE.test(url);
+}
+
+// src/zhihu/create-article.ts
+function delay(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function getPasteModifier() {
+  return os2.platform() === "darwin" ? "Meta" : "Control";
+}
+async function fillTitle(page, title) {
+  await page.evaluate((titleText) => {
+    const input = document.querySelector('textarea[placeholder*="\u6807\u9898"]') || document.querySelector(".WriteIndex-titleInput textarea") || document.querySelector(".WriteIndex-titleInput input");
+    if (!input) throw new Error("\u672A\u627E\u5230\u6807\u9898\u8F93\u5165\u6846\uFF0C\u8BF7\u786E\u8BA4\u7F16\u8F91\u5668\u9875\u9762\u5DF2\u5B8C\u5168\u52A0\u8F7D");
+    const setter = Object.getOwnPropertyDescriptor(
+      input instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype,
+      "value"
+    )?.set;
+    if (setter) {
+      setter.call(input, titleText);
+    } else {
+      input.value = titleText;
+    }
+    input.dispatchEvent(new InputEvent("input", { bubbles: true, cancelable: true, data: titleText }));
+    input.dispatchEvent(new Event("change", { bubbles: true }));
+    if (input.value.trim() !== titleText.trim()) {
+      throw new Error("\u6807\u9898\u586B\u5199\u5931\u8D25\uFF0C\u8BF7\u5237\u65B0\u9875\u9762\u540E\u91CD\u8BD5");
+    }
+  }, title);
+}
+async function pasteHtmlToEditor(page, html) {
+  const browser = page.browser();
+  const tempPage = await browser.newPage();
+  const modifier = getPasteModifier();
+  try {
+    const fullHtml = `<!DOCTYPE html><html><head><meta charset="utf-8"></head><body>${html}</body></html>`;
+    await tempPage.setContent(fullHtml, { waitUntil: "domcontentloaded" });
+    await delay(300);
+    await tempPage.click("body");
+    await tempPage.keyboard.down(modifier);
+    await tempPage.keyboard.press("KeyA");
+    await tempPage.keyboard.up(modifier);
+    await delay(100);
+    await tempPage.keyboard.down(modifier);
+    await tempPage.keyboard.press("KeyC");
+    await tempPage.keyboard.up(modifier);
+    await delay(300);
+  } finally {
+    await tempPage.close();
+  }
+  await page.bringToFront();
+  await page.waitForSelector(".public-DraftEditor-content", { timeout: 1e4 });
+  await page.click(".public-DraftEditor-content");
+  await delay(200);
+  await page.keyboard.down(modifier);
+  await page.keyboard.press("KeyA");
+  await page.keyboard.up(modifier);
+  await delay(100);
+  await page.keyboard.press("Backspace");
+  await delay(200);
+  await page.keyboard.down(modifier);
+  await page.keyboard.press("KeyV");
+  await page.keyboard.up(modifier);
+  await delay(1500);
+  const probe = html.replace(/<[^>]+>/g, "").trim().slice(0, 15);
+  const verifyResult = await page.evaluate((probeText) => {
+    const editor = document.querySelector(".public-DraftEditor-content");
+    if (!editor) return { ok: false, reason: "no editor" };
+    const text = (editor.innerText || "").trim();
+    if (!text) return { ok: false, reason: "empty" };
+    const inner = editor.innerHTML;
+    const hasRichFormat = inner.includes("data-text") || /font-weight:\s*bold|font-style:\s*italic|code-block|blockquote/i.test(inner);
+    const normalizedText = text.replace(/\s+/g, "");
+    const normalizedProbe = probeText.replace(/\s+/g, "");
+    const hasProbe = normalizedText.includes(normalizedProbe);
+    return {
+      ok: text.length > 20 && hasProbe && (hasRichFormat || text.length > 50),
+      reason: !hasProbe ? "probe mismatch" : !hasRichFormat && text.length <= 50 ? "no rich format" : void 0
+    };
+  }, probe);
+  if (!verifyResult.ok) {
+    throw new Error(
+      `\u6B63\u6587\u586B\u5199\u5931\u8D25\uFF08Markdown \u8F6C HTML \u7C98\u8D34\u672A\u751F\u6548\uFF09${verifyResult.reason ? `: ${verifyResult.reason}` : ""}`
+    );
+  }
+}
+async function zhihuCreateArticle(page, args) {
+  const { title, content } = args;
+  if (!title?.trim()) throw new Error("\u53C2\u6570 title \u4E0D\u80FD\u4E3A\u7A7A");
+  if (!content?.trim()) throw new Error("\u53C2\u6570 content \u4E0D\u80FD\u4E3A\u7A7A");
+  const url = page.url();
+  if (!isZhihuWriteUrl(url)) {
+    throw new Error("\u5F53\u524D\u9875\u9762\u4E0D\u662F\u77E5\u4E4E\u4E13\u680F\u7F16\u8F91\u5668\uFF0C\u8BF7\u5148\u6253\u5F00 https://zhuanlan.zhihu.com/write");
+  }
+  let markdown;
+  try {
+    markdown = stripLeadingH1(decodeBase64Content(content));
+  } catch {
+    throw new Error("content \u4E0D\u662F\u6709\u6548\u7684 Base64 \u7F16\u7801\uFF0C\u8BF7\u68C0\u67E5\u53C2\u6570\u6216\u4F7F\u7528 @base64file: \u5F15\u7528\u6587\u4EF6");
+  }
+  if (!markdown.trim()) {
+    throw new Error("\u6B63\u6587\u5185\u5BB9\u4E3A\u7A7A\uFF0C\u8BF7\u68C0\u67E5 Markdown \u6587\u4EF6");
+  }
+  const html = markdownToHtml(markdown);
+  await fillTitle(page, title.trim());
+  await delay(500);
+  await pasteHtmlToEditor(page, html);
+  const result = {
+    success: true,
+    message: "\u6587\u7AE0\u6807\u9898\u548C\u6B63\u6587\u5DF2\u6210\u529F\u586B\u5199\u5230\u77E5\u4E4E\u4E13\u680F\u7F16\u8F91\u5668\uFF08Markdown \u5DF2\u8F6C\u4E3A\u5BCC\u6587\u672C\uFF09\uFF0C\u8349\u7A3F\u5C06\u81EA\u52A8\u4FDD\u5B58",
+    title: title.trim(),
+    contentLength: markdown.length
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(result) }]
+  };
+}
+
 // src/commands/run.ts
 async function runCommand({
   toolName,
@@ -622,28 +819,65 @@ async function runCommand({
   const browser = await connectBrowser();
   try {
     const page = await getTargetPage(browser, tabid);
+    const urlBefore = page.url();
     const cleanedArgs = argsJson.trim();
-    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)");
+    if (toolName === "create_article") {
+      let parsedArgs;
+      try {
+        parsedArgs = JSON.parse(cleanedArgs);
+      } catch {
+        throw new Error("\u53C2\u6570\u4E0D\u662F\u6709\u6548\u7684 JSON");
+      }
+      if (isZhihuWriteUrl(page.url())) {
+        return await zhihuCreateArticle(page, parsedArgs);
       }
-      let res = await mcp.executeTool(name, inputString);
-      if (typeof res === "string") {
+    }
+    let result;
+    try {
+      result = await page.evaluate(async (name, inputString) => {
+        const mcp = document.modelContext || document.modelContext || document.modelContext;
+        if (!mcp || typeof mcp.executeTool !== "function") {
+          throw new Error("\u5F53\u524D\u9875\u9762\u6CA1\u6709\u6CE8\u5165 WebMCP \u73AF\u5883 (document.modelContext \u672A\u627E\u5230)");
+        }
+        const tools = await mcp.getTools();
+        const toolObj = tools.find((t) => t.name === name);
+        if (!toolObj) throw new Error(`Tool ${name} not found`);
+        let res = await mcp.executeTool(toolObj, inputString);
+        if (typeof res === "string") {
+          try {
+            res = JSON.parse(res);
+          } catch {
+          }
+        }
+        if (res === void 0 || res === null) {
+          throw new Error("\u5DE5\u5177 execute \u672A\u8FD4\u56DE\u7ED3\u679C\uFF0C\u8BF7\u68C0\u67E5\u5DE5\u5177\u5B9E\u73B0\u662F\u5426\u7F3A\u5C11 return");
+        }
+        if (typeof res === "object" && res.success === false) {
+          const failed = res;
+          throw new Error(failed.error || failed.message || "\u5DE5\u5177\u6267\u884C\u5931\u8D25");
+        }
+        return res;
+      }, toolName, cleanedArgs);
+    } catch (evalError) {
+      const errMsg = evalError instanceof Error ? evalError.message : String(evalError);
+      const isContextDestroyed = errMsg.includes("context was destroyed") || errMsg.includes("Execution context was destroyed") || errMsg.includes("Cannot read properties of null") && errMsg.includes("context");
+      if (isContextDestroyed) {
+        await new Promise((resolve3) => setTimeout(resolve3, 800));
+        let newUrl = "";
         try {
-          res = JSON.parse(res);
+          newUrl = page.url();
         } catch {
         }
+        if (newUrl && newUrl !== urlBefore) {
+          return {
+            success: true,
+            message: `\u5DE5\u5177 ${toolName} \u6267\u884C\u5B8C\u6210\uFF0C\u9875\u9762\u5DF2\u5BFC\u822A\u81F3 ${newUrl}`,
+            navigatedTo: newUrl
+          };
+        }
       }
-      if (res === void 0 || res === null) {
-        throw new Error("\u5DE5\u5177 execute \u672A\u8FD4\u56DE\u7ED3\u679C\uFF0C\u8BF7\u68C0\u67E5\u5DE5\u5177\u5B9E\u73B0\u662F\u5426\u7F3A\u5C11 return");
-      }
-      if (typeof res === "object" && res.success === false) {
-        const failed = res;
-        throw new Error(failed.error || failed.message || "\u5DE5\u5177\u6267\u884C\u5931\u8D25");
-      }
-      return res;
-    }, toolName, cleanedArgs);
+      throw evalError;
+    }
     return result;
   } finally {
     await browser.disconnect();
@@ -675,11 +909,19 @@ async function tabsOpenCommand(url) {
     await page.goto(url, { waitUntil: "domcontentloaded" });
     await injectIntoPage(page);
     await new Promise((resolve3) => setTimeout(resolve3, 500));
+    let tabid;
+    try {
+      tabid = await getPageTargetId(page);
+      await activateTabById(browser, tabid);
+      setLastActiveTabId(tabid);
+    } catch (e) {
+      console.warn("Best-effort tab activation failed:", e);
+    }
     return {
       success: true,
-      tabid: await getPageTargetId(page),
+      tabid,
       url: page.url(),
-      title: await page.title()
+      title: await page.title().catch(() => "")
     };
   } finally {
     await browser.disconnect();
@@ -711,9 +953,11 @@ async function tabsSwitchCommand(tabid) {
   try {
     await activateTabById(browser, tabid);
     const page = await getTargetPage(browser, tabid);
+    const realTabid = await getPageTargetId(page);
+    setLastActiveTabId(realTabid);
     return {
       success: true,
-      tabid: await getPageTargetId(page),
+      tabid: realTabid,
       url: page.url(),
       title: await page.title()
     };
@@ -775,7 +1019,7 @@ async function tabsForwardCommand(tabid) {
 // package.json
 var package_default = {
   name: "@opentiny/webmcp-cli",
-  version: "0.0.3",
+  version: "0.0.6",
   type: "module",
   description: "WebMCP CLI for AI Agents to interact with browser via Puppeteer",
   main: "dist/index.js",
@@ -815,6 +1059,7 @@ var package_default = {
     clipboardy: "^5.3.1",
     commander: "^11.1.0",
     json5: "^2.2.3",
+    marked: "^15.0.7",
     picocolors: "^1.0.0",
     "puppeteer-core": "^22.0.0"
   },
@@ -875,9 +1120,66 @@ function cleanOldLogs(baseDir, logDir) {
   } catch (e) {
   }
 }
+function formatLogResult(result) {
+  if (result === void 0 || result === null) {
+    return "null";
+  }
+  try {
+    if (typeof result !== "object") {
+      return String(result);
+    }
+    const clone = JSON.parse(JSON.stringify(result));
+    let a11yTreeStr = "";
+    let searchResultStr = "";
+    if (clone && Array.isArray(clone.content) && clone.content.length > 0 && clone.content[0] && typeof clone.content[0].text === "string") {
+      const text = clone.content[0].text;
+      if (text.startsWith("\u6D4F\u89C8\u5668\u72B6\u6001: ")) {
+        let jsonStr = text.substring("\u6D4F\u89C8\u5668\u72B6\u6001: ".length);
+        let extraAlerts = "";
+        const firstNewline = jsonStr.indexOf("\n");
+        if (firstNewline !== -1) {
+          extraAlerts = jsonStr.substring(firstNewline);
+          jsonStr = jsonStr.substring(0, firstNewline);
+        }
+        try {
+          const parsed = JSON.parse(jsonStr);
+          if (parsed && typeof parsed.content === "string") {
+            a11yTreeStr = parsed.content;
+            parsed.content = "[Formatted A11y Tree - See details below]";
+            clone.content[0].text = `\u6D4F\u89C8\u5668\u72B6\u6001: ${JSON.stringify(parsed, null, 2)}${extraAlerts}`;
+          }
+        } catch {
+        }
+      } else if (text.includes("A11y Tree \u641C\u7D22\u7ED3\u679C") || text.includes("\u65E0\u969C\u788D\u6811\u641C\u7D22\u7ED3\u679C") || text.includes("\u65E0\u969C\u788D\u6811\u641C\u7D22") || text.includes("\u547D\u4E2D\u884C") || text.includes("context:")) {
+        searchResultStr = text;
+        clone.content[0].text = "[Search A11y Tree Result - See details below]";
+      }
+    }
+    let out = JSON.stringify(clone, null, 2);
+    if (a11yTreeStr) {
+      out += `
+
+[FORMATTED A11Y TREE]:
+${a11yTreeStr}`;
+    }
+    if (searchResultStr) {
+      out += `
+
+[FORMATTED SEARCH RESULT]:
+${searchResultStr}`;
+    }
+    return out;
+  } catch (e) {
+    try {
+      return JSON.stringify(result, null, 2);
+    } catch {
+      return String(result);
+    }
+  }
+}
 function writeLog(commandName, args, result, error) {
   try {
-    const baseDir = process.env.WEBMCP_WORKSPACE || path2.join(os2.homedir(), ".webmcp_chrome_profile");
+    const baseDir = process.env.WEBMCP_WORKSPACE || path2.join(os3.homedir(), ".webmcp_chrome_profile");
     const logDir = path2.join(baseDir, "logs");
     if (!fs2.existsSync(logDir)) {
       fs2.mkdirSync(logDir, { recursive: true });
@@ -900,15 +1202,8 @@ ${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";
-      }
+      const formattedResult = formatLogResult(result);
+      logText += formattedResult.split("\n").map((line) => `  ${line}`).join("\n") + "\n";
     } else {
       logText += `RESULT: null
 `;
@@ -938,7 +1233,7 @@ program.command("state").description("\u83B7\u53D6\u6D4F\u89C8\u5668\u5F53\u524D
   try {
     const result = await stateCommand(args);
     writeLog("state", args, result);
-    console.log(JSON.stringify(result, null, 2));
+    console.log(formatLogResult(result));
   } catch (error) {
     handleCommandError(error, "state", args);
   }
@@ -972,7 +1267,7 @@ program.command("run <toolName> [args...]").description("\u5411\u6307\u5B9A\u987
       tabid: parseTabId(options.tabid)
     });
     writeLog("run", { ...rawArgs, finalArgsJson }, result);
-    console.log(JSON.stringify(result, null, 2));
+    console.log(formatLogResult(result));
   } catch (error) {
     handleCommandError(error, "run", { ...rawArgs, finalArgsJson });
   }