@vibelet/cli 0.1.38 → 1.0.0

package/src/process-scanner.ts

@@ -1,514 +0,0 @@
-import { execFile } from 'child_process';
-import { readdir, stat } from 'fs/promises';
-import { basename, join } from 'path';
-import { homedir } from 'os';
-import { promisify } from 'util';
-import type { AgentType, ApprovalMode, SessionConfidence } from '@vibelet/shared';
-import {
-  extractSessionIdFromSessionFile,
-  readSessionFileMeta,
-  readSessionRuntimeHintsFromFile,
-} from './scanner.js';
-import { logger as rootLogger } from './logger.js';
-
-const execFileAsync = promisify(execFile);
-const log = rootLogger.child({ module: 'process-scanner' });
-const PROCESS_SCAN_COMMAND_TIMEOUT_MS = 1_500;
-const RELEVANT_PROCESS_PGREP_PATTERN = '(^|[^[:alnum:]_.-])(claude|codex)([^[:alnum:]_.-]|$)';
-const RELEVANT_PROCESS_COMMAND_REGEX = /(^|[^A-Za-z0-9_.-])(claude|codex)([^A-Za-z0-9_.-]|$)/;
-
-// ---------------------------------------------------------------------------
-// Throttle: reuse result if called again within TTL
-// ---------------------------------------------------------------------------
-const PROCESS_SCAN_TTL = 15_000; // 15s — explicit invalidation on mutations keeps it fresh
-let processScanCache: { value: RunningSessionCandidate[]; expiresAt: number } | null = null;
-let processScanInflight: Promise<RunningSessionCandidate[]> | null = null;
-
-/** Invalidate the process scan cache. */
-export function invalidateProcessScanCache(): void {
-  processScanCache = null;
-}
-
-export interface ProcessSnapshot {
-  pid: number;
-  agent: AgentType;
-  command: string;
-  cwd: string;
-  sessionFiles: string[];
-}
-
-export interface RunningSessionCandidate {
-  agent: AgentType;
-  pid: number;
-  cwd: string;
-  command: string;
-  sessionId: string;
-  confidence: SessionConfidence;
-  approvalMode?: ApprovalMode;
-  sessionFilePath?: string;
-  title?: string;
-  isResponding?: boolean;
-}
-
-interface RecentSessionFileMatch {
-  path: string;
-  mtimeMs: number;
-  sessionId: string;
-}
-
-function normalizeToken(token: string): string {
-  return token.replace(/^['"]|['"]$/g, '');
-}
-
-function tokenizeCommand(command: string): string[] {
-  return (command.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map(normalizeToken);
-}
-
-function detectAgentAndArgsFromTokens(tokens: string[]): { agent: AgentType; args: string[] } | null {
-  for (let index = 0; index < tokens.length; index += 1) {
-    const token = tokens[index];
-    const binary = basename(token);
-    if (binary === 'claude' || binary === 'codex') {
-      return { agent: binary, args: tokens.slice(index + 1) };
-    }
-
-    // Shell wrappers such as `zsh -lc 'cd /repo && claude --resume ...'`
-    // surface the inner command as one quoted token. Re-scan that token
-    // so explicit resume/session-id flags remain discoverable.
-    if (/\s/.test(token)) {
-      const nested = detectAgentAndArgs(token);
-      if (nested) {
-        return nested;
-      }
-    }
-  }
-  return null;
-}
-
-function detectAgentAndArgs(command: string): { agent: AgentType; args: string[] } | null {
-  return detectAgentAndArgsFromTokens(tokenizeCommand(command));
-}
-
-export function isRelevantProcessCommand(command: string): boolean {
-  return RELEVANT_PROCESS_COMMAND_REGEX.test(command);
-}
-
-export function extractExplicitSessionId(agent: AgentType, command: string): string | null {
-  const detected = detectAgentAndArgs(command);
-  if (!detected || detected.agent !== agent) return null;
-
-  const { args } = detected;
-  if (agent === 'claude') {
-    for (let index = 0; index < args.length; index += 1) {
-      const token = args[index];
-      if ((token === '--resume' || token === '--session-id') && args[index + 1] && !args[index + 1].startsWith('-')) {
-        return args[index + 1];
-      }
-      if (token.startsWith('--resume=')) {
-        return token.slice('--resume='.length);
-      }
-      if (token.startsWith('--session-id=')) {
-        return token.slice('--session-id='.length);
-      }
-    }
-    return null;
-  }
-
-  if (args[0] !== 'resume') return null;
-  for (let index = 1; index < args.length; index += 1) {
-    const token = args[index];
-    if (!token.startsWith('-')) return token;
-  }
-  return null;
-}
-
-function parseClaudeApprovalModeFromArgs(args: string[]): ApprovalMode | undefined {
-  if (args.includes('--dangerously-skip-permissions')) {
-    return 'autoApprove';
-  }
-  for (let index = 0; index < args.length; index += 1) {
-    const token = args[index];
-    const next = args[index + 1];
-    const value = token === '--permission-mode'
-      ? next
-      : token.startsWith('--permission-mode=')
-        ? token.slice('--permission-mode='.length)
-        : undefined;
-    if (value === 'plan') return 'plan';
-    if (value === 'acceptEdits') return 'acceptEdits';
-    if (value === 'default') return 'normal';
-  }
-  return undefined;
-}
-
-function parseCodexApprovalModeFromArgs(args: string[]): ApprovalMode | undefined {
-  if (args.includes('--dangerously-bypass-approvals-and-sandbox')) {
-    return 'autoApprove';
-  }
-  return undefined;
-}
-
-function parseApprovalModeFromProcessCommand(agent: AgentType, command: string): ApprovalMode | undefined {
-  const detected = detectAgentAndArgs(command);
-  if (!detected || detected.agent !== agent) return undefined;
-  return agent === 'claude'
-    ? parseClaudeApprovalModeFromArgs(detected.args)
-    : parseCodexApprovalModeFromArgs(detected.args);
-}
-
-function confidenceRank(confidence: SessionConfidence): number {
-  switch (confidence) {
-    case 'high': return 3;
-    case 'medium': return 2;
-    default: return 1;
-  }
-}
-
-function isSupportedSessionFilePath(agent: AgentType, filePath: string): boolean {
-  if (agent === 'claude') {
-    return filePath.includes('/.claude/projects/') && !filePath.includes('/subagents/');
-  }
-  return filePath.includes('/.codex/sessions/');
-}
-
-/**
- * Returns true if the command includes `--continue` (or `-c`), meaning
- * "resume the most recent conversation for this cwd".  When no open
- * session file is found, we cannot reliably determine which session
- * `--continue` actually resolved to — the file-based fallback can pick
- * the *wrong* session if another conversation was created after the
- * process started.
- */
-export function hasContinueFlag(agent: AgentType, command: string): boolean {
-  const detected = detectAgentAndArgs(command);
-  if (!detected || detected.agent !== agent) return false;
-  return detected.args.includes('--continue') || detected.args.includes('-c');
-}
-
-export function classifyProcessSnapshot(snapshot: ProcessSnapshot): RunningSessionCandidate | null {
-  const uniqueFiles = [...new Set(snapshot.sessionFiles)].filter((filePath) =>
-    isSupportedSessionFilePath(snapshot.agent, filePath),
-  );
-  const explicitSessionId = extractExplicitSessionId(snapshot.agent, snapshot.command);
-  const approvalMode = parseApprovalModeFromProcessCommand(snapshot.agent, snapshot.command);
-  if (explicitSessionId) {
-    return {
-      agent: snapshot.agent,
-      pid: snapshot.pid,
-      cwd: snapshot.cwd,
-      command: snapshot.command,
-      sessionId: explicitSessionId,
-      confidence: 'high',
-      ...(approvalMode ? { approvalMode } : {}),
-      ...(uniqueFiles.length === 1 ? { sessionFilePath: uniqueFiles[0] } : {}),
-    };
-  }
-
-  if (uniqueFiles.length !== 1) return null;
-
-  const sessionId = extractSessionIdFromSessionFile(snapshot.agent, uniqueFiles[0]);
-  if (!sessionId) return null;
-
-  return {
-    agent: snapshot.agent,
-    pid: snapshot.pid,
-    cwd: snapshot.cwd,
-    command: snapshot.command,
-    sessionId,
-    confidence: 'medium',
-    ...(approvalMode ? { approvalMode } : {}),
-    sessionFilePath: uniqueFiles[0],
-  };
-}
-
-function pickBetterCandidate(current: RunningSessionCandidate, next: RunningSessionCandidate): RunningSessionCandidate {
-  let winner = current;
-  let loser = next;
-
-  if (confidenceRank(next.confidence) > confidenceRank(current.confidence)) {
-    winner = next;
-    loser = current;
-  } else if (confidenceRank(next.confidence) === confidenceRank(current.confidence) && next.pid < current.pid) {
-    winner = next;
-    loser = current;
-  }
-
-  const approvalMode = winner.approvalMode ?? loser.approvalMode;
-  return {
-    ...winner,
-    cwd: winner.cwd || loser.cwd,
-    ...(approvalMode ? { approvalMode } : {}),
-    title: winner.title ?? loser.title,
-    sessionFilePath: winner.sessionFilePath ?? loser.sessionFilePath,
-    isResponding: winner.isResponding ?? loser.isResponding,
-  };
-}
-
-export function mergeRunningSessionCandidates(candidates: RunningSessionCandidate[]): RunningSessionCandidate[] {
-  const merged = new Map<string, RunningSessionCandidate>();
-  for (const candidate of candidates) {
-    const key = `${candidate.agent}:${candidate.sessionId}`;
-    const current = merged.get(key);
-    merged.set(key, current ? pickBetterCandidate(current, candidate) : candidate);
-  }
-  return [...merged.values()];
-}
-
-export function isProcessAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function runCommand(file: string, args: string[]): Promise<string> {
-  try {
-    const { stdout } = await execFileAsync(file, args, {
-      maxBuffer: 1024 * 1024 * 8,
-      timeout: PROCESS_SCAN_COMMAND_TIMEOUT_MS,
-    });
-    return stdout;
-  } catch (error) {
-    // Downgrade to debug when the target process simply exited between
-    // pgrep and lsof — this is an expected TOCTOU race, not actionable.
-    const msg = String(error);
-    const isEsrch = msg.includes('ESRCH') || msg.includes('No such process');
-    if (isEsrch) {
-      log.debug(
-        { file, args, error: msg },
-        'process scan command skipped — process exited',
-      );
-    } else {
-      log.warn(
-        { file, args, timeoutMs: PROCESS_SCAN_COMMAND_TIMEOUT_MS, error: msg },
-        'process scan command failed',
-      );
-    }
-    return '';
-  }
-}
-
-async function hydrateRunningSessionCandidate(
-  candidate: RunningSessionCandidate,
-): Promise<RunningSessionCandidate | null> {
-  if (!candidate.sessionFilePath) return candidate;
-  const meta = await readSessionFileMeta(candidate.sessionFilePath, candidate.agent);
-  if (!meta) return null;
-  const runtimeHints = await readSessionRuntimeHintsFromFile(candidate.sessionFilePath, candidate.agent);
-  const approvalMode = meta.approvalMode ?? candidate.approvalMode;
-  return {
-    ...candidate,
-    cwd: candidate.cwd || meta.cwd,
-    ...(approvalMode ? { approvalMode } : {}),
-    title: candidate.title ?? meta.title,
-    isResponding: runtimeHints.isResponding,
-  };
-}
-
-async function readProcessCwd(pid: number): Promise<string> {
-  if (process.platform === 'win32') {
-    // On Windows, lsof is not available. We cannot reliably get process cwd,
-    // so return empty and rely on session file-based discovery instead.
-    return '';
-  }
-  const output = await runCommand('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn']);
-  const line = output.split('\n').find((entry) => entry.startsWith('n'));
-  return line?.slice(1).trim() ?? '';
-}
-
-async function readProcessSessionFiles(pid: number): Promise<string[]> {
-  if (process.platform === 'win32') {
-    // On Windows, lsof is not available. Return empty and rely on
-    // session file-based discovery via findRecentSessionFileForCwd.
-    return [];
-  }
-  const output = await runCommand('lsof', ['-p', String(pid), '-Fn']);
-  const results = output
-    .split('\n')
-    .filter((line) => line.startsWith('n'))
-    .map((line) => line.slice(1).trim())
-    .filter((filePath) => {
-      if (!filePath.endsWith('.jsonl')) return false;
-      return filePath.includes('/.claude/projects/') || filePath.includes('/.codex/sessions/');
-    });
-  return [...new Set(results)];
-}
-
-async function listRelevantProcessesUnix(): Promise<Array<{ pid: number; command: string; agent: AgentType }>> {
-  const output = await runCommand('pgrep', ['-fal', RELEVANT_PROCESS_PGREP_PATTERN]);
-  return output
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => {
-      const match = line.match(/^(\d+)\s+(.*)$/);
-      if (!match) return null;
-      const pid = Number(match[1]);
-      const command = match[2];
-      if (!isRelevantProcessCommand(command)) return null;
-      const detected = detectAgentAndArgs(command);
-      if (!Number.isFinite(pid) || !detected) return null;
-      return { pid, command, agent: detected.agent };
-    })
-    .filter((entry): entry is { pid: number; command: string; agent: AgentType } => Boolean(entry));
-}
-
-async function listRelevantProcessesWindows(): Promise<Array<{ pid: number; command: string; agent: AgentType }>> {
-  // Use WMIC to list processes with their command lines
-  const output = await runCommand('wmic', ['process', 'get', 'ProcessId,CommandLine', '/FORMAT:CSV']);
-  return output
-    .split('\n')
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => {
-      // CSV format: Node,CommandLine,ProcessId
-      const parts = line.split(',');
-      if (parts.length < 3) return null;
-      const pid = Number(parts[parts.length - 1]);
-      const command = parts.slice(1, parts.length - 1).join(',');
-      if (!Number.isFinite(pid) || pid === 0) return null;
-      if (!isRelevantProcessCommand(command)) return null;
-      const detected = detectAgentAndArgs(command);
-      if (!detected) return null;
-      return { pid, command, agent: detected.agent };
-    })
-    .filter((entry): entry is { pid: number; command: string; agent: AgentType } => Boolean(entry));
-}
-
-async function listRelevantProcesses(): Promise<Array<{ pid: number; command: string; agent: AgentType }>> {
-  if (process.platform === 'win32') return listRelevantProcessesWindows();
-  return listRelevantProcessesUnix();
-}
-
-export async function scanProcessSnapshots(): Promise<ProcessSnapshot[]> {
-  const processes = await listRelevantProcesses();
-  // Filter out PIDs that already exited between pgrep and now to avoid
-  // pointless lsof calls and noisy log warnings.
-  const alive = processes.filter((p) => isProcessAlive(p.pid));
-  return Promise.all(alive.map(async (proc) => ({
-    pid: proc.pid,
-    agent: proc.agent,
-    command: proc.command,
-    cwd: await readProcessCwd(proc.pid),
-    sessionFiles: await readProcessSessionFiles(proc.pid),
-  })));
-}
-
-function encodeCwd(cwd: string): string {
-  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
-}
-
-export async function findRecentSessionFileForCwd(agent: AgentType, cwd: string): Promise<{ sessionId: string; filePath: string } | null> {
-  if (!cwd) return null;
-
-  try {
-    if (agent === 'claude') {
-      const dirPath = join(homedir(), '.claude', 'projects', encodeCwd(cwd));
-      const files = await readdir(dirPath).catch(() => [] as string[]);
-      const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
-      if (jsonlFiles.length === 0) return null;
-
-      // Find the most recently modified file
-      let newest: { name: string; mtimeMs: number } | null = null;
-      await Promise.all(jsonlFiles.map(async (name) => {
-        const fileStat = await stat(join(dirPath, name)).catch(() => null);
-        if (fileStat && (!newest || fileStat.mtimeMs > newest.mtimeMs)) {
-          newest = { name, mtimeMs: fileStat.mtimeMs };
-        }
-      }));
-
-      if (!newest) return null;
-      const filePath = join(dirPath, (newest as { name: string; mtimeMs: number }).name);
-      const sessionId = extractSessionIdFromSessionFile(agent, filePath);
-      return sessionId ? { sessionId, filePath } : null;
-    }
-
-    // Codex: find the most recently modified session file that actually belongs to the cwd.
-    const sessionsDir = join(homedir(), '.codex', 'sessions');
-    let newest: RecentSessionFileMatch | null = null;
-
-    async function walk(dir: string): Promise<void> {
-      const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        if (entry.isDirectory()) {
-          await walk(fullPath);
-        } else if (entry.name.endsWith('.jsonl')) {
-          const fileStat = await stat(fullPath).catch(() => null);
-          if (!fileStat) {
-            continue;
-          }
-          if (newest && fileStat.mtimeMs <= newest.mtimeMs) {
-            continue;
-          }
-          const meta = await readSessionFileMeta(fullPath, agent);
-          if (!meta || meta.cwd !== cwd) {
-            continue;
-          }
-          newest = {
-            path: fullPath,
-            mtimeMs: fileStat.mtimeMs,
-            sessionId: meta.sessionId,
-          };
-        }
-      }
-    }
-
-    await walk(sessionsDir);
-    const resolvedNewest = newest as RecentSessionFileMatch | null;
-    if (!resolvedNewest) return null;
-    return { sessionId: resolvedNewest.sessionId, filePath: resolvedNewest.path };
-  } catch {
-    return null;
-  }
-}
-
-async function scanRunningSessionsImpl(): Promise<RunningSessionCandidate[]> {
-  const snapshots = await scanProcessSnapshots();
-  const hydrated = await Promise.all(
-    snapshots.map(async (snapshot) => {
-      const candidate = classifyProcessSnapshot(snapshot);
-      if (candidate) return hydrateRunningSessionCandidate(candidate);
-
-      // Skip the mtime-based fallback for --continue processes without open
-      // session files: we cannot reliably determine which session --continue
-      // resolved to, and guessing wrong creates ghost "Remote" duplicates.
-      if (hasContinueFlag(snapshot.agent, snapshot.command)) return null;
-
-      // Fallback: find the most recent session file matching the process's cwd
-      const recent = await findRecentSessionFileForCwd(snapshot.agent, snapshot.cwd);
-      if (!recent) return null;
-      return hydrateRunningSessionCandidate({
-        agent: snapshot.agent,
-        pid: snapshot.pid,
-        cwd: snapshot.cwd,
-        command: snapshot.command,
-        sessionId: recent.sessionId,
-        confidence: 'low',
-        sessionFilePath: recent.filePath,
-      });
-    }),
-  );
-  const result = mergeRunningSessionCandidates(
-    hydrated.filter((candidate): candidate is RunningSessionCandidate => candidate !== null),
-  );
-
-  processScanCache = { value: result, expiresAt: Date.now() + PROCESS_SCAN_TTL };
-  return result;
-}
-
-export async function scanRunningSessions(): Promise<RunningSessionCandidate[]> {
-  if (processScanCache && Date.now() < processScanCache.expiresAt) {
-    return processScanCache.value;
-  }
-
-  // Coalesce concurrent callers into a single in-flight scan
-  if (processScanInflight) return processScanInflight;
-
-  processScanInflight = scanRunningSessionsImpl().finally(() => {
-    processScanInflight = null;
-  });
-  return processScanInflight;
-}

