@vibelet/cli 0.1.35 → 0.1.37

package/scripts/dev.mjs

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

package/src/advertised-hosts.test.ts

@@ -0,0 +1,125 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import type { NetworkInterfaceInfo } from 'os';
+import {
+  computeAdvertisedConnectionTarget,
+  computeAdvertisedHosts,
+  parseTailscaleStatus,
+  readConfiguredFallbackHosts,
+  readTailscaleHosts,
+} from './advertised-hosts.js';
+
+function ipv4(address: string): NetworkInterfaceInfo {
+  return {
+    address,
+    netmask: '255.255.255.0',
+    family: 'IPv4',
+    mac: '00:00:00:00:00:00',
+    internal: false,
+    cidr: `${address}/24`,
+  };
+}
+
+test('computeAdvertisedHosts prefers configured canonical host and prioritizes Tailscale IPs', () => {
+  const advertised = computeAdvertisedHosts({
+    canonicalHost: 'desk-mac.local',
+    configuredCanonicalHost: 'desk.tailnet.ts.net',
+    configuredFallbackHosts: ['100.88.1.9'],
+    tailscaleCanonicalHost: '100.77.2.3',
+    tailscaleFallbackHosts: ['desk.ts.net'],
+    interfaces: {
+      en0: [ipv4('192.168.31.20')],
+      utun8: [ipv4('100.77.2.3')],
+    },
+  });
+
+  assert.equal(advertised.canonicalHost, 'desk.tailnet.ts.net');
+  assert.deepStrictEqual(advertised.fallbackHosts, ['desk-mac.local', '100.88.1.9', 'desk.ts.net', '100.77.2.3', '192.168.31.20']);
+});
+
+test('computeAdvertisedHosts removes duplicates and excludes the canonical host', () => {
+  const advertised = computeAdvertisedHosts({
+    canonicalHost: '100.77.2.3',
+    configuredFallbackHosts: ['100.77.2.3', '192.168.31.20', '192.168.31.20'],
+    interfaces: {
+      utun8: [ipv4('100.77.2.3')],
+      en0: [ipv4('192.168.31.20')],
+    },
+  });
+
+  assert.equal(advertised.canonicalHost, '100.77.2.3');
+  assert.deepStrictEqual(advertised.fallbackHosts, ['192.168.31.20']);
+});
+
+test('computeAdvertisedHosts filters out link-local and benchmark addresses', () => {
+  const advertised = computeAdvertisedHosts({
+    canonicalHost: 'desk-mac.local',
+    interfaces: {
+      en0: [ipv4('192.168.31.20'), ipv4('169.254.12.2')],
+      utun4: [ipv4('198.19.0.1')],
+    },
+  });
+
+  assert.equal(advertised.canonicalHost, 'desk-mac.local');
+  assert.deepStrictEqual(advertised.fallbackHosts, ['192.168.31.20']);
+});
+
+test('parseTailscaleStatus prefers the first Tailscale IP and keeps MagicDNS as fallback', () => {
+  const advertised = parseTailscaleStatus(JSON.stringify({
+    Self: {
+      DNSName: 'desk.tailnet.ts.net.',
+      TailscaleIPs: ['100.88.1.9', '100.99.2.4'],
+    },
+  }));
+
+  assert.deepStrictEqual(advertised, {
+    canonicalHost: '100.88.1.9',
+    fallbackHosts: ['desk.tailnet.ts.net', '100.99.2.4'],
+  });
+});
+
+test('readTailscaleHosts returns empty data when tailscale is unavailable', () => {
+  const advertised = readTailscaleHosts(() => {
+    throw new Error('tailscale unavailable');
+  });
+
+  assert.deepStrictEqual(advertised, { fallbackHosts: [] });
+});
+
+test('readConfiguredFallbackHosts parses comma separated env values', () => {
+  assert.deepStrictEqual(
+    readConfiguredFallbackHosts(' 100.77.2.3, desk.tailnet.ts.net , 192.168.31.20 '),
+    ['100.77.2.3', 'desk.tailnet.ts.net', '192.168.31.20'],
+  );
+});
+
+test('computeAdvertisedConnectionTarget keeps the base host and port without a relay', () => {
+  assert.deepStrictEqual(
+    computeAdvertisedConnectionTarget({
+      canonicalHost: 'desk-mac.local',
+      fallbackHosts: ['100.88.1.9', '192.168.31.20'],
+      port: 9876,
+    }),
+    {
+      canonicalHost: 'desk-mac.local',
+      fallbackHosts: ['100.88.1.9', '192.168.31.20'],
+      port: 9876,
+    },
+  );
+});
+
+test('computeAdvertisedConnectionTarget prefers the relay host and preserves local fallbacks', () => {
+  assert.deepStrictEqual(
+    computeAdvertisedConnectionTarget({
+      canonicalHost: 'desk-mac.local',
+      fallbackHosts: ['desk-mac.local', '100.88.1.9', '100.88.1.9', '192.168.31.20'],
+      port: 9876,
+      relayUrl: 'https://relay.example.com',
+    }),
+    {
+      canonicalHost: 'relay.example.com',
+      fallbackHosts: ['desk-mac.local', '100.88.1.9', '192.168.31.20'],
+      port: 443,
+    },
+  );
+});