@vizzly-testing/cli 0.22.2 → 0.23.1

package/dist/api/endpoints.js

@@ -311,4 +311,47 @@ export async function finalizeParallelBuild(client, parallelId) {
       'Content-Type': 'application/json'
     }
   });
+}
+
+// ============================================================================
+// Preview Endpoints
+// ============================================================================
+
+/**
+ * Upload preview ZIP file for a build
+ * @param {Object} client - API client
+ * @param {string} buildId - Build ID
+ * @param {Buffer} zipBuffer - ZIP file contents
+ * @returns {Promise<Object>} Upload result with preview URL
+ */
+export async function uploadPreviewZip(client, buildId, zipBuffer) {
+  // Create form data with the ZIP file
+  let FormData = (await import('form-data')).default;
+  let formData = new FormData();
+  formData.append('file', zipBuffer, {
+    filename: 'preview.zip',
+    contentType: 'application/zip'
+  });
+  return client.request(`/api/sdk/builds/${buildId}/preview/upload-zip`, {
+    method: 'POST',
+    body: formData,
+    headers: formData.getHeaders()
+  });
+}
+
+/**
+ * Get preview info for a build
+ * @param {Object} client - API client
+ * @param {string} buildId - Build ID
+ * @returns {Promise<Object>} Preview info or null if not found
+ */
+export async function getPreviewInfo(client, buildId) {
+  try {
+    return await client.request(`/api/sdk/builds/${buildId}/preview`);
+  } catch (error) {
+    if (error.status === 404) {
+      return null;
+    }
+    throw error;
+  }
 }

package/dist/api/index.js

@@ -16,4 +16,4 @@ export { createApiClient, DEFAULT_API_URL } from './client.js';
 export { buildApiUrl, buildAuthHeader, buildBuildPayload, buildEndpointWithParams, buildQueryParams, buildRequestHeaders, buildScreenshotCheckObject, buildScreenshotPayload, buildShaCheckPayload, buildUserAgent, computeSha256, extractErrorBody, findScreenshotBySha, isAuthError, isRateLimited, parseApiError, partitionByShaExistence, shaExists, shouldRetryWithRefresh } from './core.js';
 
 // Endpoint functions
-export { checkShas, createBuild, finalizeBuild, finalizeParallelBuild, getBatchHotspots, getBuild, getBuilds, getComparison, getScreenshotHotspots, getTddBaselines, getTokenContext, searchComparisons, updateBuildStatus, uploadScreenshot } from './endpoints.js';
+export { checkShas, createBuild, finalizeBuild, finalizeParallelBuild, getBatchHotspots, getBuild, getBuilds, getComparison, getPreviewInfo, getScreenshotHotspots, getTddBaselines, getTokenContext, searchComparisons, updateBuildStatus, uploadPreviewZip, uploadScreenshot } from './endpoints.js';

package/dist/cli.js

@@ -6,6 +6,7 @@ import { finalizeCommand, validateFinalizeOptions } from './commands/finalize.js
 import { init } from './commands/init.js';
 import { loginCommand, validateLoginOptions } from './commands/login.js';
 import { logoutCommand, validateLogoutOptions } from './commands/logout.js';
+import { previewCommand, validatePreviewOptions } from './commands/preview.js';
 import { projectListCommand, projectRemoveCommand, projectSelectCommand, projectTokenCommand, validateProjectOptions } from './commands/project.js';
 import { runCommand, validateRunOptions } from './commands/run.js';
 import { statusCommand, validateStatusOptions } from './commands/status.js';
@@ -411,6 +412,20 @@ program.command('finalize').description('Finalize a parallel build after all sha
   }
   await finalizeCommand(parallelId, options, globalOptions);
 });
