@foxden-app/foxclaw 0.10.0 → 0.11.1

package/dist/controller/controller.js

@@ -131,6 +131,7 @@ export class BridgeSessionCore {
     pendingForceTakeovers = new Map();
     pendingLoginScopesById = new Map();
     pendingAuthAddsByLoginId = new Map();
+    authLoginRecoveryTimers = new Map();
     latestTurnDiffs = new Map();
     threadTokenUsageAlerts = new Map();
     pendingAuthChoiceLists = new Map();
@@ -298,6 +299,9 @@ export class BridgeSessionCore {
         this.pendingLoginsByScope.clear();
         this.pendingLoginScopesById.clear();
         this.pendingAuthAddsByLoginId.clear();
+        for (const timer of this.authLoginRecoveryTimers.values())
+            clearTimeout(timer);
+        this.authLoginRecoveryTimers.clear();
         this.latestTurnDiffs.clear();
         this.threadTokenUsageAlerts.clear();
         this.pendingAuthChoiceLists.clear();
@@ -1812,6 +1816,15 @@ export class BridgeSessionCore {
             return;
         }
         const pendingAuthAdd = loginId ? this.pendingAuthAddsByLoginId.get(loginId) ?? null : null;
+        if (params?.success && pendingAuthAdd)
+            await this.reconcileAuthLoginCredential(pendingAuthAdd);
+        // A recovery check and the server notification may complete concurrently.
+        if (this.pendingLoginScopesById.get(loginId) !== scopeId)
+            return;
+        const timer = this.authLoginRecoveryTimers.get(loginId);
+        if (timer)
+            clearTimeout(timer);
+        this.authLoginRecoveryTimers.delete(loginId);
         this.pendingLoginScopesById.delete(loginId);
         if (this.pendingLoginsByScope.get(scopeId) === loginId) {
             this.pendingLoginsByScope.delete(scopeId);
@@ -1886,6 +1899,62 @@ export class BridgeSessionCore {
         const state = await this.listCodexAuthState();
         await this.restoreAuthAfterAddFailure(state.authDir, state.authPath, record.previousTargetPath);
     }
+    scheduleAuthLoginRecovery(loginId) {
+        const timer = setTimeout(() => {
+            this.authLoginRecoveryTimers.delete(loginId);
+            void this.recoverAuthLogin(loginId).catch(error => {
+                this.logger.warn('codex.auth_login_recovery_failed', { error: toErrorMeta(error) });
+            }).finally(() => {
+                if (!this.stopping && this.pendingAuthAddsByLoginId.has(loginId)) {
+                    this.scheduleAuthLoginRecovery(loginId);
+                }
+            });
+        }, 5_000);
+        timer.unref();
+        this.authLoginRecoveryTimers.set(loginId, timer);
+    }
+    async recoverAuthLogin(loginId) {
+        const record = this.pendingAuthAddsByLoginId.get(loginId);
+        if (!record)
+            return;
+        if (Date.now() - record.createdAt >= 15 * 60_000) {
+            await this.handleAccountLoginCompleted({ loginId, success: false, error: 'Device login timed out; completion was not confirmed.' });
+            return;
+        }
+        await this.reconcileAuthLoginCredential(record);
+        const metadata = await readChatGptAuthMetadata(record.path);
+        if (!metadata || metadata.lastRefreshMs < record.createdAt
+            || !chatGptAuthMetadataMatchesCandidateName(record.name, metadata))
+            return;
+        const account = await this.app.readAccount(true);
+        const limits = await this.app.readAccountRateLimits();
+        if (!account || !limits || !selectCodexRateLimitSnapshot(limits)
+            || (metadata.email && account.email !== metadata.email))
+            return;
+        if (!this.pendingAuthAddsByLoginId.has(loginId))
+            return;
+        this.logger.info('codex.auth_login_recovered', { candidate: record.name });
+        await this.handleAccountLoginCompleted({ loginId, success: true });
+    }
+    async reconcileAuthLoginCredential(record) {
+        const authPath = path.join(this.resolveAuthDir(), 'auth.json');
+        const [target, current] = await Promise.all([
+            readChatGptAuthRecord(record.path), readChatGptAuthRecord(authPath),
+        ]);
+        // Codex can replace auth.json atomically, breaking our candidate symlink.
+        // Only adopt a newly written credential for the same account identity.
+        if (target && current && current.lastRefreshMs >= record.createdAt
+            && current.quotaIdentityId === target.quotaIdentityId
+            && current.lastRefreshMs > target.lastRefreshMs
+            && chatGptAuthMetadataMatchesCandidateName(record.name, current)) {
+            if (!this.pendingAuthAddsByLoginId.has(record.loginId))
+                return;
+            const temporary = `${record.path}.${process.pid}.tmp`;
+            await fs.writeFile(temporary, current.raw, { mode: 0o600 });
+            await fs.rename(temporary, record.path);
+            await pointCodexAuthAtTarget(this.resolveAuthDir(), authPath, record.path);
+        }
+    }
     async restoreAuthAfterAddFailure(authDir, authPath, previousTargetPath) {
         if (previousTargetPath) {
             await pointCodexAuthAtTarget(authDir, authPath, previousTargetPath);
@@ -5548,6 +5617,7 @@ export class BridgeSessionCore {
                 mode: 'add',
                 createdAt: Date.now(),
             });
+            this.scheduleAuthLoginRecovery(login.loginId);
             await this.sendMessage(scopeId, [
                 t(locale, 'auth_add_started', { value: candidateName }),
                 t(locale, 'login_device_prereq'),
@@ -5591,6 +5661,7 @@ export class BridgeSessionCore {
                 mode: 'repair',
                 createdAt: Date.now(),
             });
+            this.scheduleAuthLoginRecovery(login.loginId);
             await this.sendMessage(scopeId, [
                 t(locale, 'auth_repair_started', { value: target.name }),
                 t(locale, 'login_device_prereq'),

package/dist/core/engine_spi.d.ts

@@ -47,6 +47,7 @@ export interface EngineTurnExecution {
     on(event: 'result', listener: (result: EngineTurnResult) => void): void;
     on(event: 'error', listener: (error: Error) => void): void;
     on(event: 'exit', listener: (code: number | null) => void): void;
+    on(event: 'conversation', listener: (conversationId: string) => void): void;
 }
 export interface EngineTurnErrorContext {
     error: string;

package/dist/core/orchestrator.d.ts

@@ -79,9 +79,14 @@ export declare class UnifiedChannelOrchestrator {
     hasActiveTurn(scopeId: string): boolean;
     sendMessage(scopeId: string, text: string, keyboard?: InlineKeyboard): Promise<number>;
     editMessage(scopeId: string, messageId: number, text: string, keyboard?: InlineKeyboard): Promise<void>;
+    private safeDeliverChunks;
+    private safeDeliverMessage;
     handleText(event: TelegramTextEvent): Promise<void>;
     handleCallback(event: TelegramCallbackEvent): Promise<void>;
-    startPromptTurn(event: TelegramTextEvent, prompt: string, locale: AppLocale): Promise<void>;
+    startPromptTurn(event: TelegramTextEvent, prompt: string, locale: AppLocale, options?: {
+        reuseMessageId?: number | undefined;
+        forcedThreadId?: string | undefined;
+    }): Promise<void>;
     private enqueuePromptTurn;
     private drainNextQueuedTurn;
     private executeTurn;