package/src/push-protocol.test.ts

@@ -1,74 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { handlePushProtocolMessage } from './push-protocol.js';
-
-test('handlePushProtocolMessage registers push tokens', () => {
-  const registered: Array<{ deviceId: string; token: string }> = [];
-  const unregistered: Array<{ deviceId: string; token: string }> = [];
-  const responses: Array<{ type: string; id: string; ok: boolean }> = [];
-
-  handlePushProtocolMessage(
-    {
-      action: 'push.register',
-      id: 'push_1',
-      pushToken: 'ExponentPushToken[register]',
-    },
-    {
-      deviceId: 'device-1',
-      registerToken: (deviceId, token) => registered.push({ deviceId, token }),
-      unregisterToken: (deviceId, token) => unregistered.push({ deviceId, token }),
-      respond: (response) => responses.push(response),
-    },
-  );
-
-  assert.deepEqual(registered, [{ deviceId: 'device-1', token: 'ExponentPushToken[register]' }]);
-  assert.deepEqual(unregistered, []);
-  assert.deepEqual(responses, [{ type: 'response', id: 'push_1', ok: true }]);
-});
-
-test('handlePushProtocolMessage unregisters push tokens', () => {
-  const registered: Array<{ deviceId: string; token: string }> = [];
-  const unregistered: Array<{ deviceId: string; token: string }> = [];
-  const responses: Array<{ type: string; id: string; ok: boolean }> = [];
-
-  handlePushProtocolMessage(
-    {
-      action: 'push.unregister',
-      id: 'push_2',
-      pushToken: 'ExponentPushToken[unregister]',
-    },
-    {
-      deviceId: 'device-2',
-      registerToken: (deviceId, token) => registered.push({ deviceId, token }),
-      unregisterToken: (deviceId, token) => unregistered.push({ deviceId, token }),
-      respond: (response) => responses.push(response),
-    },
-  );
-
-  assert.deepEqual(registered, []);
-  assert.deepEqual(unregistered, [{ deviceId: 'device-2', token: 'ExponentPushToken[unregister]' }]);
-  assert.deepEqual(responses, [{ type: 'response', id: 'push_2', ok: true }]);
-});
-
-test('handlePushProtocolMessage rejects push registration without a device context', () => {
-  const registered: Array<{ deviceId: string; token: string }> = [];
-  const unregistered: Array<{ deviceId: string; token: string }> = [];
-  const responses: Array<{ type: string; id: string; ok: boolean; error?: string }> = [];
-
-  handlePushProtocolMessage(
-    {
-      action: 'push.register',
-      id: 'push_3',
-      pushToken: 'ExponentPushToken[missing-device]',
-    },
-    {
-      registerToken: (deviceId, token) => registered.push({ deviceId, token }),
-      unregisterToken: (deviceId, token) => unregistered.push({ deviceId, token }),
-      respond: (response) => responses.push(response),
-    },
-  );
-
-  assert.deepEqual(registered, []);
-  assert.deepEqual(unregistered, []);
-  assert.deepEqual(responses, [{ type: 'response', id: 'push_3', ok: false, error: 'device_auth_required' }]);
-});

package/src/push-protocol.ts

@@ -1,36 +0,0 @@
-import type { ClientMessage, ServerMessage } from '@vibelet/shared';
-
-type PushProtocolMessage = Extract<ClientMessage, { action: 'push.register' | 'push.unregister' }>;
-type PushProtocolResponse = Extract<ServerMessage, { type: 'response' }>;
-
-export function handlePushProtocolMessage(
-  message: PushProtocolMessage,
-  handlers: {
-    deviceId?: string;
-    registerToken: (deviceId: string, token: string) => void;
-    unregisterToken: (deviceId: string, token: string) => void;
-    respond: (response: PushProtocolResponse) => void;
-  },
-): void {
-  if (!handlers.deviceId) {
-    handlers.respond({
-      type: 'response',
-      id: message.id,
-      ok: false,
-      error: 'device_auth_required',
-    });
-    return;
-  }
-
-  if (message.action === 'push.register') {
-    handlers.registerToken(handlers.deviceId, message.pushToken);
-  } else {
-    handlers.unregisterToken(handlers.deviceId, message.pushToken);
-  }
-
-  handlers.respond({
-    type: 'response',
-    id: message.id,
-    ok: true,
-  });
-}