vibecodingmachine-core 1.0.0

package/src/utils/gcloud-auth.cjs

@@ -0,0 +1,394 @@
+// Google Cloud Authentication Helper
+// Handles gcloud installation, authentication, and API key generation
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class GCloudAuth {
+  constructor() {
+    this.logger = console;
+    this.configDir = path.join(os.homedir(), '.allnightai');
+    this.apiKeyFile = path.join(this.configDir, 'gcloud-api-key.json');
+  }
+
+  /**
+   * Check if gcloud CLI is installed
+   */
+  isGCloudInstalled() {
+    try {
+      execSync('which gcloud', { stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Install gcloud CLI
+   */
+  async installGCloud() {
+    this.logger.log('Installing Google Cloud CLI...');
+
+    try {
+      const platform = os.platform();
+
+      if (platform === 'darwin') {
+        // macOS - use Homebrew
+        this.logger.log('Installing via Homebrew...');
+        execSync('brew install --cask google-cloud-sdk', {
+          stdio: 'inherit',
+          timeout: 300000 // 5 minute timeout
+        });
+      } else if (platform === 'linux') {
+        // Linux - use curl installer
+        this.logger.log('Installing via curl...');
+        execSync('curl https://sdk.cloud.google.com | bash', {
+          stdio: 'inherit',
+          shell: true,
+          timeout: 300000
+        });
+        // Source the completion script
+        execSync('exec -l $SHELL', { stdio: 'inherit', shell: true });
+      } else {
+        return {
+          success: false,
+          error: 'Unsupported platform. Please install gcloud CLI manually: https://cloud.google.com/sdk/docs/install'
+        };
+      }
+
+      this.logger.log('Google Cloud CLI installed successfully');
+      return { success: true };
+    } catch (error) {
+      this.logger.error('Failed to install gcloud CLI:', error.message);
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Check if user is authenticated with gcloud
+   */
+  isAuthenticated() {
+    try {
+      const result = execSync('gcloud auth list --filter=status:ACTIVE --format="value(account)"', {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      });
+      return result.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Authenticate with Google Cloud (opens browser)
+   */
+  async authenticate() {
+    this.logger.log('Opening browser for Google Cloud authentication...');
+
+    try {
+      // This will open the browser automatically
+      execSync('gcloud auth login', {
+        stdio: 'inherit',
+        timeout: 180000 // 3 minute timeout
+      });
+
+      this.logger.log('Successfully authenticated with Google Cloud');
+      return { success: true };
+    } catch (error) {
+      this.logger.error('Failed to authenticate:', error.message);
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get or create project
+   */
+  async ensureProject() {
+    try {
+      // Get current project
+      let project = execSync('gcloud config get-value project', {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      }).trim();
+
+      if (!project || project === '(unset)') {
+        // Create a new project
+        const projectId = `allnightai-${Date.now()}`;
+        this.logger.log(`Creating new project: ${projectId}`);
+
+        execSync(`gcloud projects create ${projectId} --name="AllNightAI"`, {
+          stdio: 'inherit'
+        });
+
+        execSync(`gcloud config set project ${projectId}`, {
+          stdio: 'inherit'
+        });
+
+        project = projectId;
+      }
+
+      return { success: true, project };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Enable required APIs
+   */
+  async enableAPIs() {
+    try {
+      this.logger.log('Enabling Vertex AI API...');
+
+      execSync('gcloud services enable aiplatform.googleapis.com', {
+        stdio: 'inherit',
+        timeout: 120000
+      });
+
+      this.logger.log('APIs enabled successfully');
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Set up gcloud PATH
+   */
+  setupGCloudPath() {
+    const gcloudPaths = [
+      '/opt/homebrew/share/google-cloud-sdk/bin',
+      '/usr/local/share/google-cloud-sdk/bin',
+      path.join(os.homedir(), 'google-cloud-sdk', 'bin')
+    ];
+
+    for (const gcloudPath of gcloudPaths) {
+      if (fs.existsSync(gcloudPath)) {
+        if (!process.env.PATH.includes(gcloudPath)) {
+          process.env.PATH = `${gcloudPath}:${process.env.PATH}`;
+          this.logger.log(`Added ${gcloudPath} to PATH`);
+        }
+        return gcloudPath;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Generate API key using Application Default Credentials
+   */
+  async generateAPIKey() {
+    try {
+      this.logger.log('Generating API credentials...');
+
+      // Ensure gcloud is in PATH
+      this.setupGCloudPath();
+
+      // Get current project
+      const project = await this.getCurrentProject();
+
+      // Display prominent warning about selecting all permissions
+      console.log('\n╔══════════════════════════════════════════════════════════════════╗');
+      console.log('║                                                                  ║');
+      console.log('║                    ⚠️  IMPORTANT INSTRUCTIONS ⚠️                 ║');
+      console.log('║                                                                  ║');
+      console.log('║  Your browser will open for Google Cloud authentication.        ║');
+      console.log('║                                                                  ║');
+      console.log('║  ╔════════════════════════════════════════════════════════╗     ║');
+      console.log('║  ║  ✓  CLICK "SELECT ALL" TO SELECT ALL PERMISSIONS  ║     ║');
+      console.log('║  ╚════════════════════════════════════════════════════════╝     ║');
+      console.log('║                                                                  ║');
+      console.log('║  Then click "Continue" or "Allow" to consent.                   ║');
+      console.log('║                                                                  ║');
+      console.log('║  If you don\'t select all permissions, authentication will fail. ║');
+      console.log('║                                                                  ║');
+      console.log('╚══════════════════════════════════════════════════════════════════╝');
+      console.log('\nProject: ' + project);
+      console.log('Opening browser in 3 seconds...\n');
+
+      // Give user time to read the warning
+      await new Promise(resolve => setTimeout(resolve, 3000));
+
+      // Use Application Default Credentials with browser
+      execSync(`gcloud auth application-default login --project=${project}`, {
+        stdio: 'inherit',
+        timeout: 300000, // 5 minutes
+        env: { ...process.env, PATH: process.env.PATH }
+      });
+
+      // Get the credentials file location
+      const credsPath = path.join(
+        os.homedir(),
+        '.config',
+        'gcloud',
+        'application_default_credentials.json'
+      );
+
+      if (!fs.existsSync(credsPath)) {
+        throw new Error('Credentials file not found');
+      }
+
+      // Copy credentials to our config directory
+      fs.mkdirSync(this.configDir, { recursive: true });
+      const creds = JSON.parse(fs.readFileSync(credsPath, 'utf8'));
+
+      // Save API key info
+      const apiKeyInfo = {
+        type: 'gcloud_application_default',
+        credentials_path: credsPath,
+        project: creds.quota_project_id || project,
+        created_at: new Date().toISOString()
+      };
+
+      fs.writeFileSync(this.apiKeyFile, JSON.stringify(apiKeyInfo, null, 2));
+
+      this.logger.log('API credentials generated and saved');
+      return {
+        success: true,
+        keyFile: this.apiKeyFile,
+        credsPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get current project ID
+   */
+  async getCurrentProject() {
+    try {
+      const project = execSync('gcloud config get-value project', {
+        encoding: 'utf8',
+        stdio: 'pipe'
+      }).trim();
+      return project;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get saved API key info
+   */
+  getSavedAPIKey() {
+    try {
+      if (!fs.existsSync(this.apiKeyFile)) {
+        return null;
+      }
+      return JSON.parse(fs.readFileSync(this.apiKeyFile, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Check if Application Default Credentials already exist
+   */
+  hasApplicationDefaultCredentials() {
+    const credsPath = path.join(
+      os.homedir(),
+      '.config',
+      'gcloud',
+      'application_default_credentials.json'
+    );
+    return fs.existsSync(credsPath);
+  }
+
+  /**
+   * Full authentication flow
+   */
+  async fullAuthFlow() {
+    // 1. Check/install gcloud
+    if (!this.isGCloudInstalled()) {
+      this.logger.log('Google Cloud CLI not found. Installing...');
+      const installResult = await this.installGCloud();
+      if (!installResult.success) {
+        return installResult;
+      }
+    }
+
+    // Ensure gcloud is in PATH
+    this.setupGCloudPath();
+
+    // 2. Authenticate
+    if (!this.isAuthenticated()) {
+      this.logger.log('Not authenticated. Starting authentication...');
+      const authResult = await this.authenticate();
+      if (!authResult.success) {
+        return authResult;
+      }
+    }
+
+    // 3. Ensure project
+    const projectResult = await this.ensureProject();
+    if (!projectResult.success) {
+      return projectResult;
+    }
+
+    // 4. Enable APIs
+    const apiResult = await this.enableAPIs();
+    if (!apiResult.success) {
+      return apiResult;
+    }
+
+    // 5. Generate API key (or use existing)
+    if (this.hasApplicationDefaultCredentials()) {
+      this.logger.log('Application Default Credentials already exist');
+
+      const credsPath = path.join(
+        os.homedir(),
+        '.config',
+        'gcloud',
+        'application_default_credentials.json'
+      );
+
+      // Save API key info
+      fs.mkdirSync(this.configDir, { recursive: true });
+      const apiKeyInfo = {
+        type: 'gcloud_application_default',
+        credentials_path: credsPath,
+        project: projectResult.project,
+        created_at: new Date().toISOString()
+      };
+      fs.writeFileSync(this.apiKeyFile, JSON.stringify(apiKeyInfo, null, 2));
+
+      return {
+        success: true,
+        keyFile: this.apiKeyFile,
+        credsPath: credsPath,
+        project: projectResult.project
+      };
+    }
+
+    const keyResult = await this.generateAPIKey();
+    if (!keyResult.success) {
+      return keyResult;
+    }
+
+    return {
+      success: true,
+      keyFile: keyResult.keyFile,
+      credsPath: keyResult.credsPath,
+      project: projectResult.project
+    };
+  }
+}
+
+module.exports = { GCloudAuth };

package/src/utils/logger.cjs

@@ -0,0 +1,193 @@
+// @vibecodingmachine/core - Logger Utility (CommonJS)
+// Provides consistent logging functionality across the core package
+
+/**
+ * Logger utility for consistent logging
+ * Provides structured logging with different levels and formatting
+ */
+class Logger {
+  constructor(options = {}) {
+    this.level = options.level || 'info';
+    this.prefix = options.prefix || 'VibeCodingMachine';
+    this.enableTimestamp = options.enableTimestamp !== false;
+    this.enableColors = options.enableColors !== false;
+
+    // Log levels in order of priority
+    this.levels = {
+      error: 0,
+      warn: 1,
+      info: 2,
+      debug: 3,
+      trace: 4
+    };
+  }
+
+  /**
+   * Get current timestamp
+   * @returns {string} Formatted timestamp
+   */
+  getTimestamp() {
+    if (!this.enableTimestamp) return '';
+    return new Date().toISOString();
+  }
+
+  /**
+   * Format log message
+   * @param {string} level - Log level
+   * @param {string} message - Log message
+   * @param {Array} args - Additional arguments
+   * @returns {string} Formatted log message
+   */
+  formatMessage(level, message, args = []) {
+    const timestamp = this.getTimestamp();
+    const timestampStr = timestamp ? `[${timestamp}] ` : '';
+    const prefixStr = this.prefix ? `[${this.prefix}] ` : '';
+    const levelStr = `[${level.toUpperCase()}] `;
+
+    let formattedMessage = `${timestampStr}${prefixStr}${levelStr}${message}`;
+
+    if (args.length > 0) {
+      formattedMessage += ' ' + args.map(arg =>
+        typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+      ).join(' ');
+    }
+
+    return formattedMessage;
+  }
+
+  /**
+   * Check if level should be logged
+   * @param {string} level - Log level to check
+   * @returns {boolean} Whether to log this level
+   */
+  shouldLog(level) {
+    return this.levels[level] <= this.levels[this.level];
+  }
+
+  /**
+   * Log error message
+   * @param {string} message - Error message
+   * @param {...any} args - Additional arguments
+   */
+  error(message, ...args) {
+    if (!this.shouldLog('error')) return;
+
+    const formattedMessage = this.formatMessage('error', message, args);
+    console.error(formattedMessage);
+  }
+
+  /**
+   * Log warning message
+   * @param {string} message - Warning message
+   * @param {...any} args - Additional arguments
+   */
+  warn(message, ...args) {
+    if (!this.shouldLog('warn')) return;
+
+    const formattedMessage = this.formatMessage('warn', message, args);
+    console.warn(formattedMessage);
+  }
+
+  /**
+   * Log info message
+   * @param {string} message - Info message
+   * @param {...any} args - Additional arguments
+   */
+  info(message, ...args) {
+    if (!this.shouldLog('info')) return;
+
+    const formattedMessage = this.formatMessage('info', message, args);
+    console.info(formattedMessage);
+  }
+
+  /**
+   * Log debug message
+   * @param {string} message - Debug message
+   * @param {...any} args - Additional arguments
+   */
+  debug(message, ...args) {
+    if (!this.shouldLog('debug')) return;
+
+    const formattedMessage = this.formatMessage('debug', message, args);
+    console.debug(formattedMessage);
+  }
+
+  /**
+   * Log trace message
+   * @param {string} message - Trace message
+   * @param {...any} args - Additional arguments
+   */
+  trace(message, ...args) {
+    if (!this.shouldLog('trace')) return;
+
+    const formattedMessage = this.formatMessage('trace', message, args);
+    console.trace(formattedMessage);
+  }
+
+  /**
+   * Log message (alias for info)
+   * @param {string} message - Log message
+   * @param {...any} args - Additional arguments
+   */
+  log(message, ...args) {
+    this.info(message, ...args);
+  }
+
+  /**
+   * Set log level
+   * @param {string} level - New log level
+   */
+  setLevel(level) {
+    if (this.levels.hasOwnProperty(level)) {
+      this.level = level;
+    } else {
+      this.warn(`Invalid log level: ${level}. Using 'info' instead.`);
+      this.level = 'info';
+    }
+  }
+
+  /**
+   * Get current log level
+   * @returns {string} Current log level
+   */
+  getLevel() {
+    return this.level;
+  }
+
+  /**
+   * Create a child logger with a specific prefix
+   * @param {string} childPrefix - Prefix for the child logger
+   * @param {Object} options - Additional options
+   * @returns {Logger} Child logger instance
+   */
+  child(childPrefix, options = {}) {
+    const fullPrefix = this.prefix ? `${this.prefix}:${childPrefix}` : childPrefix;
+    return new Logger({
+      level: this.level,
+      prefix: fullPrefix,
+      enableTimestamp: this.enableTimestamp,
+      enableColors: this.enableColors,
+      ...options
+    });
+  }
+}
+
+// Create default logger instance
+const logger = new Logger({
+  level: process.env.NODE_ENV === 'development' ? 'debug' : 'info',
+  prefix: 'VibeCodingMachine',
+  enableTimestamp: true,
+  enableColors: true
+});
+
+// Export console methods for backward compatibility
+const consoleLogger = {
+  log: (...args) => logger.log(...args),
+  info: (...args) => logger.info(...args),
+  warn: (...args) => logger.warn(...args),
+  error: (...args) => logger.error(...args),
+  debug: (...args) => logger.debug(...args),
+  trace: (...args) => logger.trace(...args)
+};
+
+module.exports = { logger, Logger, consoleLogger };