@assemblyline-agents/runtime 0.1.0

package/dist/attachments.js

@@ -0,0 +1,832 @@
+import { createHash } from "node:crypto";
+import { inflateRawSync } from "node:zlib";
+import { trustedProviderDownloadRequest } from "./trusted-attachments.js";
+const DEFAULT_ATTACHMENT_MAX_COUNT = 20;
+const DEFAULT_ATTACHMENT_MAX_BYTES = 50 * 1024 * 1024;
+const DEFAULT_ATTACHMENT_FETCH_TIMEOUT_MS = 30_000;
+const DEFAULT_ZIP_MAX_FILES = 500;
+const DEFAULT_ZIP_MAX_TOTAL_BYTES = 100 * 1024 * 1024;
+export async function materializeTurnAttachments(input) {
+    const maxCount = boundedPositiveIntEnv(input.env.OPENEVE_ATTACHMENT_MAX_COUNT, DEFAULT_ATTACHMENT_MAX_COUNT, 1, 100);
+    const limited = input.attachments.slice(0, maxCount);
+    const output = [];
+    const usedPaths = new Set();
+    if (input.attachments.length > limited.length) {
+        await input.state.appendEvent(input.run.id, "attachment.intake_truncated", {
+            received: input.attachments.length,
+            stored: limited.length,
+            maxCount
+        });
+    }
+    for (const [index, attachment] of limited.entries()) {
+        const path = uniqueAttachmentPath(attachment, index, usedPaths);
+        const base = sanitizeAttachmentForContext({
+            ...attachment,
+            path,
+            status: stringValue(attachment.status) || "pending"
+        });
+        const inline = inlineAttachmentContents(attachment);
+        if (inline !== undefined) {
+            try {
+                const maxBytes = boundedPositiveIntEnv(input.env.OPENEVE_ATTACHMENT_MAX_BYTES, DEFAULT_ATTACHMENT_MAX_BYTES, 1, 1024 * 1024 * 1024);
+                const contentType = attachmentContentType(attachment);
+                const bytes = typeof inline === "string" ? Buffer.from(inline) : Buffer.from(inline);
+                if (bytes.byteLength > maxBytes)
+                    throw new Error(`Attachment exceeds max bytes (${maxBytes}).`);
+                const filename = attachmentFilename(attachment, index);
+                const blob = await input.blob.put(`attachments/${input.run.id}/${path.slice("/files/original/".length)}`, bytes, contentType);
+                const extraction = await maybeExtractZipAttachment({
+                    ...input,
+                    attachment,
+                    archivePath: path,
+                    archiveFilename: filename,
+                    bytes,
+                    contentType
+                });
+                await input.state.recordFileIndex({
+                    runId: input.run.id,
+                    path,
+                    kind: "file",
+                    blobKey: blob.key,
+                    sha256: blob.sha256,
+                    sizeBytes: blob.size,
+                    metadata: {
+                        channel: input.channel,
+                        source: "turn-attachment",
+                        provider: stringValue(attachment.provider) || null,
+                        filename,
+                        contentType
+                    }
+                });
+                await input.state.appendEvent(input.run.id, "attachment.stored", {
+                    path,
+                    channel: input.channel,
+                    provider: stringValue(attachment.provider) || null,
+                    sizeBytes: blob.size,
+                    contentType,
+                    inline: true
+                });
+                output.push({
+                    ...sanitizeAttachmentForContext({
+                        ...base,
+                        id: stringValue(attachment.id) || `attachment-${index + 1}`,
+                        channel: input.channel,
+                        path,
+                        filename,
+                        name: filename,
+                        status: extraction.extractedFiles.length > 0 ? "extracted" : "stored",
+                        contentType,
+                        mimeType: contentType,
+                        size: blob.size,
+                        sizeBytes: blob.size,
+                        sha256: blob.sha256
+                    }),
+                    blobKey: blob.key,
+                    ...blobUriForContext(blob),
+                    ...(extraction.extractedPath ? { extractedPath: extraction.extractedPath } : {}),
+                    ...(extraction.extractedFiles.length > 0 ? { extractedFiles: extraction.extractedFiles } : {}),
+                    ...(extraction.errorMessage ? { extractionError: extraction.errorMessage } : {})
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                await input.state.appendEvent(input.run.id, "attachment.store_failed", {
+                    path,
+                    channel: input.channel,
+                    provider: stringValue(attachment.provider) || null,
+                    error: message
+                });
+                output.push(sanitizeAttachmentForContext({
+                    ...base,
+                    status: "failed",
+                    errorMessage: message
+                }));
+            }
+            continue;
+        }
+        try {
+            const download = await attachmentDownloadRequest(attachment, input);
+            if (!download) {
+                output.push(sanitizeAttachmentForContext({
+                    ...base,
+                    status: "metadata_only"
+                }));
+                continue;
+            }
+            const downloaded = await fetchAttachmentBytes(input.fetch, download, input.env);
+            const bytes = downloaded.bytes;
+            const hintedContentType = attachmentContentType(attachment);
+            const contentType = responseContentType(downloaded.contentType, hintedContentType);
+            const filename = attachmentFilename(attachment, index);
+            const blob = await input.blob.put(`attachments/${input.run.id}/${path.slice("/files/original/".length)}`, bytes, contentType);
+            const extraction = await maybeExtractZipAttachment({
+                ...input,
+                attachment,
+                archivePath: path,
+                archiveFilename: filename,
+                bytes,
+                contentType
+            });
+            const stored = {
+                ...sanitizeAttachmentForContext({
+                    ...base,
+                    id: stringValue(attachment.id) || `attachment-${index + 1}`,
+                    channel: input.channel,
+                    status: extraction.extractedFiles.length > 0 ? "extracted" : "stored",
+                    path,
+                    filename,
+                    name: filename,
+                    contentType,
+                    mimeType: contentType,
+                    size: blob.size,
+                    sizeBytes: blob.size,
+                    sha256: blob.sha256
+                }),
+                blobKey: blob.key,
+                ...blobUriForContext(blob),
+                ...(extraction.extractedPath ? { extractedPath: extraction.extractedPath } : {}),
+                ...(extraction.extractedFiles.length > 0 ? { extractedFiles: extraction.extractedFiles } : {}),
+                ...(extraction.errorMessage ? { extractionError: extraction.errorMessage } : {})
+            };
+            await input.state.recordFileIndex({
+                runId: input.run.id,
+                path,
+                kind: "file",
+                blobKey: blob.key,
+                sha256: blob.sha256,
+                sizeBytes: blob.size,
+                metadata: {
+                    channel: input.channel,
+                    source: "turn-attachment",
+                    provider: stringValue(attachment.provider) || null,
+                    filename,
+                    contentType
+                }
+            });
+            await input.state.appendEvent(input.run.id, "attachment.stored", {
+                path,
+                channel: input.channel,
+                provider: stringValue(attachment.provider) || null,
+                sizeBytes: blob.size,
+                contentType
+            });
+            output.push(stored);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await input.state.appendEvent(input.run.id, "attachment.store_failed", {
+                path,
+                channel: input.channel,
+                provider: stringValue(attachment.provider) || null,
+                error: message
+            });
+            output.push(sanitizeAttachmentForContext({
+                ...base,
+                status: "failed",
+                errorMessage: message
+            }));
+        }
+    }
+    return output;
+}
+export function fileManifestEntries(attachments) {
+    return attachments.flatMap((attachment, index) => {
+        const path = attachmentResourcePath(attachment);
+        const displayName = stringValue(attachment.displayName) ||
+            stringValue(attachment.filename) ||
+            stringValue(attachment.name) ||
+            path.split("/").at(-1) ||
+            `attachment-${index + 1}`;
+        const contentType = attachmentContentType(attachment);
+        const size = numberValue(attachment.sizeBytes) ?? numberValue(attachment.size) ?? inlineAttachmentSize(attachment);
+        const entry = {
+            fileId: stringValue(attachment.id) || `attachment-${index + 1}`,
+            displayName,
+            mimeType: contentType,
+            contentType,
+            source: stringValue(attachment.provider) || stringValue(attachment.source) || "turn-attachment",
+            status: stringValue(attachment.status) || (hasAttachmentContents(attachment) ? "stored" : "metadata_only"),
+            originalPath: path,
+            path
+        };
+        if (size !== undefined) {
+            entry.sizeBytes = size;
+            entry.size = size;
+        }
+        const revision = stringValue(attachment.sha256);
+        if (revision)
+            entry.sha256 = revision;
+        const extractedPath = stringValue(attachment.extractedPath);
+        if (extractedPath)
+            entry.extractedPath = extractedPath;
+        const errorMessage = stringValue(attachment.errorMessage);
+        if (errorMessage)
+            entry.errorMessage = errorMessage;
+        const extracted = Array.isArray(attachment.extractedFiles)
+            ? attachment.extractedFiles.flatMap((value) => {
+                const record = recordValue(value);
+                return record ? [record] : [];
+            })
+            : [];
+        return [entry, ...extracted];
+    });
+}
+export async function attachmentContentsFromRecord(attachment, blob) {
+    const inline = inlineAttachmentContents(attachment);
+    if (inline !== undefined)
+        return inline;
+    const blobKey = stringValue(attachment.blobKey);
+    if (!blobKey || !blob)
+        return undefined;
+    const bytes = await blob.get(blobKey);
+    if (!bytes)
+        return undefined;
+    return isTextualContentType(attachmentContentType(attachment)) ? Buffer.from(bytes).toString("utf8") : bytes;
+}
+export function attachmentResourcePath(attachment) {
+    const explicitPath = stringValue(attachment.path);
+    if (explicitPath) {
+        const normalized = normalizeResourcePath(explicitPath);
+        return normalized.startsWith("/files") ? normalized : `/files/original/${sanitizeResourcePath(normalized)}`;
+    }
+    const name = stringValue(attachment.filename) || stringValue(attachment.name) || stringValue(attachment.id);
+    if (name)
+        return `/files/original/${sanitizeResourcePath(name)}`;
+    return `/files/original/attachment-${hashJson(attachment).slice(0, 12)}.txt`;
+}
+export function attachmentContentType(attachment) {
+    return stringValue(attachment.contentType) ||
+        stringValue(attachment.mimeType) ||
+        stringValue(attachment.mimetype) ||
+        "application/octet-stream";
+}
+function uniqueAttachmentPath(attachment, index, usedPaths) {
+    const explicit = stringValue(attachment.path);
+    const basePath = explicit
+        ? attachmentResourcePath({ path: explicit })
+        : `/files/original/${sanitizeResourcePath(attachmentFilename(attachment, index))}`;
+    const normalized = normalizeResourcePath(basePath);
+    if (!usedPaths.has(normalized)) {
+        usedPaths.add(normalized);
+        return normalized;
+    }
+    const dot = normalized.lastIndexOf(".");
+    const suffix = `-${index + 1}`;
+    const candidate = dot > "/files/original/".length
+        ? `${normalized.slice(0, dot)}${suffix}${normalized.slice(dot)}`
+        : `${normalized}${suffix}`;
+    usedPaths.add(candidate);
+    return candidate;
+}
+function attachmentFilename(attachment, index) {
+    const name = stringValue(attachment.filename) ||
+        stringValue(attachment.name) ||
+        stringValue(attachment.displayName) ||
+        stringValue(attachment.title) ||
+        stringValue(attachment.id);
+    if (name)
+        return name;
+    const kind = stringValue(attachment.kind) || "file";
+    return `attachment-${index + 1}${extensionForContentType(attachmentContentType(attachment), kind)}`;
+}
+function extensionForContentType(contentType, kind) {
+    if (contentType === "text/markdown")
+        return ".md";
+    if (contentType === "text/plain")
+        return ".txt";
+    if (contentType === "application/json")
+        return ".json";
+    if (contentType === "application/pdf")
+        return ".pdf";
+    if (contentType === "application/zip")
+        return ".zip";
+    if (contentType === "image/png")
+        return ".png";
+    if (contentType === "image/jpeg")
+        return ".jpg";
+    if (contentType === "image/heic" || contentType === "image/heif")
+        return ".heic";
+    if (kind === "image")
+        return ".img";
+    if (kind === "audio")
+        return ".audio";
+    if (kind === "video")
+        return ".video";
+    return "";
+}
+function responseContentType(responseType, hintedType) {
+    const contentType = responseType?.split(";")[0]?.trim();
+    return contentType || hintedType || "application/octet-stream";
+}
+async function maybeExtractZipAttachment(input) {
+    if (!isZipAttachment(input.contentType, input.archiveFilename, input.bytes))
+        return { extractedFiles: [] };
+    const zipRoot = `/files/extracted/${zipRootName(input.archiveFilename)}`;
+    try {
+        const entries = extractZipEntries(input.bytes, input.env);
+        const extractedFiles = [];
+        let skipped = 0;
+        for (const entry of entries) {
+            if (entry.skipped) {
+                skipped += 1;
+                continue;
+            }
+            const contentType = contentTypeFromFilename(entry.path);
+            const path = `${zipRoot}/${entry.path}`;
+            const blob = await input.blob.put(`attachments/${input.run.id}/extracted/${zipRoot.slice("/files/extracted/".length)}/${entry.path}`, entry.bytes, contentType);
+            await input.state.recordFileIndex({
+                runId: input.run.id,
+                path,
+                kind: "file",
+                blobKey: blob.key,
+                sha256: blob.sha256,
+                sizeBytes: blob.size,
+                metadata: {
+                    channel: input.channel,
+                    source: "zip-extraction",
+                    provider: stringValue(input.attachment.provider) || null,
+                    archivePath: input.archivePath,
+                    archiveFilename: input.archiveFilename,
+                    contentType
+                }
+            });
+            extractedFiles.push({
+                path,
+                displayName: entry.path,
+                contentType,
+                sizeBytes: blob.size,
+                sha256: blob.sha256,
+                status: "extracted"
+            });
+        }
+        await input.state.appendEvent(input.run.id, "attachment.zip_extracted", {
+            archivePath: input.archivePath,
+            extractedPath: zipRoot,
+            extractedFiles: extractedFiles.length,
+            skippedEntries: skipped,
+            sizeBytes: input.bytes.byteLength
+        });
+        return { extractedPath: zipRoot, extractedFiles };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await input.state.appendEvent(input.run.id, "attachment.zip_extract_failed", {
+            archivePath: input.archivePath,
+            error: message
+        });
+        return { extractedPath: zipRoot, extractedFiles: [], errorMessage: message };
+    }
+}
+function isZipAttachment(contentType, filename, bytes) {
+    const normalized = contentType.toLowerCase().split(";")[0]?.trim() ?? "";
+    return normalized === "application/zip" ||
+        normalized === "application/x-zip-compressed" ||
+        filename.toLowerCase().endsWith(".zip") ||
+        (bytes.byteLength >= 4 && bytes[0] === 0x50 && bytes[1] === 0x4b && bytes[2] === 0x03 && bytes[3] === 0x04);
+}
+function extractZipEntries(bytes, env) {
+    const buffer = Buffer.from(bytes);
+    const eocdOffset = findEndOfCentralDirectory(buffer);
+    if (eocdOffset < 0)
+        throw new Error("ZIP central directory was not found.");
+    const entryCount = buffer.readUInt16LE(eocdOffset + 10);
+    const centralDirectorySize = buffer.readUInt32LE(eocdOffset + 12);
+    const centralDirectoryOffset = buffer.readUInt32LE(eocdOffset + 16);
+    if (entryCount === 0xffff || centralDirectorySize === 0xffffffff || centralDirectoryOffset === 0xffffffff) {
+        throw new Error("ZIP64 archives are not supported by built-in intake extraction.");
+    }
+    const maxFiles = boundedPositiveIntEnv(env.OPENEVE_ZIP_MAX_FILES, DEFAULT_ZIP_MAX_FILES, 1, 10_000);
+    const maxTotalBytes = boundedPositiveIntEnv(env.OPENEVE_ZIP_MAX_TOTAL_BYTES, DEFAULT_ZIP_MAX_TOTAL_BYTES, 1, 2 * 1024 * 1024 * 1024);
+    const entries = [];
+    let offset = centralDirectoryOffset;
+    let extractedFiles = 0;
+    let totalBytes = 0;
+    for (let index = 0; index < entryCount; index += 1) {
+        if (offset + 46 > buffer.byteLength || buffer.readUInt32LE(offset) !== 0x02014b50) {
+            throw new Error("ZIP central directory is malformed.");
+        }
+        const flags = buffer.readUInt16LE(offset + 8);
+        const method = buffer.readUInt16LE(offset + 10);
+        const compressedSize = buffer.readUInt32LE(offset + 20);
+        const uncompressedSize = buffer.readUInt32LE(offset + 24);
+        const nameLength = buffer.readUInt16LE(offset + 28);
+        const extraLength = buffer.readUInt16LE(offset + 30);
+        const commentLength = buffer.readUInt16LE(offset + 32);
+        const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+        const rawName = buffer.subarray(offset + 46, offset + 46 + nameLength).toString((flags & 0x0800) !== 0 ? "utf8" : "utf8");
+        offset += 46 + nameLength + extraLength + commentLength;
+        const safePath = safeZipEntryPath(rawName);
+        if (!safePath || rawName.endsWith("/") || (flags & 0x0001) !== 0 || (method !== 0 && method !== 8)) {
+            entries.push({ skipped: true });
+            continue;
+        }
+        if (compressedSize === 0xffffffff || uncompressedSize === 0xffffffff || localHeaderOffset === 0xffffffff) {
+            entries.push({ skipped: true });
+            continue;
+        }
+        extractedFiles += 1;
+        if (extractedFiles > maxFiles)
+            throw new Error(`ZIP extraction exceeds max files (${maxFiles}).`);
+        totalBytes += uncompressedSize;
+        if (totalBytes > maxTotalBytes)
+            throw new Error(`ZIP extraction exceeds max bytes (${maxTotalBytes}).`);
+        const entryBytes = readZipEntry(buffer, localHeaderOffset, compressedSize, uncompressedSize, method);
+        entries.push({ path: safePath, bytes: entryBytes });
+    }
+    return entries;
+}
+function findEndOfCentralDirectory(buffer) {
+    const min = Math.max(0, buffer.byteLength - 65_557);
+    for (let offset = buffer.byteLength - 22; offset >= min; offset -= 1) {
+        if (buffer.readUInt32LE(offset) === 0x06054b50)
+            return offset;
+    }
+    return -1;
+}
+function readZipEntry(buffer, localHeaderOffset, compressedSize, uncompressedSize, method) {
+    if (localHeaderOffset + 30 > buffer.byteLength || buffer.readUInt32LE(localHeaderOffset) !== 0x04034b50) {
+        throw new Error("ZIP local file header is malformed.");
+    }
+    const localNameLength = buffer.readUInt16LE(localHeaderOffset + 26);
+    const localExtraLength = buffer.readUInt16LE(localHeaderOffset + 28);
+    const dataStart = localHeaderOffset + 30 + localNameLength + localExtraLength;
+    const dataEnd = dataStart + compressedSize;
+    if (dataEnd > buffer.byteLength)
+        throw new Error("ZIP entry data exceeds archive size.");
+    const compressed = buffer.subarray(dataStart, dataEnd);
+    const output = method === 0 ? Buffer.from(compressed) : inflateRawSync(compressed);
+    if (output.byteLength !== uncompressedSize) {
+        throw new Error("ZIP entry expanded to an unexpected size.");
+    }
+    return output;
+}
+function safeZipEntryPath(name) {
+    const normalized = name.replace(/\\/g, "/").replace(/\0/g, "");
+    if (!normalized || /^[A-Za-z]:/u.test(normalized))
+        return undefined;
+    const parts = normalized
+        .split("/")
+        .filter((part) => part && part !== ".")
+        .map((part) => part.trim());
+    if (parts.length === 0 || parts.some((part) => part === ".."))
+        return undefined;
+    return parts.map((part) => part.replace(/[^A-Za-z0-9._ -]/gu, "_")).join("/");
+}
+function zipRootName(filename) {
+    const clean = filename.replace(/\.zip$/iu, "") || "archive";
+    return sanitizeResourcePath(clean);
+}
+function contentTypeFromFilename(filename) {
+    const lower = filename.toLowerCase();
+    if (lower.endsWith(".md") || lower.endsWith(".markdown"))
+        return "text/markdown";
+    if (lower.endsWith(".txt") || lower.endsWith(".log"))
+        return "text/plain";
+    if (lower.endsWith(".json"))
+        return "application/json";
+    if (lower.endsWith(".csv"))
+        return "text/csv";
+    if (lower.endsWith(".tsv"))
+        return "text/tab-separated-values";
+    if (lower.endsWith(".xml"))
+        return "application/xml";
+    if (lower.endsWith(".html") || lower.endsWith(".htm"))
+        return "text/html";
+    if (lower.endsWith(".css"))
+        return "text/css";
+    if (lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs"))
+        return "application/javascript";
+    if (lower.endsWith(".ts") || lower.endsWith(".tsx"))
+        return "application/typescript";
+    if (lower.endsWith(".zip"))
+        return "application/zip";
+    if (lower.endsWith(".png"))
+        return "image/png";
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+        return "image/jpeg";
+    if (lower.endsWith(".gif"))
+        return "image/gif";
+    if (lower.endsWith(".webp"))
+        return "image/webp";
+    if (lower.endsWith(".pdf"))
+        return "application/pdf";
+    return "application/octet-stream";
+}
+function inlineAttachmentContents(attachment) {
+    const encoding = stringValue(attachment.encoding).toLowerCase();
+    for (const key of ["content", "text", "body", "data"]) {
+        const value = attachment[key];
+        if (typeof value !== "string")
+            continue;
+        if (encoding === "base64")
+            return Buffer.from(value, "base64");
+        return value;
+    }
+    const dataBase64 = stringValue(attachment.dataBase64) || stringValue(attachment.base64);
+    if (dataBase64)
+        return Buffer.from(dataBase64, "base64");
+    return undefined;
+}
+function inlineAttachmentSize(attachment) {
+    const contents = inlineAttachmentContents(attachment);
+    if (contents === undefined)
+        return undefined;
+    return typeof contents === "string" ? Buffer.byteLength(contents) : contents.byteLength;
+}
+function hasAttachmentContents(attachment) {
+    return inlineAttachmentContents(attachment) !== undefined || typeof attachment.blobKey === "string";
+}
+export function isTextualContentType(contentType) {
+    const normalized = contentType.toLowerCase().split(";")[0]?.trim() ?? "";
+    return normalized.startsWith("text/") ||
+        normalized === "application/json" ||
+        normalized === "application/xml" ||
+        normalized === "application/javascript" ||
+        normalized === "application/typescript" ||
+        normalized.endsWith("+json") ||
+        normalized.endsWith("+xml");
+}
+async function attachmentDownloadRequest(attachment, input) {
+    if (input.resolveAttachment) {
+        // The turn's own channel module resolves provider-specific downloads
+        // (auth lookups, host allowlists, credential headers).
+        const resolved = await input.resolveAttachment(attachment);
+        if (resolved) {
+            const request = { url: resolved.url, headers: resolved.headers };
+            if (input.trustedProvider)
+                request.provider = input.trustedProvider;
+            const filename = resolved.filename || stringValue(attachment.filename) || stringValue(attachment.name);
+            if (filename)
+                request.filename = filename;
+            return request;
+        }
+        // The channel declined the attachment: fall back to a generic,
+        // unauthenticated URL download so plain public links keep working.
+        const url = attachmentRemoteUrl(attachment);
+        if (!url)
+            return undefined;
+        const request = { url, headers: {} };
+        const provider = stringValue(attachment.provider);
+        if (provider)
+            request.provider = provider;
+        const filename = stringValue(attachment.filename) || stringValue(attachment.name);
+        if (filename)
+            request.filename = filename;
+        return request;
+    }
+    // Direct `run({ trustedAttachmentProvider })` callers get the in-runtime
+    // provider resolvers (files.info lookups, host allowlists, credential
+    // headers). Anything else falls back to a generic, unauthenticated
+    // public-URL download — provider credentials always require either a
+    // channel resolver or an explicit trusted provider.
+    if (input.trustedProvider) {
+        return trustedProviderDownloadRequest(attachment, input);
+    }
+    const url = attachmentRemoteUrl(attachment);
+    if (!url)
+        return undefined;
+    const request = { url, headers: {} };
+    const provider = stringValue(attachment.provider);
+    if (provider)
+        request.provider = provider;
+    const filename = stringValue(attachment.filename) || stringValue(attachment.name);
+    if (filename)
+        request.filename = filename;
+    return request;
+}
+/**
+ * Extract the first downloadable http(s) URL a channel attachment advertises.
+ * Exported for channel modules implementing `resolveAttachment`.
+ */
+export function attachmentRemoteUrl(attachment) {
+    return attachmentDownloadUrl(attachment);
+}
+/**
+ * True when the attachment's own trust markers (`remote.trusted` plus a
+ * matching provider/auth hint) claim the given provider. Channel modules use
+ * this in `resolveAttachment` before attaching credentials, so forged
+ * attachments never receive another provider's tokens.
+ */
+export function attachmentTrustedForProvider(attachment, provider) {
+    return trustedProviderForAttachment(attachment, provider) !== undefined;
+}
+function attachmentDownloadUrl(attachment) {
+    const remote = recordValue(attachment.remote) ?? recordValue(attachment.download);
+    const candidates = [
+        remote?.downloadUrl,
+        remote?.contentUrl,
+        attachment.downloadUrl,
+        attachment.url_private_download,
+        remote?.url_private_download,
+        attachment.url_private,
+        remote?.url_private,
+        attachment.contentUrl,
+        attachment.mediaUrl,
+        attachment.fileUrl,
+        attachment.url,
+        remote?.url,
+        attachment.href
+    ];
+    return firstDownloadableUrl(candidates);
+}
+/** Exported for channel modules and the transitional legacy resolver module. */
+export function firstDownloadableUrl(candidates) {
+    for (const candidate of candidates) {
+        const url = stringValue(candidate);
+        if (isDownloadableHttpUrl(url))
+            return url;
+    }
+    return undefined;
+}
+function isDownloadableHttpUrl(value) {
+    if (!value)
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === "https:" || url.protocol === "http:";
+    }
+    catch {
+        return false;
+    }
+}
+export function trustedProviderForAttachment(attachment, trustedProvider) {
+    const normalizedTrustedProvider = normalizeAttachmentProvider(trustedProvider);
+    if (!normalizedTrustedProvider)
+        return undefined;
+    const remote = recordValue(attachment.remote) ?? recordValue(attachment.download);
+    if (!remoteTrusted(remote))
+        return undefined;
+    const providers = [
+        attachment.provider,
+        attachment.remoteProvider,
+        remote?.provider,
+        remote?.auth,
+        remote?.authProvider,
+        attachment.authProvider
+    ].map((value) => normalizeAttachmentProvider(stringValue(value)));
+    return providers.includes(normalizedTrustedProvider) ? normalizedTrustedProvider : undefined;
+}
+function remoteTrusted(remote) {
+    return remote?.trusted === true || stringValue(remote?.trusted) === "true";
+}
+export function normalizeAttachmentProvider(value) {
+    if (!value)
+        return undefined;
+    const provider = value.toLowerCase();
+    if (provider === "photon-spectrum")
+        return "photon";
+    if (provider === "microsoft-teams")
+        return "teams";
+    if (provider === "slack" || provider === "telegram" || provider === "photon" || provider === "teams")
+        return provider;
+    return provider;
+}
+function blobUriForContext(blob) {
+    return blob.visibility === "public" ? { blobUri: blob.uri } : {};
+}
+async function fetchAttachmentBytes(fetchImpl, request, env) {
+    const maxBytes = boundedPositiveIntEnv(env.OPENEVE_ATTACHMENT_MAX_BYTES, DEFAULT_ATTACHMENT_MAX_BYTES, 1, 1024 * 1024 * 1024);
+    const init = { signal: timeoutSignal(attachmentFetchTimeoutMs(env)) };
+    if (request.headers)
+        init.headers = request.headers;
+    const response = await fetchImpl(request.url, init);
+    if (!response.ok)
+        throw new Error(`Attachment download failed: ${response.status}`);
+    const bytes = await readResponseBytesLimited(response, maxBytes);
+    const contentType = response.headers.get("content-type") ?? undefined;
+    if (isSlackHtmlDownloadPage(request, contentType, bytes)) {
+        throw new Error("Slack returned an HTML file page instead of the private file bytes. Pass Slack url_private_download or a Slack file id with SLACK_BOT_TOKEN/SLACK_USER_TOKEN.");
+    }
+    const out = { bytes };
+    if (contentType)
+        out.contentType = contentType;
+    return out;
+}
+function isSlackHtmlDownloadPage(request, contentType, bytes) {
+    if (request.provider !== "slack")
+        return false;
+    const normalized = contentType?.toLowerCase().split(";")[0]?.trim() ?? "";
+    if (normalized !== "text/html")
+        return false;
+    const filename = request.filename?.toLowerCase() ?? "";
+    if (!filename.endsWith(".zip"))
+        return false;
+    return Buffer.from(bytes.subarray(0, 512)).toString("utf8").toLowerCase().includes("<html");
+}
+async function readResponseBytesLimited(response, maxBytes) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (buffer.byteLength > maxBytes)
+            throw new Error(`Attachment exceeds max bytes (${maxBytes}).`);
+        return buffer;
+    }
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        if (!value)
+            continue;
+        total += value.byteLength;
+        if (total > maxBytes) {
+            await reader.cancel().catch(() => undefined);
+            throw new Error(`Attachment exceeds max bytes (${maxBytes}).`);
+        }
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function sanitizeAttachmentForContext(attachment) {
+    const blocked = new Set([
+        "authorization",
+        "headers",
+        "token",
+        "remote",
+        "download",
+        "downloadUrl",
+        "contentUrl",
+        "mediaUrl",
+        "fileUrl",
+        "dataBase64",
+        "base64",
+        "url",
+        "url_private_download",
+        "url_private",
+        "href",
+        "authProvider",
+        "remoteProvider",
+        // Blob pointers must always be runtime-issued: a forged inbound blobKey
+        // (or a nested extractedFiles entry carrying one) would otherwise let a
+        // crafted payload read arbitrary blobs in the shared storage root.
+        // Callers re-attach the runtime's own pointers after sanitization.
+        "blobKey",
+        "blobUri",
+        "extractedFiles"
+    ]);
+    const out = {};
+    for (const [key, value] of Object.entries(attachment)) {
+        if (blocked.has(key))
+            continue;
+        out[key] = safeJson(value);
+    }
+    return out;
+}
+function timeoutSignal(timeoutMs) {
+    return AbortSignal.timeout(timeoutMs);
+}
+/** Attachment download timeout (`OPENEVE_ATTACHMENT_FETCH_TIMEOUT_MS`). Exported for channel `resolveAttachment` lookups. */
+export function attachmentFetchTimeoutMs(env) {
+    return boundedPositiveIntEnv(env.OPENEVE_ATTACHMENT_FETCH_TIMEOUT_MS, DEFAULT_ATTACHMENT_FETCH_TIMEOUT_MS, 1_000, 120_000);
+}
+function boundedPositiveIntEnv(value, fallback, min, max) {
+    const parsed = Number.parseInt(value ?? "", 10);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.min(max, Math.max(min, parsed));
+}
+function normalizeResourcePath(path) {
+    const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/").trim();
+    const absolute = normalized.startsWith("/") ? normalized : `/${normalized}`;
+    if (absolute.split("/").some((part) => part === "..")) {
+        throw new Error(`Invalid resource path: ${path}`);
+    }
+    return absolute === "/" ? "/" : absolute.replace(/\/$/u, "");
+}
+function sanitizeResourcePath(path) {
+    return path
+        .replace(/\\/g, "/")
+        .replace(/^\/+/u, "")
+        .split("/")
+        .filter((part) => part && part !== "." && part !== "..")
+        .map((part) => part.replace(/[^A-Za-z0-9._-]/gu, "_"))
+        .join("/") || "resource";
+}
+function stringValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    return typeof value === "string" ? value.trim() : "";
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function recordValue(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value)) ? value : undefined;
+}
+function safeJson(value) {
+    return JSON.parse(JSON.stringify(value ?? null));
+}
+function hashJson(value) {
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function sha256(contents) {
+    return createHash("sha256").update(contents).digest("hex");
+}
+//# sourceMappingURL=attachments.js.map