ai-zero-token 1.0.1 → 1.0.3

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

@@ -0,0 +1,405 @@
+#!/usr/bin/env node
+import { askOpenAICodex } from "../providers/openai-codex/chat.js";
+const SUPPORTED_IMAGE_MODELS = /* @__PURE__ */ new Set([
+  "gpt-image-1",
+  "gpt-image-1-mini",
+  "gpt-image-1.5",
+  "gpt-image-2"
+]);
+const SUPPORTED_IMAGE_SIZES = /* @__PURE__ */ new Set([
+  "1024x1024",
+  "1024x1536",
+  "1536x1024"
+]);
+const SUPPORTED_IMAGE_QUALITIES = /* @__PURE__ */ new Set([
+  "low",
+  "medium",
+  "high"
+]);
+const SUPPORTED_IMAGE_FORMATS = /* @__PURE__ */ new Set([
+  "png",
+  "webp",
+  "jpeg"
+]);
+const SUPPORTED_IMAGE_BACKGROUNDS = /* @__PURE__ */ new Set([
+  "transparent",
+  "opaque"
+]);
+const IMAGE_GENERATION_MAX_ATTEMPTS = 3;
+const IMAGE_GENERATION_RETRY_DELAYS_MS = [1500, 4e3];
+function truncateForLog(value, max = 160) {
+  if (value.length <= max) {
+    return value;
+  }
+  return `${value.slice(0, max)}...`;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toImageGenerationOutput(value) {
+  if (!isRecord(value) || value.type !== "image_generation_call") {
+    return null;
+  }
+  return value;
+}
+function toImageGenerationEventOutput(value) {
+  if (!isRecord(value) || typeof value.type !== "string") {
+    return null;
+  }
+  if (value.type.startsWith("response.output_item.") && isRecord(value.item)) {
+    return toImageGenerationOutput(value.item);
+  }
+  if (value.type === "response.image_generation_call.partial_image") {
+    return {
+      id: typeof value.item_id === "string" ? value.item_id : void 0,
+      type: "image_generation_call",
+      partial_image_b64: typeof value.partial_image_b64 === "string" ? value.partial_image_b64 : void 0,
+      background: typeof value.background === "string" ? value.background : void 0,
+      output_format: typeof value.output_format === "string" ? value.output_format : void 0,
+      size: typeof value.size === "string" ? value.size : void 0
+    };
+  }
+  return null;
+}
+function normalizeReturnedSize(size, fallback) {
+  if (typeof size === "string" && SUPPORTED_IMAGE_SIZES.has(size)) {
+    return size;
+  }
+  if (typeof fallback === "string" && SUPPORTED_IMAGE_SIZES.has(fallback)) {
+    return fallback;
+  }
+  return void 0;
+}
+function normalizeReturnedQuality(quality) {
+  if (typeof quality === "string" && SUPPORTED_IMAGE_QUALITIES.has(quality)) {
+    return quality;
+  }
+  return void 0;
+}
+function normalizeReturnedFormat(format) {
+  if (typeof format === "string" && SUPPORTED_IMAGE_FORMATS.has(format)) {
+    return format;
+  }
+  return void 0;
+}
+function normalizeReturnedBackground(background) {
+  if (typeof background === "string" && SUPPORTED_IMAGE_BACKGROUNDS.has(background)) {
+    return background;
+  }
+  return void 0;
+}
+function collectImageGenerationOutputs(raw) {
+  if (!isRecord(raw)) {
+    return [];
+  }
+  const finalItems = /* @__PURE__ */ new Map();
+  const partialItems = /* @__PURE__ */ new Map();
+  const response = isRecord(raw.response) ? raw.response : null;
+  const events = Array.isArray(raw.events) ? raw.events : [];
+  if (response && Array.isArray(response.output)) {
+    for (const output of response.output) {
+      const image = toImageGenerationOutput(output);
+      if (!image || !image.id) {
+        continue;
+      }
+      if (typeof image.result === "string" && image.result.length > 0) {
+        finalItems.set(image.id, image);
+      } else if (typeof image.partial_image_b64 === "string" && image.partial_image_b64.length > 0) {
+        partialItems.set(image.id, image);
+      }
+    }
+  }
+  for (const event of events) {
+    const image = toImageGenerationEventOutput(event);
+    if (!image || !image.id) {
+      continue;
+    }
+    if (typeof image.result === "string" && image.result.length > 0) {
+      finalItems.set(image.id, image);
+    } else if (typeof image.partial_image_b64 === "string" && image.partial_image_b64.length > 0) {
+      partialItems.set(image.id, image);
+    }
+  }
+  if (finalItems.size > 0) {
+    return Array.from(finalItems.values());
+  }
+  return Array.from(partialItems.values()).map((item) => ({
+    ...item,
+    result: item.partial_image_b64
+  }));
+}
+function summarizeImageDebug(raw) {
+  if (!isRecord(raw)) {
+    return {
+      rawType: typeof raw
+    };
+  }
+  const response = isRecord(raw.response) ? raw.response : null;
+  const events = Array.isArray(raw.events) ? raw.events : [];
+  const imageEvents = events.filter((event) => isRecord(event) && typeof event.type === "string" && event.type.includes("image_generation")).slice(0, 12).map((event) => {
+    const safeEvent = event;
+    return {
+      type: safeEvent.type,
+      item_id: typeof safeEvent.item_id === "string" ? safeEvent.item_id : void 0,
+      output_index: typeof safeEvent.output_index === "number" ? safeEvent.output_index : void 0,
+      partial_image_b64_length: typeof safeEvent.partial_image_b64 === "string" ? safeEvent.partial_image_b64.length : void 0
+    };
+  });
+  return {
+    response_status: typeof response?.status === "string" ? response.status : void 0,
+    response_error: isRecord(response?.error) ? {
+      code: typeof response.error.code === "string" ? response.error.code : void 0,
+      message: typeof response.error.message === "string" ? response.error.message : void 0,
+      type: typeof response.error.type === "string" ? response.error.type : void 0
+    } : void 0,
+    response_output_length: Array.isArray(response?.output) ? response.output.length : 0,
+    event_count: events.length,
+    event_types: events.filter((event) => isRecord(event) && typeof event.type === "string").slice(0, 20).map((event) => event.type),
+    error_events: events.filter((event) => isRecord(event) && (event.type === "error" || event.type === "response.failed")).slice(0, 5).map((event) => {
+      const safeEvent = event;
+      const eventError = isRecord(safeEvent.error) ? safeEvent.error : null;
+      const eventResponse = isRecord(safeEvent.response) ? safeEvent.response : null;
+      const responseError = eventResponse && isRecord(eventResponse.error) ? eventResponse.error : null;
+      return {
+        type: safeEvent.type,
+        code: typeof eventError?.code === "string" ? eventError.code : typeof responseError?.code === "string" ? responseError.code : void 0,
+        message: typeof eventError?.message === "string" ? eventError.message : typeof responseError?.message === "string" ? responseError.message : void 0
+      };
+    }),
+    image_events: imageEvents
+  };
+}
+function extractRequestIdFromMessage(message) {
+  const match = message.match(/request ID ([a-z0-9-]+)/i);
+  return match?.[1];
+}
+function createImageFailureDetails(code, message) {
+  const normalizedMessage = typeof message === "string" && message.trim() ? message.trim() : typeof code === "string" && code.trim() ? code.trim() : null;
+  if (!normalizedMessage) {
+    return null;
+  }
+  const normalizedCode = typeof code === "string" && code.trim() ? code.trim() : void 0;
+  return {
+    code: normalizedCode,
+    message: normalizedMessage,
+    requestId: extractRequestIdFromMessage(normalizedMessage),
+    transient: normalizedCode === "server_error" || /retry your request/i.test(normalizedMessage) || /temporar/i.test(normalizedMessage)
+  };
+}
+function extractImageFailureDetails(raw) {
+  if (!isRecord(raw)) {
+    return null;
+  }
+  const response = isRecord(raw.response) ? raw.response : null;
+  if (response) {
+    const responseError = isRecord(response.error) ? response.error : null;
+    const responseStatus = typeof response.status === "string" ? response.status : void 0;
+    const details = createImageFailureDetails(responseError?.code, responseError?.message);
+    if (responseStatus === "failed" && details) {
+      return details;
+    }
+  }
+  const events = Array.isArray(raw.events) ? raw.events : [];
+  for (const event of events) {
+    if (!isRecord(event)) {
+      continue;
+    }
+    if (event.type === "error") {
+      const eventError = isRecord(event.error) ? event.error : event;
+      const details = createImageFailureDetails(eventError.code, eventError.message);
+      if (details) {
+        return details;
+      }
+    }
+    if (event.type === "response.failed" && isRecord(event.response)) {
+      const responseError = isRecord(event.response.error) ? event.response.error : null;
+      const details = createImageFailureDetails(responseError?.code, responseError?.message);
+      if (details) {
+        return details;
+      }
+    }
+  }
+  return null;
+}
+function createError(message, statusCode) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function extractImageUsage(raw) {
+  if (!isRecord(raw) || !isRecord(raw.response)) {
+    return void 0;
+  }
+  const toolUsage = isRecord(raw.response.tool_usage) ? raw.response.tool_usage : null;
+  const imageGen = toolUsage && isRecord(toolUsage.image_gen) ? toolUsage.image_gen : null;
+  if (!imageGen || typeof imageGen.input_tokens !== "number" || typeof imageGen.output_tokens !== "number" || typeof imageGen.total_tokens !== "number") {
+    return void 0;
+  }
+  return {
+    input_tokens: imageGen.input_tokens,
+    input_tokens_details: isRecord(imageGen.input_tokens_details) ? {
+      image_tokens: Number(imageGen.input_tokens_details.image_tokens ?? 0),
+      text_tokens: Number(imageGen.input_tokens_details.text_tokens ?? 0)
+    } : void 0,
+    output_tokens: imageGen.output_tokens,
+    output_tokens_details: isRecord(imageGen.output_tokens_details) ? {
+      image_tokens: Number(imageGen.output_tokens_details.image_tokens ?? 0),
+      text_tokens: Number(imageGen.output_tokens_details.text_tokens ?? 0)
+    } : void 0,
+    total_tokens: imageGen.total_tokens
+  };
+}
+class ImageService {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  resolveRequestedImageModel(model) {
+    if (!model) {
+      return "gpt-image-2";
+    }
+    if (!SUPPORTED_IMAGE_MODELS.has(model)) {
+      throw new Error(`\u5F53\u524D\u7F51\u5173\u4EC5\u652F\u6301\u8FD9\u4E9B\u751F\u56FE\u6A21\u578B: ${Array.from(SUPPORTED_IMAGE_MODELS).join(", ")}`);
+    }
+    return model;
+  }
+  isFreePlan(profile) {
+    return profile.quota?.planType === "free";
+  }
+  async generate(request) {
+    const profile = await this.deps.authService.requireUsableProfile("openai-codex");
+    if (this.isFreePlan(profile)) {
+      throw new Error("\u5F53\u524D\u8D26\u53F7\u4E3A free \u5957\u9910\uFF0C\u4E0D\u652F\u6301\u56FE\u7247\u751F\u6210\u3002\u8BF7\u5207\u6362\u5230 Plus \u6216\u66F4\u9AD8\u5957\u9910\u8D26\u53F7\u3002");
+    }
+    const orchestratorModel = await this.deps.configService.getDefaultModel();
+    const requestedImageModel = this.resolveRequestedImageModel(request.model);
+    const requestSummary = {
+      requestedImageModel,
+      orchestratorModel,
+      promptLength: request.prompt.length,
+      promptPreview: truncateForLog(request.prompt),
+      size: request.size ?? "default",
+      quality: request.quality ?? "default",
+      background: request.background ?? "default",
+      outputFormat: request.outputFormat ?? "default",
+      outputCompression: typeof request.outputCompression === "number" ? request.outputCompression : void 0,
+      moderation: request.moderation ?? "default"
+    };
+    console.info("[gateway:image] upstream request", requestSummary);
+    const tool = {
+      type: "image_generation",
+      model: requestedImageModel
+    };
+    if (request.size) {
+      tool.size = request.size;
+    }
+    if (request.quality) {
+      tool.quality = request.quality;
+    }
+    if (request.background) {
+      tool.background = request.background;
+    }
+    if (request.outputFormat) {
+      tool.output_format = request.outputFormat;
+    }
+    if (typeof request.outputCompression === "number") {
+      tool.output_compression = request.outputCompression;
+    }
+    if (request.moderation) {
+      tool.moderation = request.moderation;
+    }
+    for (let attempt = 1; attempt <= IMAGE_GENERATION_MAX_ATTEMPTS; attempt += 1) {
+      let result;
+      try {
+        result = await askOpenAICodex({
+          profile,
+          model: orchestratorModel,
+          bodyOverride: {
+            model: orchestratorModel,
+            input: [
+              {
+                role: "user",
+                content: [
+                  {
+                    type: "input_text",
+                    text: request.prompt
+                  }
+                ]
+              }
+            ],
+            tools: [tool],
+            tool_choice: {
+              type: "image_generation"
+            },
+            include: ["reasoning.encrypted_content"]
+          }
+        });
+        await this.deps.authService.updateProfileQuota(profile.profileId, result.quota, "openai-codex");
+      } catch (error) {
+        const quota = error.quota;
+        await this.deps.authService.updateProfileQuota(profile.profileId, quota, "openai-codex");
+        throw error;
+      }
+      const raw = isRecord(result.raw) ? result.raw : {};
+      const response = isRecord(raw.response) ? raw.response : null;
+      const images = collectImageGenerationOutputs(raw);
+      const debugSummary = summarizeImageDebug(raw);
+      if (images.length === 0) {
+        const upstreamFailure = extractImageFailureDetails(raw);
+        console.error("[gateway:image] parse failure", {
+          ...requestSummary,
+          attempt,
+          upstreamFailure,
+          debug: debugSummary
+        });
+        if (upstreamFailure?.transient && attempt < IMAGE_GENERATION_MAX_ATTEMPTS) {
+          const retryDelayMs = IMAGE_GENERATION_RETRY_DELAYS_MS[attempt - 1] ?? 4e3;
+          console.warn("[gateway:image] transient upstream failure, retrying", {
+            ...requestSummary,
+            attempt,
+            retryDelayMs,
+            code: upstreamFailure.code,
+            requestId: upstreamFailure.requestId
+          });
+          await sleep(retryDelayMs);
+          continue;
+        }
+        if (upstreamFailure) {
+          const reason = upstreamFailure.code ? `${upstreamFailure.code}: ${upstreamFailure.message}` : upstreamFailure.message;
+          throw createError(`\u4E0A\u6E38\u56FE\u7247\u751F\u6210\u5931\u8D25: ${reason}`, upstreamFailure.transient ? 503 : 502);
+        }
+        throw createError("\u56FE\u7247\u751F\u6210\u8BF7\u6C42\u5DF2\u5B8C\u6210\uFF0C\u4F46\u6CA1\u6709\u89E3\u6790\u51FA image_generation_call \u7ED3\u679C\u3002", 502);
+      }
+      const first = images[0];
+      const imageResult = {
+        created: typeof response?.created_at === "number" ? response.created_at : Math.floor(Date.now() / 1e3),
+        data: images.map((image) => ({
+          b64_json: image.result ?? "",
+          ...image.revised_prompt ? { revised_prompt: image.revised_prompt } : {}
+        })),
+        background: normalizeReturnedBackground(first.background),
+        output_format: normalizeReturnedFormat(first.output_format),
+        quality: normalizeReturnedQuality(first.quality),
+        size: normalizeReturnedSize(first.size, request.size),
+        usage: extractImageUsage(raw)
+      };
+      console.info("[gateway:image] upstream response", {
+        ...requestSummary,
+        attempt,
+        imageCount: imageResult.data.length,
+        firstImageBase64Length: imageResult.data[0]?.b64_json.length ?? 0,
+        outputFormat: imageResult.output_format ?? request.outputFormat ?? "unknown",
+        quality: imageResult.quality ?? request.quality ?? "unknown",
+        size: imageResult.size ?? request.size ?? "unknown",
+        debug: debugSummary
+      });
+      return imageResult;
+    }
+    throw createError("\u56FE\u7247\u751F\u6210\u5931\u8D25\uFF1A\u8D85\u8FC7\u6700\u5927\u91CD\u8BD5\u6B21\u6570\u3002", 503);
+  }
+}
+export {
+  ImageService
+};

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,27 +11,55 @@ 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}`);
     }
     return this.configService.getDefaultModel(provider);
   }
-  async resolveModel(provider = "openai-codex", requested) {
+  async resolveModel(provider = "openai-codex", requested, options) {
     if (provider !== "openai-codex") {
       throw new Error(`\u6682\u4E0D\u652F\u6301 provider: ${provider}`);
     }
     if (!requested) {
       return this.configService.getDefaultModel(provider);
     }
-    if (!isSupportedCodexModel(requested)) {
-      throw new Error(`\u5F53\u524D demo \u672A\u5185\u7F6E\u6A21\u578B: ${requested}`);
+    if (options?.allowUnknown) {
+      return requested;
+    }
+    if (!await hasCodexModel(requested)) {
+      throw new Error(`\u5F53\u524D\u7F51\u5173\u672A\u627E\u5230\u53EF\u7528\u6A21\u578B: ${requested}`);
     }
     return requested;
   }
@@ -39,4 +67,3 @@ class ModelService {
 export {
   ModelService
 };
-//# sourceMappingURL=model-service.js.map

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

@@ -5,12 +5,41 @@ 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");
+const PROFILE_CLAIM_PATH = "https://api.openai.com/profile";
 function createEmptyStore() {
   return {
     version: 1,
     profiles: {}
   };
 }
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      return null;
+    }
+    const payload = parts[1] ?? "";
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padding = normalized.length % 4 === 0 ? "" : "=".repeat(4 - normalized.length % 4);
+    const decoded = Buffer.from(normalized + padding, "base64").toString("utf8");
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function extractEmailFromAccessToken(token) {
+  const payload = decodeJwtPayload(token);
+  const profileClaim = payload?.[PROFILE_CLAIM_PATH];
+  const email = profileClaim?.email;
+  if (typeof email === "string" && email.trim()) {
+    return email.trim();
+  }
+  const topLevelEmail = payload?.email;
+  if (typeof topLevelEmail === "string" && topLevelEmail.trim()) {
+    return topLevelEmail.trim();
+  }
+  return void 0;
+}
 function getStateDir() {
   return stateDir;
 }
@@ -24,10 +53,14 @@ async function loadStore() {
     const normalizedProfiles = Object.fromEntries(
       Object.entries(parsed.profiles ?? {}).map(([profileId, profile]) => [
         profileId,
-        {
-          ...profile,
-          mode: "oauth_account"
-        }
+        (() => {
+          const recoveredEmail = typeof profile.email === "string" && profile.email.trim() ? profile.email.trim() : extractEmailFromAccessToken(profile.access);
+          return {
+            ...profile,
+            mode: "oauth_account",
+            email: recoveredEmail
+          };
+        })()
       ])
     );
     return {
@@ -50,6 +83,31 @@ async function saveProfile(profile) {
   store.activeProfileId = profile.profileId;
   await saveStore(store);
 }
+async function updateProfile(profileId, updater) {
+  const store = await loadStore();
+  const profile = store.profiles[profileId];
+  if (!profile) {
+    return null;
+  }
+  const updated = updater(profile);
+  store.profiles[profileId] = updated;
+  await saveStore(store);
+  return updated;
+}
+async function listProfiles() {
+  const store = await loadStore();
+  return Object.values(store.profiles);
+}
+async function setActiveProfile(profileId) {
+  const store = await loadStore();
+  const profile = store.profiles[profileId];
+  if (!profile) {
+    return null;
+  }
+  store.activeProfileId = profileId;
+  await saveStore(store);
+  return profile;
+}
 async function getActiveProfile() {
   const store = await loadStore();
   const activeId = store.activeProfileId?.trim();
@@ -59,6 +117,18 @@ async function getActiveProfile() {
   const first = Object.values(store.profiles)[0];
   return first ?? null;
 }
+async function removeProfile(profileId) {
+  const store = await loadStore();
+  if (!store.profiles[profileId]) {
+    return null;
+  }
+  delete store.profiles[profileId];
+  if (store.activeProfileId === profileId) {
+    store.activeProfileId = Object.keys(store.profiles)[0];
+  }
+  await saveStore(store);
+  return store.activeProfileId ? store.profiles[store.activeProfileId] ?? null : null;
+}
 async function clearStore() {
   await fs.rm(stateDir, { recursive: true, force: true });
 }
@@ -67,8 +137,11 @@ export {
   getActiveProfile,
   getStateDir,
   getStorePath,
+  listProfiles,
   loadStore,
+  removeProfile,
   saveProfile,
-  saveStore
+  saveStore,
+  setActiveProfile,
+  updateProfile
 };
-//# sourceMappingURL=profile-store.js.map