@foxden-app/foxclaw 0.4.2 → 0.4.3

package/README.md

@@ -101,7 +101,7 @@ FoxClaw 只响应 `TG_ALLOWED_USER_ID` 的消息——把机器人拉进群不
 **多账号管理：**
 - Codex 账户管理：`/account`、`/quota`、`/login_device`、`/auth add <name>`
 - 触发用量限制时自动在本地 `auth.json_*` 之间切换认证——5 小时限制到了自动换号
-- `/auth` 面板查看、启用、禁用、切换候选账号
+- `/auth` 面板查看、启用、禁用、切换候选账号；多 bot 模式下会按账号 ID 汇总各 runtime 最近掌握的额度快照
 
 **线程与会话：**
 - `/threads`、`/open`、`/new`、`/where`、`/interrupt`——稳定的聊天-线程绑定

package/README_EN.md

@@ -101,7 +101,7 @@ FoxClaw accepts messages only from `TG_ALLOWED_USER_ID`. Putting the bot in a gr
 **Multi-account management:**
 - Codex account controls: `/account`, `/quota`, `/login_device`, `/auth add <name>`
 - Automatic auth rotation across local `auth.json_*` files when a usage limit is hit — seamless account switching
-- `/auth` panel to view, enable, disable, and switch between candidate accounts
+- `/auth` panel to view, enable, disable, and switch between candidate accounts; in multi-bot mode it merges recent quota snapshots by account ID across runtimes
 
 **Threads and sessions:**
 - `/threads`, `/open`, `/new`, `/where`, `/interrupt` — sticky chat-to-thread binding

package/dist/auth/mirror.d.ts

@@ -21,6 +21,10 @@ export interface AuthMirrorValidationResult {
     ok: boolean;
     reason?: string | null;
 }
