@startanaicompany/cli 1.1.0 → 1.3.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@startanaicompany/cli",
-  "version": "1.1.0",
+  "version": "1.3.1",
   "description": "Official CLI for StartAnAiCompany.com - Deploy AI recruitment sites with ease",
   "main": "src/index.js",
   "bin": {
-    "saac": "./bin/saac.js"
+    "saac": "bin/saac.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/src/commands/create.js

@@ -1,4 +1,278 @@
-// TODO: Implement create command
-module.exports = async function() {
-  console.log('create command - Coming soon!');
-};
+/**
+ * Create command - Create a new application
+ */
+
+const api = require('../lib/api');
+const { isAuthenticated, saveProjectConfig } = require('../lib/config');
+const logger = require('../lib/logger');
+
+async function create(name, 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);
+    }
+
+    // Validate required fields
+    if (!name) {
+      logger.error('Application name is required');
+      logger.newline();
+      logger.info('Usage:');
+      logger.log('  saac create <name> [options]');
+      logger.newline();
+      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('  -t, --git-token <token>              Git API token');
+      logger.newline();
+      logger.info('Optional options:');
+      logger.log('  -b, --branch <branch>                Git branch (default: master)');
+      logger.log('  -d, --domain-suffix <suffix>         Domain suffix (default: startanaicompany.com)');
+      logger.log('  -p, --port <port>                    Port to expose (default: 3000)');
+      logger.log('  --build-pack <pack>                  Build pack: dockercompose, nixpacks, dockerfile, static');
+      logger.log('  --install-cmd <command>              Install command (e.g., "pnpm install")');
+      logger.log('  --build-cmd <command>                Build command (e.g., "npm run build")');
+      logger.log('  --start-cmd <command>                Start command (e.g., "node server.js")');
+      logger.log('  --pre-deploy-cmd <command>           Pre-deployment command (e.g., "npm run migrate")');
+      logger.log('  --post-deploy-cmd <command>          Post-deployment command (e.g., "npm run seed")');
+      logger.log('  --health-check                       Enable health checks');
+      logger.log('  --health-path <path>                 Health check path (default: /health)');
+      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('  --cpu-limit <limit>                  CPU limit (e.g., "1", "2.5")');
+      logger.log('  --memory-limit <limit>               Memory limit (e.g., "512M", "2G")');
+      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 -t abc123');
+      logger.log('  saac create api -s api -r git@git... -t abc123 --build-pack nixpacks --port 8080');
+      logger.log('  saac create web -s web -r git@git... -t abc123 --health-check --pre-deploy-cmd "npm run migrate"');
+      process.exit(1);
+    }
+
+    if (!options.subdomain || !options.repository || !options.gitToken) {
+      logger.error('Missing required options: subdomain, repository, and git-token are required');
+      logger.newline();
+      logger.info('Example:');
+      logger.log(`  saac create ${name} -s myapp -r git@git.startanaicompany.com:user/repo.git -t your_token`);
+      process.exit(1);
+    }
+
+    logger.section(`Creating Application: ${name}`);
+    logger.newline();
+
+    // Build application payload
+    const appData = {
+      name: name,
+      subdomain: options.subdomain,
+      domain_suffix: options.domainSuffix || 'startanaicompany.com',
+      git_repository: options.repository,
+      git_branch: options.branch || 'master',
+      git_api_token: options.gitToken,
+    };
+
+    // Optional: Port configuration
+    if (options.port) {
+      appData.ports_exposes = options.port;
+    }
+
+    // Optional: 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);
+      }
+      appData.build_pack = options.buildPack;
+    }
+
+    // Optional: Custom commands
+    if (options.installCmd) {
+      appData.install_command = options.installCmd;
+    }
+    if (options.buildCmd) {
+      appData.build_command = options.buildCmd;
+    }
+    if (options.startCmd) {
+      appData.start_command = options.startCmd;
+    }
+    if (options.preDeployCmd) {
+      appData.pre_deployment_command = options.preDeployCmd;
+    }
+    if (options.postDeployCmd) {
+      appData.post_deployment_command = options.postDeployCmd;
+    }
+
+    // Optional: Resource limits
+    if (options.cpuLimit) {
+      appData.cpu_limit = options.cpuLimit;
+    }
+    if (options.memoryLimit) {
+      appData.memory_limit = options.memoryLimit;
+    }
+
+    // Optional: Health check configuration
+    if (options.healthCheck) {
+      appData.health_check_enabled = true;
+      if (options.healthPath) {
+        appData.health_check_path = options.healthPath;
+      }
+      if (options.healthInterval) {
+        appData.health_check_interval = parseInt(options.healthInterval, 10);
+      }
+      if (options.healthTimeout) {
+        appData.health_check_timeout = parseInt(options.healthTimeout, 10);
+      }
+      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);
+        }
+        appData.health_check_retries = retries;
+      }
+    }
+
+    // Optional: 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);
+      }
+
+      appData.environment_variables = envVars;
+    }
+
+    // Show configuration summary
+    logger.info('Configuration:');
+    logger.field('Name', appData.name);
+    logger.field('Subdomain', `${appData.subdomain}.${appData.domain_suffix}`);
+    logger.field('Repository', appData.git_repository);
+    logger.field('Branch', appData.git_branch);
+    if (appData.ports_exposes) {
+      logger.field('Port', appData.ports_exposes);
+    }
+    if (appData.build_pack) {
+      logger.field('Build Pack', appData.build_pack);
+    }
+    if (appData.cpu_limit || appData.memory_limit) {
+      const limits = [];
+      if (appData.cpu_limit) limits.push(`CPU: ${appData.cpu_limit}`);
+      if (appData.memory_limit) limits.push(`Memory: ${appData.memory_limit}`);
+      logger.field('Resource Limits', limits.join(', '));
+      logger.warn('Note: Free tier limited to 1 vCPU, 1024M RAM');
+    }
+    if (appData.health_check_enabled) {
+      logger.field('Health Check', `Enabled on ${appData.health_check_path || '/health'}`);
+    }
+    if (appData.pre_deployment_command) {
+      logger.field('Pre-Deploy Hook', appData.pre_deployment_command);
+    }
+    if (appData.environment_variables) {
+      logger.field('Environment Vars', `${Object.keys(appData.environment_variables).length} variable(s)`);
+    }
+
+    logger.newline();
+
+    const spin = logger.spinner('Creating application...').start();
+
+    try {
+      const result = await api.createApplication(appData);
+
+      spin.succeed('Application created successfully!');
+
+      // Save project configuration
+      saveProjectConfig({
+        applicationUuid: result.coolify_app_uuid,
+        applicationName: result.app_name,
+        subdomain: result.subdomain,
+        domainSuffix: appData.domain_suffix,
+        gitRepository: appData.git_repository,
+      });
+
+      logger.newline();
+      logger.success('Application created!');
+      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.newline();
+
+      // Show next steps
+      if (result.next_steps && result.next_steps.length > 0) {
+        logger.info('Next Steps:');
+        result.next_steps.forEach((step, index) => {
+          logger.log(`  ${index + 1}. ${step}`);
+        });
+        logger.newline();
+      }
+
+      logger.info('Useful commands:');
+      logger.log(`  saac deploy              Deploy your application`);
+      logger.log(`  saac logs --follow       View deployment logs`);
+      logger.log(`  saac status              Check application status`);
+      logger.log(`  saac env set KEY=VALUE   Set environment variables`);
+
+    } catch (error) {
+      spin.fail('Application creation 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 {
+        throw error;
+      }
+      process.exit(1);
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = create;

package/src/commands/init.js

@@ -1,4 +1,160 @@
-// TODO: Implement init command
-module.exports = async function() {
-  console.log('init command - Coming soon!');
-};
+/**
+ * Init command - Initialize SAAC project in current directory
+ *
+ * Two modes:
+ * 1. Interactive: Select from existing applications (no options provided)
+ * 2. Create: Create new application and link to directory (options provided)
+ */
+
+const api = require('../lib/api');
+const { isAuthenticated, saveProjectConfig, getProjectConfig } = require('../lib/config');
+const logger = require('../lib/logger');
+const inquirer = require('inquirer');
+
+async function init(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);
+    }
+
+    logger.section('Initialize SAAC Project');
+    logger.newline();
+
+    // Check if already initialized
+    const existingConfig = getProjectConfig();
+    if (existingConfig) {
+      logger.warn('This directory is already linked to an application');
+      logger.newline();
+      logger.field('Application', existingConfig.applicationName);
+      logger.field('UUID', existingConfig.applicationUuid);
+      logger.field('Domain', `${existingConfig.subdomain}.${existingConfig.domainSuffix}`);
+      logger.newline();
+
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'overwrite',
+          message: 'Do you want to re-initialize this directory?',
+          default: false,
+        },
+      ]);
+
+      if (!overwrite) {
+        logger.info('Keeping existing configuration');
+        process.exit(0);
+      }
+
+      logger.newline();
+    }
+
+    // Determine mode: Create new app OR link existing app
+    const hasCreateOptions = options.name || options.subdomain || options.repository;
+
+    if (hasCreateOptions) {
+      // CREATE MODE: Create a new application
+      await createAndInitialize(options);
+    } else {
+      // INTERACTIVE MODE: Link existing application
+      await linkExistingApplication();
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Create a new application and initialize directory
+ */
+async function createAndInitialize(options) {
+  logger.error('Create mode not yet implemented');
+  logger.newline();
+  logger.info('To create a new application, use:');
+  logger.log('  saac create <name> -s <subdomain> -r <repository> -t <git-token>');
+  logger.newline();
+  logger.info('To link an existing application, run:');
+  logger.log('  saac init');
+  process.exit(1);
+
+  // TODO: Implement create-and-init flow
+  // This would call the create command functionality, then save the config
+}
+
+/**
+ * Link an existing application to current directory (interactive)
+ */
+async function linkExistingApplication() {
+
+  // Fetch user's applications
+  const spin = logger.spinner('Fetching your applications...').start();
+
+  try {
+    const result = await api.listApplications();
+    const applications = Array.isArray(result) ? result : (result.applications || []);
+
+    spin.succeed(`Found ${applications.length} application(s)`);
+
+    if (applications.length === 0) {
+      logger.newline();
+      logger.warn('You have no applications yet');
+      logger.newline();
+      logger.info('Create one with:');
+      logger.log('  saac create <name> -s <subdomain> -r <repository> -t <git-token>');
+      process.exit(1);
+    }
+
+    logger.newline();
+
+    // Interactive: Let user select application
+    const choices = applications.map(app => ({
+      name: `${app.name} - ${app.domain || `${app.subdomain}.startanaicompany.com`} (${app.status})`,
+      value: app,
+    }));
+
+    const { selectedApp } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedApp',
+        message: 'Select application to link to this directory:',
+        choices: choices,
+      },
+    ]);
+
+    logger.newline();
+
+    // Save project configuration
+    saveProjectConfig({
+      applicationUuid: selectedApp.uuid,
+      applicationName: selectedApp.name,
+      subdomain: selectedApp.subdomain,
+      domainSuffix: selectedApp.domain_suffix || 'startanaicompany.com',
+      gitRepository: selectedApp.git_repository,
+    });
+
+    logger.success('Project initialized!');
+    logger.newline();
+    logger.field('Application', selectedApp.name);
+    logger.field('UUID', selectedApp.uuid);
+    logger.field('Domain', selectedApp.domain || `${selectedApp.subdomain}.startanaicompany.com`);
+    logger.field('Status', selectedApp.status);
+    logger.newline();
+
+    logger.info('You can now use:');
+    logger.log('  saac deploy              Deploy your application');
+    logger.log('  saac logs --follow       View deployment logs');
+    logger.log('  saac status              Check application status');
+    logger.log('  saac update --port 8080  Update configuration');
+
+  } catch (error) {
+    spin.fail('Failed to fetch applications');
+    throw error;
+  }
+}
+
+module.exports = init;

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;