browser-web-search 0.1.0

package/dist/index.js

@@ -0,0 +1,691 @@
+#!/usr/bin/env node
+
+// src/commands/site.ts
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join, relative } from "path";
+import { homedir } from "os";
+
+// src/openclaw-bridge.ts
+import { execFileSync } from "child_process";
+
+// src/openclaw-json.ts
+function buildPreview(raw) {
+  return raw.length > 200 ? `${raw.slice(0, 200)}...` : raw;
+}
+function tryParseJson(raw) {
+  try {
+    return { ok: true, value: JSON.parse(raw) };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+function tryParseLastJsonLineBlock(raw) {
+  const lines = raw.split(/\r?\n/);
+  for (let end = lines.length; end > 0; end -= 1) {
+    for (let start = end - 1; start >= 0; start -= 1) {
+      const candidate = lines.slice(start, end).join("\n").trim();
+      if (!candidate) {
+        continue;
+      }
+      const parsed = tryParseJson(candidate);
+      if (parsed.ok) {
+        return parsed;
+      }
+    }
+  }
+  return null;
+}
+function parseOpenClawJson(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new Error("OpenClaw returned empty output");
+  }
+  const direct = tryParseJson(trimmed);
+  if (direct.ok) {
+    return direct.value;
+  }
+  const lineBlock = tryParseLastJsonLineBlock(trimmed);
+  if (lineBlock) {
+    return lineBlock.value;
+  }
+  throw new Error(`Failed to parse OpenClaw JSON output: ${direct.error.message}
+Raw (preview): ${buildPreview(trimmed)}`);
+}
+
+// src/openclaw-bridge.ts
+var OPENCLAW_EVALUATE_TIMEOUT_MS = 12e4;
+var EXEC_TIMEOUT_BUFFER_MS = 5e3;
+function buildOpenClawArgs(args, timeout) {
+  const [subcommand, ...rest] = args;
+  if (!subcommand) {
+    throw new Error("OpenClaw browser command requires a subcommand");
+  }
+  return ["openclaw", "browser", subcommand, "--timeout", String(timeout), ...rest];
+}
+function getOpenClawExecTimeout(timeout) {
+  return timeout + EXEC_TIMEOUT_BUFFER_MS;
+}
+function runOpenClaw(args, timeout) {
+  return execFileSync("npx", buildOpenClawArgs(args, timeout), {
+    encoding: "utf-8",
+    timeout: getOpenClawExecTimeout(timeout),
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function ocGetTabs() {
+  const raw = runOpenClaw(["tabs", "--json"], 15e3);
+  const data = parseOpenClawJson(raw);
+  return (data.tabs || []).filter((tab) => tab.type === "page");
+}
+function ocFindTabByDomain(tabs, domain) {
+  return tabs.find((tab) => {
+    try {
+      const hostname = new URL(tab.url).hostname;
+      return hostname === domain || hostname.endsWith(`.${domain}`);
+    } catch {
+      return false;
+    }
+  });
+}
+function ocOpenTab(url) {
+  const raw = runOpenClaw(["open", url, "--json"], 3e4);
+  const data = parseOpenClawJson(raw);
+  return data.id || data.targetId || "";
+}
+function ocEvaluate(targetId, fn) {
+  const raw = runOpenClaw(["evaluate", "--fn", fn, "--target-id", targetId], OPENCLAW_EVALUATE_TIMEOUT_MS);
+  return parseOpenClawJson(raw);
+}
+
+// src/jq.ts
+function splitTopLevel(input, separator) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let inString = false;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const prev = input[i - 1];
+    if (char === '"' && prev !== "\\") inString = !inString;
+    if (!inString) {
+      if (char === "{" || char === "(" || char === "[") depth++;
+      if (char === "}" || char === ")" || char === "]") depth--;
+      if (depth === 0 && input.slice(i, i + separator.length) === separator) {
+        parts.push(current.trim());
+        current = "";
+        i += separator.length - 1;
+        continue;
+      }
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+function parseLiteral(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) return JSON.parse(trimmed);
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null") return null;
+  return Number(trimmed);
+}
+function getField(value, field) {
+  return value !== null && typeof value === "object" ? value[field] : void 0;
+}
+function applySegment(inputs, expr) {
+  if (expr === ".") return inputs;
+  if (expr.startsWith("select(")) {
+    const match = expr.match(/^select\((.+?)\s*(==|>)\s*(.+)\)$/);
+    if (!match) throw new Error(`\u4E0D\u652F\u6301\u7684 jq \u8868\u8FBE\u5F0F: ${expr}`);
+    const [, leftExpr, op, rightExpr] = match;
+    const expected = parseLiteral(rightExpr);
+    return inputs.filter((item) => {
+      const left = applyExpression([item], leftExpr)[0];
+      return op === "==" ? left === expected : Number(left) > Number(expected);
+    });
+  }
+  if (expr.startsWith("{") && expr.endsWith("}")) {
+    const body = expr.slice(1, -1).trim();
+    if (!body) return inputs.map(() => ({}));
+    const entries = splitTopLevel(body, ",");
+    return inputs.map((item) => {
+      const obj = {};
+      for (const entry of entries) {
+        const colon = entry.indexOf(":");
+        if (colon === -1) {
+          const key = entry.trim().replace(/^\./, "");
+          obj[key] = applyExpression([item], `.${key}`)[0];
+        } else {
+          const key = entry.slice(0, colon).trim();
+          const valueExpr = entry.slice(colon + 1).trim();
+          obj[key] = applyExpression([item], valueExpr)[0];
+        }
+      }
+      return obj;
+    });
+  }
+  if (!expr.startsWith(".")) throw new Error(`\u4E0D\u652F\u6301\u7684 jq \u8868\u8FBE\u5F0F: ${expr}`);
+  let current = inputs;
+  let remaining = expr.slice(1);
+  while (remaining.length > 0) {
+    if (remaining.startsWith("[]")) {
+      current = current.flatMap((item) => Array.isArray(item) ? item : []);
+      remaining = remaining.slice(2);
+    } else if (remaining.startsWith("[")) {
+      const match = remaining.match(/^\[(-?\d+)\]/);
+      if (!match) throw new Error(`\u4E0D\u652F\u6301\u7684 jq \u8868\u8FBE\u5F0F: .${remaining}`);
+      const index = Number(match[1]);
+      current = current.map((item) => {
+        if (!Array.isArray(item)) return void 0;
+        return item[index >= 0 ? index : item.length + index];
+      });
+      remaining = remaining.slice(match[0].length);
+    } else if (remaining.startsWith(".")) {
+      remaining = remaining.slice(1);
+    } else {
+      const match = remaining.match(/^([A-Za-z_][A-Za-z0-9_]*)/);
+      if (!match) throw new Error(`\u4E0D\u652F\u6301\u7684 jq \u8868\u8FBE\u5F0F: .${remaining}`);
+      const field = match[1];
+      current = current.map((item) => getField(item, field));
+      remaining = remaining.slice(field.length);
+    }
+  }
+  return current;
+}
+function applyExpression(inputs, expression) {
+  const segments = splitTopLevel(expression.trim(), "|");
+  return segments.reduce((current, segment) => applySegment(current, segment.trim()), inputs);
+}
+function applyJq(data, expression) {
+  return applyExpression([data], expression).filter((item) => item !== void 0);
+}
+
+// src/commands/site.ts
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+var BWS_DIR = join(homedir(), ".bws");
+var LOCAL_SITES_DIR = join(BWS_DIR, "sites");
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var BUILTIN_SITES_DIR = join(__dirname, "../sites");
+function exitJsonError(error, extra = {}) {
+  console.log(JSON.stringify({ success: false, error, ...extra }, null, 2));
+  process.exit(1);
+}
+function parseSiteMeta(filePath, source) {
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const sitesDir = source === "local" ? LOCAL_SITES_DIR : BUILTIN_SITES_DIR;
+  const relPath = relative(sitesDir, filePath);
+  const defaultName = relPath.replace(/\.js$/, "").replace(/\\/g, "/");
+  const metaMatch = content.match(/\/\*\s*@meta\s*\n([\s\S]*?)\*\//);
+  if (metaMatch) {
+    try {
+      const metaJson = JSON.parse(metaMatch[1]);
+      return {
+        name: metaJson.name || defaultName,
+        description: metaJson.description || "",
+        domain: metaJson.domain || "",
+        args: metaJson.args || {},
+        capabilities: metaJson.capabilities,
+        readOnly: metaJson.readOnly,
+        example: metaJson.example,
+        filePath,
+        source
+      };
+    } catch {
+    }
+  }
+  const meta = {
+    name: defaultName,
+    description: "",
+    domain: "",
+    args: {},
+    filePath,
+    source
+  };
+  const tagPattern = /\/\/\s*@(\w+)[ \t]+(.*)/g;
+  let match;
+  while ((match = tagPattern.exec(content)) !== null) {
+    const [, key, value] = match;
+    switch (key) {
+      case "name":
+        meta.name = value.trim();
+        break;
+      case "description":
+        meta.description = value.trim();
+        break;
+      case "domain":
+        meta.domain = value.trim();
+        break;
+      case "args":
+        for (const arg of value.trim().split(/[,\s]+/).filter(Boolean)) {
+          meta.args[arg] = { required: true };
+        }
+        break;
+      case "example":
+        meta.example = value.trim();
+        break;
+    }
+  }
+  return meta;
+}
+function scanSites(dir, source) {
+  if (!existsSync(dir)) return [];
+  const sites = [];
+  function walk(currentDir) {
+    let entries;
+    try {
+      entries = readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        walk(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".js")) {
+        const meta = parseSiteMeta(fullPath, source);
+        if (meta) sites.push(meta);
+      }
+    }
+  }
+  walk(dir);
+  return sites;
+}
+function getAllSites() {
+  const builtin = scanSites(BUILTIN_SITES_DIR, "builtin");
+  const local = scanSites(LOCAL_SITES_DIR, "local");
+  const byName = /* @__PURE__ */ new Map();
+  for (const s of builtin) byName.set(s.name, s);
+  for (const s of local) byName.set(s.name, s);
+  return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function siteList(options) {
+  const sites = getAllSites();
+  if (sites.length === 0) {
+    if (options.json) {
+      console.log("[]");
+      return;
+    }
+    console.log("\u672A\u627E\u5230\u4EFB\u4F55 site adapter\u3002");
+    console.log(`  \u5185\u7F6E adapter \u76EE\u5F55: ${BUILTIN_SITES_DIR}`);
+    console.log(`  \u79C1\u6709 adapter \u76EE\u5F55: ${LOCAL_SITES_DIR}`);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(sites.map((s) => ({
+      name: s.name,
+      description: s.description,
+      domain: s.domain,
+      args: s.args,
+      source: s.source
+    })), null, 2));
+    return;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of sites) {
+    const platform = s.name.split("/")[0];
+    if (!groups.has(platform)) groups.set(platform, []);
+    groups.get(platform).push(s);
+  }
+  for (const [platform, items] of groups) {
+    console.log(`
+${platform}/`);
+    for (const s of items) {
+      const cmd = s.name.split("/").slice(1).join("/");
+      const src = s.source === "local" ? " (local)" : "";
+      const desc = s.description ? ` - ${s.description}` : "";
+      console.log(`  ${cmd.padEnd(20)}${desc}${src}`);
+    }
+  }
+  console.log();
+}
+function siteSearch(query, options) {
+  const sites = getAllSites();
+  const q = query.toLowerCase();
+  const matches = sites.filter(
+    (s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.domain.toLowerCase().includes(q)
+  );
+  if (matches.length === 0) {
+    if (options.json) {
+      console.log("[]");
+      return;
+    }
+    console.log(`\u672A\u627E\u5230\u5339\u914D "${query}" \u7684 adapter\u3002`);
+    console.log("  \u67E5\u770B\u6240\u6709: bws site list");
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(matches.map((s) => ({
+      name: s.name,
+      description: s.description,
+      domain: s.domain,
+      source: s.source
+    })), null, 2));
+    return;
+  }
+  for (const s of matches) {
+    const src = s.source === "local" ? " (local)" : "";
+    console.log(`${s.name.padEnd(24)} ${s.description}${src}`);
+  }
+}
+function findSiteByName(name) {
+  return getAllSites().find((site) => site.name === name);
+}
+function siteInfo(name, options) {
+  const site = findSiteByName(name);
+  if (!site) {
+    if (options.json) {
+      exitJsonError(`adapter "${name}" not found`, { action: "bws site list" });
+    }
+    console.error(`[error] site info: adapter "${name}" not found.`);
+    console.error("  Try: bws site list");
+    process.exit(1);
+  }
+  const meta = {
+    name: site.name,
+    description: site.description,
+    domain: site.domain,
+    args: site.args,
+    example: site.example,
+    readOnly: site.readOnly
+  };
+  if (options.json) {
+    console.log(JSON.stringify(meta, null, 2));
+    return;
+  }
+  console.log(`${site.name} \u2014 ${site.description}`);
+  console.log();
+  console.log("\u53C2\u6570\uFF1A");
+  const argEntries = Object.entries(site.args);
+  if (argEntries.length === 0) {
+    console.log("  \uFF08\u65E0\uFF09");
+  } else {
+    for (const [argName, argDef] of argEntries) {
+      const requiredText = argDef.required ? "\u5FC5\u586B" : "\u53EF\u9009";
+      const description = argDef.description || "";
+      console.log(`  ${argName} (${requiredText})    ${description}`.trimEnd());
+    }
+  }
+  console.log();
+  console.log("\u793A\u4F8B\uFF1A");
+  console.log(`  ${site.example || `bws site ${site.name}`}`);
+  console.log();
+  console.log(`\u57DF\u540D\uFF1A${site.domain || "\uFF08\u672A\u58F0\u660E\uFF09"}`);
+  console.log(`\u53EA\u8BFB\uFF1A${site.readOnly ? "\u662F" : "\u5426"}`);
+}
+async function siteRun(name, args, options) {
+  const sites = getAllSites();
+  const site = sites.find((s) => s.name === name);
+  if (!site) {
+    const fuzzy = sites.filter((s) => s.name.includes(name));
+    if (options.json) {
+      exitJsonError(`site "${name}" not found`, {
+        suggestions: fuzzy.slice(0, 5).map((s) => s.name),
+        action: fuzzy.length > 0 ? void 0 : "bws site update"
+      });
+    }
+    console.error(`[error] site: "${name}" not found.`);
+    if (fuzzy.length > 0) {
+      console.error("  Did you mean:");
+      for (const s of fuzzy.slice(0, 5)) {
+        console.error(`    bws site ${s.name}`);
+      }
+    } else {
+      console.error("  Try: bws site list");
+      console.error("  Or:  bws site update");
+    }
+    process.exit(1);
+  }
+  const argNames = Object.keys(site.args);
+  const argMap = {};
+  const positionalArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      const flagName = args[i].slice(2);
+      if (flagName in site.args && args[i + 1]) {
+        argMap[flagName] = args[i + 1];
+        i++;
+      }
+    } else {
+      positionalArgs.push(args[i]);
+    }
+  }
+  let posIdx = 0;
+  for (const argName of argNames) {
+    if (!argMap[argName] && posIdx < positionalArgs.length) {
+      argMap[argName] = positionalArgs[posIdx++];
+    }
+  }
+  for (const [argName, argDef] of Object.entries(site.args)) {
+    if (argDef.required && !argMap[argName]) {
+      const usage = argNames.map((a) => {
+        const def = site.args[a];
+        return def.required ? `<${a}>` : `[${a}]`;
+      }).join(" ");
+      if (options.json) {
+        exitJsonError(`missing required argument "${argName}"`, {
+          usage: `bws site ${name} ${usage}`,
+          example: site.example
+        });
+      }
+      console.error(`[error] site ${name}: missing required argument "${argName}".`);
+      console.error(`  Usage: bws site ${name} ${usage}`);
+      if (site.example) console.error(`  Example: ${site.example}`);
+      process.exit(1);
+    }
+  }
+  const jsContent = readFileSync(site.filePath, "utf-8");
+  const jsBody = jsContent.replace(/\/\*\s*@meta[\s\S]*?\*\//, "").trim();
+  const argsJson = JSON.stringify(argMap);
+  let targetId;
+  if (site.domain) {
+    const tabs = ocGetTabs();
+    const existing = ocFindTabByDomain(tabs, site.domain);
+    if (existing) {
+      targetId = existing.targetId;
+    } else {
+      targetId = ocOpenTab(`https://${site.domain}`);
+      await new Promise((resolve) => setTimeout(resolve, 3e3));
+    }
+  } else {
+    const tabs = ocGetTabs();
+    if (tabs.length === 0) {
+      throw new Error("No tabs open in OpenClaw browser");
+    }
+    targetId = tabs[0].targetId;
+  }
+  const wrappedFn = `async () => { const __fn = ${jsBody}; return await __fn(${argsJson}); }`;
+  const parsed = ocEvaluate(targetId, wrappedFn);
+  if (typeof parsed === "object" && parsed !== null && "error" in parsed) {
+    const errObj = parsed;
+    const checkText = `${errObj.error} ${errObj.hint || ""}`;
+    const isAuthError = /401|403|unauthorized|forbidden|not.?logged|login.?required|sign.?in|auth/i.test(checkText);
+    const loginHint = isAuthError && site.domain ? `Please log in to https://${site.domain} in your OpenClaw browser first, then retry.` : void 0;
+    const hint = loginHint || errObj.hint;
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: errObj.error, hint }));
+    } else {
+      console.error(`[error] site ${name}: ${errObj.error}`);
+      if (hint) console.error(`  Hint: ${hint}`);
+    }
+    process.exit(1);
+  }
+  if (options.jq) {
+    const expr = options.jq.replace(/^\.data\./, ".");
+    const results = applyJq(parsed, expr);
+    for (const r of results) {
+      console.log(typeof r === "string" ? r : JSON.stringify(r));
+    }
+  } else if (options.json) {
+    console.log(JSON.stringify({ success: true, data: parsed }));
+  } else {
+    console.log(JSON.stringify(parsed, null, 2));
+  }
+}
+async function siteCommand(args, options = {}) {
+  const subCommand = args[0];
+  if (!subCommand || subCommand === "--help" || subCommand === "-h") {
+    console.log(`bws site - \u7F51\u7AD9 CLI \u5316
+
+\u7528\u6CD5:
+  bws site list                      \u5217\u51FA\u6240\u6709\u53EF\u7528 adapter
+  bws site info <name>               \u67E5\u770B adapter \u8BE6\u60C5
+  bws site search <query>            \u641C\u7D22 adapter
+  bws site <name> [args...]          \u8FD0\u884C adapter
+
+\u793A\u4F8B:
+  bws site list
+  bws site zhihu/hot
+  bws site xiaohongshu/search "\u65C5\u884C"
+  bws site bilibili/popular`);
+    return;
+  }
+  switch (subCommand) {
+    case "list":
+      siteList(options);
+      break;
+    case "search":
+      if (!args[1]) {
+        console.error("[error] site search: <query> is required.");
+        console.error("  Usage: bws site search <query>");
+        process.exit(1);
+      }
+      siteSearch(args[1], options);
+      break;
+    case "info":
+      if (!args[1]) {
+        console.error("[error] site info: <name> is required.");
+        console.error("  Usage: bws site info <name>");
+        process.exit(1);
+      }
+      siteInfo(args[1], options);
+      break;
+    case "run":
+      if (!args[1]) {
+        console.error("[error] site run: <name> is required.");
+        console.error("  Usage: bws site run <name> [args...]");
+        console.error("  Try: bws site list");
+        process.exit(1);
+      }
+      await siteRun(args[1], args.slice(2), options);
+      break;
+    default:
+      if (subCommand.includes("/")) {
+        await siteRun(subCommand, args.slice(1), options);
+      } else {
+        console.error(`[error] site: unknown subcommand "${subCommand}".`);
+        console.error("  Available: list, info, search, run");
+        console.error("  Try: bws site --help");
+        process.exit(1);
+      }
+      break;
+  }
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var HELP_TEXT = `
+Browser Web Search (BWS) v${VERSION}
+
+\u628A\u4EFB\u4F55\u7F51\u7AD9\u53D8\u6210\u547D\u4EE4\u884C API\uFF0C\u4F7F\u7528 OpenClaw \u6D4F\u89C8\u5668 + \u7528\u6237\u767B\u5F55\u6001\u3002
+
+\u7528\u6CD5:
+  bws site list                      \u5217\u51FA\u6240\u6709\u53EF\u7528 adapter
+  bws site info <name>               \u67E5\u770B adapter \u5143\u4FE1\u606F
+  bws site search <query>            \u641C\u7D22 adapter
+  bws site <name> [args...]          \u8FD0\u884C adapter
+  bws <name> [args...]               \u8FD0\u884C adapter\uFF08\u7B80\u5199\uFF09
+
+\u793A\u4F8B:
+  bws site list                      # \u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4
+  bws zhihu/hot                      # \u77E5\u4E4E\u70ED\u699C
+  bws xiaohongshu/search "\u65C5\u884C"       # \u5C0F\u7EA2\u4E66\u641C\u7D22
+  bws bilibili/popular               # B\u7AD9\u70ED\u95E8
+
+\u9009\u9879:
+  --json               \u4EE5 JSON \u683C\u5F0F\u8F93\u51FA
+  --jq <expr>          \u5BF9 JSON \u8F93\u51FA\u5E94\u7528 jq \u8FC7\u6EE4
+  --help, -h           \u663E\u793A\u5E2E\u52A9\u4FE1\u606F
+  --version, -v        \u663E\u793A\u7248\u672C\u53F7
+
+\u9700\u8981 OpenClaw \u73AF\u5883\u8FD0\u884C\u3002
+`.trim();
+function parseArgs(args) {
+  const result = {
+    command: "",
+    args: [],
+    flags: {}
+  };
+  let skipNext = false;
+  for (let i = 0; i < args.length; i++) {
+    if (skipNext) {
+      skipNext = false;
+      continue;
+    }
+    const arg = args[i];
+    if (arg === "--json") {
+      result.flags.json = true;
+    } else if (arg === "--jq") {
+      skipNext = true;
+      const nextIdx = i + 1;
+      if (nextIdx < args.length) {
+        result.flags.jq = args[nextIdx];
+        result.flags.json = true;
+      }
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(HELP_TEXT);
+      process.exit(0);
+    } else if (arg === "--version" || arg === "-v") {
+      console.log(VERSION);
+      process.exit(0);
+    } else if (!result.command) {
+      result.command = arg;
+    } else {
+      result.args.push(arg);
+    }
+  }
+  return result;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log(HELP_TEXT);
+    process.exit(0);
+  }
+  const parsed = parseArgs(args);
+  switch (parsed.command) {
+    case "site":
+      await siteCommand(parsed.args, {
+        json: parsed.flags.json,
+        jq: parsed.flags.jq
+      });
+      break;
+    default:
+      if (parsed.command.includes("/")) {
+        await siteCommand([parsed.command, ...parsed.args], {
+          json: parsed.flags.json,
+          jq: parsed.flags.jq
+        });
+      } else {
+        console.error(`[error] \u672A\u77E5\u547D\u4EE4: ${parsed.command}`);
+        console.error("  \u8FD0\u884C bws --help \u67E5\u770B\u5E2E\u52A9");
+        process.exit(1);
+      }
+      break;
+  }
+}
+main().catch((error) => {
+  console.error(`[error] ${error.message || error}`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map