@startanaicompany/cli 1.5.0 → 1.8.0

package/bin/saac.js

@@ -96,12 +96,6 @@ keysCommand
   .description('Generate a new API key (invalidates old one)')
   .action(keys.regenerate);
 
-keysCommand
-  .command('show')
-  .alias('info')
-  .description('Show API key information')
-  .action(keys.show);
-
 // Git OAuth commands
 const gitCommand = program
   .command('git')
@@ -150,6 +144,7 @@ program
   // Required options
   .option('-s, --subdomain <subdomain>', 'Subdomain')
   .option('-r, --repository <url>', 'Git repository URL (SSH format)')
+  .option('--org <organization_id>', 'Organization ID (required)')
   // Basic options
   .option('-b, --branch <branch>', 'Git branch', 'master')
   .option('-d, --domain-suffix <suffix>', 'Domain suffix', 'startanaicompany.com')
@@ -210,8 +205,9 @@ program
 
 program
   .command('deploy')
-  .description('Deploy current application')
-  .option('-f, --force', 'Force deployment')
+  .description('Deploy current application (streams build logs by default)')
+  .option('--no-stream', 'Skip streaming and return immediately after queuing')
+  .option('--no-cache', 'Rebuild without Docker cache (slower but fresh build)')
   .action(deploy);
 
 program
@@ -231,6 +227,7 @@ program
   .option('-t, --tail <lines>', 'Number of lines to show (runtime logs only)', '100')
   .option('-f, --follow', 'Follow log output (runtime logs only)')
   .option('--since <time>', 'Show logs since timestamp (runtime logs only)')
