@nylorun/runtime 0.8.0-beta → 0.10.0-beta

package/dist/tenant/reset.d.ts

@@ -0,0 +1,21 @@
+import type { Store } from "../core/store.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 interface ResetTenantContext {
+    store: Store;
+    registry: ExecutorRegistry;
+    sandbox: SandboxManager;
+    paths: TenantPaths;
+    /** Clear in-memory session observers after DB 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.
+ */
+export declare function resetTenant(ctx: ResetTenantContext, scope: ResetScope): Promise<void>;

package/dist/tenant/reset.js

@@ -0,0 +1,125 @@
+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
+ * target is restored so the Tenant layout stays valid (A17).
+ */
+function replaceDirectory(dir) {
+    mkdirSync(dir, { recursive: true });
+    const sibling = `${dir}.resetting`;
+    if (existsSync(sibling))
+        rmSync(sibling, { recursive: true, force: true });
+    renameSync(dir, sibling);
+    try {
+        mkdirSync(dir, { recursive: true });
+        rmSync(sibling, { recursive: true, force: true });
+    }
+    catch (error) {
+        // Best-effort restore if recreation failed.
+        if (!existsSync(dir) && existsSync(sibling)) {
+            try {
+                renameSync(sibling, dir);
+            }
+            catch {
+                /* leave sibling for operator inspection */
+            }
+        }
+        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.
+ */
+export async function resetTenant(ctx, scope) {
+    const clearSessions = scope === "sessions" || scope === "all";
+    const clearSandboxes = scope === "sandboxes" || scope === "all";
+    const clearAll = scope === "all";
+    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);
+        }
+    });
+    if (clearSessions)
+        ctx.clearSessionState();
+    if (clearAll)
+        ctx.clearExecutorStreams();
+    if (clearSandboxes)
+        replaceDirectory(ctx.paths.sandboxes);
+    if (clearAll) {
+        mkdirSync(ctx.paths.logs, { recursive: true });
+        const logSibling = join(ctx.paths.logs, "tenant.log.resetting");
+        if (existsSync(ctx.paths.log)) {
+            if (existsSync(logSibling))
+                rmSync(logSibling, { force: true });
+            renameSync(ctx.paths.log, logSibling);
+            try {
+                writeFileSync(ctx.paths.log, "");
+                rmSync(logSibling, { force: true });
+            }
+            catch (error) {
+                if (!existsSync(ctx.paths.log) && existsSync(logSibling)) {
+                    try {
+                        renameSync(logSibling, ctx.paths.log);
+                    }
+                    catch {
+                        /* leave sibling */
+                    }
+                }
+                throw error;
+            }
+        }
+        else {
+            writeFileSync(ctx.paths.log, "");
+        }
+    }
+}

package/dist/tenant/runtime.d.ts

@@ -0,0 +1,80 @@
+import { type ServerResponse, type IncomingMessage } from "node:http";
+import { type ModelProvider } from "../core/provider.js";
+import type { TenantConfig, TenantHandle, TenantSummary } from "./types.js";
+import type { TenantEnvelope } from "@nylorun/core/contracts";
+import { type AuthorizeResult } from "../vault/service.js";
+/** TENANTS-CCR: test/injection hooks until TenantConfig gains them. */
+export type TenantOpenHooks = {
+    modelProvider?: ModelProvider;
+    vaultKek?: Buffer | string | null;
+    /** When true, create the KEK file on first vault write (tests / new Tenants). */
+    createKekIfMissing?: boolean;
+};
+export declare class TenantRuntime implements TenantHandle {
+    private readonly config;
+    private readonly store;
+    private readonly vault;
+    private kek;
+    private readonly kekPath;
+    private readonly running;
+    private readonly pending;
+    private readonly observers;
+    private readonly executorStreams;
+    private readonly registry;
+    private readonly mcp;
+    private readonly sandbox;
+    private closing;
+    private closed;
+    private readonly lockPath?;
+    private readonly timer;
+    private readonly modelProvider;
+    private readonly useVaultModel;
+    private readonly createKekIfMissing;
+    private readonly flowLimits;
+    readonly envelope: TenantEnvelope;
+    private constructor();
+    static open(config: TenantConfig, hooks?: TenantOpenHooks): Promise<TenantRuntime>;
+    private session;
+    private publish;
+    private send;
+    private notify;
+    /**
+     * Manifest v4 replaced beforeModelCall/afterModelCall with scoped hooks. Turns started under
+     * an older manifest cannot continue, and their hook actions no longer parse, so end them.
+     */
+    private retireLegacyHooks;
+    private expireClaims;
+    private schedule;
+    private execute;
+    private invokeModel;
+    private resolveEffect;
+    /** Journal and dispatch a new flow effect (agent / tool node / fn / verify). */
+    private resolveNewFlowEffect;
+    private scope;
+    private scoped;
+    private requireApplication;
+    private sandboxRouteDeps;
+    private body;
+    private command;
+    private sse;
+    handle(request: IncomingMessage, response: ServerResponse, _url?: URL): Promise<void>;
+    private view;
+    private prepareMcp;
+    private callMcpTool;
+    private callSandboxTool;
+    authorize(sessionId: string, request: {
+        url: string;
+        serverName?: string;
+    }): Promise<AuthorizeResult>;
+    private ensureKek;
+    private dispatchTenant;
+    private dispatchVault;
+    summary(): TenantSummary;
+    drain(activeWork: "drain" | "cancel", timeoutMs?: number): Promise<void>;
+    close(): Promise<void>;
+}
+/**
+ * Open a Tenant Runtime from an explicit `TenantConfig`. No listen() (A1).
+ * Implements `OpenTenantRuntime`.
+ */
+export declare function openTenantRuntime(config: TenantConfig, hooks?: TenantOpenHooks): Promise<TenantHandle>;