@boxes-dev/dvb-runtime 1.0.297 → 1.0.299

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

@@ -1,786 +0,0 @@
-import path from "node:path";
-import { confirm as clackConfirm, isCancel, log as clackLog, select as clackSelect, } from "@clack/prompts";
-import { resolveSocketInfo, SpritesApiError, } from "@boxes-dev/core";
-import { logger } from "../../logger.js";
-import { colors } from "../../ui/colors.js";
-import { showCopyableUrl, showCopyableValue } from "../../ui/copyableUrl.js";
-import { writeRepoMarker } from "./registry.js";
-import { ensureRemoteCodexConfig, expandHome, shellQuote, stageRemoteSetupArtifacts, } from "./remote.js";
-import { ensureSshConfig, ensureSshKey, copyToClipboard, openBrowser, parseGitRemote, readRemoteOrigin, setRemoteOrigin, verifySshAuth, } from "./ssh.js";
-import { runRemoteCodexSetup, } from "./codex/index.js";
-import {} from "./codex/plan.js";
-import { bootstrapRemoteClaudeConfig } from "./claudeBootstrap.js";
-import { mergeServicesToml, splitShellCommand, } from "../servicesToml.js";
-import { runInitStep } from "./progress.js";
-import { hasCompletedManagedInitSetup, hasManagedDaemonValidated, hasRemoteCodexApplied, } from "./state.js";
-const parseExecUnexpectedResponseStatus = (error) => {
-    if (!(error instanceof Error))
-        return null;
-    const match = /Unexpected server response: (\d{3})/.exec(error.message);
-    if (!match)
-        return null;
-    const status = Number(match[1]);
-    return Number.isFinite(status) ? status : null;
-};
-const isRetryableCheckpointForbiddenError = (error) => {
-    if (error instanceof SpritesApiError)
-        return error.status === 403;
-    const execStatus = parseExecUnexpectedResponseStatus(error);
-    return execStatus === 403;
-};
-const buildServicesTomlUpdates = (services) => {
-    const updates = {};
-    for (const service of services) {
-        const name = service.name.trim();
-        if (!name) {
-            throw new Error("Service name is required in setup.json services.");
-        }
-        const parts = splitShellCommand(service.command ?? "");
-        const [cmd, ...args] = parts;
-        if (!cmd) {
-            throw new Error(`Service "${name}" is missing a command.`);
-        }
-        updates[name] = {
-            name,
-            cmd,
-            ...(args.length > 0 ? { args } : {}),
-            ...(service.httpPort !== null ? { httpPort: service.httpPort } : {}),
-        };
-    }
-    return updates;
-};
-const readRemoteSetupTodo = async ({ client, spriteAlias, workdir, }) => {
-    try {
-        const bytes = await client.readFile(spriteAlias, {
-            path: ".devbox/setup.todo",
-            workingDir: workdir,
-        });
-        const summary = Buffer.from(bytes).toString("utf8").trim();
-        return summary.length > 0 ? summary : null;
-    }
-    catch (error) {
-        if (error instanceof SpritesApiError && error.status === 404) {
-            return null;
-        }
-        throw error;
-    }
-};
-const completeCodexApply = async ({ progressEnabled, validateManagedInitCompletion, updateInitState, clearResumeState, updateRegistryProjectStatus, resolveInitStatus, getInitState, }) => {
-    if (!hasRemoteCodexApplied(getInitState()?.steps)) {
-        await updateInitState({ steps: { remoteCodexApplied: true } });
-        await updateRegistryProjectStatus(resolveInitStatus(getInitState()?.steps, getInitState()?.complete));
-    }
-    if (!hasManagedDaemonValidated(getInitState()?.steps)) {
-        if (validateManagedInitCompletion) {
-            await runInitStep({
-                enabled: progressEnabled,
-                title: "Validating managed daemon",
-                fn: async ({ status }) => {
-                    status.stage("Checking managed daemon readiness");
-                    await validateManagedInitCompletion(status);
-                },
-            });
-        }
-        await updateInitState({ steps: { managedDaemonValidated: true } });
-    }
-    await clearResumeState();
-    await updateRegistryProjectStatus(resolveInitStatus(getInitState()?.steps, getInitState()?.complete));
-};
-const normalizeStoredPath = (value) => {
-    const trimmed = value?.trim();
-    return trimmed ? trimmed : null;
-};
-const getCodexSetupResumeState = (state) => {
-    const threadId = normalizeStoredPath(state?.codexSetupThreadId);
-    const execSessionId = normalizeStoredPath(state?.codexSetupExecSessionId);
-    if (!threadId && !execSessionId) {
-        return null;
-    }
-    return {
-        threadId,
-        execSessionId,
-        runRoot: normalizeStoredPath(state?.codexSetupRunRoot),
-        lastMessagePath: normalizeStoredPath(state?.codexSetupLastMessagePath),
-        setupTodoPath: normalizeStoredPath(state?.codexSetupTodoPath),
-    };
-};
-const codexSetupResumeStatesEqual = (left, right) => left?.threadId === right?.threadId &&
-    left?.execSessionId === right?.execSessionId &&
-    left?.runRoot === right?.runRoot &&
-    left?.lastMessagePath === right?.lastMessagePath &&
-    left?.setupTodoPath === right?.setupTodoPath;
-const writeRemoteServicesToml = async ({ client, spriteAlias, workdir, services, }) => {
-    if (services.length === 0)
-        return;
-    let baseContent = "";
-    try {
-        const bytes = await client.readFile(spriteAlias, {
-            path: "devbox.toml",
-            workingDir: workdir,
-        });
-        baseContent = Buffer.from(bytes).toString("utf8");
-    }
-    catch (error) {
-        if (!(error instanceof SpritesApiError && error.status === 404)) {
-            throw error;
-        }
-    }
-    const updates = buildServicesTomlUpdates(services);
-    if (Object.keys(updates).length === 0)
-        return;
-    const merged = mergeServicesToml(baseContent, updates);
-    await client.writeFile(spriteAlias, path.posix.join(workdir.replace(/\/$/, ""), "devbox.toml"), Buffer.from(merged));
-};
-const enableRemoteServices = async ({ client, spriteAlias, services, status, }) => {
-    if (services.length === 0)
-        return;
-    logger.info("init_services_enable_start", {
-        box: spriteAlias,
-        serviceCount: services.length,
-    });
-    for (const service of services) {
-        const name = service.name.trim();
-        if (!name) {
-            throw new Error("Service name is required in setup.json services.");
-        }
-        status?.stage(`Enabling service: ${name}`);
-        const parts = splitShellCommand(service.command ?? "");
-        const [cmd, ...args] = parts;
-        if (!cmd) {
-            throw new Error(`Service "${name}" is missing a command.`);
-        }
-        const input = {
-            cmd,
-            ...(args.length > 0 ? { args } : {}),
-            ...(service.httpPort !== null ? { httpPort: service.httpPort } : {}),
-        };
-        await client.createService(spriteAlias, name, input);
-    }
-    logger.info("init_services_enable_complete", { box: spriteAlias });
-};
-const promptBeforeOpenBrowser = async ({ url, title, promptMessage, consequence, throwInitCanceled, }) => {
-    if (!process.stdin.isTTY)
-        return false;
-    showCopyableUrl(url, title);
-    const message = typeof promptMessage === "string" && promptMessage.trim().length > 0
-        ? promptMessage
-        : `Open ${title} in your browser?`;
-    const choice = await clackSelect({
-        message,
-        options: [
-            { value: "open", label: "Open in browser" },
-            { value: "skip", label: "Skip" },
-        ],
-        initialValue: "open",
-    });
-    if (isCancel(choice)) {
-        throwInitCanceled();
-    }
-    if (choice === "skip") {
-        clackLog.warn(consequence);
-        return false;
-    }
-    return true;
-};
-const ensureGitSafeDirectory = async ({ client, spriteAlias, workdir, remoteHome, status, }) => {
-    status.stage("Configuring git safe dir");
-    logger.info("init_git_safe_directory_configure_start", {
-        box: spriteAlias,
-        workdir,
-    });
-    const script = [
-        "set -euo pipefail",
-        `repo=${shellQuote(workdir)}`,
-        'if [ ! -d "$repo" ]; then',
-        '  echo "Missing repo workdir: $repo" >&2',
-        "  exit 1",
-        "fi",
-        'if [ ! -d "$repo/.git" ]; then',
-        "  exit 0",
-        "fi",
-        "if ! command -v git >/dev/null 2>&1; then",
-        "  exit 0",
-        "fi",
-        "",
-        "ensure_safe_in_file() {",
-        '  cfg="$1"',
-        '  existing="$(git config --file "$cfg" --get-all safe.directory 2>/dev/null || true)"',
-        '  if printf \'%s\\n\' "$existing" | grep -Fxq "$repo"; then',
-        "    return 0",
-        "  fi",
-        '  git config --file "$cfg" --add safe.directory "$repo"',
-        "}",
-        "",
-        // Ensure the repo is trusted for the modal runtime home.
-        `ensure_safe_in_file ${shellQuote(path.posix.join(remoteHome, ".gitconfig"))}`,
-    ].join("\n");
-    const result = await client.exec(spriteAlias, [
-        "/bin/bash",
-        "--noprofile",
-        "--norc",
-        "-e",
-        "-u",
-        "-o",
-        "pipefail",
-        "-c",
-        script,
-    ]);
-    if (result.exitCode !== 0) {
-        const details = result.stderr || result.stdout || "";
-        throw new Error(details
-            ? `Failed to configure git safe.directory: ${details.trim()}`
-            : `Failed to configure git safe.directory (exit ${result.exitCode})`);
-    }
-    logger.info("init_git_safe_directory_configure_complete", {
-        box: spriteAlias,
-        workdir,
-    });
-};
-const formatCompleteInitSummaryLines = ({ alias, workdir, isTty, }) => {
-    const heading = (value) => (isTty ? colors.bold(value) : value);
-    const formattedAlias = isTty ? colors.boldWhite(alias) : alias;
-    const formattedWorkdir = isTty ? colors.gray(workdir) : workdir;
-    return [
-        `Your devbox ${formattedAlias} is set up!`,
-        `project directory on devbox: ${formattedWorkdir}`,
-        "",
-        "Connect to this devbox from the desktop app or the terminal.",
-        "",
-        heading("Desktop app"),
-        "- open the Boxes.dev desktop app",
-        "- chat with Claude or Codex",
-        "- run your app in the terminal tabs",
-        "",
-        heading("Terminal"),
-        `- run \`dvb connect ${alias}\` to get a shell on your devbox`,
-        "- run claude / codex from one tab, run your app in another tab.",
-        "",
-        "Ports are forwarded automatically when you run your app on the devbox, so you can open your app at localhost:<port> in your local browser.",
-    ];
-};
-const runFinalizeFlow = async ({ client, canonical, spriteAlias, alias, computeProvider, workdir, repoRoot, projectDir, fingerprint, projectOrigin, projectCreatedAt, finalApprovedPlan, shouldResume, nonInteractive, progressEnabled, parsed, skipCodexApply, skipServicesConfig, skipServicesEnable, remoteHome, remoteSetupPath, remoteArtifactsBundlePath, remoteArtifactsManifestPath, socketInfo, pathSetup, initCodexProxyOptions, throwInitCanceled, getInitState, updateInitState, updateRegistryProjectStatus, resolveInitStatus, validateManagedInitCompletion, isRetryableInitError, retryInitStep, recordCodexCheckpoint, }) => {
-    const expandedWorkdir = expandHome(workdir, remoteHome);
-    let remoteCodexAlreadyApplied = skipCodexApply || hasRemoteCodexApplied(getInitState()?.steps);
-    let managedValidationCompleted = hasManagedDaemonValidated(getInitState()?.steps);
-    const readCodexSetupResumeState = () => getCodexSetupResumeState(getInitState());
-    const persistCodexSetupResumeState = async (resumeState) => {
-        const current = readCodexSetupResumeState();
-        if (codexSetupResumeStatesEqual(current, resumeState)) {
-            return;
-        }
-        await updateInitState({
-            codexSetupThreadId: resumeState?.threadId ?? null,
-            codexSetupExecSessionId: resumeState?.execSessionId ?? null,
-            codexSetupRunRoot: resumeState?.runRoot ?? null,
-            codexSetupLastMessagePath: resumeState?.lastMessagePath ?? null,
-            codexSetupTodoPath: resumeState?.setupTodoPath ?? null,
-        });
-    };
-    if (remoteCodexAlreadyApplied && managedValidationCompleted) {
-        await persistCodexSetupResumeState(null);
-    }
-    const skipGitSafeDirectory = Boolean(shouldResume && getInitState()?.steps.gitSafeDirectoryConfigured);
-    if (!skipGitSafeDirectory) {
-        await runInitStep({
-            enabled: progressEnabled,
-            title: "Configuring git safe dir",
-            fn: async ({ status }) => {
-                await ensureGitSafeDirectory({
-                    client,
-                    spriteAlias,
-                    workdir: expandedWorkdir,
-                    remoteHome,
-                    status,
-                });
-                await updateInitState({
-                    steps: { gitSafeDirectoryConfigured: true },
-                });
-            },
-        });
-    }
-    const skipSshAuth = Boolean(nonInteractive || (shouldResume && getInitState()?.steps.sshAuthConfigured));
-    if (!skipSshAuth) {
-        const { remoteOrigin, remoteInfo } = await runInitStep({
-            enabled: progressEnabled,
-            title: "Checking git SSH remote",
-            fn: async () => {
-                const remoteOrigin = await readRemoteOrigin(client, spriteAlias, expandedWorkdir);
-                const remoteInfo = remoteOrigin ? parseGitRemote(remoteOrigin) : null;
-                return { remoteOrigin, remoteInfo };
-            },
-        });
-        if (!remoteOrigin) {
-            if (!parsed.json) {
-                console.warn("Warning: unable to detect remote origin on sprite. Skipping SSH setup.");
-            }
-        }
-        else if (!remoteInfo) {
-            if (!parsed.json) {
-                console.warn(`Warning: unrecognized git remote format (${remoteOrigin}). Skipping SSH setup.`);
-            }
-        }
-        else {
-            let activeOrigin = remoteOrigin;
-            if (remoteInfo.protocol === "https") {
-                if (!parsed.json) {
-                    clackLog.info(`Origin is HTTPS (${remoteOrigin}).`);
-                    clackLog.info("This only changes the remote devbox checkout (your local checkout is unchanged).");
-                    clackLog.info("Switching the remote devbox checkout to SSH automatically.");
-                    showCopyableValue(remoteInfo.sshUrl, "Git remote");
-                    clackLog.info("If you do not add the SSH key below, git pull/push on the remote will not work.");
-                }
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Switching remote git to SSH",
-                    fn: async () => {
-                        await setRemoteOrigin(client, spriteAlias, expandedWorkdir, remoteInfo.sshUrl);
-                    },
-                });
-                activeOrigin = remoteInfo.sshUrl;
-            }
-            if (activeOrigin) {
-                const publicKey = await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Generating SSH key",
-                    fn: async () => await ensureSshKey(client, spriteAlias, `${alias}@devbox`),
-                });
-                await runInitStep({
-                    enabled: progressEnabled,
-                    title: "Updating SSH config",
-                    fn: async () => await ensureSshConfig(client, spriteAlias, remoteInfo.host),
-                });
-                if (!parsed.json) {
-                    showCopyableValue(publicKey, `Add this SSH public key to ${remoteInfo.host}`);
-                    const copied = await copyToClipboard(publicKey);
-                    if (copied) {
-                        clackLog.success("Copied SSH public key to clipboard.");
-                    }
-                    else {
-                        clackLog.warn("Could not copy the SSH key automatically.");
-                    }
-                    const openBrowserPromptMessage = copied
-                        ? `SSH key copied to clipboard; click "Add SSH key". Open ${remoteInfo.host} SSH key page in your browser?`
-                        : `Open ${remoteInfo.host} SSH key page in your browser?`;
-                    const shouldOpen = await promptBeforeOpenBrowser({
-                        url: remoteInfo.settingsUrl,
-                        title: `${remoteInfo.host} SSH key page`,
-                        promptMessage: openBrowserPromptMessage,
-                        consequence: [
-                            "Skipping browser open.",
-                            "You must add the SSH key before git pull/push will work via SSH.",
-                        ].join(" "),
-                        throwInitCanceled,
-                    });
-                    if (shouldOpen) {
-                        const opened = openBrowser(remoteInfo.settingsUrl);
-                        if (!opened) {
-                            clackLog.warn("Unable to open the browser automatically.");
-                        }
-                    }
-                }
-                const added = await clackConfirm({
-                    message: "Have you added the SSH key? Remote git pull/push will not work until you do.",
-                    active: "Yes, verify now",
-                    inactive: "Not yet",
-                    initialValue: true,
-                });
-                if (isCancel(added)) {
-                    throwInitCanceled();
-                }
-                if (!added) {
-                    if (!parsed.json) {
-                        console.warn("Skipping SSH verification. Add the key and re-run `dvb init --resume` to verify.");
-                    }
-                }
-                else {
-                    const verified = await runInitStep({
-                        enabled: progressEnabled,
-                        title: "Verifying git SSH auth",
-                        fn: async () => await verifySshAuth(client, spriteAlias, remoteInfo.host, expandedWorkdir),
-                    });
-                    if (!verified) {
-                        if (!parsed.json) {
-                            console.warn("SSH auth verification failed. Confirm the key is added and that the repo access is granted.");
-                        }
-                    }
-                    else {
-                        await updateInitState({
-                            steps: { sshAuthConfigured: true },
-                        });
-                    }
-                }
-            }
-        }
-    }
-    if (!skipServicesConfig) {
-        await runInitStep({
-            enabled: progressEnabled,
-            title: "Writing services config",
-            fn: async () => {
-                await writeRemoteServicesToml({
-                    client,
-                    spriteAlias,
-                    workdir: expandedWorkdir,
-                    services: finalApprovedPlan.services.backgroundServices,
-                });
-                await updateInitState({ steps: { servicesConfigWritten: true } });
-            },
-        });
-    }
-    const projectMeta = {
-        fingerprint,
-        canonical,
-        alias,
-        computeProvider,
-        workdir,
-        origin: projectOrigin,
-        createdAt: projectCreatedAt,
-    };
-    const projectMetaPath = `${remoteHome}/.devbox/projects/${fingerprint}.json`;
-    await runInitStep({
-        enabled: progressEnabled,
-        title: "Registering project",
-        fn: async () => {
-            let existing = {};
-            try {
-                const raw = await client.readFile(spriteAlias, {
-                    path: projectMetaPath,
-                });
-                const parsed = JSON.parse(Buffer.from(raw).toString("utf8"));
-                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-                    existing = parsed;
-                }
-            }
-            catch (error) {
-                if (!(error instanceof SpritesApiError && error.status === 404)) {
-                    throw error;
-                }
-            }
-            const existingCheckpoints = existing.checkpoints &&
-                typeof existing.checkpoints === "object" &&
-                !Array.isArray(existing.checkpoints)
-                ? existing.checkpoints
-                : {};
-            const stateCheckpoints = getInitState()?.checkpoints ?? {};
-            const merged = {
-                ...existing,
-                ...projectMeta,
-                checkpoints: { ...existingCheckpoints, ...stateCheckpoints },
-            };
-            await client.writeFile(spriteAlias, projectMetaPath, Buffer.from(JSON.stringify(merged, null, 2)));
-        },
-    });
-    await runInitStep({
-        enabled: progressEnabled,
-        title: "Writing local metadata",
-        fn: async () => {
-            await writeRepoMarker(projectDir, {
-                fingerprint,
-                canonical,
-                alias,
-                computeProvider,
-            });
-        },
-    });
-    await runInitStep({
-        enabled: progressEnabled,
-        title: "Bootstrapping Claude config (opt)",
-        fn: async ({ status, ok }) => {
-            status.stage("Checking Claude config state");
-            try {
-                const result = await bootstrapRemoteClaudeConfig({
-                    client,
-                    spriteAlias,
-                    localRepoRoot: repoRoot,
-                    remoteWorkdir: expandedWorkdir,
-                    remoteHome,
-                });
-                if (result.status === "skipped_existing") {
-                    ok("Bootstrapping Claude config (opt) (already configured)");
-                    return;
-                }
-                if (result.status === "updated_existing") {
-                    ok("Bootstrapping Claude config (opt) (updated existing state)");
-                    return;
-                }
-                if (result.parseWarnings.length > 0) {
-                    logger.warn("init_claude_bootstrap_local_parse_warnings", {
-                        box: spriteAlias,
-                        warningCount: result.parseWarnings.length,
-                        warnings: result.parseWarnings,
-                    });
-                }
-                ok("Bootstrapping Claude config (opt)");
-            }
-            catch (error) {
-                logger.warn("init_claude_bootstrap_failed", {
-                    box: spriteAlias,
-                    workdir: expandedWorkdir,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                if (!parsed.json) {
-                    const message = error instanceof Error && error.message
-                        ? error.message
-                        : String(error);
-                    console.warn(`Warning: failed to bootstrap Claude config (optional). ${message}`);
-                }
-                ok("Bootstrapping Claude config (opt) (skipped)");
-            }
-        },
-    });
-    const skipCodexConfigUpdate = Boolean(shouldResume && getInitState()?.steps.codexConfigUpdated);
-    if (!skipCodexConfigUpdate) {
-        await runInitStep({
-            enabled: progressEnabled,
-            title: "Updating Codex config",
-            fn: async ({ status }) => {
-                await retryInitStep({
-                    status,
-                    title: "Updating Codex config",
-                    fn: async () => await ensureRemoteCodexConfig({
-                        client,
-                        spriteAlias,
-                        trustedPaths: [remoteHome, expandedWorkdir],
-                    }),
-                });
-            },
-        });
-        await updateInitState({ steps: { codexConfigUpdated: true } });
-    }
-    const skipSetupArtifactsStage = Boolean(skipCodexApply ||
-        (shouldResume && getInitState()?.steps.setupArtifactsStaged));
-    if (!skipSetupArtifactsStage) {
-        await runInitStep({
-            enabled: progressEnabled,
-            title: "Staging setup artifacts",
-            fn: async ({ status }) => {
-                status.stage("Staging repo + external artifacts");
-                await stageRemoteSetupArtifacts({
-                    client,
-                    spriteAlias,
-                    computeProvider,
-                    workdir: expandedWorkdir,
-                    artifactsBundlePath: remoteArtifactsBundlePath,
-                    artifactsManifestPath: remoteArtifactsManifestPath,
-                });
-            },
-        });
-        await updateInitState({ steps: { setupArtifactsStaged: true } });
-    }
-    if (!skipCodexApply) {
-        await runInitStep({
-            enabled: progressEnabled,
-            title: "Snapshot FS (pre-setup)",
-            fn: async ({ status, fail, ok }) => {
-                try {
-                    const checkpoint = await retryInitStep({
-                        status,
-                        title: "Snapshot FS (pre-setup)",
-                        shouldRetry: (error) => isRetryableInitError(error) ||
-                            isRetryableCheckpointForbiddenError(error),
-                        fn: async () => await recordCodexCheckpoint({
-                            client,
-                            canonical,
-                            spriteAlias,
-                            phase: "preCodexSetup",
-                        }),
-                    });
-                    if (checkpoint.id) {
-                        ok(`Snapshot created: ${checkpoint.id}`);
-                    }
-                }
-                catch (error) {
-                    logger.warn("init_checkpoint_create_failed", {
-                        box: canonical,
-                        fingerprint,
-                        phase: "pre-codex-setup",
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    fail("Snapshot FS (pre-setup) (failed)");
-                    throw error;
-                }
-            },
-        });
-    }
-    if (!skipServicesEnable) {
-        await runInitStep({
-            enabled: progressEnabled,
-            title: "Enabling services",
-            fn: async ({ status }) => {
-                await enableRemoteServices({
-                    client,
-                    spriteAlias,
-                    services: finalApprovedPlan.services.backgroundServices,
-                    status,
-                });
-                await updateInitState({ steps: { servicesEnabled: true } });
-            },
-        });
-    }
-    if (remoteCodexAlreadyApplied && !managedValidationCompleted) {
-        await completeCodexApply({
-            progressEnabled,
-            validateManagedInitCompletion,
-            updateInitState,
-            clearResumeState: async () => {
-                await persistCodexSetupResumeState(null);
-            },
-            updateRegistryProjectStatus,
-            resolveInitStatus,
-            getInitState,
-        });
-        remoteCodexAlreadyApplied = hasRemoteCodexApplied(getInitState()?.steps);
-        managedValidationCompleted = hasManagedDaemonValidated(getInitState()?.steps);
-    }
-    if (shouldResume &&
-        !remoteCodexAlreadyApplied &&
-        getInitState()?.steps.setupArtifactsStaged) {
-        const setupTodo = await runInitStep({
-            enabled: progressEnabled,
-            title: "Checking remote setup state",
-            fn: async () => await readRemoteSetupTodo({
-                client,
-                spriteAlias,
-                workdir: expandedWorkdir,
-            }),
-        });
-        if (setupTodo) {
-            logger.info("init_codex_resume_detected_remote_completion", {
-                box: spriteAlias,
-                workdir: expandedWorkdir,
-            });
-            await completeCodexApply({
-                progressEnabled,
-                validateManagedInitCompletion,
-                updateInitState,
-                clearResumeState: async () => {
-                    await persistCodexSetupResumeState(null);
-                },
-                updateRegistryProjectStatus,
-                resolveInitStatus,
-                getInitState,
-            });
-            remoteCodexAlreadyApplied = hasRemoteCodexApplied(getInitState()?.steps);
-            managedValidationCompleted = hasManagedDaemonValidated(getInitState()?.steps);
-        }
-    }
-    if (!remoteCodexAlreadyApplied) {
-        await runInitStep({
-            enabled: progressEnabled,
-            title: "Running Codex setup",
-            fn: async ({ status }) => {
-                await runRemoteCodexSetup({
-                    client,
-                    spriteAlias,
-                    computeProvider,
-                    expandedWorkdir,
-                    remoteSetupPath,
-                    remoteArtifactsBundlePath,
-                    remoteArtifactsManifestPath,
-                    socketInfo,
-                    status,
-                    pathSetup,
-                    entrypoints: finalApprovedPlan.services.appEntrypoints,
-                    resumeState: readCodexSetupResumeState(),
-                    onResumeStateChange: async (resumeState) => {
-                        await persistCodexSetupResumeState(resumeState);
-                    },
-                    interactiveLoginAllowed: !nonInteractive,
-                    emitCodexOutput: !parsed.json,
-                    ...(initCodexProxyOptions
-                        ? { proxyOptions: initCodexProxyOptions }
-                        : {}),
-                });
-            },
-        });
-        await completeCodexApply({
-            progressEnabled,
-            validateManagedInitCompletion,
-            updateInitState,
-            clearResumeState: async () => {
-                await persistCodexSetupResumeState(null);
-            },
-            updateRegistryProjectStatus,
-            resolveInitStatus,
-            getInitState,
-        });
-        remoteCodexAlreadyApplied = hasRemoteCodexApplied(getInitState()?.steps);
-        managedValidationCompleted = hasManagedDaemonValidated(getInitState()?.steps);
-    }
-    const needsPostSetupSnapshot = () => {
-        const state = getInitState();
-        const hasPostSnapshot = Boolean(state?.checkpoints?.postCodexSetup?.id);
-        return (!hasPostSnapshot &&
-            (!skipCodexApply || hasCompletedManagedInitSetup(state?.steps)));
-    };
-    if (needsPostSetupSnapshot()) {
-        await runInitStep({
-            enabled: progressEnabled,
-            title: "Snapshot FS (post-setup)",
-            fn: async ({ status, fail, ok }) => {
-                try {
-                    const checkpoint = await retryInitStep({
-                        status,
-                        title: "Snapshot FS (post-setup)",
-                        shouldRetry: (error) => isRetryableInitError(error) ||
-                            isRetryableCheckpointForbiddenError(error),
-                        fn: async () => await recordCodexCheckpoint({
-                            client,
-                            canonical,
-                            spriteAlias,
-                            phase: "postCodexSetup",
-                        }),
-                    });
-                    if (checkpoint.id) {
-                        ok(`Snapshot created: ${checkpoint.id}`);
-                    }
-                }
-                catch (error) {
-                    logger.warn("init_checkpoint_create_failed", {
-                        box: canonical,
-                        fingerprint,
-                        phase: "post-codex-setup",
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                    fail("Snapshot FS (post-setup) (failed)");
-                    throw error;
-                }
-            },
-        });
-    }
-    const finalStatus = resolveInitStatus(getInitState()?.steps, getInitState()?.complete);
-    const isComplete = finalStatus === "complete";
-    await runInitStep({
-        enabled: progressEnabled,
-        title: "Finalizing init",
-        fn: async () => {
-            await updateInitState({ complete: isComplete });
-            await updateRegistryProjectStatus(finalStatus);
-        },
-    });
-    if (parsed.json) {
-        console.log(JSON.stringify({
-            ok: true,
-            status: finalStatus,
-            canonical,
-            alias,
-            workdir,
-            fingerprint,
-        }, null, 2));
-        return;
-    }
-    if (!isComplete) {
-        console.log(`devbox initialized (setup incomplete): ${alias} -> ${canonical}`);
-        console.log(`workdir: ${workdir}`);
-        console.log("next: run `dvb init --resume` from this repo to finish setup");
-        console.log("sprites: synced to control plane");
-        return;
-    }
-    console.log(formatCompleteInitSummaryLines({
-        alias,
-        workdir,
-        isTty: Boolean(process.stdout.isTTY),
-    }).join("\n"));
-};
-export { completeCodexApply, enableRemoteServices, formatCompleteInitSummaryLines, readRemoteSetupTodo, runFinalizeFlow, };
-//# sourceMappingURL=finalizeFlow.js.map