npm - ai-zero-token - Versions diffs - 2.0.4 → 2.0.5 - Mend

ai-zero-token 2.0.4 → 2.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/admin-ui/dist/index.html CHANGED Viewed

@@ -5,10 +5,10 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/svg+xml" href="/assets/app-mark-nsRs4vo7.svg" />
     <title>AI Zero Token</title>
-    <script type="module" crossorigin src="/assets/index-rgcJgVAu.js"></script>
+    <script type="module" crossorigin src="/assets/index--rNjdmzf.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/jsx-runtime-DqpGtLhh.js">
     <link rel="modulepreload" crossorigin href="/assets/profiles-DMOjJORP.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-By4r-wy3.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-DjtN30PC.css">
   </head>
   <body>
     <div id="root"></div>

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

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { PassThrough, Readable } from "node:stream";
 import { loadSettings } from "../store/settings-store.js";
 const CURL_STATUS_MARKER = "\n__CURL_STATUS__:";
 const CURL_HEADERS_MARKER = "\n__CURL_HEADERS__:";
@@ -38,6 +42,9 @@ function logHttpTiming(params) {
     totalMs: params.timing.totalMs
   });
 }
+function isElectronRuntime() {
+  return typeof process.versions.electron === "string";
+}
 function normalizeHeaders(headers) {
   const normalized = {};
   headers.forEach((value, key) => {
@@ -62,6 +69,33 @@ function normalizeCurlHeaders(value) {
     })
   );
 }
