bazaar.it 0.1.0 → 0.2.1

package/dist/commands/media.js

@@ -0,0 +1,362 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { basename, extname } from 'path';
+import { loadConfig, hasAuth, getProjectId } from '../lib/config.js';
+import { apiRequest, uploadMedia } from '../lib/api.js';
+import { error, output, table } from '../lib/output.js';
+/**
+ * Format file size in human-readable format
+ */
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+/**
+ * Determine file type from extension
+ */
+function getFileType(filename) {
+    const ext = extname(filename).toLowerCase().slice(1);
+    const imageExts = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'avif', 'heic', 'heif', 'tiff', 'bmp', 'svg'];
+    const videoExts = ['mp4', 'webm', 'mov', 'avi', 'mkv', 'm4v', 'wmv', 'flv'];
+    const audioExts = ['mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a', 'wma'];
+    if (imageExts.includes(ext))
+        return 'image';
+    if (videoExts.includes(ext))
+        return 'video';
+    if (audioExts.includes(ext))
+        return 'audio';
+    return 'unknown';
+}
+/**
+ * Get MIME type from filename
+ */
+function getMimeType(filename) {
+    const ext = extname(filename).toLowerCase().slice(1);
+    const mimeTypes = {
+        // Images
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        png: 'image/png',
+        gif: 'image/gif',
+        webp: 'image/webp',
+        avif: 'image/avif',
+        heic: 'image/heic',
+        heif: 'image/heif',
+        tiff: 'image/tiff',
+        bmp: 'image/bmp',
+        svg: 'image/svg+xml',
+        // Videos
+        mp4: 'video/mp4',
+        webm: 'video/webm',
+        mov: 'video/quicktime',
+        avi: 'video/x-msvideo',
+        mkv: 'video/x-matroska',
+        m4v: 'video/x-m4v',
+        wmv: 'video/x-ms-wmv',
+        flv: 'video/x-flv',
+        // Audio
+        mp3: 'audio/mpeg',
+        wav: 'audio/wav',
+        ogg: 'audio/ogg',
+        flac: 'audio/flac',
+        aac: 'audio/aac',
+        m4a: 'audio/mp4',
+        wma: 'audio/x-ms-wma',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+}
+export const mediaCommand = new Command('media')
+    .description('Manage media files in your project');
+// Upload subcommand
+mediaCommand
+    .command('upload <file>')
+    .description('Upload an image, video, or audio file to the media library')
+    .option('--name <name>', 'Custom name for the uploaded file')
+    .action(async (filePath, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'AUTH_MISSING',
+                message: 'Not authenticated',
+                category: 'auth',
+                retryable: false,
+                transient: false,
+                exitCode: 13,
+                suggestion: 'Run: baz auth login <api-key>',
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error('Not authenticated', 'Run: baz auth login <api-key>');
+        }
+        process.exit(13);
+    }
+    // Get project ID
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'VALIDATION',
+                message: err.message,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 64,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(64);
+    }
+    // Validate file exists
+    if (!existsSync(filePath)) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'NOT_FOUND',
+                message: `File not found: ${filePath}`,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 64,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(`File not found: ${filePath}`);
+        }
+        process.exit(64);
+    }
+    // Get file info
+    const stats = statSync(filePath);
+    const filename = options.name || basename(filePath);
+    const fileType = getFileType(filePath);
+    const mimeType = getMimeType(filePath);
+    // Validate file type
+    if (fileType === 'unknown') {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'VALIDATION',
+                message: `Unsupported file type: ${extname(filePath)}`,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 64,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(`Unsupported file type: ${extname(filePath)}`);
+            console.log(chalk.gray('\nSupported formats:'));
+            console.log(chalk.gray('  Images: jpg, png, gif, webp, avif, heic'));
+            console.log(chalk.gray('  Videos: mp4, webm, mov, avi, mkv'));
+            console.log(chalk.gray('  Audio:  mp3, wav, ogg, flac, aac, m4a'));
+        }
+        process.exit(64);
+    }
+    // Check file size limits
+    const maxSizes = {
+        image: 50 * 1024 * 1024, // 50MB
+        video: 2 * 1024 * 1024 * 1024, // 2GB
+        audio: 500 * 1024 * 1024, // 500MB
+    };
+    if (stats.size > maxSizes[fileType]) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'VALIDATION',
+                message: `File too large: ${formatSize(stats.size)}`,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 64,
+                details: `Maximum size for ${fileType}: ${formatSize(maxSizes[fileType])}`,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(`File too large: ${formatSize(stats.size)}`);
+            console.log(chalk.gray(`Maximum size for ${fileType}: ${formatSize(maxSizes[fileType])}`));
+        }
+        process.exit(64);
+    }
+    // Show upload info
+    if (!globalOpts.json) {
+        console.log(chalk.cyan(`Uploading ${fileType}:`), chalk.white(filename));
+        console.log(chalk.gray(`  Size: ${formatSize(stats.size)}`));
+        console.log(chalk.gray(`  Type: ${mimeType}`));
+        console.log(chalk.gray(`  Project: ${projectId}`));
+        console.log();
+    }
+    const spinner = ora('Uploading...').start();
+    try {
+        const buffer = readFileSync(filePath);
+        const result = await uploadMedia(config, {
+            projectId,
+            buffer,
+            filename,
+            mimeType,
+        });
+        spinner.succeed('Upload complete');
+        if (globalOpts.json) {
+            output(result, { json: true });
+        }
+        else {
+            console.log();
+            console.log(chalk.green('┌' + '─'.repeat(48) + '┐'));
+            console.log(chalk.green('│') + chalk.green.bold(' ✓ File uploaded successfully').padEnd(48) + chalk.green('│'));
+            console.log(chalk.green('└' + '─'.repeat(48) + '┘'));
+            console.log();
+            console.log(chalk.gray('URL:'), chalk.cyan(result.url));
+            console.log(chalk.gray('Key:'), chalk.dim(result.key));
+            console.log();
+            console.log(chalk.dim('Use this URL in your prompts to reference the file.'));
+        }
+    }
+    catch (err) {
+        spinner.fail('Upload failed');
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'UNKNOWN',
+                message: err.message,
+                category: 'fatal',
+                retryable: false,
+                transient: false,
+                exitCode: 1,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(1);
+    }
+});
+// List subcommand
+mediaCommand
+    .command('list')
+    .description('List uploaded media files for the active project')
+    .option('--type <type>', 'Filter by type: image, video, audio, logo')
+    .option('--limit <n>', 'Max items to show', '50')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'AUTH_MISSING',
+                message: 'Not authenticated',
+                category: 'auth',
+                retryable: false,
+                transient: false,
+                exitCode: 13,
+                suggestion: 'Run: baz auth login <api-key>',
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error('Not authenticated', 'Run: baz auth login <api-key>');
+        }
+        process.exit(13);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'VALIDATION',
+                message: err.message,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 64,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(64);
+    }
+    const spinner = globalOpts.json ? null : ora('Fetching media...').start();
+    try {
+        const result = await apiRequest(config, 'media.getMediaContext', { projectId });
+        spinner?.stop();
+        let items = result.allMedia || [];
+        // Filter by type
+        if (options.type) {
+            const filterType = options.type.toLowerCase();
+            items = items.filter(m => m.type === filterType);
+        }
+        // Apply limit
+        const limit = parseInt(options.limit, 10) || 50;
+        items = items.slice(0, limit);
+        if (globalOpts.json) {
+            const lean = items.map(m => ({
+                id: m.id,
+                url: m.url,
+                type: m.type,
+                originalName: m.originalName || null,
+                fileSize: m.fileSize || null,
+                duration: m.duration || null,
+                tags: m.tags || [],
+            }));
+            output(lean, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        if (items.length === 0) {
+            console.log(chalk.gray('No media files found.'));
+            console.log(chalk.gray('Upload files with: baz media upload <file>'));
+            return;
+        }
+        console.log(`Media Files (${items.length} items)`);
+        console.log();
+        const rows = items.map(m => {
+            const name = m.originalName || '—';
+            const size = m.fileSize ? formatSize(m.fileSize) : '—';
+            const tags = (m.tags || []).slice(0, 3).join(', ') || '—';
+            return [m.type, name.length > 30 ? name.slice(0, 27) + '...' : name, size, tags];
+        });
+        table(['Type', 'Name', 'Size', 'Tags'], rows);
+    }
+    catch (err) {
+        spinner?.stop();
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'UNKNOWN',
+                message: err.message,
+                category: 'fatal',
+                retryable: false,
+                transient: false,
+                exitCode: 1,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(1);
+    }
+});

package/dist/commands/project.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const projectCommand: Command;