@nylorun/runtime 0.8.0-beta → 0.10.0-beta

package/dist/tenant/types.d.ts

@@ -0,0 +1,125 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { AdminTenant, AdminTenantStatus, HostAggregate, TenantEnvelope } from "@nylorun/core/contracts";
+import type { FlowLimits } from "../core/limits.js";
+import type { SandboxBackend } from "../sandbox/types.js";
+export type TenantMode = "shared" | "ephemeral" | "test";
+export interface TenantPaths {
+    root: string;
+    envelope: string;
+    database: string;
+    lock: string;
+    kek: string;
+    home: string;
+    tmp: string;
+    migration: string;
+    sandboxes: string;
+    pluginData: string;
+    logs: string;
+    log: string;
+}
+export type TenantModelConfig = {
+    kind: "vault";
+} | {
+    kind: "gateway";
+    url: string;
+    model: string;
+} | {
+    kind: "fixture";
+} | {
+    kind: "scripted";
+    output?: string;
+};
+export interface TenantConfig {
+    tenantId: string;
+    mode: TenantMode;
+    paths: TenantPaths;
+    sandbox: {
+        backend: "auto" | "microsandbox" | "virtual";
+        backends?: readonly SandboxBackend[];
+    };
+    model: TenantModelConfig;
+    childEnv: Readonly<Record<string, string>>;
+    leaseMs?: number;
+    /** Operator flow limits (`RuntimeOptions.flow` / `workflows.md` §13). */
+    flow?: Partial<FlowLimits>;
+    /**
+     * Optional env snapshot for `NYLORUN_FLOW_*`. Host passes this; the Runtime
+     * never reads ambient process environment for flow limits.
+     */
+    flowEnv?: Readonly<Record<string, string | undefined>>;
+    vaultFetch?: typeof fetch;
+    logger: Logger;
+}
+export interface Logger {
+    info(message: string, fields?: Record<string, unknown>): void;
+    warn(message: string, fields?: Record<string, unknown>): void;
+    error(message: string, fields?: Record<string, unknown>): void;
+}
+export interface TenantSummary {
+    ready: boolean;
+    runningSessions: number;
+    connectedExecutors: number;
+    pendingActions: number;
+    uncertainEffects: number;
+}
+/** An open Tenant Runtime. Created only by the Tenant module. */
+export interface TenantHandle {
+    readonly envelope: TenantEnvelope;
+    /** Headers already validated by the Host. Authenticates, authorizes, dispatches. */
+    handle(request: IncomingMessage, response: ServerResponse, url: URL): Promise<void>;
+    summary(): TenantSummary;
+    /** Stop scheduling; wait for or cancel active turns. */
+    drain(activeWork: "drain" | "cancel", timeoutMs?: number): Promise<void>;
+    close(): Promise<void>;
+}
+export type TenantResolution = {
+    kind: "open";
+    handle: TenantHandle;
+} | {
+    kind: "not-found";
+} | {
+    kind: "quarantined";
+    quarantine: Quarantine;
+};
+export interface Quarantine {
+    code: "locked" | "kek-missing" | "corrupt" | "schema-too-new" | "migration-failed" | "envelope-invalid" | "open-timeout" | "open-failed";
+    message: string;
+    repair: string;
+    lockPath?: string;
+    lockPid?: number;
+}
+export interface BootstrapPrincipal {
+    principalId: string;
+    credentialHash: string;
+    idempotencyKey: string;
+}
+/** The deep module (§8). HTTP, CLI and tests use only this. */
+export interface TenantModule {
+    start(): Promise<void>;
+    readonly started: boolean;
+    resolve(id: string): TenantResolution;
+    create(input: {
+        tenantId: string;
+        name: string;
+    } & BootstrapPrincipal): Promise<{
+        envelope: TenantEnvelope;
+        created: boolean;
+    }>;
+    list(): Promise<readonly AdminTenant[]>;
+    status(id: string): Promise<AdminTenantStatus | undefined>;
+    delete(id: string, activeWork: "refuse" | "drain" | "cancel"): Promise<void>;
+    summarize(): HostAggregate;
+    close(): Promise<void>;
+}
+/** Storage adapter behind the module (§8): OSS directory+SQLite, and in-memory for tests. */
+export interface TenantStore {
+    enumerate(): Promise<readonly string[]>;
+    readEnvelope(id: string): Promise<TenantEnvelope>;
+    create(envelope: TenantEnvelope, bootstrap: BootstrapPrincipal): Promise<"created" | "exists">;
+    bootstrapMatches(id: string, bootstrap: BootstrapPrincipal): Promise<boolean>;
+    open(id: string): Promise<TenantHandle>;
+    trash(id: string, now: Date): Promise<void>;
+    removePartial(id: string): Promise<void>;
+}
+/** Injected into the store so WS-B can test without WS-A. */
+export type OpenTenantRuntime = (config: TenantConfig) => Promise<TenantHandle>;

package/dist/tenant/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vault/kek.d.ts

@@ -1,6 +1,9 @@
-export declare function defaultKekPath(): string;
+/**
+ * Read the Tenant vault KEK from an explicit value or file path.
+ * No environment override (A7).
+ */
 export declare function readVaultKek(options: {
     vaultKek?: Buffer | string | null;
-    vaultKekPath?: string;
+    vaultKekPath: string;
 }): Buffer | undefined;
 export declare function createKekFile(path: string): Buffer;

package/dist/vault/kek.js

@@ -1,22 +1,19 @@
 import { randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
 import { parseKek } from "./crypto.js";
-export function defaultKekPath() {
-    return join(process.cwd(), ".nylorun", "vault-kek");
-}
+/**
+ * Read the Tenant vault KEK from an explicit value or file path.
+ * No environment override (A7).
+ */
 export function readVaultKek(options) {
     if (options.vaultKek === null)
         return undefined;
     if (options.vaultKek !== undefined)
         return parseKek(options.vaultKek);
-    const fromEnv = process.env.NYLORUN_VAULT_KEK;
-    if (fromEnv)
-        return parseKek(fromEnv);
-    const path = options.vaultKekPath ?? defaultKekPath();
-    if (!existsSync(path))
+    if (!existsSync(options.vaultKekPath))
         return undefined;
-    return parseKek(readFileSync(path, "utf8"));
+    return parseKek(readFileSync(options.vaultKekPath, "utf8"));
 }
 export function createKekFile(path) {
     const bytes = randomBytes(32);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const RUNTIME_VERSION = "0.8.0-beta";
+export declare const RUNTIME_VERSION = "0.10.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.8.0-beta";
+export const RUNTIME_VERSION = "0.10.0-beta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/runtime",
-  "version": "0.8.0-beta",
+  "version": "0.10.0-beta",
   "description": "SQLite agent execution host and model providers.",
   "type": "module",
   "license": "Apache-2.0",
@@ -12,6 +12,9 @@
   "engines": {
     "node": ">=24.0.0"
   },
+  "bin": {
+    "nylorun-runtime": "dist/launcher/main.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -25,7 +28,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"
@@ -43,20 +46,20 @@
     "provenance": true
   },
   "scripts": {
-    "build": "npm run clean && node ../scripts/check-typescript-version.mjs && tsc -p tsconfig.json",
+    "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)\"",
     "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",
     "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",
     "@hono/node-server": "^2.1.1",
-    "@nylorun/harness": "0.17.0-beta",
-    "@nylorun/core": "0.3.0-beta",
+    "@nylorun/harness": "0.19.0-beta",
+    "@nylorun/core": "0.5.0-beta",
     "just-bash": "3.4.2"
   },
   "optionalDependencies": {

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