@pellux/goodvibes-daemon-sdk 0.18.3 → 0.30.1

package/README.md

@@ -1,14 +1,20 @@
 # @pellux/goodvibes-daemon-sdk
 
-Embeddable daemon and control-plane route contracts, dispatchers, and handler builders for GoodVibes.
+Internal workspace package backing `@pellux/goodvibes-sdk/daemon`.
 
-Install:
+Consumers should install `@pellux/goodvibes-sdk` and import this surface from the umbrella package.
 
-```bash
-npm install @pellux/goodvibes-daemon-sdk
+Consumer import:
+
+```ts
+import {
+  createDaemonControlRouteHandlers,
+  createDaemonTelemetryRouteHandlers,
+  dispatchDaemonApiRoutes,
+} from '@pellux/goodvibes-sdk/daemon';
 ```
 
-Use this package to:
+This surface is for:
 - embed daemon routes in another host
 - dispatch operator, automation, session, task, or remote API calls
 - reuse shared daemon auth/error helpers
@@ -20,7 +26,7 @@ import {
   createDaemonControlRouteHandlers,
   createDaemonTelemetryRouteHandlers,
   dispatchDaemonApiRoutes,
-} from '@pellux/goodvibes-daemon-sdk';
+} from '@pellux/goodvibes-sdk/daemon';
 ```
 
 This package gives you reusable route modules, but your host still owns:
@@ -29,4 +35,4 @@ This package gives you reusable route modules, but your host still owns:
 - auth/session storage
 - runtime bootstrapping
 
-Use this package when you are embedding GoodVibes into another TypeScript server. Do not use it for normal client-side integrations.
+Use this surface when you are embedding GoodVibes into another TypeScript server. Do not use it for normal client-side integrations.

package/dist/api-router.d.ts

@@ -1,3 +1,10 @@
 import type { DaemonApiRouteHandlers } from './context.js';
-export declare function dispatchDaemonApiRoutes(req: Request, handlers: DaemonApiRouteHandlers): Promise<Response | null>;
+/**
+ * Optional extension dispatchers injected alongside the standard route set.
+ * Each dispatcher is tried in order after the built-in routes; the first
+ * non-null result wins. Use this to wire companion-chat, provider, or other
+ * feature routes into the standalone daemon without modifying core route files.
+ */
+export type DaemonApiRouteExtension = (req: Request) => Promise<Response | null> | Response | null;
+export declare function dispatchDaemonApiRoutes(req: Request, handlers: DaemonApiRouteHandlers, extensions?: readonly DaemonApiRouteExtension[]): Promise<Response | null>;
 //# sourceMappingURL=api-router.d.ts.map

