@boxes-dev/dvb 1.0.576 → 1.0.578

package/dist/bin/dvb-update.cjs

@@ -24,14 +24,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/bootstrap/runtimeManager.ts
-var import_node_child_process = require("node:child_process");
-var import_node_crypto2 = require("node:crypto");
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto3 = require("node:crypto");
 var import_node_module = require("node:module");
-var import_promises2 = __toESM(require("node:fs/promises"), 1);
-var import_node_fs7 = require("node:fs");
+var import_promises3 = __toESM(require("node:fs/promises"), 1);
+var import_node_fs8 = require("node:fs");
 var import_node_http = __toESM(require("node:http"), 1);
-var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
 
 // ../../node_modules/tar/dist/esm/index.min.js
 var import_events = __toESM(require("events"), 1);
@@ -3042,6 +3042,182 @@ var isSemverGreater = (candidateVersion, currentVersion) => {
   return comparison !== null && comparison > 0;
 };
 
+// src/bootstrap/standaloneManager.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs7 = require("node:fs");
+var import_promises2 = __toESM(require("node:fs/promises"), 1);
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
+var DEFAULT_MANIFEST_URL = "https://deploy.boxes.dev/cli/latest.json";
+var resolveManifestUrl = () => {
+  if ("https://deploy.boxes.dev/cli/latest.json") {
+    return "https://deploy.boxes.dev/cli/latest.json";
+  }
+  return DEFAULT_MANIFEST_URL;
+};
+var isStandaloneMode = () => {
+  const versionJsonPath = import_node_path11.default.join(import_node_path11.default.dirname(process.execPath), "version.json");
+  return (0, import_node_fs7.existsSync)(versionJsonPath);
+};
+var readLocalVersionMeta = () => {
+  const versionJsonPath = import_node_path11.default.join(import_node_path11.default.dirname(process.execPath), "version.json");
+  if (!(0, import_node_fs7.existsSync)(versionJsonPath)) return null;
+  try {
+    return JSON.parse((0, import_node_fs7.readFileSync)(versionJsonPath, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+var resolveStandaloneDir = (homeDir) => import_node_path11.default.join(resolveDevboxDir(homeDir), "standalone");
+var resolveCurrentLink = (homeDir) => import_node_path11.default.join(resolveStandaloneDir(homeDir), "current");
+var checkStandaloneUpdate = async (homeDir = import_node_os2.default.homedir()) => {
+  const local = readLocalVersionMeta();
+  if (!local) return null;
+  const manifestUrl = resolveManifestUrl();
+  const res = await fetch(manifestUrl, {
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to fetch standalone manifest: ${res.status} ${res.statusText}`
+    );
+  }
+  const manifest = await res.json();
+  if (manifest.version === local.version) {
+    return null;
+  }
+  const platformKey = `${local.platform}-${local.arch}`;
+  const archive = manifest.archives?.[platformKey];
+  if (!archive) {
+    throw new Error(
+      `No standalone archive for ${platformKey} in manifest v${manifest.version}`
+    );
+  }
+  return {
+    manifest,
+    archive,
+    currentVersion: local.version
+  };
+};
+var downloadStandaloneUpdate = async (manifest, archive, homeDir = import_node_os2.default.homedir()) => {
+  const standaloneDir = resolveStandaloneDir(homeDir);
+  await import_promises2.default.mkdir(standaloneDir, { recursive: true });
+  const local = readLocalVersionMeta();
+  const platformKey = local ? `${local.platform}-${local.arch}` : `${process.platform}-${process.arch}`;
+  const version = manifest.version;
+  const versionDir = import_node_path11.default.join(standaloneDir, `${version}-${platformKey}`);
+  const currentLink = resolveCurrentLink(homeDir);
+  if ((0, import_node_fs7.existsSync)(import_node_path11.default.join(versionDir, "dvb"))) {
+    await atomicSymlink(standaloneDir, currentLink, versionDir);
+    return;
+  }
+  const tmpSuffix = `${version}-${platformKey}-${Date.now()}`;
+  const tmpDir = import_node_path11.default.join(standaloneDir, `.tmp-${tmpSuffix}`);
+  const tarballPath = import_node_path11.default.join(standaloneDir, `.download-${tmpSuffix}.tar.gz`);
+  try {
+    const res = await fetch(archive.url, {
+      signal: AbortSignal.timeout(5 * 60 * 1e3)
+      // 5 minute timeout for large download
+    });
+    if (!res.ok) {
+      throw new Error(`Failed to download ${archive.url}: ${res.status}`);
+    }
+    const body = await res.arrayBuffer();
+    (0, import_node_fs7.writeFileSync)(tarballPath, Buffer.from(body));
+    const hash = (0, import_node_crypto2.createHash)("sha256");
+    hash.update((0, import_node_fs7.readFileSync)(tarballPath));
+    const actualHash = hash.digest("hex");
+    if (actualHash !== archive.sha256) {
+      throw new Error(
+        `SHA256 mismatch: expected ${archive.sha256}, got ${actualHash}`
+      );
+    }
+    await import_promises2.default.mkdir(tmpDir, { recursive: true });
+    (0, import_node_child_process.execFileSync)("tar", [
+      "xzf",
+      tarballPath,
+      "-C",
+      tmpDir,
+      "--strip-components=1"
+    ]);
+    try {
+      (0, import_node_child_process.execFileSync)(import_node_path11.default.join(tmpDir, "dvb"), ["--help"], {
+        stdio: "pipe",
+        timeout: 15e3
+      });
+    } catch (err) {
+      const exitErr = err;
+      throw new Error(
+        `Validation failed: dvb --help exited with code ${exitErr.status}`
+      );
+    }
+    if ((0, import_node_fs7.existsSync)(versionDir)) {
+      await import_promises2.default.rm(versionDir, { recursive: true });
+    }
+    await import_promises2.default.rename(tmpDir, versionDir);
+    await atomicSymlink(standaloneDir, currentLink, versionDir);
+    await pruneOldVersions(standaloneDir, version, platformKey);
+  } finally {
+    try {
+      await import_promises2.default.rm(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+    try {
+      await import_promises2.default.unlink(tarballPath);
+    } catch {
+    }
+  }
+};
+var updateStandaloneOnce = async (homeDir = import_node_os2.default.homedir()) => {
+  const check = await checkStandaloneUpdate(homeDir);
+  if (!check) {
+    const local = readLocalVersionMeta();
+    return {
+      changed: false,
+      previousVersion: local?.version ?? null,
+      currentVersion: local?.version ?? "unknown"
+    };
+  }
+  await downloadStandaloneUpdate(check.manifest, check.archive, homeDir);
+  return {
+    changed: true,
+    previousVersion: check.currentVersion,
+    currentVersion: check.manifest.version
+  };
+};
+var atomicSymlink = async (parentDir, linkPath, target) => {
+  const relTarget = import_node_path11.default.relative(parentDir, target);
+  const tmpLink = import_node_path11.default.join(parentDir, `.current-tmp-${Date.now()}`);
+  try {
+    await import_promises2.default.symlink(relTarget, tmpLink);
+    await import_promises2.default.rename(tmpLink, linkPath);
+  } catch {
+    try {
+      await import_promises2.default.unlink(tmpLink);
+    } catch {
+    }
+    try {
+      await import_promises2.default.unlink(linkPath);
+    } catch {
+    }
+    await import_promises2.default.symlink(relTarget, linkPath);
+  }
+};
+var pruneOldVersions = async (standaloneDir, currentVersion, platformKey) => {
+  try {
+    const entries = await import_promises2.default.readdir(standaloneDir, { withFileTypes: true });
+    const versionDirs = entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "current" && e.name.endsWith(`-${platformKey}`)
+    ).map((e) => e.name).sort().reverse();
+    const toRemove = versionDirs.slice(2);
+    for (const dir of toRemove) {
+      await import_promises2.default.rm(import_node_path11.default.join(standaloneDir, dir), { recursive: true, force: true });
+    }
+  } catch {
+  }
+};
+
 // src/bootstrap/runtimeManager.ts
 var MIN_NODE_MAJOR = 22;
 var RUNTIME_PACKAGE_NAME = "@boxes-dev/dvb-runtime";
@@ -3070,10 +3246,10 @@ var resolveBasePath = () => {
     return __filename;
   }
   const argv1 = typeof process.argv[1] === "string" ? process.argv[1] : "";
-  return argv1 || import_node_path11.default.join(process.cwd(), "dvb");
+  return argv1 || import_node_path12.default.join(process.cwd(), "dvb");
 };
 var readJsonFile = async (filePath) => {
-  const raw = await import_promises2.default.readFile(filePath, "utf8");
+  const raw = await import_promises3.default.readFile(filePath, "utf8");
   return JSON.parse(raw);
 };
 var readJsonFileIfExists = async (filePath) => {
@@ -3088,14 +3264,14 @@ var readJsonFileIfExists = async (filePath) => {
 };
 var writeJsonFileAtomic = async (filePath, value) => {
   const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await import_promises2.default.mkdir(import_node_path11.default.dirname(filePath), { recursive: true, mode: 448 });
-  await import_promises2.default.writeFile(tempPath, JSON.stringify(value, null, 2), "utf8");
-  await import_promises2.default.rename(tempPath, filePath);
+  await import_promises3.default.mkdir(import_node_path12.default.dirname(filePath), { recursive: true, mode: 448 });
+  await import_promises3.default.writeFile(tempPath, JSON.stringify(value, null, 2), "utf8");
+  await import_promises3.default.rename(tempPath, filePath);
 };
 var readStageVersion = async (runtimeDir) => {
   try {
     const manifest = await readJsonFile(
-      import_node_path11.default.join(runtimeDir, "package.json")
+      import_node_path12.default.join(runtimeDir, "package.json")
     );
     if (typeof manifest.version !== "string") return null;
     const version = manifest.version.trim();
@@ -3104,25 +3280,25 @@ var readStageVersion = async (runtimeDir) => {
     return null;
   }
 };
-var resolveRuntimeBinPath = (runtimeDir, kind) => import_node_path11.default.join(runtimeDir, "dist", "bin", `${kind}.cjs`);
+var resolveRuntimeBinPath = (runtimeDir, kind) => import_node_path12.default.join(runtimeDir, "dist", "bin", `${kind}.cjs`);
 var readLinkedRuntimeVersion = async (linkPath) => {
   try {
-    const runtimeDir = await import_promises2.default.realpath(linkPath);
-    const version = import_node_path11.default.basename(runtimeDir).trim();
+    const runtimeDir = await import_promises3.default.realpath(linkPath);
+    const version = import_node_path12.default.basename(runtimeDir).trim();
     return version.length > 0 ? version : null;
   } catch {
     return null;
   }
 };
-var readCurrentRuntime = async (homeDir = import_node_os2.default.homedir()) => {
+var readCurrentRuntime = async (homeDir = import_node_os3.default.homedir()) => {
   const currentLink = resolveCurrentRuntimeLink(homeDir);
   try {
-    const runtimeDir = await import_promises2.default.realpath(currentLink);
+    const runtimeDir = await import_promises3.default.realpath(currentLink);
     const version = await readStageVersion(runtimeDir);
     if (!version) return null;
     const dvbBin = resolveRuntimeBinPath(runtimeDir, "dvb");
     const dvbdBin = resolveRuntimeBinPath(runtimeDir, "dvbd");
-    if (!(0, import_node_fs7.existsSync)(dvbBin) || !(0, import_node_fs7.existsSync)(dvbdBin)) {
+    if (!(0, import_node_fs8.existsSync)(dvbBin) || !(0, import_node_fs8.existsSync)(dvbdBin)) {
       return null;
     }
     return { version, runtimeDir };
@@ -3130,9 +3306,9 @@ var readCurrentRuntime = async (homeDir = import_node_os2.default.homedir()) =>
     return null;
   }
 };
-var listLiveRuntimeVersions = async (homeDir = import_node_os2.default.homedir()) => {
+var listLiveRuntimeVersions = async (homeDir = import_node_os3.default.homedir()) => {
   const releasesDir = resolveRuntimeReleasesDir(homeDir);
-  const ps2 = (0, import_node_child_process.spawnSync)("ps", ["eww", "-Ao", "command="], {
+  const ps2 = (0, import_node_child_process2.spawnSync)("ps", ["eww", "-Ao", "command="], {
     encoding: "utf8"
   });
   if (ps2.error || ps2.status !== 0 || typeof ps2.stdout !== "string") {
@@ -3154,7 +3330,7 @@ var listLiveRuntimeVersions = async (homeDir = import_node_os2.default.homedir()
   }
   return [...versions];
 };
-var pruneRuntimeReleases = async (homeDir = import_node_os2.default.homedir()) => {
+var pruneRuntimeReleases = async (homeDir = import_node_os3.default.homedir()) => {
   const releasesDir = resolveRuntimeReleasesDir(homeDir);
   const keep = /* @__PURE__ */ new Set();
   const current = await readCurrentRuntime(homeDir);
@@ -3175,7 +3351,7 @@ var pruneRuntimeReleases = async (homeDir = import_node_os2.default.homedir()) =
     }
   }
   try {
-    const entries = await import_promises2.default.readdir(releasesDir, { withFileTypes: true });
+    const entries = await import_promises3.default.readdir(releasesDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) {
         continue;
@@ -3186,7 +3362,7 @@ var pruneRuntimeReleases = async (homeDir = import_node_os2.default.homedir()) =
       if (keep.has(entry.name)) {
         continue;
       }
-      await import_promises2.default.rm(import_node_path11.default.join(releasesDir, entry.name), {
+      await import_promises3.default.rm(import_node_path12.default.join(releasesDir, entry.name), {
         recursive: true,
         force: true
       });
@@ -3201,7 +3377,7 @@ var pruneRuntimeReleases = async (homeDir = import_node_os2.default.homedir()) =
 var resolveBundledRuntimeRoot = () => {
   const require2 = (0, import_node_module.createRequire)(resolveBasePath());
   const manifestPath = require2.resolve(`${RUNTIME_PACKAGE_NAME}/package.json`);
-  return import_node_path11.default.dirname(manifestPath);
+  return import_node_path12.default.dirname(manifestPath);
 };
 var readBundledRuntime = async () => {
   const runtimeDir = resolveBundledRuntimeRoot();
@@ -3211,20 +3387,20 @@ var readBundledRuntime = async () => {
   }
   return { version, runtimeDir };
 };
-var ensureReleasesDir = async (homeDir = import_node_os2.default.homedir()) => {
+var ensureReleasesDir = async (homeDir = import_node_os3.default.homedir()) => {
   const releasesDir = resolveRuntimeReleasesDir(homeDir);
-  await import_promises2.default.mkdir(releasesDir, { recursive: true, mode: 448 });
+  await import_promises3.default.mkdir(releasesDir, { recursive: true, mode: 448 });
   try {
-    await import_promises2.default.chmod(releasesDir, 448);
+    await import_promises3.default.chmod(releasesDir, 448);
   } catch {
   }
   return releasesDir;
 };
-var ensureUpdaterDir = async (homeDir = import_node_os2.default.homedir()) => {
+var ensureUpdaterDir = async (homeDir = import_node_os3.default.homedir()) => {
   const updaterDir = resolveUpdaterDir(homeDir);
-  await import_promises2.default.mkdir(updaterDir, { recursive: true, mode: 448 });
+  await import_promises3.default.mkdir(updaterDir, { recursive: true, mode: 448 });
   try {
-    await import_promises2.default.chmod(updaterDir, 448);
+    await import_promises3.default.chmod(updaterDir, 448);
   } catch {
   }
   return updaterDir;
@@ -3246,23 +3422,23 @@ var isProcessAlive = (pid) => {
     return code === "EPERM";
   }
 };
-var createStageDir = async (version, homeDir = import_node_os2.default.homedir()) => {
+var createStageDir = async (version, homeDir = import_node_os3.default.homedir()) => {
   const releasesDir = await ensureReleasesDir(homeDir);
-  return await import_promises2.default.mkdtemp(
-    import_node_path11.default.join(
+  return await import_promises3.default.mkdtemp(
+    import_node_path12.default.join(
       releasesDir,
       `.tmp-${version.replace(/[^a-zA-Z0-9._-]+/g, "-")}-`
     )
   );
 };
 var copyBundledRuntimeToStage = async (bundled, stageDir) => {
-  await import_promises2.default.copyFile(
-    import_node_path11.default.join(bundled.runtimeDir, "package.json"),
-    import_node_path11.default.join(stageDir, "package.json")
+  await import_promises3.default.copyFile(
+    import_node_path12.default.join(bundled.runtimeDir, "package.json"),
+    import_node_path12.default.join(stageDir, "package.json")
   );
-  await import_promises2.default.cp(
-    import_node_path11.default.join(bundled.runtimeDir, "dist"),
-    import_node_path11.default.join(stageDir, "dist"),
+  await import_promises3.default.cp(
+    import_node_path12.default.join(bundled.runtimeDir, "dist"),
+    import_node_path12.default.join(stageDir, "dist"),
     {
       recursive: true
     }
@@ -3299,7 +3475,7 @@ var downloadTarball = async (url, filePath) => {
     throw new Error(`Runtime tarball download failed with ${response.status}.`);
   }
   const buffer = Buffer.from(await response.arrayBuffer());
-  await import_promises2.default.writeFile(filePath, buffer);
+  await import_promises3.default.writeFile(filePath, buffer);
 };
 var extractRuntimeTarballToStage = async (tarballPath, stageDir) => {
   await lo({
@@ -3444,21 +3620,21 @@ var terminateChild = async (child) => {
   });
 };
 var validateRuntimeStage = async (stageDir, expectedVersion) => {
-  const socketDir = import_node_path11.default.join(
+  const socketDir = import_node_path12.default.join(
     "/tmp",
-    `dvb-runtime-validate-${process.pid}-${(0, import_node_crypto2.randomUUID)().slice(0, 8)}`
+    `dvb-runtime-validate-${process.pid}-${(0, import_node_crypto3.randomUUID)().slice(0, 8)}`
   );
-  const socketPath = import_node_path11.default.join(socketDir, "devboxd.sock");
+  const socketPath = import_node_path12.default.join(socketDir, "devboxd.sock");
   const daemonBinPath = resolveRuntimeBinPath(stageDir, "dvbd");
-  if (!(0, import_node_fs7.existsSync)(daemonBinPath)) {
+  if (!(0, import_node_fs8.existsSync)(daemonBinPath)) {
     throw new Error(`Runtime stage is missing ${daemonBinPath}.`);
   }
   const cliBinPath = resolveRuntimeBinPath(stageDir, "dvb");
-  if (!(0, import_node_fs7.existsSync)(cliBinPath)) {
+  if (!(0, import_node_fs8.existsSync)(cliBinPath)) {
     throw new Error(`Runtime stage is missing ${cliBinPath}.`);
   }
-  await import_promises2.default.mkdir(socketDir, { recursive: true, mode: 448 });
-  const child = (0, import_node_child_process.spawn)(process.execPath, [daemonBinPath], {
+  await import_promises3.default.mkdir(socketDir, { recursive: true, mode: 448 });
+  const child = (0, import_node_child_process2.spawn)(process.execPath, [daemonBinPath], {
     env: {
       ...process.env,
       DEVBOX_SOCKET_PATH: socketPath
@@ -3479,9 +3655,9 @@ var validateRuntimeStage = async (stageDir, expectedVersion) => {
         `Runtime stage reported version ${validated.version}; expected ${expectedVersion}.`
       );
     }
-    const cliHomeDir = import_node_path11.default.join(socketDir, "home");
-    await import_promises2.default.mkdir(cliHomeDir, { recursive: true, mode: 448 });
-    const cliChild = (0, import_node_child_process.spawn)(process.execPath, [cliBinPath, "--help"], {
+    const cliHomeDir = import_node_path12.default.join(socketDir, "home");
+    await import_promises3.default.mkdir(cliHomeDir, { recursive: true, mode: 448 });
+    const cliChild = (0, import_node_child_process2.spawn)(process.execPath, [cliBinPath, "--help"], {
       env: {
         ...process.env,
         HOME: cliHomeDir
@@ -3502,22 +3678,22 @@ var validateRuntimeStage = async (stageDir, expectedVersion) => {
     }
   } finally {
     await terminateChild(child);
-    await import_promises2.default.rm(socketDir, { recursive: true, force: true });
+    await import_promises3.default.rm(socketDir, { recursive: true, force: true });
   }
 };
 var writeSymlinkAtomic = async (linkPath, target) => {
   const tempPath = `${linkPath}.tmp-${process.pid}-${Date.now()}`;
-  await import_promises2.default.symlink(target, tempPath);
+  await import_promises3.default.symlink(target, tempPath);
   try {
-    await import_promises2.default.rename(tempPath, linkPath);
+    await import_promises3.default.rename(tempPath, linkPath);
   } catch (error) {
-    await import_promises2.default.rm(linkPath, { recursive: true, force: true });
-    await import_promises2.default.rename(tempPath, linkPath);
+    await import_promises3.default.rm(linkPath, { recursive: true, force: true });
+    await import_promises3.default.rename(tempPath, linkPath);
     if (error instanceof Error) {
     }
   }
 };
-var writeUpdaterHeartbeat = async (homeDir = import_node_os2.default.homedir()) => {
+var writeUpdaterHeartbeat = async (homeDir = import_node_os3.default.homedir()) => {
   const current = await readJsonFileIfExists(
     resolveUpdaterDaemonPath(homeDir)
   );
@@ -3529,7 +3705,7 @@ var writeUpdaterHeartbeat = async (homeDir = import_node_os2.default.homedir())
     heartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
   });
 };
-var claimUpdaterDaemon = async (homeDir = import_node_os2.default.homedir()) => {
+var claimUpdaterDaemon = async (homeDir = import_node_os3.default.homedir()) => {
   await ensureUpdaterDir(homeDir);
   const daemonPath = resolveUpdaterDaemonPath(homeDir);
   const record = {
@@ -3540,7 +3716,7 @@ var claimUpdaterDaemon = async (homeDir = import_node_os2.default.homedir()) =>
   };
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      await import_promises2.default.writeFile(daemonPath, JSON.stringify(record, null, 2), {
+      await import_promises3.default.writeFile(daemonPath, JSON.stringify(record, null, 2), {
         encoding: "utf8",
         flag: "wx"
       });
@@ -3554,20 +3730,20 @@ var claimUpdaterDaemon = async (homeDir = import_node_os2.default.homedir()) =>
       if (existing && isProcessAlive(existing.pid)) {
         return false;
       }
-      await import_promises2.default.rm(daemonPath, { force: true });
+      await import_promises3.default.rm(daemonPath, { force: true });
     }
   }
   return false;
 };
-var releaseUpdaterDaemon = async (homeDir = import_node_os2.default.homedir()) => {
+var releaseUpdaterDaemon = async (homeDir = import_node_os3.default.homedir()) => {
   const daemonPath = resolveUpdaterDaemonPath(homeDir);
   const current = await readJsonFileIfExists(daemonPath);
   if (!current || current.pid !== process.pid) {
     return;
   }
-  await import_promises2.default.rm(daemonPath, { force: true });
+  await import_promises3.default.rm(daemonPath, { force: true });
 };
-var writeUpdaterState = async (state, homeDir = import_node_os2.default.homedir()) => {
+var writeUpdaterState = async (state, homeDir = import_node_os3.default.homedir()) => {
   await ensureUpdaterDir(homeDir);
   await writeJsonFileAtomic(resolveUpdaterStatePath(homeDir), state);
 };
@@ -3583,12 +3759,12 @@ var waitWithShutdown = async (shutdown, timeoutMs) => {
     await new Promise((resolve) => setTimeout(resolve, delay));
   }
 };
-var promoteRuntimeStage = async (stageDir, version, homeDir = import_node_os2.default.homedir()) => {
+var promoteRuntimeStage = async (stageDir, version, homeDir = import_node_os3.default.homedir()) => {
   const previous = await readCurrentRuntime(homeDir);
   const versionDir = resolveRuntimeVersionDir(version, homeDir);
   if (stageDir !== versionDir) {
-    await import_promises2.default.rm(versionDir, { recursive: true, force: true });
-    await import_promises2.default.rename(stageDir, versionDir);
+    await import_promises3.default.rm(versionDir, { recursive: true, force: true });
+    await import_promises3.default.rename(stageDir, versionDir);
   }
   if (previous && previous.version !== version) {
     await writeSymlinkAtomic(
@@ -3602,7 +3778,7 @@ var promoteRuntimeStage = async (stageDir, version, homeDir = import_node_os2.de
   } catch {
   }
 };
-var installBundledRuntime = async (bundled, homeDir = import_node_os2.default.homedir()) => {
+var installBundledRuntime = async (bundled, homeDir = import_node_os3.default.homedir()) => {
   const stageDir = await createStageDir(bundled.version, homeDir);
   try {
     await copyBundledRuntimeToStage(bundled, stageDir);
@@ -3613,21 +3789,21 @@ var installBundledRuntime = async (bundled, homeDir = import_node_os2.default.ho
       runtimeDir: resolveRuntimeVersionDir(bundled.version, homeDir)
     };
   } catch (error) {
-    await import_promises2.default.rm(stageDir, { recursive: true, force: true });
+    await import_promises3.default.rm(stageDir, { recursive: true, force: true });
     throw error;
   }
 };
-var installDownloadedRuntime = async (manifest, homeDir = import_node_os2.default.homedir()) => {
+var installDownloadedRuntime = async (manifest, homeDir = import_node_os3.default.homedir()) => {
   const tarball = manifest.dist?.tarball?.trim();
   if (!tarball) {
     throw new Error("Runtime manifest is missing dist.tarball.");
   }
   const stageDir = await createStageDir(manifest.version, homeDir);
-  const tarballPath = import_node_path11.default.join(stageDir, "runtime.tgz");
+  const tarballPath = import_node_path12.default.join(stageDir, "runtime.tgz");
   try {
     await downloadTarball(tarball, tarballPath);
     await extractRuntimeTarballToStage(tarballPath, stageDir);
-    await import_promises2.default.rm(tarballPath, { force: true });
+    await import_promises3.default.rm(tarballPath, { force: true });
     await validateRuntimeStage(stageDir, manifest.version);
     await promoteRuntimeStage(stageDir, manifest.version, homeDir);
     return {
@@ -3635,11 +3811,11 @@ var installDownloadedRuntime = async (manifest, homeDir = import_node_os2.defaul
       runtimeDir: resolveRuntimeVersionDir(manifest.version, homeDir)
     };
   } catch (error) {
-    await import_promises2.default.rm(stageDir, { recursive: true, force: true });
+    await import_promises3.default.rm(stageDir, { recursive: true, force: true });
     throw error;
   }
 };
-var ensureBundledRuntimeStaged = async (homeDir = import_node_os2.default.homedir()) => {
+var ensureBundledRuntimeStaged = async (homeDir = import_node_os3.default.homedir()) => {
   const bundled = await readBundledRuntime();
   const current = await readCurrentRuntime(homeDir);
   if (current && compareSemver(current.version, bundled.version) === 0) {
@@ -3657,7 +3833,7 @@ var ensureBundledRuntimeStaged = async (homeDir = import_node_os2.default.homedi
     throw error;
   }
 };
-var updateRuntimeOnce = async (homeDir = process.env.HOME?.trim() || import_node_os2.default.homedir()) => {
+var updateRuntimeOnce = async (homeDir = process.env.HOME?.trim() || import_node_os3.default.homedir()) => {
   assertNodeVersion();
   const bundled = await readBundledRuntime();
   const current = await ensureBundledRuntimeStaged(homeDir);
@@ -3678,7 +3854,7 @@ var updateRuntimeOnce = async (homeDir = process.env.HOME?.trim() || import_node
     source: "downloaded"
   };
 };
-var writeUpdatePassState = async (result, homeDir = import_node_os2.default.homedir()) => {
+var writeUpdatePassState = async (result, homeDir = import_node_os3.default.homedir()) => {
   await writeUpdaterState(
     {
       status: "ok",
@@ -3691,7 +3867,7 @@ var writeUpdatePassState = async (result, homeDir = import_node_os2.default.home
     homeDir
   );
 };
-var writeUpdatePassErrorState = async (currentVersion, error, homeDir = import_node_os2.default.homedir()) => {
+var writeUpdatePassErrorState = async (currentVersion, error, homeDir = import_node_os3.default.homedir()) => {
   await writeUpdaterState(
     {
       status: "error",
@@ -3704,7 +3880,7 @@ var writeUpdatePassErrorState = async (currentVersion, error, homeDir = import_n
     homeDir
   );
 };
-var runUpdaterPass = async (homeDir = import_node_os2.default.homedir()) => {
+var runUpdaterPass = async (homeDir = import_node_os3.default.homedir()) => {
   const current = await readCurrentRuntime(homeDir);
   try {
     const result = await updateRuntimeOnce(homeDir);
@@ -3715,7 +3891,7 @@ var runUpdaterPass = async (homeDir = import_node_os2.default.homedir()) => {
     throw error;
   }
 };
-var runBackgroundUpdaterDaemon = async (homeDir = process.env.HOME?.trim() || import_node_os2.default.homedir()) => {
+var runBackgroundUpdaterDaemon = async (homeDir = process.env.HOME?.trim() || import_node_os3.default.homedir()) => {
   assertNodeVersion();
   const claimed = await claimUpdaterDaemon(homeDir);
   if (!claimed) {
@@ -3735,6 +3911,12 @@ var runBackgroundUpdaterDaemon = async (homeDir = process.env.HOME?.trim() || im
         await runUpdaterPass(homeDir);
       } catch {
       }
+      if (isStandaloneMode()) {
+        try {
+          await updateStandaloneOnce(homeDir);
+        } catch {
+        }
+      }
       await writeUpdaterHeartbeat(homeDir);
       await waitWithShutdown(shutdown, UPDATER_INTERVAL_MS);
     }