@arnilo/prism-server 0.0.96 → 0.1.0

package/dist/rate-limit.js

@@ -0,0 +1,41 @@
+/** Tiny in-memory sliding window for tests/single-process hosts. Not a distributed limiter. */
+export function createMemoryRateLimiter(options) {
+    if (!Number.isSafeInteger(options.maxRequests) || options.maxRequests < 1) {
+        throw new RangeError("maxRequests must be a positive safe integer");
+    }
+    if (!Number.isSafeInteger(options.windowMs) || options.windowMs < 1) {
+        throw new RangeError("windowMs must be a positive safe integer");
+    }
+    const maxKeys = options.maxKeys ?? 1024;
+    if (!Number.isSafeInteger(maxKeys) || maxKeys < 1)
+        throw new RangeError("maxKeys must be a positive safe integer");
+    const buckets = new Map();
+    return (input) => {
+        input.signal.throwIfAborted();
+        const key = options.key?.(input) ?? defaultKey(input);
+        const now = Date.now();
+        const windowStart = now - options.windowMs;
+        let stamps = (buckets.get(key) ?? []).filter((t) => t > windowStart);
+        if (stamps.length >= options.maxRequests) {
+            const oldest = stamps[0] ?? now;
+            return {
+                retryAfterMs: Math.max(1, oldest + options.windowMs - now),
+                code: "ERR_PRISM_SERVER_RATE_LIMIT",
+                message: "Rate limit exceeded",
+            };
+        }
+        stamps = [...stamps, now];
+        if (!buckets.has(key) && buckets.size >= maxKeys) {
+            const first = buckets.keys().next().value;
+            if (first !== undefined)
+                buckets.delete(first);
+        }
+        buckets.set(key, stamps);
+        return true;
+    };
+}
+function defaultKey(input) {
+    const o = input.authorization.ownership;
+    return `${o.tenantId ?? ""}\0${o.accountId ?? ""}\0${o.userId ?? ""}\0${input.operation}\0${input.capabilityId}`;
+}
+//# sourceMappingURL=rate-limit.js.map

package/dist/replay.d.ts

@@ -0,0 +1,31 @@
+import type { AgentEventEnvelope, AgentEventRecord, AgentEventSource, AgentEventSourcePage, OwnershipScope, PersistencePage, ProductionPersistenceStore } from "@arnilo/prism";
+import { type PrismDeploymentLimits } from "./limits.js";
+export interface PrismEventReplayRequest {
+    readonly ownership: OwnershipScope;
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly cursor?: string;
+    readonly signal?: AbortSignal;
+}
+export interface PrismEventReplay {
+    page(input: PrismEventReplayRequest): Promise<PersistencePage<AgentEventRecord>>;
+}
+export interface CreatePrismEventReplayOptions {
+    readonly limits?: PrismDeploymentLimits;
+}
+export interface PrismAgentEventReplay {
+    page(input: PrismEventReplayRequest): Promise<AgentEventSourcePage>;
+    subscribe(input: PrismEventReplayRequest): AsyncIterable<AgentEventEnvelope>;
+}
+/** Shared source-backed page/follow adapter. Authorization supplies ownership before each call. */
+export declare function createPrismAgentEventReplay(source: AgentEventSource, options?: CreatePrismEventReplayOptions): PrismAgentEventReplay;
+/** Ownership-scoped, cursor-paginated legacy persistence replay. Does not re-run work. */
+export declare function createPrismEventReplay(store: Pick<ProductionPersistenceStore, "queryEvents">, options?: CreatePrismEventReplayOptions): PrismEventReplay;
+export interface CreatePrismReplayHandlerOptions {
+    readonly replay: PrismEventReplay;
+    readonly authorize: (request: Request) => false | OwnershipScope | Promise<false | OwnershipScope>;
+    readonly basePath?: string;
+    readonly limits?: PrismDeploymentLimits;
+}
+/** Optional HTTP adapter: POST `{ sessionId, runId, cursor? }` → ownership-scoped page. */
+export declare function createPrismReplayHandler(options: CreatePrismReplayHandlerOptions): import("./types.js").PrismRequestHandler;

