@geminixiang/mikan 1.0.0-beta.3 → 1.0.0-beta.30

package/dist/sandbox/gondolin.js

@@ -0,0 +1,764 @@
+import { createHash, randomBytes } from "node:crypto";
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import * as log from "../log.js";
+import { withRuntimeBootstrap } from "./container.js";
+import { SandboxError } from "./errors.js";
+import { createMountedRuntimePathContext } from "./path-context.js";
+import { execReadFile, execReadFileBase64, execWriteFile, shellEscape } from "./utils.js";
+const MINIMUM_NODE_VERSION = [23, 6, 0];
+const MIKAN_IMAGE = "mikan-sandbox:latest";
+/** Write-back cadence for projected `/workspace` files (e.g. MEMORY.md). */
+const PROJECTION_SYNC_INTERVAL_MS = 2000;
+const PROJECTION_LOCK_RETRY_MS = 25;
+const PROJECTION_LOCK_STALE_MS = 60_000;
+/**
+ * A command may quietly work for a long time, but a session that produces no
+ * frame at all for this long is indistinguishable from one wedged on dead
+ * storage (for example, blocked guest workspace I/O) — kill it and say so
+ * instead of hanging the run.
+ */
+const EXEC_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+const sessions = new Map();
+const transitions = new Map();
+let activeShutdowns = 0;
+let shutdownGeneration = 0;
+/*
+ * Crash-recovery vocabulary.
+ *
+ * - **Gone**: the command never reached the runtime because its session socket
+ *   refused the connection. Recreating the runtime and retrying is safe.
+ * - **Interrupted**: the runtime died or went silent with a command in flight.
+ *   Side effects may have landed, so the failure must surface.
+ */
+/**
+ * The runtime is gone and the command never reached it (the session socket
+ * refused the connection) — safe to recreate the runtime and retry.
+ */
+class GondolinRuntimeGoneError extends Error {
+}
+/** The runtime died with the command in flight — not safe to retry blindly. */
+class GondolinRuntimeInterruptedError extends Error {
+}
+class GondolinResourceManager {
+    constructor() {
+        this.boostedKeys = new Set();
+        this.overrideLimits = new Map();
+    }
+    configure(defaultLimits, boostLimits) {
+        this.defaultLimits = defaultLimits;
+        this.boostLimits = boostLimits;
+        this.boostedKeys.clear();
+        this.overrideLimits.clear();
+    }
+    async boost(key) {
+        if (this.boostLimits?.cpus || this.boostLimits?.memory) {
+            this.overrideLimits.delete(key);
+            this.boostedKeys.add(key);
+        }
+        return this.getLimitStatus(key);
+    }
+    async setLimits(key, limits) {
+        this.boostedKeys.delete(key);
+        this.overrideLimits.set(key, { ...this.defaultLimits, ...limits });
+        return this.getLimitStatus(key);
+    }
+    getLimitStatus(key) {
+        return { limits: this.effectiveLimits(key), boosted: this.boostedKeys.has(key) };
+    }
+    getDefaultLimits() {
+        return this.defaultLimits;
+    }
+    getBoostLimits() {
+        return this.boostLimits;
+    }
+    clear(key) {
+        this.boostedKeys.delete(key);
+        this.overrideLimits.delete(key);
+    }
+    effectiveLimits(key) {
+        const override = this.overrideLimits.get(key);
+        if (override)
+            return override;
+        if (!this.boostedKeys.has(key))
+            return this.defaultLimits;
+        return { ...this.defaultLimits, ...this.boostLimits };
+    }
+}
+export const gondolinResources = new GondolinResourceManager();
+/** Configure the Gondolin resource controller. */
+export function configureGondolinRuntime(options) {
+    gondolinResources.configure(options.limits, options.boostLimits);
+}
+function parseGondolinSandboxArg(value) {
+    if (!value.startsWith("gondolin:"))
+        return undefined;
+    const profile = value.slice("gondolin:".length);
+    if (!profile) {
+        throw new SandboxError("Error: gondolin sandbox requires a profile (e.g., gondolin:default)");
+    }
+    if (profile !== "default") {
+        throw new SandboxError(`Error: unsupported gondolin profile '${profile}'. Use 'gondolin:default'`);
+    }
+    return { type: "gondolin", profile };
+}
+function assertSupportedNodeVersion() {
+    const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+    if (major < MINIMUM_NODE_VERSION[0] || (major === MINIMUM_NODE_VERSION[0] && minor < 6)) {
+        throw new SandboxError(`Error: gondolin:default requires Node.js >=23.6.0 (current: ${process.versions.node}). Other sandbox modes remain available on Node.js >=22.19.0.`);
+    }
+}
+async function validateGondolinSandbox() {
+    assertSupportedNodeVersion();
+    console.log("  Gondolin microVM enabled. Profile: default");
+}
+async function resolveDesiredRuntime(config) {
+    const selector = config.image ?? MIKAN_IMAGE;
+    const { ensureImageSelector } = (await import("@earendil-works/gondolin"));
+    const resolvedImage = await ensureImageSelector(selector);
+    const image = resolvedImage.assetDir;
+    const imageIdentity = resolvedImage.buildId ?? resolvedImage.assetDir;
+    const mounts = (config.mounts ?? [{ source: config.workspacePath ?? process.cwd(), target: "/workspace" }]).toSorted((left, right) => left.target.localeCompare(right.target));
+    return {
+        image,
+        imageIdentity,
+        mounts,
+        credentialIdentity: credentialIdentity(mounts),
+        limits: config.resourceKey
+            ? gondolinResources.getLimitStatus(config.resourceKey).limits
+            : undefined,
+    };
+}
+/**
+ * Content hashes of credential file mounts (files projected outside
+ * /workspace). Rotating a credential on the host changes the fingerprint, so
+ * the next command recreates the runtime with a fresh projection instead of
+ * serving the stale copy for the rest of the VM's life. Workspace files are
+ * excluded: the guest writes them back, which would drift the runtime it runs
+ * in.
+ */
+function credentialIdentity(mounts) {
+    const identity = {};
+    for (const mount of mounts) {
+        if (mount.target.startsWith("/workspace/") || mount.target === "/workspace")
+            continue;
+        try {
+            if (!statSync(mount.source).isFile())
+                continue;
+            identity[mount.target] = createHash("sha256")
+                .update(readFileSync(mount.source))
+                .digest("hex");
+        }
+        catch {
+            // missing source: creation skips it too, so it has no runtime identity
+        }
+    }
+    return identity;
+}
+function runtimeFingerprint(desired) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        image: desired.imageIdentity,
+        mounts: desired.mounts,
+        credentials: desired.credentialIdentity,
+        limits: desired.limits,
+    }))
+        .digest("hex");
+}
+function gondolinCpuCount(cpus) {
+    if (cpus === undefined)
+        return undefined;
+    const parsed = Number(cpus);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new SandboxError(`Error: invalid Gondolin CPU limit '${cpus}'`);
+    }
+    // ponytail: Gondolin exposes whole vCPUs; add host cgroup quotas if fractional enforcement matters.
+    return Math.ceil(parsed);
+}
+function sha256(data) {
+    return createHash("sha256").update(data).digest("hex");
+}
+function partitionMounts(mounts) {
+    const directories = [];
+    const files = [];
+    for (const mount of mounts) {
+        let isDirectory;
+        try {
+            isDirectory = statSync(mount.source).isDirectory();
+        }
+        catch {
+            log.logWarning(`Skipping missing Gondolin mount source ${mount.source}`);
+            continue;
+        }
+        if (isDirectory) {
+            directories.push(mount);
+        }
+        else {
+            files.push({
+                ...mount,
+                syncBack: mount.target.startsWith("/workspace/"),
+                lastHash: "",
+            });
+        }
+    }
+    return { directories, files };
+}
+/** Copy file mounts into the guest; credentials get user-only permissions. */
+async function projectFiles(vm, files) {
+    for (const projection of files) {
+        const content = readFileSync(projection.source);
+        await vm.fs.mkdir(dirname(projection.target), { recursive: true });
+        await vm.fs.writeFile(projection.target, content);
+        if (!projection.syncBack) {
+            // credential projection: no write-back, keep it owner-only
+            await vm.exec(`chmod 600 ${shellEscape(projection.target)}`);
+        }
+        projection.lastHash = sha256(content);
+    }
+}
+function restrictSocketAccess(socketPath) {
+    // The session socket grants arbitrary exec inside the VM (and through its
+    // mounts, the workspace) — keep it to this user even under a lax umask.
+    try {
+        chmodSync(dirname(socketPath), 0o700);
+        chmodSync(socketPath, 0o600);
+    }
+    catch {
+        // best-effort hardening
+    }
+}
+function projectionLockIsStale(lockPath) {
+    let ownerKnown = false;
+    let ownerAlive = false;
+    try {
+        const pid = Number(readFileSync(join(lockPath, "owner"), "utf8").trim());
+        if (Number.isInteger(pid) && pid > 0) {
+            ownerKnown = true;
+            try {
+                process.kill(pid, 0);
+                ownerAlive = true;
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === "EPERM")
+                    ownerAlive = true;
+            }
+        }
+    }
+    catch {
+        // An owner file may not have been written before its process died.
+    }
+    try {
+        const oldEnough = Date.now() - statSync(lockPath).mtimeMs >= PROJECTION_LOCK_STALE_MS;
+        return (ownerKnown && !ownerAlive) || oldEnough;
+    }
+    catch {
+        return false;
+    }
+}
+async function withProjectionLock(source, operation) {
+    const lockPath = `${source}.mikan-sync.lock`;
+    for (;;) {
+        try {
+            mkdirSync(lockPath, { mode: 0o700 });
+            writeFileSync(join(lockPath, "owner"), `${process.pid}\n`, { mode: 0o600 });
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            if (projectionLockIsStale(lockPath)) {
+                rmSync(lockPath, { recursive: true, force: true });
+                continue;
+            }
+            await new Promise((resolve) => setTimeout(resolve, PROJECTION_LOCK_RETRY_MS));
+        }
+    }
+    try {
+        return await operation();
+    }
+    finally {
+        rmSync(lockPath, { recursive: true, force: true });
+    }
+}
+/** One live microVM owned by this process, addressed by its session socket. */
+class GondolinRuntime {
+    constructor(vm, socketPath, projections) {
+        this.vm = vm;
+        this.socketPath = socketPath;
+        this.projections = projections;
+        this.syncing = false;
+    }
+    /** Boot a VM for the desired configuration and make it command-ready. */
+    static async create(instanceId, desired) {
+        const { VM, RealFSProvider, ReadonlyProvider, findSession } = (await import("@earendil-works/gondolin"));
+        const { directories, files } = partitionMounts(desired.mounts);
+        const vm = await VM.create({
+            sandbox: { imagePath: desired.image },
+            env: { TZ: "Asia/Taipei" },
+            sessionLabel: `mikan:${instanceId}`,
+            cpus: gondolinCpuCount(desired.limits?.cpus),
+            memory: desired.limits?.memory,
+            vfs: {
+                mounts: Object.fromEntries(directories.map(({ source, target, readOnly }) => [
+                    target,
+                    // ReadonlyProvider blocks every write operation on the backing
+                    // provider — gondolin's own answer to read-only host directories.
+                    readOnly
+                        ? new ReadonlyProvider(new RealFSProvider(source))
+                        : new RealFSProvider(source),
+                ])),
+            },
+        });
+        try {
+            await vm.start();
+            await projectFiles(vm, files);
+            const session = await findSession(vm.id);
+            if (!session)
+                throw new Error(`Gondolin session '${vm.id}' did not register`);
+            restrictSocketAccess(session.socketPath);
+            const runtime = new GondolinRuntime(vm, session.socketPath, files);
+            runtime.startProjectionSync();
+            return runtime;
+        }
+        catch (error) {
+            // never leave a half-booted runner (and its overlay disk) behind
+            await vm.close().catch(() => { });
+            throw error;
+        }
+    }
+    /**
+     * Run one command over a dedicated session IPC connection. Aborting (or the
+     * caller's timeout signal firing) destroys the connection, which kills the
+     * in-flight guest process.
+     */
+    async exec(command, options = {}) {
+        return execOverSessionConnect(async (callbacks) => {
+            const { connectToSession } = await import("@earendil-works/gondolin");
+            return connectToSession(this.socketPath, callbacks);
+        }, command, options);
+    }
+    /** Whether the VM runner process is still up. */
+    isAlive() {
+        try {
+            return this.vm.getHostPid() !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Sync projected files back one last time, then shut the VM down. */
+    async close() {
+        this.closing ??= (async () => {
+            clearInterval(this.syncTimer);
+            try {
+                await this.syncProjections();
+            }
+            catch {
+                // best effort; the periodic sync already captured earlier edits
+            }
+            await this.vm.close();
+        })();
+        return this.closing;
+    }
+    startProjectionSync() {
+        if (!this.projections.some((projection) => projection.syncBack))
+            return;
+        this.syncTimer = setInterval(() => void this.syncProjections(), PROJECTION_SYNC_INTERVAL_MS);
+        this.syncTimer.unref?.();
+    }
+    async syncProjections() {
+        if (this.syncing)
+            return;
+        this.syncing = true;
+        try {
+            for (const projection of this.projections) {
+                if (!projection.syncBack)
+                    continue;
+                try {
+                    const data = await this.vm.fs.readFile(projection.target);
+                    const content = Buffer.isBuffer(data) ? data : Buffer.from(String(data));
+                    const hash = sha256(content);
+                    if (hash === projection.lastHash)
+                        continue;
+                    await withProjectionLock(projection.source, async () => {
+                        let hostHash;
+                        try {
+                            hostHash = sha256(readFileSync(projection.source));
+                        }
+                        catch (error) {
+                            if (error.code !== "ENOENT")
+                                throw error;
+                            hostHash = "";
+                        }
+                        if (hostHash !== projection.lastHash) {
+                            const conflict = `${projection.source}.mikan-conflict.${process.pid}.${randomBytes(8).toString("hex")}`;
+                            writeFileSync(conflict, content);
+                            projection.lastHash = hash;
+                            log.logWarning(`Skipped Gondolin projection write-back for '${projection.source}': host content changed; guest content preserved at '${conflict}'`);
+                            return;
+                        }
+                        // atomic host write: a crash mid-sync must not truncate the file
+                        const staged = `${projection.source}.mikan-sync.${process.pid}.${randomBytes(8).toString("hex")}`;
+                        try {
+                            writeFileSync(staged, content);
+                            renameSync(staged, projection.source);
+                            projection.lastHash = hash;
+                        }
+                        finally {
+                            try {
+                                unlinkSync(staged);
+                            }
+                            catch {
+                                // rename succeeded or the staging write failed
+                            }
+                        }
+                    });
+                }
+                catch {
+                    // guest file missing or read raced a writer; next tick retries
+                }
+            }
+        }
+        finally {
+            this.syncing = false;
+        }
+    }
+}
+function abortError() {
+    return new Error("Error: command aborted");
+}
+/**
+ * Run one command through a fresh session connection. Closing the connection
+ * (abort, timeout, or the far side dying) kills the in-flight guest process.
+ */
+export async function execOverSessionConnect(connect, command, options = {}) {
+    if (options.signal?.aborted)
+        throw abortError();
+    const idleTimeoutMs = options.idleTimeoutMs ?? EXEC_IDLE_TIMEOUT_MS;
+    return await new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        let received = false;
+        let settled = false;
+        let client;
+        let idleTimer;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(idleTimer);
+            options.signal?.removeEventListener("abort", onAbort);
+            fn();
+        };
+        const onAbort = () => settle(() => {
+            client?.close();
+            reject(abortError());
+        });
+        const onIdle = () => settle(() => {
+            client?.close();
+            reject(new GondolinRuntimeInterruptedError(`no session activity for ${Math.round(idleTimeoutMs / 1000)}s — killed the command ` +
+                `(guest I/O hangs when the workspace sits on a dead mount; check the workspace health)`));
+        });
+        const armIdleTimer = () => {
+            if (idleTimeoutMs <= 0 || settled)
+                return;
+            clearTimeout(idleTimer);
+            idleTimer = setTimeout(onIdle, idleTimeoutMs);
+            idleTimer.unref?.();
+        };
+        armIdleTimer();
+        const callbacks = {
+            onJson: (message) => {
+                received = true;
+                armIdleTimer();
+                if (message.type === "exec_response" && message.id === 1) {
+                    settle(() => {
+                        client?.close();
+                        resolve({
+                            stdout,
+                            stderr,
+                            code: typeof message.exit_code === "number" ? message.exit_code : 1,
+                        });
+                    });
+                }
+                else if (message.type === "error") {
+                    settle(() => {
+                        client?.close();
+                        reject(new Error(`Error: Gondolin exec failed (${message.code}): ${message.message}`));
+                    });
+                }
+            },
+            onBinary: (frame) => {
+                received = true;
+                armIdleTimer();
+                const tag = frame.readUInt8(0);
+                const data = frame.subarray(5).toString("utf8");
+                if (tag === 1)
+                    stdout += data;
+                else
+                    stderr += data;
+            },
+            onClose: (error) => {
+                settle(() => {
+                    const detail = error?.message ?? "connection closed before the command finished";
+                    const code = error?.code;
+                    if (!received && (code === "ENOENT" || code === "ECONNREFUSED")) {
+                        reject(new GondolinRuntimeGoneError(detail));
+                    }
+                    else {
+                        reject(new GondolinRuntimeInterruptedError(detail));
+                    }
+                });
+            },
+        };
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        Promise.resolve(connect(callbacks))
+            .then((created) => {
+            client = created;
+            if (settled) {
+                created.close();
+                return;
+            }
+            created.send({
+                type: "exec",
+                id: 1,
+                cmd: "/bin/sh",
+                argv: ["-c", command],
+                env: Object.entries(options.env ?? {}).map(([key, value]) => `${key}=${value}`),
+                cwd: "/workspace",
+            });
+        })
+            .catch((err) => settle(() => reject(new GondolinRuntimeGoneError(err instanceof Error ? err.message : String(err)))));
+    });
+}
+function createSession(key, config, desired, fingerprint) {
+    let session;
+    const runtime = GondolinRuntime.create(key, desired).catch((error) => {
+        if (sessions.get(key) === session)
+            sessions.delete(key);
+        throw error;
+    });
+    session = {
+        runtime,
+        fingerprint,
+        resourceKey: config.resourceKey,
+        activeOperations: 0,
+        lastUsed: Date.now(),
+        idleWaiters: [],
+    };
+    return session;
+}
+async function acquireSession(key, config, generation = shutdownGeneration) {
+    if (activeShutdowns > 0 || generation !== shutdownGeneration) {
+        throw new SandboxError("Error: Gondolin runtime is shutting down");
+    }
+    const pending = transitions.get(key);
+    if (pending) {
+        await pending;
+        return acquireSession(key, config, generation);
+    }
+    const desired = await resolveDesiredRuntime(config);
+    if (activeShutdowns > 0 || generation !== shutdownGeneration) {
+        throw new SandboxError("Error: Gondolin runtime is shutting down");
+    }
+    const concurrentTransition = transitions.get(key);
+    if (concurrentTransition) {
+        await concurrentTransition;
+        return acquireSession(key, config, generation);
+    }
+    const fingerprint = runtimeFingerprint(desired);
+    const existing = sessions.get(key);
+    if (existing?.fingerprint === fingerprint) {
+        existing.activeOperations += 1;
+        return existing;
+    }
+    const transition = replaceSession(key, config, desired, fingerprint, existing);
+    transitions.set(key, transition);
+    try {
+        await transition;
+    }
+    finally {
+        if (transitions.get(key) === transition)
+            transitions.delete(key);
+    }
+    return acquireSession(key, config, generation);
+}
+async function replaceSession(key, config, desired, fingerprint, existing) {
+    if (existing) {
+        await closeSession(key, existing, {
+            waitForActiveOperations: true,
+            resetResources: false,
+            throwOnError: true,
+        });
+    }
+    const replacement = createSession(key, config, desired, fingerprint);
+    sessions.set(key, replacement);
+    await replacement.runtime;
+}
+function discardDeadSession(key, session) {
+    if (sessions.get(key) !== session)
+        return;
+    sessions.delete(key);
+    log.logWarning(`Gondolin runtime for '${key}' died; the session will be recreated`);
+}
+async function withRuntime(key, config, operation) {
+    for (let attempt = 0;; attempt += 1) {
+        const session = await acquireSession(key, config);
+        let runtime;
+        try {
+            runtime = await session.runtime;
+            return await operation(runtime);
+        }
+        catch (error) {
+            const gone = error instanceof GondolinRuntimeGoneError;
+            const interrupted = error instanceof GondolinRuntimeInterruptedError;
+            if (gone || (interrupted && runtime && !runtime.isAlive())) {
+                discardDeadSession(key, session);
+            }
+            // Nothing reached a gone runtime, so recreating and retrying is safe;
+            // an interrupted command may have side effects and must surface.
+            if (gone && attempt === 0)
+                continue;
+            if (gone || interrupted) {
+                throw new SandboxError(`Error: Gondolin runtime for '${key}' died (${error.message}); it is recreated on the next command`);
+            }
+            throw error;
+        }
+        finally {
+            session.activeOperations -= 1;
+            session.lastUsed = Date.now();
+            if (session.activeOperations === 0) {
+                for (const resolve of session.idleWaiters.splice(0))
+                    resolve();
+            }
+        }
+    }
+}
+function waitForIdle(session) {
+    if (session.activeOperations === 0)
+        return Promise.resolve();
+    return new Promise((resolve) => session.idleWaiters.push(resolve));
+}
+async function closeSession(key, session, options = {}) {
+    if (sessions.get(key) !== session)
+        return;
+    sessions.delete(key);
+    try {
+        if (options.waitForActiveOperations)
+            await waitForIdle(session);
+        const runtime = await session.runtime;
+        await runtime.close();
+        if (options.resetResources !== false &&
+            session.resourceKey &&
+            !Array.from(sessions.values()).some(({ resourceKey }) => resourceKey === session.resourceKey)) {
+            gondolinResources.clear(session.resourceKey);
+        }
+    }
+    catch (error) {
+        session.fingerprint = "";
+        // Re-track for a retried close, unless a replacement already claimed the
+        // key — then the failed runtime stays for the reconcile paths and
+        // clobbering the replacement would leak it too.
+        if (!sessions.has(key))
+            sessions.set(key, session);
+        if (options.throwOnError)
+            throw error;
+        log.logWarning(`Failed to close Gondolin session '${key}'`, error instanceof Error ? error.message : String(error));
+    }
+}
+export async function stopIdleGondolinVms(maxIdleMs, now = Date.now()) {
+    const idle = Array.from(sessions.entries()).filter(([key, session]) => !transitions.has(key) &&
+        session.activeOperations === 0 &&
+        now - session.lastUsed >= maxIdleMs);
+    await Promise.all(idle.map(([key, session]) => {
+        // Register the close as a transition so a concurrent acquire waits for
+        // it instead of racing the shared session slot.
+        const transition = closeSession(key, session).finally(() => {
+            if (transitions.get(key) === transition)
+                transitions.delete(key);
+        });
+        transitions.set(key, transition);
+        return transition;
+    }));
+}
+/**
+ * Drop Gondolin's registry entries for sessions that no longer answer — socket
+ * files and metadata left behind by a mikan that died without cleanup.
+ */
+export async function reconcileGondolinRuntimes() {
+    try {
+        const { gcSessions } = (await import("@earendil-works/gondolin"));
+        const collected = await gcSessions();
+        log.logInfo(`Reconciled Gondolin sessions (collected=${collected})`);
+    }
+    catch (error) {
+        log.logWarning("Failed to collect Gondolin session registry", error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Stop every runtime this process owns. Runtimes do not outlive mikan, so
+ * shutdown must close them: that syncs projected files back to the host and
+ * releases each VM's overlay disk before the process exits.
+ */
+export async function stopAllGondolinRuntimes() {
+    shutdownGeneration += 1;
+    activeShutdowns += 1;
+    try {
+        await Promise.allSettled(transitions.values());
+        const current = Array.from(sessions.entries());
+        await Promise.all(current.map(([key, session]) => closeSession(key, session, { waitForActiveOperations: true })));
+    }
+    finally {
+        activeShutdowns -= 1;
+    }
+}
+function executionSignal(options) {
+    const signals = [options?.signal];
+    if (options?.timeout && options.timeout > 0) {
+        signals.push(AbortSignal.timeout(options.timeout * 1000));
+    }
+    const active = signals.filter((signal) => signal !== undefined);
+    return active.length > 0 ? AbortSignal.any(active) : undefined;
+}
+export class GondolinExecutor {
+    constructor(config, env) {
+        this.config = config;
+        this.env = env;
+        assertSupportedNodeVersion();
+        this.workspacePath = config.workspacePath ?? process.cwd();
+        this.instanceId = config.instanceId ?? this.workspacePath;
+    }
+    async exec(command, options) {
+        return withRuntime(this.instanceId, this.config, (runtime) => runtime.exec(withRuntimeBootstrap(command, this.env), {
+            env: this.env,
+            signal: executionSignal(options),
+        }));
+    }
+    async readFile(path) {
+        return execReadFile(this, path);
+    }
+    async readFileBase64(path) {
+        return execReadFileBase64(this, path);
+    }
+    async writeFile(path, content) {
+        return execWriteFile(this, path, content);
+    }
+    getWorkspacePath() {
+        return "/workspace";
+    }
+    getPathContext(hostWorkspaceRoot) {
+        return createMountedRuntimePathContext(hostWorkspaceRoot, "/workspace");
+    }
+    getSandboxConfig() {
+        return this.config;
+    }
+}
+export const gondolinSandboxAdapter = {
+    type: "gondolin",
+    credentials: { env: true, fileMounts: true },
+    parse: parseGondolinSandboxArg,
+    validate: validateGondolinSandbox,
+    createExecutor: (config, env) => new GondolinExecutor(config, env),
+};
+//# sourceMappingURL=gondolin.js.map