package/dist/api-router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-router.d.ts","sourceRoot":"","sources":["../src/api-router.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE3D,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,sBAAsB,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAQtH"}
+{"version":3,"file":"api-router.d.ts","sourceRoot":"","sources":["../src/api-router.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE3D;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,QAAQ,GAAG,IAAI,CAAC;AAEnG,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,sBAAsB,EAChC,UAAU,CAAC,EAAE,SAAS,uBAAuB,EAAE,GAC9C,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAgB1B"}

package/dist/api-router.js

@@ -1,13 +1,22 @@
-// Synced from goodvibes-tui/src/control-plane/routes/api-router.ts
 import { dispatchAutomationRoutes } from './automation.js';
 import { dispatchOperatorRoutes } from './operator.js';
 import { dispatchRemoteRoutes } from './remote.js';
 import { dispatchSessionRoutes } from './sessions.js';
 import { dispatchTaskRoutes } from './tasks.js';
-export async function dispatchDaemonApiRoutes(req, handlers) {
-    return (await dispatchRemoteRoutes(req, handlers)
+export async function dispatchDaemonApiRoutes(req, handlers, extensions) {
+    const coreResult = (await dispatchRemoteRoutes(req, handlers)
         ?? await dispatchOperatorRoutes(req, handlers)
         ?? await dispatchAutomationRoutes(req, handlers)
         ?? await dispatchSessionRoutes(req, handlers)
         ?? await dispatchTaskRoutes(req, handlers));
+    if (coreResult !== null)
+        return coreResult;
+    if (extensions) {
+        for (const extension of extensions) {
+            const result = await extension(req);
+            if (result !== null)
+                return result;
+        }
+    }
+    return null;
 }

package/dist/artifact-upload.d.ts

@@ -0,0 +1,26 @@
+export type ArtifactUploadFieldMap = Record<string, unknown>;
+export interface ArtifactStoreUploadLike {
+    create(input: Record<string, unknown>): Promise<unknown>;
+    getMaxBytes?(): number;
+    createFromStream?(input: {
+        readonly stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array | Buffer | string> | Iterable<Uint8Array | Buffer | string>;
+        readonly kind?: string;
+        readonly mimeType?: string;
+        readonly filename?: string;
+        readonly sourceUri?: string;
+        readonly sizeBytes?: number;
+        readonly retentionMs?: number;
+        readonly acquisitionMode?: string;
+        readonly fetchMode?: string;
+        readonly metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+export interface ArtifactUploadResult {
+    readonly artifact: unknown;
+    readonly artifactId: string;
+    readonly fields: ArtifactUploadFieldMap;
+}
+export declare function isJsonContentType(contentType: string | null): boolean;
+export declare function isArtifactUploadRequest(req: Request): boolean;
+export declare function createArtifactFromUploadRequest(artifactStore: ArtifactStoreUploadLike, req: Request): Promise<ArtifactUploadResult | Response>;
+//# sourceMappingURL=artifact-upload.d.ts.map

package/dist/artifact-upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-upload.d.ts","sourceRoot":"","sources":["../src/artifact-upload.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE7D,MAAM,WAAW,uBAAuB;IACtC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACzD,WAAW,CAAC,IAAI,MAAM,CAAC;IACvB,gBAAgB,CAAC,CAAC,KAAK,EAAE;QACvB,QAAQ,CAAC,MAAM,EACX,cAAc,CAAC,UAAU,CAAC,GAC1B,aAAa,CAAC,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC,GAC3C,QAAQ,CAAC,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC,CAAC;QAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;QAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC7C,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;CACzC;AA+BD,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAGrE;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAE7D;AAED,wBAAsB,+BAA+B,CACnD,aAAa,EAAE,uBAAuB,EACtC,GAAG,EAAE,OAAO,GACX,OAAO,CAAC,oBAAoB,GAAG,QAAQ,CAAC,CAM1C"}

package/dist/artifact-upload.js

@@ -0,0 +1,535 @@
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, open, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { GoodVibesSdkError } from '@pellux/goodvibes-errors';
+const JSON_FIELD_NAMES = new Set(['metadata', 'target', 'options']);
+const MAX_MULTIPART_FIELD_BYTES = 1024 * 1024;
+const MAX_MULTIPART_BODY_OVERHEAD_BYTES = MAX_MULTIPART_FIELD_BYTES;
+function artifactUploadError(message, options = {}) {
+    return new GoodVibesSdkError(message, {
+        category: 'bad_request',
+        source: 'runtime',
+        operation: 'daemon.artifactUpload',
+        status: options.status,
+        code: options.code ?? 'ARTIFACT_UPLOAD_INVALID_REQUEST',
+    });
+}
+function artifactSizeError(maxBytes) {
+    return artifactUploadError(`Artifact exceeds the ${maxBytes}-byte limit.`, {
+        status: 413,
+        code: 'ARTIFACT_UPLOAD_TOO_LARGE',
+    });
+}
+export function isJsonContentType(contentType) {
+    const lower = (contentType ?? '').split(';')[0]?.trim().toLowerCase() ?? '';
+    return lower === '' || lower === 'application/json' || lower.endsWith('+json');
+}
+export function isArtifactUploadRequest(req) {
+    return !isJsonContentType(req.headers.get('content-type'));
+}
+export async function createArtifactFromUploadRequest(artifactStore, req) {
+    const contentType = req.headers.get('content-type') ?? '';
+    if (contentType.toLowerCase().includes('multipart/form-data')) {
+        return createArtifactFromMultipart(artifactStore, req);
+    }
+    return createArtifactFromRawBody(artifactStore, req);
+}
+function parseUploadField(name, value) {
+    const trimmed = value.trim();
+    if (JSON_FIELD_NAMES.has(name)) {
+        return parseJsonField(trimmed, name);
+    }
+    if (name === 'tags') {
+        if (trimmed.startsWith('[')) {
+            const parsed = parseJsonField(trimmed, name);
+            return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === 'string') : [];
+        }
+        return trimmed.split(',').map((entry) => entry.trim()).filter(Boolean);
+    }
+    if (name === 'allowPrivateHosts')
+        return trimmed === 'true' || trimmed === '1' || trimmed === 'yes';
+    if (name === 'retentionMs') {
+        const parsed = Number(trimmed);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return value;
+}
+function parseJsonField(value, fieldName) {
+    if (!value)
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        void error;
+        throw artifactUploadError(`Invalid JSON in multipart field ${fieldName}.`);
+    }
+}
+function readStringField(fields, key) {
+    const value = fields[key];
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function readNumberField(fields, key) {
+    const value = fields[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function readMetadata(fields) {
+    const metadata = fields.metadata;
+    return typeof metadata === 'object' && metadata !== null && !Array.isArray(metadata)
+        ? metadata
+        : {};
+}
+function readArtifactId(artifact) {
+    if (typeof artifact === 'object' && artifact !== null) {
+        const id = artifact.id;
+        if (typeof id === 'string' && id.trim().length > 0)
+            return id;
+    }
+    return Response.json({ error: 'Artifact store returned an artifact without an id.' }, { status: 500 });
+}
+function isFileLike(value) {
+    return typeof value === 'object'
+        && value !== null
+        && typeof value.stream === 'function'
+        && typeof value.arrayBuffer === 'function';
+}
+async function createArtifactFromMultipart(artifactStore, req) {
+    if (req.body)
+        return createArtifactFromStreamingMultipart(artifactStore, req);
+    let form;
+    try {
+        form = await req.formData();
+    }
+    catch (error) {
+        void error;
+        return Response.json({ error: 'Invalid multipart upload.' }, { status: 400 });
+    }
+    const fields = {};
+    let file = null;
+    for (const [name, value] of form.entries()) {
+        if (typeof value === 'string') {
+            try {
+                const parsed = parseUploadField(name, value);
+                if (parsed !== undefined)
+                    fields[name] = parsed;
+            }
+            catch (error) {
+                return Response.json({ error: error instanceof Error ? error.message : String(error) }, { status: 400 });
+            }
+            continue;
+        }
+        if (!file && isFileLike(value)) {
+            file = value;
+        }
+    }
+    if (!file)
+        return Response.json({ error: 'Multipart upload requires a file field.' }, { status: 400 });
+    const maxBytes = artifactStore.getMaxBytes?.();
+    if (typeof maxBytes === 'number' && typeof file.size === 'number' && file.size > maxBytes) {
+        return Response.json({ error: `Artifact exceeds the ${maxBytes}-byte limit.` }, { status: 413 });
+    }
+    const artifact = await createArtifactFromStream(artifactStore, {
+        stream: file.stream(),
+        fields,
+        filename: readStringField(fields, 'filename') ?? file.name,
+        mimeType: readStringField(fields, 'mimeType') ?? file.type,
+        sizeBytes: typeof file.size === 'number' ? file.size : undefined,
+        maxBytes,
+    });
+    const artifactId = readArtifactId(artifact);
+    return artifactId instanceof Response ? artifactId : { artifact, artifactId, fields };
+}
+async function createArtifactFromStreamingMultipart(artifactStore, req) {
+    let spooled = null;
+    try {
+        spooled = await spoolMultipartUpload(req, artifactStore.getMaxBytes?.());
+        const artifact = await createArtifactFromStream(artifactStore, {
+            stream: readFileChunks(spooled.filePath),
+            fields: spooled.fields,
+            filename: readStringField(spooled.fields, 'filename') ?? spooled.filename,
+            mimeType: readStringField(spooled.fields, 'mimeType') ?? spooled.mimeType,
+            sizeBytes: spooled.sizeBytes,
+            maxBytes: artifactStore.getMaxBytes?.(),
+        });
+        const artifactId = readArtifactId(artifact);
+        return artifactId instanceof Response ? artifactId : { artifact, artifactId, fields: spooled.fields };
+    }
+    catch (error) {
+        return Response.json({ error: error instanceof Error ? error.message : String(error) }, { status: 400 });
+    }
+    finally {
+        await spooled?.cleanup();
+    }
+}
+async function createArtifactFromRawBody(artifactStore, req) {
+    if (!req.body)
+        return Response.json({ error: 'Raw artifact upload requires a request body.' }, { status: 400 });
+    const url = new URL(req.url);
+    const fields = readFieldsFromSearchParams(url.searchParams);
+    const contentType = req.headers.get('content-type')?.split(';')[0]?.trim();
+    const maxBytes = artifactStore.getMaxBytes?.();
+    const sizeBytes = readContentLength(req);
+    if (typeof maxBytes === 'number' && typeof sizeBytes === 'number' && sizeBytes > maxBytes) {
+        return Response.json({ error: `Artifact exceeds the ${maxBytes}-byte limit.` }, { status: 413 });
+    }
+    const artifact = await createArtifactFromStream(artifactStore, {
+        stream: req.body,
+        fields,
+        filename: readStringField(fields, 'filename')
+            ?? req.headers.get('x-goodvibes-filename')?.trim()
+            ?? filenameFromContentDisposition(req.headers.get('content-disposition')),
+        mimeType: readStringField(fields, 'mimeType') ?? contentType ?? undefined,
+        sizeBytes,
+        maxBytes,
+    });
+    const artifactId = readArtifactId(artifact);
+    return artifactId instanceof Response ? artifactId : { artifact, artifactId, fields };
+}
+async function* readFileChunks(path) {
+    const handle = await open(path, 'r');
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    try {
+        for (;;) {
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            yield buffer.subarray(0, bytesRead);
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+function readFieldsFromSearchParams(params) {
+    const fields = {};
+    for (const [name, value] of params.entries()) {
+        try {
+            const parsed = parseUploadField(name, value);
+            if (parsed !== undefined)
+                fields[name] = parsed;
+        }
+        catch (error) {
+            void error;
+            fields[name] = value;
+        }
+    }
+    return fields;
+}
+function readContentLength(req) {
+    const parsed = Number(req.headers.get('content-length') ?? NaN);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function filenameFromContentDisposition(header) {
+    if (!header)
+        return undefined;
+    const match = header.match(/filename\*?=(?:UTF-8''|")?([^";]+)/i);
+    if (!match?.[1])
+        return undefined;
+    try {
+        return decodeURIComponent(match[1].replace(/^"|"$/g, ''));
+    }
+    catch (error) {
+        void error;
+        return match[1].replace(/^"|"$/g, '');
+    }
+}
+function multipartBoundary(contentType) {
+    const match = contentType.match(/(?:^|;)\s*boundary=(?:"([^"]+)"|([^;]+))/i);
+    const boundary = match?.[1] ?? match?.[2];
+    return boundary && boundary.trim().length > 0 ? boundary.trim() : null;
+}
+function decodeHeaderValue(value) {
+    const unquoted = value.trim().replace(/^"|"$/g, '');
+    try {
+        return decodeURIComponent(unquoted.replace(/^UTF-8''/i, ''));
+    }
+    catch (error) {
+        void error;
+        return unquoted;
+    }
+}
+function parseMultipartPartHeaders(headerText) {
+    const headers = new Map();
+    for (const line of headerText.split('\r\n')) {
+        const separator = line.indexOf(':');
+        if (separator < 0)
+            continue;
+        headers.set(line.slice(0, separator).trim().toLowerCase(), line.slice(separator + 1).trim());
+    }
+    const disposition = headers.get('content-disposition') ?? '';
+    const output = {};
+    for (const segment of disposition.split(';').slice(1)) {
+        const [rawKey, ...rawValue] = segment.split('=');
+        const key = rawKey?.trim().toLowerCase();
+        const value = rawValue.join('=');
+        if (!key || !value)
+            continue;
+        if (key === 'name')
+            output.name = decodeHeaderValue(value);
+        if (key === 'filename' || key === 'filename*')
+            output.filename = decodeHeaderValue(value);
+    }
+    const contentType = headers.get('content-type');
+    if (contentType)
+        output.contentType = contentType.split(';')[0]?.trim();
+    return output;
+}
+async function spoolMultipartUpload(req, maxFileBytes) {
+    const boundary = multipartBoundary(req.headers.get('content-type') ?? '');
+    if (!boundary)
+        throw artifactUploadError('Multipart upload is missing a boundary.');
+    if (!req.body)
+        throw artifactUploadError('Multipart upload requires a request body.');
+    const contentLength = readContentLength(req);
+    if (typeof maxFileBytes === 'number'
+        && typeof contentLength === 'number'
+        && contentLength > maxFileBytes + MAX_MULTIPART_BODY_OVERHEAD_BYTES) {
+        throw artifactSizeError(maxFileBytes);
+    }
+    const tempDir = await mkdtemp(join(tmpdir(), 'goodvibes-upload-'));
+    const filePath = join(tempDir, `${randomUUID()}.upload`);
+    const fields = {};
+    const firstBoundary = Buffer.from(`--${boundary}`);
+    const bodyBoundary = Buffer.from(`\r\n--${boundary}`);
+    const headerSeparator = Buffer.from('\r\n\r\n');
+    const reader = req.body.getReader();
+    let buffer = Buffer.alloc(0);
+    let fileSeen = false;
+    let filename;
+    let mimeType;
+    let sizeBytes = 0;
+    const readMore = async () => {
+        const { done, value } = await reader.read();
+        if (done)
+            return false;
+        buffer = Buffer.concat([buffer, Buffer.from(value)]);
+        return true;
+    };
+    const consumeBoundarySuffix = async () => {
+        while (buffer.length < 2) {
+            if (!await readMore())
+                throw artifactUploadError('Unexpected end of multipart body.');
+        }
+        if (buffer.subarray(0, 2).toString() === '--') {
+            buffer = buffer.subarray(2);
+            return 'done';
+        }
+        if (buffer.subarray(0, 2).toString() === '\r\n') {
+            buffer = buffer.subarray(2);
+            return 'next';
+        }
+        throw artifactUploadError('Invalid multipart boundary terminator.');
+    };
+    const consumeInitialBoundary = async () => {
+        for (;;) {
+            const index = buffer.indexOf(firstBoundary);
+            if (index >= 0) {
+                buffer = buffer.subarray(index + firstBoundary.length);
+                return consumeBoundarySuffix();
+            }
+            if (!await readMore())
+                throw artifactUploadError('Invalid multipart upload.');
+            const readIndex = buffer.indexOf(firstBoundary);
+            if (readIndex >= 0) {
+                buffer = buffer.subarray(readIndex + firstBoundary.length);
+                return consumeBoundarySuffix();
+            }
+            if (buffer.length > firstBoundary.length * 2) {
+                buffer = buffer.subarray(buffer.length - firstBoundary.length * 2);
+            }
+        }
+    };
+    const readHeaders = async () => {
+        for (;;) {
+            const index = buffer.indexOf(headerSeparator);
+            if (index >= 0) {
+                const headerText = buffer.subarray(0, index).toString('utf8');
+                buffer = buffer.subarray(index + headerSeparator.length);
+                return parseMultipartPartHeaders(headerText);
+            }
+            if (!await readMore())
+                throw artifactUploadError('Unexpected end of multipart headers.');
+            if (buffer.length > MAX_MULTIPART_FIELD_BYTES)
+                throw artifactUploadError('Multipart part headers are too large.');
+        }
+    };
+    const readPart = async (onChunk) => {
+        const keepBytes = bodyBoundary.length - 1;
+        for (;;) {
+            const index = buffer.indexOf(bodyBoundary);
+            if (index >= 0) {
+                if (index > 0)
+                    await onChunk(buffer.subarray(0, index));
+                buffer = buffer.subarray(index + bodyBoundary.length);
+                return consumeBoundarySuffix();
+            }
+            if (buffer.length > keepBytes) {
+                await onChunk(buffer.subarray(0, buffer.length - keepBytes));
+                buffer = buffer.subarray(buffer.length - keepBytes);
+            }
+            if (!await readMore())
+                throw artifactUploadError('Unexpected end of multipart part.');
+        }
+    };
+    const readFieldPart = async (name) => {
+        const chunks = [];
+        let fieldBytes = 0;
+        const state = await readPart(async (chunk) => {
+            fieldBytes += chunk.byteLength;
+            if (fieldBytes > MAX_MULTIPART_FIELD_BYTES)
+                throw artifactUploadError(`Multipart field ${name} is too large.`);
+            chunks.push(chunk);
+        });
+        const parsed = parseUploadField(name, Buffer.concat(chunks).toString('utf8'));
+        if (parsed !== undefined)
+            fields[name] = parsed;
+        return state;
+    };
+    const readFilePart = async (headers) => {
+        const handle = await open(filePath, 'wx');
+        try {
+            const state = await readPart(async (chunk) => {
+                sizeBytes += chunk.byteLength;
+                if (typeof maxFileBytes === 'number' && sizeBytes > maxFileBytes) {
+                    throw artifactSizeError(maxFileBytes);
+                }
+                await handle.write(chunk);
+            });
+            fileSeen = true;
+            filename = headers.filename;
+            mimeType = headers.contentType;
+            return state;
+        }
+        finally {
+            await handle.close();
+        }
+    };
+    try {
+        for (let state = await consumeInitialBoundary(); state !== 'done';) {
+            const headers = await readHeaders();
+            if (headers.filename !== undefined && !fileSeen) {
+                state = await readFilePart(headers);
+            }
+            else if (headers.filename !== undefined) {
+                state = await readPart(async () => { });
+            }
+            else if (headers.name) {
+                state = await readFieldPart(headers.name);
+            }
+            else {
+                state = await readPart(async () => { });
+            }
+        }
+        if (!fileSeen)
+            throw artifactUploadError('Multipart upload requires a file field.');
+        return {
+            filePath,
+            ...(filename ? { filename } : {}),
+            ...(mimeType ? { mimeType } : {}),
+            sizeBytes,
+            fields,
+            cleanup: async () => {
+                await cleanupTempDir(tempDir);
+            },
+        };
+    }
+    catch (error) {
+        await cleanupTempDir(tempDir, error);
+        throw error;
+    }
+    finally {
+        releaseReaderLock(reader);
+    }
+}
+async function cleanupTempDir(tempDir, originalError) {
+    try {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+    catch (cleanupError) {
+        if (originalError !== undefined) {
+            throw new AggregateError([originalError, cleanupError], 'Multipart upload failed and temporary upload cleanup also failed.');
+        }
+        throw cleanupError;
+    }
+}
+function releaseReaderLock(reader) {
+    try {
+        reader.releaseLock();
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return;
+        throw error;
+    }
+}
+async function createArtifactFromStream(artifactStore, input) {
+    if (typeof input.maxBytes === 'number' && typeof input.sizeBytes === 'number' && input.sizeBytes > input.maxBytes) {
+        throw artifactSizeError(input.maxBytes);
+    }
+    const base = {
+        ...(readStringField(input.fields, 'kind') ? { kind: readStringField(input.fields, 'kind') } : {}),
+        ...(input.mimeType ? { mimeType: input.mimeType } : {}),
+        ...(input.filename ? { filename: input.filename } : {}),
+        ...(readStringField(input.fields, 'sourceUri') ? { sourceUri: readStringField(input.fields, 'sourceUri') } : {}),
+        ...(typeof input.sizeBytes === 'number' ? { sizeBytes: input.sizeBytes } : {}),
+        ...(typeof readNumberField(input.fields, 'retentionMs') === 'number' ? { retentionMs: readNumberField(input.fields, 'retentionMs') } : {}),
+        acquisitionMode: 'inline-data',
+        fetchMode: 'not-applicable',
+        metadata: readMetadata(input.fields),
+    };
+    if (artifactStore.createFromStream) {
+        return artifactStore.createFromStream({
+            stream: input.stream,
+            ...base,
+        });
+    }
+    const buffer = await bufferUploadStream(input.stream, input.maxBytes);
+    return artifactStore.create({
+        ...base,
+        dataBase64: buffer.toString('base64'),
+    });
+}
+function isWebReadableStream(stream) {
+    return typeof stream.getReader === 'function';
+}
+function isAsyncUploadIterable(stream) {
+    return typeof stream[Symbol.asyncIterator] === 'function';
+}
+async function* iterateUploadStream(stream) {
+    if (isWebReadableStream(stream)) {
+        const reader = stream.getReader();
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    yield value;
+            }
+        }
+        finally {
+            releaseReaderLock(reader);
+        }
+        return;
+    }
+    if (isAsyncUploadIterable(stream)) {
+        yield* stream;
+        return;
+    }
+    for (const chunk of stream)
+        yield chunk;
+}
+async function bufferUploadStream(stream, maxBytes) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of iterateUploadStream(stream)) {
+        const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : Buffer.from(chunk);
+        totalBytes += buffer.byteLength;
+        if (typeof maxBytes === 'number' && totalBytes > maxBytes) {
+            throw artifactSizeError(maxBytes);
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}

package/dist/automation.d.ts

@@ -1,3 +1,3 @@
-import type { DaemonApiRouteHandlers } from './context.js';
-export declare function dispatchAutomationRoutes(req: Request, handlers: Pick<DaemonApiRouteHandlers, 'getReview' | 'getIntegrationSession' | 'getIntegrationAutomation' | 'getAutomationJobs' | 'postAutomationJob' | 'getAutomationRuns' | 'getAutomationRun' | 'automationRunAction' | 'patchAutomationJob' | 'deleteAutomationJob' | 'setAutomationJobEnabled' | 'runAutomationJobNow' | 'getDeliveries' | 'getDelivery' | 'getSchedules' | 'postSchedule' | 'deleteSchedule' | 'setScheduleEnabled' | 'runScheduleNow'>): Promise<Response | null>;
+import type { DaemonAutomationRouteHandlers } from './context.js';
+export declare function dispatchAutomationRoutes(req: Request, handlers: DaemonAutomationRouteHandlers): Promise<Response | null>;
 //# sourceMappingURL=automation.d.ts.map

package/dist/automation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"automation.d.ts","sourceRoot":"","sources":["../src/automation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE3D,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,IAAI,CACZ,sBAAsB,EACpB,WAAW,GACX,uBAAuB,GACvB,0BAA0B,GAC1B,mBAAmB,GACnB,mBAAmB,GACnB,mBAAmB,GACnB,kBAAkB,GAClB,qBAAqB,GACrB,oBAAoB,GACpB,qBAAqB,GACrB,yBAAyB,GACzB,qBAAqB,GACrB,eAAe,GACf,aAAa,GACb,cAAc,GACd,cAAc,GACd,gBAAgB,GAChB,oBAAoB,GACpB,gBAAgB,CACnB,GACA,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CA+C1B"}
+{"version":3,"file":"automation.d.ts","sourceRoot":"","sources":["../src/automation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAElE,wBAAsB,wBAAwB,CAC5C,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,6BAA6B,GACtC,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CA+C1B"}