@boxes-dev/dvb-runtime 1.0.297 → 1.0.299

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

@@ -1,791 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import path from "node:path";
-import { ModalClient, NotFoundError } from "modal";
-import { createLogger, ProviderClientError, SpritesApiError, resolveModalClientCredentials, withDevboxSpan, } from "@boxes-dev/core";
-import { resolveModalEnvironmentName, resolveModalSandboxName, } from "./modalLifecycle.js";
-import { CORE_SERVICE_NAMES, mapDaemonControlSessionRecord, mapProviderServiceRecord, mapProviderServiceRecordToSpriteService, parseDaemonControlError, validateManagedServiceName, withTimeout, } from "./daemonRuntimeShared.js";
-import { DirectDaemonExecSocket, runDirectDaemonControlRequest, } from "./directDaemonRuntime.js";
-const MODAL_DAEMON_REQUEST_TIMEOUT_MS = 15_000;
-const MODAL_DAEMON_REQUEST_TIMEOUT_MAX_MS = 120_000;
-const MODAL_SANDBOX_RESOLVE_TIMEOUT_MS = 30_000;
-const MODAL_DAEMON_FS_WRITE_MAX_RAW_BYTES = 1 * 1024 * 1024;
-// Keep direct Modal control frames comfortably below the transport ceiling.
-const MODAL_DAEMON_FS_WRITE_FRAME_MAX_BYTES = 3 * 1024 * 1024;
-const MODAL_DAEMON_REQUEST_ID_PLACEHOLDER = "0".repeat(32);
-const MODAL_DAEMON_MULTIPART_WRITE_CONCURRENCY = 1;
-const MODAL_DAEMON_WRITE_TIMEOUT_BASE_MS = 5_000;
-const MODAL_DAEMON_WRITE_TIMEOUT_PER_MIB_MS = 2_000;
-const MODAL_DAEMON_MULTIPART_ASSEMBLE_MIN_TIMEOUT_MS = 30_000;
-const logger = createLogger("modal_runtime");
-const isSandboxNotFoundError = (error) => error instanceof NotFoundError;
-const shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
-const clampModalControlTimeoutMs = (timeoutMs) => {
-    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
-        return MODAL_DAEMON_REQUEST_TIMEOUT_MS;
-    }
-    return Math.min(Math.max(Math.ceil(timeoutMs), MODAL_DAEMON_REQUEST_TIMEOUT_MS), MODAL_DAEMON_REQUEST_TIMEOUT_MAX_MS);
-};
-const sha256Hex = (data) => createHash("sha256").update(data).digest("hex");
-const estimateBase64EncodedByteLength = (bytes) => Math.ceil(bytes / 3) * 4;
-const estimateModalFsWriteControlMessageBytes = (remotePath, bytes) => {
-    const overhead = Buffer.byteLength(JSON.stringify({
-        type: "fs_write",
-        path: remotePath,
-        mkdir: true,
-        requestId: MODAL_DAEMON_REQUEST_ID_PLACEHOLDER,
-        data: "",
-    }), "utf8");
-    return overhead + estimateBase64EncodedByteLength(bytes);
-};
-const resolveMaxModalFsWriteBytes = (remotePath) => {
-    const overhead = estimateModalFsWriteControlMessageBytes(remotePath, 0);
-    const remainingBytes = MODAL_DAEMON_FS_WRITE_FRAME_MAX_BYTES - overhead;
-    if (remainingBytes <= 0) {
-        throw new Error(`Modal fs_write path exceeds the control frame budget: ${remotePath}`);
-    }
-    return Math.max(1, Math.min(MODAL_DAEMON_FS_WRITE_MAX_RAW_BYTES, Math.floor(remainingBytes / 4) * 3));
-};
-const shouldChunkModalFsWrite = (remotePath, bytes) => bytes > resolveMaxModalFsWriteBytes(remotePath);
-const estimateModalWriteTimeoutMs = (bytes) => {
-    const wholeMiB = Math.max(1, Math.ceil(bytes / (1024 * 1024)));
-    return clampModalControlTimeoutMs(MODAL_DAEMON_WRITE_TIMEOUT_BASE_MS +
-        wholeMiB * MODAL_DAEMON_WRITE_TIMEOUT_PER_MIB_MS);
-};
-const normalizeConcurrency = (concurrency) => Math.max(1, Math.floor(concurrency));
-const resolveBoundedConcurrency = (itemCount, concurrency) => Math.max(1, Math.min(itemCount, normalizeConcurrency(concurrency)));
-const estimateModalMultipartPartTimeoutMs = (bytes, concurrency) => estimateModalWriteTimeoutMs(bytes * normalizeConcurrency(concurrency));
-const estimateModalMultipartAssembleTimeoutMs = (bytes) => clampModalControlTimeoutMs(Math.max(MODAL_DAEMON_MULTIPART_ASSEMBLE_MIN_TIMEOUT_MS, estimateModalWriteTimeoutMs(bytes) * 2));
-const buildModalMultipartWritePlan = (remotePath, data) => {
-    const normalizedRemotePath = path.posix.normalize(remotePath);
-    const remoteDir = path.posix.dirname(normalizedRemotePath);
-    const remoteBaseName = path.posix.basename(normalizedRemotePath);
-    const uploadId = randomUUID();
-    const partDir = path.posix.join(remoteDir, `.${remoteBaseName}.tmp-upload-${uploadId}`);
-    const assembledTmpPath = path.posix.join(remoteDir, `.${remoteBaseName}.tmp-assemble-${uploadId}`);
-    const partSizeLimitBytes = resolveMaxModalFsWriteBytes(path.posix.join(partDir, "part-00000"));
-    const parts = [];
-    for (let offset = 0, index = 0; offset < data.length; index += 1) {
-        const nextOffset = Math.min(offset + partSizeLimitBytes, data.length);
-        const partData = data.subarray(offset, nextOffset);
-        parts.push({
-            index,
-            remotePath: path.posix.join(partDir, `part-${String(index).padStart(5, "0")}`),
-            data: partData,
-            sizeBytes: partData.length,
-            sha256: sha256Hex(partData),
-        });
-        offset = nextOffset;
-    }
-    return {
-        partDir,
-        assembledTmpPath,
-        expectedSizeBytes: data.length,
-        expectedSha256: sha256Hex(data),
-        partSizeLimitBytes,
-        parts,
-    };
-};
-const buildModalMultipartAssembleScript = (remotePath, plan) => [
-    "set -euo pipefail",
-    `target=${shellQuote(path.posix.normalize(remotePath))}`,
-    `part_dir=${shellQuote(plan.partDir)}`,
-    `assembled_tmp=${shellQuote(plan.assembledTmpPath)}`,
-    `expected_size=${plan.expectedSizeBytes}`,
-    `expected_sha=${shellQuote(plan.expectedSha256)}`,
-    "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",
-    'mkdir -p "$(dirname "$target")"',
-    '[ -d "$part_dir" ] || { echo "Missing multipart upload directory: $part_dir" >&2; exit 1; }',
-    ': > "$assembled_tmp"',
-    ...plan.parts.flatMap((part) => [
-        `part_path=${shellQuote(part.remotePath)}`,
-        `part_expected_size=${part.sizeBytes}`,
-        `part_expected_sha=${shellQuote(part.sha256)}`,
-        '[ -f "$part_path" ] || { echo "Missing upload 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_size" ]; then echo "Assembled file size mismatch: expected $expected_size got $assembled_size" >&2; exit 1; fi',
-    'assembled_sha="$(hash_file "$assembled_tmp")"',
-    'if [ "$assembled_sha" != "$expected_sha" ]; then echo "Assembled file checksum mismatch" >&2; exit 1; fi',
-    'mv "$assembled_tmp" "$target"',
-    'rm -rf "$part_dir"',
-    "trap - EXIT",
-].join("\n");
-const buildModalMultipartCleanupScript = (plan) => [
-    "set -euo pipefail",
-    `rm -rf ${shellQuote(plan.partDir)}`,
-    `rm -f ${shellQuote(plan.assembledTmpPath)}`,
-].join("\n");
-const buildModalControlTraceAttributes = (alias, requestPayload, expectedType, responseTimeoutMs) => {
-    const requestType = typeof requestPayload.type === "string" ? requestPayload.type : "unknown";
-    return {
-        "devbox.modal.alias": alias,
-        "devbox.modal.request_type": requestType,
-        "devbox.modal.expected_type": expectedType,
-        "devbox.modal.response_timeout_ms": responseTimeoutMs,
-        ...(typeof requestPayload.path === "string"
-            ? { "devbox.modal.path": requestPayload.path }
-            : {}),
-        ...(typeof requestPayload.serviceName === "string"
-            ? { "devbox.modal.service_name": requestPayload.serviceName }
-            : {}),
-        ...(typeof requestPayload.sessionId === "string"
-            ? { "devbox.modal.session_id": requestPayload.sessionId }
-            : {}),
-        ...(requestType === "fs_write" && typeof requestPayload.data === "string"
-            ? { "devbox.modal.write_base64_bytes": requestPayload.data.length }
-            : {}),
-        ...(requestType === "exec" && Array.isArray(requestPayload.cmd)
-            ? {
-                "devbox.modal.exec_argc": requestPayload.cmd.length,
-                "devbox.modal.exec_argv0": typeof requestPayload.cmd[0] === "string"
-                    ? requestPayload.cmd[0]
-                    : "",
-            }
-            : {}),
-    };
-};
-const runWithConcurrency = async (items, concurrency, worker) => {
-    if (items.length === 0) {
-        return;
-    }
-    const boundedConcurrency = resolveBoundedConcurrency(items.length, concurrency);
-    let nextIndex = 0;
-    let firstError = null;
-    const workers = Array.from({ length: boundedConcurrency }, async () => {
-        while (true) {
-            if (firstError) {
-                return;
-            }
-            const currentIndex = nextIndex;
-            nextIndex += 1;
-            if (currentIndex >= items.length) {
-                return;
-            }
-            const item = items.at(currentIndex);
-            if (item === undefined) {
-                return;
-            }
-            try {
-                await worker(item);
-            }
-            catch (error) {
-                if (!firstError) {
-                    firstError = error;
-                }
-                return;
-            }
-        }
-    });
-    await Promise.all(workers);
-    if (firstError) {
-        throw firstError;
-    }
-};
-const resolveReadPath = (readPath, workingDir) => {
-    if (path.posix.isAbsolute(readPath))
-        return path.posix.normalize(readPath);
-    if (workingDir && workingDir.trim().length > 0) {
-        return path.posix.normalize(path.posix.join(workingDir, readPath));
-    }
-    return path.posix.normalize(readPath);
-};
-const createModalRuntimeClient = ({ alias, appName: initialAppName, sandboxId: initialSandboxId, ensureActive, credentialMode, credentials, createConnectToken: _createConnectToken, createCheckpoint: createCheckpointViaControlPlane, cwd, serviceRole: requestedServiceRole, }) => {
-    let modal = null;
-    let modalSandboxName = alias;
-    try {
-        const modalCredentials = resolveModalClientCredentials({
-            ...(credentialMode ? { credentialMode } : {}),
-            ...(credentials !== undefined ? { credentials } : {}),
-            ...(cwd ? { cwd } : {}),
-        });
-        const modalEnvironmentName = resolveModalEnvironmentName();
-        modalSandboxName = resolveModalSandboxName(alias, modalEnvironmentName);
-        modal = new ModalClient({
-            tokenId: modalCredentials.tokenId,
-            tokenSecret: modalCredentials.tokenSecret,
-            environment: modalEnvironmentName,
-        });
-    }
-    catch (error) {
-        if (!(error instanceof ProviderClientError &&
-            error.code === "authentication_required")) {
-            throw error;
-        }
-    }
-    let appName = initialAppName;
-    let sandboxId = initialSandboxId;
-    let sandboxPromise = null;
-    const serviceRole = requestedServiceRole ?? "user";
-    const resolveDaemonConnectInfo = async ({ alias: rawAlias, intent, }) => {
-        const normalizedAlias = rawAlias.trim();
-        if (normalizedAlias !== alias) {
-            throw new Error(`Modal init runtime is bound to alias "${alias}", but got "${normalizedAlias}".`);
-        }
-        if (!_createConnectToken) {
-            throw new Error("Modal daemon access requires a control plane session. Run `dvb setup` and retry.");
-        }
-        const connectInfo = await _createConnectToken(intent);
-        return {
-            provider: "modal",
-            url: connectInfo.url,
-            connectToken: connectInfo.token,
-        };
-    };
-    const requireAlias = (name) => {
-        if (name !== alias) {
-            throw new Error(`Modal init runtime is bound to alias "${alias}", but got "${name}".`);
-        }
-    };
-    const resolveSandbox = async (intent = "shell") => {
-        if (!modal) {
-            throw new Error("Modal direct API access is unavailable. Use BYO modal auth for file and command operations.");
-        }
-        const directModal = modal;
-        if (sandboxPromise)
-            return sandboxPromise;
-        sandboxPromise = (async () => {
-            try {
-                const runningSandbox = await withTimeout(directModal.sandboxes.fromName(appName, modalSandboxName), MODAL_SANDBOX_RESOLVE_TIMEOUT_MS, "Timed out resolving running modal sandbox by name.");
-                sandboxId = runningSandbox.sandboxId;
-                return runningSandbox;
-            }
-            catch (error) {
-                if (!isSandboxNotFoundError(error)) {
-                    throw error;
-                }
-            }
-            if (ensureActive) {
-                const ensured = await withTimeout(ensureActive(intent), MODAL_SANDBOX_RESOLVE_TIMEOUT_MS, "Timed out waiting for modal devbox wake.");
-                appName = ensured.appName;
-                sandboxId = ensured.sandboxId;
-                return await withTimeout(directModal.sandboxes.fromId(ensured.sandboxId), MODAL_SANDBOX_RESOLVE_TIMEOUT_MS, "Timed out resolving modal sandbox after wake.");
-            }
-            return await withTimeout(directModal.sandboxes.fromId(sandboxId), MODAL_SANDBOX_RESOLVE_TIMEOUT_MS, "Timed out resolving modal sandbox by id.");
-        })().catch((error) => {
-            sandboxPromise = null;
-            throw error;
-        });
-        return sandboxPromise;
-    };
-    const exec = async (name, cmd, options) => {
-        requireAlias(name);
-        const response = await runControlRequest({
-            type: "exec",
-            cmd,
-            ...(typeof options?.timeoutMs === "number"
-                ? { timeoutMs: options.timeoutMs }
-                : {}),
-        }, "exec_result", typeof options?.timeoutMs === "number"
-            ? {
-                responseTimeoutMs: clampModalControlTimeoutMs(options.timeoutMs + 5_000),
-            }
-            : undefined);
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            throw new Error(text);
-        }
-        const exitCode = typeof response.exitCode === "number" &&
-            Number.isFinite(response.exitCode)
-            ? response.exitCode
-            : 1;
-        const stdout = typeof response.stdout === "string" ? response.stdout : "";
-        const stderr = typeof response.stderr === "string" ? response.stderr : "";
-        return { exitCode, stdout, stderr };
-    };
-    const execShellScript = async (script, timeoutMs, failureMessage) => {
-        const result = await exec(alias, [
-            "/bin/bash",
-            "--noprofile",
-            "--norc",
-            "-e",
-            "-u",
-            "-o",
-            "pipefail",
-            "-c",
-            script,
-        ], { timeoutMs });
-        if (result.exitCode !== 0) {
-            throw new Error(result.stderr || result.stdout || failureMessage);
-        }
-    };
-    const readFile = async (name, options) => {
-        requireAlias(name);
-        const resolvedPath = resolveReadPath(options.path, options.workingDir);
-        const response = await runControlRequest({
-            type: "fs_read",
-            path: options.path,
-            ...(options.workingDir ? { workingDir: options.workingDir } : {}),
-        }, "fs_read_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            if (code === "not_found") {
-                throw new SpritesApiError(404, "GET", `/files/${encodeURIComponent(resolvedPath)}`, text);
-            }
-            throw new Error(text);
-        }
-        const data = typeof response.data === "string"
-            ? Buffer.from(response.data, "base64")
-            : Buffer.alloc(0);
-        return new Uint8Array(data);
-    };
-    const writeFile = async (name, remotePath, data, options) => {
-        requireAlias(name);
-        const total = data.length;
-        options?.onProgress?.(0, total);
-        const chunked = shouldChunkModalFsWrite(remotePath, total);
-        const plan = chunked
-            ? buildModalMultipartWritePlan(remotePath, data)
-            : null;
-        const chunkCount = plan ? plan.parts.length : 0;
-        const multipartConcurrency = plan
-            ? resolveBoundedConcurrency(plan.parts.length, MODAL_DAEMON_MULTIPART_WRITE_CONCURRENCY)
-            : 1;
-        await withDevboxSpan("modal.write_file", {
-            "devbox.modal.alias": alias,
-            "devbox.modal.path": remotePath,
-            "devbox.modal.size_bytes": total,
-            "devbox.modal.chunked": chunked,
-            ...(chunked ? { "devbox.modal.chunk_count": chunkCount } : {}),
-        }, async () => {
-            logger.info("modal_fs_write_start", {
-                alias,
-                remotePath,
-                sizeBytes: total,
-                chunked,
-                ...(chunked
-                    ? {
-                        chunkBytes: plan?.partSizeLimitBytes,
-                        chunkCount,
-                        multipartConcurrency,
-                    }
-                    : {}),
-            });
-            try {
-                if (!chunked) {
-                    const response = await runControlRequest({
-                        type: "fs_write",
-                        path: remotePath,
-                        mkdir: true,
-                        data: Buffer.from(data).toString("base64"),
-                    }, "fs_write_result", {
-                        responseTimeoutMs: estimateModalWriteTimeoutMs(total),
-                    });
-                    if (response.status !== "ok") {
-                        const { text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-                        throw new Error(text);
-                    }
-                    options?.onProgress?.(total, total);
-                    logger.info("modal_fs_write_complete", {
-                        alias,
-                        remotePath,
-                        sizeBytes: total,
-                        chunked: false,
-                    });
-                    return;
-                }
-                if (!plan) {
-                    throw new Error("Missing multipart upload plan.");
-                }
-                let uploadedBytes = 0;
-                await runWithConcurrency(plan.parts, multipartConcurrency, async (part) => {
-                    const response = await runControlRequest({
-                        type: "fs_write",
-                        path: part.remotePath,
-                        mkdir: true,
-                        data: Buffer.from(part.data).toString("base64"),
-                    }, "fs_write_result", {
-                        responseTimeoutMs: estimateModalMultipartPartTimeoutMs(part.sizeBytes, multipartConcurrency),
-                    });
-                    if (response.status !== "ok") {
-                        const { text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-                        throw new Error(text);
-                    }
-                    uploadedBytes += part.sizeBytes;
-                    logger.info("modal_fs_write_chunk_complete", {
-                        alias,
-                        remotePath,
-                        chunkIndex: part.index,
-                        chunkCount: plan.parts.length,
-                        chunkSizeBytes: part.sizeBytes,
-                        uploadedBytes,
-                        totalBytes: total,
-                    });
-                    options?.onProgress?.(uploadedBytes, total);
-                });
-                await execShellScript(buildModalMultipartAssembleScript(remotePath, plan), estimateModalMultipartAssembleTimeoutMs(total), "Failed to assemble multipart Modal upload.");
-                options?.onProgress?.(total, total);
-                logger.info("modal_fs_write_complete", {
-                    alias,
-                    remotePath,
-                    sizeBytes: total,
-                    chunked: true,
-                    chunkCount: plan.parts.length,
-                });
-            }
-            catch (error) {
-                if (plan) {
-                    try {
-                        await execShellScript(buildModalMultipartCleanupScript(plan), MODAL_DAEMON_REQUEST_TIMEOUT_MS, "Failed to clean up multipart Modal upload.");
-                    }
-                    catch (cleanupError) {
-                        logger.warn("modal_fs_write_cleanup_failed", {
-                            alias,
-                            remotePath,
-                            error: cleanupError instanceof Error
-                                ? cleanupError.message
-                                : String(cleanupError),
-                        });
-                    }
-                }
-                logger.error("modal_fs_write_failed", {
-                    alias,
-                    remotePath,
-                    sizeBytes: total,
-                    chunked,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
-            }
-        });
-    };
-    const upsertServiceControl = async (name, service, input) => {
-        const response = await runControlRequest({
-            type: "service_upsert",
-            serviceName: service,
-            actor: serviceRole,
-            scope: input.scope,
-            cmd: input.cmd,
-            args: input.args,
-            httpPort: input.httpPort,
-            workingDir: input.workingDir,
-            autostart: input.autostart,
-            restartPolicy: input.restartPolicy,
-        }, "service_upsert_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            if (code === "service_not_found") {
-                throw new SpritesApiError(404, "PUT", `/v1/sprites/${encodeURIComponent(name)}/services/${encodeURIComponent(service)}`, text);
-            }
-            throw new Error(text);
-        }
-        return mapProviderServiceRecord(response.service);
-    };
-    const listServices = async (name) => {
-        const records = await listServiceRecords(name);
-        return records.map((record) => mapProviderServiceRecordToSpriteService(record));
-    };
-    const getService = async (name, service) => {
-        const record = await getServiceRecord(name, service);
-        return record ? mapProviderServiceRecordToSpriteService(record) : null;
-    };
-    const listServiceRecords = async (name) => {
-        requireAlias(name);
-        const response = await runControlRequest({ type: "services_list" }, "services_list_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            throw new Error(text);
-        }
-        const records = Array.isArray(response.services) ? response.services : [];
-        return records.map((entry) => mapProviderServiceRecord(entry));
-    };
-    const getServiceRecord = async (name, service) => {
-        requireAlias(name);
-        validateManagedServiceName(service);
-        const response = await runControlRequest({ type: "service_get", serviceName: service }, "service_get_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            if (code === "service_not_found") {
-                return null;
-            }
-            throw new Error(text);
-        }
-        return mapProviderServiceRecord(response.service);
-    };
-    const upsertServiceRecord = async (name, service, input) => {
-        requireAlias(name);
-        validateManagedServiceName(service);
-        return await upsertServiceControl(name, service, input);
-    };
-    const createService = async (name, service, input) => {
-        requireAlias(name);
-        validateManagedServiceName(service);
-        if (!input.cmd || !input.cmd.trim()) {
-            throw new Error(`Service "${service}" is missing a command.`);
-        }
-        if (input.needs && input.needs.length > 0) {
-            throw new Error("Service dependencies are not supported yet.");
-        }
-        const record = await upsertServiceControl(name, service, {
-            scope: CORE_SERVICE_NAMES.has(service) ? "core" : "user",
-            cmd: input.cmd.trim(),
-            args: input.args ?? [],
-            httpPort: typeof input.httpPort === "number" ? input.httpPort : null,
-            workingDir: null,
-            autostart: true,
-            restartPolicy: "always",
-        });
-        return mapProviderServiceRecordToSpriteService(record);
-    };
-    const startService = async (name, service) => {
-        requireAlias(name);
-        validateManagedServiceName(service);
-        const response = await runControlRequest({ type: "service_start", serviceName: service, actor: serviceRole }, "service_start_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            if (code === "service_not_found") {
-                throw new Error(`Service "${service}" does not exist.`);
-            }
-            throw new Error(text);
-        }
-        return Array.isArray(response.events)
-            ? response.events
-                .filter((entry) => entry && typeof entry === "object")
-                .map((entry) => entry)
-            : [{ event: "started", service }];
-    };
-    const stopService = async (name, service, options) => {
-        requireAlias(name);
-        validateManagedServiceName(service);
-        const response = await runControlRequest({
-            type: "service_stop",
-            serviceName: service,
-            actor: serviceRole,
-            ...(options?.timeout ? { timeout: options.timeout } : {}),
-        }, "service_stop_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            if (code === "service_not_found") {
-                throw new Error(`Service "${service}" does not exist.`);
-            }
-            throw new Error(text);
-        }
-        return Array.isArray(response.events)
-            ? response.events
-                .filter((entry) => entry && typeof entry === "object")
-                .map((entry) => entry)
-            : [{ event: "stopped", service }];
-    };
-    const signalService = async (name, service, options) => {
-        requireAlias(name);
-        validateManagedServiceName(service);
-        const signal = typeof options?.signal === "string" && options.signal.trim().length > 0
-            ? options.signal.trim()
-            : "TERM";
-        const response = await runControlRequest({
-            type: "service_signal",
-            serviceName: service,
-            signal,
-            actor: serviceRole,
-        }, "service_signal_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            if (code === "service_not_found") {
-                throw new Error(`Service "${service}" does not exist.`);
-            }
-            throw new Error(text);
-        }
-        return Array.isArray(response.events)
-            ? response.events
-                .filter((entry) => entry && typeof entry === "object")
-                .map((entry) => entry)
-            : [{ event: "signaled", service, signal }];
-    };
-    const deleteService = async (name, service) => {
-        requireAlias(name);
-        validateManagedServiceName(service);
-        const response = await runControlRequest({ type: "service_delete", serviceName: service, actor: serviceRole }, "service_delete_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            if (code === "service_not_found") {
-                throw new SpritesApiError(404, "DELETE", `/v1/sprites/${encodeURIComponent(name)}/services/${encodeURIComponent(service)}`, text);
-            }
-            throw new Error(text);
-        }
-    };
-    const readServiceLogs = async (name, service, options) => {
-        requireAlias(name);
-        validateManagedServiceName(service);
-        const tailValue = typeof options?.tail === "number" && Number.isFinite(options.tail)
-            ? Math.max(1, Math.min(20_000, Math.floor(options.tail)))
-            : 200;
-        const response = await runControlRequest({ type: "service_logs_tail", serviceName: service, tail: tailValue }, "service_logs_tail_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            throw new Error(text);
-        }
-        const lines = Array.isArray(response.lines)
-            ? response.lines.map((entry) => String(entry))
-            : [];
-        return lines.join("\n");
-    };
-    const parseKillTimeoutOption = (value) => {
-        if (!value)
-            return undefined;
-        const trimmed = value.trim().toLowerCase();
-        if (!trimmed)
-            return undefined;
-        const match = /^(\d+)(ms|s|m)?$/.exec(trimmed);
-        if (!match)
-            return undefined;
-        const amount = Number.parseInt(match[1] ?? "", 10);
-        if (!Number.isFinite(amount) || amount <= 0) {
-            return undefined;
-        }
-        const unit = match[2] ?? "ms";
-        if (unit === "ms")
-            return amount;
-        if (unit === "s")
-            return amount * 1000;
-        if (unit === "m")
-            return amount * 60_000;
-        return undefined;
-    };
-    const runControlRequest = async (requestPayload, expectedType, options) => {
-        const requestType = typeof requestPayload.type === "string" ? requestPayload.type : "unknown";
-        const responseTimeoutMs = clampModalControlTimeoutMs(options?.responseTimeoutMs ?? MODAL_DAEMON_REQUEST_TIMEOUT_MS);
-        return await withDevboxSpan("modal.control.request", buildModalControlTraceAttributes(alias, requestPayload, expectedType, responseTimeoutMs), async () => {
-            const startedAt = Date.now();
-            try {
-                return await runDirectDaemonControlRequest({
-                    alias,
-                    provider: "modal",
-                    resolveConnectInfo: resolveDaemonConnectInfo,
-                    requestPayload,
-                    expectedType,
-                    timeoutMs: responseTimeoutMs,
-                });
-            }
-            catch (error) {
-                logger.error("modal_control_request_failed", {
-                    alias,
-                    requestType,
-                    expectedType,
-                    responseTimeoutMs,
-                    durationMs: Date.now() - startedAt,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
-            }
-        });
-    };
-    const listExecSessions = async (name) => {
-        requireAlias(name);
-        const response = await runControlRequest({ type: "sessions_list" }, "sessions_list_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            throw new Error(text);
-        }
-        const records = Array.isArray(response.sessions) ? response.sessions : [];
-        const sessions = [];
-        for (const entry of records) {
-            const mapped = mapDaemonControlSessionRecord(entry);
-            if (!mapped)
-                continue;
-            sessions.push(mapped);
-        }
-        return sessions;
-    };
-    const killExecSession = async (name, sessionId, options) => {
-        requireAlias(name);
-        const timeoutMs = parseKillTimeoutOption(options?.timeout);
-        const response = await runControlRequest({
-            type: "session_kill",
-            sessionId,
-            ...(options?.signal ? { signal: options.signal } : {}),
-            ...(typeof timeoutMs === "number" ? { timeoutMs } : {}),
-        }, "session_kill_result", typeof timeoutMs === "number"
-            ? {
-                responseTimeoutMs: clampModalControlTimeoutMs(timeoutMs + 5_000),
-            }
-            : undefined);
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, "Modal daemon control request failed.");
-            if (code === "not_found") {
-                throw new SpritesApiError(404, "DELETE", `/v1/sprites/${encodeURIComponent(name)}/exec/${encodeURIComponent(sessionId)}`, text);
-            }
-            throw new Error(text);
-        }
-        return Array.isArray(response.events)
-            ? response.events
-                .filter((entry) => entry && typeof entry === "object")
-                .map((entry) => entry)
-            : [{ event: "killed", session_id: sessionId }];
-    };
-    const openExecSession = (name, options) => {
-        const normalizedAlias = name.trim();
-        requireAlias(normalizedAlias);
-        return new DirectDaemonExecSocket("modal", resolveDaemonConnectInfo, normalizedAlias, options);
-    };
-    const attachExecSession = (name, sessionId) => {
-        const normalizedAlias = name.trim();
-        requireAlias(normalizedAlias);
-        return new DirectDaemonExecSocket("modal", resolveDaemonConnectInfo, normalizedAlias, {
-            cmd: [],
-            tty: true,
-            stdin: true,
-            sessionId,
-        });
-    };
-    const createCheckpoint = async (name, options) => {
-        requireAlias(name);
-        if (modal) {
-            const sandbox = await resolveSandbox();
-            const image = await sandbox.snapshotFilesystem();
-            const checkpointId = `v${Date.now()}${Math.floor(Math.random() * 10_000)}`;
-            return [
-                {
-                    id: checkpointId,
-                    checkpoint_id: checkpointId,
-                    provider: "modal",
-                    provider_checkpoint_id: image.imageId,
-                    ...(options?.comment ? { comment: options.comment } : {}),
-                },
-            ];
-        }
-        if (createCheckpointViaControlPlane) {
-            return await createCheckpointViaControlPlane(options?.comment);
-        }
-        throw new Error("Modal checkpoint creation is unavailable. Run `dvb setup` or provide Modal BYO credentials.");
-    };
-    return {
-        writeFile,
-        readFile,
-        exec,
-        listExecSessions,
-        killExecSession,
-        createCheckpoint,
-        listServices,
-        getService,
-        createService,
-        startService,
-        stopService,
-        listServiceRecords,
-        getServiceRecord,
-        upsertServiceRecord,
-        signalService,
-        deleteService,
-        readServiceLogs,
-        openExecSession,
-        attachExecSession,
-    };
-};
-export { createModalRuntimeClient };
-//# sourceMappingURL=modalRuntime.js.map