@nylorun/runtime 0.10.0-beta → 0.12.0-beta

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

@@ -10,8 +10,8 @@ export interface PiModelOptions {
     readonly root?: string;
     readonly onPreview?: (preview: ModelPreview) => void;
     readonly media?: Pick<RuntimeMedia, "dataUrl">;
-    readonly readHostModel?: () => HostModelSecret | undefined;
-    readonly writeHostCredential?: (credential: Credential) => void;
+    readonly readHostModel?: () => HostModelSecret | undefined | Promise<HostModelSecret | undefined>;
+    readonly writeHostCredential?: (credential: Credential) => void | Promise<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

@@ -14,9 +14,9 @@ export function piModel(options = {}) {
     return async (call, context) => {
         context.signal.throwIfAborted();
         const root = options.root ?? "";
-        const stored = options.readHostModel?.();
+        const stored = await options.readHostModel?.();
         if (!stored)
-            throw new Error("Model provider is not configured. Start nylorun dev in a terminal, or set it in Studio.");
+            throw new Error("Model provider is not configured. Set it in Studio, or run nylo configure (npx @nylorun/cli configure).");
         const requested = call.model?.id;
         const selection = {
             provider: stored.provider,
@@ -28,7 +28,7 @@ export function piModel(options = {}) {
         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.");
+            throw new Error("Unknown model. Run nylo configure (npx @nylorun/cli configure).");
         const signatureFor = (part) => {
             const metadata = "providerMetadata" in part ? part.providerMetadata?.pi : undefined;
             if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
@@ -290,12 +290,12 @@ function hostCredentialStore(stored, write) {
             const next = await fn(current);
             if (next === undefined)
                 return current;
-            write?.(next);
+            await write?.(next);
             current = next;
             return next;
         },
         async delete() {
-            throw new Error("Replace the model provider through nylorun dev or Studio.");
+            throw new Error("Replace the model provider in Studio, or with nylo configure.");
         },
     };
 }

package/dist/sandbox/manager.d.ts

@@ -1,5 +1,5 @@
 import { type AgentManifest, type CapabilityManifest, type SandboxToolName } from "@nylorun/core/define";
-import type { Store } from "../core/store.js";
+import type { SessionStore } from "../store/types.js";
 import { type SandboxSelection, type SandboxSelectionReport } from "./select.js";
 import { type SandboxToolOutcome } from "./tools.js";
 import type { SandboxBackend } from "./types.js";
@@ -18,16 +18,23 @@ interface SandboxRecord {
     createdAt: string;
     updatedAt: string;
 }
+export interface SandboxSweepOptions {
+    /** The sweep's clock, in ms since the epoch. Defaults to `Date.now()`. */
+    readonly now?: number;
+    /** Whether a session still exists; sandboxes of deleted sessions are removed. */
+    readonly sessionExists: (sessionId: string) => boolean | Promise<boolean>;
+}
 export interface SandboxManagerOptions {
     /** Distinguishes this Runtime's sandboxes from other Runtimes on the same machine. */
     readonly scope: string;
-    readonly store: Store;
+    readonly store: SessionStore;
     readonly backends: readonly SandboxBackend[];
-    /** `auto`, `microsandbox` or `virtual`. Undefined means an invalid NYLORUN_SANDBOX value. */
+    /** `auto` 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;
+    /** Writes a session event in its own transaction; never called inside one. */
+    readonly emit: (sessionId: string, turnId: string | null, type: string, payload: unknown) => void | Promise<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;
@@ -37,25 +44,36 @@ export declare class SandboxManager {
     private readonly live;
     private readonly prefix;
     private closing;
+    private reconciled;
     constructor(options: SandboxManagerOptions);
+    /**
+     * One Tenant sweep pass:
+     * - stops sandboxes idle for at least their idle timeout (their files remain; the next
+     *   call reattaches);
+     * - marks records whose compute this process does not hold as stopped (compute is gone
+     *   after a Runtime restart);
+     * - on the first pass of this process, removes sandboxes whose session no longer exists
+     *   (skipped for ephemeral Runtimes, which delete theirs on close).
+     */
+    sweep(options: SandboxSweepOptions): Promise<void>;
     /** 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;
+    hasRecords(): Promise<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 executeOpen;
     private open;
-    private armIdle;
     private stop;
     private record;
     /** The sandbox record for a session, if one was ever created. */
-    status(sessionId: string): SandboxRecord | undefined;
+    status(sessionId: string): Promise<SandboxRecord | undefined>;
     /** Delete sandboxes this Runtime owns whose session no longer exists. */
-    reconcile(sessionExists: (sessionId: string) => boolean): Promise<void>;
+    reconcile(sessionExists: (sessionId: string) => boolean | Promise<boolean>): Promise<void>;
     close(): Promise<void>;
 }
 export {};

package/dist/sandbox/manager.js

@@ -2,6 +2,10 @@
  * 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.
+ *
+ * The manager keeps no timers. The Tenant sweep calls `sweep`, which stops sandboxes idle
+ * past their timeout, marks records of compute this process no longer holds as stopped
+ * (after a restart), and, once per process, removes sandboxes whose session is gone.
  */
 import { createHash } from "node:crypto";
 import { isSandboxToolName, } from "@nylorun/core/define";
@@ -24,15 +28,53 @@ export class SandboxManager {
     live = new Map();
     prefix;
     closing = false;
+    reconciled = 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" });
+    }
+    /**
+     * One Tenant sweep pass:
+     * - stops sandboxes idle for at least their idle timeout (their files remain; the next
+     *   call reattaches);
+     * - marks records whose compute this process does not hold as stopped (compute is gone
+     *   after a Runtime restart);
+     * - on the first pass of this process, removes sandboxes whose session no longer exists
+     *   (skipped for ephemeral Runtimes, which delete theirs on close).
+     */
+    async sweep(options) {
+        if (this.closing)
+            return;
+        const now = options.now ?? Date.now();
+        const idle = (live) => !!live.handle && live.active === 0 && now - live.lastUsedAt >= live.idleMs;
+        const stops = [];
+        for (const [key, live] of this.live) {
+            if (!idle(live))
+                continue;
+            // Queued behind any call already waiting; checked again when its turn comes.
+            live.tail = live.tail
+                .then(() => (idle(live) ? this.stop(key, live) : undefined))
+                .catch(() => undefined);
+            stops.push(live.tail);
+        }
+        await Promise.all(stops);
+        await this.options.store.tx(async (t) => {
+            for (const record of await t.listSandboxes()) {
+                if (record.state === "stopped")
+                    continue;
+                const live = this.live.get(record.key);
+                if (live && (live.handle || live.active > 0))
+                    continue;
+                await t.put("sandboxes", record.key, { ...record, state: "stopped" });
+            }
         });
+        if (this.reconciled || this.options.ephemeral)
+            return;
+        this.reconciled = true;
+        if (!(await this.hasRecords()))
+            return;
+        await this.reconcile(async (sessionId) => [...this.live.values()].some((live) => live.sessionId === sessionId) ||
+            (await options.sessionExists(sessionId)));
     }
     /** Backends are probed once, on first use, and the choice holds for the life of the Runtime. */
     get ready() {
@@ -42,15 +84,15 @@ export class SandboxManager {
                 ? selectSandboxBackend(this.options.backends, preference)
                 : Promise.resolve({
                     preference: "auto",
-                    reason: `NYLORUN_SANDBOX='${this.options.preference}' is not valid; use auto, microsandbox or virtual`,
+                    reason: `NYLORUN_SANDBOX='${this.options.preference}' is not valid; use auto 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;
+    async hasRecords() {
+        return (await this.options.store.tx((t) => t.counts())).sandboxes > 0;
     }
     keyOf(sessionId) {
         return this.prefix + createHash("sha256").update(sessionId).digest("hex").slice(0, 16);
@@ -84,7 +126,14 @@ export class SandboxManager {
             };
         let live = this.live.get(key);
         if (!live) {
-            live = { sessionId: session.id, backend, idleMs: idleMsOf(capability.sandbox), tail: Promise.resolve() };
+            live = {
+                sessionId: session.id,
+                backend,
+                idleMs: idleMsOf(capability.sandbox),
+                active: 0,
+                lastUsedAt: Date.now(),
+                tail: Promise.resolve(),
+            };
             this.live.set(key, live);
         }
         const entry = live;
@@ -97,15 +146,24 @@ export class SandboxManager {
             throw new Error("Turn cancelled");
         if (this.closing)
             throw new Error("Runtime is shutting down");
-        clearTimeout(live.timer);
+        live.active += 1;
+        try {
+            return await this.executeOpen(live, session, spec, toolName, input, signal);
+        }
+        finally {
+            live.active -= 1;
+            live.lastUsedAt = Date.now();
+        }
+    }
+    async executeOpen(live, session, spec, toolName, input, signal) {
         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", {
+                await this.record(spec.key, session.id, live.backend.name, spec.image, "stopped");
+                await this.options.emit(session.id, session.activeTurnId, "sandbox.state", {
                     state: "stopped",
                     backend: live.backend.name,
                     error: message,
@@ -124,7 +182,7 @@ export class SandboxManager {
             const outcome = await runSandboxTool(live.handle, toolName, (input ?? {}), signal, (value) => {
                 report = value;
             });
-            this.options.emit(session.id, session.activeTurnId, "sandbox.exec", {
+            await this.options.emit(session.id, session.activeTurnId, "sandbox.exec", {
                 tool: toolName,
                 ...report,
                 ...(report.command ? { command: report.command.slice(0, 500) } : {}),
@@ -145,38 +203,26 @@ export class SandboxManager {
                 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 existing = await this.options.store.tx((t) => t.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", {
+        await this.record(spec.key, session.id, live.backend.name, spec.image, "creating", existing);
+        await 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 });
+        await this.record(spec.key, session.id, live.backend.name, spec.image, "running", existing);
+        await 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)
@@ -186,25 +232,28 @@ export class SandboxManager {
             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 });
+            await this.record(key, live.sessionId, live.backend.name, undefined, "stopped");
+            await 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)) {
+    async record(key, sessionId, backend, image, state, known) {
         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,
-        }));
+        await this.options.store.tx(async (t) => {
+            const existing = known ?? (await t.get("sandboxes", key));
+            await t.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));
+        return this.options.store.tx((t) => t.get("sandboxes", this.keyOf(sessionId)));
     }
     /** Delete sandboxes this Runtime owns whose session no longer exists. */
     async reconcile(sessionExists) {
@@ -212,11 +261,11 @@ export class SandboxManager {
         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))
+            const record = await this.options.store.tx((t) => t.get("sandboxes", key));
+            if (record && (await sessionExists(record.sessionId)))
                 continue;
             await backend.remove(key);
-            this.options.store.tx(() => this.options.store.delete("sandboxes", key));
+            await this.options.store.tx((t) => t.delete("sandboxes", key));
         }
     }
     async close() {
@@ -224,7 +273,6 @@ export class SandboxManager {
         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;

package/dist/sandbox/select.d.ts

@@ -15,7 +15,7 @@ export interface SandboxSelectionReport {
     readonly reason: string;
     readonly probes: readonly SandboxProbe[];
 }
-/** The default order: strongest isolation first, then the backend that always works. */
+/** The backends a Runtime probes, in order. `auto` picks the first available one. */
 export declare function defaultSandboxBackends(options: {
     readonly root: string;
 }): SandboxBackend[];

package/dist/sandbox/select.js

@@ -1,9 +1,8 @@
-import { microsandboxBackend } from "../adapters/sandbox/microsandbox.js";
 import { virtualBackend } from "../adapters/sandbox/virtual.js";
-const PREFERENCES = ["auto", "microsandbox", "virtual"];
-/** The default order: strongest isolation first, then the backend that always works. */
+const PREFERENCES = ["auto", "virtual"];
+/** The backends a Runtime probes, in order. `auto` picks the first available one. */
 export function defaultSandboxBackends(options) {
-    return [microsandboxBackend(), virtualBackend({ root: options.root })];
+    return [virtualBackend({ root: options.root })];
 }
 export function parseSandboxPreference(value) {
     const normalized = (value ?? "auto").trim().toLowerCase() || "auto";
@@ -75,7 +74,7 @@ export async function probeSandboxBackends(options = {}) {
             preference: "auto",
             backend: null,
             isolation: null,
-            reason: "sandbox.backend must be auto, microsandbox or virtual",
+            reason: "sandbox.backend must be auto or virtual",
             probes: await Promise.all(backends.map((backend) => backend.probe())),
         };
     return reportSelection(await selectSandboxBackend(backends, preference));

package/dist/sandbox/types.d.ts

@@ -3,8 +3,8 @@
  * and import a substrate SDK; everything else in the Runtime talks to this interface.
  */
 import type { SandboxNetworkPreset } from "@nylorun/core/define";
-export type SandboxBackendName = "microsandbox" | "virtual";
-export type SandboxIsolation = "vm" | "process";
+export type SandboxBackendName = "virtual";
+export type SandboxIsolation = "process";
 export interface SandboxProbe {
     readonly name: SandboxBackendName;
     readonly available: boolean;

package/dist/store/canonical.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Canonical JSON: object keys sorted, `undefined` members dropped. Idempotency
+ * comparisons (commands, effects, vault requests) compare canonical forms.
+ */
+export declare function canonical(value: unknown): string;

package/dist/store/canonical.js

@@ -0,0 +1,17 @@
+/**
+ * Canonical JSON: object keys sorted, `undefined` members dropped. Idempotency
+ * comparisons (commands, effects, vault requests) compare canonical forms.
+ */
+export function canonical(value) {
+    if (Array.isArray(value))
+        return "[" + value.map(canonical).join(",") + "]";
+    if (value && typeof value === "object")
+        return ("{" +
+            Object.keys(value)
+                .sort()
+                .filter((k) => value[k] !== undefined)
+                .map((k) => JSON.stringify(k) + ":" + canonical(value[k]))
+                .join(",") +
+            "}");
+    return JSON.stringify(value) ?? "null";
+}

package/dist/store/cursor.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Event cursors. A cursor names the last event a client has seen:
+ * `base64url("<sessionId>:<seq>")`, where `seq` is the per-session event
+ * sequence and also the S2 sequence number in `sessions/<sessionId>`.
+ * The encoding matches the old global-sequence cursors, so clients see no format change.
+ */
+export declare function encodeCursor(sessionId: string, seq: number): string;
+/** Decodes a cursor for `sessionId`, or throws `Invalid cursor`. */
+export declare function decodeCursor(sessionId: string, cursor: string): number;

package/dist/store/cursor.js

@@ -0,0 +1,18 @@
+/**
+ * Event cursors. A cursor names the last event a client has seen:
+ * `base64url("<sessionId>:<seq>")`, where `seq` is the per-session event
+ * sequence and also the S2 sequence number in `sessions/<sessionId>`.
+ * The encoding matches the old global-sequence cursors, so clients see no format change.
+ */
+export function encodeCursor(sessionId, seq) {
+    return Buffer.from(`${sessionId}:${seq}`).toString("base64url");
+}
+/** Decodes a cursor for `sessionId`, or throws `Invalid cursor`. */
+export function decodeCursor(sessionId, cursor) {
+    const decoded = Buffer.from(cursor, "base64url").toString();
+    const prefix = `${sessionId}:`;
+    const rest = decoded.slice(prefix.length);
+    if (!decoded.startsWith(prefix) || !/^\d+$/.test(rest))
+        throw new Error("Invalid cursor");
+    return Number(rest);
+}

package/dist/store/memory.d.ts

@@ -0,0 +1,57 @@
+import { type CommitListener, type DocTable, type ExecutorRow, type PrincipalRow, type SessionOwnership, type SessionStore, type SessionStoreOptions, type StoreHealth, type Tx, type VaultAuditRow, type VaultCredentialRow, type VaultIdempotencyRow, type VaultRow } from "./types.js";
+/** Schema version the fake reports; it has no migrations. */
+export declare const MEMORY_SCHEMA_VERSION = 1;
+interface SessionMeta extends SessionOwnership {
+    nextSeq: number;
+}
+interface State {
+    /** JSON text per id, like a `body` column. */
+    docs: Record<DocTable, Map<string, string>>;
+    sessionMeta: Map<string, SessionMeta>;
+    /** sessionId → seq → event JSON. */
+    outbox: Map<string, Map<number, string>>;
+    executors: Map<string, ExecutorRow>;
+    principals: Map<string, PrincipalRow>;
+    vaults: Map<string, VaultRow>;
+    credentials: Map<string, VaultCredentialRow>;
+    audit: VaultAuditRow[];
+    idempotency: Map<string, VaultIdempotencyRow>;
+    settings: Map<string, string>;
+}
+/**
+ * The data behind in-memory Session Stores: what a database is to its connections. Several
+ * `MemorySessionStore`s on one `MemoryStoreData` see each other's commits and serialize their
+ * transactions together, as several processes on one Tenant schema would; it outlives them,
+ * so a test can close a Tenant and open it again.
+ */
+export declare class MemoryStoreData {
+    /** @internal */ state: State;
+    /** @internal */ queue: Promise<void>;
+}
+/**
+ * In-memory `SessionStore` for unit tests. Not a supported profile.
+ *
+ * Transactions are serialized (one at a time), each works on a copy of the
+ * state and replaces it on commit, so a throw rolls back everything: documents,
+ * sequences, outbox rows, `afterCommit` callbacks and `signalWork`. Commit listeners see
+ * only this store's commits, as with a Postgres connection.
+ */
+export declare class MemorySessionStore implements SessionStore {
+    /** Shared with other stores on the same data; a fresh, private one by default. */
+    private readonly data;
+    readonly tenantId: string;
+    private readonly active;
+    private readonly listeners;
+    private readonly now;
+    private readonly onError;
+    private closed;
+    constructor(options: SessionStoreOptions, 
+    /** Shared with other stores on the same data; a fresh, private one by default. */
+    data?: MemoryStoreData);
+    tx<T>(fn: (t: Tx) => Promise<T>): Promise<T>;
+    onCommit(listener: CommitListener): () => void;
+    health(): Promise<StoreHealth>;
+    close(): Promise<void>;
+    private acquire;
+}
+export {};