erosolar-cli 2.1.285 → 2.1.287

package/dist/core/unifiedOrchestrator.js

@@ -15,7 +15,7 @@
  * - Analysis: Code quality, performance, patterns
  * - Git: Status, commits, branches, diffs
  */
-import { execSync, spawn } from 'child_process';
+import { spawn } from 'child_process';
 import { EventEmitter } from 'node:events';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -96,15 +96,16 @@ export class UnifiedOrchestrator extends EventEmitter {
     /**
      * Execute a shell command with Claude Code-style event emission.
      * Events are emitted in the tool lifecycle pattern:
-     * - tool:start -> tool:progress (optional) -> tool:complete/tool:error
+     * - tool:start -> tool:progress (streamed) -> tool:complete/tool:error
+     *
+     * Streaming keeps the UI responsive instead of blocking on execSync.
      */
-    exec(command, timeout = 60000) {
+    async exec(command, timeout = 60000) {
         const start = Date.now();
         this.commandIndex++;
         const toolId = `exec-${this.commandIndex}-${Date.now()}`;
         const toolName = this.inferToolName(command);
         const description = this.describeCommand(command);
-        // Emit Claude Code-style tool:start event
         this.emitOrchestratorEvent('tool:start', {
             toolId,
             toolName,
@@ -112,63 +113,84 @@ export class UnifiedOrchestrator extends EventEmitter {
             index: this.commandIndex,
             args: { command },
         });
-        // Legacy event for backward compatibility
         this.emitOrchestratorEvent('command:start', {
             command,
             index: this.commandIndex,
             total: undefined,
         });
-        try {
-            const output = execSync(command, {
+        return await new Promise((resolve) => {
+            let outputBuffer = '';
+            let resolved = false;
+            const complete = (success, exitCode, errorMessage) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                cleanup();
+                const duration = Date.now() - start;
+                const combinedOutput = outputBuffer || (errorMessage ?? '');
+                const result = {
+                    success,
+                    output: combinedOutput,
+                    error: errorMessage,
+                    duration,
+                    command,
+                    exitCode: exitCode ?? undefined,
+                };
+                this.results.push(result);
+                const completeEvent = {
+                    toolId,
+                    toolName,
+                    success,
+                    output: this.truncateOutput(combinedOutput),
+                    duration,
+                    exitCode: exitCode ?? undefined,
+                };
+                this.emitOrchestratorEvent(success ? 'tool:complete' : 'tool:error', completeEvent);
+                this.emitOrchestratorEvent(success ? 'command:complete' : 'command:error', {
+                    command,
+                    result,
+                    duration,
+                });
+                resolve(result);
+            };
+            const child = spawn(command, {
                 cwd: this.workingDir,
-                encoding: 'utf-8',
-                timeout,
-                maxBuffer: 50 * 1024 * 1024,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            const duration = Date.now() - start;
-            const result = { success: true, output: output || '', duration, command, exitCode: 0 };
-            this.results.push(result);
-            // Emit Claude Code-style tool:complete event
-            this.emitOrchestratorEvent('tool:complete', {
-                toolId,
-                toolName,
-                success: true,
-                output: this.truncateOutput(output || ''),
-                duration,
-                exitCode: 0,
+                shell: true,
+                env: process.env,
             });
-            // Legacy event
-            this.emitOrchestratorEvent('command:complete', {
-                command,
-                result,
-                duration,
-            });
-            return result;
-        }
-        catch (e) {
-            const err = e;
-            const output = (err.stdout || err.stderr || err.message || '');
-            const duration = Date.now() - start;
-            const result = { success: false, output, error: err.message, duration, command, exitCode: err.status };
-            this.results.push(result);
-            // Emit Claude Code-style tool:error event
-            this.emitOrchestratorEvent('tool:error', {
-                toolId,
-                toolName,
-                success: false,
-                output: this.truncateOutput(output),
-                duration,
-                exitCode: err.status,
+            let timer = null;
+            const handleData = (data) => {
+                const text = data.toString();
+                outputBuffer += text;
+                this.emitOrchestratorEvent('tool:progress', {
+                    toolId,
+                    toolName,
+                    output: this.truncateOutput(text, 200),
+                });
+            };
+            child.stdout?.on('data', handleData);
+            child.stderr?.on('data', handleData);
+            const cleanup = () => {
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+                child.stdout?.off('data', handleData);
+                child.stderr?.off('data', handleData);
+            };
+            timer = setTimeout(() => {
+                child.kill('SIGKILL');
+                complete(false, child.exitCode, `Timeout after ${timeout}ms`);
+            }, timeout);
+            child.on('error', (error) => {
+                complete(false, child.exitCode, error.message);
             });
-            // Legacy event
-            this.emitOrchestratorEvent('command:error', {
-                command,
-                result,
-                duration,
+            child.on('close', (code, signal) => {
+                const success = code === 0;
+                const message = success ? undefined : signal ? `Exited with signal ${signal}` : `Exited with code ${code ?? -1}`;
+                complete(success, code, message);
             });
-            return result;
-        }
+        });
     }
     /** Infer a tool name from the command for Claude Code-style display */
     inferToolName(command) {
@@ -258,12 +280,16 @@ export class UnifiedOrchestrator extends EventEmitter {
         return output.slice(0, maxLength - 3) + '...';
     }
     /** Execute multiple commands sequentially */
-    execMany(commands, timeout) {
-        return commands.map(cmd => this.exec(cmd, timeout));
+    async execMany(commands, timeout) {
+        const results = [];
+        for (const cmd of commands) {
+            results.push(await this.exec(cmd, timeout));
+        }
+        return results;
     }
     /** Execute multiple commands in parallel */
     async execParallel(commands, timeout) {
-        return Promise.all(commands.map(cmd => Promise.resolve(this.exec(cmd, timeout))));
+        return Promise.all(commands.map(cmd => this.exec(cmd, timeout)));
     }
     /** Start a background process */
     execBackground(command, id) {
@@ -325,13 +351,13 @@ export class UnifiedOrchestrator extends EventEmitter {
         return this.exec('rm -rf node_modules dist .tsbuildinfo .eslintcache coverage 2>&1; echo "Cleaned"', 30000);
     }
     /** Run full CI pipeline */
-    ci() {
-        return [
-            this.lint(),
-            this.typecheck(),
-            this.test(),
-            this.build(),
-        ];
+    async ci() {
+        const results = [];
+        results.push(await this.lint());
+        results.push(await this.typecheck());
+        results.push(await this.test());
+        results.push(await this.build());
+        return results;
     }
     // ==========================================================================
     // SECURITY TOOLS
@@ -527,39 +553,39 @@ export class UnifiedOrchestrator extends EventEmitter {
         ]);
     }
     /** Full offensive assessment */
-    fullOffensive(target) {
+    async fullOffensive(target) {
         const results = [];
-        results.push(...this.enumerate());
-        results.push(...this.networkMap());
-        results.push(...this.privescCheck());
-        results.push(...this.credentialHunt());
-        results.push(...this.persistenceCheck());
+        results.push(...await this.enumerate());
+        results.push(...await this.networkMap());
+        results.push(...await this.privescCheck());
+        results.push(...await this.credentialHunt());
+        results.push(...await this.persistenceCheck());
         if (os.platform() === 'darwin') {
-            results.push(...this.macosOffensive());
+            results.push(...await this.macosOffensive());
         }
         if (target) {
-            results.push(...this.targetRecon(target));
-            results.push(...this.serviceDetect(target));
+            results.push(...await this.targetRecon(target));
+            results.push(...await this.serviceDetect(target));
         }
         return results;
     }
     /** Attack chain execution */
-    attackChain(target, depth = 'medium') {
+    async attackChain(target, depth = 'medium') {
         const results = [];
         // Phase 1: Recon
-        results.push(...this.targetRecon(target));
+        results.push(...await this.targetRecon(target));
         // Phase 2: Enumeration
-        results.push(...this.subdomainEnum(target));
+        results.push(...await this.subdomainEnum(target));
         if (depth !== 'light') {
             // Phase 3: Service detection
-            results.push(...this.serviceDetect(target));
-            results.push(...this.sslAnalyze(target));
+            results.push(...await this.serviceDetect(target));
+            results.push(...await this.sslAnalyze(target));
         }
         if (depth === 'deep') {
             // Phase 4: Deep analysis
-            results.push(...this.webFingerprint(`https://${target}`));
-            results.push(...this.pathEnum(`https://${target}`));
-            results.push(...this.cloudDetect(target));
+            results.push(...await this.webFingerprint(`https://${target}`));
+            results.push(...await this.pathEnum(`https://${target}`));
+            results.push(...await this.cloudDetect(target));
         }
         return results;
     }
@@ -702,10 +728,10 @@ export class UnifiedOrchestrator extends EventEmitter {
         return fs.existsSync(fullPath);
     }
     /** List directory */
-    listDir(dirPath = '.', recursive = false) {
+    async listDir(dirPath = '.', recursive = false) {
         const fullPath = path.isAbsolute(dirPath) ? dirPath : path.join(this.workingDir, dirPath);
         if (recursive) {
-            const result = this.exec(`find "${fullPath}" -type f 2>/dev/null | head -100`);
+            const result = await this.exec(`find "${fullPath}" -type f 2>/dev/null | head -100`);
             return result.output.split('\n').filter(Boolean);
         }
         return fs.readdirSync(fullPath);
@@ -984,63 +1010,63 @@ export class UnifiedOrchestrator extends EventEmitter {
         this.setPhase('executing');
         // Analyze objective and execute appropriate tools
         if (this.matchesIntent(objective, ['build', 'compile', 'typescript', 'tsc'])) {
-            this.typecheck();
-            this.build();
+            await this.typecheck();
+            await this.build();
         }
         if (this.matchesIntent(objective, ['test', 'spec', 'jest', 'mocha'])) {
-            this.test();
+            await this.test();
         }
         if (this.matchesIntent(objective, ['lint', 'eslint', 'format', 'prettier'])) {
-            this.lint();
-            this.format(true);
+            await this.lint();
+            await this.format(true);
         }
         if (this.matchesIntent(objective, ['security', 'audit', 'vulnerab', 'scan'])) {
-            this.securityAudit();
-            this.vulnerabilityScan();
+            await this.securityAudit();
+            await this.vulnerabilityScan();
         }
         if (this.matchesIntent(objective, ['attack', 'offensive', 'pentest', 'red team', 'recon'])) {
             if (target) {
-                this.targetRecon(target);
-                this.serviceDetect(target);
-                this.sslAnalyze(target);
+                await this.targetRecon(target);
+                await this.serviceDetect(target);
+                await this.sslAnalyze(target);
             }
-            this.enumerate();
-            this.credentialHunt();
-            this.persistenceCheck();
+            await this.enumerate();
+            await this.credentialHunt();
+            await this.persistenceCheck();
         }
         if (this.matchesIntent(objective, ['defense', 'blue team', 'harden', 'protect'])) {
-            this.defenseCheck();
-            this.securityAudit();
-            this.persistenceCheck();
+            await this.defenseCheck();
+            await this.securityAudit();
+            await this.persistenceCheck();
         }
         if (this.matchesIntent(objective, ['investigate', 'forensic', 'analyze'])) {
-            this.investigateFiles();
-            this.investigateProcesses();
-            this.investigateNetwork();
+            await this.investigateFiles();
+            await this.investigateProcesses();
+            await this.investigateNetwork();
         }
         if (this.matchesIntent(objective, ['bug', 'fix', 'error', 'issue', 'problem'])) {
-            this.typecheck();
-            this.lint();
-            this.analyzeQuality();
-            this.findDeadCode();
+            await this.typecheck();
+            await this.lint();
+            await this.analyzeQuality();
+            await this.findDeadCode();
         }
         if (this.matchesIntent(objective, ['ci', 'pipeline', 'full', 'complete', 'all'])) {
-            this.ci();
-            this.securityAudit();
-            this.analyzeQuality();
+            await this.ci();
+            await this.securityAudit();
+            await this.analyzeQuality();
         }
         if (this.matchesIntent(objective, ['git', 'status', 'commit', 'branch'])) {
-            this.gitStatus();
-            this.gitLog(10);
-            this.gitDiff();
+            await this.gitStatus();
+            await this.gitLog(10);
+            await this.gitDiff();
         }
         if (this.matchesIntent(objective, ['clean', 'remove', 'delete', 'clear'])) {
-            this.clean();
+            await this.clean();
         }
         if (this.matchesIntent(objective, ['health', 'check', 'status'])) {
-            this.gitStatus();
-            this.typecheck();
-            this.deps('audit');
+            await this.gitStatus();
+            await this.typecheck();
+            await this.deps('audit');
         }
         // Phase: Reporting - Analyze results and generate report
         this.setPhase('reporting');
@@ -1097,10 +1123,10 @@ export class UnifiedOrchestrator extends EventEmitter {
     // ==========================================================================
     // STATIC METHODS
     // ==========================================================================
-    static run(command, workingDir) {
+    static async run(command, workingDir) {
         return new UnifiedOrchestrator(workingDir).exec(command);
     }
-    static runMany(commands, workingDir) {
+    static async runMany(commands, workingDir) {
         return new UnifiedOrchestrator(workingDir).execMany(commands);
     }
 }
@@ -1153,80 +1179,80 @@ export const containerEnum = (dir) => new UnifiedOrchestrator(dir).containerEnum
 export const fullOffensive = (target, dir) => new UnifiedOrchestrator(dir).fullOffensive(target);
 export const attackChain = (target, depth, dir) => new UnifiedOrchestrator(dir).attackChain(target, depth);
 // Composite Operations - Full Pipelines
-export const fullEngineering = (dir) => {
+export const fullEngineering = async (dir) => {
     const o = new UnifiedOrchestrator(dir);
-    o.exec('npm run clean 2>&1 || true');
-    o.deps('install');
-    o.ci();
-    o.analyzeQuality();
+    await o.exec('npm run clean 2>&1 || true');
+    await o.deps('install');
+    await o.ci();
+    await o.analyzeQuality();
     for (const r of o.getResults())
         o.analyze(r.output, 'engineering');
     return o.generateReport('Full Engineering');
 };
-export const fullSecurity = (dir) => {
+export const fullSecurity = async (dir) => {
     const o = new UnifiedOrchestrator(dir);
-    o.securityAudit();
-    o.vulnerabilityScan();
-    o.defenseCheck();
-    o.persistenceCheck();
+    await o.securityAudit();
+    await o.vulnerabilityScan();
+    await o.defenseCheck();
+    await o.persistenceCheck();
     for (const r of o.getResults())
         o.analyze(r.output, 'security');
     return o.generateReport('Full Security');
 };
-export const fullDefensive = (dir) => {
+export const fullDefensive = async (dir) => {
     const o = new UnifiedOrchestrator(dir);
-    o.defenseCheck();
-    o.persistenceCheck();
-    o.securityAudit();
+    await o.defenseCheck();
+    await o.persistenceCheck();
+    await o.securityAudit();
     for (const r of o.getResults())
         o.analyze(r.output, 'defensive');
     return o.generateReport('Full Defensive');
 };
-export const fullInvestigation = (dir) => {
+export const fullInvestigation = async (dir) => {
     const o = new UnifiedOrchestrator(dir);
-    o.investigateFiles();
-    o.investigateProcesses();
-    o.investigateNetwork();
-    o.investigateBrowser();
-    o.investigateEmail();
-    o.investigateIMessage();
+    await o.investigateFiles();
+    await o.investigateProcesses();
+    await o.investigateNetwork();
+    await o.investigateBrowser();
+    await o.investigateEmail();
+    await o.investigateIMessage();
     for (const r of o.getResults())
         o.analyze(r.output, 'investigation');
     return o.generateReport('Full Investigation');
 };
-export const redTeam = (target, dir) => {
+export const redTeam = async (target, dir) => {
     const o = new UnifiedOrchestrator(dir);
     if (target)
-        o.targetRecon(target);
-    o.enumerate();
-    o.vulnerabilityScan();
-    o.persistenceCheck();
-    o.credentialHunt();
-    o.networkMap();
+        await o.targetRecon(target);
+    await o.enumerate();
+    await o.vulnerabilityScan();
+    await o.persistenceCheck();
+    await o.credentialHunt();
+    await o.networkMap();
     if (os.platform() === 'darwin')
-        o.macosOffensive();
+        await o.macosOffensive();
     for (const r of o.getResults())
         o.analyze(r.output, 'redteam');
     return o.generateReport('Red Team Operation');
 };
-export const blueTeam = (dir) => {
+export const blueTeam = async (dir) => {
     const o = new UnifiedOrchestrator(dir);
-    o.defenseCheck();
-    o.securityAudit();
-    o.persistenceCheck();
-    o.investigateProcesses();
-    o.investigateNetwork();
+    await o.defenseCheck();
+    await o.securityAudit();
+    await o.persistenceCheck();
+    await o.investigateProcesses();
+    await o.investigateNetwork();
     for (const r of o.getResults())
         o.analyze(r.output, 'blueteam');
     return o.generateReport('Blue Team Operation');
 };
-export const intelligence = (target, dir) => {
+export const intelligence = async (target, dir) => {
     const o = new UnifiedOrchestrator(dir);
-    o.recon(target);
+    await o.recon(target);
     if (target)
-        o.targetRecon(target);
-    o.enumerate();
-    o.investigateNetwork();
+        await o.targetRecon(target);
+    await o.enumerate();
+    await o.investigateNetwork();
     for (const r of o.getResults())
         o.analyze(r.output, 'intelligence');
     return o.generateReport('Intelligence Collection');