@jsonstudio/rcc 0.90.876 → 0.90.1270

package/dist/providers/core/config/camoufox-launcher.js

@@ -9,6 +9,11 @@ import { logOAuthDebug } from '../../auth/oauth-logger.js';
 import { CAMO_CLICK_TARGETS, clickCamoGoogleAccountByHint, hasCamoGoogleSignInPrompt, clickCamoGoogleSignInBySelector, clickCamoTarget, ensureCamoProfile, getActiveCamoPageUrl, gotoCamoUrl, startCamoSession, setDefaultCamoProfile } from './camoufox-actions.js';
 const activeLaunchers = new Set();
 let lastCamoufoxLaunchFailureReason = null;
+function logCamoufoxLauncherNonBlocking(stage, error, details = {}) {
+    const reason = error instanceof Error ? (error.stack || `${error.name}: ${error.message}`) : String(error);
+    const detailSuffix = Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+    console.warn(`[camoufox-launcher] ${stage} failed (non-blocking): ${reason}${detailSuffix}`);
+}
 function setCamoufoxLaunchFailureReason(reason) {
     lastCamoufoxLaunchFailureReason = reason && reason.trim().length > 0 ? reason.trim() : null;
 }
@@ -33,8 +38,8 @@ function terminateLauncher(handle) {
             try {
                 child.kill('SIGKILL');
             }
-            catch {
-                // ignore escalation failures
+            catch (error) {
+                logCamoufoxLauncherNonBlocking('terminate_launcher.sigkill', error);
             }
             resolve();
         }, 2000);
@@ -50,7 +55,8 @@ function terminateLauncher(handle) {
             }
             child.kill('SIGTERM');
         }
-        catch {
+        catch (error) {
+            logCamoufoxLauncherNonBlocking('terminate_launcher.sigterm', error);
             clearTimeout(timer);
             resolve();
         }
@@ -195,7 +201,8 @@ function runCamoCliCheck() {
         }
         return result.status === 0;
     }
-    catch {
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('run_camo_cli_check.spawn', error);
         return false;
     }
 }
@@ -208,7 +215,7 @@ export function shouldRepairCamoufoxFingerprintForOAuth(providerFamily, navigato
     if (platform !== 'win32') {
         return false;
     }
-    return family === 'gemini' || family === 'iflow' || family === 'qwen';
+    return family === 'gemini' || family === 'qwen';
 }
 export function sanitizeCamouConfigForOAuth(provider, fingerprintEnv) {
     const env = { ...(fingerprintEnv || {}) };
@@ -229,15 +236,6 @@ export function sanitizeCamouConfigForOAuth(provider, fingerprintEnv) {
     if (!parsed) {
         return env;
     }
-    const family = getProviderFamily(provider);
-    if (family === 'iflow') {
-        // iFlow OAuth 页面在部分指纹下会因 header 覆盖导致页面乱码；OAuth 场景统一移除该覆盖。
-        delete parsed['headers.Accept-Encoding'];
-        if (Object.prototype.hasOwnProperty.call(parsed, 'timezone')) {
-            delete parsed.timezone;
-        }
-        env.CAMOU_CONFIG_1 = JSON.stringify(parsed);
-    }
     return env;
 }
 function buildProfileId(provider, alias) {
@@ -256,9 +254,60 @@ function buildProfileId(provider, alias) {
     const prefixed = `rc-${normalized}`;
     return prefixed.length > 64 ? prefixed.slice(0, 64) : prefixed;
 }
+const DISABLED_CAMOUFOX_AUTO_MODE = new Set(['0', 'false', 'no', 'off', 'manual', 'none']);
+const REMOVED_CAMOUFOX_AUTO_MODE = new Set(['qwen']);
+function resolveDefaultCamoufoxAutoMode(provider) {
+    const family = getProviderFamily(provider);
+    if (family === 'antigravity') {
+        return 'antigravity';
+    }
+    if (family === 'gemini') {
+        return 'gemini';
+    }
+    return '';
+}
+function resolveEffectiveCamoufoxAutoMode(provider) {
+    const raw = String(process.env.ROUTECODEX_CAMOUFOX_AUTO_MODE || '').trim().toLowerCase();
+    if (raw) {
+        if (DISABLED_CAMOUFOX_AUTO_MODE.has(raw) || REMOVED_CAMOUFOX_AUTO_MODE.has(raw)) {
+            return '';
+        }
+        return raw;
+    }
+    return resolveDefaultCamoufoxAutoMode(provider);
+}
 function getProfileRoot() {
     return resolveRccCamoufoxProfilesDir();
 }
+function profileDirExists(profileId) {
+    const normalized = String(profileId || '').trim();
+    if (!normalized) {
+        return false;
+    }
+    try {
+        return fs.existsSync(path.join(getProfileRoot(), normalized));
+    }
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('profile_dir_exists.stat', error, { profileId: normalized });
+        return false;
+    }
+}
+function resolvePreferredOAuthProfileId(provider, alias, explicitProfileId) {
+    const explicit = String(explicitProfileId || '').trim();
+    if (explicit) {
+        return explicit;
+    }
+    const derived = buildProfileId(provider, alias);
+    const family = getProviderFamily(provider);
+    const normalizedAlias = String(alias || '').trim().toLowerCase();
+    if (family === 'qwen' && normalizedAlias) {
+        const sharedAuthProfileId = buildProfileId('auth', normalizedAlias);
+        if (profileDirExists(sharedAuthProfileId)) {
+            return sharedAuthProfileId;
+        }
+    }
+    return derived;
+}
 export function getCamoufoxProfileDir(provider, alias) {
     const profileId = buildProfileId(provider, alias);
     const root = getProfileRoot();
@@ -269,8 +318,8 @@ export function ensureCamoufoxProfileDir(provider, alias) {
     try {
         fs.mkdirSync(dir, { recursive: true });
     }
-    catch {
-        // directory creation failures are non-fatal for OAuth; browser can still run with its own defaults
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('ensure_profile_dir.mkdir', error, { dir });
     }
     return dir;
 }
@@ -291,8 +340,10 @@ function resolveCamoufoxScriptPath() {
                 return resolved;
             }
         }
-        catch {
-            // ignore resolution errors for explicit override
+        catch (error) {
+            logCamoufoxLauncherNonBlocking('resolve_script_path.override_probe', error, {
+                configured: expanded
+            });
         }
     }
     // Fallback: use built-in launcher script shipped with routecodex
@@ -313,8 +364,8 @@ function resolveCamoufoxScriptPath() {
             }
         }
     }
