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

package/dist/bin.js

@@ -1,14 +1,10 @@
 #!/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 pc2 from "picocolors";
+import { readFileSync } from "fs";
+import { resolve } from "path";
 
 // src/browser.ts
 import puppeteer from "puppeteer-core";
@@ -16,20 +12,34 @@ import pc from "picocolors";
 import fs from "fs";
 import os from "os";
 import path from "path";
+import http from "http";
 import { spawn } from "child_process";
 import { fileURLToPath } from "url";
 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 httpGet(url, timeoutMs = 1500) {
+  return new Promise((resolve2, reject) => {
+    const req = http.get(url, { timeout: timeoutMs }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk.toString();
+      });
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          resolve2(data);
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}`));
+        }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("request timeout"));
+    });
+  });
 }
 function promiseWithTimeout(promise, timeoutMs = 5e3, errorMsg = "Operation timed out") {
   let timeoutId;
@@ -45,8 +55,8 @@ function promiseWithTimeout(promise, timeoutMs = 5e3, errorMsg = "Operation time
 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;
+      await httpGet(url, 1500);
+      return true;
     } catch {
     }
     if (i < retries - 1) {
@@ -55,45 +65,6 @@ async function checkCdpReady(url, retries = 3) {
   }
   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 getDefaultBrowserPath() {
   const platform = os.platform();
   if (platform === "darwin") {
@@ -156,20 +127,18 @@ async function startBrowserInBackground() {
   child.unref();
   for (let i = 0; i < 20; i++) {
     try {
-      const urls = [`http://localhost:${CDP_PORT}/json/version`, `http://127.0.0.1:${CDP_PORT}/json/version`];
+      const urls = [`http://127.0.0.1:${CDP_PORT}/json/version`, `http://localhost:${CDP_PORT}/json/version`];
       for (const url of urls) {
         try {
-          const response = await fetchWithTimeout(url, 1e3);
-          if (response.ok) {
-            console.log(pc.green(`${browserInfo.name} \u542F\u52A8\u5E76\u5C31\u7EEA\u3002`));
-            return;
-          }
+          await httpGet(url, 1e3);
+          console.log(pc.green(`${browserInfo.name} \u542F\u52A8\u5E76\u5C31\u7EEA\u3002`));
+          return;
         } catch (err) {
         }
       }
     } catch (e) {
     }
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    await new Promise((resolve2) => setTimeout(resolve2, 500));
   }
   throw new Error(`${browserInfo.name} \u542F\u52A8\u8D85\u65F6\uFF0C\u65E0\u6CD5\u8FDE\u63A5\u5230 CDP \u7AEF\u53E3\u3002`);
 }
@@ -190,90 +159,51 @@ async function connectBrowser() {
       return false;
     }
   };
-  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");
+  const portAddresses = [
+    `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", "");
+    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`
+      );
+      console.log(pc.green(`connectBrowser: \u6210\u529F\u8FDE\u63A5 ${browserURL}`));
+      return browser2;
+    } catch {
     }
