@jsonstudio/rcc 0.89.3 → 0.89.168

package/scripts/classify-sample-tools.mjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+
+const suffix = '_req_process_tool_filters_request_pre.json';
+const sampleRoot = process.argv[2] || path.join(os.homedir(), '.routecodex', 'codex-samples');
+
+const SHELL_PATTERNS = {
+  read: [
+    'ls',
+    'dir ',
+    'pwd',
+    'cat ',
+    'type ',
+    'head ',
+    'tail ',
+    'stat',
+    'tree',
+    'wc ',
+    'du ',
+    'printf "',
+    'python - <<',
+    'python -c',
+    'node - <<',
+    'node -e',
+    'codesign --display'
+  ],
+  search: [
+    'rg ',
+    'rg-',
+    'grep ',
+    'grep-',
+    'ripgrep',
+    'find ',
+    'fd ',
+    'locate ',
+    'search ',
+    'codesearch',
+    'ack ',
+    'ag ',
+    'where ',
+    'which '
+  ],
+  write: [
+    'apply_patch',
+    'sed -i',
+    'perl -pi',
+    'tee ',
+    'cat <<',
+    'cat >',
+    'printf >',
+    'touch ',
+    'truncate',
+    'mkdir',
+    'mktemp',
+    'rmdir',
+    'rm ',
+    'rm -',
+    'unlink',
+    'mv ',
+    'cp ',
+    'ln -',
+    'chmod',
+    'chown',
+    'chgrp',
+    'tar xf',
+    'tar cf',
+    'git add',
+    'git commit',
+    'git apply',
+    'git am',
+    'git rebase',
+    'git checkout',
+    'git merge',
+    'patch <<',
+    'npm install',
+    'pnpm install',
+    'yarn add',
+    'yarn install',
+    'pip install',
+    'pip3 install',
+    'brew install',
+    'cargo add',
+    'cargo install',
+    'go install',
+    'make install'
+  ]
+};
+
+function canonicalizeToolName(name) {
+  if (!name) return '';
+  const trimmed = name.trim();
+  const idx = trimmed.indexOf('arg_');
+  if (idx > 0) return trimmed.slice(0, idx);
+  return trimmed;
+}
+
+function normalizeCommand(cmd) {
+  if (!cmd) return '';
+  if (Array.isArray(cmd)) return cmd.join(' ');
+  if (typeof cmd === 'object') {
+    if (cmd.command) return normalizeCommand(cmd.command);
+    if (cmd.args) return normalizeCommand(cmd.args);
+    try {
+    return JSON.stringify(cmd);
+  } catch {
+    return String(cmd);
+  }
+  }
+  return String(cmd || '').trim();
+}
+
+function detectCategory(tool, cmd) {
+  if (!tool) return 'other';
+  const lowTool = tool.toLowerCase();
+  if (lowTool === 'apply_patch') return 'write';
+  if (lowTool === 'describe_current_request') return 'read';
+  if (lowTool === 'list_mcp_resources' || lowTool === 'list_mcp_tools') return 'other';
+  if (lowTool === 'update_plan') return 'other';
+
+  const normalizedCmd = cmd.toLowerCase();
+  if (lowTool === 'shell_command' || lowTool === 'shell' || lowTool === 'bash') {
+    return detectShellCommandCategory(normalizedCmd);
+  }
+  if (matchesAny(normalizedCmd, SHELL_PATTERNS.write)) return 'write';
+  if (matchesAny(normalizedCmd, SHELL_PATTERNS.search)) return 'search';
+  if (matchesAny(normalizedCmd, SHELL_PATTERNS.read)) return 'read';
+  return 'other';
+}
+
+function detectShellCommandCategory(cmd) {
+  if (!cmd) return 'other';
+  const segments = splitCommandSegments(cmd);
+  if (segments.some((seg) => matchesAny(seg, SHELL_PATTERNS.write))) return 'write';
+  if (segments.some((seg) => matchesAny(seg, SHELL_PATTERNS.search))) return 'search';
+  if (segments.some((seg) => matchesAny(seg, SHELL_PATTERNS.read))) return 'read';
+  return 'other';
+}
+
+function splitCommandSegments(cmd) {
+  return cmd
+    .split(/[\n;&]+/)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+}
+
+function matchesAny(text, patterns) {
+  const lower = text.toLowerCase();
+  return patterns.some((pattern) => lower.includes(pattern.toLowerCase()));
+}
+
+async function listCandidateFiles(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  const out = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...(await listCandidateFiles(full)));
+    } else if (entry.isFile() && entry.name.endsWith(suffix)) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function extractRequestKey(filePath) {
+  const base = path.basename(filePath);
+  const match = base.match(/^(req_\d+_[^_]+)/);
+  return match ? match[1] : base;
+}
+
+function ensureSummary(summary, tool) {
+  if (!summary.has(tool)) {
+    summary.set(tool, {
+      total: 0,
+      categories: { read: 0, write: 0, search: 0, other: 0 },
+      samples: []
+    });
+  }
+  return summary.get(tool);
+}
+
+function recordSample(summary, tool, category, command, filePath) {
+  const item = ensureSummary(summary, tool);
+  item.total += 1;
+  item.categories[category] += 1;
+  if (item.samples.length < 5) {
+    item.samples.push({ category, command, file: path.basename(filePath) });
+  }
+}
+
+async function main() {
+  const protocols = await fs.readdir(sampleRoot, { withFileTypes: true });
+  const files = [];
+  for (const proto of protocols) {
+    if (!proto.isDirectory()) continue;
+    const dir = path.join(sampleRoot, proto.name);
+    const protoFiles = await listCandidateFiles(dir);
+    files.push(...protoFiles);
+  }
+  files.sort((a, b) => a.localeCompare(b));
+  const summary = new Map();
+  const processedRequests = new Set();
+  for (const filePath of files) {
+    const reqKey = extractRequestKey(filePath);
+    if (processedRequests.has(reqKey)) {
+      continue;
+    }
+    processedRequests.add(reqKey);
+    let data;
+    try {
+      const raw = await fs.readFile(filePath, 'utf8');
+      data = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const messages = Array.isArray(data?.messages) ? data.messages : [];
+    for (const msg of messages) {
+      if (!msg || msg.role !== 'assistant') continue;
+      if (!Array.isArray(msg.tool_calls)) continue;
+      for (const call of msg.tool_calls) {
+        const name = canonicalizeToolName(call?.function?.name || call?.name || '');
+        if (!name) continue;
+        let parsedArgs;
+        if (typeof call?.function?.arguments === 'string') {
+          try {
+            parsedArgs = JSON.parse(call.function.arguments);
+          } catch {
+            parsedArgs = undefined;
+          }
+        } else if (call?.function?.arguments && typeof call.function.arguments === 'object') {
+          parsedArgs = call.function.arguments;
+        }
+        const command = normalizeCommand(parsedArgs?.command || parsedArgs?.input || parsedArgs?.args || parsedArgs);
+        const category = detectCategory(name, command);
+        recordSample(summary, name, category, command, filePath);
+      }
+    }
+  }
+
+  const result = Array.from(summary.entries())
+    .map(([name, info]) => ({ name, ...info }))
+    .sort((a, b) => b.total - a.total);
+
+  console.log(JSON.stringify({ sampleRoot, toolCount: result.length, tools: result }, null, 2));
+}
+
+main().catch((err) => {
+  console.error('Failed to classify tools:', err);
+  process.exit(1);
+});

package/scripts/ensure-llmswitch-mode.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+
+const rawMode = String(process.env.BUILD_MODE || process.env.RCC_BUILD_MODE || 'release').toLowerCase();
+const mode = rawMode === 'dev' ? 'dev' : 'release';
+
+const sharedCoreDir = path.join(PROJECT_ROOT, 'sharedmodule', 'llmswitch-core');
+const nodeModulesScope = path.join(PROJECT_ROOT, 'node_modules', '@jsonstudio');
+const llmsPath = path.join(nodeModulesScope, 'llms');
+
+function runNodeScript(relativePath, args = []) {
+  const scriptPath = path.join(PROJECT_ROOT, relativePath);
+  const res = spawnSync(process.execPath, [scriptPath, ...args], { stdio: 'inherit' });
+  if ((res.status ?? 0) !== 0) {
+    process.exit(res.status ?? 2);
+  }
+}
+
+function isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+function readLink(p) {
+  try {
+    return fs.readlinkSync(p);
+  } catch {
+    return null;
+  }
+}
+
+function exists(p) {
+  try {
+    fs.accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ensureDevLink() {
+  if (!exists(sharedCoreDir)) {
+    console.error(`[llmswitch:ensure] BUILD_MODE=dev 但未找到 ${sharedCoreDir}`);
+    console.error('[llmswitch:ensure] 请先 clone sharedmodule/llmswitch-core，或改用 BUILD_MODE=release');
+    process.exit(2);
+  }
+  if (isSymlink(llmsPath)) {
+    const target = readLink(llmsPath);
+    if (target) {
+      const resolved = path.resolve(nodeModulesScope, target);
+      const expected = path.resolve(sharedCoreDir);
+      if (resolved === expected) {
+        console.log('[llmswitch:ensure] dev link ok: node_modules/@jsonstudio/llms -> sharedmodule/llmswitch-core');
+        return;
+      }
+    }
+  }
+  console.log('[llmswitch:ensure] linking dev core: node_modules/@jsonstudio/llms -> sharedmodule/llmswitch-core');
+  runNodeScript('scripts/link-llmswitch.mjs');
+}
+
+function ensureReleasePackage() {
+  if (isSymlink(llmsPath)) {
+    console.log('[llmswitch:ensure] release mode: unlinking node_modules/@jsonstudio/llms symlink');
+    runNodeScript('scripts/link-llmswitch.mjs', ['unlink']);
+  }
+  const pkgPath = path.join(llmsPath, 'package.json');
+  if (!exists(pkgPath)) {
+    console.log('[llmswitch:ensure] BUILD_MODE=release: installing @jsonstudio/llms via npm (missing in node_modules)');
+    const res = spawnSync('npm', ['install', '--no-audit', '--no-fund'], { cwd: PROJECT_ROOT, stdio: 'inherit' });
+    if ((res.status ?? 0) !== 0) {
+      process.exit(res.status ?? 2);
+    }
+    if (!exists(pkgPath)) {
+      console.error('[llmswitch:ensure] npm install completed but @jsonstudio/llms is still missing');
+      process.exit(2);
+    }
+  }
+  console.log('[llmswitch:ensure] release package ok: using npm-installed @jsonstudio/llms');
+}
+
+if (mode === 'dev') {
+  ensureDevLink();
+} else {
+  ensureReleasePackage();
+}

package/scripts/gen-build-info.mjs

@@ -4,16 +4,32 @@ import path from 'node:path';
 
 const cwd = process.cwd();
 const pkgPath = path.join(cwd, 'package.json');
+const lockPath = path.join(cwd, 'package-lock.json');
 const outPath = path.join(cwd, 'src', 'build-info.ts');
 
 const mode = String(process.env.BUILD_MODE || process.env.RCC_BUILD_MODE || 'release').toLowerCase();
 const valid = new Set(['dev', 'release']);
 const buildMode = valid.has(mode) ? mode : 'release';
 
-let version = '0.0.0';
-try {
-  version = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version || version;
-} catch {}
+const skipAutoBump = ['1', 'true', 'yes'].includes(
+  String(process.env.ROUTECODEX_SKIP_AUTO_BUMP || process.env.BUILD_SKIP_AUTO_BUMP || '').trim().toLowerCase()
+);
+
+const pkg = readJson(pkgPath);
+let version = typeof pkg?.version === 'string' ? pkg.version : '0.0.0';
+
+if (!skipAutoBump) {
+  const nextVersion = bumpPatchVersion(version);
+  if (nextVersion !== version) {
+    version = nextVersion;
+    if (pkg) {
+      pkg.version = nextVersion;
+      writeJson(pkgPath, pkg);
+      updatePackageLock(lockPath, nextVersion);
+      console.log(`[build-info] auto-bump version → ${nextVersion}`);
+    }
+  }
+}
 
 const content = `// Auto-generated by scripts/gen-build-info.mjs
 export interface BuildInfo { mode: 'dev' | 'release'; version: string; buildTime: string }
@@ -28,3 +44,41 @@ fs.mkdirSync(path.dirname(outPath), { recursive: true });
 fs.writeFileSync(outPath, content, 'utf-8');
 console.log(`[build-info] mode=${buildMode} version=${version} → ${outPath}`);
 
+function readJson(targetPath) {
+  try {
+    return JSON.parse(fs.readFileSync(targetPath, 'utf-8'));
+  } catch {
+    return undefined;
+  }
+}
+
+function writeJson(targetPath, data) {
+  fs.writeFileSync(targetPath, `${JSON.stringify(data, null, 2)}\n`, 'utf-8');
+}
+
+function bumpPatchVersion(input) {
+  if (!input || typeof input !== 'string') {
+    return '0.0.001';
+  }
+  const segments = input.split('.');
+  while (segments.length < 3) {
+    segments.push('0');
+  }
+  const [major, minor, patchRaw] = segments;
+  const parsedPatch = Number.parseInt(patchRaw, 10);
+  const nextPatch = Number.isFinite(parsedPatch) ? parsedPatch + 1 : 1;
+  const formattedPatch = String(nextPatch).padStart(3, '0');
+  return `${major}.${minor}.${formattedPatch}`;
+}
+
+function updatePackageLock(targetPath, version) {
+  const lock = readJson(targetPath);
+  if (!lock) {
+    return;
+  }
+  lock.version = version;
+  if (lock.packages && lock.packages['']) {
+    lock.packages[''].version = version;
+  }
+  writeJson(targetPath, lock);
+}

package/scripts/install-global.sh

@@ -82,7 +82,7 @@ build_project() {
     # 构建项目
     echo "🔨 编译TypeScript..."
     # dev 包：显式使用 BUILD_MODE=dev 以便在编译期区分 dev/release
-   BUILD_MODE=dev timeout 300 npm run build || {
+   BUILD_MODE=dev ROUTECODEX_SKIP_AUTO_BUMP=1 timeout 300 npm run build || {
        echo "❌ 构建超时或失败"
        echo "💡 尝试手动构建：npm run build"
        exit 1

package/scripts/install-release.sh

@@ -18,6 +18,13 @@ echo "🔨 构建源码..."
 # release 包：显式使用 BUILD_MODE=release 以便在编译期区分 dev/release
 BUILD_MODE=release npm run build
 
+# 构建过程可能自动 bump 版本号，因此需要重新读取
+NEW_VERSION=$(node -p "require('./package.json').version" 2>/dev/null || echo "${VERSION}")
+if [ "${NEW_VERSION}" != "${VERSION}" ]; then
+  echo "ℹ️  构建后版本变更: ${VERSION} → ${NEW_VERSION}"
+  VERSION=${NEW_VERSION}
+fi
+
 TMP_DIR=$(mktemp -d "${TMPDIR:-/tmp}/rcc-release.XXXXXX")
 TARBALL="routecodex-${VERSION}.tgz"
 

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

@@ -23,7 +23,7 @@ function resolveSamplesDir() {
 }
 
 function parseEntryFilter() {
-  const raw = String(process.env.ROUTECODEX_MOCK_ENTRY_FILTER || 'openai-chat').trim();
+  const raw = String(process.env.ROUTECODEX_MOCK_ENTRY_FILTER || 'openai-chat,openai-responses').trim();
   if (!raw || raw.toLowerCase() === 'all') {
     return null;
   }
@@ -57,15 +57,23 @@ async function loadRegistry() {
   });
 }
 
-async function loadSampleDocument(sample) {
+async function loadSampleDocument(sample, options = {}) {
+  const fileName = options.fileName || 'request.json';
   const sampleDir = path.join(MOCK_SAMPLES_DIR, sample.path);
-  const requestPath = path.join(sampleDir, 'request.json');
-  const raw = await fs.readFile(requestPath, 'utf-8');
-  const doc = JSON.parse(raw);
-  if (!doc || typeof doc !== 'object' || !doc.body) {
-    throw new Error(`Sample ${sample.reqId} missing request body`);
+  const requestPath = path.join(sampleDir, fileName);
+  try {
+    const raw = await fs.readFile(requestPath, 'utf-8');
+    const doc = JSON.parse(raw);
+    if (!doc || typeof doc !== 'object' || !doc.body) {
+      throw new Error(`Sample ${sample.reqId} missing request body (${fileName})`);
+    }
+    return doc;
+  } catch (error) {
+    if (options.optional) {
+      return null;
+    }
+    throw error;
   }
-  return doc;
 }
 
 function parseProviderKey(providerKey) {
@@ -103,7 +111,7 @@ function buildConfig(sample, port) {
           type: 'mock-provider',
           providerType: 'responses',
           baseURL: `https://mock.local/${providerId}`,
-          compat: 'passthrough',
+          compatibilityProfile: 'compat:passthrough',
           providerId: sample.providerId,
           auth: {
             type: 'apikey',
@@ -154,7 +162,8 @@ function createServer(configPath, port) {
     ROUTECODEX_PORT: String(port),
     ROUTECODEX_CONFIG_PATH: configPath
   };
-  const child = spawn('routecodex', ['start', '--config', configPath], {
+  const entry = path.join(PROJECT_ROOT, 'dist', 'index.js');
+  const child = spawn(process.execPath, [entry], {
     cwd: PROJECT_ROOT,
     env,
     stdio: ['ignore', 'pipe', 'pipe']
@@ -255,10 +264,46 @@ function collectInvalidNames(payload) {
   return failures;
 }
 
+function extractRequestBody(doc) {
+  const body = doc && typeof doc === 'object' ? doc.body : undefined;
+  if (!body || typeof body !== 'object') {
+    return {};
+  }
+  if (body.body && typeof body.body === 'object') {
+    return body.body;
+  }
+  if (body.payload && typeof body.payload === 'object') {
+    return body.payload;
+  }
+  return body;
+}
+
+function resolveRequestUrl(sample, requestDoc, port) {
+  const rawCandidate =
+    requestDoc.endpoint ||
+    (requestDoc.meta && typeof requestDoc.meta.entryEndpoint === 'string' ? requestDoc.meta.entryEndpoint : undefined) ||
+    requestDoc.url ||
+    sample.entry ||
+    '/v1/responses';
+  if (typeof rawCandidate === 'string' && /^https?:\/\//i.test(rawCandidate.trim())) {
+    return rawCandidate.trim();
+  }
+  const normalizedPath = typeof rawCandidate === 'string' && rawCandidate.trim().length
+    ? rawCandidate.trim()
+    : '/v1/responses';
+  const pathWithSlash = normalizedPath.startsWith('/') ? normalizedPath : `/${normalizedPath}`;
+  return `http://127.0.0.1:${port}${pathWithSlash}`;
+}
+
 async function sendRequest(sample, requestDoc, port) {
-  const url = `http://127.0.0.1:${port}${requestDoc.endpoint || sample.entry}`;
+  const url = resolveRequestUrl(sample, requestDoc, port);
+  const payload = extractRequestBody(requestDoc);
   const headers = { 'content-type': 'application/json' };
-  if (requestDoc.body?.stream === true) {
+  const wantsStream =
+    payload?.stream === true ||
+    (requestDoc.body && typeof requestDoc.body === 'object' && requestDoc.body.stream === true) ||
+    (requestDoc.meta && requestDoc.meta.stream === true);
+  if (wantsStream) {
     headers.accept = 'text/event-stream';
   }
   const controller = new AbortController();
@@ -267,7 +312,7 @@ async function sendRequest(sample, requestDoc, port) {
     const res = await fetch(url, {
       method: 'POST',
       headers,
-      body: JSON.stringify(requestDoc.body),
+      body: JSON.stringify(payload),
       signal: controller.signal
     });
     const text = await res.text();
@@ -283,7 +328,8 @@ async function sendRequest(sample, requestDoc, port) {
 }
 
 async function runSample(sample, index) {
-  const requestDoc = await loadSampleDocument(sample);
+  const clientDoc = await loadSampleDocument(sample, { fileName: 'client-request.json', optional: true });
+  const requestDoc = clientDoc || (await loadSampleDocument(sample));
   const port = 5800 + index;
   const { dir, file } = await writeTempConfig(sample, port);
   const server = createServer(file, port);

package/scripts/pack-mode.mjs

@@ -14,14 +14,36 @@ function parseArgs(argv) {
   return out;
 }
 
+const projectRoot = process.cwd();
 const args = parseArgs(process.argv);
 if (!args.name || !args.bin) {
   console.error('Usage: node scripts/pack-mode.mjs --name <packageName> --bin <binName>');
   process.exit(1);
 }
 
-const pkgPath = path.join(process.cwd(), 'package.json');
+const pkgPath = path.join(projectRoot, 'package.json');
 const backupPath = pkgPath + '.bak.pack';
+const ensureScriptPath = path.join(projectRoot, 'scripts', 'ensure-llmswitch-mode.mjs');
+const llmsPath = path.join(projectRoot, 'node_modules', '@jsonstudio', 'llms');
+
+function runEnsureMode(mode) {
+  const env = { ...process.env, BUILD_MODE: mode };
+  const res = spawnSync(process.execPath, [ensureScriptPath], { stdio: 'inherit', env });
+  if ((res.status ?? 0) !== 0) {
+    throw new Error(`ensure-llmswitch-mode failed for ${mode}`);
+  }
+}
+
+function isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+const hadDevLink = isSymlink(llmsPath);
+runEnsureMode('release');
 
 const original = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
 fs.writeFileSync(backupPath, JSON.stringify(original, null, 2));
@@ -55,4 +77,11 @@ try {
   // restore
   fs.writeFileSync(pkgPath, fs.readFileSync(backupPath, 'utf-8'));
   fs.unlinkSync(backupPath);
+  if (hadDevLink) {
+    try {
+      runEnsureMode('dev');
+    } catch (err) {
+      console.warn('[pack-mode] failed to restore dev llms link:', err);
+    }
+  }
 }

package/scripts/publish-rcc.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+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 packageJson = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf-8'));
+const version = packageJson.version;
+const tarballName = `jsonstudio-rcc-${version}.tgz`;
+const tarballPath = path.join(PROJECT_ROOT, tarballName);
+
+function run(command, args, options = {}) {
+  const res = spawnSync(command, args, { stdio: 'inherit', ...options });
+  if ((res.status ?? 0) !== 0) {
+    throw new Error(`${command} ${args.join(' ')} failed`);
+  }
+}
+
+try {
+  run(process.execPath, [PACK_SCRIPT, '--name', '@jsonstudio/rcc', '--bin', 'rcc'], { cwd: PROJECT_ROOT });
+  if (!fs.existsSync(tarballPath)) {
+    throw new Error(`tarball not found: ${tarballPath}`);
+  }
+  run('npm', ['publish', tarballName], { cwd: PROJECT_ROOT });
+} catch (err) {
+  console.error('[publish-rcc] failed:', err.message);
+  process.exit(1);
+}