@foxden-app/foxclaw 0.12.0 → 0.13.0

package/dist/controller/auth_quota_service.d.ts

@@ -0,0 +1,27 @@
+import { CodexAuthQuotaSnapshot, CodexAuthCandidate, CodexAuthState, CodexAuthQuotaIdentity } from './state_types.js';
+import { type ChatGptAuthMetadata } from '../auth/mirror.js';
+import type { CodexRateLimitSnapshot } from '../types.js';
+import type { AppConfig } from '../config.js';
+import type { BridgeStore } from '../store/database.js';
+import type { Logger } from '../logger.js';
+import type { CodexAppClient } from '../codex_app/client.js';
+export declare class CodexAuthQuotaService {
+    private readonly config;
+    private readonly store;
+    private readonly logger;
+    private readonly app;
+    private readonly syncCodexAuthCandidate;
+    private authQuotaSnapshots;
+    private authQuotaSnapshotsLoaded;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, app: Pick<CodexAppClient, 'readAccountRateLimits'>, syncCodexAuthCandidate: (name: string) => Promise<void>);
+    refreshCurrentCodexAuthQuota(state: CodexAuthState): Promise<void>;
+    applySharedCodexAuthQuotaSnapshots(state: CodexAuthState, candidateQuotaIdentities?: Map<string, CodexAuthQuotaIdentity>): Promise<void>;
+    recordCodexAuthQuotaSnapshot(candidateName: string, metadata: ChatGptAuthMetadata | null, snapshot: CodexRateLimitSnapshot): Promise<void>;
+    readCodexAuthCandidateQuotaIdentities(candidates: CodexAuthCandidate[]): Promise<Map<string, CodexAuthQuotaIdentity>>;
+    codexAuthQuotaSnapshotMatchesIdentity(snapshot: CodexAuthQuotaSnapshot | null, identity: CodexAuthQuotaIdentity | null): snapshot is CodexAuthQuotaSnapshot;
+    readCodexAuthQuotaSnapshots(): Promise<Record<string, CodexAuthQuotaSnapshot>>;
+    writeCodexAuthQuotaSnapshots(): Promise<void>;
+    codexAuthQuotaSnapshotPath(): string;
+    private authRuntimeId;
+    private runtimeSnapshotFilename;
+}

package/dist/controller/auth_quota_service.js

