@jsonstudio/rcc 0.89.1205 → 0.89.1457

package/scripts/camoufox/launch-auth.mjs

@@ -7,6 +7,12 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
+function isTruthy(value) {
+  if (!value) return false;
+  const v = String(value).trim().toLowerCase();
+  return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+
 function parseArgs(argv) {
   const args = { profile: 'default', url: '', autoMode: '', devMode: false };
   const list = argv.slice(2);
@@ -65,6 +71,44 @@ async function getCamoufoxCacheRoot() {
   });
 }
 
+function resolveCamoufoxBinary(cacheRoot) {
+  const override = (process.env.ROUTECODEX_CAMOUFOX_BINARY || '').trim();
+  if (override) {
+    return override;
+  }
+
+  const isMac = process.platform === 'darwin';
+  if (!cacheRoot && isMac) {
+    // Best-effort fallback when python3 is unavailable/broken:
+    // Camoufox's packaged app is commonly placed under ~/Library/Caches/camoufox/Camoufox.app.
+    const guessed = path.join(os.homedir(), 'Library', 'Caches', 'camoufox');
+    if (fs.existsSync(path.join(guessed, 'Camoufox.app'))) {
+      cacheRoot = guessed;
+    }
+  }
+  if (cacheRoot && isMac) {
+    const appPath = path.join(cacheRoot, 'Camoufox.app');
+    const macBinary = path.join(appPath, 'Contents', 'MacOS', 'camoufox');
+    if (fs.existsSync(macBinary)) {
+      return macBinary;
+    }
+  }
+
+  try {
+    const located = spawnSync('which', ['camoufox'], { encoding: 'utf-8' });
+    if (located.status === 0) {
+      const resolved = String(located.stdout || '').trim();
+      if (resolved) {
+        return resolved;
+      }
+    }
+  } catch {
+    // ignore lookup failure
+  }
+
+  return 'camoufox';
+}
+
 async function ensureProfileDir(profileId) {
   const root = path.join(os.homedir(), '.routecodex', 'camoufox-profiles');
   const dir = path.join(root, profileId);
@@ -108,17 +152,16 @@ async function main() {
 
   const cacheRoot = await getCamoufoxCacheRoot();
   if (!cacheRoot) {
-    console.error(
-      '[camoufox-launch-auth] Failed to resolve Camoufox cache root via "python3 -m camoufox path"'
+    console.warn(
+      '[camoufox-launch-auth] Failed to resolve Camoufox cache root via "python3 -m camoufox path"; falling back to PATH/override.'
     );
-    process.exit(1);
   }
 
   const camoufoxBinary = resolveCamoufoxBinary(cacheRoot);
 
   if (autoMode && autoMode.trim().toLowerCase() === 'iflow') {
     try {
-      await runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, devMode });
+      await runAutoFlowWithFallback('iflow', { url, profileDir, profileId, camoufoxBinary, devMode });
       process.exit(0);
     } catch (error) {
       console.error(
@@ -132,7 +175,7 @@ async function main() {
 
   if (autoMode && autoMode.trim().toLowerCase() === 'gemini') {
     try {
-      await runGeminiAutoFlow({ url, profileDir, camoufoxBinary, devMode });
+      await runAutoFlowWithFallback('gemini', { url, profileDir, profileId, camoufoxBinary, devMode });
       process.exit(0);
     } catch (error) {
       console.error(
@@ -146,7 +189,7 @@ async function main() {
 
   if (autoMode && autoMode.trim().toLowerCase() === 'antigravity') {
     try {
-      await runAntigravityAutoFlow({ url, profileDir, camoufoxBinary, devMode });
+      await runAutoFlowWithFallback('antigravity', { url, profileDir, profileId, camoufoxBinary, devMode });
       process.exit(0);
     } catch (error) {
       console.error(
@@ -166,59 +209,29 @@ main().catch((err) => {
   process.exit(1);
 });
 
-function resolveCamoufoxBinary(cacheRoot) {
-  const isMac = process.platform === 'darwin';
-  if (isMac) {
-    const appPath = path.join(cacheRoot, 'Camoufox.app');
-    const macBinary = path.join(appPath, 'Contents', 'MacOS', 'camoufox');
-    if (fs.existsSync(macBinary)) {
-      return macBinary;
-    }
-  }
-  try {
-    const located = spawnSync('which', ['camoufox'], { encoding: 'utf-8' });
-    if (located.status === 0) {
-      const resolved = located.stdout.trim();
-      if (resolved) {
-        return resolved;
+async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
+  let browserExitCode = 0;
+  let browser = null;
+  const shutdownBrowser = (signal = 'SIGTERM') => {
+    try {
+      if (!browser) {
+        return;
       }
+      browser.kill(signal);
+    } catch {
+      // ignore
     }
-  } catch {
-    // ignore lookup failure
-  }
-  return 'camoufox';
-}
+  };
+  ['SIGTERM', 'SIGINT', 'SIGHUP'].forEach((signal) => {
+    process.on(signal, () => shutdownBrowser(signal));
+  });
 
-async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
-  let browserExitCode = 0;
   try {
-    const browser = spawn(camoufoxBinary, ['-profile', profileDir, url], {
-      detached: true,
+    browser = spawn(camoufoxBinary, ['-profile', profileDir, url], {
+      detached: false,
       stdio: 'ignore'
     });
 
-    const shutdownBrowser = (signal = 'SIGTERM') => {
-      try {
-        if (browser.pid) {
-          try {
-            process.kill(-browser.pid, signal);
-            return;
-          } catch {
-            // process group kill may fail on non-unix systems; fall back to direct kill
-          }
-        }
-        browser.kill(signal);
-      } catch {
-        // ignore
-      }
-    };
-
-    ['SIGTERM', 'SIGINT'].forEach((signal) => {
-      process.on(signal, () => {
-        shutdownBrowser(signal);
-      });
-    });
-
     browserExitCode = await new Promise((resolve) => {
       browser.on('exit', (code) => resolve(code ?? 0));
       browser.on('error', () => resolve(1));
@@ -234,6 +247,95 @@ async function launchManualCamoufox({ camoufoxBinary, profileDir, url }) {
   process.exit(browserExitCode);
 }
 
+function isSelectorOrTimeoutError(error) {
+  const message = error instanceof Error ? error.message : String(error || '');
+  return (
+    /timeout/i.test(message) ||
+    /waiting for selector/i.test(message) ||
+    /strict mode violation/i.test(message) ||
+    message.includes('未能定位') ||
+    message.includes('无法定位')
+  );
+}
+
+async function runHeadedManualAssistFlow({ url, profileDir, camoufoxBinary, timeoutMs, label }) {
+  let firefox;
+  try {
+    ({ firefox } = await import('playwright-core'));
+  } catch (error) {
+    throw new Error(
+      `playwright-core is required for headed manual assist (${error instanceof Error ? error.message : String(error)})`
+    );
+  }
+
+  console.warn(
+    `[camoufox-launch-auth] ${label}: 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
+  });
+
+  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 browser opened. Please complete OAuth manually...');
+    const callbackPage = await waitForCallback(context, page, timeoutMs);
+    await callbackPage.waitForLoadState('load', { timeout: 120000 }).catch(() => {});
+    console.log('[camoufox-launch-auth] OAuth callback detected, manual completion finished.');
+  } finally {
+    await shutdown();
+  }
+}
+
+async function runAutoFlowWithFallback(kind, options) {
+  const mode = String(kind || '').trim().toLowerCase();
+  const label = mode || 'auto';
+  const timeoutMs = Number(process.env.ROUTECODEX_CAMOUFOX_GEMINI_TIMEOUT_MS || 120_000);
+
+  try {
+    if (mode === 'iflow') {
+      await runIflowAutoFlow(options);
+      return;
+    }
+    if (mode === 'gemini') {
+      await runGeminiAutoFlow(options);
+      return;
+    }
+    if (mode === 'antigravity') {
+      await runAntigravityAutoFlow(options);
+      return;
+    }
+    throw new Error(`Unknown auto mode: ${mode}`);
+  } catch (error) {
+    if (!options.devMode && isSelectorOrTimeoutError(error)) {
+      await runHeadedManualAssistFlow({
+        url: options.url,
+        profileDir: options.profileDir,
+        camoufoxBinary: options.camoufoxBinary,
+        timeoutMs: Number(process.env.ROUTECODEX_OAUTH_TIMEOUT_MS || 10 * 60_000),
+        label
+      });
+      return;
+    }
+    throw error;
+  }
+}
+
 async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, devMode }) {
   let firefox;
   try {
@@ -252,6 +354,17 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
     headless,
     acceptDownloads: false
   });
+  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));
+    });
+  });
 
   let callbackObserved = false;
   try {
@@ -352,7 +465,7 @@ async function runIflowAutoFlow({ url, profileDir, profileId, camoufoxBinary, de
     }
     throw error;
   } finally {
-    await context.close().catch(() => {});
+    await shutdown();
   }
 }
 
@@ -374,6 +487,17 @@ async function runGeminiAutoFlow({ url, profileDir, camoufoxBinary, devMode }) {
     headless: !devMode,
     acceptDownloads: false
   });
+  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));
+    });
+  });
 
   let callbackObserved = false;
   try {
@@ -440,7 +564,7 @@ async function runGeminiAutoFlow({ url, profileDir, camoufoxBinary, devMode }) {
     await callbackPage.waitForLoadState('load', { timeout: timeoutMs }).catch(() => {});
     console.log('[camoufox-launch-auth] OAuth callback detected, automation complete.');
   } finally {
-    await context.close().catch(() => {});
+    await shutdown();
   }
 }
 
@@ -462,6 +586,17 @@ async function runAntigravityAutoFlow({ url, profileDir, camoufoxBinary, devMode
     headless: !devMode,
     acceptDownloads: false
   });
+  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));
+    });
+  });
 
   let callbackObserved = false;
   try {
@@ -544,7 +679,7 @@ async function runAntigravityAutoFlow({ url, profileDir, camoufoxBinary, devMode
     }
     throw error;
   } finally {
-    await context.close().catch(() => {});
+    await shutdown();
   }
 }
 
@@ -584,7 +719,7 @@ async function waitForElementInPages(context, selector, timeoutMs) {
   return null;
 }
 
-async function waitForCallback(context, fallbackPage) {
+async function waitForCallback(context, fallbackPage, timeoutMs = 120000) {
   const isCallbackUrl = (current) => {
     if (typeof current !== 'string') {
       return false;
@@ -605,13 +740,13 @@ async function waitForCallback(context, fallbackPage) {
   }
 
   try {
-    await fallbackPage.waitForURL((current) => isCallbackUrl(current), { timeout: 120000 });
+    await fallbackPage.waitForURL((current) => isCallbackUrl(current), { timeout: timeoutMs });
     return fallbackPage;
   } catch {
     // ignore and wait for popup
   }
 
-  const callback = await context.waitForEvent('page', { timeout: 120000 });
+  const callback = await context.waitForEvent('page', { timeout: timeoutMs });
   await callback.waitForLoadState('domcontentloaded', { timeout: 60000 }).catch(() => {});
   return callback;
 }

package/scripts/ci/repo-sanity.mjs

@@ -0,0 +1,138 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+
+function runGit(args) {
+  const out = spawnSync('git', args, { encoding: 'utf8' });
+  if (out.status !== 0) {
+    throw new Error(`git ${args.join(' ')} failed: ${out.stderr || out.stdout}`);
+  }
+  return String(out.stdout || '');
+}
+
+function isIgnoredByGit(p) {
+  const out = spawnSync('git', ['check-ignore', '-q', p], { encoding: 'utf8' });
+  return out.status === 0;
+}
+
+function listRootEntries() {
+  const cwd = process.cwd();
+  return fs
+    .readdirSync(cwd, { withFileTypes: true })
+    .filter((d) => d.name !== '.git')
+    .filter((d) => !isIgnoredByGit(d.name))
+    .map((d) => d.name)
+    .sort();
+}
+
+function isForbiddenRootFile(p) {
+  const base = path.posix.basename(p);
+  const allow = new Set(['AGENTS.md', 'README.md', 'task.md']);
+  if (allow.has(base)) return false;
+  if (/^test-.*\.(mjs|js|ts|py)$/i.test(base)) return true;
+  if (/^debug-.*\.(mjs|js|ts)$/i.test(base)) return true;
+  if (/\.pid$/i.test(base)) return true;
+  if (/\.tgz$/i.test(base)) return true;
+  if (base === 'plan.md') return true;
+  if (base === 'task-fallback.md') return true;
+  if (base === 'task.archive.md') return true;
+  if (base === 'WARP.md') return true;
+  if (base === 'CLAUDE.md') return true;
+  if (/(_SUMMARY|_FIX)_/i.test(base) && base.toLowerCase().endsWith('.md')) return true;
+  // Disallow ad-hoc root markdown by default (docs belong under docs/).
+  if (base.toLowerCase().endsWith('.md')) return true;
+  return false;
+}
+
+function isForbiddenTrackedPath(p) {
+  // Keep the rules narrow and explicit: this is an audit guard, not a policy engine.
+  if (p.startsWith('docs/archive/')) return true;
+  if (p.startsWith('scripts/dev/')) return true;
+  if (p.startsWith('scripts/test-') && p.endsWith('.mjs')) return true;
+  if (p.startsWith('tools/')) return true;
+  if (p.startsWith('replay/')) return true;
+  if (p.startsWith('servertool/')) return true;
+  if (p.startsWith('verified-configs/')) return true;
+  if (p.startsWith('interpreter/')) return true;
+  if (p.startsWith('exporters/')) return true;
+  if (p.startsWith('bin/')) return true;
+  if (p.startsWith('.npm-cache-local/')) return true;
+  if (p.startsWith('.claude/')) return true;
+  if (p.startsWith('.iflow/')) return true;
+  if (p === '.secrets.baseline') return true;
+  if (p.endsWith('/.DS_Store') || p === '.DS_Store') return true;
+  return false;
+}
+
+function checkRootLayout() {
+  // Fixed top-level layout. Adding new root entries requires an explicit policy change.
+  const allowed = new Set([
+    'eslint.config.js',
+    '.github',
+    '.gitignore',
+    'AGENTS.md',
+    'README.md',
+    'config',
+    'configsamples',
+    'dist',
+    'docs',
+    'jest.config.js',
+    'node_modules',
+    'package',
+    'package-lock.json',
+    'package.json',
+    'rcc',
+    'samples',
+    'scripts',
+    'sharedmodule',
+    'src',
+    'task.md',
+    'tests',
+    'tmp',
+    'tsconfig.json',
+    'vendor',
+  ]);
+
+  const rootEntries = listRootEntries();
+  const unexpected = rootEntries.filter((name) => !allowed.has(name));
+  if (unexpected.length) {
+    console.error('[repo-sanity] unexpected root entries (top-level is fixed):');
+    for (const name of unexpected) console.error(`- ${name}`);
+    process.exit(2);
+  }
+}
+
+function checkUntrackedNotIgnored() {
+  // Fail fast if anything new appears outside gitignore (anywhere in repo).
+  const out = runGit(['ls-files', '--others', '--exclude-standard']);
+  const paths = out
+    .split('\n')
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (paths.length) {
+    console.error('[repo-sanity] untracked files not ignored (add them to git or gitignore):');
+    for (const p of paths.slice(0, 200)) console.error(`- ${p}`);
+    if (paths.length > 200) console.error(`- ... (${paths.length - 200} more)`);
+    process.exit(2);
+  }
+}
+
+const files = runGit(['ls-files']).split('\n').map((s) => s.trim()).filter(Boolean);
+const forbidden = [];
+for (const p of files) {
+  if (isForbiddenTrackedPath(p)) forbidden.push(p);
+  if (!p.includes('/') && isForbiddenRootFile(p)) forbidden.push(p);
+}
+
+if (forbidden.length) {
+  console.error('[repo-sanity] forbidden tracked files detected:');
+  for (const p of Array.from(new Set(forbidden)).sort()) {
+    console.error(`- ${p}`);
+  }
+  process.exit(2);
+}
+
+checkRootLayout();
+checkUntrackedNotIgnored();
+
+console.log('[repo-sanity] ok');

package/scripts/mock-provider/run-regressions.mjs

@@ -6,6 +6,7 @@ import os from 'os';
 import { fileURLToPath } from 'url';
 import { spawn } from 'child_process';
 import { setTimeout as delay } from 'node:timers/promises';
+import http from 'node:http';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '../..');
@@ -251,7 +252,17 @@ async function waitForHealth(port, serverProc, timeoutMs = 20000) {
     try {
       const res = await fetch(`http://127.0.0.1:${port}/health`, { method: 'GET' });
       if (res.ok) {
-        return;
+        // /health becomes reachable before runtime is fully initialized (server starts listening first
+        // to support token portal). Mock regressions must wait until hub pipeline is ready.
+        try {
+          const data = await res.json();
+          const ready = data && (data.ready === true || data.pipelineReady === true || data.status === 'ok');
+          if (ready) {
+            return;
+          }
+        } catch {
+          // ignore JSON errors, retry
+        }
       }
     } catch {
       // retry
@@ -276,6 +287,150 @@ async function stopServer(child, forceTimeout = 5000) {
   child.kill('SIGKILL');
 }
 
+async function createLocalUpstreamServer(handler) {
+  return await new Promise((resolve, reject) => {
+    const server = http.createServer(handler);
+    server.on('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      if (!address || typeof address !== 'object') {
+        reject(new Error('Failed to obtain listen address for upstream server'));
+        return;
+      }
+      resolve({
+        server,
+        port: address.port
+      });
+    });
+  });
+}
+
+function buildIflowUaProbeConfig(port, upstreamPort) {
+  return {
+    version: '1.0.0',
+    virtualrouter: {
+      inputProtocol: 'openai',
+      outputProtocol: 'openai',
+      providers: {
+        iflow: {
+          id: 'iflow',
+          enabled: true,
+          type: 'iflow',
+          baseURL: `http://127.0.0.1:${upstreamPort}/v1`,
+          compatibilityProfile: 'chat:iflow',
+          auth: {
+            type: 'apikey',
+            apiKey: 'test-upstream-token'
+          },
+          models: {
+            'glm-4.7': { supportsStreaming: false }
+          }
+        }
+      },
+      routing: {
+        default: ['iflow.glm-4.7']
+      }
+    },
+    httpserver: {
+      host: '127.0.0.1',
+      port
+    }
+  };
+}
+
+async function runIflowUserAgentRegression() {
+  const seen = {
+    path: '',
+    headers: {},
+    body: ''
+  };
+
+  const { server: upstream, port: upstreamPort } = await createLocalUpstreamServer(async (req, res) => {
+    try {
+      seen.path = String(req.url || '');
+      seen.headers = req.headers || {};
+      let raw = '';
+      req.setEncoding('utf8');
+      req.on('data', (chunk) => {
+        raw += chunk;
+      });
+      await new Promise((resolve) => req.on('end', resolve));
+      seen.body = raw;
+    } catch {
+      // ignore
+    }
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(
+      JSON.stringify({
+        id: 'chatcmpl_mock_iflow_ua',
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: 'glm-4.7',
+        choices: [
+          {
+            index: 0,
+            message: { role: 'assistant', content: 'ok' },
+            finish_reason: 'stop'
+          }
+        ],
+        usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }
+      })
+    );
+  });
+
+  const port = 5750;
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'routecodex-iflow-ua-'));
+  const configPath = path.join(dir, 'config.json');
+  await fs.writeFile(configPath, JSON.stringify(buildIflowUaProbeConfig(port, upstreamPort), null, 2), 'utf-8');
+
+  const entry = path.join(PROJECT_ROOT, 'dist', 'index.js');
+  const child = spawn(process.execPath, [entry], {
+    cwd: PROJECT_ROOT,
+    env: {
+      ...process.env,
+      ROUTECODEX_PORT: String(port),
+      ROUTECODEX_CONFIG_PATH: configPath,
+      RCC_PORT: String(port),
+      RCC_CONFIG_PATH: configPath
+    },
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  try {
+    await waitForHealth(port, child);
+    const res = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        // If UA precedence is wrong, this inbound UA will leak to upstream and break iFlow glm-4.7.
+        'User-Agent': 'curl/8.7.1'
+      },
+      body: JSON.stringify({
+        model: 'iflow.glm-4.7',
+        messages: [{ role: 'user', content: 'hi' }],
+        max_tokens: 16,
+        stream: false
+      })
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      throw new Error(`ua probe request failed: HTTP ${res.status}: ${text}`);
+    }
+
+    const upstreamUa = typeof seen.headers['user-agent'] === 'string' ? seen.headers['user-agent'] : '';
+    if (upstreamUa !== 'iFlow-Cli') {
+      throw new Error(
+        `iflow UA regression: expected upstream user-agent="iFlow-Cli", got ${JSON.stringify(upstreamUa)} (path=${seen.path})`
+      );
+    }
+  } finally {
+    await stopServer(child);
+    await fs.rm(dir, { recursive: true, force: true });
+    await new Promise((resolve) => upstream.close(() => resolve()));
+  }
+}
+
 function collectInvalidNames(payload) {
   const failures = [];
   const check = (value, location) => {
@@ -546,6 +701,7 @@ async function runSample(sample, index) {
 
 async function main() {
   await ensureCliAvailable();
+  await runIflowUserAgentRegression();
   const samples = await loadRegistry();
   const watchedTags = new Set(['invalid_name', 'missing_output', 'missing_tool_call_id', 'require_fc_call_ids', 'regression']);
   const regressionSamples = samples.filter(