@startanaicompany/cli 1.4.16 → 1.4.18

package/src/commands/logs.js

@@ -1,4 +1,232 @@
-// TODO: Implement logs command
-module.exports = async function() {
-  console.log('logs command - Coming soon!');
-};
+/**
+ * Logs command - View application runtime logs or deployment logs
+ */
+
+const api = require('../lib/api');
+const { getProjectConfig, isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+
+async function logs(deploymentUuidArg, options) {
+  try {
+    // Check authentication
+    if (!isAuthenticated()) {
+      logger.error('Not logged in. Run: saac login');
+      process.exit(1);
+    }
+
+    // Check for project config
+    const projectConfig = getProjectConfig();
+    if (!projectConfig || !projectConfig.applicationUuid) {
+      logger.error('No application found in current directory');
+      logger.info('Run this command from a project directory (must have .saac/config.json)');
+      logger.newline();
+      logger.info('Or initialize with:');
+      logger.log('  saac init');
+      process.exit(1);
+    }
+
+    const { applicationUuid, applicationName } = projectConfig;
+
+    // Determine if we're fetching deployment logs or runtime logs
+    if (options.deployment !== undefined) {
+      // Deployment logs mode
+      return await getDeploymentLogs(applicationUuid, applicationName, deploymentUuidArg || options.deployment, options);
+    } else {
+      // Runtime logs mode (not implemented yet)
+      return await getRuntimeLogs(applicationUuid, applicationName, options);
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Get deployment logs (build logs)
+ */
+async function getDeploymentLogs(applicationUuid, applicationName, deploymentUuid, options) {
+  logger.section(`Deployment Logs: ${applicationName}`);
+  logger.newline();
+
+  const spin = logger.spinner('Fetching deployment logs...').start();
+
+  try {
+    // Build query parameters
+    const params = {};
+    if (deploymentUuid && deploymentUuid !== true) {
+      params.deployment_uuid = deploymentUuid;
+    }
+    if (options.raw) {
+      params.format = 'raw';
+    }
+    if (options.includeHidden) {
+      params.include_hidden = true;
+    }
+
+    const result = await api.getDeploymentLogs(applicationUuid, params);
+
+    // Update spinner with status
+    if (result.status === 'finished') {
+      spin.succeed('Deployment logs retrieved (finished)');
+    } else if (result.status === 'failed') {
+      spin.fail('Deployment logs retrieved (failed)');
+    } else {
+      spin.succeed(`Deployment logs retrieved (${result.status})`);
+    }
+
+    logger.newline();
+
+    // Display header information
+    logger.field('Deployment UUID', result.deployment_uuid || 'N/A');
+    logger.field('Application', result.application_name || applicationName);
+
+    // Status with color
+    let statusDisplay;
+    if (result.status === 'finished') {
+      statusDisplay = logger.chalk.green(result.status);
+    } else if (result.status === 'failed') {
+      statusDisplay = logger.chalk.red(result.status);
+    } else {
+      statusDisplay = logger.chalk.yellow(result.status);
+    }
+    logger.field('Status', statusDisplay);
+
+    if (result.commit) {
+      logger.field('Commit', result.commit);
+    }
+    if (result.commit_message) {
+      logger.field('Message', result.commit_message);
+    }
+    if (result.started_at) {
+      logger.field('Started', new Date(result.started_at).toLocaleString());
+    }
+    if (result.finished_at) {
+      logger.field('Finished', new Date(result.finished_at).toLocaleString());
+    }
+    if (result.duration_seconds !== undefined) {
+      logger.field('Duration', `${result.duration_seconds}s`);
+    }
+
+    logger.newline();
+    logger.info(`Log Output (${result.log_count || 0} lines):`);
+    logger.log('─'.repeat(60));
+    logger.newline();
+
+    // Display logs
+    if (options.raw || result.raw_logs) {
+      // Raw format - just print the text
+      console.log(result.raw_logs);
+    } else if (result.logs && result.logs.length > 0) {
+      // Parsed format - colorize stderr
+      result.logs.forEach(entry => {
+        if (entry.type === 'stderr') {
+          console.log(logger.chalk.red(entry.output));
+        } else {
+          console.log(entry.output);
+        }
+      });
+    } else {
+      logger.warn('No logs available');
+    }
+
+    // Display errors summary if present
+    if (result.errors && result.errors.length > 0) {
+      logger.newline();
+      logger.log('─'.repeat(60));
+      logger.newline();
+      logger.error('Errors Detected:');
+      result.errors.forEach(err => {
+        logger.log(`  ${logger.chalk.red(`[${err.type}]`)} ${err.message}`);
+        if (err.detail) {
+          logger.log(`    ${logger.chalk.gray(err.detail)}`);
+        }
+      });
+    }
+
+  } catch (error) {
+    spin.fail('Failed to fetch deployment logs');
+
+    if (error.response?.status === 404) {
+      logger.newline();
+      logger.warn('No deployments found for this application');
+      logger.newline();
+      logger.info('Deploy first with:');
+      logger.log('  saac deploy');
+    } else {
+      throw error;
+    }
+  }
+}
+
+/**
+ * Get runtime logs (container logs)
+ */
+async function getRuntimeLogs(applicationUuid, applicationName, options) {
+  logger.section(`Runtime Logs: ${applicationName}`);
+  logger.newline();
+
+  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;
+    }
+
+    const result = await api.getApplicationLogs(applicationUuid, params);
+
+    spin.succeed('Runtime logs retrieved');
+
+    logger.newline();
+
+    // Display logs
+    if (result.logs && result.logs.length > 0) {
+      result.logs.forEach(log => {
+        console.log(log);
+      });
+    } else if (typeof result === 'string') {
+      console.log(result);
+    } else {
+      logger.warn('No logs available');
+      logger.newline();
+      logger.info('Make sure your application is deployed:');
+      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');
+
+    if (error.response?.status === 404) {
+      logger.newline();
+      logger.warn('Application not found or no logs available');
+      logger.newline();
+      logger.info('Deploy first with:');
+      logger.log('  saac deploy');
+    } else if (error.response?.status === 501) {
+      logger.newline();
+      logger.warn('Runtime logs endpoint not implemented yet');
+      logger.newline();
+      logger.info('Use deployment logs instead:');
+      logger.log('  saac logs --deployment');
+    } else {
+      throw error;
+    }
+  }
+}
+
+module.exports = logs;

package/src/commands/run.js

@@ -0,0 +1,170 @@
+/**
+ * Run Command - Execute local command with remote environment variables
+ */
+
+const api = require('../lib/api');
+const { getProjectConfig, isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// In-memory cache for environment variables (5 minutes TTL)
+const envCache = new Map();
+const CACHE_TTL = 300000; // 5 minutes in milliseconds
+
+/**
+ * Get environment variables (with caching)
+ * @param {string} appUuid - Application UUID
+ * @param {boolean} forceRefresh - Skip cache and fetch fresh
+ */
+async function getEnvironmentVariables(appUuid, forceRefresh = false) {
+  // Check cache first
+  if (!forceRefresh) {
+    const cached = envCache.get(appUuid);
+    if (cached) {
+      const age = Date.now() - cached.timestamp;
+      if (age < CACHE_TTL) {
+        logger.info('📦 Using cached environment variables (updated <5 min ago)');
+        return cached.data;
+      }
+      // Cache expired
+      envCache.delete(appUuid);
+    }
+  }
+
+  // Fetch from API
+  const client = api.createClient();
+  const response = await client.get(`/applications/${appUuid}/env/export`);
+
+  // Cache for 5 minutes
+  envCache.set(appUuid, {
+    data: response.data,
+    timestamp: Date.now()
+  });
+
+  return response.data;
+}
+
+/**
+ * Run command with remote environment variables
+ * @param {string} command - Command to execute
+ * @param {object} options - Command options
+ */
+async function run(command, options = {}) {
+  try {
+    // Check authentication
+    if (!isAuthenticated()) {
+      logger.error('Not logged in. Run: saac login');
+      process.exit(1);
+    }
+
+    // Check for project config
+    const projectConfig = getProjectConfig();
+    if (!projectConfig || !projectConfig.applicationUuid) {
+      logger.error('No application found in current directory');
+      logger.info('Run this command from a project directory (must have .saac/config.json)');
+      logger.newline();
+      logger.info('Or initialize with:');
+      logger.log('  saac init');
+      process.exit(1);
+    }
+
+    const { applicationUuid, applicationName } = projectConfig;
+
+    // Fetch environment variables
+    logger.newline();
+    const spin = logger.spinner('Fetching environment variables...').start();
+
+    let envData;
+    try {
+      envData = await getEnvironmentVariables(applicationUuid, options.sync);
+      spin.succeed('Environment variables retrieved');
+    } catch (error) {
+      spin.fail('Failed to fetch environment variables');
+
+      if (error.response?.status === 429) {
+        const retryAfter = error.response.headers['retry-after'] || 60;
+        logger.newline();
+        logger.error(`Rate limit exceeded. Too many requests.`);
+        logger.info(`Retry in ${retryAfter} seconds.`);
+        logger.newline();
+        logger.info('Note: Environment variables are cached for 5 minutes.');
+        process.exit(1);
+      }
+
+      throw error;
+    }
+
+    logger.newline();
+
+    // Create temp file for environment variables
+    const tempDir = os.tmpdir();
+    const tempFile = path.join(tempDir, `saac-env-${applicationUuid}.sh`);
+
+    // Write export script to temp file with secure permissions
+    fs.writeFileSync(tempFile, envData.export_script, { mode: 0o600 });
+
+    // Setup cleanup handlers
+    const cleanup = () => {
+      try {
+        if (fs.existsSync(tempFile)) {
+          fs.unlinkSync(tempFile);
+        }
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+    };
+
+    process.on('SIGINT', () => {
+      cleanup();
+      process.exit(130);
+    });
+
+    process.on('SIGTERM', () => {
+      cleanup();
+      process.exit(143);
+    });
+
+    // Display info
+    logger.info(`Running command with ${envData.variable_count} remote environment variables`);
+    logger.field('  Application', applicationName);
+    logger.field('  Command', command);
+
+    if (!options.quiet) {
+      logger.newline();
+      logger.warn('⚠️  Secrets are exposed on local machine');
+      logger.info(`Temporary file: ${tempFile} (will be deleted on exit)`);
+    }
+
+    logger.newline();
+    logger.section('Command Output');
+    logger.newline();
+
+    // Execute command with sourced environment
+    const shell = process.env.SHELL || '/bin/bash';
+    const proc = spawn(shell, ['-c', `source "${tempFile}" && ${command}`], {
+      stdio: 'inherit',
+      cwd: process.cwd()
+    });
+
+    proc.on('exit', (code) => {
+      cleanup();
+      process.exit(code || 0);
+    });
+
+    proc.on('error', (error) => {
+      cleanup();
+      logger.newline();
+      logger.error(`Failed to execute command: ${error.message}`);
+      process.exit(1);
+    });
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = run;

package/src/commands/shell.js

@@ -0,0 +1,166 @@
+/**
+ * Shell Command - Open interactive shell with remote environment variables
+ */
+
+const api = require('../lib/api');
+const { getProjectConfig, isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// In-memory cache for environment variables (5 minutes TTL)
+const envCache = new Map();
+const CACHE_TTL = 300000; // 5 minutes in milliseconds
+
+/**
+ * Get environment variables (with caching)
+ * @param {string} appUuid - Application UUID
+ * @param {boolean} forceRefresh - Skip cache and fetch fresh
+ */
+async function getEnvironmentVariables(appUuid, forceRefresh = false) {
+  // Check cache first
+  if (!forceRefresh) {
+    const cached = envCache.get(appUuid);
+    if (cached) {
+      const age = Date.now() - cached.timestamp;
+      if (age < CACHE_TTL) {
+        logger.info('📦 Using cached environment variables (updated <5 min ago)');
+        return cached.data;
+      }
+      // Cache expired
+      envCache.delete(appUuid);
+    }
+  }
+
+  // Fetch from API
+  const client = api.createClient();
+  const response = await client.get(`/applications/${appUuid}/env/export`);
+
+  // Cache for 5 minutes
+  envCache.set(appUuid, {
+    data: response.data,
+    timestamp: Date.now()
+  });
+
+  return response.data;
+}
+
+/**
+ * Open interactive shell with remote environment variables
+ * @param {object} options - Command options
+ */
+async function shell(options = {}) {
+  try {
+    // Check authentication
+    if (!isAuthenticated()) {
+      logger.error('Not logged in. Run: saac login');
+      process.exit(1);
+    }
+
+    // Check for project config
+    const projectConfig = getProjectConfig();
+    if (!projectConfig || !projectConfig.applicationUuid) {
+      logger.error('No application found in current directory');
+      logger.info('Run this command from a project directory (must have .saac/config.json)');
+      logger.newline();
+      logger.info('Or initialize with:');
+      logger.log('  saac init');
+      process.exit(1);
+    }
+
+    const { applicationUuid, applicationName } = projectConfig;
+
+    // Fetch environment variables
+    logger.newline();
+    const spin = logger.spinner('Fetching environment variables...').start();
+
+    let envData;
+    try {
+      envData = await getEnvironmentVariables(applicationUuid, options.sync);
+      spin.succeed('Environment variables retrieved');
+    } catch (error) {
+      spin.fail('Failed to fetch environment variables');
+
+      if (error.response?.status === 429) {
+        const retryAfter = error.response.headers['retry-after'] || 60;
+        logger.newline();
+        logger.error(`Rate limit exceeded. Too many requests.`);
+        logger.info(`Retry in ${retryAfter} seconds.`);
+        logger.newline();
+        logger.info('Note: Environment variables are cached for 5 minutes.');
+        process.exit(1);
+      }
+
+      throw error;
+    }
+
+    logger.newline();
+
+    // Determine shell to use
+    const userShell = options.cmd || process.env.SHELL || '/bin/bash';
+    const shellName = path.basename(userShell);
+
+    // Display info
+    logger.success(`🚀 Opening shell with ${envData.variable_count} environment variables loaded`);
+    logger.newline();
+    logger.field('  Application', applicationName);
+    logger.field('  Shell', shellName);
+    logger.field('  Variables', envData.variable_count);
+    logger.newline();
+    logger.warn('⚠️  Secrets are exposed on local machine');
+    logger.newline();
+    logger.info('Type "exit" or press Ctrl+D to close the shell');
+    logger.section('─'.repeat(60));
+    logger.newline();
+
+    // Merge remote environment variables with current process env
+    const mergedEnv = {
+      ...process.env,
+      ...envData.environment,
+      SAAC_ENV_LOADED: '1',
+      SAAC_APP_NAME: applicationName,
+      SAAC_APP_UUID: applicationUuid
+    };
+
+    // Determine shell arguments for interactive mode
+    let shellArgs = [];
+    if (shellName === 'bash' || shellName === 'sh') {
+      shellArgs = ['-i']; // Interactive mode
+    } else if (shellName === 'zsh') {
+      shellArgs = ['-i']; // Interactive mode
+    } else if (shellName === 'fish') {
+      shellArgs = ['-i']; // Interactive mode
+    }
+    // If custom shell, try -i flag (most shells support it)
+    else if (!userShell.includes('/')) {
+      shellArgs = ['-i'];
+    }
+
+    // Spawn shell directly with merged environment
+    const shellProc = spawn(userShell, shellArgs, {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+      env: mergedEnv
+    });
+
+    shellProc.on('exit', (code) => {
+      logger.newline();
+      logger.success('✓ Shell closed, environment variables cleared');
+      process.exit(code || 0);
+    });
+
+    shellProc.on('error', (error) => {
+      logger.newline();
+      logger.error(`Failed to open shell: ${error.message}`);
+      process.exit(1);
+    });
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = shell;

package/src/commands/whoami.js

@@ -1,4 +1,90 @@
-// TODO: Implement whoami command
-module.exports = async function() {
-  console.log('whoami command - Coming soon!');
-};
+/**
+ * Whoami Command - Show current user information
+ */
+
+const api = require('../lib/api');
+const { isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+
+/**
+ * Display current authenticated user information
+ */
+async function whoami() {
+  try {
+    // Check authentication
+    if (!isAuthenticated()) {
+      logger.error('Not logged in');
+      logger.newline();
+      logger.info('Run:');
+      logger.log('  saac login -e <email> -k <api-key>');
+      process.exit(1);
+    }
+
+    const spin = logger.spinner('Fetching user information...').start();
+
+    try {
+      const user = await api.getUserInfo();
+
+      spin.succeed('User information retrieved');
+
+      logger.newline();
+
+      logger.section('Current User');
+      logger.newline();
+
+      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('Member Since', formatDate(user.created_at));
+
+      logger.newline();
+
+      // Git Connections
+      if (user.git_connections && user.git_connections.length > 0) {
+        logger.info('Git Connections:');
+        for (const conn of user.git_connections) {
+          logger.log(`  • ${conn.gitUsername} @ ${conn.gitHost} (${conn.providerType})`);
+          logger.log(`    Connected: ${formatDate(conn.connectedAt)}`);
+        }
+        logger.newline();
+      }
+
+      // Quotas
+      logger.info('Quotas:');
+      logger.field('  Applications', `${user.application_count} / ${user.max_applications}`);
+
+      logger.newline();
+
+      logger.info('Commands:');
+      logger.log('  View applications: ' + logger.chalk.cyan('saac list'));
+      logger.log('  View status:       ' + logger.chalk.cyan('saac status'));
+      logger.log('  Logout:            ' + logger.chalk.cyan('saac logout'));
+
+    } catch (error) {
+      spin.fail('Failed to fetch user information');
+      throw error;
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Format ISO date string to readable format
+ * @param {string} isoString - ISO 8601 date string
+ * @returns {string} Formatted date
+ */
+function formatDate(isoString) {
+  if (!isoString) return 'N/A';
+
+  const date = new Date(isoString);
+  return date.toLocaleDateString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric'
+  });
+}
+
+module.exports = whoami;