-    catch {
-        // ignore
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('resolve_script_path.builtin_probe', error);
     }
     return null;
 }
@@ -358,7 +409,10 @@ function runPythonWithLaunchers(buildArgs, options) {
             }
             return { launcher, result };
         }
-        catch {
+        catch (error) {
+            logCamoufoxLauncherNonBlocking('run_python_with_launchers.spawn_sync', error, {
+                command: launcher.command
+            });
             continue;
         }
     }
@@ -407,8 +461,8 @@ function resolveGenFingerprintScriptPath() {
             }
         }
     }
-    catch {
-        // ignore
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('resolve_gen_fingerprint_script_path', error);
     }
     return null;
 }
@@ -468,8 +522,8 @@ function loadFingerprintEnv(profileId) {
             return env;
         }
     }
-    catch {
-        // Missing or invalid file – caller will re-generate.
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('load_fingerprint_env.read_or_parse', error, { fpPath });
     }
     return null;
 }
@@ -506,8 +560,10 @@ function writeMinimalFingerprintEnv(profileId, osPolicy) {
             const payload = { env };
             await fsAsync.writeFile(fpPath, JSON.stringify(payload), { encoding: 'utf-8' });
         }
-        catch {
-            // best-effort
+        catch (error) {
+            logCamoufoxLauncherNonBlocking('write_minimal_fingerprint_env.persist', error, {
+                path: fpPath
+            });
         }
     })();
     return env;
@@ -529,8 +585,10 @@ function ensureFingerprintEnv(profileId, provider, alias) {
     try {
         fs.mkdirSync(fpRoot, { recursive: true });
     }
-    catch {
-        // non-fatal
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('ensure_fingerprint_env.mkdir', error, {
+            root: fpRoot
+        });
     }
     const scriptArgs = ['--profile-id', profileId, '--output-dir', fpRoot];
     if (osPolicy) {
@@ -574,8 +632,12 @@ export function ensureCamoufoxFingerprintForToken(provider, alias) {
     try {
         void ensureFingerprintEnv(profileId, provider, alias);
     }
-    catch {
-        // fingerprint generation failures are non-fatal for token scanning
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('ensure_fingerprint_for_token', error, {
+            profileId,
+            provider: provider ?? null,
+            alias: alias ?? null
+        });
     }
 }
 function isTruthyFlag(value) {
@@ -612,7 +674,10 @@ function resolvePortalOauthUrl(rawUrl) {
         const normalized = oauthUrl.trim();
         return normalized || null;
     }
-    catch {
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('resolve_portal_oauth_url.parse', error, {
+            rawUrl: String(rawUrl || '').slice(0, 200)
+        });
         return null;
     }
 }
@@ -642,18 +707,6 @@ async function maybeAdvanceTokenPortal(options) {
         required: autoModeEnabled
     });
 }