package/dist/replay.js

@@ -0,0 +1,144 @@
+import { resolvePrismDeploymentLimits } from "./limits.js";
+import { PrismServerError } from "./types.js";
+/** Shared source-backed page/follow adapter. Authorization supplies ownership before each call. */
+export function createPrismAgentEventReplay(source, options = {}) {
+    const limits = resolvePrismDeploymentLimits(options.limits);
+    const read = (input) => {
+        input.signal?.throwIfAborted();
+        assertOwnership(input.ownership);
+        if (!input.sessionId || !input.runId)
+            throw new PrismServerError("Run is unavailable", 404, "ERR_PRISM_SERVER_REPLAY");
+        if (input.cursor !== undefined)
+            assertCursor(input.cursor, limits);
+        return {
+            ownership: input.ownership,
+            sessionId: input.sessionId,
+            runId: input.runId,
+            after: input.cursor,
+            limit: limits.maxReplayEvents,
+            signal: input.signal,
+        };
+    };
+    return {
+        page: (input) => source.page(read(input)),
+        subscribe(input) {
+            return {
+                [Symbol.asyncIterator]: () => source.subscribe(read(input))[Symbol.asyncIterator](),
+            };
+        },
+    };
+}
+/** Ownership-scoped, cursor-paginated legacy persistence replay. Does not re-run work. */
+export function createPrismEventReplay(store, options = {}) {
+    const limits = resolvePrismDeploymentLimits(options.limits);
+    return {
+        async page(input) {
+            input.signal?.throwIfAborted();
+            assertOwnership(input.ownership);
+            if (!input.sessionId || !input.runId) {
+                throw new PrismServerError("sessionId and runId are required", 400, "ERR_PRISM_SERVER_REPLAY");
+            }
+            if (input.cursor !== undefined)
+                assertCursor(input.cursor, limits);
+            const page = await store.queryEvents({
+                sessionId: input.sessionId,
+                runId: input.runId,
+                cursor: input.cursor,
+                limit: limits.maxReplayEvents,
+                order: "asc",
+                redacted: true,
+                ...input.ownership,
+            });
+            if (page.items.length > limits.maxReplayEvents) {
+                throw new PrismServerError("Replay page exceeds limit", 507, "ERR_PRISM_SERVER_REPLAY_LIMIT");
+            }
+            if (page.items.some((record) => !record.redacted)) {
+                throw new PrismServerError("Replay page must be redacted", 500, "ERR_PRISM_SERVER_REPLAY");
+            }
+            if (page.nextCursor !== undefined)
+                assertCursor(page.nextCursor, limits);
+            return page;
+        },
+    };
+}
+/** Optional HTTP adapter: POST `{ sessionId, runId, cursor? }` → ownership-scoped page. */
+export function createPrismReplayHandler(options) {
+    const base = (options.basePath ?? "/prism/replay/events").replace(/\/+$/, "");
+    const limits = resolvePrismDeploymentLimits(options.limits);
+    return async (request) => {
+        try {
+            if (request.method !== "POST") {
+                throw new PrismServerError("Method not allowed", 405, "ERR_PRISM_SERVER_METHOD");
+            }
+            const path = new URL(request.url).pathname.replace(/\/+$/, "");
+            if (path !== base)
+                throw new PrismServerError("Not found", 404, "ERR_PRISM_SERVER_NOT_FOUND");
+            const ownership = await options.authorize(request);
+            if (!ownership)
+                throw new PrismServerError("Forbidden", 403, "ERR_PRISM_SERVER_FORBIDDEN");
+            assertOwnership(ownership);
+            const body = await readSmallJson(request, limits.maxReplayCursorBytes + 1024);
+            const page = await options.replay.page({
+                ownership,
+                sessionId: readId(body.sessionId, "sessionId"),
+                runId: readId(body.runId, "runId"),
+                cursor: body.cursor === undefined ? undefined : readCursor(body.cursor, limits),
+                signal: request.signal,
+            });
+            return new Response(JSON.stringify(page), {
+                status: 200,
+                headers: { "content-type": "application/json; charset=utf-8" },
+            });
+        }
+        catch (error) {
+            if (error instanceof PrismServerError) {
+                return new Response(JSON.stringify({ error: { code: error.code, message: error.message } }), {
+                    status: error.status,
+                    headers: { "content-type": "application/json; charset=utf-8" },
+                });
+            }
+            return new Response(JSON.stringify({ error: { code: "ERR_PRISM_SERVER", message: "Replay failed" } }), {
+                status: 500,
+                headers: { "content-type": "application/json; charset=utf-8" },
+            });
+        }
+    };
+}
+function assertOwnership(ownership) {
+    if (![ownership.tenantId, ownership.accountId, ownership.userId].some((v) => typeof v === "string" && v.length > 0)) {
+        throw new PrismServerError("Forbidden", 403, "ERR_PRISM_SERVER_FORBIDDEN");
+    }
+}
+function assertCursor(cursor, limits) {
+    if (typeof cursor !== "string" || Buffer.byteLength(cursor, "utf8") > limits.maxReplayCursorBytes) {
+        throw new PrismServerError("Replay cursor exceeds limit", 400, "ERR_PRISM_SERVER_REPLAY_CURSOR");
+    }
+}
+function readCursor(value, limits) {
+    if (typeof value !== "string")
+        throw new PrismServerError("cursor must be a string", 400, "ERR_PRISM_SERVER_BODY");
+    assertCursor(value, limits);
+    return value;
+}
+function readId(value, name) {
+    if (typeof value !== "string" || !value || value.length > 128 || !/^[A-Za-z0-9._:-]+$/.test(value)) {
+        throw new PrismServerError(`Invalid ${name}`, 400, "ERR_PRISM_SERVER_BODY");
+    }
+    return value;
+}
+async function readSmallJson(request, maxBytes) {
+    const text = await request.text();
+    if (Buffer.byteLength(text, "utf8") > maxBytes) {
+        throw new PrismServerError("Request body too large", 413, "ERR_PRISM_SERVER_BODY_LIMIT");
+    }
+    try {
+        const value = JSON.parse(text);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("object");
+        return value;
+    }
+    catch {
+        throw new PrismServerError("Invalid JSON object body", 400, "ERR_PRISM_SERVER_BODY");
+    }
+}
+//# sourceMappingURL=replay.js.map

