@codemoreira/esad 2.0.0-rc.1 → 2.0.1-0

package/bin/esad.js

@@ -1,89 +1,82 @@
 #!/usr/bin/env node
-
-const { program } = require('commander');
-const pkg = require('../package.json');
-
-// Import Commands
-const initCommand = require('../src/cli/commands/init');
-const createModuleCommand = require('../src/cli/commands/createModule');
-const createCdnCommand = require('../src/cli/commands/createCdn');
-const deployCommand = require('../src/cli/commands/deploy');
-const devCommand = require('../src/cli/commands/dev');
-const hostCommand = require('../src/cli/commands/host');
-const buildCommand = require('../src/cli/commands/build');
-
-program
-  .version(pkg.version)
-  .description('esad - Easy Super App Development Toolkit');
-
-// --- COMMMAND: esad init ---
-program
-  .command('init <project-name>')
-  .description('Scaffold a new ESAD workspace containing the Host App')
-  .action(async (name) => {
-     await initCommand(name);
-     process.exit(0);
-  });
-
-// --- COMMAND: esad create-cdn ---
-program
-  .command('create-cdn [cdn-name]')
-  .description('Scaffold the CDN / Registry backend')
-  .action(async (name) => {
-     await createCdnCommand(name);
-     process.exit(0);
-  });
-
-// --- COMMAND: esad host ---
-program
-  .command('host <subcommand>')
-  .description('Manage the Host App (dev, android, ios)')
-  .action(async (sub) => {
-     await hostCommand(sub);
-     process.exit(0);
-  });
-
-// --- COMMAND: esad create-module ---
-program
-  .command('create-module <module-name>')
-  .description('Scaffold a React Native mini-app automatically configured for Module Federation via ESAD')
-  .action(async (name) => {
-     await createModuleCommand(name);
-     process.exit(0);
-  });
-
-// --- COMMAND: esad build ---
-program
-  .command('build')
-  .option('-i, --id <moduleId>', 'The Module ID to build')
-  .option('-p, --platform <platform>', 'Platform to build for (android, ios)', 'android')
-  .description('Builds a production bundle for the host or a specific module')
-  .action(async (options) => {
-     await buildCommand(options);
-     process.exit(0);
-  });
-
-// --- COMMAND: esad deploy ---
-program
-  .command('deploy')
-  .option('-v, --version <semver>', 'Version number (e.g., 1.0.0)')
-  .option('-i, --id <moduleId>', 'The Module ID to deploy')
-  .option('-e, --entry <entryFileName>', 'The name of the main entry bundle (e.g., index.bundle)', 'index.bundle')
-  .description('Zips the local dist directory and uploads it to the configured deployment endpoint')
-  .action(async (options) => {
-     await deployCommand(options);
-     process.exit(0);
-  });
-
-// --- COMMAND: esad dev ---
-program
-  .command('dev')
-  .option('-i, --id <moduleId>', 'The Module ID to run in dev mode')
-  .option('-p, --port <port>', 'The port to run the dev server on', '8081')
-  .description('Starts the dev server and updates the external registry to bypass CDN')
-  .action(async (options) => {
-     await devCommand(options);
-     // Note: dev command has its own shutdown logic with SIGINT/SIGTERM
-  });
-
-program.parse(process.argv);
+
+const { program } = require('commander');
+const pkg = require('../package.json');
+
+program
+  .version(pkg.version)
+  .description('esad - Easy Super App Development Toolkit (V2)');
+
+// --- COMMAND: esad create [name] --type [host|module|cdn] ---
+program
+  .command('create [name]')
+  .option('-t, --type <type>', 'Type of project: host, module, cdn', 'module')
+  .description('Unified scaffolding for host apps, modules, and cdn registries')
+  .action(async (name, options) => {
+    await require('../src/cli/commands/create')(name, options);
+    process.exit(0);
+  });
+
+// --- COMMAND: esad dev [moduleId] ---
+program
+  .command('dev [id]') // [id] as alias to -i for better UX
+  .option('-i, --id <moduleId>', 'The Module ID to run in dev mode')
+  .option('-p, --port <port>', 'The port to run the dev server on', '8081')
+  .description('Starts the dev server and updates the local mapping')
+  .action(async (id, options) => {
+    const opts = { ...options, id: id || options.id };
+    await require('../src/cli/commands/dev')(opts);
+  });
+
+// --- COMMAND: esad build [id] ---
+program
+  .command('build [id]')
+  .option('-i, --id <moduleId>', 'The Module ID to build')
+  .option('-p, --platform <platform>', 'Platform: android, ios', 'android')
+  .description('Builds a production bundle')
+  .action(async (id, options) => {
+    const opts = { ...options, id: id || options.id };
+    await require('../src/cli/commands/build')(opts);
+    process.exit(0);
+  });
+
+// --- COMMAND: esad deploy [id] ---
+program
+  .command('deploy [id]')
+  .option('-i, --id <moduleId>', 'The Module ID to deploy')
+  .option('-v, --version <version>', 'Specific version to deploy')
+  .description('Executes the programmable deploy hook')
+  .action(async (id, options) => {
+    const opts = { ...options, id: id || options.id };
+    await require('../src/cli/commands/deploy')(opts);
+    process.exit(0);
+  });
+
+// --- COMMAND: esad host <sub> ---
+program
+  .command('host <subcommand>')
+  .description('Manage host application (android, ios, login)')
+  .action(async (sub) => {
+    await require('../src/cli/commands/host')(sub);
+    process.exit(0);
+  });
+
+// --- COMMAND: esad doctor ---
+program
+  .command('doctor')
+  .description('Check environment for common issues')
+  .action(async () => {
+    await require('../src/cli/commands/doctor')();
+    process.exit(0);
+  });
+
+// --- COMMAND: esad link [id] ---
+program
+  .command('link [id]')
+  .description('Optimize development via local filesystem linking')
+  .action(async (id) => {
+    await require('../src/cli/commands/link')(id);
+    process.exit(0);
+  });
+
+program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemoreira/esad",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.1-0",
   "description": "Easy Super App Development - Zero-Config CLI and DevTools for React Native Module Federation",
   "main": "src/plugin/index.js",
   "types": "./src/plugin/index.d.ts",