-function isIflowOAuthUrl(rawUrl) {
-    if (!rawUrl || typeof rawUrl !== 'string') {
-        return false;
-    }
-    try {
-        const parsed = new URL(rawUrl);
-        return /(?:^|\.)iflow\.cn$/i.test(parsed.hostname) && parsed.pathname === '/oauth';
-    }
-    catch {
-        return rawUrl.includes('iflow.cn/oauth');
-    }
-}
 function isQwenAuthorizeUrl(rawUrl) {
     if (!rawUrl || typeof rawUrl !== 'string') {
         return false;
@@ -698,6 +751,56 @@ function isGoogleAuthUrl(rawUrl) {
         return rawUrl.includes('accounts.google.com');
     }
 }
+function isLocalOAuthCallbackUrl(rawUrl) {
+    if (!rawUrl || typeof rawUrl !== 'string') {
+        return false;
+    }
+    try {
+        const parsed = new URL(rawUrl);
+        const host = String(parsed.hostname || '').toLowerCase();
+        const isLocalHost = host === '127.0.0.1' || host === 'localhost' || host === '::1';
+        if (!isLocalHost) {
+            return false;
+        }
+        const pathName = String(parsed.pathname || '').toLowerCase();
+        if (pathName.includes('oauth2callback') ||
+            pathName.includes('oauth/callback') ||
+            pathName.includes('oauth_callback')) {
+            return true;
+        }
+        return parsed.searchParams.has('code') || parsed.searchParams.has('state');
+    }
+    catch (error) {
+        logCamoufoxLauncherNonBlocking('is_local_oauth_callback_url.parse', error, {
+            rawUrl: String(rawUrl || '').slice(0, 200)
+        });
+        return false;
+    }
+}
+async function waitForOAuthRelatedPage(options) {
+    const timeoutMs = options.settleTimeoutMs > 0 ? options.settleTimeoutMs : 12000;
+    const intervalMs = options.pollIntervalMs > 0 ? options.pollIntervalMs : 300;
+    const provider = String(options.provider || '').trim().toLowerCase();
+    const deadline = Date.now() + timeoutMs;
+    let lastUrl = null;
+    while (Date.now() <= deadline) {
+        const activeUrl = getActiveCamoPageUrl(options.actionContext);
+        if (activeUrl) {
+            lastUrl = activeUrl;
+            if (isTokenPortalUrl(activeUrl) || isLocalOAuthCallbackUrl(activeUrl)) {
+                return activeUrl;
+            }
+            if (provider === 'qwen' && (isQwenAuthorizeUrl(activeUrl) || isQwenLoginUrl(activeUrl) || isGoogleAuthUrl(activeUrl))) {
+                return activeUrl;
+            }
+            if ((provider === 'gemini-cli' || provider === 'antigravity') && isGoogleAuthUrl(activeUrl)) {
+                return activeUrl;
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return lastUrl;
+}
 async function maybeAdvanceQwenAuthorization(options) {
     const provider = String(options.provider || '').trim().toLowerCase();
     if (provider !== 'qwen') {
@@ -726,18 +829,29 @@ async function maybeAdvanceQwenAuthorization(options) {
         logOAuthDebug('[OAuth] camo-cli qwen oauth page not ready (no active url)');
         return false;
     }
+    if (isLocalOAuthCallbackUrl(activeUrl)) {
+        logOAuthDebug(`[OAuth] camo-cli qwen oauth callback already reached: ${activeUrl}`);
+        return true;
+    }
     if (isGoogleAuthUrl(activeUrl)) {
         // Google auth handled in the next stage.
         return true;
     }
     if (isQwenLoginUrl(activeUrl)) {
-        // Login screen requires user interaction; trigger fallback to headful/manual mode.
-        logOAuthDebug(`[OAuth] camo-cli qwen login page detected; falling back to manual: ${activeUrl}`);
-        return false;
+        logOAuthDebug(`[OAuth] camo-cli qwen login page detected; advancing with Google login: ${activeUrl}`);
+        const retryCount = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_QWEN_CLICK_RETRIES, autoModeEnabled ? 12 : 2);
+        const retryDelayMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_QWEN_CLICK_RETRY_DELAY_MS, 500);
+        return clickCamoTarget(options.actionContext, CAMO_CLICK_TARGETS.qwenGoogleContinue, {
+            retries: retryCount,
+            retryDelayMs,
+            required: true
+        });
     }
     if (!isQwenAuthorizeUrl(activeUrl)) {
-        logOAuthDebug(`[OAuth] camo-cli qwen oauth page not ready: ${activeUrl}`);
-        return false;
+        // Qwen flow can jump directly to callback/Google/other intermediate pages depending on session state.
+        // Do not hard-fail on non-qwen pages here; let subsequent steps/callback waiter continue.
+        logOAuthDebug(`[OAuth] camo-cli qwen oauth page not ready; continue without strict qwen click: ${activeUrl}`);
+        return true;
     }
     const readyDelayMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_QWEN_CONFIRM_WAIT_MS, 1200);
     if (readyDelayMs > 0) {
@@ -761,46 +875,10 @@ async function maybeAdvanceQwenAuthorization(options) {
     });
     return googleClicked;
 }
-async function maybeAdvanceIflowAccountSelection(options) {
-    const provider = String(options.provider || '').trim().toLowerCase();
-    if (provider !== 'iflow') {
-        return true;
-    }
-    const autoMode = String(process.env.ROUTECODEX_CAMOUFOX_AUTO_MODE || '').trim().toLowerCase();
-    const autoModeEnabled = autoMode === 'iflow';
-    if (!autoModeEnabled) {
-        return true;
-    }
-    let activeUrl = getActiveCamoPageUrl(options.actionContext);
-    if (activeUrl && !isIflowOAuthUrl(activeUrl) && isTokenPortalUrl(activeUrl)) {
-        const settleTimeoutMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_IFLOW_OAUTH_SETTLE_MS, 7000);
-        const pollIntervalMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_IFLOW_OAUTH_POLL_MS, 250);
-        const waited = await waitForIflowOAuthPage({
-            actionContext: options.actionContext,
-            settleTimeoutMs,
-            pollIntervalMs
-        });
-        if (!waited) {
-            logOAuthDebug(`[OAuth] camo-cli iflow account advance skipped (iflow oauth page not ready): ${activeUrl || 'n/a'}`);
-            return true;
-        }
-        activeUrl = waited;
-    }
-    if (!activeUrl || !isIflowOAuthUrl(activeUrl)) {
-        return true;
-    }
-    logOAuthDebug(`[OAuth] camo-cli iflow oauth page ready: ${activeUrl}`);
-    const retryCount = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_IFLOW_ACCOUNT_CLICK_RETRIES, autoModeEnabled ? 6 : 2);
-    const retryDelayMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_IFLOW_ACCOUNT_CLICK_RETRY_DELAY_MS, 400);
-    return clickCamoTarget(options.actionContext, CAMO_CLICK_TARGETS.iflowAccountSelect, {
-        retries: retryCount,
-        retryDelayMs,
-        required: autoModeEnabled
-    });
-}
 async function waitForGoogleAuthPage(options) {
     const timeoutMs = options.settleTimeoutMs > 0 ? options.settleTimeoutMs : 7000;
     const intervalMs = options.pollIntervalMs > 0 ? options.pollIntervalMs : 250;
+    const provider = String(options.provider || '').trim().toLowerCase();
     const deadline = Date.now() + timeoutMs;
     let lastUrl = null;
     while (Date.now() <= deadline) {
@@ -810,10 +888,22 @@ async function waitForGoogleAuthPage(options) {
             if (isGoogleAuthUrl(activeUrl)) {
                 return activeUrl;
             }
+            if (provider === 'qwen' && (isQwenLoginUrl(activeUrl) || isQwenAuthorizeUrl(activeUrl) || isLocalOAuthCallbackUrl(activeUrl))) {
+                return activeUrl;
+            }
         }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
-    return isGoogleAuthUrl(lastUrl || '') ? lastUrl : null;
+    if (!lastUrl) {
+        return null;
+    }
+    if (isGoogleAuthUrl(lastUrl)) {
+        return lastUrl;
+    }
+    if (provider === 'qwen' && (isQwenLoginUrl(lastUrl) || isQwenAuthorizeUrl(lastUrl) || isLocalOAuthCallbackUrl(lastUrl))) {
+        return lastUrl;
+    }
+    return null;
 }
 async function waitForGoogleSignInPrompt(options) {
     const timeoutMs = options.settleTimeoutMs > 0 ? options.settleTimeoutMs : 12_000;
@@ -849,16 +939,47 @@ async function maybeAdvanceGoogleAuth(options) {
         return true;
     }
     let activeUrl = getActiveCamoPageUrl(options.actionContext);
-    const needsGooglePageWait = !!activeUrl && !isGoogleAuthUrl(activeUrl) && (isQwenAuthorizeUrl(activeUrl) || isTokenPortalUrl(activeUrl));
+    const needsGooglePageWait = !!activeUrl &&
+        !isGoogleAuthUrl(activeUrl) &&
+        (isQwenAuthorizeUrl(activeUrl) || isQwenLoginUrl(activeUrl) || isTokenPortalUrl(activeUrl));
     if (needsGooglePageWait) {
         const settleTimeoutMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_GOOGLE_OAUTH_SETTLE_MS, 7000);
         const pollIntervalMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_GOOGLE_OAUTH_POLL_MS, 250);
         activeUrl = await waitForGoogleAuthPage({
+            provider,
             actionContext: options.actionContext,
             settleTimeoutMs,
             pollIntervalMs
         });
     }