@@ -0,0 +1,151 @@
+import { CODEX_AUTH_QUOTA_SNAPSHOT_FILENAME, } from './state_types.js';
+import { chatGptAuthMetadataMatchesCandidateName, readChatGptAuthRecord, readChatGptAuthMetadata, } from '../auth/mirror.js';
+import { selectCodexRateLimitSnapshot, authQuotaSnapshotFromRateLimit, isFiniteCodexAuthQuotaSnapshotRecord, mergeCodexAuthQuotaSnapshots, codexAuthQuotaSnapshotFromRecord, isCodexAuthQuotaSnapshot, normalizeCodexAuthQuotaSnapshot, } from './auth_presentation.js';
+import { formatUserError } from './shared_helpers.js';
+import { isCodexApiKeyAuthCandidate } from './auth_files.js';
+import { readAccessTokenExpiresAtMs } from '../auth/cross_node_sync.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class CodexAuthQuotaService {
+    config;
+    store;
+    logger;
+    app;
+    syncCodexAuthCandidate;
+    authQuotaSnapshots = {};
+    authQuotaSnapshotsLoaded = false;
+    constructor(config, store, logger, app, syncCodexAuthCandidate) {
+        this.config = config;
+        this.store = store;
+        this.logger = logger;
+        this.app = app;
+        this.syncCodexAuthCandidate = syncCodexAuthCandidate;
+    }
+    async refreshCurrentCodexAuthQuota(state) {
+        const candidate = state.candidates.find(entry => entry.isCurrent);
+        if (!candidate) {
+            return;
+        }
+        if (candidate.state === 'needs_repair') {
+            return;
+        }
+        try {
+            const metadata = await readChatGptAuthMetadata(candidate.path);
+            if (!metadata || !chatGptAuthMetadataMatchesCandidateName(candidate.name, metadata)) {
+                return;
+            }
+            const snapshot = selectCodexRateLimitSnapshot(await this.app.readAccountRateLimits());
+            if (!snapshot) {
+                return;
+            }
+            const quota = authQuotaSnapshotFromRateLimit(snapshot, metadata?.accountId ?? null, metadata?.quotaIdentityId ?? null);
+            candidate.quota = quota;
+            await this.recordCodexAuthQuotaSnapshot(candidate.name, metadata, snapshot);
+            await this.applySharedCodexAuthQuotaSnapshots(state);
+            await this.syncCodexAuthCandidate(candidate.name);
+        }
+        catch (error) {
+            this.logger.warn('codex.auth_quota_refresh_failed', { error: formatUserError(error) });
+        }
+    }
+    async applySharedCodexAuthQuotaSnapshots(state, candidateQuotaIdentities) {
+        const quotaIdentities = candidateQuotaIdentities ?? await this.readCodexAuthCandidateQuotaIdentities(state.candidates);
+        const uniqueQuotaIdentityIds = [...new Set([...quotaIdentities.values()].map(identity => identity.quotaIdentityId))];
+        if (uniqueQuotaIdentityIds.length === 0) {
+            return;
+        }
+        const snapshotsByIdentity = new Map();
+        for (const record of this.store.listCodexAuthQuotaSnapshots(uniqueQuotaIdentityIds)) {
+            if (!isFiniteCodexAuthQuotaSnapshotRecord(record)) {
+                continue;
+            }
+            snapshotsByIdentity.set(record.quotaIdentityId, mergeCodexAuthQuotaSnapshots(snapshotsByIdentity.get(record.quotaIdentityId) ?? null, codexAuthQuotaSnapshotFromRecord(record)));
+        }
+        for (const candidate of state.candidates) {
+            const quotaIdentity = quotaIdentities.get(candidate.name);
+            if (!quotaIdentity) {
+                continue;
+            }
+            candidate.quota = mergeCodexAuthQuotaSnapshots(candidate.quota, snapshotsByIdentity.get(quotaIdentity.quotaIdentityId) ?? null);
+        }
+    }
+    async recordCodexAuthQuotaSnapshot(candidateName, metadata, snapshot) {
+        const quota = authQuotaSnapshotFromRateLimit(snapshot, metadata?.accountId ?? null, metadata?.quotaIdentityId ?? null);
+        this.authQuotaSnapshots[candidateName] = quota;
+        if (metadata) {
+            this.store.setCodexAuthQuotaSnapshot(this.authRuntimeId(), candidateName, metadata.accountId, metadata.quotaIdentityId, quota);
+        }
+        await this.writeCodexAuthQuotaSnapshots();
+    }
+    async readCodexAuthCandidateQuotaIdentities(candidates) {
+        const entries = await Promise.all(candidates.map(async (candidate) => {
+            const record = await readChatGptAuthRecord(candidate.path);
+            const metadataMatchesName = record
+                ? chatGptAuthMetadataMatchesCandidateName(candidate.name, record)
+                : false;
+            candidate.credentialKind = record && metadataMatchesName
+                ? 'chatgpt'
+                : await isCodexApiKeyAuthCandidate(candidate.path)
+                    ? 'api-key'
+                    : 'invalid';
+            candidate.credentialLastRefreshMs = record && metadataMatchesName ? record.lastRefreshMs : null;
+            candidate.credentialExpiresAtMs = record && metadataMatchesName ? readAccessTokenExpiresAtMs(record.raw) : null;
+            return [candidate.name, record && metadataMatchesName ? {
+                    accountId: record.accountId,
+                    quotaIdentityId: record.quotaIdentityId,
+                } : null];
+        }));
+        const quotaIdentities = new Map();
+        for (const [name, quotaIdentity] of entries) {
+            if (quotaIdentity) {
+                quotaIdentities.set(name, quotaIdentity);
+            }
+        }
+        return quotaIdentities;
+    }
+    codexAuthQuotaSnapshotMatchesIdentity(snapshot, identity) {
+        if (!snapshot) {
+            return false;
+        }
+        const snapshotIdentityId = snapshot.quotaIdentityId ?? snapshot.accountId ?? null;
+        if (!snapshotIdentityId) {
+            return identity === null;
+        }
+        return identity !== null && snapshotIdentityId === identity.quotaIdentityId;
+    }
+    async readCodexAuthQuotaSnapshots() {
+        if (this.authQuotaSnapshotsLoaded) {
+            return this.authQuotaSnapshots;
+        }
+        this.authQuotaSnapshotsLoaded = true;
+        try {
+            const parsed = JSON.parse(await fs.readFile(this.codexAuthQuotaSnapshotPath(), 'utf8'));
+            if (parsed && typeof parsed === 'object') {
+                for (const [name, value] of Object.entries(parsed)) {
+                    if (isCodexAuthQuotaSnapshot(value)) {
+                        this.authQuotaSnapshots[name] = normalizeCodexAuthQuotaSnapshot(value);
+                    }
+                }
+            }
+        }
+        catch {
+            // A missing or invalid historical cache should not block the auth panel.
+        }
+        return this.authQuotaSnapshots;
+    }
+    async writeCodexAuthQuotaSnapshots() {
+        const snapshotPath = this.codexAuthQuotaSnapshotPath();
+        await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
+        const temporaryPath = `${snapshotPath}.${process.pid}.tmp`;
+        await fs.writeFile(temporaryPath, `${JSON.stringify(this.authQuotaSnapshots, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        await fs.rename(temporaryPath, snapshotPath);
+    }
+    codexAuthQuotaSnapshotPath() {
+        return path.join(path.dirname(this.config.statusPath), this.runtimeSnapshotFilename(CODEX_AUTH_QUOTA_SNAPSHOT_FILENAME));
+    }
+    authRuntimeId() { return this.config.tgScopeBotId ?? 'default'; }
+    runtimeSnapshotFilename(filename) { return this.config.tgScopeBotId ? filename.replace(/\.json$/, `-${this.config.tgScopeBotId}.json`) : filename; }
+}

package/dist/controller/controller.d.ts

@@ -1,55 +1,13 @@
-import type { AppConfig } from '../config.js';
-import type { Logger } from '../logger.js';
-import type { BridgeStore } from '../store/database.js';
-import { type AuthSyncClusterAuditResult } from '../auth/cross_node_sync.js';
-import type { AppLocale, RuntimeStatus } from '../types.js';
 import type { TelegramGateway, TelegramTextEvent, TelegramCallbackEvent } from '../telegram/gateway.js';
 import { BridgeMessagingRouter } from '../channels/bridge_messaging_router.js';
+import type { AppConfig } from '../config.js';
+import type { BridgeStore } from '../store/database.js';
+import type { Logger } from '../logger.js';
 import type { CodexAppClient } from '../codex_app/client.js';
-import type { SelfUpdateRuntime, SelfUpdateStatus } from '../update.js';
-type AuthProactiveRefreshStatus = NonNullable<RuntimeStatus['authProactiveRefresh']>;
-export interface CoreCoordinator {
-    canSelfUpdate?: () => boolean;
-    authCandidateUpdated?: (runtimeId: string, candidateName: string) => Promise<void>;
-    authCandidateDeleted?: (runtimeId: string, candidateName: string, reason?: string | null) => Promise<void>;
-    recoverAuthCandidate?: (runtimeId: string, candidateName: string, options?: {
-        crossNode?: boolean;
-    }) => Promise<boolean>;
-    acquireAuthRefreshLease?: (reason: string) => Promise<{
-        ok: boolean;
-        leaseId: string | null;
-        reason?: string | null;
-    }>;
-    releaseAuthRefreshLease?: (leaseId: string | null) => Promise<void>;
-    getAuthSyncStatus?: () => RuntimeStatus['authSync'];
-    authSyncSafeAll?: () => Promise<{
-        localSynced: number;
-        localSkipped: number;
-        sent: number;
-        skipped: number;
-    }>;
-    authSyncPushAll?: () => Promise<{
-        sent: number;
-        skipped: number;
-    }>;
-    authSyncTest?: () => Promise<{
-        sent: number;
-        replied: number;
-        missing: string[];
-    }>;
-    authSyncAudit?: () => Promise<AuthSyncClusterAuditResult | null>;
-    statusUpdated?: (status: RuntimeStatus) => void;
-    getServiceStatus?: () => Promise<{
-        currentVersion?: string;
-        bots: NonNullable<RuntimeStatus['bots']>;
-        weixinRuntime?: RuntimeStatus['weixinRuntime'];
-        authMirror?: RuntimeStatus['authMirror'];
-        authSync?: RuntimeStatus['authSync'];
-        authProactiveRefresh?: AuthProactiveRefreshStatus | null;
-        lastUpdate?: SelfUpdateStatus | null;
-    }>;
-    selfUpdateCompleted?: (status: SelfUpdateStatus) => void;
-}
+import type { SelfUpdateRuntime } from '../update.js';
+import type { AppLocale, RuntimeStatus } from '../types.js';
+import { CoreCoordinator } from './state_types.js';
+export type { CoreCoordinator } from './state_types.js';
 export declare class BridgeSessionCore {
     private readonly config;
     private readonly store;
@@ -59,6 +17,14 @@ export declare class BridgeSessionCore {
     private readonly selfUpdater;
     private readonly coordinator;
     private readonly ownsTelegramRuntime;
+    private readonly listeners;
+    private readonly controlOperations;
+    private controlPlaneStarted;
+    private recoverExecution;
+    private executionHost;
+    private readonly localUsage;
+    private readonly authQuota;
+    private readonly nativePanels;
     private activeTurns;
     private activeTurnsByTurnId;
     private observedThreadWatchers;
@@ -82,11 +48,6 @@ export declare class BridgeSessionCore {
     private externalAuthValidationInProgress;
     private turnStartInProgress;
     private authRotationFailedTargets;
-    private localUsageCache;
-    private localUsageCacheLoaded;
-    private localUsageRefresh;
-    private authQuotaSnapshots;
-    private authQuotaSnapshotsLoaded;
     private lastRemoteControlStatus;
     private pendingThreadRenames;
     private pendingThreadNewCwds;
@@ -113,6 +74,14 @@ export declare class BridgeSessionCore {
     private threadListPresentationState;
     private readonly messaging;
     constructor(config: AppConfig, store: BridgeStore, logger: Logger, bot: TelegramGateway, app: CodexAppClient, outbound: BridgeMessagingRouter, selfUpdater?: SelfUpdateRuntime | null, coordinator?: CoreCoordinator | null, ownsTelegramRuntime?: boolean);
+    attachExecutionHost(host: {
+        ownsScope(scopeId: string): boolean;
+        hasExecutingTasks(): boolean;
+    }): void;
+    startControlPlane(): Promise<void>;
+    stopControlPlane(): Promise<void>;
+    getPendingApprovalCount(): number;
+    dispatchBackendCommand(event: TelegramTextEvent): Promise<void>;
     /** Wire Telegram inbound events. Call before {@link startCodexApp}. */
     registerTelegramInboundHandlers(): void;
     /**
@@ -122,12 +91,16 @@ export declare class BridgeSessionCore {
     dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
     hasPendingInteraction(scopeId: string): boolean;
     /** Start Codex app-server transport and attach RPC listeners. */
-    startCodexApp(): Promise<void>;
+    startCodexApp(options?: {
+        recoverExecution?: boolean;
+    }): Promise<void>;
     /** Begin Telegram Bot API long-polling after handlers and Codex are ready. */
     startTelegramPolling(): Promise<void>;
     /** Telegram-only default startup (single channel). */
     start(): Promise<void>;
-    stop(): Promise<void>;
+    stop(options?: {
+        keepTransports?: boolean;
+    }): Promise<void>;
     getRuntimeStatus(): RuntimeStatus;
     private handleText;
     private handleCommand;
@@ -139,6 +112,7 @@ export declare class BridgeSessionCore {
     private handleThreadRenameIndexCommand;
     handleCallback(event: TelegramCallbackEvent): Promise<void>;
     private handleApprovalTextCommand;
+    private trackControlOperation;
     private handleNotification;
     private handleServerRequest;
     private sendApprovalRequestToThreadScopes;