@vizzly-testing/cli 0.26.1 → 0.27.0

package/dist/commands/preview.js

@@ -597,11 +597,21 @@ export async function previewCommand(path, options = {}, globalOptions = {}, dep
         success: true,
         buildId,
         previewUrl: result.previewUrl,
-        files: result.uploaded,
-        totalBytes: result.totalBytes,
+        files: result.uploaded || fileCount,
+        bytes: totalSize,
+        compressedBytes: zipBuffer.length,
+        compressionRatio: parseFloat(compressionRatio) / 100,
         newBytes: result.newBytes,
-        deduplicationRatio: result.deduplicationRatio
+        reusedBlobs: result.reusedBlobs || 0,
+        deduplicationRatio: result.deduplicationRatio,
+        basePath: result.basePath || null,
+        expiresAt: result.expiresAt || null
       });
+      output.cleanup();
+      return {
+        success: true,
+        result
+      };
     } else {
       output.complete('Preview uploaded');
       output.blank();

package/dist/commands/project.js

@@ -107,6 +107,25 @@ export async function projectSelectCommand(options = {}, globalOptions = {}) {
       projectName: selectedProject.name,
       organizationSlug: selectedOrg.slug
     });
+
+    // JSON output for success
+    if (globalOptions.json) {
+      output.data({
+        status: 'configured',
+        project: {
+          name: selectedProject.name,
+          slug: selectedProject.slug
+        },
+        organization: {
+          name: selectedOrg.name,
+          slug: selectedOrg.slug
+        },
+        directory: currentDir,
+        tokenCreated: true
+      });
+      output.cleanup();
+      return;
+    }
     output.complete('Project configured');
     output.blank();
     output.keyValue({
@@ -136,9 +155,13 @@ export async function projectListCommand(_options = {}, globalOptions = {}) {
   try {
     let mappings = await getProjectMappings();
     let paths = Object.keys(mappings);
+    let currentDir = resolve(process.cwd());
     if (paths.length === 0) {
       if (globalOptions.json) {
-        output.data({});
+        output.data({
+          projects: [],
+          current: null
+        });
       } else {
         output.header('project:list');
         output.print('  No projects configured');
@@ -149,13 +172,29 @@ export async function projectListCommand(_options = {}, globalOptions = {}) {
       return;
     }
     if (globalOptions.json) {
-      output.data(mappings);
+      let projects = paths.map(path => {
+        let mapping = mappings[path];
+        return {
+          directory: path,
+          isCurrent: path === currentDir,
+          project: {
+            name: mapping.projectName,
+            slug: mapping.projectSlug
+          },
+          organization: mapping.organizationSlug,
+          createdAt: mapping.createdAt
+        };
+      });
+      let current = projects.find(p => p.isCurrent) || null;
+      output.data({
+        projects,
+        current
+      });
       output.cleanup();
       return;
     }
     output.header('project:list');
     let colors = output.getColors();
-    let currentDir = resolve(process.cwd());
     for (let path of paths) {
       let mapping = mappings[path];
       let isCurrent = path === currentDir;
@@ -211,8 +250,13 @@ export async function projectTokenCommand(_options = {}, globalOptions = {}) {
     if (globalOptions.json) {
       output.data({
         token: tokenStr,
-        projectSlug: mapping.projectSlug,
-        organizationSlug: mapping.organizationSlug
+        directory: currentDir,
+        project: {
+          name: mapping.projectName,
+          slug: mapping.projectSlug
+        },
+        organization: mapping.organizationSlug,
+        createdAt: mapping.createdAt
       });
       output.cleanup();
       return;
@@ -304,7 +348,23 @@ export async function projectRemoveCommand(_options = {}, globalOptions = {}) {
       return;
     }
 
-    // Confirm removal
+    // In JSON mode, skip confirmation (for scripting)
+    if (globalOptions.json) {
+      await deleteProjectMapping(currentDir);
+      output.data({
+        removed: true,
+        directory: currentDir,
+        project: {
+          name: mapping.projectName,
+          slug: mapping.projectSlug
+        },
+        organization: mapping.organizationSlug
+      });
+      output.cleanup();
+      return;
+    }
+
+    // Confirm removal (interactive mode only)
     output.header('project:remove');
     output.labelValue('Current configuration', '');
     output.keyValue({
@@ -320,15 +380,9 @@ export async function projectRemoveCommand(_options = {}, globalOptions = {}) {
       return;
     }
     await deleteProjectMapping(currentDir);
-    if (globalOptions.json) {
-      output.data({
-        removed: true
-      });
-    } else {
-      output.complete('Project configuration removed');
-      output.blank();
-      output.hint('Run "vizzly project:select" to configure a different project');
-    }
+    output.complete('Project configuration removed');
+    output.blank();
+    output.hint('Run "vizzly project:select" to configure a different project');
     output.cleanup();
   } catch (error) {
     output.error('Failed to remove project configuration', error);

package/dist/commands/projects.js

@@ -0,0 +1,96 @@
+/**
+ * Projects command - List projects the user has access to
+ */
+
+import { createApiClient } from '../api/client.js';
+import { loadConfig } from '../utils/config-loader.js';
+import { getApiUrl } from '../utils/environment-config.js';
+import * as output from '../utils/output.js';
+
+/**
+ * Projects command implementation
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ */
+export async function projectsCommand(options = {}, globalOptions = {}) {
+  output.configure({
+    json: globalOptions.json,
+    verbose: globalOptions.verbose,
+    color: !globalOptions.noColor
+  });
+  try {
+    let config = await loadConfig(globalOptions.config, globalOptions);
+    if (!config.apiKey) {
+      output.error('API token required. Use --token, set VIZZLY_TOKEN, or run "vizzly login"');
+      output.cleanup();
+      process.exit(1);
+    }
+    let client = createApiClient({
+      baseUrl: config.apiUrl || getApiUrl(),
+      token: config.apiKey
+    });
+
+    // Build query params
+    let params = new URLSearchParams();
+    if (options.org) params.set('organization', options.org);
+    if (options.limit) params.set('limit', String(options.limit));
+    if (options.offset) params.set('offset', String(options.offset));
+    let queryString = params.toString();
+    let endpoint = `/api/sdk/projects${queryString ? `?${queryString}` : ''}`;
+    output.startSpinner('Fetching projects...');
+    let response = await client.request(endpoint);
+    output.stopSpinner();
+    let projects = response.projects || [];
+    let pagination = response.pagination || {};
+    if (globalOptions.json) {
+      output.data({
+        projects: projects.map(p => ({
+          id: p.id,
+          name: p.name,
+          slug: p.slug,
+          organizationName: p.organizationName,
+          organizationSlug: p.organizationSlug,
+          buildCount: p.buildCount,
+          createdAt: p.created_at,
+          updatedAt: p.updated_at
+        })),
+        pagination
+      });
+    } else {
+      output.header('projects');
+      let colors = output.getColors();
+      if (projects.length === 0) {
+        output.print('  No projects found');
+        if (options.org) {
+          output.hint(`No projects in organization "${options.org}"`);
+        }
+      } else {
+        output.labelValue('Showing', `${projects.length} of ${pagination.total}`);
+        output.blank();
+        for (let project of projects) {
+          output.print(`  ${colors.bold(project.name)} ${colors.dim(`@${project.organizationSlug}/${project.slug}`)}`);
+          output.print(`    ${colors.dim(`${project.buildCount} builds`)}`);
+        }
+        if (pagination.hasMore) {
+          output.blank();
+          output.hint(`Use --offset ${(options.offset || 0) + projects.length} to see more`);
+        }
+      }
+    }
+    output.cleanup();
+  } catch (error) {
+    output.stopSpinner();
+    output.error('Failed to fetch projects', error);
+    output.cleanup();
+    process.exit(1);
+  }
+}
+
+/**
+ * Validate projects options
+ * @param {Object} _options - Command options
+ * @returns {string[]} Validation errors
+ */
+export function validateProjectsOptions(_options = {}) {
+  return [];
+}

package/dist/commands/review.js

@@ -0,0 +1,319 @@
+/**
+ * Review commands - approve, reject, and comment on comparisons/builds
+ */
+
+import { createApiClient as defaultCreateApiClient } from '../api/index.js';
+import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
+import * as defaultOutput from '../utils/output.js';
+
+/**
+ * Approve a comparison
+ * @param {string} comparisonId - Comparison ID to approve
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ * @param {Object} deps - Dependencies for testing
+ */
+export async function approveCommand(comparisonId, options = {}, globalOptions = {}, deps = {}) {
+  let {
+    loadConfig = defaultLoadConfig,
+    createApiClient = defaultCreateApiClient,
+    output = defaultOutput,
+    exit = code => process.exit(code)
+  } = deps;
+  output.configure({
+    json: globalOptions.json,
+    verbose: globalOptions.verbose,
+    color: !globalOptions.noColor
+  });
+  try {
+    let allOptions = {
+      ...globalOptions,
+      ...options
+    };
+    let config = await loadConfig(globalOptions.config, allOptions);
+    if (!config.apiKey) {
+      output.error('API token required');
+      output.hint('Use --token or set VIZZLY_TOKEN environment variable');
+      exit(1);
+      return;
+    }
+    output.startSpinner('Approving comparison...');
+    let client = createApiClient({
+      baseUrl: config.apiUrl,
+      token: config.apiKey,
+      command: 'approve'
+    });
+    let body = {};
+    if (options.comment) {
+      body.comment = options.comment;
+    }
+    let response = await client.request(`/api/sdk/comparisons/${comparisonId}/approve`, {
+      method: 'POST',
+      body: Object.keys(body).length > 0 ? JSON.stringify(body) : undefined,
+      headers: Object.keys(body).length > 0 ? {
+        'Content-Type': 'application/json'
+      } : undefined
+    });
+    output.stopSpinner();
+    if (globalOptions.json) {
+      output.data({
+        approved: true,
+        comparisonId,
+        comparison: response.comparison
+      });
+      output.cleanup();
+      return;
+    }
+    output.complete(`Comparison ${comparisonId} approved`);
+    if (options.comment) {
+      output.hint(`Comment: "${options.comment}"`);
+    }
+    output.cleanup();
+  } catch (error) {
+    output.stopSpinner();
+    if (globalOptions.json) {
+      output.data({
+        approved: false,
+        comparisonId,
+        error: {
+          message: error.message,
+          code: error.code
+        }
+      });
+      output.cleanup();
+      exit(1);
+      return;
+    }
+    output.error('Failed to approve comparison', error);
+    output.cleanup();
+    exit(1);
+  }
+}
+
+/**
+ * Reject a comparison
+ * @param {string} comparisonId - Comparison ID to reject
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ * @param {Object} deps - Dependencies for testing
+ */
+export async function rejectCommand(comparisonId, options = {}, globalOptions = {}, deps = {}) {
+  let {
+    loadConfig = defaultLoadConfig,
+    createApiClient = defaultCreateApiClient,
+    output = defaultOutput,
+    exit = code => process.exit(code)
+  } = deps;
+  output.configure({
+    json: globalOptions.json,
+    verbose: globalOptions.verbose,
+    color: !globalOptions.noColor
+  });
+  try {
+    let allOptions = {
+      ...globalOptions,
+      ...options
+    };
+    let config = await loadConfig(globalOptions.config, allOptions);
+    if (!config.apiKey) {
+      output.error('API token required');
+      output.hint('Use --token or set VIZZLY_TOKEN environment variable');
+      exit(1);
+      return;
+    }
+    if (!options.reason) {
+      output.error('Reason required when rejecting');
+      output.hint('Use --reason "explanation" to provide a reason');
+      exit(1);
+      return;
+    }
+    output.startSpinner('Rejecting comparison...');
+    let client = createApiClient({
+      baseUrl: config.apiUrl,
+      token: config.apiKey,
+      command: 'reject'
+    });
+    let response = await client.request(`/api/sdk/comparisons/${comparisonId}/reject`, {
+      method: 'POST',
+      body: JSON.stringify({
+        reason: options.reason
+      }),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+    output.stopSpinner();
+    if (globalOptions.json) {
+      output.data({
+        rejected: true,
+        comparisonId,
+        reason: options.reason,
+        comparison: response.comparison
+      });
+      output.cleanup();
+      return;
+    }
+    output.complete(`Comparison ${comparisonId} rejected`);
+    output.hint(`Reason: "${options.reason}"`);
+    output.cleanup();
+  } catch (error) {
+    output.stopSpinner();
+    if (globalOptions.json) {
+      output.data({
+        rejected: false,
+        comparisonId,
+        error: {
+          message: error.message,
+          code: error.code
+        }
+      });
+      output.cleanup();
+      exit(1);
+      return;
+    }
+    output.error('Failed to reject comparison', error);
+    output.cleanup();
+    exit(1);
+  }
+}
+
+/**
+ * Add a comment to a build
+ * @param {string} buildId - Build ID to comment on
+ * @param {string} message - Comment message
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ * @param {Object} deps - Dependencies for testing
+ */
+export async function commentCommand(buildId, message, options = {}, globalOptions = {}, deps = {}) {
+  let {
+    loadConfig = defaultLoadConfig,
+    createApiClient = defaultCreateApiClient,
+    output = defaultOutput,
+    exit = code => process.exit(code)
+  } = deps;
+  output.configure({
+    json: globalOptions.json,
+    verbose: globalOptions.verbose,
+    color: !globalOptions.noColor
+  });
+  try {
+    let allOptions = {
+      ...globalOptions,
+      ...options
+    };
+    let config = await loadConfig(globalOptions.config, allOptions);
+    if (!config.apiKey) {
+      output.error('API token required');
+      output.hint('Use --token or set VIZZLY_TOKEN environment variable');
+      exit(1);
+      return;
+    }
+    if (!message || message.trim() === '') {
+      output.error('Comment message required');
+      exit(1);
+      return;
+    }
+    output.startSpinner('Adding comment...');
+    let client = createApiClient({
+      baseUrl: config.apiUrl,
+      token: config.apiKey,
+      command: 'comment'
+    });
+    let body = {
+      content: message,
+      type: options.type || 'general'
+    };
+    let response = await client.request(`/api/sdk/builds/${buildId}/comments`, {
+      method: 'POST',
+      body: JSON.stringify(body),
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+    output.stopSpinner();
+    if (globalOptions.json) {
+      output.data({
+        created: true,
+        buildId,
+        comment: response.comment
+      });
+      output.cleanup();
+      return;
+    }
+    output.complete('Comment added');
+    output.labelValue('Build', buildId);
+    output.labelValue('Message', message);
+    output.cleanup();
+  } catch (error) {
+    output.stopSpinner();
+    if (globalOptions.json) {
+      output.data({
+        created: false,
+        buildId,
+        error: {
+          message: error.message,
+          code: error.code
+        }
+      });
+      output.cleanup();
+      exit(1);
+      return;
+    }
+    output.error('Failed to add comment', error);
+    output.cleanup();
+    exit(1);
+  }
+}
+
+/**
+ * Validate approve command options
+ * @param {string} comparisonId - Comparison ID
+ * @param {Object} options - Command options
+ * @returns {string[]} Array of error messages
+ */
+export function validateApproveOptions(comparisonId, _options = {}) {
+  let errors = [];
+  if (!comparisonId || comparisonId.trim() === '') {
+    errors.push('Comparison ID is required');
+  }
+  return errors;
+}
+
+/**
+ * Validate reject command options
+ * @param {string} comparisonId - Comparison ID
+ * @param {Object} options - Command options
+ * @returns {string[]} Array of error messages
+ */
+export function validateRejectOptions(comparisonId, options = {}) {
+  let errors = [];
+  if (!comparisonId || comparisonId.trim() === '') {
+    errors.push('Comparison ID is required');
+  }
+  if (!options.reason || options.reason.trim() === '') {
+    errors.push('--reason is required when rejecting');
+  }
+  return errors;
+}
+
+/**
+ * Validate comment command options
+ * @param {string} buildId - Build ID
+ * @param {string} message - Comment message
+ * @param {Object} options - Command options
+ * @returns {string[]} Array of error messages
+ */
+export function validateCommentOptions(buildId, message, options = {}) {
+  let errors = [];
+  if (!buildId || buildId.trim() === '') {
+    errors.push('Build ID is required');
+  }
+  if (!message || message.trim() === '') {
+    errors.push('Comment message is required');
+  }
+  if (options.type && !['general', 'approval', 'rejection'].includes(options.type)) {
+    errors.push('--type must be one of: general, approval, rejection');
+  }
+  return errors;
+}