@boxes-dev/dvb-runtime 1.0.298 → 1.0.299

package/dist/devbox/commands/provider/modalLifecycle.js

@@ -1,702 +0,0 @@
-import { resolveDevboxProfile, resolveModalClientCredentials, } from "@boxes-dev/core";
-import { createHash } from "node:crypto";
-import { AlreadyExistsError, ModalClient, NotFoundError } from "modal";
-import { findModalSandboxViaControlPlane, provisionModalSandboxViaControlPlane, terminateModalSandboxesByAliasViaControlPlane, } from "../../controlPlane.js";
-const DEFAULT_APP_NAME = "sandbox-modal-smoke";
-const DEFAULT_MODAL_ENVIRONMENT = "main";
-const DEFAULT_MODAL_DEVBOX_IMAGE = "public.ecr.aws/d8m4p4w9/modal-devbox:latest";
-const DEFAULT_TIMEOUT_MS = 24 * 60 * 60 * 1000;
-const IMAGE_TAG_RESOLUTION_CACHE_TTL_MS = 5 * 60 * 1000;
-const MODAL_SANDBOX_RUNNING_POLL_MS = 1_000;
-const SANDBOX_LIST_PAGE_LIMIT = 100;
-const MODAL_PID1_GUARD_PATH = "/usr/local/bin/pid1-guard";
-const MODAL_DAEMON_SUPERVISOR_PATH = "/opt/modal-devbox/modal-daemon-supervisor.sh";
-const MODAL_PLATFORM_VERSION_PATH = "/etc/modal-devbox/platform-version";
-const MODAL_BOOTSTRAP_CONTRACT_VERSION_PATH = "/etc/modal-devbox/bootstrap-contract-version";
-const CURRENT_MODAL_BOOTSTRAP_CONTRACT_VERSION = "2";
-const FINISHED_STATUS_LABELS = {
-    1: "success",
-    2: "failure",
-    3: "terminated",
-    4: "timeout",
-    5: "init_failure",
-    6: "internal_failure",
-    7: "idle_timeout",
-};
-const REGISTRY_MANIFEST_ACCEPT_HEADER = [
-    "application/vnd.oci.image.index.v1+json",
-    "application/vnd.oci.image.manifest.v1+json",
-    "application/vnd.docker.distribution.manifest.list.v2+json",
-    "application/vnd.docker.distribution.manifest.v2+json",
-].join(", ");
-const resolvedImageTagCache = new Map();
-const shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
-const MODAL_DAEMON_SUPERVISOR_ENTRYPOINT = [
-    MODAL_PID1_GUARD_PATH,
-    MODAL_DAEMON_SUPERVISOR_PATH,
-];
-const trimEnv = (value) => value?.trim() ?? "";
-const EMBEDDED_BUILD_PROFILE = resolveDevboxProfile();
-const resolveModalEnvironmentName = () => {
-    // Production `dvb` builds are pinned to `main` regardless of runtime env.
-    if (!EMBEDDED_BUILD_PROFILE) {
-        return DEFAULT_MODAL_ENVIRONMENT;
-    }
-    return trimEnv(process.env.MODAL_ENVIRONMENT) || "dev";
-};
-const resolveConvexInstanceSeed = () => {
-    const candidates = [
-        trimEnv(process.env.DEVBOX_CONVEX_URL),
-        trimEnv(process.env.CONVEX_CLOUD_URL),
-        trimEnv(process.env.CONVEX_SITE_URL),
-    ].filter((value) => value.length > 0);
-    const raw = candidates[0];
-    if (!raw) {
-        return null;
-    }
-    let normalized = raw;
-    if (normalized.startsWith("dev:")) {
-        normalized = normalized.slice(4);
-    }
-    if (normalized.includes(".convex.site")) {
-        normalized = normalized.replace(".convex.site", ".convex.cloud");
-    }
-    if (!normalized.startsWith("http://") && !normalized.startsWith("https://")) {
-        normalized = `https://${normalized}`;
-    }
-    try {
-        return new URL(normalized).host.toLowerCase();
-    }
-    catch {
-        return normalized.toLowerCase();
-    }
-};
-const resolveDevModalSandboxPrefix = () => {
-    const seed = resolveConvexInstanceSeed();
-    if (!seed) {
-        throw new Error("Missing Convex deployment URL context for MODAL_ENVIRONMENT=dev. Set DEVBOX_CONVEX_URL or CONVEX_CLOUD_URL.");
-    }
-    return createHash("sha256").update(seed).digest("hex").slice(0, 8);
-};
-const resolveModalSandboxName = (alias, environmentName) => {
-    const normalizedAlias = alias.trim();
-    if (!normalizedAlias) {
-        throw new Error("Modal alias is required.");
-    }
-    if (environmentName !== "dev") {
-        return normalizedAlias;
-    }
-    return `${resolveDevModalSandboxPrefix()}-${normalizedAlias}`;
-};
-const parseRegistryImageTag = (imageTag) => {
-    const trimmed = imageTag.trim();
-    if (!trimmed || trimmed.includes("@")) {
-        return null;
-    }
-    const lastSlashIndex = trimmed.lastIndexOf("/");
-    const lastColonIndex = trimmed.lastIndexOf(":");
-    if (lastColonIndex <= lastSlashIndex) {
-        return null;
-    }
-    const repositoryWithHost = trimmed.slice(0, lastColonIndex);
-    const tag = trimmed.slice(lastColonIndex + 1).trim();
-    if (!repositoryWithHost || !tag) {
-        return null;
-    }
-    const firstSlashIndex = repositoryWithHost.indexOf("/");
-    if (firstSlashIndex <= 0) {
-        return null;
-    }
-    const registryHost = repositoryWithHost.slice(0, firstSlashIndex);
-    const repository = repositoryWithHost.slice(firstSlashIndex + 1);
-    if (!repository) {
-        return null;
-    }
-    const hasExplicitRegistryHost = registryHost.includes(".") ||
-        registryHost.includes(":") ||
-        registryHost === "localhost";
-    if (!hasExplicitRegistryHost) {
-        return null;
-    }
-    return {
-        registryHost,
-        repository,
-        tag,
-        repositoryWithHost,
-    };
-};
-const parseWwwAuthenticateBearer = (headerValue) => {
-    const trimmed = headerValue.trim();
-    if (!trimmed.toLowerCase().startsWith("bearer ")) {
-        return null;
-    }
-    const attributes = new Map();
-    for (const match of trimmed
-        .slice("bearer ".length)
-        .matchAll(/([A-Za-z0-9_-]+)="([^"]*)"/g)) {
-        const [, key, value] = match;
-        if (!key) {
-            continue;
-        }
-        attributes.set(key.toLowerCase(), value ?? "");
-    }
-    const realm = attributes.get("realm");
-    const service = attributes.get("service");
-    const scope = attributes.get("scope");
-    if (!realm || !service) {
-        return null;
-    }
-    return {
-        realm,
-        service,
-        scope: scope || null,
-    };
-};
-const fetchRegistryToken = async ({ realm, service, scope, }) => {
-    const tokenUrl = new URL(realm);
-    tokenUrl.searchParams.set("service", service);
-    if (scope) {
-        tokenUrl.searchParams.set("scope", scope);
-    }
-    const response = await fetch(tokenUrl.toString());
-    if (!response.ok) {
-        throw new Error(`Container registry auth token request failed (${response.status}).`);
-    }
-    const payload = (await response.json());
-    const token = typeof payload.token === "string"
-        ? payload.token.trim()
-        : typeof payload.access_token === "string"
-            ? payload.access_token.trim()
-            : "";
-    if (!token) {
-        throw new Error("Container registry auth token response was empty.");
-    }
-    return token;
-};
-const resolveLatestImageTagToDigest = async (parsed) => {
-    const manifestUrl = `https://${parsed.registryHost}/v2/${parsed.repository}/manifests/${encodeURIComponent(parsed.tag)}`;
-    const fetchManifest = async ({ method, token, }) => {
-        const headers = {
-            Accept: REGISTRY_MANIFEST_ACCEPT_HEADER,
-        };
-        if (token) {
-            headers.Authorization = `Bearer ${token}`;
-        }
-        return await fetch(manifestUrl, {
-            headers,
-            method,
-        });
-    };
-    let token = null;
-    let headResponse = await fetchManifest({ method: "HEAD" });
-    if (headResponse.status === 401) {
-        const authHeader = headResponse.headers.get("www-authenticate") ?? "";
-        const challenge = parseWwwAuthenticateBearer(authHeader);
-        if (!challenge) {
-            throw new Error(`Container registry auth challenge missing or invalid for ${parsed.repositoryWithHost}:${parsed.tag}.`);
-        }
-        token = await fetchRegistryToken(challenge);
-        headResponse = await fetchManifest({
-            method: "HEAD",
-            token,
-        });
-    }
-    if (!headResponse.ok) {
-        throw new Error(`Container registry manifest lookup failed for ${parsed.repositoryWithHost}:${parsed.tag} (${headResponse.status}).`);
-    }
-    const headDigest = headResponse.headers.get("docker-content-digest")?.trim();
-    if (headDigest) {
-        return `${parsed.repositoryWithHost}@${headDigest}`;
-    }
-    const getResponse = await fetchManifest(token
-        ? {
-            method: "GET",
-            token,
-        }
-        : {
-            method: "GET",
-        });
-    if (!getResponse.ok) {
-        throw new Error(`Container registry manifest body lookup failed for ${parsed.repositoryWithHost}:${parsed.tag} (${getResponse.status}).`);
-    }
-    const headerDigest = getResponse.headers.get("docker-content-digest")?.trim();
-    if (headerDigest) {
-        return `${parsed.repositoryWithHost}@${headerDigest}`;
-    }
-    const manifestBytes = Buffer.from(await getResponse.arrayBuffer());
-    const bodyDigest = `sha256:${createHash("sha256").update(manifestBytes).digest("hex")}`;
-    return `${parsed.repositoryWithHost}@${bodyDigest}`;
-};
-const resolveImageTagForBuild = async (imageTag) => {
-    const parsed = parseRegistryImageTag(imageTag);
-    if (!parsed || parsed.tag !== "latest") {
-        return imageTag;
-    }
-    const cacheKey = `${parsed.repositoryWithHost}:${parsed.tag}`;
-    const now = Date.now();
-    const cached = resolvedImageTagCache.get(cacheKey);
-    if (cached && cached.expiresAt > now) {
-        return cached.value;
-    }
-    const resolved = await resolveLatestImageTagToDigest(parsed);
-    resolvedImageTagCache.set(cacheKey, {
-        value: resolved,
-        expiresAt: now + IMAGE_TAG_RESOLUTION_CACHE_TTL_MS,
-    });
-    return resolved;
-};
-const decodeJwtExpMs = (token) => {
-    const segments = token.split(".");
-    if (segments.length < 2)
-        return null;
-    const payload = segments[1];
-    if (!payload)
-        return null;
-    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
-    const padLength = (4 - (normalized.length % 4)) % 4;
-    const padded = `${normalized}${"=".repeat(padLength)}`;
-    try {
-        const parsed = JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
-        const exp = parsed.exp;
-        if (typeof exp !== "number" || !Number.isFinite(exp) || exp <= 0) {
-            return null;
-        }
-        return Math.floor(exp * 1000);
-    }
-    catch {
-        return null;
-    }
-};
-const createSafeModalAuthTokenManager = (modal) => {
-    let token = "";
-    let tokenExpMs = 0;
-    let inFlight = null;
-    const TOKEN_REFRESH_SKEW_MS = 30_000;
-    const FALLBACK_TOKEN_TTL_MS = 15 * 60 * 1000;
-    const hasFreshToken = () => token.length > 0 && Date.now() + TOKEN_REFRESH_SKEW_MS < tokenExpMs;
-    const fetchToken = async () => {
-        const authTokenGet = modal.cpClient.authTokenGet;
-        if (typeof authTokenGet !== "function") {
-            throw new Error("Modal auth token endpoint unavailable.");
-        }
-        const response = await authTokenGet({});
-        const nextToken = typeof response?.token === "string" ? response.token.trim() : "";
-        if (!nextToken) {
-            throw new Error("Modal auth token unavailable.");
-        }
-        token = nextToken;
-        tokenExpMs =
-            decodeJwtExpMs(nextToken) ?? Date.now() + FALLBACK_TOKEN_TTL_MS;
-        return nextToken;
-    };
-    return {
-        start: () => { },
-        stop: () => {
-            token = "";
-            tokenExpMs = 0;
-            inFlight = null;
-        },
-        getToken: async () => {
-            if (hasFreshToken())
-                return token;
-            if (!inFlight) {
-                inFlight = fetchToken().finally(() => {
-                    inFlight = null;
-                });
-            }
-            return await inFlight;
-        },
-    };
-};
-const installSafeModalAuthTokenManager = (modal) => {
-    const candidate = modal;
-    if (candidate.authTokenManager)
-        return;
-    candidate.authTokenManager = createSafeModalAuthTokenManager(candidate);
-};
-const normalizeModalVersion = (value) => {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-};
-const parseModalPlatformState = (stdout) => {
-    const values = new Map();
-    for (const rawLine of stdout.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (!line) {
-            continue;
-        }
-        const separatorIndex = line.indexOf("=");
-        if (separatorIndex <= 0) {
-            continue;
-        }
-        values.set(line.slice(0, separatorIndex).trim(), line.slice(separatorIndex + 1).trim());
-    }
-    return {
-        platformVersion: normalizeModalVersion(values.get("platform_version")),
-        bootstrapContractVersion: normalizeModalVersion(values.get("bootstrap_contract_version")),
-    };
-};
-const isSandboxRunning = (runtime) => (runtime?.result?.status ?? 0) === 0;
-const isSandboxTerminal = (runtime) => {
-    const statusCode = runtime?.result?.status;
-    return (typeof statusCode === "number" &&
-        statusCode !== 0 &&
-        Object.prototype.hasOwnProperty.call(FINISHED_STATUS_LABELS, statusCode));
-};
-const sleepMs = (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
-const formatRuntimeResult = (runtime) => {
-    const statusCode = runtime?.result?.status;
-    const exitCode = runtime?.result?.exitcode;
-    const statusLabel = typeof statusCode === "number"
-        ? (FINISHED_STATUS_LABELS[statusCode] ?? String(statusCode))
-        : "unknown";
-    const exitLabel = typeof exitCode === "number" ? String(exitCode) : "unknown";
-    return `status=${statusLabel}, exit=${exitLabel}`;
-};
-const waitForSandboxRunning = async ({ modal, sandboxId, timeoutSeconds, context, }) => {
-    const deadline = Date.now() + timeoutSeconds * 1_000;
-    let lastRuntime;
-    while (true) {
-        // Modal returns the current state immediately for timeout=0, while positive
-        // timeouts can block until the timeout expires even if the sandbox is
-        // already running.
-        const runtime = await modal.cpClient.sandboxWait({
-            sandboxId,
-            timeout: 0,
-        });
-        lastRuntime = runtime;
-        if (isSandboxRunning(runtime)) {
-            return;
-        }
-        if (isSandboxTerminal(runtime) || Date.now() >= deadline) {
-            throw new Error(`Modal sandbox ${sandboxId} was not running after ${context} (${formatRuntimeResult(lastRuntime)}).`);
-        }
-        await sleepMs(MODAL_SANDBOX_RUNNING_POLL_MS);
-    }
-};
-const readModalPlatformStateFromSandbox = async (modal, sandboxId) => {
-    if (!modal.sandboxes) {
-        return {
-            platformVersion: null,
-            bootstrapContractVersion: CURRENT_MODAL_BOOTSTRAP_CONTRACT_VERSION,
-        };
-    }
-    const sandbox = await modal.sandboxes.fromId(sandboxId);
-    const script = [
-        "set -euo pipefail",
-        `platform_version=""`,
-        `if [ -r ${shellQuote(MODAL_PLATFORM_VERSION_PATH)} ]; then`,
-        `  platform_version="$(head -n 1 ${shellQuote(MODAL_PLATFORM_VERSION_PATH)} | tr -d '\\r')"`,
-        "fi",
-        `bootstrap_contract_version=""`,
-        `if [ -r ${shellQuote(MODAL_BOOTSTRAP_CONTRACT_VERSION_PATH)} ]; then`,
-        `  bootstrap_contract_version="$(head -n 1 ${shellQuote(MODAL_BOOTSTRAP_CONTRACT_VERSION_PATH)} | tr -d '\\r')"`,
-        "fi",
-        'printf "platform_version=%s\\n" "$platform_version"',
-        'printf "bootstrap_contract_version=%s\\n" "$bootstrap_contract_version"',
-    ].join("\n");
-    const process = await sandbox.exec(["/bin/bash", "-lc", script], {
-        mode: "text",
-        stdout: "pipe",
-        stderr: "pipe",
-        timeoutMs: 60_000,
-    });
-    const [exitCode, stdout, stderr] = await Promise.all([
-        process.wait(),
-        process.stdout.readText(),
-        process.stderr.readText(),
-    ]);
-    if (exitCode !== 0) {
-        const detail = stderr.trim() || stdout.trim() || `exit=${exitCode}`;
-        throw new Error(`Failed to read Modal platform state: ${detail}`);
-    }
-    const platformState = parseModalPlatformState(stdout);
-    return {
-        platformVersion: platformState.platformVersion,
-        bootstrapContractVersion: platformState.bootstrapContractVersion ??
-            CURRENT_MODAL_BOOTSTRAP_CONTRACT_VERSION,
-    };
-};
-const parsePositiveInt = (value, fallback) => {
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0)
-        return fallback;
-    return parsed;
-};
-const resolveRegions = () => {
-    const raw = trimEnv(process.env.MODAL_SANDBOX_REGION);
-    if (!raw)
-        return [];
-    return raw
-        .split(",")
-        .map((value) => value.trim())
-        .filter((value) => value.length > 0);
-};
-const resolveAppName = () => trimEnv(process.env.MODAL_SANDBOX_APP) || DEFAULT_APP_NAME;
-const resolveModalSandboxTimeoutMs = () => parsePositiveInt(trimEnv(process.env.MODAL_SANDBOX_TIMEOUT_MS), DEFAULT_TIMEOUT_MS);
-const isNotFoundError = (error) => error instanceof NotFoundError;
-const isModalAlreadyExistsError = (error) => {
-    if (error instanceof AlreadyExistsError) {
-        return true;
-    }
-    const message = error instanceof Error
-        ? `${error.name} ${error.message}`
-        : String(error ?? "");
-    if (/\bALREADY_EXISTS\b/i.test(message)) {
-        return true;
-    }
-    return /already exists/i.test(message);
-};
-const trimToNull = (value) => {
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-};
-const resolveControlPlaneToken = (options) => trimToNull(options?.credentials?.controlPlaneToken);
-const hasContextModalCredentialPair = (options) => Boolean(trimToNull(options?.credentials?.modalTokenId) &&
-    trimToNull(options?.credentials?.modalTokenSecret));
-const shouldUseControlPlaneFallback = (options) => !options?.client &&
-    Boolean(resolveControlPlaneToken(options)) &&
-    !hasContextModalCredentialPair(options);
-const withModalClient = async (options, fn) => {
-    if (options?.client) {
-        return await fn(options.client);
-    }
-    const modalCredentials = resolveModalClientCredentials({
-        ...(options?.credentialMode
-            ? { credentialMode: options.credentialMode }
-            : {}),
-        ...(options?.credentials !== undefined
-            ? { credentials: options.credentials }
-            : {}),
-        ...(options?.cwd ? { cwd: options.cwd } : {}),
-    });
-    const modal = new ModalClient({
-        tokenId: modalCredentials.tokenId,
-        tokenSecret: modalCredentials.tokenSecret,
-        environment: resolveModalEnvironmentName(),
-    });
-    installSafeModalAuthTokenManager(modal);
-    try {
-        return await fn(modal);
-    }
-    finally {
-        modal.close();
-    }
-};
-const resolveModalApp = async (modal, appName, createIfMissing) => {
-    try {
-        const app = await modal.apps.fromName(appName, { createIfMissing });
-        return { appId: app.appId, appName };
-    }
-    catch (error) {
-        if (!createIfMissing && isNotFoundError(error)) {
-            return null;
-        }
-        throw error;
-    }
-};
-const listSandboxesRaw = async (modal, appId, includeFinished) => {
-    const sandboxes = [];
-    let beforeTimestamp = 0;
-    let guard = 0;
-    while (true) {
-        guard += 1;
-        if (guard > SANDBOX_LIST_PAGE_LIMIT) {
-            throw new Error("Modal sandbox list pagination exceeded safety limit.");
-        }
-        const response = await modal.cpClient.sandboxList({
-            appId,
-            beforeTimestamp,
-            environmentName: modal.environmentName(),
-            includeFinished,
-            tags: [],
-        });
-        if (!response.sandboxes.length)
-            break;
-        sandboxes.push(...response.sandboxes);
-        const nextCursor = response.sandboxes[response.sandboxes.length - 1];
-        if (!nextCursor || nextCursor.createdAt === beforeTimestamp)
-            break;
-        beforeTimestamp = nextCursor.createdAt;
-    }
-    return sandboxes;
-};
-const formatSandboxStatus = (sandbox) => {
-    const result = sandbox.taskInfo?.result;
-    const status = result?.status ?? 0;
-    if (status === 0)
-        return "running";
-    const label = FINISHED_STATUS_LABELS[status] ?? String(status);
-    const exitCode = result?.exitcode ?? "unknown";
-    return `finished:${label}:exit=${String(exitCode)}`;
-};
-const isRunningSandbox = (sandbox) => (sandbox.taskInfo?.result?.status ?? 0) === 0;
-const resolveImageFromTag = async (modal, imageTag) => {
-    const secretName = trimEnv(process.env.MODAL_SANDBOX_IMAGE_SECRET);
-    if (!secretName) {
-        return modal.images.fromRegistry(imageTag);
-    }
-    const secret = await modal.secrets.fromName(secretName);
-    if (imageTag.includes(".dkr.ecr.")) {
-        return modal.images.fromAwsEcr(imageTag, secret);
-    }
-    return modal.images.fromRegistry(imageTag, secret);
-};
-const provisionModalSandbox = async (alias, options) => {
-    if (shouldUseControlPlaneFallback(options)) {
-        const controlPlaneToken = resolveControlPlaneToken(options);
-        if (!controlPlaneToken) {
-            throw new Error("Control plane token is required for modal provisioning.");
-        }
-        return await provisionModalSandboxViaControlPlane(controlPlaneToken, alias);
-    }
-    const appName = resolveAppName();
-    const envImageTag = trimEnv(process.env.MODAL_SANDBOX_IMAGE);
-    const imageTag = envImageTag || DEFAULT_MODAL_DEVBOX_IMAGE;
-    const resolvedImageTag = await resolveImageTagForBuild(imageTag);
-    const timeoutMs = resolveModalSandboxTimeoutMs();
-    const timeoutSecs = Math.max(1, Math.floor(timeoutMs / 1000));
-    const regions = resolveRegions();
-    return await withModalClient(options, async (modal) => {
-        const sandboxName = resolveModalSandboxName(alias, modal.environmentName());
-        const app = await resolveModalApp(modal, appName, true);
-        if (!app) {
-            throw new Error(`Could not resolve Modal app "${appName}".`);
-        }
-        const buildImage = async (tag) => {
-            const image = await resolveImageFromTag(modal, tag);
-            return await image.build({ appId: app.appId });
-        };
-        const builtImage = await buildImage(resolvedImageTag);
-        const createResponse = await modal.cpClient.sandboxCreate({
-            appId: app.appId,
-            definition: {
-                imageId: builtImage.imageId,
-                timeoutSecs,
-                name: sandboxName,
-                ...(regions.length > 0 ? { schedulerPlacement: { regions } } : {}),
-                entrypointArgs: MODAL_DAEMON_SUPERVISOR_ENTRYPOINT,
-                enableSnapshot: true,
-            },
-        });
-        const sandboxId = typeof createResponse.sandboxId === "string"
-            ? createResponse.sandboxId.trim()
-            : "";
-        if (!sandboxId) {
-            throw new Error("Modal sandbox create response is missing sandbox id.");
-        }
-        await waitForSandboxRunning({
-            modal,
-            sandboxId,
-            timeoutSeconds: 120,
-            context: "fresh Modal sandbox provision",
-        });
-        const platformState = await readModalPlatformStateFromSandbox(modal, sandboxId);
-        return {
-            sandboxId,
-            appId: app.appId,
-            appName,
-            imageTag: resolvedImageTag,
-            timeoutMs,
-            memorySnapshotEnabled: false,
-            regions,
-            platformVersion: platformState.platformVersion,
-            bootstrapContractVersion: platformState.bootstrapContractVersion,
-        };
-    });
-};
-const findModalSandbox = async (options, operationOptions) => {
-    if (shouldUseControlPlaneFallback(operationOptions)) {
-        const controlPlaneToken = resolveControlPlaneToken(operationOptions);
-        if (!controlPlaneToken) {
-            throw new Error("Control plane token is required for modal sandbox lookup.");
-        }
-        return await findModalSandboxViaControlPlane(controlPlaneToken, options);
-    }
-    const appName = resolveAppName();
-    const includeFinished = options.includeFinished ?? true;
-    return await withModalClient(operationOptions, async (modal) => {
-        const sandboxName = resolveModalSandboxName(options.alias, modal.environmentName());
-        const app = await resolveModalApp(modal, appName, false);
-        if (!app)
-            return null;
-        const sandboxes = await listSandboxesRaw(modal, app.appId, includeFinished);
-        const matching = sandboxes.filter((sandbox) => {
-            if (options.sandboxId && sandbox.id === options.sandboxId)
-                return true;
-            return sandbox.name === sandboxName;
-        });
-        if (matching.length === 0)
-            return null;
-        matching.sort((left, right) => {
-            const runningOrder = Number(isRunningSandbox(right)) - Number(isRunningSandbox(left));
-            if (runningOrder !== 0)
-                return runningOrder;
-            return right.createdAt - left.createdAt;
-        });
-        const selected = matching[0];
-        if (!selected) {
-            throw new Error("Modal sandbox selection failed.");
-        }
-        return {
-            sandboxId: selected.id,
-            appId: app.appId,
-            appName: app.appName,
-            name: options.alias,
-            createdAt: selected.createdAt,
-            status: formatSandboxStatus(selected),
-            regions: selected.regions,
-        };
-    });
-};
-const terminateModalSandboxesByAlias = async (alias, options) => {
-    if (shouldUseControlPlaneFallback(options)) {
-        const controlPlaneToken = resolveControlPlaneToken(options);
-        if (!controlPlaneToken) {
-            throw new Error("Control plane token is required for modal sandbox termination.");
-        }
-        return await terminateModalSandboxesByAliasViaControlPlane(controlPlaneToken, {
-            alias,
-            ...(typeof options?.includeFinished === "boolean"
-                ? { includeFinished: options.includeFinished }
-                : {}),
-        });
-    }
-    const appName = resolveAppName();
-    const includeFinished = options?.includeFinished ?? false;
-    return await withModalClient(options, async (modal) => {
-        const sandboxName = resolveModalSandboxName(alias, modal.environmentName());
-        const app = await resolveModalApp(modal, appName, false);
-        if (!app) {
-            return {
-                appName,
-                appId: null,
-                matchedSandboxIds: [],
-                terminatedSandboxIds: [],
-            };
-        }
-        const sandboxes = await listSandboxesRaw(modal, app.appId, includeFinished);
-        const matching = sandboxes.filter((sandbox) => sandbox.name === sandboxName);
-        const terminatedSandboxIds = [];
-        for (const sandbox of matching) {
-            await modal.cpClient.sandboxTerminate({ sandboxId: sandbox.id });
-            terminatedSandboxIds.push(sandbox.id);
-        }
-        return {
-            appName: app.appName,
-            appId: app.appId,
-            matchedSandboxIds: matching.map((sandbox) => sandbox.id),
-            terminatedSandboxIds,
-        };
-    });
-};
-export { provisionModalSandbox };
-export { findModalSandbox, isModalAlreadyExistsError, resolveModalEnvironmentName, resolveModalSandboxName, resolveModalSandboxTimeoutMs, terminateModalSandboxesByAlias, };
-//# sourceMappingURL=modalLifecycle.js.map