@vibelet/cli 0.1.34 → 0.1.36

package/src/config.test.ts

@@ -0,0 +1,254 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { join } from 'path';
+import { homedir } from 'os';
+import { isTransientPath, buildSanitizedEnv, execViaLoginShell, config } from './config.js';
+
+const configModuleUrl = new URL('./config.ts', import.meta.url).href;
+
+function buildChildEnv(overrides: Record<string, string | undefined>): NodeJS.ProcessEnv {
+  const nextEnv: NodeJS.ProcessEnv = { ...process.env };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === undefined) {
+      delete nextEnv[key];
+    } else {
+      nextEnv[key] = value;
+    }
+  }
+  return nextEnv;
+}
+
+function readConfigValueInIsolatedProcess(
+  overrides: Record<string, string | undefined>,
+  expression: string,
+): string {
+  return execFileSync(
+    process.execPath,
+    [
+      '--import',
+      'tsx',
+      '-e',
+      `import { config } from ${JSON.stringify(configModuleUrl)}; process.stdout.write(String(${expression}));`,
+    ],
+    {
+      env: buildChildEnv(overrides),
+      encoding: 'utf8',
+    },
+  ).trim();
+}
+
+test('isTransientPath: detects fnm_multishells as transient', () => {
+  assert.equal(isTransientPath('/tmp/fnm_multishells/12345/bin/codex'), true);
+});
+
+test('isTransientPath: returns false for normal paths', () => {
+  assert.equal(isTransientPath('/usr/local/bin/codex'), false);
+});
+
+test('isTransientPath: returns false for home directory paths', () => {
+  assert.equal(isTransientPath('/Users/test/.local/bin/claude'), false);
+});
+
+test('isTransientPath: returns false for empty string', () => {
+  assert.equal(isTransientPath(''), false);
+});
+
+// buildSanitizedEnv tests
+
+test('buildSanitizedEnv: returns an object with PATH key', () => {
+  const env = buildSanitizedEnv();
+  assert.ok('PATH' in env);
+  assert.equal(typeof env.PATH, 'string');
+  assert.ok(env.PATH.length > 0);
+});
+
+test('buildSanitizedEnv: PATH includes extra directories', () => {
+  const env = buildSanitizedEnv();
+  assert.ok(env.PATH.includes('/usr/local/bin'));
+});
+
+test('buildSanitizedEnv: HOME is set', () => {
+  const env = buildSanitizedEnv();
+  assert.ok('HOME' in env);
+  assert.equal(typeof env.HOME, 'string');
+  assert.ok(env.HOME.length > 0);
+});
+
+test('buildSanitizedEnv: CLAUDE_CODE_ENTRYPOINT is removed', () => {
+  process.env.CLAUDE_CODE_ENTRYPOINT = 'test_value';
+  const env = buildSanitizedEnv();
+  assert.equal(env.CLAUDE_CODE_ENTRYPOINT, undefined);
+  delete process.env.CLAUDE_CODE_ENTRYPOINT;
+});
+
+test('buildSanitizedEnv: CLAUDECODE is removed', () => {
+  process.env.CLAUDECODE = 'test_value';
+  const env = buildSanitizedEnv();
+  assert.equal(env.CLAUDECODE, undefined);
+  delete process.env.CLAUDECODE;
+});
+
+test('buildSanitizedEnv: contains process.env values', () => {
+  const testKey = 'VIBE_TEST_UNIQUE_KEY_' + Date.now();
+  process.env[testKey] = 'test_value_123';
+  const env = buildSanitizedEnv();
+  assert.equal(env[testKey], 'test_value_123');
+  delete process.env[testKey];
+});
+
+// execViaLoginShell tests
+
+test('execViaLoginShell: returns correct command (a shell path)', () => {
+  const result = execViaLoginShell('claude', ['--help']);
+  assert.equal(typeof result.command, 'string');
+  assert.ok(result.command.startsWith('/'));
+});
+
+test('execViaLoginShell: args contain -lc flag', () => {
+  const result = execViaLoginShell('claude', ['--help']);
+  assert.equal(result.args[0], '-lc');
+});
+
+test('execViaLoginShell: includes the passed cmd in the shell command string', () => {
+  const result = execViaLoginShell('claude', ['--help', '--verbose']);
+  assert.ok(result.args[1].includes('claude'));
+});
+
+test('execViaLoginShell: includes the passed args after -- separator', () => {
+  const result = execViaLoginShell('claude', ['--help', '--verbose']);
+  const dashDashIndex = result.args.indexOf('--');
+  assert.ok(dashDashIndex >= 0);
+  assert.equal(result.args[dashDashIndex + 1], '--help');
+  assert.equal(result.args[dashDashIndex + 2], '--verbose');
+});
+
+// config object tests
+
+test('config.port: defaults to 9876 when VIBE_PORT not set', () => {
+  assert.equal(config.port, 9876);
+});
+
+test('config.legacyToken: defaults to an empty string', () => {
+  assert.equal(config.legacyToken, '');
+});
+
+test('config.legacyToken: respects VIBE_TOKEN env override on fresh import', async () => {
+  const original = process.env.VIBE_TOKEN;
+  process.env.VIBE_TOKEN = 'legacy-secret';
+  try {
+    const freshModule = await import(`./config.ts?test=${Date.now()}`);
+    assert.equal(freshModule.config.legacyToken, 'legacy-secret');
+  } finally {
+    if (original == null) {
+      delete process.env.VIBE_TOKEN;
+    } else {
+      process.env.VIBE_TOKEN = original;
+    }
+  }
+});
+
+test('config.idleTimeoutMs: allows disabling idle sweep with 0', () => {
+  assert.equal(
+    readConfigValueInIsolatedProcess(
+      { VIBE_IDLE_TIMEOUT_MS: '0' },
+      'config.idleTimeoutMs',
+    ),
+    '0',
+  );
+});
+
+test('config.turnStallTimeoutMs: defaults to 5 minutes', () => {
+  assert.equal(config.turnStallTimeoutMs, 5 * 60 * 1000);
+});
+
+test('config.turnStallTimeoutMs: allows disabling stall sweep with 0', () => {
+  assert.equal(
+    readConfigValueInIsolatedProcess(
+      { VIBE_TURN_STALL_TIMEOUT_MS: '0' },
+      'config.turnStallTimeoutMs',
+    ),
+    '0',
+  );
+});
+
+test('config.turnStallTimeoutMs: respects env override on fresh import', () => {
+  assert.equal(
+    readConfigValueInIsolatedProcess(
+      { VIBE_TURN_STALL_TIMEOUT_MS: '120000' },
+      'config.turnStallTimeoutMs',
+    ),
+    '120000',
+  );
+});
+
+test('config.isTransientPath: is the isTransientPath function', () => {
+  assert.equal(config.isTransientPath, isTransientPath);
+});
+
+test('config.buildSanitizedEnv: is the buildSanitizedEnv function', () => {
+  assert.equal(config.buildSanitizedEnv, buildSanitizedEnv);
+});
+
+// Binary detection / cached resolver tests
+
+test('config.claudePath: returns a path string', () => {
+  // This may resolve to a real path or fall back to 'claude'
+  const path = config.claudePath;
+  assert.equal(typeof path, 'string');
+  assert.ok(path.length > 0);
+});
+
+test('config.codexPath: returns a path string', () => {
+  const path = config.codexPath;
+  assert.equal(typeof path, 'string');
+  assert.ok(path.length > 0);
+});
+
+test('config.claudePath: respects CLAUDE_PATH env override', () => {
+  assert.equal(
+    readConfigValueInIsolatedProcess(
+      { CLAUDE_PATH: '/custom/path/to/claude' },
+      'config.claudePath',
+    ),
+    '/custom/path/to/claude',
+  );
+});
+
+test('config.codexPath: respects CODEX_PATH env override', () => {
+  assert.equal(
+    readConfigValueInIsolatedProcess(
+      { CODEX_PATH: '/custom/path/to/codex' },
+      'config.codexPath',
+    ),
+    '/custom/path/to/codex',
+  );
+});
+
+test('buildSanitizedEnv: PATH includes all required extra directories', () => {
+  const env = buildSanitizedEnv();
+  const home = homedir();
+  const requiredDirs = [
+    '/usr/local/bin',
+    '/opt/homebrew/bin',
+    join(home, '.npm-global', 'bin'),
+    join(home, '.local', 'bin'),
+    join(home, '.claude', 'bin'),
+  ];
+  for (const dir of requiredDirs) {
+    assert.ok(env.PATH.includes(dir), `PATH should include ${dir}`);
+  }
+});
+
+test('buildSanitizedEnv: includes home-relative paths', () => {
+  const env = buildSanitizedEnv();
+  const home = homedir();
+  assert.ok(env.PATH.includes(join(home, '.local', 'bin')) || env.PATH.includes('.local/bin'));
+});
+
+test('execViaLoginShell: works with codex command', () => {
+  const result = execViaLoginShell('codex', ['app-server', '--listen', 'stdio://']);
+  assert.ok(result.args[1].includes('codex'));
+  const dashDashIndex = result.args.indexOf('--');
+  assert.equal(result.args[dashDashIndex + 1], 'app-server');
+});

