@codemoreira/esad 1.4.6-8 → 1.4.6

package/src/cli/commands/deploy.js

@@ -1,118 +1,112 @@
-const fs = require('fs-extra');
-const path = require('path');
-const AdmZip = require('adm-zip');
-const chalk = require('chalk');
-const { getWorkspaceConfig, syncHostConfig } = require('../utils/config');
-const { resolveModuleMetadata, listAvailableModules } = require('../utils/resolution');
-const { prepareNative } = require('../utils/scaffold');
-
-module.exports = async (options) => {
-  let cwd = process.cwd();
-  let pkgPath = path.join(cwd, 'package.json');
-  
-  // Enforce Workspace Root
-  const configObj = getWorkspaceConfig();
-  if (!configObj) {
-    console.error(chalk.red(`❌ Error: Call this command from the project root (esad.config.json not found).`));
-    process.exit(1);
-  }
-
-  const workspaceRoot = path.dirname(configObj.path);
-  const { projectName } = configObj.data;
-  
-  syncHostConfig(configObj);
-  
-  let moduleId = options.id;
-  
-  if (moduleId) {
-    const meta = resolveModuleMetadata(moduleId, configObj);
-    if (!meta) {
-      console.error(chalk.red(`\n❌ Error: Module not found: ${moduleId}`));
-      listAvailableModules(configObj);
-      process.exit(1);
-    }
-    cwd = meta.path;
-    moduleId = meta.id; // Correct fully qualified ID
-    pkgPath = path.join(cwd, 'package.json');
-    console.log(`📂 Module detected for Deploy: ${path.basename(cwd)}`);
-  } else {
-    // Target host by default if in root
-    const hostDir = path.join(workspaceRoot, `${projectName}-host`);
-    if (fs.existsSync(hostDir)) {
-      cwd = hostDir;
-      pkgPath = path.join(cwd, 'package.json');
-      console.log(chalk.green(`📂 Host detected for Deploy: ${path.basename(cwd)}`));
-    }
-  }
-
-  if (!fs.existsSync(pkgPath)) {
-    console.error(chalk.red(`❌ Error: package.json not found in ${cwd}.`));
-    process.exit(1);
-  }
-
-  const pkg = fs.readJsonSync(pkgPath);
-  moduleId = moduleId || pkg.name;
-  const version = options.version || pkg.version;
-  const entry = options.entry || 'index.bundle';
-
-  // Ensure Native Folders are present (useful for consistency)
-  await prepareNative(cwd, 'all');
-
-  console.log(`\n☁️  Starting ESAD Deploy for ${moduleId} (v${version})\n`);
-  
-  const config = configObj ? configObj.data : null;
-  if (!config?.deployEndpoint) {
-    console.error(`❌ Error: 'deployEndpoint' not configured in esad.config.json.`);
-    process.exit(1);
-  }
-  
-  const deployUrl = config.deployEndpoint.replace('{{moduleId}}', moduleId);
-  console.log(`📡 Deployment Endpoint Resolved: ${deployUrl}`);
-  
-  const distPath = path.join(cwd, 'build');
-  if (!fs.existsSync(distPath)) {
-    console.error(`❌ Error: build/ directory not found in ${cwd}. Did you run the build command?`);
-    process.exit(1);
-  }
-
-  const zip = new AdmZip();
-  zip.addLocalFolder(distPath);
-  
-  const zipPath = path.join(cwd, `bundle-${moduleId}-${version}.zip`);
-  zip.writeZip(zipPath);
-  console.log(`🗜️  Zipped output to ${zipPath}`);
-
-  console.log(`🚀 Uploading to CDN via multipart POST...`);
-  
-  try {
-    const FormData = require('form-data'); // Standard in Node versions, or use native if available
-    const form = new FormData();
-    form.append('version', version);
-    form.append('bundle', fs.createReadStream(zipPath));
-
-    const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
-    
-    // Simple CDN expects POST /api/admin/assets/:id/versions
-    const uploadUrl = deployUrl.includes('/versions') ? deployUrl : `${deployUrl}/versions`;
-
-    const response = await fetch(uploadUrl, {
-      method: 'POST',
-      body: form,
-      headers: form.getHeaders(),
-    });
-
-    if (response.ok) {
-      const result = await response.json();
-      console.log(chalk.green(`✅ Successfully uploaded ${moduleId} v${version} to CDN!`));
-      console.log(`📄 Active Version is now: ${result.active_version}`);
-    } else {
-      const errorText = await response.text();
-      console.error(chalk.red(`❌ Failed to upload: ${response.status} ${response.statusText}`));
-      console.error(errorText);
-    }
-  } catch (err) {
-    console.error(chalk.red(`❌ Error during upload: ${err.message}`));
-  } finally {
-    fs.unlinkSync(zipPath);
-  }
-};
+const fs = require('fs-extra');
+const path = require('path');
+const AdmZip = require('adm-zip');
+const chalk = require('chalk');
+const { getWorkspaceConfig } = require('../utils/config');
+const { resolveModuleMetadata, listAvailableModules } = require('../utils/resolution');
+
+module.exports = async (options) => {
+  let cwd = process.cwd();
+  let pkgPath = path.join(cwd, 'package.json');
+  
+  // Enforce Workspace Root
+  const configObj = getWorkspaceConfig();
+  if (!configObj) {
+    console.error(chalk.red(`❌ Error: Call this command from the project root (esad.config.json not found).`));
+    process.exit(1);
+  }
+
+  const workspaceRoot = path.dirname(configObj.path);
+  const { projectName } = configObj.data;
+  
+  let moduleId = options.id;
+  
+  if (moduleId) {
+    const meta = resolveModuleMetadata(moduleId, configObj);
+    if (!meta) {
+      console.error(chalk.red(`\n❌ Error: Module not found: ${moduleId}`));
+      listAvailableModules(configObj);
+      process.exit(1);
+    }
+    cwd = meta.path;
+    moduleId = meta.id; // Correct fully qualified ID
+    pkgPath = path.join(cwd, 'package.json');
+    console.log(`📂 Module detected for Deploy: ${path.basename(cwd)}`);
+  } else {
+    // Target host by default if in root
+    const hostDir = path.join(workspaceRoot, `${projectName}-host`);
+    if (fs.existsSync(hostDir)) {
+      cwd = hostDir;
+      pkgPath = path.join(cwd, 'package.json');
+      console.log(chalk.green(`📂 Host detected for Deploy: ${path.basename(cwd)}`));
+    }
+  }
+
+  if (!fs.existsSync(pkgPath)) {
+    console.error(chalk.red(`❌ Error: package.json not found in ${cwd}.`));
+    process.exit(1);
+  }
+
+  const pkg = fs.readJsonSync(pkgPath);
+  moduleId = moduleId || pkg.name;
+  const version = options.version || pkg.version;
+  const entry = options.entry || 'index.bundle';
+
+  console.log(`\n☁️  Starting ESAD Deploy for ${moduleId} (v${version})\n`);
+  
+  const config = configObj ? configObj.data : null;
+  if (!config?.deployEndpoint) {
+    console.error(`❌ Error: 'deployEndpoint' not configured in esad.config.json.`);
+    process.exit(1);
+  }
+  
+  const deployUrl = config.deployEndpoint.replace('{{moduleId}}', moduleId);
+  console.log(`📡 Deployment Endpoint Resolved: ${deployUrl}`);
+  
+  const distPath = path.join(cwd, 'build');
+  if (!fs.existsSync(distPath)) {
+    console.error(`❌ Error: build/ directory not found in ${cwd}. Did you run the build command?`);
+    process.exit(1);
+  }
+
+  const zip = new AdmZip();
+  zip.addLocalFolder(distPath);
+  
+  const zipPath = path.join(cwd, `bundle-${moduleId}-${version}.zip`);
+  zip.writeZip(zipPath);
+  console.log(`🗜️  Zipped output to ${zipPath}`);
+
+  console.log(`🚀 Uploading to CDN via multipart POST...`);
+  
+  try {
+    const FormData = require('form-data'); // Standard in Node versions, or use native if available
+    const form = new FormData();
+    form.append('version', version);
+    form.append('bundle', fs.createReadStream(zipPath));
+
+    const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
+    
+    // Simple CDN expects POST /api/admin/assets/:id/versions
+    const uploadUrl = deployUrl.includes('/versions') ? deployUrl : `${deployUrl}/versions`;
+
+    const response = await fetch(uploadUrl, {
+      method: 'POST',
+      body: form,
+      headers: form.getHeaders(),
+    });
+
+    if (response.ok) {
+      const result = await response.json();
+      console.log(chalk.green(`✅ Successfully uploaded ${moduleId} v${version} to CDN!`));
+      console.log(`📄 Active Version is now: ${result.active_version}`);
+    } else {
+      const errorText = await response.text();
+      console.error(chalk.red(`❌ Failed to upload: ${response.status} ${response.statusText}`));
+      console.error(errorText);
+    }
+  } catch (err) {
+    console.error(chalk.red(`❌ Error during upload: ${err.message}`));
+  } finally {
+    fs.unlinkSync(zipPath);
+  }
+};

