@plico-ai/server 0.0.0-reserved.0 → 0.1.0

package/dist/app/types.d.ts

@@ -0,0 +1,103 @@
+import type { RequestListener } from "node:http";
+import type { PlicoEvent, RunSummary, Thread, ThreadMessage } from "@plico-ai/contracts";
+import type { DryRunScriptStep, Engine, EventStore, ModelProvider, ThreadStore } from "@plico-ai/runtime";
+import type { MountOptions } from "../mount.js";
+import type { Metadata } from "./metadata.js";
+/** What the shared layer runs on. Internal: hosts pass a project folder to `createPlico` instead. */
+export interface AppDeps {
+    projectRoot: string;
+    eventStore: EventStore;
+    threadStore?: ThreadStore;
+    provider?: ModelProvider;
+    providerRecoveryKey?: string;
+    /** Account-only identity used to resume queued runs after a model change. */
+    providerAccountKey?: string;
+    engine: Engine;
+    /**
+     * Set by a mounted handler for one request. New threads and runs carry it as their metadata, and
+     * every read and action refuses what it does not match.
+     */
+    scope?: Metadata;
+    /** Inspection only: the HTTP API answers reads and refuses every change. */
+    inspect?: true;
+    /** Set by a mounted handler for one request: host data for the runs and decisions it causes. */
+    context?: Metadata;
+}
+export interface EventFollowOptions {
+    /** Yield events after this sequence number. Defaults to the start of the run. */
+    after?: number;
+    /** Stops following. The iterator then ends without error. */
+    signal?: AbortSignal;
+    /** Milliseconds between reads of the event log. Defaults to 2000. */
+    pollMs?: number;
+}
+export interface SendMessageOptions {
+    /** Record the message without starting a run. Defaults to true. */
+    startRun?: boolean;
+    /**
+     * Host data passed to tools as `ctx.context` for the run this message starts, and recorded on its
+     * `run.started` event. It must not carry secrets.
+     */
+    context?: Metadata;
+}
+export interface Plico {
+    threads: {
+        /** `metadata` is host data kept with the thread, set now and never changed. */
+        create(options?: {
+            metadata?: Metadata;
+        }): Promise<Thread>;
+        get(threadId: string): Promise<Thread | undefined>;
+        /** `metadata` keeps threads whose top-level keys equal every given value. */
+        list(filter?: {
+            metadata?: Metadata;
+        }): Promise<Thread[]>;
+        /** Rejects with `thread.not_found` for an unknown thread. */
+        rename(threadId: string, title: string): Promise<Thread>;
+        messages(threadId: string): Promise<ThreadMessage[]>;
+        /**
+         * Records a user message and, unless `startRun` is false, starts the run that answers it. The
+         * returned message carries the `runId`. Rejects with `thread.busy` while another run is active.
+         */
+        send(threadId: string, content: string, options?: SendMessageOptions): Promise<ThreadMessage>;
+    };
+    runs: {
+        /**
+         * Starts a run that has no thread and no model, running the optional script against the
+         * project's tools. Provider-backed runs start through `threads.send`.
+         */
+        start(options?: {
+            script?: DryRunScriptStep[];
+            metadata?: Metadata;
+            /** Passed to tools as `ctx.context` and recorded on `run.started`. No secrets. */
+            context?: Metadata;
+        }): Promise<{
+            runId: string;
+        }>;
+        get(runId: string): Promise<RunSummary | undefined>;
+        /** `metadata` keeps runs whose top-level keys equal every given value. */
+        list(filter?: {
+            metadata?: Metadata;
+        }): Promise<RunSummary[]>;
+        cancel(runId: string): Promise<string>;
+        /** Follows a run's events from a cursor until it reaches a terminal state or is stopped. */
+        events(runId: string, options?: EventFollowOptions): AsyncGenerator<PlicoEvent, void, void>;
+    };
+    approvals: {
+        /**
+         * Delivers an approval decision to a waiting run. `context` describes who decided and is
+         * recorded on `approval.decided`. Returns the engine's signal result.
+         */
+        decide(runId: string, requestId: string, approved: boolean, options?: {
+            context?: Metadata;
+        }): Promise<string>;
+    };
+    /**
+     * The `/v1` API as a web-standard handler for Hono, Next.js, Bun and Deno. The host's own
+     * authentication runs first; `scope` then keeps each request to its own data.
+     */
+    fetch(options?: MountOptions): (request: Request) => Promise<Response>;
+    /** The `/v1` API as a Node handler for Express, Fastify and `http`. Honours a parsed `req.body`. */
+    node(options?: MountOptions): RequestListener;
+    /** Stops following events, waits for recovery and closes the stores Plico opened. */
+    close(): Promise<void>;
+}