package/src/config.ts

@@ -0,0 +1,324 @@
+import { execFileSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join, delimiter } from 'path';
+import { homedir } from 'os';
+import { logger as rootLogger } from './logger.js';
+
+const TRANSIENT_PATH_MARKERS = ['fnm_multishells'];
+const CACHE_TTL = 60_000;
+const IS_WIN32 = process.platform === 'win32';
+const log = rootLogger.child({ module: 'config' });
+
+export function isTransientPath(p: string): boolean {
+  return TRANSIENT_PATH_MARKERS.some(marker => p.includes(marker));
+}
+
+function getLoginShellCandidates(): string[] {
+  if (IS_WIN32) return []; // No login shell on Windows
+  return [process.env.SHELL, '/bin/zsh', '/bin/bash', '/bin/sh']
+    .filter((s): s is string => !!s)
+    .filter((s, i, a) => a.indexOf(s) === i);
+}
+
+// ===== Shell Environment =====
+
+let cachedShellEnv: Record<string, string> | null = null;
+
+function loadUserShellEnv(): Record<string, string> {
+  if (cachedShellEnv && !isTransientPath(cachedShellEnv.PATH ?? '')) return cachedShellEnv;
+
+  for (const shell of getLoginShellCandidates()) {
+    try {
+      const result = execFileSync(shell, ['-ilc', 'env'], {
+        timeout: 5000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      const env: Record<string, string> = {};
+      for (const line of result.split('\n')) {
+        const idx = line.indexOf('=');
+        if (idx > 0) env[line.slice(0, idx)] = line.slice(idx + 1);
+      }
+      if (!isTransientPath(env.PATH ?? '')) {
+        cachedShellEnv = env;
+      } else {
+        cachedShellEnv = null;
+      }
+      return env;
+    } catch { /* next */ }
+  }
+  cachedShellEnv = {};
+  return {};
+}
+
+function getExpandedPath(shellEnv: Record<string, string> = loadUserShellEnv()): string {
+  const home = homedir();
+  const pnpmHome = shellEnv.PNPM_HOME || process.env.PNPM_HOME || (IS_WIN32 ? join(home, 'pnpm') : join(home, 'Library', 'pnpm'));
+  const basePath = shellEnv.PATH || process.env.PATH || '';
+  const extra = IS_WIN32
+    ? [
+        join(home, '.npm-global', 'bin'),
+        join(home, '.local', 'bin'),
+        join(home, '.claude', 'bin'),
+        pnpmHome,
+        join(home, 'AppData', 'Roaming', 'npm'),
+        join(home, 'AppData', 'Local', 'Programs', 'node'),
+      ]
+    : [
+        '/usr/local/bin', '/opt/homebrew/bin', '/usr/bin', '/bin',
+        join(home, '.npm-global', 'bin'),
+        join(home, '.local', 'bin'),
+        join(home, '.claude', 'bin'),
+        pnpmHome,
+      ];
+  const current = basePath.split(delimiter).filter(Boolean);
+  const seen = new Set(current);
+  for (const p of extra) {
+    if (!seen.has(p)) { current.push(p); seen.add(p); }
+  }
+  return current.join(delimiter);
+}
+
+function getPositiveNumberEnv(name: string, fallback: number): number {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+
+function getNonNegativeNumberEnv(name: string, fallback: number): number {
+  const raw = process.env[name];
+  if (raw == null || raw === '') return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : fallback;
+}
+
+export function buildSanitizedEnv(): Record<string, string> {
+  const shellEnv = loadUserShellEnv();
+  const merged: Record<string, string> = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (typeof v === 'string') merged[k] = v;
+  }
+  for (const [k, v] of Object.entries(shellEnv)) {
+    if (typeof v === 'string') merged[k] = v;
+  }
+  merged.PATH = getExpandedPath(shellEnv);
+  if (!merged.HOME) merged.HOME = homedir();
+  delete merged.CLAUDE_CODE_ENTRYPOINT;
+  delete merged.CLAUDECODE;
+  return merged;
+}
+
+// ===== Binary Detection =====
+
+/**
+ * On Windows, resolve a bare command name like "codex" to its real executable
+ * path (e.g. codex.exe) using `where.exe`. This avoids the common issue where
+ * Node's `spawn('codex')` fails with ENOENT because it doesn't search PATH
+ * for `.cmd`/`.ps1`/`.exe` extensions the way PowerShell/cmd do.
+ */
+function resolveViaWhere(name: string): string | undefined {
+  if (!IS_WIN32) return undefined;
+  try {
+    const output = execFileSync('where.exe', [name], {
+      timeout: 3000, stdio: 'pipe', encoding: 'utf-8',
+    }).trim();
+    // `where` returns one result per line. Prefer .exe over .cmd/.ps1
+    const lines = output.split(/\r?\n/).filter(Boolean);
+    const exe = lines.find(l => l.endsWith('.exe'));
+    return exe ?? lines[0];
+  } catch { return undefined; }
+}
+
+function runVersionSync(binaryPath: string, timeout = 3000): string | null {
+  try {
+    return execFileSync(binaryPath, ['--version'], {
+      timeout, stdio: 'pipe', encoding: 'utf-8', env: buildSanitizedEnv(),
+      ...(IS_WIN32 ? { shell: true } : {}),
+    }).trim() || null;
+  } catch { return null; }
+}
+
+function runViaLoginShellSync(cmd: string, args: string[], timeout = 5000): string | null {
+  for (const shell of getLoginShellCandidates()) {
+    try {
+      return execFileSync(shell, ['-ilc', `command -v ${cmd} >/dev/null 2>&1 && exec ${cmd} "$@"`, '--', ...args], {
+        timeout, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8',
+      }).trim() || null;
+    } catch { /* next */ }
+  }
+  return null;
+}
+
+function findViaLoginShell(cmd: string): string | undefined {
+  for (const shell of getLoginShellCandidates()) {
+    try {
+      const result = execFileSync(shell, ['-ilc', `command -v ${cmd}`], {
+        timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf-8',
+      }).trim();
+      if (result) return result;
+    } catch { /* next */ }
+  }
+  return undefined;
+}
+
+// ===== Claude Detection =====
+
+function getClaudeCandidates(): string[] {
+  const home = homedir();
+  return [
+    join(home, '.local', 'bin', 'claude'),
+    join(home, '.claude', 'bin', 'claude'),
+    '/usr/local/bin/claude',
+    '/opt/homebrew/bin/claude',
+    join(home, '.npm-global', 'bin', 'claude'),
+  ];
+}
+
+function findClaudeUncached(): string | undefined {
+  // On Windows, use `where.exe` instead of known Unix paths
+  if (IS_WIN32) {
+    const found = resolveViaWhere('claude');
+    if (found && runVersionSync(found)) return found;
+    return undefined;
+  }
+  // Check known paths
+  for (const p of getClaudeCandidates()) {
+    if (runVersionSync(p)) return p;
+  }
+  // which (with sanitized env that has expanded PATH)
+  try {
+    const result = execFileSync('/usr/bin/which', ['claude'], {
+      timeout: 3000, stdio: 'pipe', encoding: 'utf-8', env: buildSanitizedEnv(),
+    }).trim();
+    // Skip cmux wrappers
+    if (result && !result.includes('cmux') && runVersionSync(result)) return result;
+  } catch { /* not found */ }
+  return undefined;
+}
+
+// ===== Codex Detection =====
+
+function getCodexCandidates(): string[] {
+  const home = homedir();
+  const pnpmHomes = [process.env.PNPM_HOME, join(home, 'Library', 'pnpm')]
+    .filter((p): p is string => !!p);
+  return [
+    '/usr/local/bin/codex',
+    '/opt/homebrew/bin/codex',
+    join(home, '.npm-global', 'bin', 'codex'),
+    join(home, '.local', 'bin', 'codex'),
+    ...pnpmHomes.map(p => join(p, 'codex')),
+  ];
+}
+
+function findCodexUncached(): string | undefined {
+  // On Windows, use `where.exe` to find the real executable
+  if (IS_WIN32) {
+    const found = resolveViaWhere('codex');
+    if (found && runVersionSync(found)) return found;
+    return undefined;
+  }
+  let transientFallback: string | undefined;
+  // Check known paths
+  for (const p of getCodexCandidates()) {
+    if (!runVersionSync(p)) continue;
+    if (!isTransientPath(p)) return p;
+    transientFallback = p;
+  }
+  // which with sanitized env
+  try {
+    const result = execFileSync('/usr/bin/which', ['codex'], {
+      timeout: 3000, stdio: 'pipe', encoding: 'utf-8', env: buildSanitizedEnv(),
+    }).trim();
+    if (result && runVersionSync(result)) {
+      if (!isTransientPath(result)) return result;
+      transientFallback = transientFallback ?? result;
+    }
+  } catch { /* not found */ }
+  // Login shell fallback
+  const found = findViaLoginShell('codex');
+  if (found && runVersionSync(found)) {
+    if (!isTransientPath(found)) return found;
+    transientFallback = transientFallback ?? found;
+  }
+  return transientFallback;
+}
+
+// ===== Cached Resolvers =====
+
+function createCachedResolver(finder: () => string | undefined, name: string) {
+  let cached: string | null = null;
+  let timestamp = 0;
+  return (): string => {
+    const envKey = name === 'claude' ? 'CLAUDE_PATH' : 'CODEX_PATH';
+    if (process.env[envKey]) return process.env[envKey]!;
+
+    const now = Date.now();
+    // Re-resolve if expired, missing, or transient
+    if (!cached || now - timestamp > CACHE_TTL || !existsSync(cached) || isTransientPath(cached)) {
+      const found = finder();
+      cached = found ?? name;
+      timestamp = now;
+      log.info({ name, path: cached, transient: isTransientPath(cached) }, 'binary resolved');
+    }
+    return cached;
+  };
+}
+
+const resolveClaude = createCachedResolver(findClaudeUncached, 'claude');
+const resolveCodex = createCachedResolver(findCodexUncached, 'codex');
+
+// ===== CLI Args =====
+
+function parseCliArgs(): Record<string, string> {
+  const result: Record<string, string> = {};
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--') && i + 1 < args.length) {
+      const key = arg.slice(2);
+      result[key] = args[++i];
+    }
+  }
+  return result;
+}
+
+const cliArgs = parseCliArgs();
+
+// ===== Export =====
+
+export function execViaLoginShell(cmd: string, args: string[]): { command: string; args: string[] } {
+  if (IS_WIN32) {
+    // On Windows, resolve via where.exe and spawn directly
+    const resolved = resolveViaWhere(cmd);
+    return { command: resolved ?? cmd, args };
+  }
+  const shell = getLoginShellCandidates()[0] ?? '/bin/zsh';
+  return {
+    command: shell,
+    args: ['-lc', `command -v ${cmd} >/dev/null 2>&1 && exec ${cmd} "$@"`, '--', ...args],
+  };
+}
+
+export const config = {
+  port: Number(process.env.VIBE_PORT) || 9876,
+  legacyToken: process.env.VIBE_TOKEN || '',
+  canonicalHost: cliArgs['host'] || process.env.VIBELET_CANONICAL_HOST || process.env.VIBELET_HOST || '',
+  fallbackHosts: cliArgs['fallback-hosts'] || process.env.VIBELET_FALLBACK_HOSTS || '',
+  /** Public relay URL (e.g. https://abc.trycloudflare.com). Overrides host/port in QR pairing payload. */
+  relayUrl: process.env.VIBELET_RELAY_URL || '',
+  /** Idle timeout in ms before a driver is automatically released. Default: 30 minutes. 0 = disabled. */
+  idleTimeoutMs: getNonNegativeNumberEnv('VIBE_IDLE_TIMEOUT_MS', 30 * 60 * 1000),
+  /** Maximum inactivity in ms for an in-flight turn before it is failed and the driver is stopped. 0 = disabled. */
+  turnStallTimeoutMs: getNonNegativeNumberEnv('VIBE_TURN_STALL_TIMEOUT_MS', 5 * 60 * 1000),
+  /** Maximum size for ~/.vibelet/data/audit.jsonl before it is trimmed in place. */
+  auditMaxBytes: getPositiveNumberEnv('VIBE_AUDIT_MAX_BYTES', 8 * 1024 * 1024),
+  /** Maximum size for each ~/.vibelet/logs/daemon.*.log file before it is trimmed in place. */
+  daemonLogMaxBytes: getPositiveNumberEnv('VIBE_DAEMON_LOG_MAX_BYTES', 16 * 1024 * 1024),
+  /** How often the daemon trims its own stdout/stderr logs. */
+  storageHousekeepingIntervalMs: getPositiveNumberEnv('VIBE_STORAGE_HOUSEKEEPING_INTERVAL_MS', 5 * 60 * 1000),
+  get claudePath() { return resolveClaude(); },
+  get codexPath() { return resolveCodex(); },
+  isTransientPath,
+  execViaLoginShell,
+  buildSanitizedEnv,
+};