@startanaicompany/cli 1.4.16 → 1.4.18

package/src/commands/create.js

@@ -8,6 +8,7 @@ const logger = require('../lib/logger');
 const oauth = require('../lib/oauth');
 const inquirer = require('inquirer');
 const { execSync } = require('child_process');
+const errorDisplay = require('../lib/errorDisplay');
 
 async function create(name, options) {
   try {
@@ -281,14 +282,12 @@ async function create(name, options) {
 
     logger.newline();
 
-    const spin = logger.spinner('Creating application...').start();
+    const spin = logger.spinner('Creating application and deploying (this may take up to 5 minutes)...').start();
 
     try {
       const result = await api.createApplication(appData);
 
-      spin.succeed('Application created successfully!');
-
-      // Save project configuration
+      // Always save project configuration (even if deployment failed)
       saveProjectConfig({
         applicationUuid: result.coolify_app_uuid,
         applicationName: result.app_name,
@@ -297,13 +296,35 @@ async function create(name, options) {
         gitRepository: appData.git_repository,
       });
 
+      // Check if deployment failed
+      if (result.success === false) {
+        spin.fail('Deployment failed');
+
+        // Display detailed error information
+        errorDisplay.displayDeploymentError(result, logger);
+
+        // Show recovery instructions
+        errorDisplay.displayCreateRecoveryInstructions(result, logger);
+
+        process.exit(1);
+      }
+
+      // SUCCESS: Application created and deployed
+      spin.succeed('Application created and deployed successfully!');
+
       logger.newline();
-      logger.success('Application created!');
+      logger.success('Your application is live!');
       logger.newline();
       logger.field('Name', result.app_name);
       logger.field('Domain', result.domain);
       logger.field('UUID', result.coolify_app_uuid);
-      logger.field('Status', result.deployment_status);
+      logger.field('Status', result.deployment_status || 'finished');
+      if (result.git_branch) {
+        logger.field('Branch', result.git_branch);
+      }
+      if (result.deployment_uuid) {
+        logger.field('Deployment ID', result.deployment_uuid);
+      }
       logger.newline();
 
       // Show next steps

package/src/commands/delete.js

@@ -1,4 +1,191 @@
-// TODO: Implement delete command
-module.exports = async function() {
-  console.log('delete command - Coming soon!');
-};
+/**
+ * Delete Command - Permanently delete application
+ */
+
+const api = require('../lib/api');
+const { getProjectConfig, isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Delete application with confirmation
+ * @param {object} options - Command options
+ */
+async function deleteApp(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 } = projectConfig;
+
+    // Fetch application details for confirmation
+    const fetchSpin = logger.spinner('Fetching application details...').start();
+
+    let app;
+    try {
+      app = await api.getApplication(applicationUuid);
+      fetchSpin.succeed('Application details retrieved');
+    } catch (error) {
+      fetchSpin.fail('Failed to fetch application details');
+      throw error;
+    }
+
+    logger.newline();
+
+    // Show confirmation prompt (unless --yes flag)
+    if (!options.yes) {
+      logger.warn('WARNING: This will permanently delete your application!');
+      logger.newline();
+
+      logger.field('Application', app.name);
+      logger.field('Domain', app.domain || `https://${app.subdomain}.startanaicompany.com`);
+      logger.field('UUID', app.uuid);
+      logger.field('Status', app.status);
+
+      logger.newline();
+
+      logger.error('This action cannot be undone. All data will be lost:');
+      logger.log('  • Application configuration');
+      logger.log('  • All deployments');
+      logger.log('  • Environment variables');
+      logger.log('  • All logs');
+      logger.log('  • DNS records');
+
+      logger.newline();
+
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'confirmation',
+          message: 'Type \'yes\' to confirm deletion:',
+          validate: (input) => {
+            if (input === 'yes') {
+              return true;
+            }
+            return 'Please type \'yes\' to confirm';
+          }
+        }
+      ]);
+
+      if (answers.confirmation !== 'yes') {
+        logger.error('Deletion cancelled');
+        process.exit(0);
+      }
+
+      logger.newline();
+    }
+
+    // Delete application
+    const deleteSpin = logger.spinner('Deleting application...').start();
+
+    try {
+      const result = await api.deleteApplication(app.uuid);
+
+      deleteSpin.succeed('Application deleted successfully!');
+
+      logger.newline();
+
+      logger.info('Resources deleted:');
+      for (const [resource, deleted] of Object.entries(result.resources_deleted || {})) {
+        const icon = deleted ? '✓' : '✗';
+        const name = resource.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+        const color = deleted ? logger.chalk.green : logger.chalk.red;
+        logger.log(`  ${color(icon)} ${name}`);
+      }
+
+      logger.newline();
+
+      logger.success(`Application '${result.application_name}' has been permanently deleted.`);
+
+      logger.newline();
+
+      logger.info('Next steps:');
+      logger.log('  • Remove local project: rm -rf .saac/');
+      logger.log('  • Create new application: saac create');
+      logger.log('  • View other applications: saac list');
+
+      // Remove local config
+      const configDir = path.join(process.cwd(), '.saac');
+      if (fs.existsSync(configDir)) {
+        fs.rmSync(configDir, { recursive: true, force: true });
+        logger.newline();
+        logger.success('Local configuration removed');
+      }
+
+    } catch (error) {
+      deleteSpin.fail('Failed to delete application');
+
+      if (error.response?.status === 404) {
+        logger.newline();
+        logger.warn('Application not found or already deleted');
+      } else if (error.response?.status === 409) {
+        logger.newline();
+        const data = error.response.data;
+
+        if (data.error === 'DEPLOYMENT_IN_PROGRESS') {
+          logger.warn('Cannot delete application while deployment is in progress');
+          logger.newline();
+          logger.info('Details:');
+          logger.field('  Deployment Status', data.current_deployment_status);
+          if (data.deployment_uuid) {
+            logger.field('  Deployment UUID', data.deployment_uuid);
+          }
+          logger.newline();
+          logger.info('Suggestion:');
+          logger.log('  Wait for deployment to finish or fail before deleting');
+          logger.newline();
+          logger.info('Check deployment status:');
+          logger.log('  saac deployments');
+        }
+      } else if (error.response?.status === 500) {
+        logger.newline();
+        const data = error.response.data;
+
+        if (data.error === 'PARTIAL_DELETION') {
+          logger.warn('Application partially deleted. Some resources may remain.');
+          logger.newline();
+          logger.info('Cleanup status:');
+          if (data.details) {
+            for (const [resource, deleted] of Object.entries(data.details)) {
+              if (resource !== 'error') {
+                const icon = deleted ? '✓' : '✗';
+                const name = resource.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+                logger.log(`  ${icon} ${name}`);
+              }
+            }
+            if (data.details.error) {
+              logger.newline();
+              logger.error('Error: ' + data.details.error);
+            }
+          }
+          logger.newline();
+          logger.info('Please contact support to complete cleanup');
+        }
+      }
+
+      throw error;
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = deleteApp;

package/src/commands/deploy.js

@@ -5,6 +5,7 @@
 const api = require('../lib/api');
 const { getProjectConfig, isAuthenticated } = require('../lib/config');
 const logger = require('../lib/logger');
+const errorDisplay = require('../lib/errorDisplay');
 
 async function deploy(options) {
   try {
@@ -25,30 +26,62 @@ async function deploy(options) {
     const { applicationUuid, applicationName } = projectConfig;
 
     logger.section(`Deploying ${applicationName}`);
+    logger.newline();
 
-    const spin = logger.spinner('Triggering deployment...').start();
+    const spin = logger.spinner('Deploying application (waiting for completion, up to 5 minutes)...').start();
 
     try {
       const result = await api.deployApplication(applicationUuid);
 
-      spin.succeed('Deployment triggered!');
+      // 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!');
 
       logger.newline();
-      logger.success('Deployment started successfully');
+      logger.success('Your application has been deployed!');
       logger.newline();
       logger.field('Application', applicationName);
       logger.field('Status', result.status);
+      if (result.git_branch) {
+        logger.field('Branch', result.git_branch);
+      }
       if (result.domain) {
         logger.field('Domain', result.domain);
       }
-      logger.field('Deployment ID', result.deployment_id);
+      if (result.deployment_uuid || result.deployment_id) {
+        logger.field('Deployment ID', result.deployment_uuid || result.deployment_id);
+      }
       logger.newline();
-      logger.info(
-        `View logs with: ${logger.chalk.yellow('saac logs --follow')}`
-      );
+
+      // 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`);
 
     } catch (error) {
-      spin.fail('Deployment failed');
+      spin.fail('Deployment request failed');
       throw error;
     }
   } catch (error) {

package/src/commands/deployments.js

@@ -0,0 +1,130 @@
+/**
+ * Deployments command - List deployment history
+ */
+
+const api = require('../lib/api');
+const { getProjectConfig, isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+const { table } = require('table');
+
+async function deployments(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;
+
+    logger.section(`Deployment History: ${applicationName}`);
+    logger.newline();
+
+    const spin = logger.spinner('Fetching deployment history...').start();
+
+    try {
+      // Build query parameters
+      const params = {};
+      if (options.limit) {
+        params.limit = parseInt(options.limit, 10);
+      }
+      if (options.offset) {
+        params.offset = parseInt(options.offset, 10);
+      }
+
+      const result = await api.getDeployments(applicationUuid, params);
+
+      spin.succeed('Deployment history retrieved');
+
+      if (!result.deployments || result.deployments.length === 0) {
+        logger.newline();
+        logger.warn('No deployments found for this application');
+        logger.newline();
+        logger.info('Deploy your application with:');
+        logger.log('  saac deploy');
+        return;
+      }
+
+      logger.newline();
+
+      // Build table data
+      const data = [
+        ['UUID', 'Status', 'Branch', 'Commit', 'Duration', 'Trigger', 'Date'],
+      ];
+
+      result.deployments.forEach((d) => {
+        const uuid = d.deployment_uuid ? d.deployment_uuid.substring(0, 23) + '...' : 'N/A';
+
+        // Colorize status
+        let statusDisplay;
+        if (d.status === 'finished') {
+          statusDisplay = logger.chalk.green('finished');
+        } else if (d.status === 'failed') {
+          statusDisplay = logger.chalk.red('failed');
+        } else if (d.status === 'running' || d.status === 'queued') {
+          statusDisplay = logger.chalk.yellow(d.status);
+        } else {
+          statusDisplay = logger.chalk.gray(d.status || 'unknown');
+        }
+
+        const branch = d.git_branch || 'N/A';
+        const commit = d.git_commit ? d.git_commit.substring(0, 7) : 'N/A';
+        const duration = d.duration_seconds ? `${d.duration_seconds}s` : '-';
+        const trigger = d.triggered_by || 'api';
+        const date = d.started_at ? new Date(d.started_at).toLocaleString() : 'N/A';
+
+        data.push([
+          uuid,
+          statusDisplay,
+          branch,
+          commit,
+          duration,
+          trigger,
+          date,
+        ]);
+      });
+
+      console.log(table(data, {
+        header: {
+          alignment: 'center',
+          content: `Showing ${result.deployments.length} of ${result.total} deployments`,
+        },
+      }));
+
+      // Show pagination info
+      if (result.total > result.deployments.length) {
+        const remaining = result.total - result.deployments.length;
+        logger.info(`${remaining} more deployment(s) available`);
+        logger.newline();
+        logger.info('View more with:');
+        logger.log(`  saac deployments --limit ${options.limit || 20} --offset ${(options.offset || 0) + (options.limit || 20)}`);
+      }
+
+      logger.newline();
+      logger.info('View deployment logs:');
+      logger.log('  saac logs --deployment              # Latest deployment');
+      logger.log('  saac logs --deployment <uuid>       # Specific deployment');
+
+    } catch (error) {
+      spin.fail('Failed to fetch deployment history');
+      throw error;
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = deployments;

package/src/commands/domain.js

@@ -1,4 +1,205 @@
-// TODO: Implement domain command
-module.exports = async function() {
-  console.log('domain command - Coming soon!');
+/**
+ * Domain Management Commands - Manage application domain and subdomain
+ */
+
+const api = require('../lib/api');
+const { getProjectConfig, isAuthenticated, saveProjectConfig } = require('../lib/config');
+const logger = require('../lib/logger');
+
+/**
+ * Set/change application subdomain
+ * @param {string} subdomain - New subdomain
+ * @param {object} options - Command options
+ */
+async function set(subdomain, 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;
+
+    // Validate subdomain format
+    const subdomainRegex = /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/;
+    if (!subdomainRegex.test(subdomain)) {
+      logger.error('Invalid subdomain format');
+      logger.newline();
+      logger.info('Subdomain must:');
+      logger.log('  • Be 3-63 characters long');
+      logger.log('  • Contain only lowercase letters, numbers, and hyphens');
+      logger.log('  • Not start or end with a hyphen');
+      logger.newline();
+      logger.info('Valid examples:');
+      logger.log('  my-app, johnsmith, app-123');
+      logger.newline();
+      logger.info('Invalid examples:');
+      logger.log('  My-App (uppercase), -myapp (starts with hyphen), a (too short)');
+      process.exit(1);
+    }
+
+    const domainSuffix = options.domainSuffix || 'startanaicompany.com';
+
+    logger.section('Updating Domain');
+    logger.newline();
+
+    logger.info('Configuration:');
+    logger.field('  Application', applicationName);
+    logger.field('  New Subdomain', subdomain);
+    logger.field('  Domain Suffix', domainSuffix);
+    logger.field('  New Domain', `https://${subdomain}.${domainSuffix}`);
+
+    logger.newline();
+
+    const spin = logger.spinner('Updating domain...').start();
+
+    try {
+      const result = await api.updateDomain(applicationUuid, subdomain, domainSuffix);
+
+      spin.succeed('Domain updated successfully!');
+
+      logger.newline();
+
+      logger.field('Old Domain', result.old_domain);
+      logger.field('New Domain', result.new_domain);
+
+      logger.newline();
+      logger.info('DNS propagation may take 1-5 minutes');
+      logger.info('Your application will be accessible at the new domain shortly.');
+
+      // Update local config
+      projectConfig.subdomain = subdomain;
+      projectConfig.domain = result.new_domain;
+      saveProjectConfig(projectConfig);
+
+      logger.newline();
+      logger.success('Local configuration updated');
+
+    } catch (error) {
+      spin.fail('Failed to update domain');
+
+      if (error.response?.status === 409) {
+        logger.newline();
+        const data = error.response.data;
+
+        if (data.error === 'SUBDOMAIN_TAKEN') {
+          logger.warn('Subdomain is already taken');
+          logger.newline();
+
+          if (data.suggestions && data.suggestions.length > 0) {
+            logger.info('Try these alternatives:');
+            data.suggestions.forEach(suggestion => {
+              logger.log(`  • ${suggestion}`);
+            });
+          }
+        } else if (data.error === 'SUBDOMAIN_BLOCKED') {
+          logger.warn('Subdomain is reserved and cannot be used');
+          logger.newline();
+          logger.info('Reserved subdomains:');
+          if (data.blocklist) {
+            data.blocklist.forEach(blocked => {
+              logger.log(`  • ${blocked}`);
+            });
+          }
+        }
+      } else if (error.response?.status === 403) {
+        logger.newline();
+        const data = error.response.data;
+
+        if (data.error === 'DOMAIN_SUFFIX_NOT_ALLOWED') {
+          logger.warn('Custom domain suffix not available on your plan');
+          logger.newline();
+          logger.info('Allowed suffixes:');
+          if (data.allowed_suffixes) {
+            data.allowed_suffixes.forEach(suffix => {
+              logger.log(`  • ${suffix}`);
+            });
+          }
+          logger.newline();
+          if (data.upgrade_required) {
+            logger.info('Upgrade to Pro plan for custom domain support');
+          }
+        }
+      }
+
+      throw error;
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show current domain information
+ */
+async function show() {
+  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 } = projectConfig;
+
+    const spin = logger.spinner('Fetching application details...').start();
+
+    try {
+      const app = await api.getApplication(applicationUuid);
+
+      spin.succeed('Application details retrieved');
+
+      logger.newline();
+
+      logger.section(`Domain Information: ${app.name}`);
+      logger.newline();
+
+      logger.field('Domain', app.domain || `https://${app.subdomain}.startanaicompany.com`);
+      logger.field('Subdomain', app.subdomain);
+      logger.field('Domain Suffix', 'startanaicompany.com');
+      logger.field('Status', app.status);
+
+      logger.newline();
+      logger.info('To change domain:');
+      logger.log('  saac domain set <new-subdomain>');
+
+    } catch (error) {
+      spin.fail('Failed to fetch application details');
+      throw error;
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  set,
+  show,
 };