focalapi-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1557 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/lib/errors.ts
+var ApiError = class extends Error {
+  code;
+  status;
+  hint;
+  /** 上游原始响应体（已截断），仅调试用途，打印前需脱敏。 */
+  body;
+  constructor(code, message, opts) {
+    super(message);
+    this.name = "ApiError";
+    this.code = code;
+    this.status = opts?.status;
+    this.hint = opts?.hint;
+    this.body = opts?.body;
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message,
+        ...this.hint ? { hint: this.hint } : {},
+        ...this.status !== void 0 ? { status: this.status } : {}
+      }
+    };
+  }
+};
+function refineErrorCode(status, message) {
+  const m = message.toLowerCase();
+  if (m.includes("quota") || m.includes("\u989D\u5EA6") || m.includes("insufficient")) {
+    return "insufficient_quota";
+  }
+  if (m.includes("model") && (m.includes("not") || m.includes("\u4E0D\u5B58\u5728") || m.includes("\u65E0"))) {
+    return "model_not_found";
+  }
+  if (m.includes("key") || m.includes("token") || m.includes("auth")) {
+    return status === 401 || status === 403 ? "invalid_api_key" : "invalid_request";
+  }
+  switch (status) {
+    case 400:
+      return "invalid_request";
+    case 401:
+    case 403:
+      return "invalid_api_key";
+    case 404:
+      return "model_not_found";
+    case 429:
+      return "rate_limited";
+    default:
+      return status >= 500 ? "server_error" : "invalid_request";
+  }
+}
+
+// src/lib/output.ts
+function isInteractive() {
+  return Boolean(process.stdout.isTTY) && !process.env.CI;
+}
+var KEY_PATTERN = /(?<![A-Za-z0-9_-])sk-[A-Za-z0-9]{20,}/g;
+function maskKey(key) {
+  if (key.length <= 8) {
+    return "***";
+  }
+  return `${key.slice(0, 5)}***${key.slice(-4)}`;
+}
+function sanitize(value) {
+  if (typeof value === "string") {
+    return value.replace(KEY_PATTERN, (m) => maskKey(m));
+  }
+  if (Array.isArray(value)) {
+    return value.map(sanitize);
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (/api[-_]?key|authorization|token/i.test(k) && typeof v === "string") {
+        const replaced = v.replace(KEY_PATTERN, (m) => maskKey(m));
+        out[k] = replaced !== v ? replaced : maskKey(v);
+      } else {
+        out[k] = sanitize(v);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+function printJson(data) {
+  process.stdout.write(JSON.stringify(sanitize(data), null, 2) + "\n");
+}
+function info(message) {
+  process.stderr.write(message + "\n");
+}
+function printError(err, opts) {
+  if (err instanceof ApiError) {
+    if (opts?.json) {
+      printJson(err.toJSON());
+    } else {
+      process.stderr.write(`\u9519\u8BEF [${err.code}]\uFF1A${err.message}
+`);
+      const hint = err.hint;
+      if (hint) {
+        process.stderr.write(`\u63D0\u793A\uFF1A${hint}
+`);
+      }
+    }
+    return;
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  if (opts?.json) {
+    printJson({ error: { code: "internal_error", message } });
+  } else {
+    process.stderr.write(`\u5185\u90E8\u9519\u8BEF\uFF1A${message}
+`);
+  }
+}
+function printTable(headers, rows) {
+  const widths = headers.map(
+    (h, i) => Math.max(displayWidth(h), ...rows.map((r) => displayWidth(r[i] ?? "")))
+  );
+  const line = (cells) => cells.map((c, i) => c + " ".repeat(Math.max(0, (widths[i] ?? 0) - displayWidth(c)))).join("  ");
+  process.stdout.write(line(headers) + "\n");
+  process.stdout.write(widths.map((w) => "-".repeat(w)).join("  ") + "\n");
+  for (const row of rows) {
+    process.stdout.write(line(row) + "\n");
+  }
+}
+function displayWidth(s) {
+  let width = 0;
+  for (const ch of s) {
+    width += /[⺀-鿿豈-﫿︰-﹏＀-￠￡-￦]/.test(ch) ? 2 : 1;
+  }
+  return width;
+}
+
+// src/lib/version.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+// src/commands/auth.ts
+import { createInterface } from "readline/promises";
+
+// src/lib/config.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_BASE_URL = "https://api.focalapi.com";
+var DEFAULT_PROFILE = "default";
+function normalizeHomePath(p) {
+  if (process.platform === "win32") {
+    const m = /^\/([a-zA-Z])\/(.*)$/.exec(p);
+    if (m) {
+      return `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, "\\")}`;
+    }
+  }
+  return p;
+}
+function configDir() {
+  const dir = process.env.FOCALAPI_CONFIG_DIR ?? join(homedir(), ".focalapi");
+  return normalizeHomePath(dir);
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function loadConfig() {
+  const path = configPath();
+  if (!existsSync(path)) {
+    return { currentProfile: DEFAULT_PROFILE, profiles: {} };
+  }
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    return {
+      currentProfile: raw.currentProfile ?? DEFAULT_PROFILE,
+      profiles: raw.profiles ?? {}
+    };
+  } catch {
+    throw new ApiError("config_corrupted", `\u914D\u7F6E\u6587\u4EF6\u635F\u574F\uFF1A${path}`, {
+      hint: "\u4FEE\u590D\u6216\u5220\u9664\u8BE5\u6587\u4EF6\u540E\u91CD\u65B0\u8FD0\u884C focalapi auth login\u3002"
+    });
+  }
+}
+function saveConfig(config) {
+  const dir = configDir();
+  mkdirSync(dir, { recursive: true });
+  const path = configPath();
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function getProfile(name) {
+  const config = loadConfig();
+  const profileName = name ?? config.currentProfile;
+  return config.profiles[profileName] ?? {};
+}
+function clearProfile(name) {
+  const config = loadConfig();
+  delete config.profiles[name];
+  if (config.currentProfile === name) {
+    config.currentProfile = DEFAULT_PROFILE;
+  }
+  saveConfig(config);
+  return config;
+}
+function resolveBaseUrl(explicit, profileName) {
+  const fromEnv = process.env.FOCALAPI_BASE_URL;
+  const fromProfile = getProfile(profileName).baseUrl;
+  return (explicit ?? fromEnv ?? fromProfile ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+function resolveAuth(opts) {
+  const baseUrl = resolveBaseUrl(opts?.baseUrl, opts?.profile);
+  if (opts?.key) {
+    return { apiKey: opts.key, baseUrl, keySource: "flag" };
+  }
+  const fromEnv = process.env.FOCALAPI_API_KEY;
+  if (fromEnv) {
+    return { apiKey: fromEnv, baseUrl, keySource: "env" };
+  }
+  const fromProfile = getProfile(opts?.profile).apiKey;
+  if (fromProfile) {
+    return { apiKey: fromProfile, baseUrl, keySource: "config" };
+  }
+  throw new ApiError("missing_api_key", "\u672A\u627E\u5230 API Key", {
+    hint: "\u8FD0\u884C focalapi auth login --key <sk-...>\uFF0C\u6216\u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF FOCALAPI_API_KEY\u3002Key \u5728 https://focalapi.com/console/token \u521B\u5EFA\u3002"
+  });
+}
+
+// src/lib/http.ts
+var DEFAULT_TIMEOUT_MS = 6e4;
+function buildUrl(baseUrl, path, query) {
+  const url = new URL(path.replace(/^\/+/, ""), `${baseUrl}/`);
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value !== void 0) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+function extractErrorMessage(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { message: raw.slice(0, 500) || "\u672A\u77E5\u9519\u8BEF", body: void 0 };
+  }
+  const obj = parsed;
+  const errObj = obj?.error;
+  const message = typeof errObj?.message === "string" && errObj.message || typeof obj?.message === "string" && obj.message || JSON.stringify(parsed).slice(0, 500);
+  return { message, body: parsed };
+}
+async function request(opts) {
+  const res = await rawRequest(opts);
+  const text = await res.text();
+  if (text.length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new ApiError("bad_response", `\u54CD\u5E94\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${text.slice(0, 200)}`, {
+      status: res.status
+    });
+  }
+}
+async function rawRequest(opts) {
+  const url = buildUrl(opts.baseUrl, opts.path, opts.query);
+  const headers = { ...opts.headers };
+  if (opts.apiKey) {
+    headers.Authorization = `Bearer ${opts.apiKey}`;
+  }
+  let payload;
+  if (opts.formData) {
+    payload = opts.formData;
+  } else if (opts.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+    payload = JSON.stringify(opts.body);
+  }
+  let res;
+  try {
+    res = await fetch(url, {
+      method: opts.method ?? (payload !== void 0 ? "POST" : "GET"),
+      headers,
+      body: payload,
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const name = err?.name ?? "";
+    if (name === "TimeoutError" || name === "AbortError") {
+      throw new ApiError("timeout", `\u8BF7\u6C42\u8D85\u65F6\uFF08${opts.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms\uFF09\uFF1A${url}`, {
+        hint: "\u7A0D\u540E\u91CD\u8BD5\uFF0C\u6216\u8FD0\u884C focalapi doctor \u68C0\u67E5\u94FE\u8DEF\u8D28\u91CF\u3002"
+      });
+    }
+    throw new ApiError("network_error", `\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF1A${err?.message ?? err}`, {
+      hint: "\u68C0\u67E5\u7F51\u7EDC\u4EE3\u7406\u4E0E FOCALAPI_BASE_URL \u914D\u7F6E\uFF1B\u53EF\u8FD0\u884C focalapi doctor \u505A\u94FE\u8DEF\u8BCA\u65AD\u3002"
+    });
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    const { message, body } = extractErrorMessage(text);
+    const code = refineErrorCode(res.status, message);
+    throw new ApiError(code, message, { status: res.status, body });
+  }
+  return res;
+}
+async function* sseEvents(res) {
+  if (!res.body) {
+    throw new ApiError("bad_response", "\u6D41\u5F0F\u54CD\u5E94\u7F3A\u5C11 body");
+  }
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (!line.startsWith("data:")) continue;
+        const data = line.slice(5).trim();
+        if (data === "[DONE]") return;
+        if (data) yield data;
+      }
+    }
+    const tail = buffer.trim();
+    if (tail.startsWith("data:")) {
+      const data = tail.slice(5).trim();
+      if (data && data !== "[DONE]") yield data;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/commands/auth.ts
+async function fetchTokenUsage(baseUrl, apiKey) {
+  const res = await request({
+    baseUrl,
+    path: "/api/usage/token/",
+    apiKey,
+    timeoutMs: 15e3
+  });
+  if (!res.data) {
+    throw new ApiError("bad_response", "\u7528\u91CF\u63A5\u53E3\u54CD\u5E94\u7F3A\u5C11 data \u5B57\u6BB5");
+  }
+  return res.data;
+}
+async function promptForKey() {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const answer = await rl.question("\u8BF7\u7C98\u8D34 API Key\uFF08sk-...\uFF09\uFF1A");
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+function registerAuth(program) {
+  const auth = program.command("auth").description("API Key \u767B\u5F55\u4E0E\u72B6\u6001");
+  auth.command("login").description("\u9A8C\u8BC1\u5E76\u4FDD\u5B58 API Key\uFF08Key \u5728 https://focalapi.com/console/token \u521B\u5EFA\uFF09").option("--key <key>", "API Key\uFF08sk-...\uFF09\uFF1B\u4E0D\u4F20\u4E14\u4E3A\u7EC8\u7AEF\u73AF\u5883\u65F6\u8FDB\u5165\u4EA4\u4E92\u7C98\u8D34").action(async (opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    let key = opts.key ?? g.key ?? process.env.FOCALAPI_API_KEY;
+    if (!key) {
+      if (!isInteractive()) {
+        throw new ApiError("missing_api_key", "\u975E\u4EA4\u4E92\u73AF\u5883\u5FC5\u987B\u901A\u8FC7 --key \u6216 FOCALAPI_API_KEY \u63D0\u4F9B Key", {
+          hint: "focalapi auth login --key <sk-...>"
+        });
+      }
+      info(`\u63A7\u5236\u53F0\u4EE4\u724C\u9875\uFF1Ahttps://focalapi.com/console/token`);
+      key = await promptForKey();
+    }
+    if (!key.startsWith("sk-")) {
+      throw new ApiError("invalid_request", "Key \u683C\u5F0F\u4E0D\u6B63\u786E\uFF1A\u5E94\u4EE5 sk- \u5F00\u5934");
+    }
+    const baseUrl = resolveBaseUrl(g.baseUrl, g.profile);
+    const usage = await fetchTokenUsage(baseUrl, key);
+    const profileName = g.profile ?? loadConfig().currentProfile ?? DEFAULT_PROFILE;
+    const config = loadConfig();
+    config.profiles[profileName] = {
+      ...config.profiles[profileName],
+      apiKey: key,
+      baseUrl: g.baseUrl ?? process.env.FOCALAPI_BASE_URL ?? config.profiles[profileName]?.baseUrl
+    };
+    config.currentProfile = profileName;
+    saveConfig(config);
+    if (g.json) {
+      printJson({
+        success: true,
+        profile: profileName,
+        baseUrl,
+        key: maskKey(key),
+        token: usage
+      });
+    } else {
+      info(`\u2713 \u767B\u5F55\u6210\u529F\uFF08profile: ${profileName}\uFF09`);
+      info(`  Key\uFF1A${maskKey(key)}`);
+      info(`  \u4EE4\u724C\u540D\uFF1A${usage.name}`);
+      info(`  \u5269\u4F59\u989D\u5EA6\uFF1A${usage.unlimited_quota ? "\u65E0\u9650" : usage.total_available}`);
+      info(`  API \u5730\u5740\uFF1A${baseUrl}`);
+      info(`\u63A5\u4E0B\u6765\u53EF\u8FD0\u884C\uFF1Afocalapi doctor \u505A\u7AEF\u5230\u7AEF\u81EA\u68C0\uFF08\u4F7F\u7528\u514D\u8D39\u6F14\u7EC3\u6A21\u578B\uFF0C\u4E0D\u6D88\u8017\u989D\u5EA6\uFF09`);
+    }
+  });
+  auth.command("status").description("\u67E5\u770B\u5F53\u524D Key \u7684\u6709\u6548\u6027\u3001\u989D\u5EA6\u4E0E\u6765\u6E90").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth2 = resolveAuth(g);
+    const usage = await fetchTokenUsage(auth2.baseUrl, auth2.apiKey);
+    if (g.json) {
+      printJson({
+        valid: true,
+        key: maskKey(auth2.apiKey),
+        keySource: auth2.keySource,
+        baseUrl: auth2.baseUrl,
+        token: usage
+      });
+    } else {
+      printTable(
+        ["\u9879\u76EE", "\u503C"],
+        [
+          ["Key", maskKey(auth2.apiKey)],
+          ["\u6765\u6E90", auth2.keySource],
+          ["API \u5730\u5740", auth2.baseUrl],
+          ["\u4EE4\u724C\u540D", usage.name],
+          ["\u5269\u4F59\u989D\u5EA6", usage.unlimited_quota ? "\u65E0\u9650" : String(usage.total_available)],
+          ["\u5DF2\u7528\u989D\u5EA6", String(usage.total_used)],
+          ["\u8FC7\u671F\u65F6\u95F4", usage.expires_at > 0 ? new Date(usage.expires_at * 1e3).toLocaleString() : "\u6C38\u4E0D\u8FC7\u671F"]
+        ]
+      );
+    }
+  });
+  auth.command("logout").description("\u5220\u9664\u672C\u5730\u4FDD\u5B58\u7684 API Key").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const profileName = g.profile ?? loadConfig().currentProfile ?? DEFAULT_PROFILE;
+    const profile = getProfile(profileName);
+    clearProfile(profileName);
+    if (g.json) {
+      printJson({ success: true, profile: profileName, hadKey: Boolean(profile.apiKey) });
+    } else {
+      info(profile.apiKey ? `\u2713 \u5DF2\u5220\u9664 profile\u300C${profileName}\u300D\u7684\u672C\u5730 Key` : `profile\u300C${profileName}\u300D\u672C\u5C31\u6CA1\u6709\u4FDD\u5B58 Key`);
+    }
+  });
+}
+
+// src/commands/models.ts
+function registerModels(program) {
+  const models = program.command("models").description("\u53EF\u7528\u6A21\u578B\u67E5\u8BE2");
+  models.command("list").description("\u5217\u51FA\u5F53\u524D Key \u53EF\u7528\u7684\u5168\u90E8\u6A21\u578B").option("--filter <keyword>", "\u6309 id \u5173\u952E\u5B57\u8FC7\u6EE4\uFF08\u4E0D\u533A\u5206\u5927\u5C0F\u5199\uFF09").action(async (opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const res = await request({ baseUrl: auth.baseUrl, path: "/v1/models", apiKey: auth.apiKey });
+    let list = res.data ?? [];
+    if (opts.filter) {
+      const kw = opts.filter.toLowerCase();
+      list = list.filter((m) => m.id.toLowerCase().includes(kw));
+    }
+    if (g.json) {
+      printJson({ data: list });
+    } else {
+      printTable(
+        ["\u6A21\u578B ID", "\u63D0\u4F9B\u65B9"],
+        list.map((m) => [m.id, m.owned_by ?? "-"])
+      );
+    }
+  });
+  models.command("get").description("\u67E5\u770B\u5355\u4E2A\u6A21\u578B\u8BE6\u60C5").argument("<model>", "\u6A21\u578B ID").action(async (model, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const res = await request({
+      baseUrl: auth.baseUrl,
+      path: `/v1/models/${encodeURIComponent(model)}`,
+      apiKey: auth.apiKey
+    });
+    if (g.json) {
+      printJson(res);
+    } else {
+      printTable(
+        ["\u5B57\u6BB5", "\u503C"],
+        Object.entries(res).map(([k, v]) => [k, typeof v === "object" ? JSON.stringify(v) : String(v)])
+      );
+    }
+  });
+}
+
+// src/lib/fileinput.ts
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { basename, extname } from "path";
+var MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".m4a": "audio/mp4",
+  ".mp4": "video/mp4",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json"
+};
+function isImageMime(mime) {
+  return mime.startsWith("image/");
+}
+function readInputFile(path) {
+  let stat;
+  try {
+    stat = statSync(path);
+  } catch {
+    throw new ApiError("invalid_request", `\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${path}`);
+  }
+  if (!stat.isFile()) {
+    throw new ApiError("invalid_request", `\u4E0D\u662F\u6587\u4EF6\uFF1A${path}`);
+  }
+  if (stat.size > 50 * 1024 * 1024) {
+    throw new ApiError("invalid_request", `\u6587\u4EF6\u8D85\u8FC7 50MB \u4E0A\u9650\uFF1A${path}`, {
+      hint: "\u5927\u6587\u4EF6\u8BF7\u5148\u538B\u7F29\u6216\u5206\u6BB5\u5904\u7406\u3002"
+    });
+  }
+  const ext = extname(path).toLowerCase();
+  const mime = MIME_BY_EXT[ext] ?? "application/octet-stream";
+  return { path, name: basename(path), mime, size: stat.size, data: readFileSync2(path) };
+}
+function toDataUrl(file) {
+  return `data:${file.mime};base64,${file.data.toString("base64")}`;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+
+// src/commands/chat.ts
+function resolveModel(flag) {
+  const model = flag ?? process.env.FOCALAPI_MODEL;
+  if (!model) {
+    throw new ApiError("invalid_request", "\u7F3A\u5C11\u6A21\u578B\u53C2\u6570", {
+      hint: "\u7528 -m <model> \u6307\u5B9A\u6A21\u578B\uFF0C\u6216\u8BBE\u7F6E FOCALAPI_MODEL\uFF1B\u53EF\u7528\u6A21\u578B\u89C1 focalapi models list\u3002\u514D\u8D39\u6F14\u7EC3\u6A21\u578B\uFF1Afocal-rehearsal-chat\u3002"
+    });
+  }
+  return model;
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => part && typeof part === "object" && "text" in part ? String(part.text ?? "") : "").join("");
+  }
+  return "";
+}
+function registerChat(program) {
+  program.command("chat").description("\u5BF9\u8BDD\u4E0E\u591A\u6A21\u6001\u63A8\u7406\uFF08/v1/chat/completions\uFF09").argument("[prompt...]", "\u63D0\u793A\u8BCD\uFF1B\u7701\u7565\u4E14 stdin \u4E3A\u7BA1\u9053\u65F6\u4ECE stdin \u8BFB\u53D6").option("-m, --model <model>", "\u6A21\u578B ID\uFF08\u6216\u8BBE FOCALAPI_MODEL\uFF09").option("--system <text>", "system \u63D0\u793A\u8BCD").option("--input <file...>", "\u8F93\u5165\u6587\u4EF6\uFF08\u56FE\u7247\u8F6C data URL\uFF0C\u5982 --input @photo.jpg\uFF1B@ \u524D\u7F00\u53EF\u9009\uFF09").option("--max-tokens <n>", "max_tokens", (v) => Number.parseInt(v, 10)).option("--stream", "\u5F3A\u5236\u6D41\u5F0F\u8F93\u51FA").option("--no-stream", "\u5F3A\u5236\u975E\u6D41\u5F0F").action(
+    async (promptParts, opts, cmd) => {
+      const g = cmd.optsWithGlobals();
+      const auth = resolveAuth(g);
+      const model = resolveModel(opts.model);
+      let prompt = promptParts.join(" ").trim();
+      if (!prompt && !process.stdin.isTTY) {
+        prompt = await readStdin();
+      }
+      const inputs = (opts.input ?? []).map((p) => readInputFile(p.replace(/^@/, "")));
+      if (!prompt && inputs.length === 0) {
+        throw new ApiError("invalid_request", "\u7F3A\u5C11\u63D0\u793A\u8BCD", {
+          hint: 'focalapi chat "\u4F60\u7684\u95EE\u9898" -m <model>\uFF0C\u6216 echo "\u95EE\u9898" | focalapi chat -m <model>\u3002'
+        });
+      }
+      let userContent = prompt;
+      if (inputs.length > 0) {
+        const parts = [];
+        if (prompt) parts.push({ type: "text", text: prompt });
+        for (const file of inputs) {
+          if (isImageMime(file.mime)) {
+            parts.push({ type: "image_url", image_url: { url: toDataUrl(file) } });
+          } else if (file.mime.startsWith("text/") || file.mime === "application/json") {
+            parts.push({ type: "text", text: `
+
+[\u6587\u4EF6 ${file.name}]
+${file.data.toString("utf-8")}` });
+          } else {
+            throw new ApiError("invalid_request", `chat \u6682\u4E0D\u652F\u6301\u8BE5\u6587\u4EF6\u7C7B\u578B\uFF1A${file.name}\uFF08${file.mime}\uFF09`, {
+              hint: "\u56FE\u7247\u53EF\u76F4\u63A5\u4F20\u5165\uFF1B\u97F3\u89C6\u9891\u8BF7\u7528 focalapi audio \u7CFB\u5217\u547D\u4EE4\u3002"
+            });
+          }
+        }
+        userContent = parts;
+      }
+      const messages = [];
+      if (opts.system) messages.push({ role: "system", content: opts.system });
+      messages.push({ role: "user", content: userContent });
+      const body = { model, messages };
+      if (opts.maxTokens !== void 0) body.max_tokens = opts.maxTokens;
+      const stream = opts.stream ?? (isInteractive() && !g.json);
+      body.stream = stream;
+      if (!stream) {
+        const res2 = await request({
+          baseUrl: auth.baseUrl,
+          path: "/v1/chat/completions",
+          apiKey: auth.apiKey,
+          body,
+          timeoutMs: 3e5
+        });
+        if (g.json) {
+          printJson(res2);
+        } else {
+          const text = extractText(res2.choices?.[0]?.message?.content);
+          process.stdout.write(text + "\n");
+          if (res2.usage) {
+            info(`\uFF08tokens: prompt=${res2.usage.prompt_tokens ?? "-"} completion=${res2.usage.completion_tokens ?? "-"}\uFF09`);
+          }
+        }
+        return;
+      }
+      const res = await rawRequest({
+        baseUrl: auth.baseUrl,
+        path: "/v1/chat/completions",
+        apiKey: auth.apiKey,
+        body,
+        timeoutMs: 3e5
+      });
+      const collected = [];
+      for await (const data of sseEvents(res)) {
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const text = extractText(chunk.choices?.[0]?.delta?.content);
+        if (text) {
+          collected.push(text);
+          process.stdout.write(text);
+        }
+      }
+      process.stdout.write("\n");
+      if (g.json) {
+        printJson({ model, content: collected.join("") });
+      }
+    }
+  );
+}
+
+// src/commands/doctor.ts
+var REHEARSAL_MODEL = "focal-rehearsal-chat";
+var CHECK_TIMEOUT_MS = 15e3;
+async function runCheck(name, fn) {
+  try {
+    return { name, ok: true, detail: await fn() };
+  } catch (err) {
+    if (err instanceof ApiError) {
+      return { name, ok: false, detail: `[${err.code}] ${err.message}`, hint: err.hint };
+    }
+    return { name, ok: false, detail: err instanceof Error ? err.message : String(err) };
+  }
+}
+function registerDoctor(program) {
+  program.command("doctor").description("\u53EA\u8BFB\u8BCA\u65AD\uFF1A\u7F51\u7EDC\u3001\u9274\u6743\u3001\u6F14\u7EC3\u6A21\u578B\u7AEF\u5230\u7AEF\u3001\u989D\u5EA6\uFF08\u4E0D\u4FEE\u6539\u4EFB\u4F55\u8D44\u6E90\uFF09").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const results = [];
+    let auth;
+    results.push(
+      await runCheck("API Key \u89E3\u6790", async () => {
+        auth = resolveAuth(g);
+        return `${maskKey(auth.apiKey)}\uFF08\u6765\u6E90\uFF1A${auth.keySource}\uFF09`;
+      })
+    );
+    if (auth) {
+      const a = auth;
+      results.push(
+        await runCheck("\u7F51\u7EDC\u4E0E\u9274\u6743\uFF08GET /v1/models\uFF09", async () => {
+          const res = await request({
+            baseUrl: a.baseUrl,
+            path: "/v1/models",
+            apiKey: a.apiKey,
+            timeoutMs: CHECK_TIMEOUT_MS
+          });
+          return `${a.baseUrl} \u53EF\u8FBE\uFF0C${res.data?.length ?? 0} \u4E2A\u53EF\u7528\u6A21\u578B`;
+        })
+      );
+      results.push(
+        await runCheck(`\u7AEF\u5230\u7AEF\u63A8\u7406\uFF08${REHEARSAL_MODEL}\uFF0C\u514D\u8D39\u6F14\u7EC3\u6A21\u578B\uFF09`, async () => {
+          const res = await request({
+            baseUrl: a.baseUrl,
+            path: "/v1/chat/completions",
+            apiKey: a.apiKey,
+            body: { model: REHEARSAL_MODEL, messages: [{ role: "user", content: "ping" }] },
+            timeoutMs: CHECK_TIMEOUT_MS
+          });
+          const ok = (res.choices?.length ?? 0) > 0;
+          if (!ok) throw new ApiError("bad_response", "\u6F14\u7EC3\u6A21\u578B\u54CD\u5E94\u7F3A\u5C11 choices");
+          return "\u6F14\u7EC3\u6A21\u578B\u5F80\u8FD4\u6210\u529F";
+        })
+      );
+      results.push(
+        await runCheck("\u989D\u5EA6\uFF08GET /api/usage/token/\uFF09", async () => {
+          const usage = await fetchTokenUsage(a.baseUrl, a.apiKey);
+          const quota = usage.unlimited_quota ? "\u65E0\u9650" : `\u5269\u4F59 ${usage.total_available}`;
+          const expiry = usage.expires_at > 0 ? `\uFF0C${new Date(usage.expires_at * 1e3).toLocaleDateString()} \u8FC7\u671F` : "";
+          return `${quota}${expiry}`;
+        })
+      );
+    }
+    const allOk = results.every((r) => r.ok);
+    if (g.json) {
+      printJson({ ok: allOk, checks: results });
+    } else {
+      printTable(
+        ["\u68C0\u67E5\u9879", "\u7ED3\u679C", "\u8BE6\u60C5"],
+        results.map((r) => [r.name, r.ok ? "\u2713" : "\u2717", r.detail + (r.hint ? `
+  \u63D0\u793A\uFF1A${r.hint}` : "")])
+      );
+    }
+    if (!allOk) {
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/commands/gen.ts
+import { createWriteStream as createWriteStream2 } from "fs";
+import { mkdir as mkdir2, writeFile } from "fs/promises";
+import { join as join3, resolve as resolve2 } from "path";
+import { pipeline as pipeline2 } from "stream/promises";
+import { Readable as Readable2 } from "stream";
+
+// src/lib/tasks.ts
+import { createWriteStream } from "fs";
+import { mkdir } from "fs/promises";
+import { join as join2, resolve } from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+var SUCCESS_STATES = /* @__PURE__ */ new Set(["success", "succeeded", "completed", "done", "finish", "finished"]);
+var FAILED_STATES = /* @__PURE__ */ new Set(["failed", "failure", "error", "cancelled", "canceled"]);
+var RUNNING_STATES = /* @__PURE__ */ new Set(["running", "processing", "in_progress", "generating"]);
+var PENDING_STATES = /* @__PURE__ */ new Set(["pending", "queued", "submitted", "waiting", "not_start"]);
+function normalizeTaskStatus(raw) {
+  const s = String(raw ?? "").toLowerCase();
+  if (SUCCESS_STATES.has(s)) return "success";
+  if (FAILED_STATES.has(s)) return "failed";
+  if (RUNNING_STATES.has(s)) return "running";
+  if (PENDING_STATES.has(s)) return "pending";
+  return "unknown";
+}
+function extractTaskId(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const obj = body;
+  const direct = obj.task_id ?? obj.id ?? obj.taskId;
+  if (typeof direct === "string" && direct) return direct;
+  if (typeof direct === "number") return String(direct);
+  const data = obj.data;
+  const nested = data?.task_id ?? data?.id;
+  if (typeof nested === "string" && nested) return nested;
+  return void 0;
+}
+function extractProgress(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const obj = body;
+  for (const key of ["progress", "percent"]) {
+    const v = obj[key] ?? obj.data?.[key];
+    if (typeof v === "number") return v <= 1 ? Math.round(v * 100) : Math.round(v);
+    if (typeof v === "string") {
+      const n = Number.parseFloat(v.replace("%", ""));
+      if (!Number.isNaN(n)) return n <= 1 ? Math.round(n * 100) : Math.round(n);
+    }
+  }
+  return void 0;
+}
+async function fetchTask(baseUrl, apiKey, taskId) {
+  const raw = await request({
+    baseUrl,
+    path: `/v1/video/generations/${encodeURIComponent(taskId)}`,
+    apiKey
+  });
+  const obj = raw;
+  const rawStatus = String(obj?.status ?? obj?.data?.status ?? "");
+  return {
+    taskId,
+    status: normalizeTaskStatus(rawStatus),
+    rawStatus,
+    progress: extractProgress(raw),
+    raw
+  };
+}
+async function pollTask(baseUrl, apiKey, taskId, opts) {
+  const intervalMs = opts?.intervalMs ?? 5e3;
+  const timeoutMs = opts?.timeoutMs ?? 30 * 6e4;
+  const deadline = Date.now() + timeoutMs;
+  let last;
+  for (; ; ) {
+    last = await fetchTask(baseUrl, apiKey, taskId);
+    opts?.onUpdate?.(last);
+    if (last.status === "success") return last;
+    if (last.status === "failed") {
+      throw new ApiError("task_failed", `\u4EFB\u52A1 ${taskId} \u5931\u8D25\uFF08\u4E0A\u6E38\u72B6\u6001\uFF1A${last.rawStatus || "unknown"}\uFF09`, {
+        body: last.raw,
+        hint: "\u8FD0\u884C focalapi task status " + taskId + " --json \u67E5\u770B\u4E0A\u6E38\u8FD4\u56DE\u8BE6\u60C5\uFF1B\u82E5\u662F\u63D0\u793A\u8BCD\u6216\u53C2\u6570\u95EE\u9898\u8BF7\u8C03\u6574\u540E\u91CD\u8BD5\u3002"
+      });
+    }
+    if (Date.now() > deadline) {
+      throw new ApiError("timeout", `\u4EFB\u52A1 ${taskId} \u7B49\u5F85\u8D85\u65F6\uFF08${Math.round(timeoutMs / 6e4)} \u5206\u949F\uFF09`, {
+        hint: `\u53EF\u7A0D\u540E\u8FD0\u884C focalapi task status ${taskId} \u67E5\u770B\uFF0C\u6216 focalapi task download ${taskId} \u7EED\u53D6\u4EA7\u7269\u3002`
+      });
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+}
+var EXT_BY_CONTENT_TYPE = {
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/webp": ".webp",
+  "audio/mpeg": ".mp3",
+  "audio/wav": ".wav"
+};
+async function downloadTaskContent(baseUrl, apiKey, taskId, outDir, filenameBase) {
+  const res = await rawRequest({
+    baseUrl,
+    path: `/v1/videos/${encodeURIComponent(taskId)}/content`,
+    apiKey,
+    timeoutMs: 6e5
+  });
+  const contentType = res.headers.get("content-type")?.split(";")[0]?.trim() ?? "";
+  const ext = EXT_BY_CONTENT_TYPE[contentType] ?? ".bin";
+  const dir = resolve(outDir);
+  await mkdir(dir, { recursive: true });
+  const filePath = join2(dir, `${filenameBase ?? `task-${taskId}`}${ext}`);
+  if (!res.body) {
+    throw new ApiError("bad_response", "\u4E0B\u8F7D\u54CD\u5E94\u7F3A\u5C11 body");
+  }
+  await pipeline(Readable.fromWeb(res.body), createWriteStream(filePath));
+  return filePath;
+}
+
+// src/commands/gen.ts
+var MAX_IMAGE_N = 128;
+var MAX_TASK_DURATION_SECONDS = 3600;
+var DEFAULT_OUT_DIR = "focalapi-out";
+function clampInt(value, min, max, name) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new ApiError("invalid_request", `${name} \u5FC5\u987B\u662F ${min}\u2013${max} \u7684\u6574\u6570\uFF08\u6536\u5230\uFF1A${value}\uFF09`);
+  }
+  return value;
+}
+async function saveImageItem(item, dir, base, apiKey) {
+  if (item.b64_json) {
+    const filePath = join3(dir, `${base}.png`);
+    await writeFile(filePath, Buffer.from(item.b64_json, "base64"));
+    return filePath;
+  }
+  if (item.url) {
+    const res = await fetch(item.url, {
+      headers: item.url.includes("focalapi") ? { Authorization: `Bearer ${apiKey}` } : void 0,
+      signal: AbortSignal.timeout(3e5)
+    });
+    if (!res.ok || !res.body) {
+      throw new ApiError("bad_response", `\u56FE\u50CF\u4E0B\u8F7D\u5931\u8D25\uFF08HTTP ${res.status}\uFF09\uFF1A${item.url.slice(0, 120)}`);
+    }
+    const ext = res.headers.get("content-type")?.includes("jpeg") ? ".jpg" : ".png";
+    const filePath = join3(dir, `${base}${ext}`);
+    await pipeline2(Readable2.fromWeb(res.body), createWriteStream2(filePath));
+    return filePath;
+  }
+  throw new ApiError("bad_response", "\u56FE\u50CF\u7ED3\u679C\u65E2\u6CA1\u6709 url \u4E5F\u6CA1\u6709 b64_json");
+}
+function registerGen(program) {
+  const gen = program.command("gen").description("\u56FE\u50CF / \u89C6\u9891\u751F\u6210");
+  gen.command("image").description("\u751F\u6210\u56FE\u50CF\uFF08\u540C\u6B65\u8FD4\u56DE\uFF0C\u4EA7\u7269\u81EA\u52A8\u4E0B\u8F7D\u5230\u672C\u5730\uFF09").argument("<prompt...>", "\u63D0\u793A\u8BCD").requiredOption("-m, --model <model>", "\u56FE\u50CF\u6A21\u578B ID\uFF08focalapi models list \u67E5\u770B\uFF09").option("--size <size>", "\u5C3A\u5BF8\uFF0C\u5982 1024x1024").option("--n <count>", "\u5F20\u6570\uFF081\u2013128\uFF09", (v) => Number.parseInt(v, 10), 1).option("-o, --out <dir>", "\u8F93\u51FA\u76EE\u5F55", DEFAULT_OUT_DIR).action(async (promptParts, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const n = clampInt(opts.n, 1, MAX_IMAGE_N, "n");
+    const body = { model: opts.model, prompt: promptParts.join(" "), n };
+    if (opts.size) body.size = opts.size;
+    const res = await request({
+      baseUrl: auth.baseUrl,
+      path: "/v1/images/generations",
+      apiKey: auth.apiKey,
+      body,
+      timeoutMs: 6e5
+    });
+    const items = res.data ?? [];
+    if (items.length === 0) {
+      throw new ApiError("bad_response", "\u56FE\u50CF\u751F\u6210\u54CD\u5E94\u4E3A\u7A7A", { body: res });
+    }
+    const dir = resolve2(opts.out);
+    await mkdir2(dir, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const files = [];
+    for (const [i, item] of items.entries()) {
+      files.push(await saveImageItem(item, dir, `image-${ts}-${i + 1}`, auth.apiKey));
+    }
+    if (g.json) {
+      printJson({ files, count: files.length });
+    } else {
+      for (const f of files) info(`\u2713 ${f}`);
+    }
+  });
+  gen.command("video").description("\u751F\u6210\u89C6\u9891\uFF08\u4EFB\u52A1\u5236\uFF1A\u9ED8\u8BA4\u8F6E\u8BE2\u81F3\u5B8C\u6210\u5E76\u4E0B\u8F7D\uFF1B--no-wait \u53EA\u53D6 task_id\uFF09").argument("<prompt...>", "\u63D0\u793A\u8BCD").requiredOption("-m, --model <model>", "\u89C6\u9891\u6A21\u578B ID\uFF08focalapi models list \u67E5\u770B\uFF09").option("--seconds <n>", "\u65F6\u957F\u79D2\u6570\uFF081\u20133600\uFF09", (v) => Number.parseInt(v, 10)).option("--size <size>", "\u5206\u8FA8\u7387\uFF0C\u5982 1280x720").option("--no-wait", "\u63D0\u4EA4\u540E\u7ACB\u5373\u8FD4\u56DE task_id\uFF0C\u4E0D\u7B49\u5F85\u5B8C\u6210").option("--poll-interval <ms>", "\u8F6E\u8BE2\u95F4\u9694\u6BEB\u79D2", (v) => Number.parseInt(v, 10), 5e3).option("--timeout <minutes>", "\u6700\u957F\u7B49\u5F85\u5206\u949F", (v) => Number.parseInt(v, 10), 30).option("-o, --out <dir>", "\u8F93\u51FA\u76EE\u5F55", DEFAULT_OUT_DIR).action(
+    async (promptParts, opts, cmd) => {
+      const g = cmd.optsWithGlobals();
+      const auth = resolveAuth(g);
+      const body = { model: opts.model, prompt: promptParts.join(" ") };
+      if (opts.seconds !== void 0) {
+        body.seconds = String(clampInt(opts.seconds, 1, MAX_TASK_DURATION_SECONDS, "seconds"));
+      }
+      if (opts.size) body.size = opts.size;
+      const created = await request({
+        baseUrl: auth.baseUrl,
+        path: "/v1/video/generations",
+        apiKey: auth.apiKey,
+        body,
+        timeoutMs: 12e4
+      });
+      const taskId = extractTaskId(created);
+      if (!taskId) {
+        throw new ApiError("bad_response", "\u89C6\u9891\u4EFB\u52A1\u54CD\u5E94\u4E2D\u672A\u627E\u5230 task_id", { body: created });
+      }
+      if (opts.wait === false) {
+        if (g.json) {
+          printJson({ task_id: taskId, submitted: true });
+        } else {
+          process.stdout.write(taskId + "\n");
+          info(`\u4EFB\u52A1\u5DF2\u63D0\u4EA4\u3002\u7EED\u53D6\uFF1Afocalapi task status ${taskId} / focalapi task download ${taskId}`);
+        }
+        return;
+      }
+      info(`\u4EFB\u52A1 ${taskId} \u5DF2\u63D0\u4EA4\uFF0C\u7B49\u5F85\u5B8C\u6210\u2026\u2026`);
+      const final = await pollTask(auth.baseUrl, auth.apiKey, taskId, {
+        intervalMs: opts.pollInterval,
+        timeoutMs: opts.timeout * 6e4,
+        onUpdate: (t) => {
+          if (!g.json) {
+            info(`  \u72B6\u6001\uFF1A${t.rawStatus || t.status}${t.progress !== void 0 ? `\uFF08${t.progress}%\uFF09` : ""}`);
+          }
+        }
+      });
+      const filePath = await downloadTaskContent(auth.baseUrl, auth.apiKey, taskId, opts.out);
+      if (g.json) {
+        printJson({ task_id: taskId, status: final.status, file: filePath });
+      } else {
+        info(`\u2713 ${filePath}`);
+      }
+    }
+  );
+}
+
+// src/commands/task.ts
+function registerTask(program) {
+  const task = program.command("task").description("\u4EFB\u52A1\u67E5\u8BE2\u4E0E\u4EA7\u7269\u4E0B\u8F7D\uFF08\u89C6\u9891\u7B49\u4EFB\u52A1\u5236\u80FD\u529B\uFF09");
+  task.command("status").description("\u67E5\u8BE2\u4EFB\u52A1\u72B6\u6001").argument("<task_id>", "\u4EFB\u52A1 ID").action(async (taskId, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const info_ = await fetchTask(auth.baseUrl, auth.apiKey, taskId);
+    if (g.json) {
+      printJson({ task_id: taskId, status: info_.status, raw_status: info_.rawStatus, progress: info_.progress, raw: info_.raw });
+    } else {
+      printTable(
+        ["\u5B57\u6BB5", "\u503C"],
+        [
+          ["\u4EFB\u52A1 ID", taskId],
+          ["\u72B6\u6001", `${info_.status}${info_.rawStatus && info_.rawStatus !== info_.status ? `\uFF08\u4E0A\u6E38\uFF1A${info_.rawStatus}\uFF09` : ""}`],
+          ["\u8FDB\u5EA6", info_.progress !== void 0 ? `${info_.progress}%` : "-"]
+        ]
+      );
+      if (info_.status === "success") {
+        info(`\u4EA7\u7269\u4E0B\u8F7D\uFF1Afocalapi task download ${taskId}`);
+      }
+    }
+  });
+  task.command("download").description("\u4E0B\u8F7D\u4EFB\u52A1\u4EA7\u7269\uFF08\u7ECF focalapi \u5185\u5BB9\u4EE3\u7406\uFF0C\u65E0\u9700\u4E0A\u6E38\u7B7E\u540D URL\uFF09").argument("<task_id>", "\u4EFB\u52A1 ID").option("-o, --out <dir>", "\u8F93\u51FA\u76EE\u5F55", "focalapi-out").action(async (taskId, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const filePath = await downloadTaskContent(auth.baseUrl, auth.apiKey, taskId, opts.out);
+    if (g.json) {
+      printJson({ task_id: taskId, file: filePath });
+    } else {
+      info(`\u2713 ${filePath}`);
+    }
+  });
+}
+
+// src/commands/search.ts
+import { readFileSync as readFileSync3 } from "fs";
+function extractResults(raw) {
+  if (!raw || typeof raw !== "object") return [];
+  const obj = raw;
+  const candidates = [obj.results, obj.data, obj.items, obj.output];
+  for (const c of candidates) {
+    if (!Array.isArray(c)) continue;
+    const out = [];
+    for (const item of c) {
+      if (!item || typeof item !== "object") continue;
+      const it = item;
+      const url = typeof it.url === "string" ? it.url : typeof it.link === "string" ? it.link : "";
+      const title = typeof it.title === "string" ? it.title : url;
+      const snippet = typeof it.snippet === "string" ? it.snippet : typeof it.content === "string" ? it.content.slice(0, 200) : void 0;
+      if (url || title) out.push({ title, url, ...snippet ? { snippet } : {} });
+    }
+    if (out.length > 0) return out;
+  }
+  return [];
+}
+function registerSearch(program) {
+  program.command("search").description("\u8054\u7F51\u641C\u7D22\uFF08/v1/alpha/search\uFF0Calpha \u7EA7\u63A5\u53E3\uFF09").argument("<query...>", "\u641C\u7D22\u5185\u5BB9").requiredOption("-m, --model <model>", "\u641C\u7D22\u6A21\u578B ID\uFF08focalapi models list --filter search \u67E5\u770B\uFF09").option("--raw <json|@file>", "\u5B8C\u6574\u81EA\u5B9A\u4E49\u8BF7\u6C42\u4F53\uFF08JSON \u5B57\u7B26\u4E32\u6216 @\u6587\u4EF6\uFF09\uFF0C\u4E0E query \u5408\u5E76").action(async (queryParts, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    let body = { model: opts.model, query: queryParts.join(" ") };
+    if (opts.raw) {
+      const text = opts.raw.startsWith("@") ? readFileSync3(opts.raw.slice(1), "utf-8") : opts.raw;
+      try {
+        body = { ...JSON.parse(text), model: opts.model };
+      } catch {
+        throw new ApiError("invalid_request", "--raw \u4E0D\u662F\u5408\u6CD5 JSON");
+      }
+    }
+    const res = await request({
+      baseUrl: auth.baseUrl,
+      path: "/v1/alpha/search",
+      apiKey: auth.apiKey,
+      body,
+      timeoutMs: 12e4
+    });
+    if (g.json) {
+      printJson(res);
+      return;
+    }
+    const results = extractResults(res);
+    if (results.length === 0) {
+      printJson(res);
+      return;
+    }
+    printTable(
+      ["#", "\u6807\u9898", "\u94FE\u63A5"],
+      results.map((r, i) => [String(i + 1), r.title.slice(0, 60), r.url])
+    );
+  });
+}
+
+// src/commands/audio.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import { resolve as resolve3 } from "path";
+function registerAudio(program) {
+  const audio = program.command("audio").description("\u97F3\u9891\uFF1A\u8F6C\u5199\u4E0E\u5408\u6210");
+  audio.command("transcribe").description("\u8BED\u97F3\u8F6C\u6587\u5B57").argument("<file>", "\u97F3\u9891\u6587\u4EF6\u8DEF\u5F84").requiredOption("-m, --model <model>", "\u8F6C\u5199\u6A21\u578B ID").option("--language <lang>", "\u8BED\u8A00\u4EE3\u7801\uFF08\u5982 zh\u3001en\uFF09").action(async (file, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const input = readInputFile(file);
+    const form = new FormData();
+    form.append("file", new Blob([input.data], { type: input.mime }), input.name);
+    form.append("model", opts.model);
+    if (opts.language) form.append("language", opts.language);
+    const res = await request({
+      baseUrl: auth.baseUrl,
+      path: "/v1/audio/transcriptions",
+      apiKey: auth.apiKey,
+      formData: form,
+      timeoutMs: 3e5
+    });
+    if (g.json) {
+      printJson(res);
+    } else {
+      process.stdout.write((res.text ?? JSON.stringify(res)) + "\n");
+    }
+  });
+  audio.command("speech").description("\u6587\u5B57\u8F6C\u8BED\u97F3\uFF0C\u4EA7\u7269\u4FDD\u5B58\u4E3A\u97F3\u9891\u6587\u4EF6").argument("<text...>", "\u8981\u5408\u6210\u7684\u6587\u672C").requiredOption("-m, --model <model>", "TTS \u6A21\u578B ID").option("--voice <voice>", "\u97F3\u8272", "alloy").option("--format <fmt>", "\u97F3\u9891\u683C\u5F0F\uFF08mp3/wav/...\uFF09", "mp3").option("-o, --out <file>", "\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84").action(async (textParts, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const res = await rawRequest({
+      baseUrl: auth.baseUrl,
+      path: "/v1/audio/speech",
+      apiKey: auth.apiKey,
+      body: { model: opts.model, input: textParts.join(" "), voice: opts.voice, response_format: opts.format },
+      timeoutMs: 3e5
+    });
+    const buf = Buffer.from(await res.arrayBuffer());
+    if (buf.length === 0) {
+      throw new ApiError("bad_response", "\u8BED\u97F3\u5408\u6210\u8FD4\u56DE\u7A7A\u5185\u5BB9");
+    }
+    const outPath = resolve3(opts.out ?? `focalapi-out/speech-${Date.now()}.${opts.format}`);
+    await writeFile2(outPath, buf);
+    if (g.json) {
+      printJson({ file: outPath, bytes: buf.length });
+    } else {
+      info(`\u2713 ${outPath}`);
+    }
+  });
+}
+
+// src/commands/embed.ts
+function registerEmbed(program) {
+  program.command("embed").description("\u6587\u672C\u5411\u91CF\u5316\uFF08/v1/embeddings\uFF09").argument("[text...]", "\u6587\u672C\uFF1B\u7701\u7565\u4E14 stdin \u4E3A\u7BA1\u9053\u65F6\u4ECE stdin \u8BFB\u53D6").requiredOption("-m, --model <model>", "\u5411\u91CF\u6A21\u578B ID").option("--input <file>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6\u6587\u672C\uFF08@ \u524D\u7F00\u53EF\u9009\uFF09").action(async (textParts, opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    let text = textParts.join(" ").trim();
+    if (opts.input) {
+      text = readInputFile(opts.input.replace(/^@/, "")).data.toString("utf-8");
+    } else if (!text && !process.stdin.isTTY) {
+      text = await readStdin();
+    }
+    if (!text) {
+      throw new ApiError("invalid_request", "\u7F3A\u5C11\u5F85\u5411\u91CF\u5316\u6587\u672C", {
+        hint: 'focalapi embed "\u6587\u672C" -m <model>\uFF0C\u6216 focalapi embed -m <model> --input @file.txt\u3002'
+      });
+    }
+    const res = await request({
+      baseUrl: auth.baseUrl,
+      path: "/v1/embeddings",
+      apiKey: auth.apiKey,
+      body: { model: opts.model, input: text },
+      timeoutMs: 12e4
+    });
+    if (g.json) {
+      printJson(res);
+    } else {
+      const vec = res.data?.[0]?.embedding ?? [];
+      info(`\u7EF4\u5EA6\uFF1A${vec.length}\uFF1Btokens\uFF1A${res.usage?.total_tokens ?? "-"}`);
+      info("\u5B8C\u6574\u5411\u91CF\u8BF7\u7528 --json \u8F93\u51FA\u3002");
+    }
+  });
+}
+
+// src/commands/rerank.ts
+import { readFileSync as readFileSync4 } from "fs";
+function registerRerank(program) {
+  program.command("rerank").description("\u6309\u67E5\u8BE2\u5BF9\u6587\u6863\u91CD\u6392\u5E8F\uFF08/v1/rerank\uFF09").requiredOption("-m, --model <model>", "rerank \u6A21\u578B ID").requiredOption("--query <text>", "\u67E5\u8BE2").requiredOption("--docs <json|@file>", "\u6587\u6863\u6570\u7EC4\uFF08JSON \u5B57\u7B26\u4E32\u6216 @file.json\uFF09").option("--top-n <n>", "\u53EA\u8FD4\u56DE\u524D N \u6761", (v) => Number.parseInt(v, 10)).action(async (opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const text = opts.docs.startsWith("@") ? readFileSync4(opts.docs.slice(1), "utf-8") : opts.docs;
+    let documents;
+    try {
+      documents = JSON.parse(text);
+    } catch {
+      throw new ApiError("invalid_request", "--docs \u4E0D\u662F\u5408\u6CD5 JSON \u6570\u7EC4");
+    }
+    if (!Array.isArray(documents) || documents.length === 0) {
+      throw new ApiError("invalid_request", "--docs \u5FC5\u987B\u662F\u975E\u7A7A JSON \u6570\u7EC4");
+    }
+    const body = { model: opts.model, query: opts.query, documents };
+    if (opts.topN !== void 0) body.top_n = opts.topN;
+    const res = await request({
+      baseUrl: auth.baseUrl,
+      path: "/v1/rerank",
+      apiKey: auth.apiKey,
+      body,
+      timeoutMs: 12e4
+    });
+    if (g.json) {
+      printJson(res);
+      return;
+    }
+    const rows = (res.results ?? []).map((r) => {
+      const doc = typeof r.document === "string" ? r.document : r.document?.text ?? "";
+      return [String(r.index ?? "-"), String(r.relevance_score ?? "-"), doc.slice(0, 60)];
+    });
+    printTable(["\u539F\u6587\u6863\u5E8F\u53F7", "\u76F8\u5173\u5EA6", "\u6587\u6863\u9884\u89C8"], rows);
+  });
+}
+
+// src/commands/usage.ts
+function defaultStartDate() {
+  const now = /* @__PURE__ */ new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-01`;
+}
+function todayDate() {
+  const now = /* @__PURE__ */ new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+}
+function registerUsage(program) {
+  program.command("usage").description("\u67E5\u770B\u5F53\u524D Key \u7684\u989D\u5EA6\u4E0E\u5468\u671F\u7528\u91CF").option("--start <date>", "\u7528\u91CF\u7EDF\u8BA1\u8D77\u59CB\u65E5\uFF08YYYY-MM-DD\uFF0C\u9ED8\u8BA4\u5F53\u6708 1 \u65E5\uFF09").option("--end <date>", "\u7528\u91CF\u7EDF\u8BA1\u622A\u6B62\u65E5\uFF08YYYY-MM-DD\uFF0C\u9ED8\u8BA4\u4ECA\u5929\uFF09").action(async (opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const token = await fetchTokenUsage(auth.baseUrl, auth.apiKey);
+    const start = opts.start ?? defaultStartDate();
+    const end = opts.end ?? todayDate();
+    const billing = await request({
+      baseUrl: auth.baseUrl,
+      path: "/v1/dashboard/billing/usage",
+      query: { start_date: start, end_date: end },
+      apiKey: auth.apiKey
+    });
+    if (g.json) {
+      printJson({ token, period: { start, end }, billing });
+      return;
+    }
+    printTable(
+      ["\u9879\u76EE", "\u503C"],
+      [
+        ["\u4EE4\u724C\u540D", token.name],
+        ["\u603B\u989D\u5EA6", token.unlimited_quota ? "\u65E0\u9650" : String(token.total_granted)],
+        ["\u5DF2\u7528", String(token.total_used)],
+        ["\u5269\u4F59", token.unlimited_quota ? "\u65E0\u9650" : String(token.total_available)],
+        ["\u8FC7\u671F\u65F6\u95F4", token.expires_at > 0 ? new Date(token.expires_at * 1e3).toLocaleString() : "\u6C38\u4E0D\u8FC7\u671F"],
+        [`\u5468\u671F\u7528\u91CF\uFF08${start} ~ ${end}\uFF09`, JSON.stringify(billing)]
+      ]
+    );
+  });
+}
+
+// src/commands/connect.ts
+import { cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2, platform } from "os";
+import { dirname, join as join4 } from "path";
+import { fileURLToPath } from "url";
+var MANIFEST_NAME = ".focalapi-connect-manifest.json";
+function homeDir() {
+  return normalizeHomePath(process.env.FOCALAPI_HOME ?? homedir2());
+}
+function getTargets() {
+  const home = homeDir();
+  const claudeRoot = join4(home, ".claude");
+  const codexRoot = join4(home, ".codex");
+  const opencodeRoot = join4(home, ".config", "opencode");
+  const hermesRoot = platform() === "win32" ? join4(home, "AppData", "Local", "hermes") : join4(home, ".config", "hermes");
+  return [
+    {
+      id: "claude-code",
+      name: "Claude Code",
+      skillsDir: join4(claudeRoot, "skills"),
+      detected: existsSync2(claudeRoot),
+      providerHint: [
+        "Claude Code provider \u914D\u7F6E\uFF08\u624B\u52A8\uFF09\uFF1A",
+        "  \u5728 ~/.claude/settings.json \u7684 env \u6BB5\u52A0\u5165\uFF1A",
+        '    "ANTHROPIC_BASE_URL": "https://api.focalapi.com",',
+        '    "ANTHROPIC_AUTH_TOKEN": "<\u4F60\u7684 sk- key>"',
+        "  \uFF08focalapi \u5DF2\u517C\u5BB9 /v1/messages \u534F\u8BAE\uFF09"
+      ].join("\n")
+    },
+    {
+      id: "codex",
+      name: "Codex",
+      skillsDir: join4(codexRoot, "skills"),
+      detected: existsSync2(codexRoot),
+      providerHint: [
+        "Codex provider \u914D\u7F6E\uFF08\u624B\u52A8\uFF09\uFF1A",
+        "  \u5728 ~/.codex/config.toml \u52A0\u5165\uFF1A",
+        "    [model_providers.focalapi]",
+        '    name = "focalapi"',
+        '    base_url = "https://api.focalapi.com/v1"',
+        '    env_key = "FOCALAPI_API_KEY"',
+        "  \uFF08focalapi \u5DF2\u517C\u5BB9 /v1/responses \u4E0E /v1/chat/completions\uFF09"
+      ].join("\n")
+    },
+    {
+      id: "opencode",
+      name: "OpenCode",
+      skillsDir: join4(opencodeRoot, "skills"),
+      detected: existsSync2(opencodeRoot),
+      providerHint: [
+        "OpenCode provider \u914D\u7F6E\uFF08\u624B\u52A8\uFF09\uFF1A",
+        "  \u5728 opencode.json \u7684 provider \u6BB5\u52A0\u5165 openai-compatible \u63D0\u4F9B\u5546\uFF0C",
+        '  baseURL = "https://api.focalapi.com/v1"\uFF0CapiKey \u6307\u5411\u4F60\u7684 sk- key\u3002'
+      ].join("\n")
+    },
+    {
+      id: "hermes",
+      name: "Hermes",
+      skillsDir: join4(hermesRoot, "skills"),
+      detected: existsSync2(hermesRoot),
+      providerHint: [
+        "Hermes \u914D\u7F6E\uFF08\u624B\u52A8\uFF09\uFF1A",
+        "  \u6280\u80FD\u5DF2\u88C5\u5165\u9ED8\u8BA4 profile \u7684 skills \u76EE\u5F55\uFF1B\u975E\u9ED8\u8BA4 profile \u8BF7\u628A\u6280\u80FD\u76EE\u5F55\u590D\u5236\u5230",
+        "  hermes/profiles/<name>/skills/\u3002provider \u5728 config.yaml \u52A0 openai-compatible",
+        '  \u63D0\u4F9B\u5546\uFF0Cbase_url = "https://api.focalapi.com/v1"\u3002'
+      ].join("\n")
+    }
+  ];
+}
+function bundledSkillsDir() {
+  if (process.env.FOCALAPI_SKILLS_DIR) {
+    return process.env.FOCALAPI_SKILLS_DIR;
+  }
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [join4(here, "..", "skills"), join4(here, "..", "..", "skills")];
+  for (const dir of candidates) {
+    if (existsSync2(join4(dir, "focalapi", "SKILL.md"))) {
+      return dir;
+    }
+  }
+  throw new ApiError("internal_error", "\u672A\u627E\u5230\u5185\u7F6E skills \u76EE\u5F55\uFF08focalapi/SKILL.md \u7F3A\u5931\uFF09");
+}
+function listBundledSkills(srcDir) {
+  const dir = srcDir ?? bundledSkillsDir();
+  return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory() && d.name.startsWith("focalapi") && existsSync2(join4(dir, d.name, "SKILL.md"))).map((d) => d.name).sort();
+}
+function manifestPath(skillsDir) {
+  return join4(skillsDir, MANIFEST_NAME);
+}
+function readManifest(skillsDir) {
+  const path = manifestPath(skillsDir);
+  if (!existsSync2(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync5(path, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function installTo(target, skills, srcDir) {
+  mkdirSync2(target.skillsDir, { recursive: true });
+  for (const skill of skills) {
+    cpSync(join4(srcDir, skill), join4(target.skillsDir, skill), { recursive: true });
+  }
+  const manifest = {
+    tool: "focalapi-cli",
+    version: VERSION,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    skills
+  };
+  writeFileSync2(manifestPath(target.skillsDir), JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  return manifest;
+}
+function uninstallFrom(target) {
+  const manifest = readManifest(target.skillsDir);
+  if (!manifest) {
+    return { removed: [], hadManifest: false };
+  }
+  const removed = [];
+  for (const skill of manifest.skills) {
+    const dir = join4(target.skillsDir, skill);
+    if (skill.startsWith("focalapi") && existsSync2(dir)) {
+      rmSync(dir, { recursive: true, force: true });
+      removed.push(skill);
+    }
+  }
+  rmSync(manifestPath(target.skillsDir), { force: true });
+  return { removed, hadManifest: true };
+}
+function resolveTargets(targetIds, g) {
+  const all = getTargets();
+  if (targetIds && targetIds.length > 0) {
+    const unknown = targetIds.filter((id) => !all.some((t) => t.id === id));
+    if (unknown.length > 0) {
+      throw new ApiError("invalid_request", `\u672A\u77E5 Agent\uFF1A${unknown.join(", ")}`, {
+        hint: `\u53EF\u9009\uFF1A${all.map((t) => t.id).join(" | ")}\u3002`
+      });
+    }
+    return all.filter((t) => targetIds.includes(t.id));
+  }
+  const detected = all.filter((t) => t.detected);
+  if (detected.length === 0) {
+    throw new ApiError("invalid_request", "\u672A\u68C0\u6D4B\u5230\u4EFB\u4F55\u672C\u673A Agent", {
+      hint: `\u652F\u6301\uFF1A${all.map((t) => `${t.id}\uFF08${t.name}\uFF09`).join("\u3001")}\u3002\u53EF\u5148\u663E\u5F0F\u6307\u5B9A\uFF1Afocalapi connect install <agent>\u3002`
+    });
+  }
+  if (!g.json) {
+    info(`\u68C0\u6D4B\u5230 ${detected.length} \u4E2A Agent\uFF1A${detected.map((t) => t.name).join("\u3001")}`);
+  }
+  return detected;
+}
+function registerConnect(program) {
+  const connect = program.command("connect").description("\u628A focalapi \u80FD\u529B\u6CE8\u5165\u672C\u673A AI Agent\uFF08skills \u5B89\u88C5/\u5378\u8F7D\uFF09");
+  connect.command("list").description("\u5217\u51FA\u652F\u6301\u7684 Agent \u53CA\u68C0\u6D4B/\u5B89\u88C5\u72B6\u6001").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const rows = getTargets().map((t) => {
+      const manifest = readManifest(t.skillsDir);
+      return {
+        id: t.id,
+        name: t.name,
+        detected: t.detected,
+        skillsDir: t.skillsDir,
+        installed: manifest ? `${manifest.skills.length} \u4E2A\u6280\u80FD\uFF08v${manifest.version}\uFF09` : ""
+      };
+    });
+    if (g.json) {
+      printJson({ agents: rows });
+    } else {
+      printTable(
+        ["Agent", "ID", "\u68C0\u6D4B\u5230", "\u5DF2\u5B89\u88C5", "\u6280\u80FD\u76EE\u5F55"],
+        rows.map((r) => [r.name, r.id, r.detected ? "\u2713" : "-", r.installed || "-", r.skillsDir])
+      );
+    }
+  });
+  connect.command("install").description("\u5411\u6307\u5B9A\uFF08\u6216\u5168\u90E8\u5DF2\u68C0\u6D4B\u5230\u7684\uFF09Agent \u5B89\u88C5 focalapi \u6280\u80FD\u5305").argument("[targets...]", `Agent ID\uFF0C\u5982 claude-code codex\uFF1B\u7701\u7565=\u5168\u90E8\u5DF2\u68C0\u6D4B\u5230\u7684`).action(async (targetIds, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const targets = resolveTargets(targetIds, g);
+    const srcDir = bundledSkillsDir();
+    const skills = listBundledSkills(srcDir);
+    const results = targets.map((t) => ({ target: t, manifest: installTo(t, skills, srcDir) }));
+    if (g.json) {
+      printJson({
+        installed: results.map((r) => ({ agent: r.target.id, skillsDir: r.target.skillsDir, skills: r.manifest.skills }))
+      });
+      return;
+    }
+    for (const { target, manifest } of results) {
+      info(`\u2713 ${target.name}\uFF1A${manifest.skills.length} \u4E2A\u6280\u80FD\u5DF2\u88C5\u5165 ${target.skillsDir}`);
+    }
+    info("");
+    info("\u6280\u80FD\u5DF2\u5C31\u7EEA\u3002\u8981\u8BA9 Agent \u76F4\u63A5\u4EE5 focalapi \u4E3A\u6A21\u578B\u540E\u7AEF\uFF0C\u8FD8\u9700\u914D\u7F6E provider\uFF08v1 \u8BF7\u624B\u52A8\uFF09\uFF1A");
+    for (const { target } of results) {
+      info("");
+      info(target.providerHint);
+    }
+    info("");
+    info("\u5B8C\u6210\u540E\u91CD\u542F Agent \u4F1A\u8BDD\uFF0C\u5373\u53EF\u7528\u81EA\u7136\u8BED\u8A00\u8BA9\u5B83\u8C03\u7528 focalapi\uFF08\u5982\u300C\u7528 focalapi \u753B\u4E00\u5F20\u2026\u2026\u300D\uFF09\u3002");
+    info("\u5378\u8F7D\uFF1Afocalapi connect uninstall");
+  });
+  connect.command("uninstall").description("\u6309 manifest \u7CBE\u786E\u5378\u8F7D\u6CE8\u5165\u7684\u6280\u80FD\uFF08\u4E0D\u78B0\u5176\u4ED6\u6587\u4EF6\uFF09").argument("[targets...]", "Agent ID\uFF1B\u7701\u7565=\u5168\u90E8\u5DF2\u68C0\u6D4B\u5230\u7684").action(async (targetIds, _opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    const targets = resolveTargets(targetIds, g);
+    const results = targets.map((t) => ({ target: t, ...uninstallFrom(t) }));
+    if (g.json) {
+      printJson({
+        uninstalled: results.map((r) => ({ agent: r.target.id, removed: r.removed, hadManifest: r.hadManifest }))
+      });
+      return;
+    }
+    for (const r of results) {
+      if (!r.hadManifest) {
+        info(`- ${r.target.name}\uFF1A\u65E0 focalapi \u5B89\u88C5\u8BB0\u5F55\uFF0C\u8DF3\u8FC7`);
+      } else {
+        info(`\u2713 ${r.target.name}\uFF1A\u5DF2\u79FB\u9664 ${r.removed.length} \u4E2A\u6280\u80FD`);
+      }
+    }
+  });
+}
+
+// src/commands/update.ts
+var REGISTRY_URL = "https://registry.npmjs.org/focalapi-cli/latest";
+function compareVersions(a, b) {
+  const pa = a.split(".").map((x) => Number.parseInt(x, 10) || 0);
+  const pb = b.split(".").map((x) => Number.parseInt(x, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff > 0 ? 1 : -1;
+  }
+  return 0;
+}
+function registerUpdate(program) {
+  program.command("update").description("\u68C0\u67E5\u662F\u5426\u6709\u65B0\u7248\u672C\uFF08\u53EA\u8BFB\uFF0C\u4E0D\u81EA\u52A8\u5347\u7EA7\uFF09").action(async (_opts, cmd) => {
+    const g = cmd.optsWithGlobals();
+    let latest;
+    try {
+      const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(8e3) });
+      if (res.status === 404) {
+        if (g.json) {
+          printJson({ current: VERSION, published: false, updateAvailable: false });
+        } else {
+          info(`\u5F53\u524D\u7248\u672C v${VERSION}\uFF1Bfocalapi-cli \u5C1A\u672A\u53D1\u5E03\u5230 npm\uFF0C\u65E0\u9700\u66F4\u65B0\u3002`);
+        }
+        return;
+      }
+      if (!res.ok) {
+        throw new ApiError("network_error", `npm registry \u8FD4\u56DE HTTP ${res.status}`);
+      }
+      const data = await res.json();
+      latest = data.version ?? "0.0.0";
+    } catch (err) {
+      if (err instanceof ApiError) throw err;
+      throw new ApiError("network_error", `\u65E0\u6CD5\u8FDE\u63A5 npm registry\uFF1A${err?.message ?? err}`, {
+        hint: "\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8BD5\uFF1B\u8BE5\u547D\u4EE4\u53EA\u505A\u7248\u672C\u68C0\u67E5\uFF0C\u4E0D\u5F71\u54CD\u672C\u5730\u4F7F\u7528\u3002"
+      });
+    }
+    const updateAvailable = compareVersions(latest, VERSION) > 0;
+    if (g.json) {
+      printJson({ current: VERSION, latest, published: true, updateAvailable });
+      return;
+    }
+    if (updateAvailable) {
+      info(`\u53D1\u73B0\u65B0\u7248\u672C\uFF1Av${latest}\uFF08\u5F53\u524D v${VERSION}\uFF09`);
+      info("\u5347\u7EA7\uFF1Anpm i -g focalapi-cli@latest");
+    } else {
+      info(`\u5DF2\u662F\u6700\u65B0\u7248\u672C\uFF08v${VERSION}\uFF09\u3002`);
+    }
+  });
+}
+
+// src/commands/request.ts
+function normalizeReadPath(path) {
+  if (!path.startsWith("/") || path.startsWith("//")) {
+    throw new ApiError("invalid_request", "\u8BF7\u6C42\u8DEF\u5F84\u5FC5\u987B\u662F\u4EE5 / \u5F00\u5934\u7684\u7AD9\u5185\u8DEF\u5F84\uFF0C\u4F8B\u5982 /v1/models");
+  }
+  const parsed = new URL(path, "https://focalapi.invalid");
+  if (parsed.origin !== "https://focalapi.invalid") {
+    throw new ApiError("invalid_request", "\u8BF7\u6C42\u8DEF\u5F84\u4E0D\u80FD\u5305\u542B\u5916\u90E8\u57DF\u540D");
+  }
+  return `${parsed.pathname}${parsed.search}`;
+}
+function registerRequest(program) {
+  program.command("request").description("\u539F\u59CB\u53EA\u8BFB API \u8BF7\u6C42\uFF08\u4EC5 GET/HEAD\uFF1B\u7528\u4E8E\u5C1A\u672A\u5C01\u88C5\u7684\u7AEF\u70B9\uFF09").argument("<method>", "HTTP \u65B9\u6CD5\uFF1AGET \u6216 HEAD").argument("<path>", "\u7AD9\u5185 API \u8DEF\u5F84\uFF0C\u4F8B\u5982 /v1/models").action(async (methodArg, pathArg, _opts, cmd) => {
+    const method = methodArg.toUpperCase();
+    if (method !== "GET" && method !== "HEAD") {
+      throw new ApiError("invalid_request", "request \u4EC5\u5141\u8BB8 GET \u6216 HEAD\uFF1B\u5199\u64CD\u4F5C\u8BF7\u4F7F\u7528\u660E\u786E\u7684\u9AD8\u9636\u547D\u4EE4");
+    }
+    const g = cmd.optsWithGlobals();
+    const auth = resolveAuth(g);
+    const path = normalizeReadPath(pathArg);
+    const res = await rawRequest({
+      baseUrl: auth.baseUrl,
+      path,
+      method,
+      apiKey: auth.apiKey
+    });
+    const text = await res.text();
+    let data = null;
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = text;
+      }
+    }
+    printJson({
+      method,
+      path,
+      status: res.status,
+      content_type: res.headers.get("content-type") ?? null,
+      data
+    });
+  });
+}
+
+// src/cli.ts
+function buildProgram() {
+  const program = new Command();
+  program.name("focalapi").description("\u8FDE\u63A5 focalapi \u4E0E AI Agent \u7684\u547D\u4EE4\u884C\u5DE5\u5177\uFF1A\u5BF9\u8BDD\u3001\u56FE\u50CF\u3001\u89C6\u9891\u3001\u641C\u7D22\u3001\u97F3\u9891\u3001\u7528\u91CF\uFF0C\u4E00\u6761\u547D\u4EE4\u76F4\u8FBE").version(VERSION, "-v, --version", "\u663E\u793A\u7248\u672C\u53F7").option("--json", "\u4EE5 JSON \u8F93\u51FA\uFF08\u9762\u5411 Agent \u4E0E\u811A\u672C\uFF0Cstdout \u7EAF\u51C0\uFF09").option("--base-url <url>", "\u8986\u76D6 API \u5730\u5740\uFF08\u9ED8\u8BA4 https://api.focalapi.com\uFF0C\u53EF\u7528 FOCALAPI_BASE_URL\uFF09").option("--key <key>", "\u8986\u76D6 API Key\uFF08\u53EF\u7528 FOCALAPI_API_KEY\uFF09").option("--profile <name>", "\u4F7F\u7528\u6307\u5B9A\u914D\u7F6E\u6863\u6848");
+  registerAuth(program);
+  registerModels(program);
+  registerChat(program);
+  registerGen(program);
+  registerTask(program);
+  registerSearch(program);
+  registerAudio(program);
+  registerEmbed(program);
+  registerRerank(program);
+  registerUsage(program);
+  registerDoctor(program);
+  registerConnect(program);
+  registerUpdate(program);
+  registerRequest(program);
+  return program;
+}
+async function main(argv = process.argv) {
+  const program = buildProgram();
+  try {
+    await program.parseAsync(argv);
+    return 0;
+  } catch (err) {
+    let json = false;
+    try {
+      json = Boolean(program.opts().json);
+    } catch {
+    }
+    printError(err, { json });
+    return 1;
+  }
+}
+var invokedDirectly = typeof process.argv[1] === "string" && (process.argv[1].endsWith("cli.ts") || process.argv[1].endsWith("cli.js"));
+if (invokedDirectly) {
+  main().then((code) => {
+    process.exitCode = code;
+  });
+}
+export {
+  buildProgram,
+  main
+};