+export interface ChatGptAuthMetadata {
+    accountId: string;
+    lastRefreshMs: number;
+}
 export declare class AuthCandidateMirror {
     private readonly canonicalDir;
     private readonly runtimes;
@@ -47,3 +51,4 @@ export declare class AuthCandidateMirror {
     private resolveCanonicalCurrentCandidate;
 }
 export declare function isAuthCandidateName(name: string): boolean;
+export declare function readChatGptAuthMetadata(filePath: string): Promise<ChatGptAuthMetadata | null>;

package/dist/auth/mirror.js

@@ -216,12 +216,31 @@ async function listAuthCandidateNames(dir) {
 async function readChatGptAuthRecord(filePath) {
     try {
         const raw = await fs.readFile(filePath, 'utf8');
+        const metadata = parseChatGptAuthMetadata(raw);
+        if (!metadata)
+            return null;
+        return { raw, ...metadata };
+    }
+    catch {
+        return null;
+    }
+}
+export async function readChatGptAuthMetadata(filePath) {
+    try {
+        return parseChatGptAuthMetadata(await fs.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function parseChatGptAuthMetadata(raw) {
+    try {
         const parsed = JSON.parse(raw);
         const accountId = typeof parsed.tokens?.account_id === 'string' ? parsed.tokens.account_id : '';
         const lastRefreshMs = typeof parsed.last_refresh === 'string' ? Date.parse(parsed.last_refresh) : NaN;
         if (!accountId || !Number.isFinite(lastRefreshMs))
             return null;
-        return { raw, accountId, lastRefreshMs };
+        return { accountId, lastRefreshMs };
     }
     catch {
         return null;

package/dist/controller/controller.d.ts

@@ -295,6 +295,9 @@ export declare class BridgeSessionCore {
     private refreshCodexLocalUsageStats;
     private codexLocalUsageSnapshotPath;
     private refreshCurrentCodexAuthQuota;
+    private applySharedCodexAuthQuotaSnapshots;
+    private readCodexAuthCandidateAccountIds;
+    private codexAuthQuotaSnapshotMatchesAccount;
     private readCodexAuthQuotaSnapshots;
     private writeCodexAuthQuotaSnapshots;
     private codexAuthQuotaSnapshotPath;

package/dist/controller/controller.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { normalizeLocale, t } from '../i18n.js';
+import { readChatGptAuthMetadata } from '../auth/mirror.js';
 import { parseCommand } from './commands.js';
 import { buildAccessSettingsKeyboard, buildModelSettingsKeyboard, buildSetupPanelKeyboard, buildThreadListKeyboard, buildThreadsKeyboard, clampEffortToModel, formatAccessPresetLabel, formatActiveTurnMessageModeLabel, formatAccessSettingsMessage, formatApprovalPolicyLabel, formatCollaborationModeLabel, formatModelSettingsMessage, formatSandboxModeLabel, formatServiceTierStatusLabel, formatSetupPanelMessage, formatThreadContextSummary, formatThreadsMessage, formatWeixinAccessCopyPaste, formatWeixinModelCopyPaste, formatWeixinThreadsCopyPaste, formatWeixinWhereNavCopyPaste, formatWhereMessage, normalizeRequestedEffort, resolveCurrentModel, resolveActiveTurnMessageMode, resolveRequestedModel, } from './presentation.js';
 import { clampServiceTierToModel, resolveFastTierForModel } from './service_tier.js';
@@ -4510,9 +4511,15 @@ export class BridgeSessionCore {
     async listCodexAuthState() {
         const state = await listCodexAuthState(this.store.listDisabledCodexAuthCandidateNames(this.authRuntimeId()), this.resolveAuthDir());
         const snapshots = await this.readCodexAuthQuotaSnapshots();
+        const candidateAccountIds = await this.readCodexAuthCandidateAccountIds(state.candidates);
         state.candidates.forEach((candidate) => {
-            candidate.quota = snapshots[candidate.name] ?? null;
+            const candidateAccountId = candidateAccountIds.get(candidate.name) ?? null;
+            const snapshot = snapshots[candidate.name] ?? null;
+            candidate.quota = this.codexAuthQuotaSnapshotMatchesAccount(snapshot, candidateAccountId)
+                ? snapshot
+                : null;
         });
+        await this.applySharedCodexAuthQuotaSnapshots(state, candidateAccountIds);
         return state;
     }
     resolveAuthDir() {
@@ -4741,19 +4748,67 @@ export class BridgeSessionCore {
             return;
         }
         try {
+            const metadata = await readChatGptAuthMetadata(candidate.path);
             const snapshot = selectCodexRateLimitSnapshot(await this.app.readAccountRateLimits());
             if (!snapshot) {
                 return;
             }
-            const quota = authQuotaSnapshotFromRateLimit(snapshot);
+            const quota = authQuotaSnapshotFromRateLimit(snapshot, metadata?.accountId ?? null);
             candidate.quota = quota;
             this.authQuotaSnapshots[candidate.name] = quota;
+            if (metadata?.accountId) {
+                this.store.setCodexAuthQuotaSnapshot(this.authRuntimeId(), candidate.name, metadata.accountId, quota);
+            }
             await this.writeCodexAuthQuotaSnapshots();
+            await this.applySharedCodexAuthQuotaSnapshots(state);
         }
         catch (error) {
             this.logger.warn('codex.auth_quota_refresh_failed', { error: formatUserError(error) });
         }
     }
+    async applySharedCodexAuthQuotaSnapshots(state, candidateAccountIds) {
+        const accountIds = candidateAccountIds ?? await this.readCodexAuthCandidateAccountIds(state.candidates);
+        const uniqueAccountIds = [...new Set(accountIds.values())];
+        if (uniqueAccountIds.length === 0) {
+            return;
+        }
+        const snapshotsByAccount = new Map();
+        for (const record of this.store.listCodexAuthQuotaSnapshots(uniqueAccountIds)) {
+            if (!isFiniteCodexAuthQuotaSnapshotRecord(record)) {
+                continue;
+            }
+            snapshotsByAccount.set(record.accountId, mergeCodexAuthQuotaSnapshots(snapshotsByAccount.get(record.accountId) ?? null, codexAuthQuotaSnapshotFromRecord(record)));
+        }
+        for (const candidate of state.candidates) {
+            const accountId = accountIds.get(candidate.name);
+            if (!accountId) {
+                continue;
+            }
+            candidate.quota = mergeCodexAuthQuotaSnapshots(candidate.quota, snapshotsByAccount.get(accountId) ?? null);
+        }
+    }
+    async readCodexAuthCandidateAccountIds(candidates) {
+        const entries = await Promise.all(candidates.map(async (candidate) => {
+            const metadata = await readChatGptAuthMetadata(candidate.path);
+            return [candidate.name, metadata?.accountId ?? null];
+        }));
+        const accountIds = new Map();
+        for (const [name, accountId] of entries) {
+            if (accountId) {
+                accountIds.set(name, accountId);
+            }
+        }
+        return accountIds;
+    }
+    codexAuthQuotaSnapshotMatchesAccount(snapshot, accountId) {
+        if (!snapshot) {
+            return false;
+        }
+        if (!snapshot.accountId) {
+            return accountId === null;
+        }
+        return accountId !== null && snapshot.accountId === accountId;
+    }
     async readCodexAuthQuotaSnapshots() {
         if (this.authQuotaSnapshotsLoaded) {
             return this.authQuotaSnapshots;
@@ -7934,13 +7989,50 @@ function formatRemainingUsagePercent(usedPercent) {
     const remainingPercent = remainingUsagePercent(usedPercent);
     return remainingPercent === null ? '?' : formatUsagePercent(remainingPercent);
 }
-function authQuotaSnapshotFromRateLimit(snapshot) {
+function authQuotaSnapshotFromRateLimit(snapshot, accountId = null) {
     return {
         capturedAtMs: Date.now(),
+        accountId,
         primaryRemainingPercent: snapshot.primary ? remainingUsagePercent(snapshot.primary.usedPercent) : null,
         secondaryRemainingPercent: snapshot.secondary ? remainingUsagePercent(snapshot.secondary.usedPercent) : null,
     };
 }
+function codexAuthQuotaSnapshotFromRecord(record) {
+    return {
+        capturedAtMs: record.capturedAtMs,
+        accountId: record.accountId,
+        primaryRemainingPercent: record.primaryRemainingPercent,
+        secondaryRemainingPercent: record.secondaryRemainingPercent,
+    };
+}
+function mergeCodexAuthQuotaSnapshots(current, incoming) {
+    if (!current) {
+        return incoming;
+    }
+    if (!incoming) {
+        return current;
+    }
+    return {
+        capturedAtMs: Math.max(current.capturedAtMs, incoming.capturedAtMs),
+        accountId: current.accountId ?? incoming.accountId ?? null,
+        primaryRemainingPercent: fresherNullableQuotaValue(current.primaryRemainingPercent, current.capturedAtMs, incoming.primaryRemainingPercent, incoming.capturedAtMs),
+        secondaryRemainingPercent: fresherNullableQuotaValue(current.secondaryRemainingPercent, current.capturedAtMs, incoming.secondaryRemainingPercent, incoming.capturedAtMs),
+    };
+}
+function fresherNullableQuotaValue(currentValue, currentCapturedAtMs, incomingValue, incomingCapturedAtMs) {
+    if (currentValue === null) {
+        return incomingValue;
+    }
+    if (incomingValue === null) {
+        return currentValue;
+    }
+    return incomingCapturedAtMs >= currentCapturedAtMs ? incomingValue : currentValue;
+}
+function isFiniteCodexAuthQuotaSnapshotRecord(record) {
+    return Number.isFinite(record.capturedAtMs)
+        && isNullableFiniteNumber(record.primaryRemainingPercent)
+        && isNullableFiniteNumber(record.secondaryRemainingPercent);
+}
 function remainingUsagePercent(usedPercent) {
     if (!Number.isFinite(usedPercent)) {
         return null;
@@ -7962,6 +8054,7 @@ function isCodexAuthQuotaSnapshot(value) {
     const snapshot = value;
     return typeof snapshot.capturedAtMs === 'number'
         && Number.isFinite(snapshot.capturedAtMs)
+        && (snapshot.accountId === undefined || snapshot.accountId === null || typeof snapshot.accountId === 'string')
         && isNullableFiniteNumber(snapshot.primaryRemainingPercent)
         && isNullableFiniteNumber(snapshot.secondaryRemainingPercent);
 }

package/dist/store/database.d.ts

@@ -24,6 +24,15 @@ export interface PendingUserInputStoredRecord {
     submittedAt: number | null;
     resolvedAt: number | null;
 }
+export interface CodexAuthQuotaSnapshotRecord {
+    runtimeId: string;
+    candidateName: string;
+    accountId: string;
+    capturedAtMs: number;
+    primaryRemainingPercent: number | null;
+    secondaryRemainingPercent: number | null;
+    updatedAt: number;
+}
 export declare class BridgeStore {
     private db;
     constructor(dbPath: string);
@@ -77,5 +86,7 @@ export declare class BridgeStore {
     setWeixinContextToken(scopeId: string, contextToken: string): void;
     listDisabledCodexAuthCandidateNames(runtimeId?: string): Set<string>;
     setCodexAuthCandidateDisabled(name: string, disabled: boolean, runtimeId?: string): void;
+    setCodexAuthQuotaSnapshot(runtimeId: string, candidateName: string, accountId: string, snapshot: Pick<CodexAuthQuotaSnapshotRecord, 'capturedAtMs' | 'primaryRemainingPercent' | 'secondaryRemainingPercent'>): void;
+    listCodexAuthQuotaSnapshots(accountIds: string[]): CodexAuthQuotaSnapshotRecord[];
     private ensureColumn;
 }

package/dist/store/database.js

@@ -123,6 +123,18 @@ export class BridgeStore {
         updated_at INTEGER NOT NULL,
         PRIMARY KEY (runtime_id, name)
       );
+      CREATE TABLE IF NOT EXISTS codex_auth_quota_snapshots (
+        runtime_id TEXT NOT NULL,
+        candidate_name TEXT NOT NULL,
+        account_id TEXT NOT NULL,
+        captured_at_ms INTEGER NOT NULL,
+        primary_remaining_percent REAL,
+        secondary_remaining_percent REAL,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (runtime_id, candidate_name)
+      );
+      CREATE INDEX IF NOT EXISTS codex_auth_quota_snapshots_account_idx
+        ON codex_auth_quota_snapshots(account_id);
     `);
         this.ensureColumn('thread_cache', 'name', 'TEXT');
         this.ensureColumn('thread_cache', 'model_provider', 'TEXT');
@@ -509,6 +521,54 @@ export class BridgeStore {
       ON CONFLICT(name) DO UPDATE SET disabled = excluded.disabled, updated_at = excluded.updated_at
     `).run(name, disabled ? 1 : 0, Date.now());
     }
+    setCodexAuthQuotaSnapshot(runtimeId, candidateName, accountId, snapshot) {
+        this.db.prepare(`
+      INSERT INTO codex_auth_quota_snapshots (
+        runtime_id,
+        candidate_name,
+        account_id,
+        captured_at_ms,
+        primary_remaining_percent,
+        secondary_remaining_percent,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(runtime_id, candidate_name) DO UPDATE SET
+        account_id = excluded.account_id,
+        captured_at_ms = excluded.captured_at_ms,
+        primary_remaining_percent = excluded.primary_remaining_percent,
+        secondary_remaining_percent = excluded.secondary_remaining_percent,
+        updated_at = excluded.updated_at
+    `).run(runtimeId, candidateName, accountId, snapshot.capturedAtMs, snapshot.primaryRemainingPercent, snapshot.secondaryRemainingPercent, Date.now());
+    }
+    listCodexAuthQuotaSnapshots(accountIds) {
+        const uniqueAccountIds = [...new Set(accountIds.filter(Boolean))];
+        if (uniqueAccountIds.length === 0) {
+            return [];
+        }
+        const placeholders = uniqueAccountIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+      SELECT
+        runtime_id,
+        candidate_name,
+        account_id,
+        captured_at_ms,
+        primary_remaining_percent,
+        secondary_remaining_percent,
+        updated_at
+      FROM codex_auth_quota_snapshots
+      WHERE account_id IN (${placeholders})
+    `).all(...uniqueAccountIds);
+        return rows.map(row => ({
+            runtimeId: String(row.runtime_id),
+            candidateName: String(row.candidate_name),
+            accountId: String(row.account_id),
+            capturedAtMs: Number(row.captured_at_ms),
+            primaryRemainingPercent: nullableNumber(row.primary_remaining_percent),
+            secondaryRemainingPercent: nullableNumber(row.secondary_remaining_percent),
+            updatedAt: Number(row.updated_at),
+        }));
+    }
     ensureColumn(table, column, definition) {
         const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
         if (columns.some(entry => entry.name === column)) {
@@ -517,6 +577,13 @@ export class BridgeStore {
         this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
     }
 }
+function nullableNumber(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    const numberValue = Number(value);
+    return Number.isFinite(numberValue) ? numberValue : null;
+}
 function normalizeCollaborationMode(value) {
     return value === 'default' || value === 'plan' ? value : null;
 }

package/docs/user-manual.md

@@ -389,7 +389,7 @@ If the login is cancelled or fails, FoxClaw tries to restore the previous auth t
 
 ### 6.3 The `/auth` Panel
 
-`/auth` lists candidate accounts, the current account, and the auth directory. It also provides buttons for switching, disabling, login, and reload. In multi-bot mode the panel names the `@botname` runtime being managed, because private chats, groups, and topics on one bot share that bot's current auth. The `5h|7d` numbers before each filename are the last recorded remaining percentages for the two quota windows; the current auth is refreshed when the panel opens, while other candidates are not switched merely to query quota.
+`/auth` lists candidate accounts, the current account, and the auth directory. It also provides buttons for switching, disabling, login, and reload. In multi-bot mode the panel names the `@botname` runtime being managed, because private chats, groups, and topics on one bot share that bot's current auth. The `5h|7d` numbers before each filename are the last recorded remaining percentages for the two quota windows; the current auth is refreshed when the panel opens, while other candidates are not switched merely to query quota. When multiple bot runtimes have recently used the same ChatGPT account, FoxClaw combines their cached quota snapshots by verified account ID, so one bot's `/auth` panel can show quota information learned by another bot without mixing different accounts.
 
 Approximation:
 

package/docs/zh/user-manual.md

@@ -389,7 +389,7 @@ cp -L ~/.codex/auth.json ~/.codex/auth.json_personal
 
 ### 6.3 `/auth` 面板
 
-`/auth` 会列出候选账号、当前账号和 auth 目录，并提供按钮切换、禁用、登录和重载。多 bot 模式中，面板顶部还会显示当前正在管理的 `@botname`，因为该 bot 内的私聊、群聊和话题共享同一个当前 auth。每个候选名前的 `5h|7d` 数字表示上次记录到的两个额度窗口剩余百分比；当前 auth 会在打开面板时刷新，其他候选不会为了查询额度被自动切换。
+`/auth` 会列出候选账号、当前账号和 auth 目录，并提供按钮切换、禁用、登录和重载。多 bot 模式中，面板顶部还会显示当前正在管理的 `@botname`，因为该 bot 内的私聊、群聊和话题共享同一个当前 auth。每个候选名前的 `5h|7d` 数字表示上次记录到的两个额度窗口剩余百分比；当前 auth 会在打开面板时刷新，其他候选不会为了查询额度被自动切换。如果多个 bot runtime 最近使用过同一个 ChatGPT 账号，FoxClaw 会按已验证的账号 ID 合并它们缓存到的额度快照，因此一个 bot 的 `/auth` 面板可以显示另一个 bot 掌握到的额度信息，同时不会把不同账号混在一起。
 
 示意：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",

package/skills/foxclaw/SKILL.md

@@ -146,7 +146,7 @@ After either bootstrap path:
    - the bot is an admin in the group
    - the configured `TG_ALLOWED_CHAT_ID` and `TG_ALLOWED_TOPIC_ID` match the target group/topic
 5. If group or topic mode is enabled, also verify that private chat still responds for the configured `TG_ALLOWED_USER_ID`.
-6. With multiple bots, send `/status` and `/auth` privately to each bot; verify the status lists each app-server and the auth panel names the intended bot runtime.
+6. With multiple bots, send `/status` and `/auth` privately to each bot; verify the status lists each app-server, the auth panel names the intended bot runtime, and `/auth` quota snapshots are combined only for matching ChatGPT account IDs.
 
 ## First Telegram Message Check