bazaar.it 0.1.0 → 0.2.0

package/dist/commands/export.js

@@ -0,0 +1,360 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, hasAuth, getProjectId } from '../lib/config.js';
+import { apiRequest, ApiError } from '../lib/api.js';
+import { success, error, output } from '../lib/output.js';
+function exitExportAuthError(globalOpts) {
+    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>',
+            continue: false,
+        }, { json: true, compact: globalOpts.compact });
+    }
+    else {
+        error('Not authenticated', 'Run: baz auth login <api-key>');
+    }
+    process.exit(13);
+}
+export const exportCommand = new Command('export')
+    .description('Export video from active project');
+/**
+ * baz export start
+ * Supports --wait for blocking operation (agent-friendly)
+ */
+exportCommand
+    .command('start')
+    .description('Start a video export/render')
+    .option('--quality <quality>', 'Video quality: low, medium, high', 'high')
+    .option('--format <format>', 'Output format: mp4, webm, gif', 'mp4')
+    .option('--wait', 'Block until export completes (agent-friendly)')
+    .option('--timeout <seconds>', 'Fail if export takes longer than this (requires --wait)', '600')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitExportAuthError(globalOpts);
+    }
+    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,
+                continue: false,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(64); // Input error exit code
+    }
+    const spinner = ora('Starting export...').start();
+    const startTime = Date.now();
+    const timeoutMs = parseInt(options.timeout, 10) * 1000;
+    try {
+        const result = await apiRequest(config, 'render.startRender', {
+            projectId,
+            quality: options.quality,
+            format: options.format,
+        });
+        const renderId = result.renderId || result.id;
+        // If --wait flag, block until complete
+        if (options.wait) {
+            spinner.text = 'Rendering...';
+            const checkStatus = async () => {
+                return await apiRequest(config, 'render.getRenderStatus', { renderId });
+            };
+            let status = await checkStatus();
+            let lastProgress = 0;
+            while (status.status === 'pending' || status.status === 'rendering' || status.status === 'in_progress') {
+                // Check timeout
+                const elapsed = Date.now() - startTime;
+                if (elapsed > timeoutMs) {
+                    spinner.fail();
+                    if (globalOpts.json) {
+                        console.log(JSON.stringify({
+                            type: 'error',
+                            code: 'TIMEOUT',
+                            errorType: 'TIMEOUT',
+                            message: `Export timed out after ${options.timeout} seconds`,
+                            category: 'transient',
+                            retryable: true,
+                            transient: true,
+                            continue: false,
+                        }));
+                    }
+                    else {
+                        error(`Export timed out after ${options.timeout} seconds`);
+                    }
+                    process.exit(10); // Transient error - can retry
+                }
+                const progress = status.progress || 0;
+                if (progress !== lastProgress) {
+                    lastProgress = progress;
+                    // Emit progress event for agents
+                    if (globalOpts.json) {
+                        console.log(JSON.stringify({
+                            type: 'progress',
+                            exportId: renderId,
+                            progress,
+                            eta_seconds: Math.ceil((timeoutMs - (Date.now() - startTime)) / 1000),
+                            continue: true,
+                        }));
+                    }
+                }
+                spinner.text = `Rendering... ${progress}%`;
+                await new Promise(r => setTimeout(r, 3000));
+                status = await checkStatus();
+            }
+            spinner.stop();
+            if (status.status === 'completed' || status.status === 'done') {
+                const finalResult = {
+                    type: 'export_completed',
+                    success: true,
+                    exportId: renderId,
+                    url: status.url || status.outputUrl,
+                    status: 'completed',
+                    continue: false,
+                };
+                if (globalOpts.json) {
+                    output(finalResult, { json: true });
+                }
+                else {
+                    success('Export complete!');
+                    if (status.url || status.outputUrl) {
+                        console.log(`  Download: ${chalk.cyan(status.url || status.outputUrl)}`);
+                    }
+                }
+            }
+            else {
+                // Export failed
+                if (globalOpts.json) {
+                    console.log(JSON.stringify({
+                        type: 'error',
+                        code: 'EXPORT_FAILED',
+                        errorType: 'EXPORT_FAILED',
+                        message: status.error || 'Export failed',
+                        category: 'fatal',
+                        retryable: false,
+                        transient: false,
+                        continue: false,
+                    }));
+                }
+                else {
+                    error(`Export failed: ${status.error || status.status}`);
+                }
+                process.exit(1);
+            }
+        }
+        else {
+            // Non-blocking mode (original behavior)
+            spinner.stop();
+            if (globalOpts.json) {
+                output({
+                    type: 'export_started',
+                    exportId: renderId,
+                    status: 'pending',
+                    continue: true, // Agent should poll for completion
+                }, { json: true });
+                return;
+            }
+            success(`Export started!`);
+            console.log(`  Render ID: ${chalk.cyan(renderId)}`);
+            console.log();
+            console.log(chalk.gray(`Check status: baz export status ${renderId}`));
+            console.log(chalk.gray(`Or use: baz export start --wait`));
+        }
+    }
+    catch (err) {
+        spinner.stop();
+        if (err instanceof ApiError) {
+            if (globalOpts.json) {
+                output({ ...err.toJSON(), continue: false }, { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(err.message, err.suggestion);
+            }
+            process.exit(err.exitCode);
+        }
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'UNKNOWN',
+                message: err.message,
+                category: 'fatal',
+                retryable: false,
+                transient: false,
+                exitCode: 1,
+                continue: false,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(1);
+    }
+});
+/**
+ * baz export status <renderId>
+ */
+exportCommand
+    .command('status <renderId>')
+    .description('Check export status')
+    .option('--wait', 'Wait for completion')
+    .action(async (renderId, options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+    });
+    if (!hasAuth(config)) {
+        exitExportAuthError(globalOpts);
+    }
+    const checkStatus = async () => {
+        const result = await apiRequest(config, 'render.getRenderStatus', {
+            renderId,
+        });
+        return result;
+    };
+    if (options.wait) {
+        const spinner = ora('Waiting for export to complete...').start();
+        try {
+            let status = await checkStatus();
+            while (status.status === 'pending' || status.status === 'rendering' || status.status === 'in_progress') {
+                const progress = status.progress || 0;
+                spinner.text = `Rendering... ${progress}%`;
+                await new Promise(r => setTimeout(r, 3000));
+                status = await checkStatus();
+            }
+            spinner.stop();
+            if (globalOpts.json) {
+                output(status, { json: true });
+                return;
+            }
+            if (status.status === 'completed' || status.status === 'done') {
+                success('Export complete!');
+                if (status.url || status.outputUrl) {
+                    console.log(`  Download: ${chalk.cyan(status.url || status.outputUrl)}`);
+                }
+            }
+            else {
+                error(`Export failed: ${status.error || status.status}`);
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            spinner.stop();
+            error(err.message);
+            process.exit(1);
+        }
+    }
+    else {
+        const spinner = ora('Checking status...').start();
+        try {
+            const status = await checkStatus();
+            spinner.stop();
+            if (globalOpts.json) {
+                output(status, { json: true });
+                return;
+            }
+            const statusColor = status.status === 'completed' || status.status === 'done' ? chalk.green :
+                status.status === 'failed' || status.status === 'error' ? chalk.red :
+                    chalk.yellow;
+            console.log(`Status: ${statusColor(status.status)}`);
+            if (status.progress !== undefined) {
+                console.log(`Progress: ${status.progress}%`);
+            }
+            if (status.url || status.outputUrl) {
+                console.log(`Download: ${chalk.cyan(status.url || status.outputUrl)}`);
+            }
+            if (status.error) {
+                console.log(`Error: ${chalk.red(status.error)}`);
+            }
+        }
+        catch (err) {
+            spinner.stop();
+            error(err.message);
+            process.exit(1);
+        }
+    }
+});
+/**
+ * baz export list
+ */
+exportCommand
+    .command('list')
+    .description('List recent exports')
+    .option('--limit <n>', 'Number of exports to show', '10')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+        projectId: globalOpts.projectId,
+    });
+    if (!hasAuth(config)) {
+        exitExportAuthError(globalOpts);
+    }
+    let projectId;
+    try {
+        projectId = getProjectId(config, globalOpts.projectId);
+    }
+    catch (err) {
+        error(err.message);
+        process.exit(1);
+    }
+    const spinner = ora('Fetching exports...').start();
+    try {
+        const result = await apiRequest(config, 'render.listRenders', {
+            projectId,
+            limit: parseInt(options.limit, 10),
+        });
+        spinner.stop();
+        if (globalOpts.json) {
+            output(result, { json: true });
+            return;
+        }
+        const renders = Array.isArray(result) ? result : result.renders || [];
+        if (renders.length === 0) {
+            console.log(chalk.gray('No exports yet.'));
+            console.log(chalk.gray('Start one with: baz export start'));
+            return;
+        }
+        console.log(`Recent Exports (${renders.length}):`);
+        console.log();
+        for (const render of renders) {
+            const statusColor = render.status === 'completed' || render.status === 'done' ? chalk.green :
+                render.status === 'failed' || render.status === 'error' ? chalk.red :
+                    chalk.yellow;
+            console.log(`  ${chalk.gray(render.id?.slice(0, 8) || 'unknown')}  ${statusColor(render.status)}  ${render.createdAt || ''}`);
+            if (render.url || render.outputUrl) {
+                console.log(`    ${chalk.cyan(render.url || render.outputUrl)}`);
+            }
+        }
+    }
+    catch (err) {
+        spinner.stop();
+        error(err.message);
+        process.exit(1);
+    }
+});