+function parseCurlHeaderDump(raw) {
+  const blocks = raw.replace(/\r\n/g, "\n").split(/\n\n+/).map((block2) => block2.trim()).filter((block2) => /^HTTP\//i.test(block2));
+  const block = blocks[blocks.length - 1];
+  if (!block) {
+    return null;
+  }
+  const lines = block.split("\n");
+  const statusMatch = /^HTTP(?:\/\S+)?\s+(\d{3})/i.exec(lines[0]?.trim() ?? "");
+  const status = statusMatch ? Number.parseInt(statusMatch[1], 10) : NaN;
+  if (!Number.isFinite(status)) {
+    return null;
+  }
+  const headers = {};
+  for (const line of lines.slice(1)) {
+    const separator = line.indexOf(":");
+    if (separator <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separator).trim().toLowerCase();
+    const value = line.slice(separator + 1).trim();
+    if (!key || !value) {
+      continue;
+    }
+    headers[key] = headers[key] ? `${headers[key]}, ${value}` : value;
+  }
+  return { status, headers };
+}
 async function runCurlRequest(init, params) {
   const requestId = params?.requestId ?? nextRequestId();
   const startedAt = performance.now();
@@ -89,13 +123,16 @@ async function runCurlRequest(init, params) {
   for (const [key, value] of Object.entries(init.headers ?? {})) {
     args.push("--header", `${key}: ${value}`);
   }
-  if (typeof init.body === "string") {
-    args.push("--data-raw", init.body);
+  const hasBody = typeof init.body === "string";
+  if (hasBody) {
+    args.push("--data-binary", "@-");
   }
   const child = spawn("curl", args, {
     env: process.env,
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"]
   });
+  child.stdin.on("error", () => void 0);
+  child.stdin.end(hasBody ? init.body : void 0);
   const phases = {
     spawnCurlMs: performance.now() - startedAt
   };
@@ -166,6 +203,133 @@ async function runCurlRequest(init, params) {
     headers
   };
 }
+async function waitForCurlHeaders(params) {
+  const startedAt = performance.now();
+  while (performance.now() - startedAt < params.timeoutMs) {
+    try {
+      const raw = await fs.readFile(params.headerPath, "utf8");
+      const parsed = parseCurlHeaderDump(raw);
+      if (parsed) {
+        return parsed;
+      }
+    } catch {
+    }
+    if (params.isClosed()) {
+      throw new Error(params.stderr().trim() || "curl stream \u8BF7\u6C42\u5728\u8FD4\u56DE\u54CD\u5E94\u5934\u524D\u7ED3\u675F\u3002");
+    }
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  throw new Error("\u7B49\u5F85 curl stream \u54CD\u5E94\u5934\u8D85\u65F6\u3002");
+}
+async function runCurlStream(init, params) {
+  if (init.signal?.aborted) {
+    throw new Error("stream \u8BF7\u6C42\u5DF2\u53D6\u6D88\u3002");
+  }
+  const requestId = params?.requestId ?? nextRequestId();
+  const startedAt = performance.now();
+  const timeoutSeconds = typeof params?.timeoutMs === "number" && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0 ? Math.max(1, Math.ceil(params.timeoutMs / 1e3)) : void 0;
+  const headerPath = path.join(os.tmpdir(), `azt-curl-headers-${process.pid}-${requestId}.txt`);
+  const args = [
+    "--silent",
+    "--show-error",
+    "--location",
+    "--no-buffer",
+    "--request",
+    init.method,
+    init.url,
+    "--dump-header",
+    headerPath
+  ];
+  if (typeof timeoutSeconds === "number") {
+    args.push("--connect-timeout", String(Math.min(timeoutSeconds, 10)));
+    args.push("--max-time", String(timeoutSeconds));
+  } else {
+    args.push("--connect-timeout", "10");
+  }
+  if (params?.proxy?.enabled && params.proxy.url.trim()) {
+    args.push("--proxy", params.proxy.url.trim());
+    if (params.proxy.noProxy.trim()) {
+      args.push("--noproxy", params.proxy.noProxy.trim());
+    }
+  }
+  for (const [key, value] of Object.entries(init.headers ?? {})) {
+    args.push("--header", `${key}: ${value}`);
+  }
+  const hasBody = typeof init.body === "string";
+  if (hasBody) {
+    args.push("--data-binary", "@-");
+  }
+  const child = spawn("curl", args, {
+    env: process.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  child.stdin.on("error", () => void 0);
+  child.stdin.end(hasBody ? init.body : void 0);
+  const body = new PassThrough();
+  const phases = {
+    spawnCurlMs: performance.now() - startedAt
+  };
+  let stderr = "";
+  let closed = false;
+  let exitCode = 0;
+  const abort = () => {
+    child.kill("SIGTERM");
+  };
+  init.signal?.addEventListener("abort", abort, { once: true });
+  child.stdout.pipe(body);
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  child.on("error", (error) => {
+    closed = true;
+    stderr = stderr || error.message;
+    body.destroy(error);
+  });
+  child.on("close", (code) => {
+    closed = true;
+    exitCode = code ?? 1;
+    init.signal?.removeEventListener("abort", abort);
+    void fs.unlink(headerPath).catch(() => void 0);
+    if (exitCode !== 0 && !init.signal?.aborted) {
+      body.destroy(new Error(stderr.trim() || `curl stream \u8BF7\u6C42\u5931\u8D25\uFF0C\u9000\u51FA\u7801 ${exitCode}`));
+    }
+  });
+  let parsed;
+  try {
+    parsed = await waitForCurlHeaders({
+      headerPath,
+      isClosed: () => closed,
+      stderr: () => stderr,
+      timeoutMs: typeof params?.timeoutMs === "number" ? Math.min(params.timeoutMs, 3e4) : 3e4
+    });
+  } catch (error) {
+    child.kill("SIGTERM");
+    init.signal?.removeEventListener("abort", abort);
+    void fs.unlink(headerPath).catch(() => void 0);
+    body.destroy(error instanceof Error ? error : new Error(String(error)));
+    throw error;
+  }
+  phases.waitForHeadersMs = performance.now() - startedAt - phases.spawnCurlMs;
+  const timing = finalizeTiming(startedAt, phases);
+  logHttpTiming({
+    requestId,
+    method: init.method,
+    url: init.url,
+    status: parsed.status,
+    transport: "curl",
+    timing,
+    fallbackFrom: params?.fallbackFrom
+  });
+  return {
+    body: Readable.toWeb(body),
+    status: parsed.status,
+    transport: "curl",
+    timing,
+    requestId,
+    headers: parsed.headers
+  };
+}
 async function loadNetworkProxySettings() {
   try {
     const settings = await loadSettings();
@@ -236,6 +400,67 @@ async function requestText(init) {
     timeoutMs: remainingTimeoutMs
   });
 }
+async function requestStream(init) {
+  const requestId = nextRequestId();
+  const requestStartedAt = performance.now();
+  const proxy = init.ignoreProxy ? void 0 : init.proxyOverride ?? await loadNetworkProxySettings();
+  const useCurlOnly = process.env.OAUTH_DEMO_USE_CURL === "1" || isElectronRuntime();
+  const useConfiguredProxy = !!proxy?.enabled && !!proxy.url.trim();
+  const timeoutMs = init.timeoutMs;
+  if (!useCurlOnly && !useConfiguredProxy) {
+    const phases = {};
+    try {
+      const fetchStartedAt = performance.now();
+      const response = await fetch(init.url, {
+        method: init.method,
+        headers: init.headers,
+        body: init.body,
+        signal: init.signal
+      });
+      phases.waitForHeadersMs = performance.now() - fetchStartedAt;
+      const timing = finalizeTiming(requestStartedAt, phases);
+      logHttpTiming({
+        requestId,
+        method: init.method,
+        url: init.url,
+        status: response.status,
+        transport: "fetch",
+        timing
+      });
+      if (!response.body) {
+        throw new Error("fetch stream \u54CD\u5E94\u7F3A\u5C11 body\u3002");
+      }
+      return {
+        body: response.body,
+        status: response.status,
+        transport: "fetch",
+        timing,
+        requestId,
+        headers: normalizeHeaders(response.headers)
+      };
+    } catch (error) {
+      if (init.signal?.aborted) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      safeConsole("warn", "[http] fetch stream attempt failed", {
+        requestId,
+        method: init.method,
+        url: init.url,
+        elapsedMs: roundMs(performance.now() - requestStartedAt),
+        error: message
+      });
+    }
+  }
+  const remainingTimeoutMs = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? Math.max(1e3, timeoutMs - (performance.now() - requestStartedAt)) : void 0;
+  return runCurlStream(init, {
+    requestId,
+    fallbackFrom: useCurlOnly || useConfiguredProxy ? void 0 : "fetch",
+    proxy,
+    timeoutMs: remainingTimeoutMs
+  });
+}
 export {
+  requestStream,
   requestText
 };

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { DEFAULT_CODEX_MODEL } from "../../models/openai-codex-models.js";
-import { requestText } from "../http-client.js";
+import { requestStream, 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;
@@ -39,21 +39,65 @@ function parseOptionalText(value) {
 function parseUpstreamErrorBody(body) {
   try {
     const parsed = JSON.parse(body);
-    const error = parsed.error;
-    if (!error || typeof error !== "object") {
+    const record = asRecord(parsed.error);
+    if (!record) {
       return void 0;
     }
-    const record = error;
+    const eligiblePromo = asRecord(record.eligible_promo);
     return {
       message: typeof record.message === "string" ? record.message : void 0,
       type: typeof record.type === "string" ? record.type : void 0,
       code: typeof record.code === "string" ? record.code : void 0,
-      param: typeof record.param === "string" || record.param === null ? record.param : void 0
+      param: typeof record.param === "string" || record.param === null ? record.param : void 0,
+      planType: typeof record.plan_type === "string" ? record.plan_type : void 0,
+      resetsAt: typeof record.resets_at === "number" && Number.isFinite(record.resets_at) ? record.resets_at : void 0,
+      resetsInSeconds: typeof record.resets_in_seconds === "number" && Number.isFinite(record.resets_in_seconds) ? record.resets_in_seconds : void 0,
+      promoCampaignId: typeof eligiblePromo?.campaign_id === "string" ? eligiblePromo.campaign_id : void 0,
+      promoMessage: typeof eligiblePromo?.message === "string" ? eligiblePromo.message : void 0
     };
   } catch {
     return void 0;
   }
 }
+function buildCodexRequestHeaders(profile) {
+  return {
+    Accept: "text/event-stream",
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${profile.access}`,
+    "ChatGPT-Account-Id": profile.accountId,
+    "OpenAI-Beta": "responses=experimental",
+    Originator: "pi",
+    "User-Agent": "pi (bun demo)"
+  };
+}
+function createCodexUpstreamError(status, body, transport, quota, requestId) {
+  const upstreamError = parseUpstreamErrorBody(body);
+  const error = new Error(`\u8C03\u7528 Responses API \u5931\u8D25: HTTP ${status} via ${transport} ${body}`);
+  error.quota = quota ?? createUsageLimitQuotaSnapshot(status, upstreamError, requestId);
+  error.upstreamStatus = status;
+  error.upstreamErrorCode = upstreamError?.code;
+  error.upstreamErrorType = upstreamError?.type;
+  error.upstreamErrorMessage = upstreamError?.message;
+  return error;
+}
+function createUsageLimitQuotaSnapshot(status, upstreamError, requestId) {
+  const errorKind = `${upstreamError?.type ?? ""} ${upstreamError?.code ?? ""}`.toLowerCase();
+  if (status !== 429 && !errorKind.includes("usage_limit_reached")) {
+    return void 0;
+  }
+  return {
+    capturedAt: Date.now(),
+    sourceRequestId: requestId,
+    planType: upstreamError?.planType,
+    primaryUsedPercent: 100,
+    primaryResetAt: upstreamError?.resetsAt,
+    primaryResetAfterSeconds: upstreamError?.resetsInSeconds,
+    creditsHasCredits: false,
+    creditsBalance: "0",
+    promoCampaignId: upstreamError?.promoCampaignId,
+    promoMessage: upstreamError?.promoMessage
+  };
+}
 function extractCodexQuotaSnapshot(headers, requestId) {
   const activeLimit = parseOptionalText(headers["x-codex-active-limit"]);
   const planType = parseOptionalText(headers["x-codex-plan-type"]);
@@ -362,34 +406,50 @@ async function askOpenAICodex(params) {
   const response = await requestText({
     method: "POST",
     url: CODEX_RESPONSES_URL,
-    headers: {
-      Accept: "text/event-stream",
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${params.profile.access}`,
-      "ChatGPT-Account-Id": params.profile.accountId,
-      "OpenAI-Beta": "responses=experimental",
-      Originator: "pi",
-      "User-Agent": "pi (bun demo)"
-    },
+    headers: buildCodexRequestHeaders(params.profile),
     body: JSON.stringify(requestBody)
   });
   const quota = extractCodexQuotaSnapshot(response.headers, response.requestId);
   if (response.status < 200 || response.status >= 300) {
-    const upstreamError = parseUpstreamErrorBody(response.body);
-    const error = new Error(`\u8C03\u7528 Responses API \u5931\u8D25: HTTP ${response.status} via ${response.transport} ${response.body}`);
-    error.quota = quota;
-    error.upstreamStatus = response.status;
-    error.upstreamErrorCode = upstreamError?.code;
-    error.upstreamErrorType = upstreamError?.type;
-    error.upstreamErrorMessage = upstreamError?.message;
-    throw error;
+    throw createCodexUpstreamError(response.status, response.body, response.transport, quota, response.requestId);
   }
   return {
     ...extractCodexText(response.body, requestBody),
     quota
   };
 }
+async function streamOpenAICodex(params) {
+  const requestBody = params.passthroughBody ? { ...params.bodyOverride ?? {} } : {
+    ...buildDefaultRequestBody(params),
+    ...params.bodyOverride ?? {}
+  };
+  if (!params.passthroughBody && 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 requestStream({
+    method: "POST",
+    url: CODEX_RESPONSES_URL,
+    headers: buildCodexRequestHeaders(params.profile),
+    body: JSON.stringify(requestBody),
+    signal: params.signal
+  });
+  const headers = response.headers;
+  const requestId = headers["x-request-id"] ?? response.requestId;
+  const quota = extractCodexQuotaSnapshot(headers, requestId);
+  if (response.status < 200 || response.status >= 300) {
+    const body = await new Response(response.body).text();
+    throw createCodexUpstreamError(response.status, body, response.transport, quota, requestId);
+  }
+  return {
+    body: response.body,
+    headers,
+    quota,
+    requestId,
+    status: response.status
+  };
+}
 export {
   askOpenAICodex,
-  extractCodexQuotaSnapshot
+  extractCodexQuotaSnapshot,
+  streamOpenAICodex
 };

package/dist/core/services/auth-service.js CHANGED Viewed

@@ -15,8 +15,10 @@ import {
 } from "../providers/openai-codex/oauth.js";
 import { askOpenAICodex } from "../providers/openai-codex/chat.js";
 import {
+  applyGatewayToCodexProviderConfig,
   applyProfileToCodexAuth,
-  getCodexAuthStatus
+  getCodexAuthStatus,
+  removeGatewayFromCodexProviderConfig
 } from "../store/codex-auth-store.js";
 import {
   exportProfilesToJson,
@@ -209,7 +211,8 @@ class AuthService {
   }
   async maybeAutoSwitchProfile(profile, provider) {
     const settings = await this.configService.getSettings();
-    if (!settings.autoSwitch.enabled || !this.isQuotaExhausted(profile)) {
+    const excludedProfileIds = new Set(settings.autoSwitch.excludedProfileIds);
+    if (!settings.autoSwitch.enabled || excludedProfileIds.has(profile.profileId) || !this.isQuotaExhausted(profile)) {
       return profile;
     }
     const [profiles, codexStatus] = await Promise.all([
@@ -222,7 +225,7 @@ class AuthService {
       profile: item,
       index,
       distance: currentIndex >= 0 ? (index - currentIndex + profiles.length) % profiles.length : index + 1
-    })).filter((item) => item.profile.provider === provider && item.profile.profileId !== profile.profileId).filter((item) => this.hasKnownAvailableQuota(item.profile)).sort((left, right) => {
+    })).filter((item) => item.profile.provider === provider && item.profile.profileId !== profile.profileId).filter((item) => !excludedProfileIds.has(item.profile.profileId)).filter((item) => this.hasKnownAvailableQuota(item.profile)).sort((left, right) => {
       const leftCodexConflict = codexAccountId && left.profile.accountId === codexAccountId ? 1 : 0;
       const rightCodexConflict = codexAccountId && right.profile.accountId === codexAccountId ? 1 : 0;
       const codexDiff = leftCodexConflict - rightCodexConflict;
@@ -326,6 +329,12 @@ class AuthService {
     const profile = await this.requireFreshProfileWithIdToken(profileId, provider);
     return applyProfileToCodexAuth(profile);
   }
+  async applyGatewayToCodexProvider(params) {
+    return applyGatewayToCodexProviderConfig(params);
+  }
+  async removeGatewayFromCodexProvider(params) {
+    return removeGatewayFromCodexProviderConfig(params);
+  }
   async getActiveProfile(provider = "openai-codex") {
     const profile = await getActiveProfile();
     if (!profile || profile.provider !== provider) {
@@ -517,9 +526,9 @@ class AuthService {
   async recordProfileRequestFailure(profileId, error, quota, provider = "openai-codex", options) {
     const authStatus = this.createAuthStatusFromError(error);
     if (!quota && !authStatus) {
-      return;
+      return null;
     }
-    await this.applyProfileRuntimeUpdate(
+    return this.applyProfileRuntimeUpdate(
       profileId,
       provider,
       (profile) => ({

package/dist/core/services/config-service.js CHANGED Viewed

@@ -31,14 +31,22 @@ function normalizeNetworkProxy(settings, params) {
     noProxy
   };
 }
+function normalizeProfileIdList(value, fallback = []) {
+  if (!value) {
+    return fallback;
+  }
+  return Array.from(
+    new Set(
+      value.map((item) => item.trim()).filter(Boolean)
+    )
+  );
+}
 class ConfigService {
   async getSettings() {
     return this.ensureSettings();
   }
   async ensureSettings() {
-    const settings = await loadSettings();
-    await saveSettings(settings);
-    return settings;
+    return loadSettings();
   }
   async getDefaultProvider() {
     const settings = await this.getSettings();
@@ -81,7 +89,8 @@ class ConfigService {
     const next = {
       ...settings,
       autoSwitch: {
-        enabled: params.enabled
+        enabled: params.enabled ?? settings.autoSwitch.enabled,
+        excludedProfileIds: normalizeProfileIdList(params.excludedProfileIds, settings.autoSwitch.excludedProfileIds)
       }
     };
     await saveSettings(next);
@@ -138,7 +147,8 @@ class ConfigService {
       next = {
         ...next,
         autoSwitch: {
-          enabled: params.autoSwitch.enabled
+          enabled: params.autoSwitch.enabled ?? next.autoSwitch.enabled,
+          excludedProfileIds: normalizeProfileIdList(params.autoSwitch.excludedProfileIds, next.autoSwitch.excludedProfileIds)
         }
       };
     }