vibelet 1.0.11 → 1.0.12

package/bin/vibelet.mjs

@@ -8,6 +8,7 @@ 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);
@@ -419,8 +435,18 @@ 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() {
@@ -448,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;
       }
@@ -469,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';
     },
   };
@@ -703,6 +762,7 @@ function createCompactPairingPayload(pairingPayload) {
       target.port,
       target.source,
       target.stability,
+      target.secure === true,
     ]);
   }
   return compactPayload;
@@ -799,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,
       }))
@@ -808,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;
       }
@@ -916,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`);
@@ -978,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'));
@@ -1125,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');
@@ -1275,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();
@@ -1314,7 +1393,8 @@ async function main() {
     return;
   }
 
-  if (healthyDaemon && hasExplicitConfigOverrides) {
+  const shouldReplaceDetachedDaemon = !healthyDaemon && !backend.handlesProcessLifecycle && backend.isServiceInstalled();
+  if (shouldReplaceDetachedDaemon || (healthyDaemon && hasExplicitConfigOverrides)) {
     await stopRunningDaemon(backend);
   }