@jsonstudio/rcc 0.89.1562 → 0.89.1803

package/scripts/camoufox/launch-auth.mjs

@@ -53,7 +53,121 @@ function stripAnsi(input) {
   return input.replace(/\u001b\[[0-9;]*m/g, '');
 }
 
+function resolveGoogleLanguageHint() {
+  const raw = String(
+    process.env.ROUTECODEX_OAUTH_GOOGLE_HL ||
+    process.env.RCC_OAUTH_GOOGLE_HL ||
+    'en'
+  ).trim();
+  if (!raw) {
+    return 'en';
+  }
+  const lowered = raw.toLowerCase();
+  if (lowered === 'auto' || lowered === 'off' || lowered === 'none' || lowered === '0' || lowered === 'false') {
+    return 'en';
+  }
+  return raw.replace(/_/g, '-');
+}
+
+function buildLocaleEnv() {
+  const localeTag = resolveGoogleLanguageHint();
+  const parts = String(localeTag || 'en').split('-').filter(Boolean);
+  const language = (parts[0] || 'en').toLowerCase();
+  const region = (parts[1] || (language === 'zh' ? 'CN' : language === 'ja' ? 'JP' : language === 'ko' ? 'KR' : 'US')).toUpperCase();
+  const normalizedTag = `${language}-${region}`;
+  const posixLocale = `${language}_${region}.UTF-8`;
+  return {
+    LANG: posixLocale,
+    LC_ALL: posixLocale,
+    LANGUAGE: normalizedTag
+  };
+}
+
+function buildFirefoxUserPrefs() {
+  const lang = resolveGoogleLanguageHint();
+  const osFonts = process.platform === 'darwin'
+    ? {
+        sansCn: 'PingFang SC, Hiragino Sans GB, Heiti SC',
+        serifCn: 'Songti SC, STSong',
+        sansJa: 'Hiragino Sans, Yu Gothic, Osaka',
+        sansKo: 'Apple SD Gothic Neo, Nanum Gothic'
+      }
+    : {
+        sansCn: 'Noto Sans CJK SC, Microsoft YaHei, SimHei',
+        serifCn: 'Noto Serif CJK SC, SimSun',
+        sansJa: 'Noto Sans CJK JP, Yu Gothic',
+        sansKo: 'Noto Sans CJK KR, Malgun Gothic'
+      };
+
+  return {
+    'intl.accept_languages': lang,
+    'javascript.use_us_english_locale': true,
+    'intl.charset.fallback.override': 'UTF-8',
+    'gfx.downloadable_fonts.enabled': true,
+    'font.default.x-western': 'sans-serif',
+    'font.name.sans-serif.x-western': 'Arial',
+    'font.name.serif.x-western': 'Times New Roman',
+    'font.name.sans-serif.zh-CN': osFonts.sansCn,
+    'font.name.serif.zh-CN': osFonts.serifCn,
+    'font.name.sans-serif.ja': osFonts.sansJa,
+    'font.name.sans-serif.ko': osFonts.sansKo
+  };
+}
+
+function buildCamoufoxLaunchEnv() {
+  return {
+    ...process.env,
+    ...buildLocaleEnv()
+  };
+}
+
+function quoteUserPrefValue(value) {
+  if (typeof value === 'string') {
+    return JSON.stringify(value);
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  return JSON.stringify(String(value));
+}
+
+function buildManagedUserPrefBlock() {
+  const start = '// ROUTECODEX_CAMOUFOX_PREFS_BEGIN';
+  const end = '// ROUTECODEX_CAMOUFOX_PREFS_END';
+  const prefs = buildFirefoxUserPrefs();
+  const lines = [start];
+  for (const [key, value] of Object.entries(prefs)) {
+    lines.push('user_pref(' + JSON.stringify(key) + ', ' + quoteUserPrefValue(value) + ');');
+  }
+  lines.push(end);
+  return lines.join('\n') + '\n';
+}
+
+function ensureManagedProfilePrefs(profileDir) {
+  const userJsPath = path.join(profileDir, 'user.js');
+  const start = '// ROUTECODEX_CAMOUFOX_PREFS_BEGIN';
+  const end = '// ROUTECODEX_CAMOUFOX_PREFS_END';
+  const managedBlock = buildManagedUserPrefBlock();
+  let existing = '';
+  try {
+    existing = fs.readFileSync(userJsPath, 'utf8');
+  } catch {
+    existing = '';
+  }
+
+  let nextContent = managedBlock;
+  if (existing && existing.includes(start) && existing.includes(end)) {
+    const pattern = new RegExp(start + '[\\s\\S]*?' + end + '\n?', 'm');
+    nextContent = existing.replace(pattern, managedBlock);
+  } else if (existing.trim().length > 0) {
+    nextContent = existing.trimEnd() + '\n\n' + managedBlock;
+  }
+
+  fs.writeFileSync(userJsPath, nextContent, 'utf8');
+}
+
 async function getCamoufoxCacheRoot() {
+  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_PATH_TIMEOUT_MS || 8000);
   return new Promise((resolve) => {
     const child = spawn('python3', ['-m', 'camoufox', 'path'], {
       stdio: ['ignore', 'pipe', 'pipe']
@@ -62,8 +176,26 @@ async function getCamoufoxCacheRoot() {
     child.stdout.on('data', (chunk) => {
       out += String(chunk);
     });
-    child.on('error', () => resolve(null));
+    const timer = setTimeout(() => {
+      try {
+        child.kill('SIGKILL');
+      } catch {
+        // ignore
+      }
+      console.warn(
+        `[camoufox-launch-auth] camoufox path resolution timed out after ${timeoutMs}ms; falling back to PATH/override.`
+      );
+      resolve(null);
+    }, timeoutMs);
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
+    child.on('error', () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
     child.on('close', () => {
+      clearTimeout(timer);
       const cleaned = stripAnsi(out).trim();
       const line = cleaned.split(/\r?\n/).filter((l) => l.trim()).pop() || '';
       resolve(line || null);
@@ -149,8 +281,29 @@ async function main() {
 
   const profileId = profile || 'default';
   const profileDir = await ensureProfileDir(profileId);
+  try {
+    ensureManagedProfilePrefs(profileDir);
+  } catch (error) {
+    console.warn(
+      '[camoufox-launch-auth] Failed to persist managed profile prefs:',
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+
+  const urlPreview = String(url).length > 160 ? `${String(url).slice(0, 160)}…` : String(url);
+  console.log(
+    `[camoufox-launch-auth] start profileId=${profileId} devMode=${devMode ? '1' : '0'} autoMode=${autoMode || '-'}`
+  );
+  console.log(`[camoufox-launch-auth] url=${urlPreview}`);
+
+  const binaryOverride = (process.env.ROUTECODEX_CAMOUFOX_BINARY || '').trim();
+  if (binaryOverride) {
+    console.log('[camoufox-launch-auth] ROUTECODEX_CAMOUFOX_BINARY is set; skipping python3 camoufox path lookup.');
+  } else {
+    console.log('[camoufox-launch-auth] Resolving Camoufox path via python3 -m camoufox path ...');
+  }
 
-  const cacheRoot = await getCamoufoxCacheRoot();
+  const cacheRoot = binaryOverride ? null : await getCamoufoxCacheRoot();
   if (!cacheRoot) {
     console.warn(
       '[camoufox-launch-auth] Failed to resolve Camoufox cache root via "python3 -m camoufox path"; falling back to PATH/override.'
@@ -158,6 +311,18 @@ async function main() {
   }
 
   const camoufoxBinary = resolveCamoufoxBinary(cacheRoot);
+  console.log(`[camoufox-launch-auth] binary=${camoufoxBinary}`);
+  console.log(`[camoufox-launch-auth] profileDir=${profileDir}`);
+
+  const openOnly = isTruthy(
+    process.env.ROUTECODEX_CAMOUFOX_OPEN_ONLY || process.env.RCC_CAMOUFOX_OPEN_ONLY
+  );
+  if (openOnly) {
+    console.log('[camoufox-launch-auth] open-only mode enabled; launching Camoufox and exiting (no automation/wait).');
+    await launchCamoufoxDetached({ camoufoxBinary, profileDir, url });
+    process.exit(0);
+    return;
+  }
 
   if (autoMode && autoMode.trim().toLowerCase() === 'iflow') {
     try {
@@ -201,6 +366,40 @@ async function main() {
     return;
   }
 
+  if (autoMode && autoMode.trim().toLowerCase() === 'qwen') {
+    try {
+      await runAutoFlowWithFallback('qwen', { url, profileDir, profileId, camoufoxBinary, devMode });
+      process.exit(0);
+    } catch (error) {
+      console.error(
+        '[camoufox-launch-auth] Auto qwen auth failed:',
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Interactive CLI flows set devMode=true by default. In that case, prefer Playwright headed
+  // "manual assist" mode so users always see a window and clear progress logs.
+  if (devMode) {
+    try {
+      await runHeadedManualAssistFlow({
+        url,
+        profileDir,
+        camoufoxBinary,
+        timeoutMs: Number(process.env.ROUTECODEX_OAUTH_TIMEOUT_MS || 10 * 60_000),
+        label: 'manual'
+      });
+      process.exit(0);
+    } catch (error) {
+      console.warn(
+        '[camoufox-launch-auth] manual: headed assist failed, falling back to direct Camoufox launch:',
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+
   await launchManualCamoufox({ camoufoxBinary, profileDir, url });
 }
 
@@ -210,6 +409,10 @@ main().catch((err) => {
 });
 
 async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
+  console.log('[camoufox-launch-auth] Launching Camoufox (direct binary) for manual completion...');
+  console.log(`[camoufox-launch-auth] binary=${camoufoxBinary}`);
+  console.log(`[camoufox-launch-auth] profileDir=${profileDir}`);
+  console.log(`[camoufox-launch-auth] url=${url}`);
   let browserExitCode = 0;
   let browser = null;
   const shutdownBrowser = (signal = 'SIGTERM') => {
@@ -229,7 +432,8 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
   try {
     browser = spawn(camoufoxBinary, ['-profile', profileDir, url], {
       detached: false,
-      stdio: 'ignore'
+      stdio: 'ignore',
+      env: buildCamoufoxLaunchEnv()
     });
 
     browserExitCode = await new Promise((resolve) => {
@@ -247,6 +451,24 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
   process.exit(browserExitCode);
 }
 
+async function launchCamoufoxDetached({ camoufoxBinary, profileDir, url }) {
+  console.log('[camoufox-launch-auth] Launching Camoufox (detached) ...');
+  try {
+    const child = spawn(camoufoxBinary, ['-profile', profileDir, url], {
+      detached: true,
+      stdio: 'ignore',
+      env: buildCamoufoxLaunchEnv()
+    });
+    child.unref();
+  } catch (error) {
+    console.error(
+      '[camoufox-launch-auth] Detached launch failed:',
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+}
+
 function isSelectorOrTimeoutError(error) {
   const message = error instanceof Error ? error.message : String(error || '');
   return (
@@ -275,7 +497,8 @@ async function runHeadedManualAssistFlow({ url, profileDir, camoufoxBinary, time
   const context = await firefox.launchPersistentContext(profileDir, {
     executablePath: camoufoxBinary,
     headless: false,
-    acceptDownloads: false
+    acceptDownloads: false,
+    firefoxUserPrefs: buildFirefoxUserPrefs()
   });
 
   let closed = false;
@@ -320,9 +543,22 @@ async function runAutoFlowWithFallback(kind, options) {
       await runAntigravityAutoFlow(options);
       return;
     }
+    if (mode === 'qwen') {
+      await runQwenAutoFlow(options);
+      return;
+    }
     throw new Error(`Unknown auto mode: ${mode}`);
   } catch (error) {
     if (!options.devMode && isSelectorOrTimeoutError(error)) {
+      if (mode === 'qwen') {
+        await runHeadedQwenManualAssistFlow({
+          url: options.url,
+          profileDir: options.profileDir,
+          camoufoxBinary: options.camoufoxBinary,
+          timeoutMs: Number(process.env.ROUTECODEX_CAMOUFOX_QWEN_TIMEOUT_MS || 10 * 60_000)
+        });
+        return;
+      }
       await runHeadedManualAssistFlow({
         url: options.url,
         profileDir: options.profileDir,
@@ -336,6 +572,59 @@ async function runAutoFlowWithFallback(kind, options) {
   }
 }
 
+async function runHeadedQwenManualAssistFlow({ url, profileDir, camoufoxBinary, timeoutMs }) {
+  let firefox;
+  try {
+    ({ firefox } = await import('playwright-core'));
+  } catch (error) {
+    throw new Error(
+      `playwright-core is required for headed qwen manual assist (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+
+  console.warn(
+    '[camoufox-launch-auth] qwen: falling back to headed mode for manual completion (no selector match).'
+  );
+  cleanupExistingCamoufox(profileDir);
+  const context = await firefox.launchPersistentContext(profileDir, {
+    executablePath: camoufoxBinary,
+    headless: false,
+    acceptDownloads: false,
+    firefoxUserPrefs: buildFirefoxUserPrefs()
+  });
+
+  let closed = false;
+  const shutdown = async () => {
+    if (closed) return;
+    closed = true;
+    await context.close().catch(() => {});
+  };
+  ['SIGTERM', 'SIGINT', 'SIGHUP'].forEach((signal) => {
+    process.on(signal, () => {
+      void shutdown().finally(() => process.exit(0));
+    });
+  });
+
+  try {
+    const page = context.pages()[0] || (await context.newPage());
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 }).catch(() => {});
+    console.log('[camoufox-launch-auth] Headed Qwen browser opened. Please complete Qwen authorization manually...');
+
+    const started = Date.now();
+    while (Date.now() - started < timeoutMs) {
+      const pages = context.pages();
+      if (pages.length === 0) {
+        console.log('[camoufox-launch-auth] Browser closed by user, exiting.');
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    console.warn('[camoufox-launch-auth] Qwen manual assist timed out; exiting.');
+  } finally {
+    await shutdown();
+  }
+}
+
 async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, devMode }) {
   let firefox;
   try {
@@ -352,7 +641,8 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
   const context = await firefox.launchPersistentContext(profileDir, {
     executablePath: camoufoxBinary,
     headless,
-    acceptDownloads: false
+    acceptDownloads: false,
+    firefoxUserPrefs: buildFirefoxUserPrefs()
   });
   let closing = false;
   const shutdown = async () => {
@@ -454,9 +744,9 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
     }
     console.log('[camoufox-launch-auth] Account clicked, waiting for callback...');
 
-    const callbackPage = await waitForCallback(context, iflowPage);
+    const callbackPage = await waitForCallback(context, iflowPage, timeoutMs);
     callbackObserved = true;
-    await callbackPage.waitForLoadState('load', { timeout: 120000 }).catch(() => {});
+    await callbackPage.waitForLoadState('load', { timeout: timeoutMs }).catch(() => {});
     console.log('[camoufox-launch-auth] OAuth callback detected, automation complete.');
   } catch (error) {
     if (callbackObserved && isBrowserClosedError(error)) {
@@ -479,13 +769,14 @@ async function runGeminiAutoFlow({ url, profileDir, camoufoxBinary, devMode }) {
     );
   }
 
-  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_GEMINI_TIMEOUT_MS || 120_000);
+  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_GEMINI_TIMEOUT_MS || 300_000);
   const accountPreference = (process.env.ROUTECODEX_CAMOUFOX_ACCOUNT_TEXT || '').trim();
   cleanupExistingCamoufox(profileDir);
   const context = await firefox.launchPersistentContext(profileDir, {
     executablePath: camoufoxBinary,
     headless: !devMode,
-    acceptDownloads: false
+    acceptDownloads: false,
+    firefoxUserPrefs: buildFirefoxUserPrefs()
   });
   let closing = false;
   const shutdown = async () => {
@@ -559,8 +850,8 @@ async function runGeminiAutoFlow({ url, profileDir, camoufoxBinary, devMode }) {
       console.log('[camoufox-launch-auth] No confirmation button detected within 120s, continuing...');
     }
 
-    const activePage = confirmResult?.page || authPage;
-    const callbackPage = await waitForCallback(context, activePage);
+    const activePage = confirmResult?.page || page;
+    const callbackPage = await waitForCallback(context, activePage, timeoutMs);
     await callbackPage.waitForLoadState('load', { timeout: timeoutMs }).catch(() => {});
     console.log('[camoufox-launch-auth] OAuth callback detected, automation complete.');
   } finally {
@@ -578,13 +869,17 @@ async function runAntigravityAutoFlow({ url, profileDir, camoufoxBinary, devMode
     );
   }
 
-  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_GEMINI_TIMEOUT_MS || 120_000);
+  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_GEMINI_TIMEOUT_MS || 300_000);
+  const portalButtonTimeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_PORTAL_BUTTON_TIMEOUT_MS || 300_000);
+  const portalPopupTimeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_PORTAL_POPUP_TIMEOUT_MS || 300_000);
+  const pageLoadTimeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_PAGE_LOAD_TIMEOUT_MS || 300_000);
   const accountPreference = (process.env.ROUTECODEX_CAMOUFOX_ACCOUNT_TEXT || '').trim();
   cleanupExistingCamoufox(profileDir);
   const context = await firefox.launchPersistentContext(profileDir, {
     executablePath: camoufoxBinary,
     headless: !devMode,
-    acceptDownloads: false
+    acceptDownloads: false,
+    firefoxUserPrefs: buildFirefoxUserPrefs()
   });
   let closing = false;
   const shutdown = async () => {
@@ -607,12 +902,33 @@ async function runAntigravityAutoFlow({ url, profileDir, camoufoxBinary, devMode
     if (page.url().includes('token-auth')) {
       console.log('[camoufox-launch-auth] Portal detected, auto-clicking continue button...');
       const button = page.locator('#continue-btn');
-      await button.waitFor({ timeout: 20000 });
-      const popupPromise = context.waitForEvent('page', { timeout: 10000 }).catch(() => null);
-      await button.click();
+      await button.waitFor({ timeout: portalButtonTimeoutMs });
+      const popupPromise = context.waitForEvent('page', { timeout: portalPopupTimeoutMs }).catch(() => null);
+      const navPromise = page
+        .waitForURL((current) => typeof current === 'string' && !String(current).includes('token-auth'), {
+          timeout: portalPopupTimeoutMs
+        })
+        .catch(() => null);
+      try {
+        await button.click({ timeout: portalButtonTimeoutMs });
+      } catch {
+        await page.evaluate(() => {
+          const el = document.querySelector('#continue-btn');
+          if (!el) return;
+          const events = ['mouseenter', 'mouseover', 'mousemove', 'mousedown', 'mouseup', 'click'];
+          for (const type of events) {
+            el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
+          }
+        });
+      }
       const popup = await popupPromise;
-      authPage = popup ?? page;
-      await authPage.waitForLoadState('domcontentloaded', { timeout: 30000 }).catch(() => {});
+      if (popup) {
+        authPage = popup;
+      } else {
+        await navPromise;
+        authPage = page;
+      }
+      await authPage.waitForLoadState('domcontentloaded', { timeout: pageLoadTimeoutMs }).catch(() => {});
     }
 
     console.log('[camoufox-launch-auth] Antigravity OAuth page loaded, waiting for account selector (<=120s)...');
@@ -652,23 +968,37 @@ async function runAntigravityAutoFlow({ url, profileDir, camoufoxBinary, devMode
       }
     }, handle);
 
-    const confirmSelector = 'span.VfPpkd-vQzf8d[jsname="V67aGc"]';
-    const confirmResult = await waitForElementInPages(context, confirmSelector, timeoutMs);
+    // Google confirmation screens vary by locale/font/text; click by container/role instead of innerText.
+    const confirmSelectors = [
+      // Common primary action container on Google OAuth screens.
+      'div.VfPpkd-RLmnJb',
+      // Common button class.
+      'button.VfPpkd-LgbsSe',
+      // Alternate shape (sometimes rendered as div role=button).
+      'div[role="button"].VfPpkd-LgbsSe'
+    ];
+    const confirmResult = await waitForAnyElementInPages(context, confirmSelectors, timeoutMs);
     if (confirmResult) {
-      const signIn = confirmResult.locator.filter({ hasText: 'Sign in' });
-      if ((await signIn.count().catch(() => 0)) > 0) {
-        console.log('[camoufox-launch-auth] Sign-in confirmation span located (jsname=V67aGc), clicking...');
-        await signIn.first().click({ timeout: timeoutMs }).catch(() => {});
-        console.log('[camoufox-launch-auth] Antigravity confirmation acknowledged, waiting for callback...');
-      } else {
-        console.warn('[camoufox-launch-auth] Confirmation element present but text mismatch; skipping auto-click.');
+      console.log(`[camoufox-launch-auth] Confirmation element detected (${confirmResult.selector}), clicking...`);
+      try {
+        await confirmResult.locator.first().click({ timeout: timeoutMs });
+      } catch {
+        await confirmResult.page.evaluate((sel) => {
+          const el = document.querySelector(sel);
+          if (!el) return;
+          const events = ['mouseenter', 'mouseover', 'mousemove', 'mousedown', 'mouseup', 'click'];
+          for (const type of events) {
+            el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
+          }
+        }, confirmResult.selector);
       }
+      console.log('[camoufox-launch-auth] Antigravity confirmation acknowledged, waiting for callback...');
     } else {
       console.log('[camoufox-launch-auth] No Antigravity confirmation button detected within 120s, continuing...');
     }
 
     const activePage = confirmResult?.page || authPage;
-    const callbackPage = await waitForCallback(context, activePage);
+    const callbackPage = await waitForCallback(context, activePage, timeoutMs);
     callbackObserved = true;
     await callbackPage.waitForLoadState('load', { timeout: timeoutMs }).catch(() => {});
     console.log('[camoufox-launch-auth] OAuth callback detected, automation complete.');
@@ -683,6 +1013,118 @@ async function runAntigravityAutoFlow({ url, profileDir, camoufoxBinary, devMode
   }
 }
 
+async function runQwenAutoFlow({ url, profileDir, camoufoxBinary, devMode }) {
+  let firefox;
+  try {
+    ({ firefox } = await import('playwright-core'));
+  } catch (error) {
+    throw new Error(
+      `playwright-core is required for auto qwen auth (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+
+  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_QWEN_TIMEOUT_MS || 120_000);
+  cleanupExistingCamoufox(profileDir);
+  const context = await firefox.launchPersistentContext(profileDir, {
+    executablePath: camoufoxBinary,
+    headless: !devMode,
+    acceptDownloads: false,
+    firefoxUserPrefs: buildFirefoxUserPrefs()
+  });
+  let closing = false;
+  const shutdown = async () => {
+    if (closing) return;
+    closing = true;
+    await context.close().catch(() => {});
+  };
+  ['SIGTERM', 'SIGINT', 'SIGHUP'].forEach((signal) => {
+    process.on(signal, () => {
+      void shutdown().finally(() => process.exit(0));
+    });
+  });
+
+  try {
+    const page = context.pages()[0] || (await context.newPage());
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: timeoutMs });
+
+    let authPage = page;
+    if (page.url().includes('token-auth')) {
+      console.log('[camoufox-launch-auth] Portal detected, auto-clicking continue button...');
+      const button = page.locator('#continue-btn');
+      const portalButtonTimeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_PORTAL_BUTTON_TIMEOUT_MS || 300_000);
+      const portalPopupTimeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_PORTAL_POPUP_TIMEOUT_MS || 300_000);
+      const pageLoadTimeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_PAGE_LOAD_TIMEOUT_MS || 300_000);
+      await button.waitFor({ timeout: portalButtonTimeoutMs });
+      const popupPromise = context.waitForEvent('page', { timeout: portalPopupTimeoutMs }).catch(() => null);
+      const navPromise = page
+        .waitForURL((current) => typeof current === 'string' && !String(current).includes('token-auth'), {
+          timeout: portalPopupTimeoutMs
+        })
+        .catch(() => null);
+      try {
+        await button.click({ timeout: portalButtonTimeoutMs });
+      } catch {
+        await page.evaluate(() => {
+          const el = document.querySelector('#continue-btn');
+          if (!el) return;
+          const events = ['mouseenter', 'mouseover', 'mousemove', 'mousedown', 'mouseup', 'click'];
+          for (const type of events) {
+            el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
+          }
+        });
+      }
+      const popup = await popupPromise;
+      if (popup) {
+        authPage = popup;
+      } else {
+        await navPromise;
+        authPage = page;
+      }
+      await authPage.waitForLoadState('domcontentloaded', { timeout: pageLoadTimeoutMs }).catch(() => {});
+    }
+
+    console.log('[camoufox-launch-auth] Qwen authorize page loaded, waiting for confirm button...');
+    const confirmSelector = 'button.qwen-confirm-btn';
+    const confirmResult = await waitForElementInPages(context, confirmSelector, timeoutMs);
+    if (!confirmResult) {
+      throw new Error('未能定位 Qwen Confirm 按钮');
+    }
+    console.log('[camoufox-launch-auth] Qwen confirm button detected, clicking...');
+    try {
+      await confirmResult.locator.first().click({ timeout: timeoutMs });
+    } catch {
+      await confirmResult.page.evaluate((sel) => {
+        const el = document.querySelector(sel);
+        if (!el) return;
+        const events = ['mouseenter', 'mouseover', 'mousemove', 'mousedown', 'mouseup', 'click'];
+        for (const type of events) {
+          el.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
+        }
+      }, confirmSelector);
+    }
+    console.log('[camoufox-launch-auth] Qwen confirm clicked. Waiting for authorization to settle...');
+    // Heuristics (device-code flow): we don't get a localhost callback, so wait for either:
+    // - confirm button disappears, or
+    // - URL leaves /authorize, or
+    // - a short settle window elapses.
+    await Promise.race([
+      confirmResult.page
+        .locator(confirmSelector)
+        .first()
+        .waitFor({ state: 'detached', timeout: 30_000 })
+        .catch(() => {}),
+      confirmResult.page
+        .waitForURL((current) => typeof current === 'string' && !String(current).includes('/authorize'), {
+          timeout: 30_000
+        })
+        .catch(() => {}),
+      new Promise((resolve) => setTimeout(resolve, 5000))
+    ]);
+  } finally {
+    await shutdown();
+  }
+}
+
 function isBrowserClosedError(error) {
   if (!error) {
     return false;
@@ -719,34 +1161,88 @@ async function waitForElementInPages(context, selector, timeoutMs) {
   return null;
 }
 
-async function waitForCallback(context, fallbackPage, timeoutMs = 120000) {
+async function waitForAnyElementInPages(context, selectors, timeoutMs) {
+  const list = Array.isArray(selectors) ? selectors.filter(Boolean) : [];
+  if (list.length === 0) {
+    return null;
+  }
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    for (const candidate of context.pages()) {
+      for (const selector of list) {
+        try {
+          const locator = candidate.locator(selector);
+          if ((await locator.count()) > 0) {
+            return { page: candidate, locator, selector };
+          }
+        } catch {
+          // ignore closed pages
+        }
+      }
+    }
+    const elapsed = Date.now() - start;
+    const remaining = timeoutMs - elapsed;
+    const waitSlice = Math.min(1000, remaining);
+    if (waitSlice <= 0) {
+      break;
+    }
+    try {
+      await context.waitForEvent('page', { timeout: waitSlice });
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, waitSlice));
+    }
+  }
+  return null;
+}
+
+async function waitForCallback(context, _fallbackPage, timeoutMs = 120000) {
   const isCallbackUrl = (current) => {
-    if (typeof current !== 'string') {
+    if (typeof current !== 'string' || !current) {
+      return false;
+    }
+    try {
+      const parsed = new URL(current);
+      const host = parsed.hostname.toLowerCase();
+      if (host !== '127.0.0.1' && host !== 'localhost') {
+        return false;
+      }
+      const pathname = parsed.pathname.toLowerCase();
+      const isOAuthCallback = pathname === '/oauth2callback' || /oauth.*callback/.test(pathname);
+      if (!isOAuthCallback) {
+        return false;
+      }
+      return parsed.searchParams.has('code') || parsed.searchParams.has('error');
+    } catch {
       return false;
     }
-    const lower = current.toLowerCase();
-    return (
-      lower.startsWith('http://127.0.0.1') ||
-      lower.startsWith('http://localhost') ||
-      lower.startsWith('https://127.0.0.1')
-    );
   };
 
-  const currentPages = context.pages();
-  for (const page of currentPages) {
-    if (isCallbackUrl(page.url())) {
-      return page;
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    for (const page of context.pages()) {
+      try {
+        if (isCallbackUrl(page.url())) {
+          await page.waitForLoadState('domcontentloaded', { timeout: 60000 }).catch(() => {});
+          return page;
+        }
+      } catch {
+        // ignore closed page races
+      }
+    }
+
+    const elapsed = Date.now() - startedAt;
+    const remaining = timeoutMs - elapsed;
+    const waitSlice = Math.min(1000, remaining);
+    if (waitSlice <= 0) {
+      break;
     }
-  }
 
-  try {
-    await fallbackPage.waitForURL((current) => isCallbackUrl(current), { timeout: timeoutMs });
-    return fallbackPage;
-  } catch {
-    // ignore and wait for popup
+    try {
+      await context.waitForEvent('page', { timeout: waitSlice });
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, waitSlice));
+    }
   }
 
-  const callback = await context.waitForEvent('page', { timeout: timeoutMs });
-  await callback.waitForLoadState('domcontentloaded', { timeout: 60000 }).catch(() => {});
-  return callback;
+  throw new Error('Timed out waiting for OAuth callback URL (code/error not observed)');
 }