@nylorun/runtime 0.5.0-beta → 0.7.0-beta

package/dist/sessions/host.js

@@ -1,4 +1,5 @@
-import { isHarnessError } from "@nylorun/harness";
+import { HarnessError, isHarnessError } from "@nylorun/core/define";
+import { bindingFromAgent, createRunState, run, } from "@nylorun/harness/run";
 import { scrub } from "../redact.js";
 /** The built-in single-process coordinator. Storage adapters do not implement execution. */
 export class SessionHost {
@@ -26,6 +27,19 @@ export class SessionHost {
             ? { ...session, status: "interrupted" }
             : session);
     }
+    async delete(agentId, sessionId) {
+        const key = this.key(agentId, sessionId);
+        if (this.active.has(key))
+            throw new Error("Cannot delete a session while a run is active");
+        if ("delete" in this.store && typeof this.store.delete === "function")
+            return this.store.delete(agentId, sessionId);
+        const existing = await this.store.get(agentId, sessionId);
+        if (!existing)
+            return false;
+        // Stores without delete: archive by removing via put tombstone is not supported;
+        // require ManagedSessionStore.delete or memorySessions.delete.
+        throw new Error("Session store does not support delete");
+    }
     subscribe(agentId, sessionId, listener) {
         const key = this.key(agentId, sessionId);
         let listeners = this.listeners.get(key);
@@ -144,17 +158,21 @@ export class SessionHost {
                     ...(typeof input === "string" ? { input } : {}),
                 });
                 await save();
