codex-slot 0.1.17 → 0.1.19

package/dist/account-store.js

@@ -71,15 +71,50 @@ function resolveEmailFromAuth(auth) {
         return undefined;
     }
 }
+/**
+ * 将来源 HOME 下的账号级 `.auth.json` 文件集合镜像到目标 HOME。
+ *
+ * 业务含义：
+ * 1. 仅同步 `accounts` 目录下的账号级认证文件。
+ * 2. 来源不存在某个 `.auth.json` 时，会删除目标中的同名残留，避免旧登录态混入。
+ * 3. 来源缺少 `accounts` 目录时，视为没有任何账号级认证文件。
+ *
+ * @param sourceAccountsDir 来源 `accounts` 目录绝对路径。
+ * @param targetAccountsDir 目标 `accounts` 目录绝对路径。
+ * @returns 无返回值。
+ * @throws 当文件复制或删除失败时透传文件系统错误。
+ */
+function syncAccountAuthFiles(sourceAccountsDir, targetAccountsDir) {
+    const sourceAuthFiles = new Set();
+    if (node_fs_1.default.existsSync(sourceAccountsDir)) {
+        for (const entry of node_fs_1.default.readdirSync(sourceAccountsDir, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith(".auth.json")) {
+                continue;
+            }
+            sourceAuthFiles.add(entry.name);
+            node_fs_1.default.copyFileSync(node_path_1.default.join(sourceAccountsDir, entry.name), node_path_1.default.join(targetAccountsDir, entry.name));
+        }
+    }
+    for (const entry of node_fs_1.default.readdirSync(targetAccountsDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !entry.name.endsWith(".auth.json")) {
+            continue;
+        }
+        if (!sourceAuthFiles.has(entry.name)) {
+            node_fs_1.default.rmSync(node_path_1.default.join(targetAccountsDir, entry.name), { force: true });
+        }
+    }
+}
 /**
  * 将来源 HOME 下的官方 `.codex` 登录态复制到目标 HOME。
  *
  * 只复制认证和账号元数据所需文件，不复制历史日志、缓存等无关内容。
+ * 其中 `auth.json` 为必需文件，`accounts/registry.json` 与账号级 `.auth.json`
+ * 允许缺失；缺失时会同步删除目标中的对应残留文件，避免旧缓存污染当前登录态。
  *
  * @param sourceHome 来源 HOME 目录。
  * @param targetHome 目标 HOME 目录。
  * @returns 无返回值。
- * @throws 当来源目录缺少关键认证文件时抛出错误。
+ * @throws 当来源目录缺少 `auth.json` 或复制失败时抛出错误。
  */
 function cloneCodexAuthState(sourceHome, targetHome) {
     const sourceCodexDir = getCodexDataDir(sourceHome);
@@ -87,25 +122,21 @@ function cloneCodexAuthState(sourceHome, targetHome) {
     const sourceAuthPath = node_path_1.default.join(sourceCodexDir, "auth.json");
     const sourceAccountsDir = node_path_1.default.join(sourceCodexDir, "accounts");
     const sourceRegistryPath = node_path_1.default.join(sourceAccountsDir, "registry.json");
+    const targetAccountsDir = node_path_1.default.join(targetCodexDir, "accounts");
+    const targetRegistryPath = node_path_1.default.join(targetAccountsDir, "registry.json");
     if (!node_fs_1.default.existsSync(sourceAuthPath)) {
         throw new Error((0, text_1.bi)(`来源目录缺少 auth.json: ${sourceAuthPath}`, `Source directory is missing auth.json: ${sourceAuthPath}`));
     }
-    if (!node_fs_1.default.existsSync(sourceRegistryPath)) {
-        throw new Error((0, text_1.bi)(`来源目录缺少 registry.json: ${sourceRegistryPath}`, `Source directory is missing registry.json: ${sourceRegistryPath}`));
-    }
     node_fs_1.default.mkdirSync(targetCodexDir, { recursive: true });
-    node_fs_1.default.mkdirSync(node_path_1.default.join(targetCodexDir, "accounts"), { recursive: true });
+    node_fs_1.default.mkdirSync(targetAccountsDir, { recursive: true });
     node_fs_1.default.copyFileSync(sourceAuthPath, node_path_1.default.join(targetCodexDir, "auth.json"));
-    node_fs_1.default.copyFileSync(sourceRegistryPath, node_path_1.default.join(targetCodexDir, "accounts", "registry.json"));
-    for (const entry of node_fs_1.default.readdirSync(sourceAccountsDir, { withFileTypes: true })) {
-        if (!entry.isFile()) {
-            continue;
-        }
-        if (!entry.name.endsWith(".auth.json")) {
-            continue;
-        }
-        node_fs_1.default.copyFileSync(node_path_1.default.join(sourceAccountsDir, entry.name), node_path_1.default.join(targetCodexDir, "accounts", entry.name));
+    if (node_fs_1.default.existsSync(sourceRegistryPath)) {
+        node_fs_1.default.copyFileSync(sourceRegistryPath, targetRegistryPath);
+    }
+    else {
+        node_fs_1.default.rmSync(targetRegistryPath, { force: true });
     }
+    syncAccountAuthFiles(sourceAccountsDir, targetAccountsDir);
 }
 /**
  * 检查某个 HOME 下的官方登录态是否完整。

package/dist/app/account-service.js

@@ -116,6 +116,10 @@ function renameAccount(oldName, newName) {
         };
         delete state.usage_cache[oldName];
     }
+    if (state.scheduler_stats[oldName]) {
+        state.scheduler_stats[newName] = state.scheduler_stats[oldName];
+        delete state.scheduler_stats[oldName];
+    }
     (0, state_1.saveState)(state);
     return renamedAccount;
 }

package/dist/scheduler.js

@@ -4,6 +4,12 @@ exports.pickBestAccount = pickBestAccount;
 exports.listCandidateAccounts = listCandidateAccounts;
 const config_1 = require("./config");
 const status_1 = require("./status");
+const state_1 = require("./state");
+const CRITICAL_WEEKLY_LEFT_PERCENT = 5;
+const LOW_WEEKLY_LEFT_PERCENT = 15;
+const WASTE_HORIZON_SECONDS = 5 * 60 * 60;
+const WEEKLY_WASTE_HORIZON_SECONDS = 7 * 24 * 60 * 60;
+const RECENT_USE_RECOVERY_SECONDS = 30 * 60;
 function nextResetWeight(resetAt) {
     if (!resetAt) {
         return Number.MAX_SAFE_INTEGER;
@@ -32,23 +38,171 @@ function isSoftLocalBlocked(status) {
     ].includes(status.localBlockReason ?? "");
 }
 /**
- * 对未命中额度限制的候选账号按剩余额度与重置时间排序。
+ * 将百分比字段归一化为 0 到 1 的评分，缺失时按中性值处理。
+ *
+ * @param value 原始百分比。
+ * @returns 归一化后的评分。
+ */
+function normalizePercent(value) {
+    if (value === null || value === undefined || Number.isNaN(value)) {
+        return 0.5;
+    }
+    return Math.max(0, Math.min(1, value / 100));
+}
+/**
+ * 计算 5 小时窗口的余额浪费压力，越接近重置且剩余额度越多分数越高。
+ *
+ * @param status 账号运行时状态。
+ * @returns 0 到 1 之间的浪费压力评分。
+ */
+function computeFiveHourWastePressure(status) {
+    const leftScore = normalizePercent(status.fiveHourLeftPercent);
+    if (!status.fiveHourResetsAt) {
+        return leftScore * 0.2;
+    }
+    const secondsUntilReset = status.fiveHourResetsAt - Math.floor(Date.now() / 1000);
+    if (secondsUntilReset <= 0) {
+        return 0;
+    }
+    const urgency = Math.max(0.1, Math.min(1, (WASTE_HORIZON_SECONDS - secondsUntilReset) / WASTE_HORIZON_SECONDS));
+    return leftScore * urgency;
+}
+/**
+ * 计算周窗口的余额浪费压力，周额度越接近重置且剩余越多分数越高。
+ *
+ * @param status 账号运行时状态。
+ * @returns 0 到 1 之间的周窗口浪费压力评分。
+ */
+function computeWeeklyWastePressure(status) {
+    const leftScore = normalizePercent(status.weeklyLeftPercent);
+    if (!status.weeklyResetsAt) {
+        return leftScore * 0.1;
+    }
+    const secondsUntilReset = status.weeklyResetsAt - Math.floor(Date.now() / 1000);
+    if (secondsUntilReset <= 0) {
+        return 0;
+    }
+    const urgency = Math.max(0.05, Math.min(1, (WEEKLY_WASTE_HORIZON_SECONDS - secondsUntilReset) / WEEKLY_WASTE_HORIZON_SECONDS));
+    return leftScore * urgency;
+}
+/**
+ * 计算 5 小时窗口调度时可借用的周额度承载系数，周余额越低越抑制短窗口冲动。
+ *
+ * @param status 账号运行时状态。
+ * @returns 0 到 1 之间的周额度承载系数。
+ */
+function computeWeeklyCapacityFactor(status) {
+    const weeklyLeft = status.weeklyLeftPercent;
+    if (weeklyLeft === null || weeklyLeft === undefined || Number.isNaN(weeklyLeft)) {
+        return 0.7;
+    }
+    if (weeklyLeft <= CRITICAL_WEEKLY_LEFT_PERCENT) {
+        return 0.05;
+    }
+    if (weeklyLeft < LOW_WEEKLY_LEFT_PERCENT) {
+        return 0.2;
+    }
+    if (weeklyLeft < 30) {
+        return 0.55;
+    }
+    return 1;
+}
+/**
+ * 计算周额度健康度，低于保护线时非线性降权，避免个别账号过早打穿周窗口。
+ *
+ * @param status 账号运行时状态。
+ * @returns 0 到 1 之间的周额度健康评分。
+ */
+function computeWeeklyHealthScore(status) {
+    const weeklyLeft = status.weeklyLeftPercent;
+    if (weeklyLeft === null || weeklyLeft === undefined || Number.isNaN(weeklyLeft)) {
+        return 0.5;
+    }
+    if (weeklyLeft <= CRITICAL_WEEKLY_LEFT_PERCENT) {
+        return 0;
+    }
+    if (weeklyLeft < LOW_WEEKLY_LEFT_PERCENT) {
+        return normalizePercent(weeklyLeft) * 0.35;
+    }
+    return normalizePercent(weeklyLeft);
+}
+/**
+ * 计算账号使用分散度，成功次数更少且最近未使用的账号分数更高。
+ *
+ * @param status 账号运行时状态。
+ * @param minSuccessCount 当前候选账号中的最小成功次数。
+ * @param maxSuccessCount 当前候选账号中的最大成功次数。
+ * @returns 0 到 1 之间的分散调度评分。
+ */
+function computeSpreadScore(status, minSuccessCount, maxSuccessCount) {
+    const stats = (0, state_1.getSchedulerStats)(status.id);
+    const countRange = Math.max(1, maxSuccessCount - minSuccessCount);
+    const countScore = 1 - (stats.success_count - minSuccessCount) / countRange;
+    if (!stats.last_success_at) {
+        return Math.max(0, Math.min(1, countScore * 0.6 + 0.4));
+    }
+    const secondsSinceLastUse = (Date.now() - new Date(stats.last_success_at).getTime()) / 1000;
+    const recencyScore = Math.max(0, Math.min(1, secondsSinceLastUse / RECENT_USE_RECOVERY_SECONDS));
+    return Math.max(0, Math.min(1, countScore * 0.6 + recencyScore * 0.4));
+}
+/**
+ * 计算候选账号的综合调度评分。
+ *
+ * 业务含义：
+ * 1. 周窗口承担主防浪费压力，快重置且余额多的账号优先。
+ * 2. 5 小时窗口在周额度健康时参与放大，低周余额会抑制短窗口冲动。
+ * 3. 本地成功使用历史用于打散连续请求，降低单账号被持续命中的概率。
+ *
+ * @param status 账号运行时状态。
+ * @param minSuccessCount 当前候选账号中的最小成功次数。
+ * @param maxSuccessCount 当前候选账号中的最大成功次数。
+ * @returns 综合评分，分数越高越优先。
+ */
+function computeScheduleScore(status, minSuccessCount, maxSuccessCount) {
+    const weeklyWasteScore = computeWeeklyWastePressure(status);
+    const fiveHourWasteScore = computeFiveHourWastePressure(status) * computeWeeklyCapacityFactor(status);
+    const weeklyHealthScore = computeWeeklyHealthScore(status);
+    const fiveHourLeftScore = normalizePercent(status.fiveHourLeftPercent);
+    const spreadScore = computeSpreadScore(status, minSuccessCount, maxSuccessCount);
+    return (weeklyWasteScore * 0.5 +
+        fiveHourWasteScore * 0.25 +
+        weeklyHealthScore * 0.1 +
+        spreadScore * 0.1 +
+        fiveHourLeftScore * 0.05);
+}
+/**
+ * 对候选账号按防浪费、周额度保护与均匀使用策略排序。
  *
  * @param statuses 待排序的账号状态列表。
  * @returns 排序后的账号状态列表，优先返回更适合尝试的账号。
  */
 function rankEligibleStatuses(statuses) {
-    return [...statuses].sort((left, right) => {
-        const fiveHourDiff = (right.fiveHourLeftPercent ?? -1) - (left.fiveHourLeftPercent ?? -1);
-        if (fiveHourDiff !== 0) {
-            return fiveHourDiff;
-        }
-        const weeklyDiff = (right.weeklyLeftPercent ?? -1) - (left.weeklyLeftPercent ?? -1);
-        if (weeklyDiff !== 0) {
-            return weeklyDiff;
-        }
-        return nextResetWeight(left.fiveHourResetsAt) - nextResetWeight(right.fiveHourResetsAt);
-    });
+    const primaryPool = statuses.some((item) => item.weeklyLeftPercent === null ||
+        item.weeklyLeftPercent === undefined ||
+        item.weeklyLeftPercent > CRITICAL_WEEKLY_LEFT_PERCENT)
+        ? statuses.filter((item) => item.weeklyLeftPercent === null ||
+            item.weeklyLeftPercent === undefined ||
+            item.weeklyLeftPercent > CRITICAL_WEEKLY_LEFT_PERCENT)
+        : statuses;
+    const deferredPool = statuses.filter((item) => !primaryPool.includes(item));
+    const rankPool = (items) => {
+        const successCounts = items.map((item) => (0, state_1.getSchedulerStats)(item.id).success_count);
+        const minSuccessCount = Math.min(...successCounts, 0);
+        const maxSuccessCount = Math.max(...successCounts, 0);
+        return [...items].sort((left, right) => {
+            const scoreDiff = computeScheduleScore(right, minSuccessCount, maxSuccessCount) -
+                computeScheduleScore(left, minSuccessCount, maxSuccessCount);
+            if (Math.abs(scoreDiff) > Number.EPSILON) {
+                return scoreDiff;
+            }
+            const resetDiff = nextResetWeight(left.fiveHourResetsAt) - nextResetWeight(right.fiveHourResetsAt);
+            if (resetDiff !== 0) {
+                return resetDiff;
+            }
+            return (right.weeklyLeftPercent ?? -1) - (left.weeklyLeftPercent ?? -1);
+        });
+    };
+    return [...rankPool(primaryPool), ...rankPool(deferredPool)];
 }
 /**
  * 选择当前最适合激活的账号。

package/dist/server.js

@@ -355,6 +355,7 @@ async function startServer(port) {
             if (typeof cacheControl === "string") {
                 headers["cache-control"] = cacheControl;
             }
+            (0, state_1.recordAccountScheduleSuccess)(picked.account.id);
             headers.connection = "keep-alive";
             reply.raw.writeHead(upstream.statusCode, headers);
             for await (const chunk of upstream.body) {

package/dist/state.js

@@ -13,6 +13,8 @@ exports.getUsageCache = getUsageCache;
 exports.setUsageRefreshError = setUsageRefreshError;
 exports.clearUsageRefreshError = clearUsageRefreshError;
 exports.getUsageRefreshError = getUsageRefreshError;
+exports.getSchedulerStats = getSchedulerStats;
+exports.recordAccountScheduleSuccess = recordAccountScheduleSuccess;
 exports.getManagedCodexConfigState = getManagedCodexConfigState;
 exports.getManagedCodexAuthState = getManagedCodexAuthState;
 exports.setManagedCodexConfigState = setManagedCodexConfigState;
@@ -37,6 +39,7 @@ function loadState() {
             account_blocks: {},
             usage_cache: {},
             usage_refresh_errors: {},
+            scheduler_stats: {},
             managed_codex_auth: null,
             managed_codex_config: null
         };
@@ -48,6 +51,7 @@ function loadState() {
             account_blocks: {},
             usage_cache: {},
             usage_refresh_errors: {},
+            scheduler_stats: {},
             managed_codex_auth: null,
             managed_codex_config: null
         };
@@ -55,6 +59,7 @@ function loadState() {
         account_blocks: parsed.account_blocks ?? {},
         usage_cache: parsed.usage_cache ?? {},
         usage_refresh_errors: parsed.usage_refresh_errors ?? {},
+        scheduler_stats: parsed.scheduler_stats ?? {},
         managed_codex_auth: parsed.managed_codex_auth ?? null,
         managed_codex_config: parsed.managed_codex_config ?? null
     };
@@ -172,6 +177,37 @@ function getUsageRefreshError(accountId) {
     const state = loadState();
     return state.usage_refresh_errors[accountId] ?? null;
 }
+/**
+ * 读取指定账号的调度使用统计，用于在多账号可用时做均匀分摊。
+ *
+ * @param accountId 账号标识。
+ * @returns 调度统计；不存在时返回默认零值。
+ */
+function getSchedulerStats(accountId) {
+    const state = loadState();
+    return state.scheduler_stats[accountId] ?? {
+        success_count: 0,
+        last_success_at: null
+    };
+}
+/**
+ * 记录指定账号完成一次成功代理请求，供后续调度降低连续命中同一账号的概率。
+ *
+ * @param accountId 账号标识。
+ * @returns 无返回值。
+ */
+function recordAccountScheduleSuccess(accountId) {
+    const state = loadState();
+    const current = state.scheduler_stats[accountId] ?? {
+        success_count: 0,
+        last_success_at: null
+    };
+    state.scheduler_stats[accountId] = {
+        success_count: current.success_count + 1,
+        last_success_at: new Date().toISOString()
+    };
+    saveState(state);
+}
 /**
  * 读取当前记录的 Codex `config.toml` 接管快照。
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-slot",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "本地 Codex 多账号切换与状态管理工具",
   "type": "commonjs",
   "main": "dist/cli.js",