aios-core 4.0.4 → 4.2.0

package/bin/aios-minimal.js

@@ -4,7 +4,7 @@
  * AIOS-FullStack Minimal Installation
  *
  * DEPRECATED (since v3.11.1, scheduled for removal in v5.0.0):
- * The --minimal mode was designed for expansion-packs which have been
+ * The --minimal mode was designed for squads which have been
  * replaced by the Squads system (OSR-8). This command now runs the
  * standard wizard through the main router.
  */
@@ -14,7 +14,7 @@ const path = require('path');
 
 // Show deprecation warning
 console.log('\n⚠️  DEPRECATION WARNING: aios-minimal is deprecated.');
-console.log('   The --minimal mode (expansion-packs) was replaced by Squads.');
+console.log('   The --minimal mode (squads) was replaced by Squads.');
 console.log('   Running standard installation wizard instead.\n');
 
 // Get the path to the main router (aios.js)

package/bin/aios.js

@@ -20,7 +20,7 @@ const command = args[0];
 
 // Helper: Run initialization wizard
 async function runWizard(options = {}) {
-  // Use the new v2.1 wizard from packages/installer/src/wizard/index.js
+  // Use the v4 wizard from packages/installer/src/wizard/index.js
   const wizardPath = path.join(__dirname, '..', 'packages', 'installer', 'src', 'wizard', 'index.js');
 
   if (!fs.existsSync(wizardPath)) {
@@ -43,7 +43,7 @@ async function runWizard(options = {}) {
   }
 
   try {
-    // Run the new v2.1 wizard with options
+    // Run the v4 wizard with options
     const { runWizard: executeWizard } = require(wizardPath);
     await executeWizard(options);
   } catch (error) {
@@ -633,7 +633,7 @@ Options:
 What gets removed:
   - .aios-core/     Framework core files
   - docs/stories/   Story files (if created by AIOS)
-  - squads/         Squad expansion packs
+  - squads/         Squad definitions
   - .gitignore      AIOS-added entries only
 
 What is preserved (with --keep-data):
@@ -702,7 +702,7 @@ async function runUninstall(options = {}) {
   // Items to remove
   const itemsToRemove = [
     { path: '.aios-core', description: 'Framework core' },
-    { path: 'squads', description: 'Squad expansion packs' },
+    { path: 'squads', description: 'Squad definitions' },
   ];
 
   // Optionally remove .aios

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aios-core",
-  "version": "4.0.4",
+  "version": "4.2.0",
   "description": "Synkra AIOS: AI-Orchestrated System for Full Stack Development - Core Framework",
   "bin": {
     "aios": "bin/aios.js",
@@ -39,6 +39,11 @@
     "sync:ide": "node .aios-core/infrastructure/scripts/ide-sync/index.js sync",
     "sync:ide:validate": "node .aios-core/infrastructure/scripts/ide-sync/index.js validate",
     "sync:ide:check": "node .aios-core/infrastructure/scripts/ide-sync/index.js validate --strict",
+    "sync:ide:codex": "node .aios-core/infrastructure/scripts/ide-sync/index.js sync --ide codex",
+    "sync:skills:codex": "node .aios-core/infrastructure/scripts/codex-skills-sync/index.js",
+    "sync:skills:codex:global": "node .aios-core/infrastructure/scripts/codex-skills-sync/index.js --global --global-only",
+    "validate:codex-skills": "node .aios-core/infrastructure/scripts/codex-skills-sync/validate.js --strict",
+    "validate:paths": "node .aios-core/infrastructure/scripts/validate-paths.js",
     "sync:ide:cursor": "node .aios-core/infrastructure/scripts/ide-sync/index.js sync --ide cursor",
     "sync:ide:windsurf": "node .aios-core/infrastructure/scripts/ide-sync/index.js sync --ide windsurf",
     "prepublishOnly": "npm run generate:manifest && npm run validate:manifest",

package/packages/aios-pro-cli/bin/aios-pro.js

@@ -13,12 +13,14 @@
  *   status              Show license status
  *   features            List available pro features
  *   validate            Force online license revalidation
+ *   recover             Recover lost license key via email
  *   help                Show help
  */
 
 const { execSync, spawnSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const { recoverLicense } = require('../src/recover');
 
 const PRO_PACKAGE = '@aios-fullstack/pro';
 const VERSION = require('../package.json').version;
@@ -76,6 +78,51 @@ function delegateToAios(subcommand) {
   process.exit(result.status ?? 0);
 }
 
+/**
+ * Get value of a CLI argument (e.g., --key VALUE).
+ *
+ * @param {string} flag - Flag name (e.g., '--key')
+ * @returns {string|null} Value or null
+ */
+function getArgValue(flag) {
+  const idx = args.indexOf(flag);
+  if (idx !== -1 && idx + 1 < args.length) {
+    return args[idx + 1];
+  }
+  return null;
+}
+
+/**
+ * Run the Pro Installation Wizard.
+ *
+ * @param {string} [key] - Pre-provided license key
+ */
+function runProWizard(key) {
+  // Lazy import to avoid requiring installer when not needed
+  let proSetup;
+  try {
+    proSetup = require('../../installer/src/wizard/pro-setup');
+  } catch {
+    console.error('Pro wizard module not found.');
+    console.error('Ensure aios-core installer is available.\n');
+    process.exit(1);
+  }
+
+  const options = {};
+  if (key) {
+    options.key = key;
+  }
+
+  proSetup.runProWizard(options).then((result) => {
+    if (!result.success) {
+      process.exit(1);
+    }
+  }).catch((err) => {
+    console.error(`\n  Wizard failed: ${err.message}\n`);
+    process.exit(1);
+  });
+}
+
 // ─── Commands ───────────────────────────────────────────────────────────────
 
 function showHelp() {
@@ -87,17 +134,23 @@ Usage:
 
 Commands:
   install              Install ${PRO_PACKAGE} in the current project
+  install --wizard     Install and run the setup wizard
+  setup, wizard        Run Pro setup wizard (license gate + scaffold + verify)
   activate --key KEY   Activate a license key
   deactivate           Deactivate the current license
   status               Show license status
   features             List available pro features
   validate             Force online license revalidation
+  recover              Recover lost license key via email
   help                 Show this help message
 
 Examples:
   npx aios-pro install
+  npx aios-pro setup
+  npx aios-pro wizard --key PRO-XXXX-XXXX-XXXX-XXXX
   npx aios-pro activate --key PRO-XXXX-XXXX-XXXX-XXXX
   npx aios-pro status
+  npx aios-pro recover
 
 Documentation: https://synkra.ai/pro/docs
 `);
@@ -133,9 +186,29 @@ if (command === '--version' || command === '-v') {
 }
 
 switch (command) {
-  case 'install':
-  case 'setup':
+  case 'install': {
+    // Check for --wizard flag to run wizard after install
+    const runWizardAfter = args.includes('--wizard');
     installPro();
+    if (runWizardAfter) {
+      runProWizard();
+    }
+    break;
+  }
+
+  case 'setup':
+  case 'wizard': {
+    // Run the Pro Installation Wizard with license gate
+    const wizardKey = getArgValue('--key');
+    runProWizard(wizardKey);
+    break;
+  }
+
+  case 'recover':
+    recoverLicense().catch((err) => {
+      console.error(`\n  Recovery failed: ${err.message}\n`);
+      process.exit(1);
+    });
     break;
 
   case 'activate':

package/packages/aios-pro-cli/package.json

@@ -6,8 +6,12 @@
     "aios-pro": "bin/aios-pro.js"
   },
   "files": [
-    "bin/"
+    "bin/",
+    "src/"
   ],
+  "dependencies": {
+    "open": "^10.0.0"
+  },
   "keywords": [
     "aios",
     "pro",

package/packages/aios-pro-cli/src/recover.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+/**
+ * License Recovery Flow
+ *
+ * Implements OWASP-compliant license key recovery via portal redirect.
+ * Decision 3 (D1 Section 4): Portal-first — CLI redirects to web portal.
+ *
+ * Security:
+ *   - Anti-enumeration: identical message for any email input
+ *   - No API calls — purely local CLI + browser redirect
+ *   - Rate limiting is server-side (3/email/hour) — documented, not enforced here
+ */
+
+const readline = require('readline');
+
+const RECOVERY_URL = 'https://pro.synkra.ai/recover';
+
+const RECOVERY_MESSAGE =
+  'Se este email estiver associado a uma licenca, voce recebera instrucoes de recuperacao.';
+
+/**
+ * Mask email for display: u***@example.com
+ * @param {string} email
+ * @returns {string}
+ */
+function maskEmail(email) {
+  const atIndex = email.indexOf('@');
+  if (atIndex <= 0) {
+    return '***';
+  }
+  return email[0] + '***' + email.slice(atIndex);
+}
+
+/**
+ * Prompt user for email input via readline
+ * @returns {Promise<string>}
+ */
+function promptEmail() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question('  Enter your email: ', (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Open URL in default browser with offline fallback
+ * @param {string} url
+ * @param {Function} [openFn] - Optional override for testing (defaults to dynamic import of 'open')
+ * @returns {Promise<boolean>} true if browser opened, false if fallback
+ */
+async function openBrowser(url, openFn) {
+  try {
+    const open = openFn || (await import('open')).default;
+    await open(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Main recovery flow
+ * @returns {Promise<void>}
+ */
+async function recoverLicense() {
+  console.log('\naios-pro — License Recovery\n');
+
+  const email = await promptEmail();
+
+  if (!email) {
+    console.error('\n  Error: Email is required.\n');
+    process.exit(1);
+  }
+
+  const masked = maskEmail(email);
+
+  // Anti-enumeration: identical message regardless of email validity
+  console.log(`\n  ${RECOVERY_MESSAGE}`);
+  console.log(`  Email: ${masked}\n`);
+
+  const browserOpened = await openBrowser(RECOVERY_URL);
+
+  if (browserOpened) {
+    console.log('  Recovery portal opened in your browser.');
+  } else {
+    console.log('  Could not open browser automatically.');
+  }
+
+  console.log(`  You can also visit: ${RECOVERY_URL}\n`);
+}
+
+module.exports = { recoverLicense, maskEmail, promptEmail, openBrowser, RECOVERY_URL, RECOVERY_MESSAGE };

package/packages/installer/src/__tests__/performance-benchmark.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+
+/**
+ * AIOS Installer Performance Benchmark
+ * Story INS-2: Installer Performance Optimization
+ *
+ * Measures baseline performance metrics for the installer to track optimization progress.
+ *
+ * Usage:
+ *   node performance-benchmark.js [--output <file>] [--runs <n>]
+ *
+ * Output:
+ *   JSON report with phase timings and statistics
+ */
+
+const fs = require('fs');
+const fse = require('fs-extra');
+const path = require('path');
+const crypto = require('crypto');
+const { performance } = require('perf_hooks');
+
+// Configuration
+const CONFIG = {
+  runs: 3, // Number of runs for averaging
+  outputFile: null, // Output file path (null = stdout)
+  testProjectSize: 1000, // Number of files for test project
+  verbose: false,
+};
+
+// Parse CLI arguments
+process.argv.slice(2).forEach((arg, i, arr) => {
+  if (arg === '--output' && arr[i + 1]) CONFIG.outputFile = arr[i + 1];
+  if (arg === '--runs' && arr[i + 1]) CONFIG.runs = parseInt(arr[i + 1], 10);
+  if (arg === '--verbose' || arg === '-v') CONFIG.verbose = true;
+  if (arg === '--help' || arg === '-h') {
+    console.log(`
+AIOS Installer Performance Benchmark
+
+Usage: node performance-benchmark.js [options]
+
+Options:
+  --output <file>   Save JSON report to file (default: stdout)
+  --runs <n>        Number of benchmark runs (default: 3)
+  --verbose, -v     Show detailed progress
+  --help, -h        Show this help
+
+Example:
+  node performance-benchmark.js --output baseline.json --runs 5
+`);
+    process.exit(0);
+  }
+});
+
+// Benchmark results structure
+const results = {
+  timestamp: new Date().toISOString(),
+  system: {
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version,
+    cpus: require('os').cpus().length,
+    totalMemory: Math.round(require('os').totalmem() / 1024 / 1024) + ' MB',
+  },
+  config: { ...CONFIG },
+  phases: {},
+  summary: {},
+};
+
+/**
+ * Timer utility for measuring phase durations
+ */
+class Timer {
+  constructor(name) {
+    this.name = name;
+    this.start = null;
+    this.end = null;
+    this.runs = [];
+  }
+
+  begin() {
+    this.start = performance.now();
+  }
+
+  stop() {
+    this.end = performance.now();
+    const duration = this.end - this.start;
+    this.runs.push(duration);
+    return duration;
+  }
+
+  getStats() {
+    if (this.runs.length === 0) return null;
+    const sorted = [...this.runs].sort((a, b) => a - b);
+    return {
+      min: Math.round(sorted[0]),
+      max: Math.round(sorted[sorted.length - 1]),
+      avg: Math.round(this.runs.reduce((a, b) => a + b, 0) / this.runs.length),
+      median: Math.round(sorted[Math.floor(sorted.length / 2)]),
+      runs: this.runs.map((r) => Math.round(r)),
+      unit: 'ms',
+    };
+  }
+}
+
+// Phase timers
+const timers = {
+  directoryRead: new Timer('Directory Read (readdirSync)'),
+  directoryReadWithTypes: new Timer('Directory Read (withFileTypes)'),
+  statLoop: new Timer('Stat Loop (statSync per file)'),
+  realpathSingle: new Timer('Realpath (single call)'),
+  realpathDouble: new Timer('Realpath (double call - current)'),
+  hashSequential: new Timer('Hash Files (sequential)'),
+  hashParallelBatch: new Timer('Hash Files (parallel batch)'),
+  fileCopySequential: new Timer('File Copy (sequential)'),
+  fileCopyParallel: new Timer('File Copy (parallel)'),
+  totalInstallSimulation: new Timer('Total Install Simulation'),
+};
+
+/**
+ * Log if verbose mode is enabled
+ */
+function log(msg) {
+  if (CONFIG.verbose) console.log(`[benchmark] ${msg}`);
+}
+
+/**
+ * Get the .aios-core directory for benchmarking
+ */
+function getAiosCoreDir() {
+  const projectRoot = path.resolve(__dirname, '../../../../');
+  return path.join(projectRoot, '.aios-core');
+}
+
+/**
+ * Benchmark: Directory read comparison
+ */
+async function benchmarkDirectoryRead(dir) {
+  const files = fs.readdirSync(dir);
+
+  // Method 1: readdirSync + statSync for each
+  timers.statLoop.begin();
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    fs.statSync(fullPath).isDirectory();
+  }
+  timers.statLoop.stop();
+
+  // Method 2: readdirSync with withFileTypes
+  timers.directoryReadWithTypes.begin();
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    entry.isDirectory();
+  }
+  timers.directoryReadWithTypes.stop();
+
+  return files.length;
+}
+
+/**
+ * Benchmark: Realpath comparison
+ */
+async function benchmarkRealpath(files) {
+  const sampleFiles = files.slice(0, 100); // Sample 100 files
+
+  // Method 1: Single realpath call
+  timers.realpathSingle.begin();
+  for (const file of sampleFiles) {
+    fs.realpathSync(file);
+  }
+  timers.realpathSingle.stop();
+
+  // Method 2: Double realpath call (current behavior)
+  timers.realpathDouble.begin();
+  for (const file of sampleFiles) {
+    fs.realpathSync(file);
+    fs.realpathSync(path.dirname(file)); // Simulates the duplicate call
+  }
+  timers.realpathDouble.stop();
+}
+
+/**
+ * Benchmark: File hashing comparison
+ */
+async function benchmarkHashing(files) {
+  const sampleFiles = files.slice(0, 200); // Sample 200 files for hashing
+
+  // Method 1: Sequential hashing
+  timers.hashSequential.begin();
+  for (const file of sampleFiles) {
+    try {
+      const content = fs.readFileSync(file);
+      crypto.createHash('sha256').update(content).digest('hex');
+    } catch {
+      // Skip files that can't be read
+    }
+  }
+  timers.hashSequential.stop();
+
+  // Method 2: Parallel batch hashing
+  timers.hashParallelBatch.begin();
+  const batchSize = 50;
+  for (let i = 0; i < sampleFiles.length; i += batchSize) {
+    const batch = sampleFiles.slice(i, i + batchSize);
+    await Promise.all(
+      batch.map(async (file) => {
+        try {
+          const content = await fse.readFile(file);
+          crypto.createHash('sha256').update(content).digest('hex');
+        } catch {
+          // Skip files that can't be read
+        }
+      }),
+    );
+  }
+  timers.hashParallelBatch.stop();
+}
+
+/**
+ * Collect all files recursively
+ */
+function collectFiles(dir, maxFiles = 1000) {
+  const files = [];
+
+  function walk(currentDir) {
+    if (files.length >= maxFiles) return;
+
+    try {
+      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (files.length >= maxFiles) break;
+
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else if (entry.isFile()) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+      // Skip directories we can't read
+    }
+  }
+
+  walk(dir);
+  return files;
+}
+
+/**
+ * Run all benchmarks
+ */
+async function runBenchmarks() {
+  const aiosCoreDir = getAiosCoreDir();
+
+  if (!fs.existsSync(aiosCoreDir)) {
+    console.error(`Error: .aios-core directory not found at ${aiosCoreDir}`);
+    process.exit(1);
+  }
+
+  log(`Starting benchmark with ${CONFIG.runs} runs`);
+  log(`Using .aios-core at: ${aiosCoreDir}`);
+
+  // Collect files for benchmarking
+  log('Collecting files...');
+  const allFiles = collectFiles(aiosCoreDir, CONFIG.testProjectSize);
+  log(`Collected ${allFiles.length} files`);
+
+  results.fileCount = allFiles.length;
+
+  // Run benchmarks multiple times
+  for (let run = 1; run <= CONFIG.runs; run++) {
+    log(`\n--- Run ${run}/${CONFIG.runs} ---`);
+
+    // Directory read benchmarks
+    const agentsDir = path.join(aiosCoreDir, 'development', 'agents');
+    if (fs.existsSync(agentsDir)) {
+      log('Benchmarking directory read...');
+      await benchmarkDirectoryRead(agentsDir);
+    }
+
+    // Realpath benchmarks
+    log('Benchmarking realpath...');
+    await benchmarkRealpath(allFiles);
+
+    // Hashing benchmarks
+    log('Benchmarking file hashing...');
+    await benchmarkHashing(allFiles);
+
+    // Total simulation
+    log('Running total install simulation...');
+    timers.totalInstallSimulation.begin();
+
+    // Simulate full install: read dirs + hash files
+    const devDir = path.join(aiosCoreDir, 'development');
+    if (fs.existsSync(devDir)) {
+      const subdirs = fs.readdirSync(devDir, { withFileTypes: true });
+      for (const subdir of subdirs) {
+        if (subdir.isDirectory()) {
+          const fullSubdir = path.join(devDir, subdir.name);
+          fs.readdirSync(fullSubdir);
+        }
+      }
+    }
+
+    // Simulate sequential file processing
+    for (const file of allFiles.slice(0, 500)) {
+      try {
+        fs.statSync(file);
+        fs.readFileSync(file);
+      } catch {
+        // Skip
+      }
+    }
+
+    timers.totalInstallSimulation.stop();
+  }
+
+  // Compile results
+  log('\nCompiling results...');
+
+  for (const [name, timer] of Object.entries(timers)) {
+    const stats = timer.getStats();
+    if (stats) {
+      results.phases[name] = {
+        description: timer.name,
+        ...stats,
+      };
+    }
+  }
+
+  // Calculate summary
+  const hashSeq = results.phases.hashSequential?.avg || 0;
+  const hashPar = results.phases.hashParallelBatch?.avg || 0;
+  const realpathSingle = results.phases.realpathSingle?.avg || 0;
+  const realpathDouble = results.phases.realpathDouble?.avg || 0;
+  const statLoop = results.phases.statLoop?.avg || 0;
+  const withTypes = results.phases.directoryReadWithTypes?.avg || 0;
+
+  results.summary = {
+    totalFiles: results.fileCount,
+    hashingSpeedup: hashSeq > 0 ? `${(hashSeq / hashPar).toFixed(2)}x` : 'N/A',
+    realpathSavings: realpathDouble > 0 ? `${Math.round(((realpathDouble - realpathSingle) / realpathDouble) * 100)}%` : 'N/A',
+    statLoopSavings: statLoop > 0 ? `${Math.round(((statLoop - withTypes) / statLoop) * 100)}%` : 'N/A',
+    estimatedTotalTime: results.phases.totalInstallSimulation?.avg || 0,
+    target: '<30000ms for 1000 files',
+    baseline: `${results.phases.totalInstallSimulation?.avg || 'TBD'}ms`,
+  };
+
+  // Output results
+  const output = JSON.stringify(results, null, 2);
+
+  if (CONFIG.outputFile) {
+    fs.writeFileSync(CONFIG.outputFile, output);
+    console.log(`Benchmark results saved to: ${CONFIG.outputFile}`);
+  } else {
+    console.log(output);
+  }
+
+  // Print summary to stderr for visibility
+  console.error('\n' + '='.repeat(60));
+  console.error('AIOS Installer Performance Baseline');
+  console.error('='.repeat(60));
+  console.error(`Files analyzed: ${results.fileCount}`);
+  console.error(`Runs: ${CONFIG.runs}`);
+  console.error('');
+  console.error('Phase Results (avg ms):');
+  console.error(`  Directory stat loop:     ${statLoop}ms`);
+  console.error(`  Directory withFileTypes: ${withTypes}ms (${results.summary.statLoopSavings} faster)`);
+  console.error(`  Realpath single:         ${realpathSingle}ms`);
+  console.error(`  Realpath double:         ${realpathDouble}ms (${results.summary.realpathSavings} overhead)`);
+  console.error(`  Hash sequential:         ${hashSeq}ms`);
+  console.error(`  Hash parallel:           ${hashPar}ms (${results.summary.hashingSpeedup} faster)`);
+  console.error('');
+  console.error(`Total Install Simulation:  ${results.summary.baseline}`);
+  console.error(`Target:                    ${results.summary.target}`);
+  console.error('='.repeat(60));
+}
+
+// Run benchmarks
+runBenchmarks().catch((err) => {
+  console.error('Benchmark failed:', err);
+  process.exit(1);
+});