@vibelet/cli 0.1.35 → 0.1.36

package/src/port-conflict.ts

@@ -0,0 +1,44 @@
+import { execFileSync } from 'child_process';
+
+export interface PortOccupant {
+  pid: number;
+  command?: string;
+}
+
+type SyncCommandRunner = (file: string, args: string[]) => string;
+
+function defaultCommandRunner(file: string, args: string[]): string {
+  return execFileSync(file, args, {
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+  }).trim();
+}
+
+export function parsePidList(output: string): number[] {
+  const pids = output
+    .split('\n')
+    .map((line) => Number(line.trim()))
+    .filter((pid) => Number.isFinite(pid) && pid > 0);
+  return [...new Set(pids)];
+}
+
+export function collectPortOccupants(
+  port: number,
+  runCommand: SyncCommandRunner = defaultCommandRunner,
+): PortOccupant[] {
+  let pids: number[];
+  try {
+    pids = parsePidList(runCommand('lsof', ['-ti', `tcp:${port}`]));
+  } catch {
+    return [];
+  }
+
+  return pids.map((pid) => {
+    try {
+      const command = runCommand('ps', ['-p', String(pid), '-o', 'command=']);
+      return command ? { pid, command } : { pid };
+    } catch {
+      return { pid };
+    }
+  });
+}

package/src/process-scanner.perf.test.ts

