@zibby/cli 0.1.5

package/src/commands/run.js

@@ -0,0 +1,926 @@
+import { runTest, logger, DEFAULT_OUTPUT_BASE, SESSIONS_DIR, DEFAULT_MODELS } from '@zibby/core';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { resolve, join } from 'path';
+import { glob } from 'glob';
+import chalk from 'chalk';
+import ora from 'ora';
+import dotenv from 'dotenv';
+import fetch from 'node-fetch';
+import open from 'open';
+import { getApiUrl, getAccountApiUrl, getCurrentEnvironment, getFrontendUrl } from '../config/environments.js';
+import { getSessionToken, getUserInfo } from '../config/config.js';
+
+process.env.DOTENV_CONFIG_QUIET = 'true';
+
+const nodeEnv = process.env.NODE_ENV || 'development';
+const envFiles = [
+  resolve(process.cwd(), '.env.local'),
+  resolve(process.cwd(), `.env.${nodeEnv}`),
+  resolve(process.cwd(), '.env')
+];
+
+envFiles.forEach(envFile => {
+  if (existsSync(envFile)) {
+    dotenv.config({ path: envFile, override: false });
+  }
+});
+
+function getGeneratedTestPath(specPath, config) {
+  const specsDir = config?.paths?.specs || 'test-specs';
+  const generatedDir = config?.paths?.generated || 'tests';
+  
+  return specPath
+    .replace(specsDir, generatedDir)
+    .replace(/\.txt$/, '.spec.js');
+}
+async function openTestResultsInBrowser(executionId, projectId) {
+  const frontendUrl = getFrontendUrl();
+  
+  const ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  
+  if (!ulidRegex.test(executionId) && !uuidRegex.test(executionId)) {
+    console.log(chalk.red(`\n❌ Invalid execution ID format (security check)\n`));
+    return false;
+  }
+  
+  if (!uuidRegex.test(projectId)) {
+    console.log(chalk.red(`\n❌ Invalid project ID format (security check)\n`));
+    return false;
+  }
+  
+  const parsedUrl = new URL(frontendUrl);
+  const isProd = !frontendUrl.includes('localhost') && !frontendUrl.includes('127.0.0.1');
+  if (isProd && parsedUrl.protocol !== 'https:') {
+    console.log(chalk.red(`\n❌ Frontend URL must use HTTPS in production\n`));
+    return false;
+  }
+  
+  const url = `${frontendUrl}/projects/${projectId}/runs/${executionId}`;
+  
+  try {
+    console.log(chalk.cyan(`\nOpening test results in browser...`));
+    console.log(chalk.gray(`   ${url}\n`));
+    
+    await open(url);
+    
+    return true;
+  } catch (_error) {
+    console.log(chalk.yellow(`Could not open browser automatically`));
+    console.log(chalk.gray(`   Please open manually: ${url}\n`));
+    return false;
+  }
+}
+
+function getSourceTestPath(generatedPath, config) {
+  const specsDir = config?.paths?.specs || 'test-specs';
+  const generatedDir = config?.paths?.generated || 'tests';
+
+  return generatedPath
+    .replace(generatedDir, specsDir)
+    .replace(/\.spec\.js$/, '.txt');
+}
+async function uploadExecution({ apiKey, specPath, fullSpecPath, collectionIdOrName, folder, agent, config, result, shouldOpen: _shouldOpen }) {
+  const apiUrl = getApiUrl();
+  const env = getCurrentEnvironment();
+  
+  const sessionToken = process.env.ZIBBY_USER_TOKEN || getSessionToken();
+  const userInfo = getUserInfo();
+
+  if (userInfo) {
+    console.log(chalk.gray(`Authenticated: ${userInfo.email} (${userInfo.name || 'User'})`));
+  } else {
+    console.log(chalk.gray('Authenticated: Using Personal Access Token'));
+  }
+  
+  const uploadSpinner = ora(`Uploading to ${env.name}...`).start();
+  
+  try {
+    const cwd = process.cwd();
+    
+    // Use session path from the current run's result (not latest folder)
+    let latestSession = null;
+    if (result?.state?.sessionPath) {
+      const absSessionPath = result.state.sessionPath;
+      latestSession = absSessionPath.startsWith(cwd)
+        ? absSessionPath.slice(cwd.length + 1)
+        : absSessionPath;
+    }
+
+    if (!latestSession) {
+      const outputBase = config.paths?.output || DEFAULT_OUTPUT_BASE;
+      const sessionsPattern = `${outputBase}/${SESSIONS_DIR}/*`;
+      
+      const sessionFolders = glob.sync(sessionsPattern, { cwd })
+        .filter(f => {
+          const stat = statSync(join(cwd, f));
+          return stat.isDirectory() && !/session_/.test(f);
+        })
+        .map(f => ({ path: f, stat: statSync(join(cwd, f)) }))
+        .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs);
+      
+      if (sessionFolders.length === 0) {
+        uploadSpinner.warn('No session folder found, skipping upload');
+        return;
+      }
+      
+      latestSession = sessionFolders[0].path;
+    }
+    // Check multiple locations for video files:
+    // 1. execute_live/videos/*.webm (Cursor MCP browser)
+    // 2. execute_live/*.webm (legacy location)
+    // 3. *.webm or page*.webm (Claude Agent SDK MCP server)
+    let videoFiles = glob.sync(`${latestSession}/execute_live/videos/*.webm`, { cwd });
+    if (videoFiles.length === 0) {
+      videoFiles = glob.sync(`${latestSession}/execute_live/*.webm`, { cwd });
+    }
+    if (videoFiles.length === 0) {
+      videoFiles = glob.sync(`${latestSession}/*.webm`, { cwd });
+    }
+    const eventsPath = join(cwd, latestSession, 'execute_live', 'events.json');
+    const resultPath = join(cwd, latestSession, 'execute_live', 'result.json');
+    const titlePath = join(cwd, latestSession, 'title.txt');
+    
+    // Get generated test from configured path (e.g., tests/auth/login.spec.js)
+    const generatedTestPath = getGeneratedTestPath(specPath, config);
+    const fullGeneratedTestPath = join(cwd, generatedTestPath);
+    const generatedTestExists = existsSync(fullGeneratedTestPath);
+    
+    if (videoFiles.length === 0) {
+      uploadSpinner.warn('No video file found in session folder, skipping upload');
+      return;
+    }
+    
+    const videoPath = join(cwd, videoFiles[0]);
+    const executionTitle = existsSync(titlePath) ? readFileSync(titlePath, 'utf-8').trim() : null;
+    
+    logger.debug(`Video exists: ${existsSync(videoPath)}`);
+    logger.debug(`Events exists: ${existsSync(eventsPath)}`);
+    
+    // Handle collection creation if needed (optional)
+    let collectionId = null;
+    let collectionName = null;
+    
+    if (collectionIdOrName) {
+      uploadSpinner.text = 'Resolving collection...';
+      const accountApiUrl = getAccountApiUrl();
+      const collectionResponse = await fetch(`${accountApiUrl}/collections/resolve`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          collectionIdOrName
+        }),
+      });
+
+      if (!collectionResponse.ok) {
+        const errorData = await collectionResponse.json().catch(() => ({}));
+        throw new Error(errorData.error || 'Failed to resolve collection');
+      }
+
+      const collectionData = await collectionResponse.json();
+      collectionId = collectionData.collectionId;
+      collectionName = collectionData.collectionName;
+      
+      if (collectionData.isNew) {
+        uploadSpinner.text = `Created new collection: ${collectionName}`;
+      }
+    }
+    
+    // Step 1: Calculate file sizes first (for quota check)
+    uploadSpinner.text = 'Preparing upload...';
+    
+    const fileSizes = {
+      video: existsSync(videoPath) ? readFileSync(videoPath).length : 0,
+      events: existsSync(eventsPath) ? readFileSync(eventsPath).length : 0,
+      instructions: (() => {
+        const sourceTestPath = getSourceTestPath(specPath, config);
+        const fullSourceTestPath = join(cwd, sourceTestPath);
+        return existsSync(fullSourceTestPath) ? readFileSync(fullSourceTestPath).length : 0;
+      })(),
+      result: existsSync(resultPath) ? readFileSync(resultPath).length : 0,
+    };
+    
+    // Validate file sizes locally before requesting upload
+    const totalSize = fileSizes.video + fileSizes.events + fileSizes.instructions + fileSizes.result;
+    const totalSizeMB = (totalSize / 1024 / 1024).toFixed(2);
+    
+    if (fileSizes.video > 50 * 1024 * 1024) {
+      throw new Error(`Video file too large: ${(fileSizes.video / 1024 / 1024).toFixed(2)}MB (max: 50MB)`);
+    }
+    if (totalSize > 60 * 1024 * 1024) {
+      throw new Error(`Total upload size too large: ${totalSizeMB}MB (max: 60MB)`);
+    }
+    
+    // Step 2: Initiate upload (with file sizes for quota check)
+    uploadSpinner.text = `Getting upload URLs... (${totalSizeMB}MB)`;
+    
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    };
+    
+    // Add user session token for two-layer auth (if logged in)
+    if (sessionToken) {
+      headers['X-User-Token'] = sessionToken;
+    }
+    
+    const agentProvider = typeof agent === 'object' ? agent.provider : (agent || 'cursor');
+    const rawModel = typeof agent === 'object' ? (agent[agentProvider]?.model || null) : null;
+    const agentModel = (rawModel === 'auto' && agentProvider === 'claude')
+      ? DEFAULT_MODELS.CLAUDE
+      : rawModel;
+
+    const initResponse = await fetch(`${apiUrl}/executions/upload`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        collectionId: collectionId || null,
+        specPath,
+        specContent: (() => {
+          const sourceTestPath = getSourceTestPath(specPath, config);
+          const fullSourceTestPath = join(cwd, sourceTestPath);
+          if (existsSync(fullSourceTestPath)) {
+            return readFileSync(fullSourceTestPath, 'utf-8');
+          }
+          return existsSync(fullSpecPath) ? readFileSync(fullSpecPath, 'utf-8') : '';
+        })(),
+        title: executionTitle || null,
+        agentType: agentProvider,
+        model: agentModel,
+        metadata: {
+          agent: agent || 'cursor',
+          timestamp: new Date().toISOString(),
+          folder: folder || null,
+          collectionName: collectionName || null,
+        },
+        fileSizes,
+      }),
+    });
+
+    if (!initResponse.ok) {
+      const error = await initResponse.json();
+      
+      // Handle file size limit errors (413 Payload Too Large)
+      if (initResponse.status === 413) {
+        if (error.details && Array.isArray(error.details)) {
+          throw new Error(
+            `File size limit exceeded:\n${ 
+            error.details.map(d => `  • ${d}`).join('\n') 
+            }\n\nCompress your files or reduce recording quality.`
+          );
+        }
+        throw new Error(error.error || 'Upload files too large');
+      }
+      
+      // Handle quota exceeded errors
+      if (initResponse.status === 429) {
+        if (error.quotaInfo) {
+          throw new Error(
+            `Video verification quota exceeded (${error.quotaInfo.used}/${error.quotaInfo.limit}).\n` +
+            `Plan: ${error.quotaInfo.planId}. Resets: ${new Date(error.quotaInfo.periodEnd).toLocaleDateString()}\n` +
+            `Upgrade at: https://studio.zibby.app/billing`
+          );
+        } else if (error.storageInfo) {
+          const usedGB = (error.storageInfo.used / (1024 * 1024 * 1024)).toFixed(2);
+          const limitGB = (error.storageInfo.limit / (1024 * 1024 * 1024)).toFixed(2);
+          const uploadMB = (error.storageInfo.uploadSize / (1024 * 1024)).toFixed(2);
+          throw new Error(
+            `Storage quota would be exceeded.\n` +
+            `Current usage: ${usedGB}GB / ${limitGB}GB\n` +
+            `This upload: ${uploadMB}MB\n` +
+            `Plan: ${error.storageInfo.planId}\n` +
+            `Upgrade at: https://studio.zibby.app/billing`
+          );
+        }
+      }
+      
+      throw new Error(error.error || 'Failed to initiate upload');
+    }
+
+    const { executionId, uploadUrls, isOrphan, projectId } = await initResponse.json();
+
+    // Step 2: Upload video
+    uploadSpinner.text = `Uploading video... (${executionId})`;
+    const videoBuffer = readFileSync(videoPath);
+    logger.debug(`Video buffer size: ${videoBuffer.length} bytes`);
+    logger.debug('Upload URL received (redacted)');
+    
+    const videoUpload = await fetch(uploadUrls.video, {
+      method: 'PUT',
+      body: videoBuffer,
+      headers: {
+        'Content-Type': 'video/webm',
+        'Content-Length': videoBuffer.length.toString(),
+      },
+    });
+
+    logger.debug(`Video upload status: ${videoUpload.status} ${videoUpload.statusText}`);
+    
+    if (!videoUpload.ok) {
+      const errorText = await videoUpload.text();
+      throw new Error(`Failed to upload video: ${videoUpload.status} ${videoUpload.statusText} - ${errorText}`);
+    }
+    
+    logger.info('Video uploaded successfully');
+
+    // Step 3: Upload events (if exists)
+    // Events are already enriched with AI descriptions by result-handler.js
+    if (existsSync(eventsPath) && uploadUrls.events) {
+      uploadSpinner.text = 'Uploading events...';
+      const eventsBuffer = readFileSync(eventsPath);
+            
+      const eventsUpload = await fetch(uploadUrls.events, {
+        method: 'PUT',
+        body: eventsBuffer,
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': eventsBuffer.length.toString(),
+        },
+      });
+
+      logger.debug(`Events upload status: ${eventsUpload.status} ${eventsUpload.statusText}`);
+      
+      if (!eventsUpload.ok) {
+        throw new Error('Failed to upload events');
+      }
+      
+      logger.info('Events uploaded successfully');
+    } else {
+      logger.debug(`Skipping events upload - exists: ${existsSync(eventsPath)}, hasUrl: ${!!uploadUrls.events}`);
+    }
+
+    // Step 4: Upload generated test (if exists)
+    if (generatedTestExists && uploadUrls.generatedTest) {
+      uploadSpinner.text = 'Uploading generated test...';
+      const generatedTestBuffer = readFileSync(fullGeneratedTestPath);
+      const generatedTestUpload = await fetch(uploadUrls.generatedTest, {
+        method: 'PUT',
+        body: generatedTestBuffer,
+        headers: {
+          'Content-Type': 'application/javascript',
+          'Content-Length': generatedTestBuffer.length.toString(),
+        },
+      });
+
+      if (!generatedTestUpload.ok) {
+        throw new Error('Failed to upload generated test');
+      }
+    }
+
+    // Step 4.5: Upload test instructions (original .txt file if exists)
+    if (uploadUrls.testInstructions) {
+      const sourceTestPath = getSourceTestPath(specPath, config);
+      const fullSourceTestPath = join(cwd, sourceTestPath);
+
+      if (existsSync(fullSourceTestPath)) {
+        uploadSpinner.text = 'Uploading test instructions...';
+        const testInstructionsBuffer = readFileSync(fullSourceTestPath);
+        const testInstructionsUpload = await fetch(uploadUrls.testInstructions, {
+          method: 'PUT',
+          body: testInstructionsBuffer,
+          headers: {
+            'Content-Type': 'text/plain',
+            'Content-Length': testInstructionsBuffer.length.toString(),
+          },
+        });
+
+        if (!testInstructionsUpload.ok) {
+          logger.warn('Failed to upload test instructions (non-blocking)');
+        } else {
+          logger.debug('Test instructions uploaded successfully');
+        }
+      } else {
+        console.log(`ℹ️  No source test instructions found at ${sourceTestPath}`);
+      }
+    }
+
+    // Step 4.6: Upload result.json (execution results with assertions)
+    if (uploadUrls.result && existsSync(resultPath)) {
+      uploadSpinner.text = 'Uploading test results...';
+      const resultBuffer = readFileSync(resultPath);
+      const resultUpload = await fetch(uploadUrls.result, {
+        method: 'PUT',
+        body: resultBuffer,
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': resultBuffer.length.toString(),
+        },
+      });
+
+      if (!resultUpload.ok) {
+        logger.warn('Failed to upload result.json (non-blocking)');
+      } else {
+        logger.debug('result.json uploaded successfully');
+      }
+    }
+
+    // Step 5: Confirm upload (fileSizes already calculated above)
+    uploadSpinner.text = 'Confirming upload...';
+    
+    const confirmResponse = await fetch(`${apiUrl}/executions/${executionId}/confirm`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        status: 'completed',
+        metadata: {
+          uploadedAt: new Date().toISOString(),
+        },
+        fileSizes,
+      }),
+    });
+
+    if (!confirmResponse.ok) {
+      throw new Error('Failed to confirm upload');
+    }
+
+    uploadSpinner.succeed('Uploaded to Zibby Cloud!');
+    
+    console.log(chalk.gray(`\n${  '━'.repeat(50)}`));
+    console.log(chalk.white(`Execution ID: ${chalk.cyan(executionId)}`));
+    
+    const frontendUrl = getFrontendUrl();
+    
+    if (isOrphan) {
+      console.log(chalk.white(`Location: ${chalk.yellow('History tab')}`));
+    } else {
+      console.log(chalk.white(`Collection: ${chalk.cyan(collectionId)}`));
+    }
+    
+    const executionUrl = projectId 
+      ? `${frontendUrl}/projects/${projectId}/runs/${executionId}`
+      : `${frontendUrl}/history?execution=${executionId}`;
+    console.log(chalk.white(`View execution: ${chalk.cyan(executionUrl)}`));
+    console.log(chalk.gray(`${'━'.repeat(50)  }\n`));
+    
+    // Return execution info for --open flag
+    return {
+      success: true,
+      executionId,
+      projectId: projectId || null,
+    };
+    
+  } catch (error) {
+    uploadSpinner.fail('Upload failed');
+    console.log(chalk.red(`   ${error.message}`));
+    if (process.env.DEBUG) {
+      console.log(chalk.gray(`   Stack: ${error.stack}`));
+    }
+    console.log(chalk.gray('   Continuing without upload...\n'));
+    return { success: false };
+  }
+}
+
+async function fetchSourceTestCases(executionId, sourceIds, apiKey) {
+  const apiUrl = getApiUrl();
+  const ids = sourceIds.join(',');
+  const response = await fetch(`${apiUrl}/executions/${executionId}/test-cases?ids=${ids}`, {
+    headers: { 'Authorization': `Bearer ${apiKey}` }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch test cases: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  return data.testCases || [];
+}
+
+export async function runCommand(specPath, options) {
+  const _env = getCurrentEnvironment();
+  
+  // Set up graceful shutdown on Ctrl+C
+  // Note: We don't handle SIGINT at this level anymore
+  // Let the agent's executePrompt handle it and propagate naturally
+  
+  console.log(chalk.bold.cyan('\nZibby Test Automation\n'));
+  console.log(chalk.gray('━'.repeat(50)));
+
+  // --sources mode: fetch test cases from cloud and run them
+  if (options.sources) {
+    if (!options.execution) {
+      console.log(chalk.red('\n❌ --execution <id> is required when using --sources\n'));
+      process.exit(1);
+    }
+    const apiKey = options.project || process.env.ZIBBY_API_KEY;
+    if (!apiKey) {
+      console.log(chalk.red('\n❌ --project <id> or ZIBBY_API_KEY required when using --sources\n'));
+      process.exit(1);
+    }
+
+    const sourceIds = options.sources.split(',').map(s => s.trim());
+    console.log(chalk.white(`Fetching ${sourceIds.length} test case(s) from execution ${chalk.cyan(options.execution)}...`));
+
+    const testCases = await fetchSourceTestCases(options.execution, sourceIds, apiKey);
+    if (testCases.length === 0) {
+      console.log(chalk.red('\nNo test cases found for the given IDs\n'));
+      process.exit(1);
+    }
+
+    console.log(chalk.green(`✓ Fetched ${testCases.length} test case(s)`));
+
+    // Write each test case to a temp spec file and run sequentially
+    const { mkdirSync, writeFileSync } = await import('fs');
+    const tmpDir = resolve(process.cwd(), '.zibby-tmp');
+    mkdirSync(tmpDir, { recursive: true });
+
+    for (const tc of testCases) {
+      const specContent = `# ${tc.title}\n\n${tc.content}`;
+      const tmpSpec = resolve(tmpDir, `${tc.id}.txt`);
+      writeFileSync(tmpSpec, specContent, 'utf-8');
+      console.log(chalk.gray('━'.repeat(50)));
+      console.log(chalk.white(`\nRunning: ${chalk.cyan(tc.title)} (${tc.id})`));
+
+      // Recurse into runCommand with the temp spec file, carrying over options but without --sources
+      const childOptions = { ...options, sources: undefined, execution: undefined };
+      // Force sync on
+      childOptions.sync = true;
+      await runCommand(tmpSpec, childOptions);
+    }
+
+    // Cleanup
+    const { rmSync } = await import('fs');
+    rmSync(tmpDir, { recursive: true, force: true });
+    return;
+  }
+
+  if (!specPath && !options.sources) {
+    console.log(chalk.red('\n❌ Missing test spec path\n'));
+    console.log(chalk.white('Usage:'));
+    console.log(chalk.gray('  zibby run <spec-path>          Run a test spec file'));
+    console.log(chalk.gray('  zibby run test-specs/login.txt  Example\n'));
+    process.exit(1);
+  }
+
+  const fullSpecPath = resolve(process.cwd(), specPath);
+  
+  if (!existsSync(fullSpecPath)) {
+    console.log(chalk.red(`\n❌ Test spec not found: ${specPath}\n`));
+    process.exit(1);
+  }
+
+  let config = {
+    headless: options.headless || false,
+    playwrightArtifacts: true, // Enable trace.zip generation for exact selectors
+  };
+
+  const configPath = resolve(process.cwd(), options.config);
+  if (existsSync(configPath)) {
+    try {
+      const userConfig = await import(configPath);
+      // Infer provider from agent config (claude/cursor key presence)
+      const inferProvider = (agentConfig) => {
+        if (agentConfig?.provider) return agentConfig.provider;
+        if (agentConfig?.claude) return 'claude';
+        if (agentConfig?.cursor) return 'cursor';
+        return 'claude';
+      };
+      
+      config = {
+        ...config,
+        ...userConfig.default,
+        // Preserve full agent object, infer or override provider
+        agent: userConfig.default?.agent ? {
+          ...userConfig.default.agent,
+          provider: options.agent || inferProvider(userConfig.default.agent)
+        } : { provider: options.agent || 'claude' },
+        mcp: userConfig.default?.browser?.mcp || 'playwright',
+        headless: options.headless !== undefined ? options.headless : userConfig.default?.browser?.headless,
+        paths: userConfig.default?.paths || { specs: 'test-specs', generated: 'tests' },
+        cloudSync: userConfig.default?.cloudSync || false,
+      };
+    } catch (_error) {
+      console.log(chalk.yellow(`⚠️  Could not load config from ${options.config}`));
+    }
+  } else {
+    // No config file, use defaults
+    config.agent = { provider: options.agent || 'claude' };
+    config.cloudSync = false;
+  }
+
+  // Check cloud sync requirements BEFORE running test
+  let apiKey = process.env.ZIBBY_API_KEY;
+  const shouldSync = options.sync || (config.cloudSync === true && options.sync !== false);
+  
+  // If --project flag is a token (starts with zby_), use it as API key override
+  if (options.project && options.project.startsWith('zby_')) {
+    apiKey = options.project;
+    console.log(chalk.gray('Using --project as API token (overriding .env)'));
+  }
+  
+  if (shouldSync && !apiKey) {
+    console.log(chalk.red('\n❌ Error: Cloud sync is enabled but ZIBBY_API_KEY not set\n'));
+    console.log(chalk.white('Cloud sync is enabled in .zibby.config.js'));
+    console.log(chalk.white('You need to set ZIBBY_API_KEY in .env file\n'));
+    console.log(chalk.white('Option 1: Add to .env file:'));
+    console.log(chalk.gray('  ZIBBY_API_KEY=zby_your_key_here\n'));
+    console.log(chalk.white('Option 2: Disable cloud sync:'));
+    console.log(chalk.gray('  Edit .zibby.config.js → cloudSync: false\n'));
+    console.log(chalk.white('Get your API key from: https://zibby.dev/dashboard\n'));
+    process.exit(1);
+  }
+  
+  if (shouldSync && apiKey) {
+    let sessionToken = process.env.ZIBBY_USER_TOKEN;
+    let userInfo;
+
+    if (sessionToken) {
+      console.log(chalk.gray('Using Personal Access Token from ZIBBY_USER_TOKEN'));
+    } else {
+      sessionToken = getSessionToken();
+      userInfo = getUserInfo();
+      
+      if (!sessionToken || !userInfo) {
+        console.log(chalk.red('\n❌ Error: User authentication required for uploads\n'));
+        console.log(chalk.gray('Choose one of these options:\n'));
+        console.log(chalk.cyan('  Option 1 (Local Development):'));
+        console.log(chalk.gray('    zibby login\n'));
+        console.log(chalk.cyan('  Option 2 (CI/CD):'));
+        console.log(chalk.gray('    1. Generate a Personal Access Token at:'));
+        console.log(chalk.gray('       https://zibby.app/settings/tokens'));
+        console.log(chalk.gray('    2. Set environment variable:'));
+        console.log(chalk.gray('       export ZIBBY_USER_TOKEN=zby_pat_xxxxx\n'));
+        process.exit(1);
+      }
+
+      if (userInfo) {
+        console.log(chalk.gray(`Authenticated: ${userInfo.email} (${userInfo.name || 'User'})`));
+      }
+    }
+  }
+  
+  if (shouldSync && apiKey) {
+    const apiUrl = getApiUrl();
+    
+    try {
+      if (!apiKey.startsWith('zby_')) {
+        console.log(chalk.red(`\n❌ Invalid API token format\n`));
+        console.log(chalk.white('This CLI requires a project API token (starts with "zby_").'));
+        console.log(chalk.gray(`   Format: zby_***\n`));
+        console.log(chalk.white('Get your project API token from settings:\n'));
+        console.log(chalk.gray('   Local: http://localhost:3001/settings'));
+        console.log(chalk.gray('   Prod: https://app.zibby.app/settings\n'));
+        process.exit(1);
+      }
+      
+      const projectsResponse = await fetch(`${apiUrl}/projects`, {
+        headers: { 'Authorization': `Bearer ${apiKey}` }
+      });
+      
+      if (!projectsResponse.ok) {
+        console.log(chalk.red(`\n❌ Unauthorized: Invalid project API token\n`));
+        console.log(chalk.white('Your project API token is invalid or does not have access.'));
+        console.log(chalk.gray(`   Token format: zby_***\n`));
+        console.log(chalk.white('Get your project API token from settings:\n'));
+        console.log(chalk.gray('   Local: http://localhost:3001/settings'));
+        console.log(chalk.gray('   Prod: https://app.zibby.app/settings\n'));
+        process.exit(1);
+      }
+      
+      const projectsData = await projectsResponse.json();
+      const projectsList = projectsData.projects || [];
+      
+      if (!projectsList || projectsList.length === 0) {
+        console.log(chalk.red(`\n❌ No projects found for this token\n`));
+        process.exit(1);
+      }
+      
+      // Use the first project (project tokens are scoped to a single project)
+      const project = projectsList[0];
+      console.log(chalk.green(`✓ Authorized for project: ${project.name} (${project.projectId})`));
+    } catch (error) {
+      console.log(chalk.red(`\n❌ Failed to validate API credentials: ${error.message}\n`));
+      process.exit(1);
+    }
+  }
+
+  if (config.agent === 'claude' && !process.env.ANTHROPIC_API_KEY) {
+    console.log(chalk.red('\n❌ Error: ANTHROPIC_API_KEY not set\n'));
+    console.log(chalk.white('Set your API key:'));
+    console.log(chalk.gray('  export ANTHROPIC_API_KEY="sk-ant-..."\n'));
+    console.log(chalk.white('Or add to .env file:'));
+    console.log(chalk.gray('  ANTHROPIC_API_KEY=sk-ant-...\n'));
+    console.log(chalk.white('Get your API key from: https://console.anthropic.com/\n'));
+    process.exit(1);
+  }
+
+  if (config.agent === 'cursor') {
+    const { checkCursorAgentInstalled, getCursorAgentInstallInstructions } = await import('@zibby/core');
+    const installed = await checkCursorAgentInstalled();
+    
+    if (!installed) {
+      console.log(chalk.red(getCursorAgentInstallInstructions()));
+      process.exit(1);
+    }
+    
+    // Check for CURSOR_API_KEY (required in CI, optional locally if Cursor IDE is installed)
+    const isCI = process.env.CI || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.GITHUB_ACTIONS;
+    
+    if (!process.env.CURSOR_API_KEY) {
+      if (isCI) {
+        // Required in CI environments
+        console.log(chalk.red('\n❌ Error: CURSOR_API_KEY not set\n'));
+        console.log(chalk.white('In CI/CD, you must provide your Cursor API key:'));
+        console.log(chalk.gray('  export CURSOR_API_KEY="your-cursor-token-here"\n'));
+        console.log(chalk.white('Get your API key from: https://cursor.com/settings\n'));
+        console.log(chalk.white('Add it to your CI/CD environment variables.\n'));
+        process.exit(1);
+      } else {
+        // Optional locally - show warning
+        console.log(chalk.yellow('⚠️  CURSOR_API_KEY not set (using locally stored Cursor credentials)\n'));
+      }
+    }
+  }
+
+  console.log(chalk.white(`Test Spec: ${chalk.cyan(specPath)}`));
+  const agentProvider = typeof config.agent === 'object' ? config.agent.provider : config.agent;
+  console.log(chalk.white(`Agent: ${chalk.cyan(agentProvider)}`));
+  console.log(chalk.white(`Browser: ${chalk.cyan(config.mcp || 'playwright')} ${config.headless ? chalk.gray('(headless)') : chalk.gray('(headed)')}`));
+  if (config.cloudSync) {
+    console.log(chalk.white(`Cloud Sync: ${chalk.green('enabled')}`));
+  }
+  if (options.autoApprove) {
+    console.log(chalk.white(`Auto-approve: ${chalk.yellow('enabled (CI/CD mode)')}`));
+  }
+  if (options.collection) {
+    console.log(chalk.white(`Collection: ${chalk.cyan(options.collection)}${options.folder ? ` / ${options.folder}` : ''}`));
+  } else {
+    console.log(chalk.gray(`Mode: Orphan execution (History tab)`));
+  }
+
+  if (process.env.ZIBBY_MEMORY) {
+    try {
+      const { DoltDB } = await import('@zibby/memory');
+      const doltAvailable = DoltDB.isAvailable();
+      const dbExists = existsSync(join(process.cwd(), '.zibby', 'memory', '.dolt'));
+
+      if (!doltAvailable) {
+        console.log(chalk.red(`\n❌ Memory requires Dolt but it's not installed\n`));
+        console.log(chalk.white(`  Install:`));
+        console.log(chalk.gray(`    brew install dolt          # macOS`));
+        console.log(chalk.gray(`    curl -L https://github.com/dolthub/dolt/releases/latest/download/install.sh | sudo bash  # Linux\n`));
+        console.log(chalk.white(`  Then initialize:`));
+        console.log(chalk.gray(`    zibby init --mem\n`));
+        process.exit(1);
+      } else if (!dbExists) {
+        console.log(chalk.red(`\n❌ Memory database not initialized\n`));
+        console.log(chalk.white(`  Run:`));
+        console.log(chalk.gray(`    zibby init --mem\n`));
+        process.exit(1);
+      } else {
+        console.log(chalk.white(`Memory: ${chalk.green('enabled')}`));
+      }
+    } catch {
+      console.log(chalk.red(`\n❌ Memory requested but @zibby/memory package is not available\n`));
+      process.exit(1);
+    }
+  }
+
+  console.log(chalk.gray('━'.repeat(50)));
+
+  const spinner = ora('Initializing...').start();
+
+  try {
+    // Stop spinner before test execution to allow clean streaming output
+    spinner.stop();
+    
+    const fallbackAgentModule = await import('@zibby/core/templates/browser-test-automation/graph.js').catch(() => null);
+
+    const result = await runTest(fullSpecPath, {
+      ...config,
+      specPath,
+      apiKey: process.env.ANTHROPIC_API_KEY,
+      autoApprove: options.autoApprove,
+      force: options.autoApprove,
+      singleNode: options.node,
+      sessionId: options.session,
+      workflow: options.workflow,
+      contextConfig: config.context,
+      fallbackAgentModule,
+    });
+
+    // Normalize output path - remove double slashes and make relative
+    let normalizedPath = result.outputPath || null;
+    if (normalizedPath) {
+      normalizedPath = normalizedPath.replace(/\/+/g, '/');
+      if (normalizedPath.includes(process.cwd())) {
+        normalizedPath = normalizedPath.replace(`${process.cwd()  }/`, '');
+      }
+    }
+
+    // Only show success message if test was actually generated
+    const testGenerated = result.state?.generate_script?.scriptPath || 
+                          result.state?.verify_script?.success;
+    
+    console.log(chalk.gray(`\n${  '━'.repeat(50)}`));
+    
+    if (testGenerated && normalizedPath) {
+      console.log(chalk.green('✓ Test execution completed'));
+      console.log(chalk.white(`Generated test: ${chalk.cyan(normalizedPath)}`));
+      if (result.toolCount !== undefined) {
+        console.log(chalk.white(`Tools used: ${chalk.cyan(result.toolCount)}`));
+      }
+      console.log(chalk.gray(`${'━'.repeat(50)  }\n`));
+      
+      console.log(chalk.cyan('Next steps:'));
+      console.log(chalk.white(`  1. Review generated test: ${normalizedPath}`));
+      console.log(chalk.white(`  2. Run with Playwright: npx playwright test ${normalizedPath}`));
+      console.log(chalk.white(`  3. View report: npx playwright show-report\n`));
+    } else {
+      // Workflow stopped early - check if execute_live completed
+      const executeLiveResult = result.state?.execute_live;
+      
+      if (executeLiveResult) {
+        // execute_live ran but returned success=false
+        const hasRealExecution = executeLiveResult.steps?.length > 0 || executeLiveResult.actions?.length > 0;
+        
+        if (hasRealExecution) {
+          // Test executed but found failures
+          console.log(chalk.white(`\nExecution Summary:`));
+          console.log(chalk.white(`  Steps: ${executeLiveResult.steps?.length || 0}`));
+          console.log(chalk.white(`  Actions: ${executeLiveResult.actions?.length || 0}`));
+          if (executeLiveResult.finalUrl) {
+            console.log(chalk.white(`  Final URL: ${executeLiveResult.finalUrl}`));
+          }
+          if (executeLiveResult.notes) {
+            console.log(chalk.white(`\n📝 ${executeLiveResult.notes}`));
+          }
+        } else {
+          // execute_live couldn't run (no tools, etc.)
+          console.log(chalk.red('✖ Workflow did not complete'));
+          console.log(chalk.yellow(`\n⚠️  ${executeLiveResult.notes || 'Test execution failed'}`));
+        }
+      } else {
+        // Unknown failure
+        console.log(chalk.red('✖ Workflow did not complete'));
+      }
+      
+      console.log(chalk.gray(`${'━'.repeat(50)  }\n`));
+    }
+
+    // Auto-sync to cloud if enabled (already declared above)
+    // Skip upload for single node runs (incomplete artifacts)
+    if (options.node) {
+      console.log(chalk.gray('\nNote: Upload skipped for single node execution'));
+      console.log(chalk.gray('   Run full workflow to upload all artifacts\n'));
+    } else if (shouldSync) {
+      // Use --project flag as API key (preferred), otherwise fall back to ZIBBY_API_KEY
+      const uploadApiKey = options.project || process.env.ZIBBY_API_KEY;
+      
+      if (!uploadApiKey) {
+        console.log(chalk.yellow('\nCloud sync enabled but no API key provided'));
+        console.log(chalk.gray('   Option 1: Use --project flag: --project zby_xxx'));
+        console.log(chalk.gray('   Option 2: Add to .env: ZIBBY_API_KEY=zby_xxx\n'));
+      } else {
+        const uploadResult = await uploadExecution({
+          apiKey: uploadApiKey,
+          specPath,
+          fullSpecPath,
+          projectId: null, // Backend extracts from API key
+          collectionIdOrName: options.collection || null,
+          folder: options.folder,
+          agent: config.agent,
+          config,
+          result, // Pass the result with codegenFiles
+          shouldOpen: options.open,
+        });
+        
+        // Open browser if --open flag is set and upload succeeded
+        if (options.open && uploadResult?.success && uploadResult.executionId && uploadResult.projectId) {
+          await openTestResultsInBrowser(uploadResult.executionId, uploadResult.projectId);
+        }
+      }
+    }
+
+  } catch (error) {
+    // Stop spinner if still running
+    if (spinner.isSpinning) {
+      spinner.stop();
+    }
+
+    if (process.env.ZIBBY_MEMORY) {
+      try {
+        const { memoryEndRun } = await import('@zibby/memory');
+        memoryEndRun(process.cwd(), { passed: false });
+      } catch { /* @zibby/memory not available */ }
+    }
+    
+    console.log(chalk.red('\n✖ Test failed\n'));
+    
+    // Check if error is from user interruption
+    if (error.message.includes('Interrupted by user')) {
+      console.log(chalk.yellow('Test execution was interrupted\n'));
+      process.exit(130);
+    }
+    
+    console.log(chalk.red(`Error: ${error.message}\n`));
+    if (error.stack) {
+      console.log(chalk.gray(error.stack));
+    }
+    process.exit(1);
+  }
+}
+