+    if (activeUrl && isLocalOAuthCallbackUrl(activeUrl)) {
+        logOAuthDebug(`[OAuth] camo-cli google auth stage reached local callback: ${activeUrl}`);
+        return true;
+    }
+    if (provider === 'qwen' && activeUrl && isQwenLoginUrl(activeUrl)) {
+        const qwenRetryCount = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_QWEN_CLICK_RETRIES, autoModeEnabled ? 12 : 2);
+        const qwenRetryDelayMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_QWEN_CLICK_RETRY_DELAY_MS, 500);
+        const qwenLoginClicked = await clickCamoTarget(options.actionContext, CAMO_CLICK_TARGETS.qwenGoogleContinue, {
+            retries: qwenRetryCount,
+            retryDelayMs: qwenRetryDelayMs,
+            required: true
+        });
+        if (!qwenLoginClicked) {
+            return false;
+        }
+        const settleTimeoutMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_GOOGLE_OAUTH_SETTLE_MS, 7000);
+        const pollIntervalMs = parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_GOOGLE_OAUTH_POLL_MS, 250);
+        activeUrl = await waitForGoogleAuthPage({
+            provider,
+            actionContext: options.actionContext,
+            settleTimeoutMs,
+            pollIntervalMs
+        });
+        if (activeUrl && isLocalOAuthCallbackUrl(activeUrl)) {
+            logOAuthDebug(`[OAuth] camo-cli qwen login advance reached local callback: ${activeUrl}`);
+            return true;
+        }
+    }
     if (!activeUrl || !isGoogleAuthUrl(activeUrl)) {
         return true;
     }
