maiass 5.7.31

package/lib/token-validator.js

@@ -0,0 +1,184 @@
+// API Token validation utility for debug mode
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import dotenv from 'dotenv';
+import colors from './colors.js';
+import { getConfigPaths } from './config.js';
+import { SYMBOLS } from './symbols.js';
+
+/**
+ * List of API tokens to validate
+ */
+const API_TOKENS = [
+  {
+    name: 'MAIASS_AI_TOKEN',
+    description: 'MAIASS AI API Token',
+    minLength: 10,
+    pattern: /^[a-zA-Z0-9_-]+$/
+  },
+  {
+    name: 'MAIASS_API_KEY',
+    description: 'MAIASS   API Key',
+    minLength: 20,
+    pattern: /^sk-[a-zA-Z0-9]+$/
+  }
+];
+
+/**
+ * Validate if a token value appears to be valid
+ * @param {string} token - The token value
+ * @param {Object} tokenConfig - Token configuration
+ * @returns {Object} Validation result
+ */
+function validateTokenValue(token, tokenConfig) {
+  if (!token || token.trim() === '') {
+    return { valid: false, reason: 'empty' };
+  }
+
+  const trimmedToken = token.trim();
+  
+  if (trimmedToken.length < tokenConfig.minLength) {
+    return { valid: false, reason: 'too_short' };
+  }
+
+  if (tokenConfig.pattern && !tokenConfig.pattern.test(trimmedToken)) {
+    return { valid: false, reason: 'invalid_format' };
+  }
+
+  return { valid: true, reason: 'valid' };
+}
+
+/**
+ * Load environment variables from a specific file without affecting global env
+ * @param {string} filePath - Path to the environment file
+ * @returns {Object} Environment variables from the file
+ */
+function loadEnvFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    const result = dotenv.config({ path: filePath, processEnv: {} });
+    return result.parsed || {};
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Get the status symbol and color for validation result
+ * @param {Object} validation - Validation result
+ * @returns {Object} Symbol and color info
+ */
+function getValidationDisplay(validation) {
+  if (!validation) {
+    return { symbol: colors.Gray(SYMBOLS.MINUS), status: 'not found', color: colors.Gray };
+  }
+
+  switch (validation.reason) {
+    case 'valid':
+      return { symbol: colors.Green(SYMBOLS.CHECK), status: 'valid', color: colors.Green };
+    case 'empty':
+      return { symbol: colors.Yellow(SYMBOLS.WARNING), status: 'empty', color: colors.Yellow };
+    case 'too_short':
+      return { symbol: colors.Red(SYMBOLS.CROSS), status: 'too short', color: colors.Red };
+    case 'invalid_format':
+      return { symbol: colors.Red(SYMBOLS.CROSS), status: 'invalid format', color: colors.Red };
+    default:
+      return { symbol: colors.Red(SYMBOLS.CROSS), status: 'invalid', color: colors.Red };
+  }
+}
+
+/**
+ * Display API token validation results for debug mode
+ * Only displays when MAIASS_DEBUG is enabled
+ */
+export function displayTokenValidation() {
+  // Only run in debug mode
+  if (process.env.MAIASS_DEBUG !== 'true') {
+    return;
+  }
+
+  console.log(colors.Blue('\n[DEBUG] API Token Validation:'));
+  
+  const paths = getConfigPaths();
+  
+  // Define environment files in priority order (same as config.js)
+  const envFiles = [
+    {
+      path: path.join(paths.data, 'secure.env'),
+      name: 'secure.env (OS secure)',
+      priority: 1
+    },
+    {
+      path: path.join(paths.config, 'config.env'),
+      name: 'config.env (OS config)',
+      priority: 2
+    },
+    {
+      path: path.join(paths.home, '.maiass.env'),
+      name: '.maiass.env (user home)',
+      priority: 3
+    },
+    {
+      path: path.resolve(process.cwd(), '.env.maiass'),
+      name: '.env.maiass (project)',
+      priority: 4
+    }
+  ];
+
+  // Check each environment file
+  envFiles.forEach(envFile => {
+    console.log(colors.Blue(`\n[DEBUG] Checking ${envFile.name}:`));
+    console.log(colors.Gray(`[DEBUG]   Path: ${envFile.path}`));
+    
+    const envVars = loadEnvFile(envFile.path);
+    
+    if (!envVars) {
+      console.log(colors.Gray(`[DEBUG]   ${SYMBOLS.MINUS} File not found or unreadable`));
+      return;
+    }
+
+    console.log(colors.Green(`[DEBUG]   ${SYMBOLS.CHECK} File loaded successfully`));
+    
+    // Check each API token
+    API_TOKENS.forEach(tokenConfig => {
+      const tokenValue = envVars[tokenConfig.name];
+      const validation = tokenValue ? validateTokenValue(tokenValue, tokenConfig) : null;
+      const display = getValidationDisplay(validation);
+      
+      console.log(`[DEBUG]     ${display.symbol} ${tokenConfig.description} (${tokenConfig.name}): ${display.color(display.status)}`);
+      
+      if (validation && validation.valid) {
+        // Show partial token for confirmation (first 8 chars + ...)
+        const maskedToken = tokenValue.substring(0, 8) + '...';
+        console.log(colors.Gray(`[DEBUG]       Preview: ${maskedToken}`));
+      }
+    });
+  });
+
+  // Show final token resolution (what's actually in process.env after all files loaded)
+  console.log(colors.Blue('\n[DEBUG] Final Token Resolution (after all files loaded):'));
+  API_TOKENS.forEach(tokenConfig => {
+    const tokenValue = process.env[tokenConfig.name];
+    const validation = tokenValue ? validateTokenValue(tokenValue, tokenConfig) : null;
+    const display = getValidationDisplay(validation);
+    
+    console.log(`[DEBUG]   ${display.symbol} ${tokenConfig.description} (${tokenConfig.name}): ${display.color(display.status)}`);
+    
+    if (validation && validation.valid) {
+      const maskedToken = tokenValue.substring(0, 8) + '...';
+      console.log(colors.Gray(`[DEBUG]     Active: ${maskedToken}`));
+    }
+  });
+  
+  console.log(colors.Blue('[DEBUG] Token validation complete.\n'));
+}
+
+export default {
+  displayTokenValidation,
+  validateTokenValue,
+  API_TOKENS
+};