package/src/cli/commands/dev.js

@@ -1,12 +1,10 @@
 const { spawn } = require('cross-spawn');
-const { getWorkspaceConfig, syncHostConfig } = require('../utils/config');
+const { getWorkspaceConfig } = require('../utils/config');
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
-const { resolveModuleMetadata, listAvailableModules, resolveProjectDir } = require('../utils/resolution');
-const { runProcess } = require('../utils/process');
 const { prepareNative } = require('../utils/scaffold');
-const AdmZip = require('adm-zip');
+const { resolveProjectDir, listAvailableModules } = require('../utils/resolution');
 
 module.exports = async (options) => {
   let cwd = process.cwd();
@@ -22,109 +20,70 @@ module.exports = async (options) => {
   const workspaceRoot = path.dirname(configObj.path);
   const { projectName } = configObj.data;
   
-  // Synchronize Host Config
-  syncHostConfig(configObj);
-  
   if (options.id) {
-    const metadata = resolveModuleMetadata(options.id, configObj);
-    if (!metadata) {
+    const targetDir = resolveProjectDir(options.id, configObj);
+    if (!targetDir) {
       console.error(chalk.red(`\n❌ Error: Module not found: ${options.id}`));
       listAvailableModules(configObj);
       process.exit(1);
     }
-    cwd = metadata.path;
-    moduleId = metadata.id;
+    cwd = targetDir;
     pkgPath = path.join(cwd, 'package.json');
-    console.log(chalk.green(`📂 Module detected: ${path.relative(workspaceRoot, cwd)} (ID: ${moduleId})`));
+    console.log(chalk.green(`📂 Module detected: ${path.relative(workspaceRoot, cwd)}`));
   } else {
     // Target host by default if in root
     const hostDir = path.join(workspaceRoot, `${projectName}-host`);
     if (fs.existsSync(hostDir)) {
       cwd = hostDir;
-      moduleId = pkg.name; // Fallback to package name if in host
       pkgPath = path.join(cwd, 'package.json');
       console.log(chalk.green(`📂 Host detected: ${path.relative(workspaceRoot, cwd)}`));
     }
   }
 
-  if (!fs.existsSync(pkgPath)) {
-    console.error(chalk.red(`❌ Error: package.json not found in ${cwd}.`));
-    process.exit(1);
-  }
-
   const pkg = fs.readJsonSync(pkgPath);
-  if (!moduleId) moduleId = pkg.name;
-  const platform = options.platform || 'android';
+  const moduleId = options.id || pkg.name;
+  const port = options.port || '8081';
 
-  console.log(chalk.cyan(`\n☁️  Starting ESAD Dev-Push for ${moduleId} (${platform})\n`));
+  // Determine if it's a Host or Module
+  const isHost = pkg.name.endsWith('-host') || pkg.dependencies?.['@callstack/repack'];
   
-  const config = configObj ? configObj.data : null;
-  const devUrlBase = config?.devModeEndpoint || config?.deployEndpoint?.replace('/versions', '');
-  
-  if (!devUrlBase) {
-    console.error(chalk.red(`❌ Error: 'devModeEndpoint' or 'deployEndpoint' not configured in esad.config.json.`));
-    process.exit(1);
-  }
+  // 1. Initial Checks & Automated Native Preparation
+  await prepareNative(cwd, 'all');
 
-  const devUploadUrl = devUrlBase.replace('{{moduleId}}', moduleId) + '/dev';
-  console.log(`📡 Dev-Cloud Endpoint: ${devUploadUrl}`);
-
-  // 0. Prepare Native
-  await prepareNative(cwd, platform);
+  if (isHost && !options.id) {
+     console.log(`\n🚀 Starting Host App Dev Server (Re.Pack/Rspack)...\n`);
+     await spawn('npx', ['react-native', 'webpack-start'], { cwd, stdio: 'inherit', shell: true });
+     return;
+  }
 
-  // 1. Build
-  console.log(`\n🏗️  Step 1/3: Building bundle...`);
-  const bundleOutput = path.join(cwd, 'build', platform, 'index.bundle');
-  await fs.ensureDir(path.dirname(bundleOutput));
+  console.log(`\n⚡ Starting ESAD Dev Server for ${moduleId} on port ${port}...\n`);
   
-  try {
-    await runProcess('npx', [
-      'react-native', 
-      'webpack-bundle', 
-      '--platform', platform, 
-      '--dev', 'false',
-      '--bundle-output', bundleOutput,
-      '--assets-dest', path.dirname(bundleOutput),
-      '--reset-cache'
-    ], cwd);
-  } catch (err) {
-    console.error(chalk.red(`❌ Build failed.`));
-    process.exit(1);
-  }
+  const config = configObj ? configObj.data : null;
+  let devApiUrl = config?.devModeEndpoint ? config.devModeEndpoint.replace('{{moduleId}}', moduleId) : null;
 
-  // 2. Zip
-  console.log(`\n🗜️  Step 2/3: Zipping assets...`);
-  const zip = new AdmZip();
-  const buildDir = path.join(cwd, 'build');
-  zip.addLocalFolder(buildDir);
-  const zipPath = path.join(cwd, `dev-bundle-${moduleId}.zip`);
-  zip.writeZip(zipPath);
+  const setDevMode = async (isActive) => {
+    if (!devApiUrl) return;
+    try {
+      const body = { 
+        is_dev_mode: isActive, 
+        ...(isActive && { dev_url: `http://localhost:${port}/index.bundle` }) 
+      };
+      const res = await fetch(devApiUrl, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
+      if (res.ok) console.log(`📡 Registry Sync: Dev Override is ${isActive ? 'ON' : 'OFF'} for module ${moduleId}`);
+    } catch(e) { /* ignore */ }
+  };
 
-  // 3. Upload
-  console.log(`\n🚀 Step 3/3: Pushing to Dev-Cloud...`);
-  try {
-    const FormData = require('form-data');
-    const form = new FormData();
-    form.append('bundle', fs.createReadStream(zipPath));
+  await setDevMode(true);
 
-    const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
-    const response = await fetch(devUploadUrl, {
-      method: 'POST',
-      body: form,
-      headers: form.getHeaders(),
-    });
+  const proc = spawn('npx', ['react-native', 'webpack-start', '--port', port], { cwd, stdio: 'inherit', shell: true });
 
-    if (response.ok) {
-      console.log(chalk.green(`\n✅ Successfully synced ${moduleId} to Dev-Cloud!`));
-      console.log(`📱 Host app configured with 'devModeFor: ["${options.id || moduleId}"]' will now load this version.\n`);
-    } else {
-      const errorText = await response.text();
-      console.error(chalk.red(`❌ Cloud Sync failed: ${response.status} ${response.statusText}`));
-      console.error(errorText);
-    }
-  } catch (err) {
-    console.error(chalk.red(`❌ Error during sync: ${err.message}`));
-  } finally {
-    if (fs.existsSync(zipPath)) fs.unlinkSync(zipPath);
-  }
+  const shutdown = async () => {
+    console.log(`\n🛑 Stopping ESAD Dev Server and reverting registry status...`);
+    await setDevMode(false);
+    proc.kill();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
 };

package/src/cli/commands/host.js

@@ -7,7 +7,12 @@ const readline = require('readline');
 const { getWorkspaceConfig } = require('../utils/config');
 const { prepareNative } = require('../utils/scaffold');
 
-const askQuestion = (query, rl) => new Promise((resolve) => rl.question(query, resolve));
+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
@@ -23,12 +28,6 @@ const isPortInUse = (port) => new Promise((resolve) => {
 });
 
 module.exports = async (subcommand) => {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  if (!subcommand) subcommand = 'dev';
   let cwd = process.cwd();
   let pkgPath = path.join(cwd, 'package.json');
   
@@ -65,7 +64,7 @@ module.exports = async (subcommand) => {
     console.log(`[b] Bundler Only`);
     console.log(`[c] Cancel`);
     
-    const choice = (await askQuestion(`\nSelect platform: `, rl)).toLowerCase();
+    const choice = (await askQuestion(`\nSelect platform: `)).toLowerCase();
     
     if (choice === 'c') {
       console.log(`\n❌ Cancelled.`);
@@ -87,13 +86,14 @@ module.exports = async (subcommand) => {
     if (shouldStartBundler && choice !== 'c') {
       console.log(`\n🛠️ Starting Rspack Bundler in a new window...`);
       if (process.platform === 'win32') {
-        spawn('cmd', ['/c', 'start', '/D', cwd, 'npx', 'react-native', 'start', '--reset-cache'], { 
+        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', 'start', '--reset-cache'], { 
+        spawn('npx', ['react-native', 'webpack-start'], { 
           cwd, 
           detached: true, 
           stdio: 'inherit', 
@@ -123,10 +123,10 @@ module.exports = async (subcommand) => {
     // 6. Launch Native App
     if (choice === 'a') {
       console.log(`🤖 Compiling and launching on Android...`);
-      await runProcess('npx', ['expo', 'run:android', '--no-bundler'], cwd);
+      await runProcess('react-native', ['run-android', '--no-packager'], cwd);
     } else if (choice === 'i') {
       console.log(`🍎 Compiling and launching on iOS...`);
-      await runProcess('npx', ['expo', 'run:ios', '--no-bundler'], cwd);
+      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.`);
@@ -140,16 +140,13 @@ module.exports = async (subcommand) => {
     // Other subcommands (android, ios directly)
     try {
       if (subcommand === 'android') {
-        console.log(`🤖 Compiling and launching on Android...`);
-        await runProcess('npx', ['expo', 'run:android', '--no-bundler'], cwd);
+        await runProcess('react-native', ['run-android', '--no-packager'], cwd);
       } else if (subcommand === 'ios') {
-        console.log(`🍎 Compiling and launching on iOS...`);
-        await runProcess('npx', ['expo', 'run:ios', '--no-bundler'], cwd);
+        await runProcess('react-native', ['run-ios', '--no-packager'], cwd);
       }
     } catch (err) {
       console.error(`❌ Error running host command: ${err.message}`);
-    } finally {
-      rl.close();
     }
+    rl.close();
   }
 };

package/src/cli/utils/config.js

@@ -1,37 +1,11 @@
-const fs = require('fs-extra');
-const path = require('path');
-
-const getWorkspaceConfig = () => {
-  let cwd = process.cwd();
-  let configPath = path.join(cwd, 'esad.config.json');
-  
-  // Search up to 2 levels (root or project folder)
-  if (!fs.existsSync(configPath)) configPath = path.join(cwd, '..', 'esad.config.json');
-  if (!fs.existsSync(configPath)) configPath = path.join(cwd, '..', '..', 'esad.config.json');
-  
-  if (!fs.existsSync(configPath)) return null;
-  return { path: configPath, data: fs.readJsonSync(configPath) };
-};
-
-const syncHostConfig = (configObj) => {
-  if (!configObj) return;
-  const { projectName } = configObj.data;
-  const workspaceRoot = path.dirname(configObj.path);
-  const hostDir = path.join(workspaceRoot, `${projectName}-host`);
-  
-  if (fs.existsSync(hostDir)) {
-    const hostConfigPath = path.join(hostDir, 'esad.config.json');
-    
-    // Only pass client-safe fields
-    const clientConfig = {
-      projectName: configObj.data.projectName,
-      registryUrl: configObj.data.registryUrl,
-      devModeFor: configObj.data.devModeFor || []
-    };
-    
-    fs.writeJsonSync(hostConfigPath, clientConfig, { spaces: 2 });
-    console.log(`\n🔄 Sync: Config propagated to ${path.relative(workspaceRoot, hostConfigPath)}`);
-  }
-};
-
-module.exports = { getWorkspaceConfig, syncHostConfig };
+const fs = require('fs-extra');
+const path = require('path');
+
+const getWorkspaceConfig = () => {
+  let configPath = path.join(process.cwd(), 'esad.config.json');
+  if (!fs.existsSync(configPath)) configPath = path.join(process.cwd(), '../esad.config.json');
+  if (!fs.existsSync(configPath)) return null;
+  return { path: configPath, data: fs.readJsonSync(configPath) };
+};
+
+module.exports = { getWorkspaceConfig };

package/src/cli/utils/process.js

@@ -1,21 +1,66 @@
-const { spawn } = require('cross-spawn');
-
-/**
- * Helper to spawn commands synchronously
- * @param {string} cmd 
- * @param {string[]} args 
- * @param {string} cwd 
- * @returns {Promise<void>}
- */
-const runProcess = (cmd, args, cwd = process.cwd()) => {
-  const executable = (process.platform === 'win32' && cmd === 'npx') ? 'npx.cmd' : cmd;
-  return new Promise((resolve, reject) => {
-    const child = spawn(executable, args, { stdio: 'inherit', cwd, shell: true });
-    child.on('close', code => {
-      if (code !== 0) reject(new Error(`Command ${cmd} ${args.join(' ')} failed`));
-      else resolve();
-    });
-  });
-};
-
-module.exports = { runProcess };
+const { spawn } = require('cross-spawn');
+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 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;
+
+    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})`);
+
+    // Mark as started after a short delay
+    setTimeout(() => { started = true; }, 2000);
+
+    const spawnFn = useNativeSpawn ? nativeSpawn : spawn;
+    const child = 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;
+      }
+
+      console.error(`[ESAD] Process Error: ${err.code} - ${err.message}`);
+      finalize(reject, new Error(`Failed to start ${cmd}: ${err.message}`));
+    });
+
+    child.on('close', code => {
+      if (code !== 0) {
+        finalize(reject, new Error(`Process ${cmd} exited with code ${code}`));
+      } else {
+        finalize(resolve);
+      }
+    });
+  });
+};
+
+module.exports = { runProcess };