+  .option('--type <type>', 'Filter by log type: build, runtime, access (runtime logs only)')
   .action(logs);
 
 // Local development commands

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startanaicompany/cli",
-  "version": "1.5.0",
+  "version": "1.8.0",
   "description": "Official CLI for StartAnAiCompany.com - Deploy AI recruitment sites with ease",
   "main": "src/index.js",
   "bin": {

package/src/commands/create.js

@@ -89,6 +89,7 @@ async function create(name, options) {
       logger.info('Required options:');
       logger.log('  -s, --subdomain <subdomain>          Subdomain for your app');
       logger.log('  -r, --repository <url>               Git repository URL (SSH format)');
+      logger.log('  --org <organization_id>              Organization ID');
       logger.newline();
       logger.info('Optional options:');
       logger.log('  -b, --branch <branch>                Git branch (default: master)');
@@ -110,17 +111,17 @@ async function create(name, options) {
       logger.log('  --env <KEY=VALUE>                    Environment variable (can be used multiple times)');
       logger.newline();
       logger.info('Example:');
-      logger.log('  saac create my-app -s myapp -r git@git.startanaicompany.com:user/repo.git');
-      logger.log('  saac create api -s api -r git@git... --build-pack nixpacks --port 8080');
-      logger.log('  saac create web -s web -r git@git... --health-check --pre-deploy-cmd "npm run migrate"');
+      logger.log('  saac create my-app -s myapp -r git@git.startanaicompany.com:user/repo.git --org <org_id>');
+      logger.log('  saac create api -s api -r git@git... --org <org_id> --build-pack nixpacks --port 8080');
+      logger.log('  saac create web -s web -r git@git... --org <org_id> --health-check --pre-deploy-cmd "npm run migrate"');
       process.exit(1);
     }
 
-    if (!options.subdomain || !options.repository) {
-      logger.error('Missing required options: subdomain and repository are required');
+    if (!options.subdomain || !options.repository || !options.org) {
+      logger.error('Missing required options: subdomain, repository, and organization ID are required');
       logger.newline();
       logger.info('Example:');
-      logger.log(`  saac create ${name} -s myapp -r git@git.startanaicompany.com:user/repo.git`);
+      logger.log(`  saac create ${name} -s myapp -r git@git.startanaicompany.com:user/repo.git --org <org_id>`);
       logger.newline();
       logger.info('Note: Git OAuth connection required. Connect with: saac git connect');
       process.exit(1);
@@ -156,6 +157,7 @@ async function create(name, options) {
       domain_suffix: options.domainSuffix || 'startanaicompany.com',
       git_repository: options.repository,
       git_branch: options.branch || 'master',
+      organization_id: options.org,
     };
 
     // OAuth tokens are retrieved from database by wrapper

package/src/commands/delete.js

@@ -113,7 +113,7 @@ async function deleteApp(options) {
 
       logger.newline();
 
-      logger.success(`Application '${result.application_name}' has been permanently deleted.`);
+      logger.success(`Application '${app.name}' has been permanently deleted.`);
 
       logger.newline();
 

package/src/commands/deploy.js

@@ -1,9 +1,9 @@
 /**
- * Deploy command
+ * Deploy command with streaming support
  */
 
 const api = require('../lib/api');
-const { getProjectConfig, ensureAuthenticated } = require('../lib/config');
+const { getProjectConfig, ensureAuthenticated, getUser } = require('../lib/config');
 const logger = require('../lib/logger');
 const errorDisplay = require('../lib/errorDisplay');
 
@@ -30,57 +30,55 @@ async function deploy(options) {
     logger.section(`Deploying ${applicationName}`);
     logger.newline();
 
-    const spin = logger.spinner('Deploying application (waiting for completion, up to 5 minutes)...').start();
+    // Default to streaming mode (agents and users need visibility)
+    // Use fire-and-forget mode only if --no-stream is explicitly set
+    if (options.stream !== false) {
+      return await deployWithStreaming(applicationUuid, applicationName, options);
+    }
+
+    // Fire-and-forget mode (only when --no-stream is used)
+    const spin = logger.spinner('Queueing deployment...').start();
 
     try {
-      const result = await api.deployApplication(applicationUuid);
+      const deployOptions = {};
+      if (options.noCache) {
+        deployOptions.no_cache = true;
+      }
+
+      const result = await api.deployApplication(applicationUuid, deployOptions);
 
       // Check if deployment failed
       if (result.success === false) {
         spin.fail('Deployment failed');
-
-        // Display detailed error information
         errorDisplay.displayDeploymentError(result, logger);
-
-        // Handle timeout specifically
-        if (result.status === 'timeout') {
-          errorDisplay.displayTimeoutInstructions(logger);
-        }
-
         process.exit(1);
       }
 
-      // SUCCESS: Deployment completed
-      spin.succeed('Deployment completed successfully!');
+      // SUCCESS: Deployment queued
+      spin.succeed('Deployment queued');
 
       logger.newline();
-      logger.success('Your application has been deployed!');
+      logger.success('Deployment has been queued!');
       logger.newline();
       logger.field('Application', applicationName);
-      logger.field('Status', result.status);
+      logger.field('Status', 'queued (daemon will build within 30 seconds)');
       if (result.git_branch) {
         logger.field('Branch', result.git_branch);
       }
       if (result.domain) {
         logger.field('Domain', result.domain);
       }
-      if (result.deployment_uuid || result.deployment_id) {
-        logger.field('Deployment ID', result.deployment_uuid || result.deployment_id);
+      if (options.noCache) {
+        logger.field('Build Mode', 'No cache (full rebuild)');
       }
       logger.newline();
 
-      // Show Traefik status if present
-      if (result.traefik_status === 'queued') {
-        logger.info('Routing configuration is being applied (may take a few seconds)');
-        logger.newline();
-      } else if (result.traefik_status === 'failed') {
-        logger.warn('Routing configuration failed - application may not be accessible');
-        logger.newline();
-      }
-
-      logger.info('Useful commands:');
-      logger.log(`  saac logs --follow       View live deployment logs`);
-      logger.log(`  saac status              Check application status`);
+      logger.info('The daemon will pick up this deployment shortly and begin building.');
+      logger.newline();
+      logger.info('Monitor deployment progress:');
+      logger.log(`  saac deploy                  Stream build logs in real-time (default)`);
+      logger.log(`  saac logs --deployment       View deployment logs after completion`);
+      logger.log(`  saac status                  Check application status`);
 
     } catch (error) {
       spin.fail('Deployment request failed');
@@ -92,4 +90,170 @@ async function deploy(options) {
   }
 }
 
+/**
+ * Deploy with SSE streaming
+ */
+async function deployWithStreaming(applicationUuid, applicationName, options) {
+  const user = getUser();
+  const config = require('../lib/config');
+  const baseUrl = config.getApiUrl();
+
+  logger.info('Initiating deployment with build log streaming...');
+  logger.newline();
+
+  try {
+    const headers = {
+      'Accept': 'text/event-stream',
+      'Content-Type': 'application/json',
+    };
+
+    // Add authentication header
+    if (process.env.SAAC_API_KEY) {
+      headers['X-API-Key'] = process.env.SAAC_API_KEY;
+    } else if (user.sessionToken) {
+      headers['X-Session-Token'] = user.sessionToken;
+    } else if (user.apiKey) {
+      headers['X-API-Key'] = user.apiKey;
+    }
+
+    const body = { stream: true };
+    if (options.noCache) {
+      body.no_cache = true;
+    }
+
+    const url = `${baseUrl}/applications/${applicationUuid}/deploy`;
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`HTTP ${response.status}: ${errorText}`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let deploymentQueued = false;
+
+    // Handle Ctrl+C gracefully
+    const cleanup = () => {
+      reader.cancel();
+      logger.newline();
+      logger.info('Stream closed');
+      process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) {
+        break;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        // Skip empty lines and comments (keepalive)
+        if (!line.trim() || line.startsWith(':')) {
+          continue;
+        }
+
+        // Parse SSE data lines
+        if (line.startsWith('data: ')) {
+          try {
+            const data = JSON.parse(line.slice(6));
+
+            // Handle deploy_queued event
+            if (data.event === 'deploy_queued') {
+              logger.success('✓ Deployment queued');
+              logger.newline();
+              logger.field('Application', applicationName);
+              logger.field('Branch', data.git_branch || 'master');
+              if (data.domain) {
+                logger.field('Domain', data.domain);
+              }
+              if (options.noCache) {
+                logger.field('Build Mode', 'No cache (full rebuild)');
+              }
+              logger.newline();
+              logger.info('Waiting for daemon to start build...');
+              logger.newline();
+              deploymentQueued = true;
+              continue;
+            }
+
+            // Handle deploy_finished event
+            if (data.event === 'deploy_finished') {
+              logger.newline();
+              logger.log('─'.repeat(60));
+              logger.newline();
+
+              if (data.status === 'running') {
+                logger.success('✓ Deployment completed successfully!');
+              } else if (data.status === 'failed') {
+                logger.error('✗ Deployment failed');
+              } else {
+                logger.info(`Deployment status: ${data.status}`);
+              }
+
+              logger.newline();
+              logger.field('Final Status', data.status);
+              if (data.deployment_uuid) {
+                logger.field('Deployment UUID', data.deployment_uuid);
+              }
+              logger.newline();
+
+              if (data.status === 'running') {
+                logger.info('Your application is now running!');
+                logger.newline();
+                logger.info('Next steps:');
+                logger.log(`  saac status                  Check application status`);
+                logger.log(`  saac logs --follow           View live application logs`);
+              } else if (data.status === 'failed') {
+                logger.info('View full deployment logs:');
+                logger.log(`  saac logs --deployment       View complete build logs`);
+              }
+
+              // Clean exit
+              process.removeListener('SIGINT', cleanup);
+              process.removeListener('SIGTERM', cleanup);
+              process.exit(data.status === 'running' ? 0 : 1);
+            }
+
+            // Handle build log messages
+            if (data.type === 'build' && data.message) {
+              const timestamp = new Date(data.timestamp).toLocaleTimeString();
+              const service = logger.chalk.cyan(`[${data.service}]`);
+              console.log(`${logger.chalk.gray(timestamp)} ${service} ${data.message}`);
+            }
+          } catch (parseError) {
+            logger.warn(`Failed to parse event: ${line}`);
+          }
+        }
+      }
+    }
+
+    // Stream ended without deploy_finished event
+    logger.newline();
+    logger.warn('Build stream ended unexpectedly');
+    logger.info('Check deployment status with: saac status');
+
+  } catch (error) {
+    logger.error('Failed to stream deployment');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
 module.exports = deploy;

package/src/commands/keys.js

@@ -87,61 +87,6 @@ async function regenerate() {
   }
 }
 
-/**
- * Show API key info (without revealing full key)
- */
-async function show() {
-  try {
-    if (!(await ensureAuthenticated())) {
-      logger.error('Not logged in');
-      logger.newline();
-      logger.info('Login first:');
-      logger.log('  saac login -e <email>');
-      process.exit(1);
-    }
-
-    logger.section('API Key Information');
-    logger.newline();
-
-    const spin = logger.spinner('Fetching API key info...').start();
-
-    try {
-      const result = await api.getApiKeyInfo();
-
-      spin.succeed('API key info retrieved');
-
-      logger.newline();
-      logger.field('Key Prefix', result.key_prefix); // e.g., "cw_RJ1gH8..."
-      logger.field('Created', new Date(result.created_at).toLocaleDateString());
-      logger.field('Last Used', result.last_used_at
-        ? new Date(result.last_used_at).toLocaleString()
-        : 'Never');
-
-      logger.newline();
-      logger.info('Commands:');
-      logger.log('  saac keys regenerate    Generate new API key');
-      logger.log('  saac sessions           View active sessions');
-
-    } catch (error) {
-      spin.fail('Failed to fetch API key info');
-
-      // If endpoint doesn't exist yet, show helpful message
-      if (error.response?.status === 404) {
-        logger.newline();
-        logger.warn('API key info endpoint not available yet');
-        logger.info('You can still regenerate your key with:');
-        logger.log('  saac keys regenerate');
-      } else {
-        throw error;
-      }
-    }
-  } catch (error) {
-    logger.error(error.response?.data?.message || error.message);
-    process.exit(1);
-  }
-}
-
 module.exports = {
   regenerate,
-  show,
 };

package/src/commands/logs.js

@@ -168,20 +168,26 @@ async function getRuntimeLogs(applicationUuid, applicationName, options) {
   logger.section(`Runtime Logs: ${applicationName}`);
   logger.newline();
 
+  // Follow mode - use SSE streaming
+  if (options.follow) {
+    return await streamRuntimeLogs(applicationUuid, applicationName, options);
+  }
+
+  // Regular mode - fetch logs once
   const spin = logger.spinner('Fetching runtime logs...').start();
 
   try {
     // Build query parameters
     const params = {};
-    if (options.follow) {
-      params.follow = true;
-    }
     if (options.tail) {
       params.tail = parseInt(options.tail, 10);
     }
     if (options.since) {
       params.since = options.since;
     }
+    if (options.type) {
+      params.type = options.type;
+    }
 
     const result = await api.getApplicationLogs(applicationUuid, params);
 
@@ -192,9 +198,16 @@ async function getRuntimeLogs(applicationUuid, applicationName, options) {
     // Display logs
     if (result.logs) {
       if (Array.isArray(result.logs)) {
-        // Logs is an array
+        // Logs is an array of objects
         result.logs.forEach(log => {
-          console.log(log);
+          if (log.message) {
+            // Format: [timestamp] [service] message
+            const timestamp = new Date(log.timestamp).toLocaleTimeString();
+            const service = logger.chalk.cyan(`[${log.service}]`);
+            console.log(`${logger.chalk.gray(timestamp)} ${service} ${log.message}`);
+          } else {
+            console.log(log);
+          }
         });
       } else if (typeof result.logs === 'string') {
         // Logs is a string (most common format from backend)
@@ -212,13 +225,6 @@ async function getRuntimeLogs(applicationUuid, applicationName, options) {
       logger.log('  saac deploy');
     }
 
-    // Note about follow mode
-    if (options.follow) {
-      logger.newline();
-      logger.info('Note: Follow mode (--follow) for live logs is not yet implemented');
-      logger.info('This command shows recent logs only');
-    }
-
   } catch (error) {
     spin.fail('Failed to fetch runtime logs');
 
@@ -240,4 +246,123 @@ async function getRuntimeLogs(applicationUuid, applicationName, options) {
   }
 }
 
+/**
+ * Stream runtime logs via SSE (Server-Sent Events)
+ */
+async function streamRuntimeLogs(applicationUuid, applicationName, options) {
+  const { getUser } = require('../lib/config');
+  const user = getUser();
+  const config = require('../lib/config');
+
+  // Get base URL from config
+  const baseUrl = config.getApiUrl();
+
+  // Build query parameters
+  const params = new URLSearchParams();
+  params.set('follow', 'true');
+  if (options.tail) {
+    params.set('tail', options.tail);
+  }
+  if (options.since) {
+    params.set('since', options.since);
+  }
+  if (options.type) {
+    params.set('type', options.type);
+  }
+
+  const url = `${baseUrl}/applications/${applicationUuid}/logs?${params.toString()}`;
+
+  logger.info('Streaming live logs... (Press Ctrl+C to stop)');
+  logger.newline();
+
+  try {
+    const headers = {
+      'Accept': 'text/event-stream',
+    };
+
+    // Add authentication header
+    if (process.env.SAAC_API_KEY) {
+      headers['X-API-Key'] = process.env.SAAC_API_KEY;
+    } else if (user.sessionToken) {
+      headers['X-Session-Token'] = user.sessionToken;
+    } else if (user.apiKey) {
+      headers['X-API-Key'] = user.apiKey;
+    }
+
+    const response = await fetch(url, { headers });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    // Handle Ctrl+C gracefully
+    const cleanup = () => {
+      reader.cancel();
+      logger.newline();
+      logger.info('Stream closed');
+      process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) {
+        break;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        // Skip empty lines and comments (keepalive)
+        if (!line.trim() || line.startsWith(':')) {
+          continue;
+        }
+
+        // Parse SSE data lines
+        if (line.startsWith('data: ')) {
+          try {
+            const data = JSON.parse(line.slice(6));
+
+            // Skip connection event
+            if (data.event === 'connected') {
+              logger.success('Connected to log stream');
+              logger.newline();
+              continue;
+            }
+
+            // Display log message
+            if (data.message) {
+              const timestamp = new Date(data.timestamp).toLocaleTimeString();
+              const service = logger.chalk.cyan(`[${data.service}]`);
+              console.log(`${logger.chalk.gray(timestamp)} ${service} ${data.message}`);
+            }
+          } catch (parseError) {
+            logger.warn(`Failed to parse log entry: ${line}`);
+          }
+        }
+      }
+    }
+
+    logger.newline();
+    logger.info('Stream ended');
+
+  } catch (error) {
+    logger.error('Failed to stream logs');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
 module.exports = logs;

package/src/commands/whoami.js

@@ -33,7 +33,7 @@ async function whoami() {
 
       logger.field('Email', user.email);
       logger.field('User ID', user.id);
-      logger.field('Verified', user.verified ? logger.chalk.green('Yes ✓') : logger.chalk.red('No ✗'));
+      logger.field('Verified', user.email_verified ? logger.chalk.green('Yes ✓') : logger.chalk.red('No ✗'));
       logger.field('Member Since', formatDate(user.created_at));
 
       logger.newline();

package/src/lib/api.js

@@ -120,10 +120,10 @@ async function getApplication(uuid) {
  * Deploy application
  * Note: This waits for deployment to complete (up to 5 minutes)
  */
-async function deployApplication(uuid) {
+async function deployApplication(uuid, options = {}) {
   // Use 5-minute timeout for deployment waiting
   const client = createClient(300000); // 5 minutes
-  const response = await client.post(`/applications/${uuid}/deploy`);
+  const response = await client.post(`/applications/${uuid}/deploy`, options);
   return response.data;
 }