@vibelet/cli 0.1.38 → 1.0.0

package/perf-reporter.mjs

@@ -1,138 +0,0 @@
-/**
- * Custom Node.js test reporter that extracts performance metrics
- * and writes them to a JSON baseline file.
- *
- * Usage:
- *   pnpm test:perf:baseline
- */
-
-function parseMetrics(text) {
-  const metrics = {};
-  const totalMatch = text.match(/([\d.]+)ms\s+total/);
-  if (totalMatch) metrics.totalMs = parseFloat(totalMatch[1]);
-  const avgMatch = text.match(/([\d.]+)ms\s+avg/);
-  if (avgMatch) metrics.avgMs = parseFloat(avgMatch[1]);
-  const forMatch = text.match(/([\d.]+)ms\s+for\s+(\d+)\s+calls/);
-  if (forMatch) {
-    metrics.totalMs = parseFloat(forMatch[1]);
-    metrics.calls = parseInt(forMatch[2], 10);
-  }
-  const coldMatch = text.match(/cold:\s*([\d.]+)ms/);
-  if (coldMatch) metrics.coldMs = parseFloat(coldMatch[1]);
-  const cachedMatch = text.match(/cached:\s*([\d.]+)ms/);
-  if (cachedMatch) metrics.cachedMs = parseFloat(cachedMatch[1]);
-  const throttledMatch = text.match(/throttled:\s*([\d.]+)ms/);
-  if (throttledMatch) metrics.throttledMs = parseFloat(throttledMatch[1]);
-  const pagesMatch = text.match(/(\d+)\s+pages,\s+(\d+)\s+sessions,\s+([\d.]+)ms/);
-  if (pagesMatch) {
-    metrics.pages = parseInt(pagesMatch[1], 10);
-    metrics.sessions = parseInt(pagesMatch[2], 10);
-    metrics.totalMs = parseFloat(pagesMatch[3]);
-  }
-  return metrics;
-}
-
-/**
- * Match a stdout line to its test by looking for key phrases from the test name.
- * E.g., test "small Claude file (10 lines) × 100 < 200ms" matches stdout "small (10 lines): 23.25ms total"
- */
-function findMetricsLine(allStdout, testName) {
-  // Extract a short key from the test name for matching
-  // Try to match parenthesized content like "(10 lines)", "(uuid)", "(short)", etc.
-  const parenMatch = testName.match(/\(([^)]+)\)/);
-  const keyword = parenMatch ? parenMatch[1] : null;
-
-  for (const line of allStdout) {
-    if (line.used) continue;
-    if (keyword && line.text.includes(keyword)) {
-      line.used = true;
-      return line.text;
-    }
-  }
-
-  // Fallback: try matching key words from test name
-  const words = testName.toLowerCase().split(/\s+/).filter(w => w.length > 3);
-  for (const line of allStdout) {
-    if (line.used) continue;
-    const lower = line.text.toLowerCase();
-    const matchCount = words.filter(w => lower.includes(w)).length;
-    if (matchCount >= 2) {
-      line.used = true;
-      return line.text;
-    }
-  }
-
-  return null;
-}
-
-export default async function* perfReporter(source) {
-  const results = [];
-  const suiteStack = [];
-  // Collect all stdout lines with a used flag
-  const stdoutLines = [];
-
-  for await (const event of source) {
-    switch (event.type) {
-      case 'test:stdout':
-        if (event.data.message) {
-          // Split on newlines in case multiple lines arrive in one event
-          for (const line of event.data.message.split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed) stdoutLines.push({ text: trimmed, used: false });
-          }
-        }
-        break;
-
-      case 'test:pass':
-      case 'test:fail': {
-        const name = event.data.name;
-        const nesting = event.data.nesting;
-        if (nesting === 0) break;
-
-        const suite = suiteStack.length > 0 ? suiteStack[suiteStack.length - 1] : '';
-        const durationMs = event.data.details?.duration_ms ?? 0;
-
-        // Find matching metrics from stdout
-        const metricsLine = findMetricsLine(stdoutLines, name);
-        const metrics = metricsLine ? parseMetrics(metricsLine) : {};
-
-        results.push({
-          test: name,
-          suite,
-          durationMs,
-          passed: event.type === 'test:pass',
-          metrics,
-        });
-        break;
-      }
-
-      case 'test:dequeue':
-        if (event.data.nesting === 1) {
-          suiteStack.push(event.data.name);
-        }
-        break;
-
-      case 'test:complete':
-        if (event.data.nesting === 1) {
-          suiteStack.pop();
-        }
-        break;
-    }
-  }
-
-  const baseline = {
-    timestamp: new Date().toISOString(),
-    nodeVersion: process.version,
-    platform: process.platform,
-    arch: process.arch,
-    results,
-    summary: {
-      total: results.length,
-      passed: results.filter(r => r.passed).length,
-      failed: results.filter(r => !r.passed).length,
-      totalDurationMs: results.reduce((sum, r) => sum + r.durationMs, 0),
-    },
-  };
-
-  yield JSON.stringify(baseline, null, 2) + '\n';
-}