@@ -58,4 +58,4 @@
     "@types/react": "^19.2.14",
     "@types/react-native": "^0.72.8"
   }
-}
+}

package/src/cli/commands/build.js

@@ -4,7 +4,7 @@ const fs = require('fs-extra');
 const chalk = require('chalk');
 const { getWorkspaceConfig } = require('../utils/config');
 const { resolveProjectDir } = require('../utils/resolution');
-const { clearAllDevMode } = require('../utils/transformer');
+const { clearAllDevMode, syncContextDownwards } = require('../utils/transformer');
 
 module.exports = async (options) => {
   const configObj = getWorkspaceConfig();
@@ -35,6 +35,7 @@ module.exports = async (options) => {
   // 1. CLEANUP CONFIG (Avoid shipping local dev URLs)
   console.log(chalk.gray(`🧹 Cleaning up devMode mappings in esad.config.js...`));
   clearAllDevMode(configObj.path);
+  syncContextDownwards(configObj);
 
   try {
     const bundleOutput = path.join(cwd, 'build', 'index.bundle'); // Simplified path as per V2

package/src/cli/commands/create.js

@@ -0,0 +1,161 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { runProcess } = require('../utils/process');
+const { cloneTemplate, renameProject } = require('../utils/scaffold');
+const { getWorkspaceConfig } = require('../utils/config');
+const templatesConfig = require('../templates/templates.json');
+
+const initHost = async (projectName) => {
+  const workspaceDir = path.join(process.cwd(), projectName);
+  console.log(`\n🚀 Initializing ESAD Workspace: ${projectName}...\n`);
+  
+  fs.ensureDirSync(workspaceDir);
+
+  const configPath = path.join(workspaceDir, 'esad.config.js');
+  if (!fs.existsSync(configPath)) {
+    const configTemplate = `/**
+ * ESAD: Super App Configuration
+ */
+export default {
+  projectName: '${projectName}',
+  
+  // 1. Development Overrides
+  // Managed automatically by 'esad dev'
+  devMode: {},
+
+  // 2. Programmable Deployment
+  // Receives the compiled bundle.
+  async deploy(bundle, { version, moduleId, options }) {
+    console.log('🚀 Starting custom upload for ' + moduleId + '...');
+    // return { status: 'mock_success', moduleId, version };
+  }
+};
+`;
+    fs.writeFileSync(configPath, configTemplate);
+    console.log(`✅ Generated programmable configuration: esad.config.js`);
+  }
+
+  const gitignorePath = path.join(workspaceDir, '.gitignore');
+  if (!fs.existsSync(gitignorePath)) {
+    const hostName = `${projectName}-host`;
+    const gitignoreContent = `# ESAD Workspace Git Configuration\n` +
+      `/*\n\n` +
+      `!/${hostName}/\n` +
+      `!/esad.config.js\n` +
+      `!/.gitignore\n` +
+      `\nnode_modules/\n`;
+    fs.writeFileSync(gitignorePath, gitignoreContent);
+    console.log(`✅ Generated .gitignore`);
+  }
+
+  const hostName = `${projectName}-host`;
+  const hostDir = path.join(workspaceDir, hostName);
+  
+  try {
+    await cloneTemplate(templatesConfig.host, hostDir);
+    await renameProject(hostDir, hostName);
+    
+    // Inject local context mock immediately to avoid crashes on fresh boot
+    fs.writeJsonSync(path.join(hostDir, '.esad.context.json'), { projectName, devMode: {} }, { spaces: 2 });
+    
+    console.log(`\n📦 Installing dependencies into host...`);
+    await runProcess('npm', ['install'], { cwd: hostDir });
+    console.log(`\n🎉 ESAD Workspace Initialized!`);
+    console.log(`-> cd ${projectName}/${hostName}\n-> esad host dev (to start Host)`);
+  } catch (err) {
+    console.error(`❌ Failed to init Host:`, err.message);
+  }
+};
+
+const createModule = async (moduleName) => {
+  const configObj = getWorkspaceConfig();
+  if (!configObj) {
+    console.error(`❌ Error: Call this command from inside an ESAD workspace (esad.config.js not found).`);
+    return;
+  }
+
+  const config = await configObj.load();
+  const projectName = config.default?.projectName || config.projectName;
+
+  const isPrefixed = moduleName.startsWith(`${projectName}-`);
+  const finalModuleName = isPrefixed ? moduleName : `${projectName}-${moduleName}`;
+
+  const workspaceDir = configObj.root;
+  const targetDir = path.join(workspaceDir, finalModuleName);
+
+  console.log(`\n📦 Creating federated mini-app: ${finalModuleName}...\n`);
+
+  try {
+    await cloneTemplate(templatesConfig.module, targetDir);
+    await renameProject(targetDir, finalModuleName);
+    
+    // Inject local context mock immediately
+    fs.writeJsonSync(path.join(targetDir, '.esad.context.json'), { projectName, devMode: {} }, { spaces: 2 });
+    
+    console.log(`\n📦 Installing dependencies...`);
+    await runProcess('npm', ['install'], { cwd: targetDir });
+    console.log(`\n🎉 Module ${finalModuleName} is ready!`);
+  } catch (err) {
+    console.error(`❌ Failed to scaffold module`, err.message);
+  }
+};
+
+const createCdn = async (cdnName) => {
+  const configObj = getWorkspaceConfig();
+  if (!configObj) {
+    console.error(`❌ Error: Call this command from inside an ESAD workspace (esad.config.js not found).`);
+    return;
+  }
+
+  const config = await configObj.load();
+  const projectName = config.default?.projectName || config.projectName;
+
+  const finalCdnName = cdnName || `${projectName}-cdn`;
+  const cdnPath = path.join(process.cwd(), finalCdnName);
+
+  if (fs.existsSync(cdnPath)) {
+    console.error(`❌ Error: Directory ./${finalCdnName} already exists.`);
+    return;
+  }
+
+  console.log(`\n📦 Initializing Flux Registry & CDN: ${finalCdnName}...\n`);
+
+  try {
+    console.log(`📡 Cloning template from GitHub...`);
+    await runProcess('git', ['clone', 'https://github.com/CodeMoreira/simple-cdn.git', finalCdnName]);
+    console.log(`🧹 Cleaning up template metadata...`);
+    await fs.remove(path.join(cdnPath, '.git'));
+    console.log(`\n📥 Installing dependencies (this may take a minute)...`);
+    await runProcess('npm', ['install'], { cwd: cdnPath });
+    console.log(`\n✅ CDN Registry created successfully in ./${finalCdnName}\n`);
+  } catch (error) {
+    console.error(`\n❌ Failed to create CDN: ${error.message}`);
+  }
+};
+
+module.exports = async (name, options) => {
+  const type = options.type;
+
+  if (type === 'host') {
+    if (!name) {
+      console.error(chalk.red('❌ Error: Project name is required for host creation.'));
+      process.exit(1);
+    }
+    return await initHost(name);
+  }
+
+  if (type === 'module') {
+    if (!name) {
+       console.error(chalk.red('❌ Error: Module name is required. Usage: esad create [name] --type module'));
+       process.exit(1);
+    }
+    return await createModule(name);
+  }
+
+  if (type === 'cdn') {
+    return await createCdn(name);
+  }
+
+  console.error(chalk.red(`❌ Unknown type: ${type}. Valid types are: host, module, cdn.`));
+};

package/src/cli/commands/dev.js

@@ -45,13 +45,14 @@ module.exports = async (options) => {
      return;
   }
 
-  const { updateDevMode, removeDevMode } = require('../utils/transformer');
+  const { updateDevMode, removeDevMode, syncContextDownwards } = require('../utils/transformer');
   
   console.log(`\n⚡ Starting ESAD Dev Server for ${chalk.cyan(moduleId)} on port ${port}...\n`);
   
   // Automate devMode update in esad.config.js
   const localBundleUrl = `http://localhost:${port}/index.bundle`;
   updateDevMode(configObj.path, moduleId, localBundleUrl);
+  syncContextDownwards(configObj);
   console.log(chalk.gray(`📡 Mode: Module Dev. Host configured to load ${moduleId} from ${localBundleUrl}`));
 
   const proc = runProcess('npx', ['react-native', 'webpack-start', '--port', port], { cwd });
@@ -59,6 +60,7 @@ module.exports = async (options) => {
   const shutdown = async () => {
     console.log(`\n🛑 Stopping ESAD Dev Server and reverting config...`);
     removeDevMode(configObj.path, moduleId);
+    syncContextDownwards(configObj);
     if (proc.kill) proc.kill();
     process.exit(0);
   };

package/src/cli/commands/doctor.js

@@ -0,0 +1,72 @@
+const { getWorkspaceConfig } = require('../utils/config');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+module.exports = async () => {
+  console.log(`\n🏥 ${chalk.bold('ESAD Doctor: Environment Diagnostics')}\n`);
+
+  const configObj = getWorkspaceConfig();
+  let errors = 0;
+  let warnings = 0;
+
+  // 1. Config Validation
+  if (!configObj) {
+    console.error(`${chalk.red('✖')} esad.config.js not found in any parent directories.`);
+    errors++;
+  } else {
+    console.log(`${chalk.green('✔')} esad.config.js detected at: ${chalk.gray(configObj.path)}`);
+    
+    // 2. Deployment Hook Validation
+    const config = await configObj.load();
+    const deployHook = config.default?.deploy || config.deploy;
+    if (typeof deployHook === 'function') {
+      console.log(`${chalk.green('✔')} Generic 'deploy' hook is properly defined.`);
+    } else {
+      console.warn(`${chalk.yellow('⚠')} Warning: 'deploy' hook is missing or is not a function.`);
+      warnings++;
+    }
+  }
+
+  // 3. Registry & Auth Check
+  const envPath = path.join(process.cwd(), '.env');
+  if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, 'utf8');
+    if (envContent.includes('EXPO_PUBLIC_REGISTRY_URL')) {
+      console.log(`${chalk.green('✔')} EXPO_PUBLIC_REGISTRY_URL found in .env`);
+    } else {
+      console.warn(`${chalk.yellow('⚠')} Warning: EXPO_PUBLIC_REGISTRY_URL not found in .env (Host might fail to resolve modules).`);
+      warnings++;
+    }
+  } else {
+    console.warn(`${chalk.yellow('⚠')} Warning: .env file not found in current directory.`);
+    warnings++;
+  }
+
+  // 4. Dependency Sync Check (Simple version)
+  const pkgPath = path.join(process.cwd(), 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    const pkg = fs.readJsonSync(pkgPath);
+    const deps = pkg.dependencies || {};
+    
+    const criticalDeps = ['react-native', '@callstack/repack', 'react'];
+    criticalDeps.forEach(dep => {
+      if (deps[dep]) {
+        console.log(`${chalk.green('✔')} Found critical dependency: ${dep} (${deps[dep]})`);
+      } else {
+        console.warn(`${chalk.yellow('⚠')} Missing critical dependency in this context: ${dep}`);
+        warnings++;
+      }
+    });
+  }
+
+  console.log(`\n------------------------------------------------`);
+  if (errors === 0) {
+    console.log(`${chalk.bold.green('STABLE')}: ${errors} errors, ${warnings} warnings.`);
+    if (warnings > 0) console.log(`👉 Consider addressing the warnings to ensure a perfect developer experience.`);
+  } else {
+    console.log(`${chalk.bold.red('UNSTABLE')}: ${errors} errors, ${warnings} warnings.`);
+    console.log(`👉 Run 'esad init' or fix the manual errors above.`);
+  }
+  console.log(`------------------------------------------------\n`);
+};

package/src/cli/commands/link.js

@@ -0,0 +1,35 @@
+const { getWorkspaceConfig } = require('../utils/config');
+const { resolveProjectDir } = require('../utils/resolution');
+const { updateDevMode } = require('../utils/transformer');
+const path = require('path');
+const chalk = require('chalk');
+
+module.exports = async (moduleId) => {
+  const configObj = getWorkspaceConfig();
+  if (!configObj) {
+    console.error(chalk.red(`❌ Error: esad.config.js not found.`));
+    process.exit(1);
+  }
+
+  if (!moduleId) {
+    console.error(chalk.red(`❌ Error: Module ID is required for linking. Usage: esad link [module-name]`));
+    process.exit(1);
+  }
+
+  const targetDir = resolveProjectDir(moduleId, configObj);
+  if (!targetDir) {
+    console.error(chalk.red(`❌ Error: Module not found: ${moduleId}`));
+    process.exit(1);
+  }
+
+  // Generate a local filesystem link
+  // Re.Pack can handle file:// on some platforms, or we use this as a hint for the resolver.
+  const localPath = `file://${path.join(targetDir, 'build', 'index.bundle')}`;
+  
+  updateDevMode(configObj.path, moduleId, localPath);
+
+  console.log(`\n🔗 ${chalk.bold('Module Linked Locally')}`);
+  console.log(`${chalk.cyan(moduleId)} -> ${chalk.gray(localPath)}`);
+  console.log(`\n👉 Run 'esad build ${moduleId}' to generate the bundle if you haven't yet.`);
+  console.log(`📡 The Host app's ScriptManager will now prioritize this local file.\n`);
+};

package/src/cli/utils/transformer.js

@@ -1,44 +1,82 @@
-const fs = require('fs-extra');
-const path = require('path');
-
-/**
- * Safely updates the devMode object in esad.config.js
- * This uses a simple yet robust regex approach to preserve comments/formatting.
- */
-const updateDevMode = (configPath, moduleId, url) => {
-  let content = fs.readFileSync(configPath, 'utf8');
-
-  // 1. Ensure devMode object exists
-  if (!content.includes('devMode:')) {
-    // Inject devMode before the last closing brace (naive but effective for clean configs)
-    content = content.replace(/}([^}]*)$/, `  devMode: {},\n}$1`);
-  }
-
-  // 2. Add or update the module entry
-  const entryRegex = new RegExp(`(['"]${moduleId}['"]|${moduleId}):\\s*['"]([^'"]*)['"]`, 'g');
-  
-  if (entryRegex.test(content)) {
-    // Update existing
-    content = content.replace(entryRegex, `$1: '${url}'`);
-  } else {
-    // Insert new entry into devMode object
-    const devModeRegex = /(devMode:\s*{)/;
-    content = content.replace(devModeRegex, `$1\n    '${moduleId}': '${url}',`);
-  }
-
-  fs.writeFileSync(configPath, content);
-};
-
-const clearAllDevMode = (configPath) => {
-  if (!fs.existsSync(configPath)) return;
-  let content = fs.readFileSync(configPath, 'utf8');
-
-  // Remove the entire devMode block
-  const devModeBlockRegex = /\s*devMode:\s*{[\s\S]*?},?/g;
-  content = content.replace(devModeBlockRegex, '');
-
-  fs.writeFileSync(configPath, content);
-};
-
-module.exports = { updateDevMode, removeDevMode, clearAllDevMode };
-
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Safely updates the devMode object in esad.config.js
+ * This uses a simple yet robust regex approach to preserve comments/formatting.
+ */
+const updateDevMode = (configPath, moduleId, url) => {
+  let content = fs.readFileSync(configPath, 'utf8');
+
+  // 1. Ensure devMode object exists
+  if (!content.includes('devMode:')) {
+    // Inject devMode before the last closing brace (naive but effective for clean configs)
+    content = content.replace(/}([^}]*)$/, `  devMode: {},\n}$1`);
+  }
+
+  // 2. Add or update the module entry
+  const entryRegex = new RegExp(`(['"]${moduleId}['"]|${moduleId}):\\s*['"]([^'"]*)['"]`, 'g');
+  
+  if (entryRegex.test(content)) {
+    // Update existing
+    content = content.replace(entryRegex, `$1: '${url}'`);
+  } else {
+    // Insert new entry into devMode object
+    const devModeRegex = /(devMode:\s*{)/;
+    content = content.replace(devModeRegex, `$1\n    '${moduleId}': '${url}',`);
+  }
+
+  fs.writeFileSync(configPath, content);
+};
+
+const removeDevMode = (configPath, moduleId) => {
+  if (!fs.existsSync(configPath)) return;
+  let content = fs.readFileSync(configPath, 'utf8');
+
+  // Remove specific module entry
+  const entryRegex = new RegExp(`\\s*['"]?${moduleId}['"]?:\\s*['"]([^'"]*)['"],?`, 'g');
+  content = content.replace(entryRegex, '');
+
+  fs.writeFileSync(configPath, content);
+};
+
+const clearAllDevMode = (configPath) => {
+  if (!fs.existsSync(configPath)) return;
+  let content = fs.readFileSync(configPath, 'utf8');
+
+  // Remove the entire devMode block
+  const devModeBlockRegex = /\s*devMode:\s*{[\s\S]*?},?/g;
+  content = content.replace(devModeBlockRegex, '');
+
+  fs.writeFileSync(configPath, content);
+};
+
+const syncContextDownwards = (configObj) => {
+  if (!fs.existsSync(configObj.path)) return;
+  const configDir = path.dirname(configObj.path);
+
+  // Clear cache to read fresh state
+  delete require.cache[require.resolve(configObj.path)];
+  let configContent = require(configObj.path);
+  if (configContent.default) configContent = configContent.default;
+
+  const exportData = {
+    projectName: configContent.projectName || 'esad-workspace',
+    devMode: configContent.devMode || {}
+  };
+
+  try {
+    const children = fs.readdirSync(configDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => path.join(configDir, dirent.name))
+      .filter(dir => fs.existsSync(path.join(dir, 'package.json')));
+
+    for (const childDir of children) {
+      fs.writeJsonSync(path.join(childDir, '.esad.context.json'), exportData, { spaces: 2 });
+    }
+  } catch (err) {
+    console.error('Failed to sync context downwards:', err.message);
+  }
+};
+
+module.exports = { updateDevMode, removeDevMode, clearAllDevMode, syncContextDownwards };

