@jsonstudio/rcc 0.89.1121 → 0.89.1189

package/scripts/backfill-apply-patch-exec-errorsamples.mjs

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+
+/**
+ * Backfill apply_patch execution failures into ~/.routecodex/errorsamples/apply_patch_exec/**.
+ *
+ * Source: ~/.routecodex/codex-samples/** (stage snapshots)
+ * Signal: tool role message name=apply_patch and content includes "apply_patch verification failed".
+ *
+ * This is a best-effort collector for debugging. It does NOT attempt any semantic repair.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+
+const HOME = os.homedir();
+const CODEX_ROOT_PRIMARY = path.join(HOME, '.routecodex', 'codex-samples');
+const CODEX_ROOT_ALT = path.join(HOME, '.routecodex', 'codex samples');
+
+const ERR_BASE =
+  process.env.ROUTECODEX_ERRORSAMPLES_DIR && process.env.ROUTECODEX_ERRORSAMPLES_DIR.trim().length
+    ? path.resolve(process.env.ROUTECODEX_ERRORSAMPLES_DIR)
+    : path.join(HOME, '.routecodex', 'errorsamples');
+const OUT_ROOT = path.join(ERR_BASE, 'apply_patch_exec');
+
+const MAX_PER_TYPE = 250;
+
+function detectApplyPatchToolMode() {
+  return 'freeform';
+}
+
+function classifyExecutionFailure(content) {
+  const raw = String(content || '');
+  const trimmed = raw.trim();
+  const prefix = 'apply_patch verification failed:';
+  const msg = trimmed.toLowerCase().startsWith(prefix) ? trimmed.slice(prefix.length).trim() : trimmed;
+  const lower = msg.toLowerCase();
+
+  if (lower.includes('failed to read file')) return { errorType: 'read_file_failed', message: msg };
+  if (lower.includes('no such file') || lower.includes('file not found')) return { errorType: 'file_not_found', message: msg };
+  if (lower.includes('failed to find context')) return { errorType: 'context_not_found', message: msg };
+  if (lower.includes('failed to find expected lines')) return { errorType: 'expected_lines_not_found', message: msg };
+  if (lower.includes('invalid patch')) return { errorType: 'invalid_patch', message: msg };
+  if (lower.includes('failed to parse')) return { errorType: 'parse_failed', message: msg };
+
+  return { errorType: 'unknown', message: msg };
+}
+
+function stableId({ errorType, errorMessage, toolCallId, toolCallArgs, requestId, mode }) {
+  const key = `${String(errorType)}:${String(errorMessage)}:${String(toolCallId || '')}:${String(toolCallArgs || '')}:${String(
+    requestId || ''
+  )}:${String(mode || '')}`;
+  return crypto.createHash('sha1').update(key).digest('hex').slice(0, 16);
+}
+
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function* walkJsonFiles(root) {
+  const stack = [root];
+  while (stack.length) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) stack.push(full);
+      else if (entry.isFile() && entry.name.toLowerCase().endsWith('.json')) yield full;
+    }
+  }
+}
+
+async function ensureDir(p) {
+  await fs.mkdir(p, { recursive: true });
+}
+
+async function countJsonFiles(dir) {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.json')).length;
+  } catch {
+    return 0;
+  }
+}
+
+function buildToolCallArgsIndex(messages) {
+  const map = new Map();
+  for (const msg of messages) {
+    const toolCalls = Array.isArray(msg?.tool_calls) ? msg.tool_calls : [];
+    for (const tc of toolCalls) {
+      const id = typeof tc?.id === 'string' ? tc.id : '';
+      const fn = tc?.function;
+      const name = typeof fn?.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
+      if (!id || name !== 'apply_patch') continue;
+      const args = typeof fn?.arguments === 'string' ? fn.arguments : '';
+      if (args) map.set(id, args);
+    }
+  }
+  return map;
+}
+
+async function main() {
+  const roots = [];
+  if (await fileExists(CODEX_ROOT_PRIMARY)) roots.push(CODEX_ROOT_PRIMARY);
+  if (await fileExists(CODEX_ROOT_ALT)) roots.push(CODEX_ROOT_ALT);
+
+  if (!roots.length) {
+    console.log('[backfill:apply_patch_exec] skip (no codex-samples root found)');
+    return;
+  }
+
+  await ensureDir(OUT_ROOT);
+
+  const mode = detectApplyPatchToolMode();
+
+  let scanned = 0;
+  let matchedFiles = 0;
+  let captured = 0;
+  let skippedLimit = 0;
+  let skippedExists = 0;
+
+  for (const root of roots) {
+    for await (const file of walkJsonFiles(root)) {
+      scanned += 1;
+      if (!file.endsWith('req_process_stage1_tool_governance.json')) continue;
+
+      let doc;
+      try {
+        doc = JSON.parse(await fs.readFile(file, 'utf-8'));
+      } catch {
+        continue;
+      }
+
+      const messages = Array.isArray(doc?.messages) ? doc.messages : [];
+      if (!messages.length) continue;
+
+      const toolCallArgsById = buildToolCallArgsIndex(messages);
+
+      const toolMsgs = messages.filter(
+        (m) =>
+          m &&
+          m.role === 'tool' &&
+          String(m.name || '').trim().toLowerCase() === 'apply_patch' &&
+          typeof m.content === 'string' &&
+          m.content.toLowerCase().includes('apply_patch verification failed')
+      );
+      if (!toolMsgs.length) continue;
+
+      matchedFiles += 1;
+
+      const metadata = doc?.metadata || {};
+      const requestId = typeof metadata?.requestId === 'string' ? metadata.requestId : undefined;
+      const entryEndpoint = typeof metadata?.originalEndpoint === 'string' ? metadata.originalEndpoint : undefined;
+      const providerKey = typeof metadata?.providerKey === 'string' ? metadata.providerKey : undefined;
+      const modelId = typeof doc?.model === 'string' ? doc.model : undefined;
+
+      for (const m of toolMsgs) {
+        const { errorType, message } = classifyExecutionFailure(m.content);
+        const safeType = String(errorType || 'unknown').replace(/[^a-z0-9-]/gi, '_');
+        const typeDir = path.join(OUT_ROOT, safeType);
+        await ensureDir(typeDir);
+
+        const currentCount = await countJsonFiles(typeDir);
+        if (currentCount >= MAX_PER_TYPE) {
+          skippedLimit += 1;
+          continue;
+        }
+
+        const toolCallId = typeof m.tool_call_id === 'string' ? m.tool_call_id : undefined;
+        const toolCallArgs = toolCallId ? toolCallArgsById.get(toolCallId) : undefined;
+        const id = `sample_${stableId({
+          errorType,
+          errorMessage: message,
+          toolCallId,
+          toolCallArgs,
+          requestId,
+          mode
+        })}`;
+        const outPath = path.join(typeDir, `${id}.json`);
+
+        if (await fileExists(outPath)) {
+          skippedExists += 1;
+          continue;
+        }
+
+        const payload = {
+          id,
+          timestamp: new Date().toISOString(),
+          errorType,
+          errorMessage: message,
+          toolCallId,
+          toolCallArgs,
+          requestId,
+          entryEndpoint,
+          providerKey,
+          model: modelId,
+          source: 'codex-samples:req_process_stage1_tool_governance',
+          meta: { applyPatchToolMode: mode, sourceFile: file }
+        };
+        await fs.writeFile(outPath, JSON.stringify(payload, null, 2), 'utf-8');
+        captured += 1;
+      }
+    }
+  }
+
+  console.log(
+    `[backfill:apply_patch_exec] scanned=${scanned} matchedFiles=${matchedFiles} captured=${captured} skippedExists=${skippedExists} skippedLimit=${skippedLimit} out=${OUT_ROOT}`
+  );
+}
+
+main().catch((err) => {
+  console.error('[backfill:apply_patch_exec] failed:', err?.stack || err?.message || String(err));
+  process.exit(2);
+});

package/scripts/compare-codex-rccx.mjs

@@ -23,8 +23,10 @@
  */
 
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
+import { writeErrorSampleJson } from './lib/errorsamples.mjs';
 
 const DEFAULT_ROUTE_BASE = process.env.ROUTECODEX_BASE || 'http://127.0.0.1:5555';
 const DEFAULT_RCCX_BASE = process.env.RCCX_BASE || 'http://127.0.0.1:5556';