-                const result = await agent.run({
-                    state: document.state,
-                    input,
+                const binding = bindingFromAgent(agent);
+                const engineInput = resolveEngineInput(document.state, input);
+                const state = ensureEngineState(binding, document.state, options.sessionState);
+                const result = await run({
+                    binding,
+                    state,
+                    input: engineInput,
                     info: options.info,
                     signal: controller.signal,
                     onModelCall: options.onModelCall,
                     onEvent: (event) => {
                         add(event.type, event);
                     },
-                    record: async (state) => {
-                        document = { ...document, state };
+                    record: async (next) => {
+                        document = { ...document, state: next };
                         await save();
                     },
                 });
@@ -235,7 +253,9 @@ export class SessionHost {
                 throw new Error("This session was interrupted; reconcile its external effects before cancellation.");
             if (stored?.state?.status !== "paused")
                 return;
-            const result = await agent.run({
+            const binding = bindingFromAgent(agent);
+            const result = await run({
+                binding,
                 state: stored.state,
                 input: { kind: "continue" },
                 signal: AbortSignal.abort(new Error("Paused execution cancelled")),
@@ -289,3 +309,51 @@ export class SessionHost {
             await this.store.close();
     }
 }
+function ensureEngineState(binding, existing, sessionState) {
+    if (existing) {
+        if (!sessionState || Object.keys(existing.state ?? {}).length > 0)
+            return existing;
+        return {
+            ...existing,
+            state: { ...(existing.state ?? {}), ...sessionState },
+        };
+    }
+    return createRunState(binding, {
+        ...(sessionState ? { state: sessionState } : {}),
+    });
+}
+/**
+ * Map DX `wait-resolve` onto harness approve/respond/settle using wait metadata.
+ * Engine `ExecutionInput` already includes `wait-resolve`; resume is wired via
+ * existing interaction/deferred kinds until full wait-id resume lands.
+ */
+export function resolveEngineInput(state, input) {
+    if (typeof input !== "object" || !("kind" in input) || input.kind !== "wait-resolve")
+        return input;
+    const call = state?.plan?.calls.find((item) => item.wait?.waitId === input.waitId);
+    if (!call)
+        throw new HarnessError("execution.invalid-input", "No pending wait matches waitId");
+    if (call.status === "interaction" && call.interaction) {
+        if (call.interaction.kind === "approval")
+            return {
+                kind: "approve",
+                interactionId: call.interaction.id,
+                approved: input.value !== false && input.value !== "false",
+            };
+        return {
+            kind: "respond",
+            interactionId: call.interaction.id,
+            value: input.value ?? null,
+        };
+    }
+    if (call.status === "deferred")
+        return {
+            kind: "settle",
+            invocationId: call.invocationId,
+            outcome: {
+                kind: "completed",
+                output: input.value ?? null,
+            },
+        };
+    throw new HarnessError("execution.invalid-input", "Wait is no longer pending");
+}

package/dist/sessions/store.d.ts

@@ -32,6 +32,7 @@ export interface SessionStore {
     get(agentId: string, sessionId: string): Promise<StoredSession | undefined>;
     put(agentId: string, sessionId: string, session: StoredSession): Promise<void>;
     list(agentId: string): Promise<readonly SessionSummary[]>;
+    delete?(agentId: string, sessionId: string): Promise<boolean>;
 }
 export interface ManagedSessionStore extends SessionStore {
     close(): Promise<void>;

package/dist/sessions/store.js

@@ -26,5 +26,8 @@ export function memorySessions() {
                 .map(sessionSummary)
                 .sort((a, b) => b.startedAt - a.startedAt);
         },
+        async delete(agentId, sessionId) {
+            return documents.delete(key(agentId, sessionId));
+        },
     };
 }

package/dist/vault/crypto.d.ts

@@ -0,0 +1,12 @@
+export declare class VaultCryptoError extends Error {
+    constructor();
+}
+export declare function kekId(kek: Buffer): string;
+export declare function parseKek(value: Buffer | string): Buffer;
+export declare function encryptSecret(kek: Buffer, aad: Buffer, plaintext: Buffer): {
+    nonce: Buffer;
+    ciphertext: Buffer;
+    wrappedDek: Buffer;
+    kekId: string;
+};
+export declare function decryptSecret(kek: Buffer, aad: Buffer, nonce: Buffer, ciphertext: Buffer, wrappedDek: Buffer, expectedKekId: string): Buffer;

package/dist/vault/crypto.js

@@ -0,0 +1,80 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, } from "node:crypto";
+const IV_BYTES = 12;
+const TAG_BYTES = 16;
+export class VaultCryptoError extends Error {
+    constructor() {
+        super("Vault credential could not be read");
+    }
+}
+export function kekId(kek) {
+    return createHash("sha256").update(kek).digest("hex");
+}
+export function parseKek(value) {
+    const bytes = typeof value === "string" ? Buffer.from(value.trim(), "base64") : value;
+    if (bytes.length !== 32)
+        throw new Error("Vault key-encryption key must be 32 bytes");
+    return Buffer.from(bytes);
+}
+export function encryptSecret(kek, aad, plaintext) {
+    const dek = randomBytes(32);
+    try {
+        const nonce = randomBytes(IV_BYTES);
+        const cipher = createCipheriv("aes-256-gcm", dek, nonce);
+        cipher.setAAD(aad);
+        const body = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return {
+            nonce,
+            ciphertext: Buffer.concat([body, tag]),
+            wrappedDek: wrapKey(kek, dek),
+            kekId: kekId(kek),
+        };
+    }
+    finally {
+        dek.fill(0);
+    }
+}
+export function decryptSecret(kek, aad, nonce, ciphertext, wrappedDek, expectedKekId) {
+    if (expectedKekId !== kekId(kek))
+        throw new VaultCryptoError();
+    const dek = unwrapKey(kek, wrappedDek);
+    try {
+        if (ciphertext.length < TAG_BYTES)
+            throw new VaultCryptoError();
+        const tag = ciphertext.subarray(ciphertext.length - TAG_BYTES);
+        const body = ciphertext.subarray(0, ciphertext.length - TAG_BYTES);
+        const decipher = createDecipheriv("aes-256-gcm", dek, nonce);
+        decipher.setAAD(aad);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(body), decipher.final()]);
+    }
+    catch (error) {
+        if (error instanceof VaultCryptoError)
+            throw error;
+        throw new VaultCryptoError();
+    }
+    finally {
+        dek.fill(0);
+    }
+}
+function wrapKey(kek, dek) {
+    const nonce = randomBytes(IV_BYTES);
+    const cipher = createCipheriv("aes-256-gcm", kek, nonce);
+    const body = Buffer.concat([cipher.update(dek), cipher.final()]);
+    return Buffer.concat([nonce, body, cipher.getAuthTag()]);
+}
+function unwrapKey(kek, wrapped) {
+    try {
+        if (wrapped.length < IV_BYTES + TAG_BYTES)
+            throw new VaultCryptoError();
+        const nonce = wrapped.subarray(0, IV_BYTES);
+        const tag = wrapped.subarray(wrapped.length - TAG_BYTES);
+        const body = wrapped.subarray(IV_BYTES, wrapped.length - TAG_BYTES);
+        const decipher = createDecipheriv("aes-256-gcm", kek, nonce);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(body), decipher.final()]);
+    }
+    catch {
+        throw new VaultCryptoError();
+    }
+}

package/dist/vault/error.d.ts

@@ -0,0 +1,4 @@
+export declare class VaultError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}

