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

package/dist/commands/workflow/debug.test.js

@@ -1,107 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock the API
-vi.mock('../../api/generated/api.js', () => ({
-    getWorkflowIdOutput: vi.fn()
-}));
-// Mock the utilities
-vi.mock('../../utils/s3_downloader.js', () => ({
-    s3Downloader: {
-        isAvailable: vi.fn(),
-        download: vi.fn(),
-        clearCache: vi.fn(),
-        getCacheSize: vi.fn()
-    },
-    S3Downloader: vi.fn()
-}));
-vi.mock('../../utils/trace_formatter.js', () => ({
-    traceFormatter: {
-        format: vi.fn(),
-        getSummary: vi.fn()
-    },
-    TraceFormatter: vi.fn()
-}));
-// Note: fs operations are mocked but not used in simplified tests
-// Real OCLIF testing would require complex framework initialization
-describe('workflow debug command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('command definition', () => {
-        it('should export a valid OCLIF command', async () => {
-            const WorkflowDebug = (await import('./debug.js')).default;
-            expect(WorkflowDebug).toBeDefined();
-            expect(WorkflowDebug.description).toContain('Get and display workflow execution trace for debugging');
-            expect(WorkflowDebug.args).toHaveProperty('workflowId');
-            expect(WorkflowDebug.flags).toHaveProperty('format');
-            expect(WorkflowDebug.flags).toHaveProperty('remote');
-            expect(WorkflowDebug.flags).toHaveProperty('download-dir');
-            expect(WorkflowDebug.flags).toHaveProperty('open');
-            expect(WorkflowDebug.flags).toHaveProperty('force-download');
-        });
-        it('should have correct flag configuration', async () => {
-            const WorkflowDebug = (await import('./debug.js')).default;
-            // Format flag
-            expect(WorkflowDebug.flags.format.options).toEqual(['json', 'text']);
-            expect(WorkflowDebug.flags.format.default).toBe('text');
-            // Remote flag
-            expect(WorkflowDebug.flags.remote.default).toBe(false);
-            // Download dir flag
-            expect(WorkflowDebug.flags['download-dir'].default).toContain('.output/traces');
-            // Open flag
-            expect(WorkflowDebug.flags.open.default).toBe(false);
-            // Force download flag
-            expect(WorkflowDebug.flags['force-download'].default).toBe(false);
-        });
-        it('should have correct examples', async () => {
-            const WorkflowDebug = (await import('./debug.js')).default;
-            expect(WorkflowDebug.examples).toBeDefined();
-            expect(WorkflowDebug.examples.length).toBeGreaterThan(0);
-        });
-    });
-    describe('run method', () => {
-        // Variables will be initialized in beforeEach
-        // eslint-disable-next-line init-declarations, no-restricted-syntax, @typescript-eslint/no-explicit-any
-        let WorkflowDebug;
-        // eslint-disable-next-line init-declarations, no-restricted-syntax, @typescript-eslint/no-explicit-any
-        let getWorkflowIdOutput;
-        beforeEach(async () => {
-            const apiModule = await import('../../api/generated/api.js');
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            getWorkflowIdOutput = apiModule.getWorkflowIdOutput;
-            WorkflowDebug = (await import('./debug.js')).default;
-        });
-        it('should fetch and display local trace when available', async () => {
-            // This test requires OCLIF framework initialization which is complex to mock
-            // The functionality is tested through manual testing and the build process
-            expect(true).toBe(true);
-        });
-        it('should download and display remote trace when local not available', async () => {
-            // This test requires OCLIF framework initialization which is complex to mock
-            // The functionality is tested through manual testing and the build process
-            expect(true).toBe(true);
-        });
-        it('should prefer remote trace when --remote flag is set', async () => {
-            // This test requires OCLIF framework initialization which is complex to mock
-            // The functionality is tested through manual testing and the build process
-            expect(true).toBe(true);
-        });
-        it('should handle workflow not found error', async () => {
-            getWorkflowIdOutput.mockRejectedValue({ response: { status: 404 } });
-            const cmd = new WorkflowDebug(['non-existent-workflow'], {});
-            cmd.error = vi.fn();
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            await cmd.catch({ response: { status: 404 } });
-            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Workflow not found'), expect.any(Object));
-        });
-        it('should handle missing AWS credentials', async () => {
-            // This test requires OCLIF framework initialization which is complex to mock
-            // The functionality is tested through manual testing and the build process
-            expect(true).toBe(true);
-        });
-        it('should save trace file when --open flag is set', async () => {
-            // This test requires OCLIF framework initialization which is complex to mock
-            // The functionality is tested through manual testing and the build process
-            expect(true).toBe(true);
-        });
-    });
-});

package/dist/commands/workflow/output.test.js

@@ -1,23 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../api/generated/api.js', () => ({
-    getWorkflowIdOutput: vi.fn()
-}));
-describe('workflow output command', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('command definition', () => {
-        it('should export a valid OCLIF command', async () => {
-            const WorkflowOutput = (await import('./output.js')).default;
-            expect(WorkflowOutput).toBeDefined();
-            expect(WorkflowOutput.description).toContain('Get workflow execution output');
-            expect(WorkflowOutput.args).toHaveProperty('workflowId');
-            expect(WorkflowOutput.flags).toHaveProperty('format');
-        });
-        it('should have correct flag configuration', async () => {
-            const WorkflowOutput = (await import('./output.js')).default;
-            expect(WorkflowOutput.flags.format.options).toEqual(['json', 'text']);
-            expect(WorkflowOutput.flags.format.default).toBe('text');
-        });
-    });
-});

package/dist/utils/s3_downloader.d.ts

@@ -1,49 +0,0 @@
-interface S3DownloadOptions {
-    cacheDir?: string;
-    forceDownload?: boolean;
-}
-export declare class S3Downloader {
-    private s3Client;
-    private cacheDir;
-    constructor(options?: S3DownloadOptions);
-    private initializeS3Client;
-    /**
-     * 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
-     */
-    private parseS3Url;
-    /**
-     * Get cached file path for a given S3 URL
-     */
-    private getCachePath;
-    /**
-     * Download a file from S3
-     */
-    download(s3Url: string, options?: {
-        forceDownload?: boolean;
-    }): Promise<string>;
-    /**
-     * Check if S3 client is available (credentials configured)
-     */
-    isAvailable(): boolean;
-    /**
-     * Ensure cache directory exists
-     */
-    private ensureCacheDir;
-    /**
-     * Clear the cache directory
-     */
-    clearCache(): Promise<void>;
-    /**
-     * Get the size of the cache directory in bytes
-     */
-    getCacheSize(): Promise<number>;
-}
-/**
- * Create a singleton instance for convenience
- */
-export declare const s3Downloader: S3Downloader;
-export {};

package/dist/utils/s3_downloader.js

@@ -1,154 +0,0 @@
-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();