@bbigbang/agent-node 0.1.0

package/dist/attachmentInput.js

@@ -0,0 +1,588 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { inflateSync } from 'node:zlib';
+import { extractAttachmentIdFromUri } from './attachmentMaterializer.js';
+export const INLINE_TEXT_ATTACHMENT_PREVIEW_MAX_BYTES = 64 * 1024;
+export const INLINE_IMAGE_ATTACHMENT_MAX_BYTES = 5 * 1024 * 1024;
+const PNG_VALIDATION_MAX_INFLATED_BYTES = 16 * 1024 * 1024;
+export function resolveLocalImageAttachmentPath(attachment) {
+    const localPath = resolveLocalAttachmentPath(attachment);
+    if (!localPath)
+        return null;
+    if (!isWithinInlineImageSizeLimit(localPath))
+        return null;
+    const mediaType = normalizeClaudeInlineImageMediaType(attachment?.mimeType)
+        ?? inferClaudeInlineImageMediaTypeFromPath(localPath);
+    if (!mediaType)
+        return null;
+    return fileMatchesClaudeImageMediaType(localPath, mediaType) ? localPath : null;
+}
+export function resolveLocalAttachmentPath(attachment) {
+    const uri = normalizeOptionalString(attachment?.uri);
+    if (!uri)
+        return null;
+    let localPath = null;
+    if (uri.startsWith('file://')) {
+        try {
+            localPath = fileURLToPath(uri);
+        }
+        catch {
+            return null;
+        }
+    }
+    else if (path.isAbsolute(uri)) {
+        localPath = uri;
+    }
+    if (!localPath)
+        return null;
+    return fs.existsSync(localPath) ? localPath : null;
+}
+export function formatAttachmentTextReference(attachment, index, resolvedLocalPath, resolvedAttachmentId) {
+    const uri = normalizeOptionalString(attachment.uri) ?? '(missing uri)';
+    const mime = normalizeOptionalString(attachment.mimeType);
+    const attachmentId = resolvedAttachmentId ?? normalizeOptionalString(attachment.assetId) ?? extractAttachmentIdFromUri(uri);
+    const localPath = resolvedLocalPath ?? normalizeOptionalString(attachment.preferredLocalPath) ?? resolveLocalAttachmentPath(attachment);
+    const filename = normalizeOptionalString(attachment.filename);
+    if (localPath) {
+        return `Attachment ${index + 1}${filename ? ` (${filename})` : ''}: local_path="${localPath}"${mime ? ` (${mime})` : ''}. Read this file directly from disk.`;
+    }
+    if (attachmentId) {
+        return `Attachment ${index + 1}${filename ? ` (${filename})` : ''}: use view_file(attachment_id="${attachmentId}") to inspect it${mime ? ` (${mime})` : ''}.`;
+    }
+    return `Attachment ${index + 1}: ${uri}${mime ? ` (${mime})` : ''}`;
+}
+export function promptAlreadyReferencesAttachment(promptText, attachmentId) {
+    return promptText.includes(`attachment_id="${attachmentId}"`)
+        || promptText.includes(`ID: ${attachmentId}`);
+}
+export function resolveClaudeInlineImageAttachment(attachment) {
+    const localPath = resolveLocalAttachmentPath(attachment);
+    if (!localPath)
+        return null;
+    if (!isWithinInlineImageSizeLimit(localPath))
+        return null;
+    const mediaType = normalizeClaudeInlineImageMediaType(attachment.mimeType)
+        ?? inferClaudeInlineImageMediaTypeFromPath(localPath);
+    if (!mediaType)
+        return null;
+    if (!fileMatchesClaudeImageMediaType(localPath, mediaType))
+        return null;
+    return { path: localPath, mediaType };
+}
+function isWithinInlineImageSizeLimit(localPath) {
+    try {
+        const stat = fs.statSync(localPath);
+        return stat.isFile() && stat.size <= INLINE_IMAGE_ATTACHMENT_MAX_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+export function buildInlineTextAttachmentPreview(attachment, localPath, index, maxBytes = INLINE_TEXT_ATTACHMENT_PREVIEW_MAX_BYTES) {
+    if (!isInlineTextAttachment(localPath, attachment.mimeType))
+        return null;
+    const stat = fs.statSync(localPath);
+    if (!stat.isFile())
+        return null;
+    const readBytes = Math.min(stat.size, maxBytes + 4);
+    const fileBuffer = readBytes > 0
+        ? readFilePrefixSync(localPath, readBytes)
+        : Buffer.alloc(0);
+    if (!isLikelyUtf8Text(fileBuffer))
+        return null;
+    const truncated = stat.size > maxBytes;
+    const previewBuffer = truncated ? fileBuffer.subarray(0, maxBytes) : fileBuffer;
+    const previewText = trimIncompleteUtf8Suffix(previewBuffer).toString('utf8');
+    const filename = normalizeOptionalString(attachment.filename);
+    const mime = normalizeOptionalString(attachment.mimeType);
+    const sizeLabel = `${(stat.size / 1024).toFixed(1)} KB`;
+    const suffix = truncated
+        ? `\n\n[truncated preview: showing first ${(maxBytes / 1024).toFixed(0)} KB of ${sizeLabel}; inspect local_path for the full file.]`
+        : '';
+    return [
+        `Attachment ${index + 1}${filename ? ` (${filename})` : ''}: local_path="${localPath}"${mime ? ` (${mime})` : ''}, ${sizeLabel}.`,
+        previewText + suffix,
+    ].join('\n\n');
+}
+function readFilePrefixSync(localPath, byteCount) {
+    const fd = fs.openSync(localPath, 'r');
+    try {
+        const buffer = Buffer.alloc(byteCount);
+        const bytesRead = fs.readSync(fd, buffer, 0, byteCount, 0);
+        return bytesRead === byteCount ? buffer : buffer.subarray(0, bytesRead);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function isInlineTextAttachment(localPath, mimeType) {
+    const normalizedMime = normalizeOptionalString(mimeType)?.toLowerCase();
+    if (normalizedMime?.startsWith('text/'))
+        return true;
+    if (normalizedMime === 'application/json' || normalizedMime === 'application/xml')
+        return true;
+    return /\.(csv|ini|json|jsonc|log|md|rst|text|toml|txt|xml|ya?ml|[cm]?[jt]sx?|py|rb|rs|go|java|kt|lua|php|sh|sql|swift|vue|css|scss|html)$/i.test(localPath);
+}
+function normalizeClaudeInlineImageMediaType(mimeType) {
+    const normalized = normalizeOptionalString(mimeType)?.toLowerCase();
+    switch (normalized) {
+        case 'image/png':
+        case 'image/jpeg':
+        case 'image/gif':
+        case 'image/webp':
+            return normalized;
+        case 'image/jpg':
+            return 'image/jpeg';
+        default:
+            return null;
+    }
+}
+function inferClaudeInlineImageMediaTypeFromPath(localPath) {
+    const ext = path.extname(localPath).toLowerCase();
+    switch (ext) {
+        case '.png':
+            return 'image/png';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.gif':
+            return 'image/gif';
+        case '.webp':
+            return 'image/webp';
+        default:
+            return null;
+    }
+}
+function fileMatchesClaudeImageMediaType(localPath, mediaType) {
+    let fileBuffer;
+    try {
+        fileBuffer = fs.readFileSync(localPath);
+    }
+    catch {
+        return false;
+    }
+    switch (mediaType) {
+        case 'image/png':
+            return isStructurallyValidPng(fileBuffer);
+        case 'image/jpeg':
+            return isStructurallyValidJpeg(fileBuffer);
+        case 'image/gif':
+            return isStructurallyValidGif(fileBuffer);
+        case 'image/webp':
+            return isStructurallyValidWebp(fileBuffer);
+    }
+}
+function isStructurallyValidPng(buffer) {
+    const pngSignature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    if (buffer.length < 45 || !buffer.subarray(0, 8).equals(pngSignature))
+        return false;
+    let offset = 8;
+    let sawIhdr = false;
+    let sawIdat = false;
+    let expectedInflatedBytes = 0;
+    const idatChunks = [];
+    while (offset + 12 <= buffer.length) {
+        const chunkLength = buffer.readUInt32BE(offset);
+        const chunkType = buffer.subarray(offset + 4, offset + 8).toString('ascii');
+        const dataStart = offset + 8;
+        const crcEnd = dataStart + chunkLength + 4;
+        if (crcEnd > buffer.length)
+            return false;
+        if (!sawIhdr) {
+            if (chunkType !== 'IHDR' || chunkLength !== 13)
+                return false;
+            const width = buffer.readUInt32BE(dataStart);
+            const height = buffer.readUInt32BE(dataStart + 4);
+            const bitDepth = buffer[dataStart + 8];
+            const colorType = buffer[dataStart + 9];
+            const compression = buffer[dataStart + 10];
+            const filter = buffer[dataStart + 11];
+            const interlace = buffer[dataStart + 12];
+            if (width === 0 || height === 0)
+                return false;
+            if (!isValidPngBitDepthColorType(bitDepth, colorType))
+                return false;
+            if (compression !== 0 || filter !== 0 || (interlace !== 0 && interlace !== 1))
+                return false;
+            expectedInflatedBytes = estimatePngInflatedByteLength(width, height, bitDepth, colorType, interlace);
+            if (expectedInflatedBytes <= 0 || expectedInflatedBytes > PNG_VALIDATION_MAX_INFLATED_BYTES)
+                return false;
+            sawIhdr = true;
+        }
+        else if (chunkType === 'IDAT') {
+            if (chunkLength === 0)
+                return false;
+            idatChunks.push(buffer.subarray(dataStart, dataStart + chunkLength));
+            sawIdat = true;
+        }
+        else if (chunkType === 'IEND') {
+            if (chunkLength !== 0 || !sawIhdr || !sawIdat || crcEnd !== buffer.length)
+                return false;
+            try {
+                const inflated = inflateSync(Buffer.concat(idatChunks), { maxOutputLength: expectedInflatedBytes + 1 });
+                return inflated.length === expectedInflatedBytes;
+            }
+            catch {
+                return false;
+            }
+        }
+        offset = crcEnd;
+    }
+    return false;
+}
+function estimatePngInflatedByteLength(width, height, bitDepth, colorType, interlace) {
+    if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height))
+        return 0;
+    if (interlace === 1)
+        return estimateAdam7PngInflatedByteLength(width, height, bitDepth, colorType);
+    const bitsPerPixel = getPngBitsPerPixel(bitDepth, colorType);
+    if (bitsPerPixel <= 0)
+        return 0;
+    const rowBytes = Math.ceil((width * bitsPerPixel) / 8);
+    return height * (rowBytes + 1);
+}
+function estimateAdam7PngInflatedByteLength(width, height, bitDepth, colorType) {
+    const bitsPerPixel = getPngBitsPerPixel(bitDepth, colorType);
+    if (bitsPerPixel <= 0)
+        return 0;
+    const passes = [
+        { x: 0, y: 0, dx: 8, dy: 8 },
+        { x: 4, y: 0, dx: 8, dy: 8 },
+        { x: 0, y: 4, dx: 4, dy: 8 },
+        { x: 2, y: 0, dx: 4, dy: 4 },
+        { x: 0, y: 2, dx: 2, dy: 4 },
+        { x: 1, y: 0, dx: 2, dy: 2 },
+        { x: 0, y: 1, dx: 1, dy: 2 },
+    ];
+    let total = 0;
+    for (const pass of passes) {
+        const passWidth = pass.x >= width ? 0 : Math.floor((width - pass.x + pass.dx - 1) / pass.dx);
+        const passHeight = pass.y >= height ? 0 : Math.floor((height - pass.y + pass.dy - 1) / pass.dy);
+        if (passWidth === 0 || passHeight === 0)
+            continue;
+        total += passHeight * (Math.ceil((passWidth * bitsPerPixel) / 8) + 1);
+    }
+    return total;
+}
+function getPngBitsPerPixel(bitDepth, colorType) {
+    switch (colorType) {
+        case 0:
+        case 3:
+            return bitDepth;
+        case 2:
+            return bitDepth * 3;
+        case 4:
+            return bitDepth * 2;
+        case 6:
+            return bitDepth * 4;
+        default:
+            return 0;
+    }
+}
+function isValidPngBitDepthColorType(bitDepth, colorType) {
+    switch (colorType) {
+        case 0:
+            return [1, 2, 4, 8, 16].includes(bitDepth);
+        case 2:
+        case 4:
+        case 6:
+            return [8, 16].includes(bitDepth);
+        case 3:
+            return [1, 2, 4, 8].includes(bitDepth);
+        default:
+            return false;
+    }
+}
+function isStructurallyValidJpeg(buffer) {
+    if (buffer.length < 12
+        || buffer[0] !== 0xff
+        || buffer[1] !== 0xd8
+        || buffer[buffer.length - 2] !== 0xff
+        || buffer[buffer.length - 1] !== 0xd9) {
+        return false;
+    }
+    let offset = 2;
+    let sawFrame = false;
+    let sawScanData = false;
+    while (offset + 1 < buffer.length) {
+        if (buffer[offset] !== 0xff)
+            return false;
+        while (offset < buffer.length && buffer[offset] === 0xff)
+            offset += 1;
+        if (offset >= buffer.length)
+            return false;
+        const marker = buffer[offset];
+        offset += 1;
+        if (marker === 0xd9)
+            return sawFrame && sawScanData && offset === buffer.length;
+        if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+            continue;
+        }
+        if (offset + 2 > buffer.length)
+            return false;
+        const segmentLength = buffer.readUInt16BE(offset);
+        if (segmentLength < 2)
+            return false;
+        const dataStart = offset + 2;
+        const segmentEnd = offset + segmentLength;
+        if (segmentEnd > buffer.length)
+            return false;
+        if (isJpegStartOfFrameMarker(marker)) {
+            if (segmentLength < 8)
+                return false;
+            const height = buffer.readUInt16BE(dataStart + 1);
+            const width = buffer.readUInt16BE(dataStart + 3);
+            const components = buffer[dataStart + 5];
+            if (width === 0 || height === 0 || components === 0 || components > 4)
+                return false;
+            sawFrame = true;
+        }
+        if (marker === 0xda) {
+            if (!sawFrame)
+                return false;
+            const scan = readJpegScanData(buffer, segmentEnd);
+            if (!scan?.hadData)
+                return false;
+            sawScanData = true;
+            offset = scan.nextMarkerOffset;
+            continue;
+        }
+        offset = segmentEnd;
+    }
+    return false;
+}
+function isStructurallyValidGif(buffer) {
+    const header = buffer.subarray(0, 6).toString('ascii');
+    if (buffer.length < 14 || (header !== 'GIF87a' && header !== 'GIF89a'))
+        return false;
+    const width = buffer.readUInt16LE(6);
+    const height = buffer.readUInt16LE(8);
+    if (width === 0 || height === 0)
+        return false;
+    const packed = buffer[10];
+    const globalColorTableSize = (packed & 0x80) !== 0
+        ? 3 * (2 ** ((packed & 0x07) + 1))
+        : 0;
+    let offset = 13 + globalColorTableSize;
+    let sawImage = false;
+    while (offset < buffer.length) {
+        const marker = buffer[offset];
+        offset += 1;
+        if (marker === 0x3b) {
+            return sawImage && offset === buffer.length;
+        }
+        if (marker === 0x21) {
+            if (offset >= buffer.length)
+                return false;
+            offset += 1;
+            const skipped = skipGifSubBlocks(buffer, offset);
+            if (!skipped)
+                return false;
+            offset = skipped.offset;
+            continue;
+        }
+        if (marker !== 0x2c)
+            return false;
+        if (offset + 9 > buffer.length)
+            return false;
+        const imageWidth = buffer.readUInt16LE(offset + 4);
+        const imageHeight = buffer.readUInt16LE(offset + 6);
+        const imagePacked = buffer[offset + 8];
+        offset += 9;
+        const localColorTableSize = (imagePacked & 0x80) !== 0
+            ? 3 * (2 ** ((imagePacked & 0x07) + 1))
+            : 0;
+        offset += localColorTableSize;
+        if (imageWidth === 0 || imageHeight === 0 || offset >= buffer.length)
+            return false;
+        offset += 1;
+        const skipped = skipGifSubBlocks(buffer, offset);
+        if (!skipped?.hadData)
+            return false;
+        offset = skipped.offset;
+        sawImage = true;
+    }
+    return false;
+}
+function isStructurallyValidWebp(buffer) {
+    if (buffer.length < 16)
+        return false;
+    if (buffer.subarray(0, 4).toString('ascii') !== 'RIFF')
+        return false;
+    if (buffer.subarray(8, 12).toString('ascii') !== 'WEBP')
+        return false;
+    const riffSize = buffer.readUInt32LE(4);
+    if (riffSize + 8 !== buffer.length)
+        return false;
+    let offset = 12;
+    let sawImageData = false;
+    while (offset + 8 <= buffer.length) {
+        const chunkType = buffer.subarray(offset, offset + 4).toString('ascii');
+        const chunkSize = buffer.readUInt32LE(offset + 4);
+        const dataStart = offset + 8;
+        const dataEnd = dataStart + chunkSize;
+        if (dataEnd > buffer.length)
+            return false;
+        if (chunkType === 'VP8 ') {
+            if (!isValidWebpVp8Chunk(buffer.subarray(dataStart, dataEnd)))
+                return false;
+            sawImageData = true;
+        }
+        else if (chunkType === 'VP8L') {
+            if (!isValidWebpVp8lChunk(buffer.subarray(dataStart, dataEnd)))
+                return false;
+            sawImageData = true;
+        }
+        else if (chunkType === 'VP8X') {
+            if (!isValidWebpVp8xChunk(buffer.subarray(dataStart, dataEnd)))
+                return false;
+        }
+        else if (chunkType === 'ANMF') {
+            if (chunkSize < 16 || !containsValidWebpImageChunk(buffer, dataStart + 16, dataEnd))
+                return false;
+            sawImageData = true;
+        }
+        offset = dataEnd + (chunkSize % 2);
+    }
+    return sawImageData && offset === buffer.length;
+}
+function isJpegStartOfFrameMarker(marker) {
+    return ((marker >= 0xc0 && marker <= 0xc3)
+        || (marker >= 0xc5 && marker <= 0xc7)
+        || (marker >= 0xc9 && marker <= 0xcb)
+        || (marker >= 0xcd && marker <= 0xcf));
+}
+function readJpegScanData(buffer, startOffset) {
+    let offset = startOffset;
+    let hadData = false;
+    while (offset + 1 < buffer.length) {
+        if (buffer[offset] !== 0xff) {
+            hadData = true;
+            offset += 1;
+            continue;
+        }
+        const marker = buffer[offset + 1];
+        if (marker === 0x00) {
+            hadData = true;
+            offset += 2;
+            continue;
+        }
+        if (marker === 0xff) {
+            offset += 1;
+            continue;
+        }
+        if (marker >= 0xd0 && marker <= 0xd7) {
+            hadData = true;
+            offset += 2;
+            continue;
+        }
+        return { nextMarkerOffset: offset, hadData };
+    }
+    return null;
+}
+function skipGifSubBlocks(buffer, offset) {
+    let cursor = offset;
+    let hadData = false;
+    while (cursor < buffer.length) {
+        const blockSize = buffer[cursor];
+        cursor += 1;
+        if (blockSize === 0)
+            return { offset: cursor, hadData };
+        if (cursor + blockSize > buffer.length)
+            return null;
+        hadData = true;
+        cursor += blockSize;
+    }
+    return null;
+}
+function isValidWebpVp8Chunk(chunk) {
+    return chunk.length >= 10
+        && chunk[3] === 0x9d
+        && chunk[4] === 0x01
+        && chunk[5] === 0x2a
+        && (chunk.readUInt16LE(6) & 0x3fff) > 0
+        && (chunk.readUInt16LE(8) & 0x3fff) > 0;
+}
+function isValidWebpVp8lChunk(chunk) {
+    if (chunk.length < 5 || chunk[0] !== 0x2f)
+        return false;
+    const bits = chunk.readUInt32LE(1);
+    const width = (bits & 0x3fff) + 1;
+    const height = ((bits >> 14) & 0x3fff) + 1;
+    return width > 0 && height > 0;
+}
+function isValidWebpVp8xChunk(chunk) {
+    if (chunk.length !== 10)
+        return false;
+    const width = 1 + chunk[4] + (chunk[5] << 8) + (chunk[6] << 16);
+    const height = 1 + chunk[7] + (chunk[8] << 8) + (chunk[9] << 16);
+    return width > 0 && height > 0;
+}
+function containsValidWebpImageChunk(buffer, startOffset, endOffset) {
+    let offset = startOffset;
+    while (offset + 8 <= endOffset) {
+        const chunkType = buffer.subarray(offset, offset + 4).toString('ascii');
+        const chunkSize = buffer.readUInt32LE(offset + 4);
+        const dataStart = offset + 8;
+        const dataEnd = dataStart + chunkSize;
+        if (dataEnd > endOffset)
+            return false;
+        if (chunkType === 'VP8 ' && isValidWebpVp8Chunk(buffer.subarray(dataStart, dataEnd))) {
+            return true;
+        }
+        if (chunkType === 'VP8L' && isValidWebpVp8lChunk(buffer.subarray(dataStart, dataEnd))) {
+            return true;
+        }
+        offset = dataEnd + (chunkSize % 2);
+    }
+    return false;
+}
+function isLikelyUtf8Text(buffer) {
+    if (buffer.length === 0)
+        return true;
+    const sample = buffer.subarray(0, Math.min(buffer.length, INLINE_TEXT_ATTACHMENT_PREVIEW_MAX_BYTES));
+    let suspicious = 0;
+    for (const byte of sample) {
+        if (byte === 0)
+            return false;
+        if (byte < 0x20 && byte !== 0x09 && byte !== 0x0a && byte !== 0x0d) {
+            suspicious += 1;
+        }
+    }
+    if (suspicious > Math.max(8, sample.length * 0.05))
+        return false;
+    const decoded = sample.toString('utf8');
+    const replacementCount = (decoded.match(/\uFFFD/g) ?? []).length;
+    return replacementCount <= Math.max(4, decoded.length * 0.01);
+}
+function trimIncompleteUtf8Suffix(buffer) {
+    if (buffer.length === 0)
+        return buffer;
+    let continuationBytes = 0;
+    while (continuationBytes < Math.min(3, buffer.length)
+        && (buffer[buffer.length - 1 - continuationBytes] & 0b1100_0000) === 0b1000_0000) {
+        continuationBytes += 1;
+    }
+    const leadIndex = buffer.length - 1 - continuationBytes;
+    if (leadIndex < 0) {
+        return buffer.subarray(0, buffer.length - continuationBytes);
+    }
+    const leadByte = buffer[leadIndex];
+    const expectedLength = ((leadByte & 0b1000_0000) === 0 ? 1
+        : (leadByte & 0b1110_0000) === 0b1100_0000 ? 2
+            : (leadByte & 0b1111_0000) === 0b1110_0000 ? 3
+                : (leadByte & 0b1111_1000) === 0b1111_0000 ? 4
+                    : 1);
+    const actualLength = buffer.length - leadIndex;
+    if (actualLength < expectedLength) {
+        return buffer.subarray(0, leadIndex);
+    }
+    return buffer;
+}
+function normalizeOptionalString(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.trim();
+    return normalized ? normalized : null;
+}