@output.ai/cli 0.3.0-dev.pr156.c8e7f40 → 0.3.1-dev.pr156.0

package/dist/utils/s3_downloader.js

@@ -0,0 +1,154 @@
+import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { existsSync } from 'node:fs';
+export class S3Downloader {
+    s3Client = null;
+    cacheDir;
+    constructor(options = {}) {
+        this.cacheDir = options.cacheDir || path.join(process.cwd(), '.output', 'traces');
+        this.initializeS3Client();
+    }
+    initializeS3Client() {
+        const region = process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || 'us-east-1';
+        const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
+        const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+        if (!accessKeyId || !secretAccessKey) {
+            // S3 client not available without credentials
+            this.s3Client = null;
+            return;
+        }
+        this.s3Client = new S3Client({
+            region,
+            credentials: {
+                accessKeyId,
+                secretAccessKey
+            }
+        });
+    }
+    /**
+     * Parse S3 URL to extract bucket and key
+     * Supports formats:
+     * - https://bucket.s3.amazonaws.com/path/to/file
+     * - https://bucket.s3.region.amazonaws.com/path/to/file
+     * - s3://bucket/path/to/file
+     */
+    parseS3Url(url) {
+        // Handle s3:// protocol
+        if (url.startsWith('s3://')) {
+            const withoutProtocol = url.slice(5);
+            const firstSlash = withoutProtocol.indexOf('/');
+            if (firstSlash === -1) {
+                throw new Error(`Invalid S3 URL format: ${url}`);
+            }
+            return {
+                bucket: withoutProtocol.substring(0, firstSlash),
+                key: withoutProtocol.substring(firstSlash + 1)
+            };
+        }
+        // Handle https:// URLs
+        if (url.startsWith('https://')) {
+            const urlObj = new URL(url);
+            const hostname = urlObj.hostname;
+            // Extract bucket from hostname
+            // Format: bucket.s3.amazonaws.com or bucket.s3.region.amazonaws.com
+            const s3Match = hostname.match(/^([^.]+)\.s3(?:\.[^.]+)?\.amazonaws\.com$/);
+            if (!s3Match) {
+                throw new Error(`Invalid S3 URL format: ${url}`);
+            }
+            const bucket = s3Match[1];
+            const key = urlObj.pathname.startsWith('/') ? urlObj.pathname.slice(1) : urlObj.pathname;
+            return { bucket, key };
+        }
+        throw new Error(`Unsupported S3 URL format: ${url}`);
+    }
+    /**
+     * Get cached file path for a given S3 URL
+     */
+    getCachePath(url) {
+        const { key } = this.parseS3Url(url);
+        // Use the last part of the key as filename to preserve the original name
+        const filename = path.basename(key);
+        return path.join(this.cacheDir, filename);
+    }
+    /**
+     * Download a file from S3
+     */
+    async download(s3Url, options = {}) {
+        if (!this.s3Client) {
+            throw new Error('AWS credentials not configured. Please set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables.');
+        }
+        // Check cache first
+        const cachePath = this.getCachePath(s3Url);
+        if (!options.forceDownload && existsSync(cachePath)) {
+            const content = await fs.readFile(cachePath, 'utf-8');
+            return content;
+        }
+        // Parse S3 URL
+        const { bucket, key } = this.parseS3Url(s3Url);
+        try {
+            // Download from S3
+            const command = new GetObjectCommand({
+                Bucket: bucket,
+                Key: key
+            });
+            const response = await this.s3Client.send(command);
+            if (!response.Body) {
+                throw new Error('Empty response from S3');
+            }
+            // Convert stream to string
+            const bodyContents = await response.Body.transformToString();
+            // Cache the file
+            await this.ensureCacheDir();
+            await fs.writeFile(cachePath, bodyContents, 'utf-8');
+            return bodyContents;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to download from S3: ${error.message}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check if S3 client is available (credentials configured)
+     */
+    isAvailable() {
+        return this.s3Client !== null;
+    }
+    /**
+     * Ensure cache directory exists
+     */
+    async ensureCacheDir() {
+        await fs.mkdir(this.cacheDir, { recursive: true });
+    }
+    /**
+     * Clear the cache directory
+     */
+    async clearCache() {
+        if (existsSync(this.cacheDir)) {
+            await fs.rm(this.cacheDir, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Get the size of the cache directory in bytes
+     */
+    async getCacheSize() {
+        if (!existsSync(this.cacheDir)) {
+            return 0;
+        }
+        const files = await fs.readdir(this.cacheDir);
+        // eslint-disable-next-line no-restricted-syntax
+        let totalSize = 0;
+        for (const file of files) {
+            const filePath = path.join(this.cacheDir, file);
+            const stats = await fs.stat(filePath);
+            totalSize += stats.size;
+        }
+        return totalSize;
+    }
+}
+/**
+ * Create a singleton instance for convenience
+ */
+export const s3Downloader = new S3Downloader();

package/dist/utils/trace_formatter.d.ts

@@ -1,27 +1,61 @@
-/**
- * Format duration in human-readable format
- */
-export declare function formatDuration(ms: number): string;
-/**
- * Format trace data based on the requested format
- */
-export declare function format(traceData: string | object, outputFormat?: 'json' | 'text'): string;
-/**
- * Get summary statistics from trace
- */
-export declare function getSummary(traceData: string | object): {
-    totalDuration: number;
-    totalEvents: number;
-    totalSteps: number;
-    totalActivities: number;
-    hasErrors: boolean;
-};
-/**
- * Display trace tree with debug command formatting style
- */
-export declare function displayDebugTree(node: any): string;
-export declare const traceFormatter: {
-    format: typeof format;
-    getSummary: typeof getSummary;
-    displayDebugTree: typeof displayDebugTree;
-};
+export declare class TraceFormatter {
+    /**
+     * Format trace data based on the requested format
+     */
+    format(traceData: string | object, format?: 'json' | 'text'): string;
+    /**
+     * Format trace as human-readable text with tree structure
+     */
+    private formatAsText;
+    /**
+     * Format the header with workflow information
+     */
+    private formatHeader;
+    /**
+     * Format events as a timeline table
+     */
+    private formatEventsTable;
+    /**
+     * Format trace as a tree structure
+     */
+    private formatTree;
+    /**
+     * Get a readable name for an event
+     */
+    private getEventName;
+    /**
+     * Format the phase with icons
+     */
+    private formatPhase;
+    /**
+     * Format duration in human-readable format
+     */
+    private formatDuration;
+    /**
+     * Format error for display
+     */
+    private formatError;
+    /**
+     * Format details for table display
+     */
+    private formatDetails;
+    /**
+     * Format details for tree display
+     */
+    private formatTreeDetails;
+    /**
+     * Truncate long values for display
+     */
+    private truncateValue;
+    /**
+     * Get summary statistics from trace
+     */
+    getSummary(traceData: string | object): {
+        totalDuration: number;
+        totalEvents: number;
+        totalSteps: number;
+        totalActivities: number;
+        hasErrors: boolean;
+    };
+}
+export declare const traceFormatter: TraceFormatter;