@boxes-dev/dvb-runtime 1.0.297 → 1.0.299

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

@@ -1,1058 +0,0 @@
-import path from "node:path";
-import os from "node:os";
-import { cancel as clackCancel, confirm as clackConfirm, isCancel, } from "@clack/prompts";
-import { resolveSocketInfo } from "@boxes-dev/core";
-import { createSecretStore, loadConfig, resolveCodexAuthMode, normalizeGitRemoteUrl, resolveRemoteRelayBaseUrl, resolveRelayBaseUrl, resolveDevboxProjectDir, SpritesApiError, slugify, } from "@boxes-dev/core";
-import { DAEMON_TIMEOUT_MS, ensureDaemonRunning, requestJson, requireDaemonFeatures, } from "../../daemonClient.js";
-import { ensureSpritesToken } from "../../auth.js";
-import { ensureModalDaemonInstalled, fetchManagedDaemonConnectInfo, fetchResolvedModalCredentials, fetchSpriteDaemonRelease, getConvexUrl, isManagedDaemonNotReadyError, issueSpriteDaemonToken, markE2bDaemonBootstrapFailed, markE2bDaemonBootstrapReady, upsertModalDevboxLifecycle, } from "../../controlPlane.js";
-import { logger } from "../../logger.js";
-import { parseInitArgs } from "./args.js";
-import { getErrorCode, isRetryableInitError } from "./retryableErrors.js";
-import { runInitStatusFlow } from "./statusFlow.js";
-import { acquireInitSessionLock, createCodexCheckpointRecorder, createInitStateUpdater, extractInitCheckpointId, prepareInitSessionState, } from "./session.js";
-import { findRepoRoot, ensureRepoProjectId, readRepoOrigin } from "./repo.js";
-import { bootstrapDevbox, ensureSpriteDaemonService, expandHome, installSpriteDaemon, resolveRemoteHomeDir, shellQuote, } from "./remote.js";
-import { readRepoMarker, removeRepoMarker, writeRepoMarker, } from "./registry.js";
-import { hasCompletedManagedInitSetup, hasInitRemoteState, readInitState, writeInitState, } from "./state.js";
-import { ensureKnownHostsFile, ensureLocalSshKey, ensureRemoteSshAccess, ensureSshdService, readLocalSshPublicKey, } from "../sshAccess.js";
-import { ensureRemoteCodexInstalled } from "./codex/index.js";
-import { runInitStep } from "./progress.js";
-import { runSetupPlanFlow } from "./setupPlanFlow.js";
-import { hasResumeRemoteRepoState, reconcileResumeRemoteRepoState, runProvisionFlow, } from "./provisionFlow.js";
-import { runFinalizeFlow } from "./finalizeFlow.js";
-import { runE2bProviderInitPhases, resolveInitProviderClient, runModalProviderInitPhases, runSpritesProviderInitPhases, } from "./provider/index.js";
-import { createE2bInitRuntimeClient } from "./provider/e2bRuntime.js";
-import { resolveModalSandboxTimeoutMs, } from "../provider/modalLifecycle.js";
-const requireDaemonJsonOk = (response, label) => {
-    if (response.status >= 200 && response.status < 300) {
-        return response.body;
-    }
-    const parseError = response.parseError
-        ? ` (invalid json: ${response.parseError})`
-        : "";
-    const raw = typeof response.rawBody === "string" && response.rawBody.trim().length > 0
-        ? response.rawBody.trim()
-        : "";
-    const snippet = raw ? raw.slice(0, 500) : "";
-    throw new Error(`${label} failed: daemon returned ${response.status}${parseError}${snippet ? `: ${snippet}` : ""}`);
-};
-const resolveInitStatus = (steps, complete) => {
-    if (complete || hasCompletedManagedInitSetup(steps))
-        return "complete";
-    if (steps?.setupUploaded && steps?.workdirProvisioned) {
-        return "remote_ready";
-    }
-    return "local_required";
-};
-const mergeLocalPaths = (existing, repoRoot) => {
-    const merged = new Set(existing ?? []);
-    merged.add(repoRoot);
-    return [...merged];
-};
-const buildRemoteInitPaths = (workdir, remoteHome) => {
-    const expandedWorkdir = expandHome(workdir, remoteHome);
-    return {
-        remoteHome,
-        expandedWorkdir,
-        remoteSetupPath: path.posix.join(expandedWorkdir, ".devbox", "setup.json"),
-        remoteArtifactsBundlePath: path.posix.join(expandedWorkdir, ".devbox", "setup-artifacts.tgz"),
-        remoteArtifactsManifestPath: path.posix.join(expandedWorkdir, ".devbox", "setup-artifacts.json"),
-        remoteArtifactsPartsDescriptorPath: path.posix.join(expandedWorkdir, ".devbox", "setup-artifacts.parts.json"),
-    };
-};
-const shouldRetryManagedInitCompletionValidation = (error) => isRetryableInitError(error) ||
-    (isManagedDaemonNotReadyError(error) && error.state === "pending");
-const DEFAULT_INIT_STEP_RETRIES = 3;
-const ALIAS_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const RESERVED_ALIAS_PATTERN = /^dvb-[a-f0-9]{12}-/;
-const DEFAULT_COMPUTE_PROVIDER = "e2b";
-const delay = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const normalizeAlias = (value) => value.trim().toLowerCase();
-export const resolveComputeProvider = ({ requested, checkpoint, registry, marker, shouldResume, allowCheckpointOverride, }) => {
-    if (requested &&
-        checkpoint &&
-        requested !== checkpoint &&
-        !allowCheckpointOverride) {
-        throw new Error(`Init checkpoint compute provider is "${checkpoint}", but --compute was "${requested}". Re-run with \`--compute ${checkpoint}\` or \`dvb init --force --compute ${requested}\`.`);
-    }
-    if (shouldResume && checkpoint && registry && checkpoint !== registry) {
-        throw new Error(`Init checkpoint compute provider is "${checkpoint}", but registry compute provider is "${registry}". Re-run with \`dvb init --force --compute ${registry}\` to reset state.`);
-    }
-    return (requested ?? checkpoint ?? registry ?? marker ?? DEFAULT_COMPUTE_PROVIDER);
-};
-const validateAlias = (alias) => {
-    if (!alias) {
-        throw new Error("Alias is required.");
-    }
-    if (RESERVED_ALIAS_PATTERN.test(alias)) {
-        throw new Error(`Alias "${alias}" is reserved. Choose an alias that does not start with dvb-<12 hex>-.`);
-    }
-    if (!ALIAS_PATTERN.test(alias)) {
-        throw new Error(`Invalid alias "${alias}". Use lowercase letters, numbers, and dashes.`);
-    }
-};
-const computeRetryDelayMs = (retryIndex) => {
-    // retryIndex is 1-based (1..N)
-    const base = 500;
-    const cap = 5000;
-    const exp = Math.min(cap, base * 2 ** Math.max(0, retryIndex - 1));
-    const jitter = Math.floor(Math.random() * 150);
-    return exp + jitter;
-};
-const retryInitStep = async ({ status, title, retries = DEFAULT_INIT_STEP_RETRIES, shouldRetry = isRetryableInitError, fn, }) => {
-    let lastError = null;
-    const maxRetries = Math.max(0, Math.floor(retries));
-    const attempts = maxRetries + 1;
-    for (let attempt = 1; attempt <= attempts; attempt += 1) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            lastError = error;
-            const retryIndex = attempt; // 1-based retry count for the next attempt
-            if (retryIndex > maxRetries || !shouldRetry(error)) {
-                throw error;
-            }
-            status.stage(`${title} (retry ${retryIndex}/${maxRetries})`);
-            logger.warn("init_step_retry", {
-                title,
-                retry: retryIndex,
-                retries: maxRetries,
-                errorName: error instanceof Error ? error.name : undefined,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                errorCode: getErrorCode(error),
-                ...(error instanceof SpritesApiError ? { status: error.status } : {}),
-            });
-            await delay(computeRetryDelayMs(retryIndex));
-        }
-    }
-    throw lastError instanceof Error
-        ? lastError
-        : new Error(`Init step failed: ${title}`);
-};
-const throwInitCanceled = () => {
-    clackCancel("Init canceled.");
-    throw new Error("Init canceled.");
-};
-const confirmDestroyExistingDevbox = async ({ existingEntry, parsed, }) => {
-    if (parsed.yes)
-        return true;
-    if (!process.stdin.isTTY || parsed.json) {
-        throw new Error(`Repo already initialized (box: ${existingEntry.canonical}). Re-run with --force --yes to destroy and recreate.`);
-    }
-    const displayAlias = existingEntry.alias?.trim() || existingEntry.canonical;
-    const prompt = {
-        message: `Devbox "${displayAlias}" already exists. Destroy it and continue init?`,
-        active: "Destroy and continue",
-        inactive: "Abort init",
-        initialValue: false,
-    };
-    const confirmedDestroy = await clackConfirm(prompt);
-    if (isCancel(confirmedDestroy)) {
-        throwInitCanceled();
-    }
-    if (!confirmedDestroy) {
-        throw new Error("Init canceled.");
-    }
-    return true;
-};
-export const runInit = async (args) => {
-    const parsed = parseInitArgs(args);
-    const progressEnabled = process.stdout.isTTY && !parsed.json;
-    const run = async () => {
-        const detected = await runInitStep({
-            enabled: progressEnabled,
-            title: "Detecting repository",
-            fn: async () => {
-                const cwd = process.cwd();
-                const repoRoot = await findRepoRoot(cwd);
-                const repoName = path.basename(repoRoot);
-                const slug = slugify(repoName);
-                const localHomeDir = process.env.HOME ?? os.homedir();
-                // Recoverability contract:
-                // - Every init step must be idempotent and/or checkpointed in init-state.json.
-                // - `complete` must only be true when the setup is actually usable without
-                //   additional `dvb init --resume` work.
-                // See: apps/cli/docs/INIT_RECOVERABILITY.md
-                const projectId = await ensureRepoProjectId(repoRoot);
-                const projectDir = resolveDevboxProjectDir(projectId, localHomeDir);
-                const repoMarker = await readRepoMarker(projectDir);
-                const origin = await readRepoOrigin(repoRoot);
-                const normalizedOrigin = origin ? normalizeGitRemoteUrl(origin) : null;
-                const fingerprint = projectId;
-                let initState = await readInitState(projectDir);
-                const initFingerprintMismatch = Boolean(initState?.fingerprint) &&
-                    initState?.fingerprint !== fingerprint;
-                if (!initFingerprintMismatch &&
-                    initState?.complete &&
-                    !hasCompletedManagedInitSetup(initState.steps)) {
-                    // Older versions could mark init "complete" before both remote Codex
-                    // setup and post-setup validation had finished. Treat this as
-                    // incomplete so `dvb init --resume` can recover.
-                    initState = { ...initState, complete: false };
-                    await writeInitState(projectDir, initState);
-                }
-                if (!initFingerprintMismatch &&
-                    initState?.complete &&
-                    hasCompletedManagedInitSetup(initState.steps) &&
-                    !initState.checkpoints?.postCodexSetup?.id) {
-                    // Prior behavior could finish setup before creating the post-setup
-                    // snapshot, then mark init complete on resume. Keep init resumable
-                    // until the post-setup snapshot is recorded.
-                    initState = { ...initState, complete: false };
-                    await writeInitState(projectDir, initState);
-                }
-                return {
-                    repoRoot,
-                    repoName,
-                    slug,
-                    localHomeDir,
-                    projectId,
-                    projectDir,
-                    repoMarker,
-                    origin,
-                    normalizedOrigin,
-                    fingerprint,
-                    initState,
-                    initFingerprintMismatch,
-                };
-            },
-        });
-        const { repoRoot, repoName, slug, localHomeDir, projectId, projectDir, repoMarker, origin, normalizedOrigin, fingerprint, } = detected;
-        let initState = detected.initState;
-        const initFingerprintMismatch = detected.initFingerprintMismatch;
-        if (await runInitStatusFlow({
-            parsed,
-            repoRoot,
-            origin,
-            normalizedOrigin,
-            projectId,
-            projectDir,
-            fingerprint,
-            repoMarker,
-            initState,
-            initFingerprintMismatch,
-            requireDaemonJsonOk,
-            resolveInitStatus,
-        })) {
-            return;
-        }
-        const initSessionLock = await acquireInitSessionLock(projectDir);
-        try {
-            const preparedSession = await prepareInitSessionState({
-                parsed,
-                requestedComputeProvider: parsed.compute,
-                initState,
-                initFingerprintMismatch,
-                projectDir,
-                fingerprint,
-            });
-            initState = preparedSession.initState;
-            const { shouldResume, nonInteractive, skipCodexCliEnsure } = preparedSession;
-            const getInitState = () => initState;
-            const { updateInitState } = createInitStateUpdater({
-                fingerprint,
-                projectDir,
-                getInitState,
-                setInitState: (next) => {
-                    initState = next;
-                },
-            });
-            const recordCodexCheckpoint = createCodexCheckpointRecorder({
-                repoName,
-                fingerprint,
-                getInitState,
-                updateInitState,
-                extractCheckpointId: extractInitCheckpointId,
-                onCheckpointIdMissing: ({ canonical, phaseLabel }) => {
-                    logger.warn("init_checkpoint_id_missing", {
-                        box: canonical,
-                        fingerprint,
-                        phase: phaseLabel,
-                    });
-                },
-                onCheckpointMetaUpdateFailed: ({ canonical, phaseLabel, error }) => {
-                    logger.warn("init_checkpoint_meta_update_failed", {
-                        box: canonical,
-                        fingerprint,
-                        phase: phaseLabel,
-                        error,
-                    });
-                },
-            });
-            const socketInfo = resolveSocketInfo();
-            await runInitStep({
-                enabled: progressEnabled,
-                title: "Starting dvbd",
-                fn: async () => {
-                    await ensureDaemonRunning(socketInfo.socketPath);
-                    await requireDaemonFeatures(socketInfo.socketPath, ["registry"]);
-                },
-            });
-            let existingEntry = await runInitStep({
-                enabled: progressEnabled,
-                title: "Checking devboxes",
-                fn: async () => {
-                    const existingProject = await requestJson(socketInfo.socketPath, "GET", `/registry/project?fingerprint=${encodeURIComponent(fingerprint)}`, DAEMON_TIMEOUT_MS.registry);
-                    return (requireDaemonJsonOk(existingProject, "Checking devboxes (/registry/project)").project ?? null);
-                },
-            });
-            if (existingEntry && !parsed.force) {
-                if (shouldResume) {
-                    const pendingAlias = normalizeAlias(initState?.alias ?? "");
-                    const existingAlias = normalizeAlias(existingEntry.alias ?? "");
-                    if (pendingAlias && existingAlias && existingAlias !== pendingAlias) {
-                        throw new Error(`Repo already initialized (alias: ${existingAlias}) and does not match pending init (alias: ${pendingAlias}).`);
-                    }
-                }
-                else {
-                    await confirmDestroyExistingDevbox({
-                        existingEntry,
-                        parsed,
-                    });
-                    parsed.force = true;
-                }
-            }
-            const computeProvider = resolveComputeProvider({
-                requested: parsed.compute,
-                checkpoint: hasInitRemoteState(initState)
-                    ? initState?.computeProvider
-                    : undefined,
-                registry: existingEntry?.computeProvider,
-                marker: repoMarker?.computeProvider,
-                shouldResume,
-                allowCheckpointOverride: parsed.force && !shouldResume,
-            });
-            const alias = normalizeAlias(parsed.alias ?? initState?.alias ?? existingEntry?.alias ?? slug);
-            validateAlias(alias);
-            const workdir = `~/${slug}`;
-            await updateInitState({ computeProvider, alias, workdir });
-            let { remoteHome, expandedWorkdir, remoteSetupPath, remoteArtifactsBundlePath, remoteArtifactsManifestPath, remoteArtifactsPartsDescriptorPath, } = buildRemoteInitPaths(workdir, computeProvider === "modal"
-                ? "/root"
-                : computeProvider === "e2b"
-                    ? "/home/boxes"
-                    : "/home/sprite");
-            const pathSetup = 'export PATH="$HOME/.local/bin:$PATH"';
-            let canonical = alias;
-            let projectCreatedAt = existingEntry?.createdAt ?? new Date().toISOString();
-            let projectLocalPaths = mergeLocalPaths(existingEntry?.localPaths, repoRoot);
-            let projectOrigin = normalizedOrigin ?? existingEntry?.origin ?? undefined;
-            const resetProjectMetadata = () => {
-                projectCreatedAt = new Date().toISOString();
-                projectLocalPaths = [repoRoot];
-                projectOrigin = normalizedOrigin ?? undefined;
-            };
-            const buildProjectEntry = (initStatus) => ({
-                fingerprint,
-                alias,
-                computeProvider,
-                providerInstanceId: canonical,
-                origin: projectOrigin,
-                createdAt: projectCreatedAt,
-                initStatus,
-                initUpdatedAt: new Date().toISOString(),
-                localPaths: projectLocalPaths,
-            });
-            const updateRegistryProjectStatus = async (initStatus) => {
-                const response = await requestJson(socketInfo.socketPath, "POST", "/registry/upsert", DAEMON_TIMEOUT_MS.registry, {
-                    project: buildProjectEntry(initStatus),
-                });
-                requireDaemonJsonOk(response, "Updating registry project (/registry/upsert)");
-            };
-            const resolveRegistryProject = async () => await runInitStep({
-                enabled: progressEnabled,
-                title: "Resolving devbox",
-                fn: async () => {
-                    const response = await requestJson(socketInfo.socketPath, "GET", `/registry/project?fingerprint=${encodeURIComponent(fingerprint)}`, DAEMON_TIMEOUT_MS.registry);
-                    return (requireDaemonJsonOk(response, "Resolving devbox (/registry/project)").project ?? null);
-                },
-            });
-            const writeLocalMetadata = async (resolvedCanonical) => await runInitStep({
-                enabled: progressEnabled,
-                title: "Writing local metadata",
-                fn: async () => {
-                    await writeRepoMarker(projectDir, {
-                        fingerprint,
-                        canonical: resolvedCanonical,
-                        alias,
-                        computeProvider,
-                    });
-                },
-            });
-            const clearLocalMetadata = async () => {
-                await removeRepoMarker(projectDir);
-            };
-            if (parsed.force && !shouldResume && !existingEntry && repoMarker) {
-                await clearLocalMetadata();
-            }
-            const modalOperationOptions = computeProvider === "modal"
-                ? await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Loading managed devbox access",
-                    fn: async ({ status }) => {
-                        status.stage("Loading devbox config");
-                        const config = await loadConfig(process.env.HOME ? { homeDir: process.env.HOME } : undefined);
-                        const store = await createSecretStore(config?.tokenStore, process.env.HOME ? { homeDir: process.env.HOME } : undefined);
-                        const { controlPlaneToken } = await ensureSpritesToken(store, (message) => status.stage(message));
-                        if (!controlPlaneToken) {
-                            throw new Error("Missing control plane session. Run `dvb setup` in a TTY first.");
-                        }
-                        status.stage("Resolving Modal credentials");
-                        const resolved = await fetchResolvedModalCredentials(controlPlaneToken);
-                        const tokenId = typeof resolved.tokenId === "string"
-                            ? resolved.tokenId.trim()
-                            : "";
-                        const tokenSecret = typeof resolved.tokenSecret === "string"
-                            ? resolved.tokenSecret.trim()
-                            : "";
-                        if ((tokenId && !tokenSecret) || (!tokenId && tokenSecret)) {
-                            throw new Error("Modal credentials are incomplete. Re-run `dvb setup --modal-auth byo --modal-token-id <id> --modal-token-secret <secret>`.");
-                        }
-                        return {
-                            credentials: {
-                                mode: "auto",
-                                controlPlaneToken,
-                                spritesToken: null,
-                                modalTokenId: tokenId || null,
-                                modalTokenSecret: tokenSecret || null,
-                                e2bApiKey: null,
-                            },
-                        };
-                    },
-                })
-                : undefined;
-            if (computeProvider === "modal") {
-                const modalResult = await runModalProviderInitPhases({
-                    parsed,
-                    shouldResume,
-                    alias,
-                    workdir,
-                    progressEnabled,
-                    getInitState,
-                    updateInitState,
-                    updateRegistryProjectStatus,
-                    resolveInitStatus,
-                    existingEntry,
-                    canonical,
-                    clearLocalMetadata,
-                    resetProjectMetadata,
-                    resolveRegistryProject,
-                    writeLocalMetadata,
-                    throwInitCanceled,
-                    ...(modalOperationOptions ? { modalOperationOptions } : {}),
-                });
-                existingEntry = modalResult.existingEntry;
-                canonical = modalResult.canonical;
-            }
-            const runtime = await runInitStep({
-                enabled: progressEnabled,
-                title: "Loading devbox config",
-                fn: async ({ status }) => {
-                    const config = await loadConfig(process.env.HOME ? { homeDir: process.env.HOME } : undefined);
-                    const store = await createSecretStore(config?.tokenStore, process.env.HOME ? { homeDir: process.env.HOME } : undefined);
-                    const relayBaseUrl = resolveRelayBaseUrl(config);
-                    const { token, controlPlaneToken } = await ensureSpritesToken(store, (message) => status.stage(message));
-                    return {
-                        config,
-                        relayBaseUrl,
-                        token,
-                        controlPlaneToken,
-                    };
-                },
-            });
-            const config = runtime.config;
-            const controlPlaneToken = runtime.controlPlaneToken;
-            const modalCredentialContext = {
-                mode: "auto",
-                controlPlaneToken: controlPlaneToken ? controlPlaneToken.trim() : null,
-                spritesToken: runtime.token ? runtime.token.trim() : null,
-                modalTokenId: modalOperationOptions?.credentials?.modalTokenId ?? null,
-                modalTokenSecret: modalOperationOptions?.credentials?.modalTokenSecret ?? null,
-                e2bApiKey: null,
-            };
-            const client = computeProvider === "modal"
-                ? (() => {
-                    const modalSandbox = initState?.modal;
-                    if (!modalSandbox?.sandboxId || !modalSandbox.appName) {
-                        throw new Error("Modal init state is missing sandbox metadata after provisioning.");
-                    }
-                    return resolveInitProviderClient({
-                        computeProvider: "modal",
-                        modal: {
-                            alias,
-                            appName: modalSandbox.appName,
-                            sandboxId: modalSandbox.sandboxId,
-                            credentials: modalCredentialContext,
-                        },
-                    });
-                })()
-                : computeProvider === "e2b"
-                    ? resolveInitProviderClient({
-                        computeProvider: "e2b",
-                        e2b: {
-                            credentials: {
-                                mode: "shared",
-                                controlPlaneToken: controlPlaneToken && controlPlaneToken.trim().length > 0
-                                    ? controlPlaneToken.trim()
-                                    : null,
-                                spritesToken: runtime.token ? runtime.token.trim() : null,
-                                modalTokenId: null,
-                                modalTokenSecret: null,
-                                e2bApiKey: null,
-                            },
-                        },
-                    })
-                    : resolveInitProviderClient({
-                        computeProvider: "sprites",
-                        sprites: {
-                            apiBaseUrl: runtime.relayBaseUrl,
-                            token: runtime.token,
-                        },
-                    });
-            if (computeProvider === "modal") {
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Registering modal lifecycle",
-                    fn: async () => {
-                        const token = (controlPlaneToken ?? "").trim();
-                        if (!token) {
-                            throw new Error("Control plane session required to register modal lifecycle.");
-                        }
-                        const modalSandbox = initState?.modal;
-                        if (!modalSandbox?.sandboxId ||
-                            !modalSandbox.appName ||
-                            !modalSandbox.appId ||
-                            !Array.isArray(modalSandbox.regions)) {
-                            throw new Error("Modal init state is missing sandbox metadata for lifecycle registration.");
-                        }
-                        await upsertModalDevboxLifecycle(token, {
-                            alias,
-                            appName: modalSandbox.appName,
-                            appId: modalSandbox.appId,
-                            sandboxId: modalSandbox.sandboxId,
-                            timeoutMs: modalSandbox.timeoutMs ?? resolveModalSandboxTimeoutMs(),
-                            memorySnapshotEnabled: modalSandbox.memorySnapshotEnabled ?? false,
-                            regions: modalSandbox.regions,
-                            ...(modalSandbox.imageTag
-                                ? { imageTag: modalSandbox.imageTag }
-                                : {}),
-                            ...(modalSandbox.platformVersion
-                                ? { runningPlatformVersion: modalSandbox.platformVersion }
-                                : {}),
-                            ...(modalSandbox.bootstrapContractVersion
-                                ? {
-                                    runningBootstrapContractVersion: modalSandbox.bootstrapContractVersion,
-                                }
-                                : {}),
-                            runningStartedAt: Date.now(),
-                        });
-                    },
-                });
-            }
-            const initCodexAuthMode = resolveCodexAuthMode(config);
-            const localInitCodexProxyOptions = initCodexAuthMode === "proxy"
-                ? {
-                    relayBaseUrl: runtime.relayBaseUrl,
-                    controlPlaneToken: (controlPlaneToken ?? "").trim(),
-                }
-                : undefined;
-            const remoteInitCodexProxyOptions = initCodexAuthMode === "proxy"
-                ? {
-                    relayBaseUrl: resolveRemoteRelayBaseUrl(config),
-                    controlPlaneToken: (controlPlaneToken ?? "").trim(),
-                }
-                : undefined;
-            if (initCodexAuthMode === "proxy" &&
-                !localInitCodexProxyOptions?.controlPlaneToken) {
-                throw new Error("Control plane session required for init Codex proxy mode.");
-            }
-            if (computeProvider === "sprites") {
-                const spritesResult = await runSpritesProviderInitPhases({
-                    parsed,
-                    shouldResume,
-                    alias,
-                    workdir,
-                    fingerprint,
-                    progressEnabled,
-                    client,
-                    getInitState,
-                    updateInitState,
-                    existingEntry,
-                    canonical,
-                    socketPath: socketInfo.socketPath,
-                    ensurePortsFeature: async () => await requireDaemonFeatures(socketInfo.socketPath, ["ports"]),
-                    clearLocalMetadata,
-                    resetProjectMetadata,
-                    throwInitCanceled,
-                });
-                existingEntry = spritesResult.existingEntry;
-                canonical = spritesResult.canonical;
-            }
-            if (computeProvider === "e2b") {
-                const e2bResult = await runE2bProviderInitPhases({
-                    parsed,
-                    shouldResume,
-                    alias,
-                    workdir,
-                    progressEnabled,
-                    client,
-                    getInitState,
-                    updateInitState,
-                    existingEntry,
-                    canonical,
-                    socketPath: socketInfo.socketPath,
-                    ensurePortsFeature: async () => await requireDaemonFeatures(socketInfo.socketPath, ["ports"]),
-                    clearLocalMetadata,
-                    resetProjectMetadata,
-                    throwInitCanceled,
-                });
-                existingEntry = e2bResult.existingEntry;
-                canonical = e2bResult.canonical;
-            }
-            if (computeProvider === "modal") {
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Installing remote daemon",
-                    fn: async ({ status, fail }) => {
-                        try {
-                            const token = (controlPlaneToken ?? "").trim();
-                            if (!token) {
-                                throw new Error("Control plane session required to install daemon.");
-                            }
-                            await retryInitStep({
-                                status,
-                                title: "Installing remote daemon",
-                                fn: async () => {
-                                    status.stage("Installing via control plane");
-                                    await ensureModalDaemonInstalled(token, alias);
-                                },
-                            });
-                            await updateInitState({ steps: { daemonInstalled: true } });
-                        }
-                        catch (error) {
-                            logger.warn("sprite_daemon_install_failed", {
-                                box: canonical,
-                                error: String(error),
-                            });
-                            fail("Installing remote daemon (failed)");
-                            throw error;
-                        }
-                    },
-                });
-            }
-            await runInitStep({
-                enabled: progressEnabled,
-                title: "Bootstrapping devbox",
-                fn: async ({ status, fail }) => {
-                    try {
-                        await retryInitStep({
-                            status,
-                            title: "Bootstrapping devbox",
-                            retries: 5,
-                            fn: async () => await bootstrapDevbox(client, alias, {
-                                onPhase: (completedPhases, totalPhases, detail) => {
-                                    status.phaseProgress({
-                                        title: "Bootstrapping devbox",
-                                        completedPhases,
-                                        totalPhases,
-                                        detail,
-                                    });
-                                },
-                            }),
-                        });
-                    }
-                    catch (error) {
-                        logger.warn("devbox_bootstrap_failed", {
-                            box: canonical,
-                            error: String(error),
-                        });
-                        fail("Bootstrapping devbox (failed)");
-                        throw error;
-                    }
-                },
-            });
-            const initialStatus = resolveInitStatus(initState?.steps, initState?.complete);
-            if (!shouldResume || !initState?.steps.registrySynced) {
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Syncing devboxes",
-                    fn: async () => {
-                        await updateRegistryProjectStatus(initialStatus);
-                        await updateInitState({
-                            canonical,
-                            alias,
-                            workdir,
-                            steps: { registrySynced: true },
-                        });
-                    },
-                });
-            }
-            if (shouldResume &&
-                computeProvider === "e2b" &&
-                !initState?.steps.daemonInstalled) {
-                try {
-                    await ensureSpriteDaemonService({
-                        client,
-                        spriteName: alias,
-                        computeProvider,
-                    });
-                    if (controlPlaneToken) {
-                        await markE2bDaemonBootstrapReady(controlPlaneToken, alias);
-                    }
-                    await updateInitState({ steps: { daemonInstalled: true } });
-                }
-                catch (error) {
-                    logger.info("sprite_daemon_resume_probe_failed", {
-                        box: canonical,
-                        error: String(error),
-                    });
-                }
-            }
-            if (computeProvider !== "modal" &&
-                (!shouldResume || !initState?.steps.daemonInstalled)) {
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Installing remote daemon",
-                    fn: async ({ status, fail }) => {
-                        try {
-                            const convexUrl = getConvexUrl();
-                            if (!controlPlaneToken) {
-                                throw new Error("Control plane session required to install daemon.");
-                            }
-                            if (!convexUrl) {
-                                throw new Error("Convex URL unavailable.");
-                            }
-                            status.stage("Resolving daemon release");
-                            const release = await fetchSpriteDaemonRelease(controlPlaneToken, computeProvider);
-                            if (!release) {
-                                throw new Error("No remote daemon release available.");
-                            }
-                            status.stage("Issuing daemon token");
-                            const heartbeatToken = await issueSpriteDaemonToken(controlPlaneToken, alias);
-                            if (!heartbeatToken) {
-                                throw new Error("Daemon token unavailable.");
-                            }
-                            await retryInitStep({
-                                status,
-                                title: "Installing remote daemon",
-                                fn: async () => {
-                                    const bootstrapClient = computeProvider === "e2b"
-                                        ? createE2bInitRuntimeClient({
-                                            controlPlaneToken,
-                                            serviceRole: "system",
-                                            transportMode: "bootstrap_only",
-                                        })
-                                        : undefined;
-                                    return await installSpriteDaemon({
-                                        client,
-                                        ...(bootstrapClient ? { bootstrapClient } : {}),
-                                        spriteName: alias,
-                                        release,
-                                        convexUrl,
-                                        heartbeatToken,
-                                        computeProvider,
-                                        onDownloadProgress: (downloadedBytes, totalBytes) => {
-                                            status.byteProgress({
-                                                title: "Installing remote daemon",
-                                                uploadedBytes: downloadedBytes,
-                                                totalBytes,
-                                                detail: computeProvider === "e2b"
-                                                    ? "fetching package"
-                                                    : "downloading package",
-                                            });
-                                        },
-                                        ...(computeProvider === "e2b"
-                                            ? {}
-                                            : {
-                                                onUploadProgress: (uploadedBytes, totalBytes) => {
-                                                    status.byteProgress({
-                                                        title: "Installing remote daemon",
-                                                        uploadedBytes,
-                                                        totalBytes,
-                                                        detail: "uploading package",
-                                                    });
-                                                },
-                                            }),
-                                        onPhase: (completedPhases, totalPhases, detail) => {
-                                            status.phaseProgress({
-                                                title: "Installing remote daemon",
-                                                completedPhases,
-                                                totalPhases,
-                                                detail,
-                                            });
-                                        },
-                                    });
-                                },
-                            });
-                            if (computeProvider === "e2b") {
-                                await markE2bDaemonBootstrapReady(controlPlaneToken, alias);
-                            }
-                            await updateInitState({ steps: { daemonInstalled: true } });
-                        }
-                        catch (error) {
-                            if (computeProvider === "e2b" && controlPlaneToken) {
-                                try {
-                                    await markE2bDaemonBootstrapFailed(controlPlaneToken, alias, error instanceof Error ? error.message : String(error));
-                                }
-                                catch (stateError) {
-                                    logger.warn("sprite_daemon_install_state_update_failed", {
-                                        box: canonical,
-                                        error: String(stateError),
-                                    });
-                                }
-                            }
-                            logger.warn("sprite_daemon_install_failed", {
-                                box: canonical,
-                                error: String(error),
-                            });
-                            fail("Installing remote daemon (failed)");
-                            throw error;
-                        }
-                    },
-                });
-            }
-            await runInitStep({
-                enabled: progressEnabled,
-                title: "Ensuring daemon service",
-                fn: async ({ status, fail }) => {
-                    try {
-                        await retryInitStep({
-                            status,
-                            title: "Ensuring daemon service",
-                            fn: async () => await ensureSpriteDaemonService({
-                                client,
-                                spriteName: alias,
-                                computeProvider,
-                            }),
-                        });
-                        await updateInitState({ steps: { daemonServiceEnsured: true } });
-                    }
-                    catch (error) {
-                        logger.warn("sprite_daemon_service_failed", {
-                            box: canonical,
-                            error: String(error),
-                        });
-                        fail("Ensuring daemon service (failed)");
-                        throw error;
-                    }
-                },
-            });
-            const skipSshdConfig = shouldResume && initState?.steps.sshdConfigured;
-            if (!skipSshdConfig) {
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "SSH access setup",
-                    fn: async ({ status, fail }) => {
-                        const totalPhases = 5;
-                        const setPhase = (completedPhases, detail) => {
-                            status.phaseProgress({
-                                title: "SSH access setup",
-                                completedPhases,
-                                totalPhases,
-                                detail,
-                            });
-                        };
-                        try {
-                            await retryInitStep({
-                                status,
-                                title: "SSH access setup",
-                                fn: async () => {
-                                    setPhase(0, "ensure ssh key");
-                                    await ensureLocalSshKey();
-                                    setPhase(1, "ensure known_hosts");
-                                    await ensureKnownHostsFile();
-                                    setPhase(2, "read ssh key");
-                                    const publicKey = await readLocalSshPublicKey();
-                                    setPhase(3, "bootstrap sshd");
-                                    await ensureRemoteSshAccess({
-                                        client,
-                                        box: alias,
-                                        publicKey,
-                                        computeProvider,
-                                    });
-                                    setPhase(4, "ensure sshd service");
-                                    await ensureSshdService(client, alias, computeProvider);
-                                    setPhase(5, "completed");
-                                },
-                            });
-                            await updateInitState({ steps: { sshdConfigured: true } });
-                        }
-                        catch (error) {
-                            logger.warn("sshd_config_failed", {
-                                box: canonical,
-                                error: String(error),
-                            });
-                            fail("SSH access setup (failed)");
-                            throw error;
-                        }
-                    },
-                });
-            }
-            if (!skipCodexCliEnsure) {
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Ensuring Codex CLI",
-                    fn: async ({ status, fail }) => {
-                        try {
-                            await retryInitStep({
-                                status,
-                                title: "Ensuring Codex CLI",
-                                fn: async () => await ensureRemoteCodexInstalled(client, alias, computeProvider),
-                            });
-                            await updateInitState({ steps: { codexCliEnsured: true } });
-                        }
-                        catch (error) {
-                            logger.warn("codex_cli_ensure_failed", {
-                                box: canonical,
-                                fingerprint,
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                            fail("Ensuring Codex CLI (failed)");
-                            throw error;
-                        }
-                    },
-                });
-            }
-            if (shouldResume && hasResumeRemoteRepoState(getInitState())) {
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Checking remote repo state",
-                    fn: async () => {
-                        const remoteWorkdirState = await reconcileResumeRemoteRepoState({
-                            client,
-                            spriteAlias: alias,
-                            expandedWorkdir,
-                            getInitState,
-                            updateInitState,
-                        });
-                        if (remoteWorkdirState === "missing") {
-                            logger.info("init_resume_remote_repo_missing", {
-                                box: canonical,
-                                workdir: expandedWorkdir,
-                            });
-                        }
-                    },
-                });
-            }
-            const { setupPath, finalApprovedPlan, setupArtifacts, skipServicesConfig, skipServicesEnable, skipSetupUpload, } = await runSetupPlanFlow({
-                projectDir,
-                repoRoot,
-                localHomeDir,
-                shouldResume,
-                nonInteractive,
-                progressEnabled,
-                parsed,
-                getInitState,
-                updateInitState,
-                ...(localInitCodexProxyOptions
-                    ? { initCodexProxyOptions: localInitCodexProxyOptions }
-                    : {}),
-                throwInitCanceled,
-            });
-            if (computeProvider === "e2b") {
-                const resolvedRemoteHome = await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Resolving remote home",
-                    fn: async ({ status }) => {
-                        status.stage("Connecting managed daemon");
-                        return await resolveRemoteHomeDir(client, alias);
-                    },
-                });
-                ({
-                    remoteHome,
-                    expandedWorkdir,
-                    remoteSetupPath,
-                    remoteArtifactsBundlePath,
-                    remoteArtifactsManifestPath,
-                    remoteArtifactsPartsDescriptorPath,
-                } = buildRemoteInitPaths(workdir, resolvedRemoteHome));
-            }
-            await runProvisionFlow({
-                client,
-                spriteAlias: alias,
-                expandedWorkdir,
-                repoRoot,
-                localHomeDir,
-                shouldResume,
-                parsed,
-                progressEnabled,
-                setupPath,
-                remoteSetupPath,
-                setupArtifacts,
-                skipSetupUpload,
-                remoteArtifactsBundlePath,
-                remoteArtifactsManifestPath,
-                remoteArtifactsPartsDescriptorPath,
-                getInitState,
-                updateInitState,
-                refreshRegistryProjectStatus: async () => await updateRegistryProjectStatus(resolveInitStatus(initState?.steps, initState?.complete)),
-            });
-            await runFinalizeFlow({
-                client,
-                canonical,
-                spriteAlias: alias,
-                alias,
-                computeProvider,
-                workdir,
-                repoRoot,
-                projectDir,
-                fingerprint,
-                projectCreatedAt,
-                ...(projectOrigin !== undefined ? { projectOrigin } : {}),
-                finalApprovedPlan,
-                shouldResume,
-                nonInteractive,
-                progressEnabled,
-                parsed,
-                skipCodexApply: Boolean(shouldResume && getInitState()?.steps.remoteCodexApplied),
-                skipServicesConfig,
-                skipServicesEnable,
-                remoteHome,
-                remoteSetupPath,
-                remoteArtifactsBundlePath,
-                remoteArtifactsManifestPath,
-                socketInfo,
-                pathSetup,
-                ...(remoteInitCodexProxyOptions
-                    ? { initCodexProxyOptions: remoteInitCodexProxyOptions }
-                    : {}),
-                throwInitCanceled,
-                getInitState,
-                updateInitState,
-                updateRegistryProjectStatus,
-                resolveInitStatus,
-                ...(computeProvider === "sprites"
-                    ? {}
-                    : {
-                        validateManagedInitCompletion: async (status) => {
-                            if (!controlPlaneToken) {
-                                throw new Error("Control plane session required to validate managed daemon.");
-                            }
-                            for (const intent of ["proxy", "shell"]) {
-                                await retryInitStep({
-                                    status,
-                                    title: "Validating managed daemon",
-                                    shouldRetry: shouldRetryManagedInitCompletionValidation,
-                                    fn: async () => {
-                                        status.stage(intent === "proxy"
-                                            ? "Checking managed daemon proxy access"
-                                            : "Checking managed daemon shell access");
-                                        await fetchManagedDaemonConnectInfo(controlPlaneToken, alias, intent, true);
-                                    },
-                                });
-                            }
-                        },
-                    }),
-                isRetryableInitError,
-                retryInitStep,
-                recordCodexCheckpoint,
-            });
-        }
-        finally {
-            await initSessionLock.release();
-        }
-    };
-    await run();
-};
-//# sourceMappingURL=index.js.map