@@ -938,23 +1059,6 @@ async function waitForTokenPortalPage(options) {
     }
     return false;
 }
-async function waitForIflowOAuthPage(options) {
-    const timeoutMs = options.settleTimeoutMs > 0 ? options.settleTimeoutMs : 7000;
-    const intervalMs = options.pollIntervalMs > 0 ? options.pollIntervalMs : 250;
-    const deadline = Date.now() + timeoutMs;
-    let lastUrl = null;
-    while (Date.now() <= deadline) {
-        const activeUrl = getActiveCamoPageUrl(options.actionContext);
-        if (activeUrl) {
-            lastUrl = activeUrl;
-            if (isIflowOAuthUrl(activeUrl)) {
-                return activeUrl;
-            }
-        }
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-    return isIflowOAuthUrl(lastUrl || '') ? lastUrl : null;
-}
 export async function openAuthInCamoufox(options) {
     setCamoufoxLaunchFailureReason(null);
     logOAuthDebug(`[OAuth] Camoufox: launch requested url=${options.url} provider=${options.provider ?? ''} alias=${options.alias ?? ''}`);
@@ -965,17 +1069,10 @@ export async function openAuthInCamoufox(options) {
         return false;
     }
     const launchUrl = applyGoogleLocaleHint(url);
-    const derivedProfileId = buildProfileId(options.provider, options.alias);
     const explicitProfileId = options.profileId && options.profileId.trim().length > 0
         ? options.profileId.trim()
         : '';
-    const hasProviderAlias = String(options.provider || '').trim().length > 0 || String(options.alias || '').trim().length > 0;
-    const profileId = hasProviderAlias
-        ? derivedProfileId
-        : (explicitProfileId || derivedProfileId);
-    if (hasProviderAlias && explicitProfileId && explicitProfileId !== derivedProfileId) {
-        logOAuthDebug(`[OAuth] Camoufox profile override ignored: explicit=${explicitProfileId} derived=${derivedProfileId}`);
-    }
+    const profileId = resolvePreferredOAuthProfileId(options.provider, options.alias, explicitProfileId);
     // Ensure profile directory exists ahead of launch so that fingerprint/profile data can be persisted per token.
     const profileDir = ensureCamoufoxProfileDir(options.provider, options.alias);
     const profileRoot = getProfileRoot();
@@ -988,6 +1085,7 @@ export async function openAuthInCamoufox(options) {
     const devMode = String(process.env.ROUTECODEX_CAMOUFOX_DEV_MODE || '').trim().toLowerCase();
     const headless = !(devMode === '1' || devMode === 'true' || devMode === 'yes' || devMode === 'on');
     const camoCommand = resolveCamoCliCommand();
+    const effectiveAutoMode = resolveEffectiveCamoufoxAutoMode(options.provider);
     try {
         console.log(`[OAuth] Camoufox launcher spawn via camo-cli: profileId=${profileId} headless=${headless ? '1' : '0'}`);
         const fingerprintEnvRaw = ensureFingerprintEnv(profileId, options.provider, options.alias);
@@ -995,6 +1093,12 @@ export async function openAuthInCamoufox(options) {
         const localeEnv = resolveCamoufoxLocaleEnv();
         const sharedEnv = {
             ...process.env,
+            ...(effectiveAutoMode
+                ? {
+                    ROUTECODEX_CAMOUFOX_AUTO_MODE: effectiveAutoMode,
+                    RCC_CAMOUFOX_AUTO_MODE: effectiveAutoMode
+                }
+                : {}),
             ...localeEnv,
             ...fingerprintEnv,
             WEBAUTO_PATHS_PROFILES: profileRoot,
@@ -1026,6 +1130,7 @@ export async function openAuthInCamoufox(options) {
         let gotoOk = gotoCamoUrl(actionContext, effectiveLaunchUrl);
         if (!gotoOk) {
             const isPortalLaunch = isTokenPortalUrl(launchUrl);
+            const provider = String(options.provider || '').trim().toLowerCase();
             if (!headless) {
                 logOAuthDebug('[OAuth] camo-cli goto returned non-zero in headful mode; keep session for manual portal/open-url continuation');
                 gotoOk = true;
@@ -1043,6 +1148,19 @@ export async function openAuthInCamoufox(options) {
                     gotoOk = true;
                 }
             }
+            if (!gotoOk) {
+                const relatedSettled = await waitForOAuthRelatedPage({
+                    provider,
+                    launchUrl,
+                    actionContext,
+                    settleTimeoutMs: parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_GOTO_SETTLE_MS, provider === 'qwen' ? 15000 : 8000),
+                    pollIntervalMs: parsePositiveInt(process.env.ROUTECODEX_CAMOUFOX_GOTO_POLL_MS, 250)
+                });
+                if (relatedSettled) {
+                    logOAuthDebug(`[OAuth] camo-cli goto returned non-zero but oauth-related page settled to: ${relatedSettled}`);
+                    gotoOk = true;
+                }
+            }
             if (!gotoOk) {
                 const fallbackOauthUrl = resolvePortalOauthUrl(launchUrl);
                 if (fallbackOauthUrl && headless) {
@@ -1064,14 +1182,6 @@ export async function openAuthInCamoufox(options) {
             setCamoufoxLaunchFailureReason('element_not_found:token_portal_continue');
             return false;
         }
-        const iflowAdvanced = await maybeAdvanceIflowAccountSelection({
-            provider: options.provider,
-            actionContext
-        });
-        if (!iflowAdvanced) {
-            setCamoufoxLaunchFailureReason('element_not_found:iflow_account_select');
-            return false;
-        }
         const qwenAdvanced = await maybeAdvanceQwenAuthorization({
             provider: options.provider,
             actionContext
@@ -1094,6 +1204,10 @@ export async function openAuthInCamoufox(options) {
     }
     catch (error) {
         setCamoufoxLaunchFailureReason(`exception:${error instanceof Error ? error.message : String(error)}`);
+        logCamoufoxLauncherNonBlocking('open_auth_in_camoufox', error, {
+            provider: options.provider ?? null,
+            alias: options.alias ?? null
+        });
         logOAuthDebug(`[OAuth] camo-cli launch failed - ${error instanceof Error ? error.message : String(error)}`);
         return false;
     }