@nylorun/runtime 0.6.0-beta → 0.8.0-beta

package/dist/mcp/stdio.js

@@ -0,0 +1,80 @@
+import { mkdirSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+const ROOT_TOKEN = "${PLUGIN_ROOT}";
+const DATA_TOKEN = "${PLUGIN_DATA}";
+/** Single-pass replacement. Text inserted for a token is not scanned again. */
+export function expandPluginPlaceholders(value, pluginRoot, pluginData) {
+    let out = "";
+    for (let index = 0; index < value.length;) {
+        if (value.startsWith(ROOT_TOKEN, index)) {
+            out += pluginRoot;
+            index += ROOT_TOKEN.length;
+            continue;
+        }
+        if (value.startsWith(DATA_TOKEN, index)) {
+            out += pluginData;
+            index += DATA_TOKEN.length;
+            continue;
+        }
+        out += value[index];
+        index += 1;
+    }
+    return out;
+}
+export function prepareStdioLaunch(server, options) {
+    const pluginData = options.pluginData;
+    mkdirSync(pluginData, { recursive: true });
+    const pluginRoot = options.pluginRoot;
+    if (needsPluginRoot(server) && !pluginRoot)
+        throw new Error("stdio server requires a plugin root");
+    for (const key of Object.keys(server.env ?? {})) {
+        if (key === "PLUGIN_ROOT" || key === "PLUGIN_DATA")
+            throw new Error(`stdio env must not set ${key}`);
+    }
+    const command = server.command.startsWith("./")
+        ? resolve(pluginRoot, server.command)
+        : server.command;
+    const args = (server.args ?? []).map((arg) => expand(arg, pluginRoot, pluginData));
+    const cwd = server.cwd
+        ? resolveContainedCwd(server.cwd, pluginRoot, pluginData)
+        : (pluginRoot ?? pluginData);
+    const env = {};
+    for (const [key, value] of Object.entries(server.env ?? {}))
+        env[key] = expand(value, pluginRoot, pluginData);
+    if (pluginRoot)
+        env.PLUGIN_ROOT = pluginRoot;
+    env.PLUGIN_DATA = pluginData;
+    return { command, args, cwd, env };
+}
+function needsPluginRoot(server) {
+    if (server.command.startsWith("./"))
+        return true;
+    const values = [
+        ...(server.args ?? []),
+        ...Object.values(server.env ?? {}),
+        ...(server.cwd === undefined ? [] : [server.cwd]),
+    ];
+    return values.some((value) => value.includes(ROOT_TOKEN));
+}
+function expand(value, pluginRoot, pluginData) {
+    if (value.includes(ROOT_TOKEN) && !pluginRoot)
+        throw new Error("stdio server requires a plugin root");
+    return expandPluginPlaceholders(value, pluginRoot ?? "", pluginData);
+}
+function resolveContainedCwd(cwd, pluginRoot, pluginData) {
+    const expanded = expand(cwd, pluginRoot, pluginData);
+    const base = cwdTargetsData(cwd) ? pluginData : pluginRoot;
+    if (!base)
+        throw new Error("stdio server requires a plugin root");
+    const absolute = isAbsolute(expanded) ? expanded : resolve(base, expanded);
+    if (!isInside(base, absolute))
+        throw new Error(`Working directory escapes ${base}`);
+    return absolute;
+}
+function cwdTargetsData(cwd) {
+    return cwd === DATA_TOKEN || cwd.startsWith(`${DATA_TOKEN}/`);
+}
+function isInside(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
+}

package/dist/model/catalog.d.ts

@@ -0,0 +1,12 @@
+export type HostModelCatalog = {
+    providers: {
+        id: string;
+        name: string;
+        models: {
+            id: string;
+            name: string;
+        }[];
+    }[];
+};
+/** Public provider and model names. No credentials. */
+export declare function hostModelCatalog(): HostModelCatalog;

package/dist/model/catalog.js

@@ -0,0 +1,29 @@
+import { modelsFor } from "./models.js";
+const emptyStore = {
+    async read() {
+        return undefined;
+    },
+    async list() {
+        return [];
+    },
+    async modify(_providerId, fn) {
+        return fn(undefined);
+    },
+    async delete() { },
+};
+/** Public provider and model names. No credentials. */
+export function hostModelCatalog() {
+    const models = modelsFor({ provider: "", model: "" }, emptyStore, {
+        environment: false,
+    });
+    return {
+        providers: models.getProviders().map((provider) => ({
+            id: provider.id,
+            name: provider.name,
+            models: models.getModels(provider.id).map((model) => ({
+                id: model.id,
+                name: model.name,
+            })),
+        })),
+    };
+}

package/dist/model/models.d.ts

@@ -6,4 +6,6 @@ export type Selection = Readonly<{
         baseUrl: string;
     }>;
 }>;
