@codemoreira/esad 2.0.1-0 → 2.0.1-12

package/README.md

@@ -1,82 +1,88 @@
-# ESAD (Easy Super App Development) 🚀
-
-Zero-Config CLI and DevTools for React Native Module Federation + Expo.
-
-ESAD is a unified toolkit designed to abstract all the complexity from Super App development using **Re.Pack (Rspack)** and **Expo**.
-
----
-
-## 🏗️ CLI Commands
-
-### 1. Initialize a Workspace
-```bash
-npx @codemoreira/esad init my-project
-```
-
-### 2. Create a Federated Module
-```bash
-npx esad create-module module-name
-```
-
-### 3. Create a Local CDN / Registry
-```bash
-npx esad create-cdn
-```
-
-### 4. Development & Native Automation
-Starts the Rspack server and **automatically patches** native files (Gradle, Entry Points) if necessary.
-```bash
-npx esad host dev  # Run the Host App
-npx esad dev --id module-name --port 9000  # Run a Module
-```
-
-### 5. Build for Production
-Prepares the bundle and chunks for deployment, generating a standardized `./build` directory.
-```bash
-npx esad build --id module-name --platform android
-```
-
-### 6. Deployment
-Packages the `./build` folder and uploads it to your configured Registry/CDN via multipart POST.
-```bash
-npx esad deploy --id module-name --version 1.0.0
-```
-
----
-
-## 🛠️ Library Usage
-
-### 🎨 Bundler Plugin (`@codemoreira/esad/plugin`)
-Wrap your configuration to enable ESAD's smart resolution and redirection logic:
-```javascript
-import { withESAD } from '@codemoreira/esad/plugin';
-
-export default withESAD({
-  type: 'module', // or 'host'
-  id: 'my-mini-app'
-});
-```
-
-### ⚡ Global State SDK (`@codemoreira/esad/client`)
-Share state across the Host and all Remote Modules reactively:
-```javascript
-import { useESADState } from '@codemoreira/esad/client';
-
-const [user, setUser] = useESADState('user');
-```
-
----
-
-## 🏠 Template Features (Host & Module)
-
-ESAD provides high-quality, boilerplate-free templates:
-- **🚀 Rspack + Re.Pack**: Blazing fast builds powered by Rspack.
-- **📱 Clean UI**: Modern, responsive designs built with **Vanilla StyleSheet** (No external CSS libraries required).
-- **🛤️ Dynamic Navigation**: Pre-configured Dashboard and Module Viewer with **Suspense** support.
-- **🔐 State-Driven Auth**: Built-in login and session management via the ESAD SDK.
-- **🔧 Automated Patching**: CLI-driven injection of Re.Pack extensions into Android and iOS native projects.
-
----
-
-## 🎨 Architecture & Workflow
-For technical diagrams and the modular deployment lifecycle, see [ESAD_ARCHITECTURE.md](./ESAD_ARCHITECTURE.md).
+# ESAD (Easy Super App Development) 🚀
+
+Zero-Config CLI and DevTools for React Native Module Federation + Expo.
+
+ESAD is a unified toolkit designed to abstract all the complexity from Super App development using **Re.Pack (Rspack)** and **Expo**. It provides a professional, linear workflow from scaffolding to deployment.
+
+---
+
+## 🏗️ CLI Workflow (V2)
+
+### 1. Initialize a Workspace
+Creates the project root, a programmable `esad.config.js`, and the Host Application.
+```bash
+npx @codemoreira/esad init my-project
+```
+
+### 2. Expand your Workspace
+Create new Federated Modules or a Local Registry/CDN.
+```bash
+esad create my-module   # Creates a new module (Feature)
+esad create --type cdn  # Scaffolds a local registry for testing
+```
+
+### 3. Development Manager (Unified)
+The `dev` command is the single entry point for development. It automatically detects if it should run the Host or a Module.
+
+**Run the Host App (Interactive):**
+```bash
+esad dev
+```
+*Allows selecting Android, iOS, or Bundler Only. Automatically patches native files.*
+
+**Run a specific Module:**
+```bash
+esad dev my-module --port 9000
+```
+*Starts the module server and updates the Host's local mapping automatically.*
+
+### 4. Build & Deploy
+Prepare and push your features to the registry.
+
+**Build for Production:**
+```bash
+esad build my-module --platform android
+```
+
+**Execute Programmable Deploy:**
+```bash
+esad deploy my-module --version 1.0.0
+```
+
+---
+
+## 🛠️ Library Usage
+
+### 🎨 Bundler Plugin (`@codemoreira/esad/plugin`)
+Wrap your configuration to enable ESAD's smart resolution and redirection logic:
+```javascript
+import { withESAD } from '@codemoreira/esad/plugin';
+
+export default withESAD({
+  type: 'module', // or 'host'
+  id: 'my-mini-app'
+});
+```
+
+### ⚡ Global State SDK (`@codemoreira/esad/client`)
+Share state across the Host and all Remote Modules reactively:
+```javascript
+import { useESADState } from '@codemoreira/esad/client';
+
+const [user, setUser] = useESADState('user');
+```
+
+---
+
+## 🏠 Template Features (Host & Module)
+ESAD templates provide a high-end starting point:
+- **🚀 Rspack + Re.Pack**: Blazing fast builds.
+- **📱 Professional Architecture**: Modular structure (`src/api`, `src/components`, `src/navigation`).
+- **🛤️ Dynamic Navigation**: Pre-configured Module Viewer with **Suspense** and **ErrorBoundary** support.
+- **🔐 State-Driven Auth**: Built-in login and session management via the ESAD SDK.
+- **🔧 Automated Native Patching**: Zero-config injection into Android/iOS projects.
+
+---
+
+## 🎨 Architecture & Workflow
+For technical diagrams and the full lifecycle, see [ESAD_ARCHITECTURE.md](./ESAD_ARCHITECTURE.md).

