@jsonstudio/rcc 0.89.2239 → 0.90.89

package/scripts/compare-responses-sse.mjs

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+// Compare inbound vs outbound Responses SSE frames field-by-field.
+// Usage:
+//   node scripts/compare-responses-sse.mjs --inbound <file> --outbound <file> [--ignore sequence_number,timestamp] [--limit 20]
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+function usage() {
+  console.log(`Usage:
+  node scripts/compare-responses-sse.mjs --inbound <file> --outbound <file> [--ignore fields] [--limit N]
+
+Options:
+  --inbound   Path to inbound SSE log (frames separated by blank lines).
+  --outbound  Path to outbound SSE log (frames separated by blank lines).
+  --ignore    Comma-separated field names to ignore (default: sequence_number).
+  --limit     Max mismatches to print (default: 20).
+`);
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = { ignore: new Set(['sequence_number']), limit: 20 };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--inbound') opts.inbound = args[++i];
+    else if (arg === '--outbound') opts.outbound = args[++i];
+    else if (arg === '--ignore') {
+      const raw = (args[++i] || '').trim();
+      opts.ignore = new Set(raw ? raw.split(',').map((s) => s.trim()).filter(Boolean) : []);
+    } else if (arg === '--limit') {
+      opts.limit = Number(args[++i] || 20);
+    } else if (arg === '--help' || arg === '-h') {
+      usage();
+      process.exit(0);
+    } else {
+      console.error(`Unknown arg: ${arg}`);
+      usage();
+      process.exit(1);
+    }
+  }
+  if (!opts.inbound || !opts.outbound) {
+    usage();
+    process.exit(1);
+  }
+  return opts;
+}
+
+function readFile(file) {
+  return fs.readFileSync(path.resolve(file), 'utf8');
+}
+
+function extractRawSse(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('{')) {
+    return text;
+  }
+  try {
+    const data = JSON.parse(trimmed);
+    const raw =
+      data?.body?.raw ??
+      data?.data?.raw ??
+      data?.raw ??
+      data?.payload?.raw ??
+      data?.body?.payload?.raw;
+    if (typeof raw === 'string') {
+      return raw;
+    }
+  } catch {
+    // fall through to raw text
+  }
+  return text;
+}
+
+function splitFrames(text) {
+  if (text.includes('\n\n')) {
+    return text
+      .split(/\n\n+/)
+      .map((s) => s.trim())
+      .filter(Boolean);
+  }
+  // Fallback: some captures omit blank lines; split on repeated "event:" headers.
+  const lines = text.split('\n');
+  const frames = [];
+  let current = [];
+  for (const line of lines) {
+    if (line.startsWith('event:') && current.length) {
+      frames.push(current.join('\n').trim());
+      current = [];
+    }
+    if (line.trim().length === 0) {
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.length) {
+    frames.push(current.join('\n').trim());
+  }
+  return frames.filter(Boolean);
+}
+
+function parseFrame(frame, index) {
+  const lines = frame.split('\n');
+  let event = null;
+  let dataLines = [];
+  let id = null;
+  for (const line of lines) {
+    if (line.startsWith('event:')) {
+      event = line.slice(6).trim();
+    } else if (line.startsWith('data:')) {
+      dataLines.push(line.slice(5).trim());
+    } else if (line.startsWith('id:')) {
+      id = line.slice(3).trim();
+    }
+  }
+  const dataRaw = dataLines.join('\n');
+  let data;
+  if (dataRaw === '[DONE]') {
+    data = '[DONE]';
+  } else {
+    try {
+      data = dataRaw ? JSON.parse(dataRaw) : null;
+    } catch {
+      data = dataRaw;
+    }
+  }
+  return { index, event, data, id, raw: frame };
+}
+
+function parseSseFile(file) {
+  const rawText = extractRawSse(readFile(file));
+  const frames = splitFrames(rawText);
+  return frames.map((frame, index) => parseFrame(frame, index));
+}
+
+function eventKey(ev) {
+  const data = ev.data || {};
+  if (data && typeof data === 'object') {
+    if (data.item && typeof data.item === 'object') {
+      if (data.item.id) return `item:${data.item.id}`;
+      if (data.item.call_id) return `call:${data.item.call_id}`;
+    }
+    if (data.item_id) return `item_id:${data.item_id}`;
+    if (data.call_id) return `call:${data.call_id}`;
+    if (data.response && data.response.id) return `resp:${data.response.id}`;
+    if (data.output_index !== undefined) return `out:${data.output_index}`;
+    if (data.summary_index !== undefined) return `summary:${data.summary_index}`;
+    if (data.content_index !== undefined) return `content:${data.content_index}`;
+  }
+  return `idx:${ev.index}`;
+}
+
+function normalizeIgnore(ignoreSet) {
+  return new Set([...ignoreSet].filter(Boolean));
+}
+
+function diffValues(a, b, ignoreSet, path = '$', diffs = []) {
+  if (ignoreSet.has(path.split('.').slice(-1)[0])) {
+    return diffs;
+  }
+  if (a === b) return diffs;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      diffs.push({ path, a, b, reason: 'array-length' });
+    }
+    const len = Math.max(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+      diffValues(a[i], b[i], ignoreSet, `${path}[${i}]`, diffs);
+    }
+    return diffs;
+  }
+  if (a && b && typeof a === 'object' && typeof b === 'object') {
+    const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+    for (const key of keys) {
+      const nextPath = `${path}.${key}`;
+      if (ignoreSet.has(key)) {
+        continue;
+      }
+      diffValues(a[key], b[key], ignoreSet, nextPath, diffs);
+    }
+    return diffs;
+  }
+  diffs.push({ path, a, b, reason: 'value' });
+  return diffs;
+}
+
+function groupEvents(events) {
+  const map = new Map();
+  for (const ev of events) {
+    const key = `${ev.event || 'unknown'}|${eventKey(ev)}`;
+    if (!map.has(key)) map.set(key, []);
+    map.get(key).push(ev);
+  }
+  return map;
+}
+
+function compare(inbound, outbound, ignoreSet, limit) {
+  const inboundMap = groupEvents(inbound);
+  const outboundMap = groupEvents(outbound);
+  const mismatches = [];
+  const missingOutbound = [];
+
+  for (const [key, inEvents] of inboundMap.entries()) {
+    const outEvents = outboundMap.get(key) || [];
+    const count = Math.max(inEvents.length, outEvents.length);
+    for (let i = 0; i < count; i++) {
+      const inEv = inEvents[i];
+      const outEv = outEvents[i];
+      if (!outEv) {
+        missingOutbound.push({ key, inEv });
+        continue;
+      }
+      const diffs = diffValues(inEv.data, outEv.data, ignoreSet);
+      if (diffs.length) {
+        mismatches.push({ key, inEv, outEv, diffs });
+      }
+    }
+    outboundMap.delete(key);
+  }
+
+  const extraOutbound = [];
+  for (const [key, outEvents] of outboundMap.entries()) {
+    for (const outEv of outEvents) {
+      extraOutbound.push({ key, outEv });
+    }
+  }
+
+  console.log('Summary');
+  console.log(`- inbound events: ${inbound.length}`);
+  console.log(`- outbound events: ${outbound.length}`);
+  console.log(`- missing outbound: ${missingOutbound.length}`);
+  console.log(`- extra outbound: ${extraOutbound.length}`);
+  console.log(`- mismatches: ${mismatches.length}`);
+
+  if (missingOutbound.length) {
+    console.log('\nMissing outbound (first few):');
+    for (const m of missingOutbound.slice(0, limit)) {
+      console.log(`- ${m.key}`);
+    }
+  }
+
+  if (extraOutbound.length) {
+    console.log('\nExtra outbound (first few):');
+    for (const m of extraOutbound.slice(0, limit)) {
+      console.log(`- ${m.key}`);
+    }
+  }
+
+  if (mismatches.length) {
+    console.log('\nField mismatches (first few):');
+    for (const m of mismatches.slice(0, limit)) {
+      console.log(`- ${m.key}`);
+      for (const diff of m.diffs.slice(0, limit)) {
+        console.log(`  ${diff.path}: ${JSON.stringify(diff.a)} !== ${JSON.stringify(diff.b)}`);
+      }
+    }
+  }
+}
+
+function main() {
+  const opts = parseArgs();
+  const inbound = parseSseFile(opts.inbound);
+  const outbound = parseSseFile(opts.outbound);
+  compare(inbound, outbound, normalizeIgnore(opts.ignore), opts.limit);
+}
+
+main();

