ai-zero-token 2.0.4 → 2.0.6

package/dist/core/store/codex-auth-store.js

@@ -1,16 +1,301 @@
 #!/usr/bin/env node
+import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
 function getCodexHomeDir() {
   return process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
 }
+const OPENAI_CODEX_PROVIDER_ID = "openai";
+const LEGACY_CODEX_PROVIDER_ID = "ai-zero-token";
+const DEFAULT_CODEX_PROVIDER_ID = OPENAI_CODEX_PROVIDER_ID;
 function getCodexAuthPath() {
   return path.join(getCodexHomeDir(), "auth.json");
 }
+function getCodexConfigPath() {
+  return path.join(getCodexHomeDir(), "config.toml");
+}
+function getCodexStateDbPath() {
+  return path.join(getCodexHomeDir(), "state_5.sqlite");
+}
 function createBackupSuffix() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatTomlString(value) {
+  return JSON.stringify(value);
+}
+function validateProviderId(providerId) {
+  if (!/^[A-Za-z0-9_-]+$/.test(providerId)) {
+    throw new Error("Codex providerId \u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u77ED\u6A2A\u7EBF\u3002");
+  }
+}
+async function fileExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sqliteQuote(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+async function runSqlite(dbPath, sql) {
+  const { stdout } = await execFileAsync("sqlite3", [dbPath, sql], {
+    timeout: 15e3,
+    maxBuffer: 1024 * 1024
+  });
+  return stdout.trim();
+}
+async function migrateLegacyCodexHistoryProvider() {
+  const dbPath = getCodexStateDbPath();
+  if (!await fileExists(dbPath)) {
+    return {
+      path: dbPath,
+      migratedCount: 0,
+      skipped: true
+    };
+  }
+  try {
+    const countRaw = await runSqlite(
+      dbPath,
+      `select count(*) from threads where model_provider=${sqliteQuote(LEGACY_CODEX_PROVIDER_ID)};`
+    );
+    const migratedCount = Number.parseInt(countRaw, 10);
+    if (!Number.isFinite(migratedCount) || migratedCount <= 0) {
+      return {
+        path: dbPath,
+        migratedCount: 0,
+        skipped: true
+      };
+    }
+    const backupPath = `${dbPath}.azt-backup-${createBackupSuffix()}`;
+    await runSqlite(dbPath, `.backup ${sqliteQuote(backupPath)}`);
+    await runSqlite(
+      dbPath,
+      `update threads set model_provider=${sqliteQuote(OPENAI_CODEX_PROVIDER_ID)} where model_provider=${sqliteQuote(LEGACY_CODEX_PROVIDER_ID)};`
+    );
+    return {
+      path: dbPath,
+      backupPath,
+      migratedCount
+    };
+  } catch (error) {
+    return {
+      path: dbPath,
+      migratedCount: 0,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function normalizeCodexProviderBaseUrl(value) {
+  let normalized = value.trim();
+  if (!normalized) {
+    throw new Error("Codex provider base_url \u4E0D\u80FD\u4E3A\u7A7A\u3002");
+  }
+  if (!/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(normalized)) {
+    normalized = `http://${normalized}`;
+  }
+  let url;
+  try {
+    url = new URL(normalized);
+  } catch {
+    throw new Error("Codex provider base_url \u683C\u5F0F\u9519\u8BEF\uFF0C\u8BF7\u586B\u5199\u5B8C\u6574\u7684 http(s) URL\u3002");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Codex provider base_url \u5FC5\u987B\u662F http(s) URL\u3002");
+  }
+  url.hash = "";
+  url.search = "";
+  const path2 = url.pathname.replace(/\/+$/g, "");
+  if (!path2 || path2 === "/") {
+    url.pathname = "/codex/v1";
+  } else if (path2 === "/v1") {
+    url.pathname = "/codex/v1";
+  } else if (path2.endsWith("/codex")) {
+    url.pathname = `${path2}/v1`;
+  } else {
+    url.pathname = path2;
+  }
+  return url.toString().replace(/\/+$/g, "");
+}
+function parseTomlStringValue(value) {
+  const trimmed = value.trim().replace(/\s+#.*$/g, "");
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return typeof parsed === "string" ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function findFirstTableLine(lines) {
+  const index = lines.findIndex((line) => /^\s*\[/.test(line));
+  return index === -1 ? lines.length : index;
+}
+function parseRootString(raw, key) {
+  const lines = raw.split(/\r?\n/);
+  const firstTableLine = findFirstTableLine(lines);
+  const keyPattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*(.+)$`);
+  for (let index = 0; index < firstTableLine; index += 1) {
+    const match = keyPattern.exec(lines[index] ?? "");
+    if (match) {
+      return parseTomlStringValue(match[1] ?? "");
+    }
+  }
+  return void 0;
+}
+function parseRootModelProvider(raw) {
+  return parseRootString(raw, "model_provider");
+}
+function parseGatewayProviderTable(raw, providerId) {
+  const lines = raw.split(/\r?\n/);
+  const tablePattern = new RegExp(`^\\s*\\[\\s*model_providers\\.${escapeRegExp(providerId)}\\s*\\]\\s*$`);
+  const start = lines.findIndex((line) => tablePattern.test(line));
+  if (start === -1) {
+    return { exists: false };
+  }
+  let baseUrl;
+  for (let index = start + 1; index < lines.length && !/^\s*\[/.test(lines[index] ?? ""); index += 1) {
+    const match = /^\s*base_url\s*=\s*(.+)$/.exec(lines[index] ?? "");
+    if (match) {
+      baseUrl = parseTomlStringValue(match[1] ?? "");
+    }
+  }
+  return { exists: true, baseUrl };
+}
+function upsertRootString(raw, key, value) {
+  if (!raw.trim()) {
+    return `${key} = ${formatTomlString(value)}
+`;
+  }
+  const lines = raw.split(/\r?\n/);
+  const firstTableLine = findFirstTableLine(lines);
+  const nextLine = `${key} = ${formatTomlString(value)}`;
+  const keyPattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`);
+  for (let index = 0; index < firstTableLine; index += 1) {
+    if (keyPattern.test(lines[index])) {
+      lines[index] = nextLine;
+      return lines.join("\n");
+    }
+  }
+  lines.splice(firstTableLine, 0, nextLine, "");
+  return lines.join("\n");
+}
+function upsertRootModelProvider(raw, providerId) {
+  return upsertRootString(raw, "model_provider", providerId);
+}
+function buildGatewayProviderBlock(providerId, baseUrl) {
+  return [
+    "# AI Zero Token managed Codex provider",
+    `[model_providers.${providerId}]`,
+    'name = "AI Zero Token"',
+    `base_url = ${formatTomlString(baseUrl)}`,
+    'wire_api = "responses"',
+    "supports_websockets = false"
+  ];
+}
+function upsertGatewayProviderTable(raw, providerId, baseUrl) {
+  const lines = raw.split(/\r?\n/);
+  const tablePattern = new RegExp(`^\\s*\\[\\s*model_providers\\.${escapeRegExp(providerId)}\\s*\\]\\s*$`);
+  const start = lines.findIndex((line) => tablePattern.test(line));
+  const block = buildGatewayProviderBlock(providerId, baseUrl);
+  if (start === -1) {
+    const trimmed = raw.replace(/\s+$/g, "");
+    return `${trimmed}${trimmed ? "\n\n" : ""}${block.join("\n")}
+`;
+  }
+  let end = start + 1;
+  while (end < lines.length && !/^\s*\[/.test(lines[end])) {
+    end += 1;
+  }
+  const replaceStart = start > 0 && /AI Zero Token managed Codex provider/.test(lines[start - 1]) ? start - 1 : start;
+  lines.splice(replaceStart, end - replaceStart, ...block, "");
+  return lines.join("\n").replace(/\s+$/g, "\n");
+}
+function applyGatewayProviderConfig(raw, providerId, baseUrl) {
+  const sanitizedRaw = removeOpenAIGatewayConfig(raw).raw;
+  return upsertGatewayProviderTable(upsertRootModelProvider(sanitizedRaw, providerId), providerId, baseUrl);
+}
+function applyOpenAIGatewayConfig(raw, baseUrl) {
+  const withoutLegacyProvider = removeGatewayProviderConfig(raw, LEGACY_CODEX_PROVIDER_ID).raw;
+  return upsertRootString(
+    upsertRootModelProvider(withoutLegacyProvider, OPENAI_CODEX_PROVIDER_ID),
+    "openai_base_url",
+    baseUrl
+  );
+}
+function removeRootString(raw, key, expectedValue) {
+  const lines = raw.split(/\r?\n/);
+  const firstTableLine = findFirstTableLine(lines);
+  const keyPattern = new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*(.+)$`);
+  for (let index = 0; index < firstTableLine; index += 1) {
+    const match = keyPattern.exec(lines[index] ?? "");
+    if (!match) {
+      continue;
+    }
+    if (typeof expectedValue === "string" && parseTomlStringValue(match[1] ?? "") !== expectedValue) {
+      continue;
+    }
+    lines.splice(index, 1);
+    if (lines[index] === "" && (index === 0 || lines[index - 1] === "")) {
+      lines.splice(index, 1);
+    }
+    return { raw: lines.join("\n").replace(/^\s+\n/g, ""), removed: true };
+  }
+  return { raw, removed: false };
+}
+function removeRootModelProvider(raw, providerId) {
+  return removeRootString(raw, "model_provider", providerId);
+}
+function removeGatewayProviderTable(raw, providerId) {
+  const lines = raw.split(/\r?\n/);
+  const tablePattern = new RegExp(`^\\s*\\[\\s*model_providers\\.${escapeRegExp(providerId)}\\s*\\]\\s*$`);
+  const start = lines.findIndex((line) => tablePattern.test(line));
+  if (start === -1) {
+    return { raw, removed: false };
+  }
+  let end = start + 1;
+  while (end < lines.length && !/^\s*\[/.test(lines[end])) {
+    end += 1;
+  }
+  const replaceStart = start > 0 && /AI Zero Token managed Codex provider/.test(lines[start - 1]) ? start - 1 : start;
+  lines.splice(replaceStart, end - replaceStart);
+  return {
+    raw: lines.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\s+$/g, "\n"),
+    removed: true
+  };
+}
+function removeGatewayProviderConfig(raw, providerId) {
+  const rootRemoved = removeRootModelProvider(raw, providerId);
+  const tableRemoved = removeGatewayProviderTable(rootRemoved.raw, providerId);
+  return {
+    raw: tableRemoved.raw,
+    removed: rootRemoved.removed || tableRemoved.removed
+  };
+}
+function removeOpenAIGatewayConfig(raw) {
+  const openAIBaseRemoved = removeRootString(raw, "openai_base_url");
+  const openAIProviderRemoved = removeRootModelProvider(openAIBaseRemoved.raw, OPENAI_CODEX_PROVIDER_ID);
+  const legacyRemoved = removeGatewayProviderConfig(openAIProviderRemoved.raw, LEGACY_CODEX_PROVIDER_ID);
+  return {
+    raw: legacyRemoved.raw,
+    removed: openAIBaseRemoved.removed || openAIProviderRemoved.removed || legacyRemoved.removed
+  };
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -23,14 +308,69 @@ async function readCodexAuth() {
     return null;
   }
 }
+async function getCodexGatewayProviderStatus(params) {
+  const requestedProviderId = params?.providerId?.trim();
+  const providerId = requestedProviderId || DEFAULT_CODEX_PROVIDER_ID;
+  validateProviderId(providerId);
+  const configPath = getCodexConfigPath();
+  let raw = "";
+  try {
+    raw = await fs.readFile(configPath, "utf8");
+  } catch {
+    return {
+      path: configPath,
+      providerId,
+      exists: false,
+      active: false
+    };
+  }
+  const modelProvider = parseRootModelProvider(raw);
+  if (providerId === OPENAI_CODEX_PROVIDER_ID) {
+    const openAIBaseUrl = parseRootString(raw, "openai_base_url");
+    if (openAIBaseUrl && (!modelProvider || modelProvider === OPENAI_CODEX_PROVIDER_ID)) {
+      return {
+        path: configPath,
+        providerId: OPENAI_CODEX_PROVIDER_ID,
+        exists: true,
+        active: !modelProvider || modelProvider === OPENAI_CODEX_PROVIDER_ID,
+        baseUrl: openAIBaseUrl,
+        modelProvider
+      };
+    }
+    const legacyTable = parseGatewayProviderTable(raw, LEGACY_CODEX_PROVIDER_ID);
+    if (!requestedProviderId && legacyTable.exists) {
+      return {
+        path: configPath,
+        providerId: LEGACY_CODEX_PROVIDER_ID,
+        exists: true,
+        active: modelProvider === LEGACY_CODEX_PROVIDER_ID,
+        baseUrl: legacyTable.baseUrl,
+        modelProvider
+      };
+    }
+  }
+  const table = parseGatewayProviderTable(raw, providerId);
+  return {
+    path: configPath,
+    providerId,
+    exists: table.exists,
+    active: modelProvider === providerId && table.exists,
+    baseUrl: table.baseUrl,
+    modelProvider
+  };
+}
 async function getCodexAuthStatus() {
   const authPath = getCodexAuthPath();
-  const auth = await readCodexAuth();
+  const [auth, gatewayProvider] = await Promise.all([
+    readCodexAuth(),
+    getCodexGatewayProviderStatus()
+  ]);
   if (!auth) {
     return {
       path: authPath,
       exists: false,
-      hasIdToken: false
+      hasIdToken: false,
+      gatewayProvider
     };
   }
   const tokens = isRecord(auth.tokens) ? auth.tokens : {};
@@ -39,7 +379,8 @@ async function getCodexAuthStatus() {
     exists: true,
     accountId: typeof tokens.account_id === "string" ? tokens.account_id : void 0,
     hasIdToken: typeof tokens.id_token === "string" && tokens.id_token.length > 0,
-    lastRefresh: typeof auth.last_refresh === "string" ? auth.last_refresh : void 0
+    lastRefresh: typeof auth.last_refresh === "string" ? auth.last_refresh : void 0,
+    gatewayProvider
   };
 }
 async function applyProfileToCodexAuth(profile) {
@@ -82,13 +423,97 @@ async function applyProfileToCodexAuth(profile) {
     accountId: profile.accountId,
     hasIdToken: true,
     lastRefresh: authFile.last_refresh,
+    gatewayProvider: await getCodexGatewayProviderStatus(),
     backupPath,
     appliedProfileId: profile.profileId,
     appliedEmail: profile.email
   };
 }
+async function applyGatewayToCodexProviderConfig(params) {
+  const providerId = params.providerId?.trim() || DEFAULT_CODEX_PROVIDER_ID;
+  validateProviderId(providerId);
+  const baseUrl = normalizeCodexProviderBaseUrl(params.baseUrl);
+  const configPath = getCodexConfigPath();
+  const codexHomeDir = path.dirname(configPath);
+  await fs.mkdir(codexHomeDir, { recursive: true });
+  let raw = "";
+  let backupPath;
+  try {
+    raw = await fs.readFile(configPath, "utf8");
+    backupPath = `${configPath}.azt-backup-${createBackupSuffix()}`;
+    await fs.copyFile(configPath, backupPath);
+  } catch {
+    raw = "";
+    backupPath = void 0;
+  }
+  const useOpenAIProvider = providerId === OPENAI_CODEX_PROVIDER_ID;
+  const next = useOpenAIProvider ? applyOpenAIGatewayConfig(raw, baseUrl) : applyGatewayProviderConfig(raw, providerId, baseUrl);
+  const tmpPath = `${configPath}.tmp-${process.pid}`;
+  await fs.writeFile(tmpPath, next, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await fs.rename(tmpPath, configPath);
+  await fs.chmod(configPath, 384);
+  return {
+    path: configPath,
+    backupPath,
+    providerId,
+    baseUrl,
+    historyMigration: useOpenAIProvider ? await migrateLegacyCodexHistoryProvider() : void 0
+  };
+}
+async function removeGatewayFromCodexProviderConfig(params) {
+  const providerId = params?.providerId?.trim() || DEFAULT_CODEX_PROVIDER_ID;
+  validateProviderId(providerId);
+  const configPath = getCodexConfigPath();
+  let raw = "";
+  try {
+    raw = await fs.readFile(configPath, "utf8");
+  } catch {
+    return {
+      path: configPath,
+      providerId,
+      removed: false
+    };
+  }
+  const sanitized = removeOpenAIGatewayConfig(raw);
+  const next = providerId === OPENAI_CODEX_PROVIDER_ID || providerId === LEGACY_CODEX_PROVIDER_ID ? sanitized : (() => {
+    const providerRemoved = removeGatewayProviderConfig(sanitized.raw, providerId);
+    return {
+      raw: providerRemoved.raw,
+      removed: sanitized.removed || providerRemoved.removed
+    };
+  })();
+  if (!next.removed) {
+    return {
+      path: configPath,
+      providerId,
+      removed: false
+    };
+  }
+  const backupPath = `${configPath}.azt-backup-${createBackupSuffix()}`;
+  await fs.copyFile(configPath, backupPath);
+  const tmpPath = `${configPath}.tmp-${process.pid}`;
+  await fs.writeFile(tmpPath, next.raw.trim() ? next.raw : "", {
+    encoding: "utf8",
+    mode: 384
+  });
+  await fs.rename(tmpPath, configPath);
+  await fs.chmod(configPath, 384);
+  return {
+    path: configPath,
+    backupPath,
+    providerId,
+    removed: true
+  };
+}
 export {
+  applyGatewayToCodexProviderConfig,
   applyProfileToCodexAuth,
   getCodexAuthPath,
-  getCodexAuthStatus
+  getCodexAuthStatus,
+  getCodexConfigPath,
+  getCodexGatewayProviderStatus,
+  removeGatewayFromCodexProviderConfig
 };

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import {
   ensureStateMigrated,
@@ -16,10 +17,14 @@ function createDefaultSettings() {
       noProxy: "localhost,127.0.0.1,::1"
     },
     autoSwitch: {
-      enabled: false
+      enabled: false,
+      excludedProfileIds: []
     },
     runtime: {
-      quotaSyncConcurrency: 16
+      quotaSyncConcurrency: 3
+    },
+    image: {
+      freeAccountWebGenerationEnabled: false
     },
     server: {
       host: "0.0.0.0",
@@ -27,48 +32,79 @@ function createDefaultSettings() {
     }
   };
 }
+function normalizeSettings(parsed) {
+  const defaults = createDefaultSettings();
+  return {
+    version: 1,
+    defaultProvider: parsed.defaultProvider ?? defaults.defaultProvider,
+    defaultModel: parsed.defaultModel ?? defaults.defaultModel,
+    networkProxy: {
+      enabled: parsed.networkProxy?.enabled ?? defaults.networkProxy.enabled,
+      url: parsed.networkProxy?.url ?? defaults.networkProxy.url,
+      noProxy: parsed.networkProxy?.noProxy ?? defaults.networkProxy.noProxy
+    },
+    autoSwitch: {
+      enabled: parsed.autoSwitch?.enabled ?? defaults.autoSwitch.enabled,
+      excludedProfileIds: normalizeStringList(parsed.autoSwitch?.excludedProfileIds)
+    },
+    runtime: {
+      quotaSyncConcurrency: normalizeQuotaSyncConcurrency(parsed.runtime?.quotaSyncConcurrency, defaults.runtime.quotaSyncConcurrency)
+    },
+    image: {
+      freeAccountWebGenerationEnabled: parsed.image?.freeAccountWebGenerationEnabled ?? defaults.image.freeAccountWebGenerationEnabled
+    },
+    server: {
+      host: parsed.server?.host ?? defaults.server.host,
+      port: parsed.server?.port ?? defaults.server.port
+    }
+  };
+}
 async function loadSettings() {
   try {
     await ensureStateMigrated();
     const raw = await fs.readFile(getSettingsPath(), "utf8");
     const parsed = JSON.parse(raw);
-    const defaults = createDefaultSettings();
-    return {
-      version: 1,
-      defaultProvider: parsed.defaultProvider ?? defaults.defaultProvider,
-      defaultModel: parsed.defaultModel ?? defaults.defaultModel,
-      networkProxy: {
-        enabled: parsed.networkProxy?.enabled ?? defaults.networkProxy.enabled,
-        url: parsed.networkProxy?.url ?? defaults.networkProxy.url,
-        noProxy: parsed.networkProxy?.noProxy ?? defaults.networkProxy.noProxy
-      },
-      autoSwitch: {
-        enabled: parsed.autoSwitch?.enabled ?? defaults.autoSwitch.enabled
-      },
-      runtime: {
-        quotaSyncConcurrency: normalizeQuotaSyncConcurrency(parsed.runtime?.quotaSyncConcurrency, defaults.runtime.quotaSyncConcurrency)
-      },
-      server: {
-        host: parsed.server?.host ?? defaults.server.host,
-        port: parsed.server?.port ?? defaults.server.port
-      }
-    };
+    return normalizeSettings(parsed);
   } catch {
     return createDefaultSettings();
   }
 }
-function normalizeQuotaSyncConcurrency(value, fallback = 16) {
+function normalizeQuotaSyncConcurrency(value, fallback = 3) {
   const parsed = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : fallback;
   if (!Number.isFinite(parsed)) {
     return fallback;
   }
   return Math.min(32, Math.max(1, Math.trunc(parsed)));
 }
-async function saveSettings(settings) {
+function normalizeStringList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return Array.from(
+    new Set(
+      value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean)
+    )
+  );
+}
+let settingsSaveQueue = Promise.resolve();
+async function writeSettingsAtomic(settings) {
   await ensureStateMigrated();
   await fs.mkdir(getStateDir(), { recursive: true });
-  await fs.writeFile(getSettingsPath(), `${JSON.stringify(settings, null, 2)}
+  const settingsPath = getSettingsPath();
+  const tempPath = `${settingsPath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(tempPath, `${JSON.stringify(settings, null, 2)}
 `, "utf8");
+    await fs.rename(tempPath, settingsPath);
+  } catch (error) {
+    await fs.rm(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function saveSettings(settings) {
+  const nextSave = settingsSaveQueue.then(() => writeSettingsAtomic(settings), () => writeSettingsAtomic(settings));
+  settingsSaveQueue = nextSave.catch(() => void 0);
+  await nextSave;
 }
 export {
   createDefaultSettings,

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

@@ -34,6 +34,18 @@ function getStorePath() {
 function getSettingsPath() {
   return path.join(stateDir, "settings.json");
 }
+function getUsageDir() {
+  return path.join(stateDir, "usage");
+}
+function getUsageEventsDir() {
+  return path.join(getUsageDir(), "events");
+}
+function getUsageDailyPath() {
+  return path.join(getUsageDir(), "daily.json");
+}
+function getUsageLifetimePath() {
+  return path.join(getUsageDir(), "lifetime.json");
+}
 async function ensureStateMigrated() {
   if (!migrationPromise) {
     migrationPromise = (async () => {
@@ -50,5 +62,9 @@ export {
   ensureStateMigrated,
   getSettingsPath,
   getStateDir,
-  getStorePath
+  getStorePath,
+  getUsageDailyPath,
+  getUsageDir,
+  getUsageEventsDir,
+  getUsageLifetimePath
 };