@nylorun/runtime 0.10.0-beta → 0.12.0-beta

package/dist/tenant/principals.d.ts

@@ -1,17 +1,16 @@
-import type { DatabaseSync } from "node:sqlite";
+import type { Tx } from "../store/types.js";
 import type { BootstrapPrincipal } from "./types.js";
-export interface PrincipalRow {
-    id: string;
-    role: "application";
-    tokenHash: string;
-    idempotencyKey: string | null;
-    createdAt: string;
-}
+export type { PrincipalRow } from "../store/types.js";
+/** Principal id of the Studio key derived from the admin key. */
+export declare const STUDIO_PRINCIPAL_ID = "studio";
 /**
- * Writes the application principal and idempotency key in one transaction.
+ * Writes the application principal and idempotency key in the caller's transaction, plus
+ * principal `studio` when the bootstrap carries a Studio credential hash.
  * Exported for WS-B's `TenantStore.create` (A3).
  */
-export declare function bootstrapPrincipal(db: DatabaseSync, bootstrap: BootstrapPrincipal): void;
-export declare function findPrincipalByTokenHash(db: DatabaseSync, tokenHash: string): PrincipalRow | undefined;
-export declare function applicationTokenHashes(db: DatabaseSync): readonly string[];
-export declare function isApplicationTokenHash(db: DatabaseSync, tokenHash: string): boolean;
+export declare function bootstrapPrincipal(t: Tx, bootstrap: BootstrapPrincipal, now?: Date): Promise<void>;
+/**
+ * Whether the stored bootstrap, Studio and derived principals equal `bootstrap`. A retried
+ * create names the same derived principals, so each must be stored with its hash.
+ */
+export declare function bootstrapPrincipalMatches(t: Tx, bootstrap: BootstrapPrincipal): Promise<boolean>;

package/dist/tenant/principals.js

@@ -1,44 +1,56 @@
+/** Principal id of the Studio key derived from the admin key. */
+export const STUDIO_PRINCIPAL_ID = "studio";
 /**
- * Writes the application principal and idempotency key in one transaction.
+ * Writes the application principal and idempotency key in the caller's transaction, plus
+ * principal `studio` when the bootstrap carries a Studio credential hash.
  * Exported for WS-B's `TenantStore.create` (A3).
  */
