@boxes-dev/dvb-runtime 1.0.297 → 1.0.299

package/dist/devbox/commands/init/remote.js

@@ -1,766 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { SpritesApiError, createLogger, } from "@boxes-dev/core";
-import { mergeCodexInitConfig } from "./codex/config.js";
-const DAEMON_SERVICE_NAME = "devbox-sprite-daemon";
-const MODAL_DAEMON_HEALTH_PORT = 8080;
-const SPRITE_DAEMON_SESSION_PORT = 8788;
-const DEFAULT_DAEMON_BASE_URL = process.env.SPRITE_DAEMON_BASE_URL?.trim() || "https://deploy-dev.boxes.dev";
-const DEFAULT_HEARTBEAT_MS = 30_000;
-const MANAGED_DAEMON_NODE_PATH = "/opt/devbox-runtime/node/current/bin/node";
-const BOOTSTRAP_EXEC_TIMEOUT_MS = 90_000;
-const BOOTSTRAP_EXEC_HANDSHAKE_TIMEOUT_MS = 20_000;
-const BASIC_ALIASES_MARKER = "\n# Basic aliases";
-const LEGACY_BASH_TRAP = "trap 'echo -ne \"\\033]0;${BASH_COMMAND}\\007\"' DEBUG";
-const SAFE_BASH_TRAP = 'trap \'printf "\\033]0;%s\\007" "${BASH_COMMAND//[^[:print:]]/}"\' DEBUG';
-const BASH_HISTORY_BLOCK = [
-    "# History search with up/down arrows",
-    "if [[ $- == *i* ]]; then bind '\"\\e[A\": history-search-backward'; fi",
-    "if [[ $- == *i* ]]; then bind '\"\\eOA\": history-search-backward'; fi",
-    "if [[ $- == *i* ]]; then bind '\"\\e[B\": history-search-forward'; fi",
-    "if [[ $- == *i* ]]; then bind '\"\\eOB\": history-search-forward'; fi",
-].join("\n");
-const ZSH_HISTORY_BLOCK = [
-    "# History search with up/down arrows",
-    "autoload -Uz history-search-end",
-    "zle -N history-beginning-search-backward-end history-search-end",
-    "zle -N history-beginning-search-forward-end history-search-end",
-    "bindkey '^[[A' history-beginning-search-backward-end  # Up arrow",
-    "bindkey '^[OA' history-beginning-search-backward-end  # Up arrow",
-    "bindkey '^[[B' history-beginning-search-forward-end   # Down arrow",
-    "bindkey '^[OB' history-beginning-search-forward-end   # Down arrow",
-].join("\n");
-const HISTORY_BLOCK_PATTERN = /^# History search with up\/down arrows\n[\s\S]*?(?=\n# Basic aliases|(?![\s\S]))/m;
-const BASH_HISTORY_LINE_PATTERN = /^.*history-search-(?:backward|forward).*$\n?/gm;
-const ZSH_HISTORY_LINE_PATTERN = /^.*history-search-end.*$\n?|^.*history-beginning-search-backward-end.*$\n?|^.*history-beginning-search-forward-end.*$\n?/gm;
-const logger = createLogger("devbox-init");
-const truncateTail = (value, maxChars) => {
-    if (value.length <= maxChars)
-        return value;
-    const omitted = value.length - maxChars;
-    return `[truncated ${omitted} chars] ${value.slice(-maxChars)}`;
-};
-const shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
-const buildDaemonPaths = (homeDir) => {
-    const daemonDir = `${homeDir}/.devbox/daemon`;
-    return {
-        daemonDir,
-        daemonTarball: `${daemonDir}/sprite-daemon.tar.gz`,
-        daemonBundleDir: `${daemonDir}/bundle`,
-        daemonEntry: `${daemonDir}/bundle/sprite-daemon.mjs`,
-        daemonWrapper: `${daemonDir}/run-daemon.sh`,
-        daemonConfigFile: `${daemonDir}/config.json`,
-        daemonLogFile: `${daemonDir}/sprite-daemon.log`,
-    };
-};
-const resolveDaemonAssetTarget = (computeProvider) => computeProvider === "sprites" ? "sprites" : "managed";
-const resolveRemoteHomeDir = async (client, spriteAlias) => {
-    const homeResult = await execWithLog(client, spriteAlias, ["set -euo pipefail", 'printf "%s" "$HOME"'].join("\n"), "resolve-remote-home");
-    if (homeResult.exitCode !== 0) {
-        const details = homeResult.stderr || homeResult.stdout || "";
-        throw new Error(details
-            ? `resolve remote home failed: ${details}`
-            : `resolve remote home failed (exit ${homeResult.exitCode})`);
-    }
-    const resolved = homeResult.stdout.trim();
-    if (!resolved.startsWith("/")) {
-        throw new Error(`resolve remote home returned invalid path: ${resolved}`);
-    }
-    return resolved.replace(/\/+$/, "") || resolved;
-};
-const expandHome = (value, homeDir) => {
-    if (value.startsWith("~/")) {
-        return `${homeDir}/${value.slice(2)}`;
-    }
-    return value;
-};
-const execWithLog = async (client, spriteAlias, script, stage, options) => {
-    const requestId = randomUUID();
-    const startedAt = Date.now();
-    logger.info("sprites_request", {
-        requestId,
-        method: "exec",
-        path: "/exec",
-        box: spriteAlias,
-        stage,
-    });
-    const result = await client.exec(spriteAlias, ["/bin/bash", "-lc", script], options);
-    const durationMs = Date.now() - startedAt;
-    logger.info("sprites_response", {
-        requestId,
-        method: "exec",
-        path: "/exec",
-        status: result.exitCode === 0 ? "ok" : "error",
-        exitCode: result.exitCode,
-        durationMs,
-        ...(result.exitCode !== 0
-            ? {
-                stdoutBytes: result.stdout.length,
-                stderrBytes: result.stderr.length,
-                stdoutPreview: result.stdout
-                    ? truncateTail(result.stdout, 4000)
-                    : undefined,
-                stderrPreview: result.stderr
-                    ? truncateTail(result.stderr, 4000)
-                    : undefined,
-            }
-            : {}),
-        box: spriteAlias,
-        stage,
-    });
-    return result;
-};
-const writeRemoteFile = async (client, spriteAlias, path, content, stage) => {
-    const requestId = randomUUID();
-    logger.info("sprites_request", {
-        requestId,
-        method: "writeFile",
-        path,
-        box: spriteAlias,
-        stage,
-    });
-    const buffer = typeof content === "string" ? Buffer.from(content, "utf8") : content;
-    await client.writeFile(spriteAlias, path, buffer);
-    logger.info("sprites_response", {
-        requestId,
-        method: "writeFile",
-        path,
-        status: "ok",
-        box: spriteAlias,
-        stage,
-    });
-};
-const readRemoteFile = async (client, spriteAlias, path, stage) => {
-    const requestId = randomUUID();
-    logger.info("sprites_request", {
-        requestId,
-        method: "readFile",
-        path,
-        box: spriteAlias,
-        stage,
-    });
-    try {
-        const bytes = await client.readFile(spriteAlias, { path });
-        logger.info("sprites_response", {
-            requestId,
-            method: "readFile",
-            path,
-            status: "ok",
-            bytes: bytes.byteLength,
-            box: spriteAlias,
-            stage,
-        });
-        return Buffer.from(bytes).toString("utf8");
-    }
-    catch (error) {
-        const notFound = error instanceof SpritesApiError && error.status === 404;
-        logger.info("sprites_response", {
-            requestId,
-            method: "readFile",
-            path,
-            status: notFound ? "not_found" : "error",
-            box: spriteAlias,
-            stage,
-        });
-        if (notFound)
-            return null;
-        throw error;
-    }
-};
-const ensureTrailingNewline = (value) => value.endsWith("\n") ? value : `${value}\n`;
-const upsertHistoryBlock = ({ data, canonicalBlock, historyLinePattern, }) => {
-    if (HISTORY_BLOCK_PATTERN.test(data)) {
-        return data.replace(HISTORY_BLOCK_PATTERN, () => canonicalBlock);
-    }
-    const withoutLegacyLines = data.replace(historyLinePattern, "");
-    if (withoutLegacyLines.includes(BASIC_ALIASES_MARKER)) {
-        return withoutLegacyLines.replace(BASIC_ALIASES_MARKER, `\n${canonicalBlock}\n${BASIC_ALIASES_MARKER}`);
-    }
-    return `${withoutLegacyLines.replace(/\n+$/, "")}\n\n${canonicalBlock}\n`;
-};
-const patchBashrcContent = (data) => {
-    let next = data;
-    if (next.includes(LEGACY_BASH_TRAP)) {
-        next = next.replace(LEGACY_BASH_TRAP, SAFE_BASH_TRAP);
-    }
-    next = upsertHistoryBlock({
-        data: next,
-        canonicalBlock: BASH_HISTORY_BLOCK,
-        historyLinePattern: BASH_HISTORY_LINE_PATTERN,
-    });
-    return ensureTrailingNewline(next);
-};
-const patchZshrcContent = (data) => ensureTrailingNewline(upsertHistoryBlock({
-    data,
-    canonicalBlock: ZSH_HISTORY_BLOCK,
-    historyLinePattern: ZSH_HISTORY_LINE_PATTERN,
-}));
-const bootstrapDevbox = async (client, spriteAlias, { onPhase } = {}) => {
-    const totalPhases = 4;
-    const reportPhase = (completedPhases, detail) => {
-        onPhase?.(completedPhases, totalPhases, detail);
-    };
-    const remoteHome = await resolveRemoteHomeDir(client, spriteAlias);
-    reportPhase(0, "fix ownership/permissions");
-    const permissionsScript = [
-        "set -euo pipefail",
-        `home=${shellQuote(remoteHome)}`,
-        'if [ ! -d "$home" ]; then',
-        '  echo "missing home directory: $home" >&2',
-        "  exit 1",
-        "fi",
-        'mkdir -p "$home/.devbox"',
-        'chmod 755 "$home" || true',
-        'chmod 755 "$home/.devbox" || true',
-    ].join("\n");
-    const permsResult = await execWithLog(client, spriteAlias, permissionsScript, "bootstrap-permissions", {
-        timeoutMs: BOOTSTRAP_EXEC_TIMEOUT_MS,
-        handshakeTimeoutMs: BOOTSTRAP_EXEC_HANDSHAKE_TIMEOUT_MS,
-    });
-    if (permsResult.exitCode !== 0) {
-        const details = permsResult.stderr || permsResult.stdout || "";
-        throw new Error(details
-            ? `devbox bootstrap failed: ${details}`
-            : `devbox bootstrap failed (exit ${permsResult.exitCode})`);
-    }
-    reportPhase(1, "prefer IPv4 localhost");
-    const ipv4PreferenceScript = [
-        "set -euo pipefail",
-        'if [ "$(id -u)" -eq 0 ]; then',
-        '  if ! grep -q "ipv4first" /etc/gai.conf 2>/dev/null; then',
-        "    cat <<'EOF' >> /etc/gai.conf",
-        "# devbox: prefer IPv4 for localhost",
-        "precedence ::ffff:0:0/96  100",
-        "EOF",
-        "  fi",
-        "else",
-        '  if ! sudo -n grep -q "ipv4first" /etc/gai.conf 2>/dev/null; then',
-        "    cat <<'EOF' | sudo -n tee -a /etc/gai.conf >/dev/null",
-        "# devbox: prefer IPv4 for localhost",
-        "precedence ::ffff:0:0/96  100",
-        "EOF",
-        "  fi",
-        "fi",
-    ].join("\n");
-    const ipv4Result = await execWithLog(client, spriteAlias, ipv4PreferenceScript, "bootstrap-ipv4-preference", {
-        timeoutMs: BOOTSTRAP_EXEC_TIMEOUT_MS,
-        handshakeTimeoutMs: BOOTSTRAP_EXEC_HANDSHAKE_TIMEOUT_MS,
-    });
-    if (ipv4Result.exitCode !== 0) {
-        const details = ipv4Result.stderr || ipv4Result.stdout || "";
-        throw new Error(details
-            ? `devbox bootstrap failed: ${details}`
-            : `devbox bootstrap failed (exit ${ipv4Result.exitCode})`);
-    }
-    reportPhase(2, "patching .bashrc");
-    await patchBashrc(client, spriteAlias, remoteHome);
-    reportPhase(3, "patching .zshrc");
-    await patchZshrc(client, spriteAlias, remoteHome);
-    reportPhase(4, "completed");
-};
-const patchRemoteRcFile = async (client, spriteAlias, options) => {
-    const existing = await readRemoteFile(client, spriteAlias, options.path, `${options.errorLabel}-read`);
-    if (existing === null) {
-        logger.warn("init_rc_patch_skipped_missing_file", {
-            box: spriteAlias,
-            path: options.path,
-            rcFile: options.errorLabel,
-        });
-        return;
-    }
-    const next = options.transform(existing);
-    if (next === existing) {
-        return;
-    }
-    await writeRemoteFile(client, spriteAlias, options.path, next, `${options.errorLabel}-write`);
-    const modeResult = await execWithLog(client, spriteAlias, ["set -euo pipefail", `chmod 644 ${shellQuote(options.path)}`].join("\n"), `${options.errorLabel}-chmod`);
-    if (modeResult.exitCode !== 0) {
-        const details = modeResult.stderr || modeResult.stdout || "";
-        throw new Error(details
-            ? `${options.errorLabel} patch failed: ${details}`
-            : `${options.errorLabel} patch failed (exit ${modeResult.exitCode})`);
-    }
-};
-const patchBashrc = async (client, spriteAlias, homeDir) => await patchRemoteRcFile(client, spriteAlias, {
-    path: `${homeDir}/.bashrc`,
-    errorLabel: "bashrc",
-    transform: patchBashrcContent,
-});
-const patchZshrc = async (client, spriteAlias, homeDir) => await patchRemoteRcFile(client, spriteAlias, {
-    path: `${homeDir}/.zshrc`,
-    errorLabel: "zshrc",
-    transform: patchZshrcContent,
-});
-const ensureRemoteCodexConfig = async ({ client, spriteAlias, trustedPaths, }) => {
-    const remoteHome = await resolveRemoteHomeDir(client, spriteAlias);
-    const codexConfigDir = `${remoteHome}/.codex`;
-    const codexConfigPath = `${codexConfigDir}/config.toml`;
-    const mkdirResult = await execWithLog(client, spriteAlias, [
-        "set -euo pipefail",
-        `mkdir -p ${shellQuote(codexConfigDir)}`,
-        `chmod 700 ${shellQuote(codexConfigDir)}`,
-    ].join("\n"), "codex-config-mkdir");
-    if (mkdirResult.exitCode !== 0) {
-        const details = mkdirResult.stderr || mkdirResult.stdout || "";
-        throw new Error(details
-            ? `codex config mkdir failed: ${details}`
-            : `codex config mkdir failed (exit ${mkdirResult.exitCode})`);
-    }
-    const existing = await readRemoteFile(client, spriteAlias, codexConfigPath, "codex-config-read");
-    const next = mergeCodexInitConfig({
-        existingContent: existing,
-        trustedPaths,
-    });
-    await writeRemoteFile(client, spriteAlias, codexConfigPath, next, "codex-config-write");
-    const chmodResult = await execWithLog(client, spriteAlias, ["set -euo pipefail", `chmod 600 ${shellQuote(codexConfigPath)}`].join("\n"), "codex-config-chmod");
-    if (chmodResult.exitCode !== 0) {
-        const details = chmodResult.stderr || chmodResult.stdout || "";
-        throw new Error(details
-            ? `codex config chmod failed: ${details}`
-            : `codex config chmod failed (exit ${chmodResult.exitCode})`);
-    }
-};
-const stageRemoteSetupArtifacts = async ({ client, spriteAlias, computeProvider, workdir, artifactsBundlePath, artifactsManifestPath, }) => {
-    const remoteHome = await resolveRemoteHomeDir(client, spriteAlias);
-    const { daemonBundleDir } = buildDaemonPaths(remoteHome);
-    const daemonNodePath = computeProvider === "sprites"
-        ? `${daemonBundleDir}/bin/node`
-        : MANAGED_DAEMON_NODE_PATH;
-    const stagedExternalDir = `${workdir.replace(/\/$/, "")}/.devbox/staged-external`;
-    const stagedIndexPath = `${stagedExternalDir}/index.json`;
-    const script = [
-        "set -euo pipefail",
-        "",
-        `workdir=${shellQuote(workdir)}`,
-        `bundle=${shellQuote(artifactsBundlePath)}`,
-        `manifest=${shellQuote(artifactsManifestPath)}`,
-        `staged_external=${shellQuote(stagedExternalDir)}`,
-        `staged_index=${shellQuote(stagedIndexPath)}`,
-        `daemon_node=${shellQuote(daemonNodePath)}`,
-        "",
-        'mkdir -p "$workdir/.devbox"',
-        'mkdir -p "$staged_external"',
-        "",
-        'if [ ! -x "$daemon_node" ]; then',
-        '  echo "daemon node missing at $daemon_node" >&2',
-        "  exit 1",
-        "fi",
-        'node_cmd="$daemon_node"',
-        "",
-        'tmp="$(mktemp -d)"',
-        'cleanup() { rm -rf "$tmp"; }',
-        "trap cleanup EXIT",
-        "",
-        "have_bundle=0",
-        "have_manifest=0",
-        'if [ -s "$bundle" ]; then have_bundle=1; fi',
-        'if [ -s "$manifest" ]; then have_manifest=1; fi',
-        "",
-        'if [ "$have_bundle" -eq 1 ]; then',
-        '  mkdir -p "$tmp/extracted"',
-        '  tar -xzf "$bundle" -C "$tmp/extracted"',
-        "",
-        '  if [ -d "$tmp/extracted/repo" ]; then',
-        '    backup_root="$workdir/.devbox/backups/setup-artifacts-$(date -u +%Y%m%dT%H%M%SZ)"',
-        '    mkdir -p "$backup_root/repo"',
-        "    if command -v rsync >/dev/null 2>&1; then",
-        '      rsync -a --backup --backup-dir="$backup_root/repo" "$tmp/extracted/repo/" "$workdir/"',
-        "    else",
-        '      echo "Warning: rsync missing; copying repo artifacts without backup" >&2',
-        '      cp -a "$tmp/extracted/repo/." "$workdir/"',
-        "    fi",
-        "  fi",
-        "",
-        '  if [ -d "$tmp/extracted/external" ]; then',
-        "    # External artifacts are staged for Codex to place appropriately on Linux.",
-        "    if command -v rsync >/dev/null 2>&1; then",
-        '      rsync -a --delete "$tmp/extracted/external/" "$staged_external/"',
-        "    else",
-        '      rm -rf "$staged_external"',
-        '      mkdir -p "$staged_external"',
-        '      cp -a "$tmp/extracted/external/." "$staged_external/"',
-        "    fi",
-        "  fi",
-        "fi",
-        "",
-        'if [ "$have_manifest" -eq 1 ] && [ -n "$node_cmd" ]; then',
-        '  MANIFEST_PATH="$manifest" STAGED_INDEX_PATH="$staged_index" "$node_cmd" - <<\'NODE\'',
-        "const fs = require('fs');",
-        "const path = require('path');",
-        "",
-        "const manifestPath = process.env.MANIFEST_PATH;",
-        "const outPath = process.env.STAGED_INDEX_PATH;",
-        "",
-        "let manifest;",
-        "try {",
-        "  manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));",
-        "} catch {",
-        "  manifest = null;",
-        "}",
-        "",
-        "const entries = Array.isArray(manifest?.entries) ? manifest.entries : [];",
-        "const external = [];",
-        "for (const entry of entries) {",
-        "  if (!entry || typeof entry !== 'object') continue;",
-        "  const bundlePath = entry.bundlePath;",
-        "  if (typeof bundlePath !== 'string') continue;",
-        "  if (!bundlePath.startsWith('external/')) continue;",
-        "  const rel = bundlePath.slice('external/'.length).replace(/\\\\/g, '/');",
-        "  const stagedPath = path.posix.join('.devbox', 'staged-external', rel);",
-        "  external.push({",
-        "    kind: typeof entry.kind === 'string' ? entry.kind : null,",
-        "    name: typeof entry.name === 'string' ? entry.name : null,",
-        "    sourcePath: typeof entry.sourcePath === 'string' ? entry.sourcePath : null,",
-        "    stagedPath,",
-        "    description: typeof entry.description === 'string' ? entry.description : null,",
-        "    vars: Array.isArray(entry.vars) ? entry.vars.filter((v) => typeof v === 'string') : null,",
-        "    usage: typeof entry.usage === 'string' ? entry.usage : null,",
-        "  });",
-        "}",
-        "",
-        "const payload = {",
-        "  createdAt: new Date().toISOString(),",
-        "  entries: external,",
-        "};",
-        "",
-        "fs.mkdirSync(path.dirname(outPath), { recursive: true });",
-        "fs.writeFileSync(outPath, JSON.stringify(payload, null, 2), 'utf8');",
-        "NODE",
-        "else",
-        "  # Manifest missing: still write an empty index so Codex can rely on it existing.",
-        '  created_at="$(date -u +%Y-%m-%dT%H:%M:%SZ)"',
-        '  printf \'{"createdAt":"%s","entries":[]}\\n\' "$created_at" > "$staged_index"',
-        "fi",
-        "",
-        'chmod -R u+rwX,go-rwx "$workdir/.devbox" || true',
-    ].join("\n");
-    const result = await execWithLog(client, spriteAlias, script, "stage-setup-artifacts");
-    if (result.exitCode !== 0) {
-        const details = result.stderr || result.stdout || "";
-        throw new Error(details
-            ? `staging setup artifacts failed: ${details}`
-            : `staging setup artifacts failed (exit ${result.exitCode})`);
-    }
-};
-const resolveDaemonUrl = (release, computeProvider) => release.url?.trim() ||
-    `${DEFAULT_DAEMON_BASE_URL}/sprite-daemon-${resolveDaemonAssetTarget(computeProvider)}-${release.sha256}.tar.gz`;
-const fetchDaemonBinary = async (release, computeProvider, onProgress) => {
-    const url = resolveDaemonUrl(release, computeProvider);
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to download the remote daemon package (${response.status} ${response.statusText}).`);
-    }
-    const expectedSize = Number.isFinite(release.size) && release.size > 0 ? release.size : null;
-    const contentLengthHeader = response.headers.get("content-length");
-    const parsedContentLength = contentLengthHeader
-        ? Number.parseInt(contentLengthHeader, 10)
-        : Number.NaN;
-    const responseContentLength = Number.isFinite(parsedContentLength) && parsedContentLength > 0
-        ? parsedContentLength
-        : null;
-    const totalBytes = expectedSize ?? responseContentLength;
-    if (!response.body) {
-        const buffer = new Uint8Array(await response.arrayBuffer());
-        if (onProgress) {
-            const fallbackTotal = Math.max(totalBytes ?? 0, buffer.byteLength);
-            onProgress(0, fallbackTotal);
-            onProgress(buffer.byteLength, fallbackTotal);
-        }
-        return { buffer, url };
-    }
-    const reader = response.body.getReader();
-    const chunks = [];
-    let receivedBytes = 0;
-    if (onProgress) {
-        onProgress(0, totalBytes ?? 1);
-    }
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        if (!value || value.byteLength === 0)
-            continue;
-        chunks.push(value);
-        receivedBytes += value.byteLength;
-        if (onProgress) {
-            const progressTotal = totalBytes === null
-                ? Math.max(receivedBytes, 1)
-                : Math.max(totalBytes, receivedBytes);
-            onProgress(receivedBytes, progressTotal);
-        }
-    }
-    const buffer = new Uint8Array(receivedBytes);
-    let offset = 0;
-    for (const chunk of chunks) {
-        buffer.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    if (onProgress) {
-        const progressTotal = totalBytes === null
-            ? Math.max(receivedBytes, 1)
-            : Math.max(totalBytes, receivedBytes);
-        onProgress(receivedBytes, progressTotal);
-    }
-    return { buffer, url };
-};
-const fetchDaemonBinaryOnRemote = async ({ client, spriteAlias, release, computeProvider, remoteTarballPath, onProgress, }) => {
-    const url = resolveDaemonUrl(release, computeProvider);
-    const totalBytes = Number.isFinite(release.size) && release.size > 0 ? release.size : 1;
-    onProgress?.(0, totalBytes);
-    const script = [
-        "set -euo pipefail",
-        `url=${shellQuote(url)}`,
-        `tarball=${shellQuote(remoteTarballPath)}`,
-        `expected_sha=${shellQuote(release.sha256)}`,
-        'mkdir -p "$(dirname "$tarball")"',
-        "if ! command -v curl >/dev/null 2>&1; then",
-        '  echo "curl is required to fetch the remote daemon package." >&2',
-        "  exit 127",
-        "fi",
-        "if ! command -v sha256sum >/dev/null 2>&1; then",
-        '  echo "sha256sum is required to verify the remote daemon package." >&2',
-        "  exit 127",
-        "fi",
-        'tmp_tarball="${tarball}.tmp.$$"',
-        'cleanup() { rm -f "$tmp_tarball"; }',
-        "trap cleanup EXIT",
-        'curl --fail --location --silent --show-error "$url" --output "$tmp_tarball"',
-        'actual_sha="$(sha256sum "$tmp_tarball" | awk \'{print $1}\')"',
-        'if [ "$actual_sha" != "$expected_sha" ]; then',
-        '  echo "remote daemon package checksum mismatch" >&2',
-        "  exit 1",
-        "fi",
-        'mv "$tmp_tarball" "$tarball"',
-        "trap - EXIT",
-        'chmod 600 "$tarball" || true',
-    ].join("\n");
-    const result = await execWithLog(client, spriteAlias, script, "fetch-remote-daemon-package", {
-        timeoutMs: 120_000,
-        handshakeTimeoutMs: BOOTSTRAP_EXEC_HANDSHAKE_TIMEOUT_MS,
-    });
-    if (result.exitCode !== 0) {
-        throw new Error(result.stderr ||
-            result.stdout ||
-            "Failed to fetch the remote daemon package.");
-    }
-    onProgress?.(totalBytes, totalBytes);
-};
-const buildDaemonConfig = (convexUrl, heartbeatToken, computeProvider) => new TextEncoder().encode(JSON.stringify({
-    convexUrl,
-    heartbeatToken,
-    heartbeatMs: DEFAULT_HEARTBEAT_MS,
-    computeProvider,
-}, null, 2));
-const isSameArgs = (left, right) => {
-    if (!left)
-        return right.length === 0;
-    if (left.length !== right.length)
-        return false;
-    return left.every((value, index) => value === right[index]);
-};
-const ensureSpriteDaemonService = async ({ client, spriteName, computeProvider, }) => {
-    const remoteHome = await resolveRemoteHomeDir(client, spriteName);
-    const paths = buildDaemonPaths(remoteHome);
-    if (computeProvider === "modal") {
-        const script = [
-            "set -euo pipefail",
-            `wrapper=${shellQuote(paths.daemonWrapper)}`,
-            `health_port=${String(MODAL_DAEMON_HEALTH_PORT)}`,
-            'if [ ! -x "$wrapper" ]; then',
-            '  echo "missing remote daemon launcher" >&2',
-            "  exit 1",
-            "fi",
-            "ready=0",
-            "for _ in $(seq 1 120); do",
-            '  if (echo >"/dev/tcp/127.0.0.1/${health_port}") >/dev/null 2>&1; then',
-            "    ready=1",
-            "    break",
-            "  fi",
-            "  sleep 0.25",
-            "done",
-            'if [ "$ready" -ne 1 ]; then',
-            '  echo "remote daemon health port not ready" >&2',
-            "  exit 1",
-            "fi",
-            "echo ok",
-        ].join("\n");
-        const result = await execWithLog(client, spriteName, script, "ensure-sprite-daemon");
-        if (result.exitCode !== 0) {
-            throw new Error(result.stderr || result.stdout || "Remote daemon health check failed.");
-        }
-        return;
-    }
-    if (computeProvider === "e2b") {
-        const script = [
-            "set -euo pipefail",
-            `wrapper=${shellQuote(paths.daemonWrapper)}`,
-            `control_port=${String(MODAL_DAEMON_HEALTH_PORT)}`,
-            `session_port=${String(SPRITE_DAEMON_SESSION_PORT)}`,
-            'if [ ! -x "$wrapper" ]; then',
-            '  echo "missing remote daemon launcher" >&2',
-            "  exit 1",
-            "fi",
-            "control_ready=0",
-            "for _ in $(seq 1 120); do",
-            '  if (echo >"/dev/tcp/127.0.0.1/${control_port}") >/dev/null 2>&1; then',
-            "    control_ready=1",
-            "    break",
-            "  fi",
-            "  sleep 0.25",
-            "done",
-            'if [ "$control_ready" -ne 1 ]; then',
-            '  echo "remote daemon control port not ready" >&2',
-            "  exit 1",
-            "fi",
-            "session_ready=0",
-            "for _ in $(seq 1 40); do",
-            '  if (echo >"/dev/tcp/127.0.0.1/${session_port}") >/dev/null 2>&1; then',
-            "    session_ready=1",
-            "    break",
-            "  fi",
-            "  sleep 0.25",
-            "done",
-            'if [ "$session_ready" -ne 1 ]; then',
-            '  echo "remote daemon session port not ready" >&2',
-            "  exit 1",
-            "fi",
-            'echo "ok"',
-        ].join("\n");
-        const result = await execWithLog(client, spriteName, script, "ensure-sprite-daemon");
-        if (result.exitCode !== 0) {
-            throw new Error(result.stderr || result.stdout || "Remote daemon health check failed.");
-        }
-        return;
-    }
-    const expectedCmd = paths.daemonWrapper;
-    const expectedArgs = [];
-    const existing = await client.getService(spriteName, DAEMON_SERVICE_NAME);
-    const needsCreate = !existing ||
-        existing.cmd !== expectedCmd ||
-        !isSameArgs(existing.args, expectedArgs);
-    if (needsCreate) {
-        await client.createService(spriteName, DAEMON_SERVICE_NAME, {
-            cmd: expectedCmd,
-            args: expectedArgs,
-        });
-    }
-    const current = needsCreate
-        ? await client.getService(spriteName, DAEMON_SERVICE_NAME)
-        : existing;
-    const status = current?.state?.status ?? null;
-    if (status !== "running") {
-        await client.startService(spriteName, DAEMON_SERVICE_NAME, {
-            duration: "0",
-        });
-    }
-    const refreshed = await client.getService(spriteName, DAEMON_SERVICE_NAME);
-    if (refreshed?.state?.status !== "running") {
-        throw new Error("Remote daemon service failed to start.");
-    }
-};
-const installSpriteDaemon = async ({ client, bootstrapClient, spriteName, release, convexUrl, heartbeatToken, computeProvider, onDownloadProgress, onUploadProgress, onPhase, }) => {
-    const usesRemotePackageFetch = computeProvider === "e2b";
-    const totalPhases = usesRemotePackageFetch ? 4 : 5;
-    const reportPhase = (completedPhases, detail) => {
-        onPhase?.(completedPhases, totalPhases, detail);
-    };
-    const installClient = computeProvider === "e2b" && bootstrapClient ? bootstrapClient : client;
-    const remoteHome = await resolveRemoteHomeDir(installClient, spriteName);
-    const paths = buildDaemonPaths(remoteHome);
-    const configPhase = usesRemotePackageFetch ? 1 : 2;
-    const installPhase = usesRemotePackageFetch ? 2 : 3;
-    const ensurePhase = usesRemotePackageFetch ? 3 : 4;
-    if (usesRemotePackageFetch) {
-        reportPhase(0, "fetch package");
-        await fetchDaemonBinaryOnRemote({
-            client: installClient,
-            spriteAlias: spriteName,
-            release,
-            computeProvider,
-            remoteTarballPath: paths.daemonTarball,
-            ...(onDownloadProgress ? { onProgress: onDownloadProgress } : {}),
-        });
-    }
-    else {
-        reportPhase(0, "download package");
-        const { buffer } = await fetchDaemonBinary(release, computeProvider, onDownloadProgress);
-        reportPhase(1, "upload package");
-        if (onUploadProgress) {
-            await installClient.writeFile(spriteName, paths.daemonTarball, buffer, {
-                onProgress: onUploadProgress,
-            });
-        }
-        else {
-            await installClient.writeFile(spriteName, paths.daemonTarball, buffer);
-        }
-    }
-    reportPhase(configPhase, "upload config");
-    await installClient.writeFile(spriteName, paths.daemonConfigFile, Buffer.from(buildDaemonConfig(convexUrl, heartbeatToken, computeProvider)));
-    reportPhase(installPhase, "install daemon");
-    const installLines = [
-        `mkdir -p ${paths.daemonDir}`,
-        `rm -rf ${paths.daemonBundleDir}`,
-        `mkdir -p ${paths.daemonBundleDir}`,
-        `tar -xzf ${paths.daemonTarball} -C ${paths.daemonBundleDir}`,
-        `chmod 755 ${paths.daemonEntry} || true`,
-        `chmod 755 ${paths.daemonBundleDir}/bin/* || true`,
-    ];
-    if (computeProvider === "modal" || computeProvider === "e2b") {
-        installLines.push(`managed_node_path=${shellQuote(MANAGED_DAEMON_NODE_PATH)}`);
-        if (computeProvider === "modal") {
-            installLines.push('if [ ! -x "$managed_node_path" ] && [ -x /opt/modal-devbox/converge.sh ]; then', "  /opt/modal-devbox/converge.sh --mode upgrade --force >/tmp/devbox-converge.log 2>&1 || true", "fi");
-        }
-        else {
-            installLines.push('if [ ! -x "$managed_node_path" ] && [ -x /opt/e2b-devbox/converge.sh ]; then', "  sudo -n /opt/e2b-devbox/converge.sh --mode upgrade --force >/tmp/devbox-converge.log 2>&1 || true", "fi");
-        }
-        installLines.push([
-            'if [ ! -x "$managed_node_path" ]; then',
-            '  echo "required managed daemon node missing at $managed_node_path" >&2',
-            "  if [ -f /tmp/devbox-converge.log ]; then",
-            '    echo "--- /tmp/devbox-converge.log (tail) ---" >&2',
-            "    tail -n 200 /tmp/devbox-converge.log >&2 || true",
-            "  fi",
-            "  exit 1",
-            "fi",
-        ].join("\n"), [
-            '"$managed_node_path"',
-            shellQuote(paths.daemonEntry),
-            "daemonctl install --json --timeout-ms 20000",
-            `--tarball ${shellQuote(paths.daemonTarball)}`,
-            `--release-sha ${shellQuote(release.sha256)}`,
-            `--config-path ${shellQuote(paths.daemonConfigFile)}`,
-        ].join(" "));
-    }
-    else {
-        installLines.push([
-            `${paths.daemonEntry} daemonctl install --json --timeout-ms 20000`,
-            `--tarball ${paths.daemonTarball}`,
-            `--release-sha ${release.sha256}`,
-            `--config-path ${paths.daemonConfigFile}`,
-        ].join(" "));
-    }
-    const installScript = ["set -euo pipefail", ...installLines].join("\n");
-    const result = computeProvider === "e2b"
-        ? await execWithLog(installClient, spriteName, installScript, "install-sprite-daemon", {
-            timeoutMs: 120_000,
-            handshakeTimeoutMs: BOOTSTRAP_EXEC_HANDSHAKE_TIMEOUT_MS,
-        })
-        : await client.exec(spriteName, [
-            "/bin/bash",
-            "--noprofile",
-            "--norc",
-            "-e",
-            "-u",
-            "-o",
-            "pipefail",
-            "-c",
-            installLines.join("\n"),
-        ], { timeoutMs: 120_000 });
-    if (result.exitCode !== 0) {
-        throw new Error(result.stderr || result.stdout || "Daemon install failed.");
-    }
-    reportPhase(ensurePhase, "ensure daemon service");
-    await ensureSpriteDaemonService({ client, spriteName, computeProvider });
-    reportPhase(totalPhases, "completed");
-};
-export { bootstrapDevbox, ensureSpriteDaemonService, expandHome, resolveRemoteHomeDir, shellQuote, installSpriteDaemon, ensureRemoteCodexConfig, stageRemoteSetupArtifacts, };
-//# sourceMappingURL=remote.js.map