@@ -0,0 +1,222 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  classifyProcessSnapshot,
+  extractExplicitSessionId,
+  mergeRunningSessionCandidates,
+  scanRunningSessions,
+  invalidateProcessScanCache,
+  type ProcessSnapshot,
+  type RunningSessionCandidate,
+} from './process-scanner.js';
+
+function measure(fn: () => void, iterations: number): { totalMs: number; avgMs: number } {
+  fn(); // warmup
+  const start = performance.now();
+  for (let i = 0; i < iterations; i++) fn();
+  const totalMs = performance.now() - start;
+  return { totalMs, avgMs: totalMs / iterations };
+}
+
+const ITERATIONS = 10_000;
+
+describe('process-scanner performance', () => {
+
+  describe('extractExplicitSessionId', () => {
+
+    it(`claude --resume parsing × ${ITERATIONS} < 50ms`, () => {
+      const { totalMs } = measure(() => {
+        extractExplicitSessionId('claude', 'node /usr/bin/claude --resume 019d03e3-2672-7011-9c6d-5ba083b71111');
+      }, ITERATIONS);
+      console.log(`  claude --resume: ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
+    });
+
+    it(`claude --resume= parsing × ${ITERATIONS} < 50ms`, () => {
+      const { totalMs } = measure(() => {
+        extractExplicitSessionId('claude', 'claude --resume=abc123def456');
+      }, ITERATIONS);
+      console.log(`  claude --resume=: ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
+    });
+
+    it(`codex resume parsing × ${ITERATIONS} < 50ms`, () => {
+      const { totalMs } = measure(() => {
+        extractExplicitSessionId('codex', 'codex resume 019d03e3-2672-7011-9c6d-5ba083b71111');
+      }, ITERATIONS);
+      console.log(`  codex resume: ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
+    });
+
+    it(`no match parsing × ${ITERATIONS} < 50ms`, () => {
+      const { totalMs } = measure(() => {
+        extractExplicitSessionId('claude', 'claude --yolo --mode auto');
+      }, ITERATIONS);
+      console.log(`  no match: ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 50, `took ${totalMs.toFixed(2)}ms, expected < 50ms`);
+    });
+
+    it(`complex quoted command × ${ITERATIONS} < 100ms`, () => {
+      const cmd = '/usr/local/bin/node "/opt/homebrew/bin/claude" --resume "019d03e3-2672-7011-9c6d-5ba083b71111" --cwd "/Users/test/my project"';
+      const { totalMs } = measure(() => {
+        extractExplicitSessionId('claude', cmd);
+      }, ITERATIONS);
+      console.log(`  complex quoted: ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
+    });
+  });
+
+  describe('classifyProcessSnapshot', () => {
+
+    it(`high confidence (explicit resume) × ${ITERATIONS} < 100ms`, () => {
+      const snapshot: ProcessSnapshot = {
+        pid: 6581,
+        agent: 'codex',
+        command: 'codex resume 019d03e3-2672-7011-9c6d-5ba083b71111',
+        cwd: '/repo',
+        sessionFiles: [],
+      };
+      const { totalMs } = measure(() => {
+        classifyProcessSnapshot(snapshot);
+      }, ITERATIONS);
+      console.log(`  high confidence: ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
+    });
+
+    it(`medium confidence (single file) × ${ITERATIONS} < 100ms`, () => {
+      const snapshot: ProcessSnapshot = {
+        pid: 52424,
+        agent: 'codex',
+        command: 'codex --yolo',
+        cwd: '/repo',
+        sessionFiles: ['/Users/test/.codex/sessions/2026/03/20/rollout-019d08ac-c265-7270-9497-d14125228a50.jsonl'],
+      };
+      const { totalMs } = measure(() => {
+        classifyProcessSnapshot(snapshot);
+      }, ITERATIONS);
+      console.log(`  medium confidence: ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
+    });
+
+    it(`null result (multiple files) × ${ITERATIONS} < 100ms`, () => {
+      const snapshot: ProcessSnapshot = {
+        pid: 52424,
+        agent: 'codex',
+        command: 'codex --yolo',
+        cwd: '/repo',
+        sessionFiles: [
+          '/Users/test/.codex/sessions/2026/03/20/rollout-a.jsonl',
+          '/Users/test/.codex/sessions/2026/03/20/rollout-b.jsonl',
+        ],
+      };
+      const { totalMs } = measure(() => {
+        classifyProcessSnapshot(snapshot);
+      }, ITERATIONS);
+      console.log(`  null (multi-file): ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
+    });
+
+    it(`subagent filtering × ${ITERATIONS} < 100ms`, () => {
+      const snapshot: ProcessSnapshot = {
+        pid: 1000,
+        agent: 'claude',
+        command: 'claude --resume abc',
+        cwd: '/repo',
+        sessionFiles: ['/Users/test/.claude/projects/-repo/subagents/abc.jsonl'],
+      };
+      const { totalMs } = measure(() => {
+        classifyProcessSnapshot(snapshot);
+      }, ITERATIONS);
+      console.log(`  subagent filter: ${totalMs.toFixed(2)}ms for ${ITERATIONS} calls`);
+      assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
+    });
+  });
+
+  describe('mergeRunningSessionCandidates', () => {
+
+    function makeCandidates(count: number): RunningSessionCandidate[] {
+      return Array.from({ length: count }, (_, i) => ({
+        agent: (i % 2 === 0 ? 'claude' : 'codex') as 'claude' | 'codex',
+        pid: 1000 + i,
+        cwd: `/repo/project-${i % 5}`,
+        command: `${i % 2 === 0 ? 'claude' : 'codex'} --resume session-${i % (count / 2)}`,
+        sessionId: `session-${i % (count / 2)}`,
+        confidence: (i % 3 === 0 ? 'high' : 'medium') as 'high' | 'medium',
+      }));
+    }
+
+    it('merge 50 candidates (25 unique) × 1000 < 100ms', () => {
+      const candidates = makeCandidates(50);
+      const { totalMs, avgMs } = measure(() => {
+        mergeRunningSessionCandidates(candidates);
+      }, 1000);
+      console.log(`  merge 50: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 100, `took ${totalMs.toFixed(2)}ms, expected < 100ms`);
+    });
+
+    it('merge 200 candidates (100 unique) × 500 < 200ms', () => {
+      const candidates = makeCandidates(200);
+      const { totalMs, avgMs } = measure(() => {
+        mergeRunningSessionCandidates(candidates);
+      }, 500);
+      console.log(`  merge 200: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 200, `took ${totalMs.toFixed(2)}ms, expected < 200ms`);
+    });
+
+    it('merge 1000 candidates (500 unique) × 100 < 500ms', () => {
+      const candidates = makeCandidates(1000);
+      const { totalMs, avgMs } = measure(() => {
+        mergeRunningSessionCandidates(candidates);
+      }, 100);
+      console.log(`  merge 1000: ${totalMs.toFixed(2)}ms total, ${avgMs.toFixed(3)}ms avg`);
+      assert.ok(totalMs < 500, `took ${totalMs.toFixed(2)}ms, expected < 500ms`);
+    });
+
+    it('merge 0 candidates × 10000 < 20ms', () => {
+      const { totalMs } = measure(() => {
+        mergeRunningSessionCandidates([]);
+      }, 10000);
+      console.log(`  merge 0: ${totalMs.toFixed(2)}ms for 10000 calls`);
+      assert.ok(totalMs < 20, `took ${totalMs.toFixed(2)}ms, expected < 20ms`);
+    });
+  });
+
+  describe('scanRunningSessions throttle', () => {
+
+    it('second call within TTL is near-instant (< 1ms)', async () => {
+      invalidateProcessScanCache();
+
+      // First call (cold — shells out to pgrep + lsof)
+      const coldStart = performance.now();
+      await scanRunningSessions();
+      const coldMs = performance.now() - coldStart;
+
+      // Second call (throttled)
+      const warmStart = performance.now();
+      await scanRunningSessions();
+      const warmMs = performance.now() - warmStart;
+
+      console.log(`  scanRunningSessions cold: ${coldMs.toFixed(2)}ms, throttled: ${warmMs.toFixed(3)}ms`);
+      assert.ok(warmMs < 1, `throttled call took ${warmMs.toFixed(3)}ms, expected < 1ms`);
+
+      invalidateProcessScanCache();
+    });
+
+    it('invalidateProcessScanCache forces re-scan', async () => {
+      invalidateProcessScanCache();
+      await scanRunningSessions();
+
+      // After invalidation, should re-scan (not instant)
+      invalidateProcessScanCache();
+      const start = performance.now();
+      await scanRunningSessions();
+      const ms = performance.now() - start;
+
+      console.log(`  after invalidation: ${ms.toFixed(2)}ms`);
+      // Just verify it completes without error
+      assert.ok(ms >= 0);
+
+      invalidateProcessScanCache();
+    });
+  });
+});