package/dist/types.d.ts

@@ -1,9 +1,13 @@
-import type { Agent, AgentRunLifecycle, AgentSession, OwnershipScope, RunOptions, SecretRedactor } from "@arnilo/prism";
+import type { Agent, AgentEventSource, AgentIdentity, AgentRunLifecycle, AgentRunRef, AgentSession, OwnershipScope, RunOptions, SecretRedactor } from "@arnilo/prism";
 import type { RunWorkflowOptions, WorkflowCheckpointAdapter, WorkflowDefinition, WorkflowSchedules } from "@arnilo/prism-workflows";
+import type { PrismDrainController } from "./drain.js";
 import type { PrismServerLimits } from "./limits.js";
-export type PrismServerOperation = "agent.run" | "agent.stream" | "agent.status" | "agent.resume" | "workflow.run" | "workflow.stream" | "workflow.status" | "workflow.cancel" | "workflow.resume" | "workflow.enqueue" | "workflow.replay" | "schedule.create" | "schedule.list" | "schedule.pause" | "schedule.resume" | "schedule.trigger" | "schedule.delete";
+import type { PrismServerRateLimiter } from "./rate-limit.js";
+export type PrismServerOperation = "agent.run" | "agent.stream" | "agent.status" | "agent.resume" | "agent.events" | "workflow.run" | "workflow.stream" | "workflow.status" | "workflow.cancel" | "workflow.resume" | "workflow.enqueue" | "workflow.replay" | "schedule.create" | "schedule.list" | "schedule.pause" | "schedule.resume" | "schedule.trigger" | "schedule.delete";
 export interface PrismServerAuthorization {
     readonly ownership: OwnershipScope;
+    /** Host-verified identity; when set must project onto `ownership` without widening. */
+    readonly identity?: AgentIdentity;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
 export interface PrismServerAuthorizationInput {
@@ -13,9 +17,18 @@ export interface PrismServerAuthorizationInput {
     readonly signal: AbortSignal;
 }
 export type PrismServerAuthorizer = (input: PrismServerAuthorizationInput) => false | PrismServerAuthorization | Promise<false | PrismServerAuthorization>;
+export interface PrismAgentEventResolutionInput {
+    readonly runId: string;
+    readonly authorization: PrismServerAuthorization;
+    readonly signal: AbortSignal;
+}
 export interface PrismAgentExposure {
     readonly sessionFactory: (authorization: PrismServerAuthorization) => AgentSession | Promise<AgentSession>;
     readonly runOptions?: Omit<RunOptions, "ownership" | "signal" | "redactor">;
+    /** Optional durable cross-replica event source. Requires resolveRun. */
+    readonly events?: AgentEventSource;
+    /** Resolves an authorized public run selector to exact internal session/run IDs. */
+    readonly resolveRun?: (input: PrismAgentEventResolutionInput) => AgentRunRef | undefined | Promise<AgentRunRef | undefined>;
 }
 /** Explicit durable status/resume capability. Omit it to expose no agent lifecycle routes. */
 export interface PrismAgentRunExposure {
@@ -40,10 +53,15 @@ export interface CreatePrismHandlerOptions {
     readonly redactor?: SecretRedactor;
     readonly limits?: PrismServerLimits;
     readonly disconnectAborts?: boolean;
+    /** Optional graceful drain; blocks admit operations with 503 while draining. */
+    readonly drain?: PrismDrainController;
+    /** Optional host rate-limit adapter; runs after authorize, before admit/session create. */
+    readonly rateLimit?: PrismServerRateLimiter;
 }
 export type PrismRequestHandler = (request: Request) => Promise<Response>;
 export declare class PrismServerError extends Error {
     readonly status: number;
     readonly code: string;
-    constructor(message: string, status?: number, code?: string);
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+    constructor(message: string, status?: number, code?: string, headers?: Readonly<Record<string, string>> | undefined);
 }

package/dist/types.js

@@ -1,10 +1,12 @@
 export class PrismServerError extends Error {
     status;
     code;
-    constructor(message, status = 500, code = "ERR_PRISM_SERVER") {
+    headers;
+    constructor(message, status = 500, code = "ERR_PRISM_SERVER", headers) {
         super(message);
         this.status = status;
         this.code = code;
+        this.headers = headers;
         this.name = "PrismServerError";
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arnilo/prism-server",
-  "version": "0.0.96",
+  "version": "0.1.0",
   "description": "Optional framework-free Web Request-to-Response handler for explicitly selected Prism agents and workflows.",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,6 +9,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./artifact-bodies": {
+      "types": "./dist/artifact-bodies.d.ts",
+      "default": "./dist/artifact-bodies.js"
     }
   },
   "files": [
@@ -25,11 +29,12 @@
     "pack:dry-run": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.0.96",
-    "@arnilo/prism-workflows": "0.0.96"
+    "@arnilo/prism": "0.1.0",
+    "@arnilo/prism-workflows": "0.1.0"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../..",
+    "@arnilo/prism-session-store-sqlite": "file:../session-store-sqlite",
     "@arnilo/prism-workflows": "file:../workflows"
   },
   "engines": {