@vibelet/cli 0.1.37 → 1.0.0

package/src/config.ts

@@ -1,324 +0,0 @@
-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,
-};

package/src/dev-auth.test.ts

@@ -1,183 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawn, type ChildProcess } from 'node:child_process';
-import { rmSync, mkdtempSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { tmpdir } from 'node:os';
-import { createServer, Socket } from 'node:net';
-import path from 'node:path';
-import test from 'node:test';
-import { fileURLToPath } from 'node:url';
-import WebSocket from 'ws';
-
-const require = createRequire(import.meta.url);
-const srcDir = path.dirname(fileURLToPath(import.meta.url));
-const daemonDir = path.resolve(srcDir, '..');
-const tsxPackageJsonPath = require.resolve('tsx/package.json');
-const tsxCliPath = path.resolve(path.dirname(tsxPackageJsonPath), 'dist/cli.mjs');
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function getFreePort(): Promise<number> {
-  const server = createServer();
-  server.listen(0, '127.0.0.1');
-  await new Promise<void>((resolve) => server.once('listening', () => resolve()));
-  const address = server.address();
-  assert.ok(address && typeof address === 'object');
-  const { port } = address;
-  await new Promise<void>((resolve, reject) => {
-    server.close((error) => (error ? reject(error) : resolve()));
-  });
-  return port;
-}
-
-async function isPortListening(port: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = new Socket();
-
-    const finish = (result: boolean) => {
-      socket.removeAllListeners();
-      socket.destroy();
-      resolve(result);
-    };
-
-    socket.setTimeout(200);
-    socket.once('connect', () => finish(true));
-    socket.once('timeout', () => finish(false));
-    socket.once('error', () => finish(false));
-    socket.connect(port, '127.0.0.1');
-  });
-}
-
-async function waitForPortState(port: number, expectedListening: boolean, timeoutMs: number): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-
-  while (Date.now() < deadline) {
-    if ((await isPortListening(port)) === expectedListening) {
-      return;
-    }
-    await delay(100);
-  }
-
-  throw new Error(`Timed out waiting for port ${port} to become ${expectedListening ? 'open' : 'closed'}.`);
-}
-
-async function waitForExit(child: ChildProcess, timeoutMs: number): Promise<void> {
-  if (child.exitCode !== null || child.signalCode !== null) return;
-
-  await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error('Timed out waiting for daemon to exit.')), timeoutMs);
-
-    child.once('exit', () => {
-      clearTimeout(timer);
-      resolve();
-    });
-  });
-}
-
-async function cleanupChild(child: ChildProcess, port: number): Promise<void> {
-  if (child.exitCode === null && child.signalCode === null) {
-    child.kill('SIGTERM');
-    try {
-      await waitForExit(child, 5000);
-    } catch {}
-  }
-
-  await waitForPortState(port, false, 5000).catch(() => {});
-}
-
-async function openWebSocket(url: string): Promise<WebSocket> {
-  return new Promise((resolve, reject) => {
-    const ws = new WebSocket(url);
-    const timer = setTimeout(() => {
-      ws.terminate();
-      reject(new Error(`Timed out waiting for websocket open: ${url}`));
-    }, 5000);
-
-    ws.once('open', () => {
-      clearTimeout(timer);
-      resolve(ws);
-    });
-    ws.once('error', (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-    ws.once('close', (code, reason) => {
-      clearTimeout(timer);
-      reject(new Error(`WebSocket closed before opening (${code}): ${reason.toString()}`));
-    });
-  });
-}
-
-async function waitForCloseCode(url: string): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const ws = new WebSocket(url);
-    const timer = setTimeout(() => {
-      ws.terminate();
-      reject(new Error(`Timed out waiting for websocket close: ${url}`));
-    }, 5000);
-
-    ws.once('close', (code) => {
-      clearTimeout(timer);
-      resolve(code);
-    });
-    ws.once('error', () => {
-      // The server closes invalid connections quickly; rely on the close code.
-    });
-  });
-}
-
-test(
-  'dev mode still requires a valid token for protected HTTP and WebSocket access',
-  { timeout: 30000 },
-  async (t) => {
-    const port = await getFreePort();
-    const homeDir = mkdtempSync(path.join(tmpdir(), 'vibelet-dev-auth-'));
-    const packageJsonPath = path.resolve(daemonDir, 'package.json');
-    const validToken = 'test-token';
-
-    const child = spawn(process.execPath, [tsxCliPath, 'src/index.ts'], {
-      cwd: daemonDir,
-      env: {
-        ...process.env,
-        HOME: homeDir,
-        VIBE_PORT: String(port),
-        VIBE_DEV: '1',
-        VIBE_TOKEN: validToken,
-        CLAUDE_PATH: process.execPath,
-        CODEX_PATH: process.execPath,
-      },
-      stdio: 'ignore',
-    });
-
-    t.after(async () => {
-      await cleanupChild(child, port);
-      rmSync(homeDir, { recursive: true, force: true });
-    });
-
-    await waitForPortState(port, true, 15000);
-
-    const invalidUrl = new URL(`http://127.0.0.1:${port}/file`);
-    invalidUrl.searchParams.set('path', packageJsonPath);
-    invalidUrl.searchParams.set('token', '1');
-
-    const invalidResponse = await fetch(invalidUrl);
-    assert.equal(invalidResponse.status, 401);
-
-    const validUrl = new URL(`http://127.0.0.1:${port}/file`);
-    validUrl.searchParams.set('path', packageJsonPath);
-    validUrl.searchParams.set('token', validToken);
-
-    const validResponse = await fetch(validUrl);
-    assert.equal(validResponse.status, 200);
-    assert.match(await validResponse.text(), /"name": "@vibelet\/daemon"/);
-
-    const closedCode = await waitForCloseCode(`ws://127.0.0.1:${port}?token=1`);
-    assert.equal(closedCode, 4001);
-
-    const ws = await openWebSocket(`ws://127.0.0.1:${port}?token=${encodeURIComponent(validToken)}`);
-    ws.close();
-    await new Promise<void>((resolve) => ws.once('close', () => resolve()));
-  },
-);