bazaar.it 0.1.0 → 0.2.1

package/dist/commands/state.d.ts

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

package/dist/commands/state.js

@@ -0,0 +1,171 @@
+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 { error, output, formatDuration } from '../lib/output.js';
+import { normalizeScenes } from '../lib/project-state.js';
+function handleStateError(err, globalOpts) {
+    if (err instanceof ApiError) {
+        if (globalOpts.json) {
+            output(err.toJSON(), { 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 || 'Unknown error',
+            category: 'fatal',
+            retryable: false,
+            transient: false,
+            exitCode: 1,
+        }, { json: true, compact: globalOpts.compact });
+    }
+    else {
+        error(err.message || 'Unknown error');
+    }
+    process.exit(1);
+}
+export const stateCommand = new Command('state')
+    .description('Get a machine-friendly snapshot of current project state')
+    .option('--include-code', 'Include scene TSX code in scene payload')
+    .option('--include-messages', 'Include recent project messages')
+    .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('Collecting state snapshot...').start();
+    try {
+        const [projectResult, validationResult, renderResult, subscriptionResult] = await Promise.all([
+            apiRequest(config, 'project.getFullProject', {
+                id: projectId,
+                include: options.includeMessages ? ['scenes', 'messages'] : ['scenes'],
+                includeSceneCode: options.includeCode === true,
+            }),
+            apiRequest(config, 'project.validate', { projectId }),
+            apiRequest(config, 'render.listRenders').catch(() => []),
+            apiRequest(config, 'payment.getSubscriptionSummary').catch(() => null),
+        ]);
+        spinner?.stop();
+        const project = projectResult.project ?? projectResult;
+        const codeRequested = options.includeCode === true;
+        const scenes = normalizeScenes((projectResult.scenes ?? []), { codeOmitted: !codeRequested });
+        const activeTasks = (Array.isArray(renderResult) ? renderResult : [])
+            .filter((job) => job?.status === 'pending' || job?.status === 'rendering');
+        const scenePayload = scenes.map((scene) => {
+            const raw = (projectResult.scenes ?? []).find((item) => item.id === scene.id);
+            return {
+                id: scene.id,
+                name: scene.name,
+                track: scene.track,
+                order: scene.order,
+                startFrame: scene.startFrame,
+                durationFrames: scene.durationFrames,
+                endFrame: scene.endFrame,
+                hasCode: scene.hasCode,
+                hasCompilationError: scene.hasCompilationError,
+                ...(options.includeCode === true && raw?.tsxCode ? { tsxCode: raw.tsxCode } : {}),
+            };
+        });
+        const snapshot = {
+            type: 'state_snapshot',
+            timestamp: new Date().toISOString(),
+            project: {
+                id: projectId,
+                title: project?.title || project?.name || 'Untitled',
+                format: project?.props?.meta?.format || 'landscape',
+                width: project?.props?.meta?.width,
+                height: project?.props?.meta?.height,
+                updatedAt: project?.updatedAt,
+            },
+            timeline: validationResult.summary,
+            validation: {
+                valid: validationResult.valid,
+                errorCount: validationResult.errors.length,
+                warningCount: validationResult.warnings.length,
+            },
+            scenes: scenePayload,
+            activeTasks: activeTasks.map((task) => ({
+                id: task?.id,
+                status: task?.status,
+                progress: task?.progress,
+                createdAt: task?.createdAt,
+            })),
+            resources: subscriptionResult
+                ? {
+                    balance: subscriptionResult.balance,
+                    tierDisplayName: subscriptionResult.tierDisplayName,
+                    canExportWatermarkFree: subscriptionResult.canExportWatermarkFree,
+                    nextResetAt: subscriptionResult.nextResetAt,
+                }
+                : null,
+            ...(options.includeMessages ? { messages: projectResult.messages ?? [] } : {}),
+        };
+        if (globalOpts.json) {
+            output(snapshot, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        console.log(chalk.bold('State Snapshot'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(`Project: ${chalk.cyan(snapshot.project.title)} (${projectId.slice(0, 8)}...)`);
+        console.log(`Format: ${snapshot.project.format}${snapshot.project.width && snapshot.project.height ? ` (${snapshot.project.width}x${snapshot.project.height})` : ''}`);
+        console.log(`Scenes: ${snapshot.timeline.sceneCount} across ${snapshot.timeline.trackCount} track(s)`);
+        console.log(`Duration: ${formatDuration(snapshot.timeline.totalDurationSeconds)}`);
+        console.log(`Validation: ${snapshot.validation.valid ? chalk.green('valid') : chalk.red('issues found')} (${snapshot.validation.errorCount} errors, ${snapshot.validation.warningCount} warnings)`);
+        console.log(`Active tasks: ${snapshot.activeTasks.length}`);
+        if (snapshot.resources) {
+            console.log(`Balance: $${Number(snapshot.resources.balance ?? 0).toFixed(2)} (${snapshot.resources.tierDisplayName || 'tier unknown'})`);
+        }
+    }
+    catch (err) {
+        spinner?.stop();
+        handleStateError(err, globalOpts);
+    }
+});

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,219 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, hasAuth, getProjectId } from '../lib/config.js';
+import { apiRequest } from '../lib/api.js';
+import { error, formatDuration } from '../lib/output.js';
+/**
+ * Render an ASCII timeline of scenes
+ */
+function renderTimeline(scenes, fps, width = 50) {
+    if (scenes.length === 0)
+        return ['  (no scenes)'];
+    const getStartFrame = (scene) => scene.start ?? scene.props?.start ?? scene.startFrame ?? 0;
+    const getDurationFrames = (scene) => scene.duration ?? scene.durationInFrames ?? 0;
+    const getTrack = (scene) => scene.track ?? scene.order ?? 0;
+    const hasError = (scene) => Boolean(scene.compilationError ?? scene.compilation_error);
+    const getName = (scene) => scene.name ?? scene.data?.name ?? '';
+    // Calculate total duration
+    let totalFrames = 0;
+    scenes.forEach((s) => {
+        const end = getStartFrame(s) + getDurationFrames(s);
+        if (end > totalFrames)
+            totalFrames = end;
+    });
+    if (totalFrames === 0)
+        return ['  (no duration)'];
+    const lines = [];
+    // Group scenes by track
+    const tracks = new Map();
+    scenes.forEach((s) => {
+        const track = getTrack(s);
+        if (!tracks.has(track))
+            tracks.set(track, []);
+        tracks.get(track).push(s);
+    });
+    // Sort tracks
+    const sortedTracks = Array.from(tracks.keys()).sort((a, b) => a - b);
+    // Render each track
+    for (const trackNum of sortedTracks) {
+        const trackScenes = tracks.get(trackNum);
+        const trackLabel = `Track ${trackNum}`;
+        // Create timeline bar
+        let bar = ' '.repeat(width);
+        for (const scene of trackScenes) {
+            const startFrame = getStartFrame(scene);
+            const duration = getDurationFrames(scene);
+            // Calculate position in the bar
+            const startPos = Math.floor((startFrame / totalFrames) * width);
+            const endPos = Math.min(Math.floor(((startFrame + duration) / totalFrames) * width), width);
+            const sceneWidth = Math.max(1, endPos - startPos);
+            // Get scene identifier (first 6 chars of name or "▒")
+            const name = getName(scene).slice(0, sceneWidth - 1) || '▓';
+            const displayName = name.padEnd(sceneWidth, '▓').slice(0, sceneWidth);
+            // Color based on status
+            const coloredName = hasError(scene) ? chalk.red(displayName) : chalk.green(displayName);
+            // Insert into bar
+            bar = bar.slice(0, startPos) + displayName + bar.slice(startPos + sceneWidth);
+        }
+        // Add track label and bar
+        lines.push(`  ${chalk.dim(trackLabel.padEnd(8))} │${chalk.gray(bar)}│`);
+    }
+    // Add time axis
+    const totalSeconds = totalFrames / fps;
+    const midTime = formatDuration(totalSeconds / 2);
+    const endTime = formatDuration(totalSeconds);
+    const axisBar = '─'.repeat(width);
+    lines.push(`  ${' '.repeat(8)} └${axisBar}┘`);
+    lines.push(`  ${' '.repeat(8)}  ${chalk.dim('0:00')}${' '.repeat(Math.floor(width / 2) - 4)}${chalk.dim(midTime)}${' '.repeat(Math.floor(width / 2) - midTime.length)}${chalk.dim(endTime)}`);
+    return lines;
+}
+export const statusCommand = new Command('status')
+    .description('Show project overview and timeline')
+    .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) {
+            console.log(JSON.stringify({
+                type: 'error',
+                code: 'AUTH_MISSING',
+                message: 'Not authenticated',
+                category: 'auth',
+                retryable: false,
+                transient: false,
+                exitCode: 13,
+                suggestion: 'Run: baz auth login <api-key>',
+            }));
+        }
+        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) {
+            console.log(JSON.stringify({
+                type: 'error',
+                code: 'VALIDATION',
+                message: err.message,
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 64,
+            }));
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(64);
+    }
+    const spinner = ora('Fetching project status...').start();
+    try {
+        // Use full project query as canonical source of scene state.
+        const projectResult = await apiRequest(config, 'project.getFullProject', {
+            id: projectId,
+            include: ['scenes'],
+            includeSceneCode: false,
+        });
+        spinner.stop();
+        const project = projectResult.project || projectResult;
+        const scenes = projectResult.scenes || [];
+        const fps = 30;
+        const getStartFrame = (scene) => scene.start ?? scene.props?.start ?? scene.startFrame ?? 0;
+        const getDurationFrames = (scene) => scene.duration ?? scene.durationInFrames ?? 0;
+        const getTrack = (scene) => scene.track ?? scene.order ?? 0;
+        const hasError = (scene) => Boolean(scene.compilationError ?? scene.compilation_error);
+        const getName = (scene) => scene.name ?? scene.data?.name ?? 'Untitled';
+        // Calculate stats
+        let totalFrames = 0;
+        let errorCount = 0;
+        const trackSet = new Set();
+        scenes.forEach((s) => {
+            const end = getStartFrame(s) + getDurationFrames(s);
+            if (end > totalFrames)
+                totalFrames = end;
+            if (hasError(s))
+                errorCount++;
+            trackSet.add(getTrack(s));
+        });
+        const totalDuration = totalFrames / fps;
+        const trackCount = trackSet.size || 1;
+        // JSON output
+        if (globalOpts.json) {
+            console.log(JSON.stringify({
+                projectId,
+                title: project.title || 'Untitled',
+                scenes: scenes.length,
+                tracks: trackCount,
+                totalDuration,
+                errors: errorCount,
+                sceneList: scenes.map((s) => ({
+                    id: s.id,
+                    name: getName(s),
+                    track: getTrack(s),
+                    startFrame: getStartFrame(s),
+                    durationInFrames: getDurationFrames(s),
+                    hasError: hasError(s),
+                })),
+            }, null, 2));
+            return;
+        }
+        // Pretty output
+        console.log();
+        console.log(chalk.bold('Project Status'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log();
+        // Project info
+        console.log(`  ${chalk.dim('Project:')}  ${project.title || 'Untitled'}`);
+        console.log(`  ${chalk.dim('ID:')}       ${projectId.slice(0, 8)}...`);
+        console.log();
+        // Stats box
+        console.log(chalk.cyan('┌─────────────────────────────────────────────────────────┐'));
+        console.log(chalk.cyan('│') + `  Scenes: ${chalk.bold(String(scenes.length).padEnd(4))}  Tracks: ${chalk.bold(String(trackCount).padEnd(4))}  Duration: ${chalk.bold(formatDuration(totalDuration).padEnd(8))}  ${errorCount > 0 ? chalk.red(`Errors: ${errorCount}`) : chalk.green('✓ No errors')}`.padEnd(56) + chalk.cyan('│'));
+        console.log(chalk.cyan('└─────────────────────────────────────────────────────────┘'));
+        console.log();
+        // Timeline
+        if (scenes.length > 0) {
+            console.log(chalk.dim('  Timeline:'));
+            const timelineLines = renderTimeline(scenes, fps, 50);
+            timelineLines.forEach(line => console.log(line));
+            console.log();
+        }
+        // Scene list
+        if (scenes.length > 0) {
+            console.log(chalk.dim('  Scenes:'));
+            scenes.forEach((s, i) => {
+                const startSec = getStartFrame(s) / fps;
+                const endSec = startSec + (getDurationFrames(s) / fps);
+                const timeRange = `${formatDuration(startSec)}-${formatDuration(endSec)}`;
+                const track = getTrack(s);
+                const status = hasError(s)
+                    ? chalk.red('✗')
+                    : chalk.green('✓');
+                const trackBadge = chalk.dim(`T${track}`);
+                console.log(`    ${status} ${chalk.gray(`${i + 1}.`)} ${getName(s).padEnd(25)} ${chalk.dim(timeRange.padEnd(12))} ${trackBadge}`);
+            });
+            console.log();
+        }
+        // Help text
+        console.log(chalk.gray('  Commands:'));
+        console.log(chalk.gray('    baz prompt "<instruction>"   Send prompt to agent'));
+        console.log(chalk.gray('    baz scenes list              List scenes'));
+        console.log(chalk.gray('    baz export start             Export video'));
+        console.log();
+    }
+    catch (err) {
+        spinner.stop();
+        error(err.message);
+        process.exit(1);
+    }
+});

