@boxes-dev/dvb-runtime 1.0.298 → 1.0.299

package/dist/devbox/commands/init/provider/e2bRuntime.js

@@ -1,679 +0,0 @@
-import path from "node:path";
-import { CommandExitError, NotFoundError, Sandbox } from "e2b";
-import { ProviderNotImplementedError, SpritesApiError, } from "@boxes-dev/core";
-import { createManagedCheckpoint, fetchE2bBootstrapConnectInfo, fetchManagedDaemonConnectInfo, isManagedDaemonNotReadyError, } from "../../../controlPlane.js";
-import { coerceE2bExecResponse } from "../../../e2bExecErrors.js";
-import { CORE_SERVICE_NAMES, mapDaemonControlSessionRecord, mapProviderServiceRecord, mapProviderServiceRecordToSpriteService, parseDaemonControlError, } from "../../provider/daemonRuntimeShared.js";
-import { DirectDaemonExecSocket, isDirectDaemonTransportError, runDirectDaemonControlRequest, } from "../../provider/directDaemonRuntime.js";
-const E2B_NATIVE_WRITE_THRESHOLD_BYTES = 512 * 1024;
-const E2B_DAEMON_CONTROL_TIMEOUT_MS = 15_000;
-const E2B_EXPECTED_RUNTIME_USER = "boxes";
-const E2B_EXPECTED_RUNTIME_HOME = "/home/boxes";
-const MANAGED_DAEMON_CONTROL_ERROR = "Managed daemon control request failed.";
-const requireAlias = (value) => {
-    const alias = value.trim();
-    if (!alias) {
-        throw new Error("Devbox alias is required.");
-    }
-    return alias;
-};
-const requireControlPlaneToken = (value) => {
-    const token = value.trim();
-    if (!token) {
-        throw new Error("Control plane session required for managed runtime operations.");
-    }
-    return token;
-};
-const shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
-const normalizeRemotePath = (targetPath, workingDir) => {
-    const trimmedPath = targetPath.trim();
-    if (!trimmedPath) {
-        throw new Error("path is required.");
-    }
-    if (path.posix.isAbsolute(trimmedPath)) {
-        return path.posix.normalize(trimmedPath);
-    }
-    const baseDir = workingDir?.trim();
-    if (!baseDir) {
-        throw new Error(`Relative path "${targetPath}" requires workingDir to be provided.`);
-    }
-    if (!path.posix.isAbsolute(baseDir)) {
-        throw new Error(`workingDir must be absolute: ${workingDir}`);
-    }
-    return path.posix.normalize(path.posix.join(baseDir, trimmedPath));
-};
-const serializeCommand = (cmd) => {
-    if (cmd.length === 0) {
-        throw new Error("cmd must contain at least one argument.");
-    }
-    const [command, ...args] = cmd;
-    if (!command || !command.trim()) {
-        throw new Error("cmd[0] must be a non-empty string.");
-    }
-    return [command, ...args].map((segment) => shellQuote(segment)).join(" ");
-};
-const toArrayBuffer = (data) => {
-    const bytes = Buffer.from(data);
-    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
-};
-const createBootstrapSandbox = (connectInfo) => new Sandbox({
-    sandboxId: connectInfo.sandboxId,
-    sandboxDomain: connectInfo.sandboxDomain,
-    envdVersion: connectInfo.envdVersion,
-    envdAccessToken: connectInfo.envdAccessToken,
-    ...(connectInfo.trafficAccessToken
-        ? { trafficAccessToken: connectInfo.trafficAccessToken }
-        : {}),
-});
-const createDefaultBootstrapTransport = (options) => {
-    const sandboxByAlias = new Map();
-    const resolveSandbox = async (alias) => {
-        const cached = sandboxByAlias.get(alias);
-        if (cached) {
-            return await cached;
-        }
-        const pending = options
-            .resolveBootstrapConnectInfo(alias)
-            .then((connectInfo) => createBootstrapSandbox(connectInfo))
-            .catch((error) => {
-            sandboxByAlias.delete(alias);
-            throw error;
-        });
-        sandboxByAlias.set(alias, pending);
-        return await pending;
-    };
-    return {
-        exec: async (alias, cmd, execOptions) => {
-            const sandbox = await resolveSandbox(alias);
-            try {
-                const completed = await sandbox.commands.run(serializeCommand(cmd), {
-                    ...(typeof execOptions?.timeoutMs === "number"
-                        ? { timeoutMs: execOptions.timeoutMs }
-                        : {}),
-                });
-                return {
-                    exitCode: completed.exitCode,
-                    stdout: completed.stdout,
-                    stderr: completed.stderr,
-                };
-            }
-            catch (error) {
-                if (error instanceof CommandExitError) {
-                    const providerError = typeof error.error === "string" ? error.error.trim() : "";
-                    const stderr = error.stderr || providerError;
-                    return {
-                        exitCode: error.exitCode,
-                        stdout: error.stdout,
-                        stderr,
-                    };
-                }
-                throw error;
-            }
-        },
-        readFile: async (alias, readOptions) => {
-            const sandbox = await resolveSandbox(alias);
-            const resolvedPath = normalizeRemotePath(readOptions.path, readOptions.workingDir);
-            try {
-                return await sandbox.files.read(resolvedPath, { format: "bytes" });
-            }
-            catch (error) {
-                if (error instanceof NotFoundError) {
-                    throw new Error(`E2B_FILE_NOT_FOUND:${resolvedPath}`);
-                }
-                throw error;
-            }
-        },
-        writeFile: async (alias, writeOptions) => {
-            const sandbox = await resolveSandbox(alias);
-            const resolvedPath = normalizeRemotePath(writeOptions.path);
-            await sandbox.files.write(resolvedPath, toArrayBuffer(writeOptions.data));
-        },
-    };
-};
-const buildE2bRuntimeIdentityCommand = () => [
-    "/bin/bash",
-    "--noprofile",
-    "--norc",
-    "-lc",
-    [
-        "set -euo pipefail",
-        'printf \'user=%s\\nhome=%s\\npwd=%s\\n\' "$(whoami)" "$HOME" "$PWD"',
-    ].join("\n"),
-];
-const parseE2bRuntimeIdentity = (stdout) => {
-    const values = new Map();
-    for (const line of stdout.split(/\r?\n/)) {
-        const separatorIndex = line.indexOf("=");
-        if (separatorIndex <= 0) {
-            continue;
-        }
-        const key = line.slice(0, separatorIndex).trim();
-        const value = line.slice(separatorIndex + 1).trim();
-        if (!key || !value) {
-            continue;
-        }
-        values.set(key, value);
-    }
-    const user = values.get("user") ?? "";
-    const home = values.get("home") ?? "";
-    const pwd = values.get("pwd") ?? "";
-    if (!user || !home || !pwd) {
-        throw new Error(`Managed runtime identity probe returned unexpected output: ${stdout.trim() || "(empty)"}`);
-    }
-    return { user, home, pwd };
-};
-const formatE2bRuntimeIdentity = (identity) => `user=${identity.user} home=${identity.home} pwd=${identity.pwd}`;
-const buildUnsupportedE2bRuntimeIdentityMessage = (alias, identity) => [
-    `Devbox "${alias}" is using an unsupported runtime identity ${formatE2bRuntimeIdentity(identity)}.`,
-    `Expected user=${E2B_EXPECTED_RUNTIME_USER} home=${E2B_EXPECTED_RUNTIME_HOME} pwd=${E2B_EXPECTED_RUNTIME_HOME}.`,
-    "This devbox was provisioned from an outdated managed template.",
-    "Destroy it and re-run `dvb init` after updating the managed template.",
-].join(" ");
-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 isE2bBootstrapPendingError = (error) => {
-    if (isDirectDaemonTransportError(error)) {
-        return error.retryable;
-    }
-    if (isManagedDaemonNotReadyError(error)) {
-        return error.provider === "e2b" && error.state === "pending";
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return (message.includes("Failed to read managed daemon config") ||
-        message.includes("daemon host is unavailable"));
-};
-const coerceBootstrapReadFileError = (targetPath, error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("E2B_FILE_NOT_FOUND:")) {
-        throw new SpritesApiError(404, "GET", targetPath, "path does not exist");
-    }
-    throw error;
-};
-const throwE2bNotImplemented = (capability) => {
-    throw new ProviderNotImplementedError({
-        provider: "e2b",
-        capability,
-        message: `Managed init runtime capability "${capability}" is not implemented yet.`,
-    });
-};
-const createE2bInitRuntimeClient = (options) => {
-    const controlPlaneToken = requireControlPlaneToken(options.controlPlaneToken);
-    const serviceRole = options.serviceRole ?? "user";
-    const transportMode = options.transportMode ?? "auto";
-    const daemonConnectInfoByAlias = new Map();
-    const daemonReadyAliases = new Set();
-    const resolveBootstrapConnectInfo = options.resolveBootstrapConnectInfo ??
-        (async (alias) => {
-            const info = await fetchE2bBootstrapConnectInfo(controlPlaneToken, alias);
-            return {
-                sandboxId: info.sandboxId,
-                sandboxDomain: info.sandboxDomain,
-                envdVersion: info.envdVersion,
-                envdAccessToken: info.envdAccessToken,
-                trafficAccessToken: info.trafficAccessToken,
-            };
-        });
-    const bootstrapTransport = options.bootstrapTransport ??
-        createDefaultBootstrapTransport({ resolveBootstrapConnectInfo });
-    const bootstrapIdentityByAlias = new Map();
-    const ensureBootstrapRuntimeIdentity = async (name) => {
-        const alias = requireAlias(name);
-        const cached = bootstrapIdentityByAlias.get(alias);
-        if (cached) {
-            await cached;
-            return;
-        }
-        const pending = bootstrapTransport
-            .exec(alias, buildE2bRuntimeIdentityCommand(), {
-            timeoutMs: E2B_DAEMON_CONTROL_TIMEOUT_MS,
-        })
-            .then((result) => {
-            if (result.exitCode !== 0) {
-                throw new Error(`Managed runtime identity check failed for "${alias}": ${result.stderr || result.stdout || "unknown error"}`);
-            }
-            const identity = parseE2bRuntimeIdentity(result.stdout);
-            if (identity.user !== E2B_EXPECTED_RUNTIME_USER ||
-                identity.home !== E2B_EXPECTED_RUNTIME_HOME ||
-                identity.pwd !== E2B_EXPECTED_RUNTIME_HOME) {
-                throw new Error(buildUnsupportedE2bRuntimeIdentityMessage(alias, identity));
-            }
-        })
-            .catch((error) => {
-            bootstrapIdentityByAlias.delete(alias);
-            throw error;
-        });
-        bootstrapIdentityByAlias.set(alias, pending);
-        await pending;
-    };
-    const createCheckpoint = async (name, checkpointOptions) => {
-        const alias = requireAlias(name);
-        return await createManagedCheckpoint(controlPlaneToken, alias, checkpointOptions?.comment);
-    };
-    const resolveDaemonConnectInfo = async ({ alias: rawAlias, forceRefresh, allowWake, }) => {
-        const alias = requireAlias(rawAlias);
-        if (forceRefresh) {
-            daemonConnectInfoByAlias.delete(alias);
-        }
-        const cached = daemonConnectInfoByAlias.get(alias);
-        if (cached) {
-            const info = await cached;
-            return {
-                provider: "e2b",
-                url: info.url,
-                authToken: info.token,
-            };
-        }
-        const resolveConnectInfo = options.resolveDaemonConnectInfo ??
-            (async (resolvedAlias) => {
-                const connectInfo = await fetchManagedDaemonConnectInfo(controlPlaneToken, resolvedAlias, "proxy", allowWake);
-                if (connectInfo.provider !== "e2b") {
-                    throw new Error(`Managed daemon connect returned provider "${connectInfo.provider}" for alias "${resolvedAlias}".`);
-                }
-                return connectInfo;
-            });
-        const pending = resolveConnectInfo(alias)
-            .then((info) => ({
-            url: info.url,
-            token: info.token,
-        }))
-            .catch((error) => {
-            daemonConnectInfoByAlias.delete(alias);
-            throw error;
-        });
-        daemonConnectInfoByAlias.set(alias, pending);
-        const info = await pending;
-        return {
-            provider: "e2b",
-            url: info.url,
-            authToken: info.token,
-        };
-    };
-    const runControlRequest = async (name, requestPayload, expectedType, timeoutMs = E2B_DAEMON_CONTROL_TIMEOUT_MS) => {
-        const alias = requireAlias(name);
-        return await runDirectDaemonControlRequest({
-            alias,
-            provider: "e2b",
-            resolveConnectInfo: resolveDaemonConnectInfo,
-            requestPayload,
-            expectedType,
-            timeoutMs,
-        });
-    };
-    const exec = async (name, cmd, execOptions) => {
-        const alias = requireAlias(name);
-        if (transportMode === "bootstrap_only") {
-            await ensureBootstrapRuntimeIdentity(alias);
-            return await bootstrapTransport.exec(alias, cmd, {
-                ...(typeof execOptions?.timeoutMs === "number"
-                    ? { timeoutMs: execOptions.timeoutMs }
-                    : {}),
-            });
-        }
-        let response;
-        try {
-            response = await runControlRequest(alias, {
-                type: "exec",
-                cmd,
-                ...(typeof execOptions?.timeoutMs === "number"
-                    ? { timeoutMs: execOptions.timeoutMs }
-                    : {}),
-            }, "exec_result", typeof execOptions?.timeoutMs === "number"
-                ? Math.max(E2B_DAEMON_CONTROL_TIMEOUT_MS, execOptions.timeoutMs + 5_000)
-                : E2B_DAEMON_CONTROL_TIMEOUT_MS);
-            daemonReadyAliases.add(alias);
-        }
-        catch (error) {
-            if (daemonReadyAliases.has(alias) || !isE2bBootstrapPendingError(error)) {
-                throw error;
-            }
-            await ensureBootstrapRuntimeIdentity(alias);
-            return await bootstrapTransport.exec(alias, cmd, {
-                ...(typeof execOptions?.timeoutMs === "number"
-                    ? { timeoutMs: execOptions.timeoutMs }
-                    : {}),
-            });
-        }
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            throw new Error(text);
-        }
-        return coerceE2bExecResponse(response);
-    };
-    const writeFileWithBootstrapTransport = async (alias, remotePath, bytes, writeOptions) => {
-        await ensureBootstrapRuntimeIdentity(alias);
-        await bootstrapTransport.writeFile(alias, {
-            path: remotePath,
-            data: bytes,
-        });
-        writeOptions?.onProgress?.(bytes.length, bytes.length);
-    };
-    const readFile = async (name, readOptions) => {
-        const alias = requireAlias(name);
-        if (transportMode === "bootstrap_only") {
-            await ensureBootstrapRuntimeIdentity(alias);
-            try {
-                return await bootstrapTransport.readFile(alias, {
-                    path: readOptions.path,
-                    ...(typeof readOptions.workingDir === "string"
-                        ? { workingDir: readOptions.workingDir }
-                        : {}),
-                });
-            }
-            catch (error) {
-                return coerceBootstrapReadFileError(readOptions.path, error);
-            }
-        }
-        let response;
-        try {
-            response = await runControlRequest(alias, {
-                type: "fs_read",
-                path: readOptions.path,
-                ...(typeof readOptions.workingDir === "string"
-                    ? { workingDir: readOptions.workingDir }
-                    : {}),
-            }, "fs_read_result");
-            daemonReadyAliases.add(alias);
-        }
-        catch (error) {
-            if (daemonReadyAliases.has(alias) || !isE2bBootstrapPendingError(error)) {
-                throw error;
-            }
-            await ensureBootstrapRuntimeIdentity(alias);
-            try {
-                return await bootstrapTransport.readFile(alias, {
-                    path: readOptions.path,
-                    ...(typeof readOptions.workingDir === "string"
-                        ? { workingDir: readOptions.workingDir }
-                        : {}),
-                });
-            }
-            catch (bootstrapError) {
-                return coerceBootstrapReadFileError(readOptions.path, bootstrapError);
-            }
-        }
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            if (code === "not_found") {
-                throw new SpritesApiError(404, "GET", readOptions.path, 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, writeOptions) => {
-        const alias = requireAlias(name);
-        const bytes = Uint8Array.from(data);
-        writeOptions?.onProgress?.(0, bytes.length);
-        if (transportMode === "bootstrap_only" ||
-            bytes.length > E2B_NATIVE_WRITE_THRESHOLD_BYTES) {
-            await writeFileWithBootstrapTransport(alias, remotePath, bytes, writeOptions);
-            return;
-        }
-        let response;
-        try {
-            response = await runControlRequest(alias, {
-                type: "fs_write",
-                path: remotePath,
-                mkdir: true,
-                data: Buffer.from(bytes).toString("base64"),
-            }, "fs_write_result");
-            daemonReadyAliases.add(alias);
-        }
-        catch (error) {
-            if (daemonReadyAliases.has(alias) || !isE2bBootstrapPendingError(error)) {
-                throw error;
-            }
-            await writeFileWithBootstrapTransport(alias, remotePath, bytes, writeOptions);
-            return;
-        }
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            throw new Error(text);
-        }
-        writeOptions?.onProgress?.(bytes.length, bytes.length);
-    };
-    const listServiceRecords = async (name) => {
-        const response = await runControlRequest(name, { type: "services_list" }, "services_list_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            throw new Error(text);
-        }
-        const records = Array.isArray(response.services) ? response.services : [];
-        return records.map((entry) => mapProviderServiceRecord(entry));
-    };
-    const getServiceRecord = async (name, service) => {
-        const response = await runControlRequest(name, { type: "service_get", serviceName: service }, "service_get_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            if (code === "service_not_found") {
-                return null;
-            }
-            throw new Error(text);
-        }
-        return mapProviderServiceRecord(response.service);
-    };
-    const upsertServiceRecord = async (name, service, input) => {
-        const response = await runControlRequest(name, {
-            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 { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            throw new Error(text);
-        }
-        return mapProviderServiceRecord(response.service);
-    };
-    const listExecSessions = async (name) => {
-        const response = await runControlRequest(name, { type: "sessions_list" }, "sessions_list_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            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) => {
-        const alias = requireAlias(name);
-        const normalizedSessionId = sessionId.trim();
-        if (!normalizedSessionId) {
-            throw new Error("Session id is required.");
-        }
-        const timeoutMs = parseKillTimeoutOption(options?.timeout);
-        const response = await runControlRequest(alias, {
-            type: "session_kill",
-            sessionId: normalizedSessionId,
-            ...(options?.signal ? { signal: options.signal } : {}),
-            ...(typeof timeoutMs === "number" ? { timeoutMs } : {}),
-        }, "session_kill_result", typeof timeoutMs === "number"
-            ? Math.max(E2B_DAEMON_CONTROL_TIMEOUT_MS, timeoutMs + 5_000)
-            : E2B_DAEMON_CONTROL_TIMEOUT_MS);
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            if (code === "not_found") {
-                throw new SpritesApiError(404, "DELETE", `/v1/sprites/${encodeURIComponent(alias)}/exec/${encodeURIComponent(normalizedSessionId)}`, 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: normalizedSessionId }];
-    };
-    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 createService = async (name, service, input) => {
-        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 upsertServiceRecord(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",
-        });
-        if (!record) {
-            throw new Error(`Service "${service}" failed to initialize.`);
-        }
-        return mapProviderServiceRecordToSpriteService(record);
-    };
-    const startService = async (name, service) => {
-        const response = await runControlRequest(name, { type: "service_start", serviceName: service, actor: serviceRole }, "service_start_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            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) => {
-        const response = await runControlRequest(name, {
-            type: "service_stop",
-            serviceName: service,
-            actor: serviceRole,
-            ...(options?.timeout ? { timeout: options.timeout } : {}),
-        }, "service_stop_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            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) => {
-        const response = await runControlRequest(name, {
-            type: "service_signal",
-            serviceName: service,
-            actor: serviceRole,
-            signal: typeof options?.signal === "string" &&
-                options.signal.trim().length > 0
-                ? options.signal.trim()
-                : "TERM",
-        }, "service_signal_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            throw new Error(text);
-        }
-        return Array.isArray(response.events)
-            ? response.events
-                .filter((entry) => entry && typeof entry === "object")
-                .map((entry) => entry)
-            : [{ event: "signaled", service }];
-    };
-    const deleteService = async (name, service) => {
-        const response = await runControlRequest(name, { type: "service_delete", serviceName: service, actor: serviceRole }, "service_delete_result");
-        if (response.status !== "ok") {
-            const { code, text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            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) => {
-        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(name, { type: "service_logs_tail", serviceName: service, tail: tailValue }, "service_logs_tail_result");
-        if (response.status !== "ok") {
-            const { text } = parseDaemonControlError(response, MANAGED_DAEMON_CONTROL_ERROR);
-            throw new Error(text);
-        }
-        const lines = Array.isArray(response.lines)
-            ? response.lines.map((entry) => String(entry))
-            : [];
-        return lines.join("\n");
-    };
-    const openExecSession = (name, options) => {
-        const alias = requireAlias(name);
-        return new DirectDaemonExecSocket("e2b", resolveDaemonConnectInfo, alias, options);
-    };
-    const attachExecSession = (name, sessionId) => {
-        const alias = requireAlias(name);
-        return new DirectDaemonExecSocket("e2b", resolveDaemonConnectInfo, alias, {
-            cmd: [],
-            tty: true,
-            stdin: true,
-            sessionId,
-        });
-    };
-    return {
-        exec,
-        readFile,
-        writeFile,
-        createCheckpoint,
-        listExecSessions,
-        killExecSession,
-        listServices,
-        getService,
-        createService,
-        startService,
-        stopService,
-        signalService,
-        deleteService,
-        readServiceLogs,
-        listServiceRecords,
-        getServiceRecord,
-        upsertServiceRecord,
-        openExecSession,
-        attachExecSession,
-    };
-};
-export { createE2bInitRuntimeClient };
-//# sourceMappingURL=e2bRuntime.js.map