-    console.log(pc.yellow("connectBrowser: \u6B63\u5728\u5C1D\u8BD5\u8FDE\u63A5 127.0.0.1:9222..."));
-    const browser2 = 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 browser2;
-  } catch (error) {
+  }
+  console.log(pc.yellow(`connectBrowser: \u7AEF\u53E3 ${CDP_PORT} \u65E0\u54CD\u5E94\uFF0C\u6B63\u5728\u542F\u52A8\u65B0\u7684\u6D4F\u89C8\u5668\u5B9E\u4F8B...`));
+  try {
+    await startBrowserInBackground();
+  } catch (launchError) {
+    const msg = launchError instanceof Error ? launchError.message : String(launchError);
+    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 {
-      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..."));
+      console.log(pc.yellow(`connectBrowser: \u6D4F\u89C8\u5668\u5DF2\u542F\u52A8\uFF0C\u6B63\u5728\u8FDE\u63A5 ${browserURL}...`));
       const browser2 = await promiseWithTimeout(
-        puppeteer.connect({
-          browserURL: `http://localhost:${CDP_PORT}`,
-          defaultViewport: null,
-          targetFilter
-        }),
+        puppeteer.connect({ browserURL, defaultViewport: null, targetFilter }),
         1e4,
-        "puppeteer.connect to localhost timed out"
+        `puppeteer.connect to ${browserURL} after launch timed out`
       );
-      console.log(pc.green("connectBrowser: \u6210\u529F\u8FDE\u63A5 localhost:9222"));
+      console.log(pc.green(`connectBrowser: \u6210\u529F\u8FDE\u63A5 ${browserURL}`));
       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 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 browser2 = 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 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 browser2 = 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 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\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.");
-      }
+    } 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`);
 }
 async function getPageTargetId(page2) {
   const session = await page2.target().createCDPSession();
@@ -351,14 +281,12 @@ async function getTargetPage(browser2, tabid2) {
       let activeTargetId = null;
       for (const url of urls) {
         try {
-          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://"));
-            if (active) {
-              activeTargetId = active.id;
-              break;
-            }
+          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 {
         }
@@ -404,7 +332,7 @@ async function injectWebMCPPolyfillAndTools(page2, force = false) {
       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 new Promise((resolve2) => setTimeout(resolve2, 300));
   }
   await injectDomainTools(page2);
 }
@@ -492,7 +420,7 @@ async function stateCommand({ tabid: tabid2 }) {
         if (pUrl.startsWith("devtools://")) return null;
         const pTitle = await Promise.race([
           p.title().catch(() => "Unknown"),
-          new Promise((resolve) => setTimeout(() => resolve("Unknown"), 500))
+          new Promise((resolve2) => setTimeout(() => resolve2("Unknown"), 500))
         ]);
         return {
           // 使用真实的 Chrome target ID，而非数组下标
@@ -512,6 +440,7 @@ async function stateCommand({ tabid: tabid2 }) {
 }
 
 // src/commands/run.ts
+import JSON5 from "json5";
 async function runCommand({
   toolName,
   argsJson,
@@ -520,10 +449,15 @@ async function runCommand({
   const browser2 = await connectBrowser();
   try {
     const page2 = await getTargetPage(browser2, tabid2);
+    let cleanedArgs = argsJson.trim();
+    if (cleanedArgs.startsWith("'") && cleanedArgs.endsWith("'")) {
+      cleanedArgs = cleanedArgs.slice(1, -1).trim();
+    }
     try {
-      JSON.parse(argsJson);
+      const obj = JSON5.parse(cleanedArgs);
+      cleanedArgs = JSON.stringify(obj);
     } catch (e) {
-      throw new Error(`\u53C2\u6570\u4E0D\u662F\u6709\u6548\u7684 JSON: ${e.message}`);
+      throw new Error(`\u53C2\u6570\u4E0D\u662F\u6709\u6548\u7684 JSON \u6216 JS \u5BF9\u8C61: ${e.message}`);
     }
     const result2 = await page2.evaluate(async (name, inputString) => {
       const mcp = navigator.modelContextTesting || navigator.modelContext;
@@ -537,8 +471,7 @@ async function runCommand({
         } catch (e) {
         }
       }
-      return res;
-    }, toolName, argsJson);
+    }, toolName, cleanedArgs);
     return result2;
   } finally {
     await browser2.disconnect();
@@ -598,7 +531,7 @@ async function tabsOpenCommand(url) {
     url = normalizeUrl(url);
     await page2.goto(url, { waitUntil: "domcontentloaded" });
     await injectIntoPage(page2);
-    await new Promise((resolve) => setTimeout(resolve, 500));
+    await new Promise((resolve2) => setTimeout(resolve2, 500));
     return {
       success: true,
       tabid: await getPageTargetId(page2),
@@ -699,7 +632,7 @@ async function tabsForwardCommand(tabid2) {
 // package.json
 var package_default = {
   name: "@opentiny/webmcp-cli",
-  version: "0.0.1-alpha.3",
+  version: "0.0.1-alpha.5",
   type: "module",
   description: "WebMCP CLI for AI Agents to interact with browser via Puppeteer",
   main: "dist/index.js",
@@ -738,6 +671,7 @@ var package_default = {
     "@page-agent/page-controller": "catalog:",
     clipboardy: "^5.3.1",
     commander: "^11.1.0",
+    json5: "^2.2.3",
     picocolors: "^1.0.0",
     "puppeteer-core": "^22.0.0"
   },
@@ -752,6 +686,13 @@ var package_default = {
 
 // src/bin.ts
 var program = new Command();
+function cleanJsonString(str) {
+  let cleaned = str.trim();
+  if (cleaned.startsWith("'") && cleaned.endsWith("'")) {
+    cleaned = cleaned.slice(1, -1).trim();
+  }
+  return cleaned;
+}
 function parseTabId(id) {
   if (!id) return void 0;
   return id;
@@ -761,6 +702,19 @@ function handleCommandError(error, commandName) {
   console.error(pc2.red(`Error executing ${commandName} command: ${msg}`));
   process.exit(1);
 }
+function expandFileRefs(argsJson) {
+  return argsJson.replace(/"@(base64)?file:([^"]+)"/g, (_match, base64Flag, filePath) => {
+    const absPath = resolve(process.cwd(), filePath);
+    let content;
+    try {
+      content = readFileSync(absPath, "utf-8");
+    } catch (e) {
+      throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6\u5F15\u7528 "${filePath}": ${e.message}`);
+    }
+    const value = base64Flag ? Buffer.from(content, "utf-8").toString("base64") : content;
+    return JSON.stringify(value);
+  });
+}
 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) {
@@ -775,11 +729,54 @@ program.command("state").description("\u83B7\u53D6\u6D4F\u89C8\u5668\u5F53\u524D
     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) => {
+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(
+  "-f, --file <path>",
+  `\u4ECE\u6307\u5B9A .json \u6587\u4EF6\u8BFB\u53D6\u6574\u4E2A\u53C2\u6570\uFF08\u6587\u4EF6\u5185\u5BB9\u5373\u4E3A\u53C2\u6570 JSON\uFF09\u3002
+\u5982\u9700\u5728\u53C2\u6570\u4E2D\u5185\u8054\u5F15\u7528\u6587\u4EF6\uFF0C\u4F7F\u7528\u5360\u4F4D\u7B26\u8BED\u6CD5\uFF1A
+  @file:<path>       \u8BFB\u53D6\u6587\u4EF6\u539F\u59CB\u6587\u672C
+  @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) => {
   try {
+    let finalArgsJson = "";
+    if (options.file) {
+      const filePath = resolve(process.cwd(), options.file);
+      try {
+        finalArgsJson = readFileSync(filePath, "utf-8").trim();
+      } catch (e) {
+        throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 "${filePath}": ${e.message}`);
+      }
+    } else if (args && args.length > 0) {
+      const firstArg = args[0].trim();
+      const cleanedFirstArg = cleanJsonString(firstArg);
+      if (cleanedFirstArg.startsWith("{") && cleanedFirstArg.endsWith("}")) {
+        finalArgsJson = args.map(cleanJsonString).join(" ");
+      } else {
+        const obj = {};
+        for (const pair of args) {
+          const index = pair.indexOf("=");
+          if (index === -1) {
+            throw new Error(`\u65E0\u6548\u7684\u53C2\u6570\u683C\u5F0F "${pair}"\u3002\u5FC5\u987B\u662F JSON \u5B57\u7B26\u4E32\u6216 key=value \u683C\u5F0F\u3002`);
+          }
+          const key = pair.substring(0, index).trim();
+          let val = pair.substring(index + 1).trim();
+          val = cleanJsonString(val);
+          try {
+            obj[key] = JSON.parse(val);
+          } catch {
+            obj[key] = val;
+          }
+        }
+        finalArgsJson = JSON.stringify(obj);
+      }
+    }
+    if (!finalArgsJson) {
+      throw new Error("\u5FC5\u987B\u63D0\u4F9B\u53C2\u6570\u6216\u901A\u8FC7 -f/--file \u6307\u5B9A\u53C2\u6570\u6587\u4EF6");
+    }
+    finalArgsJson = expandFileRefs(finalArgsJson);
     const result2 = await runCommand({
       toolName,
-      argsJson,
+      argsJson: finalArgsJson,
       tabid: parseTabId(options.tabid)
     });
     console.log(JSON.stringify(result2, null, 2));