vibelet 1.2.153 → 1.2.154

package/dist/runtime-version.cjs

@@ -1,2 +1,2 @@
-var c=require("node:fs"),n=require("node:path"),p="@vibelet/cli";function i(r){try{let e=JSON.parse((0,c.readFileSync)(r,"utf8"));if(e.name===p&&typeof e.version=="string"&&e.version.length>0)return e.version}catch{}return null}function l(){return"1.2.153"}var a=l();process.stdout.write(`${a}
+var c=require("node:fs"),n=require("node:path"),p="@vibelet/cli";function i(r){try{let e=JSON.parse((0,c.readFileSync)(r,"utf8"));if(e.name===p&&typeof e.version=="string"&&e.version.length>0)return e.version}catch{}return null}function l(){return"1.2.154"}var a=l();process.stdout.write(`${a}
 `);

package/dist/vibelet.mjs

@@ -11245,7 +11245,7 @@ module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("zlib");
 
 /***/ }),
 
-/***/ 2517:
+/***/ 2755:
 /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
 
 
@@ -11267,17 +11267,208 @@ var external_node_fs_ = __nccwpck_require__(3024);
 var external_node_module_ = __nccwpck_require__(8995);
 // EXTERNAL MODULE: external "node:path"
 var external_node_path_ = __nccwpck_require__(6760);
+;// CONCATENATED MODULE: external "node:fs/promises"
+const promises_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:fs/promises");
+;// CONCATENATED MODULE: external "node:util"
+const external_node_util_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:util");
+;// CONCATENATED MODULE: ../../packages/cloudflared-tunnel/managed-binary.mjs
+
+
+
+
+
+
+const execFileAsync = (0,external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
+const DEFAULT_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_UPDATE_TIMEOUT_MS = 30_000;
+
+function parseCloudflaredVersion(output) {
+  return String(output || '').match(/cloudflared version\s+([0-9]+(?:\.[0-9]+){1,2})/i)?.[1] ?? null;
+}
+
+async function readUpdateState(updateStatePath) {
+  try {
+    const state = JSON.parse(await (0,promises_namespaceObject.readFile)(updateStatePath, 'utf8'));
+    return state && typeof state === 'object' ? state : null;
+  } catch {
+    return null;
+  }
+}
+
+async function writeUpdateState(updateStatePath, state) {
+  await (0,promises_namespaceObject.mkdir)((0,external_node_path_.dirname)(updateStatePath), { recursive: true });
+  const temporaryPath = `${updateStatePath}.tmp-${process.pid}-${Date.now()}`;
+  await (0,promises_namespaceObject.writeFile)(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  await (0,promises_namespaceObject.rename)(temporaryPath, updateStatePath);
+}
+
+async function runVersion(binaryPath, timeoutMs, runCommand) {
+  if (!binaryPath || !(0,external_node_fs_.existsSync)(binaryPath)) return null;
+  try {
+    const { stdout, stderr } = await runCommand(binaryPath, ['--version'], {
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      maxBuffer: 1024 * 1024,
+    });
+    return parseCloudflaredVersion(`${stdout || ''}\n${stderr || ''}`);
+  } catch {
+    return null;
+  }
+}
+
+async function probeCloudflaredLaunchSpecVersion(
+  launchSpec,
+  { timeoutMs = 5_000, runCommand = execFileAsync } = {},
+) {
+  try {
+    const { stdout, stderr } = await runCommand(launchSpec.command, [...launchSpec.args, '--version'], {
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      maxBuffer: 1024 * 1024,
+      ...(launchSpec.shell ? { shell: true } : {}),
+    });
+    return parseCloudflaredVersion(`${stdout || ''}\n${stderr || ''}`);
+  } catch {
+    return null;
+  }
+}
+
+async function installLatestToTemporaryPath({ launchSpec, binaryPath, timeoutMs, platform, runCommand }) {
+  const temporaryDir = (0,external_node_path_.join)((0,external_node_path_.dirname)(binaryPath), `.cloudflared-update-${process.pid}-${Date.now()}`);
+  const temporaryBinaryPath = (0,external_node_path_.join)(temporaryDir, (0,external_node_path_.basename)(binaryPath));
+  await (0,promises_namespaceObject.mkdir)(temporaryDir, { recursive: true });
+  try {
+    await runCommand(launchSpec.command, [...launchSpec.args, 'bin', 'install', 'latest'], {
+      encoding: 'utf8',
+      timeout: timeoutMs,
+      maxBuffer: 4 * 1024 * 1024,
+      env: { ...process.env, CLOUDFLARED_BIN: temporaryBinaryPath },
+      ...(launchSpec.shell ? { shell: true } : {}),
+    });
+    const version = await runVersion(temporaryBinaryPath, timeoutMs, runCommand);
+    if (!version) throw new Error('downloaded cloudflared did not report a valid version');
+
+    if (platform === 'win32' && (0,external_node_fs_.existsSync)(binaryPath)) {
+      const backupPath = `${binaryPath}.previous-${process.pid}`;
+      await (0,promises_namespaceObject.rename)(binaryPath, backupPath);
+      try {
+        await (0,promises_namespaceObject.rename)(temporaryBinaryPath, binaryPath);
+        await (0,promises_namespaceObject.rm)(backupPath, { force: true });
+      } catch (error) {
+        await (0,promises_namespaceObject.rename)(backupPath, binaryPath).catch(() => undefined);
+        throw error;
+      }
+    } else {
+      await (0,promises_namespaceObject.rename)(temporaryBinaryPath, binaryPath);
+    }
+    return version;
+  } finally {
+    await (0,promises_namespaceObject.rm)(temporaryDir, { recursive: true, force: true });
+  }
+}
+
+async function resolveManagedCloudflared({
+  launchSpec,
+  updateStatePath,
+  now = Date.now(),
+  updateIntervalMs = DEFAULT_UPDATE_INTERVAL_MS,
+  timeoutMs = DEFAULT_UPDATE_TIMEOUT_MS,
+  platform = process.platform,
+  runCommand = execFileAsync,
+}) {
+  const state = await readUpdateState(updateStatePath);
+  const lastAttemptAt = Date.parse(state?.lastAttemptAt || '');
+  const recentlyAttempted = Number.isFinite(lastAttemptAt) && now - lastAttemptAt < updateIntervalMs;
+  if (recentlyAttempted) {
+    return {
+      launchSpec,
+      version: state?.installedVersion ?? null,
+      update: 'skipped',
+    };
+  }
+
+  const attemptedAt = new Date(now).toISOString();
+  const binaryPath = launchSpec.managedBinaryPath;
+  if (launchSpec.source !== 'dependency' || !binaryPath) {
+    const version = state?.installedVersion ?? null;
+    let stateWarning = '';
+    try {
+      await writeUpdateState(updateStatePath, {
+        ...state,
+        lastAttemptAt: attemptedAt,
+        installedVersion: version,
+      });
+    } catch (error) {
+      stateWarning = ` Update state could not be saved: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    return {
+      launchSpec,
+      version,
+      update: 'skipped',
+      warning: `Skipping cloudflared self-update for unmanaged ${launchSpec.source} executable: ${launchSpec.description}.${stateWarning}`,
+    };
+  }
+
+  const previousVersion = await runVersion(binaryPath, timeoutMs, runCommand);
+  try {
+    const installedVersion = await installLatestToTemporaryPath({
+      launchSpec,
+      binaryPath,
+      timeoutMs,
+      platform,
+      runCommand,
+    });
+    await writeUpdateState(updateStatePath, {
+      lastAttemptAt: attemptedAt,
+      lastSuccessAt: attemptedAt,
+      installedVersion,
+    });
+    return {
+      launchSpec,
+      version: installedVersion,
+      update: previousVersion ? 'updated' : 'fresh',
+    };
+  } catch (error) {
+    const fallbackVersion = previousVersion || (await runVersion(binaryPath, timeoutMs, runCommand));
+    await writeUpdateState(updateStatePath, {
+      ...state,
+      lastAttemptAt: attemptedAt,
+      installedVersion: fallbackVersion,
+    }).catch(() => undefined);
+    return {
+      launchSpec,
+      version: fallbackVersion,
+      update: 'failed',
+      warning: `cloudflared update failed; continuing with ${fallbackVersion || 'the existing launcher'}: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
 ;// CONCATENATED MODULE: ../../packages/cloudflared-tunnel/index.mjs
 
 
 
 
 
+
+
+
 const QUICK_TUNNEL_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com(?=$|[\s"',)\]])/g;
 const npmFallbackArgs = ['--yes', '--package=cloudflared', 'cloudflared'];
 const npmFallbackDescription = `npx ${npmFallbackArgs.join(' ')}`;
 const defaultUrlTimeoutMs = 90_000;
 
+function supportsFastAutoProtocolFallback(version) {
+  if (!version) return false;
+  const parts = version.split('.').map(Number);
+  const threshold = [2026, 5, 2];
+  for (let index = 0; index < threshold.length; index += 1) {
+    const value = parts[index] || 0;
+    if (value !== threshold[index]) return value > threshold[index];
+  }
+  return true;
+}
+
 function extractQuickTunnelUrl(logContent) {
   if (typeof logContent !== 'string' || logContent.length === 0) {
     return null;
@@ -11403,6 +11594,21 @@ function resolveInstalledCloudflaredCliPath({
   return (0,external_node_fs_.existsSync)(cliPath) ? cliPath : null;
 }
 
+function createDependencyLaunchSpec(dependencyCliPath, platform = process.platform) {
+  return {
+    command: process.execPath,
+    args: [dependencyCliPath],
+    source: 'dependency',
+    description: dependencyCliPath,
+    managedBinaryPath: (0,external_node_path_.join)(
+      (0,external_node_path_.dirname)((0,external_node_path_.dirname)(dependencyCliPath)),
+      'bin',
+      platform === 'win32' ? 'cloudflared.exe' : 'cloudflared',
+    ),
+    urlTimeoutMs: defaultUrlTimeoutMs,
+  };
+}
+
 function resolveCloudflaredLaunchSpec({
   pathValue = process.env.PATH ?? '',
   pathExtValue = process.env.PATHEXT ?? '',
@@ -11427,13 +11633,7 @@ function resolveCloudflaredLaunchSpec({
 
   const dependencyCliPath = resolveInstalledCloudflaredCliPath({ resolvePackageJsonPath });
   if (dependencyCliPath) {
-    return {
-      command: process.execPath,
-      args: [dependencyCliPath],
-      source: 'dependency',
-      description: dependencyCliPath,
-      urlTimeoutMs: defaultUrlTimeoutMs,
-    };
+    return createDependencyLaunchSpec(dependencyCliPath, platform);
   }
 
   return {
@@ -11446,6 +11646,11 @@ function resolveCloudflaredLaunchSpec({
   };
 }
 
+function resolvePreferredCloudflaredLaunchSpec() {
+  const dependencyCliPath = resolveInstalledCloudflaredCliPath();
+  return dependencyCliPath ? createDependencyLaunchSpec(dependencyCliPath) : resolveCloudflaredLaunchSpec();
+}
+
 function summarizeCloudflaredLog(logContent, { maxLines = 8, maxChars = 1200 } = {}) {
   const lines = logContent
     .split(/\r?\n/u)
@@ -11546,13 +11751,50 @@ function readCloudflaredLog(logPath) {
   }
 }
 
-function startTunnel({ port, logDir, tunnelStatePath, resolveLaunchSpec = resolveCloudflaredLaunchSpec }) {
+async function startTunnel({
+  port,
+  logDir,
+  tunnelStatePath,
+  protocol = 'auto',
+  updateStatePath,
+  resolveLaunchSpec = resolvePreferredCloudflaredLaunchSpec,
+  resolveFallbackLaunchSpec = resolveCloudflaredLaunchSpec,
+}) {
+  if (!['auto', 'quic', 'http2'].includes(protocol)) {
+    throw new Error(`Unsupported cloudflared protocol: ${protocol}`);
+  }
+  const unresolvedLaunchSpec = resolveLaunchSpec();
+  const managed = updateStatePath
+    ? await resolveManagedCloudflared({ launchSpec: unresolvedLaunchSpec, updateStatePath })
+    : null;
+  let launchSpec = managed?.launchSpec ?? unresolvedLaunchSpec;
+  if (
+    managed &&
+    managed.version === null &&
+    launchSpec.managedBinaryPath &&
+    !(0,external_node_fs_.existsSync)(launchSpec.managedBinaryPath)
+  ) {
+    const fallbackLaunchSpec = resolveFallbackLaunchSpec();
+    if (fallbackLaunchSpec.source !== 'dependency') launchSpec = fallbackLaunchSpec;
+  }
+  if (managed?.warning) process.stderr.write(`[cloudflared] ${managed.warning}\n`);
+  const launchVersion =
+    managed?.version ??
+    (updateStatePath && launchSpec.source !== 'dependency'
+      ? await probeCloudflaredLaunchSpecVersion(launchSpec)
+      : null);
+  const effectiveProtocol =
+    protocol === 'auto' && updateStatePath && !supportsFastAutoProtocolFallback(launchVersion) ? 'http2' : protocol;
+  if (effectiveProtocol !== protocol) {
+    process.stderr.write(
+      `[cloudflared] cloudflared ${launchVersion || 'unknown'} lacks fast auto connectivity pre-checks; using http2 until the managed binary updates to 2026.5.2 or newer.\n`,
+    );
+  }
+
   return new Promise((resolveStart, rejectStart) => {
     const logPath = (0,external_node_path_.join)(logDir, 'tunnel.stderr.log');
     (0,external_node_fs_.mkdirSync)(logDir, { recursive: true });
 
-    const launchSpec = resolveLaunchSpec();
-
     // Truncate first so URL polling cannot match a stale quick-tunnel URL.
     (0,external_node_fs_.writeFileSync)(logPath, '', 'utf8');
     const stdoutLogFd = (0,external_node_fs_.openSync)(logPath, 'a');
@@ -11561,7 +11803,7 @@ function startTunnel({ port, logDir, tunnelStatePath, resolveLaunchSpec = resolv
     try {
       child = (0,external_node_child_process_.spawn)(
         launchSpec.command,
-        [...launchSpec.args, 'tunnel', '--protocol', 'http2', '--url', `http://localhost:${port}`],
+        [...launchSpec.args, 'tunnel', '--protocol', effectiveProtocol, '--url', `http://localhost:${port}`],
         {
           detached: true,
           stdio: ['ignore', stdoutLogFd, stderrLogFd],
@@ -13817,7 +14059,7 @@ __nccwpck_require__.a(__webpack_module__, async (__webpack_handle_async_dependen
 /* harmony import */ var node_url__WEBPACK_IMPORTED_MODULE_5__ = __nccwpck_require__(3136);
 /* harmony import */ var qrcode__WEBPACK_IMPORTED_MODULE_6__ = __nccwpck_require__(7514);
 /* harmony import */ var _vibelet_cli_args_mjs__WEBPACK_IMPORTED_MODULE_14__ = __nccwpck_require__(6927);
-/* harmony import */ var _cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_7__ = __nccwpck_require__(2517);
+/* harmony import */ var _cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_7__ = __nccwpck_require__(2755);
 /* harmony import */ var _vibelet_launchd_mjs__WEBPACK_IMPORTED_MODULE_11__ = __nccwpck_require__(1010);
 /* harmony import */ var _linux_systemd_mjs__WEBPACK_IMPORTED_MODULE_8__ = __nccwpck_require__(4217);
 /* harmony import */ var _vibelet_stop_logic_mjs__WEBPACK_IMPORTED_MODULE_12__ = __nccwpck_require__(6274);
@@ -13861,6 +14103,7 @@ const stderrLogPath = (0,node_path__WEBPACK_IMPORTED_MODULE_4__.join)(logDir, 'd
 const pidFilePath = (0,node_path__WEBPACK_IMPORTED_MODULE_4__.join)(vibeletDir, 'daemon.pid');
 const relayConfigPath = (0,node_path__WEBPACK_IMPORTED_MODULE_4__.join)(vibeletDir, 'relay.json');
 const tunnelStatePath = (0,node_path__WEBPACK_IMPORTED_MODULE_4__.join)(vibeletDir, 'tunnel.json');
+const cloudflaredUpdateStatePath = (0,node_path__WEBPACK_IMPORTED_MODULE_4__.join)(vibeletDir, 'cloudflared-update.json');
 const updateCheckPath = (0,node_path__WEBPACK_IMPORTED_MODULE_4__.join)(vibeletDir, 'update-check.json');
 const OFFICIAL_SITE_URL = 'https://vibelet.icu';
 const UPDATE_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
@@ -14799,7 +15042,7 @@ function printHelp() {
   process.stdout.write(`  # Need a fresh Cloudflare Tunnel URL?\n`);
   process.stdout.write(`  npx ${packageJson.name} --access=remote --force\n\n`);
   process.stdout.write(`  # Or bring your own tunnel and pass the URL manually:\n`);
-  process.stdout.write(`  npx cloudflared tunnel --protocol http2 --url http://localhost:${port}\n`);
+  process.stdout.write(`  npx cloudflared tunnel --protocol auto --url http://localhost:${port}\n`);
   process.stdout.write(`  ngrok http ${port}\n`);
   process.stdout.write(`  npx ${packageJson.name} --access=https://<your-tunnel-url>\n\n`);
   process.stdout.write(`  # Tailscale (P2P VPN, no tunnel needed)\n`);
@@ -14979,6 +15222,10 @@ async function main() {
   // --remote/--tunnel remain accepted for compatibility, but startup commands
   // now default to managed remote access unless another connection target wins.
   const shouldManageTunnel = startCommand && !localFlag && relayArg === null && !hostArg && !fallbackHostsArg;
+  const cloudflaredProtocol = process.env.VIBELET_CLOUDFLARED_PROTOCOL?.trim() || 'http2';
+  if (!['auto', 'quic', 'http2'].includes(cloudflaredProtocol)) {
+    fail(`Unsupported VIBELET_CLOUDFLARED_PROTOCOL: ${cloudflaredProtocol}. Use auto, quic, or http2.`);
+  }
 
   if (localFlag) {
     process.env.VIBELET_LOCAL_ONLY = '1';
@@ -14995,7 +15242,13 @@ async function main() {
       if (forceFlag) (0,_cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_7__/* .stopTunnel */ .HM)(getTunnelManagerOptions());
       process.stdout.write('Starting Cloudflare Tunnel...\n');
       try {
-        const tunnel = await (0,_cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_7__/* .startTunnel */ .DH)({ port, logDir, tunnelStatePath });
+        const tunnel = await (0,_cloudflared_tunnel_manager_mjs__WEBPACK_IMPORTED_MODULE_7__/* .startTunnel */ .DH)({
+          port,
+          logDir,
+          tunnelStatePath,
+          protocol: cloudflaredProtocol,
+          updateStatePath: cloudflaredUpdateStatePath,
+        });
         process.stdout.write(`Tunnel ready: ${tunnel.url}\n`);
         saveRelayConfig(tunnel.url);
       } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibelet",
-  "version": "1.2.153",
+  "version": "1.2.154",
   "description": "Cross-platform CLI for installing and running the Vibelet daemon",
   "homepage": "https://vibelet.icu",
   "files": [
@@ -26,6 +26,7 @@
     "access": "public"
   },
   "dependencies": {
+    "cloudflared": "0.7.1",
     "node-pty": "^1.1.0",
     "ws": "^8.18.0"
   }