grimoire-framework 1.0.0

package/packages/grimoire-install/src/os-detector.js

@@ -0,0 +1,280 @@
+/**
+ * OS Detector - Detects operating system for cross-platform support
+ *
+ * Supports:
+ * - macOS (Darwin)
+ * - Linux (native)
+ * - Windows (native + WSL detection)
+ *
+ * @module os-detector
+ */
+
+'use strict';
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * OS types enum
+ */
+const OS_TYPE = {
+  MACOS: 'macos',
+  LINUX: 'linux',
+  WINDOWS: 'windows',
+  WSL: 'wsl',
+  UNKNOWN: 'unknown',
+};
+
+/**
+ * Detects if running in WSL (Windows Subsystem for Linux)
+ * @returns {boolean} True if running in WSL
+ */
+function isWSL() {
+  // Check environment variable (most reliable)
+  if (process.env.WSL_DISTRO_NAME) {
+    return true;
+  }
+
+  // Check /proc/version for Microsoft signature
+  try {
+    const procVersion = fs.readFileSync('/proc/version', 'utf8').toLowerCase();
+    if (procVersion.includes('microsoft') || procVersion.includes('wsl')) {
+      return true;
+    }
+  } catch {
+    // /proc/version doesn't exist (not Linux/WSL)
+  }
+
+  // Check for WSL interop
+  try {
+    const interop = fs.existsSync('/proc/sys/fs/binfmt_misc/WSLInterop');
+    if (interop) {
+      return true;
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  return false;
+}
+
+/**
+ * Gets the WSL distribution name
+ * @returns {string|null} Distribution name or null
+ */
+function getWSLDistro() {
+  if (process.env.WSL_DISTRO_NAME) {
+    return process.env.WSL_DISTRO_NAME;
+  }
+
+  try {
+    const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+    const nameMatch = osRelease.match(/^NAME="?([^"\n]+)"?/m);
+    if (nameMatch) {
+      return nameMatch[1];
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  return null;
+}
+
+/**
+ * Detects the current operating system
+ * @returns {Object} OS detection result
+ */
+function detectOS() {
+  const platform = process.platform;
+  const release = os.release();
+  const arch = process.arch;
+
+  // Base result structure
+  const result = {
+    type: OS_TYPE.UNKNOWN,
+    platform,
+    release,
+    arch,
+    isWSL: false,
+    wslDistro: null,
+    homeDir: os.homedir(),
+    shell: process.env.SHELL || process.env.COMSPEC || '/bin/sh',
+    pathSeparator: path.sep,
+  };
+
+  switch (platform) {
+    case 'darwin':
+      result.type = OS_TYPE.MACOS;
+      result.packageManager = 'brew';
+      result.installInstructions = {
+        node: 'brew install node@18',
+        git: 'brew install git',
+        docker: 'brew install --cask docker',
+        gh: 'brew install gh',
+      };
+      break;
+
+    case 'linux':
+      // Check if it's WSL
+      if (isWSL()) {
+        result.type = OS_TYPE.WSL;
+        result.isWSL = true;
+        result.wslDistro = getWSLDistro();
+        result.packageManager = detectLinuxPackageManager();
+        result.installInstructions = getLinuxInstallInstructions(result.packageManager);
+        // WSL-specific note
+        result.notes = [
+          'Running in WSL (Windows Subsystem for Linux)',
+          'Docker Desktop for Windows must be configured for WSL integration',
+        ];
+      } else {
+        result.type = OS_TYPE.LINUX;
+        result.packageManager = detectLinuxPackageManager();
+        result.installInstructions = getLinuxInstallInstructions(result.packageManager);
+      }
+      break;
+
+    case 'win32':
+      result.type = OS_TYPE.WINDOWS;
+      result.packageManager = 'winget';
+      result.shell = process.env.COMSPEC || 'cmd.exe';
+      result.pathSeparator = '\\';
+      result.installInstructions = {
+        node: 'winget install OpenJS.NodeJS.LTS',
+        git: 'winget install Git.Git',
+        docker: 'winget install Docker.DockerDesktop',
+        gh: 'winget install GitHub.cli',
+      };
+      result.notes = [
+        'For best experience, consider using WSL',
+        'Install WSL: wsl --install',
+      ];
+      break;
+
+    default:
+      result.type = OS_TYPE.UNKNOWN;
+      result.installInstructions = {
+        node: 'Visit https://nodejs.org to download Node.js',
+        git: 'Visit https://git-scm.com to download Git',
+        docker: 'Visit https://docker.com to download Docker',
+        gh: 'Visit https://cli.github.com to download GitHub CLI',
+      };
+  }
+
+  return result;
+}
+
+/**
+ * Detects the Linux package manager
+ * @returns {string} Package manager name
+ */
+function detectLinuxPackageManager() {
+  // Check for common package managers
+  const managers = [
+    { name: 'apt', check: '/usr/bin/apt' },
+    { name: 'apt-get', check: '/usr/bin/apt-get' },
+    { name: 'dnf', check: '/usr/bin/dnf' },
+    { name: 'yum', check: '/usr/bin/yum' },
+    { name: 'pacman', check: '/usr/bin/pacman' },
+    { name: 'zypper', check: '/usr/bin/zypper' },
+    { name: 'apk', check: '/sbin/apk' },
+  ];
+
+  for (const manager of managers) {
+    if (fs.existsSync(manager.check)) {
+      return manager.name;
+    }
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Gets install instructions for Linux based on package manager
+ * @param {string} packageManager - The detected package manager
+ * @returns {Object} Install instructions
+ */
+function getLinuxInstallInstructions(packageManager) {
+  const instructions = {
+    apt: {
+      node: 'sudo apt update && sudo apt install -y nodejs npm',
+      git: 'sudo apt install -y git',
+      docker: 'sudo apt install -y docker.io && sudo systemctl start docker',
+      gh: 'sudo apt install -y gh',
+    },
+    'apt-get': {
+      node: 'sudo apt-get update && sudo apt-get install -y nodejs npm',
+      git: 'sudo apt-get install -y git',
+      docker: 'sudo apt-get install -y docker.io && sudo systemctl start docker',
+      gh: 'sudo apt-get install -y gh',
+    },
+    dnf: {
+      node: 'sudo dnf install -y nodejs npm',
+      git: 'sudo dnf install -y git',
+      docker: 'sudo dnf install -y docker && sudo systemctl start docker',
+      gh: 'sudo dnf install -y gh',
+    },
+    yum: {
+      node: 'sudo yum install -y nodejs npm',
+      git: 'sudo yum install -y git',
+      docker: 'sudo yum install -y docker && sudo systemctl start docker',
+      gh: 'sudo yum install -y gh',
+    },
+    pacman: {
+      node: 'sudo pacman -S nodejs npm',
+      git: 'sudo pacman -S git',
+      docker: 'sudo pacman -S docker && sudo systemctl start docker',
+      gh: 'sudo pacman -S github-cli',
+    },
+    zypper: {
+      node: 'sudo zypper install nodejs npm',
+      git: 'sudo zypper install git',
+      docker: 'sudo zypper install docker && sudo systemctl start docker',
+      gh: 'sudo zypper install gh',
+    },
+    apk: {
+      node: 'apk add nodejs npm',
+      git: 'apk add git',
+      docker: 'apk add docker',
+      gh: 'apk add github-cli',
+    },
+    unknown: {
+      node: 'Visit https://nodejs.org to download Node.js',
+      git: 'Visit https://git-scm.com to download Git',
+      docker: 'Visit https://docker.com to download Docker',
+      gh: 'Visit https://cli.github.com to download GitHub CLI',
+    },
+  };
+
+  return instructions[packageManager] || instructions.unknown;
+}
+
+/**
+ * Gets a user-friendly OS name
+ * @param {Object} osInfo - OS detection result
+ * @returns {string} User-friendly name
+ */
+function getOSDisplayName(osInfo) {
+  switch (osInfo.type) {
+    case OS_TYPE.MACOS:
+      return `macOS (${osInfo.release})`;
+    case OS_TYPE.WSL:
+      return `WSL (${osInfo.wslDistro || 'Linux'})`;
+    case OS_TYPE.LINUX:
+      return `Linux (${osInfo.release})`;
+    case OS_TYPE.WINDOWS:
+      return `Windows (${osInfo.release})`;
+    default:
+      return `Unknown (${osInfo.platform})`;
+  }
+}
+
+module.exports = {
+  OS_TYPE,
+  detectOS,
+  isWSL,
+  getWSLDistro,
+  detectLinuxPackageManager,
+  getOSDisplayName,
+};

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

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+/**
+ * grimoire-pro CLI
+ *
+ * Thin CLI wrapper for @grimoire-fullstack/pro.
+ * Provides a clean npx interface: npx grimoire-pro install
+ *
+ * Commands:
+ *   install             Install @grimoire-fullstack/pro in the current project
+ *   activate --key X    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 help
+ */
+
+const { execSync, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { recoverLicense } = require('../src/recover');
+
+const PRO_PACKAGE = '@grimoire-fullstack/pro';
+const VERSION = require('../package.json').version;
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function run(cmd, options = {}) {
+  const result = spawnSync(cmd, {
+    shell: true,
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    ...options,
+  });
+  return result.status;
+}
+
+function isProInstalled() {
+  try {
+    const pkgPath = path.join(process.cwd(), 'node_modules', '@grimoire-fullstack', 'pro', 'package.json');
+    return fs.existsSync(pkgPath);
+  } catch {
+    return false;
+  }
+}
+
+function findgrimoireCli() {
+  // Check local node_modules first
+  const localBin = path.join(process.cwd(), 'node_modules', '.bin', 'grimoire');
+  if (fs.existsSync(localBin) || fs.existsSync(localBin + '.cmd')) {
+    return 'npx grimoire';
+  }
+
+  // Check global
+  try {
+    execSync('grimoire --version', { stdio: 'pipe' });
+    return 'grimoire';
+  } catch {
+    return null;
+  }
+}
+
+function delegateTogrimoire(subcommand) {
+  const grimoire = findgrimoireCli();
+  if (!grimoire) {
+    console.error('grimoire CLI not found.');
+    console.error('Install it first: npm install grimoire');
+    process.exit(1);
+  }
+
+  const spawnArgs = ['pro', subcommand, ...args.slice(1)];
+  const result = spawnSync(grimoire, spawnArgs, { stdio: 'inherit' });
+  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 grimoire 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() {
+  console.log(`
+grimoire-pro v${VERSION} — grimoire Pro CLI
+
+Usage:
+  npx grimoire-pro <command> [options]
+
+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 grimoire-pro install
+  npx grimoire-pro setup
+  npx grimoire-pro wizard --key PRO-XXXX-XXXX-XXXX-XXXX
+  npx grimoire-pro activate --key PRO-XXXX-XXXX-XXXX-XXXX
+  npx grimoire-pro status
+  npx grimoire-pro recover
+
+Documentation: https://grimoire.ai/pro/docs
+`);
+}
+
+function installPro() {
+  console.log(`\nInstalling ${PRO_PACKAGE}...\n`);
+
+  const exitCode = run(`npm install ${PRO_PACKAGE}`);
+
+  if (exitCode !== 0) {
+    console.error(`\nFailed to install ${PRO_PACKAGE}`);
+    process.exit(1);
+  }
+
+  console.log(`\n✅ ${PRO_PACKAGE} installed successfully!\n`);
+  console.log('Next steps:');
+  console.log('  npx grimoire-pro activate --key PRO-XXXX-XXXX-XXXX-XXXX');
+  console.log('  npx grimoire-pro status');
+  console.log('');
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+if (!command || command === 'help' || command === '--help' || command === '-h') {
+  showHelp();
+  process.exit(0);
+}
+
+if (command === '--version' || command === '-v') {
+  console.log(`grimoire-pro v${VERSION}`);
+  process.exit(0);
+}
+
+switch (command) {
+  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':
+  case 'deactivate':
+  case 'status':
+  case 'features':
+  case 'validate':
+    if (!isProInstalled()) {
+      console.error(`${PRO_PACKAGE} is not installed.`);
+      console.error('Run first: npx grimoire-pro install\n');
+      process.exit(1);
+    }
+    delegateTogrimoire(command);
+    break;
+
+  default:
+    console.error(`Unknown command: ${command}\n`);
+    showHelp();
+    process.exit(1);
+}
+
+

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

@@ -0,0 +1,38 @@
+{
+  "name": "grimoire-pro",
+  "version": "0.1.0",
+  "description": "CLI for grimoire Pro — install, activate and manage your license",
+  "bin": {
+    "grimoire-pro": "bin/grimoire-pro.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "open": "^10.0.0"
+  },
+  "keywords": [
+    "grimoire",
+    "pro",
+    "license",
+    "cli",
+    "grimoire"
+  ],
+  "author": "grimoireAI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/grimoireAI/grimoire.git",
+    "directory": "packages/grimoire-pro-cli"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  }
+}
+
+

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

@@ -0,0 +1,101 @@
+#!/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.grimoire.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('\ngrimoire-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/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@grimoire/installer",
+  "version": "3.2.1",
+  "description": "grimoire Installer - Automated setup wizard for grimoire projects (greenfield & brownfield)",
+  "main": "src/index.js",
+  "bin": {
+    "grimoire-installer": "./src/index.js"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:unit": "jest tests/unit",
+    "test:integration": "jest tests/integration"
+  },
+  "keywords": [
+    "grimoire",
+    "installer",
+    "wizard",
+    "cli",
+    "setup",
+    "greenfield",
+    "brownfield"
+  ],
+  "author": "grimoire Fullstack Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.3.2"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0"
+  }
+}
+
+