@startanaicompany/cli 1.3.1 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startanaicompany/cli",
-  "version": "1.3.1",
+  "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/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;

package/src/lib/oauth.js

@@ -0,0 +1,205 @@
+/**
+ * OAuth Helper Module
+ * Handles Git OAuth authentication flow for SAAC CLI
+ */
+
+const axios = require('axios');
+const open = require('open');
+const crypto = require('crypto');
+const logger = require('./logger');
+const { getApiUrl } = require('./config');
+
+/**
+ * Extract git_host from repository URL
+ * @param {string} gitUrl - Git repository URL (SSH or HTTPS)
+ * @returns {string} - Git host domain
+ */
+function extractGitHost(gitUrl) {
+  // SSH format: git@git.startanaicompany.com:user/repo.git
+  const sshMatch = gitUrl.match(/git@([^:]+):/);
+  if (sshMatch) {
+    return sshMatch[1];
+  }
+
+  // HTTPS format: https://git.startanaicompany.com/user/repo.git
+  const httpsMatch = gitUrl.match(/https?:\/\/([^/]+)/);
+  if (httpsMatch) {
+    return httpsMatch[1];
+  }
+
+  throw new Error('Invalid Git repository URL format. Expected SSH (git@host:user/repo.git) or HTTPS (https://host/user/repo.git)');
+}
+
+/**
+ * Initiate OAuth flow for a git_host
+ * @param {string} gitHost - Git host domain
+ * @param {string} apiKey - User's API key
+ * @returns {Promise<object>} - { gitUsername, gitHost }
+ */
+async function connectGitAccount(gitHost, apiKey) {
+  const sessionId = crypto.randomBytes(16).toString('hex');
+
+  logger.newline();
+  logger.section(`Connecting to ${gitHost}`);
+  logger.newline();
+  logger.field('Session ID', sessionId);
+  logger.newline();
+
+  // Build authorization URL
+  const baseUrl = getApiUrl().replace('/api/v1', ''); // Remove /api/v1 suffix
+  const authUrl = `${baseUrl}/oauth/authorize?git_host=${encodeURIComponent(gitHost)}&session_id=${sessionId}`;
+
+  logger.info('Opening browser for authentication...');
+  logger.newline();
+  logger.warn('If browser doesn\'t open, visit:');
+  logger.log(`  ${authUrl}`);
+  logger.newline();
+
+  // Open browser
+  try {
+    await open(authUrl);
+  } catch (error) {
+    logger.warn('Could not open browser automatically');
+    logger.info('Please open the URL above manually');
+  }
+
+  const spin = logger.spinner('Waiting for authorization...').start();
+
+  try {
+    // Poll for completion
+    const result = await pollForCompletion(sessionId, apiKey);
+
+    spin.succeed(`Connected to ${gitHost} as ${result.gitUsername}`);
+
+    return result;
+  } catch (error) {
+    spin.fail('Authorization failed');
+    throw error;
+  }
+}
+
+/**
+ * Poll OAuth session until completed
+ * @param {string} sessionId - Session ID
+ * @param {string} apiKey - User's API key
+ * @returns {Promise<object>} - { gitUsername, gitHost }
+ */
+async function pollForCompletion(sessionId, apiKey) {
+  const pollInterval = 2000; // 2 seconds
+  const maxAttempts = 150; // 5 minutes total (150 * 2s)
+
+  const baseUrl = getApiUrl().replace('/api/v1', ''); // Remove /api/v1 suffix
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    await sleep(pollInterval);
+
+    try {
+      const response = await axios.get(
+        `${baseUrl}/oauth/poll/${sessionId}`,
+        {
+          headers: {
+            'X-API-Key': apiKey,
+          },
+        }
+      );
+
+      const { status, gitUsername, gitHost } = response.data;
+
+      if (status === 'completed') {
+        return { gitUsername, gitHost };
+      }
+
+      if (status === 'failed') {
+        throw new Error('OAuth authorization failed');
+      }
+
+      // Still pending, continue polling
+      // Silent polling - spinner shows progress
+    } catch (error) {
+      if (error.response?.status === 404) {
+        throw new Error('OAuth session not found or expired');
+      }
+      throw error;
+    }
+  }
+
+  throw new Error('OAuth authorization timed out (5 minutes). Please try again.');
+}
+
+/**
+ * Check if user has OAuth connection for git_host
+ * @param {string} gitHost - Git host domain
+ * @param {string} apiKey - User's API key
+ * @returns {Promise<object|null>} - Connection object or null
+ */
+async function getConnection(gitHost, apiKey) {
+  try {
+    const response = await axios.get(
+      `${getApiUrl()}/users/me/oauth`,
+      {
+        headers: {
+          'X-API-Key': apiKey,
+        },
+      }
+    );
+
+    const connection = response.data.connections.find(
+      (conn) => conn.gitHost === gitHost
+    );
+
+    return connection || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * List all OAuth connections
+ * @param {string} apiKey - User's API key
+ * @returns {Promise<array>} - Array of connection objects
+ */
+async function listConnections(apiKey) {
+  const response = await axios.get(
+    `${getApiUrl()}/users/me/oauth`,
+    {
+      headers: {
+        'X-API-Key': apiKey,
+      },
+    }
+  );
+
+  return response.data.connections || [];
+}
+
+/**
+ * Revoke OAuth connection for git_host
+ * @param {string} gitHost - Git host domain
+ * @param {string} apiKey - User's API key
+ */
+async function revokeConnection(gitHost, apiKey) {
+  await axios.delete(
+    `${getApiUrl()}/users/me/oauth/${encodeURIComponent(gitHost)}`,
+    {
+      headers: {
+        'X-API-Key': apiKey,
+      },
+    }
+  );
+}
+
+/**
+ * Sleep utility
+ * @param {number} ms - Milliseconds to sleep
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  extractGitHost,
+  connectGitAccount,
+  getConnection,
+  listConnections,
+  revokeConnection,
+};