@predicatelabs/sdk 0.99.9

package/dist/failure-artifacts.js

@@ -0,0 +1,805 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailureArtifactBuffer = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const zlib = __importStar(require("zlib"));
+const SENTIENCE_API_URL = 'https://api.sentienceapi.com';
+async function writeJsonAtomic(filePath, data) {
+    const tmpPath = `${filePath}.tmp`;
+    await fs_1.default.promises.writeFile(tmpPath, JSON.stringify(data, null, 2));
+    await fs_1.default.promises.rename(tmpPath, filePath);
+}
+/**
+ * Check if ffmpeg is available on the system PATH.
+ */
+function isFfmpegAvailable() {
+    try {
+        const result = (0, child_process_1.spawnSync)('ffmpeg', ['-version'], {
+            timeout: 5000,
+            stdio: 'pipe',
+        });
+        return result.status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get ffmpeg version as a tuple [major, minor] or null if unable to determine.
+ * Used to determine which flags to use (e.g., -vsync vs -fps_mode).
+ */
+function getFfmpegVersion() {
+    try {
+        const result = (0, child_process_1.spawnSync)('ffmpeg', ['-version'], {
+            timeout: 5000,
+            stdio: 'pipe',
+        });
+        if (result.status !== 0) {
+            return null;
+        }
+        const output = result.stdout?.toString('utf-8') || '';
+        // Parse version from output like "ffmpeg version 7.0.1 ..." or "ffmpeg version n7.0.1 ..."
+        const match = output.match(/ffmpeg version [n]?(\d+)\.(\d+)/i);
+        if (match) {
+            return [parseInt(match[1], 10), parseInt(match[2], 10)];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate an MP4 video clip from a directory of frames using ffmpeg.
+ */
+function generateClipFromFrames(framesDir, outputPath, fps = 8) {
+    // Find all frame files and sort them
+    const files = fs_1.default
+        .readdirSync(framesDir)
+        .filter(f => f.startsWith('frame_') && (f.endsWith('.png') || f.endsWith('.jpeg') || f.endsWith('.jpg')))
+        .sort();
+    if (files.length === 0) {
+        console.warn('No frame files found for clip generation');
+        return false;
+    }
+    // Create a temporary file list for ffmpeg concat demuxer
+    // Use relative path (just filename) since we run ffmpeg with cwd=framesDir
+    const listFile = 'frames_list.txt';
+    const listFilePath = path_1.default.join(framesDir, listFile);
+    const frameDuration = 1.0 / fps;
+    try {
+        // Write the frames list file
+        const listContent = files.map(f => `file '${f}'\nduration ${frameDuration}`).join('\n') +
+            `\nfile '${files[files.length - 1]}'`; // ffmpeg concat quirk
+        fs_1.default.writeFileSync(listFilePath, listContent);
+        // Determine which vsync/fps_mode flag to use based on ffmpeg version
+        // -vsync is deprecated in ffmpeg 7.0+, use -fps_mode instead (available since 5.1)
+        const version = getFfmpegVersion();
+        let syncArgs;
+        if (version && (version[0] > 5 || (version[0] === 5 && version[1] >= 1))) {
+            // ffmpeg 5.1+: use -fps_mode
+            syncArgs = ['-fps_mode', 'vfr'];
+        }
+        else {
+            // ffmpeg < 5.1: use legacy -vsync
+            syncArgs = ['-vsync', 'vfr'];
+        }
+        // Run ffmpeg to generate the clip
+        const result = (0, child_process_1.spawnSync)('ffmpeg', [
+            '-y',
+            '-f',
+            'concat',
+            '-safe',
+            '0',
+            '-i',
+            listFile,
+            ...syncArgs,
+            '-pix_fmt',
+            'yuv420p',
+            '-c:v',
+            'libx264',
+            '-crf',
+            '23',
+            outputPath,
+        ], {
+            timeout: 60000, // 1 minute timeout
+            cwd: framesDir,
+            stdio: 'pipe',
+        });
+        if (result.status !== 0) {
+            const stderr = result.stderr?.toString('utf-8').slice(0, 500) ?? '';
+            console.warn(`ffmpeg failed with return code ${result.status}: ${stderr}`);
+            return false;
+        }
+        return fs_1.default.existsSync(outputPath);
+    }
+    catch (err) {
+        console.warn(`Error generating clip: ${err}`);
+        return false;
+    }
+    finally {
+        // Clean up the list file
+        try {
+            fs_1.default.unlinkSync(listFilePath);
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+function redactSnapshotDefaults(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return payload;
+    }
+    const elements = Array.isArray(payload.elements) ? payload.elements : null;
+    if (!elements) {
+        return payload;
+    }
+    const redactedElements = elements.map((el) => {
+        if (!el || typeof el !== 'object')
+            return el;
+        const inputType = String(el.input_type || '').toLowerCase();
+        if (['password', 'email', 'tel'].includes(inputType) && 'value' in el) {
+            return { ...el, value: null, value_redacted: true };
+        }
+        return el;
+    });
+    return { ...payload, elements: redactedElements };
+}
+class FailureArtifactBuffer {
+    constructor(runId, options = {}, timeNow = () => Date.now()) {
+        this.frames = [];
+        this.steps = [];
+        this.persisted = false;
+        this.runId = runId;
+        this.options = {
+            bufferSeconds: options.bufferSeconds ?? 15,
+            captureOnAction: options.captureOnAction ?? true,
+            fps: options.fps ?? 0,
+            persistMode: options.persistMode ?? 'onFail',
+            outputDir: options.outputDir ?? '.sentience/artifacts',
+            onBeforePersist: options.onBeforePersist ?? null,
+            redactSnapshotValues: options.redactSnapshotValues ?? true,
+            clip: {
+                mode: options.clip?.mode ?? 'auto',
+                fps: options.clip?.fps ?? 8,
+                seconds: options.clip?.seconds,
+            },
+        };
+        this.timeNow = timeNow;
+        this.tempDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'sentience-artifacts-'));
+        this.framesDir = path_1.default.join(this.tempDir, 'frames');
+        fs_1.default.mkdirSync(this.framesDir, { recursive: true });
+    }
+    getOptions() {
+        return this.options;
+    }
+    recordStep(action, stepId, stepIndex, url) {
+        this.steps.push({
+            ts: this.timeNow(),
+            action,
+            step_id: stepId,
+            step_index: stepIndex,
+            url,
+        });
+    }
+    async addFrame(image, fmt = 'jpeg') {
+        const ts = this.timeNow();
+        const fileName = `frame_${ts}.${fmt}`;
+        const filePath = path_1.default.join(this.framesDir, fileName);
+        await fs_1.default.promises.writeFile(filePath, image);
+        this.frames.push({ ts, fileName, filePath });
+        this.prune();
+    }
+    frameCount() {
+        return this.frames.length;
+    }
+    prune() {
+        const cutoff = this.timeNow() - this.options.bufferSeconds * 1000;
+        const keep = [];
+        for (const frame of this.frames) {
+            if (frame.ts >= cutoff) {
+                keep.push(frame);
+            }
+            else {
+                try {
+                    fs_1.default.unlinkSync(frame.filePath);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        this.frames = keep;
+    }
+    async persist(reason, status, snapshot, diagnostics, metadata) {
+        if (this.persisted) {
+            return null;
+        }
+        const outDir = this.options.outputDir;
+        await fs_1.default.promises.mkdir(outDir, { recursive: true });
+        const ts = this.timeNow();
+        const runDir = path_1.default.join(outDir, `${this.runId}-${ts}`);
+        const framesOut = path_1.default.join(runDir, 'frames');
+        await fs_1.default.promises.mkdir(framesOut, { recursive: true });
+        for (const frame of this.frames) {
+            await fs_1.default.promises.copyFile(frame.filePath, path_1.default.join(framesOut, frame.fileName));
+        }
+        await writeJsonAtomic(path_1.default.join(runDir, 'steps.json'), this.steps);
+        let snapshotPayload = snapshot;
+        if (snapshotPayload && this.options.redactSnapshotValues) {
+            snapshotPayload = redactSnapshotDefaults(snapshotPayload);
+        }
+        let diagnosticsPayload = diagnostics;
+        let framePaths = this.frames.map(frame => frame.filePath);
+        let dropFrames = false;
+        if (this.options.onBeforePersist) {
+            try {
+                const result = this.options.onBeforePersist({
+                    runId: this.runId,
+                    reason,
+                    status,
+                    snapshot: snapshotPayload,
+                    diagnostics: diagnosticsPayload,
+                    framePaths,
+                    metadata: metadata ?? {},
+                });
+                if (result.snapshot !== undefined) {
+                    snapshotPayload = result.snapshot;
+                }
+                if (result.diagnostics !== undefined) {
+                    diagnosticsPayload = result.diagnostics;
+                }
+                if (result.framePaths) {
+                    framePaths = result.framePaths;
+                }
+                dropFrames = Boolean(result.dropFrames);
+            }
+            catch {
+                dropFrames = true;
+            }
+        }
+        if (!dropFrames) {
+            for (const framePath of framePaths) {
+                if (!fs_1.default.existsSync(framePath)) {
+                    continue;
+                }
+                const fileName = path_1.default.basename(framePath);
+                await fs_1.default.promises.copyFile(framePath, path_1.default.join(framesOut, fileName));
+            }
+        }
+        let snapshotWritten = false;
+        if (snapshotPayload) {
+            await writeJsonAtomic(path_1.default.join(runDir, 'snapshot.json'), snapshotPayload);
+            snapshotWritten = true;
+        }
+        let diagnosticsWritten = false;
+        if (diagnosticsPayload) {
+            await writeJsonAtomic(path_1.default.join(runDir, 'diagnostics.json'), diagnosticsPayload);
+            diagnosticsWritten = true;
+        }
+        // Generate video clip from frames (optional, requires ffmpeg)
+        let clipGenerated = false;
+        const clipOptions = this.options.clip;
+        if (!dropFrames && framePaths.length > 0 && clipOptions.mode !== 'off') {
+            let shouldGenerate = false;
+            if (clipOptions.mode === 'auto') {
+                // Only generate if ffmpeg is available
+                shouldGenerate = isFfmpegAvailable();
+                if (!shouldGenerate) {
+                    // Silent in auto mode - just skip
+                }
+            }
+            else if (clipOptions.mode === 'on') {
+                // Always attempt to generate
+                shouldGenerate = true;
+                if (!isFfmpegAvailable()) {
+                    console.warn("ffmpeg not found on PATH but clip.mode='on'. " +
+                        'Install ffmpeg to generate video clips.');
+                    shouldGenerate = false;
+                }
+            }
+            if (shouldGenerate) {
+                const clipPath = path_1.default.join(runDir, 'failure.mp4');
+                clipGenerated = generateClipFromFrames(framesOut, clipPath, clipOptions.fps ?? 8);
+                if (clipGenerated) {
+                    console.log(`Generated failure clip: ${clipPath}`);
+                }
+                else {
+                    console.warn('Failed to generate video clip');
+                }
+            }
+        }
+        const manifest = {
+            run_id: this.runId,
+            created_at_ms: ts,
+            status,
+            reason,
+            buffer_seconds: this.options.bufferSeconds,
+            frame_count: dropFrames ? 0 : framePaths.length,
+            frames: dropFrames ? [] : framePaths.map(p => ({ file: path_1.default.basename(p), ts: null })),
+            snapshot: snapshotWritten ? 'snapshot.json' : null,
+            diagnostics: diagnosticsWritten ? 'diagnostics.json' : null,
+            clip: clipGenerated ? 'failure.mp4' : null,
+            clip_fps: clipGenerated ? (clipOptions.fps ?? 8) : null,
+            metadata: metadata ?? {},
+            frames_redacted: !dropFrames && Boolean(this.options.onBeforePersist),
+            frames_dropped: dropFrames,
+        };
+        await writeJsonAtomic(path_1.default.join(runDir, 'manifest.json'), manifest);
+        this.persisted = true;
+        return runDir;
+    }
+    async cleanup() {
+        await fs_1.default.promises.rm(this.tempDir, { recursive: true, force: true });
+    }
+    /**
+     * Upload persisted artifacts to cloud storage.
+     *
+     * This method uploads all artifacts from a persisted directory to cloud storage
+     * using presigned URLs from the gateway. It follows the same pattern as trace
+     * screenshot uploads.
+     *
+     * @param apiKey - Sentience API key for authentication
+     * @param apiUrl - Sentience API base URL (default: https://api.sentienceapi.com)
+     * @param persistedDir - Path to persisted artifacts directory. If undefined, uses the
+     *                       most recent persist() output directory.
+     * @param logger - Optional logger for progress/error messages
+     * @returns artifact_index_key on success, null on failure
+     *
+     * @example
+     * const buf = new FailureArtifactBuffer('run-123', options);
+     * await buf.addFrame(screenshotBytes);
+     * const runDir = await buf.persist('assertion failed', 'failure');
+     * const artifactKey = await buf.uploadToCloud('sk-...');
+     * // artifactKey can be passed to /v1/traces/complete
+     */
+    async uploadToCloud(apiKey, apiUrl, persistedDir, logger) {
+        const baseUrl = apiUrl || SENTIENCE_API_URL;
+        // Determine which directory to upload
+        let targetDir = persistedDir;
+        if (!targetDir) {
+            // Find most recent persisted directory
+            const outputDir = this.options.outputDir;
+            if (!fs_1.default.existsSync(outputDir)) {
+                logger?.warn('No artifacts directory found');
+                return null;
+            }
+            // Look for directories matching runId pattern
+            const entries = fs_1.default.readdirSync(outputDir, { withFileTypes: true });
+            const matchingDirs = entries
+                .filter(e => e.isDirectory() && e.name.startsWith(this.runId))
+                .map(e => ({
+                name: e.name,
+                path: path_1.default.join(outputDir, e.name),
+                mtime: fs_1.default.statSync(path_1.default.join(outputDir, e.name)).mtimeMs,
+            }))
+                .sort((a, b) => b.mtime - a.mtime);
+            if (matchingDirs.length === 0) {
+                logger?.warn(`No persisted artifacts found for runId=${this.runId}`);
+                return null;
+            }
+            targetDir = matchingDirs[0].path;
+        }
+        if (!fs_1.default.existsSync(targetDir)) {
+            logger?.warn(`Artifacts directory not found: ${targetDir}`);
+            return null;
+        }
+        // Read manifest to understand what files need uploading
+        const manifestPath = path_1.default.join(targetDir, 'manifest.json');
+        if (!fs_1.default.existsSync(manifestPath)) {
+            logger?.warn('manifest.json not found in artifacts directory');
+            return null;
+        }
+        const manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        // Build list of artifacts to upload
+        const artifacts = this.collectArtifactsForUpload(targetDir, manifest);
+        if (artifacts.length === 0) {
+            logger?.warn('No artifacts to upload');
+            return null;
+        }
+        logger?.info(`Uploading ${artifacts.length} artifact(s) to cloud`);
+        // Request presigned URLs from gateway
+        const uploadUrls = await this.requestArtifactUrls(apiKey, baseUrl, artifacts, logger);
+        if (!uploadUrls) {
+            return null;
+        }
+        // Upload artifacts in parallel
+        const artifactIndexKey = await this.uploadArtifacts(artifacts, uploadUrls, logger);
+        if (artifactIndexKey) {
+            // Report completion to gateway
+            await this.completeArtifacts(apiKey, baseUrl, artifactIndexKey, artifacts, logger);
+        }
+        return artifactIndexKey;
+    }
+    collectArtifactsForUpload(persistedDir, manifest) {
+        const artifacts = [];
+        // Core JSON artifacts
+        const jsonFiles = ['manifest.json', 'steps.json'];
+        if (manifest.snapshot) {
+            jsonFiles.push('snapshot.json');
+        }
+        if (manifest.diagnostics) {
+            jsonFiles.push('diagnostics.json');
+        }
+        for (const filename of jsonFiles) {
+            const filePath = path_1.default.join(persistedDir, filename);
+            if (fs_1.default.existsSync(filePath)) {
+                artifacts.push({
+                    name: filename,
+                    sizeBytes: fs_1.default.statSync(filePath).size,
+                    contentType: 'application/json',
+                    filePath,
+                });
+            }
+        }
+        // Video clip
+        if (manifest.clip) {
+            const clipPath = path_1.default.join(persistedDir, 'failure.mp4');
+            if (fs_1.default.existsSync(clipPath)) {
+                artifacts.push({
+                    name: 'failure.mp4',
+                    sizeBytes: fs_1.default.statSync(clipPath).size,
+                    contentType: 'video/mp4',
+                    filePath: clipPath,
+                });
+            }
+        }
+        // Frames
+        const framesDir = path_1.default.join(persistedDir, 'frames');
+        if (fs_1.default.existsSync(framesDir)) {
+            const frameFiles = fs_1.default.readdirSync(framesDir).sort();
+            for (const frameFile of frameFiles) {
+                const ext = path_1.default.extname(frameFile).toLowerCase();
+                if (['.jpeg', '.jpg', '.png'].includes(ext)) {
+                    const framePath = path_1.default.join(framesDir, frameFile);
+                    const contentType = ext === '.png' ? 'image/png' : 'image/jpeg';
+                    artifacts.push({
+                        name: `frames/${frameFile}`,
+                        sizeBytes: fs_1.default.statSync(framePath).size,
+                        contentType,
+                        filePath: framePath,
+                    });
+                }
+            }
+        }
+        return artifacts;
+    }
+    async requestArtifactUrls(apiKey, apiUrl, artifacts, logger) {
+        try {
+            // Prepare request payload (exclude local path)
+            const artifactsPayload = artifacts.map(a => ({
+                name: a.name,
+                size_bytes: a.sizeBytes,
+                content_type: a.contentType,
+            }));
+            const body = JSON.stringify({
+                run_id: this.runId,
+                artifacts: artifactsPayload,
+            });
+            return new Promise(resolve => {
+                const url = new url_1.URL(`${apiUrl}/v1/traces/artifacts/init`);
+                const protocol = url.protocol === 'https:' ? https : http;
+                const options = {
+                    hostname: url.hostname,
+                    port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                    path: url.pathname + url.search,
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(body),
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                    timeout: 30000,
+                };
+                const req = protocol.request(options, res => {
+                    let data = '';
+                    res.on('data', chunk => {
+                        data += chunk;
+                    });
+                    res.on('end', () => {
+                        if (res.statusCode === 200) {
+                            try {
+                                resolve(JSON.parse(data));
+                            }
+                            catch {
+                                logger?.warn('Failed to parse artifact upload URLs response');
+                                resolve(null);
+                            }
+                        }
+                        else {
+                            logger?.warn(`Failed to get artifact upload URLs: HTTP ${res.statusCode}`);
+                            resolve(null);
+                        }
+                    });
+                });
+                req.on('error', error => {
+                    logger?.error(`Error requesting artifact upload URLs: ${error.message}`);
+                    resolve(null);
+                });
+                req.on('timeout', () => {
+                    req.destroy();
+                    logger?.warn('Artifact URLs request timeout');
+                    resolve(null);
+                });
+                req.write(body);
+                req.end();
+            });
+        }
+        catch (error) {
+            logger?.error(`Error requesting artifact upload URLs: ${error.message}`);
+            return null;
+        }
+    }
+    async uploadArtifacts(artifacts, uploadUrls, logger) {
+        const urlMap = new Map();
+        for (const item of uploadUrls.upload_urls) {
+            urlMap.set(item.name, item);
+        }
+        const indexUpload = uploadUrls.artifact_index_upload;
+        const storageKeys = new Map();
+        const uploadPromises = [];
+        for (const artifact of artifacts) {
+            const urlInfo = urlMap.get(artifact.name);
+            if (!urlInfo) {
+                continue;
+            }
+            const uploadPromise = this.uploadSingleArtifact(artifact, urlInfo, logger).then(success => ({
+                name: artifact.name,
+                success,
+            }));
+            uploadPromises.push(uploadPromise);
+        }
+        // Wait for all uploads
+        const results = await Promise.all(uploadPromises);
+        let uploadedCount = 0;
+        const failedNames = [];
+        for (const result of results) {
+            if (result.success) {
+                uploadedCount++;
+                const urlInfo = urlMap.get(result.name);
+                if (urlInfo?.storage_key) {
+                    storageKeys.set(result.name, urlInfo.storage_key);
+                }
+            }
+            else {
+                failedNames.push(result.name);
+            }
+        }
+        if (uploadedCount === artifacts.length) {
+            logger?.info(`All ${uploadedCount} artifacts uploaded successfully`);
+        }
+        else {
+            logger?.warn(`Uploaded ${uploadedCount}/${artifacts.length} artifacts. Failed: ${failedNames.join(', ')}`);
+        }
+        // Upload artifact index file
+        if (indexUpload && uploadedCount > 0) {
+            return this.uploadArtifactIndex(artifacts, storageKeys, indexUpload, logger);
+        }
+        return null;
+    }
+    async uploadSingleArtifact(artifact, urlInfo, logger) {
+        try {
+            const data = fs_1.default.readFileSync(artifact.filePath);
+            return new Promise(resolve => {
+                const url = new url_1.URL(urlInfo.upload_url);
+                const protocol = url.protocol === 'https:' ? https : http;
+                const options = {
+                    hostname: url.hostname,
+                    port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                    path: url.pathname + url.search,
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': artifact.contentType,
+                        'Content-Length': data.length,
+                    },
+                    timeout: 60000,
+                };
+                const req = protocol.request(options, res => {
+                    res.on('data', () => { });
+                    res.on('end', () => {
+                        if (res.statusCode === 200) {
+                            resolve(true);
+                        }
+                        else {
+                            logger?.warn(`Artifact ${artifact.name} upload failed: HTTP ${res.statusCode}`);
+                            resolve(false);
+                        }
+                    });
+                });
+                req.on('error', error => {
+                    logger?.warn(`Artifact ${artifact.name} upload error: ${error.message}`);
+                    resolve(false);
+                });
+                req.on('timeout', () => {
+                    req.destroy();
+                    logger?.warn(`Artifact ${artifact.name} upload timeout`);
+                    resolve(false);
+                });
+                req.write(data);
+                req.end();
+            });
+        }
+        catch (error) {
+            logger?.warn(`Artifact ${artifact.name} upload error: ${error.message}`);
+            return false;
+        }
+    }
+    async uploadArtifactIndex(artifacts, storageKeys, indexUpload, logger) {
+        try {
+            // Build index content
+            const indexData = {
+                run_id: this.runId,
+                created_at_ms: Date.now(),
+                artifacts: artifacts
+                    .filter(a => storageKeys.has(a.name))
+                    .map(a => ({
+                    name: a.name,
+                    storage_key: storageKeys.get(a.name) || '',
+                    content_type: a.contentType,
+                })),
+            };
+            // Compress and upload
+            const indexJson = Buffer.from(JSON.stringify(indexData, null, 2), 'utf-8');
+            const compressed = zlib.gzipSync(indexJson);
+            return new Promise(resolve => {
+                const url = new url_1.URL(indexUpload.upload_url);
+                const protocol = url.protocol === 'https:' ? https : http;
+                const options = {
+                    hostname: url.hostname,
+                    port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                    path: url.pathname + url.search,
+                    method: 'PUT',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Encoding': 'gzip',
+                        'Content-Length': compressed.length,
+                    },
+                    timeout: 30000,
+                };
+                const req = protocol.request(options, res => {
+                    res.on('data', () => { });
+                    res.on('end', () => {
+                        if (res.statusCode === 200) {
+                            logger?.info('Artifact index uploaded successfully');
+                            resolve(indexUpload.storage_key || '');
+                        }
+                        else {
+                            logger?.warn(`Artifact index upload failed: HTTP ${res.statusCode}`);
+                            resolve(null);
+                        }
+                    });
+                });
+                req.on('error', error => {
+                    logger?.warn(`Error uploading artifact index: ${error.message}`);
+                    resolve(null);
+                });
+                req.on('timeout', () => {
+                    req.destroy();
+                    logger?.warn('Artifact index upload timeout');
+                    resolve(null);
+                });
+                req.write(compressed);
+                req.end();
+            });
+        }
+        catch (error) {
+            logger?.warn(`Error uploading artifact index: ${error.message}`);
+            return null;
+        }
+    }
+    async completeArtifacts(apiKey, apiUrl, artifactIndexKey, artifacts, logger) {
+        try {
+            // Calculate stats
+            const totalSize = artifacts.reduce((sum, a) => sum + a.sizeBytes, 0);
+            const framesArtifacts = artifacts.filter(a => a.name.startsWith('frames/'));
+            const framesTotal = framesArtifacts.reduce((sum, a) => sum + a.sizeBytes, 0);
+            // Get individual file sizes
+            const manifestSize = artifacts.find(a => a.name === 'manifest.json')?.sizeBytes || 0;
+            const snapshotSize = artifacts.find(a => a.name === 'snapshot.json')?.sizeBytes || 0;
+            const diagnosticsSize = artifacts.find(a => a.name === 'diagnostics.json')?.sizeBytes || 0;
+            const stepsSize = artifacts.find(a => a.name === 'steps.json')?.sizeBytes || 0;
+            const clipSize = artifacts.find(a => a.name === 'failure.mp4')?.sizeBytes || 0;
+            const body = JSON.stringify({
+                run_id: this.runId,
+                artifact_index_key: artifactIndexKey,
+                stats: {
+                    manifest_size_bytes: manifestSize,
+                    snapshot_size_bytes: snapshotSize,
+                    diagnostics_size_bytes: diagnosticsSize,
+                    steps_size_bytes: stepsSize,
+                    clip_size_bytes: clipSize,
+                    frames_total_size_bytes: framesTotal,
+                    frames_count: framesArtifacts.length,
+                    total_artifact_size_bytes: totalSize,
+                },
+            });
+            return new Promise(resolve => {
+                const url = new url_1.URL(`${apiUrl}/v1/traces/artifacts/complete`);
+                const protocol = url.protocol === 'https:' ? https : http;
+                const options = {
+                    hostname: url.hostname,
+                    port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                    path: url.pathname + url.search,
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.byteLength(body),
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                    timeout: 10000,
+                };
+                const req = protocol.request(options, res => {
+                    res.on('data', () => { });
+                    res.on('end', () => {
+                        if (res.statusCode === 200) {
+                            logger?.info('Artifact completion reported to gateway');
+                        }
+                        else {
+                            logger?.warn(`Failed to report artifact completion: HTTP ${res.statusCode}`);
+                        }
+                        resolve();
+                    });
+                });
+                req.on('error', error => {
+                    logger?.warn(`Error reporting artifact completion: ${error.message}`);
+                    resolve();
+                });
+                req.on('timeout', () => {
+                    req.destroy();
+                    logger?.warn('Artifact completion request timeout');
+                    resolve();
+                });
+                req.write(body);
+                req.end();
+            });
+        }
+        catch (error) {
+            logger?.warn(`Error reporting artifact completion: ${error.message}`);
+        }
+    }
+}
+exports.FailureArtifactBuffer = FailureArtifactBuffer;
+//# sourceMappingURL=failure-artifacts.js.map