vibelet 1.0.10 → 1.0.12

package/bin/vibelet.mjs

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 
 import { spawn, spawnSync } from 'node:child_process';
-import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, openSync, writeSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, openSync, writeSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { basename, delimiter, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import QRCode from 'qrcode';
 import { extractQuickTunnelUrl } from './cloudflared-quick-tunnel.mjs';
 import { formatCloudflaredFailureMessage, resolveCloudflaredLaunchSpec } from './cloudflared-resolver.mjs';
+import { canUseSystemdUserManager, isSystemdUserManagerUnavailable } from './linux-systemd.mjs';
 import { doesHealthMatchRequestedConnectionConfig, shouldReuseHealthyDaemon } from './vibelet-runtime-policy.mjs';
 
 // ─── Paths & constants ─────────────────────────────────────────────────────────
@@ -16,7 +17,6 @@ const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const packageJson = JSON.parse(readFileSync(join(rootDir, 'package.json'), 'utf8'));
 const daemonDistDir = resolve(rootDir, 'dist');
 const daemonEntryPath = resolve(daemonDistDir, 'index.cjs');
-const port = Number(process.env.VIBE_PORT) || 9876;
 const vibeletDir = join(homedir(), '.vibelet');
 const pairingQrPngPath = join(vibeletDir, 'pairing-qr.png');
 const logDir = join(vibeletDir, 'logs');
@@ -35,6 +35,22 @@ const UPDATE_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
 
 let officialSitePrinted = false;
 let updateMessage = '';
+let port = normalizePortValue(process.env.VIBE_PORT) ?? 9876;
+
+function normalizePortValue(rawValue) {
+  if (typeof rawValue !== 'string' && typeof rawValue !== 'number') {
+    return null;
+  }
+  const normalized = String(rawValue).trim();
+  if (!/^\d+$/.test(normalized)) {
+    return null;
+  }
+  const parsed = Number(normalized);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    return null;
+  }
+  return parsed;
+}
 
 function printOfficialSite() {
   if (officialSitePrinted) return;
@@ -147,7 +163,7 @@ function readRuntimeMetadata() {
 
 function ensureRuntimeInstalled() {
   if (!existsSync(daemonEntryPath)) {
-    fail('The compiled daemon runtime is missing.', 'Run `pnpm build` before invoking `npx @vibelet/cli` from a source checkout.');
+    fail('The compiled daemon runtime is missing.', 'Run `pnpm build:release` before invoking `npx @vibelet/cli` from a source checkout.');
   }
 
   const sourceDaemonStat = statSync(daemonEntryPath);
@@ -218,6 +234,75 @@ function isProcessAlive(pid) {
   }
 }
 
+// ─── Service PATH helpers ──────────────────────────────────────────────────────
+
+// Transient shims like fnm_multishells/<pid>/bin disappear or get GC'd after the
+// shell that created them exits. Long-lived services (launchd, systemd) that
+// inherit these paths end up spawning wrapper scripts whose `exec node` fails
+// with "node: not found". Stabilize to the underlying stable dir/file.
+function isTransientNodePath(p) {
+  return typeof p === 'string' && p.includes('fnm_multishells');
+}
+
+function stabilizeServiceFile(p) {
+  if (!p || !isTransientNodePath(p)) return p;
+  try {
+    const stable = join(realpathSync(dirname(p)), basename(p));
+    if (existsSync(stable) && !isTransientNodePath(stable)) return stable;
+  } catch { /* broken symlink */ }
+  return p;
+}
+
+function stabilizeServiceDir(dir) {
+  if (!dir || !isTransientNodePath(dir)) return dir;
+  try {
+    const real = realpathSync(dir);
+    if (real && !isTransientNodePath(real)) return real;
+  } catch { /* broken symlink */ }
+  return dir;
+}
+
+// Build a PATH the daemon can rely on under launchd/systemd, where no login
+// shell ran and no rc files loaded. Puts the node bin dir first so wrapper
+// scripts spawned by the daemon (codex, claude) can resolve `node` via PATH,
+// then falls back to common system and user-tool locations.
+function buildServicePath(nodeBinDir) {
+  const home = homedir();
+  const pnpmHome = process.env.PNPM_HOME
+    || (process.platform === 'win32' ? join(home, 'pnpm') : join(home, 'Library', 'pnpm'));
+  const baseline = process.platform === 'win32'
+    ? [
+        nodeBinDir,
+        join(home, '.npm-global', 'bin'),
+        join(home, '.local', 'bin'),
+        join(home, '.claude', 'bin'),
+        pnpmHome,
+      ]
+    : [
+        nodeBinDir,
+        '/usr/local/bin',
+        '/opt/homebrew/bin',
+        '/usr/bin',
+        '/bin',
+        '/usr/sbin',
+        '/sbin',
+        join(home, '.npm-global', 'bin'),
+        join(home, '.local', 'bin'),
+        join(home, '.claude', 'bin'),
+        pnpmHome,
+      ];
+  const current = (process.env.PATH || '')
+    .split(delimiter)
+    .filter(Boolean)
+    .map(stabilizeServiceDir);
+  const out = [];
+  const seen = new Set();
+  for (const p of [...baseline, ...current]) {
+    if (p && !seen.has(p)) { out.push(p); seen.add(p); }
+  }
+  return out.join(delimiter);
+}
+
 // ─── Platform service backends ──────────────────────────────────────────────────
 
 function createDarwinBackend() {
@@ -232,12 +317,20 @@ function createDarwinBackend() {
   }
 
   function plistContents() {
+    // Prefer a stable node path — fnm_multishells shims disappear when the
+    // installing shell exits, leaving launchd unable to respawn the daemon.
+    const nodeBin = stabilizeServiceFile(process.execPath);
     const programArgs = [
-      process.execPath,
+      nodeBin,
       runtimeDaemonEntryPath,
     ].map((value) => `      <string>${value}</string>`).join('\n');
 
-    const envVars = { VIBE_PORT: String(port) };
+    // launchd starts the daemon with a bare PATH; inject a rich one so child
+    // CLIs like codex (a sh wrapper that does `exec node`) can find node.
+    const envVars = {
+      PATH: buildServicePath(dirname(nodeBin)),
+      VIBE_PORT: String(port),
+    };
     if (process.env.VIBELET_RELAY_URL) envVars.VIBELET_RELAY_URL = process.env.VIBELET_RELAY_URL;
     if (process.env.VIBELET_CANONICAL_HOST) envVars.VIBELET_CANONICAL_HOST = process.env.VIBELET_CANONICAL_HOST;
     if (process.env.VIBELET_FALLBACK_HOSTS) envVars.VIBELET_FALLBACK_HOSTS = process.env.VIBELET_FALLBACK_HOSTS;
@@ -342,22 +435,35 @@ function createLinuxBackend() {
     return spawnSync('systemctl', ['--user', ...args], { encoding: 'utf8' });
   }
 
-  function hasSystemd() {
-    return spawnSync('systemctl', ['--user', '--version'], { encoding: 'utf8' }).status === 0;
+  function resultOutput(result) {
+    return [result?.stderr, result?.stdout].filter(Boolean).join('\n').trim();
+  }
+
+  let useSystemd = canUseSystemdUserManager();
+
+  function demoteToDetachedIfSystemdUnavailable(result) {
+    if (!isSystemdUserManagerUnavailable(resultOutput(result))) {
+      return false;
+    }
+    useSystemd = false;
+    return true;
   }
 
   function unitContents() {
+    const nodeBin = stabilizeServiceFile(process.execPath);
+    const servicePath = buildServicePath(dirname(nodeBin));
     return `[Unit]
 Description=Vibelet Daemon
 After=network.target
 
 [Service]
-ExecStart=${process.execPath} ${runtimeDaemonEntryPath}
+ExecStart=${nodeBin} ${runtimeDaemonEntryPath}
 WorkingDirectory=${runtimeCurrentDir}
 Restart=always
 RestartSec=3
 StandardOutput=append:${stdoutLogPath}
 StandardError=append:${stderrLogPath}
+Environment=PATH=${servicePath}
 Environment=VIBE_PORT=${port}${process.env.VIBELET_RELAY_URL ? `\nEnvironment=VIBELET_RELAY_URL=${process.env.VIBELET_RELAY_URL}` : ''}${process.env.VIBELET_CANONICAL_HOST ? `\nEnvironment=VIBELET_CANONICAL_HOST=${process.env.VIBELET_CANONICAL_HOST}` : ''}${process.env.VIBELET_FALLBACK_HOSTS ? `\nEnvironment=VIBELET_FALLBACK_HOSTS=${process.env.VIBELET_FALLBACK_HOSTS}` : ''}
 
 [Install]
@@ -368,18 +474,26 @@ WantedBy=default.target
   // Fallback: detached process with PID file (no systemd)
   const fallback = createDetachedBackend();
 
-  const useSystemd = hasSystemd();
   return {
-    name: useSystemd ? 'systemd' : 'detached',
-    handlesProcessLifecycle: useSystemd,
+    get name() {
+      return useSystemd ? 'systemd' : 'detached';
+    },
+
+    get handlesProcessLifecycle() {
+      return useSystemd;
+    },
 
     isServiceInstalled() {
-      if (!hasSystemd()) return fallback.isServiceInstalled();
-      return systemctl(['is-enabled', unitName]).status === 0;
+      if (!useSystemd) return fallback.isServiceInstalled();
+      const result = systemctl(['is-enabled', unitName]);
+      if (result.status !== 0 && demoteToDetachedIfSystemdUnavailable(result)) {
+        return fallback.isServiceInstalled();
+      }
+      return result.status === 0;
     },
 
     install() {
-      if (!hasSystemd()) {
+      if (!useSystemd) {
         fallback.install();
         return;
       }
@@ -389,33 +503,58 @@ WantedBy=default.target
       const currentContents = existsSync(unitPath) ? readFileSync(unitPath, 'utf8') : null;
       if (currentContents !== nextContents) {
         writeFileSync(unitPath, nextContents, 'utf8');
-        systemctl(['daemon-reload']);
+        const reloadResult = systemctl(['daemon-reload']);
+        if (reloadResult.status !== 0) {
+          if (demoteToDetachedIfSystemdUnavailable(reloadResult)) {
+            fallback.install();
+            return;
+          }
+          fail('Failed to reload vibelet systemd user units.', resultOutput(reloadResult));
+        }
+      }
+      const enableResult = systemctl(['enable', unitName]);
+      if (enableResult.status !== 0) {
+        if (demoteToDetachedIfSystemdUnavailable(enableResult)) {
+          fallback.install();
+          return;
+        }
+        fail('Failed to enable vibelet daemon.', resultOutput(enableResult));
       }
-      systemctl(['enable', unitName]);
     },
 
     start() {
-      if (!hasSystemd()) {
+      if (!useSystemd) {
         fallback.start();
         return;
       }
       const result = systemctl(['start', unitName]);
       if (result.status !== 0) {
+        if (demoteToDetachedIfSystemdUnavailable(result)) {
+          fallback.install();
+          fallback.start();
+          return;
+        }
         fail('Failed to start vibelet daemon.', result.stderr || result.stdout);
       }
     },
 
     stop() {
-      if (!hasSystemd()) {
+      if (!useSystemd) {
         fallback.stop();
         return;
       }
-      systemctl(['stop', unitName]);
+      const result = systemctl(['stop', unitName]);
+      if (result.status !== 0 && demoteToDetachedIfSystemdUnavailable(result)) {
+        fallback.stop();
+      }
     },
 
     statusLabel() {
-      if (!hasSystemd()) return fallback.statusLabel();
+      if (!useSystemd) return fallback.statusLabel();
       const result = systemctl(['is-active', unitName]);
+      if (result.status !== 0 && demoteToDetachedIfSystemdUnavailable(result)) {
+        return fallback.statusLabel();
+      }
       return result.stdout?.trim() || 'unknown';
     },
   };
@@ -556,7 +695,7 @@ async function waitForDaemonExit(timeoutMs) {
   return false;
 }
 
-async function waitForHealth(timeoutMs = 10_000) {
+async function waitForHealth(timeoutMs = 30_000) {
   const health = await probeHealth(timeoutMs);
   if (health) {
     return health;
@@ -623,6 +762,7 @@ function createCompactPairingPayload(pairingPayload) {
       target.port,
       target.source,
       target.stability,
+      target.secure === true,
     ]);
   }
   return compactPayload;
@@ -719,6 +859,7 @@ function normalizePairingConnections(pairingPayload) {
         kind: target.kind === 'relay' ? 'relay' : 'direct',
         host: normalizeHostValue(target.host),
         port: Math.floor(Number(target.port)),
+        ...(target.secure === true ? { secure: true } : {}),
         source: target.source,
         stability: target.stability,
       }))
@@ -728,7 +869,7 @@ function normalizePairingConnections(pairingPayload) {
   const dedupe = (targets) => {
     const seen = new Set();
     return targets.filter((target) => {
-      const key = `${target.host}:${target.port}`;
+      const key = `${target.host}:${target.port}:${target.secure === true ? 'secure' : 'plain'}`;
       if (seen.has(key)) {
         return false;
       }
@@ -836,6 +977,7 @@ function printHelp() {
   process.stdout.write(`  npx ${packageJson.name} --force  Force a new Cloudflare Tunnel URL\n`);
   process.stdout.write(`  npx ${packageJson.name} --relay <url>  Use a custom tunnel URL for remote access\n`);
   process.stdout.write(`  npx ${packageJson.name} --host <ip>   Set the primary host/IP address\n`);
+  process.stdout.write(`  npx ${packageJson.name} --port <port>  Start or query the daemon on a custom port\n`);
   process.stdout.write(`  npx ${packageJson.name} --fallback-hosts <ips>  Comma-separated fallback IPs\n`);
   process.stdout.write(`  npx ${packageJson.name} stop      Stop the daemon\n`);
   process.stdout.write(`  npx ${packageJson.name} restart   Restart the daemon\n`);
@@ -898,6 +1040,16 @@ function parseRelayArg() {
   return parseNamedArg('relay', 'https://abc.trycloudflare.com');
 }
 
+function parsePortArg() {
+  const rawValue = parseNamedArg('port', '9876');
+  if (rawValue === null) return null;
+  const parsed = normalizePortValue(rawValue);
+  if (parsed === null) {
+    fail('--port must be an integer between 1 and 65535');
+  }
+  return parsed;
+}
+
 function loadRelayConfig() {
   try {
     const data = JSON.parse(readFileSync(relayConfigPath, 'utf8'));
@@ -1045,6 +1197,12 @@ async function main() {
   checkForUpdateFromCache();
   fetchLatestVersionInBackground();
 
+  const portArg = parsePortArg();
+  if (portArg !== null) {
+    port = portArg;
+    process.env.VIBE_PORT = String(portArg);
+  }
+
   consumeFlag('remote') || consumeFlag('tunnel') || readNpmConfigFlag('remote') || readNpmConfigFlag('tunnel');
   const localFlag = consumeFlag('local') || readNpmConfigFlag('local');
   const forceFlag = consumeFlag('force') || readNpmConfigFlag('force');
@@ -1195,7 +1353,8 @@ async function main() {
       fallbackHosts: fallbackHostsArg || '',
       localMode: localFlag,
     }) && (localFlag || Boolean(relayUrl) || Boolean(hostArg) || Boolean(fallbackHostsArg));
-    if (healthyDaemon && hasExplicitConfigOverrides) {
+    const shouldReplaceDetachedDaemon = !healthyDaemon && !backend.handlesProcessLifecycle && backend.isServiceInstalled();
+    if (shouldReplaceDetachedDaemon || (healthyDaemon && hasExplicitConfigOverrides)) {
       await stopRunningDaemon(backend);
     }
     ensureRuntimeInstalled();
@@ -1234,7 +1393,8 @@ async function main() {
     return;
   }
 
-  if (healthyDaemon && hasExplicitConfigOverrides) {
+  const shouldReplaceDetachedDaemon = !healthyDaemon && !backend.handlesProcessLifecycle && backend.isServiceInstalled();
+  if (shouldReplaceDetachedDaemon || (healthyDaemon && hasExplicitConfigOverrides)) {
     await stopRunningDaemon(backend);
   }