@@ -230,6 +232,29 @@ async function main() {
       rccxRunDir,
       rccxError: rccxResult.error || null
     });
+    try {
+      const file = await writeErrorSampleJson({
+        group: 'compare-codex-rccx',
+        kind: 'missing-artifacts',
+        payload: {
+          kind: 'compare-codex-rccx-missing-artifacts',
+          stamp: new Date().toISOString(),
+          samplePath,
+          requestId,
+          routeBase: opts.routeBase,
+          rccxBase: opts.rccxBase,
+          routeLabel: opts.routeLabel,
+          rccxLabel: opts.rccxLabel,
+          routeRunDir,
+          rccxRunDir,
+          routeError: routeResult.error || null,
+          rccxError: rccxResult.error || null
+        }
+      });
+      console.error(`[compare-codex-rccx] wrote errorsample: ${file}`);
+    } catch (err) {
+      console.error('[compare-codex-rccx] failed to write errorsample:', err);
+    }
     process.exitCode = 1;
     return;
   }
@@ -252,6 +277,33 @@ async function main() {
     // 为了调试 429 / 系列冷却问题，额外打印一小段 body 样本。
     console.log('[compare-codex-rccx] routecodex.bodySample =', routeResult.bodySample);
     console.log('[compare-codex-rccx] rccx.bodySample      =', rccxResult.bodySample);
+    try {
+      const file = await writeErrorSampleJson({
+        group: 'compare-codex-rccx',
+        kind: 'mismatch',
+        payload: {
+          kind: 'compare-codex-rccx-mismatch',
+          stamp: new Date().toISOString(),
+          samplePath,
+          requestId,
+          routeBase: opts.routeBase,
+          rccxBase: opts.rccxBase,
+          routeLabel: opts.routeLabel,
+          rccxLabel: opts.rccxLabel,
+          routeRunDir,
+          rccxRunDir,
+          routeMeta,
+          rccxMeta,
+          routeBodyKind: routeResult.bodyKind,
+          rccxBodyKind: rccxResult.bodyKind,
+          routeBodySample: routeResult.bodySample,
+          rccxBodySample: rccxResult.bodySample
+        }
+      });
+      console.error(`[compare-codex-rccx] wrote errorsample: ${file}`);
+    } catch (err) {
+      console.error('[compare-codex-rccx] failed to write errorsample:', err);
+    }
     process.exitCode = 1;
     return;
   }