package/bin/esad.js

@@ -7,22 +7,30 @@ program
   .version(pkg.version)
   .description('esad - Easy Super App Development Toolkit (V2)');
 
-// --- COMMAND: esad create [name] --type [host|module|cdn] ---
+// --- COMMAND: esad init [name] ---
+program
+  .command('init [name]')
+  .description('Creates the base of an ESAD project (Workspace and Host App)')
+  .action(async (name) => {
+    await require('../src/cli/commands/init')(name);
+  });
+
+// --- COMMAND: esad create [name] --type [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')
+  .option('-t, --type <type>', 'Type of resource: module, cdn', 'module')
+  .description('Expands an existing workspace by scaffolding modules or a local cdn')
   .action(async (name, options) => {
     await require('../src/cli/commands/create')(name, options);
-    process.exit(0);
   });
 
-// --- COMMAND: esad dev [moduleId] ---
+// --- COMMAND: esad dev [id] ---
 program
-  .command('dev [id]') // [id] as alias to -i for better UX
+  .command('dev [id]')
   .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')
+  .option('--platform <platform>', 'Platform for host: android, ios, bundler')
+  .description('Starts the development environment. Run without [id] for Host App or with [id] for a specific Module.')
   .action(async (id, options) => {
     const opts = { ...options, id: id || options.id };
     await require('../src/cli/commands/dev')(opts);
@@ -33,11 +41,10 @@ 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')
+  .description('Builds a production bundle for a module or the host application')
   .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] ---
@@ -49,16 +56,6 @@ program
   .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 ---
@@ -67,7 +64,6 @@ program
   .description('Check environment for common issues')
   .action(async () => {
     await require('../src/cli/commands/doctor')();
-    process.exit(0);
   });
 
 // --- COMMAND: esad link [id] ---
@@ -76,7 +72,6 @@ program
   .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.1-0",
+  "version": "2.0.1-12",
   "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",
@@ -50,6 +50,7 @@
     "cross-spawn": "^7.0.3",
     "form-data": "^4.0.0",
     "fs-extra": "^11.2.0",
+    "jiti": "^2.6.1",
     "node-fetch": "^2.7.0",
     "process": "^0.11.10"
   },
@@ -58,4 +59,4 @@
     "@types/react": "^19.2.14",
     "@types/react-native": "^0.72.8"
   }
-}
+}

package/src/cli/commands/build.js