package/dist/vault/error.js

@@ -0,0 +1,7 @@
+export class VaultError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}

package/dist/vault/kek.d.ts

@@ -0,0 +1,6 @@
+export declare function defaultKekPath(): string;
+export declare function readVaultKek(options: {
+    vaultKek?: Buffer | string | null;
+    vaultKekPath?: string;
+}): Buffer | undefined;
+export declare function createKekFile(path: string): Buffer;

package/dist/vault/kek.js

@@ -0,0 +1,26 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseKek } from "./crypto.js";
+export function defaultKekPath() {
+    return join(process.cwd(), ".nylorun", "vault-kek");
+}
+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))
+        return undefined;
+    return parseKek(readFileSync(path, "utf8"));
+}
+export function createKekFile(path) {
+    const bytes = randomBytes(32);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${bytes.toString("base64")}\n`, { mode: 0o600 });
+    return bytes;
+}

package/dist/vault/service.d.ts

@@ -0,0 +1,59 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { CreateCredentialRequest, CreateVaultRequest, CredentialInfo, CredentialSelection, RotateCredentialRequest, VaultInfo } from "@nylorun/core/contracts";
+export type AuthorizeResult = {
+    status: "unauthenticated";
+    url: string;
+    headers: Record<string, string>;
+} | {
+    status: "authorized";
+    url: string;
+    headers: {
+        authorization: string;
+    };
+} | {
+    status: "refused";
+    url: string;
+    credentialIds: string[];
+    reason: string;
+};
+export declare class VaultService {
+    private readonly db;
+    private readonly tx;
+    private readonly kek;
+    private readonly fetchImpl;
+    constructor(db: DatabaseSync, tx: <T>(fn: () => T) => T, kek: () => Buffer, fetchImpl: typeof fetch);
+    createVault(body: CreateVaultRequest): VaultInfo;
+    listVaults(ownerUserId: string): VaultInfo[];
+    getVault(id: string): VaultInfo;
+    deleteVault(id: string): {
+        id: string;
+    };
+    createCredential(vaultId: string, body: CreateCredentialRequest): CredentialInfo;
+    listCredentials(vaultId: string): CredentialInfo[];
+    getCredential(vaultId: string, id: string): CredentialInfo;
+    rotateCredential(vaultId: string, id: string, body: RotateCredentialRequest): CredentialInfo;
+    deleteCredential(vaultId: string, id: string): {
+        id: string;
+    };
+    assertAttachment(ownerUserId: string, vaultIds: readonly string[], selections: readonly CredentialSelection[]): void;
+    recordAttachment(sessionId: string, vaultIds: readonly string[]): void;
+    authorize(input: {
+        sessionId: string;
+        vaultIds: readonly string[];
+        credentialSelections: readonly CredentialSelection[];
+        url: string;
+        serverName?: string;
+    }): Promise<AuthorizeResult>;
+    reject(route: string): void;
+    private refresh;
+    private replay;
+    private insertCredential;
+    private writePayload;
+    private readPayload;
+    private vaultInfo;
+    private vaultRow;
+    private credentialInfo;
+    private credentialRow;
+    private rowsForVault;
+    private audit;
+}