@jsonstudio/rcc 0.89.1968 → 0.89.2202

package/scripts/auth-iflow-manual.mjs

@@ -2,7 +2,6 @@
 import os from 'os';
 import path from 'path';
 import fs from 'fs/promises';
-import { createProviderOAuthStrategy } from '../dist/providers/core/config/provider-oauth-configs.js';
 
 async function resolveIflowTokenPath() {
   const envFile = process.env.IFLOW_TOKEN_FILE;
@@ -41,28 +40,19 @@ async function run() {
   await fs.mkdir(path.dirname(tokenPath), { recursive: true });
   try { await fs.access(tokenPath); } catch { await fs.writeFile(tokenPath, '{}', 'utf-8'); }
   
-  // Use device code flow but let user open the URL manually
-  const strategy = createProviderOAuthStrategy('iflow', {
-    flowType: 'device_code',
-    endpoints: {
-      deviceCodeUrl: 'https://iflow.cn/oauth/device/code',
-      tokenUrl: 'https://iflow.cn/oauth/token',
-      userInfoUrl: 'https://iflow.cn/api/oauth/getUserInfo'
+  // Route through the same OAuth lifecycle as runtime to avoid stale per-script endpoint drift.
+  const { ensureValidOAuthToken } = await import('../dist/providers/auth/oauth-lifecycle.js');
+  await ensureValidOAuthToken(
+    'iflow',
+    {
+      type: 'iflow-oauth',
+      tokenFile: tokenPath
     },
-    client: { clientId: '10009311001', scopes: ['openid','profile','email','api'] }
-  }, tokenPath);
-  
-  // Manually trigger device code flow
-  const deviceCodeData = await strategy.initiateDeviceCodeFlow();
-  console.log('Please open this URL in your browser:');
-  console.log(deviceCodeData.verification_uri);
-  console.log('User code:', deviceCodeData.user_code);
-  console.log('Press Enter when you have authorized...');
-  
-  await new Promise(resolve => process.stdin.once('data', resolve));
-  
-  const token = await strategy.pollForToken(deviceCodeData);
-  await strategy.saveToken(token);
+    {
+      forceReauthorize: true,
+      openBrowser: true
+    }
+  );
 
   // clean up duplicate token files for the same sequence
   for (const dup of duplicates) {
@@ -75,7 +65,7 @@ async function run() {
     }
   }
 
-  console.log(`[iflow-manual] Token saved to: ${tokenPath}`);
+  console.log(`[iflow-manual] Token refreshed and saved to: ${tokenPath}`);
 }
 
 run().catch(err => { console.error('[iflow-manual] Error:', err); process.exit(1); });

package/scripts/camoufox/launch-auth.mjs

@@ -104,6 +104,14 @@ function buildFirefoxUserPrefs() {
     'javascript.use_us_english_locale': true,
     'intl.charset.fallback.override': 'UTF-8',
     'gfx.downloadable_fonts.enabled': true,
+    'browser.startup.page': 0,
+    'browser.sessionstore.resume_from_crash': false,
+    'browser.sessionstore.resume_session_once': false,
+    'browser.sessionstore.max_resumed_crashes': 0,
+    'layers.acceleration.disabled': true,
+    'gfx.webrender.all': false,
+    'gfx.webrender.software': true,
+    'media.hardware-video-decoding.enabled': false,
     'font.default.x-western': 'sans-serif',
     'font.name.sans-serif.x-western': 'Arial',
     'font.name.serif.x-western': 'Times New Roman',
@@ -270,6 +278,92 @@ function cleanupExistingCamoufox(profileDir) {
       // ignore lock cleanup failure
     }
   }
+  const volatileStatePaths = [
+    'sessionstore.jsonlz4',
+    'sessionstore-backups',
+    'recovery.jsonlz4',
+    'recovery.baklz4',
+    'previous.jsonlz4',
+    'sessionCheckpoints.json',
+    'startupCache'
+  ];
+  for (const rel of volatileStatePaths) {
+    const target = path.join(profileDir, rel);
+    try {
+      if (fs.existsSync(target)) {
+        fs.rmSync(target, { recursive: true, force: true });
+      }
+    } catch {
+      // ignore volatile state cleanup failure
+    }
+  }
+}
+
+function hasRunningCamoufoxForProfile(profileDir) {
+  if (!profileDir) {
+    return false;
+  }
+  try {
+    const running = listRunningCamoufoxProcesses();
+    return running.some((proc) => String(proc.command || '').includes(profileDir));
+  } catch {
+    return false;
+  }
+}
+
+function hasAnyRunningCamoufox() {
+  try {
+    return listRunningCamoufoxProcesses().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function listRunningCamoufoxProcesses() {
+  const probe = spawnSync('pgrep', ['-fal', 'camoufox'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  });
+  if (!probe || probe.status !== 0) {
+    return [];
+  }
+
+  const selfPid = process.pid;
+  const lines = String(probe.stdout || '')
+    .split(/\r?\n/)
+    .map((line) => String(line || '').trim())
+    .filter(Boolean);
+
+  const result = [];
+  for (const line of lines) {
+    const spaceIdx = line.indexOf(' ');
+    if (spaceIdx <= 0) {
+      continue;
+    }
+    const pid = Number(line.slice(0, spaceIdx));
+    const command = line.slice(spaceIdx + 1).trim();
+    if (!Number.isFinite(pid) || pid <= 0 || pid === selfPid) {
+      continue;
+    }
+    const cmd = command.toLowerCase();
+    if (!cmd) {
+      continue;
+    }
+    if (cmd.includes('launch-auth.mjs')) {
+      continue;
+    }
+    if (cmd.includes('pgrep -fal camoufox')) {
+      continue;
+    }
+    const looksLikeCamoufox =
+      cmd.includes('camoufox.app/contents/macos/camoufox') ||
+      /(^|\/)camoufox(\s|$)/.test(cmd);
+    if (!looksLikeCamoufox) {
+      continue;
+    }
+    result.push({ pid, command });
+  }
+  return result;
 }
 
 async function main() {
@@ -413,6 +507,16 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
   console.log(`[camoufox-launch-auth] binary=${camoufoxBinary}`);
   console.log(`[camoufox-launch-auth] profileDir=${profileDir}`);
   console.log(`[camoufox-launch-auth] url=${url}`);
+  if (hasRunningCamoufoxForProfile(profileDir)) {
+    console.log(
+      '[camoufox-launch-auth] Same OAuth profile is already running; cleaning stale session state and relaunching isolated instance.'
+    );
+    cleanupExistingCamoufox(profileDir);
+  } else if (hasAnyRunningCamoufox()) {
+    console.log(
+      '[camoufox-launch-auth] Detected other Camoufox instances with different profiles; launching isolated OAuth instance with -no-remote.'
+    );
+  }
   let browserExitCode = 0;
   let browser = null;
   const shutdownBrowser = (signal = 'SIGTERM') => {
@@ -430,7 +534,7 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
   });
 
   try {
-    browser = spawn(camoufoxBinary, ['-profile', profileDir, url], {
+    browser = spawn(camoufoxBinary, ['-no-remote', '-profile', profileDir, url], {
       detached: false,
       stdio: 'ignore',
       env: buildCamoufoxLaunchEnv()
@@ -453,8 +557,18 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
 
 async function launchCamoufoxDetached({ camoufoxBinary, profileDir, url }) {
   console.log('[camoufox-launch-auth] Launching Camoufox (detached) ...');
+  if (hasRunningCamoufoxForProfile(profileDir)) {
+    console.log(
+      '[camoufox-launch-auth] Same OAuth profile is already running; cleaning stale session state and relaunching isolated instance.'
+    );
+    cleanupExistingCamoufox(profileDir);
+  } else if (hasAnyRunningCamoufox()) {
+    console.log(
+      '[camoufox-launch-auth] Detected other Camoufox instances with different profiles; launching isolated OAuth instance with -no-remote.'
+    );
+  }
   try {
-    const child = spawn(camoufoxBinary, ['-profile', profileDir, url], {
+    const child = spawn(camoufoxBinary, ['-no-remote', '-profile', profileDir, url], {
       detached: true,
       stdio: 'ignore',
       env: buildCamoufoxLaunchEnv()
@@ -474,9 +588,14 @@ function isSelectorOrTimeoutError(error) {
   return (
     /timeout/i.test(message) ||
     /waiting for selector/i.test(message) ||
+    /selector[^.\n]*not detected/i.test(message) ||
+    /page\/account selector not detected/i.test(message) ||
+    /not detected/i.test(message) ||
     /strict mode violation/i.test(message) ||
+    /target page, context or browser has been closed/i.test(message) ||
     message.includes('未能定位') ||
-    message.includes('无法定位')
+    message.includes('无法定位') ||
+    message.includes('未检测到')
   );
 }
 
@@ -636,6 +755,7 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
   }
 
   const headless = !devMode;
+  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_IFLOW_TIMEOUT_MS || 300_000);
   console.log(`[camoufox-launch-auth] Launching Camoufox in ${headless ? 'headless' : 'headed'} mode...`);
   cleanupExistingCamoufox(profileDir);
   const context = await firefox.launchPersistentContext(profileDir, {
@@ -668,7 +788,7 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
     await button.click();
     console.log('[camoufox-launch-auth] Continue button clicked, waiting for iFlow window...');
     const popup = await popupPromise;
-    const iflowPage = popup ?? page;
+    let iflowPage = popup ?? page;
     const selectors = [
       'span.accountName--ZKlffRBc',
       'span[class^="accountName--"]',
@@ -678,16 +798,44 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
     ];
     const selectorQuery = selectors.join(', ');
     console.log('[camoufox-launch-auth] Waiting for iFlow OAuth URL or account DOM to load...');
+    const waitForCallbackPromise = waitForCallback(context, iflowPage, 60000)
+      .then((callbackPage) => ({ kind: 'callback', callbackPage }))
+      .catch((error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn('[camoufox-launch-auth] waitForCallback did not settle:', msg);
+        return null;
+      });
     const waitForUrlPromise = iflowPage
       .waitForURL((current) => typeof current === 'string' && current.includes('iflow.cn'), { timeout: 60000 })
-      .then(() => 'url');
+      .then(() => ({ kind: 'url' }))
+      .catch((error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn('[camoufox-launch-auth] waitForURL did not settle:', msg);
+        return null;
+      });
     const waitForDomPromise = iflowPage
       .waitForSelector(selectorQuery, { timeout: 60000 })
-      .then(() => 'dom');
-    const raceResult = await Promise.race([waitForUrlPromise, waitForDomPromise]);
-    waitForUrlPromise.catch(() => {});
-    waitForDomPromise.catch(() => {});
-    if (raceResult === 'url') {
+      .then(() => ({ kind: 'dom' }))
+      .catch((error) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.warn('[camoufox-launch-auth] waitForSelector did not settle:', msg);
+        return null;
+      });
+    const raceResult = await Promise.race([waitForUrlPromise, waitForDomPromise, waitForCallbackPromise]);
+    if (!raceResult) {
+      const fallback = await waitForAnyElementInPages(context, selectors, 60000);
+      if (fallback?.page) {
+        iflowPage = fallback.page;
+        console.log('[camoufox-launch-auth] Fallback page with account DOM detected, continuing...');
+      } else {
+        throw new Error('iFlow OAuth page/account selector not detected');
+      }
+    } else if (raceResult.kind === 'callback') {
+      callbackObserved = true;
+      await raceResult.callbackPage.waitForLoadState('load', { timeout: timeoutMs }).catch(() => {});
+      console.log('[camoufox-launch-auth] OAuth callback detected before account selection, automation complete.');
+      return;
+    } else if (raceResult.kind === 'url') {
       console.log(`[camoufox-launch-auth] iFlow URL detected: ${await iflowPage.url()}`);
       await iflowPage.waitForSelector(selectorQuery, { timeout: 60000 });
     } else {

package/scripts/ci/check-file-line-limit.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+
+const repoRoot = process.cwd();
+const policyPath = path.join(repoRoot, 'config', 'file-line-limit-policy.json');
+
+function run(cmd) {
+  return execSync(cmd, { cwd: repoRoot, stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf8' }).trim();
+}
+
+function tryRun(cmd) {
+  try {
+    return run(cmd);
+  } catch {
+    return '';
+  }
+}
+
+function loadPolicy() {
+  const raw = fs.readFileSync(policyPath, 'utf8');
+  const parsed = JSON.parse(raw);
+  return {
+    limit: Number(parsed.limit) > 0 ? Number(parsed.limit) : 500,
+    extensions: Array.isArray(parsed.extensions) ? parsed.extensions.map((v) => String(v).toLowerCase()) : [],
+    excludeDirs: Array.isArray(parsed.excludeDirs) ? parsed.excludeDirs.map((v) => String(v)) : [],
+    allowList: Array.isArray(parsed.allowList) ? parsed.allowList.map((v) => String(v)) : []
+  };
+}
+
+function resolveRange() {
+  const argvBase = process.argv.find((arg) => arg.startsWith('--base='));
+  if (argvBase) {
+    const value = argvBase.slice('--base='.length).trim();
+    if (value) {
+      return `${value}...HEAD`;
+    }
+  }
+  const envBase = String(process.env.ROUTECODEX_LINE_LIMIT_BASE || '').trim();
+  if (envBase) {
+    return `${envBase}...HEAD`;
+  }
+  const inCi = String(process.env.CI || '').toLowerCase() === 'true';
+  const hasLocalChanges = Boolean(tryRun('git status --porcelain'));
+  if (!inCi && hasLocalChanges) {
+    return '';
+  }
+  const isPr = String(process.env.GITHUB_EVENT_NAME || '') === 'pull_request';
+  const baseRef = String(process.env.GITHUB_BASE_REF || '').trim();
+  if (isPr && baseRef) {
+    return `origin/${baseRef}...HEAD`;
+  }
+  const hasHeadParent = tryRun('git rev-parse --verify --quiet HEAD~1');
+  if (hasHeadParent) {
+    return 'HEAD~1...HEAD';
+  }
+  return '';
+}
+
+function parseNameStatus(output) {
+  if (!output) return [];
+  return output
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const parts = line.split('\t');
+      if (parts.length < 2) return null;
+      const status = parts[0];
+      if (status.startsWith('R')) {
+        return { status: 'R', path: parts[2] || parts[1] };
+      }
+      return { status: status[0], path: parts[1] };
+    })
+    .filter((v) => v && typeof v.path === 'string');
+}
+
+function isExcluded(filePath, policy) {
+  const normalized = filePath.replace(/\\/g, '/');
+  if (policy.allowList.includes(normalized)) {
+    return true;
+  }
+  return policy.excludeDirs.some((prefix) => normalized.startsWith(prefix));
+}
+
+function isCodeFile(filePath, policy) {
+  const ext = path.extname(filePath).toLowerCase();
+  return policy.extensions.includes(ext);
+}
+
+function countLines(filePath) {
+  const content = fs.readFileSync(path.join(repoRoot, filePath), 'utf8');
+  if (!content.length) return 0;
+  return content.split(/\r?\n/).length;
+}
+
+function getChangedFiles(range) {
+  const diffCmd = range
+    ? `git diff --name-status --diff-filter=ACMR ${range}`
+    : 'git diff --name-status --diff-filter=ACMR HEAD';
+  return parseNameStatus(tryRun(diffCmd));
+}
+
+function main() {
+  const policy = loadPolicy();
+  const range = resolveRange();
+  const changed = getChangedFiles(range);
+  if (!changed.length) {
+    console.log('[file-line-limit] no changed files; skip');
+    return;
+  }
+
+  const violations = [];
+  for (const entry of changed) {
+    const filePath = entry.path;
+    if (!filePath || !fs.existsSync(path.join(repoRoot, filePath))) {
+      continue;
+    }
+    if (!isCodeFile(filePath, policy) || isExcluded(filePath, policy)) {
+      continue;
+    }
+    const lines = countLines(filePath);
+    if (lines < policy.limit) {
+      continue;
+    }
+    const violationType = entry.status === 'A' ? 'new-file-over-limit' : 'modified-file-over-limit';
+    violations.push({ type: violationType, path: filePath, lines });
+  }
+
+  if (!violations.length) {
+    console.log(
+      `[file-line-limit] pass (range=${range || 'HEAD'} limit=${policy.limit}, checked=${changed.length})`
+    );
+    return;
+  }
+
+  console.error(`[file-line-limit] fail (limit=${policy.limit}, range=${range || 'HEAD'})`);
+  for (const violation of violations) {
+    console.error(`- ${violation.type}: ${violation.path} (${violation.lines} lines)`);
+  }
+  console.error(
+    'Fix: split by feature/function and extract reusable helpers; if temporary exemption is required, add path to config/file-line-limit-policy.json allowList with a tracked follow-up issue.'
+  );
+  process.exit(1);
+}
+
+main();

package/scripts/copy-compat-assets.mjs

@@ -14,6 +14,17 @@ async function ensureDir(p) {
   await fs.mkdir(p, { recursive: true }).catch(() => {});
 }
 
+async function assertFileExists(filePath, message) {
+  try {
+    const stats = await fs.stat(filePath);
+    if (!stats.isFile()) {
+      throw new Error(message);
+    }
+  } catch {
+    throw new Error(message);
+  }
+}
+
 async function main() {
   const PROMPT_SRC = path.resolve(process.cwd(), 'src/config/system-prompts');
   const PROMPT_DIST = path.resolve(process.cwd(), 'dist/config/system-prompts');
@@ -21,6 +32,7 @@ async function main() {
   const CAMOUFOX_DIST = path.resolve(process.cwd(), 'dist/scripts/camoufox');
   const DEEPSEEK_SRC = path.resolve(process.cwd(), 'scripts/deepseek');
   const DEEPSEEK_DIST = path.resolve(process.cwd(), 'dist/scripts/deepseek');
+  const REQUIRED_DEEPSEEK_ASSETS = ['pow-solver.mjs', 'sha3_wasm_bg.7b9ca65ddd.wasm'];
   const promptCopied = [];
   const camoufoxCopied = [];
   const deepseekCopied = [];
@@ -69,6 +81,20 @@ async function main() {
     } catch (deepseekErr) {
       if (deepseekErr && deepseekErr.code !== 'ENOENT') throw deepseekErr;
     }
+
+    for (const rel of REQUIRED_DEEPSEEK_ASSETS) {
+      const sourcePath = path.join(DEEPSEEK_SRC, rel);
+      const distPath = path.join(DEEPSEEK_DIST, rel);
+      await assertFileExists(
+        sourcePath,
+        `[copy-compat-assets] missing required deepseek source asset: ${sourcePath}`
+      );
+      await assertFileExists(
+        distPath,
+        `[copy-compat-assets] missing required deepseek dist asset after copy: ${distPath}`
+      );
+    }
+
     console.log(`[copy-compat-assets] prompts copied: ${promptCopied.length}`);
     console.log(`[copy-compat-assets] camoufox assets copied: ${camoufoxCopied.length}`);
     console.log(`[copy-compat-assets] deepseek assets copied: ${deepseekCopied.length}`);

package/scripts/tests/ci-jest.mjs

@@ -11,9 +11,11 @@ const routingInstructionTests = [
   'tests/commands/oauth-command.qwen-auto.spec.ts',
   'tests/server/runtime/request-executor.single-attempt.spec.ts',
   'tests/server/runtime/executor-provider.retryable.spec.ts',
+  'tests/server/runtime/http-server/executor/usage-aggregator.spec.ts',
   'tests/providers/auth/tokenfile-auth.iflow.spec.ts',
   'tests/providers/core/runtime/gemini-http-provider.unit.test.ts',
   'tests/providers/core/runtime/gemini-cli-http-provider.unit.test.ts',
+  'tests/providers/core/runtime/deepseek-http-provider.unit.test.ts',
   'tests/providers/core/runtime/base-provider.spec.ts',
   'tests/providers/core/runtime/http-transport-provider.headers.test.ts',
   'tests/providers/core/runtime/protocol-http-providers.unit.test.ts',
@@ -64,8 +66,10 @@ const routingInstructionTests = [
   'tests/servertool/hub-pipeline-session-headers.spec.ts',
   'tests/servertool/stopmessage-anthropic-stop-sequence.spec.ts',
   'tests/servertool/servertool-progress-logging.spec.ts',
+  'tests/sharedmodule/virtual-router-hit-log.spec.ts',
   'tests/unified-hub/hub-v1-single-path-imports.spec.ts',
   'tests/unified-hub/policy-errorsample-write.spec.ts',
+  'tests/unified-hub/runtime-error-errorsample-write.spec.ts',
   'tests/unified-hub/policy-observe-shadow.spec.ts',
   'tests/unified-hub/shadow-runtime-compare.errorsamples.spec.ts'
 ];

package/scripts/verify-codex-error-samples.mjs

@@ -41,14 +41,35 @@ async function fileExists(p) {
 }
 
 async function collectSampleFiles(rootDir) {
-  const entries = await fs.readdir(rootDir, { withFileTypes: true });
   const files = [];
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    if (!entry.name.toLowerCase().endsWith('.json')) continue;
-    files.push(path.join(rootDir, entry.name));
+  const queue = [rootDir];
+
+  while (queue.length > 0) {
+    const currentDir = queue.shift();
+    if (!currentDir) {
+      continue;
+    }
+
+    let entries = [];
+    try {
+      entries = await fs.readdir(currentDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!entry.name.toLowerCase().endsWith('.json')) continue;
+      files.push(fullPath);
+    }
   }
-  return files;
+
+  return files.sort();
 }
 
 async function checkFile(filePath) {