@jini-ai/http-kit 0.2.1

package/dist/attachments.d.ts

@@ -0,0 +1,317 @@
+import type { Express, Request, Response } from 'express';
+import type { AdapterContext } from './adapter.js';
+/**
+ * A staged upload as it crosses the wire and as `claim()` returns it.
+ *
+ * Deliberately declared here rather than imported from `@jini-ai/chat/core`, whose `ChatAttachment`
+ * this mirrors field-for-field: the same reason `media.ts` declares its own `MediaTask`/
+ * `MediaDispatchEngine` port types instead of depending on `@jini-ai/media`. A transport package
+ * should not acquire a dependency on a *domain* package (`jini.domain: "chat"`) to describe an
+ * upload that has nothing chat-specific about it. `attachments.test.ts` holds a compile-time
+ * assignability check in both directions against the real `ChatAttachment`, so the mirror cannot
+ * silently drift — the drift risk is paid for with a test rather than with a dependency edge.
+ *
+ * `path` means two different things at two different times, on purpose:
+ * - as returned by `register()` / over the wire: an opaque `attachment:<uuid>` capability id;
+ * - as returned by `claim()`: the real absolute filesystem path, server-side only.
+ */
+export interface StoredAttachment {
+    path: string;
+    name: string;
+    kind: 'image' | 'file';
+    size?: number;
+    /**
+     * User-visible ordering for the turn that carries this attachment. Present for exact structural
+     * parity with `ChatAttachment`; this store never sets it, because display ordering is the
+     * renderer's concern and nothing here would be able to reconstruct it.
+     */
+    order?: number;
+}
+/** What `claim()` hands back: trusted paths plus the one directory an agent may be granted. */
+export interface AttachmentClaim {
+    attachments: StoredAttachment[];
+    /** Absent only for an empty claim — there is no directory to grant when nothing was claimed. */
+    batchDirectory?: string;
+}
+/** Why an attachment operation was refused. Maps to an HTTP status in `statusForRejection`. */
+export type AttachmentRejectionReason = 
+/** The batch id is missing or not of the accepted shape. */
+'invalid-batch'
+/** One file exceeded the per-attachment byte cap. */
+ | 'attachment-too-large'
+/** The batch already holds `maxAttachments` files. */
+ | 'batch-count-exceeded'
+/** This file would push the batch past `maxBatchBytes`. */
+ | 'batch-too-large'
+/** The store as a whole is at `maxStoredAttachments` / `maxStoredBytes`. */
+ | 'storage-full'
+/** Nothing was uploaded — a zero-byte body. */
+ | 'empty-attachment'
+/** More concurrent uploads than `maxConcurrentUploads`. */
+ | 'too-many-concurrent-uploads'
+/** The cleanup request body was not a `{ batchId, paths }` of the accepted shape. */
+ | 'invalid-cleanup-request'
+/**
+ * The request stream was already drained before this route saw it — a host body-parser ordering
+ * problem, not anything the caller did. See this module's doc.
+ */
+ | 'attachment-body-consumed'
+/**
+ * The stored file is not the canonical regular file it was registered as. Reported opaquely over
+ * HTTP: this means either a bug or an active attempt to redirect a claim.
+ */
+ | 'attachment-integrity'
+/** More attachments in one claim than `maxAttachments` allows. */
+ | 'too-many-attachments'
+/** The same capability id appeared twice in one claim. */
+ | 'duplicate-attachment'
+/** No such capability id, or a run already claimed it. */
+ | 'attachment-unknown-or-claimed'
+/** One claim spanned more than one batch. */
+ | 'mixed-batch';
+/**
+ * A refusal this module classified itself, as opposed to an unexpected filesystem/programming
+ * error. The route pack turns the `reason` into a status code and lets the `message` through to the
+ * caller; anything that is *not* one of these is redacted to a generic `INTERNAL_ERROR`.
+ */
+export declare class AttachmentRejectedError extends Error {
+    readonly reason: AttachmentRejectionReason;
+    constructor(reason: AttachmentRejectionReason, message: string);
+}
+/**
+ * Registers, validates, and expires uploads staged for a run. `createDiskAttachmentStore` is the
+ * implementation this package ships; a host with its own storage (object store, tmpfs, a quota
+ * system of its own) can satisfy this port instead and keep the route pack.
+ */
+export interface AttachmentStore {
+    /** Creates (idempotently) the private directory that holds one batch's files. */
+    createBatchDirectory: (batchId: string) => Promise<string>;
+    /**
+     * Takes ownership of an already-written file and returns its opaque capability record. Rejects —
+     * and deletes the file — if it is not a canonical regular file directly inside its batch
+     * directory, or if any quota would be exceeded.
+     */
+    register: (input: {
+        batchId: string;
+        path: string;
+        name: string;
+        kind: StoredAttachment['kind'];
+        size: number;
+    }) => Promise<StoredAttachment>;
+    /** Exchanges capability ids for real paths, exactly once, binding them to `runId`. */
+    claim: (attachments: readonly StoredAttachment[], runId: string) => Promise<AttachmentClaim>;
+    /** Deletes the named still-unclaimed uploads, then the batch directory if it is now empty. */
+    deleteUnclaimed: (batchId: string, paths: readonly string[]) => Promise<void>;
+    /** Deletes everything `runId` claimed. Safe to call for a run that claimed nothing. */
+    cleanupRun: (runId: string) => Promise<void>;
+    /** Deletes unclaimed uploads older than the retention window. */
+    pruneExpired: (now?: number) => Promise<void>;
+    /** Deletes every tracked upload. For host shutdown. */
+    dispose: () => Promise<void>;
+}
+export interface CreateDiskAttachmentStoreOptions {
+    /** Root directory this store owns outright — it is emptied on construction. */
+    readonly uploadDirectory: string;
+    /** Files per batch, i.e. per composer turn. Also caps one `claim()`. Defaults to 10. */
+    readonly maxAttachments?: number;
+    /** Total bytes per batch. Defaults to 50 MB. */
+    readonly maxBatchBytes?: number;
+    /** Tracked files across all batches. Defaults to 100. */
+    readonly maxStoredAttachments?: number;
+    /** Tracked bytes across all batches. Defaults to 200 MB. */
+    readonly maxStoredBytes?: number;
+    /** How long an unclaimed upload survives `pruneExpired`. Defaults to one hour. */
+    readonly retentionMs?: number;
+}
+export interface AttachmentRecord {
+    id: string;
+    filePath: string;
+    name: string;
+    kind: StoredAttachment['kind'];
+    size: number;
+    batchId: string;
+    batchDirectory: string;
+    dev: number;
+    ino: number;
+    createdAt: number;
+    claimedRunId?: string;
+}
+/** What registration recorded about a file, as `isUnchangedAttachment` needs it. */
+export interface RecordedAttachmentIdentity {
+    readonly filePath: string;
+    readonly dev: number;
+    readonly ino: number;
+    readonly size: number;
+}
+/**
+ * What the filesystem reports about a file right now — the subset of `fs.Stats` (plus `realpath`)
+ * an integrity check needs.
+ *
+ * `isRegularFile` comes from `lstat().isFile()`, which is false for a symlink *and* for a
+ * directory. There is deliberately no separate `isSymbolicLink` field: `lstat` reports exactly one
+ * file type, so `isFile()` and `isSymbolicLink()` are mutually exclusive and a symlink check after
+ * an `isFile()` check could never be the deciding one.
+ */
+export interface ObservedAttachmentIdentity {
+    readonly isRegularFile: boolean;
+    readonly dev: number;
+    readonly ino: number;
+    readonly size: number;
+    /** `realpath` of the file — differs from its own path when any path component became a symlink. */
+    readonly canonicalPath: string;
+}
+/**
+ * `true` when the file on disk is still the same file registration accepted.
+ *
+ * Every condition is a distinct real attack: a regular file swapped for a symlink or directory, a
+ * parent directory swapped for a symlink pointing elsewhere, the file replaced by a different file
+ * at the same path (new inode), the same inode truncated or appended to (new size), or the path
+ * now resolving onto a different device.
+ *
+ * Pure and exported on purpose. Staging a *device* change for a file that keeps its path is not
+ * something a test can do on a real filesystem, and a check that can only be exercised in
+ * production is a check nobody knows works — a fake identity states each case directly.
+ */
+export declare function isUnchangedAttachment(recorded: RecordedAttachmentIdentity, observed: ObservedAttachmentIdentity): boolean;
+/**
+ * Phase 1 of `claim()`: synchronously reserves `attachments` for `runId`, or throws (releasing
+ * whatever it already reserved this call) the first time a requested attachment turns out to be
+ * unknown or already claimed.
+ *
+ * The reservation loop deliberately has no `await`: this store's exactly-once guarantee is what
+ * stops two runs being handed the same real path on disk, and `claim` is reachable concurrently
+ * (two run starts, one shared attachment). Nothing between `records.get` and the assignment of
+ * `record.claimedRunId` may ever become asynchronous — that window is exactly where a concurrent
+ * call would get its turn and could observe the same record as still unclaimed.
+ *
+ * Exported so this invariant can be exercised directly against a plain `Map` of fabricated
+ * records, without going through a disk-backed store.
+ */
+export declare function reserveAttachmentRecords(attachments: readonly StoredAttachment[], records: ReadonlyMap<string, AttachmentRecord>, runId: string, maxAttachments: number): AttachmentRecord[];
+/**
+ * Phase 2 of `claim()`: re-verifies every already-reserved record against the filesystem — not
+ * merely re-read, but re-checked against what registration recorded, so someone able to write into
+ * the batch directory between upload and run start cannot get the agent to read a file of their
+ * choosing — and checks every claimed attachment shares one batch. Returns the shared batch
+ * directory on success (or `''` for an empty `claimed`, which `claim()` never passes in — it
+ * returns before calling this — but which a direct caller can still treat as "no batch").
+ *
+ * Throws without releasing `claimed`'s reservations; releasing is the caller's job (`claim`'s own
+ * `catch`), so a rejected claim still leaves nothing half-claimed and the caller can retry with a
+ * corrected set.
+ *
+ * Exported so the integrity and mixed-batch checks can be exercised directly against fabricated
+ * records over real files on disk, without a full `createDiskAttachmentStore` around them.
+ */
+export declare function verifyClaimedAttachments(claimed: readonly AttachmentRecord[]): Promise<string>;
+/**
+ * Reduces an untrusted upload filename to a display-only basename over a conservative allowlist.
+ * Never used as the name of the stored file — see this module's trust-model doc.
+ */
+export declare function sanitizeAttachmentName(requestedName: unknown): string;
+/** `true` when `body`'s first 8 bytes are the PNG signature. */
+export declare function hasPngSignature(body: Uint8Array): boolean;
+/** `true` when `body`'s first 3 bytes are the JPEG start-of-image marker. */
+export declare function hasJpegSignature(body: Uint8Array): boolean;
+/** `true` when `body`'s first 6 bytes spell either GIF version tag. */
+export declare function hasGifSignature(body: Uint8Array): boolean;
+/** `true` when `body` opens with a RIFF container whose form type is WEBP. */
+export declare function hasWebpSignature(body: Uint8Array): boolean;
+/**
+ * Infers `'image'` from the leading bytes rather than from a renderer-controlled MIME type or file
+ * extension. PNG, JPEG, GIF87a/89a, and WEBP are recognized; everything else is `'file'`.
+ *
+ * `kind` decides whether a path is later passed to `AgentExecutor.run()`'s `imagePaths`, so letting
+ * a renderer assert it would let a renderer choose how the agent runtime parses the bytes.
+ */
+export declare function detectAttachmentKind(body: Uint8Array): StoredAttachment['kind'];
+/**
+ * Streams a request body straight to a private file under a hard byte cap, keeping only the
+ * leading signature bytes in memory so an upload never costs memory proportional to its size.
+ *
+ * Opened `wx`, so this can never overwrite an existing file. A partial write is removed before the
+ * rejection propagates: the cap is enforced *during* the stream, which necessarily means some bytes
+ * already reached disk by the time it trips.
+ */
+export declare function writeBoundedAttachmentBody({ request, filePath, maxBytes, mode, }: {
+    request: AsyncIterable<unknown>;
+    filePath: string;
+    maxBytes: number;
+    mode?: number;
+}): Promise<{
+    size: number;
+    signature: Uint8Array;
+}>;
+/**
+ * The disk-backed `AttachmentStore` this package ships. Every default matches what a chat composer
+ * needs out of the box; a host that wants different quotas passes them rather than reimplementing
+ * the port.
+ *
+ * @complexity `register`/`claim` are O(n) in the number of tracked records (a small bounded number
+ * — `maxStoredAttachments`), which is what keeps the quota decision synchronous; see `register`.
+ */
+export declare function createDiskAttachmentStore({ uploadDirectory, maxAttachments, maxBatchBytes, maxStoredAttachments, maxStoredBytes, retentionMs, }: CreateDiskAttachmentStoreOptions): Promise<AttachmentStore>;
+/**
+ * Diagnostic detail for an internal-error response the public API deliberately does not disclose
+ * (SEC-005), matching `MediaInternalErrorContext`'s precedent.
+ */
+export interface AttachmentsInternalErrorContext {
+    readonly source: 'attachment-upload' | 'attachment-cleanup';
+    readonly batchId: string | null;
+    readonly correlationId: string;
+    readonly error: unknown;
+}
+export interface AttachmentsHttpDeps {
+    readonly store: AttachmentStore;
+    /**
+     * Uploads accepted at once before further requests are rate-limited. Bounds concurrent
+     * filesystem work, which matters because each in-flight upload holds an open handle and may be
+     * writing up to `maxAttachmentBytes`. Defaults to 4.
+     */
+    readonly maxConcurrentUploads?: number;
+    /**
+     * Hard per-request byte cap, enforced while streaming. Should be at or below the store's
+     * `maxBatchBytes`. Defaults to 20 MB.
+     */
+    readonly maxAttachmentBytes?: number;
+    /** Capability ids one `DELETE` may name. Defaults to 10, matching the store's batch cap. */
+    readonly maxCleanupPaths?: number;
+    /**
+     * Rejects a request whose `Origin`/`Host` is not the local daemon's, as every other mutating
+     * route in this package does. Defaults to `true`; a host whose browser sits on a *different*
+     * local port than the daemon (a dev-server proxy, say) either sets that port via `JINI_WEB_PORT`
+     * so the guard recognizes it, or opts out here and accepts that it has no CSRF protection on
+     * this route.
+     */
+    readonly requireSameOrigin?: boolean;
+    /** Host-owned sink for the real exception behind a generic `INTERNAL_ERROR` (SEC-005). Defaults to `console.error`. */
+    readonly onInternalError?: (context: AttachmentsInternalErrorContext) => void;
+}
+export declare const ATTACHMENTS_ROUTE_PATH = "/api/attachments";
+export interface AttachmentUploadResponse {
+    readonly attachment: StoredAttachment;
+}
+/**
+ * Handles one upload: rate-limit, batch directory, bounded stream to disk, signature sniff,
+ * register. Exported so a host mounting its own path (or its own framework) can reuse the whole
+ * body without re-deriving the ordering, which is load-bearing — see the `finally`.
+ */
+export declare function handleAttachmentUpload(req: Request, res: Response, deps: AttachmentsHttpDeps, state: {
+    activeUploads: number;
+}): Promise<void>;
+/**
+ * Handles a client abandoning a batch (a failed multi-file upload, a cleared composer). Only
+ * *unclaimed* uploads can be deleted this way, so a caller cannot use it to pull files out from
+ * under a run that already claimed them.
+ */
+export declare function handleAttachmentCleanup(req: Request, res: Response, deps: AttachmentsHttpDeps): Promise<void>;
+/**
+ * Mounts `POST`/`DELETE /api/attachments` on `app`. A pack's `http(app, services)` calls this
+ * directly.
+ *
+ * Hand-mounted rather than built from `defineJsonRoute`/`mountJsonRoute` for two concrete reasons:
+ * the upload reads the raw request stream (a JSON-parsed `req.body` is exactly what must not have
+ * happened), and the cleanup answers `204` with no body, which a JSON responder cannot express.
+ */
+export declare function registerAttachmentRoutes(app: Express, deps: AttachmentsHttpDeps, adapter: AdapterContext): void;
+//# sourceMappingURL=attachments.d.ts.map

package/dist/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../src/attachments.ts"],"names":[],"mappings":"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"}