@@ -263,6 +315,12 @@ async function main() {
 
 main().catch((err) => {
   console.error('[compare-codex-rccx] fatal error:', err);
+  try {
+    const root = path.join(os.homedir(), '.routecodex', 'errorsamples', 'compare-codex-rccx');
+    const file = path.join(root, `fatal-${Date.now()}.txt`);
+    fs.mkdirSync(root, { recursive: true });
+    fs.writeFileSync(file, String(err?.stack || err), 'utf8');
+    console.error(`[compare-codex-rccx] wrote errorsample: ${file}`);
+  } catch {}
   process.exitCode = 1;
 });
-

package/scripts/compare-responses-request.mjs

@@ -10,6 +10,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { writeErrorSampleJson } from './lib/errorsamples.mjs';
 
 const protocolFolders = {
   'openai-responses': 'openai-responses',
@@ -118,9 +119,15 @@ function listCounts(label, payload) {
   console.log(
     `${label} counts → input:${inputCount} messages:${messageCount} tools:${toolCount} instructions:${typeof payload?.instructions === 'string'}`
   );
+  return {
+    input: inputCount,
+    messages: messageCount,
+    tools: toolCount,
+    hasInstructions: typeof payload?.instructions === 'string'
+  };
 }
 
-function main() {
+async function main() {
   const opts = parseArgs();
   const clientProtocol = opts.clientProtocol || opts.protocol;
   const providerProtocol = opts.providerProtocol || opts.protocol;
@@ -146,8 +153,8 @@ function main() {
   const clientPayload = extractPayload(clientSnapshot);
   const providerPayload = extractPayload(providerSnapshot);
 
-  listCounts('Client', clientPayload);
-  listCounts('Provider', providerPayload);
+  const clientCounts = listCounts('Client', clientPayload);
+  const providerCounts = listCounts('Provider', providerPayload);
 
   const diffs = diffPayloads(pruneUndefined(clientPayload), pruneUndefined(providerPayload));
   if (!diffs.length) {
@@ -160,6 +167,30 @@ function main() {
     if (diffs.length > 50) {
       console.log(`  ... ${diffs.length - 50} more differences`);
     }
+
+    const record = {
+      kind: 'compare-responses-request-diff',
+      requestId: normalizedId,
+      clientProtocol,
+      providerProtocol,
+      clientPath,
+      providerPath,
+      clientCounts,
+      providerCounts,
+      diffsCount: diffs.length,
+      diffsHead: diffs.slice(0, 200),
+      diffsTruncated: diffs.length > 200
+    };
+    try {
+      const file = await writeErrorSampleJson({
+        group: 'compare-responses-request',
+        kind: 'diff',
+        payload: record
+      });
+      console.error(`[compare-responses-request] wrote errorsample: ${file}`);
+    } catch (err) {
+      console.error('[compare-responses-request] failed to write errorsample:', err);
+    }
   }
 }
 
@@ -217,4 +248,19 @@ function diffPayloads(expected, actual, path = '<root>') {
   return [{ path, expected, actual }];
 }
 
-main();
+main().catch((err) => {
+  console.error('[compare-responses-request] fatal error:', err);
+  void writeErrorSampleJson({
+    group: 'compare-responses-request',
+    kind: 'fatal',
+    payload: {
+      kind: 'compare-responses-request-fatal',
+      stamp: new Date().toISOString(),
+      argv: process.argv.slice(2),
+      error: String(err?.stack || err)
+    }
+  }).then((file) => {
+    console.error(`[compare-responses-request] wrote errorsample: ${file}`);
+  }).catch(() => {});
+  process.exitCode = 1;
+});

package/scripts/lib/errorsamples.mjs

@@ -0,0 +1,23 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+function safeStamp() {
+  const iso = new Date().toISOString();
+  // 2026-01-18T12:34:56.789Z -> 20260118-123456-789Z
+  return iso.replace(/[-:]/g, '').replace('T', '-').replace('.', '-');
+}
+
+function safeName(name) {
+  return String(name || 'sample').replace(/[^\w.-]/g, '_');
+}
+
+export async function writeErrorSampleJson({ group, kind, payload }) {
+  const root = path.join(os.homedir(), '.routecodex', 'errorsamples');
+  const dir = path.join(root, safeName(group));
+  await fs.mkdir(dir, { recursive: true });
+  const file = path.join(dir, `${safeName(kind)}-${safeStamp()}-${Math.random().toString(16).slice(2)}.json`);
+  await fs.writeFile(file, JSON.stringify(payload, null, 2), 'utf8');
+  return file;
+}
+

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

@@ -188,7 +188,7 @@ async function writeTempConfig(sample, port) {
   return { dir, file };
 }
 
-function createServer(configPath, port, snapshotRoot) {
+async function createServer(configPath, port, snapshotRoot) {
   const env = {
     ...process.env,
     ROUTECODEX_USE_MOCK: '1',
@@ -207,6 +207,16 @@ function createServer(configPath, port, snapshotRoot) {
       : {})
   };
   const entry = path.join(PROJECT_ROOT, 'dist', 'index.js');
+  // Defensive: build scripts or other verification steps may clean dist between checks.
+  // Ensure the server entry exists right before spawning.
+  // (Avoids confusing "Cannot find module dist/index.js" regressions.)
+  if (!(await fileExists(entry))) {
+    console.warn('[mock:regressions] dist/index.js missing at spawn time, rebuilding via "npm run build:min"...');
+    await runBuildForMockRegressions();
+    if (!(await fileExists(entry))) {
+      throw new Error(`dist/index.js still missing after rebuild: ${entry}`);
+    }
+  }
   const child = spawn(process.execPath, [entry], {
     cwd: PROJECT_ROOT,
     env,
@@ -465,7 +475,7 @@ async function runSample(sample, index) {
   const { dir, file } = await writeTempConfig(sample, port);
   // 为当前样本创建独立的临时快照根目录，并在完成后整体删除
   const snapshotRoot = path.join(dir, 'codex-samples');
-  const server = createServer(file, port, snapshotRoot);
+  const server = await createServer(file, port, snapshotRoot);
   const tags = new Set(Array.isArray(sample.tags) ? sample.tags : []);
   const expectSseTerminationError = tags.has('responses_sse_terminated');
   const allowSampleError =