package/src/cli/commands/createCdn.js

@@ -1,44 +0,0 @@
-const { runProcess } = require('../utils/process');
-const { getWorkspaceConfig } = require('../utils/config');
-const fs = require('fs-extra');
-const path = require('path');
-
-module.exports = async (cdnName) => {
-  const configObj = getWorkspaceConfig();
-  if (!configObj) {
-    console.error(`❌ Error: Call this command from inside an ESAD workspace (esad.config.json not found).`);
-    return;
-  }
-
-  const finalCdnName = cdnName || `${configObj.data.projectName}-cdn`;
-  const cdnPath = path.join(process.cwd(), finalCdnName);
-
-  if (fs.existsSync(cdnPath)) {
-    console.error(`❌ Error: Directory ./${finalCdnName} already exists.`);
-    return;
-  }
-
-  console.log(`\n📦 Initializing Flux Registry & CDN: ${finalCdnName}...\n`);
-
-  try {
-    // 1. Clone the template
-    console.log(`📡 Cloning template from GitHub...`);
-    await runProcess('git', ['clone', 'https://github.com/CodeMoreira/simple-cdn.git', finalCdnName]);
-
-    // 2. Remove .git from template
-    console.log(`🧹 Cleaning up template metadata...`);
-    await fs.remove(path.join(cdnPath, '.git'));
-
-    // 3. Install dependencies
-    console.log(`\n📥 Installing dependencies (this may take a minute)...`);
-    await runProcess('npm', ['install'], cdnPath);
-
-    console.log(`\n✅ CDN Registry created successfully in ./${finalCdnName}\n`);
-    console.log(`To start your CDN:`);
-    console.log(`  cd ${finalCdnName}`);
-    console.log(`  npm start\n`);
-
-  } catch (error) {
-    console.error(`\n❌ Failed to create CDN: ${error.message}`);
-  }
-};

