@startanaicompany/cli 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startanaicompany/cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Official CLI for StartAnAiCompany.com - Deploy AI recruitment sites with ease",
   "main": "src/index.js",
   "bin": {
@@ -35,14 +35,15 @@
   },
   "dependencies": {
     "axios": "^1.6.0",
+    "boxen": "^5.1.2",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "conf": "^10.2.0",
+    "dotenv": "^16.3.1",
     "inquirer": "^8.2.5",
+    "open": "^8.4.2",
     "ora": "^5.4.1",
-    "boxen": "^5.1.2",
     "table": "^6.8.1",
-    "dotenv": "^16.3.1",
     "validator": "^13.11.0"
   },
   "devDependencies": {

package/src/commands/create.js

@@ -3,8 +3,10 @@
  */
 
 const api = require('../lib/api');
-const { isAuthenticated, saveProjectConfig } = require('../lib/config');
+const { isAuthenticated, saveProjectConfig, getUser } = require('../lib/config');
 const logger = require('../lib/logger');
+const oauth = require('../lib/oauth');
+const inquirer = require('inquirer');
 
 async function create(name, options) {
   try {
@@ -27,7 +29,7 @@ async function create(name, options) {
       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.log('  -t, --git-token <token>              Git API token (optional if OAuth connected)');
       logger.newline();
       logger.info('Optional options:');
       logger.log('  -b, --branch <branch>                Git branch (default: master)');
@@ -55,17 +57,58 @@ async function create(name, options) {
       process.exit(1);
     }
 
-    if (!options.subdomain || !options.repository || !options.gitToken) {
-      logger.error('Missing required options: subdomain, repository, and git-token are required');
+    if (!options.subdomain || !options.repository) {
+      logger.error('Missing required options: subdomain and repository 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`);
+      logger.log(`  saac create ${name} -s myapp -r git@git.startanaicompany.com:user/repo.git`);
+      logger.log(`  saac create ${name} -s myapp -r git@git... -t your_token  # With manual token`);
       process.exit(1);
     }
 
     logger.section(`Creating Application: ${name}`);
     logger.newline();
 
+    // OAuth: Check if user has connected Git account for this repository
+    const user = getUser();
+    const gitHost = oauth.extractGitHost(options.repository);
+    const connection = await oauth.getConnection(gitHost, user.sessionToken || user.apiKey);
+
+    if (connection) {
+      logger.success(`Using connected account: ${connection.gitUsername}@${connection.gitHost}`);
+      logger.newline();
+    } else if (!options.gitToken) {
+      // No OAuth connection AND no manual token provided
+      logger.warn(`Git account not connected for ${gitHost}`);
+      logger.newline();
+
+      const { shouldConnect } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'shouldConnect',
+          message: 'Would you like to connect now?',
+          default: true,
+        },
+      ]);
+
+      if (!shouldConnect) {
+        logger.newline();
+        logger.error('Cannot create application without Git authentication');
+        logger.newline();
+        logger.info('Options:');
+        logger.log('  1. Connect Git account: saac git connect');
+        logger.log('  2. Provide token: saac create ... --git-token <token>');
+        process.exit(1);
+      }
+
+      // Initiate OAuth flow
+      await oauth.connectGitAccount(gitHost, user.sessionToken || user.apiKey);
+
+      logger.newline();
+      logger.section('Continuing with application creation');
+      logger.newline();
+    }
+
     // Build application payload
     const appData = {
       name: name,
@@ -73,9 +116,13 @@ async function create(name, options) {
       domain_suffix: options.domainSuffix || 'startanaicompany.com',
       git_repository: options.repository,
       git_branch: options.branch || 'master',
-      git_api_token: options.gitToken,
     };
 
+    // Only include git_api_token if provided (OAuth will be used if available)
+    if (options.gitToken) {
+      appData.git_api_token = options.gitToken;
+    }
+
     // Optional: Port configuration
     if (options.port) {
       appData.ports_exposes = options.port;

package/src/commands/git.js

@@ -0,0 +1,254 @@
+/**
+ * Git command - Manage Git account connections (OAuth)
+ */
+
+const oauth = require('../lib/oauth');
+const { isAuthenticated, getUser } = require('../lib/config');
+const logger = require('../lib/logger');
+const { table } = require('table');
+const inquirer = require('inquirer');
+
+/**
+ * Connect Git account via OAuth
+ */
+async function connect(host) {
+  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 user = getUser();
+    let gitHost;
+
+    if (!host) {
+      // No argument - ask user which provider
+      logger.section('Connect Git Account');
+      logger.newline();
+
+      const { choice } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'choice',
+          message: 'Select Git provider:',
+          choices: [
+            { name: 'git.startanaicompany.com (Gitea)', value: 'git.startanaicompany.com' },
+            { name: 'github.com', value: 'github.com' },
+            { name: 'gitlab.com', value: 'gitlab.com' },
+            { name: 'Custom host', value: 'custom' },
+          ],
+        },
+      ]);
+
+      if (choice === 'custom') {
+        const { customHost } = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'customHost',
+            message: 'Enter Git host domain:',
+            validate: (input) => input.length > 0 || 'Host cannot be empty',
+          },
+        ]);
+        gitHost = customHost;
+      } else {
+        gitHost = choice;
+      }
+    } else if (host.includes('git@') || host.includes('http')) {
+      // Repository URL provided
+      gitHost = oauth.extractGitHost(host);
+    } else {
+      // Host domain provided
+      gitHost = host;
+    }
+
+    // Check if already connected
+    const existing = await oauth.getConnection(gitHost, user.sessionToken || user.apiKey);
+    if (existing) {
+      logger.warn(`Already connected to ${gitHost}`);
+      logger.newline();
+      logger.field('Username', existing.gitUsername);
+      logger.field('Provider', existing.providerType);
+      logger.field('Expires', new Date(existing.expiresAt).toLocaleString());
+      logger.newline();
+
+      const { reconnect } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'reconnect',
+          message: 'Do you want to reconnect?',
+          default: false,
+        },
+      ]);
+
+      if (!reconnect) {
+        logger.info('Keeping existing connection');
+        return;
+      }
+
+      // Revoke and reconnect
+      await oauth.revokeConnection(gitHost, user.sessionToken || user.apiKey);
+      logger.newline();
+    }
+
+    // Initiate OAuth flow
+    await oauth.connectGitAccount(gitHost, user.sessionToken || user.apiKey);
+
+    logger.newline();
+    logger.success('Git account connected successfully!');
+    logger.newline();
+    logger.info('You can now create applications without providing --git-token:');
+    logger.log(`  saac create my-app -s myapp -r git@${gitHost}:user/repo.git`);
+
+  } catch (error) {
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * List connected Git accounts
+ */
+async function list() {
+  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 user = getUser();
+    const spin = logger.spinner('Fetching Git connections...').start();
+
+    try {
+      const connections = await oauth.listConnections(user.sessionToken || user.apiKey);
+
+      spin.succeed(`Found ${connections.length} connection(s)`);
+
+      if (connections.length === 0) {
+        logger.newline();
+        logger.warn('No Git accounts connected');
+        logger.newline();
+        logger.info('Connect an account with:');
+        logger.log('  saac git connect');
+        logger.log('  saac git connect git.startanaicompany.com');
+        logger.log('  saac git connect git@git.startanaicompany.com:user/repo.git');
+        return;
+      }
+
+      logger.newline();
+
+      // Build table data
+      const data = [
+        ['Git Host', 'Username', 'Provider', 'Expires', 'Last Used'],
+      ];
+
+      connections.forEach((conn) => {
+        const expires = new Date(conn.expiresAt).toLocaleDateString();
+        const lastUsed = conn.lastUsedAt
+          ? new Date(conn.lastUsedAt).toLocaleDateString()
+          : 'Never';
+
+        data.push([
+          conn.gitHost,
+          conn.gitUsername,
+          conn.providerType,
+          expires,
+          lastUsed,
+        ]);
+      });
+
+      console.log(table(data, {
+        header: {
+          alignment: 'center',
+          content: `Connected Git Accounts (${connections.length} total)`,
+        },
+      }));
+
+      logger.info('Commands:');
+      logger.log('  saac git connect <host>     Connect another account');
+      logger.log('  saac git disconnect <host>  Disconnect account');
+
+    } catch (error) {
+      spin.fail('Failed to fetch connections');
+      throw error;
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Disconnect Git account
+ */
+async function disconnect(host) {
+  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);
+    }
+
+    if (!host) {
+      logger.error('Git host is required');
+      logger.newline();
+      logger.info('Usage:');
+      logger.log('  saac git disconnect <host>');
+      logger.newline();
+      logger.info('Example:');
+      logger.log('  saac git disconnect git.startanaicompany.com');
+      logger.newline();
+      logger.info('To see connected accounts:');
+      logger.log('  saac git list');
+      process.exit(1);
+    }
+
+    const user = getUser();
+    const spin = logger.spinner(`Disconnecting from ${host}...`).start();
+
+    try {
+      await oauth.revokeConnection(host, user.sessionToken || user.apiKey);
+
+      spin.succeed(`Disconnected from ${host}`);
+
+      logger.newline();
+      logger.info('To reconnect:');
+      logger.log(`  saac git connect ${host}`);
+
+    } catch (error) {
+      spin.fail('Disconnect failed');
+
+      if (error.response?.status === 404) {
+        logger.newline();
+        logger.error(`No connection found for ${host}`);
+        logger.newline();
+        logger.info('To see connected accounts:');
+        logger.log('  saac git list');
+      } else {
+        throw error;
+      }
+      process.exit(1);
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  connect,
+  list,
+  disconnect,
+};

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/list.js

@@ -1,4 +1,109 @@
-// TODO: Implement list command
-module.exports = async function() {
-  console.log('list command - Coming soon!');
-};
+/**
+ * List command - List all user applications
+ */
+
+const api = require('../lib/api');
+const { isAuthenticated } = require('../lib/config');
+const logger = require('../lib/logger');
+const { table } = require('table');
+
+async function list() {
+  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 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.info('No applications yet');
+        logger.newline();
+        logger.info('Create one with:');
+        logger.log('  saac create <name> -s <subdomain> -r <repository> -t <git-token>');
+        logger.newline();
+        logger.info('Example:');
+        logger.log('  saac create my-app -s myapp -r git@git.startanaicompany.com:user/repo.git -t abc123');
+        return;
+      }
+
+      logger.newline();
+
+      // Build table data
+      const data = [
+        ['Name', 'Domain', 'Status', 'Branch', 'Created'],
+      ];
+
+      applications.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,
+          app.git_branch || 'master',
+          created
+        ]);
+      });
+
+      console.log(table(data, {
+        header: {
+          alignment: 'center',
+          content: `Your Applications (${applications.length} total)`,
+        },
+      }));
+
+      logger.info('Commands:');
+      logger.log('  saac init                Link application to current directory');
+      logger.log('  saac status              Show detailed status');
+      logger.log('  saac create <name> ...   Create new application');
+
+    } catch (error) {
+      spin.fail('Failed to fetch applications');
+      throw error;
+    }
+
+  } catch (error) {
+    logger.error(error.response?.data?.message || error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = list;