@zibby/cli 0.1.5

package/src/commands/setup-scripts.js

@@ -0,0 +1,101 @@
+import { spawn } from 'child_process';
+import { resolve, join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function runScript(scriptName, description, headed = false, cloudSync = false, video = 'on', viewport = null) {
+  const corePackagePath = resolve(__dirname, '../../../core');
+  const scriptPath = join(corePackagePath, 'scripts', scriptName);
+
+  const env = { ...process.env };
+  // Default is headed mode, so only set env var for headless
+  if (!headed) {
+    env.ZIBBY_HEADLESS = '1';
+  }
+  if (cloudSync) {
+    env.ZIBBY_CLOUD_SYNC = '1';
+  }
+  if (video) {
+    env.ZIBBY_VIDEO = video;
+  }
+  if (viewport) {
+    env.ZIBBY_VIEWPORT_WIDTH = String(viewport.width || 1280);
+    env.ZIBBY_VIEWPORT_HEIGHT = String(viewport.height || 720);
+  }
+
+  return new Promise((resolveFn, reject) => {
+    const script = spawn('bash', [scriptPath], {
+      cwd: process.cwd(),
+      stdio: 'inherit',
+      env,
+    });
+
+    script.on('close', (code) => {
+      if (code === 0) {
+        resolveFn({ success: true });
+      } else {
+        reject(new Error(`Script exited with code ${code}`));
+      }
+    });
+
+    script.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+export async function setupPlaywrightMcpCommand(options = {}) {
+  // Let the caller handle errors gracefully (e.g., init.js has a try/catch)
+  await runScript('setup-official-playwright-mcp.sh', 'Setting up official Playwright MCP', options.headed, options.cloudSync, options.video, options.viewport);
+}
+
+export async function setupCiCommand(_options) {
+  try {
+    await runScript('setup-ci.sh', 'Complete CI/CD setup');
+    console.log(chalk.green('\n✅ CI/CD setup complete!\n'));
+  } catch (error) {
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+
+export async function testWithVideoCommand(testFile, options) {
+  try {
+    const corePackagePath = resolve(__dirname, '../../../core');
+    const scriptPath = join(corePackagePath, 'scripts', 'test-with-video.sh');
+    
+    const args = [scriptPath, testFile || 'tests/'];
+    if (options.headed) {
+      args.push('headed');
+    }
+
+    console.log(chalk.cyan('\n🎥 Running tests with video recording...\n'));
+    console.log(chalk.gray('━'.repeat(50)));
+
+    const script = spawn('bash', args, {
+      cwd: process.cwd(),
+      stdio: 'inherit',
+    });
+
+    script.on('close', (code) => {
+      if (code === 0) {
+        console.log(chalk.green('\n✅ Tests complete!\n'));
+      } else {
+        console.log(chalk.red(`\n❌ Tests failed with code ${code}\n`));
+        process.exit(code);
+      }
+    });
+
+    script.on('error', (error) => {
+      console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+      process.exit(1);
+    });
+  } catch (error) {
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+

package/src/commands/upload.js

@@ -0,0 +1,163 @@
+import { readFileSync, existsSync, statSync } from 'fs';
+import { join, basename } from 'path';
+import { glob } from 'glob';
+import chalk from 'chalk';
+import ora from 'ora';
+import dotenv from 'dotenv';
+import fetch from 'node-fetch';
+import { getApiUrl, getCurrentEnvironment, getFrontendUrl } from '../config/environments.js';
+import { getSessionToken, getUserInfo } from '../config/config.js';
+
+dotenv.config();
+
+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');
+}
+
+export async function uploadCommand(specPath, options) {
+  const env = getCurrentEnvironment();
+  
+  console.log(chalk.bold.cyan('\n📤 Zibby Cloud Upload\n'));
+  console.log(chalk.gray('━'.repeat(50)));
+  console.log(chalk.white(`Environment: ${chalk.cyan(env.name)}\n`));
+
+  const cwd = process.cwd();
+  
+  const apiKey = options.project || process.env.ZIBBY_API_KEY;
+  
+  if (!apiKey) {
+    console.log(chalk.red('❌ Error: Project API key required\n'));
+    console.log(chalk.white('Provide via:'));
+    console.log(chalk.gray('  --project <token>'));
+    console.log(chalk.gray('  or ZIBBY_API_KEY in .env\n'));
+    process.exit(1);
+  }
+
+  const sessionToken = process.env.ZIBBY_USER_TOKEN || getSessionToken();
+  const userInfo = getUserInfo();
+
+  if (!sessionToken) {
+    console.log(chalk.red('\n❌ Error: User authentication required\n'));
+    console.log(chalk.cyan('Option 1 (Local):'));
+    console.log(chalk.gray('  zibby login\n'));
+    console.log(chalk.cyan('Option 2 (CI/CD):'));
+    console.log(chalk.gray('  export ZIBBY_USER_TOKEN=zby_pat_xxxxx\n'));
+    process.exit(1);
+  }
+
+  if (userInfo) {
+    console.log(chalk.gray(`Authenticated: ${userInfo.email}\n`));
+  } else {
+    console.log(chalk.gray('Authenticated: Using Personal Access Token\n'));
+  }
+
+  const sessionFolders = glob.sync('test-results/sessions/*', { cwd })
+    .filter(f => {
+      const stat = statSync(join(cwd, f));
+      return stat.isDirectory() && !/session_/.test(f);
+    })
+    .sort((a, b) => {
+      const statA = statSync(join(cwd, a));
+      const statB = statSync(join(cwd, b));
+      return statB.mtimeMs - statA.mtimeMs;
+    });
+
+  if (sessionFolders.length === 0) {
+    console.log(chalk.red('❌ No test results found\n'));
+    console.log(chalk.white('Run a test first: zibby run <spec-path>\n'));
+    process.exit(1);
+  }
+
+  const latestSession = sessionFolders[0];
+  const executeLiveDir = join(cwd, latestSession, 'execute_live');
+
+  if (!existsSync(executeLiveDir)) {
+    console.log(chalk.red(`❌ No execution data found in ${latestSession}\n`));
+    process.exit(1);
+  }
+
+  const videoPath = join(executeLiveDir, 'recording.webm');
+  const eventsPath = join(executeLiveDir, 'events.json');
+  const titlePath = join(executeLiveDir, 'title.txt');
+  const generatedTestPath = getGeneratedTestPath(specPath, {});
+
+  console.log(chalk.white('Found artifacts:'));
+  console.log(chalk.gray(`  Session: ${basename(latestSession)}`));
+  console.log(chalk.gray(`  Video: ${existsSync(videoPath) ? '✓' : '✗'}`));
+  console.log(chalk.gray(`  Events: ${existsSync(eventsPath) ? '✓' : '✗'}`));
+  console.log(chalk.gray(`  Test: ${existsSync(generatedTestPath) ? '✓' : '✗'}\n`));
+
+  const uploadSpinner = ora(`Uploading to ${env.name}...`).start();
+
+  try {
+    const formData = new FormData();
+    
+    formData.append('specPath', specPath);
+    formData.append('agent', options.agent || 'cursor');
+    formData.append('agentType', options.agent || 'cursor');
+    
+    if (options.collection) {
+      formData.append('collectionIdOrName', options.collection);
+    }
+    if (options.folder) {
+      formData.append('folder', options.folder);
+    }
+
+    if (existsSync(videoPath)) {
+      const videoBlob = new Blob([readFileSync(videoPath)]);
+      formData.append('video', videoBlob, 'recording.webm');
+    }
+
+    if (existsSync(eventsPath)) {
+      const events = readFileSync(eventsPath, 'utf-8');
+      formData.append('events', events);
+    }
+
+    if (existsSync(generatedTestPath)) {
+      const testCode = readFileSync(generatedTestPath, 'utf-8');
+      formData.append('testCode', testCode);
+    }
+
+    if (existsSync(titlePath)) {
+      const title = readFileSync(titlePath, 'utf-8').trim();
+      formData.append('title', title);
+    }
+
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/executions/upload`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'X-User-Token': sessionToken,
+      },
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      uploadSpinner.fail(`Upload failed: ${response.status}`);
+      console.log(chalk.red(`${body}\n`));
+      process.exit(1);
+    }
+
+    const result = await response.json();
+    uploadSpinner.succeed('Upload complete!');
+
+    console.log(chalk.green(`\n✓ Test uploaded successfully`));
+    console.log(chalk.gray(`  Execution ID: ${result.executionId}`));
+    
+    const frontendUrl = getFrontendUrl();
+    const resultsUrl = `${frontendUrl}/projects/${result.projectId}/runs/${result.executionId}`;
+    console.log(chalk.cyan(`\n  View results: ${resultsUrl}\n`));
+
+  } catch (err) {
+    uploadSpinner.fail('Upload failed');
+    console.log(chalk.red(`\n${err.message}\n`));
+    process.exit(1);
+  }
+}

package/src/commands/video.js

@@ -0,0 +1,30 @@
+import { organizeVideos } from '@zibby/core';
+import { resolve } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export async function videoCommand(_options) {
+  const spinner = ora('Organizing test videos...').start();
+
+  try {
+    const result = await organizeVideos({
+      projectRoot: resolve(process.cwd()),
+      verbose: false,
+    });
+
+    if (result.success) {
+      spinner.succeed(`Organized ${result.movedCount} video(s)`);
+      console.log(chalk.gray('\n📂 Videos are now next to their test files in tests/\n'));
+    } else {
+      spinner.fail('Failed to organize videos');
+      if (result.error) {
+        console.log(chalk.red(`Error: ${result.error}\n`));
+      }
+    }
+  } catch (error) {
+    spinner.fail('Failed to organize videos');
+    console.log(chalk.red(`\n❌ Error: ${error.message}\n`));
+    process.exit(1);
+  }
+}
+

package/src/commands/workflow.js

@@ -0,0 +1,369 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { resolve, join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import dotenv from 'dotenv';
+import fetch from 'node-fetch';
+import { getApiUrl, getCurrentEnvironment } from '../config/environments.js';
+import { validateGraphConfig } from '@zibby/core/framework/graph-compiler.js';
+import { generateWorkflowCode, generateNodeConfigsJson } from '@zibby/core/framework/code-generator.js';
+import '@zibby/core/templates/register-nodes.js';
+
+dotenv.config();
+
+function resolveAuth(options) {
+  const apiKey = options.apiKey || process.env.ZIBBY_API_KEY;
+  if (!apiKey) {
+    console.log(chalk.red('\n  ZIBBY_API_KEY not set'));
+    console.log(chalk.gray('  Add to .env: ZIBBY_API_KEY=zby_xxx\n'));
+    process.exit(1);
+  }
+
+  const projectId = options.project || process.env.ZIBBY_PROJECT_ID;
+  if (!projectId) {
+    console.log(chalk.red('\n  --project or ZIBBY_PROJECT_ID is required'));
+    console.log(chalk.gray('  Example: zibby workflow download --project <id> --type analysis\n'));
+    process.exit(1);
+  }
+
+  return { apiKey, projectId };
+}
+
+const VALID_TYPES = ['analysis', 'implementation', 'run_test'];
+
+function resolveWorkflowType(options) {
+  const type = options.type;
+  if (!type) {
+    console.log(chalk.red('\n  --type is required'));
+    console.log(chalk.gray(`  Valid types: ${VALID_TYPES.join(', ')}\n`));
+    process.exit(1);
+  }
+  if (!VALID_TYPES.includes(type)) {
+    console.log(chalk.red(`\n  Invalid workflow type: "${type}"`));
+    console.log(chalk.gray(`  Valid types: ${VALID_TYPES.join(', ')}\n`));
+    process.exit(1);
+  }
+  return type;
+}
+
+export async function workflowDownloadCommand(options) {
+  const env = getCurrentEnvironment();
+  const { apiKey, projectId } = resolveAuth(options);
+  const workflowType = resolveWorkflowType(options);
+
+  console.log(chalk.bold.cyan('\n  Zibby Workflow Download\n'));
+  console.log(chalk.gray('  '.padEnd(52, '-')));
+  console.log(chalk.white(`  Environment: ${chalk.cyan(env.name)}`));
+  console.log(chalk.white(`  Project:     ${chalk.cyan(projectId)}`));
+  console.log(chalk.white(`  Type:        ${chalk.cyan(workflowType)}`));
+  console.log(chalk.gray('  '.padEnd(52, '-')));
+
+  const spinner = ora('  Fetching workflow from cloud...').start();
+
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/projects/${projectId}/workflows/${workflowType}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      spinner.fail(`  API error: ${response.status}`);
+      console.log(chalk.red(`  ${body}\n`));
+      process.exit(1);
+    }
+
+    const data = await response.json();
+
+    if (!data.graph && data.isDefault) {
+      spinner.info('  No custom workflow saved -- downloading default graph');
+    } else {
+      spinner.succeed(`  Fetched workflow (v${data.version || 0})`);
+    }
+
+    const graphConfig = data.graph || null;
+    if (!graphConfig) {
+      console.log(chalk.yellow('\n  No graph config available for this workflow.'));
+      console.log(chalk.gray('  The project is using the built-in default graph.'));
+      console.log(chalk.gray('  Edit the graph in the UI first, or use --include-default to download the default.\n'));
+
+      if (!options.includeDefault) {
+        process.exit(0);
+      }
+
+      spinner.start('  Fetching default graph...');
+      const { getDefaultGraph } = await import('@zibby/core/templates/graphs/index.js');
+      const defaultGraph = getDefaultGraph(workflowType);
+      if (!defaultGraph) {
+        spinner.fail(`  No default graph found for type "${workflowType}"`);
+        process.exit(1);
+      }
+      return writeWorkflowFile(workflowType, {
+        graph: defaultGraph,
+        version: 0,
+        isDefault: true,
+        projectId,
+        workflowType,
+      }, options);
+    }
+
+    return writeWorkflowFile(workflowType, {
+      graph: graphConfig,
+      version: data.version || 0,
+      isDefault: data.isDefault || false,
+      projectId,
+      workflowType,
+    }, options);
+
+  } catch (err) {
+    spinner.fail('  Download failed');
+    console.log(chalk.red(`\n  ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+function writeWorkflowFile(workflowType, payload, options) {
+  const cwd = process.cwd();
+  const outDir = options.output || join(cwd, '.zibby');
+
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+
+  const meta = {
+    projectId: payload.projectId,
+    workflowType: payload.workflowType,
+    version: payload.version,
+    isDefault: payload.isDefault,
+  };
+
+  const jsFilename = `workflow-${workflowType}.js`;
+  const jsPath = join(outDir, jsFilename);
+  const jsCode = generateWorkflowCode(payload.graph, meta);
+  writeFileSync(jsPath, jsCode, 'utf-8');
+
+  const nodeConfigs = payload.graph.nodeConfigs || {};
+  const runtimeConfigs = generateNodeConfigsJson(nodeConfigs);
+  const configFilename = `workflow-${workflowType}.config.json`;
+  const configPath = join(outDir, configFilename);
+  writeFileSync(configPath, `${JSON.stringify(runtimeConfigs, null, 2)  }\n`, 'utf-8');
+
+  const jsonFilename = `workflow-${workflowType}.json`;
+  const jsonPath = join(outDir, jsonFilename);
+  const jsonContent = {
+    _meta: { ...meta, downloadedAt: new Date().toISOString() },
+    ...payload.graph,
+  };
+  writeFileSync(jsonPath, `${JSON.stringify(jsonContent, null, 2)  }\n`, 'utf-8');
+
+  console.log(chalk.green(`\n  Generated workflow files:`));
+  console.log(chalk.white(`    ${chalk.bold(jsPath)}`));
+  console.log(chalk.gray(`      Executable graph with inline tool bindings`));
+  console.log(chalk.white(`    ${chalk.bold(configPath)}`));
+  console.log(chalk.gray(`      Extra prompt instructions & runtime config`));
+  console.log(chalk.white(`    ${chalk.bold(jsonPath)}`));
+  console.log(chalk.gray(`      Raw JSON config (for upload back to cloud)`));
+  console.log('');
+  console.log(chalk.gray(`  Version: ${payload.version}`));
+  console.log(chalk.gray(`  Nodes:   ${payload.graph.nodes?.length || 0}`));
+  console.log(chalk.gray(`  Edges:   ${payload.graph.edges?.length || 0}\n`));
+
+  console.log(chalk.white('  To run locally:'));
+  console.log(chalk.cyan(`    zibby analyze --workflow ${jsPath}\n`));
+  console.log(chalk.white('  To upload changes back:'));
+  console.log(chalk.cyan(`    zibby workflow upload --project ${payload.projectId} --type ${workflowType}\n`));
+}
+
+export async function workflowUploadCommand(options) {
+  const env = getCurrentEnvironment();
+  const { apiKey, projectId } = resolveAuth(options);
+  const workflowType = resolveWorkflowType(options);
+
+  console.log(chalk.bold.cyan('\n  Zibby Workflow Upload\n'));
+  console.log(chalk.gray('  '.padEnd(52, '-')));
+  console.log(chalk.white(`  Environment: ${chalk.cyan(env.name)}`));
+  console.log(chalk.white(`  Project:     ${chalk.cyan(projectId)}`));
+  console.log(chalk.white(`  Type:        ${chalk.cyan(workflowType)}`));
+  console.log(chalk.gray('  '.padEnd(52, '-')));
+
+  const cwd = process.cwd();
+  const defaultJson = join(cwd, '.zibby', `workflow-${workflowType}.json`);
+  const defaultJs = join(cwd, '.zibby', `workflow-${workflowType}.js`);
+  const filePath = options.file || (existsSync(defaultJs) ? defaultJs : defaultJson);
+
+  if (!existsSync(filePath)) {
+    console.log(chalk.red(`\n  File not found: ${filePath}`));
+    console.log(chalk.gray('  Download a workflow first: zibby workflow download --project <id> --type <type>\n'));
+    process.exit(1);
+  }
+
+  const isJsFile = filePath.endsWith('.js') || filePath.endsWith('.mjs');
+  let graphConfig;
+
+  if (isJsFile) {
+    const loadSpinner = ora('  Loading JS workflow module...').start();
+    try {
+      const { pathToFileURL } = await import('url');
+      const mod = await import(pathToFileURL(resolve(filePath)).href);
+      const graph = mod.buildGraph();
+      graphConfig = graph.serialize();
+
+      const jsNodeConfigs = mod.nodeConfigs || {};
+      if (Object.keys(jsNodeConfigs).length > 0) {
+        for (const [nodeId, conf] of Object.entries(jsNodeConfigs)) {
+          graphConfig.nodeConfigs[nodeId] = { ...conf, ...graphConfig.nodeConfigs[nodeId] };
+        }
+      }
+
+      loadSpinner.succeed(`  Loaded JS module (${graph.nodes.size} nodes)`);
+    } catch (err) {
+      loadSpinner.fail(`  Failed to load JS module`);
+      console.log(chalk.red(`\n  ${err.message}\n`));
+      process.exit(1);
+    }
+  } else {
+    let fileContent;
+    try {
+      fileContent = JSON.parse(readFileSync(filePath, 'utf-8'));
+    } catch (err) {
+      console.log(chalk.red(`\n  Failed to parse ${filePath}: ${err.message}\n`));
+      process.exit(1);
+    }
+
+    const { _meta, ...config } = fileContent;
+    graphConfig = config;
+  }
+
+  if (!graphConfig.nodes || !graphConfig.edges) {
+    console.log(chalk.red('\n  Invalid workflow file: missing nodes or edges'));
+    console.log(chalk.gray('  The file should contain { nodes: [...], edges: [...], nodeConfigs: {...} }\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.gray(`\n  File:    ${filePath}`));
+  console.log(chalk.gray(`  Format:  ${isJsFile ? 'JavaScript (serialized via graph.serialize())' : 'JSON'}`));
+  console.log(chalk.gray(`  Nodes:   ${graphConfig.nodes.length}`));
+  console.log(chalk.gray(`  Edges:   ${graphConfig.edges.length}`));
+
+  const validateSpinner = ora('  Validating graph...').start();
+  const validation = validateGraphConfig(graphConfig);
+
+  if (!validation.valid) {
+    validateSpinner.fail('  Graph validation failed');
+    console.log('');
+    for (const err of validation.errors) {
+      console.log(chalk.red(`    ${err}`));
+    }
+    console.log(chalk.gray('\n  Fix the errors above and try again.\n'));
+    process.exit(1);
+  }
+  validateSpinner.succeed('  Graph is valid');
+
+  const uploadSpinner = ora('  Uploading to cloud...').start();
+
+  try {
+    const apiUrl = getApiUrl();
+    const response = await fetch(`${apiUrl}/projects/${projectId}/workflows/${workflowType}`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({ graph: graphConfig }),
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      uploadSpinner.fail(`  API error: ${response.status}`);
+      console.log(chalk.red(`  ${body}\n`));
+      process.exit(1);
+    }
+
+    const result = await response.json();
+    uploadSpinner.succeed(`  Uploaded successfully (v${result.version})`);
+
+    console.log(chalk.green(`\n  Workflow "${workflowType}" updated to version ${result.version}`));
+    console.log(chalk.gray(`  Project: ${projectId}\n`));
+
+  } catch (err) {
+    uploadSpinner.fail('  Upload failed');
+    console.log(chalk.red(`\n  ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+export async function workflowListCommand(options) {
+  const _env = getCurrentEnvironment();
+  const { apiKey, projectId } = resolveAuth(options);
+
+  console.log(chalk.bold.cyan('\n  Zibby Workflows\n'));
+
+  const spinner = ora('  Fetching workflows...').start();
+
+  try {
+    const apiUrl = getApiUrl();
+    const results = [];
+
+    for (const type of VALID_TYPES) {
+      const response = await fetch(`${apiUrl}/projects/${projectId}/workflows/${type}`, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}`,
+        },
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        results.push({
+          type,
+          version: data.version || 0,
+          isDefault: data.isDefault !== false && !data.graph,
+          nodes: data.graph?.nodes?.length || 0,
+          updatedAt: data.updatedAt || null,
+        });
+      }
+    }
+
+    spinner.succeed('  Fetched workflows\n');
+
+    console.log(chalk.gray('  '.padEnd(70, '-')));
+    console.log(
+      chalk.white('  Type'.padEnd(20)) +
+      chalk.white('Version'.padEnd(10)) +
+      chalk.white('Nodes'.padEnd(10)) +
+      chalk.white('Status'.padEnd(15)) +
+      chalk.white('Updated')
+    );
+    console.log(chalk.gray('  '.padEnd(70, '-')));
+
+    for (const wf of results) {
+      const status = wf.isDefault
+        ? chalk.gray('default')
+        : chalk.green('custom');
+      const updated = wf.updatedAt
+        ? new Date(wf.updatedAt).toLocaleDateString()
+        : chalk.gray('-');
+
+      console.log(
+        `  ${chalk.cyan(wf.type.padEnd(18))}` +
+        `${String(wf.version).padEnd(10)}` +
+        `${String(wf.nodes).padEnd(10)}` +
+        `${status.padEnd(15)}` +
+        `${updated}`
+      );
+    }
+
+    console.log(chalk.gray('  '.padEnd(70, '-')));
+    console.log('');
+
+  } catch (err) {
+    spinner.fail('  Failed to fetch workflows');
+    console.log(chalk.red(`\n  ${err.message}\n`));
+    process.exit(1);
+  }
+}