package/src/cli/commands/createModule.js

@@ -1,41 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const { runProcess } = require('../utils/process');
-const { getWorkspaceConfig } = require('../utils/config');
-const { cloneTemplate, renameProject } = require('../utils/scaffold');
-const templatesConfig = require('../templates/templates.json');
-
-module.exports = async (moduleName) => {
-  const configObj = getWorkspaceConfig();
-  if (!configObj) {
-    console.error(`❌ Error: Call this command from inside an ESAD workspace (esad.config.js not found).`);
-    return;
-  }
-
-  const config = await configObj.load();
-  const projectName = config.default?.projectName || config.projectName;
-
-  const isPrefixed = moduleName.startsWith(`${projectName}-`);
-
-  const finalModuleName = isPrefixed ? moduleName : `${projectName}-${moduleName}`;
-
-  const workspaceDir = path.dirname(configObj.path);
-  const targetDir = path.join(workspaceDir, finalModuleName);
-
-  console.log(`\n📦 Creating federated mini-app: ${finalModuleName}...\n`);
-
-  try {
-    // 1. Clone Template instead of react-native init
-    await cloneTemplate(templatesConfig.module, targetDir);
-
-    // 2. Rename Project
-    await renameProject(targetDir, finalModuleName);
-
-    console.log(`\n📦 Installing dependencies...`);
-    await runProcess('npm', ['install'], targetDir);
-
-    console.log(`\n🎉 Module ${finalModuleName} is ready!`);
-  } catch (err) {
-    console.error(`❌ Failed to scaffold module`, err.message);
-  }
-};

