@jsonstudio/rcc 0.89.2202 → 0.90.1

package/scripts/triage-errorsamples.mjs

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const ROOT =
+  process.env.ROUTECODEX_ERROR_SAMPLES_DIR &&
+  process.env.ROUTECODEX_ERROR_SAMPLES_DIR.trim().length
+    ? path.resolve(process.env.ROUTECODEX_ERROR_SAMPLES_DIR)
+    : path.join(os.homedir(), '.routecodex', 'errorsamples');
+
+const SKIP_SUBDIR = (() => {
+  const raw = String(process.env.ROUTECODEX_ERROR_SAMPLES_SKIP_SUBDIR || '').trim();
+  return raw || 'skip';
+})();
+const GOLD_SUBDIR = (() => {
+  const raw = String(process.env.ROUTECODEX_ERROR_SAMPLES_GOLD_SUBDIR || '').trim();
+  return raw || 'gold';
+})();
+
+const SHAPE_ERROR_PATTERNS = [
+  'failed to parse function arguments: missing field `cmd`',
+  'failed to parse function arguments: missing field `input`',
+  'failed to parse function arguments: missing field `command`',
+  'invalid type: map, expected a string'
+];
+
+const APPLY_PATCH_SHAPE_PATTERNS = [
+  'invalid patch',
+  'failed to parse',
+  'missing field `input`',
+  'missing field `cmd`',
+  'missing field `command`',
+  'invalid type: map, expected a string'
+];
+
+const APPLY_PATCH_NON_SHAPE_PATTERNS = [
+  'failed to find context',
+  'failed to find expected lines',
+  'failed to read file',
+  'no such file',
+  'file not found'
+];
+
+function isJsonFile(name) {
+  return name.toLowerCase().endsWith('.json');
+}
+
+async function exists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function collectSampleFiles(rootDir) {
+  const files = [];
+  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 (!isJsonFile(entry.name)) continue;
+      files.push(fullPath);
+    }
+  }
+
+  return files.sort();
+}
+
+function classifySample(raw) {
+  const lower = raw.toLowerCase();
+
+  const shapeHits = SHAPE_ERROR_PATTERNS.filter((pattern) => raw.includes(pattern));
+  if (shapeHits.length > 0) {
+    return { kind: 'shape', hits: shapeHits };
+  }
+
+  if (lower.includes('apply_patch verification failed')) {
+    const shapeMatched = APPLY_PATCH_SHAPE_PATTERNS.filter((needle) => lower.includes(needle));
+    if (shapeMatched.length > 0) {
+      return { kind: 'shape', hits: ['apply_patch verification failed (shape)'] };
+    }
+    const nonShapeMatched = APPLY_PATCH_NON_SHAPE_PATTERNS.filter((needle) => lower.includes(needle));
+    if (nonShapeMatched.length > 0) {
+      return { kind: 'non_shape', hits: ['apply_patch verification failed (context/non-shape)'] };
+    }
+    return { kind: 'non_shape', hits: ['apply_patch verification failed (unknown subtype)'] };
+  }
+
+  return { kind: 'none', hits: [] };
+}
+
+function inIgnoredSubdir(filePath) {
+  const rel = path.relative(ROOT, filePath);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    return false;
+  }
+  const parts = rel.split(path.sep).filter(Boolean);
+  return parts.includes(SKIP_SUBDIR) || parts.includes(GOLD_SUBDIR);
+}
+
+async function moveIntoSkip(filePath) {
+  const rel = path.relative(ROOT, filePath);
+  const target = path.join(ROOT, SKIP_SUBDIR, rel);
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await fs.rename(filePath, target);
+  return target;
+}
+
+async function moveIntoGold(filePath) {
+  const rel = path.relative(ROOT, filePath);
+  const target = path.join(ROOT, GOLD_SUBDIR, rel);
+  await fs.mkdir(path.dirname(target), { recursive: true });
+  await fs.rename(filePath, target);
+  return target;
+}
+
+async function main() {
+  const apply = process.argv.includes('--apply');
+
+  if (!(await exists(ROOT))) {
+    console.log(`[triage:errorsamples] skip (directory not found: ${ROOT})`);
+    return;
+  }
+
+  const files = await collectSampleFiles(ROOT);
+  if (!files.length) {
+    console.log(`[triage:errorsamples] skip (no *.json samples under ${ROOT})`);
+    return;
+  }
+
+  const shape = [];
+  const nonShape = [];
+  for (const file of files) {
+    if (inIgnoredSubdir(file)) {
+      continue;
+    }
+    let raw = '';
+    try {
+      raw = await fs.readFile(file, 'utf-8');
+    } catch {
+      continue;
+    }
+    const classified = classifySample(raw);
+    if (classified.kind === 'shape') {
+      shape.push({ file, hits: classified.hits });
+    } else if (classified.kind === 'non_shape') {
+      nonShape.push({ file, hits: classified.hits });
+    }
+  }
+
+  console.log(`[triage:errorsamples] scanned: ${files.length}`);
+  console.log(`[triage:errorsamples] shape/actionable: ${shape.length}`);
+  console.log(`[triage:errorsamples] non-shape/skip-candidate: ${nonShape.length}`);
+
+  if (shape.length > 0) {
+    console.log('[triage:errorsamples] actionable shape samples (move to gold regression set):');
+    for (const item of shape.slice(0, 20)) {
+      console.log(` - ${path.basename(item.file)} → ${item.hits.join(', ')}`);
+    }
+    if (shape.length > 20) {
+      console.log(` - ... and ${shape.length - 20} more`);
+    }
+  }
+
+  if (!apply) {
+    console.log(`[triage:errorsamples] dry-run complete (pass --apply to move shape -> ${GOLD_SUBDIR}/ and non-shape -> ${SKIP_SUBDIR}/)`);
+    return;
+  }
+
+  let movedGold = 0;
+  for (const item of shape) {
+    try {
+      await moveIntoGold(item.file);
+      movedGold += 1;
+    } catch {
+      // best-effort
+    }
+  }
+
+  let movedSkip = 0;
+  for (const item of nonShape) {
+    try {
+      await moveIntoSkip(item.file);
+      movedSkip += 1;
+    } catch {
+      // best-effort
+    }
+  }
+  console.log(`[triage:errorsamples] moved to ${GOLD_SUBDIR}/: ${movedGold}/${shape.length}`);
+  console.log(`[triage:errorsamples] moved to ${SKIP_SUBDIR}/: ${movedSkip}/${nonShape.length}`);
+}
+
+main().catch((error) => {
+  console.error('[triage:errorsamples] failed:', error);
+  process.exit(99);
+});

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

