@nylorun/runtime 0.9.0-beta → 0.11.0-beta

package/dist/sandbox/select.js

@@ -1,11 +1,8 @@
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-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";
@@ -26,10 +23,15 @@ export async function selectSandboxBackend(backends, preference) {
         const backend = backends.find((item) => item.name === preference);
         const probe = probeOf(preference);
         if (backend && probe?.available)
-            return { preference, backend, reason: `${preference} selected by NYLORUN_SANDBOX`, probes };
+            return {
+                preference,
+                backend,
+                reason: `${preference} selected by TenantConfig.sandbox.backend`,
+                probes,
+            };
         return {
             preference,
-            reason: `NYLORUN_SANDBOX=${preference} but ${preference} is unavailable: ${probe?.reason ?? "unknown backend"}. Fix it, or unset NYLORUN_SANDBOX to use the best available backend`,
+            reason: `sandbox.backend=${preference} but ${preference} is unavailable: ${probe?.reason ?? "unknown backend"}. Fix it, or set backend to auto to use the best available backend`,
             probes,
         };
     }
@@ -58,18 +60,21 @@ export function reportSelection(selection) {
     };
 }
 /**
- * Probe this machine the way a Runtime would at startup. Used by `nylorun doctor sandbox`.
- * Nothing is created or booted.
+ * Probe backends the way a Tenant Runtime would at open.
+ * Callers must pass an explicit probe root; no ambient env or OS temp (A7).
  */
 export async function probeSandboxBackends(options = {}) {
-    const preference = parseSandboxPreference(options.preference ?? process.env.NYLORUN_SANDBOX);
-    const backends = defaultSandboxBackends({ root: join(tmpdir(), "nylorun-sandbox-probe") });
+    if (!options.root) {
+        throw new Error("probeSandboxBackends requires an explicit root (Tenant or Host tmp path)");
+    }
+    const preference = parseSandboxPreference(options.preference ?? "auto");
+    const backends = defaultSandboxBackends({ root: options.root });
     if (!preference)
         return {
             preference: "auto",
             backend: null,
             isolation: null,
-            reason: "NYLORUN_SANDBOX 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/share.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared workflow sandbox: one sandbox per owning session, attached via
+ * PutSession.sandbox = { session }. Specs must match; keys use the owner id.
+ */
+import { type AgentManifest, type CapabilityManifest, type SandboxManifest, type WorkflowManifest } from "@nylorun/core/define";
+export type SessionSandboxRef = {
+    readonly id: string;
+    readonly ownerUserId: string;
+    readonly manifest: AgentManifest | WorkflowManifest | Record<string, unknown>;
+    /** Session whose id keys the sandbox. Absent means this session owns its own. */
+    readonly sandboxOwnerId?: string | null;
+};
+/** Sandbox spec declared on an agent capability or a workflow manifest. */
+export declare function sandboxSpecOf(manifest: AgentManifest | WorkflowManifest | Record<string, unknown> | undefined): SandboxManifest | undefined;
+export declare function sandboxSpecsEqual(a: SandboxManifest | undefined, b: SandboxManifest | undefined): boolean;
+/** Synthetic capability so SandboxManager.run can use a workflow (or shared) spec. */
+export declare function capabilityForSandbox(sandbox: SandboxManifest): CapabilityManifest;
+/**
+ * Resolve the session id that keys the sandbox. Walks one hop via sandboxOwnerId;
+ * cycles fall back to the starting session.
+ */
+export declare function owningSandboxSessionId(session: SessionSandboxRef, lookup: (id: string) => SessionSandboxRef | undefined): string;
+export declare function sessionHasSandbox(session: SessionSandboxRef, lookup: (id: string) => SessionSandboxRef | undefined): boolean;

package/dist/sandbox/share.js

@@ -0,0 +1,58 @@
+/**
+ * Shared workflow sandbox: one sandbox per owning session, attached via
+ * PutSession.sandbox = { session }. Specs must match; keys use the owner id.
+ */
+import { canonical, } from "@nylorun/core/define";
+/** Sandbox spec declared on an agent capability or a workflow manifest. */
+export function sandboxSpecOf(manifest) {
+    if (!manifest || typeof manifest !== "object")
+        return undefined;
+    if (manifest.kind === "workflow")
+        return manifest.sandbox;
+    const capabilities = manifest.capabilities;
+    if (!Array.isArray(capabilities))
+        return undefined;
+    for (const capability of capabilities)
+        if (capability.sandbox)
+            return capability.sandbox;
+    return undefined;
+}
+export function sandboxSpecsEqual(a, b) {
+    if (a === undefined && b === undefined)
+        return true;
+    if (a === undefined || b === undefined)
+        return false;
+    return canonical(a) === canonical(b);
+}
+/** Synthetic capability so SandboxManager.run can use a workflow (or shared) spec. */
+export function capabilityForSandbox(sandbox) {
+    return {
+        id: "sandbox",
+        type: "agent",
+        sandbox,
+        tools: [],
+    };
+}
+/**
+ * Resolve the session id that keys the sandbox. Walks one hop via sandboxOwnerId;
+ * cycles fall back to the starting session.
+ */
+export function owningSandboxSessionId(session, lookup) {
+    const seen = new Set();
+    let current = session;
+    while (current) {
+        if (seen.has(current.id))
+            return session.id;
+        seen.add(current.id);
+        const ownerId = current.sandboxOwnerId;
+        if (!ownerId || ownerId === current.id)
+            return current.id;
+        current = lookup(ownerId);
+    }
+    return session.id;
+}
+export function sessionHasSandbox(session, lookup) {
+    const ownerId = owningSandboxSessionId(session, lookup);
+    const owner = ownerId === session.id ? session : lookup(ownerId) ?? session;
+    return sandboxSpecOf(owner.manifest) !== undefined || sandboxSpecOf(session.manifest) !== undefined;
+}

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 {};