@startanaicompany/cli 1.0.0 → 1.3.0

package/src/commands/sessions.js

@@ -0,0 +1,75 @@
+/**
+ * Sessions command - List active sessions
+ */
+
+const api = require('../lib/api');
+const { isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+const { table } = require('table');
+
+async function sessions() {
+  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);
+    }
+
+    logger.section('Active Sessions');
+
+    const spin = logger.spinner('Fetching sessions...').start();
+
+    try {
+      const client = api.createClient();
+      const response = await client.get('/auth/sessions');
+      const { sessions: sessionList, total } = response.data;
+
+      spin.succeed(`Found ${total} active session(s)`);
+
+      if (total === 0) {
+        logger.newline();
+        logger.info('No active sessions');
+        return;
+      }
+
+      logger.newline();
+
+      // Format sessions as table
+      const data = [
+        ['Created', 'Last Used', 'IP Address', 'Expires'],
+      ];
+
+      sessionList.forEach((session) => {
+        const created = new Date(session.created_at).toLocaleDateString();
+        const lastUsed = new Date(session.last_used_at).toLocaleString();
+        const expires = new Date(session.expires_at).toLocaleDateString();
+        const ip = session.created_ip || 'Unknown';
+
+        data.push([created, lastUsed, ip, expires]);
+      });
+
+      console.log(table(data, {
+        header: {
+          alignment: 'center',
+          content: `${total} Active Session(s)`,
+        },
+      }));
+
+      logger.newline();
+      logger.info('Tip: Use `saac logout` to logout from current device');
+      logger.info('     Use `saac logout-all` to logout from all devices');
+
+    } catch (error) {
+      spin.fail('Failed to fetch sessions');
+      throw error;
+    }
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = sessions;

package/src/commands/status.js

