@nylorun/runtime 0.9.0-beta → 0.11.0-beta

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.9.0-beta";
+export declare const RUNTIME_VERSION = "0.11.0-beta";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in step with package.json by runtime/scripts/check-package.mjs, which runs in npm run check.
 // release:prepare also rewrites this when it bumps @nylorun/runtime.
-export const RUNTIME_VERSION = "0.9.0-beta";
+export const RUNTIME_VERSION = "0.11.0-beta";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.9.0-beta",
-  "description": "SQLite agent execution host and model providers.",
+  "version": "0.11.0-beta",
+  "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
   "repository": {
@@ -25,7 +25,7 @@
       "types": "./dist/core/runtime.d.ts",
       "import": "./dist/core/runtime.js"
     },
-    "./server": "./dist/core/main.js",
+    "./server": "./dist/host/main.js",
     "./configuration": {
       "types": "./dist/configuration.d.ts",
       "import": "./dist/configuration.js"
@@ -47,20 +47,23 @@
     "check": "npm run build && npm test && node scripts/check-package.mjs",
     "typecheck": "node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
+    "test:integration": "vitest run --config vitest.integration.config.ts",
+    "test:stack:up": "node test/stack/up.mjs up",
+    "test:stack:down": "node test/stack/up.mjs down",
     "prepack": "npm run build",
     "clean": "node -e \"import('node:fs').then(({rmSync})=>rmSync('dist',{recursive:true,force:true}))\"",
-    "start": "node dist/core/main.js"
+    "start": "node dist/host/main.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@earendil-works/pi-ai": "0.85.1",
+    "@earendil-works/pi-ai": "0.87.0",
     "@hono/node-server": "^2.1.1",
-    "@nylorun/harness": "0.18.0-beta",
-    "@nylorun/core": "0.4.0-beta",
-    "just-bash": "3.4.2"
-  },
-  "optionalDependencies": {
-    "microsandbox": "0.7.2"
+    "@nylorun/harness": "0.19.1-beta",
+    "@nylorun/core": "0.6.0-beta",
+    "@restatedev/restate-sdk": "1.16.9",
+    "@s2-dev/streamstore": "0.27.0",
+    "just-bash": "3.4.2",
+    "postgres": "^3.4.9"
   },
   "devDependencies": {
     "@types/node": "^26.5.0",

package/dist/adapters/sandbox/microsandbox.d.ts

@@ -1,2 +0,0 @@
-import type { SandboxBackend } from "../../sandbox/types.js";
-export declare function microsandboxBackend(): SandboxBackend;

package/dist/adapters/sandbox/microsandbox.js

@@ -1,238 +0,0 @@
-/** microsandbox backend: a hardware-isolated microVM per sandbox (libkrun). */
-import { accessSync, constants, readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { SANDBOX_WORKSPACE } from "@nylorun/core/define";
-/** Releases that are known not to work; the probe refuses them and selection falls back. */
-const KNOWN_BAD_VERSIONS = new Set(["0.7.0"]);
-/** Keep at most this much of each output stream in memory while a command runs. */
-const CAPTURE_LIMIT = 4 * 1024 * 1024;
-const require = createRequire(import.meta.url);
-/** The package's exports map hides package.json, so walk up from its entry point. */
-function installedVersion() {
-    try {
-        let directory = dirname(require.resolve("microsandbox"));
-        for (let depth = 0; depth < 4; depth += 1, directory = dirname(directory)) {
-            try {
-                const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
-                if (manifest.name === "microsandbox")
-                    return manifest.version;
-            }
-            catch { }
-        }
-        return undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function platformReason() {
-    if (process.platform === "darwin")
-        return process.arch === "arm64" ? undefined : "requires Apple Silicon on macOS";
-    if (process.platform === "linux") {
-        try {
-            accessSync("/dev/kvm", constants.R_OK | constants.W_OK);
-            return undefined;
-        }
-        catch {
-            return "no usable /dev/kvm (enable KVM or nested virtualisation)";
-        }
-    }
-    if (process.platform === "win32")
-        return "not yet enabled on Windows";
-    return `unsupported platform ${process.platform}`;
-}
-export function microsandboxBackend() {
-    let sdk;
-    const load = () => (sdk ??= import("microsandbox"));
-    const handleFor = (sandbox) => ({
-        async exec(request, signal) {
-            const execution = await sandbox.execStreamWith("bash", (options) => options
-                .args(["-c", request.command])
-                .cwd(request.cwd)
-                .envs({ LANG: "C.UTF-8", TERM: "dumb" })
-                .stdinNull());
-            const stdout = new Capture();
-            const stderr = new Capture();
-            let killed = false;
-            let timedOut = false;
-            const kill = () => {
-                if (killed)
-                    return;
-                killed = true;
-                void execution.kill().catch(() => undefined);
-            };
-            const timer = setTimeout(() => {
-                timedOut = true;
-                kill();
-            }, request.timeoutMs);
-            const onAbort = () => kill();
-            signal.addEventListener("abort", onAbort, { once: true });
-            if (signal.aborted)
-                kill();
-            let exitCode = -1;
-            try {
-                for await (const event of execution) {
-                    if (event.kind === "stdout")
-                        stdout.push(event.data);
-                    else if (event.kind === "stderr")
-                        stderr.push(event.data);
-                    else if (event.kind === "exited") {
-                        exitCode = event.code;
-                        break;
-                    }
-                }
-            }
-            finally {
-                clearTimeout(timer);
-                signal.removeEventListener("abort", onAbort);
-            }
-            return {
-                exitCode: killed && exitCode < 0 ? (timedOut ? 124 : 130) : exitCode,
-                stdout: stdout.text(),
-                stderr: stderr.text(),
-                killed,
-                timedOut,
-            };
-        },
-        async readFile(path) {
-            const fs = sandbox.fs();
-            if (!(await fs.exists(path)))
-                return undefined;
-            return fs.readToString(path);
-        },
-        async writeFile(path, content) {
-            await sandbox.fs().write(path, content);
-        },
-        async stop() {
-            await sandbox.stop();
-        },
-    });
-    return {
-        name: "microsandbox",
-        isolation: "vm",
-        async probe() {
-            const base = { name: "microsandbox", isolation: "vm" };
-            const version = installedVersion();
-            const platform = platformReason();
-            if (platform)
-                return { ...base, available: false, reason: platform, ...(version ? { version } : {}) };
-            if (!version)
-                return {
-                    ...base,
-                    available: false,
-                    reason: "the optional microsandbox package is not installed (reinstall with optional dependencies enabled)",
-                };
-            if (KNOWN_BAD_VERSIONS.has(version))
-                return { ...base, available: false, version, reason: `microsandbox ${version} is a known-bad release` };
-            try {
-                const msb = await load();
-                if (!(await msb.isRuntimeInstalled()))
-                    return { ...base, available: false, version, reason: "the microsandbox runtime (msb, libkrunfw) is not installed" };
-            }
-            catch (error) {
-                return {
-                    ...base,
-                    available: false,
-                    version,
-                    reason: `could not load microsandbox: ${error instanceof Error ? error.message : String(error)}`,
-                };
-            }
-            return { ...base, available: true, version, reason: "hardware-isolated microVM" };
-        },
-        unmet() {
-            return undefined;
-        },
-        async open(spec) {
-            const msb = await load();
-            const { Sandbox, SandboxNotFoundError } = msb;
-            try {
-                const existing = await Sandbox.get(spec.key);
-                return handleFor(await existing.connectOrStart());
-            }
-            catch (error) {
-                if (!(error instanceof SandboxNotFoundError))
-                    throw error;
-            }
-            const sandbox = await Sandbox.builder(spec.key)
-                .image(spec.image)
-                .cpus(spec.cpus)
-                .memory(spec.memoryMiB)
-                .patch((patch) => patch.mkdir(SANDBOX_WORKSPACE, { mode: 0o755 }))
-                .workdir(SANDBOX_WORKSPACE)
-                .label("nylorun", "sandbox")
-                .network((network) => network.policy(policyFor(msb, spec)))
-                .create();
-            return handleFor(sandbox);
-        },
-        async remove(key) {
-            const { Sandbox, SandboxNotFoundError } = await load();
-            try {
-                const handle = await Sandbox.get(key);
-                await handle.destroy({ force: true });
-            }
-            catch (error) {
-                if (!(error instanceof SandboxNotFoundError))
-                    throw error;
-            }
-        },
-        async list(prefix) {
-            const { Sandbox } = await load();
-            const keys = [];
-            let page = await Sandbox.list();
-            for (;;) {
-                for (const handle of page.sandboxes)
-                    if (handle.name.startsWith(prefix))
-                        keys.push(handle.name);
-                if (!page.nextCursor)
-                    break;
-                const cursor = page.nextCursor;
-                page = await Sandbox.listWith((list) => list.cursor(cursor));
-            }
-            return keys;
-        },
-    };
-}
-/** Deny by default. Private, loopback, link-local, metadata and host ranges are always denied. */
-function policyFor(msb, spec) {
-    const { Destination, Rule } = msb;
-    const always = ["private", "loopback", "link-local", "metadata", "multicast"];
-    // The host is denied for TCP only: its resolver answers DNS for the sandbox and filters
-    // names by this same policy, so a UDP deny would break every allowed host.
-    const host = {
-        direction: "egress",
-        destination: Destination.group("host"),
-        protocols: ["tcp"],
-        ports: [],
-        action: "deny",
-    };
-    return {
-        defaultEgress: "deny",
-        defaultIngress: "deny",
-        rules: [
-            ...always.map((group) => Rule.denyEgress(Destination.group(group))),
-            host,
-            ...(spec.network.preset === "open" ? [Rule.allowEgress(Destination.group("public"))] : []),
-            ...spec.network.hosts.map((host) => Rule.allowEgress(Destination.domain(host))),
-            ...spec.network.suffixes.map((suffix) => Rule.allowEgress(Destination.domainSuffix(suffix))),
-        ],
-    };
-}
-class Capture {
-    chunks = [];
-    size = 0;
-    dropped = 0;
-    push(data) {
-        const chunk = typeof data === "string" ? Buffer.from(data) : Buffer.from(data);
-        if (this.size >= CAPTURE_LIMIT) {
-            this.dropped += chunk.length;
-            return;
-        }
-        this.chunks.push(chunk);
-        this.size += chunk.length;
-    }
-    text() {
-        const text = Buffer.concat(this.chunks).toString("utf8");
-        return this.dropped > 0 ? `${text}\n… [${this.dropped} bytes not captured]` : text;
-    }
-}

package/dist/core/main.js

@@ -1,35 +0,0 @@
-import { startRuntime } from "./runtime.js";
-import { gatewayModel, scriptedModel, toolFixtureModel } from "./provider.js";
-const serverToken = process.env.NYLORUN_SERVER_KEY;
-if (!serverToken)
-    throw new Error("Set NYLORUN_SERVER_KEY (at least 16 characters)");
-const executors = JSON.parse(process.env.NYLORUN_EXECUTORS_JSON ?? "[]");
-const useHostModel = process.env.NYLORUN_DEV_MODEL !== "fixture" &&
-    process.env.NYLORUN_PROJECT_PROVIDER === "1";
-const model = useHostModel
-    ? undefined
-    : process.env.NYLORUN_DEV_MODEL === "fixture"
-        ? toolFixtureModel()
-        : process.env.NYLORUN_MODEL_GATEWAY_URL
-            ? gatewayModel({
-                url: process.env.NYLORUN_MODEL_GATEWAY_URL,
-                token: process.env.NYLORUN_MODEL_GATEWAY_KEY ?? "",
-                model: process.env.NYLORUN_MODEL ?? "",
-            })
-            : scriptedModel(process.env.NYLORUN_SCRIPTED_OUTPUT);
-const runtime = await startRuntime({
-    sqlitePath: process.env.NYLORUN_SQLITE_PATH ?? "./nylorun.sqlite",
-    serverToken,
-    executors,
-    model,
-    useHostModel,
-    port: Number(process.env.PORT ?? 8787),
-    hostname: process.env.HOST ?? "127.0.0.1",
-});
-console.log(`Nylorun Runtime listening at ${runtime.url}`);
-process.send?.({ type: "ready", url: runtime.url });
-let closing;
-for (const signal of ["SIGINT", "SIGTERM"])
-    process.on(signal, () => {
-        closing ??= runtime.close().then(() => { process.exit(0); });
-    });

package/dist/core/store.d.ts

@@ -1,30 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import type { LiveEvent } from "@nylorun/core/contracts";
-export declare function canonical(value: unknown): string;
-export interface ExecutorRow {
-    agentId: string;
-    tokenHash: string;
-    implementationVersion: string;
-    manifestHash?: string;
-    createdAt: string;
-    updatedAt: string;
-}
-export declare class Store {
-    readonly db: DatabaseSync;
-    constructor(path: string);
-    tx<T>(fn: () => T): T;
-    get<T = any>(table: string, id: string): T | undefined;
-    all<T = any>(table: string): T[];
-    put(table: string, id: string, body: unknown): void;
-    delete(table: string, id: string): void;
-    allExecutors(): ExecutorRow[];
-    putExecutor(row: Omit<ExecutorRow, "createdAt">): void;
-    deleteExecutor(agentId: string): void;
-    event(sessionId: string, turnId: string | null, type: string, payload: unknown): LiveEvent;
-    credentialCount(): number;
-    /** `agent` keeps only events of one agent used as a tool, by delegationId or path. */
-    history(sessionId: string, cursor?: string, agent?: string): {
-        items: LiveEvent[];
-        cursor: string | null;
-    };
-}

package/dist/core/store.js

@@ -1,202 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { randomUUID } from "node:crypto";
-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";
-}
-export class Store {
-    db;
-    constructor(path) {
-        this.db = new DatabaseSync(path);
-        this.db
-            .exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;
-      CREATE TABLE IF NOT EXISTS definitions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS sessions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS commands(id TEXT PRIMARY KEY, body TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS checkpoints(id TEXT PRIMARY KEY, body TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS effects(id TEXT PRIMARY KEY, body TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS actions(id TEXT PRIMARY KEY, body TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS sandboxes(id TEXT PRIMARY KEY, body TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS events(sequence INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, body TEXT NOT NULL);
-      CREATE INDEX IF NOT EXISTS events_session ON events(session_id, sequence);
-      CREATE TABLE IF NOT EXISTS vaults(
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL,
-        owner_user_id TEXT NOT NULL,
-        metadata_json TEXT,
-        created_at TEXT NOT NULL,
-        scope TEXT NOT NULL DEFAULT 'user'
-      );
-      CREATE INDEX IF NOT EXISTS vaults_owner ON vaults(owner_user_id);
-      CREATE TABLE IF NOT EXISTS vault_credentials(
-        id TEXT PRIMARY KEY,
-        vault_id TEXT NOT NULL REFERENCES vaults(id) ON DELETE CASCADE,
-        name TEXT NOT NULL,
-        type TEXT NOT NULL,
-        binding_json TEXT NOT NULL,
-        expires_at TEXT,
-        created_at TEXT NOT NULL,
-        rotated_at TEXT,
-        kek_id TEXT NOT NULL,
-        nonce BLOB NOT NULL,
-        ciphertext BLOB NOT NULL,
-        wrapped_dek BLOB NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS vault_credentials_vault ON vault_credentials(vault_id);
-      CREATE TABLE IF NOT EXISTS vault_audit(
-        id TEXT PRIMARY KEY,
-        at TEXT NOT NULL,
-        actor TEXT NOT NULL,
-        action TEXT NOT NULL,
-        vault_id TEXT,
-        credential_id TEXT,
-        session_id TEXT,
-        target TEXT,
-        outcome TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS vault_idempotency(
-        id TEXT PRIMARY KEY,
-        body_hash TEXT NOT NULL,
-        response TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS executors(
-        agent_id TEXT PRIMARY KEY,
-        token_hash TEXT NOT NULL UNIQUE,
-        implementation_version TEXT NOT NULL,
-        manifest_hash TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );`);
-        migrateVaultScope(this.db);
-    }
-    tx(fn) {
-        this.db.exec("BEGIN IMMEDIATE");
-        try {
-            const result = fn();
-            this.db.exec("COMMIT");
-            return result;
-        }
-        catch (e) {
-            this.db.exec("ROLLBACK");
-            throw e;
-        }
-    }
-    get(table, id) {
-        const row = this.db.prepare(`SELECT body FROM ${table} WHERE id=?`).get(id);
-        return row ? JSON.parse(String(row.body)) : undefined;
-    }
-    all(table) {
-        return this.db
-            .prepare(`SELECT body FROM ${table}`)
-            .all()
-            .map((r) => JSON.parse(String(r.body)));
-    }
-    put(table, id, body) {
-        this.db
-            .prepare(`INSERT INTO ${table}(id,body) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET body=excluded.body`)
-            .run(id, JSON.stringify(body));
-    }
-    delete(table, id) {
-        this.db.prepare(`DELETE FROM ${table} WHERE id=?`).run(id);
-    }
-    // Executors carry a bearer secret, so they use typed columns with a database-enforced unique
-    // token hash instead of flowing through the generic JSON document helpers above.
-    allExecutors() {
-        return this.db
-            .prepare("SELECT agent_id,token_hash,implementation_version,manifest_hash,created_at,updated_at FROM executors")
-            .all()
-            .map((r) => ({
-            agentId: String(r.agent_id),
-            tokenHash: String(r.token_hash),
-            implementationVersion: String(r.implementation_version),
-            manifestHash: r.manifest_hash == null ? undefined : String(r.manifest_hash),
-            createdAt: String(r.created_at),
-            updatedAt: String(r.updated_at),
-        }));
-    }
-    putExecutor(row) {
-        this.db
-            .prepare(`INSERT INTO executors(agent_id,token_hash,implementation_version,manifest_hash,created_at,updated_at)
-         VALUES(?,?,?,?,?,?)
-         ON CONFLICT(agent_id) DO UPDATE SET
-           token_hash=excluded.token_hash,
-           implementation_version=excluded.implementation_version,
-           manifest_hash=excluded.manifest_hash,
-           updated_at=excluded.updated_at`)
-            .run(row.agentId, row.tokenHash, row.implementationVersion, row.manifestHash ?? null, row.updatedAt, row.updatedAt);
-    }
-    deleteExecutor(agentId) {
-        this.db.prepare("DELETE FROM executors WHERE agent_id=?").run(agentId);
-    }
-    event(sessionId, turnId, type, payload) {
-        const base = {
-            eventId: randomUUID(),
-            sessionId,
-            turnId,
-            createdAt: new Date().toISOString(),
-            type,
-            payload,
-        };
-        const result = this.db
-            .prepare("INSERT INTO events(session_id,body) VALUES(?,?)")
-            .run(sessionId, "{}");
-        const event = {
-            ...base,
-            cursor: Buffer.from(`${sessionId}:${result.lastInsertRowid}`).toString("base64url"),
-        };
-        this.db
-            .prepare("UPDATE events SET body=? WHERE sequence=?")
-            .run(JSON.stringify(event), result.lastInsertRowid);
-        return event;
-    }
-    credentialCount() {
-        const row = this.db
-            .prepare("SELECT COUNT(*) AS n FROM vault_credentials")
-            .get();
-        return Number(row.n);
-    }
-    /** `agent` keeps only events of one agent used as a tool, by delegationId or path. */
-    history(sessionId, cursor, agent) {
-        let sequence = 0;
-        if (cursor) {
-            const decoded = Buffer.from(cursor, "base64url").toString();
-            const prefix = `${sessionId}:`;
-            if (!decoded.startsWith(prefix) ||
-                !/^\d+$/.test(decoded.slice(prefix.length)))
-                throw new Error("Invalid cursor");
-            sequence = Number(decoded.slice(prefix.length));
-        }
-        const items = this.db
-            .prepare("SELECT body FROM events WHERE session_id=? AND sequence>? ORDER BY sequence")
-            .all(sessionId, sequence)
-            .map((r) => JSON.parse(String(r.body)))
-            .filter((event) => agent === undefined || belongsTo(event, agent));
-        const last = this.db
-            .prepare("SELECT body FROM events WHERE session_id=? ORDER BY sequence DESC LIMIT 1")
-            .get(sessionId);
-        return {
-            items,
-            cursor: last ? JSON.parse(String(last.body)).cursor : null,
-        };
-    }
-}
-function belongsTo(event, agent) {
-    const ref = event.payload
-        ?.agent;
-    return ref?.delegationId === agent || ref?.path === agent;
-}
-function migrateVaultScope(db) {
-    const columns = db.prepare("PRAGMA table_info(vaults)").all();
-    if (!columns.some((column) => column.name === "scope"))
-        db.exec("ALTER TABLE vaults ADD COLUMN scope TEXT NOT NULL DEFAULT 'user'");
-    db.exec("CREATE UNIQUE INDEX IF NOT EXISTS vaults_one_host ON vaults(scope) WHERE scope = 'host'");
-}