package/lib/version-command.js

@@ -0,0 +1,256 @@
+import { log, logger } from './logger.js';
+import colors from './colors.js';
+import { SYMBOLS } from './symbols.js';
+import {
+  getCurrentVersion,
+  detectVersionFiles,
+  bumpVersion,
+  updateVersionFiles,
+  createVersionTag,
+  validateVersion,
+  parseVersion
+} from './version-manager.js';
+import { getSingleCharInput, getMultiLineInput } from './input-utils.js';
+
+/**
+ * Display current version information
+ * @param {Object} versionInfo - Version information from getCurrentVersion
+ */
+function displayVersionInfo(versionInfo) {
+  logger.header(SYMBOLS.INFO, 'Version Information');
+  
+  if (versionInfo.current) {
+    console.log(`  ${colors.BWhite('Current Version:')} ${colors.BGreen(versionInfo.current)}`);
+    console.log(`  ${colors.BWhite('Source:')} ${colors.White(versionInfo.source)}`);
+  } else {
+    console.log(`  ${colors.BYellow('No version detected')}`);
+  }
+  
+  if (versionInfo.tagVersion && versionInfo.tagVersion !== versionInfo.current) {
+    console.log(`  ${colors.BWhite('Latest Git Tag:')} ${colors.White(versionInfo.tagVersion)}`);
+  }
+  
+  console.log();
+  
+  if (versionInfo.files.length > 0) {
+    log.info(SYMBOLS.INFO, 'Version Files Found:');
+    console.log();
+    
+    versionInfo.files.forEach((file, index) => {
+      const icon = file.filename === 'package.json' ? '📦' : 
+                   file.type === 'php' ? '🐘' : 
+                   file.type === 'text' ? '📄' : '📋';
+      
+      console.log(`  ${index + 1}. ${icon} ${colors.BWhite(file.filename)}`);
+      console.log(`     ${colors.Gray('Version:')} ${colors.White(file.currentVersion)}`);
+      console.log(`     ${colors.Gray('Type:')} ${colors.White(file.type)}`);
+      console.log(`     ${colors.Gray('Path:')} ${colors.Gray(file.path)}`);
+      console.log();
+    });
+  } else {
+    log.warning(SYMBOLS.WARNING, 'No version files detected');
+    console.log();
+    console.log(colors.Gray('  Supported files: package.json, composer.json, VERSION, version.txt'));
+    console.log(colors.Gray('  WordPress: style.css, plugin.php, functions.php'));
+    console.log();
+  }
+}
+
+/**
+ * Display version bump preview
+ * @param {string} currentVersion - Current version
+ * @param {string} newVersion - New version
+ * @param {string} bumpType - Type of bump
+ * @param {Array} files - Files that will be updated
+ */
+function displayBumpPreview(currentVersion, newVersion, bumpType, files) {
+  log.info(SYMBOLS.INFO, 'Version Bump Preview:');
+  console.log();
+  
+  console.log(`  ${colors.BWhite('Current:')} ${colors.White(currentVersion)}`);
+  console.log(`  ${colors.BWhite('New:')} ${colors.BGreen(newVersion)}`);
+  console.log(`  ${colors.BWhite('Bump Type:')} ${colors.White(bumpType)}`);
+  console.log();
+  
+  if (files.length > 0) {
+    log.info(SYMBOLS.INFO, 'Files to Update:');
+    console.log();
+    
+    files.forEach((file, index) => {
+      const icon = file.filename === 'package.json' ? '📦' : 
+                   file.type === 'php' ? '🐘' : 
+                   file.type === 'text' ? '📄' : '📋';
+      
+      console.log(`  ${index + 1}. ${icon} ${colors.BWhite(file.filename)} ${colors.Gray(`(${file.currentVersion} → ${newVersion})`)}`);
+    });
+    console.log();
+  }
+}
+
+/**
+ * Handle version bump operation
+ * @param {string} bumpType - Type of bump (major, minor, patch, or specific version)
+ * @param {Object} options - Command options
+ */
+async function handleVersionBump(bumpType, options) {
+  const { dryRun, tag, tagMessage, force } = options;
+  
+  log.info(SYMBOLS.INFO, `${dryRun ? 'DRY RUN: ' : ''}Version Bump Operation`);
+  console.log();
+  
+  // Get current version information
+  const versionInfo = await getCurrentVersion();
+  
+  if (!versionInfo.current && !force) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} No current version detected`));
+    console.log();
+    log.warning(SYMBOLS.INFO, 'Use --force to create initial version');
+    return;
+  }
+  
+  // Determine new version
+  let newVersion;
+  if (versionInfo.current) {
+    newVersion = bumpVersion(versionInfo.current, bumpType);
+  } else {
+    // No current version, check if bumpType is a specific version
+    const validation = validateVersion(bumpType);
+    if (validation.valid) {
+      newVersion = bumpType;
+    } else {
+      newVersion = '1.0.0'; // Default initial version
+    }
+  }
+  
+  if (!newVersion) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} Invalid bump type: ${bumpType}`));
+    console.log();
+    log.warning(SYMBOLS.INFO, 'Valid types: major, minor, patch, or specific version (e.g., 2.1.0)');
+    return;
+  }
+  
+  // Validate new version
+  const validation = validateVersion(newVersion);
+  if (!validation.valid) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} Invalid version format: ${newVersion}`));
+    console.log(colors.Red(`  ${validation.error}`));
+    return;
+  }
+  
+  // Display preview
+  displayBumpPreview(versionInfo.current || '(none)', newVersion, bumpType, versionInfo.files);
+  
+  // Confirm operation unless dry run or force
+  if (!dryRun && !force) {
+    const confirm = await getSingleCharInput(colors.BCyan('Proceed with version bump? [Y/n] '));
+    if (confirm === 'n') {
+      log.warning(SYMBOLS.INFO, 'Version bump cancelled');
+      return;
+    }
+  }
+  
+  // Update version files
+  if (versionInfo.files.length > 0) {
+    log.blue(SYMBOLS.INFO, `${dryRun ? 'Would update' : 'Updating'} version files...`);
+    
+    const updateResult = await updateVersionFiles(newVersion, versionInfo.files, dryRun);
+    
+    if (updateResult.success) {
+      updateResult.updated.forEach(update => {
+        log.success(SYMBOLS.CHECKMARK, `${update.file} ${colors.Gray(`(${update.oldVersion} → ${update.newVersion})`)}`);
+      });
+      
+      if (updateResult.failed.length > 0) {
+        console.log();
+        log.warning(SYMBOLS.WARNING, 'Some files failed to update:');
+        updateResult.failed.forEach(failure => {
+          console.log(colors.Red(`${SYMBOLS.CROSS} ${failure.file}: ${failure.error}`));
+        });
+      }
+    } else {
+      console.error(colors.Red(`${SYMBOLS.CROSS} Failed to update version files`));
+      return;
+    }
+  } else {
+    log.warning(SYMBOLS.WARNING, 'No version files to update');
+  }
+  
+  // Create git tag if requested
+  if (tag && !dryRun) {
+    console.log();
+    log.blue(SYMBOLS.INFO, 'Creating git tag...');
+    
+    const tagResult = await createVersionTag(newVersion, tagMessage);
+    
+    if (tagResult.success) {
+      log.success(SYMBOLS.CHECKMARK, `Created tag: ${newVersion}`);
+      if (tagResult.message) {
+        console.log(colors.Gray(`  Message: ${tagResult.message}`));
+      }
+    } else {
+      console.error(colors.Red(`${SYMBOLS.CROSS} Failed to create tag: ${tagResult.error}`));
+    }
+  } else if (tag && dryRun) {
+    console.log();
+    log.blue(SYMBOLS.INFO, `Would create git tag: ${newVersion}`);
+    if (tagMessage) {
+      console.log(colors.Gray(`  Message: ${tagMessage}`));
+    }
+  }
+  
+  console.log();
+  if (dryRun) {
+    log.success(SYMBOLS.CHECKMARK, 'Dry run completed successfully');
+    log.blue(SYMBOLS.INFO, 'Run without --dry-run to apply changes');
+  } else {
+    log.success(SYMBOLS.CHECKMARK, `Version bump completed: ${versionInfo.current || '(none)'} → ${newVersion}`);
+  }
+}
+
+/**
+ * Handle version command
+ * @param {Object} args - Command arguments from yargs
+ */
+export async function handleVersionCommand(args) {
+  const {
+    _: positionalArgs,
+    'dry-run': dryRun,
+    tag,
+    'tag-message': tagMessage,
+    force,
+    current
+  } = args;
+  
+  try {
+    // If --current flag is used, just show current version info
+    if (current) {
+      const versionInfo = await getCurrentVersion();
+      displayVersionInfo(versionInfo);
+      return;
+    }
+    
+    // If no positional arguments, show current version info
+    if (positionalArgs.length === 0) {
+      const versionInfo = await getCurrentVersion();
+      displayVersionInfo(versionInfo);
+      return;
+    }
+    
+    // Get bump type from first positional argument
+    const bumpType = positionalArgs[0];
+    
+    // Handle version bump
+    await handleVersionBump(bumpType, {
+      dryRun,
+      tag,
+      tagMessage,
+      force
+    });
+    
+  } catch (error) {
+    console.error(colors.Red(`${SYMBOLS.CROSS} Version command failed: ${error.message}`));
+    if (process.env.MAIASS_DEBUG === 'true') {
+      console.error(colors.Gray(error.stack));
+    }
+  }
+}