-export declare function modelsFor(selection: Selection, credentials: CredentialStore): import("@earendil-works/pi-ai").MutableModels;
+export declare function modelsFor(selection: Selection, credentials: CredentialStore, options?: {
+    environment?: boolean;
+}): import("@earendil-works/pi-ai").MutableModels;

package/dist/model/models.js

@@ -1,7 +1,7 @@
 import { createProvider, defaultProviderAuthContext, envApiKeyAuth, } from "@earendil-works/pi-ai";
 import { stream, streamSimple, } from "@earendil-works/pi-ai/api/openai-completions";
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
-export function modelsFor(selection, credentials) {
+export function modelsFor(selection, credentials, options = {}) {
     const environmentFirst = {
         async read(providerId, options) {
             const explicit = process.env.MODEL_PROVIDER_API_KEY;
@@ -23,7 +23,9 @@ export function modelsFor(selection, credentials) {
         modify: (id, fn, options) => credentials.modify(id, fn, options),
         delete: (id, options) => credentials.delete(id, options),
     };
-    const models = builtinModels({ credentials: environmentFirst });
+    const models = builtinModels({
+        credentials: options.environment === false ? credentials : environmentFirst,
+    });
     if (!selection.custom)
         return models;
     const model = {

package/dist/model/pi-model.d.ts

@@ -1,11 +1,17 @@
+import type { Credential } from "@earendil-works/pi-ai";
 import type { RuntimeModelAdapter } from "../contracts.js";
 import type { RuntimeMedia } from "../adapters/media.js";
-import { type Selection } from "./models.js";
+import type { HostModelSecret } from "../vault/service.js";
+export interface ModelPreview {
+    readonly invocationId: string;
+    readonly text: string;
+}
 export interface PiModelOptions {
     readonly root?: string;
-    readonly onPreview?: (preview: import("./defaults.js").ModelPreview) => void;
-    readonly selection?: Selection;
+    readonly onPreview?: (preview: ModelPreview) => void;
     readonly media?: Pick<RuntimeMedia, "dataUrl">;
+    readonly readHostModel?: () => HostModelSecret | undefined;
+    readonly writeHostCredential?: (credential: Credential) => void;
 }
 /** Node model adapter. Local provider configuration is read only when invoked. */
 export declare function piModel(options?: PiModelOptions): RuntimeModelAdapter;

package/dist/model/pi-model.js

@@ -1,8 +1,6 @@
-import { join } from "node:path";
 import { scrub } from "../redact.js";
-import { ProjectCredentialStore } from "./auth-store.js";
 import { modelsFor } from "./models.js";
-import { modelSelection, projectSecrets } from "./settings.js";
+import { projectSecrets } from "./settings.js";
 const emptyUsage = () => ({
     input: 0,
     output: 0,
@@ -16,15 +14,18 @@ export function piModel(options = {}) {
     return async (call, context) => {
         context.signal.throwIfAborted();
         const root = options.root ?? process.cwd();
-        const configured = options.selection ?? modelSelection(root);
+        const stored = options.readHostModel?.();
+        if (!stored)
+            throw new Error("Model provider is not configured. Start nylorun dev in a terminal, or set it in Studio.");
         const requested = call.model?.id;
         const selection = {
-            ...configured,
-            model: requested?.startsWith(`${configured.provider}/`)
-                ? requested.slice(configured.provider.length + 1)
-                : (requested ?? configured.model),
+            provider: stored.provider,
+            model: requested?.startsWith(`${stored.provider}/`)
+                ? requested.slice(stored.provider.length + 1)
+                : (requested ?? stored.model),
+            ...(stored.baseUrl ? { custom: { baseUrl: stored.baseUrl } } : {}),
         };
-        const registry = modelsFor(selection, new ProjectCredentialStore(join(root, ".nylorun", "auth.json"), join(root, ".env", "auth.json")));
+        const registry = modelsFor(selection, hostCredentialStore(stored, options.writeHostCredential), { environment: false });
         const selected = registry.getModel(selection.provider, selection.model);
         if (!selected)
             throw new Error("Unknown model. Run nylorun configure.");
@@ -176,7 +177,10 @@ export function piModel(options = {}) {
             messages,
             tools,
         };
-        const secrets = projectSecrets(root);
+        const secrets = [
+            ...projectSecrets(root),
+            ...credentialSecrets(stored.credential),
+        ];
         // Publish only portable references, never the materialized provider image bytes.
         context.reportPreparedCall?.({
             adapter: "runtime.pi-ai",
@@ -265,7 +269,39 @@ export function piModel(options = {}) {
             };
         }
         catch (error) {
-            throw new Error(String(scrub(error instanceof Error ? error.message : String(error), projectSecrets(root))));
+            throw new Error(String(scrub(error instanceof Error ? error.message : String(error), secrets)));
         }
     };
 }
+function hostCredentialStore(stored, write) {
+    let current = stored.credential;
+    return {
+        async read(providerId) {
+            if (providerId !== stored.provider)
+                return undefined;
+            return current;
+        },
+        async list() {
+            return [{ providerId: stored.provider, type: current.type }];
+        },
+        async modify(providerId, fn) {
+            if (providerId !== stored.provider)
+                return fn(undefined);
+            const next = await fn(current);
+            if (next === undefined)
+                return current;
+            write?.(next);
+            current = next;
+            return next;
+        },
+        async delete() {
+            throw new Error("Replace the model provider through nylorun dev or Studio.");
+        },
+    };
+}
+function credentialSecrets(credential) {
+    const values = [credential.key, credential.access, credential.refresh];
+    if (credential.env)
+        values.push(...Object.values(credential.env));
+    return values.filter((value) => Boolean(value));
+}

package/dist/model/settings.d.ts

@@ -1,3 +1 @@
-import type { Selection } from "./models.js";
-export declare function modelSelection(root?: string): Selection;
 export declare function projectSecrets(root?: string): readonly string[];

package/dist/model/settings.js

@@ -1,52 +1,5 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-export function modelSelection(root = process.cwd()) {
-    const { MODEL_PROVIDER: provider, MODEL: model, MODEL_PROVIDER_BASE_URL: baseUrl, } = process.env;
-    if (provider !== undefined || model !== undefined || baseUrl !== undefined) {
-        if (!provider?.trim() || !model?.trim())
-            throw new Error("Set both MODEL_PROVIDER and MODEL, or run nylorun configure.");
-        if (provider === "custom" && !baseUrl?.trim())
-            throw new Error("Set MODEL_PROVIDER_BASE_URL for MODEL_PROVIDER=custom.");
-        if (baseUrl && provider !== "custom")
-            throw new Error("MODEL_PROVIDER_BASE_URL requires MODEL_PROVIDER=custom.");
-        if (baseUrl) {
-            let url;
-            try {
-                url = new URL(baseUrl);
-            }
-            catch {
-                throw new Error("MODEL_PROVIDER_BASE_URL must be an HTTP(S) URL.");
-            }
-            if (!["http:", "https:"].includes(url.protocol))
-                throw new Error("MODEL_PROVIDER_BASE_URL must be an HTTP(S) URL.");
-        }
-        return { provider, model, ...(baseUrl ? { custom: { baseUrl } } : {}) };
-    }
-    try {
-        let contents;
-        try {
-            contents = readFileSync(join(root, ".env", "model.json"), "utf8");
-        }
-        catch (error) {
-            if (!(error instanceof Error) ||
-                !("code" in error) ||
-                !["ENOENT", "ENOTDIR"].includes(String(error.code)))
-                throw error;
-            contents = readFileSync(join(root, "config", "model.json"), "utf8");
-        }
-        const value = JSON.parse(contents);
-        if (typeof value.provider === "string" &&
-            value.provider &&
-            typeof value.model === "string" &&
-            value.model &&
-            (value.custom === undefined || typeof value.custom.baseUrl === "string"))
-            return value;
-    }
-    catch {
-        /* Report one actionable setup error without file or credential contents. */
-    }
-    throw new Error("Run nylorun configure to connect a model provider.");
-}
 export function projectSecrets(root = process.cwd()) {
     const values = Object.entries(process.env)
         .filter(([key]) => /key|token|secret|password|credential/i.test(key))

package/dist/node/index.d.ts

@@ -1,5 +1,5 @@
-export { localSessions } from "./local-sessions.js";
 export { localMedia, MediaStore } from "../adapters/media.js";
 export { jsonlObserver } from "../adapters/observe.js";
 export { piModel, type PiModelOptions } from "../model/pi-model.js";
 export { projectAsset } from "../assets.js";
+export { probeSandboxBackends, type SandboxSelectionReport, } from "../sandbox/select.js";

package/dist/node/index.js

@@ -1,5 +1,5 @@
-export { localSessions } from "./local-sessions.js";
 export { localMedia, MediaStore } from "../adapters/media.js";
 export { jsonlObserver } from "../adapters/observe.js";
 export { piModel } from "../model/pi-model.js";
 export { projectAsset } from "../assets.js";
+export { probeSandboxBackends, } from "../sandbox/select.js";

package/dist/sandbox/manager.d.ts

@@ -0,0 +1,61 @@
+import { type AgentManifest, type CapabilityManifest, type SandboxToolName } from "@nylorun/core/define";
+import type { Store } from "../core/store.js";
+import { type SandboxSelection, type SandboxSelectionReport } from "./select.js";
+import { type SandboxToolOutcome } from "./tools.js";
+import type { SandboxBackend } from "./types.js";
+export interface SandboxSessionRef {
+    readonly id: string;
+    readonly activeTurnId: string | null;
+    readonly manifest: AgentManifest;
+}
+export type SandboxState = "creating" | "running" | "stopped";
+interface SandboxRecord {
+    key: string;
+    sessionId: string;
+    backend: string;
+    image: string;
+    state: SandboxState;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SandboxManagerOptions {
+    /** Distinguishes this Runtime's sandboxes from other Runtimes on the same machine. */
+    readonly scope: string;
+    readonly store: Store;
+    readonly backends: readonly SandboxBackend[];
+    /** `auto`, `microsandbox` or `virtual`. Undefined means an invalid NYLORUN_SANDBOX value. */
+    readonly preference: string | undefined;
+    /** Delete sandboxes on close (the Runtime's store does not outlive the process). */
+    readonly ephemeral: boolean;
+    readonly emit: (sessionId: string, turnId: string | null, type: string, payload: unknown) => void;
+}
+/** The sandbox capability that owns this tool call, when the call is a built-in sandbox tool. */
+export declare function sandboxCapabilityOf(manifest: AgentManifest | undefined, capabilityId: string | undefined, toolName: string | undefined): CapabilityManifest | undefined;
+export declare class SandboxManager {
+    private readonly options;
+    private selection?;
+    private readonly live;
+    private readonly prefix;
+    private closing;
+    constructor(options: SandboxManagerOptions);
+    /** Backends are probed once, on first use, and the choice holds for the life of the Runtime. */
+    get ready(): Promise<SandboxSelection>;
+    /** Whether any sandbox was ever recorded, so startup can skip probing for agents without one. */
+    hasRecords(): boolean;
+    keyOf(sessionId: string): string;
+    report(): Promise<SandboxSelectionReport & {
+        readonly defaultImage: string;
+    }>;
+    run(session: SandboxSessionRef, capability: CapabilityManifest, toolName: SandboxToolName, input: unknown, signal: AbortSignal): Promise<SandboxToolOutcome>;
+    private execute;
+    private open;
+    private armIdle;
+    private stop;
+    private record;
+    /** The sandbox record for a session, if one was ever created. */
+    status(sessionId: string): SandboxRecord | undefined;
+    /** Delete sandboxes this Runtime owns whose session no longer exists. */
+    reconcile(sessionExists: (sessionId: string) => boolean): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

package/dist/sandbox/manager.js

@@ -0,0 +1,239 @@
+/**
+ * Sandbox Manager: owns sandbox lifecycle for the Runtime. One sandbox per session, created on
+ * the first sandbox tool call, stopped after its idle timeout, reattached on the next call.
+ * Commands against one sandbox run one at a time.
+ */
+import { createHash } from "node:crypto";
+import { isSandboxToolName, } from "@nylorun/core/define";
+import { DEFAULT_SANDBOX_CPUS, DEFAULT_SANDBOX_IMAGE, describeNetwork, idleMsOf, memoryMiBOf, resolveNetwork, } from "./policy.js";
+import { parseSandboxPreference, reportSelection, selectSandboxBackend, } from "./select.js";
+import { runSandboxTool } from "./tools.js";
+const READ_TOOLS = new Set(["read", "grep", "glob"]);
+/** The sandbox capability that owns this tool call, when the call is a built-in sandbox tool. */
+export function sandboxCapabilityOf(manifest, capabilityId, toolName) {
+    if (!manifest || !capabilityId || !toolName || !isSandboxToolName(toolName))
+        return undefined;
+    const capability = manifest.capabilities.find((item) => item.id === capabilityId);
+    return capability?.sandbox && capability.tools?.some((tool) => tool.name === toolName)
+        ? capability
+        : undefined;
+}
+export class SandboxManager {
+    options;
+    selection;
+    live = new Map();
+    prefix;
+    closing = false;
+    constructor(options) {
+        this.options = options;
+        this.prefix = `nylorun-${options.scope}-`;
+        // Compute is gone after a Runtime restart; files remain and the next call reattaches.
+        options.store.tx(() => {
+            for (const record of options.store.all("sandboxes"))
+                if (record.state !== "stopped")
+                    options.store.put("sandboxes", record.key, { ...record, state: "stopped" });
+        });
+    }
+    /** Backends are probed once, on first use, and the choice holds for the life of the Runtime. */
+    get ready() {
+        if (!this.selection) {
+            const preference = parseSandboxPreference(this.options.preference);
+            this.selection = preference
+                ? selectSandboxBackend(this.options.backends, preference)
+                : Promise.resolve({
+                    preference: "auto",
+                    reason: `NYLORUN_SANDBOX='${this.options.preference}' is not valid; use auto, microsandbox or virtual`,
+                    probes: [],
+                });
+        }
+        return this.selection;
+    }
+    /** Whether any sandbox was ever recorded, so startup can skip probing for agents without one. */
+    hasRecords() {
+        return this.options.store.all("sandboxes").length > 0;
+    }
+    keyOf(sessionId) {
+        return this.prefix + createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
+    }
+    async report() {
+        return { ...reportSelection(await this.ready), defaultImage: DEFAULT_SANDBOX_IMAGE };
+    }
+    async run(session, capability, toolName, input, signal) {
+        const selection = await this.ready;
+        const backend = selection.backend;
+        if (!backend)
+            return {
+                kind: "failed",
+                code: "sandbox.unavailable",
+                message: `No sandbox is available: ${selection.reason}. Run \`npx nylorun doctor sandbox\` for options.`,
+            };
+        const key = this.keyOf(session.id);
+        const spec = {
+            key,
+            image: capability.sandbox?.image ?? DEFAULT_SANDBOX_IMAGE,
+            cpus: capability.sandbox?.resources?.cpus ?? DEFAULT_SANDBOX_CPUS,
+            memoryMiB: memoryMiBOf(capability.sandbox),
+            network: resolveNetwork(capability.sandbox),
+        };
+        const unmet = backend.unmet(spec);
+        if (unmet)
+            return {
+                kind: "failed",
+                code: "sandbox.unavailable",
+                message: `This agent's sandbox cannot run on the ${backend.name} backend: ${unmet}.`,
+            };
+        let live = this.live.get(key);
+        if (!live) {
+            live = { sessionId: session.id, backend, idleMs: idleMsOf(capability.sandbox), tail: Promise.resolve() };
+            this.live.set(key, live);
+        }
+        const entry = live;
+        const task = entry.tail.then(() => this.execute(entry, session, spec, toolName, input, signal));
+        entry.tail = task.catch(() => undefined);
+        return task;
+    }
+    async execute(live, session, spec, toolName, input, signal) {
+        if (signal.aborted)
+            throw new Error("Turn cancelled");
+        if (this.closing)
+            throw new Error("Runtime is shutting down");
+        clearTimeout(live.timer);
+        if (!live.handle) {
+            try {
+                live.handle = await this.open(live, session, spec);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.record(spec.key, session.id, live.backend.name, spec.image, "stopped");
+                this.options.emit(session.id, session.activeTurnId, "sandbox.state", {
+                    state: "stopped",
+                    backend: live.backend.name,
+                    error: message,
+                });
+                // Nothing ran yet, so a failed start is a definite outcome, not an uncertain one.
+                return {
+                    kind: "failed",
+                    code: "sandbox.start_failed",
+                    message: `The sandbox could not start on ${live.backend.name} (image ${spec.image}): ${message}`,
+                };
+            }
+        }
+        const started = Date.now();
+        let report = {};
+        try {
+            const outcome = await runSandboxTool(live.handle, toolName, (input ?? {}), signal, (value) => {
+                report = value;
+            });
+            this.options.emit(session.id, session.activeTurnId, "sandbox.exec", {
+                tool: toolName,
+                ...report,
+                ...(report.command ? { command: report.command.slice(0, 500) } : {}),
+                outcome: outcome.kind,
+                ...(outcome.kind === "failed" ? { code: outcome.code } : {}),
+                durationMs: Date.now() - started,
+            });
+            return outcome;
+        }
+        catch (error) {
+            // The backend itself failed; reopen on the next call.
+            live.handle = undefined;
+            if (signal.aborted || !READ_TOOLS.has(toolName))
+                throw error;
+            return {
+                kind: "failed",
+                code: "sandbox.error",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+        finally {
+            this.armIdle(spec.key, live);
+        }
+    }
+    async open(live, session, spec) {
+        const existing = this.options.store.get("sandboxes", spec.key);
+        const payload = {
+            backend: live.backend.name,
+            isolation: live.backend.isolation,
+            image: spec.image,
+            network: describeNetwork(spec.network),
+        };
+        this.record(spec.key, session.id, live.backend.name, spec.image, "creating", existing);
+        this.options.emit(session.id, session.activeTurnId, "sandbox.state", {
+            state: "creating",
+            ...payload,
+            ...(existing ? { reattach: true } : {}),
+        });
+        const handle = await live.backend.open(spec);
+        this.record(spec.key, session.id, live.backend.name, spec.image, "running", existing);
+        this.options.emit(session.id, session.activeTurnId, "sandbox.state", { state: "running", ...payload });
+        return handle;
+    }
+    armIdle(key, live) {
+        clearTimeout(live.timer);
+        if (this.closing)
+            return;
+        live.timer = setTimeout(() => {
+            live.tail = live.tail.then(() => this.stop(key, live)).catch(() => undefined);
+        }, live.idleMs);
+        live.timer.unref();
+    }
+    async stop(key, live) {
+        const handle = live.handle;
+        if (!handle)
+            return;
+        live.handle = undefined;
+        try {
+            await handle.stop();
+        }
+        finally {
+            this.record(key, live.sessionId, live.backend.name, undefined, "stopped");
+            this.options.emit(live.sessionId, null, "sandbox.state", { state: "stopped", backend: live.backend.name });
+        }
+    }
+    record(key, sessionId, backend, image, state, existing = this.options.store.get("sandboxes", key)) {
+        const now = new Date().toISOString();
+        this.options.store.tx(() => this.options.store.put("sandboxes", key, {
+            key,
+            sessionId,
+            backend,
+            image: image ?? existing?.image ?? "",
+            state,
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+        }));
+    }
+    /** The sandbox record for a session, if one was ever created. */
+    status(sessionId) {
+        return this.options.store.get("sandboxes", this.keyOf(sessionId));
+    }
+    /** Delete sandboxes this Runtime owns whose session no longer exists. */
+    async reconcile(sessionExists) {
+        const { backend } = await this.ready;
+        if (!backend)
+            return;
+        for (const key of await backend.list(this.prefix)) {
+            const record = this.options.store.get("sandboxes", key);
+            if (record && sessionExists(record.sessionId))
+                continue;
+            await backend.remove(key);
+            this.options.store.tx(() => this.options.store.delete("sandboxes", key));
+        }
+    }
+    async close() {
+        this.closing = true;
+        if (!this.selection)
+            return;
+        const tasks = [...this.live.entries()].map(async ([key, live]) => {
+            clearTimeout(live.timer);
+            await live.tail;
+            if (this.options.ephemeral) {
+                live.handle = undefined;
+                await live.backend.remove(key);
+            }
+            else
+                await this.stop(key, live);
+        });
+        await Promise.allSettled(tasks);
+        this.live.clear();
+    }
+}

package/dist/sandbox/policy.d.ts

@@ -0,0 +1,13 @@
+import { type SandboxManifest } from "@nylorun/core/define";
+import type { ResolvedNetwork } from "./types.js";
+/** Docker Official Image: Debian with bash, coreutils and Python 3; small first pull. */
+export declare const DEFAULT_SANDBOX_IMAGE = "python:3.13-slim";
+export declare const DEFAULT_SANDBOX_CPUS = 2;
+export declare const DEFAULT_SANDBOX_MEMORY_MIB = 1024;
+export declare const DEFAULT_SANDBOX_IDLE_MS: number;
+/** Package registries and code hosts. Concrete names so every backend can express them. */
+export declare const DEV_PRESET_HOSTS: readonly string[];
+export declare function resolveNetwork(manifest: SandboxManifest | undefined): ResolvedNetwork;
+export declare function idleMsOf(manifest: SandboxManifest | undefined): number;
+export declare function memoryMiBOf(manifest: SandboxManifest | undefined): number;
+export declare function describeNetwork(network: ResolvedNetwork): string;