@@ -38,7 +38,7 @@ module.exports = async (options) => {
   syncContextDownwards(configObj);
 
   try {
-    const bundleOutput = path.join(cwd, 'build', 'index.bundle'); // Simplified path as per V2
+    const bundleOutput = path.join(cwd, 'build', platform, 'index.bundle'); 
     fs.ensureDirSync(path.dirname(bundleOutput));
 
     // Run Re.Pack production build

package/src/cli/commands/create.js

@@ -6,68 +6,6 @@ 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) {
@@ -138,11 +76,9 @@ 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);
+    console.error(chalk.red('❌ Error: The "host" type is no longer supported in create.'));
+    console.error(chalk.yellow('👉 Use "esad init <project-name>" instead to create a new workspace.'));
+    process.exit(1);
   }
 
   if (type === 'module') {
@@ -157,5 +93,5 @@ module.exports = async (name, options) => {
     return await createCdn(name);
   }
 
-  console.error(chalk.red(`❌ Unknown type: ${type}. Valid types are: host, module, cdn.`));
+  console.error(chalk.red(`❌ Unknown type: ${type}. Valid types are: module, cdn.`));
 };

package/src/cli/commands/dev.js

@@ -1,72 +1,175 @@
-const { runProcess } = require('../utils/process');
-const { getWorkspaceConfig } = require('../utils/config');
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-const { prepareNative } = require('../utils/scaffold');
-const { resolveProjectDir } = require('../utils/resolution');
-
-module.exports = async (options) => {
-  const configObj = getWorkspaceConfig();
-  if (!configObj) {
-    console.error(chalk.red(`❌ Error: esad.config.js not found. Run this from your project root.`));
-    process.exit(1);
-  }
-
-  const config = await configObj.load();
-  const workspaceRoot = configObj.root;
-  const projectName = config.default?.projectName || config.projectName;
-  
-  let cwd = process.cwd();
-  let selectedModuleId = options.id;
-
-  if (selectedModuleId) {
-    const targetDir = resolveProjectDir(selectedModuleId, configObj);
-    if (!targetDir) {
-      console.error(chalk.red(`❌ Error: Module not found: ${selectedModuleId}`));
-      process.exit(1);
-    }
-    cwd = targetDir;
-  }
-
-  const pkgPath = path.join(cwd, 'package.json');
-  const pkg = fs.readJsonSync(pkgPath);
-  const moduleId = selectedModuleId || pkg.name;
-  const port = options.port || '8081';
-
-  // Determine if it's a Host or Module
-  const isHost = pkg.name.endsWith('-host') || pkg.dependencies?.['@callstack/repack'];
-  
-  await prepareNative(cwd, 'all');
-
-  if (isHost && !selectedModuleId) {
-     console.log(`\n🚀 Starting ${chalk.green('Host App')} Dev Server (Re.Pack/Rspack)...\n`);
-     await runProcess('npx', ['react-native', 'webpack-start'], { cwd });
-     return;
-  }
-
-  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 });
-
-  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);
-  };
-
-
-  process.on('SIGINT', shutdown);
-  process.on('SIGTERM', shutdown);
-};
-
+const { runProcess } = require('../utils/process');
+const { getWorkspaceConfig } = require('../utils/config');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const http = require('http');
+const readline = require('readline');
+const { spawn } = require('cross-spawn');
+const { prepareNative } = require('../utils/scaffold');
+const { resolveProjectDir } = require('../utils/resolution');
+
+/**
+ * Check if a port is in use
+ */
+const isPortInUse = (port) => new Promise((resolve) => {
+  const req = http.get(`http://localhost:${port}`, (res) => {
+    resolve(true); 
+  });
+  req.on('error', () => {
+    resolve(false); 
+  });
+  req.end();
+});
+
+const runHostDevFlow = async (cwd, options = {}) => {
+  let choice = options.platform ? options.platform.charAt(0).toLowerCase() : null;
+
+  if (!choice) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const askQuestion = (query) => new Promise((resolve) => rl.question(query, resolve));
+
+    console.log(`\n${chalk.bold('ESAD Host Dev Manager')}`);
+    console.log(chalk.dim(`---------------------`));
+    console.log(`[a] Run on Android`);
+    console.log(`[i] Run on iOS`);
+    console.log(`[b] Bundler Only`);
+    console.log(`[c] Cancel`);
+    
+    choice = (await askQuestion(`\nSelect platform: `)).toLowerCase();
+    rl.close();
+  }
+  
+  if (choice === 'c') {
+    console.log(`\n❌ Cancelled.`);
+    return;
+  }
+
+  const portBusy = await isPortInUse(8081);
+  let shouldStartBundler = true;
+
+  if (portBusy) {
+    console.log(`\n⚠️  Warning: Port 8081 is already in use.`);
+    console.log(`💡 Skipping Bundler startup. Proceeding with Native Build.\n`);
+    shouldStartBundler = false;
+  }
+
+  if (shouldStartBundler && choice !== 'c') {
+    console.log(`\n🛠️ Starting Rspack Bundler...`);
+    if (process.platform === 'win32') {
+      spawn('cmd', ['/c', 'start', '/D', cwd, 'npx.cmd', 'react-native', 'webpack-start'], { 
+        detached: true, 
+        stdio: 'ignore',
+        shell: true 
+      }).unref();
+    } else {
+      spawn('npx', ['react-native', 'webpack-start'], { 
+        cwd, 
+        detached: true, 
+        stdio: 'inherit', 
+        shell: true 
+      }).unref();
+    }
+
+    console.log(`⏳ Waiting for Rspack Bundler on port 8081...`);
+    const waitForBundler = async () => {
+      for (let i = 0; i < 30; i++) {
+        if (await isPortInUse(8081)) return true;
+        await new Promise(r => setTimeout(r, 2000));
+      }
+      return false;
+    };
+
+    if (!(await waitForBundler())) {
+      console.error(`\n❌ Timeout: Bundler did not respond.`);
+      return;
+    }
+    console.log(`✅ Bundler ready!`);
+  }
+
+  if (choice === 'a') {
+    console.log(`🤖 Launching Android...`);
+    await runProcess('react-native', ['run-android', '--no-packager'], cwd);
+  } else if (choice === 'i') {
+    console.log(`🍎 Launching iOS...`);
+    await runProcess('react-native', ['run-ios', '--no-packager'], cwd);
+  } else if (choice === 'b') {
+    console.log(`✨ Bundler is active.`);
+  }
+};
+
+module.exports = async (options) => {
+  const configObj = getWorkspaceConfig();
+  if (!configObj) {
+    console.error(chalk.red(`❌ Error: esad.config.js not found. Run this from your project root.`));
+    process.exit(1);
+  }
+
+  const config = configObj.data;
+  const workspaceRoot = configObj.root;
+  const projectName = config.projectName;
+  
+  let cwd = process.cwd();
+  let selectedModuleId = options.id;
+
+  // 1. Module Dev Flow
+  if (selectedModuleId) {
+    const targetDir = resolveProjectDir(selectedModuleId, configObj);
+    if (!targetDir) {
+      console.error(chalk.red(`❌ Error: Module not found: ${selectedModuleId}`));
+      process.exit(1);
+    }
+    cwd = targetDir;
+    
+    const pkg = fs.readJsonSync(path.join(cwd, 'package.json'));
+    const moduleId = selectedModuleId || pkg.name;
+    const port = options.port || '8081';
+
+    await prepareNative(cwd, 'all');
+
+    const { updateDevMode, removeDevMode, syncContextDownwards } = require('../utils/transformer');
+    
+    console.log(`\n⚡ Starting ESAD Dev Server for ${chalk.cyan(moduleId)} on port ${port}...\n`);
+    const localBundleUrl = `http://localhost:${port}/index.bundle`;
+    updateDevMode(configObj.path, moduleId, localBundleUrl);
+    syncContextDownwards(configObj);
+
+    const proc = runProcess('npx', ['react-native', 'webpack-start', '--port', port], { cwd });
+
+    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);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    return;
+  }
+
+  // 2. Host Dev Flow (Auto-detection)
+  const pkgPath = path.join(cwd, 'package.json');
+  let isHost = fs.existsSync(pkgPath) && fs.readJsonSync(pkgPath).name.endsWith('-host');
+
+  if (!isHost) {
+    const hostDir = path.join(workspaceRoot, `${projectName}-host`);
+    if (fs.existsSync(hostDir)) {
+      cwd = hostDir;
+      isHost = true;
+      console.log(`📂 Auto-detected Host App: ${chalk.dim(path.relative(process.cwd(), hostDir))}`);
+    }
+  }
+
+  if (isHost) {
+    await prepareNative(cwd, 'all');
+    await runHostDevFlow(cwd, options);
+  } else {
+    console.error(chalk.red(`❌ Error: Could not detect Host or Module context.`));
+    console.log(`👉 Try: esad dev <module-id>`);
+  }
+};