package/scripts/build-release.mjs

@@ -1,41 +0,0 @@
-import { build } from 'esbuild';
-import { mkdirSync, readFileSync, rmSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const daemonDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const outdir = resolve(daemonDir, '..', '..', 'dist');
-const rootPackageJson = JSON.parse(readFileSync(resolve(daemonDir, '..', '..', 'package.json'), 'utf8'));
-
-rmSync(outdir, { recursive: true, force: true });
-mkdirSync(outdir, { recursive: true });
-
-const sharedBuildOptions = {
-  bundle: true,
-  format: 'cjs',
-  platform: 'node',
-  target: 'node18',
-  minify: true,
-  sourcemap: false,
-  legalComments: 'none',
-  logLevel: 'info',
-  define: {
-    'process.env.VIBELET_CLI_VERSION': JSON.stringify(rootPackageJson.version),
-  },
-};
-
-await build({
-  ...sharedBuildOptions,
-  entryPoints: [resolve(daemonDir, 'src/index.ts')],
-  outfile: resolve(outdir, 'index.cjs'),
-});
-
-await build({
-  ...sharedBuildOptions,
-  stdin: {
-    contents: "import { CLI_VERSION } from './src/cli-version.ts'; process.stdout.write(`${CLI_VERSION}\\n`);",
-    resolveDir: daemonDir,
-    sourcefile: 'runtime-version-entry.ts',
-  },
-  outfile: resolve(outdir, 'runtime-version.cjs'),
-});

package/scripts/dev.mjs

@@ -1,537 +0,0 @@
-import { execFileSync, spawn } from 'node:child_process';
-import { mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { Socket } from 'node:net';
-import { constants as osConstants, homedir } from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { extractQuickTunnelUrl } from '../../../bin/cloudflared-quick-tunnel.mjs';
-import { formatCloudflaredFailureMessage, resolveCloudflaredLaunchSpec } from '../../../bin/cloudflared-resolver.mjs';
-
-const require = createRequire(import.meta.url);
-const currentScriptPath = fileURLToPath(import.meta.url);
-const scriptDir = path.dirname(currentScriptPath);
-const daemonDir = path.resolve(scriptDir, '..');
-const rootPackageJson = JSON.parse(readFileSync(path.resolve(daemonDir, '..', '..', 'package.json'), 'utf8'));
-const tsxPackageJsonPath = require.resolve('tsx/package.json');
-const tsxCliPath = path.resolve(path.dirname(tsxPackageJsonPath), 'dist/cli.mjs');
-const supportsDetachedGroupKill = process.platform !== 'win32';
-const vibeletDir = path.join(homedir(), '.vibelet');
-const relayConfigPath = path.join(vibeletDir, 'relay.json');
-
-let shuttingDown = false;
-let forceKillTimer;
-
-function fail(message) {
-  console.error(`[dev] ${message}`);
-  process.exit(1);
-}
-
-function parseNamedArg(name) {
-  const inlinePrefix = `--${name}=`;
-  const inlineArg = process.argv.find((arg) => arg.startsWith(inlinePrefix));
-  if (inlineArg) {
-    return inlineArg.slice(inlinePrefix.length);
-  }
-
-  const idx = process.argv.indexOf(`--${name}`);
-  if (idx === -1) return null;
-  const value = process.argv[idx + 1];
-  if (!value || value.startsWith('-')) {
-    return null;
-  }
-  return value;
-}
-
-function parseCommandArg(argv) {
-  const positionalArgs = [];
-  const namedArgsWithValues = new Set(['--relay', '--host', '--fallback-hosts']);
-
-  for (let index = 2; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (!arg || arg === '--') continue;
-
-    if (namedArgsWithValues.has(arg)) {
-      index += 1;
-      continue;
-    }
-
-    if (
-      arg.startsWith('--relay=')
-      || arg.startsWith('--host=')
-      || arg.startsWith('--fallback-hosts=')
-      || arg.startsWith('--')
-    ) {
-      continue;
-    }
-
-    positionalArgs.push(arg);
-  }
-
-  if (positionalArgs.length === 0) {
-    return 'start';
-  }
-
-  if (positionalArgs.length > 1) {
-    fail(`Too many positional arguments: ${positionalArgs.join(' ')}`);
-  }
-
-  return positionalArgs[0];
-}
-
-function readNpmConfigArg(name) {
-  const envKey = `npm_config_${name.replace(/-/g, '_')}`;
-  const value = process.env[envKey];
-  return typeof value === 'string' ? value : null;
-}
-
-function loadRelayConfig() {
-  try {
-    const data = JSON.parse(readFileSync(relayConfigPath, 'utf8'));
-    return typeof data.relayUrl === 'string' ? data.relayUrl : '';
-  } catch {
-    return '';
-  }
-}
-
-function saveRelayConfig(relayUrl) {
-  mkdirSync(vibeletDir, { recursive: true });
-  writeFileSync(relayConfigPath, JSON.stringify({ relayUrl }, null, 2) + '\n', 'utf8');
-}
-
-function clearRelayConfig() {
-  rmSync(relayConfigPath, { force: true });
-}
-
-// ─── Tunnel management (shared logic with vibelet.mjs) ──────────────────────
-
-const port = Number(process.env.VIBE_PORT) || 9876;
-const tunnelStatePath = path.join(vibeletDir, 'tunnel.json');
-const devStatePath = path.join(vibeletDir, `dev-daemon-${port}.json`);
-const logDir = path.join(vibeletDir, 'logs');
-const command = parseCommandArg(process.argv);
-
-if (command !== 'start' && command !== 'restart') {
-  fail(`Unknown command: ${command}. Use \`start\` or \`restart\`.`);
-}
-
-function consumeFlag(name) {
-  const idx = process.argv.indexOf(`--${name}`);
-  if (idx === -1) return false;
-  process.argv.splice(idx, 1);
-  return true;
-}
-
-function isProcessAlive(pid) {
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-
-function loadTunnelState() {
-  try { return JSON.parse(readFileSync(tunnelStatePath, 'utf8')); } catch { return null; }
-}
-
-function saveTunnelState(pid, url) {
-  mkdirSync(vibeletDir, { recursive: true });
-  writeFileSync(tunnelStatePath, JSON.stringify({ pid, url }, null, 2) + '\n', 'utf8');
-}
-
-function clearTunnelState() { rmSync(tunnelStatePath, { force: true }); }
-
-function readDevState() {
-  try {
-    const parsed = JSON.parse(readFileSync(devStatePath, 'utf8'));
-    const pid = Number(parsed?.pid);
-    return Number.isFinite(pid) && pid > 0 ? { pid } : null;
-  } catch {
-    return null;
-  }
-}
-
-function writeDevState(pid = process.pid) {
-  mkdirSync(vibeletDir, { recursive: true });
-  writeFileSync(devStatePath, JSON.stringify({ pid, port }, null, 2) + '\n', 'utf8');
-}
-
-function clearDevState(expectedPid = process.pid) {
-  const state = readDevState();
-  if (state && state.pid !== expectedPid) {
-    return;
-  }
-  rmSync(devStatePath, { force: true });
-}
-
-function stopTunnel() {
-  const state = loadTunnelState();
-  if (state?.pid && isProcessAlive(state.pid)) {
-    try { process.kill(state.pid, 'SIGTERM'); } catch { /* */ }
-  }
-  clearTunnelState();
-}
-
-function getAliveTunnel() {
-  const state = loadTunnelState();
-  return (state?.pid && state?.url && isProcessAlive(state.pid)) ? state : null;
-}
-
-function readCommandForPid(pid) {
-  try {
-    return execFileSync('ps', ['-p', String(pid), '-o', 'command='], {
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim();
-  } catch {
-    return '';
-  }
-}
-
-function getTrackedWrapperPid() {
-  const state = readDevState();
-  if (!state || state.pid === process.pid) {
-    return null;
-  }
-  if (!isProcessAlive(state.pid)) {
-    clearDevState(state.pid);
-    return null;
-  }
-  const commandLine = readCommandForPid(state.pid);
-  if (!commandLine.includes(currentScriptPath)) {
-    return null;
-  }
-  return state.pid;
-}
-
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function isPortListening(targetPort) {
-  return new Promise((resolve) => {
-    const socket = new Socket();
-
-    const finish = (result) => {
-      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(targetPort, '127.0.0.1');
-  });
-}
-
-async function waitForPortState(expectedListening, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if ((await isPortListening(port)) === expectedListening) {
-      return true;
-    }
-    await delay(100);
-  }
-  return (await isPortListening(port)) === expectedListening;
-}
-
-async function waitForProcessExit(pid, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!isProcessAlive(pid)) {
-      return true;
-    }
-    await delay(100);
-  }
-  return !isProcessAlive(pid);
-}
-
-function readCloudflaredLog(logPath) {
-  try {
-    return readFileSync(logPath, 'utf8');
-  } catch {
-    return '';
-  }
-}
-
-function startTunnel() {
-  return new Promise((resolve, reject) => {
-    const logPath = path.join(logDir, 'tunnel.stderr.log');
-    mkdirSync(logDir, { recursive: true });
-
-    const launchSpec = resolveCloudflaredLaunchSpec();
-
-    writeFileSync(logPath, '', 'utf8');
-    const logFd = openSync(logPath, 'a');
-    const child = spawn(launchSpec.command, [
-      ...launchSpec.args,
-      'tunnel',
-      '--protocol',
-      'http2',
-      '--url',
-      `http://localhost:${port}`,
-    ], {
-      detached: true,
-      stdio: ['ignore', logFd, logFd],
-    });
-    child.unref();
-
-    const pid = child.pid;
-    let url = null;
-
-    const timeout = setTimeout(() => {
-      if (!url) {
-        try { process.kill(pid, 'SIGTERM'); } catch { /* */ }
-        reject(new Error(formatCloudflaredFailureMessage({
-          launchSpec,
-          logContent: readCloudflaredLog(logPath),
-          logPath,
-          phase: 'timeout',
-        })));
-      }
-    }, launchSpec.urlTimeoutMs);
-
-    const poll = setInterval(() => {
-      try {
-        const content = readFileSync(logPath, 'utf8');
-        const tunnelUrl = extractQuickTunnelUrl(content);
-        if (tunnelUrl) {
-          url = tunnelUrl;
-          clearInterval(poll);
-          clearTimeout(timeout);
-          saveTunnelState(pid, url);
-          resolve({ pid, url });
-          return;
-        }
-        if (!isProcessAlive(pid)) {
-          clearInterval(poll);
-          clearTimeout(timeout);
-          reject(new Error(formatCloudflaredFailureMessage({
-            launchSpec,
-            logContent: content,
-            logPath,
-            phase: 'exit',
-          })));
-        }
-      } catch { /* file not ready yet */ }
-    }, 300);
-
-    child.on('error', (err) => {
-      clearInterval(poll);
-      clearTimeout(timeout);
-      reject(new Error(formatCloudflaredFailureMessage({
-        launchSpec,
-        logContent: readCloudflaredLog(logPath),
-        logPath,
-        err,
-        phase: 'spawn',
-      })));
-    });
-  });
-}
-
-async function restartExistingDevDaemon() {
-  const trackedWrapperPid = getTrackedWrapperPid();
-  if (trackedWrapperPid) {
-    console.log(`[dev] Stopping previous dev wrapper (pid ${trackedWrapperPid})...`);
-    try {
-      process.kill(trackedWrapperPid, 'SIGTERM');
-    } catch {}
-  }
-
-  await requestDaemonShutdown();
-
-  const [portClosed, wrapperExited] = await Promise.all([
-    waitForPortState(false, 5_000),
-    trackedWrapperPid ? waitForProcessExit(trackedWrapperPid, 5_000) : Promise.resolve(true),
-  ]);
-
-  if (!wrapperExited) {
-    fail(`Timed out waiting for previous dev wrapper (pid ${trackedWrapperPid}) to exit.`);
-  }
-
-  if (!portClosed) {
-    fail(`Timed out waiting for port ${port} to be released.`);
-  }
-
-  if (trackedWrapperPid) {
-    clearDevState(trackedWrapperPid);
-  }
-}
-
-// ─── Parse flags ────────────────────────────────────────────────────────────
-
-function readNpmConfigFlag(name) {
-  const value = process.env[`npm_config_${name.replace(/-/g, '_')}`];
-  return value === '' || value === 'true';
-}
-
-consumeFlag('remote') || consumeFlag('tunnel') || readNpmConfigFlag('remote') || readNpmConfigFlag('tunnel');
-const localFlag = consumeFlag('local') || readNpmConfigFlag('local');
-const forceFlag = consumeFlag('force') || readNpmConfigFlag('force');
-const relayArg = parseNamedArg('relay') ?? readNpmConfigArg('relay');
-const hostArg = parseNamedArg('host') ?? readNpmConfigArg('host');
-const fallbackHostsArg = parseNamedArg('fallback-hosts') ?? readNpmConfigArg('fallback-hosts');
-const envRelayUrl = process.env.VIBELET_RELAY_URL || '';
-const envCanonicalHost = process.env.VIBELET_CANONICAL_HOST || null;
-const envFallbackHosts = process.env.VIBELET_FALLBACK_HOSTS || null;
-const canonicalHost = hostArg ?? envCanonicalHost;
-const fallbackHosts = fallbackHostsArg ?? envFallbackHosts;
-const shouldManageTunnel = !localFlag
-  && relayArg === null
-  && !envRelayUrl
-  && !hostArg
-  && !fallbackHostsArg
-  && !envCanonicalHost
-  && !envFallbackHosts;
-
-if (command === 'restart') {
-  await restartExistingDevDaemon();
-}
-
-// Managed remote access: auto-start or reuse a Cloudflare Tunnel by default.
-if (shouldManageTunnel) {
-  const existing = forceFlag ? null : getAliveTunnel();
-  if (existing) {
-    console.log(`[dev] Reusing tunnel: ${existing.url} (pid ${existing.pid})`);
-    saveRelayConfig(existing.url);
-  } else {
-    if (forceFlag) stopTunnel();
-    console.log('[dev] Starting Cloudflare Tunnel...');
-    try {
-      const tunnel = await startTunnel();
-      console.log(`[dev] Tunnel ready: ${tunnel.url}`);
-      saveRelayConfig(tunnel.url);
-    } catch (err) {
-      console.error(`[dev] Tunnel failed: ${err.message}`);
-      process.exit(1);
-    }
-  }
-}
-
-if (relayArg !== null) {
-  if (relayArg) {
-    saveRelayConfig(relayArg);
-  } else {
-    clearRelayConfig();
-  }
-}
-
-const shouldIgnoreSavedRelay = relayArg === null && (localFlag || Boolean(hostArg) || Boolean(fallbackHostsArg) || Boolean(envCanonicalHost) || Boolean(envFallbackHosts));
-const relayUrl = relayArg !== null
-  ? relayArg
-  : (localFlag || Boolean(hostArg) || Boolean(fallbackHostsArg) ? '' : (envRelayUrl || (shouldIgnoreSavedRelay ? '' : loadRelayConfig())));
-
-function shouldDetachChild() {
-  if (!supportsDetachedGroupKill) {
-    return false;
-  }
-
-  const override = process.env.VIBE_DEV_DETACHED?.toLowerCase();
-  if (override === '1' || override === 'true') {
-    return true;
-  }
-  if (override === '0' || override === 'false') {
-    return false;
-  }
-
-  // In interactive shells, keep tsx watch in the foreground process group so
-  // terminal Ctrl+C reaches both the watcher and its child daemon directly.
-  return !process.stdin.isTTY;
-}
-
-const useDetachedGroupKill = shouldDetachChild();
-
-if (!getTrackedWrapperPid()) {
-  writeDevState();
-}
-
-// In non-interactive environments, run tsx watch in its own process group so
-// wrapper shutdown can tear down the watcher and the daemon child in one kill.
-const child = spawn(process.execPath, [tsxCliPath, 'watch', 'src/index.ts'], {
-  cwd: daemonDir,
-  env: {
-    ...process.env,
-    VIBE_DEV: process.env.VIBE_DEV ?? '1',
-    VIBELET_CLI_VERSION: process.env.VIBELET_CLI_VERSION ?? rootPackageJson.version,
-    ...(relayUrl ? { VIBELET_RELAY_URL: relayUrl } : {}),
-    ...(canonicalHost ? { VIBELET_CANONICAL_HOST: canonicalHost } : {}),
-    ...(fallbackHosts ? { VIBELET_FALLBACK_HOSTS: fallbackHosts } : {}),
-  },
-  stdio: 'inherit',
-  detached: useDetachedGroupKill,
-});
-
-child.once('error', (error) => {
-  console.error('[daemon:dev] failed to start tsx watch', error);
-  process.exit(1);
-});
-
-function getSignalExitCode(signal) {
-  const signalNumber = osConstants.signals?.[signal];
-  return typeof signalNumber === 'number' ? 128 + signalNumber : 1;
-}
-
-function requestDaemonShutdown() {
-  return fetch(`http://127.0.0.1:${port}/shutdown`, {
-    method: 'POST',
-  }).catch(() => undefined);
-}
-
-function killChildTree(signal = 'SIGTERM') {
-  if (child.exitCode !== null || child.signalCode !== null) {
-    return;
-  }
-
-  try {
-    if (useDetachedGroupKill && typeof child.pid === 'number') {
-      process.kill(-child.pid, signal);
-    } else {
-      child.kill(signal);
-    }
-  } catch (error) {
-    if (error && typeof error === 'object' && 'code' in error && error.code === 'ESRCH') {
-      return;
-    }
-    throw error;
-  }
-}
-
-function shutdown(signal) {
-  if (shuttingDown) {
-    return;
-  }
-  shuttingDown = true;
-
-  if (!useDetachedGroupKill) {
-    void requestDaemonShutdown();
-  }
-  killChildTree(signal === 'SIGHUP' ? 'SIGTERM' : signal);
-  forceKillTimer = setTimeout(() => {
-    try {
-      killChildTree('SIGKILL');
-    } catch {}
-  }, 3000);
-  forceKillTimer.unref();
-}
-
-process.once('SIGINT', () => shutdown('SIGINT'));
-process.once('SIGTERM', () => shutdown('SIGTERM'));
-process.once('SIGHUP', () => shutdown('SIGHUP'));
-process.once('exit', () => {
-  clearDevState(process.pid);
-  try {
-    killChildTree('SIGTERM');
-  } catch {}
-});
-
-child.once('exit', (code, signal) => {
-  if (forceKillTimer) {
-    clearTimeout(forceKillTimer);
-  }
-
-  if (signal) {
-    process.exit(getSignalExitCode(signal));
-    return;
-  }
-
-  process.exit(code ?? 0);
-});