@jsonstudio/rcc 0.90.814 → 0.90.876

package/scripts/monitor/memory-guard.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+/**
+ * RouteCodex memory guard (PID-scoped, no broad kill).
+ *
+ * Usage:
+ *   node scripts/monitor/memory-guard.mjs --port 5555 --rss-mb 8192
+ *   node scripts/monitor/memory-guard.mjs --port 5555 --rss-mb 4096 --action restart
+ *   node scripts/monitor/memory-guard.mjs --port 5555 --rss-mb 2048 --once
+ */
+
+import { execSync, spawnSync } from 'node:child_process';
+
+function parseArgs(argv) {
+  const options = {
+    port: 5555,
+    rssMb: 8192,
+    intervalMs: 2000,
+    graceMs: 5000,
+    action: 'kill', // kill | restart
+    once: false
+  };
+  const args = argv.slice(2);
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--port' && i + 1 < args.length) {
+      options.port = Number.parseInt(String(args[++i]), 10);
+      continue;
+    }
+    if (arg === '--rss-mb' && i + 1 < args.length) {
+      options.rssMb = Number.parseInt(String(args[++i]), 10);
+      continue;
+    }
+    if (arg === '--interval-ms' && i + 1 < args.length) {
+      options.intervalMs = Number.parseInt(String(args[++i]), 10);
+      continue;
+    }
+    if (arg === '--grace-ms' && i + 1 < args.length) {
+      options.graceMs = Number.parseInt(String(args[++i]), 10);
+      continue;
+    }
+    if (arg === '--action' && i + 1 < args.length) {
+      const action = String(args[++i]).trim().toLowerCase();
+      options.action = action === 'restart' ? 'restart' : 'kill';
+      continue;
+    }
+    if (arg === '--once') {
+      options.once = true;
+      continue;
+    }
+  }
+  if (!Number.isFinite(options.port) || options.port <= 0) {
+    throw new Error(`invalid --port: ${options.port}`);
+  }
+  if (!Number.isFinite(options.rssMb) || options.rssMb <= 0) {
+    throw new Error(`invalid --rss-mb: ${options.rssMb}`);
+  }
+  if (!Number.isFinite(options.intervalMs) || options.intervalMs < 200) {
+    options.intervalMs = 2000;
+  }
+  if (!Number.isFinite(options.graceMs) || options.graceMs < 0) {
+    options.graceMs = 5000;
+  }
+  return options;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function log(line) {
+  console.log(`[${nowIso()}] [memory-guard] ${line}`);
+}
+
+function runStdout(command) {
+  try {
+    return String(execSync(command, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }) || '').trim();
+  } catch {
+    return '';
+  }
+}
+
+function resolveListenerPid(port) {
+  const out = runStdout(`lsof -t -nP -iTCP:${port} -sTCP:LISTEN | head -n 1`);
+  const pid = Number.parseInt(out, 10);
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+
+function readPidCommand(pid) {
+  return runStdout(`ps -o command= -p ${pid}`);
+}
+
+function readPidRssMb(pid) {
+  const out = runStdout(`ps -o rss= -p ${pid}`);
+  const rssKb = Number.parseInt(out, 10);
+  if (!Number.isFinite(rssKb) || rssKb <= 0) {
+    return null;
+  }
+  return Math.round((rssKb / 1024) * 10) / 10;
+}
+
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isLikelyRouteCodexProcess(commandText) {
+  const text = String(commandText || '').toLowerCase();
+  return (
+    text.includes('routecodex')
+    || text.includes('dist/index.js')
+    || (text.includes('node') && text.includes('rcc'))
+  );
+}
+
+async function terminatePidScoped(pid, graceMs) {
+  log(`threshold exceeded, terminate pid=${pid} with SIGTERM`);
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (error) {
+    log(`SIGTERM failed for pid=${pid}: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  const deadline = Date.now() + graceMs;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(pid)) {
+      log(`pid=${pid} exited after SIGTERM`);
+      return;
+    }
+    await sleep(250);
+  }
+  if (isPidAlive(pid)) {
+    log(`pid=${pid} still alive after ${graceMs}ms, escalate SIGKILL`);
+    try {
+      process.kill(pid, 'SIGKILL');
+    } catch (error) {
+      log(`SIGKILL failed for pid=${pid}: ${error instanceof Error ? error.message : String(error)}`);
+      return;
+    }
+  }
+}
+
+function restartRouteCodex(port) {
+  log(`attempt restart on port=${port}`);
+  const result = spawnSync('routecodex', ['restart', '--port', String(port)], {
+    stdio: 'inherit'
+  });
+  if ((result.status ?? 1) !== 0) {
+    log(`restart failed with status=${result.status ?? -1}`);
+  } else {
+    log('restart completed');
+  }
+}
+
+async function evaluateOnce(options) {
+  const pid = resolveListenerPid(options.port);
+  if (!pid) {
+    log(`no listener found on port=${options.port}`);
+    return;
+  }
+  const cmd = readPidCommand(pid);
+  const rssMb = readPidRssMb(pid);
+  if (!isLikelyRouteCodexProcess(cmd)) {
+    log(`skip pid=${pid}, command does not look like RouteCodex: ${cmd}`);
+    return;
+  }
+  if (rssMb === null) {
+    log(`pid=${pid} rss unavailable`);
+    return;
+  }
+  log(`pid=${pid} rss=${rssMb}MB threshold=${options.rssMb}MB`);
+  if (rssMb < options.rssMb) {
+    return;
+  }
+  await terminatePidScoped(pid, options.graceMs);
+  if (options.action === 'restart') {
+    restartRouteCodex(options.port);
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv);
+  log(
+    `start port=${options.port} rssMb=${options.rssMb} intervalMs=${options.intervalMs} action=${options.action} once=${options.once}`
+  );
+  if (options.once) {
+    await evaluateOnce(options);
+    return;
+  }
+  while (true) {
+    await evaluateOnce(options);
+    await sleep(options.intervalMs);
+  }
+}
+
+main().catch((error) => {
+  log(`fatal: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});
+

package/scripts/pack-mode.mjs

@@ -62,18 +62,36 @@ function installLocalLlmsFromTarball() {
     if ((pack.status ?? 0) !== 0) {
       throw new Error(`npm pack ${localLlmsDir} failed`);
     }
-    const lines = String(pack.stdout || '')
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean);
-    const tarballName = lines[lines.length - 1];
-    if (!tarballName) {
-      throw new Error('npm pack local llms produced empty tarball name');
-    }
-    const tarballPath = path.join(tmpDir, tarballName);
-    if (!exists(tarballPath)) {
-      throw new Error(`local llms tarball missing: ${tarballPath}`);
+
+    const streamText = `${String(pack.stdout || '')}\n${String(pack.stderr || '')}`;
+    const candidates = Array.from(
+      new Set(
+        streamText
+          .split(/\s+/)
+          .map((token) => token.trim())
+          .filter((token) => token.endsWith('.tgz'))
+      )
+    );
+
+    const tarballsInTmp = (() => {
+      try {
+        return fs.readdirSync(tmpDir)
+          .filter((name) => name.endsWith('.tgz'))
+          .map((name) => path.join(tmpDir, name));
+      } catch {
+        return [];
+      }
+    })();
+
+    const resolvedCandidates = candidates
+      .map((token) => (path.isAbsolute(token) ? token : path.join(tmpDir, token)))
+      .filter((candidatePath) => exists(candidatePath));
+
+    const tarballPath = resolvedCandidates[0] || tarballsInTmp[0] || '';
+    if (!tarballPath) {
+      throw new Error(`local llms tarball missing (stdout=${JSON.stringify(String(pack.stdout || '').trim())})`);
     }
+
     runNpm(['install', '--no-audit', '--no-fund', '--no-save', tarballPath]);
   } finally {
     fs.rmSync(tmpDir, { recursive: true, force: true });
@@ -108,13 +126,10 @@ function readLocalLlmsVersion() {
 
 const isDevPkg = args.name === 'routecodex';
 const isRcc = args.name === 'rcc' || args.name === '@jsonstudio/rcc';
-const isRccx = args.name === '@jsonstudio/rccx';
 
 let hadDevLink = false;
-if (!isRccx) {
-  hadDevLink = isSymlink(llmsPath);
-  runEnsureMode('release');
-}
+hadDevLink = isSymlink(llmsPath);
+runEnsureMode('release');
 
 const original = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
 fs.writeFileSync(backupPath, JSON.stringify(original, null, 2));
@@ -138,7 +153,7 @@ try {
   mutated.name = args.name;
   mutated.bin = { [args.bin]: 'dist/cli.js' };
   // Ensure description mentions mode
-  const suffix = (isRcc || isRccx) ? ' (release)' : ' (dev)';
+  const suffix = isRcc ? ' (release)' : ' (dev)';
   mutated.description = String(original.description || 'RouteCodex')
     .replace(/\s*\((dev|release)\)$/, '')
     .concat(suffix);
@@ -189,25 +204,6 @@ try {
       }
       mutated.files = baseFiles;
     }
-  } else if (isRccx) {
-    // rccx: wasm-backed llms 核心，通过 npm alias 将 @jsonstudio/llms 指向 wasm 引擎包。
-    mutated.bundledDependencies = [];
-    mutated.bundleDependencies = [];
-
-    const deps = { ...(original.dependencies || {}) };
-    // 移除原有 TS 版 llms 直连依赖
-    if (deps['@jsonstudio/llms']) {
-      delete deps['@jsonstudio/llms'];
-    }
-    // 推断 wasm 引擎版本，若未声明则使用本地 llms-engine 缺省版本
-    const engineVersion = deps['@jsonstudio/llms-engine'] || '^0.3.0';
-    deps['@jsonstudio/llms-engine'] = engineVersion;
-    // 通过 npm alias 保持 import 形状不变
-    deps['@jsonstudio/llms'] = `npm:@jsonstudio/llms-engine@${engineVersion}`;
-    deps.ajv = deps.ajv || '^8.17.1';
-    deps.zod = deps.zod || '^3.23.8';
-
-    mutated.dependencies = deps;
   }
   fs.writeFileSync(pkgPath, JSON.stringify(mutated, null, 2));
 

package/scripts/publish-rcc.mjs

@@ -6,98 +6,76 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '..');
-const PACK_SCRIPT = path.join(PROJECT_ROOT, 'scripts', 'pack-mode.mjs');
 const pkgPath = path.join(PROJECT_ROOT, 'package.json');
-const llmsPath = path.join(PROJECT_ROOT, 'node_modules', '@jsonstudio', 'llms');
-const localLlmsPkgPath = path.join(PROJECT_ROOT, 'sharedmodule', 'llmswitch-core', 'package.json');
 
 function parseArgs(argv) {
-  const out = {};
+  const out = { passthrough: [] };
   for (let i = 2; i < argv.length; i++) {
     const a = argv[i];
     if (a === '--llms-tgz') { out.llmsTgz = argv[++i]; continue; }
     if (a === '--llms-version') { out.llmsVersion = argv[++i]; continue; }
+    if (a === '--tag') { out.tag = argv[++i]; continue; }
+    if (a === '--dry-run') { out.dryRun = true; continue; }
+    out.passthrough.push(a);
   }
   return out;
 }
 
-function exists(p) {
-  try {
-    fs.accessSync(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 function run(command, args, options = {}) {
-  const res = spawnSync(command, args, { stdio: 'inherit', ...options });
+  const res = spawnSync(command, args, { stdio: 'inherit', cwd: PROJECT_ROOT, ...options });
   if ((res.status ?? 0) !== 0) {
     throw new Error(`${command} ${args.join(' ')} failed`);
   }
 }
 
+function readPkgVersion() {
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+  return String(pkg.version || '').trim();
+}
+
 try {
   const args = parseArgs(process.argv);
-  const llmsTgz = String(args.llmsTgz || process.env.RCC_LLMS_TGZ || '').trim();
-  const llmsVersion = String(
-    args.llmsVersion ||
-    process.env.RCC_LLMS_VERSION ||
-    (exists(localLlmsPkgPath) ? JSON.parse(fs.readFileSync(localLlmsPkgPath, 'utf-8')).version : '')
-  ).trim();
 
-  const hadDevLink = (() => {
-    try {
-      return fs.lstatSync(llmsPath).isSymbolicLink();
-    } catch {
-      return false;
-    }
-  })();
+  // 始终内联本地 llms，避免发布流程改动全局 llms link。
+  const env = {
+    ...process.env,
+    RCC_LLMS_INLINE_LOCAL: process.env.RCC_LLMS_INLINE_LOCAL ?? '1'
+  };
 
-  if (llmsTgz) {
-    if (!exists(llmsTgz)) {
-      throw new Error(`--llms-tgz not found: ${llmsTgz}`);
-    }
-    if (hadDevLink) {
-      run(process.execPath, [path.join(PROJECT_ROOT, 'scripts', 'link-llmswitch.mjs'), 'unlink'], { cwd: PROJECT_ROOT });
-    }
-    run('npm', ['install', '--no-audit', '--no-fund', '--no-save', llmsTgz], { cwd: PROJECT_ROOT });
+  const packArgs = ['run', 'pack:rcc', '--'];
+  if (args.llmsTgz) {
+    packArgs.push('--llms-tgz', String(args.llmsTgz));
+  }
+  if (args.llmsVersion) {
+    packArgs.push('--llms-version', String(args.llmsVersion));
   }
 
-  // 1) 使用 release 模式构建 dist。若存在本地 sharedmodule/llmswitch-core，则 release 也以其为唯一真源。
-  run('npm', ['run', 'build:min'], {
-    cwd: PROJECT_ROOT,
-    env: { ...process.env, BUILD_MODE: 'release', ...(llmsVersion ? { RCC_LLMS_VERSION: llmsVersion } : {}) }
-  });
+  run('npm', packArgs, { env });
 
-  // 2) 通过 pack-mode 生成 rcc tarball（内部会临时切换 package.json.name/bin，并同步 llms 版本声明）
-  run(
-    process.execPath,
-    [PACK_SCRIPT, '--name', '@jsonstudio/rcc', '--bin', 'rcc'],
-    { cwd: PROJECT_ROOT, env: { ...process.env, ...(llmsVersion ? { RCC_LLMS_VERSION: llmsVersion } : {}) } }
-  );
+  const version = readPkgVersion();
+  if (!version) {
+    throw new Error('failed to read version from package.json after pack:rcc');
+  }
 
-  // 构建过程中版本号可能被 bump（gen-build-info 会 auto-bump），因此需要在 pack 之后重新读取版本号
-  const updatedPkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-  const version = updatedPkg.version;
   const tarballName = `jsonstudio-rcc-${version}.tgz`;
   const tarballPath = path.join(PROJECT_ROOT, tarballName);
-
   if (!fs.existsSync(tarballPath)) {
     throw new Error(`tarball not found: ${tarballPath}`);
   }
 
-  // 3) 发布 npm 包
-  run('npm', ['publish', tarballName], { cwd: PROJECT_ROOT });
-
-  // 4) 发布结束后恢复 dev 模式（routecodex 约定始终为 dev CLI；rcc 发布时才切 release）。
-  if (hadDevLink) {
-    run('npm', ['run', 'llmswitch:ensure'], {
-      cwd: PROJECT_ROOT,
-      env: { ...process.env, BUILD_MODE: 'dev' }
-    });
+  const publishArgs = ['publish', tarballName];
+  if (args.tag) {
+    publishArgs.push('--tag', String(args.tag));
   }
+  if (args.dryRun) {
+    publishArgs.push('--dry-run');
+  }
+  if (args.passthrough.length > 0) {
+    publishArgs.push(...args.passthrough);
+  }
+
+  run('npm', publishArgs);
 } catch (err) {
-  console.error('[publish-rcc] failed:', err.message);
+  console.error('[publish-rcc] failed:', err instanceof Error ? err.message : String(err));
   process.exit(1);
 }

package/scripts/tests/apply-patch-loop.mjs

@@ -671,6 +671,7 @@ async function main() {
     configPath: file,
     env: {
       ROUTECODEX_USE_MOCK: '1',
+      ROUTECODEX_ALLOW_MOCK_RUNTIME: '1',
       ROUTECODEX_MOCK_CONFIG_PATH: file,
       ROUTECODEX_MOCK_SAMPLES_DIR: MOCK_SAMPLES_DIR,
       ROUTECODEX_MOCK_VALIDATE_NAMES: '1',

package/scripts/tests/blackbox-rcc-vs-routecodex-antigravity.mjs

@@ -534,6 +534,8 @@ async function runOnceBlackbox(opts) {
     // Disable ManagerDaemon (quota/health background tasks) so the parity run is isolated and deterministic.
     ROUTECODEX_USE_MOCK: '1',
     RCC_USE_MOCK: '1',
+    ROUTECODEX_ALLOW_MOCK_RUNTIME: '1',
+    RCC_ALLOW_MOCK_RUNTIME: '1',
     // Disable token daemon + OAuth auto-open to keep the blackbox test non-interactive.
     ROUTECODEX_DISABLE_TOKEN_DAEMON: '1',
     RCC_DISABLE_TOKEN_DAEMON: '1',

package/scripts/tools-dev/responses-debug-client/src/index.ts

@@ -10,6 +10,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
 import OpenAI from 'openai';
+import { redactSensitiveData } from '../../../../src/utils/sensitive-redaction.js';
 
 type Unknown = Record<string, any>;
 
@@ -100,11 +101,11 @@ async function main() {
     const dir = path.join(String(home), '.routecodex', 'codex-samples', 'responses-client');
     await fs.mkdir(dir, { recursive: true });
     const out = path.join(dir, `${clientRequestId}_client-request.json`);
-    await fs.writeFile(out, JSON.stringify({
+    await fs.writeFile(out, JSON.stringify(redactSensitiveData({
       timestamp: new Date().toISOString(),
       baseURL,
       request: reqBody
-    }, null, 2), 'utf-8');
+    }), null, 2), 'utf-8');
     if (!raw) console.log(`[${nowIso()}] saved client snapshot: ${out}`);
   } catch { /* non-blocking */ }
 
@@ -130,7 +131,11 @@ async function main() {
     try {
       const dir = path.resolve(process.cwd(), 'logs', 'responses-debug', responseId || 'unknown');
       await fs.mkdir(dir, { recursive: true });
-      await fs.appendFile(path.join(dir, 'events.jsonl'), JSON.stringify({ ts: Date.now(), ...o }) + '\n', 'utf-8');
+      await fs.appendFile(
+        path.join(dir, 'events.jsonl'),
+        JSON.stringify(redactSensitiveData({ ts: Date.now(), ...o })) + '\n',
+        'utf-8'
+      );
     } catch { /* ignore */ }
   };
 

package/scripts/verify-e2e-toolcall.mjs

@@ -80,6 +80,7 @@ async function main() {
   };
   if (resolved.mode === 'mock') {
     serverEnv.ROUTECODEX_USE_MOCK = '1';
+    serverEnv.ROUTECODEX_ALLOW_MOCK_RUNTIME = '1';
     serverEnv.ROUTECODEX_MOCK_CONFIG_PATH = resolved.configPath;
     serverEnv.ROUTECODEX_MOCK_VALIDATE_NAMES = '1';
   }

package/scripts/verify-install-e2e.mjs

@@ -145,7 +145,8 @@ async function main() {
     RCC4_CONFIG_PATH: verifyConfigPath,
     // Install verification uses a mock upstream; skip ManagerDaemon modules (token/quota) so startup
     // does not depend on external network availability.
-    ROUTECODEX_USE_MOCK: '1'
+    ROUTECODEX_USE_MOCK: '1',
+    ROUTECODEX_ALLOW_MOCK_RUNTIME: '1'
   };
   const server = spawn(process.execPath, serverArgs, {
     env,