ai-zero-token 1.0.2 → 1.0.4

package/dist/core/services/model-service.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
-  CODEX_MODEL_INFOS,
-  isSupportedCodexModel
+  getCodexModelCatalog,
+  hasCodexModel
 } from "../models/openai-codex-models.js";
 class ModelService {
   constructor(configService) {
@@ -11,12 +11,37 @@ class ModelService {
     if (provider !== "openai-codex") {
       throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
     }
-    const defaultModel = await this.configService.getDefaultModel(provider);
-    return CODEX_MODEL_INFOS.map((model) => ({
+    const [{ models }, defaultModel] = await Promise.all([
+      getCodexModelCatalog(),
+      this.configService.getDefaultModel(provider)
+    ]);
+    return models.map((model) => ({
       ...model,
       isDefault: model.id === defaultModel
     }));
   }
+  async getCatalog(provider = "openai-codex") {
+    if (provider !== "openai-codex") {
+      throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
+    }
+    return (await getCodexModelCatalog()).catalog;
+  }
+  async refreshModels(provider = "openai-codex") {
+    if (provider !== "openai-codex") {
+      throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
+    }
+    const [{ models, catalog }, defaultModel] = await Promise.all([
+      getCodexModelCatalog(),
+      this.configService.getDefaultModel(provider)
+    ]);
+    return {
+      models: models.map((model) => ({
+        ...model,
+        isDefault: model.id === defaultModel
+      })),
+      catalog
+    };
+  }
   async getDefaultModel(provider = "openai-codex") {
     if (provider !== "openai-codex") {
       throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
@@ -33,8 +58,8 @@ class ModelService {
     if (options?.allowUnknown) {
       return requested;
     }
-    if (!isSupportedCodexModel(requested)) {
-      throw new Error(`\u5F53\u524D demo \u672A\u5185\u7F6E\u6A21\u578B: ${requested}`);
+    if (!await hasCodexModel(requested)) {
+      throw new Error(`\u5F53\u524D\u7F51\u5173\u672A\u627E\u5230\u53EF\u7528\u6A21\u578B: ${requested}`);
     }
     return requested;
   }

package/dist/core/services/version-service.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { requestText } from "../providers/http-client.js";
+const VERSION_CACHE_TTL_MS = 10 * 60 * 1e3;
+const packageJsonPath = path.dirname(fileURLToPath(new URL("../../../package.json", import.meta.url)));
+function compareVersionPart(left, right) {
+  const leftNumber = Number.parseInt(left, 10);
+  const rightNumber = Number.parseInt(right, 10);
+  if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) {
+    return leftNumber - rightNumber;
+  }
+  return left.localeCompare(right);
+}
+function compareSemver(left, right) {
+  const leftParts = left.split(/[.+-]/);
+  const rightParts = right.split(/[.+-]/);
+  const maxLength = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const diff = compareVersionPart(leftParts[index] ?? "0", rightParts[index] ?? "0");
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+  return 0;
+}
+async function readPackageManifest() {
+  const raw = await fs.readFile(path.join(packageJsonPath, "package.json"), "utf8");
+  const parsed = JSON.parse(raw);
+  return {
+    name: parsed.name ?? "ai-zero-token",
+    version: parsed.version ?? "0.0.0"
+  };
+}
+class VersionService {
+  cache = null;
+  inFlight = null;
+  async getVersionStatus(options) {
+    const now = Date.now();
+    if (!options?.force && this.cache && now - this.cache.checkedAt < VERSION_CACHE_TTL_MS) {
+      return this.cache;
+    }
+    if (this.inFlight) {
+      return this.inFlight;
+    }
+    this.inFlight = this.fetchVersionStatus().then((status) => {
+      this.cache = status;
+      return status;
+    }).finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  async fetchVersionStatus() {
+    const manifest = await readPackageManifest();
+    const registryUrl = `https://registry.npmjs.org/${encodeURIComponent(manifest.name)}/latest`;
+    try {
+      const response = await requestText({
+        method: "GET",
+        url: registryUrl,
+        timeoutMs: 5e3
+      });
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(`npm registry returned ${response.status}`);
+      }
+      const parsed = JSON.parse(response.body);
+      const latestVersion = typeof parsed.version === "string" && parsed.version ? parsed.version : void 0;
+      if (!latestVersion) {
+        throw new Error("npm registry did not return a version");
+      }
+      const needsUpdate = compareSemver(manifest.version, latestVersion) < 0;
+      return {
+        packageName: manifest.name,
+        currentVersion: manifest.version,
+        latestVersion,
+        checkedAt: Date.now(),
+        needsUpdate,
+        registryUrl,
+        status: needsUpdate ? "update-available" : "ok"
+      };
+    } catch (error) {
+      return {
+        packageName: manifest.name,
+        currentVersion: manifest.version,
+        checkedAt: Date.now(),
+        needsUpdate: false,
+        registryUrl,
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+}
+export {
+  VersionService
+};

package/dist/core/store/profile-store.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import fs from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const projectDir = path.dirname(fileURLToPath(new URL("../../../package.json", import.meta.url)));
-const stateDir = path.join(projectDir, ".state");
-const storePath = path.join(stateDir, "store.json");
+import {
+  ensureStateMigrated,
+  getStateDir,
+  getStorePath
+} from "./state-paths.js";
 const PROFILE_CLAIM_PATH = "https://api.openai.com/profile";
 function createEmptyStore() {
   return {
@@ -40,15 +40,10 @@ function extractEmailFromAccessToken(token) {
   }
   return void 0;
 }
-function getStateDir() {
-  return stateDir;
-}
-function getStorePath() {
-  return storePath;
-}
 async function loadStore() {
   try {
-    const raw = await fs.readFile(storePath, "utf8");
+    await ensureStateMigrated();
+    const raw = await fs.readFile(getStorePath(), "utf8");
     const parsed = JSON.parse(raw);
     const normalizedProfiles = Object.fromEntries(
       Object.entries(parsed.profiles ?? {}).map(([profileId, profile]) => [
@@ -73,8 +68,9 @@ async function loadStore() {
   }
 }
 async function saveStore(store) {
-  await fs.mkdir(stateDir, { recursive: true });
-  await fs.writeFile(storePath, `${JSON.stringify(store, null, 2)}
+  await ensureStateMigrated();
+  await fs.mkdir(getStateDir(), { recursive: true });
+  await fs.writeFile(getStorePath(), `${JSON.stringify(store, null, 2)}
 `, "utf8");
 }
 async function saveProfile(profile) {
@@ -130,7 +126,7 @@ async function removeProfile(profileId) {
   return store.activeProfileId ? store.profiles[store.activeProfileId] ?? null : null;
 }
 async function clearStore() {
-  await fs.rm(stateDir, { recursive: true, force: true });
+  await fs.rm(getStateDir(), { recursive: true, force: true });
 }
 export {
   clearStore,

package/dist/core/store/settings-store.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import fs from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const projectDir = path.dirname(fileURLToPath(new URL("../../../package.json", import.meta.url)));
-const stateDir = path.join(projectDir, ".state");
-const settingsPath = path.join(stateDir, "settings.json");
+import {
+  ensureStateMigrated,
+  getSettingsPath,
+  getStateDir
+} from "./state-paths.js";
 function createDefaultSettings() {
   return {
     version: 1,
@@ -16,12 +16,10 @@ function createDefaultSettings() {
     }
   };
 }
-function getSettingsPath() {
-  return settingsPath;
-}
 async function loadSettings() {
   try {
-    const raw = await fs.readFile(settingsPath, "utf8");
+    await ensureStateMigrated();
+    const raw = await fs.readFile(getSettingsPath(), "utf8");
     const parsed = JSON.parse(raw);
     const defaults = createDefaultSettings();
     return {
@@ -38,8 +36,9 @@ async function loadSettings() {
   }
 }
 async function saveSettings(settings) {
-  await fs.mkdir(stateDir, { recursive: true });
-  await fs.writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}
+  await ensureStateMigrated();
+  await fs.mkdir(getStateDir(), { recursive: true });
+  await fs.writeFile(getSettingsPath(), `${JSON.stringify(settings, null, 2)}
 `, "utf8");
 }
 export {

package/dist/core/store/state-paths.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const packageDir = path.dirname(fileURLToPath(new URL("../../../package.json", import.meta.url)));
+const legacyStateDir = path.join(packageDir, ".state");
+const appHomeDir = process.env.AI_ZERO_TOKEN_HOME || path.join(os.homedir(), ".ai-zero-token");
+const stateDir = path.join(appHomeDir, ".state");
+let migrationPromise = null;
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyIfMissing(fileName) {
+  const legacyPath = path.join(legacyStateDir, fileName);
+  const nextPath = path.join(stateDir, fileName);
+  if (!await pathExists(legacyPath) || await pathExists(nextPath)) {
+    return;
+  }
+  await fs.mkdir(stateDir, { recursive: true });
+  await fs.copyFile(legacyPath, nextPath);
+}
+function getStateDir() {
+  return stateDir;
+}
+function getStorePath() {
+  return path.join(stateDir, "store.json");
+}
+function getSettingsPath() {
+  return path.join(stateDir, "settings.json");
+}
+async function ensureStateMigrated() {
+  if (!migrationPromise) {
+    migrationPromise = (async () => {
+      if (legacyStateDir === stateDir) {
+        return;
+      }
+      await copyIfMissing("store.json");
+      await copyIfMissing("settings.json");
+    })();
+  }
+  await migrationPromise;
+}
+export {
+  ensureStateMigrated,
+  getSettingsPath,
+  getStateDir,
+  getStorePath
+};