@boxes-dev/dvb-runtime 1.0.298 → 1.0.299

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

@@ -1,1115 +0,0 @@
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import { homedir } from "node:os";
-import { cancel as clackCancel, isCancel, log as clackLog, select as clackSelect, } from "@clack/prompts";
-import { resolveSocketInfo, SpritesApiError, } from "@boxes-dev/core";
-import { requestJson, requireDaemonFeatures } from "../../../daemonClient.js";
-import { showCopyableUrl } from "../../../ui/copyableUrl.js";
-import { resolveRemoteHomeDir, shellQuote } from "../remote.js";
-import { ensureRemoteCodexInstalled, isRemoteCodexLoggedIn, openBrowser, renderRemoteApplyPrompt, runRemoteCodexExec, runRemoteCodexLogin, } from "./remote.js";
-import { buildCodexInitExecArgs } from "./execConfig.js";
-import { readSetupPlan, readSetupEnvSecretsPlan, readSetupExternalPlan, readSetupExtraArtifactsPlan, readServicesPlan, mergeExternalPlanEntries, mergeSetupScans, writeSetupPlan, writeSetupEnvSecretsSchema, writeSetupExternalSchema, writeSetupExtraArtifactsSchema, writeServicesPlan, writeServicesSchema, } from "./plan.js";
-import { promptForPlanApproval, promptForServicesApproval, runLocalShellHistoryScan, runLocalServicesScan, runLocalSetupEnvSecretsScan, runLocalSetupExternalScan, runLocalSetupExtraArtifactsScan, setupApprovalPrefaceLines, setupApprovalSectionExplainers, } from "./local.js";
-import { buildCodexProxyAuthorizationHeader, buildCodexProxyConfig, } from "./proxy.js";
-import { createSetupArtifacts, readSetupArtifactsPartsDescriptor, } from "./artifacts.js";
-import {} from "../progress.js";
-import { DEFAULT_CODEX_EXEC_MAX_ATTEMPTS, computeCodexExecRetryDelayMs, delay, } from "./retry.js";
-import { formatRetryReason } from "./scanStatus.js";
-const CODEX_REQUEST_URL_REGEX = /error sending request for url \(([^)]+)\)/i;
-const CODEX_STREAM_DISCONNECT_DETAIL_REGEX = /stream disconnected before completion:\s*([^\n\r]+)/i;
-const CODEX_SESSION_ID_REGEX = /session id:\s*([0-9a-f-]{20,})/i;
-const REMOTE_RELAY_FORBIDDEN_REGEX = /(unexpected status 403 Forbidden|403 Forbidden: forbidden)/i;
-const REMOTE_RELAY_MISSING_OPENAI_CONFIG_REGEX = /unexpected status 503 Service Unavailable/i;
-const REMOTE_CODEX_AUTH_STRONG_SUBSTRINGS = [
-    "refresh_token_reused",
-    "provided authentication token is expired",
-    "your refresh token has already been used",
-    "your access token could not be refreshed",
-    "no codex auth is configured",
-    "please run `codex login`",
-    "please run codex login",
-    "not_logged_in",
-    "not logged in",
-];
-const REMOTE_CODEX_AUTH_AMBIGUOUS_SUBSTRINGS = [
-    "chatgpt account id not available",
-    "chatgpt token not available",
-    "oauth authorization required",
-    "chatgpt authentication required",
-    "codex account authentication required",
-    "no refresh token available",
-    "missing bearer or basic authentication in header",
-];
-const REMOTE_CODEX_STALE_RESUME_SUBSTRINGS = [
-    "no rollout found for thread id",
-];
-const CODEX_APPLY_ARTIFACT_GRACE_MS = 10_000;
-const CODEX_APPLY_ARTIFACT_POLL_INTERVAL_MS = 1_000;
-const extractRequestUrl = (value) => {
-    const match = value.match(CODEX_REQUEST_URL_REGEX);
-    const url = match?.[1]?.trim();
-    return url && url.length > 0 ? url : null;
-};
-const extractStreamDisconnectDetail = (value) => {
-    const match = value.match(CODEX_STREAM_DISCONNECT_DETAIL_REGEX);
-    const detail = match?.[1]?.trim();
-    return detail && detail.length > 0 ? detail : null;
-};
-const extractCodexSessionId = (value) => {
-    const match = value.match(CODEX_SESSION_ID_REGEX);
-    const sessionId = match?.[1]?.trim();
-    return sessionId && sessionId.length > 0 ? sessionId : null;
-};
-const stripAnsi = (value) => value.replace(/\u001b\[[0-9;]*[A-Za-z]/g, "");
-const splitNonEmptyOutputLines = (value) => stripAnsi(value)
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0);
-const summarizeCodexOutputDetail = (value) => {
-    const lines = splitNonEmptyOutputLines(value);
-    if (lines.length === 0)
-        return null;
-    const summary = lines.slice(-3).join(" | ");
-    if (summary.length <= 500)
-        return summary;
-    return `${summary.slice(0, 500)}...`;
-};
-const summarizeCodexFailureDetail = ({ combinedOutputRaw, lastMessageReadError, sessionId, }) => {
-    const parts = [];
-    const resolvedSessionId = sessionId ?? extractCodexSessionId(combinedOutputRaw);
-    if (resolvedSessionId) {
-        parts.push(`session id: ${resolvedSessionId}`);
-    }
-    const outputDetail = summarizeCodexOutputDetail(combinedOutputRaw);
-    if (outputDetail) {
-        parts.push(`output: ${outputDetail}`);
-    }
-    const readErrorDetail = lastMessageReadError?.message.trim();
-    if (readErrorDetail) {
-        parts.push(`file read: ${readErrorDetail}`);
-    }
-    if (parts.length === 0)
-        return null;
-    return parts.join(" | ");
-};
-const isRelayForbidden = (value) => REMOTE_RELAY_FORBIDDEN_REGEX.test(value) && /\/v1\/responses/i.test(value);
-const isRelayMissingOpenAiProxyConfiguration = (value) => REMOTE_RELAY_MISSING_OPENAI_CONFIG_REGEX.test(value) &&
-    /missing OpenAI proxy configuration/i.test(value) &&
-    /\/v1\/responses/i.test(value);
-const isResponsesRequestUrl = (requestUrl) => {
-    try {
-        return new URL(requestUrl).pathname === "/v1/responses";
-    }
-    catch {
-        return /\/v1\/responses(?:[/?#)\s]|$)/i.test(requestUrl);
-    }
-};
-const lineLooksLikeRemoteCodexAuthFailure = (line) => {
-    const normalized = line.toLowerCase();
-    if (REMOTE_CODEX_AUTH_STRONG_SUBSTRINGS.some((substring) => normalized.includes(substring)) ||
-        REMOTE_CODEX_AUTH_AMBIGUOUS_SUBSTRINGS.some((substring) => normalized.includes(substring))) {
-        return true;
-    }
-    if (!normalized.includes("401 unauthorized")) {
-        return false;
-    }
-    const requestUrl = extractRequestUrl(line);
-    if (requestUrl && isResponsesRequestUrl(requestUrl)) {
-        return true;
-    }
-    return /\/v1\/responses(?:[/?#)\s]|$)/i.test(line);
-};
-const isRemoteCodexAuthFailure = (value) => splitNonEmptyOutputLines(value).some(lineLooksLikeRemoteCodexAuthFailure);
-const formatCodexRetryProgress = ({ attempt, maxAttempts, delayMs, sessionId, reason, }) => {
-    const nextAttempt = attempt + 1;
-    const delaySeconds = Math.max(1, Math.ceil(delayMs / 1000));
-    const mode = sessionId
-        ? "continuing existing session"
-        : "starting a fresh session";
-    return `retry ${nextAttempt}/${maxAttempts} in ${delaySeconds}s (${mode}): ${formatRetryReason(reason)}`;
-};
-const isRemoteCodexStaleResumeFailure = (value) => splitNonEmptyOutputLines(value).some((line) => {
-    const normalized = line.toLowerCase();
-    return REMOTE_CODEX_STALE_RESUME_SUBSTRINGS.some((substring) => normalized.includes(substring));
-});
-const classifyRemoteCodexSetupFailure = ({ execResult, lastMessageReadError, }) => {
-    const combinedOutputRaw = `${execResult.stdout}\n${execResult.stderr}`;
-    const combinedOutput = combinedOutputRaw.toLowerCase();
-    const sessionId = execResult.threadId ?? extractCodexSessionId(combinedOutputRaw);
-    // Remote Codex output includes stderr from tools the setup task runs inside
-    // the Codex session. Generic 401s from those tools are not Codex auth errors.
-    if (isRemoteCodexAuthFailure(combinedOutputRaw)) {
-        return {
-            error: new Error("codex exec failed: remote Codex auth returned 401 unauthorized. Re-run `dvb setup --codex-auth byo` (or ensure proxy auth is configured), then retry with `dvb init --resume`."),
-            retryable: false,
-            sessionId,
-        };
-    }
-    if (isRelayForbidden(combinedOutputRaw)) {
-        return {
-            error: new Error("codex exec failed: relay proxy returned 403 forbidden. Run `dvb setup --codex-auth byo` and retry with `dvb init --resume`."),
-            retryable: false,
-            sessionId,
-        };
-    }
-    if (isRelayMissingOpenAiProxyConfiguration(combinedOutputRaw)) {
-        return {
-            error: new Error("codex exec failed: relay proxy is missing OPENAI_API_KEY configuration. Re-run `just dev` so the relay tunnel deploy includes OPENAI_API_KEY, then retry with `dvb init --resume`."),
-            retryable: false,
-            sessionId,
-        };
-    }
-    if (isRemoteCodexStaleResumeFailure(combinedOutputRaw)) {
-        const detail = summarizeCodexFailureDetail({
-            combinedOutputRaw,
-            ...(lastMessageReadError ? { lastMessageReadError } : {}),
-            sessionId,
-        });
-        const detailSuffix = detail ? ` Detail: ${detail}` : "";
-        return {
-            error: new Error(`codex exec failed: stored remote setup thread no longer exists. Retrying with a fresh Codex session.${detailSuffix}`),
-            retryable: true,
-            sessionId: null,
-            resetResumeState: true,
-        };
-    }
-    if (execResult.exitCode === null) {
-        const detail = summarizeCodexFailureDetail({
-            combinedOutputRaw,
-            sessionId,
-        });
-        const detailSuffix = detail ? ` Detail: ${detail}` : "";
-        return {
-            error: new Error(`codex exec failed: remote exec stream closed before exit status.${detailSuffix}`),
-            retryable: true,
-            sessionId,
-        };
-    }
-    if (combinedOutput.includes("stream disconnected before completion")) {
-        const requestUrl = extractRequestUrl(combinedOutputRaw);
-        const detail = extractStreamDisconnectDetail(combinedOutputRaw) ??
-            summarizeCodexOutputDetail(combinedOutputRaw);
-        const detailSuffix = detail ? ` Detail: ${detail}` : "";
-        if (requestUrl && isLoopbackRelayUrl(requestUrl)) {
-            return {
-                error: new Error(`codex exec failed: local relay is unreachable at ${requestUrl}. Set a reachable remote relay URL (for example \`DEVBOX_REMOTE_RELAY_BASE_URL=https://relay.boxes.dev\`), run \`dvb setup\`, then retry with \`dvb init --resume\`.${detailSuffix}`),
-                retryable: false,
-                sessionId,
-            };
-        }
-        const requestTarget = requestUrl ?? "relay /v1/responses endpoint";
-        return {
-            error: new Error(`codex exec failed: proxy stream disconnected before completion while calling ${requestTarget}. Ensure relay connectivity from the remote devbox, then retry with \`dvb init --resume\`.${detailSuffix}`),
-            retryable: true,
-            sessionId,
-        };
-    }
-    if (combinedOutput.includes("no last agent message")) {
-        const detail = summarizeCodexFailureDetail({
-            combinedOutputRaw,
-            sessionId,
-        });
-        const detailSuffix = detail ? ` Detail: ${detail}` : "";
-        return {
-            error: new Error(`codex exec failed: Codex session ended without a final response.${detailSuffix} Setup was not applied; retry with \`dvb init --resume\`.`),
-            retryable: true,
-            sessionId,
-        };
-    }
-    if (execResult.exitCode !== 0) {
-        const detail = summarizeCodexFailureDetail({
-            combinedOutputRaw,
-            sessionId,
-            ...(lastMessageReadError ? { lastMessageReadError } : {}),
-        });
-        const detailSuffix = detail ? ` Detail: ${detail}` : "";
-        return {
-            error: new Error(`codex exec failed (exit ${String(execResult.exitCode)})${detailSuffix}`),
-            retryable: false,
-            sessionId,
-        };
-    }
-    if (lastMessageReadError) {
-        const detail = summarizeCodexFailureDetail({
-            combinedOutputRaw,
-            lastMessageReadError,
-            sessionId,
-        });
-        const detailSuffix = detail ? ` Detail: ${detail}` : "";
-        return {
-            error: new Error(`codex exec failed: Codex session ended without writing the final response file.${detailSuffix} Setup may be incomplete; retry with \`dvb init --resume\`.`),
-            retryable: true,
-            sessionId,
-        };
-    }
-    const detail = summarizeCodexFailureDetail({
-        combinedOutputRaw,
-        sessionId,
-    });
-    const detailSuffix = detail ? ` Detail: ${detail}` : "";
-    return {
-        error: new Error(`codex exec failed: Codex session ended without a final response.${detailSuffix} Setup was not applied; retry with \`dvb init --resume\`.`),
-        retryable: true,
-        sessionId,
-    };
-};
-const isLoopbackRelayUrl = (requestUrl) => {
-    try {
-        const url = new URL(requestUrl);
-        return (url.hostname === "127.0.0.1" ||
-            url.hostname === "localhost" ||
-            url.hostname === "::1");
-    }
-    catch {
-        return false;
-    }
-};
-const resolveLocalCodexAuthPathCandidates = () => {
-    const configured = (process.env.CODEX_HOME ?? "").trim();
-    if (configured) {
-        return [path.join(configured, "auth.json")];
-    }
-    return [path.join(homedir(), ".codex", "auth.json")];
-};
-const readLocalCodexAuthCache = async () => {
-    for (const authPath of resolveLocalCodexAuthPathCandidates()) {
-        try {
-            return await fs.readFile(authPath);
-        }
-        catch {
-            // try next candidate
-        }
-    }
-    return null;
-};
-const ensureLocalCodexAuthForByoInit = async () => {
-    if (await readLocalCodexAuthCache()) {
-        return;
-    }
-    throw new Error("Local Codex auth is required when `dvb setup --codex-auth byo` is active. Run `codex login` locally or switch back to `dvb setup --codex-auth proxy`, then retry with `dvb init --resume`.");
-};
-const readRemoteUtf8FileIfExists = async ({ client, spriteAlias, path, workingDir, }) => {
-    try {
-        const bytes = await client.readFile(spriteAlias, {
-            path,
-            ...(workingDir ? { workingDir } : {}),
-        });
-        return Buffer.from(bytes).toString("utf8");
-    }
-    catch (error) {
-        if (error instanceof SpritesApiError && error.status === 404) {
-            return null;
-        }
-        throw error;
-    }
-};
-const trimRemoteTextValue = (value) => {
-    if (value === null)
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-};
-const readRemoteSetupTodoSummary = async ({ client, spriteAlias, workdir, path, }) => {
-    const summary = (await readRemoteUtf8FileIfExists({
-        client,
-        spriteAlias,
-        path: path ?? ".devbox/setup.todo",
-        ...(!path || !path.startsWith("/") ? { workingDir: workdir } : {}),
-    })) ?? null;
-    return trimRemoteTextValue(summary);
-};
-const readRemoteCodexLastMessage = async ({ client, spriteAlias, path, }) => {
-    const value = (await readRemoteUtf8FileIfExists({
-        client,
-        spriteAlias,
-        path,
-    })) ?? null;
-    return trimRemoteTextValue(value);
-};
-const resolveRemoteCodexCompletionMessage = ({ lastMessage, setupTodoSummary, }) => lastMessage ?? setupTodoSummary;
-const readRemoteCodexCompletionArtifacts = async ({ client, spriteAlias, workdir, lastMessagePath, setupTodoPath, }) => {
-    const [setupTodoRaw, lastMessage] = await Promise.all([
-        readRemoteUtf8FileIfExists({
-            client,
-            spriteAlias,
-            path: setupTodoPath,
-            ...(!setupTodoPath.startsWith("/") ? { workingDir: workdir } : {}),
-        }),
-        readRemoteCodexLastMessage({
-            client,
-            spriteAlias,
-            path: lastMessagePath,
-        }),
-    ]);
-    const setupTodoSummary = trimRemoteTextValue(setupTodoRaw);
-    return {
-        lastMessagePath,
-        setupTodoPath,
-        lastMessage,
-        setupTodoRaw,
-        setupTodoSummary,
-        completionMessage: resolveRemoteCodexCompletionMessage({
-            lastMessage,
-            setupTodoSummary,
-        }),
-    };
-};
-const waitForRemoteCodexCompletionArtifacts = async ({ client, spriteAlias, workdir, lastMessagePath, setupTodoPath, graceMs = CODEX_APPLY_ARTIFACT_GRACE_MS, pollIntervalMs = CODEX_APPLY_ARTIFACT_POLL_INTERVAL_MS, }) => {
-    const deadline = Date.now() + Math.max(0, graceMs);
-    let artifacts = await readRemoteCodexCompletionArtifacts({
-        client,
-        spriteAlias,
-        workdir,
-        lastMessagePath,
-        setupTodoPath,
-    });
-    while (!artifacts.completionMessage && Date.now() < deadline) {
-        const remainingMs = deadline - Date.now();
-        await delay(Math.min(Math.max(1, pollIntervalMs), remainingMs));
-        artifacts = await readRemoteCodexCompletionArtifacts({
-            client,
-            spriteAlias,
-            workdir,
-            lastMessagePath,
-            setupTodoPath,
-        });
-    }
-    return artifacts;
-};
-const hasRemoteExecSession = async ({ client, spriteAlias, execSessionId, }) => {
-    const targetSessionId = execSessionId.trim();
-    if (!targetSessionId) {
-        return false;
-    }
-    const sessions = await client.listExecSessions(spriteAlias);
-    return sessions.some((session) => session.id === targetSessionId);
-};
-const writeCanonicalSetupTodo = async ({ client, spriteAlias, canonicalSetupTodoPath, setupTodoRaw, completionMessage, }) => {
-    const canonicalContent = setupTodoRaw ?? `${completionMessage}\n`;
-    await client.writeFile(spriteAlias, canonicalSetupTodoPath, Buffer.from(canonicalContent.endsWith("\n")
-        ? canonicalContent
-        : `${canonicalContent}\n`, "utf8"));
-};
-const syncLocalCodexAuthCacheToSprite = async ({ client, spriteAlias, status, }) => {
-    const authBytes = await readLocalCodexAuthCache();
-    if (!authBytes)
-        return false;
-    status.stage("Syncing Codex auth cache");
-    const remoteHome = await resolveRemoteHomeDir(client, spriteAlias).catch(() => null);
-    if (!remoteHome)
-        return false;
-    const remoteCodexDir = `${remoteHome}/.codex`;
-    const remoteAuthPath = `${remoteCodexDir}/auth.json`;
-    const ensureDir = await client.exec(spriteAlias, [
-        "/bin/bash",
-        "--noprofile",
-        "--norc",
-        "-e",
-        "-u",
-        "-o",
-        "pipefail",
-        "-c",
-        [
-            "set -euo pipefail",
-            `mkdir -p ${shellQuote(remoteCodexDir)}`,
-            `chmod 700 ${shellQuote(remoteCodexDir)}`,
-        ].join("\n"),
-    ]);
-    if (ensureDir.exitCode !== 0) {
-        return false;
-    }
-    try {
-        await client.writeFile(spriteAlias, remoteAuthPath, authBytes);
-    }
-    catch {
-        return false;
-    }
-    const chmodAuth = await client.exec(spriteAlias, [
-        "/bin/bash",
-        "--noprofile",
-        "--norc",
-        "-e",
-        "-u",
-        "-o",
-        "pipefail",
-        "-c",
-        `chmod 600 ${shellQuote(remoteAuthPath)}`,
-    ]);
-    if (chmodAuth.exitCode !== 0) {
-        // Best-effort: the presence of the file is what our login check uses.
-    }
-    return true;
-};
-const defaultRemoteCodexLoginDeps = {
-    syncLocalCodexAuthCacheToSprite,
-    isRemoteCodexLoggedIn,
-    requireDaemonFeatures,
-    runRemoteCodexLogin,
-    requestJson,
-    showCopyableUrl,
-    selectOpenInBrowser: clackSelect,
-    isCancelSelection: isCancel,
-    cancelInit: clackCancel,
-    openBrowser,
-    log: clackLog,
-};
-const ensureRemoteCodexLoginForByoSetup = async ({ client, spriteAlias, expandedWorkdir, socketInfo, status, pathSetup, interactiveLoginAllowed = true, deps = defaultRemoteCodexLoginDeps, }) => {
-    await deps.syncLocalCodexAuthCacheToSprite({
-        client,
-        spriteAlias,
-        status,
-    });
-    status.stage("Check Codex login");
-    const loggedIn = await deps.isRemoteCodexLoggedIn(client, spriteAlias);
-    if (loggedIn) {
-        return;
-    }
-    if (!interactiveLoginAllowed) {
-        throw new Error("Codex login requires an interactive TTY. Re-run `dvb init --resume` without `--json`, or switch to `dvb setup --codex-auth proxy` so init can authenticate non-interactively.");
-    }
-    await deps.requireDaemonFeatures(socketInfo.socketPath, ["ports"]);
-    status.stage("Waiting for Codex login");
-    let openedUrl = false;
-    let forwarded = false;
-    let portReloadError = null;
-    await deps.runRemoteCodexLogin({
-        client,
-        spriteAlias,
-        cmd: [
-            "/bin/bash",
-            "--noprofile",
-            "--norc",
-            "-e",
-            "-u",
-            "-o",
-            "pipefail",
-            "-c",
-            `${pathSetup}\ncd ${shellQuote(expandedWorkdir)}\ncodex login`,
-        ],
-        tty: true,
-        onUrl: async (url) => {
-            if (openedUrl)
-                return;
-            openedUrl = true;
-            status.stop();
-            deps.showCopyableUrl(url, "Codex login URL");
-            const action = await deps.selectOpenInBrowser({
-                message: "Open the Codex login URL in your browser?",
-                options: [
-                    { value: "open", label: "Open in browser" },
-                    { value: "skip", label: "Skip" },
-                ],
-                initialValue: "open",
-            });
-            if (deps.isCancelSelection(action)) {
-                deps.cancelInit("Init canceled.");
-                throw new Error("Init canceled.");
-            }
-            if (action === "open") {
-                const opened = await deps.openBrowser(url);
-                if (opened) {
-                    deps.log.success("Opened browser for Codex login.");
-                }
-                else {
-                    deps.log.warn("Unable to open the browser automatically.");
-                    deps.log.info("Open the URL above to log in to Codex.");
-                }
-            }
-            else {
-                deps.log.warn([
-                    "Skipping browser open.",
-                    "You must open the URL above to log in to Codex before setup can proceed.",
-                    "If you exit, re-run `dvb init --resume` from this repo.",
-                ].join(" "));
-            }
-            status.stage("Waiting for Codex login");
-        },
-        onLocalPort: async () => {
-            if (forwarded)
-                return;
-            forwarded = true;
-            try {
-                const reload = await deps.requestJson(socketInfo.socketPath, "POST", "/ports/reload", 5000, { box: spriteAlias });
-                if (reload.status < 200 || reload.status >= 300) {
-                    throw new Error("Failed to refresh port forwarding for Codex login.");
-                }
-            }
-            catch (error) {
-                portReloadError =
-                    error instanceof Error ? error : new Error(String(error));
-            }
-        },
-    });
-    if (!openedUrl) {
-        throw new Error("Codex login did not emit a login URL.");
-    }
-    if (portReloadError) {
-        throw portReloadError;
-    }
-    status.stage("Check Codex login");
-    const loggedInAfter = await deps.isRemoteCodexLoggedIn(client, spriteAlias);
-    if (!loggedInAfter) {
-        throw new Error([
-            "Codex login did not complete.",
-            "Open the login URL above and then re-run `dvb init --resume` from this repo.",
-        ].join(" "));
-    }
-};
-const uploadSetupPlan = async ({ client, spriteAlias, localSetupPath, remoteSetupPath, localArtifactsBundlePath, localArtifactsManifestPath, localArtifactsPartsDescriptorPath, remoteArtifactsBundlePath, remoteArtifactsManifestPath, remoteArtifactsPartsDescriptorPath, status, }) => {
-    status.stage("Preparing setup files");
-    const setupDirResult = await client.exec(spriteAlias, [
-        "/bin/bash",
-        "--noprofile",
-        "--norc",
-        "-e",
-        "-u",
-        "-o",
-        "pipefail",
-        "-c",
-        `mkdir -p ${shellQuote(path.posix.dirname(remoteSetupPath))}`,
-    ]);
-    if (setupDirResult.exitCode !== 0) {
-        throw new Error(setupDirResult.stderr || "Failed to prepare setup directory");
-    }
-    let splitArtifacts = null;
-    const uploadItems = [
-        {
-            label: "setup plan",
-            localPath: localSetupPath,
-            remotePath: remoteSetupPath,
-        },
-    ];
-    if (localArtifactsBundlePath &&
-        localArtifactsManifestPath &&
-        remoteArtifactsBundlePath &&
-        remoteArtifactsManifestPath) {
-        if (localArtifactsPartsDescriptorPath &&
-            remoteArtifactsPartsDescriptorPath) {
-            const descriptor = await readSetupArtifactsPartsDescriptor(localArtifactsPartsDescriptorPath);
-            const descriptorDir = path.dirname(localArtifactsPartsDescriptorPath);
-            const remoteBundleDir = path.posix.dirname(remoteArtifactsBundlePath);
-            const parts = [];
-            for (const part of descriptor.parts) {
-                const localPartPath = path.resolve(descriptorDir, part.relativePath);
-                const stat = await fs.stat(localPartPath);
-                if (stat.size !== part.sizeBytes) {
-                    throw new Error(`Setup artifact part size mismatch: ${localPartPath} (expected ${part.sizeBytes}, got ${stat.size})`);
-                }
-                parts.push({
-                    index: part.index,
-                    localPath: localPartPath,
-                    remotePath: path.posix.join(remoteBundleDir, path.posix.basename(part.relativePath)),
-                    sizeBytes: part.sizeBytes,
-                    sha256: part.sha256,
-                });
-            }
-            parts.sort((a, b) => a.index - b.index);
-            splitArtifacts = {
-                descriptorPath: localArtifactsPartsDescriptorPath,
-                remoteDescriptorPath: remoteArtifactsPartsDescriptorPath,
-                expectedBundleSize: descriptor.totalSizeBytes,
-                expectedBundleSha: descriptor.bundleSha256,
-                parts,
-            };
-            status.stage("Prep split artifact upload");
-            const cleanupScript = [
-                "set -euo pipefail",
-                `bundle=${shellQuote(remoteArtifactsBundlePath)}`,
-                `descriptor=${shellQuote(remoteArtifactsPartsDescriptorPath)}`,
-                'bundle_dir="$(dirname "$bundle")"',
-                'bundle_base="$(basename "$bundle")"',
-                'rm -f "$bundle" "$descriptor" "$descriptor".tmp-upload-*',
-                'rm -f "$bundle_dir/$bundle_base.part-"*',
-                'rm -f "$bundle_dir/$bundle_base.part-"*.tmp-upload-*',
-                'rm -f "$bundle_dir/$bundle_base.tmp-assemble-"*',
-            ].join("\n");
-            const cleanupResult = await client.exec(spriteAlias, [
-                "/bin/bash",
-                "--noprofile",
-                "--norc",
-                "-e",
-                "-u",
-                "-o",
-                "pipefail",
-                "-c",
-                cleanupScript,
-            ]);
-            if (cleanupResult.exitCode !== 0) {
-                throw new Error(cleanupResult.stderr ||
-                    cleanupResult.stdout ||
-                    "Failed to clean stale split setup artifact uploads");
-            }
-            uploadItems.push({
-                label: `artifacts manifest (${path.basename(localArtifactsManifestPath)})`,
-                localPath: localArtifactsManifestPath,
-                remotePath: remoteArtifactsManifestPath,
-            }, {
-                label: `artifacts parts (${path.basename(localArtifactsPartsDescriptorPath)})`,
-                localPath: localArtifactsPartsDescriptorPath,
-                remotePath: remoteArtifactsPartsDescriptorPath,
-            });
-            for (const part of parts) {
-                uploadItems.push({
-                    label: `artifacts part ${part.index + 1}/${parts.length}`,
-                    localPath: part.localPath,
-                    remotePath: part.remotePath,
-                });
-            }
-        }
-        else {
-            uploadItems.push({
-                label: "artifacts bundle",
-                localPath: localArtifactsBundlePath,
-                remotePath: remoteArtifactsBundlePath,
-            }, {
-                label: `artifacts manifest (${path.basename(localArtifactsManifestPath)})`,
-                localPath: localArtifactsManifestPath,
-                remotePath: remoteArtifactsManifestPath,
-            });
-        }
-    }
-    const plannedUploads = await Promise.all(uploadItems.map(async (item) => {
-        const stats = await fs.stat(item.localPath);
-        return { ...item, size: stats.size };
-    }));
-    const totalBytes = plannedUploads.reduce((sum, item) => sum + item.size, 0);
-    let uploadedBytes = 0;
-    const updateProgress = (currentFileBytes, detail) => status.byteProgress({
-        title: "Uploading setup plan",
-        uploadedBytes: uploadedBytes + currentFileBytes,
-        totalBytes,
-        detail,
-    });
-    for (const [index, upload] of plannedUploads.entries()) {
-        const detail = `${upload.label} (${index + 1}/${plannedUploads.length})`;
-        const fileData = await fs.readFile(upload.localPath);
-        updateProgress(0, detail);
-        await client.writeFile(spriteAlias, upload.remotePath, fileData, {
-            onProgress: (fileUploadedBytes, fileTotalBytes) => {
-                const bounded = Math.min(fileUploadedBytes, Math.max(fileData.length, fileTotalBytes));
-                updateProgress(bounded, detail);
-            },
-        });
-        uploadedBytes += fileData.length;
-        updateProgress(fileData.length, detail);
-    }
-    if (splitArtifacts && remoteArtifactsBundlePath) {
-        status.stage("Assembling artifacts on remote");
-        const assembledTmpPath = `${remoteArtifactsBundlePath}.tmp-assemble-${randomUUID()}`;
-        const assembleScript = [
-            "set -euo pipefail",
-            `bundle=${shellQuote(remoteArtifactsBundlePath)}`,
-            `descriptor=${shellQuote(splitArtifacts.remoteDescriptorPath)}`,
-            `assembled_tmp=${shellQuote(assembledTmpPath)}`,
-            `expected_bundle_size=${splitArtifacts.expectedBundleSize}`,
-            `expected_bundle_sha=${shellQuote(splitArtifacts.expectedBundleSha)}`,
-            "hash_file() {",
-            "  if command -v sha256sum >/dev/null 2>&1; then",
-            "    sha256sum \"$1\" | awk '{print $1}'",
-            "    return 0",
-            "  fi",
-            "  if command -v shasum >/dev/null 2>&1; then",
-            "    shasum -a 256 \"$1\" | awk '{print $1}'",
-            "    return 0",
-            "  fi",
-            '  echo "No SHA256 tool available (sha256sum/shasum)." >&2',
-            "  return 1",
-            "}",
-            'cleanup() { rm -f "$assembled_tmp"; }',
-            "trap cleanup EXIT",
-            ': > "$assembled_tmp"',
-            ...splitArtifacts.parts.flatMap((part) => [
-                `part_path=${shellQuote(part.remotePath)}`,
-                `part_expected_size=${part.sizeBytes}`,
-                `part_expected_sha=${shellQuote(part.sha256)}`,
-                '[ -f "$part_path" ] || { echo "Missing setup artifact part: $part_path" >&2; exit 1; }',
-                'part_size="$(wc -c < "$part_path" | tr -d \'[:space:]\')"',
-                'if [ "$part_size" != "$part_expected_size" ]; then echo "Part size mismatch for $part_path: expected $part_expected_size got $part_size" >&2; exit 1; fi',
-                'part_sha="$(hash_file "$part_path")"',
-                'if [ "$part_sha" != "$part_expected_sha" ]; then echo "Part checksum mismatch for $part_path" >&2; exit 1; fi',
-                'cat "$part_path" >> "$assembled_tmp"',
-            ]),
-            'assembled_size="$(wc -c < "$assembled_tmp" | tr -d \'[:space:]\')"',
-            'if [ "$assembled_size" != "$expected_bundle_size" ]; then echo "Assembled bundle size mismatch: expected $expected_bundle_size got $assembled_size" >&2; exit 1; fi',
-            'assembled_sha="$(hash_file "$assembled_tmp")"',
-            'if [ "$assembled_sha" != "$expected_bundle_sha" ]; then echo "Assembled bundle checksum mismatch" >&2; exit 1; fi',
-            'mv "$assembled_tmp" "$bundle"',
-            'rm -f "$descriptor"',
-            ...splitArtifacts.parts.map((part) => `rm -f ${shellQuote(part.remotePath)}`),
-            "trap - EXIT",
-        ].join("\n");
-        const assembleResult = await client.exec(spriteAlias, [
-            "/bin/bash",
-            "--noprofile",
-            "--norc",
-            "-e",
-            "-u",
-            "-o",
-            "pipefail",
-            "-c",
-            assembleScript,
-        ]);
-        if (assembleResult.exitCode !== 0) {
-            throw new Error(assembleResult.stderr ||
-                assembleResult.stdout ||
-                "Failed to assemble split setup artifacts on remote");
-        }
-    }
-    status.byteProgress({
-        title: "Uploading setup plan",
-        uploadedBytes: totalBytes,
-        totalBytes,
-        detail: "completed",
-    });
-};
-const runRemoteCodexSetup = async ({ client, spriteAlias, computeProvider, expandedWorkdir, remoteSetupPath, remoteArtifactsBundlePath, remoteArtifactsManifestPath, socketInfo, status, pathSetup, entrypoints, proxyOptions, resumeState = null, onResumeStateChange, interactiveLoginAllowed = true, emitCodexOutput = true, remoteExecOptions, completionArtifactsGraceMs = CODEX_APPLY_ARTIFACT_GRACE_MS, completionArtifactsPollIntervalMs = CODEX_APPLY_ARTIFACT_POLL_INTERVAL_MS, }) => {
-    if (!proxyOptions) {
-        // Always prefer local Codex auth in BYO mode so remote setup uses the same
-        // credential state as the user's local machine.
-        await ensureRemoteCodexLoginForByoSetup({
-            client,
-            spriteAlias,
-            expandedWorkdir,
-            socketInfo,
-            status,
-            pathSetup,
-            interactiveLoginAllowed,
-        });
-    }
-    status.stage("Apply setup plan");
-    const remoteHome = await resolveRemoteHomeDir(client, spriteAlias);
-    const proxyRoot = proxyOptions
-        ? `${remoteHome}/.devbox/tmp/codex-proxy-${randomUUID()}`
-        : null;
-    const proxyTokenPath = proxyRoot ? `${proxyRoot}/devbox-token` : null;
-    const proxyCodexHome = proxyRoot ? `${proxyRoot}/codex-home` : null;
-    const proxyConfigPath = proxyCodexHome
-        ? `${proxyCodexHome}/config.toml`
-        : null;
-    const canonicalSetupTodoPath = path.posix.join(expandedWorkdir, ".devbox", "setup.todo");
-    if (proxyOptions && proxyRoot && proxyTokenPath && proxyConfigPath) {
-        status.stage("Preparing Codex proxy");
-        const codexHomePath = proxyCodexHome ?? `${proxyRoot}/codex-home`;
-        try {
-            const prepResult = await client.exec(spriteAlias, [
-                "/bin/bash",
-                "--noprofile",
-                "--norc",
-                "-e",
-                "-u",
-                "-o",
-                "pipefail",
-                "-c",
-                [
-                    "set -euo pipefail",
-                    `mkdir -p ${shellQuote(codexHomePath)}`,
-                    `chmod 700 ${shellQuote(proxyRoot)} ${shellQuote(codexHomePath)}`,
-                ].join("\n"),
-            ]);
-            if (prepResult.exitCode !== 0) {
-                throw new Error(prepResult.stderr ||
-                    prepResult.stdout ||
-                    "Failed to prepare Codex proxy context");
-            }
-            const proxyAuthHeader = buildCodexProxyAuthorizationHeader(proxyOptions.controlPlaneToken);
-            const proxyConfig = buildCodexProxyConfig({
-                relayBaseUrl: proxyOptions.relayBaseUrl,
-                trustedPaths: [expandedWorkdir, remoteHome],
-            });
-            await client.writeFile(spriteAlias, proxyTokenPath, Buffer.from(proxyAuthHeader, "utf8"));
-            await client.writeFile(spriteAlias, proxyConfigPath, Buffer.from(proxyConfig, "utf8"));
-            const chmodResult = await client.exec(spriteAlias, [
-                "/bin/bash",
-                "--noprofile",
-                "--norc",
-                "-e",
-                "-u",
-                "-o",
-                "pipefail",
-                "-c",
-                [
-                    "set -euo pipefail",
-                    `chmod 600 ${shellQuote(proxyTokenPath)} ${shellQuote(proxyConfigPath)}`,
-                ].join("\n"),
-            ]);
-            if (chmodResult.exitCode !== 0) {
-                throw new Error(chmodResult.stderr ||
-                    chmodResult.stdout ||
-                    "Failed to secure Codex proxy context");
-            }
-        }
-        catch (error) {
-            await client
-                .exec(spriteAlias, [
-                "/bin/bash",
-                "--noprofile",
-                "--norc",
-                "-e",
-                "-u",
-                "-o",
-                "pipefail",
-                "-c",
-                `rm -rf ${shellQuote(proxyRoot)}`,
-            ])
-                .catch(() => { });
-            throw error;
-        }
-    }
-    const buildRemoteCodexExecArgs = ({ prompt, lastMessagePath, resumeThreadId, }) => resumeThreadId
-        ? [
-            ...buildCodexInitExecArgs(),
-            "resume",
-            "--dangerously-bypass-approvals-and-sandbox",
-            "--json",
-            "--output-last-message",
-            lastMessagePath,
-            resumeThreadId,
-            prompt,
-        ]
-        : [
-            ...buildCodexInitExecArgs(),
-            "--dangerously-bypass-approvals-and-sandbox",
-            "--json",
-            "--output-last-message",
-            lastMessagePath,
-            prompt,
-        ];
-    const buildRemoteCodexCommand = ({ prompt, lastMessagePath, setupTodoPath, resumeThreadId, clearArtifacts, }) => [
-        "set -euo pipefail",
-        `output_path=${shellQuote(lastMessagePath)}`,
-        `summary_path=${shellQuote(setupTodoPath)}`,
-        `mkdir -p ${shellQuote(path.posix.dirname(lastMessagePath))}`,
-        `mkdir -p ${shellQuote(path.posix.dirname(setupTodoPath))}`,
-        ...(clearArtifacts ? ['rm -f "$output_path" "$summary_path"'] : []),
-        pathSetup,
-        ...(proxyRoot && proxyTokenPath && proxyCodexHome
-            ? [
-                `proxy_root=${shellQuote(proxyRoot)}`,
-                `proxy_token=${shellQuote(proxyTokenPath)}`,
-                'export DEVBOX_TOKEN="$(cat "$proxy_token")"',
-                `export CODEX_HOME=${shellQuote(proxyCodexHome)}`,
-            ]
-            : []),
-        `cd ${shellQuote(expandedWorkdir)}`,
-        `codex exec ${buildRemoteCodexExecArgs({
-            prompt,
-            lastMessagePath,
-            resumeThreadId,
-        })
-            .map((arg) => shellQuote(arg))
-            .join(" ")}`,
-    ].join("\n");
-    let lastMessage = "";
-    let activeThreadId = resumeState?.threadId ?? null;
-    let activeExecSessionId = resumeState?.execSessionId ?? null;
-    let activeRunRoot = resumeState?.runRoot ?? null;
-    let activeLastMessagePath = resumeState?.lastMessagePath ?? null;
-    let activeSetupTodoPath = resumeState?.setupTodoPath ?? null;
-    try {
-        for (let attempt = 1; attempt <= DEFAULT_CODEX_EXEC_MAX_ATTEMPTS; attempt += 1) {
-            const existingExecSessionAvailable = activeExecSessionId
-                ? await hasRemoteExecSession({
-                    client,
-                    spriteAlias,
-                    execSessionId: activeExecSessionId,
-                })
-                : false;
-            if (activeExecSessionId && !existingExecSessionAvailable) {
-                activeExecSessionId = null;
-                if (!activeThreadId) {
-                    activeRunRoot = null;
-                    activeLastMessagePath = null;
-                    activeSetupTodoPath = null;
-                    await onResumeStateChange?.(null);
-                }
-                else if (onResumeStateChange &&
-                    activeRunRoot &&
-                    activeLastMessagePath &&
-                    activeSetupTodoPath) {
-                    await onResumeStateChange({
-                        threadId: activeThreadId,
-                        execSessionId: null,
-                        runRoot: activeRunRoot,
-                        lastMessagePath: activeLastMessagePath,
-                        setupTodoPath: activeSetupTodoPath,
-                    });
-                }
-            }
-            const reusingSessionArtifacts = Boolean(activeRunRoot && activeLastMessagePath && activeSetupTodoPath);
-            const reattachingExistingExecSession = Boolean(activeExecSessionId);
-            const continuingExistingThread = Boolean(activeThreadId);
-            const attemptRunRoot = reusingSessionArtifacts && activeRunRoot
-                ? activeRunRoot
-                : `${remoteHome}/.devbox/tmp/codex-apply-${randomUUID()}`;
-            const attemptLastMessagePath = reusingSessionArtifacts && activeLastMessagePath
-                ? activeLastMessagePath
-                : `${attemptRunRoot}/codex-setup-output.txt`;
-            const attemptSetupTodoPath = reusingSessionArtifacts && activeSetupTodoPath
-                ? activeSetupTodoPath
-                : `${attemptRunRoot}/setup.todo`;
-            activeRunRoot = attemptRunRoot;
-            activeLastMessagePath = attemptLastMessagePath;
-            activeSetupTodoPath = attemptSetupTodoPath;
-            const prompt = reattachingExistingExecSession
-                ? null
-                : continuingExistingThread
-                    ? "continue"
-                    : await renderRemoteApplyPrompt({
-                        setupPath: remoteSetupPath,
-                        artifactsBundle: remoteArtifactsBundlePath,
-                        artifactsManifest: remoteArtifactsManifestPath,
-                        entrypoints,
-                        computeProvider,
-                        setupTodoPath: attemptSetupTodoPath,
-                    });
-            const remoteCodexCommand = prompt === null
-                ? null
-                : buildRemoteCodexCommand({
-                    prompt,
-                    lastMessagePath: attemptLastMessagePath,
-                    setupTodoPath: attemptSetupTodoPath,
-                    resumeThreadId: activeThreadId,
-                    clearArtifacts: !reusingSessionArtifacts,
-                });
-            status.stage("Apply setup plan");
-            const execResult = await runRemoteCodexExec({
-                client,
-                spriteAlias,
-                ...(activeExecSessionId ? { execSessionId: activeExecSessionId } : {}),
-                cmd: remoteCodexCommand === null
-                    ? []
-                    : [
-                        "/bin/bash",
-                        "--noprofile",
-                        "--norc",
-                        "-e",
-                        "-u",
-                        "-o",
-                        "pipefail",
-                        "-c",
-                        remoteCodexCommand,
-                    ],
-                onProgress: (update) => {
-                    status.stage(`Apply setup plan - ${update.message}`);
-                },
-                onStateChange: async (state) => {
-                    activeThreadId = state.threadId ?? activeThreadId;
-                    activeExecSessionId = state.execSessionId ?? activeExecSessionId;
-                    if (onResumeStateChange &&
-                        activeRunRoot &&
-                        activeLastMessagePath &&
-                        activeSetupTodoPath &&
-                        (activeThreadId || activeExecSessionId)) {
-                        await onResumeStateChange({
-                            threadId: activeThreadId,
-                            execSessionId: activeExecSessionId,
-                            runRoot: activeRunRoot,
-                            lastMessagePath: activeLastMessagePath,
-                            setupTodoPath: activeSetupTodoPath,
-                        });
-                    }
-                },
-                ...(remoteExecOptions ?? {}),
-            });
-            activeThreadId = execResult.threadId ?? activeThreadId;
-            activeExecSessionId = execResult.execSessionId ?? activeExecSessionId;
-            if (onResumeStateChange &&
-                activeRunRoot &&
-                activeLastMessagePath &&
-                activeSetupTodoPath &&
-                (activeThreadId || activeExecSessionId)) {
-                await onResumeStateChange({
-                    threadId: activeThreadId,
-                    execSessionId: activeExecSessionId,
-                    runRoot: activeRunRoot,
-                    lastMessagePath: activeLastMessagePath,
-                    setupTodoPath: activeSetupTodoPath,
-                });
-            }
-            const completionArtifacts = execResult.exitCode === 0 || execResult.exitCode === null
-                ? await waitForRemoteCodexCompletionArtifacts({
-                    client,
-                    spriteAlias,
-                    workdir: expandedWorkdir,
-                    lastMessagePath: attemptLastMessagePath,
-                    setupTodoPath: attemptSetupTodoPath,
-                    graceMs: completionArtifactsGraceMs,
-                    pollIntervalMs: completionArtifactsPollIntervalMs,
-                })
-                : null;
-            if (completionArtifacts?.completionMessage) {
-                await writeCanonicalSetupTodo({
-                    client,
-                    spriteAlias,
-                    canonicalSetupTodoPath,
-                    setupTodoRaw: completionArtifacts.setupTodoRaw,
-                    completionMessage: completionArtifacts.completionMessage,
-                });
-                lastMessage = completionArtifacts.completionMessage;
-                break;
-            }
-            const lastMessageReadError = completionArtifacts && completionArtifacts.lastMessage === null
-                ? new Error(`Remote Codex output file missing: ${completionArtifacts.lastMessagePath}`)
-                : null;
-            const failure = classifyRemoteCodexSetupFailure({
-                execResult,
-                ...(lastMessageReadError ? { lastMessageReadError } : {}),
-            });
-            if (!failure.retryable || attempt >= DEFAULT_CODEX_EXEC_MAX_ATTEMPTS) {
-                throw failure.error;
-            }
-            if (failure.resetResumeState) {
-                activeThreadId = null;
-                activeExecSessionId = null;
-                activeRunRoot = null;
-                activeLastMessagePath = null;
-                activeSetupTodoPath = null;
-                await onResumeStateChange?.(null);
-            }
-            else {
-                activeThreadId = failure.sessionId ?? activeThreadId;
-                if (!activeThreadId && !activeExecSessionId) {
-                    activeRunRoot = null;
-                    activeLastMessagePath = null;
-                    activeSetupTodoPath = null;
-                }
-            }
-            const delayMs = computeCodexExecRetryDelayMs(attempt);
-            status.stage(`Apply setup plan - ${formatCodexRetryProgress({
-                attempt,
-                maxAttempts: DEFAULT_CODEX_EXEC_MAX_ATTEMPTS,
-                delayMs,
-                sessionId: activeThreadId ?? activeExecSessionId,
-                reason: failure.error.message,
-            })}`);
-            await delay(delayMs);
-        }
-    }
-    finally {
-        if (proxyRoot) {
-            await client
-                .exec(spriteAlias, [
-                "/bin/bash",
-                "--noprofile",
-                "--norc",
-                "-e",
-                "-u",
-                "-o",
-                "pipefail",
-                "-c",
-                `rm -rf ${shellQuote(proxyRoot)}`,
-            ])
-                .catch(() => { });
-        }
-    }
-    if (!lastMessage) {
-        throw new Error("codex exec failed: remote apply exhausted retries.");
-    }
-    if (!emitCodexOutput)
-        return;
-    status.stop();
-    process.stdout.write(`${lastMessage}\n`);
-};
-export { createSetupArtifacts, promptForPlanApproval, promptForServicesApproval, readSetupPlan, readSetupEnvSecretsPlan, readSetupExternalPlan, readSetupExtraArtifactsPlan, readServicesPlan, runLocalShellHistoryScan, runLocalServicesScan, runLocalSetupEnvSecretsScan, runLocalSetupExternalScan, runLocalSetupExtraArtifactsScan, setupApprovalPrefaceLines, setupApprovalSectionExplainers, uploadSetupPlan, writeSetupPlan, mergeExternalPlanEntries, mergeSetupScans, writeSetupEnvSecretsSchema, writeSetupExternalSchema, writeSetupExtraArtifactsSchema, writeServicesPlan, writeServicesSchema, runRemoteCodexSetup, ensureRemoteCodexInstalled, isRemoteCodexLoggedIn, openBrowser, runRemoteCodexLogin, renderRemoteApplyPrompt, ensureLocalCodexAuthForByoInit, ensureRemoteCodexLoginForByoSetup, classifyRemoteCodexSetupFailure, resolveRemoteCodexCompletionMessage, waitForRemoteCodexCompletionArtifacts, readRemoteSetupTodoSummary, };
-//# sourceMappingURL=index.js.map