package/src/cli/commands/init.js

@@ -1,78 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const { runProcess } = require('../utils/process');
-const { cloneTemplate, renameProject } = require('../utils/scaffold');
-const templatesConfig = require('../templates/templates.json');
-
-module.exports = async (projectName) => {
-  const workspaceDir = path.join(process.cwd(), projectName);
-  console.log(`\n🚀 Initializing ESAD Workspace: ${projectName}...\n`);
-  
-  fs.ensureDirSync(workspaceDir);
-
-  const configPath = path.join(workspaceDir, 'esad.config.js');
-  if (!fs.existsSync(configPath)) {
-    const configTemplate = `/**
- * ESAD: Super App Configuration
- */
-export default {
-  projectName: '${projectName}',
-  
-  // 1. Development Overrides
-  // Managed automatically by 'esad dev'
-  devMode: {},
-
-  // 2. Programmable Deployment
-  // Receives the compiled bundle.
-  async deploy(bundle, { version, moduleId, options }) {
-    console.log('🚀 Starting custom upload for ' + moduleId + '...');
-    
-    // Example: Simple CDN V2 upload
-    // const response = await fetch('http://localhost:3000/api/admin/modules/' + moduleId + '/versions', {
-    //   method: 'POST',
-    //   body: bundle,
-    //   headers: { 'Authorization': 'Bearer YOUR_TOKEN' }
-    // });
-    // return await response.json();
-
-    return { status: 'mock_success', moduleId, version };
-  }
-};
-`;
-    fs.writeFileSync(configPath, configTemplate);
-    console.log(`✅ Generated programmable configuration: esad.config.js`);
-  }
-
-  const gitignorePath = path.join(workspaceDir, '.gitignore');
-  if (!fs.existsSync(gitignorePath)) {
-    const hostName = `${projectName}-host`;
-    const gitignoreContent = `# ESAD Workspace Git Configuration\n` +
-      `/*\n\n` +
-      `!/${hostName}/\n` +
-      `!/esad.config.js\n` +
-      `!/.gitignore\n` +
-      `\nnode_modules/\n`;
-    fs.writeFileSync(gitignorePath, gitignoreContent);
-    console.log(`✅ Generated .gitignore`);
-  }
-
-
-  const hostName = `${projectName}-host`;
-  const hostDir = path.join(workspaceDir, hostName);
-  
-  try {
-    // 1. Clone Template instead of create-expo-app
-    await cloneTemplate(templatesConfig.host, hostDir);
-    
-    // 2. Rename Project
-    await renameProject(hostDir, hostName);
-
-    console.log(`\n📦 Installing dependencies into host...`);
-    await runProcess('npm', ['install'], hostDir); 
-
-    console.log(`\n🎉 ESAD Workspace Initialized!`);
-    console.log(`-> cd ${projectName}/${hostName}\n-> esad host dev (to start Host)`);
-  } catch (err) {
-    console.error(`❌ Failed to init Host:`, err.message);
-  }
-};