@vibelet/cli 0.1.35 → 0.1.37

package/src/process-scanner.test.ts

@@ -0,0 +1,575 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, utimes, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import {
+  classifyProcessSnapshot,
+  extractExplicitSessionId,
+  findRecentSessionFileForCwd,
+  hasContinueFlag,
+  isRelevantProcessCommand,
+  isProcessAlive,
+  mergeRunningSessionCandidates,
+  type ProcessSnapshot,
+  type RunningSessionCandidate,
+} from './process-scanner.js';
+
+function snapshot(overrides: Partial<ProcessSnapshot>): ProcessSnapshot {
+  return {
+    pid: 1,
+    agent: 'codex',
+    command: 'codex --yolo',
+    cwd: '/repo',
+    sessionFiles: [],
+    ...overrides,
+  };
+}
+
+test('classifies explicit codex resume as high confidence', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    pid: 6581,
+    command: 'codex resume 019d03e3-2672-7011-9c6d-5ba083b71111',
+  }));
+
+  assert.deepEqual(candidate, {
+    agent: 'codex',
+    pid: 6581,
+    cwd: '/repo',
+    command: 'codex resume 019d03e3-2672-7011-9c6d-5ba083b71111',
+    sessionId: '019d03e3-2672-7011-9c6d-5ba083b71111',
+    confidence: 'high',
+  });
+});
+
+test('classifies explicit Claude resume with permission flags and keeps approval mode', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    pid: 6582,
+    command: 'claude --resume session-1 --permission-mode acceptEdits',
+  }));
+
+  assert.deepEqual(candidate, {
+    agent: 'claude',
+    pid: 6582,
+    cwd: '/repo',
+    command: 'claude --resume session-1 --permission-mode acceptEdits',
+    sessionId: 'session-1',
+    confidence: 'high',
+    approvalMode: 'acceptEdits',
+  });
+});
+
+test('classifies explicit Claude bypass mode from process command', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    pid: 6583,
+    command: 'claude --resume session-2 --dangerously-skip-permissions',
+  }));
+
+  assert.equal(candidate?.approvalMode, 'autoApprove');
+});
+
+test('classifies explicit Claude resume without forcing normal and keeps unique session file for hydration', () => {
+  const filePath = '/Users/test/.claude/projects/-Users-test-repo/session-3.jsonl';
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    pid: 6584,
+    command: 'claude --resume session-3',
+    sessionFiles: [filePath],
+  }));
+
+  assert.deepEqual(candidate, {
+    agent: 'claude',
+    pid: 6584,
+    cwd: '/repo',
+    command: 'claude --resume session-3',
+    sessionId: 'session-3',
+    confidence: 'high',
+    sessionFilePath: filePath,
+  });
+});
+
+test('classifies a single codex rollout file as medium confidence', () => {
+  const filePath = '/Users/test/.codex/sessions/2026/03/20/rollout-2026-03-20T08-37-12-019d08ac-c265-7270-9497-d14125228a50.jsonl';
+  const candidate = classifyProcessSnapshot(snapshot({
+    pid: 52424,
+    sessionFiles: [filePath],
+  }));
+
+  assert.equal(candidate?.confidence, 'medium');
+  assert.equal(candidate?.sessionId, '019d08ac-c265-7270-9497-d14125228a50');
+  assert.equal(candidate?.sessionFilePath, filePath);
+});
+
+test('drops ambiguous app-server processes with multiple session files', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    command: 'codex app-server',
+    sessionFiles: [
+      '/Users/test/.codex/sessions/2026/03/20/rollout-2026-03-20T08-37-12-019d08ac-c265-7270-9497-d14125228a50.jsonl',
+      '/Users/test/.codex/sessions/2026/03/20/rollout-2026-03-20T08-42-17-019d08b1-67e6-75a1-bdb6-3c1b25b1103b.jsonl',
+    ],
+  }));
+
+  assert.equal(candidate, null);
+});
+
+test('drops claude --continue without a unique session file', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    command: 'claude --dangerously-skip-permissions --continue',
+    sessionFiles: [],
+  }));
+
+  assert.equal(candidate, null);
+});
+
+test('drops claude subagent transcript files', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    command: 'claude --dangerously-skip-permissions --continue',
+    sessionFiles: [
+      '/Users/test/.claude/projects/-Users-test/repo/subagents/agent-aa9cc4dbb140502a8.jsonl',
+    ],
+  }));
+
+  assert.equal(candidate, null);
+});
+
+// ===== extractExplicitSessionId =====
+
+test('extracts claude session id from --resume flag', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', 'claude --resume abc-123-def'),
+    'abc-123-def',
+  );
+});
+
+test('extracts claude session id from --resume= syntax', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', 'claude --resume=abc-123-def'),
+    'abc-123-def',
+  );
+});
+
+test('returns null for claude without --resume', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', 'claude --dangerously-skip-permissions --continue'),
+    null,
+  );
+});
+
+test('returns null when --resume has no value', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', 'claude --resume --other-flag'),
+    null,
+  );
+});
+
+test('extracts codex session id from resume subcommand', () => {
+  assert.equal(
+    extractExplicitSessionId('codex', 'codex resume 019d03e3-2672-7011-9c6d-5ba083b71111'),
+    '019d03e3-2672-7011-9c6d-5ba083b71111',
+  );
+});
+
+test('returns null for codex without resume subcommand', () => {
+  assert.equal(
+    extractExplicitSessionId('codex', 'codex --yolo'),
+    null,
+  );
+});
+
+test('returns null when agent does not match binary in command', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', 'codex resume abc-123'),
+    null,
+  );
+});
+
+test('handles quoted tokens in command', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', 'claude --resume "my-session-id"'),
+    'my-session-id',
+  );
+});
+
+test('handles full path to binary', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', '/usr/local/bin/claude --resume sess-1'),
+    'sess-1',
+  );
+});
+
+test('extracts claude session id from shell-wrapped resume command', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', "zsh -lc 'cd /repo && claude --resume sess-1'"),
+    'sess-1',
+  );
+});
+
+test('returns null for empty command', () => {
+  assert.equal(
+    extractExplicitSessionId('codex', ''),
+    null,
+  );
+});
+
+// ===== relevant process command matching =====
+
+test('isRelevantProcessCommand matches shell-wrapped claude resume commands', () => {
+  assert.equal(
+    isRelevantProcessCommand("zsh -lc 'cd /repo && claude --resume sess-1'"),
+    true,
+  );
+});
+
+test('isRelevantProcessCommand ignores binaries that only contain claude as a substring', () => {
+  assert.equal(
+    isRelevantProcessCommand("zsh -lc '/usr/local/bin/claude-wrapper --resume sess-1'"),
+    false,
+  );
+});
+
+// ===== mergeRunningSessionCandidates (continued) =====
+
+test('dedupes duplicate running candidates by keeping the higher confidence entry', () => {
+  const high: RunningSessionCandidate = {
+    agent: 'codex',
+    pid: 6581,
+    cwd: '/repo',
+    command: 'codex resume 019d03e3-2672-7011-9c6d-5ba083b71111',
+    sessionId: '019d03e3-2672-7011-9c6d-5ba083b71111',
+    confidence: 'high',
+  };
+  const medium: RunningSessionCandidate = {
+    agent: 'codex',
+    pid: 72545,
+    cwd: '/repo',
+    command: 'codex --yolo',
+    sessionId: '019d03e3-2672-7011-9c6d-5ba083b71111',
+    confidence: 'medium',
+    title: 'Recovered title',
+    sessionFilePath: '/Users/test/.codex/sessions/2026/03/20/rollout-2026-03-20T08-37-12-019d03e3-2672-7011-9c6d-5ba083b71111.jsonl',
+    isResponding: true,
+  };
+
+  assert.deepEqual(mergeRunningSessionCandidates([medium, high]), [{
+    ...high,
+    title: 'Recovered title',
+    sessionFilePath: medium.sessionFilePath,
+    isResponding: true,
+  }]);
+});
+
+test('mergeRunningSessionCandidates: keeps both when different sessionIds', () => {
+  const a: RunningSessionCandidate = {
+    agent: 'codex', pid: 1, cwd: '/repo', command: 'codex',
+    sessionId: 'aaa', confidence: 'high',
+  };
+  const b: RunningSessionCandidate = {
+    agent: 'codex', pid: 2, cwd: '/repo', command: 'codex',
+    sessionId: 'bbb', confidence: 'high',
+  };
+
+  assert.equal(mergeRunningSessionCandidates([a, b]).length, 2);
+});
+
+test('mergeRunningSessionCandidates: returns empty for empty input', () => {
+  assert.deepEqual(mergeRunningSessionCandidates([]), []);
+});
+
+// ===== classifyProcessSnapshot edge cases =====
+
+test('classifies claude --resume as high confidence', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    command: 'claude --resume my-session-id-123',
+    sessionFiles: [],
+  }));
+
+  assert.equal(candidate?.confidence, 'high');
+  assert.equal(candidate?.sessionId, 'my-session-id-123');
+});
+
+test('classifies single claude project file as medium confidence', () => {
+  const filePath = '/Users/test/.claude/projects/-Users-test-repo/session-abc.jsonl';
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    command: 'claude --dangerously-skip-permissions',
+    sessionFiles: [filePath],
+  }));
+
+  assert.equal(candidate?.confidence, 'medium');
+  assert.equal(candidate?.sessionId, 'session-abc');
+});
+
+test('returns null for process with no session files and no explicit id', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    command: 'codex app-server',
+    sessionFiles: [],
+  }));
+
+  assert.equal(candidate, null);
+});
+
+test('filters out non-supported session file paths', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    command: 'codex app-server',
+    sessionFiles: ['/tmp/random.jsonl'],
+  }));
+
+  assert.equal(candidate, null);
+});
+
+// ===== extractExplicitSessionId edge cases =====
+
+test('extracts codex resume id skipping flags before session id', () => {
+  assert.equal(
+    extractExplicitSessionId('codex', 'codex resume --some-flag session-id-abc'),
+    'session-id-abc',
+  );
+});
+
+test('returns null for codex resume with only flags', () => {
+  assert.equal(
+    extractExplicitSessionId('codex', 'codex resume --flag-only'),
+    null,
+  );
+});
+
+test('handles single-quoted session id', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', "claude --resume 'my-session'"),
+    'my-session',
+  );
+});
+
+// ===== classifyProcessSnapshot edge cases =====
+
+test('classifies process with single codex session file in supported path', () => {
+  const filePath = '/Users/test/.codex/sessions/2026/03/20/some-file-019d08ac-c265-7270-9497-d14125228a50.jsonl';
+  const candidate = classifyProcessSnapshot(snapshot({
+    command: 'codex app-server',
+    sessionFiles: [filePath],
+  }));
+
+  assert.equal(candidate?.confidence, 'medium');
+  assert.equal(candidate?.sessionFilePath, filePath);
+});
+
+test('classifies process with single claude project file', () => {
+  const filePath = '/Users/test/.claude/projects/-Users-test-repo/my-session.jsonl';
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    command: 'claude --continue',
+    sessionFiles: [filePath],
+  }));
+
+  assert.equal(candidate?.confidence, 'medium');
+  assert.equal(candidate?.sessionId, 'my-session');
+});
+
+test('ignores duplicate session files (dedupes before counting)', () => {
+  const filePath = '/Users/test/.codex/sessions/2026/03/20/rollout-019d08ac-c265-7270-9497-d14125228a50.jsonl';
+  const candidate = classifyProcessSnapshot(snapshot({
+    command: 'codex app-server',
+    sessionFiles: [filePath, filePath], // duplicate
+  }));
+
+  assert.equal(candidate?.confidence, 'medium');
+  assert.equal(candidate?.sessionId, '019d08ac-c265-7270-9497-d14125228a50');
+});
+
+// ===== mergeRunningSessionCandidates edge cases =====
+
+test('mergeRunningSessionCandidates: same confidence uses lower PID as winner', () => {
+  const a: RunningSessionCandidate = {
+    agent: 'codex', pid: 100, cwd: '/repo', command: 'codex',
+    sessionId: 'same-id', confidence: 'medium',
+  };
+  const b: RunningSessionCandidate = {
+    agent: 'codex', pid: 200, cwd: '/other', command: 'codex',
+    sessionId: 'same-id', confidence: 'medium',
+    title: 'Title from B',
+  };
+
+  const result = mergeRunningSessionCandidates([a, b]);
+  assert.equal(result.length, 1);
+  assert.equal(result[0].pid, 100); // lower PID wins
+  assert.equal(result[0].title, 'Title from B'); // title merged from loser
+});
+
+test('mergeRunningSessionCandidates: winner gets cwd from loser when winner has empty cwd', () => {
+  const a: RunningSessionCandidate = {
+    agent: 'codex', pid: 1, cwd: '', command: 'codex',
+    sessionId: 'id-1', confidence: 'high',
+  };
+  const b: RunningSessionCandidate = {
+    agent: 'codex', pid: 2, cwd: '/repo', command: 'codex',
+    sessionId: 'id-1', confidence: 'low',
+  };
+
+  const result = mergeRunningSessionCandidates([a, b]);
+  assert.equal(result[0].cwd, '/repo');
+});
+
+test('mergeRunningSessionCandidates: different agents are separate entries', () => {
+  const a: RunningSessionCandidate = {
+    agent: 'codex', pid: 1, cwd: '/repo', command: 'codex',
+    sessionId: 'same-id', confidence: 'high',
+  };
+  const b: RunningSessionCandidate = {
+    agent: 'claude', pid: 2, cwd: '/repo', command: 'claude',
+    sessionId: 'same-id', confidence: 'high',
+  };
+
+  const result = mergeRunningSessionCandidates([a, b]);
+  assert.equal(result.length, 2); // different agents = different keys
+});
+
+test('mergeRunningSessionCandidates: single candidate passes through', () => {
+  const a: RunningSessionCandidate = {
+    agent: 'codex', pid: 42, cwd: '/repo', command: 'codex resume abc',
+    sessionId: 'abc', confidence: 'high', title: 'My Title',
+  };
+
+  const result = mergeRunningSessionCandidates([a]);
+  assert.equal(result.length, 1);
+  assert.deepEqual(result[0], a);
+});
+
+// ===== extractExplicitSessionId: --session-id support =====
+
+test('extracts claude session id from --session-id flag', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', 'claude --session-id 7f03bcf8-d5aa-4eb2-b123-abcdef012345'),
+    '7f03bcf8-d5aa-4eb2-b123-abcdef012345',
+  );
+});
+
+test('extracts claude session id from --session-id= syntax', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', 'claude --session-id=7f03bcf8-d5aa-4eb2-b123-abcdef012345'),
+    '7f03bcf8-d5aa-4eb2-b123-abcdef012345',
+  );
+});
+
+test('extracts claude session id from full path binary with --session-id', () => {
+  assert.equal(
+    extractExplicitSessionId('claude', '/Users/test/.local/bin/claude --session-id abc-123'),
+    'abc-123',
+  );
+});
+
+test('classifies claude --session-id as high confidence', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    command: '/Users/test/.local/bin/claude --session-id 7f03bcf8-d5aa-4eb2-b123-abcdef012345',
+    sessionFiles: [],
+  }));
+
+  assert.equal(candidate?.confidence, 'high');
+  assert.equal(candidate?.sessionId, '7f03bcf8-d5aa-4eb2-b123-abcdef012345');
+});
+
+// ===== hasContinueFlag =====
+
+test('hasContinueFlag detects --continue', () => {
+  assert.equal(hasContinueFlag('claude', 'claude --dangerously-skip-permissions --continue'), true);
+});
+
+test('hasContinueFlag detects -c shorthand', () => {
+  assert.equal(hasContinueFlag('claude', '/usr/local/bin/claude -c'), true);
+});
+
+test('hasContinueFlag returns false without --continue', () => {
+  assert.equal(hasContinueFlag('claude', 'claude --resume abc'), false);
+});
+
+test('hasContinueFlag returns false for wrong agent', () => {
+  assert.equal(hasContinueFlag('codex', 'claude --continue'), false);
+});
+
+// ===== cwd fallback: classifyProcessSnapshot returns null, scanRunningSessions uses filesystem =====
+
+test('classifyProcessSnapshot returns null for --continue without session files (fallback skipped)', () => {
+  const candidate = classifyProcessSnapshot(snapshot({
+    agent: 'claude',
+    command: '/Users/test/.local/bin/claude --dangerously-skip-permissions --continue',
+    cwd: '/some/project',
+    sessionFiles: [],
+  }));
+
+  // classifyProcessSnapshot returns null; scanRunningSessions skips the mtime fallback for --continue
+  assert.equal(candidate, null);
+});
+
+test('findRecentSessionFileForCwd matches Codex fallback by cwd instead of global newest file', async () => {
+  const tempHome = await mkdtemp(join(tmpdir(), 'vibe-codex-cwd-'));
+  const sessionsDir = join(tempHome, '.codex', 'sessions', '2026', '03', '21');
+  const matchingOld = join(sessionsDir, 'matching-old.jsonl');
+  const nonMatchingNewest = join(sessionsDir, 'other-cwd.jsonl');
+  const matchingNewest = join(sessionsDir, 'matching-new.jsonl');
+  const originalHome = process.env.HOME;
+
+  await mkdir(sessionsDir, { recursive: true });
+  await writeFile(matchingOld, `${JSON.stringify({ cwd: '/repo-a', id: 'codex-a-old', title: 'Old match' })}\n`);
+  await writeFile(nonMatchingNewest, `${JSON.stringify({ cwd: '/repo-b', id: 'codex-b-new', title: 'Wrong cwd' })}\n`);
+  await writeFile(matchingNewest, `${JSON.stringify({ cwd: '/repo-a', id: 'codex-a-new', title: 'New match' })}\n`);
+
+  await utimes(matchingOld, new Date(1_000), new Date(1_000));
+  await utimes(nonMatchingNewest, new Date(4_000), new Date(4_000));
+  await utimes(matchingNewest, new Date(3_000), new Date(3_000));
+
+  process.env.HOME = tempHome;
+
+  try {
+    const result = await findRecentSessionFileForCwd('codex', '/repo-a');
+    assert.deepEqual(result, {
+      sessionId: 'codex-a-new',
+      filePath: matchingNewest,
+    });
+  } finally {
+    process.env.HOME = originalHome;
+    await rm(tempHome, { recursive: true, force: true });
+  }
+});
+
+// ===== scanProcessSnapshots / scanRunningSessions (live system tests) =====
+
+import { scanProcessSnapshots, scanRunningSessions } from './process-scanner.js';
+
+test('scanProcessSnapshots returns an array', async () => {
+  const snapshots = await scanProcessSnapshots();
+  assert.ok(Array.isArray(snapshots));
+  // Each snapshot should have the right shape
+  for (const s of snapshots) {
+    assert.equal(typeof s.pid, 'number');
+    assert.ok(s.agent === 'claude' || s.agent === 'codex');
+    assert.equal(typeof s.command, 'string');
+    assert.equal(typeof s.cwd, 'string');
+    assert.ok(Array.isArray(s.sessionFiles));
+  }
+});
+
+test('scanRunningSessions returns an array of valid candidates', async () => {
+  const candidates = await scanRunningSessions();
+  assert.ok(Array.isArray(candidates));
+  for (const c of candidates) {
+    assert.equal(typeof c.sessionId, 'string');
+    assert.ok(c.agent === 'claude' || c.agent === 'codex');
+    assert.ok(['high', 'medium', 'low'].includes(c.confidence));
+  }
+});
+
+// ─── isProcessAlive ──────────────────────────────────────────────────────────
+
+test('isProcessAlive returns true for the current process', () => {
+  assert.equal(isProcessAlive(process.pid), true);
+});
+
+test('isProcessAlive returns false for a non-existent PID', () => {
+  // PID 2147483647 (INT32_MAX) is almost certainly not in use.
+  assert.equal(isProcessAlive(2147483647), false);
+});