@nylorun/runtime 0.10.0-beta → 0.12.0-beta

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.10.0-beta";
+export declare const RUNTIME_VERSION = "0.12.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.10.0-beta";
+export const RUNTIME_VERSION = "0.12.0-beta";

package/package.json

@@ -1,20 +1,17 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.10.0-beta",
-  "description": "SQLite agent execution host and model providers.",
+  "version": "0.12.0-beta",
+  "description": "Nylorun Runtime: the agent execution Host on Postgres, Restate and S2, and model providers.",
   "type": "module",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/nylorun/harness.git",
+    "url": "git+https://github.com/nylorun/agents.git",
     "directory": "runtime"
   },
   "engines": {
     "node": ">=24.0.0"
   },
-  "bin": {
-    "nylorun-runtime": "dist/launcher/main.js"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -46,26 +43,30 @@
     "provenance": true
   },
   "scripts": {
-    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json && node -e \"require('node:fs').chmodSync('dist/launcher/main.js', 0o755)\"",
+    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json",
     "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/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.19.0-beta",
-    "@nylorun/core": "0.5.0-beta",
-    "just-bash": "3.4.2"
-  },
-  "optionalDependencies": {
-    "microsandbox": "0.7.2"
+    "@nylorun/harness": "0.19.2-beta",
+    "@nylorun/core": "0.7.0-beta",
+    "@restatedev/restate-sdk": "1.16.9",
+    "@s2-dev/streamstore": "0.27.0",
+    "just-bash": "3.4.2",
+    "postgres": "^3.4.9"
   },
   "devDependencies": {
+    "@ag-ui/client": "1.0.0",
     "@types/node": "^26.5.0",
     "@typescript/native": "npm:typescript@^7.0.2",
     "hono": "^4.13.8",

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/store.d.ts

@@ -1,32 +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;
-    principalId?: string;
-    createdAt: string;
-    updatedAt: string;
-}
-export declare class Store {
-    private readonly tenantId;
-    readonly db: DatabaseSync;
-    constructor(path: string, tenantId: 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,143 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { randomUUID } from "node:crypto";
-import { migrateTenantDatabase } from "../tenant/schema.js";
-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 {
-    tenantId;
-    db;
-    constructor(path, tenantId) {
-        this.tenantId = tenantId;
-        this.db = new DatabaseSync(path);
-        this.db.exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;`);
-        migrateTenantDatabase(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,principal_id,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),
-            principalId: r.principal_id == null ? undefined : String(r.principal_id),
-            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,principal_id,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,
-           principal_id=excluded.principal_id,
-           updated_at=excluded.updated_at`)
-            .run(row.agentId, row.tokenHash, row.implementationVersion, row.manifestHash ?? null, row.principalId ?? 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,
-            tenantId: this.tenantId,
-            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;
-}

package/dist/launcher/commands.d.ts

@@ -1,24 +0,0 @@
-import { type LifecycleContext } from "./lifecycle.js";
-import { type OutputSink } from "./output.js";
-export declare const launcherUsage = "Usage: nylorun-runtime [--home <dir>] [--json] <command>\n\nCommands:\n  version                  also --version\n  up [--port <n>] [--allow-downgrade]\n  down [--wait [--timeout <s>]] [--force]\n  restart [--port <n>] [--allow-downgrade] [--wait | --force]\n  run [--port <n>] [--allow-downgrade]\n  status\n  logs [--lines <n>] [--follow] [--tenant <id> | --all]";
-export interface LauncherRuntimeOptions {
-    home: string;
-    platform: NodeJS.Platform;
-    /** Node running this launcher (`process.execPath`); the Host runs on it. */
-    nodeBinary: string;
-    /** `process.versions.node`; the launcher refuses Node older than 24. */
-    nodeVersion: string;
-    sink: OutputSink;
-    /** Allowlisted ambient baseline from main.ts. */
-    baselineEnv: Readonly<Record<string, string | undefined>>;
-    fetchImpl?: typeof fetch;
-    /** Abort signal for logs --follow (tests). */
-    signal?: AbortSignal;
-    /** Optional lifecycle overrides for tests. */
-    lifecycle?: Partial<Pick<LifecycleContext, "spawnHost" | "onSignal" | "lock" | "fetchImpl" | "hostEntry" | "runtimeVersion" | "tenantSchemaMax">>;
-}
-/**
- * Run launcher commands. Returns a process exit code (0, 1, or 2).
- * Ambient values must already be resolved into `options`.
- */
-export declare function runLauncher(argv: readonly string[], options: LauncherRuntimeOptions): Promise<number>;