ai-zero-token 1.0.1 → 1.0.3

package/dist/cli/commands/models.js

@@ -1,9 +1,20 @@
 #!/usr/bin/env node
 import { createGatewayContext } from "../../core/context.js";
-async function runModelsCommand() {
+async function runModelsCommand(args = []) {
   const ctx = createGatewayContext();
-  console.log("\u5F53\u524D demo \u5185\u7F6E\u652F\u6301\u7684\u6A21\u578B:");
-  for (const model of await ctx.modelService.listModels()) {
+  const refresh = args.includes("--refresh");
+  const result = refresh ? await ctx.modelService.refreshModels() : {
+    models: await ctx.modelService.listModels(),
+    catalog: await ctx.modelService.getCatalog()
+  };
+  console.log(refresh ? "\u5DF2\u91CD\u65B0\u8BFB\u53D6 Codex \u6A21\u578B\u5217\u8868:" : "\u5F53\u524D demo \u53EF\u7528\u6A21\u578B\u5217\u8868:");
+  console.log(`- \u6765\u6E90: ${result.catalog.source === "codex-cache" ? "Codex \u672C\u5730\u7F13\u5B58" : "\u9879\u76EE\u5185\u7F6E\u56DE\u9000\u5217\u8868"}`);
+  console.log(`- \u8DEF\u5F84: ${result.catalog.cachePath}`);
+  if (result.catalog.fetchedAt) {
+    console.log(`- Codex \u66F4\u65B0\u65F6\u95F4: ${result.catalog.fetchedAt}`);
+  }
+  console.log(`- \u6570\u91CF: ${result.catalog.modelCount}`);
+  for (const model of result.models) {
     const suffix = model.isDefault ? " (\u9ED8\u8BA4)" : "";
     console.log(`- ${model.id}${suffix}`);
   }
@@ -11,4 +22,3 @@ async function runModelsCommand() {
 export {
   runModelsCommand
 };
-//# sourceMappingURL=models.js.map

package/dist/cli/commands/serve.js

@@ -2,18 +2,55 @@
 import { createGatewayContext } from "../../core/context.js";
 import { startServer } from "../../server/index.js";
 import { parseServeArgs } from "../shared.js";
-async function runServeCommand(args) {
-  const { host, port } = parseServeArgs(args);
+import { spawn } from "node:child_process";
+function createBrowserUrl(host, port) {
+  if (host === "0.0.0.0" || host === "::") {
+    return `http://127.0.0.1:${port}`;
+  }
+  return `http://${host}:${port}`;
+}
+function createListenUrl(host, port) {
+  return `http://${host}:${port}`;
+}
+function tryOpenBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      const child2 = spawn("open", [url], { stdio: "ignore", detached: true });
+      child2.unref();
+      return true;
+    }
+    if (process.platform === "win32") {
+      const child2 = spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true });
+      child2.unref();
+      return true;
+    }
+    const child = spawn("xdg-open", [url], { stdio: "ignore", detached: true });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runServeCommand(args, options) {
+  const { host, port, openBrowser } = parseServeArgs(args);
   const ctx = createGatewayContext();
   const status = await ctx.authService.getStatus();
   const server = await startServer({ host, port });
+  const adminUrl = createBrowserUrl(server.host, server.port);
+  const listenUrl = createListenUrl(server.host, server.port);
+  const shouldOpenBrowser = openBrowser ?? options?.openBrowserByDefault ?? false;
   console.log("\u672C\u5730\u7F51\u5173\u5DF2\u542F\u52A8\u3002");
-  console.log(`url: http://${server.host}:${server.port}`);
+  console.log(`url: ${listenUrl}`);
+  console.log(`admin: ${adminUrl}`);
+  console.log(`apiBase: ${adminUrl}/v1`);
   console.log(`corsOrigin: ${server.corsOrigin}`);
   console.log(`activeProvider: ${status.activeProvider ?? "none"}`);
   console.log(`defaultModel: ${status.defaultModel}`);
+  if (shouldOpenBrowser) {
+    const opened = tryOpenBrowser(adminUrl);
+    console.log(opened ? "\u5DF2\u5C1D\u8BD5\u6253\u5F00\u7BA1\u7406\u9875\u9762\u3002" : "\u672A\u80FD\u81EA\u52A8\u6253\u5F00\u7BA1\u7406\u9875\u9762\uFF0C\u8BF7\u624B\u52A8\u8BBF\u95EE\u4E0A\u9762\u7684 admin \u5730\u5740\u3002");
+  }
 }
 export {
   runServeCommand
 };
-//# sourceMappingURL=serve.js.map

package/dist/cli/commands/start.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runServeCommand } from "./serve.js";
+async function runStartCommand(args) {
+  await runServeCommand(args, {
+    openBrowserByDefault: true
+  });
+}
+export {
+  runStartCommand
+};

package/dist/cli/commands/status.js

@@ -15,6 +15,7 @@ async function runStatusCommand() {
   console.log("\u5F53\u524D\u767B\u5F55\u72B6\u6001:");
   console.log(`provider: ${status.activeProvider}`);
   console.log(`profileId: ${status.activeProfileId}`);
+  console.log(`profileCount: ${status.profileCount}`);
   console.log(`defaultModel: ${status.defaultModel}`);
   console.log(`serverHost: ${status.serverHost}`);
   console.log(`serverPort: ${status.serverPort}`);
@@ -29,4 +30,3 @@ async function runStatusCommand() {
 export {
   runStatusCommand
 };
-//# sourceMappingURL=status.js.map

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import { printHelp } from "./commands/help.js";
 import { runLoginCommand } from "./commands/login.js";
 import { runModelsCommand } from "./commands/models.js";
 import { runServeCommand } from "./commands/serve.js";
+import { runStartCommand } from "./commands/start.js";
 import { runStatusCommand } from "./commands/status.js";
 async function runCli(argv = process.argv.slice(2)) {
   const [command, ...rest] = argv;
@@ -16,7 +17,7 @@ async function runCli(argv = process.argv.slice(2)) {
       await runStatusCommand();
       return;
     case "models":
-      await runModelsCommand();
+      await runModelsCommand(rest);
       return;
     case "ask":
       await runAskCommand(rest);
@@ -24,6 +25,9 @@ async function runCli(argv = process.argv.slice(2)) {
     case "serve":
       await runServeCommand(rest);
       return;
+    case "start":
+      await runStartCommand(rest);
+      return;
     case "clear":
       await runClearCommand();
       return;
@@ -40,4 +44,3 @@ async function runCli(argv = process.argv.slice(2)) {
 export {
   runCli
 };
-//# sourceMappingURL=index.js.map

package/dist/cli/shared.js

@@ -7,16 +7,55 @@ function formatExpiry(expires) {
 function parseAskArgs(args) {
   const rest = [...args];
   let model;
+  let payloadFile;
+  let dumpRawFile;
+  let writeArtifactsDir;
+  let printRaw = false;
+  let allowUnknownModel = false;
   for (let index = 0; index < rest.length; index += 1) {
-    if (rest[index] !== "--model") {
+    if (rest[index] === "--model") {
+      model = rest[index + 1];
+      rest.splice(index, 2);
+      index -= 1;
       continue;
     }
-    model = rest[index + 1];
-    rest.splice(index, 2);
-    break;
+    if (rest[index] === "--payload-file") {
+      payloadFile = rest[index + 1];
+      rest.splice(index, 2);
+      index -= 1;
+      continue;
+    }
+    if (rest[index] === "--dump-raw") {
+      dumpRawFile = rest[index + 1];
+      rest.splice(index, 2);
+      index -= 1;
+      continue;
+    }
+    if (rest[index] === "--write-artifacts-dir") {
+      writeArtifactsDir = rest[index + 1];
+      rest.splice(index, 2);
+      index -= 1;
+      continue;
+    }
+    if (rest[index] === "--print-raw") {
+      printRaw = true;
+      rest.splice(index, 1);
+      index -= 1;
+      continue;
+    }
+    if (rest[index] === "--allow-unknown-model") {
+      allowUnknownModel = true;
+      rest.splice(index, 1);
+      index -= 1;
+    }
   }
   return {
     model,
+    payloadFile,
+    dumpRawFile,
+    writeArtifactsDir,
+    printRaw,
+    allowUnknownModel,
     prompt: rest.join(" ").trim()
   };
 }
@@ -24,6 +63,7 @@ function parseServeArgs(args) {
   const rest = [...args];
   let host;
   let port;
+  let openBrowser;
   for (let index = 0; index < rest.length; index += 1) {
     if (rest[index] === "--host") {
       host = rest[index + 1];
@@ -38,13 +78,24 @@ function parseServeArgs(args) {
       }
       rest.splice(index, 2);
       index -= 1;
+      continue;
+    }
+    if (rest[index] === "--open") {
+      openBrowser = true;
+      rest.splice(index, 1);
+      index -= 1;
+      continue;
+    }
+    if (rest[index] === "--no-open") {
+      openBrowser = false;
+      rest.splice(index, 1);
+      index -= 1;
     }
   }
-  return { host, port };
+  return { host, port, openBrowser };
 }
 export {
   formatExpiry,
   parseAskArgs,
   parseServeArgs
 };
-//# sourceMappingURL=shared.js.map

package/dist/cli.js

@@ -5,4 +5,3 @@ runCli().catch((error) => {
   console.error(`\u9519\u8BEF: ${message}`);
   process.exitCode = 1;
 });
-//# sourceMappingURL=cli.js.map

package/dist/core/context.js

@@ -2,23 +2,31 @@
 import { ConfigService } from "./services/config-service.js";
 import { AuthService } from "./services/auth-service.js";
 import { ChatService } from "./services/chat-service.js";
+import { ImageService } from "./services/image-service.js";
 import { ModelService } from "./services/model-service.js";
+import { VersionService } from "./services/version-service.js";
 function createGatewayContext() {
   const configService = new ConfigService();
   const authService = new AuthService(configService);
   const modelService = new ModelService(configService);
+  const versionService = new VersionService();
   const chatService = new ChatService({
     authService,
     modelService
   });
+  const imageService = new ImageService({
+    authService,
+    configService
+  });
   return {
     configService,
     authService,
     modelService,
-    chatService
+    versionService,
+    chatService,
+    imageService
   };
 }
 export {
   createGatewayContext
 };
-//# sourceMappingURL=context.js.map

package/dist/core/models/openai-codex-models.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 const DEFAULT_CODEX_MODEL = "gpt-5.4";
 const CODEX_MODEL_INFOS = [
   { provider: "openai-codex", id: "gpt-5.4", name: "GPT-5.4", input: ["text", "image"], source: "static" },
@@ -22,6 +25,88 @@ const SUPPORTED_CODEX_MODELS = [
   "gpt-5.1-codex-mini",
   "gpt-5.1-codex-max"
 ];
+function getCodexModelsCachePath() {
+  return process.env.CODEX_MODELS_CACHE_PATH || path.join(os.homedir(), ".codex", "models_cache.json");
+}
+function normalizeInputModalities(input) {
+  const rawValues = Array.isArray(input) ? input : [];
+  const values = /* @__PURE__ */ new Set();
+  for (const item of rawValues) {
+    if (item === "text" || item === "image") {
+      values.add(item);
+    }
+  }
+  if (values.size === 0) {
+    values.add("text");
+  }
+  return Array.from(values);
+}
+function normalizeCodexCacheEntry(entry) {
+  if (!entry || typeof entry.slug !== "string" || !entry.slug) {
+    return null;
+  }
+  if (typeof entry.visibility === "string" && entry.visibility !== "list") {
+    return null;
+  }
+  return {
+    provider: "openai-codex",
+    id: entry.slug,
+    name: typeof entry.display_name === "string" && entry.display_name ? entry.display_name : entry.slug,
+    input: normalizeInputModalities(entry.input_modalities),
+    source: "codex-cache"
+  };
+}
+function dedupeModels(models) {
+  const seen = /* @__PURE__ */ new Set();
+  const next = [];
+  for (const model of models) {
+    if (seen.has(model.id)) {
+      continue;
+    }
+    seen.add(model.id);
+    next.push(model);
+  }
+  return next;
+}
+async function getCodexModelCatalog() {
+  const cachePath = getCodexModelsCachePath();
+  try {
+    const raw = await fs.readFile(cachePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const models = dedupeModels((parsed.models ?? []).map(normalizeCodexCacheEntry).filter(Boolean));
+    if (models.length > 0) {
+      return {
+        models,
+        catalog: {
+          source: "codex-cache",
+          cachePath,
+          fetchedAt: parsed.fetched_at,
+          modelCount: models.length
+        }
+      };
+    }
+  } catch {
+  }
+  return {
+    models: CODEX_MODEL_INFOS,
+    catalog: {
+      source: "static-fallback",
+      cachePath,
+      modelCount: CODEX_MODEL_INFOS.length
+    }
+  };
+}
+async function hasCodexModel(model) {
+  const { models } = await getCodexModelCatalog();
+  return models.some((item) => item.id === model);
+}
+async function getPreferredCodexModel() {
+  const { models } = await getCodexModelCatalog();
+  if (models.some((item) => item.id === DEFAULT_CODEX_MODEL)) {
+    return DEFAULT_CODEX_MODEL;
+  }
+  return models[0]?.id ?? DEFAULT_CODEX_MODEL;
+}
 function isSupportedCodexModel(model) {
   return SUPPORTED_CODEX_MODELS.includes(model);
 }
@@ -29,6 +114,9 @@ export {
   CODEX_MODEL_INFOS,
   DEFAULT_CODEX_MODEL,
   SUPPORTED_CODEX_MODELS,
+  getCodexModelCatalog,
+  getCodexModelsCachePath,
+  getPreferredCodexModel,
+  hasCodexModel,
   isSupportedCodexModel
 };
-//# sourceMappingURL=openai-codex-models.js.map

package/dist/core/providers/http-client.js

@@ -1,7 +1,63 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 const CURL_STATUS_MARKER = "\n__CURL_STATUS__:";
-async function runCurlRequest(init) {
+const CURL_HEADERS_MARKER = "\n__CURL_HEADERS__:";
+let requestSequence = 0;
+function nextRequestId() {
+  requestSequence += 1;
+  return `http-${String(requestSequence).padStart(4, "0")}`;
+}
+function roundMs(value) {
+  return Math.round(value * 100) / 100;
+}
+function finalizeTiming(startedAt, phases) {
+  return {
+    phasesMs: Object.fromEntries(
+      Object.entries(phases).map(([key, value]) => [key, roundMs(value)])
+    ),
+    totalMs: roundMs(performance.now() - startedAt)
+  };
+}
+function logHttpTiming(params) {
+  console.info("[http] request timing", {
+    requestId: params.requestId,
+    method: params.method,
+    url: params.url,
+    transport: params.transport,
+    status: params.status,
+    bodyLength: params.bodyLength,
+    fallbackFrom: params.fallbackFrom,
+    phasesMs: params.timing.phasesMs,
+    totalMs: params.timing.totalMs
+  });
+}
+function normalizeHeaders(headers) {
+  const normalized = {};
+  headers.forEach((value, key) => {
+    normalized[key.toLowerCase()] = value;
+  });
+  return normalized;
+}
+function normalizeCurlHeaders(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(value).flatMap(([key, rawValue]) => {
+      if (typeof rawValue === "string" && rawValue.trim()) {
+        return [[key.toLowerCase(), rawValue.trim()]];
+      }
+      if (Array.isArray(rawValue)) {
+        const joined = rawValue.filter((item) => typeof item === "string" && item.trim()).join(", ");
+        return joined ? [[key.toLowerCase(), joined]] : [];
+      }
+      return [];
+    })
+  );
+}
+async function runCurlRequest(init, params) {
+  const requestId = params?.requestId ?? nextRequestId();
+  const startedAt = performance.now();
   const args = [
     "--silent",
     "--show-error",
@@ -10,7 +66,7 @@ async function runCurlRequest(init) {
     init.method,
     init.url,
     "--write-out",
-    `${CURL_STATUS_MARKER}%{http_code}`
+    `${CURL_STATUS_MARKER}%{http_code}${CURL_HEADERS_MARKER}%{header_json}`
   ];
   for (const [key, value] of Object.entries(init.headers ?? {})) {
     args.push("--header", `${key}: ${value}`);
@@ -22,6 +78,9 @@ async function runCurlRequest(init) {
     env: process.env,
     stdio: ["ignore", "pipe", "pipe"]
   });
+  const phases = {
+    spawnCurlMs: performance.now() - startedAt
+  };
   let stdout = "";
   let stderr = "";
   child.stdout.setEncoding("utf8");
@@ -36,49 +95,113 @@ async function runCurlRequest(init) {
     child.on("error", reject);
     child.on("close", (code) => resolve(code ?? 1));
   });
+  phases.waitForCurlMs = performance.now() - startedAt - phases.spawnCurlMs;
   if (exitCode !== 0) {
     throw new Error(stderr.trim() || `curl \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}`);
   }
-  const markerIndex = stdout.lastIndexOf(CURL_STATUS_MARKER);
-  if (markerIndex === -1) {
+  const parseStartedAt = performance.now();
+  const statusMarkerIndex = stdout.lastIndexOf(CURL_STATUS_MARKER);
+  const headersMarkerIndex = stdout.lastIndexOf(CURL_HEADERS_MARKER);
+  if (statusMarkerIndex === -1) {
     throw new Error("curl \u54CD\u5E94\u7F3A\u5C11\u72B6\u6001\u7801\u6807\u8BB0\u3002");
   }
-  const body = stdout.slice(0, markerIndex);
-  const statusText = stdout.slice(markerIndex + CURL_STATUS_MARKER.length).trim();
+  if (headersMarkerIndex === -1 || headersMarkerIndex < statusMarkerIndex) {
+    throw new Error("curl \u54CD\u5E94\u7F3A\u5C11\u54CD\u5E94\u5934\u6807\u8BB0\u3002");
+  }
+  const body = stdout.slice(0, statusMarkerIndex);
+  const statusText = stdout.slice(statusMarkerIndex + CURL_STATUS_MARKER.length, headersMarkerIndex).trim();
   const status = Number.parseInt(statusText, 10);
   if (!Number.isFinite(status)) {
     throw new Error(`\u65E0\u6CD5\u89E3\u6790 curl \u72B6\u6001\u7801: ${statusText}`);
   }
+  const headersText = stdout.slice(headersMarkerIndex + CURL_HEADERS_MARKER.length).trim();
+  let headers = {};
+  if (headersText) {
+    try {
+      headers = normalizeCurlHeaders(JSON.parse(headersText));
+    } catch (error) {
+      console.warn("[http] failed to parse curl response headers", {
+        requestId,
+        url: init.url,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  phases.parseResponseMs = performance.now() - parseStartedAt;
+  const timing = finalizeTiming(startedAt, phases);
+  logHttpTiming({
+    requestId,
+    method: init.method,
+    url: init.url,
+    status,
+    transport: "curl",
+    timing,
+    bodyLength: body.length,
+    fallbackFrom: params?.fallbackFrom
+  });
   return {
     body,
     status,
-    transport: "curl"
+    transport: "curl",
+    timing,
+    requestId,
+    headers
   };
 }
 async function requestText(init) {
+  const requestId = nextRequestId();
   const useCurlOnly = process.env.OAUTH_DEMO_USE_CURL === "1";
-  const timeoutMs = init.timeoutMs ?? 2e4;
+  const timeoutMs = init.timeoutMs;
+  const signal = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? AbortSignal.timeout(timeoutMs) : void 0;
   if (!useCurlOnly) {
+    const startedAt = performance.now();
+    const phases = {};
     try {
+      const fetchStartedAt = performance.now();
       const response = await fetch(init.url, {
         method: init.method,
         headers: init.headers,
         body: init.body,
-        signal: AbortSignal.timeout(timeoutMs)
+        signal
+      });
+      phases.waitForHeadersMs = performance.now() - fetchStartedAt;
+      const readBodyStartedAt = performance.now();
+      const body = await response.text();
+      phases.readBodyMs = performance.now() - readBodyStartedAt;
+      const timing = finalizeTiming(startedAt, phases);
+      logHttpTiming({
+        requestId,
+        method: init.method,
+        url: init.url,
+        status: response.status,
+        transport: "fetch",
+        timing,
+        bodyLength: body.length
       });
       return {
-        body: await response.text(),
+        body,
         status: response.status,
-        transport: "fetch"
+        transport: "fetch",
+        timing,
+        requestId,
+        headers: normalizeHeaders(response.headers)
       };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      console.log(`fetch \u8BF7\u6C42\u5931\u8D25\uFF0C\u51C6\u5907\u56DE\u9000\u5230 curl: ${message}`);
+      console.warn("[http] fetch attempt failed", {
+        requestId,
+        method: init.method,
+        url: init.url,
+        elapsedMs: roundMs(performance.now() - startedAt),
+        error: message
+      });
     }
   }
-  return runCurlRequest(init);
+  return runCurlRequest(init, {
+    requestId,
+    fallbackFrom: useCurlOnly ? void 0 : "fetch"
+  });
 }
 export {
   requestText
 };
-//# sourceMappingURL=http-client.js.map