@startanaicompany/cli 1.0.0 → 1.3.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@startanaicompany/cli",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "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/login.js

@@ -10,65 +10,59 @@ const logger = require('../lib/logger');
 
 async function login(options) {
   try {
-    logger.section('Login to StartAnAiCompany');
-
-    // Get email
-    let email = options.email;
-    if (!email) {
-      const answers = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'email',
-          message: 'Email address:',
-          validate: (input) => {
-            if (!validator.isEmail(input)) {
-              return 'Please enter a valid email address';
-            }
-            return true;
-          },
-        },
-      ]);
-      email = answers.email;
+    // Require both email and API key flags (no interactive prompts)
+    if (!options.email || !options.apiKey) {
+      logger.error('Email and API key are required');
+      logger.newline();
+      logger.info('Usage:');
+      logger.log('  saac login -e <email> -k <api-key>');
+      logger.log('  saac login --email <email> --api-key <api-key>');
+      logger.newline();
+      logger.info('Example:');
+      logger.log('  saac login -e user@example.com -k cw_your_api_key');
+      process.exit(1);
     }
 
-    // Get API key
-    let apiKey = options.apiKey;
-    if (!apiKey) {
-      const answers = await inquirer.prompt([
-        {
-          type: 'password',
-          name: 'apiKey',
-          message: 'API Key:',
-          mask: '*',
-        },
-      ]);
-      apiKey = answers.apiKey;
+    const email = options.email;
+    const apiKey = options.apiKey;
+
+    // Validate email format
+    if (!validator.isEmail(email)) {
+      logger.error('Invalid email address');
+      process.exit(1);
     }
 
-    // Verify credentials by getting user info
-    const spin = logger.spinner('Verifying credentials...').start();
+    logger.section('Login to StartAnAiCompany');
 
-    try {
-      // Save temporarily to make API call
-      saveUser({ email, apiKey });
+    // Login and get session token
+    const spin = logger.spinner('Logging in...').start();
 
-      const userInfo = await api.getUserInfo();
+    try {
+      // Call /auth/login endpoint to get session token
+      const result = await api.login(email, apiKey);
 
       spin.succeed('Login successful!');
 
-      // Update with full user info
+      // Save session token and expiration
       saveUser({
-        email: userInfo.email,
-        userId: userInfo.id,
-        apiKey,
-        verified: userInfo.email_verified,
+        email: result.user.email || email,
+        userId: result.user.id,
+        sessionToken: result.session_token,
+        expiresAt: result.expires_at,
+        verified: result.user.verified,
       });
 
       logger.newline();
       logger.success('You are now logged in!');
       logger.newline();
-      logger.field('Email', userInfo.email);
-      logger.field('Verified', userInfo.email_verified ? 'Yes' : 'No');
+      logger.field('Email', result.user.email || email);
+      logger.field('Verified', result.user.verified ? 'Yes' : 'No');
+
+      // Show expiration date
+      if (result.expires_at) {
+        const expirationDate = new Date(result.expires_at);
+        logger.field('Session expires', expirationDate.toLocaleDateString());
+      }
 
     } catch (error) {
       spin.fail('Login failed');

package/src/commands/logout.js

@@ -1,9 +1,47 @@
-const { clearUser } = require('../lib/config');
+const api = require('../lib/api');
+const { clearUser, getUser } = require('../lib/config');
 const logger = require('../lib/logger');
 
 async function logout() {
-  clearUser();
-  logger.success('Logged out successfully');
+  try {
+    const user = getUser();
+
+    if (!user || (!user.sessionToken && !user.apiKey)) {
+      logger.warn('You are not logged in');
+      return;
+    }
+
+    logger.section('Logout from StartAnAiCompany');
+
+    const spin = logger.spinner('Logging out...').start();
+
+    try {
+      // Try to revoke session on server
+      const client = api.createClient();
+      await client.post('/auth/logout');
+
+      // Clear local config
+      clearUser();
+
+      spin.succeed('Logout successful!');
+      logger.success('You have been logged out from this device');
+
+    } catch (error) {
+      // Even if server call fails, clear local config
+      clearUser();
+
+      if (error.response?.status === 401) {
+        // Session already invalid
+        spin.succeed('Logged out locally (session was expired)');
+      } else {
+        spin.warn('Logged out locally (server error)');
+        logger.warn('Session may still be active on server');
+      }
+    }
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
 }
 
 module.exports = logout;

package/src/commands/logoutAll.js

@@ -0,0 +1,74 @@
+/**
+ * Logout All command - Revoke all sessions
+ */
+
+const inquirer = require('inquirer');
+const api = require('../lib/api');
+const { clearUser, isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+
+async function logoutAll(options) {
+  try {
+    // Check authentication
+    if (!isAuthenticated()) {
+      logger.error('Not logged in');
+      process.exit(1);
+    }
+
+    logger.section('Logout from All Devices');
+
+    // Confirm unless --yes flag is provided
+    if (!options.yes) {
+      logger.warn('This will logout from ALL devices where you are logged in');
+      logger.newline();
+
+      const answers = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'confirm',
+          message: 'Are you sure you want to continue?',
+          default: false,
+        },
+      ]);
+
+      if (!answers.confirm) {
+        logger.info('Cancelled');
+        return;
+      }
+    }
+
+    const spin = logger.spinner('Revoking all sessions...').start();
+
+    try {
+      const client = api.createClient();
+      const response = await client.post('/auth/logout-all');
+
+      // Clear local config
+      clearUser();
+
+      const count = response.data.sessions_revoked || 0;
+      spin.succeed(`Logged out from ${count} device(s)!`);
+
+      logger.newline();
+      logger.success('All sessions have been revoked');
+      logger.info('You will need to login again on all devices');
+
+    } catch (error) {
+      // Even if server call fails, clear local config
+      clearUser();
+
+      if (error.response?.status === 401) {
+        spin.succeed('Logged out locally (session was expired)');
+      } else {
+        spin.fail('Failed to revoke sessions on server');
+        logger.warn('Logged out locally, but server sessions may still be active');
+        throw error;
+      }
+    }
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = logoutAll;

package/src/commands/register.js

@@ -10,40 +10,32 @@ const logger = require('../lib/logger');
 
 async function register(options) {
   try {
-    logger.section('Register for StartAnAiCompany');
-
-    // Get email (from flag or prompt)
-    let email = options.email;
-    if (!email) {
-      const answers = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'email',
-          message: 'Email address:',
-          validate: (input) => {
-            if (!validator.isEmail(input)) {
-              return 'Please enter a valid email address';
-            }
-            return true;
-          },
-        },
-      ]);
-      email = answers.email;
+    // Require email flag (no interactive prompt)
+    if (!options.email) {
+      logger.error('Email is required');
+      logger.newline();
+      logger.info('Usage:');
+      logger.log('  saac register -e <email>');
+      logger.log('  saac register --email <email> [--gitea-username <username>]');
+      logger.newline();
+      logger.info('Example:');
+      logger.log('  saac register -e user@example.com');
+      logger.log('  saac register -e user@example.com --gitea-username myuser');
+      process.exit(1);
     }
 
-    // Get Gitea username (optional, auto-detected from git)
-    let giteaUsername = options.giteaUsername;
-    if (!giteaUsername) {
-      const answers = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'giteaUsername',
-          message: 'Gitea username (optional, press Enter to skip):',
-        },
-      ]);
-      giteaUsername = answers.giteaUsername || undefined;
+    const email = options.email;
+
+    // Validate email format
+    if (!validator.isEmail(email)) {
+      logger.error('Invalid email address');
+      process.exit(1);
     }
 
+    const giteaUsername = options.giteaUsername || undefined;
+
+    logger.section('Register for StartAnAiCompany');
+
     // Register via API
     const spin = logger.spinner('Creating account...').start();
 
@@ -53,12 +45,22 @@ async function register(options) {
       spin.succeed('Account created successfully!');
 
       // Save user info
-      saveUser({
+      // If backend returns session_token, use it; otherwise fall back to api_key
+      const userData = {
         email: result.email || email,
         userId: result.user_id,
-        apiKey: result.api_key,
         verified: result.verified || false,
-      });
+      };
+
+      if (result.session_token) {
+        userData.sessionToken = result.session_token;
+        userData.expiresAt = result.expires_at;
+      } else {
+        // Backward compatibility: use API key if session token not provided
+        userData.apiKey = result.api_key;
+      }
+
+      saveUser(userData);
 
       logger.newline();
       logger.success('Registration complete!');
@@ -81,7 +83,17 @@ async function register(options) {
 
       logger.newline();
       logger.field('Email', email);
-      logger.field('API Key', result.api_key.substring(0, 20) + '...');
+
+      // Show session token or API key info
+      if (result.session_token) {
+        logger.field('Session Token', result.session_token.substring(0, 20) + '...');
+        if (result.expires_at) {
+          const expirationDate = new Date(result.expires_at);
+          logger.field('Expires', expirationDate.toLocaleDateString());
+        }
+      } else if (result.api_key) {
+        logger.field('API Key', result.api_key.substring(0, 20) + '...');
+      }
 
     } catch (error) {
       spin.fail('Registration failed');