+program.command('preview').description('Upload static files as a preview for a build').argument('<path>', 'Path to static files (dist/, build/, out/)').option('-b, --build <id>', 'Build ID to attach preview to').option('-p, --parallel-id <id>', 'Look up build by parallel ID').option('--base <path>', 'Override auto-detected base path').option('--open', 'Open preview URL in browser after upload').action(async (path, options) => {
+  const globalOptions = program.opts();
+
+  // Validate options
+  const validationErrors = validatePreviewOptions(path, options);
+  if (validationErrors.length > 0) {
+    output.error('Validation errors:');
+    for (let error of validationErrors) {
+      output.printErr(`  - ${error}`);
+    }
+    process.exit(1);
+  }
+  await previewCommand(path, options, globalOptions);
+});
 program.command('doctor').description('Run diagnostics to check your environment and configuration').option('--api', 'Include API connectivity checks').action(async options => {
   const globalOptions = program.opts();
 

package/dist/commands/finalize.js

@@ -6,6 +6,7 @@
 import { createApiClient as defaultCreateApiClient, finalizeParallelBuild as defaultFinalizeParallelBuild } from '../api/index.js';
 import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
 import * as defaultOutput from '../utils/output.js';
+import { writeSession as defaultWriteSession } from '../utils/session.js';
 
 /**
  * Finalize command implementation
@@ -20,6 +21,7 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
     createApiClient = defaultCreateApiClient,
     finalizeParallelBuild = defaultFinalizeParallelBuild,
     output = defaultOutput,
+    writeSession = defaultWriteSession,
     exit = code => process.exit(code)
   } = deps;
   output.configure({
@@ -61,6 +63,14 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
     });
     let result = await finalizeParallelBuild(client, parallelId);
     output.stopSpinner();
+
+    // Write session for subsequent commands (like preview)
+    if (result.build?.id) {
+      writeSession({
+        buildId: result.build.id,
+        parallelId
+      });
+    }
     if (globalOptions.json) {
       output.data(result);
     } else {

package/dist/commands/preview.js

@@ -0,0 +1,439 @@
+/**
+ * Preview command implementation
+ *
+ * Uploads static files as a preview for a Vizzly build.
+ * The build is automatically detected from session file or environment.
+ */
+
+import { exec, execSync } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync, statSync } from 'node:fs';
+import { readFile, realpath, stat, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { createApiClient as defaultCreateApiClient, uploadPreviewZip as defaultUploadPreviewZip } from '../api/index.js';
+import { openBrowser as defaultOpenBrowser } from '../utils/browser.js';
+import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
+import { detectBranch as defaultDetectBranch } from '../utils/git.js';
+import * as defaultOutput from '../utils/output.js';
+import { formatSessionAge as defaultFormatSessionAge, readSession as defaultReadSession } from '../utils/session.js';
+let execAsync = promisify(exec);
+
+/**
+ * Validate path for shell safety - prevents command injection
+ * @param {string} path - Path to validate
+ * @returns {boolean} true if path is safe for shell use
+ */
+function isPathSafe(path) {
+  // Reject paths with shell metacharacters that could enable command injection
+  let dangerousChars = /[`$;&|<>(){}[\]\\!*?'"]/;
+  return !dangerousChars.test(path);
+}
+
+/**
+ * Check if a command exists on the system
+ * @param {string} command - Command to check
+ * @returns {boolean}
+ */
+function commandExists(command) {
+  try {
+    let checkCmd = process.platform === 'win32' ? 'where' : 'which';
+    execSync(`${checkCmd} ${command}`, {
+      stdio: 'ignore'
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the appropriate zip command for the current platform
+ * @returns {{ command: string, available: boolean }}
+ */
+function getZipCommand() {
+  // Check for standard zip command (macOS, Linux, Windows with Git Bash)
+  if (commandExists('zip')) {
+    return {
+      command: 'zip',
+      available: true
+    };
+  }
+
+  // Windows: Check for PowerShell Compress-Archive
+  if (process.platform === 'win32') {
+    return {
+      command: 'powershell',
+      available: true
+    };
+  }
+  return {
+    command: null,
+    available: false
+  };
+}
+
+/**
+ * Create a ZIP file from a directory using system commands
+ * @param {string} sourceDir - Directory to zip
+ * @param {string} outputPath - Path for output ZIP file
+ * @returns {Promise<void>}
+ */
+async function createZipWithSystem(sourceDir, outputPath) {
+  let {
+    command,
+    available
+  } = getZipCommand();
+  if (!available) {
+    throw new Error('No zip command found. Please install zip or use PowerShell on Windows.');
+  }
+
+  // Validate paths to prevent command injection
+  // Note: outputPath is internally generated (tmpdir + random), so always safe
+  // sourceDir comes from user input, so we validate it
+  if (!isPathSafe(sourceDir)) {
+    throw new Error('Path contains unsupported characters. Please use a path without special shell characters.');
+  }
+  if (command === 'zip') {
+    // Standard zip command - create ZIP from directory contents
+    // Using cwd option is safe as it's not part of the command string
+    // -r: recursive, -q: quiet
+    await execAsync(`zip -r -q "${outputPath}" .`, {
+      cwd: sourceDir,
+      maxBuffer: 1024 * 1024 * 100 // 100MB buffer
+    });
+  } else if (command === 'powershell') {
+    // Windows PowerShell - use -LiteralPath for safer path handling
+    // Escape single quotes in paths by doubling them
+    let safeSrcDir = sourceDir.replace(/'/g, "''");
+    let safeOutPath = outputPath.replace(/'/g, "''");
+    await execAsync(`powershell -Command "Compress-Archive -LiteralPath '${safeSrcDir}\\*' -DestinationPath '${safeOutPath}' -Force"`, {
+      maxBuffer: 1024 * 1024 * 100
+    });
+  }
+}
+
+/**
+ * Count files in a directory recursively
+ * Skips symlinks to prevent path traversal attacks
+ * @param {string} dir - Directory path
+ * @returns {Promise<{ count: number, totalSize: number }>}
+ */
+async function countFiles(dir) {
+  let {
+    readdir
+  } = await import('node:fs/promises');
+  let count = 0;
+  let totalSize = 0;
+
+  // Resolve the base directory to an absolute path for traversal checks
+  let baseDir = await realpath(resolve(dir));
+  async function walk(currentDir) {
+    let entries = await readdir(currentDir, {
+      withFileTypes: true
+    });
+    for (let entry of entries) {
+      let fullPath = join(currentDir, entry.name);
+
+      // Skip symlinks to prevent traversal attacks
+      if (entry.isSymbolicLink()) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        // Skip hidden directories and common non-content directories
+        if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === '__pycache__') {
+          continue;
+        }
+
+        // Verify we're still within the base directory (prevent traversal)
+        let realSubDir = await realpath(fullPath);
+        if (!realSubDir.startsWith(baseDir)) {
+          continue;
+        }
+        await walk(fullPath);
+      } else if (entry.isFile()) {
+        // Skip hidden files
+        if (entry.name.startsWith('.')) {
+          continue;
+        }
+        count++;
+        let fileStat = await stat(fullPath);
+        totalSize += fileStat.size;
+      }
+    }
+  }
+  await walk(baseDir);
+  return {
+    count,
+    totalSize
+  };
+}
+
+/**
+ * Format bytes for display
+ * @param {number} bytes - Bytes to format
+ * @returns {string}
+ */
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+/**
+ * Preview command implementation
+ * @param {string} path - Path to static files
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ * @param {Object} deps - Dependencies for testing
+ */
+export async function previewCommand(path, options = {}, globalOptions = {}, deps = {}) {
+  let {
+    loadConfig = defaultLoadConfig,
+    createApiClient = defaultCreateApiClient,
+    uploadPreviewZip = defaultUploadPreviewZip,
+    readSession = defaultReadSession,
+    formatSessionAge = defaultFormatSessionAge,
+    detectBranch = defaultDetectBranch,
+    openBrowser = defaultOpenBrowser,
+    output = defaultOutput,
+    exit = code => process.exit(code)
+  } = deps;
+  output.configure({
+    json: globalOptions.json,
+    verbose: globalOptions.verbose,
+    color: !globalOptions.noColor
+  });
+  try {
+    // Load configuration
+    let allOptions = {
+      ...globalOptions,
+      ...options
+    };
+    let config = await loadConfig(globalOptions.config, allOptions);
+
+    // Validate API token
+    if (!config.apiKey) {
+      output.error('API token required. Use --token or set VIZZLY_TOKEN environment variable');
+      exit(1);
+      return {
+        success: false,
+        reason: 'no-api-key'
+      };
+    }
+
+    // Validate path exists and is a directory
+    if (!existsSync(path)) {
+      output.error(`Path does not exist: ${path}`);
+      exit(1);
+      return {
+        success: false,
+        reason: 'path-not-found'
+      };
+    }
+    let pathStat = statSync(path);
+    if (!pathStat.isDirectory()) {
+      output.error(`Path is not a directory: ${path}`);
+      exit(1);
+      return {
+        success: false,
+        reason: 'not-a-directory'
+      };
+    }
+
+    // Resolve build ID
+    let buildId = options.build;
+    let buildSource = 'flag';
+    if (!buildId && options.parallelId) {
+      // TODO: Look up build by parallel ID
+      output.error('Parallel ID lookup not yet implemented. Use --build to specify build ID directly.');
+      exit(1);
+      return {
+        success: false,
+        reason: 'parallel-id-not-implemented'
+      };
+    }
+    if (!buildId) {
+      // Try to read from session
+      let currentBranch = await detectBranch();
+      let session = readSession({
+        currentBranch
+      });
+      if (session?.buildId && !session.expired) {
+        if (session.branchMismatch) {
+          output.warn(`Session build is from different branch (${session.branch})`);
+          output.hint(`Use --build to specify a build ID, or run tests on this branch first.`);
+          exit(1);
+          return {
+            success: false,
+            reason: 'branch-mismatch'
+          };
+        }
+        buildId = session.buildId;
+        buildSource = session.source;
+        if (globalOptions.verbose) {
+          output.info(`Using build ${buildId} from ${buildSource} (${formatSessionAge(session.age)})`);
+        }
+      }
+    }
+    if (!buildId) {
+      output.error('No build found');
+      output.blank();
+      output.print('  Run visual tests first, then upload your preview:');
+      output.blank();
+      output.print('    vizzly run "npm test"');
+      output.print('    vizzly preview ./dist');
+      output.blank();
+      output.print('  Or specify a build explicitly:');
+      output.blank();
+      output.print('    vizzly preview ./dist --build <build-id>');
+      output.blank();
+      exit(1);
+      return {
+        success: false,
+        reason: 'no-build'
+      };
+    }
+
+    // Check for zip command availability
+    let zipInfo = getZipCommand();
+    if (!zipInfo.available) {
+      output.error('No zip command found. Please install zip (macOS/Linux) or ensure PowerShell is available (Windows).');
+      exit(1);
+      return {
+        success: false,
+        reason: 'no-zip-command'
+      };
+    }
+
+    // Count files and calculate size
+    output.startSpinner('Scanning files...');
+    let {
+      count: fileCount,
+      totalSize
+    } = await countFiles(path);
+    if (fileCount === 0) {
+      output.stopSpinner();
+      output.error(`No files found in ${path}`);
+      exit(1);
+      return {
+        success: false,
+        reason: 'no-files'
+      };
+    }
+    output.updateSpinner(`Found ${fileCount} files (${formatBytes(totalSize)})`);
+
+    // Create ZIP using system command
+    output.updateSpinner('Compressing files...');
+    // Use timestamp + random bytes for unique temp file (prevents race conditions)
+    let randomSuffix = randomBytes(8).toString('hex');
+    let zipPath = join(tmpdir(), `vizzly-preview-${Date.now()}-${randomSuffix}.zip`);
+    let zipBuffer;
+    try {
+      await createZipWithSystem(path, zipPath);
+      zipBuffer = await readFile(zipPath);
+    } catch (zipError) {
+      output.stopSpinner();
+      output.error(`Failed to create ZIP: ${zipError.message}`);
+      await unlink(zipPath).catch(() => {});
+      exit(1);
+      return {
+        success: false,
+        reason: 'zip-failed',
+        error: zipError
+      };
+    } finally {
+      // Always clean up temp file
+      await unlink(zipPath).catch(() => {});
+    }
+    let compressionRatio = ((1 - zipBuffer.length / totalSize) * 100).toFixed(0);
+    output.updateSpinner(`Compressed to ${formatBytes(zipBuffer.length)} (${compressionRatio}% smaller)`);
+
+    // Upload
+    output.updateSpinner('Uploading preview...');
+    let client = createApiClient({
+      baseUrl: config.apiUrl,
+      token: config.apiKey,
+      command: 'preview'
+    });
+    let result = await uploadPreviewZip(client, buildId, zipBuffer);
+    output.stopSpinner();
+
+    // Success output
+    if (globalOptions.json) {
+      output.data({
+        success: true,
+        buildId,
+        previewUrl: result.previewUrl,
+        files: result.uploaded,
+        totalBytes: result.totalBytes,
+        newBytes: result.newBytes,
+        deduplicationRatio: result.deduplicationRatio
+      });
+    } else {
+      output.complete('Preview uploaded');
+      output.blank();
+      let colors = output.getColors();
+      output.print(`  ${colors.brand.textTertiary('Files')}       ${colors.white(result.uploaded)} (${formatBytes(result.totalBytes)} compressed)`);
+      if (result.reusedBlobs > 0) {
+        let savedBytes = result.totalBytes - result.newBytes;
+        output.print(`  ${colors.brand.textTertiary('Deduped')}     ${colors.green(result.reusedBlobs)} files (saved ${formatBytes(savedBytes)})`);
+      }
+      if (result.basePath) {
+        output.print(`  ${colors.brand.textTertiary('Base path')}   ${colors.dim(result.basePath)}`);
+      }
+      output.blank();
+      output.print(`  ${colors.brand.textTertiary('Preview')}     ${colors.cyan(colors.underline(result.previewUrl))}`);
+
+      // Open in browser if requested
+      if (options.open) {
+        let opened = await openBrowser(result.previewUrl);
+        if (opened) {
+          output.print(`  ${colors.dim('Opened in browser')}`);
+        }
+      }
+    }
+    output.cleanup();
+    return {
+      success: true,
+      result
+    };
+  } catch (error) {
+    output.stopSpinner();
+
+    // Handle specific error types
+    if (error.status === 404) {
+      output.error(`Build not found: ${options.build || 'from session'}`);
+    } else if (error.status === 403) {
+      if (error.message?.includes('Starter')) {
+        output.error('Preview hosting requires Starter plan or above');
+        output.hint('Upgrade your plan at https://app.vizzly.dev/settings/billing');
+      } else {
+        output.error('Access denied', error);
+      }
+    } else {
+      output.error('Preview upload failed', error);
+    }
+    exit(1);
+    return {
+      success: false,
+      error
+    };
+  } finally {
+    output.cleanup();
+  }
+}
+
+/**
+ * Validate preview options
+ * @param {string} path - Path to static files
+ * @param {Object} options - Command options
+ */
+export function validatePreviewOptions(path, _options) {
+  let errors = [];
+  if (!path || path.trim() === '') {
+    errors.push('Path to static files is required');
+  }
+  return errors;
+}

package/dist/commands/run.js

@@ -13,6 +13,7 @@ import { finalizeBuild as defaultFinalizeBuild, runTests as defaultRunTests } fr
 import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
 import { detectBranch as defaultDetectBranch, detectCommit as defaultDetectCommit, detectCommitMessage as defaultDetectCommitMessage, detectPullRequestNumber as defaultDetectPullRequestNumber, generateBuildNameWithGit as defaultGenerateBuildNameWithGit } from '../utils/git.js';
 import * as defaultOutput from '../utils/output.js';
+import { writeSession as defaultWriteSession } from '../utils/session.js';
 
 /**
  * Run command implementation
@@ -41,6 +42,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {},
     generateBuildNameWithGit = defaultGenerateBuildNameWithGit,
     spawn = defaultSpawn,
     output = defaultOutput,
+    writeSession = defaultWriteSession,
     exit = code => process.exit(code),
     processOn = (event, handler) => process.on(event, handler),
     processRemoveListener = (event, handler) => process.removeListener(event, handler)
@@ -239,6 +241,14 @@ export async function runCommand(testCommand, options = {}, globalOptions = {},
           onBuildCreated: data => {
             buildUrl = data.url;
             buildId = data.buildId;
+
+            // Write session for subsequent commands (like preview)
+            writeSession({
+              buildId: data.buildId,
+              branch,
+              commit,
+              parallelId: runOptions.parallelId
+            });
             if (globalOptions.verbose) {
               output.info(`Build created: ${data.buildId}`);
             }

package/dist/commands/status.js

@@ -3,7 +3,7 @@
  * Uses functional API operations directly
  */
 
-import { createApiClient, getBuild } from '../api/index.js';
+import { createApiClient, getBuild, getPreviewInfo } from '../api/index.js';
 import { loadConfig } from '../utils/config-loader.js';
 import { getApiUrl } from '../utils/environment-config.js';
 import * as output from '../utils/output.js';
@@ -42,6 +42,9 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
       command: 'status'
     });
     let buildStatus = await getBuild(client, buildId);
+
+    // Also fetch preview info (if exists)
+    let previewInfo = await getPreviewInfo(client, buildId);
     output.stopSpinner();
 
     // Extract build data from API response
@@ -68,7 +71,13 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
         approvalStatus: build.approval_status,
         executionTime: build.execution_time_ms,
         isBaseline: build.is_baseline,
-        userAgent: build.user_agent
+        userAgent: build.user_agent,
+        preview: previewInfo ? {
+          url: previewInfo.preview_url,
+          status: previewInfo.status,
+          fileCount: previewInfo.file_count,
+          expiresAt: previewInfo.expires_at
+        } : null
       };
       output.data(statusData);
       output.cleanup();
@@ -139,6 +148,15 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
       output.labelValue('View', output.link('Build', buildUrl));
     }
 
+    // Show preview URL if available
+    if (previewInfo?.preview_url) {
+      output.labelValue('Preview', output.link('Preview', previewInfo.preview_url));
+      if (previewInfo.expires_at) {
+        let expiresDate = new Date(previewInfo.expires_at);
+        output.hint(`Preview expires ${expiresDate.toLocaleDateString()}`);
+      }
+    }
+
     // Show additional info in verbose mode
     if (globalOptions.verbose) {
       output.blank();

package/dist/commands/upload.js

@@ -3,6 +3,7 @@ import { createUploader as defaultCreateUploader } from '../services/uploader.js
 import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
 import { detectBranch as defaultDetectBranch, detectCommit as defaultDetectCommit, detectCommitMessage as defaultDetectCommitMessage, detectPullRequestNumber as defaultDetectPullRequestNumber, generateBuildNameWithGit as defaultGenerateBuildNameWithGit } from '../utils/git.js';
 import * as defaultOutput from '../utils/output.js';
+import { writeSession as defaultWriteSession } from '../utils/session.js';
 
 /**
  * Construct proper build URL with org/project context
@@ -60,6 +61,7 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
     detectPullRequestNumber = defaultDetectPullRequestNumber,
     generateBuildNameWithGit = defaultGenerateBuildNameWithGit,
     output = defaultOutput,
+    writeSession = defaultWriteSession,
     exit = code => process.exit(code),
     buildUrlConstructor = constructBuildUrl
   } = deps;
@@ -158,6 +160,16 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
     const result = await uploader.upload(uploadOptions);
     buildId = result.buildId; // Ensure we have the buildId
 
+    // Write session for subsequent commands (like preview)
+    if (buildId) {
+      writeSession({
+        buildId,
+        branch,
+        commit,
+        parallelId: config.parallelId
+      });
+    }
+
     // Mark build as completed
     if (result.buildId) {
       output.progress('Finalizing build...');