@@ -1,4 +1,164 @@
-// TODO: Implement status command
-module.exports = async function() {
-  console.log('status command - Coming soon!');
-};
+/**
+ * Status command - Show current login and account status
+ */
+
+const api = require('../lib/api');
+const { getUser, isAuthenticated, isTokenExpiringSoon } = require('../lib/config');
+const logger = require('../lib/logger');
+const { table } = require('table');
+
+async function status() {
+  try {
+    logger.section('SAAC Status');
+    logger.newline();
+
+    // Check if logged in locally (silently)
+    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 user = getUser();
+
+    // Verify session with server first
+    const spin = logger.spinner('Verifying session...').start();
+
+    try {
+      const client = api.createClient();
+      const [userInfo, appsResponse] = await Promise.all([
+        client.get('/users/me'),
+        client.get('/applications')
+      ]);
+
+      spin.succeed('Session verified');
+
+      const userData = userInfo.data;
+      const applicationsData = appsResponse.data;
+      const applications = Array.isArray(applicationsData) ? applicationsData :
+                          (applicationsData.applications || []);
+
+      logger.newline();
+
+      // NOW show login status (after successful verification)
+      logger.field('Status', logger.chalk.green('✓ Logged in'));
+      logger.field('Email', user.email);
+      logger.field('Verified', user.verified ? logger.chalk.green('Yes') : logger.chalk.red('No'));
+
+      // Show session info
+      if (user.sessionToken) {
+        const expiresAt = new Date(user.expiresAt);
+        const now = new Date();
+        const daysUntilExpiry = Math.floor((expiresAt - now) / (1000 * 60 * 60 * 24));
+
+        logger.field('Session expires', expiresAt.toLocaleDateString());
+
+        if (isTokenExpiringSoon()) {
+          logger.field('Warning', logger.chalk.yellow(`⚠ Session expires in ${daysUntilExpiry} days`));
+        } else {
+          logger.field('Days until expiry', daysUntilExpiry);
+        }
+      }
+
+      logger.newline();
+
+      // Show account info
+      logger.field('User ID', userData.id);
+      logger.field('Git Username', userData.git_username || 'Not set');
+      logger.field('Applications', `${userData.application_count} / ${userData.max_applications}`);
+
+      logger.newline();
+
+      // Show applications (max 5)
+      if (applications.length === 0) {
+        logger.info('No applications yet');
+        logger.newline();
+        logger.info('Create one with: ' + logger.chalk.cyan('saac create <name>'));
+      } else {
+        const displayApps = applications.slice(0, 5);
+        const hasMore = applications.length > 5;
+
+        const data = [
+          ['Name', 'Domain', 'Status', 'Created'],
+        ];
+
+        displayApps.forEach((app) => {
+          const created = new Date(app.created_at).toLocaleDateString();
+          const status = app.status || 'unknown';
+
+          // Status with icons (handle both Coolify format and documented format)
+          let statusDisplay;
+          if (status.startsWith('running')) {
+            statusDisplay = logger.chalk.green('Running ✓');
+          } else if (status.startsWith('stopped')) {
+            statusDisplay = logger.chalk.yellow('Stopped');
+          } else {
+            switch (status) {
+              case 'active':
+                statusDisplay = logger.chalk.green('Active ✓');
+                break;
+              case 'creating':
+                statusDisplay = logger.chalk.yellow('Creating...');
+                break;
+              case 'error':
+                statusDisplay = logger.chalk.red('Error ✗');
+                break;
+              case 'suspended':
+                statusDisplay = logger.chalk.yellow('Suspended ⚠');
+                break;
+              default:
+                statusDisplay = logger.chalk.gray(status);
+            }
+          }
+
+          data.push([
+            app.name,
+            app.domain || `${app.subdomain}.startanaicompany.com`,
+            statusDisplay,
+            created
+          ]);
+        });
+
+        console.log(table(data, {
+          header: {
+            alignment: 'center',
+            content: `Applications (showing ${displayApps.length} of ${applications.length})`,
+          },
+        }));
+
+        if (hasMore) {
+          logger.warn(`Showing first 5 applications only. You have ${applications.length - 5} more.`);
+          logger.info('Run ' + logger.chalk.cyan('saac list') + ' to see all applications');
+        }
+      }
+
+    } catch (error) {
+      spin.fail('Session verification failed');
+
+      logger.newline();
+
+      if (error.response?.status === 401) {
+        logger.error('Your session has expired or is invalid');
+        logger.newline();
+        logger.field('Email', user.email);
+        logger.field('Local session expires', new Date(user.expiresAt).toLocaleDateString());
+        logger.newline();
+        logger.warn('The session token is no longer valid on the server');
+        logger.info('Please login again:');
+        logger.log('  saac login -e ' + user.email + ' -k <api-key>');
+      } else {
+        logger.error('Failed to connect to server');
+        logger.error(error.message);
+      }
+      process.exit(1);
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = status;

package/src/commands/update.js

@@ -0,0 +1,284 @@
+/**
+ * Update command - Update application configuration
+ */
+
+const api = require('../lib/api');
+const { isAuthenticated, getProjectConfig } = require('../lib/config');
+const logger = require('../lib/logger');
+
+async function update(options) {
+  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);
+    }
+
+    // Get project config
+    const projectConfig = getProjectConfig();
+    if (!projectConfig) {
+      logger.error('Not in a SAAC project directory');
+      logger.newline();
+      logger.info('Run this command in a directory initialized with:');
+      logger.log('  saac init');
+      logger.log('  saac create <name>');
+      process.exit(1);
+    }
+
+    logger.section(`Updating Application: ${projectConfig.applicationName}`);
+    logger.newline();
+
+    // Build update payload from options
+    const updateData = {};
+    let hasChanges = false;
+
+    // Basic fields
+    if (options.name) {
+      updateData.name = options.name;
+      hasChanges = true;
+    }
+    if (options.branch) {
+      updateData.git_branch = options.branch;
+      hasChanges = true;
+    }
+
+    // Port configuration
+    if (options.port) {
+      updateData.ports_exposes = options.port;
+      hasChanges = true;
+    }
+
+    // Build pack
+    if (options.buildPack) {
+      const validBuildPacks = ['dockercompose', 'nixpacks', 'dockerfile', 'static'];
+      if (!validBuildPacks.includes(options.buildPack)) {
+        logger.error(`Invalid build pack: ${options.buildPack}`);
+        logger.info(`Must be one of: ${validBuildPacks.join(', ')}`);
+        process.exit(1);
+      }
+      updateData.build_pack = options.buildPack;
+      hasChanges = true;
+    }
+
+    // Custom commands
+    if (options.installCmd) {
+      updateData.install_command = options.installCmd;
+      hasChanges = true;
+    }
+    if (options.buildCmd) {
+      updateData.build_command = options.buildCmd;
+      hasChanges = true;
+    }
+    if (options.startCmd) {
+      updateData.start_command = options.startCmd;
+      hasChanges = true;
+    }
+    if (options.preDeployCmd) {
+      updateData.pre_deployment_command = options.preDeployCmd;
+      hasChanges = true;
+    }
+    if (options.postDeployCmd) {
+      updateData.post_deployment_command = options.postDeployCmd;
+      hasChanges = true;
+    }
+
+    // Resource limits
+    if (options.cpuLimit) {
+      updateData.cpu_limit = options.cpuLimit;
+      hasChanges = true;
+    }
+    if (options.memoryLimit) {
+      updateData.memory_limit = options.memoryLimit;
+      hasChanges = true;
+    }
+
+    // Health check configuration
+    if (options.healthCheck !== undefined) {
+      updateData.health_check_enabled = options.healthCheck;
+      hasChanges = true;
+    }
+    if (options.healthPath) {
+      updateData.health_check_path = options.healthPath;
+      hasChanges = true;
+    }
+    if (options.healthInterval) {
+      updateData.health_check_interval = parseInt(options.healthInterval, 10);
+      hasChanges = true;
+    }
+    if (options.healthTimeout) {
+      updateData.health_check_timeout = parseInt(options.healthTimeout, 10);
+      hasChanges = true;
+    }
+    if (options.healthRetries) {
+      const retries = parseInt(options.healthRetries, 10);
+      if (retries < 1 || retries > 10) {
+        logger.error('Health check retries must be between 1 and 10');
+        process.exit(1);
+      }
+      updateData.health_check_retries = retries;
+      hasChanges = true;
+    }
+
+    // Restart policy
+    if (options.restart) {
+      const validRestartPolicies = ['always', 'on-failure', 'unless-stopped', 'no'];
+      if (!validRestartPolicies.includes(options.restart)) {
+        logger.error(`Invalid restart policy: ${options.restart}`);
+        logger.info(`Must be one of: ${validRestartPolicies.join(', ')}`);
+        process.exit(1);
+      }
+      updateData.restart = options.restart;
+      hasChanges = true;
+    }
+
+    // Environment variables
+    if (options.env) {
+      const envVars = {};
+      const envArray = Array.isArray(options.env) ? options.env : [options.env];
+
+      for (const envStr of envArray) {
+        const [key, ...valueParts] = envStr.split('=');
+        const value = valueParts.join('='); // Handle values with '=' in them
+
+        if (!key || value === undefined) {
+          logger.error(`Invalid environment variable format: ${envStr}`);
+          logger.info('Use format: KEY=VALUE');
+          process.exit(1);
+        }
+
+        envVars[key] = value;
+      }
+
+      if (Object.keys(envVars).length > 50) {
+        logger.error('Maximum 50 environment variables allowed');
+        process.exit(1);
+      }
+
+      updateData.environment_variables = envVars;
+      hasChanges = true;
+    }
+
+    // Check if any changes were provided
+    if (!hasChanges) {
+      logger.error('No configuration changes specified');
+      logger.newline();
+      logger.info('Usage:');
+      logger.log('  saac update [options]');
+      logger.newline();
+      logger.info('Available options:');
+      logger.log('  -n, --name <name>                    Application name');
+      logger.log('  -b, --branch <branch>                Git branch');
+      logger.log('  -p, --port <port>                    Port to expose');
+      logger.log('  --build-pack <pack>                  Build pack: dockercompose, nixpacks, dockerfile, static');
+      logger.log('  --install-cmd <command>              Install command');
+      logger.log('  --build-cmd <command>                Build command');
+      logger.log('  --start-cmd <command>                Start command');
+      logger.log('  --pre-deploy-cmd <command>           Pre-deployment command');
+      logger.log('  --post-deploy-cmd <command>          Post-deployment command');
+      logger.log('  --cpu-limit <limit>                  CPU limit (e.g., "1", "2.5")');
+      logger.log('  --memory-limit <limit>               Memory limit (e.g., "512M", "2G")');
+      logger.log('  --health-check                       Enable health checks');
+      logger.log('  --no-health-check                    Disable health checks');
+      logger.log('  --health-path <path>                 Health check path');
+      logger.log('  --health-interval <seconds>          Health check interval in seconds');
+      logger.log('  --health-timeout <seconds>           Health check timeout in seconds');
+      logger.log('  --health-retries <count>             Health check retries (1-10)');
+      logger.log('  --restart <policy>                   Restart policy: always, on-failure, unless-stopped, no');
+      logger.log('  --env <KEY=VALUE>                    Environment variable (can be used multiple times)');
+      logger.newline();
+      logger.info('Example:');
+      logger.log('  saac update --port 8080 --health-check --health-path /api/health');
+      logger.log('  saac update --build-pack nixpacks --cpu-limit 2 --memory-limit 2G');
+      process.exit(1);
+    }
+
+    // Show configuration changes
+    logger.info('Configuration changes:');
+    Object.entries(updateData).forEach(([key, value]) => {
+      const displayKey = key.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+      let displayValue = value;
+      if (typeof value === 'object' && !Array.isArray(value)) {
+        displayValue = `${Object.keys(value).length} variable(s)`;
+      }
+      logger.field(displayKey, displayValue);
+    });
+
+    logger.newline();
+
+    const spin = logger.spinner('Updating application configuration...').start();
+
+    try {
+      const result = await api.updateApplication(projectConfig.applicationUuid, updateData);
+
+      spin.succeed('Configuration updated successfully!');
+
+      logger.newline();
+
+      if (result.updated_fields && result.updated_fields.length > 0) {
+        logger.success(`Updated ${result.updated_fields.length} field(s)`);
+        logger.newline();
+      }
+
+      // Warn if tier limits were applied
+      if (result.applied_tier_limits) {
+        logger.warn('Resource limits were capped at your tier maximum');
+        logger.info('Free tier: 1 vCPU, 1024M RAM');
+        logger.newline();
+      }
+
+      // Show next steps
+      logger.info('Next steps:');
+      logger.log('  1. Review changes above');
+      logger.log(`  2. Deploy to apply: ${logger.chalk.cyan('saac deploy')}`);
+      logger.log(`  3. Monitor deployment: ${logger.chalk.cyan('saac logs --follow')}`);
+      logger.newline();
+
+      logger.warn('Note: Configuration changes require redeployment to take effect');
+
+    } catch (error) {
+      spin.fail('Configuration update failed');
+
+      if (error.response?.status === 403) {
+        const data = error.response.data;
+        logger.newline();
+        logger.error('Quota exceeded');
+        if (data.current_tier) {
+          logger.field('Current Tier', data.current_tier);
+        }
+        logger.newline();
+        logger.warn(data.error || data.message);
+        if (data.upgrade_info) {
+          logger.info(data.upgrade_info);
+        }
+      } else if (error.response?.status === 400) {
+        const data = error.response.data;
+        logger.newline();
+        logger.error('Validation failed');
+        if (data.details) {
+          logger.newline();
+          Object.entries(data.details).forEach(([field, message]) => {
+            logger.log(`  ${logger.chalk.yellow(field)}: ${message}`);
+          });
+        } else {
+          logger.log(`  ${data.message || data.error}`);
+        }
+      } else if (error.response?.status === 404) {
+        logger.newline();
+        logger.error('Application not found');
+        logger.info('The application may have been deleted');
+      } else {
+        throw error;
+      }
+      process.exit(1);
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = update;

package/src/commands/verify.js

@@ -8,10 +8,24 @@ const logger = require('../lib/logger');
 
 async function verify(code) {
   try {
+    if (!code) {
+      logger.error('Verification code is required');
+      logger.newline();
+      logger.info('Usage:');
+      logger.log('  saac verify <code>');
+      logger.newline();
+      logger.info('Example:');
+      logger.log('  saac verify 123456');
+      process.exit(1);
+    }
+
     const user = getUser();
 
     if (!user || !user.email) {
-      logger.error('No user found. Please register first with: saac register');
+      logger.error('No user found. Please register first');
+      logger.newline();
+      logger.info('Run:');
+      logger.log('  saac register -e <email>');
       process.exit(1);
     }
 
@@ -29,16 +43,30 @@ async function verify(code) {
 
       spin.succeed('Email verified successfully!');
 
-      // Update user verification status
-      saveUser({
+      // Update user verification status and session token if provided
+      const updatedUser = {
         ...user,
         verified: true,
-      });
+      };
+
+      // If backend returns new session token after verification, update it
+      if (result.session_token) {
+        updatedUser.sessionToken = result.session_token;
+        updatedUser.expiresAt = result.expires_at;
+      }
+
+      saveUser(updatedUser);
 
       logger.newline();
       logger.success('Your account is now verified!');
       logger.info('You can now create and deploy applications.');
 
+      // Show expiration if session token was updated
+      if (result.expires_at) {
+        const expirationDate = new Date(result.expires_at);
+        logger.field('Session expires', expirationDate.toLocaleDateString());
+      }
+
     } catch (error) {
       spin.fail('Verification failed');
       throw error;

package/src/lib/api.js

@@ -3,22 +3,56 @@
  */
 
 const axios = require('axios');
+const os = require('os');
 const { getApiUrl, getUser } = require('./config');
+const pkg = require('../../package.json');
 
 /**
  * Create axios instance with base configuration
  */
 function createClient() {
   const user = getUser();
+  const envApiKey = process.env.SAAC_API_KEY; // For CI/CD
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'User-Agent': `saac-cli/${pkg.version} (${os.platform()}; ${os.arch()})`,
+  };
+
+  // Priority order:
+  // 1. Environment variable (for CI/CD, scripts)
+  // 2. Session token (for CLI users)
+  // 3. API key (backward compatibility)
+  if (envApiKey) {
+    headers['X-API-Key'] = envApiKey;
+  } else if (user?.sessionToken) {
+    headers['X-Session-Token'] = user.sessionToken;
+  } else if (user?.apiKey) {
+    headers['X-API-Key'] = user.apiKey;
+  }
 
   return axios.create({
+    baseURL: getApiUrl(),
+    timeout: 30000,
+    headers,
+  });
+}
+
+/**
+ * Login and get session token
+ */
+async function login(email, apiKey) {
+  const client = axios.create({
     baseURL: getApiUrl(),
     timeout: 30000,
     headers: {
       'Content-Type': 'application/json',
-      ...(user?.apiKey && { 'X-API-Key': user.apiKey }),
+      'X-API-Key': apiKey, // Use API key for login
     },
   });
+
+  const response = await client.post('/auth/login', { email });
+  return response.data;
 }
 
 /**
@@ -99,6 +133,15 @@ async function getApplicationLogs(uuid, params = {}) {
   return response.data;
 }
 
+/**
+ * Update application configuration
+ */
+async function updateApplication(uuid, updateData) {
+  const client = createClient();
+  const response = await client.patch(`/applications/${uuid}`, updateData);
+  return response.data;
+}
+
 /**
  * Update environment variables
  */
@@ -141,10 +184,13 @@ async function healthCheck() {
 }
 
 module.exports = {
+  createClient,
+  login,
   register,
   verifyEmail,
   getUserInfo,
   createApplication,
+  updateApplication,
   listApplications,
   getApplication,
   deployApplication,