package/dist/app/types.js

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

package/dist/body.d.ts

@@ -0,0 +1,4 @@
+/** Like `readJsonBody`, but an empty body is `{}` so a bare POST still works. */
+export declare function readOptionalJsonBody(request: Request): Promise<Record<string, unknown>>;
+export declare function readJsonBody(request: Request): Promise<Record<string, unknown>>;
+export declare const MAX_BODY_BYTES: number;

package/dist/body.js

@@ -0,0 +1,54 @@
+import { HttpError } from "./errors.js";
+/** Like `readJsonBody`, but an empty body is `{}` so a bare POST still works. */
+export async function readOptionalJsonBody(request) {
+    const raw = await readBody(request);
+    return raw.trim() === "" ? {} : parseJsonBody(request, raw);
+}
+export async function readJsonBody(request) {
+    return parseJsonBody(request, await readBody(request));
+}
+function parseJsonBody(request, raw) {
+    const mediaType = (request.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase();
+    if (mediaType !== "application/json") {
+        throw new HttpError(415, "request.unsupported_media_type", "Send the request body as application/json.");
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed) || Array.isArray(parsed)) {
+            throw new Error("Expected JSON object body.");
+        }
+        return parsed;
+    }
+    catch {
+        throw new HttpError(400, "request.invalid_json", "Malformed JSON body.");
+    }
+}
+export const MAX_BODY_BYTES = 1024 * 1024;
+async function readBody(request) {
+    const declared = Number(request.headers.get("content-length"));
+    if (declared > MAX_BODY_BYTES)
+        throw tooLarge();
+    const reader = request.body?.getReader();
+    if (!reader)
+        return "";
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.length;
+        if (size > MAX_BODY_BYTES) {
+            await reader.cancel();
+            throw tooLarge();
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function tooLarge() {
+    return new HttpError(413, "request.too_large", "Request body is too large.");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/create-plico.d.ts

@@ -0,0 +1,18 @@
+import type { Plico } from "./app/types.js";
+export interface CreatePlicoOptions {
+    /** The project folder. Its files define the agent; nothing else can. */
+    projectRoot: string;
+    /** SQLite file for threads, runs, events and the engine journal. */
+    databasePath: string;
+}
+/**
+ * Opens a Plico agent inside the calling process: stores, engine and provider come from the project
+ * and the database path. Runs a dead process left behind continue in the background, and queued
+ * runs are resumed before this returns. Call `close()` before the process exits.
+ */
+export declare function createPlico(options: CreatePlicoOptions): Promise<Plico>;
+/**
+ * `createPlico`, or with `inspect` a Plico that only reads: it recovers and resumes nothing, so a
+ * second process on a host's database cannot act on the host's runs.
+ */
+export declare function openPlico(options: CreatePlicoOptions, inspect: boolean): Promise<Plico>;

package/dist/create-plico.js

@@ -0,0 +1,75 @@
+import { validateProject } from "@plico-ai/core";
+import { createConfiguredModelProvider, createEngine, createMemoryJournal, createSqliteEngine, createSqliteEventStore, createSqliteThreadStore, modelProviderAccountKey, modelProviderRecoveryKey, } from "@plico-ai/runtime";
+import { assemblePlico } from "./app/assemble.js";
+import { recoverPlicoState, resumeQueuedRuns } from "./recovery.js";
+import { withThreadTitles } from "./thread-titles.js";
+/**
+ * Opens a Plico agent inside the calling process: stores, engine and provider come from the project
+ * and the database path. Runs a dead process left behind continue in the background, and queued
+ * runs are resumed before this returns. Call `close()` before the process exits.
+ */
+export function createPlico(options) {
+    return openPlico(options, false);
+}
+/**
+ * `createPlico`, or with `inspect` a Plico that only reads: it recovers and resumes nothing, so a
+ * second process on a host's database cannot act on the host's runs.
+ */
+export async function openPlico(options, inspect) {
+    const unknown = Object.keys(options).filter((key) => key !== "projectRoot" && key !== "databasePath");
+    if (unknown.length > 0)
+        throw new TypeError(`createPlico accepts only projectRoot and databasePath; files define the agent. Unknown option: ${unknown.join(", ")}`);
+    const { projectRoot, databasePath } = options;
+    // Inspection opens the database read-only, so it cannot settle runs the host left unfinished.
+    const eventStore = createSqliteEventStore({ databasePath, readOnly: inspect });
+    const validation = await validateProject(projectRoot);
+    const leaseMs = validation.project?.config.execution?.leaseMs;
+    const engine = inspect
+        ? createEngine({ journal: createMemoryJournal() })
+        : createSqliteEngine({
+            databasePath,
+            ...(leaseMs === undefined ? {} : { leaseMs }),
+        });
+    const model = validation.project?.config.model;
+    const provider = model ? createConfiguredModelProvider(model, options.projectRoot) : undefined;
+    const providerRecoveryKey = model ? modelProviderRecoveryKey(model) : undefined;
+    const providerAccountKey = model ? modelProviderAccountKey(model) : undefined;
+    const threadStore = createSqliteThreadStore({ databasePath, readOnly: inspect });
+    let closing = false;
+    const recoveryOptions = {
+        projectRoot,
+        eventStore: withThreadTitles({ projectRoot, eventStore, threadStore, provider }),
+        threadStore,
+        engine,
+        ...(provider ? { provider } : {}),
+        ...(providerRecoveryKey ? { providerRecoveryKey } : {}),
+        isClosed: () => closing,
+    };
+    if (!inspect) {
+        void recoverPlicoState(recoveryOptions).catch((error) => console.error(`Recovery incomplete: ${error instanceof Error ? error.message : String(error)}`));
+        try {
+            await resumeQueuedRuns({
+                ...recoveryOptions,
+                ...(providerAccountKey ? { providerAccountKey } : {}),
+            });
+        }
+        catch (error) {
+            closing = true;
+            threadStore.close();
+            throw error;
+        }
+    }
+    return assemblePlico({
+        projectRoot,
+        eventStore,
+        threadStore,
+        engine,
+        ...(provider ? { provider } : {}),
+        ...(providerRecoveryKey ? { providerRecoveryKey } : {}),
+        ...(providerAccountKey ? { providerAccountKey } : {}),
+        ...(inspect ? { inspect: true } : {}),
+    }, () => {
+        closing = true;
+        threadStore.close();
+    });
+}

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare function errorResponse(status: number, code: string, message: string, headers?: Record<string, string>): Response;
+export declare function errorMessage(error: unknown): string;

package/dist/errors.js

@@ -0,0 +1,19 @@
+import { jsonResponse } from "./responses.js";
+export class HttpError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+export function errorResponse(status, code, message, headers) {
+    return jsonResponse(status, { error: { code, message } }, headers);
+}
+export function errorMessage(error) {
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { PlicoError } from "./app/errors.js";
+export type { EventFollowOptions, Plico, SendMessageOptions, } from "./app/types.js";
+export { type CreatePlicoOptions, createPlico } from "./create-plico.js";
+export type { MountOptions } from "./mount.js";
+export { servePlico } from "./server.js";
+export type { ServePlicoOptions } from "./types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { PlicoError } from "./app/errors.js";
+export { createPlico } from "./create-plico.js";
+export { servePlico } from "./server.js";

package/dist/listener.d.ts

@@ -0,0 +1,6 @@
+import type { RequestListener } from "node:http";
+import { type ListenerOptions } from "./api.js";
+import type { Plico } from "./app/types.js";
+export type { ListenerOptions } from "./api.js";
+/** `createApi` for a Node server. It never replaces the global `Request` or `Response`. */
+export declare function createRequestListener(plico: Plico, options?: ListenerOptions): RequestListener;

package/dist/listener.js

@@ -0,0 +1,8 @@
+import { getRequestListener } from "@hono/node-server";
+import { createApi } from "./api.js";
+import { internalsOf } from "./app/assemble.js";
+/** `createApi` for a Node server. It never replaces the global `Request` or `Response`. */
+export function createRequestListener(plico, options = {}) {
+    const api = createApi(internalsOf(plico), options);
+    return getRequestListener((request) => api.fetch(request), { overrideGlobalObjects: false });
+}

package/dist/mount.d.ts

@@ -0,0 +1,32 @@
+import type { RequestListener } from "node:http";
+import { type RequestData } from "./api.js";
+import type { PlicoInternals } from "./app/assemble.js";
+/** Options for `plico.fetch()` and `plico.node()`: the API mounted inside a host app. */
+export interface MountOptions {
+    /**
+     * The host's answer to "whose data is this request about", such as `{ userId }`. Plico stamps it
+     * on new threads and runs as their metadata, and refuses every read and action on anything it
+     * does not match. A client cannot widen it. It also turns off the project-level routes
+     * (`/v1/project`, `/v1/instructions`, `/v1/eval`, `/v1/readiness`, `/v1/runs/dry`). A function
+     * that throws or returns anything but a JSON object fails the request with a 500.
+     */
+    scope?: RequestData;
+    /**
+     * Host data for the runs and approval decisions a request causes: tools read it as `ctx.context`
+     * and `run.started` records it. It must not carry secrets.
+     */
+    context?: RequestData;
+    /** The path the API is mounted under when the host does not strip it, such as `/plico`. */
+    basePath?: string;
+    /** The origin browsers use to reach the host, when it differs from the request URL. */
+    publicOrigin?: string;
+    /** Accept a `script` on `POST /v1/runs`. Off by default. */
+    allowScript?: boolean;
+}
+/** A web-standard handler, for Hono, Next.js route handlers, Bun and Deno. */
+export declare function createFetchHandler(internals: PlicoInternals, options?: MountOptions): (request: Request) => Promise<Response>;
+/**
+ * A Node `(req, res)` handler, for Express, Fastify and plain `http`. A body the host already
+ * parsed into `req.body` (such as with `express.json()`) is used instead of the request stream.
+ */
+export declare function createNodeHandler(internals: PlicoInternals, options?: MountOptions): RequestListener;

package/dist/mount.js

@@ -0,0 +1,34 @@
+import { getRequestListener } from "@hono/node-server";
+import { createApi } from "./api.js";
+function apiOptions(options) {
+    // The host authenticates the request, so the loopback Host rule does not apply.
+    return { ...options, allowRemote: true };
+}
+/** A web-standard handler, for Hono, Next.js route handlers, Bun and Deno. */
+export function createFetchHandler(internals, options = {}) {
+    const api = createApi(internals, apiOptions(options));
+    return async (request) => api.fetch(request);
+}
+/**
+ * A Node `(req, res)` handler, for Express, Fastify and plain `http`. A body the host already
+ * parsed into `req.body` (such as with `express.json()`) is used instead of the request stream.
+ */
+export function createNodeHandler(internals, options = {}) {
+    const api = createApi(internals, apiOptions(options));
+    return getRequestListener((request, env) => {
+        const incoming = env.incoming;
+        return api.fetch(withParsedBody(request, incoming?.body));
+    }, { overrideGlobalObjects: false });
+}
+function withParsedBody(request, parsed) {
+    if (parsed === undefined || request.method === "GET" || request.method === "HEAD")
+        return request;
+    const headers = new Headers(request.headers);
+    headers.delete("content-length");
+    const body = typeof parsed === "string"
+        ? parsed
+        : parsed instanceof Uint8Array
+            ? new TextDecoder().decode(parsed)
+            : JSON.stringify(parsed);
+    return new Request(request.url, { method: request.method, headers, body });
+}

package/dist/origin-guard.d.ts

@@ -0,0 +1,15 @@
+export interface GuardOptions {
+    allowRemote: boolean;
+    /** Origin browsers see, such as when TLS ends at a proxy. Defaults to connection scheme plus Host. */
+    publicOrigin?: string | undefined;
+}
+/**
+ * Keeps a web page in the developer's browser from driving a local Plico server.
+ *
+ * Plico has no authentication, so a loopback bind is the only protection. A page can still reach
+ * it by sending a cross-origin request, or by pointing its own domain at 127.0.0.1 (DNS
+ * rebinding). Browsers always send `Origin` on cross-origin requests and a `Host` that names the
+ * attacker's domain, so both are checked. `Origin` must match in scheme, host and port. Clients
+ * that send no `Origin`, such as curl and the CLI, are unaffected.
+ */
+export declare function assertTrustedRequest(request: Request, options: GuardOptions): void;

package/dist/origin-guard.js

@@ -0,0 +1,39 @@
+import { isIPv4 } from "node:net";
+import { HttpError } from "./errors.js";
+/**
+ * Keeps a web page in the developer's browser from driving a local Plico server.
+ *
+ * Plico has no authentication, so a loopback bind is the only protection. A page can still reach
+ * it by sending a cross-origin request, or by pointing its own domain at 127.0.0.1 (DNS
+ * rebinding). Browsers always send `Origin` on cross-origin requests and a `Host` that names the
+ * attacker's domain, so both are checked. `Origin` must match in scheme, host and port. Clients
+ * that send no `Origin`, such as curl and the CLI, are unaffected.
+ */
+export function assertTrustedRequest(request, options) {
+    const { allowRemote, publicOrigin } = options;
+    const own = new URL(request.url);
+    if (!allowRemote && !isLoopbackHost(hostname(own.host))) {
+        throw new HttpError(421, "request.host_not_allowed", "Host not allowed: this Plico server only answers requests addressed to a loopback host.");
+    }
+    const origin = request.headers.get("origin");
+    if (origin !== null && !isSameOrigin(origin, publicOrigin ?? own.origin)) {
+        throw new HttpError(403, "request.origin_not_allowed", "Cross-origin requests to this Plico server are not allowed.");
+    }
+}
+function isSameOrigin(origin, expected) {
+    try {
+        return new URL(origin).origin === new URL(expected).origin;
+    }
+    catch {
+        return false;
+    }
+}
+function hostname(host) {
+    const bracketed = /^\[([^\]]+)\]/.exec(host);
+    if (bracketed?.[1])
+        return bracketed[1].toLowerCase();
+    return (host.split(":")[0] ?? "").toLowerCase();
+}
+function isLoopbackHost(name) {
+    return name === "localhost" || name === "::1" || (isIPv4(name) && name.startsWith("127."));
+}

package/dist/project.d.ts

@@ -0,0 +1,2 @@
+import { type LoadedProject } from "@plico-ai/core";
+export declare function loadProjectOrThrow(projectRoot: string): Promise<LoadedProject>;

package/dist/project.js

@@ -0,0 +1,10 @@
+import { validateProject } from "@plico-ai/core";
+import { HttpError } from "./errors.js";
+export async function loadProjectOrThrow(projectRoot) {
+    const validation = await validateProject(projectRoot);
+    if (!validation.ok || !validation.project) {
+        const message = validation.errors.map((issue) => `${issue.path}: ${issue.message}`).join("; ");
+        throw new HttpError(400, "project.invalid", message || "Invalid project.");
+    }
+    return validation.project;
+}

package/dist/recovery.d.ts

@@ -0,0 +1,19 @@
+import { type Engine, type EventStore, type ModelProvider, type ThreadStore } from "@plico-ai/runtime";
+interface RecoveryOptions {
+    projectRoot: string;
+    eventStore: EventStore;
+    threadStore?: ThreadStore;
+    engine: Engine;
+    provider?: ModelProvider;
+    providerRecoveryKey?: string;
+    /** Stops recovery from touching stores a shutting-down server is closing. */
+    isClosed?: () => boolean;
+}
+interface ResumeQueuedOptions extends RecoveryOptions {
+    providerAccountKey?: string;
+}
+/** Continue runs a dead process left behind, settling any failed thread reservations. */
+export declare function recoverPlicoState(options: RecoveryOptions): Promise<void>;
+/** Start thread runs that were reserved but never reached the engine. */
+export declare function resumeQueuedRuns(options: ResumeQueuedOptions): Promise<void>;
+export {};

package/dist/recovery.js

@@ -0,0 +1,84 @@
+import { resolve } from "node:path";
+import { recoverRuns, runProject, } from "@plico-ai/runtime";
+import { finishFailedThreadRun } from "./thread-failure.js";
+/** Continue runs a dead process left behind, settling any failed thread reservations. */
+export async function recoverPlicoState(options) {
+    const dryRuns = recoverRuns({
+        engine: options.engine,
+        eventStore: options.eventStore,
+        recoveryFilter: { projectRoot: options.projectRoot },
+    });
+    const modelRuns = options.provider && options.providerRecoveryKey
+        ? recoverRuns({
+            engine: options.engine,
+            eventStore: options.eventStore,
+            provider: options.provider,
+            recoveryFilter: {
+                projectRoot: options.projectRoot,
+                providerRecoveryKey: options.providerRecoveryKey,
+                providerOnly: true,
+            },
+        })
+        : Promise.resolve([]);
+    const [dry, model] = await Promise.all([dryRuns, modelRuns]);
+    for (const run of [...dry, ...model]) {
+        if (run.state !== "failed")
+            continue;
+        console.error(`Recovered run ${run.runId}: failed${run.error ? ` (${run.error})` : ""}`);
+        if (!options.threadStore || options.isClosed?.())
+            continue;
+        const threadId = await options.threadStore.getThreadForRun(run.runId);
+        if (!threadId || options.isClosed?.())
+            continue;
+        const metadata = (await options.threadStore.getThread(threadId))?.metadata;
+        await finishFailedThreadRun(run.runId, threadId, options.projectRoot, options.engine, options.eventStore, run.error, metadata);
+    }
+}
+/** Start thread runs that were reserved but never reached the engine. */
+export async function resumeQueuedRuns(options) {
+    if (!options.provider || !options.providerAccountKey || !options.threadStore)
+        return;
+    if (!options.threadStore.storageIdentity ||
+        options.threadStore.storageIdentity !== options.eventStore.storageIdentity)
+        throw new Error("Thread and run stores must use the same database.");
+    const queued = await options.threadStore.listQueuedRuns();
+    for (const run of queued) {
+        if (options.isClosed?.())
+            return;
+        if (!run.projectRoot ||
+            identity(run.projectRoot) !== identity(options.projectRoot) ||
+            run.providerKey !== options.providerAccountKey)
+            continue;
+        const metadata = (await options.threadStore.getThread(run.threadId))?.metadata;
+        const status = await options.engine.status(run.runId);
+        if (status) {
+            if (status.state === "failed" || status.state === "cancelled" || status.state === "completed")
+                await finishFailedThreadRun(run.runId, run.threadId, options.projectRoot, options.engine, options.eventStore, status.state === "failed" ? "Queued run failed before it could be resumed." : undefined, metadata).catch((error) => console.error("Could not settle queued thread run", error));
+            continue;
+        }
+        void runProject(options.projectRoot, {
+            runId: run.runId,
+            threadId: run.threadId,
+            ...(metadata === undefined ? {} : { metadata }),
+            ...(run.context === undefined ? {} : { context: run.context }),
+            history: run.history,
+            message: run.content,
+            provider: options.provider,
+            providerRecoveryKey: options.providerRecoveryKey ?? options.providerAccountKey,
+            engine: options.engine,
+            eventStore: options.eventStore,
+        }).catch(async (error) => {
+            try {
+                await finishFailedThreadRun(run.runId, run.threadId, options.projectRoot, options.engine, options.eventStore, error, metadata);
+            }
+            catch (settleError) {
+                console.error("Could not record failed queued thread run", settleError);
+            }
+            console.error(`Queued run ${run.runId} failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+}
+function identity(path) {
+    const absolute = resolve(path);
+    return process.platform === "win32" ? absolute.toLowerCase() : absolute;
+}

package/dist/responses.d.ts

@@ -0,0 +1 @@
+export declare function jsonResponse(status: number, body: unknown, headers?: Record<string, string>): Response;

package/dist/responses.js

@@ -0,0 +1,6 @@
+export function jsonResponse(status, body, headers) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json; charset=utf-8", ...headers },
+    });
+}

package/dist/routes/artifacts.d.ts

@@ -0,0 +1,2 @@
+import type { Route } from "./types.js";
+export declare const artifactRoutes: Route[];