package/dist/commands/template.d.ts

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

package/dist/commands/template.js

@@ -0,0 +1,123 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadConfig, hasAuth } from '../lib/config.js';
+import { apiRequest, ApiError } from '../lib/api.js';
+import { output, error, table } from '../lib/output.js';
+export const templateCommand = new Command('template')
+    .description('Browse and manage templates');
+/**
+ * baz template list
+ */
+templateCommand
+    .command('list')
+    .description('List available templates')
+    .option('--category <category>', 'Filter by category')
+    .option('--format <format>', 'Filter by format: landscape, portrait, square')
+    .option('--search <query>', 'Search templates by name/description')
+    .option('--limit <n>', 'Max results', '20')
+    .action(async (options, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const config = loadConfig({
+        configPath: globalOpts.config,
+        apiUrl: globalOpts.apiUrl,
+    });
+    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);
+    }
+    const spinner = globalOpts.json ? null : ora('Fetching templates...').start();
+    try {
+        const limit = Math.min(parseInt(options.limit, 10) || 20, 100);
+        const result = await apiRequest(config, 'templates.getAll', {
+            ...(options.category && { category: options.category }),
+            ...(options.format && { format: options.format }),
+            ...(options.search && { search: options.search }),
+            limit,
+        });
+        spinner?.stop();
+        const items = result.items || [];
+        if (globalOpts.json) {
+            const lean = items.map(t => ({
+                id: t.id,
+                name: t.name,
+                description: t.description,
+                category: t.category || null,
+                formats: t.supportedFormats || [],
+                sceneCount: t.sceneCount,
+                duration: t.totalDuration || null,
+                tags: t.tags || [],
+                isOfficial: t.isOfficial,
+            }));
+            output({
+                items: lean,
+                count: lean.length,
+                hasMore: result.nextCursor !== undefined,
+            }, { json: true, compact: globalOpts.compact });
+            return;
+        }
+        if (items.length === 0) {
+            console.log(chalk.gray('No templates found.'));
+            if (options.search) {
+                console.log(chalk.gray(`Try a different search term or remove --search`));
+            }
+            return;
+        }
+        console.log(`Templates (${items.length} results)`);
+        console.log();
+        const rows = items.map(t => {
+            const name = t.name.length > 30 ? t.name.slice(0, 27) + '...' : t.name;
+            const category = t.category || '—';
+            const formats = (t.supportedFormats || []).join(', ') || '—';
+            const scenes = String(t.sceneCount);
+            const official = t.isOfficial ? chalk.cyan('*') : ' ';
+            return [official, name, category, formats, scenes];
+        });
+        table(['', 'Name', 'Category', 'Formats', 'Scenes'], rows);
+        if (result.nextCursor !== undefined) {
+            console.log();
+            console.log(chalk.gray(`More results available. Use --limit to see more.`));
+        }
+    }
+    catch (err) {
+        spinner?.stop();
+        if (err instanceof ApiError) {
+            if (globalOpts.json) {
+                output(err.toJSON(), { 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,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error(err.message);
+        }
+        process.exit(1);
+    }
+});

package/dist/commands/verify.d.ts

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

package/dist/commands/verify.js

@@ -0,0 +1,150 @@
+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 { error, output, formatDuration } from '../lib/output.js';
+function handleVerifyError(err, globalOpts) {
+    if (err instanceof ApiError) {
+        if (globalOpts.json) {
+            output(err.toJSON(), { 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 || 'Unknown error',
+            category: 'fatal',
+            retryable: false,
+            transient: false,
+            exitCode: 1,
+        }, { json: true, compact: globalOpts.compact });
+    }
+    else {
+        error(err.message || 'Unknown error');
+    }
+    process.exit(1);
+}
+function parseCriteria(options) {
+    const criteria = [];
+    if (options.criteria) {
+        for (const value of options.criteria.split(',')) {
+            const trimmed = value.trim();
+            if (trimmed)
+                criteria.push(trimmed);
+        }
+    }
+    if (options.query?.trim()) {
+        criteria.push(options.query.trim());
+    }
+    return criteria;
+}
+export const verifyCommand = new Command('verify')
+    .description('Verify current project against criteria')
+    .option('--criteria <list>', 'Comma-separated criteria to verify')
+    .option('--query <text>', 'Single verification query')
+    .option('--scene <id>', 'Scope verification to one scene ID (supports prefix)')
+    .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);
+    }
+    const criteria = parseCriteria(options);
+    if (criteria.length === 0) {
+        if (globalOpts.json) {
+            output({
+                type: 'error',
+                code: 'VALIDATION',
+                message: 'Provide --criteria or --query',
+                category: 'validation',
+                retryable: false,
+                transient: false,
+                exitCode: 65,
+            }, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            error('Provide --criteria or --query');
+        }
+        process.exit(65);
+    }
+    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('Verifying criteria...').start();
+    try {
+        const response = await apiRequest(config, 'project.verify', {
+            projectId,
+            criteria,
+            ...(options.scene ? { sceneId: options.scene } : {}),
+        });
+        spinner?.stop();
+        if (globalOpts.json) {
+            output(response, { json: true, compact: globalOpts.compact });
+        }
+        else {
+            const scopeText = response.scope?.sceneId
+                ? `scene ${response.scope.sceneId}`
+                : `project ${projectId.slice(0, 8)}...`;
+            console.log(chalk.bold('Verification Result'));
+            console.log(chalk.gray('─'.repeat(60)));
+            console.log(`Scope: ${scopeText}`);
+            console.log(`Duration: ${formatDuration(response.totalDurationSeconds)}`);
+            console.log();
+            for (const item of response.criteria) {
+                const marker = item.passed ? chalk.green('✓') : chalk.red('✗');
+                console.log(`${marker} ${item.criterion}`);
+                console.log(chalk.gray(`   ${item.evidence}`));
+            }
+            console.log();
+            console.log(response.passedAll ? chalk.green('All criteria passed.') : chalk.yellow('Some criteria failed.'));
+        }
+        process.exit(response.passedAll ? 0 : 65);
+    }
+    catch (err) {
+        spinner?.stop();
+        handleVerifyError(err, globalOpts);
+    }
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};