ai-zero-token 1.0.0 → 1.0.2

package/dist/cli/commands/serve.js

@@ -2,17 +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;
@@ -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,6 +2,7 @@
 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";
 function createGatewayContext() {
   const configService = new ConfigService();
@@ -11,14 +12,18 @@ function createGatewayContext() {
     authService,
     modelService
   });
+  const imageService = new ImageService({
+    authService,
+    configService
+  });
   return {
     configService,
     authService,
     modelService,
-    chatService
+    chatService,
+    imageService
   };
 }
 export {
   createGatewayContext
 };
-//# sourceMappingURL=context.js.map

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

@@ -31,4 +31,3 @@ export {
   SUPPORTED_CODEX_MODELS,
   isSupportedCodexModel
 };
-//# sourceMappingURL=openai-codex-models.js.map

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

@@ -1,7 +1,45 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 const CURL_STATUS_MARKER = "\n__CURL_STATUS__:";
-async function runCurlRequest(init) {
+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;
+}
+async function runCurlRequest(init, params) {
+  const requestId = params?.requestId ?? nextRequestId();
+  const startedAt = performance.now();
   const args = [
     "--silent",
     "--show-error",
@@ -22,6 +60,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,9 +77,11 @@ 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 parseStartedAt = performance.now();
   const markerIndex = stdout.lastIndexOf(CURL_STATUS_MARKER);
   if (markerIndex === -1) {
     throw new Error("curl \u54CD\u5E94\u7F3A\u5C11\u72B6\u6001\u7801\u6807\u8BB0\u3002");
@@ -49,36 +92,81 @@ async function runCurlRequest(init) {
   if (!Number.isFinite(status)) {
     throw new Error(`\u65E0\u6CD5\u89E3\u6790 curl \u72B6\u6001\u7801: ${statusText}`);
   }
+  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

package/dist/core/providers/openai-codex/chat.js

@@ -2,6 +2,101 @@
 import { DEFAULT_CODEX_MODEL } from "../../models/openai-codex-models.js";
 import { requestText } from "../http-client.js";
 const CODEX_RESPONSES_URL = "https://chatgpt.com/backend-api/codex/responses";
+const URL_KEY_RE = /(url|uri|href|download|preview|thumbnail|image|asset|file)/i;
+const REFERENCE_KEY_RE = /(image|asset|file|media|blob|artifact|download|preview|thumbnail)/i;
+const REFERENCE_VALUE_RE = /^(file|asset|image|img|media|blob)-[\w-]+$/i;
+function parseOptionalNumber(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseOptionalBoolean(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "true") {
+    return true;
+  }
+  if (trimmed === "false") {
+    return false;
+  }
+  return void 0;
+}
+function parseOptionalText(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function extractCodexQuotaSnapshot(headers, requestId) {
+  const activeLimit = parseOptionalText(headers["x-codex-active-limit"]);
+  const planType = parseOptionalText(headers["x-codex-plan-type"]);
+  const primaryUsedPercent = parseOptionalNumber(headers["x-codex-primary-used-percent"]);
+  const secondaryUsedPercent = parseOptionalNumber(headers["x-codex-secondary-used-percent"]);
+  const primaryWindowMinutes = parseOptionalNumber(headers["x-codex-primary-window-minutes"]);
+  const secondaryWindowMinutes = parseOptionalNumber(headers["x-codex-secondary-window-minutes"]);
+  const primaryResetAfterSeconds = parseOptionalNumber(headers["x-codex-primary-reset-after-seconds"]);
+  const secondaryResetAfterSeconds = parseOptionalNumber(headers["x-codex-secondary-reset-after-seconds"]);
+  const primaryResetAt = parseOptionalNumber(headers["x-codex-primary-reset-at"]);
+  const secondaryResetAt = parseOptionalNumber(headers["x-codex-secondary-reset-at"]);
+  const primaryOverSecondaryLimitPercent = parseOptionalNumber(
+    headers["x-codex-primary-over-secondary-limit-percent"]
+  );
+  const creditsHasCredits = parseOptionalBoolean(headers["x-codex-credits-has-credits"]);
+  const creditsUnlimited = parseOptionalBoolean(headers["x-codex-credits-unlimited"]);
+  const creditsBalance = parseOptionalText(headers["x-codex-credits-balance"]);
+  const promoCampaignId = parseOptionalText(headers["x-codex-promo-campaign-id"]);
+  const promoMessage = parseOptionalText(headers["x-codex-promo-message"]);
+  const hasQuotaData = [
+    activeLimit,
+    planType,
+    primaryUsedPercent,
+    secondaryUsedPercent,
+    primaryWindowMinutes,
+    secondaryWindowMinutes,
+    primaryResetAfterSeconds,
+    secondaryResetAfterSeconds,
+    primaryResetAt,
+    secondaryResetAt,
+    primaryOverSecondaryLimitPercent,
+    creditsHasCredits,
+    creditsUnlimited,
+    creditsBalance,
+    promoCampaignId,
+    promoMessage
+  ].some((value) => typeof value !== "undefined");
+  if (!hasQuotaData) {
+    return void 0;
+  }
+  return {
+    capturedAt: Date.now(),
+    sourceRequestId: requestId,
+    activeLimit,
+    planType,
+    primaryUsedPercent,
+    secondaryUsedPercent,
+    primaryWindowMinutes,
+    secondaryWindowMinutes,
+    primaryResetAfterSeconds,
+    secondaryResetAfterSeconds,
+    primaryResetAt,
+    secondaryResetAt,
+    primaryOverSecondaryLimitPercent,
+    creditsHasCredits,
+    creditsUnlimited,
+    creditsBalance,
+    promoCampaignId,
+    promoMessage
+  };
+}
 function extractOutputText(payload) {
   if (!payload || typeof payload !== "object") {
     return "";
@@ -43,12 +138,92 @@ function parseSseEvents(body) {
   }
   return events;
 }
-function extractCodexText(body) {
+function pushArtifactCandidate(items, dedupe, candidate) {
+  const signature = `${candidate.source}:${candidate.path}:${candidate.key}:${candidate.kind}:${candidate.value}`;
+  if (dedupe.has(signature)) {
+    return;
+  }
+  dedupe.add(signature);
+  items.push(candidate);
+}
+function collectArtifactCandidates(value, source, path = [], items = [], dedupe = /* @__PURE__ */ new Set()) {
+  if (typeof value === "string") {
+    const key = path[path.length - 1] ?? "";
+    const joinedPath = path.join(".");
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return items;
+    }
+    if (/^https?:\/\//i.test(trimmed)) {
+      pushArtifactCandidate(items, dedupe, {
+        source,
+        path: joinedPath,
+        key,
+        kind: "url",
+        value: trimmed
+      });
+      return items;
+    }
+    if (REFERENCE_KEY_RE.test(key) || REFERENCE_VALUE_RE.test(trimmed)) {
+      pushArtifactCandidate(items, dedupe, {
+        source,
+        path: joinedPath,
+        key,
+        kind: "reference",
+        value: trimmed
+      });
+    }
+    return items;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => {
+      collectArtifactCandidates(item, source, [...path, String(index)], items, dedupe);
+    });
+    return items;
+  }
+  if (!value || typeof value !== "object") {
+    return items;
+  }
+  for (const [key, nested] of Object.entries(value)) {
+    const nextPath = [...path, key];
+    if (typeof nested === "string" && (URL_KEY_RE.test(key) || /^https?:\/\//i.test(nested))) {
+      collectArtifactCandidates(nested, source, nextPath, items, dedupe);
+      continue;
+    }
+    collectArtifactCandidates(nested, source, nextPath, items, dedupe);
+  }
+  return items;
+}
+function buildDefaultRequestBody(params) {
+  const body = {
+    model: params.model ?? DEFAULT_CODEX_MODEL,
+    store: false,
+    stream: true,
+    instructions: params.system ?? "",
+    text: { verbosity: "medium" },
+    include: ["reasoning.encrypted_content"],
+    tool_choice: "auto",
+    parallel_tool_calls: true
+  };
+  if (typeof params.prompt === "string" && params.prompt.trim()) {
+    body.input = [
+      {
+        role: "user",
+        content: [{ type: "input_text", text: params.prompt }]
+      }
+    ];
+  }
+  return body;
+}
+function extractCodexText(body, requestBody) {
   const events = parseSseEvents(body);
   let responsePayload;
   let accumulated = "";
   for (const event of events) {
-    if (event.type === "response.completed" || event.type === "response.done" || event.type === "response.incomplete") {
+    if (typeof event.response !== "undefined") {
+      responsePayload = event.response;
+    }
+    if (event.type === "response.completed" || event.type === "response.done" || event.type === "response.incomplete" || event.type === "response.failed") {
       responsePayload = event.response;
     }
     if (typeof event.delta === "string" && event.delta) {
@@ -56,12 +231,39 @@ function extractCodexText(body) {
     }
   }
   const completedText = extractOutputText(responsePayload);
+  const artifacts = [
+    ...collectArtifactCandidates(responsePayload, "response"),
+    ...collectArtifactCandidates(events, "event")
+  ];
   if (completedText) {
-    return { text: completedText, raw: responsePayload ?? events };
+    return {
+      text: completedText,
+      raw: {
+        request: requestBody,
+        response: responsePayload ?? null,
+        events
+      },
+      artifacts
+    };
   }
-  return { text: accumulated.trim(), raw: responsePayload ?? events };
+  return {
+    text: accumulated.trim(),
+    raw: {
+      request: requestBody,
+      response: responsePayload ?? null,
+      events
+    },
+    artifacts
+  };
 }
 async function askOpenAICodex(params) {
+  const requestBody = {
+    ...buildDefaultRequestBody(params),
+    ...params.bodyOverride ?? {}
+  };
+  if (typeof requestBody.input === "undefined") {
+    throw new Error("Codex \u8BF7\u6C42\u7F3A\u5C11 input\u3002\u8BF7\u63D0\u4F9B prompt \u6216\u5728\u5B9E\u9A8C\u8BF7\u6C42\u4F53\u91CC\u663E\u5F0F\u4F20\u5165 input\u3002");
+  }
   const response = await requestText({
     method: "POST",
     url: CODEX_RESPONSES_URL,
@@ -74,29 +276,20 @@ async function askOpenAICodex(params) {
       Originator: "pi",
       "User-Agent": "pi (bun demo)"
     },
-    body: JSON.stringify({
-      model: params.model ?? DEFAULT_CODEX_MODEL,
-      store: false,
-      stream: true,
-      instructions: params.system ?? "",
-      input: [
-        {
-          role: "user",
-          content: [{ type: "input_text", text: params.prompt }]
-        }
-      ],
-      text: { verbosity: "medium" },
-      include: ["reasoning.encrypted_content"],
-      tool_choice: "auto",
-      parallel_tool_calls: true
-    })
+    body: JSON.stringify(requestBody)
   });
+  const quota = extractCodexQuotaSnapshot(response.headers, response.requestId);
   if (response.status < 200 || response.status >= 300) {
-    throw new Error(`\u8C03\u7528 Responses API \u5931\u8D25: HTTP ${response.status} via ${response.transport} ${response.body}`);
+    const error = new Error(`\u8C03\u7528 Responses API \u5931\u8D25: HTTP ${response.status} via ${response.transport} ${response.body}`);
+    error.quota = quota;
+    throw error;
   }
-  return extractCodexText(response.body);
+  return {
+    ...extractCodexText(response.body, requestBody),
+    quota
+  };
 }
 export {
-  askOpenAICodex
+  askOpenAICodex,
+  extractCodexQuotaSnapshot
 };
-//# sourceMappingURL=chat.js.map