@kaitranntt/ccs 7.73.1-dev.2 → 7.73.1-dev.3

package/README.md

@@ -177,6 +177,9 @@ ccs ollama "summarize these logs"
 ## Contribute And Report Safely
 
 - Contributing guide: [CONTRIBUTING.md](./CONTRIBUTING.md)
+- Daily local gate: `bun run format && bun run lint:fix && bun run validate` (`validate` is the fast path only)
+- Before review or merge confidence: `bun run validate:ci-parity`
+- If PR checks stay queued for more than 10 minutes, assume the self-hosted runner is offline and notify a maintainer instead of retrying blindly
 - Starter work:
   [good first issue](https://github.com/kaitranntt/ccs/labels/good%20first%20issue),
   [help wanted](https://github.com/kaitranntt/ccs/labels/help%20wanted)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "7.73.1-dev.2",
+  "version": "7.73.1-dev.3",
   "description": "Claude Code Switch - Instant profile switching between Claude, GLM, Kimi, and more",
   "keywords": [
     "cli",
@@ -70,12 +70,14 @@
     "lint:fix": "eslint src/ --fix",
     "format": "prettier --write src/",
     "format:check": "prettier --check src/",
-    "validate": "bun run typecheck && bun run lint:fix && bun run format:check && bun run test:all",
+    "validate": "bun run typecheck && bun run lint && bun run format:check && bun run test:fast",
     "validate:ci-parity": "bash scripts/ci-parity-gate.sh",
     "verify:bundle": "node scripts/verify-bundle.js",
     "test": "bun run build && bun run test:all",
     "test:ci": "bun run test:all",
-    "test:all": "bun test --max-concurrency=1 tests/unit tests/integration tests/npm",
+    "test:fast": "node scripts/run-test-bucket.js fast",
+    "test:slow": "node scripts/run-test-bucket.js slow",
+    "test:all": "node scripts/run-test-bucket.js all",
     "test:unit": "bun test tests/unit",
     "test:npm": "bun test tests/npm/",
     "test:native": "bash tests/native/unix/edge-cases.sh",

package/scripts/ci-parity-gate.sh

@@ -55,8 +55,14 @@ if git show-ref --verify --quiet "refs/remotes/origin/$BASE_BRANCH"; then
   fi
 fi
 
-echo "[i] Running CI-equivalent local checks..."
+echo "[i] Running CI-parity local checks..."
+# `set -euo pipefail` above makes every step fail fast. Keep these commands
+# explicit so parity drift is visible when CI changes.
+bun run typecheck
+bun run lint
+bun run format:check
 bun run build:all
-bun run validate
+bun run test:all
+CCS_E2E_SKIP_BUILD=1 bun run test:e2e
 
 echo "[OK] CI parity gate passed."

package/scripts/run-test-bucket.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const rootDir = path.resolve(__dirname, '..');
+const candidateRoots = ['tests/unit', 'tests/integration', 'tests/npm'];
+// Add a `.ts` test to `slowTests` when ANY of these apply:
+//   1. It spawns a child process (CLI, bun test, node, gh, etc.).
+//   2. It binds a port, starts a server, or talks to localhost.
+//   3. It reads a real file from `dist/` or the repo root at runtime.
+//   4. It waits on a timer > 500ms or a filesystem watcher.
+//   5. A single run consistently takes > 1500ms on reference hardware.
+// Tests that literally reference `dist/` in source are auto-forced slow by
+// `readsBuiltDist`. This list is the manual catch-all for `.ts` tests that
+// meet the criteria above without the literal `dist/` string.
+// `tests/unit/scripts/run-test-bucket.test.js` verifies every path here exists
+// (catches deletion drift) but CANNOT detect new undeclared slow tests.
+// Automated perf-budget enforcement tracked in issue #1071.
+const slowTests = [
+  'tests/integration/cursor-daemon-lifecycle.test.ts',
+  'tests/integration/proxy/daemon-lifecycle.test.ts',
+  'tests/unit/commands/persist-command-handler.test.ts',
+  'tests/unit/hooks/ccs-browser-mcp-server.test.ts',
+  'tests/unit/targets/codex-runtime-integration.test.ts',
+  'tests/unit/targets/codex-settings-bridge-launch.test.ts',
+  'tests/unit/targets/droid-command-routing-integration.test.ts',
+  'tests/unit/targets/droid-config-manager.test.ts',
+  'tests/unit/targets/settings-profile-browser-launch.test.ts',
+  'tests/unit/targets/settings-profile-image-analysis-launch.test.ts',
+  'tests/unit/targets/settings-profile-websearch-launch.test.ts',
+  'tests/unit/web-server/cursor-routes.test.ts',
+  'tests/unit/web-server/websearch-routes.test.ts',
+];
+// CommonJS-heavy JS suites stay slow by default because many of them mutate
+// module cache or process state. Opt them into `test:fast` only after they are
+// proven stable in the mixed fast bucket.
+const fastJsTests = new Set([
+  'tests/unit/flag-parsing-simple.test.js',
+]);
+
+const filePattern = /(\.test\.(c|m)?[jt]s|\.spec\.(c|m)?[jt]s|-test\.(c|m)?[jt]s)$/;
+
+function collectFiles(dir, files = []) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(fullPath, files);
+      continue;
+    }
+
+    if (filePattern.test(entry.name)) {
+      files.push(path.relative(rootDir, fullPath).split(path.sep).join('/'));
+    }
+  }
+
+  return files;
+}
+
+function readsBuiltDist(relativePath) {
+  const source = fs.readFileSync(path.join(rootDir, relativePath), 'utf8');
+  return source.includes('dist/');
+}
+
+function getDiscoveredTests() {
+  return candidateRoots
+    .flatMap((relativeDir) => collectFiles(path.join(rootDir, relativeDir)))
+    .sort();
+}
+
+function shouldForceSlow(file) {
+  if (file.startsWith('tests/npm/')) {
+    return true;
+  }
+
+  if (/\.(c|m)?js$/.test(file) && !fastJsTests.has(file)) {
+    return true;
+  }
+
+  return readsBuiltDist(file);
+}
+
+function getSlowSet() {
+  const discovered = getDiscoveredTests();
+  const forceSlow = discovered.filter((file) => shouldForceSlow(file));
+  return new Set([...slowTests, ...forceSlow]);
+}
+
+function selectBucket(name) {
+  const discovered = getDiscoveredTests();
+  const slowSet = getSlowSet();
+
+  return name === 'slow'
+    ? [...slowSet].sort()
+    : discovered.filter((file) => !slowSet.has(file));
+}
+
+function ensureBuildForSlowBucket() {
+  if (fs.existsSync(path.join(rootDir, 'dist', 'ccs.js'))) {
+    return 0;
+  }
+
+  const build = spawnSync('bun', ['run', 'build'], {
+    cwd: rootDir,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+  return build.status ?? 1;
+}
+
+function runBucket(name) {
+  const selected = selectBucket(name);
+
+  if (selected.length === 0) {
+    console.error(`[X] No tests matched the '${name}' bucket.`);
+    return 1;
+  }
+
+  if (name === 'slow') {
+    const buildStatus = ensureBuildForSlowBucket();
+    if (buildStatus !== 0) {
+      return buildStatus;
+    }
+  }
+
+  // Slow bucket forces sequential execution because it spawns subprocesses,
+  // binds ports, and touches shared state — parallelism causes flakes.
+  // Fast bucket keeps bun's default parallelism for speed.
+  const bunArgs = name === 'slow'
+    ? ['test', '--max-concurrency=1', ...selected]
+    : ['test', ...selected];
+
+  const result = spawnSync('bun', bunArgs, {
+    cwd: rootDir,
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+  return result.status ?? 1;
+}
+
+function main(args = process.argv.slice(2)) {
+  const bucket = args[0];
+
+  if (!['fast', 'slow', 'all'].includes(bucket)) {
+    console.error('[X] Usage: node scripts/run-test-bucket.js <fast|slow|all>');
+    return 1;
+  }
+
+  if (bucket === 'all') {
+    let exitCode = 0;
+
+    for (const name of ['fast', 'slow']) {
+      const status = runBucket(name);
+      if (status !== 0) {
+        exitCode = status;
+      }
+    }
+
+    return exitCode;
+  }
+
+  return runBucket(bucket);
+}
+
+if (require.main === module) {
+  process.exit(main());
+}
+
+module.exports = {
+  slowTests,
+  fastJsTests,
+  readsBuiltDist,
+  shouldForceSlow,
+  getDiscoveredTests,
+  getSlowSet,
+  selectBucket,
+  main,
+};