web-probe-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1641 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/state.ts
+var state_exports = {};
+__export(state_exports, {
+  checkTimeout: () => checkTimeout,
+  clearState: () => clearState,
+  getStateDir: () => getStateDir,
+  loadState: () => loadState,
+  saveState: () => saveState,
+  updateActivity: () => updateActivity
+});
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function ensureDir() {
+  if (!existsSync(STATE_DIR)) {
+    mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+function loadState() {
+  try {
+    if (!existsSync(STATE_FILE)) return null;
+    const raw = readFileSync(STATE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveState(port, pid, timeoutMinutes = 30) {
+  ensureDir();
+  const state = {
+    port,
+    pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    timeoutMinutes,
+    lastActivityAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+  try {
+    chmodSync(STATE_FILE, 384);
+  } catch {
+  }
+}
+function updateActivity() {
+  const state = loadState();
+  if (!state) return;
+  state.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
+  ensureDir();
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+}
+function clearState() {
+  try {
+    if (existsSync(STATE_FILE)) {
+      unlinkSync(STATE_FILE);
+    }
+  } catch {
+  }
+}
+function getStateDir() {
+  return STATE_DIR;
+}
+function checkTimeout() {
+  const state = loadState();
+  if (!state) return { expired: false, minutesIdle: 0 };
+  const lastActivity = new Date(state.lastActivityAt).getTime();
+  const now = Date.now();
+  const minutesIdle = (now - lastActivity) / 1e3 / 60;
+  if (minutesIdle >= state.timeoutMinutes) {
+    return { expired: true, minutesIdle: Math.round(minutesIdle) };
+  }
+  return { expired: false, minutesIdle: Math.round(minutesIdle) };
+}
+var STATE_DIR, STATE_FILE;
+var init_state = __esm({
+  "src/core/state.ts"() {
+    "use strict";
+    STATE_DIR = join(homedir(), ".web-probe");
+    STATE_FILE = join(STATE_DIR, "state.json");
+  }
+});
+
+// src/utils/platform.ts
+import { existsSync as existsSync2 } from "fs";
+import { execSync } from "child_process";
+import { platform } from "os";
+function getPlatform() {
+  return platform();
+}
+function findChromePath() {
+  const plat = getPlatform();
+  const candidates = CHROME_PATHS[plat] ?? [];
+  for (const p of candidates) {
+    if (p && existsSync2(p)) return p;
+  }
+  try {
+    if (plat === "win32") {
+      const result = execSync("where chrome.exe 2>nul", { encoding: "utf-8" }).trim();
+      const first = result.split("\n")[0]?.trim();
+      if (first && existsSync2(first)) return first;
+    } else {
+      const result = execSync("which google-chrome 2>/dev/null || which chromium 2>/dev/null", {
+        encoding: "utf-8"
+      }).trim();
+      if (result) return result;
+    }
+  } catch {
+  }
+  return null;
+}
+function getChromeVersion(chromePath) {
+  const plat = getPlatform();
+  try {
+    if (plat === "darwin") {
+      const plistPath = chromePath.replace("/MacOS/Google Chrome", "/Info.plist");
+      const output2 = execSync(
+        `/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}" 2>/dev/null`,
+        { encoding: "utf-8" }
+      ).trim();
+      return output2 || null;
+    }
+    if (plat === "win32") {
+      const output2 = execSync(
+        `powershell -NoProfile -Command "(Get-Item '${chromePath}').VersionInfo.FileVersion"`,
+        { encoding: "utf-8", stdio: "pipe" }
+      ).trim();
+      return output2 || null;
+    }
+    const output = execSync(`"${chromePath}" --version 2>/dev/null`, { encoding: "utf-8" }).trim();
+    const match = output.match(/[\d.]+/);
+    return match ? match[0] : null;
+  } catch {
+    return null;
+  }
+}
+var CHROME_PATHS;
+var init_platform = __esm({
+  "src/utils/platform.ts"() {
+    "use strict";
+    CHROME_PATHS = {
+      darwin: [
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium"
+      ],
+      linux: [
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium-browser",
+        "/usr/bin/chromium",
+        "/snap/bin/chromium"
+      ],
+      win32: [
+        `${process.env.PROGRAMFILES}\\Google\\Chrome\\Application\\chrome.exe`,
+        `${process.env["PROGRAMFILES(X86)"]}\\Google\\Chrome\\Application\\chrome.exe`,
+        `${process.env.LOCALAPPDATA}\\Google\\Chrome\\Application\\chrome.exe`
+      ]
+    };
+  }
+});
+
+// src/core/port-manager.ts
+var port_manager_exports = {};
+__export(port_manager_exports, {
+  discoverFromProcess: () => discoverFromProcess,
+  discoverPort: () => discoverPort,
+  generatePort: () => generatePort,
+  verifyPort: () => verifyPort,
+  waitForPort: () => waitForPort
+});
+import { execSync as execSync2 } from "child_process";
+function generatePort() {
+  return Math.floor(Math.random() * (PORT_MAX - PORT_MIN + 1)) + PORT_MIN;
+}
+async function verifyPort(port) {
+  try {
+    const resp = await fetch(`http://127.0.0.1:${port}/json/version`, {
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!resp.ok) return false;
+    const data = await resp.json();
+    return typeof data["Browser"] === "string";
+  } catch {
+    return false;
+  }
+}
+function discoverFromProcess() {
+  const plat = getPlatform();
+  try {
+    if (plat === "win32") {
+      const output = execSync2(
+        `powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"Name='chrome.exe'\\" | Select-Object -ExpandProperty CommandLine"`,
+        { encoding: "utf-8", stdio: "pipe" }
+      );
+      const match = output.match(/--remote-debugging-port=(\d+)/);
+      if (match) return parseInt(match[1], 10);
+    } else {
+      const output = execSync2(
+        "ps aux | grep -E 'remote-debugging-port=' | grep -v grep",
+        { encoding: "utf-8" }
+      );
+      const match = output.match(/--remote-debugging-port=(\d+)/);
+      if (match) return parseInt(match[1], 10);
+    }
+  } catch {
+  }
+  return null;
+}
+async function discoverPort() {
+  const state = loadState();
+  if (state?.port) {
+    const valid = await verifyPort(state.port);
+    if (valid) return state.port;
+  }
+  const fromProcess = discoverFromProcess();
+  if (fromProcess) {
+    const valid = await verifyPort(fromProcess);
+    if (valid) return fromProcess;
+  }
+  for (const fallback of [9222, 19222]) {
+    const valid = await verifyPort(fallback);
+    if (valid) return fallback;
+  }
+  return null;
+}
+async function waitForPort(port, timeoutMs = 1e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await verifyPort(port)) return true;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return false;
+}
+var PORT_MIN, PORT_MAX;
+var init_port_manager = __esm({
+  "src/core/port-manager.ts"() {
+    "use strict";
+    init_state();
+    init_platform();
+    PORT_MIN = 2e4;
+    PORT_MAX = 29999;
+  }
+});
+
+// src/core/chrome-launcher.ts
+import { spawn, execSync as execSync3 } from "child_process";
+function isChromeRunning() {
+  const plat = getPlatform();
+  try {
+    if (plat === "darwin") {
+      const out = execSync3("pgrep -f 'Google Chrome' 2>/dev/null || true", { encoding: "utf-8" });
+      return out.trim().length > 0;
+    }
+    if (plat === "linux") {
+      const out = execSync3("pgrep -f '(chrome|chromium)' 2>/dev/null || true", { encoding: "utf-8" });
+      return out.trim().length > 0;
+    }
+    if (plat === "win32") {
+      const out = execSync3('tasklist /FI "IMAGENAME eq chrome.exe" /NH 2>nul', { encoding: "utf-8" });
+      return out.toLowerCase().includes("chrome.exe");
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function launchChrome(requestedPort) {
+  const existingPort = await discoverPort();
+  if (existingPort) {
+    const state = loadState();
+    return {
+      port: existingPort,
+      pid: state?.pid ?? 0,
+      alreadyRunning: true
+    };
+  }
+  const port = requestedPort ?? generatePort();
+  const chromePath = findChromePath();
+  if (!chromePath) {
+    throw new Error("\u672A\u627E\u5230 Chrome \u6D4F\u89C8\u5668\uFF0C\u8BF7\u5148\u5B89\u88C5 Google Chrome");
+  }
+  const running = isChromeRunning();
+  if (running) {
+    throw new Error(
+      "Chrome \u5DF2\u5728\u8FD0\u884C\u4F46\u672A\u5F00\u542F\u8C03\u8BD5\u7AEF\u53E3\u3002\n\u8BF7\u5148\u5173\u95ED\u6240\u6709 Chrome \u7A97\u53E3\uFF0C\u7136\u540E\u91CD\u65B0\u8FD0\u884C web-probe chrome start\u3002\n\uFF08\u65E0\u6CD5\u4E3A\u5DF2\u8FD0\u884C\u7684 Chrome \u8FFD\u52A0\u8C03\u8BD5\u53C2\u6570\uFF09"
+    );
+  }
+  const plat = getPlatform();
+  const args = [
+    `--remote-debugging-port=${port}`,
+    "--no-first-run",
+    "--no-default-browser-check"
+  ];
+  const child = spawn(chromePath, args, {
+    detached: true,
+    stdio: "ignore",
+    shell: plat === "win32"
+  });
+  child.unref();
+  const pid = child.pid ?? 0;
+  const ready = await waitForPort(port, 15e3);
+  if (!ready) {
+    throw new Error(`Chrome \u8C03\u8BD5\u7AEF\u53E3 ${port} \u542F\u52A8\u8D85\u65F6\uFF0815\u79D2\uFF09\uFF0C\u8BF7\u68C0\u67E5 Chrome \u662F\u5426\u6B63\u5E38\u8FD0\u884C`);
+  }
+  saveState(port, pid);
+  return { port, pid, alreadyRunning: false };
+}
+async function stopChrome() {
+  const state = loadState();
+  if (!state) return null;
+  const { port, pid } = state;
+  if (pid > 0) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      if (getPlatform() === "win32") {
+        try {
+          execSync3(`taskkill /PID ${pid} /F 2>nul`, { stdio: "pipe" });
+        } catch {
+        }
+      }
+    }
+  }
+  clearState();
+  return { port };
+}
+async function getChromeStatus() {
+  const state = loadState();
+  if (!state) {
+    const discovered = await discoverPort();
+    if (discovered) {
+      return { running: true, port: discovered };
+    }
+    return { running: false };
+  }
+  const valid = await verifyPort(state.port);
+  if (!valid) {
+    clearState();
+    return { running: false };
+  }
+  return {
+    running: true,
+    port: state.port,
+    pid: state.pid,
+    startedAt: state.startedAt
+  };
+}
+var init_chrome_launcher = __esm({
+  "src/core/chrome-launcher.ts"() {
+    "use strict";
+    init_platform();
+    init_state();
+    init_port_manager();
+  }
+});
+
+// src/core/output.ts
+import chalk from "chalk";
+function printJSON(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printTable(headers, rows) {
+  const colWidths = headers.map((h, i) => {
+    const maxData = rows.reduce((max, row) => Math.max(max, (row[i] ?? "").length), 0);
+    return Math.max(h.length, maxData);
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(colWidths[i])).join("  ");
+  console.log(chalk.bold(headerLine));
+  for (const row of rows) {
+    const line = row.map((cell, i) => (cell ?? "").padEnd(colWidths[i])).join("  ");
+    console.log(line);
+  }
+}
+function printSuccess(message) {
+  console.log(chalk.green("\u2705 " + message));
+}
+function printError(message) {
+  console.error(chalk.red("\u274C " + message));
+}
+function printWarn(message) {
+  console.log(chalk.yellow("\u26A0\uFE0F  " + message));
+}
+function printInfo(message) {
+  console.log(chalk.blue("\u2139\uFE0F  " + message));
+}
+function printStatus(label, ok, detail) {
+  const badge = ok ? chalk.green("[OK]     ") : chalk.yellow("[WARN]   ");
+  console.log(`  ${badge} ${label}${detail ? ` (${detail})` : ""}`);
+}
+function printHeader(title) {
+  console.log();
+  console.log(chalk.bold(title));
+  console.log();
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+var init_output = __esm({
+  "src/core/output.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/chrome.ts
+var chrome_exports = {};
+__export(chrome_exports, {
+  chromeRestart: () => chromeRestart,
+  chromeStart: () => chromeStart,
+  chromeStatus: () => chromeStatus,
+  chromeStop: () => chromeStop
+});
+async function chromeStart(options) {
+  try {
+    const port = options.port ? parseInt(options.port, 10) : void 0;
+    const result = await launchChrome(port);
+    if (options.json) {
+      printJSON(result);
+      return;
+    }
+    if (result.alreadyRunning) {
+      printInfo(`\u8C03\u8BD5\u7AEF\u53E3\u5DF2\u5F00\u542F (\u7AEF\u53E3 ${result.port})`);
+    } else {
+      printSuccess(`Chrome \u8C03\u8BD5\u7AEF\u53E3\u5DF2\u542F\u52A8 (\u7AEF\u53E3 ${result.port}, PID ${result.pid})`);
+    }
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+async function chromeStop(options) {
+  const result = await stopChrome();
+  if (options.json) {
+    printJSON(result ? { stopped: true, port: result.port } : { stopped: false });
+    return;
+  }
+  if (result) {
+    printSuccess(`\u8C03\u8BD5\u7AEF\u53E3\u5DF2\u5173\u95ED (\u7AEF\u53E3 ${result.port})`);
+    printInfo("Chrome \u6D4F\u89C8\u5668\u7EE7\u7EED\u8FD0\u884C\uFF0C\u767B\u5F55\u72B6\u6001\u4E0D\u53D7\u5F71\u54CD");
+  } else {
+    printInfo("\u6CA1\u6709\u6D3B\u8DC3\u7684\u8C03\u8BD5\u7AEF\u53E3");
+  }
+}
+async function chromeStatus(options) {
+  const status = await getChromeStatus();
+  if (options.json) {
+    printJSON(status);
+    return;
+  }
+  if (status.running) {
+    printSuccess(`\u8C03\u8BD5\u7AEF\u53E3\u8FD0\u884C\u4E2D (\u7AEF\u53E3 ${status.port}${status.pid ? `, PID ${status.pid}` : ""})`);
+    if (status.startedAt) {
+      printInfo(`\u542F\u52A8\u65F6\u95F4: ${status.startedAt}`);
+    }
+  } else {
+    printInfo("\u8C03\u8BD5\u7AEF\u53E3\u672A\u8FD0\u884C");
+  }
+}
+async function chromeRestart(options) {
+  await stopChrome();
+  await chromeStart({ json: options.json });
+}
+var init_chrome = __esm({
+  "src/commands/chrome.ts"() {
+    "use strict";
+    init_chrome_launcher();
+    init_output();
+  }
+});
+
+// src/core/cdp-client.ts
+import CDP from "chrome-remote-interface";
+async function getPort() {
+  const port = await discoverPort();
+  if (!port) {
+    throw new Error(
+      "\u672A\u53D1\u73B0 Chrome \u8C03\u8BD5\u7AEF\u53E3\u3002\u8BF7\u5148\u8FD0\u884C\uFF1Aweb-probe chrome start"
+    );
+  }
+  updateActivity();
+  return port;
+}
+async function listTabs() {
+  const port = await getPort();
+  const targets = await CDP.List({ port });
+  return targets.filter((t) => t.type === "page").map((t) => ({
+    id: t.id,
+    url: t.url,
+    title: t.title,
+    type: t.type
+  }));
+}
+function resolveTabId(tabs, target) {
+  return tabs.find((t) => t.id === target) ?? tabs.find((t) => t.url.includes(target)) ?? tabs[parseInt(target, 10)];
+}
+async function connectTab(tabId) {
+  const port = await getPort();
+  const client = await CDP({ port, target: tabId });
+  return client;
+}
+async function evaluateInTab(tabId, expression) {
+  const client = await connectTab(tabId);
+  try {
+    await client.Runtime.enable();
+    const result = await client.Runtime.evaluate({
+      expression,
+      returnByValue: true,
+      awaitPromise: true
+    });
+    if (result.exceptionDetails) {
+      throw new Error(
+        result.exceptionDetails.text ?? result.exceptionDetails.exception?.description ?? "JavaScript \u6267\u884C\u9519\u8BEF"
+      );
+    }
+    return result.result.value;
+  } finally {
+    await client.close();
+  }
+}
+async function screenshotTab(tabId) {
+  const client = await connectTab(tabId);
+  try {
+    await client.Page.enable();
+    const { data } = await client.Page.captureScreenshot({ format: "png" });
+    return Buffer.from(data, "base64");
+  } finally {
+    await client.close();
+  }
+}
+async function inspectPage(tabId) {
+  const expression = `
+    (() => {
+      const getMeta = () => {
+        const metas = {};
+        document.querySelectorAll('meta[name], meta[property]').forEach(m => {
+          const key = m.getAttribute('name') || m.getAttribute('property');
+          if (key) metas[key] = m.getAttribute('content') || '';
+        });
+        return metas;
+      };
+
+      const getHeadings = () =>
+        [...document.querySelectorAll('h1,h2,h3,h4,h5,h6')].slice(0, 20).map(h => ({
+          tag: h.tagName,
+          text: h.textContent?.trim().slice(0, 100) || ''
+        }));
+
+      const getButtons = () =>
+        [...document.querySelectorAll('button, [role="button"], input[type="submit"], input[type="button"]')]
+          .slice(0, 30)
+          .map(b => b.textContent?.trim().slice(0, 50) || b.getAttribute('aria-label') || '')
+          .filter(Boolean);
+
+      const getLinks = () =>
+        [...document.querySelectorAll('a[href]')].slice(0, 30).map(a => ({
+          text: (a.textContent?.trim().slice(0, 50) || a.getAttribute('aria-label') || ''),
+          href: a.getAttribute('href') || ''
+        })).filter(l => l.text);
+
+      const getInputs = () =>
+        [...document.querySelectorAll('input, textarea, select')].slice(0, 20).map(el => ({
+          type: el.tagName.toLowerCase() === 'textarea' ? 'textarea' :
+                el.tagName.toLowerCase() === 'select' ? 'select' :
+                el.getAttribute('type') || 'text',
+          placeholder: el.getAttribute('placeholder') || '',
+          name: el.getAttribute('name') || el.getAttribute('id') || ''
+        }));
+
+      const detectFrameworks = () => {
+        const f = [];
+        if (window.__REACT_DEVTOOLS_GLOBAL_HOOK__ || document.querySelector('[data-reactroot]')) f.push('React');
+        if (window.__VUE__) f.push('Vue');
+        if (window.angular || document.querySelector('[ng-app], [data-ng-app]')) f.push('Angular');
+        if (document.querySelector('.ant-btn, .ant-layout, .ant-table')) f.push('Ant Design');
+        if (document.querySelector('.el-button, .el-table, .el-input')) f.push('Element UI');
+        if (document.querySelector('.v-application, .v-btn')) f.push('Vuetify');
+        if (document.querySelector('[class*="MuiButton"], [class*="MuiPaper"]')) f.push('Material UI');
+        return f;
+      };
+
+      const bodyText = document.body?.innerText?.trim().slice(0, 500) || '';
+
+      return JSON.stringify({
+        url: location.href,
+        title: document.title,
+        meta: getMeta(),
+        headings: getHeadings(),
+        buttons: getButtons(),
+        links: getLinks(),
+        inputs: getInputs(),
+        images: document.querySelectorAll('img').length,
+        frameworks: detectFrameworks(),
+        bodyTextPreview: bodyText
+      });
+    })()
+  `;
+  const result = await evaluateInTab(tabId, expression);
+  return JSON.parse(result);
+}
+async function clickElement(tabId, selector) {
+  await evaluateInTab(tabId, `
+    (() => {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) throw new Error('\u5143\u7D20\u672A\u627E\u5230: ' + ${JSON.stringify(selector)});
+      el.click();
+      return 'clicked';
+    })()
+  `);
+}
+async function typeInElement(tabId, selector, text) {
+  await evaluateInTab(tabId, `
+    (() => {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) throw new Error('\u5143\u7D20\u672A\u627E\u5230: ' + ${JSON.stringify(selector)});
+      el.focus();
+      el.value = ${JSON.stringify(text)};
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      return 'typed';
+    })()
+  `);
+}
+async function navigateTab(tabId, url) {
+  const client = await connectTab(tabId);
+  try {
+    await client.Page.enable();
+    await client.Page.navigate({ url });
+    await client.Page.loadEventFired();
+  } finally {
+    await client.close();
+  }
+}
+async function getHTML(tabId, selector) {
+  if (selector) {
+    return await evaluateInTab(tabId, `
+      (() => {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        return el ? el.outerHTML : null;
+      })()
+    `);
+  }
+  return await evaluateInTab(tabId, "document.documentElement.outerHTML");
+}
+var init_cdp_client = __esm({
+  "src/core/cdp-client.ts"() {
+    "use strict";
+    init_port_manager();
+    init_state();
+  }
+});
+
+// src/commands/tabs.ts
+var tabs_exports = {};
+__export(tabs_exports, {
+  tabsCommand: () => tabsCommand
+});
+async function tabsCommand(options) {
+  try {
+    const tabs = await listTabs();
+    if (options.json) {
+      printJSON(tabs);
+      return;
+    }
+    if (tabs.length === 0) {
+      console.log("\u6CA1\u6709\u6253\u5F00\u7684\u6807\u7B7E\u9875");
+      return;
+    }
+    printTable(
+      ["ID", "URL", "TITLE"],
+      tabs.map((t) => [t.id.slice(0, 8), truncate(t.url, 55), truncate(t.title, 40)])
+    );
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_tabs = __esm({
+  "src/commands/tabs.ts"() {
+    "use strict";
+    init_cdp_client();
+    init_output();
+  }
+});
+
+// src/commands/inspect.ts
+var inspect_exports = {};
+__export(inspect_exports, {
+  inspectCommand: () => inspectCommand
+});
+async function inspectCommand(target, options) {
+  try {
+    const tabs = await listTabs();
+    const tab = resolveTabId(tabs, target);
+    if (!tab) {
+      throw new Error(`\u672A\u627E\u5230\u6807\u7B7E\u9875: ${target}
+\u4F7F\u7528 web-probe tabs \u67E5\u770B\u53EF\u7528\u6807\u7B7E\u9875`);
+    }
+    const info = await inspectPage(tab.id);
+    if (options.json !== false) {
+      printJSON(info);
+    } else {
+      printJSON(info);
+    }
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_inspect = __esm({
+  "src/commands/inspect.ts"() {
+    "use strict";
+    init_cdp_client();
+    init_output();
+  }
+});
+
+// src/commands/shot.ts
+var shot_exports = {};
+__export(shot_exports, {
+  shotCommand: () => shotCommand
+});
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+async function shotByUrl(url, outputPath) {
+  const { chromium } = await import("playwright-core");
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    await page.goto(url, { waitUntil: "networkidle" });
+    const outDir = join2(tmpdir(), "web-probe");
+    mkdirSync2(outDir, { recursive: true });
+    const filename = outputPath ?? join2(outDir, `shot-url-${Date.now()}.png`);
+    await page.screenshot({ path: filename, fullPage: true });
+    return filename;
+  } finally {
+    await browser.close();
+  }
+}
+async function shotCommand(target, options) {
+  try {
+    let filePath;
+    if (target.startsWith("http://") || target.startsWith("https://")) {
+      filePath = await shotByUrl(target, options.output);
+    } else {
+      const tabs = await listTabs();
+      const tab = resolveTabId(tabs, target);
+      if (!tab) {
+        throw new Error(`\u672A\u627E\u5230\u6807\u7B7E\u9875: ${target}
+\u4F7F\u7528 web-probe tabs \u67E5\u770B\u53EF\u7528\u6807\u7B7E\u9875`);
+      }
+      const buffer = await screenshotTab(tab.id);
+      const outDir = join2(tmpdir(), "web-probe");
+      mkdirSync2(outDir, { recursive: true });
+      filePath = options.output ?? join2(outDir, `shot-${tab.id.slice(0, 8)}-${Date.now()}.png`);
+      writeFileSync2(filePath, buffer);
+    }
+    if (options.json) {
+      printJSON({ path: filePath });
+    } else {
+      printSuccess(`\u622A\u56FE\u5DF2\u4FDD\u5B58: ${filePath}`);
+    }
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_shot = __esm({
+  "src/commands/shot.ts"() {
+    "use strict";
+    init_cdp_client();
+    init_output();
+  }
+});
+
+// src/commands/eval.ts
+var eval_exports = {};
+__export(eval_exports, {
+  evalCommand: () => evalCommand
+});
+async function evalCommand(target, javascript, options) {
+  try {
+    const tabs = await listTabs();
+    const tab = resolveTabId(tabs, target);
+    if (!tab) {
+      throw new Error(`\u672A\u627E\u5230\u6807\u7B7E\u9875: ${target}
+\u4F7F\u7528 web-probe tabs \u67E5\u770B\u53EF\u7528\u6807\u7B7E\u9875`);
+    }
+    const result = await evaluateInTab(tab.id, javascript);
+    if (options.json) {
+      printJSON({ result });
+    } else {
+      if (typeof result === "string") {
+        console.log(result);
+      } else {
+        printJSON(result);
+      }
+    }
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_eval = __esm({
+  "src/commands/eval.ts"() {
+    "use strict";
+    init_cdp_client();
+    init_output();
+  }
+});
+
+// src/commands/click.ts
+var click_exports = {};
+__export(click_exports, {
+  clickCommand: () => clickCommand
+});
+async function clickCommand(target, selector, options) {
+  try {
+    const tabs = await listTabs();
+    const tab = resolveTabId(tabs, target);
+    if (!tab) {
+      throw new Error(`\u672A\u627E\u5230\u6807\u7B7E\u9875: ${target}
+\u4F7F\u7528 web-probe tabs \u67E5\u770B\u53EF\u7528\u6807\u7B7E\u9875`);
+    }
+    await clickElement(tab.id, selector);
+    if (options.json) {
+      printJSON({ success: true, selector });
+    } else {
+      printSuccess(`\u5DF2\u70B9\u51FB: ${selector}`);
+    }
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_click = __esm({
+  "src/commands/click.ts"() {
+    "use strict";
+    init_cdp_client();
+    init_output();
+  }
+});
+
+// src/commands/type.ts
+var type_exports = {};
+__export(type_exports, {
+  typeCommand: () => typeCommand
+});
+async function typeCommand(target, selector, text, options) {
+  try {
+    const tabs = await listTabs();
+    const tab = resolveTabId(tabs, target);
+    if (!tab) {
+      throw new Error(`\u672A\u627E\u5230\u6807\u7B7E\u9875: ${target}
+\u4F7F\u7528 web-probe tabs \u67E5\u770B\u53EF\u7528\u6807\u7B7E\u9875`);
+    }
+    await typeInElement(tab.id, selector, text);
+    if (options.json) {
+      printJSON({ success: true, selector, text });
+    } else {
+      printSuccess(`\u5DF2\u8F93\u5165: "${text}" \u2192 ${selector}`);
+    }
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_type = __esm({
+  "src/commands/type.ts"() {
+    "use strict";
+    init_cdp_client();
+    init_output();
+  }
+});
+
+// src/commands/nav.ts
+var nav_exports = {};
+__export(nav_exports, {
+  navCommand: () => navCommand
+});
+async function navCommand(target, url, options) {
+  try {
+    const tabs = await listTabs();
+    const tab = resolveTabId(tabs, target);
+    if (!tab) {
+      throw new Error(`\u672A\u627E\u5230\u6807\u7B7E\u9875: ${target}
+\u4F7F\u7528 web-probe tabs \u67E5\u770B\u53EF\u7528\u6807\u7B7E\u9875`);
+    }
+    await navigateTab(tab.id, url);
+    if (options.json) {
+      printJSON({ success: true, url });
+    } else {
+      printSuccess(`\u5DF2\u5BFC\u822A\u5230: ${url}`);
+    }
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_nav = __esm({
+  "src/commands/nav.ts"() {
+    "use strict";
+    init_cdp_client();
+    init_output();
+  }
+});
+
+// src/commands/html.ts
+var html_exports = {};
+__export(html_exports, {
+  htmlCommand: () => htmlCommand
+});
+async function htmlCommand(target, selector, options) {
+  try {
+    const tabs = await listTabs();
+    const tab = resolveTabId(tabs, target);
+    if (!tab) {
+      throw new Error(`\u672A\u627E\u5230\u6807\u7B7E\u9875: ${target}
+\u4F7F\u7528 web-probe tabs \u67E5\u770B\u53EF\u7528\u6807\u7B7E\u9875`);
+    }
+    const html = await getHTML(tab.id, selector);
+    if (options?.json) {
+      printJSON({ html });
+    } else {
+      console.log(html);
+    }
+  } catch (err) {
+    if (options?.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_html = __esm({
+  "src/commands/html.ts"() {
+    "use strict";
+    init_cdp_client();
+    init_output();
+  }
+});
+
+// src/utils/detect-tools.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, copyFileSync, writeFileSync as writeFileSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+function checkAnyExists(paths) {
+  return paths.some((p) => existsSync3(p));
+}
+function detectAITools() {
+  const home = homedir2();
+  const toolDefs = [
+    {
+      name: "cursor",
+      displayName: "Cursor",
+      skillDir: join3(home, ".cursor", "skills", "web-probe"),
+      skillFile: "SKILL.md",
+      format: "skill.md",
+      detectPaths: [
+        join3(home, ".cursor"),
+        join3(home, ".cursor", "skills")
+      ]
+    },
+    {
+      name: "claude-code",
+      displayName: "Claude Code",
+      skillDir: join3(home, ".claude", "skills", "web-probe"),
+      skillFile: "SKILL.md",
+      format: "skill.md",
+      detectPaths: [
+        join3(home, ".claude"),
+        join3(home, ".claude", "skills")
+      ]
+    },
+    {
+      name: "codex",
+      displayName: "Codex (OpenAI)",
+      skillDir: join3(home, ".codex", "skills", "web-probe"),
+      skillFile: "SKILL.md",
+      format: "skill.md",
+      detectPaths: [
+        join3(home, ".codex"),
+        join3(home, ".codex", "skills")
+      ]
+    },
+    {
+      name: "agents",
+      displayName: "Agents (\u901A\u7528\u6807\u51C6)",
+      skillDir: join3(home, ".agents", "skills", "web-probe"),
+      skillFile: "SKILL.md",
+      format: "skill.md",
+      detectPaths: [
+        join3(home, ".agents"),
+        join3(home, ".agents", "skills")
+      ]
+    },
+    {
+      name: "opencode",
+      displayName: "OpenCode",
+      skillDir: join3(home, ".config", "opencode", "skills", "web-probe"),
+      skillFile: "SKILL.md",
+      format: "skill.md",
+      detectPaths: [
+        join3(home, ".config", "opencode"),
+        join3(home, ".config", "opencode", "skills")
+      ]
+    },
+    {
+      name: "windsurf",
+      displayName: "Windsurf",
+      skillDir: join3(home, ".codeium", "windsurf"),
+      skillFile: "web-probe-rules.md",
+      format: "rules-file",
+      detectPaths: [
+        join3(home, ".codeium", "windsurf"),
+        join3(home, ".codeium")
+      ]
+    },
+    {
+      name: "copilot",
+      displayName: "GitHub Copilot",
+      skillDir: join3(home, ".github", "agents"),
+      skillFile: "web-probe.md",
+      format: "agents-md",
+      detectPaths: [
+        join3(home, ".github")
+      ]
+    },
+    {
+      name: "trae",
+      displayName: "Trae",
+      skillDir: join3(home, ".trae", "rules"),
+      skillFile: "web-probe.md",
+      format: "rules-file",
+      detectPaths: [
+        join3(home, ".trae")
+      ]
+    }
+  ];
+  return toolDefs.map((def) => {
+    const detected = checkAnyExists(def.detectPaths);
+    const installed = existsSync3(join3(def.skillDir, def.skillFile));
+    return { ...def, detected, installed };
+  });
+}
+function installSkill(target, skillSourcePath) {
+  mkdirSync3(target.skillDir, { recursive: true });
+  const dest = join3(target.skillDir, target.skillFile);
+  if (target.format === "skill.md") {
+    copyFileSync(skillSourcePath, dest);
+  } else {
+    const content = readFileSync2(skillSourcePath, "utf-8");
+    const stripped = content.replace(/^---[\s\S]*?---\n*/m, "");
+    writeFileSync3(dest, stripped, "utf-8");
+  }
+}
+var init_detect_tools = __esm({
+  "src/utils/detect-tools.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  doctorCommand: () => doctorCommand
+});
+import { execSync as execSync4 } from "child_process";
+async function diagnose() {
+  const nodeVersion = process.version;
+  let npxOk = false;
+  try {
+    execSync4("npx --version", { encoding: "utf-8", stdio: "pipe" });
+    npxOk = true;
+  } catch {
+  }
+  const chromePath = findChromePath();
+  const chromeVersion = chromePath ? getChromeVersion(chromePath) : null;
+  const state = loadState();
+  let cdpOk = false;
+  if (state?.port) {
+    cdpOk = await verifyPort(state.port);
+  }
+  let playwrightVersion = null;
+  try {
+    playwrightVersion = execSync4("npx playwright-core --version 2>/dev/null", {
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+  } catch {
+    try {
+      const pkg = await import("playwright-core/package.json", { with: { type: "json" } });
+      playwrightVersion = pkg.default?.version ?? null;
+    } catch {
+    }
+  }
+  const aiTools = detectAITools();
+  const tools = aiTools.map((t) => ({
+    name: t.name,
+    displayName: t.displayName,
+    detected: t.detected,
+    installed: t.installed
+  }));
+  return {
+    node: { ok: true, version: nodeVersion },
+    npx: { ok: npxOk },
+    chrome: { ok: !!chromePath, version: chromeVersion, path: chromePath },
+    cdp: { ok: cdpOk, port: state?.port ?? null, pid: state?.pid ?? null },
+    playwright: { ok: !!playwrightVersion, version: playwrightVersion },
+    tools
+  };
+}
+async function doctorCommand(options) {
+  const result = await diagnose();
+  if (options.json) {
+    printJSON(result);
+    return;
+  }
+  printHeader("\u{1F50D} web-probe \u2014 \u73AF\u5883\u8BCA\u65AD");
+  console.log("\u57FA\u7840\u4F9D\u8D56");
+  printStatus("Node.js", result.node.ok, result.node.version);
+  printStatus("npx", result.npx.ok, result.npx.ok ? "" : "\u672A\u627E\u5230");
+  console.log();
+  console.log("Chrome \u6D4F\u89C8\u5668");
+  printStatus("Chrome", result.chrome.ok, result.chrome.ok ? `\u5DF2\u5B89\u88C5${result.chrome.version ? ` (${result.chrome.version})` : ""}` : "\u672A\u627E\u5230");
+  printStatus(
+    "\u8C03\u8BD5\u7AEF\u53E3",
+    result.cdp.ok,
+    result.cdp.ok ? `\u5DF2\u5F00\u542F (\u7AEF\u53E3 ${result.cdp.port}, PID ${result.cdp.pid})` : "\u672A\u5F00\u542F"
+  );
+  console.log();
+  console.log("\u5F15\u64CE");
+  printStatus(
+    "Playwright",
+    result.playwright.ok,
+    result.playwright.ok ? result.playwright.version ?? "" : "\u672A\u5B89\u88C5"
+  );
+  console.log();
+  console.log("AI \u5DE5\u5177 Skill \u6CE8\u5165\u72B6\u6001");
+  const detectedTools = result.tools.filter((t) => t.detected);
+  const undetectedTools = result.tools.filter((t) => !t.detected);
+  if (detectedTools.length > 0) {
+    for (const tool of detectedTools) {
+      printStatus(
+        tool.displayName,
+        tool.installed,
+        tool.installed ? "\u5DF2\u6CE8\u5165" : "\u5DF2\u68C0\u6D4B\u5230\uFF0C\u672A\u6CE8\u5165 Skill"
+      );
+    }
+  }
+  if (undetectedTools.length > 0) {
+    const names = undetectedTools.map((t) => t.displayName).join(", ");
+    console.log(`  ${"         "} ${names} \u2014 \u672A\u68C0\u6D4B\u5230`);
+  }
+  const needsSkill = detectedTools.some((t) => !t.installed);
+  console.log();
+  const allCore = result.node.ok && result.chrome.ok;
+  if (allCore) {
+    printSuccess("\u6838\u5FC3\u7EC4\u4EF6\u5C31\u7EEA");
+    if (needsSkill) {
+      printWarn("\u90E8\u5206 AI \u5DE5\u5177\u672A\u6CE8\u5165 Skill\uFF0C\u8FD0\u884C web-probe skill install \u8FDB\u884C\u6CE8\u5165");
+    }
+  } else {
+    printWarn("\u90E8\u5206\u7EC4\u4EF6\u7F3A\u5931\uFF0C\u8FD0\u884C web-probe setup \u8FDB\u884C\u5B89\u88C5");
+  }
+}
+var init_doctor = __esm({
+  "src/commands/doctor.ts"() {
+    "use strict";
+    init_platform();
+    init_state();
+    init_port_manager();
+    init_detect_tools();
+    init_output();
+  }
+});
+
+// src/commands/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  setupCommand: () => setupCommand
+});
+import { execSync as execSync5 } from "child_process";
+import chalk2 from "chalk";
+function step(num, total, label, fn) {
+  process.stdout.write(`[${num}/${total}] ${label}`);
+  try {
+    const result = fn();
+    if (result === true || typeof result === "string") {
+      console.log(chalk2.green(` \u2713${typeof result === "string" ? ` (${result})` : ""}`));
+      return true;
+    }
+    console.log(chalk2.red(" \u2717"));
+    return false;
+  } catch (err) {
+    console.log(chalk2.red(` \u2717 ${err.message}`));
+    return false;
+  }
+}
+async function setupCommand(options) {
+  if (options.json) {
+    const results = {};
+    results.chrome = !!findChromePath();
+    try {
+      execSync5("npx playwright-core --version 2>/dev/null", { stdio: "pipe" });
+      results.playwright = true;
+    } catch {
+      results.playwright = false;
+    }
+    printJSON(results);
+    return;
+  }
+  console.log();
+  console.log(chalk2.bold("\u{1F680} web-probe \u2014 \u4E00\u952E\u5B89\u88C5"));
+  console.log();
+  const total = 3;
+  step(1, total, "\u68C0\u6D4B Chrome...", () => {
+    const path = findChromePath();
+    if (!path) throw new Error("\u672A\u627E\u5230 Chrome\uFF0C\u8BF7\u5148\u5B89\u88C5");
+    return true;
+  });
+  step(2, total, "\u68C0\u6D4B Playwright...", () => {
+    try {
+      __require.resolve("playwright-core");
+      return "\u5DF2\u5B89\u88C5";
+    } catch {
+      return "\u4F5C\u4E3A web-probe \u4F9D\u8D56\u5DF2\u5305\u542B";
+    }
+  });
+  step(3, total, "\u68C0\u6D4B\u73AF\u5883...", () => {
+    return true;
+  });
+  console.log();
+  printSuccess("\u73AF\u5883\u68C0\u6D4B\u5B8C\u6210\uFF01");
+  console.log();
+  console.log("  \u8FD0\u884C " + chalk2.cyan("web-probe skill install") + " \u6CE8\u5165 Skill \u5230 AI \u5DE5\u5177");
+  console.log("  \u8FD0\u884C " + chalk2.cyan("web-probe chrome start") + " \u542F\u52A8 Chrome \u8C03\u8BD5\u7AEF\u53E3");
+  console.log();
+}
+var init_setup = __esm({
+  "src/commands/setup.ts"() {
+    "use strict";
+    init_platform();
+    init_output();
+  }
+});
+
+// src/commands/explore.ts
+var explore_exports = {};
+__export(explore_exports, {
+  exploreCommand: () => exploreCommand
+});
+async function loadStagehand() {
+  try {
+    return await import("@browserbasehq/stagehand");
+  } catch {
+    throw new Error(
+      "explore \u547D\u4EE4\u9700\u8981\u5B89\u88C5 Stagehand\uFF08\u53EF\u9009\u4F9D\u8D56\uFF09\uFF1A\n\n  npm install @browserbasehq/stagehand zod\n\n\u540C\u65F6\u9700\u8981\u8BBE\u7F6E LLM API Key \u73AF\u5883\u53D8\u91CF\uFF1A\n  export OPENAI_API_KEY=sk-...\n  # \u6216 export ANTHROPIC_API_KEY=sk-ant-..."
+    );
+  }
+}
+function checkApiKey() {
+  if (process.env.OPENAI_API_KEY) {
+    return { model: "openai/gpt-4o", provider: "OpenAI" };
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { model: "anthropic/claude-sonnet-4-20250514", provider: "Anthropic" };
+  }
+  throw new Error(
+    "\u672A\u68C0\u6D4B\u5230 LLM API Key\u3002explore \u547D\u4EE4\u9700\u8981 AI \u6A21\u578B\u9A71\u52A8\u3002\n\n\u8BF7\u8BBE\u7F6E\u4EE5\u4E0B\u4EFB\u4E00\u73AF\u5883\u53D8\u91CF\uFF1A\n  export OPENAI_API_KEY=sk-...\n  export ANTHROPIC_API_KEY=sk-ant-..."
+  );
+}
+async function exploreCommand(url, goal, options) {
+  try {
+    const { Stagehand } = await loadStagehand();
+    const { model: defaultModel, provider } = checkApiKey();
+    const model = options?.model ?? defaultModel;
+    const chromePath = findChromePath();
+    if (!options?.json) {
+      printHeader("\u{1F50D} web-probe explore \u2014 AI \u81EA\u4E3B\u63A2\u7D22");
+      printInfo(`\u76EE\u6807: ${url}`);
+      if (goal) printInfo(`\u4EFB\u52A1: ${goal}`);
+      printInfo(`\u6A21\u578B: ${model} (${provider})`);
+      console.log();
+    }
+    const stagehand = new Stagehand({
+      env: "LOCAL",
+      modelName: model,
+      headless: options?.headless ?? true,
+      localBrowserLaunchOptions: {
+        executablePath: chromePath ?? void 0
+      }
+    });
+    await stagehand.init();
+    const page = stagehand.context.pages()[0];
+    await page.goto(url, { waitUntil: "networkidle" });
+    const results = [];
+    const observations = await stagehand.observe(
+      goal ?? "\u89C2\u5BDF\u9875\u9762\u4E0A\u6240\u6709\u53EF\u4EA4\u4E92\u7684\u5143\u7D20\u548C\u4E3B\u8981\u5185\u5BB9\u533A\u57DF"
+    );
+    results.push({ step: "observe", data: observations });
+    if (goal) {
+      try {
+        await stagehand.act(goal);
+        results.push({ step: "act", data: { action: goal, success: true } });
+      } catch (err) {
+        results.push({ step: "act", data: { action: goal, success: false, error: err.message } });
+      }
+    }
+    const pageInfo = await page.evaluate(() => ({
+      url: location.href,
+      title: document.title,
+      bodyText: document.body?.innerText?.trim().slice(0, 500) ?? ""
+    }));
+    results.push({ step: "page_info", data: pageInfo });
+    await stagehand.close();
+    if (options?.json) {
+      printJSON({ url, goal, model, results });
+    } else {
+      printSuccess("\u63A2\u7D22\u5B8C\u6210");
+      console.log();
+      for (const r of results) {
+        console.log(`  [${r.step}]`);
+        if (r.data) {
+          const lines = JSON.stringify(r.data, null, 2).split("\n");
+          for (const line of lines.slice(0, 15)) {
+            console.log(`    ${line}`);
+          }
+          if (lines.length > 15) console.log(`    ... (${lines.length - 15} more lines)`);
+        }
+        console.log();
+      }
+    }
+  } catch (err) {
+    if (options?.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_explore = __esm({
+  "src/commands/explore.ts"() {
+    "use strict";
+    init_output();
+    init_platform();
+  }
+});
+
+// src/commands/skill.ts
+var skill_exports = {};
+__export(skill_exports, {
+  skillInstallCommand: () => skillInstallCommand
+});
+import { join as join4, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync4 } from "fs";
+import { createInterface } from "readline";
+import chalk3 from "chalk";
+function getSkillSource() {
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join4(currentDir, "..", "src", "skill", "SKILL.md"),
+    join4(currentDir, "skill", "SKILL.md"),
+    join4(currentDir, "..", "skill", "SKILL.md")
+  ];
+  for (const p of candidates) {
+    if (existsSync4(p)) return p;
+  }
+  throw new Error(`Skill \u6A21\u677F\u6587\u4EF6\u672A\u627E\u5230\uFF0C\u641C\u7D22\u8DEF\u5F84: ${candidates.join(", ")}`);
+}
+async function askUser(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function printToolTable(tools) {
+  console.log();
+  console.log(chalk3.bold("  #   \u5DE5\u5177                \u72B6\u6001"));
+  console.log("  " + "\u2500".repeat(45));
+  tools.forEach((t, i) => {
+    const status = t.installed ? chalk3.green("\u5DF2\u6CE8\u5165 \u2713") : t.detected ? chalk3.yellow("\u5DF2\u68C0\u6D4B\u5230\uFF0C\u672A\u6CE8\u5165") : chalk3.gray("\u672A\u68C0\u6D4B\u5230");
+    console.log(`  ${String(i + 1).padStart(2)}  ${t.displayName.padEnd(18)} ${status}`);
+  });
+  console.log();
+}
+async function skillInstallCommand(options) {
+  try {
+    const skillSource = getSkillSource();
+    const tools = detectAITools();
+    if (options.target) {
+      const tool = tools.find((t) => t.name === options.target);
+      if (!tool) {
+        const names = tools.map((t) => t.name).join(", ");
+        throw new Error(`\u672A\u77E5\u76EE\u6807: ${options.target}\uFF0C\u53EF\u7528: ${names}`);
+      }
+      installSkill(tool, skillSource);
+      if (options.json) {
+        printJSON({ installed: [tool.name], path: join4(tool.skillDir, tool.skillFile) });
+        return;
+      }
+      printSuccess(`Skill \u5DF2\u6CE8\u5165\u5230 ${tool.displayName} (${join4(tool.skillDir, tool.skillFile)})`);
+      return;
+    }
+    const detected = tools.filter((t) => t.detected);
+    const notInstalled = detected.filter((t) => !t.installed);
+    if (options.json) {
+      const installed = [];
+      for (const tool of detected) {
+        installSkill(tool, skillSource);
+        installed.push(tool.name);
+      }
+      printJSON({
+        detected: detected.map((t) => t.name),
+        installed,
+        all_tools: tools.map((t) => ({ name: t.name, detected: t.detected, installed: t.installed }))
+      });
+      return;
+    }
+    console.log();
+    console.log(chalk3.bold("\u{1F50D} web-probe \u2014 AI \u5DE5\u5177\u68C0\u6D4B"));
+    printToolTable(tools);
+    if (detected.length === 0) {
+      printWarn("\u672A\u68C0\u6D4B\u5230\u4EFB\u4F55 AI \u5DE5\u5177");
+      console.log();
+      printInfo("\u53EF\u4EE5\u624B\u52A8\u6307\u5B9A\u76EE\u6807\u5DE5\u5177\uFF1A");
+      console.log(`  ${chalk3.cyan("web-probe skill install --target cursor")}`);
+      console.log(`  ${chalk3.cyan("web-probe skill install --target claude-code")}`);
+      console.log();
+      console.log("  \u53EF\u7528\u76EE\u6807: " + tools.map((t) => chalk3.cyan(t.name)).join(", "));
+      console.log();
+      return;
+    }
+    if (notInstalled.length === 0 && !options.yes) {
+      printSuccess("\u6240\u6709\u68C0\u6D4B\u5230\u7684 AI \u5DE5\u5177\u5DF2\u6CE8\u5165 Skill");
+      const answer = await askUser("  \u662F\u5426\u91CD\u65B0\u6CE8\u5165\u4EE5\u66F4\u65B0\uFF1F(y/N) ");
+      if (answer.toLowerCase() !== "y") return;
+    }
+    const toInstall = options.yes ? detected : detected;
+    if (!options.yes && notInstalled.length > 0) {
+      const names = notInstalled.map((t) => chalk3.cyan(t.displayName)).join(", ");
+      console.log(`  \u68C0\u6D4B\u5230 ${notInstalled.length} \u4E2A\u5DE5\u5177\u672A\u6CE8\u5165: ${names}`);
+      const answer = await askUser("  \u662F\u5426\u5168\u90E8\u6CE8\u5165\uFF1F(Y/n) ");
+      if (answer.toLowerCase() === "n") return;
+    }
+    console.log();
+    for (const tool of toInstall) {
+      installSkill(tool, skillSource);
+      printSuccess(`${tool.displayName} \u2192 ${join4(tool.skillDir, tool.skillFile)}`);
+    }
+    console.log();
+    printSuccess(`\u5DF2\u5B8C\u6210 ${toInstall.length} \u4E2A\u5DE5\u5177\u7684 Skill \u6CE8\u5165`);
+    console.log();
+  } catch (err) {
+    if (options.json) {
+      printJSON({ error: err.message });
+      process.exitCode = 1;
+      return;
+    }
+    printError(err.message);
+    process.exitCode = 1;
+  }
+}
+var init_skill = __esm({
+  "src/commands/skill.ts"() {
+    "use strict";
+    init_detect_tools();
+    init_output();
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname = dirname2(fileURLToPath2(import.meta.url));
+function getVersion() {
+  try {
+    const pkgPath = join5(__dirname, "..", "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+async function autoTimeoutCheck() {
+  const { checkTimeout: checkTimeout2, loadState: loadState2, clearState: clearState2 } = await Promise.resolve().then(() => (init_state(), state_exports));
+  const { verifyPort: verifyPort2 } = await Promise.resolve().then(() => (init_port_manager(), port_manager_exports));
+  const { expired, minutesIdle } = checkTimeout2();
+  if (!expired) return;
+  const state = loadState2();
+  if (!state) return;
+  const stillAlive = await verifyPort2(state.port);
+  if (stillAlive && state.pid > 0) {
+    try {
+      process.kill(state.pid, "SIGTERM");
+    } catch {
+    }
+  }
+  clearState2();
+  const chalk4 = (await import("chalk")).default;
+  console.error(
+    chalk4.yellow(`\u23F1\uFE0F  \u8C03\u8BD5\u7AEF\u53E3\u5DF2\u7A7A\u95F2 ${minutesIdle} \u5206\u949F\uFF0C\u5DF2\u81EA\u52A8\u5173\u95ED (\u7AEF\u53E3 ${state.port})`)
+  );
+}
+var program = new Command();
+program.name("web-probe").description("AI \u6D4F\u89C8\u5668\u81EA\u52A8\u5316 CLI \u5DE5\u5177").version(getVersion(), "-v, --version").hook("preAction", async () => {
+  await autoTimeoutCheck();
+});
+var chrome = program.command("chrome").description("Chrome \u8C03\u8BD5\u7AEF\u53E3\u7BA1\u7406");
+chrome.command("start").description("\u542F\u52A8 Chrome \u8C03\u8BD5\u7AEF\u53E3").option("--port <port>", "\u6307\u5B9A\u7AEF\u53E3\uFF08\u9ED8\u8BA4\u968F\u673A 20000-29999\uFF09").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (opts) => {
+  const { chromeStart: chromeStart2 } = await Promise.resolve().then(() => (init_chrome(), chrome_exports));
+  await chromeStart2(opts);
+});
+chrome.command("stop").description("\u5173\u95ED\u8C03\u8BD5\u7AEF\u53E3\uFF08\u4E0D\u5173 Chrome \u672C\u4F53\uFF09").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (opts) => {
+  const { chromeStop: chromeStop2 } = await Promise.resolve().then(() => (init_chrome(), chrome_exports));
+  await chromeStop2(opts);
+});
+chrome.command("status").description("\u663E\u793A\u5F53\u524D\u8C03\u8BD5\u7AEF\u53E3\u72B6\u6001").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (opts) => {
+  const { chromeStatus: chromeStatus2 } = await Promise.resolve().then(() => (init_chrome(), chrome_exports));
+  await chromeStatus2(opts);
+});
+chrome.command("restart").description("\u91CD\u542F\u8C03\u8BD5\uFF08\u65B0\u968F\u673A\u7AEF\u53E3\uFF09").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (opts) => {
+  const { chromeRestart: chromeRestart2 } = await Promise.resolve().then(() => (init_chrome(), chrome_exports));
+  await chromeRestart2(opts);
+});
+program.command("tabs").description("\u5217\u51FA\u6240\u6709\u6253\u5F00\u7684\u6807\u7B7E\u9875").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (opts) => {
+  const { tabsCommand: tabsCommand2 } = await Promise.resolve().then(() => (init_tabs(), tabs_exports));
+  await tabsCommand2(opts);
+});
+program.command("inspect <target>").description("\u63D0\u53D6\u9875\u9762\u5B8C\u6574\u7ED3\u6784\uFF08JSON \u8F93\u51FA\uFF09").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA", true).action(async (target, opts) => {
+  const { inspectCommand: inspectCommand2 } = await Promise.resolve().then(() => (init_inspect(), inspect_exports));
+  await inspectCommand2(target, opts);
+});
+program.command("shot <target>").description("\u622A\u56FE\uFF08target \u53EF\u4EE5\u662F tabId \u6216 URL\uFF09").option("-o, --output <path>", "\u6307\u5B9A\u8F93\u51FA\u8DEF\u5F84").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (target, opts) => {
+  const { shotCommand: shotCommand2 } = await Promise.resolve().then(() => (init_shot(), shot_exports));
+  await shotCommand2(target, opts);
+});
+program.command("eval <target> <javascript>").description("\u5728\u6807\u7B7E\u9875\u4E2D\u6267\u884C JavaScript").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (target, javascript, opts) => {
+  const { evalCommand: evalCommand2 } = await Promise.resolve().then(() => (init_eval(), eval_exports));
+  await evalCommand2(target, javascript, opts);
+});
+program.command("click <target> <selector>").description("\u70B9\u51FB\u5143\u7D20").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (target, selector, opts) => {
+  const { clickCommand: clickCommand2 } = await Promise.resolve().then(() => (init_click(), click_exports));
+  await clickCommand2(target, selector, opts);
+});
+program.command("type <target> <selector> <text>").description("\u5728\u5143\u7D20\u4E2D\u8F93\u5165\u6587\u5B57").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (target, selector, text, opts) => {
+  const { typeCommand: typeCommand2 } = await Promise.resolve().then(() => (init_type(), type_exports));
+  await typeCommand2(target, selector, text, opts);
+});
+program.command("nav <target> <url>").description("\u5BFC\u822A\u6807\u7B7E\u9875\u5230\u65B0 URL").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (target, url, opts) => {
+  const { navCommand: navCommand2 } = await Promise.resolve().then(() => (init_nav(), nav_exports));
+  await navCommand2(target, url, opts);
+});
+program.command("html <target> [selector]").description("\u63D0\u53D6 HTML \u5185\u5BB9").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (target, selector, opts) => {
+  const { htmlCommand: htmlCommand2 } = await Promise.resolve().then(() => (init_html(), html_exports));
+  await htmlCommand2(target, selector, opts);
+});
+program.command("doctor").description("\u73AF\u5883\u8BCA\u65AD\uFF08\u68C0\u67E5\u6240\u6709\u4F9D\u8D56\uFF0C\u8F93\u51FA\u72B6\u6001\u8868\uFF09").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (opts) => {
+  const { doctorCommand: doctorCommand2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+  await doctorCommand2(opts);
+});
+program.command("setup").description("\u4E00\u952E\u5B89\u88C5\u6240\u6709\u4F9D\u8D56 + \u914D\u7F6E").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (opts) => {
+  const { setupCommand: setupCommand2 } = await Promise.resolve().then(() => (init_setup(), setup_exports));
+  await setupCommand2(opts);
+});
+program.command("explore <url> [goal]").description("AI \u81EA\u4E3B\u63A2\u7D22\u7F51\u7AD9\uFF08\u9700\u5B89\u88C5 @browserbasehq/stagehand\uFF09").option("--model <model>", "LLM \u6A21\u578B\uFF08\u9ED8\u8BA4\u6839\u636E API Key \u81EA\u52A8\u9009\u62E9\uFF09").option("--no-headless", "\u663E\u793A\u6D4F\u89C8\u5668\u7A97\u53E3").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (url, goal, opts) => {
+  const { exploreCommand: exploreCommand2 } = await Promise.resolve().then(() => (init_explore(), explore_exports));
+  await exploreCommand2(url, goal, opts);
+});
+var skill = program.command("skill").description("Skill \u7BA1\u7406");
+skill.command("install").description("\u68C0\u6D4B AI \u5DE5\u5177\u5E76\u6CE8\u5165 Skill").option("--target <tool>", "\u6307\u5B9A\u76EE\u6807\u5DE5\u5177 (cursor|claude-code|codex|agents|opencode|windsurf|copilot|trae)").option("-y, --yes", "\u8DF3\u8FC7\u786E\u8BA4\uFF0C\u81EA\u52A8\u6CE8\u5165\u6240\u6709\u68C0\u6D4B\u5230\u7684\u5DE5\u5177").option("--json", "JSON \u683C\u5F0F\u8F93\u51FA").action(async (opts) => {
+  const { skillInstallCommand: skillInstallCommand2 } = await Promise.resolve().then(() => (init_skill(), skill_exports));
+  await skillInstallCommand2(opts);
+});
+program.parse();
+//# sourceMappingURL=index.js.map