-export function bootstrapPrincipal(db, bootstrap) {
-    const now = new Date().toISOString();
-    db.exec("BEGIN IMMEDIATE");
-    try {
-        db.prepare(`INSERT INTO principals(id, role, token_hash, idempotency_key, created_at)
-       VALUES(?, 'application', ?, ?, ?)`).run(bootstrap.principalId, bootstrap.credentialHash, bootstrap.idempotencyKey, now);
-        db.exec("COMMIT");
-    }
-    catch (error) {
-        db.exec("ROLLBACK");
-        throw error;
-    }
-}
-export function findPrincipalByTokenHash(db, tokenHash) {
-    const row = db
-        .prepare(`SELECT id, role, token_hash, idempotency_key, created_at
-       FROM principals WHERE token_hash = ?`)
-        .get(tokenHash);
-    if (!row)
-        return undefined;
-    return {
-        id: String(row.id),
+export async function bootstrapPrincipal(t, bootstrap, now = new Date()) {
+    const createdAt = now.toISOString();
+    await t.insertPrincipal({
+        id: bootstrap.principalId,
         role: "application",
-        tokenHash: String(row.token_hash),
-        idempotencyKey: row.idempotency_key == null ? null : String(row.idempotency_key),
-        createdAt: String(row.created_at),
-    };
-}
-export function applicationTokenHashes(db) {
-    return db
-        .prepare(`SELECT token_hash FROM principals WHERE role = 'application'`)
-        .all()
-        .map((row) => String(row.token_hash));
+        tokenHash: bootstrap.credentialHash,
+        idempotencyKey: bootstrap.idempotencyKey,
+        createdAt,
+    });
+    if (bootstrap.studioCredentialHash)
+        await t.insertPrincipal({
+            id: STUDIO_PRINCIPAL_ID,
+            role: "application",
+            tokenHash: bootstrap.studioCredentialHash,
+            idempotencyKey: null,
+            createdAt,
+        });
+    for (const principal of bootstrap.derivedPrincipals ?? [])
+        await t.insertPrincipal({
+            id: principal.id,
+            role: "application",
+            tokenHash: principal.credentialHash,
+            idempotencyKey: null,
+            createdAt,
+        });
 }
-export function isApplicationTokenHash(db, tokenHash) {
-    const row = db
-        .prepare(`SELECT 1 AS ok FROM principals WHERE role = 'application' AND token_hash = ?`)
-        .get(tokenHash);
-    return !!row;
+/**
+ * Whether the stored bootstrap, Studio and derived principals equal `bootstrap`. A retried
+ * create names the same derived principals, so each must be stored with its hash.
+ */
+export async function bootstrapPrincipalMatches(t, bootstrap) {
+    const row = await t.principalById(bootstrap.principalId);
+    if (!row ||
+        row.role !== "application" ||
+        row.tokenHash !== bootstrap.credentialHash ||
+        row.idempotencyKey !== bootstrap.idempotencyKey)
+        return false;
+    const studio = await t.principalById(STUDIO_PRINCIPAL_ID);
+    if ((studio?.role === "application" ? studio.tokenHash : undefined) !==
+        bootstrap.studioCredentialHash)
+        return false;
+    for (const principal of bootstrap.derivedPrincipals ?? []) {
+        const stored = await t.principalById(principal.id);
+        if (stored?.role !== "application" ||
+            stored.tokenHash !== principal.credentialHash)
+            return false;
+    }
+    return true;
 }

package/dist/tenant/quarantine-error.d.ts

@@ -2,5 +2,5 @@ import type { Quarantine } from "./types.js";
 /** Typed quarantine raised while opening a Tenant Runtime (A7). */
 export declare class QuarantineError extends Error {
     readonly quarantine: Quarantine;
-    constructor(code: Quarantine["code"], message: string, repair?: string, extra?: Pick<Quarantine, "lockPath" | "lockPid">);
+    constructor(code: Quarantine["code"], message: string, repair?: string);
 }

package/dist/tenant/quarantine-error.js

@@ -1,15 +1,9 @@
 /** Typed quarantine raised while opening a Tenant Runtime (A7). */
 export class QuarantineError extends Error {
     quarantine;
-    constructor(code, message, repair = "nylorun tenant status", extra) {
+    constructor(code, message, repair = "nylo tenant status") {
         super(message);
         this.name = "QuarantineError";
-        this.quarantine = {
-            code,
-            message,
-            repair,
-            ...(extra?.lockPath === undefined ? {} : { lockPath: extra.lockPath }),
-            ...(extra?.lockPid === undefined ? {} : { lockPid: extra.lockPid }),
-        };
+        this.quarantine = { code, message, repair };
     }
 }

package/dist/tenant/quarantine.d.ts

@@ -3,8 +3,6 @@ import type { Quarantine } from "./types.js";
 export declare class QuarantineError extends Error implements Quarantine {
     readonly code: Quarantine["code"];
     readonly repair: string;
-    readonly lockPath?: string;
-    readonly lockPid?: number;
     constructor(fields: Quarantine);
     toQuarantine(): Quarantine;
 }
@@ -13,15 +11,9 @@ export declare function asQuarantine(error: unknown): Quarantine | undefined;
 /** CLI-facing repair strings for every quarantine code (B9). */
 export declare function repairFor(code: Quarantine["code"], detail?: {
     tenantId?: string;
-    lockPath?: string;
-    lockPid?: number;
-    migrationPath?: string;
 }): string;
 export declare function quarantine(code: Quarantine["code"], message: string, detail?: {
     tenantId?: string;
-    lockPath?: string;
-    lockPid?: number;
-    migrationPath?: string;
 }): QuarantineError;
 /** Conflict when create bootstrap material does not match an existing Tenant (HTTP 409). */
 export declare class TenantConflictError extends Error {

package/dist/tenant/quarantine.js

@@ -2,26 +2,14 @@
 export class QuarantineError extends Error {
     code;
     repair;
-    lockPath;
-    lockPid;
     constructor(fields) {
         super(fields.message);
         this.name = "QuarantineError";
         this.code = fields.code;
         this.repair = fields.repair;
-        if (fields.lockPath !== undefined)
-            this.lockPath = fields.lockPath;
-        if (fields.lockPid !== undefined)
-            this.lockPid = fields.lockPid;
     }
     toQuarantine() {
-        return {
-            code: this.code,
-            message: this.message,
-            repair: this.repair,
-            ...(this.lockPath !== undefined ? { lockPath: this.lockPath } : {}),
-            ...(this.lockPid !== undefined ? { lockPid: this.lockPid } : {}),
-        };
+        return { code: this.code, message: this.message, repair: this.repair };
     }
 }
 export function isQuarantineError(error) {
@@ -43,28 +31,20 @@ export function asQuarantine(error) {
 export function repairFor(code, detail = {}) {
     const id = detail.tenantId ? ` ${detail.tenantId}` : "";
     switch (code) {
-        case "locked":
-            return (`nylorun tenant status${id}` +
-                (detail.lockPath !== undefined && detail.lockPid !== undefined
-                    ? ` — stop pid ${detail.lockPid} holding ${detail.lockPath}, or remove a stale lock`
-                    : " — resolve the .runtime-lock conflict"));
         case "kek-missing":
-            return `nylorun tenant status${id} — restore vault-kek for this Tenant (ciphertext cannot be opened without it)`;
+            return `nylo tenant status${id} — restore vault-kek for this Tenant (ciphertext cannot be opened without it)`;
         case "corrupt":
-            return `nylorun tenant status${id} — repair or restore the Tenant directory from backup`;
+            return `nylo tenant status${id} — restore the Tenant from backup`;
         case "schema-too-new":
-            return `nylorun runtime restart` +
-                `${id ? ` — Tenant${id} needs a newer Host` : " — Host schema is older than this Tenant"}`;
+            return `nylo tenant status${id} — the Tenant was migrated by a newer Runtime; run that version or newer`;
         case "migration-failed":
-            return detail.migrationPath
-                ? `restore ${detail.migrationPath} over the Tenant files, then nylorun tenant status${id}`
-                : `nylorun tenant status${id} — restore from .migration/ snapshot, then retry`;
+            return `nylo tenant status${id} — inspect the Runtime log for the failed migration, fix it, then restart the Runtime`;
         case "envelope-invalid":
-            return `nylorun tenant status${id} — fix or replace tenant.json so its id matches the directory name`;
+            return `nylo tenant status${id} — the Tenant envelope is missing or invalid; restore the Tenant from backup`;
         case "open-timeout":
-            return `nylorun tenant status${id} — open timed out; inspect locks and SQLite, then retry`;
+            return `nylo tenant status${id} — open timed out; inspect the Runtime log and Postgres, then retry`;
         case "open-failed":
-            return `nylorun tenant status${id} — inspect Tenant logs and repair before the Host retries open`;
+            return `nylo tenant status${id} — inspect Tenant logs and repair before the Host retries open`;
     }
 }
 export function quarantine(code, message, detail = {}) {
@@ -72,8 +52,6 @@ export function quarantine(code, message, detail = {}) {
         code,
         message,
         repair: repairFor(code, detail),
-        ...(detail.lockPath !== undefined ? { lockPath: detail.lockPath } : {}),
-        ...(detail.lockPid !== undefined ? { lockPid: detail.lockPid } : {}),
     });
 }
 /** Conflict when create bootstrap material does not match an existing Tenant (HTTP 409). */

package/dist/tenant/reset.d.ts

@@ -1,21 +1,22 @@
-import type { Store } from "../core/store.js";
+import type { ResetScope, SessionStore } from "../store/types.js";
 import type { ExecutorRegistry } from "../core/executors.js";
 import type { SandboxManager } from "../sandbox/manager.js";
 import type { TenantPaths } from "./types.js";
-export type ResetScope = "sessions" | "sandboxes" | "all";
+export type { ResetScope } from "../store/types.js";
 export interface ResetTenantContext {
-    store: Store;
+    store: SessionStore;
     registry: ExecutorRegistry;
     sandbox: SandboxManager;
     paths: TenantPaths;
-    /** Clear in-memory session observers after DB wipe. */
+    /** Clear in-memory session observers after the store wipe. */
     clearSessionState: () => void;
     /** Clear executor SSE streams when registrations are removed. */
     clearExecutorStreams: () => void;
 }
 /**
  * Reset Tenant durable state for `scope` (A17).
- * Caller must have already drained (`activeWork`). Runs SQLite work in one
- * transaction, then filesystem rename+delete for sandboxes / log as needed.
+ * Caller must have already drained (`activeWork`). Deletes store state in one
+ * transaction (`Tx.reset`), then does the filesystem rename+delete for sandboxes /
+ * log as needed. The host vault (model credentials), principals and settings stay.
  */
 export declare function resetTenant(ctx: ResetTenantContext, scope: ResetScope): Promise<void>;

package/dist/tenant/reset.js

@@ -1,12 +1,5 @@
 import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
-const SESSION_TABLES = [
-    "sessions",
-    "commands",
-    "checkpoints",
-    "effects",
-    "actions",
-];
 /**
  * Rename `dir` to a sibling, delete the sibling, recreate an empty `dir`.
  * Failure before rename leaves the original intact; after rename the empty
@@ -35,41 +28,11 @@ function replaceDirectory(dir) {
         throw error;
     }
 }
-function clearSessionTables(store) {
-    for (const table of SESSION_TABLES) {
-        store.db.prepare(`DELETE FROM ${table}`).run();
-    }
-    store.db.prepare("DELETE FROM events").run();
-}
-function clearSandboxRows(store) {
-    store.db.prepare("DELETE FROM sandboxes").run();
-}
-function clearDefinitions(store) {
-    store.db.prepare("DELETE FROM definitions").run();
-}
-function clearExecutors(store, registry) {
-    for (const row of registry.list())
-        registry.remove(row.agentId);
-    store.db.prepare("DELETE FROM executors").run();
-}
-/** Delete user-scoped vaults; keep the host vault (model credentials). */
-function clearUserVaults(store) {
-    const userVaults = store.db
-        .prepare(`SELECT id FROM vaults WHERE scope != 'host'`)
-        .all();
-    for (const vault of userVaults) {
-        store.db
-            .prepare(`DELETE FROM vault_credentials WHERE vault_id=?`)
-            .run(vault.id);
-        store.db.prepare(`DELETE FROM vaults WHERE id=?`).run(vault.id);
-    }
-    // Drop audit / idempotency rows that referenced user vaults only when all.
-    // Keep host-model idempotency so seed replay stays stable.
-}
 /**
  * Reset Tenant durable state for `scope` (A17).
- * Caller must have already drained (`activeWork`). Runs SQLite work in one
- * transaction, then filesystem rename+delete for sandboxes / log as needed.
+ * Caller must have already drained (`activeWork`). Deletes store state in one
+ * transaction (`Tx.reset`), then does the filesystem rename+delete for sandboxes /
+ * log as needed. The host vault (model credentials), principals and settings stay.
  */
 export async function resetTenant(ctx, scope) {
     const clearSessions = scope === "sessions" || scope === "all";
@@ -78,17 +41,10 @@ export async function resetTenant(ctx, scope) {
     if (clearSandboxes) {
         await ctx.sandbox.reconcile(() => false);
     }
-    ctx.store.tx(() => {
-        if (clearSessions)
-            clearSessionTables(ctx.store);
-        if (clearSandboxes)
-            clearSandboxRows(ctx.store);
-        if (clearAll) {
-            clearDefinitions(ctx.store);
-            clearExecutors(ctx.store, ctx.registry);
-            clearUserVaults(ctx.store);
-        }
-    });
+    await ctx.store.tx((t) => t.reset(scope));
+    if (clearAll)
+        for (const row of ctx.registry.list())
+            ctx.registry.remove(row.agentId);
     if (clearSessions)
         ctx.clearSessionState();
     if (clearAll)

package/dist/tenant/routes-tenant.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tenant administration and vault routes: `/v1/tenant` (status, reset, config seed, host
+ * model and providers, sandbox report) and `/v1/vaults` (vaults and credentials).
+ * A reset that deletes sessions abandons their streams (a session created again gets a new
+ * incarnation) and collects them afterwards; it never deletes the Tenant's basin.
+ *
+ * Later waves: Wave 2 / X changes what reset clears once work leaves process memory.
+ */
+import type { IncomingMessage } from "node:http";
+import type { AuthScope, TenantContext } from "./context.js";
+export declare function dispatchTenant(ctx: TenantContext, scope: AuthScope, method: string | undefined, path: string[], request: IncomingMessage): Promise<unknown>;
+export declare function dispatchVault(ctx: TenantContext, scope: AuthScope, method: string | undefined, path: string[], url: URL, request: IncomingMessage): Promise<unknown>;

package/dist/tenant/routes-tenant.js

@@ -0,0 +1,137 @@
+import { CreateCredentialRequestSchema, CreateVaultRequestSchema, PutHostModelRequestSchema, ResetTenantRequestSchema, RotateCredentialRequestSchema, SeedTenantConfigRequestSchema, SelectHostModelRequestSchema, } from "@nylorun/core/contracts";
+import { hostModelCatalog } from "../model/catalog.js";
+import { resetTenant } from "./reset.js";
+import { buildTenantStatus, seedTenantConfig } from "./status.js";
+import { ownerOf } from "./auth.js";
+import { fail, readBody } from "./http.js";
+import { clearExecutorStreams, clearObservers } from "./live.js";
+import { requestStreamCollection, sessionStreamsAbandoned, streamsStatus, } from "./streams.js";
+import { clearWork, drain } from "./scheduler.js";
+import { usesFixtureModel } from "./model-setting.js";
+export async function dispatchTenant(ctx, scope, method, path, request) {
+    const { vault } = ctx;
+    // A subject reaches only the routes `authorize` allowed its scopes.
+    if (scope.kind === "executor") {
+        await vault.reject(path.join("/"));
+        fail(403, "Application credential required");
+    }
+    if (path.length === 2 && method === "GET")
+        return await buildTenantStatus({
+            envelope: ctx.envelope,
+            config: ctx.config,
+            store: ctx.store,
+            registry: ctx.registry,
+            vault,
+            sandbox: ctx.sandbox,
+            closing: ctx.closing || ctx.closed,
+            modelConfigured: !ctx.useVaultModel ||
+                (await ctx.store.tx((t) => usesFixtureModel(t))) ||
+                (await vault.getHostModel()).configured,
+            executorStreams: ctx.live.executorStreams,
+            ...(ctx.stuckInvocations
+                ? { stuckInvocations: ctx.stuckInvocations }
+                : {}),
+            streamsStatus: () => streamsStatus(ctx),
+        });
+    if (path[2] === "reset" && path.length === 3 && method === "POST") {
+        const body = ResetTenantRequestSchema.parse(await readBody(request));
+        await drain(ctx, body.activeWork, 30_000);
+        // The deleted sessions' streams are abandoned: a session created again with the same id,
+        // during or after the reset, gets a new incarnation and starts at sequence 0. The pending
+        // collection is recorded first, so a crash before it runs leaves it to the sweep.
+        const sessionsReset = body.scope !== "sandboxes";
+        if (sessionsReset)
+            await requestStreamCollection(ctx);
+        await resetTenant({
+            store: ctx.store,
+            registry: ctx.registry,
+            sandbox: ctx.sandbox,
+            paths: ctx.config.paths,
+            clearSessionState: () => {
+                clearWork(ctx);
+                clearObservers(ctx.live);
+            },
+            clearExecutorStreams: () => clearExecutorStreams(ctx.live),
+        }, body.scope);
+        if (sessionsReset)
+            sessionStreamsAbandoned(ctx);
+        // Reset leaves the Tenant open for new work.
+        ctx.closing = false;
+        return { ok: true };
+    }
+    if (path[2] === "config" &&
+        path[3] === "seed" &&
+        path.length === 4 &&
+        method === "PUT") {
+        const body = SeedTenantConfigRequestSchema.parse(await readBody(request));
+        return await seedTenantConfig({ store: ctx.store, vault }, body);
+    }
+    if (path[2] === "models" && path.length === 3 && method === "GET")
+        return hostModelCatalog();
+    if (path[2] === "sandbox" && path.length === 3 && method === "GET")
+        return ctx.sandbox.report();
+    if (path[2] === "providers" && path.length === 3 && method === "GET")
+        return vault.listHostProviders();
+    if (path[2] === "model" && path.length === 3 && method === "GET")
+        return vault.getHostModel();
+    if (path[2] === "model" && path.length === 3 && method === "PUT")
+        return vault.putHostModel(PutHostModelRequestSchema.parse(await readBody(request)));
+    if (path[2] === "model" &&
+        path[3] === "selection" &&
+        path.length === 4 &&
+        method === "PUT")
+        return vault.selectHostModel(SelectHostModelRequestSchema.parse(await readBody(request)));
+    fail(404, "Route not found");
+}
+export async function dispatchVault(ctx, scope, method, path, url, request) {
+    const { vault } = ctx;
+    if (scope.kind === "executor") {
+        await vault.reject(path.join("/"));
+        fail(403, "Application credential required");
+    }
+    // Acting for a subject: only the subject's own vaults, and never on another's behalf.
+    const owner = ownerOf(scope);
+    if (path.length === 2 && method === "POST") {
+        const body = CreateVaultRequestSchema.parse(await readBody(request));
+        if (owner !== undefined && body.ownerUserId !== owner)
+            fail(403, "ownerUserId must be the subject");
+        return vault.createVault(body);
+    }
+    if (path.length === 2 && method === "GET") {
+        const ownerUserId = url.searchParams.get("ownerUserId") ??
+            owner ??
+            fail(400, "ownerUserId is required");
+        if (owner !== undefined && ownerUserId !== owner)
+            fail(403, "ownerUserId must be the subject");
+        return { vaults: await vault.listVaults(ownerUserId) };
+    }
+    const vaultId = path[2];
+    if (!vaultId)
+        fail(404, "Vault not found");
+    if (owner !== undefined)
+        await vault.assertOwner(vaultId, owner);
+    if (path.length === 3 && method === "GET")
+        return vault.getVault(vaultId);
+    if (path.length === 3 && method === "DELETE")
+        return vault.deleteVault(vaultId);
+    if (path[3] !== "credentials")
+        fail(404, "Route not found");
+    if (path.length === 4 && method === "POST") {
+        const body = CreateCredentialRequestSchema.parse(await readBody(request));
+        return vault.createCredential(vaultId, body);
+    }
+    if (path.length === 4 && method === "GET")
+        return { credentials: await vault.listCredentials(vaultId) };
+    const credentialId = path[4];
+    if (!credentialId)
+        fail(404, "Credential not found");
+    if (path.length === 5 && method === "GET")
+        return vault.getCredential(vaultId, credentialId);
+    if (path.length === 5 && method === "POST") {
+        const body = RotateCredentialRequestSchema.parse(await readBody(request));
+        return vault.rotateCredential(vaultId, credentialId, body);
+    }
+    if (path.length === 5 && method === "DELETE")
+        return vault.deleteCredential(vaultId, credentialId);
+    fail(404, "Route not found");
+}

package/dist/tenant/routes.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Tenant HTTP router: authenticates the bearer token, matches `/v1/...` routes and
+ * delegates to the service modules (commands, actions, sessions, live, routes-tenant). It
+ * maps typed errors to responses and owns no business logic of its own. History, SSE and
+ * executor work streams read Durable Streams (`live.ts`).
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type TenantContext } from "./context.js";
+export declare function handle(ctx: TenantContext, request: IncomingMessage, response: ServerResponse, _url?: URL): Promise<void>;