package/scripts/install-global.sh

@@ -196,6 +196,12 @@ verify_install() {
 }
 
 verify_server_health() {
+    if [ "${ROUTECODEX_INSTALL_SKIP_E2E:-0}" = "1" ]; then
+        echo ""
+        echo "⏭️  已跳过全局 CLI 端到端检查（ROUTECODEX_INSTALL_SKIP_E2E=1）"
+        return
+    fi
+
     local HEALTH_LOG="/tmp/routecodex-install-health-$(date +%s).log"
     echo ""
     echo "🩺 执行服务器健康&端到端检查 (chat + anthropic SSE)..."

package/scripts/install-verify.mjs

@@ -25,6 +25,7 @@ const state = {
   logStream: null,
   logPath: '',
   baseUrl: '',
+  ownsServer: false,
 };
 let shuttingDown = false;
 let responsesSseParser = null;
@@ -791,9 +792,12 @@ async function verifyChatStreaming(baseUrl, model, timeoutMs, samplePayload, cha
 async function stopServer() {
   const proc = state.serverProc;
   const baseUrl = state.baseUrl;
-  if (baseUrl) {
+  if (state.ownsServer && baseUrl) {
     try { await fetch(`${baseUrl}/shutdown`, { method: 'POST' }).catch(() => {}); } catch { /* ignore */ }
   }
+  if (!state.ownsServer) {
+    return;
+  }
   if (!proc) {
     if (state.logStream) {
       try { state.logStream.end(); } catch { /* ignore */ }
@@ -903,18 +907,23 @@ async function main() {
 
   const model = resolveModel(config);
   console.log(`🔁 模型: ${model}, 端口: ${port}`);
+  const buildRestartOnly = (() => {
+    const raw = String(process.env.ROUTECODEX_BUILD_RESTART_ONLY ?? process.env.RCC_BUILD_RESTART_ONLY ?? '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+  })();
 
   const listeners = detectPortPids(port);
-  if (listeners.length) {
+  const reuseExistingServer = buildRestartOnly && listeners.length > 0;
+  if (listeners.length && !reuseExistingServer) {
     throw new Error(`端口 ${port} 已被使用 (PID: ${listeners.join(', ')}). 请先停止正在运行的 RouteCodex 实例再重试。`);
   }
+  if (reuseExistingServer) {
+    console.log(`ℹ build-restart-only: 检测到已运行服务 (PID: ${listeners.join(', ')})，复用现有实例进行验证。`);
+  }
 
   console.log('🛠️ 动态生成最新的 pipeline 配置...');
   regeneratePipelineConfig({ port, configPath });
 
-  state.logPath = path.join(os.tmpdir(), `routecodex-install-verify-${Date.now()}.log`);
-  const logStream = fs.createWriteStream(state.logPath, { flags: 'a' });
-
   let command;
   let commandArgs;
   const env = { ...process.env };
@@ -933,17 +942,25 @@ async function main() {
     env.RCC_PORT = String(port);
   }
 
-  console.log(`🚀 启动 RouteCodex server... (launcher=${launcher === 'cli' ? command : 'node dist/index.js'})`);
-  const serverProc = spawn(command, commandArgs, {
-    cwd,
-    env,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    detached: false,
-  });
-  serverProc.stdout.pipe(logStream, { end: false });
-  serverProc.stderr.pipe(logStream, { end: false });
-  state.serverProc = serverProc;
-  state.logStream = logStream;
+  if (!reuseExistingServer) {
+    state.logPath = path.join(os.tmpdir(), `routecodex-install-verify-${Date.now()}.log`);
+    const logStream = fs.createWriteStream(state.logPath, { flags: 'a' });
+    state.ownsServer = true;
+    console.log(`🚀 启动 RouteCodex server... (launcher=${launcher === 'cli' ? command : 'node dist/index.js'})`);
+    const serverProc = spawn(command, commandArgs, {
+      cwd,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: false,
+    });
+    serverProc.stdout.pipe(logStream, { end: false });
+    serverProc.stderr.pipe(logStream, { end: false });
+    state.serverProc = serverProc;
+    state.logStream = logStream;
+  } else {
+    state.ownsServer = false;
+    state.serverProc = null;
+  }
 
   await waitForHealth(baseUrl, 90000);
   console.log('✅ server 健康检查通过');

package/scripts/replay-codex-sample.mjs

@@ -7,7 +7,13 @@ import path from 'node:path';
 
 const DEFAULT_BASE_URL = process.env.ROUTECODEX_BASE || 'http://127.0.0.1:5555';
 const DEFAULT_API_KEY = process.env.ROUTECODEX_API_KEY || 'routecodex-test';
-const HEADER_DENYLIST = new Set(['authorization', 'content-length', 'host']);
+const HEADER_DENYLIST = new Set([
+  'authorization',
+  'content-length',
+  'host',
+  'accept',
+  'content-type'
+]);
 
 function usage() {
   console.log(`Usage:
@@ -70,6 +76,7 @@ function extractSampleHeaders(doc) {
     return {};
   }
   const headers = {};
+  const seen = new Set();
   for (const [key, value] of Object.entries(raw)) {
     if (typeof value !== 'string' || !value.trim()) {
       continue;
@@ -78,11 +85,38 @@ function extractSampleHeaders(doc) {
     if (HEADER_DENYLIST.has(lowered)) {
       continue;
     }
-    headers[key] = value;
+    if (seen.has(lowered)) {
+      continue;
+    }
+    headers[lowered] = value;
+    seen.add(lowered);
   }
   return headers;
 }
 
+function redactAuthorization(value) {
+  if (typeof value !== 'string' || !value.trim()) return value;
+  const marker = '::rcc-session:';
+  const idx = value.indexOf(marker);
+  if (idx >= 0) {
+    return `***${value.slice(idx)}`;
+  }
+  return '***';
+}
+
+function extractTmuxSessionIdFromKey(value) {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const marker = '::rcc-session:';
+  const idx = value.lastIndexOf(marker);
+  if (idx < 0) return null;
+  const start = idx + marker.length;
+  if (start >= value.length) return null;
+  const nextIdx = value.indexOf('::rcc-sessiond:', start);
+  const end = nextIdx >= 0 ? nextIdx : value.length;
+  const token = value.slice(start, end).trim();
+  return token || null;
+}
+
 async function readSse(response) {
   const reader = response.body?.getReader();
   if (!reader) throw new Error('Response is not streamable');
@@ -126,10 +160,15 @@ async function main() {
     ...sampleHeaders,
     'Content-Type': 'application/json',
     'Accept': wantsSse ? 'text/event-stream' : 'application/json',
-    'Authorization': `Bearer ${opts.key}`,
-    'OpenAI-Beta': sampleHeaders['OpenAI-Beta'] || 'responses-2024-12-17',
-    'X-Route-Hint': sampleHeaders['X-Route-Hint'] || sampleHeaders['x-route-hint'] || 'default'
+    // Use x-routecodex-api-key to avoid Authorization header sanitization in some clients.
+    'x-routecodex-api-key': opts.key,
+    'OpenAI-Beta': sampleHeaders['openai-beta'] || 'responses-2024-12-17',
+    'X-Route-Hint': sampleHeaders['x-route-hint'] || 'default'
   };
+  const inferredTmux = extractTmuxSessionIdFromKey(opts.key);
+  if (inferredTmux && !sampleHeaders['x-routecodex-client-tmux-session-id']) {
+    headers['x-routecodex-client-tmux-session-id'] = inferredTmux;
+  }
 
   console.log(`[replay-codex-sample] ${endpoint} → ${targetUrl} (requestId=${requestId})`);
 
@@ -147,7 +186,14 @@ async function main() {
     statusText: res.statusText,
     headers: Object.fromEntries(res.headers.entries())
   };
-  fs.writeFileSync(path.join(runDir, 'request.json'), JSON.stringify({ endpoint, body: requestBody }, null, 2));
+  const debugHeaders = { ...headers };
+  if (typeof debugHeaders['x-routecodex-api-key'] === 'string') {
+    debugHeaders['x-routecodex-api-key'] = redactAuthorization(debugHeaders['x-routecodex-api-key']);
+  }
+  fs.writeFileSync(
+    path.join(runDir, 'request.json'),
+    JSON.stringify({ endpoint, body: requestBody, headers: debugHeaders }, null, 2)
+  );
   fs.writeFileSync(path.join(runDir, 'response.meta.json'), JSON.stringify(meta, null, 2));
 
   if (!res.ok) {