package/dist/commands/logs.d.ts

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

package/dist/commands/logs.js

@@ -0,0 +1,180 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, hasAuth, getProjectId } from '../lib/config.js';
+import { apiRequest, ApiError, ErrorCodes } from '../lib/api.js';
+import { error, output } from '../lib/output.js';
+/**
+ * Format timestamp for display
+ */
+function formatTime(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleTimeString('en-US', {
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+    });
+}
+/**
+ * Color log level
+ */
+function colorLevel(level) {
+    if (!level)
+        return chalk.gray('info');
+    switch (level.toLowerCase()) {
+        case 'error':
+            return chalk.red('error');
+        case 'warn':
+        case 'warning':
+            return chalk.yellow('warn');
+        case 'info':
+            return chalk.blue('info');
+        case 'debug':
+            return chalk.gray('debug');
+        default:
+            return chalk.gray(level);
+    }
+}
+/**
+ * Truncate message for display
+ */
+function truncateMessage(msg, maxLen = 100) {
+    if (msg.length <= maxLen)
+        return msg;
+    return msg.slice(0, maxLen - 3) + '...';
+}
+export const logsCommand = new Command('logs')
+    .description('Query recent project/runtime logs')
+    .option('--errors', 'Show only errors')
+    .option('--search <text>', 'Search for text in log messages')
+    .option('--path <path>', 'Filter by API path (e.g., /api/generate-stream)')
+    .option('--since <time>', 'Time range: 5m, 1h, 24h, 7d (default: 1h)', '1h')
+    .option('--limit <n>', 'Maximum number of logs to show (default: 50)', '50')
+    .option('--project', 'Filter logs by current project ID')
+    .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);
+    }
+    // Build query parameters
+    const params = {
+        since: options.since,
+        limit: options.limit,
+    };
+    if (options.errors) {
+        params.errorsOnly = 'true';
+    }
+    if (options.search) {
+        params.search = options.search;
+    }
+    if (options.path) {
+        params.path = options.path;
+    }
+    // Get project ID if filtering by project
+    if (options.project) {
+        try {
+            params.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('Querying logs...').start();
+    try {
+        const result = await apiRequest(config, 'logs.query', params);
+        spinner?.stop();
+        if (globalOpts.json) {
+            output(result, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        if (!result.logs || result.logs.length === 0) {
+            console.log(chalk.gray('No logs found matching your criteria.'));
+            console.log(chalk.dim(`\nTry adjusting your filters or time range (--since ${options.since})`));
+            return;
+        }
+        // Display logs
+        console.log(chalk.cyan(`Found ${result.logs.length} logs:`));
+        console.log();
+        for (const log of result.logs) {
+            const time = formatTime(log._time);
+            const level = colorLevel(log.level);
+            const path = log['request.path'] ? chalk.dim(` [${log['request.path']}]`) : '';
+            const duration = log['report.durationMs'] ? chalk.dim(` ${log['report.durationMs']}ms`) : '';
+            const message = log.message ? truncateMessage(log.message, 80) : '';
+            console.log(`${chalk.gray(time)} ${level}${path}${duration} ${message}`);
+        }
+        if (result.total > result.logs.length) {
+            console.log();
+            console.log(chalk.dim(`Showing ${result.logs.length} of ${result.total} logs. Use --limit to see more.`));
+        }
+    }
+    catch (err) {
+        spinner?.fail('Failed to query logs');
+        if (err instanceof ApiError) {
+            if (err.code === ErrorCodes.NOT_FOUND) {
+                console.log(chalk.gray('No logs found for your filters.'));
+                return;
+            }
+            if (globalOpts.json) {
+                output(err.toJSON(), { json: true, compact: globalOpts.compact });
+            }
+            else {
+                error(err.message, err.suggestion);
+            }
+        }
+        else {
+            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);
+    }
+});
+// Note: Shortcut subcommands like `baz logs errors` removed to avoid
+// recursive parsing issues. Use `baz logs --errors` instead.

package/dist/commands/loop.d.ts

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