package/src/cli/commands/init.js

@@ -0,0 +1,85 @@
+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 templatesConfig = require('../templates/templates.json');
+
+module.exports = async (projectName) => {
+  if (!projectName) {
+    console.error(chalk.red('❌ Error: Project name is required to initialize a new ESAD workspace.'));
+    console.error(chalk.yellow('👉 Usage: esad init <project-name>'));
+    process.exit(1);
+  }
+
+  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` +
+      `# Note: We use a whitelist approach because modules should be kept in separate repositories.\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
+    const context = { projectName, devMode: {} };
+    fs.writeJsonSync(path.join(hostDir, '.esad.context.json'), context, { spaces: 2 });
+    
+    // Stabilize filesystem before heavy operations
+    await new Promise(res => setTimeout(res, 500));
+
+    console.log(`\n📦 Installing dependencies into host (this may take a minute)...`);
+    await runProcess('npm', ['install'], { cwd: hostDir });
+    
+    console.log(chalk.green(`\n🎉 ESAD Workspace Initialized successfully!`));
+    console.log(chalk.cyan(`\n👉 Next steps:`));
+    console.log(`   1. cd ${projectName}/${hostName}`);
+    console.log(`   2. esad dev (to start Host)`);
+    console.log(`   3. esad dev (in a module folder to federate)\n`);
+  } catch (err) {
+    console.error(chalk.red(`\n❌ Failed to initialize workspace:`));
+    console.error(chalk.yellow(`   ${err.message}`));
+    console.log(chalk.dim(`\n   Check npm logs if it was an installation error.`));
+  }
+};

