@startanaicompany/cli 1.6.0 → 1.9.1

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/exec.js

@@ -7,6 +7,45 @@ const { getProjectConfig, ensureAuthenticated } = require('../lib/config');
 const logger = require('../lib/logger');
 const { table } = require('table');
 
+/**
+ * Poll for command result with timeout
+ */
+async function pollForResult(applicationUuid, commandId, maxWaitSeconds = 120) {
+  const startTime = Date.now();
+  const pollInterval = 1000; // 1 second
+
+  while (true) {
+    const elapsed = (Date.now() - startTime) / 1000;
+
+    if (elapsed > maxWaitSeconds) {
+      throw new Error(`Command timed out after ${maxWaitSeconds} seconds`);
+    }
+
+    try {
+      const result = await api.getDbCommandResult(applicationUuid, 'exec', commandId);
+
+      if (result.status === 'completed') {
+        return result;
+      }
+
+      if (result.status === 'failed') {
+        const errorMsg = result.result?.error || result.error || 'Command failed';
+        throw new Error(errorMsg);
+      }
+
+      // Still pending, wait and retry
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    } catch (error) {
+      // If error is not a 404 (command not found yet), rethrow
+      if (error.response?.status !== 404) {
+        throw error;
+      }
+      // 404 means command not processed yet, keep polling
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+  }
+}
+
 /**
  * Execute a command in the remote container
  * @param {string} command - Command to execute
@@ -39,7 +78,7 @@ async function exec(command, options = {}) {
     const execRequest = {
       command,
       workdir: options.workdir || '/app',
-      timeout: options.timeout || 30
+      timeout: parseInt(options.timeout) || 30
     };
 
     // Validate timeout
@@ -56,11 +95,20 @@ async function exec(command, options = {}) {
     logger.field('  Timeout', `${execRequest.timeout}s`);
     logger.newline();
 
-    const spin = logger.spinner('Executing command in container...').start();
+    const spin = logger.spinner('Queueing command...').start();
 
+    let response;
     let result;
     try {
-      result = await api.executeCommand(applicationUuid, execRequest);
+      // Queue the command
+      response = await api.executeCommand(applicationUuid, execRequest);
+      const commandId = response.command_id;
+
+      spin.text = 'Waiting for daemon to execute command...';
+
+      // Poll for result with timeout buffer
+      result = await pollForResult(applicationUuid, commandId, execRequest.timeout + 30);
+
       spin.succeed('Command executed');
     } catch (error) {
       spin.fail('Command execution failed');
@@ -105,37 +153,50 @@ async function exec(command, options = {}) {
     logger.newline();
 
     // Display execution results
-    logger.success(`✓ Execution ID: ${result.execution_id}`);
-    logger.newline();
+    const execResult = result.result || {};
+
+    // Calculate duration
+    let duration = 'N/A';
+    if (result.created_at && result.completed_at) {
+      const start = new Date(result.created_at);
+      const end = new Date(result.completed_at);
+      duration = `${end - start}ms`;
+    }
 
-    logger.field('Exit Code', result.exit_code === 0
-      ? logger.chalk.green(result.exit_code)
-      : logger.chalk.red(result.exit_code)
+    logger.field('Exit Code', execResult.exit_code !== undefined
+      ? (execResult.exit_code === 0
+          ? logger.chalk.green(execResult.exit_code)
+          : logger.chalk.red(execResult.exit_code))
+      : 'N/A'
     );
-    logger.field('Duration', `${result.duration_ms}ms`);
-    logger.field('Started', new Date(result.started_at).toLocaleString());
-    logger.field('Completed', new Date(result.completed_at).toLocaleString());
+    logger.field('Duration', duration);
+    if (result.created_at) {
+      logger.field('Started', new Date(result.created_at).toLocaleString());
+    }
+    if (result.completed_at) {
+      logger.field('Completed', new Date(result.completed_at).toLocaleString());
+    }
 
     // Display stdout
-    if (result.stdout) {
+    if (execResult.stdout) {
       logger.newline();
       logger.info('Standard Output:');
       logger.section('─'.repeat(60));
-      console.log(result.stdout.trim());
+      console.log(execResult.stdout.trim());
       logger.section('─'.repeat(60));
     }
 
     // Display stderr
-    if (result.stderr) {
+    if (execResult.stderr) {
       logger.newline();
       logger.warn('Standard Error:');
       logger.section('─'.repeat(60));
-      console.error(result.stderr.trim());
+      console.error(execResult.stderr.trim());
       logger.section('─'.repeat(60));
     }
 
     // If no output
-    if (!result.stdout && !result.stderr) {
+    if (!execResult.stdout && !execResult.stderr) {
       logger.newline();
       logger.info('(No output)');
     }

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;
 }
 
@@ -319,6 +319,65 @@ async function listGitRepositories(gitHost, options = {}) {
   return response.data;
 }
 
+/**
+ * List database containers for an application
+ * @param {string} uuid - Application UUID
+ * @returns {Promise<object>} - { command_id, status }
+ */
+async function listDbContainers(uuid) {
+  const client = createClient();
+  const response = await client.get(`/applications/${uuid}/db/containers`);
+  return response.data;
+}
+
+/**
+ * Execute SQL query on application database
+ * @param {string} uuid - Application UUID
+ * @param {object} queryData - { query, db_name?, allow_writes? }
+ * @returns {Promise<object>} - { command_id, status }
+ */
+async function executeSql(uuid, queryData) {
+  const client = createClient();
+  const response = await client.post(`/applications/${uuid}/db/sql`, queryData);
+  return response.data;
+}
+
+/**
+ * Get result of a database command (universal endpoint for all command types)
+ * @param {string} uuid - Application UUID
+ * @param {string} commandType - 'sql', 'redis', 'containers' (not used, kept for API compatibility)
+ * @param {string} commandId - Command ID
+ * @returns {Promise<object>} - { status, result, command_type, created_at, completed_at }
+ */
+async function getDbCommandResult(uuid, commandType, commandId) {
+  const client = createClient();
+  const response = await client.get(`/applications/${uuid}/db/result/${commandId}`);
+  return response.data;
+}
+
+/**
+ * Execute Redis command on application database
+ * @param {string} uuid - Application UUID
+ * @param {object} commandData - { command }
+ * @returns {Promise<object>} - { command_id, status }
+ */
+async function executeRedis(uuid, commandData) {
+  const client = createClient();
+  const response = await client.post(`/applications/${uuid}/db/redis`, commandData);
+  return response.data;
+}
+
+/**
+ * Get database connection information
+ * @param {string} uuid - Application UUID
+ * @returns {Promise<object>} - { postgres: {...}, redis: {...} }
+ */
+async function getDbInfo(uuid) {
+  const client = createClient();
+  const response = await client.get(`/applications/${uuid}/db/info`);
+  return response.data;
+}
+
 module.exports = {
   createClient,
   login,
@@ -345,4 +404,9 @@ module.exports = {
   executeCommand,
   getExecutionHistory,
   listGitRepositories,
+  listDbContainers,
+  executeSql,
+  getDbCommandResult,
+  executeRedis,
+  getDbInfo,
 };