@@ -22,13 +22,40 @@ const ROOT =
   process.env.ROUTECODEX_ERROR_SAMPLES_DIR.trim().length
     ? path.resolve(process.env.ROUTECODEX_ERROR_SAMPLES_DIR)
     : path.join(os.homedir(), '.routecodex', 'errorsamples');
-
-const ERROR_PATTERNS = [
-  // exec_command / apply_patch 参数解码错误（CLI 侧报错）
+const SKIP_SUBDIR = (() => {
+  const raw = String(process.env.ROUTECODEX_ERROR_SAMPLES_SKIP_SUBDIR || '').trim();
+  return raw || 'skip';
+})();
+const GOLD_SUBDIR = (() => {
+  const raw = String(process.env.ROUTECODEX_ERROR_SAMPLES_GOLD_SUBDIR || '').trim();
+  return raw || 'gold';
+})();
+
+const SHAPE_ERROR_PATTERNS = [
+  // exec_command / shell_command / apply_patch 参数形状错误
   'failed to parse function arguments: missing field `cmd`',
   'failed to parse function arguments: missing field `input`',
-  // 历史回滚：统一 diff 校验失败
-  'apply_patch verification failed'
+  'failed to parse function arguments: missing field `command`',
+  'invalid type: map, expected a string'
+];
+
+const APPLY_PATCH_SHAPE_PATTERNS = [
+  // apply_patch 仍属于“可修复形状问题”的子类
+  'invalid patch',
+  'failed to parse',
+  'missing field `input`',
+  'missing field `cmd`',
+  'missing field `command`',
+  'invalid type: map, expected a string'
+];
+
+const APPLY_PATCH_NON_SHAPE_PATTERNS = [
+  // 这些是上下文/执行问题，不应作为“形状回归”阻塞构建
+  'failed to find context',
+  'failed to find expected lines',
+  'failed to read file',
+  'no such file',
+  'file not found'
 ];
 
 async function fileExists(p) {
@@ -43,6 +70,8 @@ async function fileExists(p) {
 async function collectSampleFiles(rootDir) {
   const files = [];
   const queue = [rootDir];
+  const skippedDirs = [];
+  const goldDirs = [];
 
   while (queue.length > 0) {
     const currentDir = queue.shift();
@@ -60,6 +89,14 @@ async function collectSampleFiles(rootDir) {
     for (const entry of entries) {
       const fullPath = path.join(currentDir, entry.name);
       if (entry.isDirectory()) {
+        if (entry.name === SKIP_SUBDIR) {
+          skippedDirs.push(fullPath);
+          continue;
+        }
+        if (entry.name === GOLD_SUBDIR) {
+          goldDirs.push(fullPath);
+          continue;
+        }
         queue.push(fullPath);
         continue;
       }
@@ -69,18 +106,38 @@ async function collectSampleFiles(rootDir) {
     }
   }
 
-  return files.sort();
+  return {
+    files: files.sort(),
+    skippedDirs,
+    goldDirs
+  };
 }
 
 async function checkFile(filePath) {
   const raw = await fs.readFile(filePath, 'utf-8');
-  const hits = [];
-  for (const pattern of ERROR_PATTERNS) {
+  const lower = raw.toLowerCase();
+  const failHits = [];
+  const warnHits = [];
+
+  for (const pattern of SHAPE_ERROR_PATTERNS) {
     if (raw.includes(pattern)) {
-      hits.push(pattern);
+      failHits.push(pattern);
+    }
+  }
+
+  if (lower.includes('apply_patch verification failed')) {
+    const shapeMatched = APPLY_PATCH_SHAPE_PATTERNS.some((needle) => lower.includes(needle));
+    const nonShapeMatched = APPLY_PATCH_NON_SHAPE_PATTERNS.some((needle) => lower.includes(needle));
+    if (shapeMatched) {
+      failHits.push('apply_patch verification failed (shape)');
+    } else if (nonShapeMatched) {
+      warnHits.push('apply_patch verification failed (context/non-shape)');
+    } else {
+      warnHits.push('apply_patch verification failed (unknown subtype)');
     }
   }
-  return hits;
+
+  return { failHits, warnHits };
 }
 
 async function main() {
@@ -89,24 +146,44 @@ async function main() {
     return;
   }
 
-  const files = await collectSampleFiles(ROOT);
+  const { files, skippedDirs, goldDirs } = await collectSampleFiles(ROOT);
   if (!files.length) {
     console.log(`[verify:errorsamples] skip (no *.json samples under ${ROOT})`);
     return;
   }
 
   console.log(`[verify:errorsamples] scanning ${files.length} sample(s) under ${ROOT}`);
+  if (skippedDirs.length > 0) {
+    console.log(`[verify:errorsamples] skip subdir "${SKIP_SUBDIR}" (${skippedDirs.length} dir(s))`);
+  }
+  if (goldDirs.length > 0) {
+    console.log(`[verify:errorsamples] gold subdir "${GOLD_SUBDIR}" (${goldDirs.length} dir(s))`);
+  }
 
   const failures = [];
+  const warnings = [];
   for (const file of files) {
-    const hits = await checkFile(file);
-    if (hits.length) {
-      failures.push({ file, hits });
+    const { failHits, warnHits } = await checkFile(file);
+    if (failHits.length) {
+      failures.push({ file, hits: failHits });
+    }
+    if (warnHits.length) {
+      warnings.push({ file, hits: warnHits });
+    }
+  }
+
+  if (warnings.length > 0) {
+    console.log(`[verify:errorsamples] warning-only samples: ${warnings.length}`);
+    for (const item of warnings.slice(0, 8)) {
+      console.log(` - ${path.basename(item.file)} → ${item.hits.join(', ')}`);
+    }
+    if (warnings.length > 8) {
+      console.log(` - ... and ${warnings.length - 8} more warning sample(s)`);
     }
   }
 
   if (!failures.length) {
-    console.log('[verify:errorsamples] ✅ no known error patterns found');
+    console.log('[verify:errorsamples] ✅ no shape-error regressions found');
     return;
   }
 

package/scripts/verify-e2e-toolcall.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import process from 'node:process';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -33,6 +33,16 @@ const AGENTS_INSTRUCTIONS = (() => {
   }
 })();
 
+function cleanupStaleServerPidFiles() {
+  try {
+    spawnSync('node', [path.join(__dirname, 'cleanup-stale-server-pids.mjs'), '--quiet'], {
+      stdio: 'ignore'
+    });
+  } catch {
+    // ignore cleanup failures
+  }
+}
+
 function readServerApiKeyFromConfig(configPath) {
   try {
     const raw = fs.readFileSync(configPath, 'utf8');
@@ -102,6 +112,7 @@ async function main() {
     await runGeminiCliStartupCheck();
   } finally {
     shutdown();
+    cleanupStaleServerPidFiles();
     if (resolved.tempDir) {
       try {
         fs.rmSync(resolved.tempDir, { recursive: true, force: true });

package/scripts/verify-install-e2e.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { once } from 'node:events';
 import { setTimeout as sleep } from 'node:timers/promises';
 import http from 'node:http';
@@ -7,26 +7,37 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-const PORT = Number(process.env.ROUTECODEX_INSTALL_VERIFY_PORT || process.env.RCC_INSTALL_VERIFY_PORT || 5560);
+const REQUESTED_PORT = Number(process.env.ROUTECODEX_INSTALL_VERIFY_PORT || process.env.RCC_INSTALL_VERIFY_PORT || 5560);
 const HOST = process.env.ROUTECODEX_INSTALL_VERIFY_HOST || '127.0.0.1';
-const BASE_URL = `http://${HOST}:${PORT}`;
+const PORT_SEARCH_LIMIT = 50;
 
-function resolveRoutecodexBinary() {
-  const prefix = process.env.npm_config_prefix || process.env.PREFIX;
-  if (prefix) {
-    const candidate = path.join(prefix, 'bin', process.platform === 'win32' ? 'routecodex.cmd' : 'routecodex');
-    if (fs.existsSync(candidate)) {
-      return candidate;
-    }
+function resolveServerEntryArgs() {
+  const serverEntry = path.join(process.cwd(), 'dist', 'index.js');
+  const modulesConfigPath = path.join(process.cwd(), 'dist', 'config', 'modules.json');
+  if (!fs.existsSync(serverEntry)) {
+    throw new Error(`verify-install-e2e missing server entry: ${serverEntry}`);
+  }
+  if (!fs.existsSync(modulesConfigPath)) {
+    throw new Error(`verify-install-e2e missing modules config: ${modulesConfigPath}`);
   }
-  return 'routecodex';
+  return [serverEntry, modulesConfigPath];
 }
 
-async function waitForHealth(timeoutMs = 60000) {
+function cleanupStaleServerPidFiles() {
+  try {
+    spawnSync('node', [path.join(process.cwd(), 'scripts', 'cleanup-stale-server-pids.mjs'), '--quiet'], {
+      stdio: 'ignore'
+    });
+  } catch {
+    // ignore cleanup failures
+  }
+}
+
+async function waitForHealth(baseUrl, timeoutMs = 60000) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
     try {
-      const res = await fetch(`${BASE_URL}/health`);
+      const res = await fetch(`${baseUrl}/health`);
       if (res.ok) {
         return;
       }
@@ -38,7 +49,7 @@ async function waitForHealth(timeoutMs = 60000) {
   throw new Error('Timed out waiting for /health');
 }
 
-async function runChatTest() {
+async function runChatTest(baseUrl) {
   const payload = {
     model: process.env.ROUTECODEX_VERIFY_CHAT_MODEL || 'glm-4.6',
     messages: [
@@ -47,7 +58,7 @@ async function runChatTest() {
     ],
     stream: false
   };
-  const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
+  const res = await fetch(`${baseUrl}/v1/chat/completions`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(payload)
@@ -66,7 +77,7 @@ async function runChatTest() {
   }
 }
 
-async function runAnthropicSseTest() {
+async function runAnthropicSseTest(baseUrl) {
   const payload = {
     model: process.env.ROUTECODEX_VERIFY_ANTHROPIC_MODEL || 'glm-4.6',
     messages: [
@@ -74,7 +85,7 @@ async function runAnthropicSseTest() {
     ],
     stream: true
   };
-  const res = await fetch(`${BASE_URL}/v1/messages`, {
+  const res = await fetch(`${baseUrl}/v1/messages`, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
@@ -115,14 +126,16 @@ async function runAnthropicSseTest() {
 }
 
 async function main() {
-  const routecodexBin = resolveRoutecodexBinary();
+  const port = await resolveVerifyPort(REQUESTED_PORT, HOST);
+  const baseUrl = `http://${HOST}:${port}`;
+  const serverArgs = resolveServerEntryArgs();
   const customConfigPath = process.env.ROUTECODEX_INSTALL_CONFIG;
   const mockServer = customConfigPath ? null : await startMockProviderServer();
-  const verifyConfigPath = customConfigPath || await writeVerifyConfig(mockServer.baseUrl);
+  const verifyConfigPath = customConfigPath || await writeVerifyConfig(mockServer.baseUrl, HOST, port);
   const env = {
     ...process.env,
-    ROUTECODEX_PORT: String(PORT),
-    RCC_PORT: String(PORT),
+    ROUTECODEX_PORT: String(port),
+    RCC_PORT: String(port),
     ROUTECODEX_HOST: HOST,
     RCC_HOST: HOST,
     ROUTECODEX_CONFIG: verifyConfigPath,
@@ -132,7 +145,7 @@ async function main() {
     // does not depend on external network availability.
     ROUTECODEX_USE_MOCK: '1'
   };
-  const server = spawn(routecodexBin, ['start'], {
+  const server = spawn(process.execPath, serverArgs, {
     env,
     stdio: ['ignore', 'pipe', 'pipe']
   });
@@ -154,9 +167,9 @@ async function main() {
   });
 
   try {
-    await waitForHealth();
-    await runChatTest();
-    await runAnthropicSseTest();
+    await waitForHealth(baseUrl);
+    await runChatTest(baseUrl);
+    await runAnthropicSseTest(baseUrl);
   } finally {
     if (!serverExited) {
       server.kill('SIGTERM');
@@ -165,6 +178,7 @@ async function main() {
     if (mockServer) {
       await mockServer.close();
     }
+    cleanupStaleServerPidFiles();
   }
 }
 
@@ -284,14 +298,14 @@ function extractUserPrompt(payload) {
     : 'verification prompt';
 }
 
-async function writeVerifyConfig(baseUrl) {
+async function writeVerifyConfig(baseUrl, host, port) {
   const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'routecodex-verify-'));
   const filePath = path.join(dir, 'config.json');
   const config = {
     version: '1.0.0',
     httpserver: {
-      host: HOST,
-      port: PORT
+      host,
+      port
     },
     virtualrouter: {
       inputProtocol: 'openai',
@@ -324,3 +338,30 @@ async function writeVerifyConfig(baseUrl) {
   await fs.promises.writeFile(filePath, JSON.stringify(config, null, 2), 'utf8');
   return filePath;
 }
+
+async function resolveVerifyPort(preferredPort, host) {
+  const basePort = Number.isFinite(preferredPort) && preferredPort > 0 ? preferredPort : 5560;
+  for (let offset = 0; offset < PORT_SEARCH_LIMIT; offset += 1) {
+    const port = basePort + offset;
+    // eslint-disable-next-line no-await-in-loop
+    if (await canListenOnPort(port, host)) {
+      return port;
+    }
+  }
+  throw new Error(`No available verification port in range ${basePort}-${basePort + PORT_SEARCH_LIMIT - 1}`);
+}
+
+async function canListenOnPort(port, host) {
+  const probe = http.createServer();
+  try {
+    await new Promise((resolve, reject) => {
+      probe.once('error', reject);
+      probe.listen(port, host, resolve);
+    });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    await new Promise((resolve) => probe.close(() => resolve(undefined))).catch(() => {});
+  }
+}