package/src/cli/utils/config.js

@@ -20,15 +20,14 @@ const getWorkspaceConfig = () => {
 
   try {
     const jiti = createJiti(__filename);
-    const configModule = jiti.import(configPath);
-    // jiti.import returns a promise for async imports if needed, but for esad.config.js 
-    // we expect a sync structure or we resolve it.
-    // However, jiti v2 import is async.
-    
+    let configData = jiti(configPath);
+    if (configData.default) configData = configData.default;
+
     return { 
       path: configPath, 
       root: path.dirname(configPath),
-      load: () => configModule 
+      data: configData,
+      load: () => configData 
     };
   } catch (err) {
     console.error(`❌ Failed to load esad.config.js: ${err.message}`);

package/src/cli/utils/process.js

@@ -3,64 +3,71 @@ const nativeSpawn = require('child_process').spawn;
 const path = require('path');
 const fs = require('fs-extra');
 
-const runProcess = (cmd, args, cwd = process.cwd()) => {
-  return new Promise((resolve, reject) => {
-    let finished = false;
-    let started = false;
+const runProcess = (cmd, args, options = process.cwd()) => {
+    const cwd = typeof options === 'string' ? options : (options.cwd || process.cwd());
+    let childRef;
+    const promise = new Promise((resolve, reject) => {
+      let finished = false;
+      let started = false;
 
-    const finalize = (fn, arg) => {
-      if (finished) return;
-      finished = true;
-      fn(arg);
-    };
+      const finalize = (fn, arg) => {
+        if (finished) return;
+        finished = true;
+        fn(arg);
+      };
 
-    const isWin = process.platform === 'win32';
-    const localBinPath = path.join(cwd, 'node_modules', '.bin', isWin ? `${cmd}.cmd` : cmd);
-    
-    let command = cmd;
-    let finalArgs = args;
-    let useNativeSpawn = false;
+      const isWin = process.platform === 'win32';
+      const localBin = isWin ? `${cmd}.cmd` : cmd;
+      const localBinPath = path.join(cwd, 'node_modules', '.bin', localBin);
+      
+      let command = cmd;
+      let finalArgs = args;
+      let useNativeSpawn = false;
 
-    if (fs.existsSync(localBinPath)) {
-      command = isWin ? `node_modules\\.bin\\${cmd}.cmd` : `./node_modules/.bin/${cmd}`;
-      useNativeSpawn = isWin; // Use native spawn on Windows for local binaries to avoid cross-spawn issues
-    } else {
-      command = isWin ? 'npx.cmd' : 'npx';
-      finalArgs = [cmd, ...args];
-    }
-    
-    console.log(`[ESAD] Resolved Command: ${command} (CWD: ${cwd})`);
+      if (fs.existsSync(localBinPath)) {
+        // 1. Priority: Local node_modules/.bin (fastest & consistent)
+        command = isWin ? `node_modules\\.bin\\${localBin}` : `./node_modules/.bin/${localBin}`;
+        useNativeSpawn = isWin; 
+      } else {
+        // 2. Fallback: System Path (git, npm, npx, etc)
+        // cross-spawn handles .cmd/.exe resolution automatically
+        command = cmd;
+        finalArgs = args;
+        useNativeSpawn = false;
+      }
+      
+      console.log(`[ESAD] Resolved Command: ${command} (CWD: ${cwd})`);
 
-    // Mark as started after a short delay
-    setTimeout(() => { started = true; }, 2000);
+      setTimeout(() => { started = true; }, 2000);
 
-    const spawnFn = useNativeSpawn ? nativeSpawn : spawn;
-    const child = spawnFn(command, finalArgs, { 
-      stdio: 'inherit', 
-      cwd, 
-      shell: true
-    });
+      const spawnFn = useNativeSpawn ? nativeSpawn : spawn;
+      childRef = spawnFn(command, finalArgs, { 
+        stdio: 'inherit', 
+        cwd, 
+        shell: true
+      });
 
-    child.on('error', err => {
-      // If the process already "started" (ran for > 2s), we ignore early-spawn errors
-      // as they are likely shell artifacts from the process exiting.
-      if (started && err.code === 'ENOENT') {
-        console.warn(`[ESAD] Warning: Late ENOENT ignored for ${cmd}.`);
-        return;
-      }
+      childRef.on('error', err => {
+        if (started && err.code === 'ENOENT') {
+          console.warn(`[ESAD] Warning: Late ENOENT ignored for ${cmd}.`);
+          return;
+        }
+        finalize(reject, err);
+      });
 
-      console.error(`[ESAD] Process Error: ${err.code} - ${err.message}`);
-      finalize(reject, new Error(`Failed to start ${cmd}: ${err.message}`));
+      childRef.on('close', code => {
+        if (code !== 0) {
+          finalize(reject, new Error(`Process ${cmd} exited with code ${code}`));
+        } else {
+          finalize(resolve);
+        }
+      });
     });
 
-    child.on('close', code => {
-      if (code !== 0) {
-        finalize(reject, new Error(`Process ${cmd} exited with code ${code}`));
-      } else {
-        finalize(resolve);
-      }
-    });
-  });
-};
+    promise.child = childRef;
+    promise.kill = (signal) => childRef && childRef.kill(signal);
+
+    return promise;
+  };
 
 module.exports = { runProcess };

package/src/cli/utils/scaffold.js

@@ -75,8 +75,25 @@ async function prepareNative(cwd, platform = 'android') {
     if (!content.includes('project.ext.react')) {
       const patch = `\nproject.ext.react = [\n    bundleCommand: "repack-bundle",\n    bundleConfig: "rspack.config.mjs"\n]\n\n`;
       content = content.replace(/react \{/, `${patch}react {`);
+      
+      // Force androidx.core version to avoid SDK 36 requirement conflict
+      if (!content.includes('androidx.core:core:')) {
+        const forcePatch = `\nconfigurations.all {\n    resolutionStrategy {\n        force 'androidx.core:core:1.15.0'\n        force 'androidx.core:core-ktx:1.15.0'\n    }\n}\n\n`;
+        content = forcePatch + content;
+      }
+
       await fs.writeFile(buildGradlePath, content);
-      console.log(`✅ Patched android/app/build.gradle for Re.Pack.`);
+      console.log(`✅ Patched android/app/build.gradle for Re.Pack and AndroidX versions.`);
+    }
+
+    const gradlePropsPath = path.join(cwd, 'android', 'gradle.properties');
+    if (fs.existsSync(gradlePropsPath)) {
+      let props = await fs.readFile(gradlePropsPath, 'utf8');
+      if (!props.includes('newArchEnabled=true')) {
+        props += '\nnewArchEnabled=true\n';
+        await fs.writeFile(gradlePropsPath, props);
+        console.log(`✅ Enabled New Architecture in android/gradle.properties.`);
+      }
     }
   }
 

package/src/cli/utils/transformer.js

@@ -10,20 +10,19 @@ const updateDevMode = (configPath, moduleId, url) => {
 
   // 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`);
+    // Inject devMode after the opening brace of export default
+    content = content.replace(/(export default\s*\{)/, `$1\n  devMode: {},\n`);
   }
 
   // 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}'`);
+    // Update existing entry
+    content = content.replace(entryRegex, `'${moduleId}': '${url}'`);
   } else {
-    // Insert new entry into devMode object
-    const devModeRegex = /(devMode:\s*{)/;
-    content = content.replace(devModeRegex, `$1\n    '${moduleId}': '${url}',`);
+    // Insert new entry right after devMode: {
+    content = content.replace(/(devMode:\s*\{)/, `$1\n    '${moduleId}': '${url}',`);
   }
 
   fs.writeFileSync(configPath, content);
@@ -44,20 +43,21 @@ 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, '');
+  // Simply reset devMode to empty object
+  const devModeBlockRegex = /devMode:\s*{[\s\S]*?}/;
+  content = content.replace(devModeBlockRegex, 'devMode: {}');
 
   fs.writeFileSync(configPath, content);
 };
 
+const { createJiti } = require('jiti');
+
 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);
+  const jiti = createJiti(__filename);
+  let configContent = jiti(configObj.path);
   if (configContent.default) configContent = configContent.default;
 
   const exportData = {

package/src/plugin/index.js

@@ -59,18 +59,17 @@ function withESAD(env, options) {
             {
               test: /\.[cm]?[jt]sx?$/,
               include: [
-                /node_modules[\\/](react-native|@react-native|expo|expo-modules-core|@expo|react-navigation|@react-navigation|@unimodules|unimodules|native-base)/,
+                /node_modules[\\/](react-native|@react-native|expo|expo-modules-core|@expo|react-navigation|@react-navigation|@unimodules|unimodules|native-base|react-native-screens|react-native-reanimated)/,
               ],
               type: 'javascript/auto',
               resolve: { fullySpecified: false },
               use: {
-                loader: 'babel-loader',
+                loader: '@callstack/repack/babel-swc-loader',
                 options: {
+                  babelrc: false,
+                  configFile: false,
                   presets: [
-                    [
-                      'babel-preset-expo',
-                      { native: { disableImportExportTransform: false } },
-                    ],
+                    'babel-preset-expo',
                   ],
                   sourceType: 'unambiguous',
                   caller: { name: 'repack' },
@@ -80,11 +79,13 @@ function withESAD(env, options) {
             {
               test: /\.[cm]?[jt]sx?$/,
               include: [dirname],
+              exclude: [/node_modules/],
               type: 'javascript/auto',
               use: {
-                loader: 'babel-loader',
+                loader: '@callstack/repack/babel-swc-loader',
                 options: {
-                  presets: ['babel-preset-expo'],
+                  // Allow project-level babel.config.js to be applied
+                  babelrc: true,
                   sourceType: 'unambiguous',
                   caller: { name: 'repack' },
                 },

package/src/cli/commands/host.js

@@ -1,152 +0,0 @@
-const { runProcess } = require('../utils/process');
-const path = require('path');
-const fs = require('fs-extra');
-const { spawn } = require('cross-spawn');
-const http = require('http');
-const readline = require('readline');
-const { getWorkspaceConfig } = require('../utils/config');
-const { prepareNative } = require('../utils/scaffold');
-
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout
-});
-
-const askQuestion = (query) => new Promise((resolve) => rl.question(query, resolve));
-
-/**
- * Check if a port is in use
- */
-const isPortInUse = (port) => new Promise((resolve) => {
-  const req = http.get(`http://localhost:${port}`, (res) => {
-    resolve(true); // Responded, so it's in use
-  });
-  req.on('error', () => {
-    resolve(false); // Refused, so it's free
-  });
-  req.end();
-});
-
-module.exports = async (subcommand) => {
-  let cwd = process.cwd();
-  let pkgPath = path.join(cwd, 'package.json');
-  
-  // Try to find workspace config to resolve host path from root
-  const configObj = getWorkspaceConfig();
-  if (configObj) {
-    const workspaceRoot = path.dirname(configObj.path);
-    const { projectName } = configObj.data;
-    const hostDir = path.join(workspaceRoot, `${projectName}-host`);
-    
-    if (fs.existsSync(hostDir)) {
-      cwd = hostDir;
-      pkgPath = path.join(cwd, 'package.json');
-      console.log(`📂 Auto-detected Host App folder: ${path.relative(process.cwd(), hostDir)}`);
-    }
-  }
-
-  if (!fs.existsSync(pkgPath)) {
-    console.error(`❌ Error: Call this command from inside the Host App or the Workspace Root.`);
-    return;
-  }
-
-  const pkg = fs.readJsonSync(pkgPath);
-
-  // 1. Initial Checks & Automated Native Preparation
-  if (subcommand === 'dev' || subcommand === 'start') {
-    await prepareNative(cwd, 'all');
-
-    // 3. Platform Selection
-    console.log(`\nESAD Host Dev Manager`);
-    console.log(`---------------------`);
-    console.log(`[a] Run on Android`);
-    console.log(`[i] Run on iOS`);
-    console.log(`[b] Bundler Only`);
-    console.log(`[c] Cancel`);
-    
-    const choice = (await askQuestion(`\nSelect platform: `)).toLowerCase();
-    
-    if (choice === 'c') {
-      console.log(`\n❌ Cancelled.`);
-      rl.close();
-      return;
-    }
-
-    // 4. Check for Port 8081
-    const portBusy = await isPortInUse(8081);
-    let shouldStartBundler = true;
-
-    if (portBusy) {
-      console.log(`\n⚠️  Warning: Port 8081 is already in use by another process.`);
-      console.log(`💡 Skipping Bundler startup - assuming it's already running. Proceeding with Native Build only.\n`);
-      shouldStartBundler = false;
-    }
-
-    // 4. Start Bundler in a New Window (if needed)
-    if (shouldStartBundler && choice !== 'c') {
-      console.log(`\n🛠️ Starting Rspack Bundler in a new window...`);
-      if (process.platform === 'win32') {
-        const npxCmd = 'npx.cmd';
-        spawn('cmd', ['/c', 'start', '/D', cwd, npxCmd, 'react-native', 'webpack-start'], { 
-          detached: true, 
-          stdio: 'ignore',
-          shell: true 
-        }).unref();
-      } else {
-        spawn('npx', ['react-native', 'webpack-start'], { 
-          cwd, 
-          detached: true, 
-          stdio: 'inherit', 
-          shell: true 
-        }).unref();
-      }
-
-      // 5. Wait for Bundler (Port 8081)
-      console.log(`⏳ Waiting for Rspack Bundler to initialize on port 8081...`);
-      const waitForBundler = async () => {
-        for (let i = 0; i < 30; i++) {
-          if (await isPortInUse(8081)) return true;
-          await new Promise(r => setTimeout(r, 2000));
-        }
-        return false;
-      };
-
-      const isReady = await waitForBundler();
-      if (!isReady) {
-        console.error(`\n❌ Timeout: Bundler did not respond after 60 seconds.`);
-        rl.close();
-        return;
-      }
-      console.log(`✅ Bundler stable and ready to use!`);
-    }
-
-    // 6. Launch Native App
-    if (choice === 'a') {
-      console.log(`🤖 Compiling and launching on Android...`);
-      await runProcess('react-native', ['run-android', '--no-packager'], cwd);
-    } else if (choice === 'i') {
-      console.log(`🍎 Compiling and launching on iOS...`);
-      await runProcess('react-native', ['run-ios', '--no-packager'], cwd);
-    } else if (choice === 'b') {
-      if (portBusy) {
-        console.log(`✨ Bundler is already active. You can launch manual native runs.`);
-      } else {
-        console.log(`✨ Bundler is running. You can open the app manually.`);
-      }
-    }
-
-    rl.close();
-  } else {
-    // Other subcommands (android, ios directly)
-    try {
-      if (subcommand === 'android') {
-        await runProcess('react-native', ['run-android', '--no-packager'], cwd);
-      } else if (subcommand === 'ios') {
-        await runProcess('react-native', ['run-ios', '--no-packager'], cwd);
-      }
-    } catch (err) {
-      console.error(`❌ Error running host command: ${err.message}`);
-    }
-    rl.close();
-  }
-};