@mcpilotx/intentorch 0.5.0

package/dist/runtime/executable-analyzer.js

@@ -0,0 +1,391 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { logger } from '../core/logger.js';
+export class ExecutableAnalyzer {
+    /**
+     * Analyze executable file type
+     */
+    static analyze(filePath) {
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        const stats = fs.statSync(filePath);
+        if (!stats.isFile()) {
+            return null;
+        }
+        // Check if file is executable
+        if (!this.isExecutable(filePath)) {
+            return null;
+        }
+        // Try different detection methods (by priority)
+        const analyses = [
+            this.analyzeWithFileCommand(filePath),
+            this.analyzeWithMagicNumbers(filePath),
+            this.analyzeShebang(filePath),
+            this.analyzeByPermissions(filePath),
+            this.analyzeByExtension(filePath),
+        ].filter(analysis => analysis !== null);
+        if (analyses.length === 0) {
+            return null;
+        }
+        // Select analysis result with highest confidence
+        const bestAnalysis = analyses.reduce((best, current) => current.confidence > best.confidence ? current : best);
+        logger.debug(`Executable analysis for ${filePath}:`, {
+            type: bestAnalysis.type,
+            confidence: bestAnalysis.confidence,
+            method: bestAnalysis.details.method,
+        });
+        return bestAnalysis;
+    }
+    /**
+     * Use file command to detect file type (highest priority)
+     */
+    static analyzeWithFileCommand(filePath) {
+        try {
+            const output = execSync(`file -b "${filePath}"`, { encoding: 'utf-8' }).trim();
+            let type = 'binary';
+            let confidence = 0.8;
+            let details = '';
+            if (output.includes('ELF')) {
+                type = 'binary';
+                confidence = 0.9;
+                details = 'ELF executable';
+            }
+            else if (output.includes('Mach-O')) {
+                type = 'binary';
+                confidence = 0.9;
+                details = 'Mach-O executable';
+            }
+            else if (output.includes('PE32+') || output.includes('PE32')) {
+                type = 'binary';
+                confidence = 0.9;
+                details = 'Windows PE executable';
+            }
+            else if (output.includes('Node.js')) {
+                type = 'node';
+                confidence = 0.95;
+                details = 'Node.js script';
+            }
+            else if (output.includes('Python')) {
+                type = 'python';
+                confidence = 0.95;
+                details = 'Python script';
+            }
+            else if (output.includes('Bourne-Again shell script')) {
+                type = 'binary';
+                confidence = 0.85;
+                details = 'Bash script';
+            }
+            else if (output.includes('POSIX shell script')) {
+                type = 'binary';
+                confidence = 0.85;
+                details = 'Shell script';
+            }
+            else {
+                // Unrecognized type
+                return null;
+            }
+            return {
+                type,
+                confidence,
+                details: {
+                    method: 'fileCommand',
+                    result: details,
+                    rawOutput: output,
+                },
+            };
+        }
+        catch (error) {
+            // file command unavailable or failed
+            return null;
+        }
+    }
+    /**
+     * Detect file type via magic numbers
+     */
+    static analyzeWithMagicNumbers(filePath) {
+        try {
+            const buffer = fs.readFileSync(filePath, { flag: 'r' });
+            // Only read first few bytes for magic number detection
+            const header = buffer.slice(0, 16);
+            const hex = header.toString('hex');
+            // ELF file: 7f 45 4c 46
+            if (hex.startsWith('7f454c46')) {
+                return {
+                    type: 'binary',
+                    confidence: 0.85,
+                    details: {
+                        method: 'magicNumber',
+                        result: 'ELF executable',
+                        rawOutput: hex.substring(0, 8),
+                    },
+                };
+            }
+            // Mach-O (64-bit): cf fa ed fe
+            // Mach-O (32-bit): ce fa ed fe
+            if (hex.startsWith('cffaedfe') || hex.startsWith('cefaedfe')) {
+                return {
+                    type: 'binary',
+                    confidence: 0.85,
+                    details: {
+                        method: 'magicNumber',
+                        result: 'Mach-O executable',
+                        rawOutput: hex.substring(0, 8),
+                    },
+                };
+            }
+            // PE file: 4d 5a (MZ)
+            if (hex.startsWith('4d5a')) {
+                return {
+                    type: 'binary',
+                    confidence: 0.85,
+                    details: {
+                        method: 'magicNumber',
+                        result: 'Windows PE executable',
+                        rawOutput: hex.substring(0, 4),
+                    },
+                };
+            }
+            // Java class file: ca fe ba be
+            if (hex.startsWith('cafebabe')) {
+                return {
+                    type: 'java',
+                    confidence: 0.9,
+                    details: {
+                        method: 'magicNumber',
+                        result: 'Java class file',
+                        rawOutput: hex.substring(0, 8),
+                    },
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Analyze Shebang line
+     */
+    static analyzeShebang(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const firstLine = content.split('\n')[0].trim();
+            if (!firstLine.startsWith('#!')) {
+                return null;
+            }
+            const shebang = firstLine.substring(2).toLowerCase();
+            let type = 'binary';
+            let confidence = 0.8;
+            if (shebang.includes('node') || shebang.includes('bun')) {
+                type = 'node';
+                confidence = 0.9;
+            }
+            else if (shebang.includes('python')) {
+                type = 'python';
+                confidence = 0.9;
+            }
+            else if (shebang.includes('bash') || shebang.includes('sh')) {
+                type = 'binary';
+                confidence = 0.85;
+            }
+            else if (shebang.includes('perl')) {
+                type = 'binary';
+                confidence = 0.8;
+            }
+            else if (shebang.includes('ruby')) {
+                type = 'binary';
+                confidence = 0.8;
+            }
+            else {
+                // Unknown interpreter
+                type = 'binary';
+                confidence = 0.7;
+            }
+            return {
+                type,
+                confidence,
+                details: {
+                    method: 'shebang',
+                    result: shebang,
+                    rawOutput: firstLine,
+                },
+            };
+        }
+        catch (error) {
+            // File may not be a text file
+            return null;
+        }
+    }
+    /**
+     * Detect by file permissions
+     */
+    static analyzeByPermissions(filePath) {
+        try {
+            const stats = fs.statSync(filePath);
+            const mode = stats.mode;
+            const isExecutable = (mode & 0o111) !== 0;
+            if (isExecutable) {
+                return {
+                    type: 'binary',
+                    confidence: 0.6,
+                    details: {
+                        method: 'permissions',
+                        result: 'Executable file',
+                        rawOutput: `mode: 0o${mode.toString(8)}`,
+                    },
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Detect by file extension (last resort)
+     */
+    static analyzeByExtension(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const extensionMap = {
+            '.exe': { type: 'binary', confidence: 0.7 },
+            '.bin': { type: 'binary', confidence: 0.7 },
+            '.app': { type: 'binary', confidence: 0.7 },
+            '.out': { type: 'binary', confidence: 0.6 },
+            '.js': { type: 'node', confidence: 0.5 },
+            '.ts': { type: 'node', confidence: 0.5 },
+            '.py': { type: 'python', confidence: 0.5 },
+            '.go': { type: 'go', confidence: 0.5 },
+            '.rs': { type: 'rust', confidence: 0.5 },
+            '.java': { type: 'java', confidence: 0.5 },
+            '.class': { type: 'java', confidence: 0.6 },
+            '.jar': { type: 'java', confidence: 0.6 },
+        };
+        const mapping = extensionMap[ext];
+        if (mapping) {
+            return {
+                type: mapping.type,
+                confidence: mapping.confidence,
+                details: {
+                    method: 'extension',
+                    result: `File extension: ${ext}`,
+                    rawOutput: ext,
+                },
+            };
+        }
+        return null;
+    }
+    /**
+     * Check if file is executable
+     */
+    static isExecutable(filePath) {
+        try {
+            const stats = fs.statSync(filePath);
+            // Check Unix execution permissions
+            if (process.platform !== 'win32') {
+                const mode = stats.mode;
+                const isExecutable = (mode & 0o111) !== 0;
+                if (isExecutable) {
+                    return true;
+                }
+            }
+            // Check file extensions (Windows)
+            if (process.platform === 'win32') {
+                const ext = path.extname(filePath).toLowerCase();
+                const executableExtensions = ['.exe', '.bat', '.cmd', '.ps1', '.com'];
+                if (executableExtensions.includes(ext)) {
+                    return true;
+                }
+            }
+            // Check shebang (script files)
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                if (content.startsWith('#!')) {
+                    return true;
+                }
+            }
+            catch {
+                // File may not be a text file
+            }
+            return false;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Find executable files in directory
+     */
+    static findExecutables(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            return [];
+        }
+        try {
+            const files = fs.readdirSync(dirPath);
+            const executables = [];
+            for (const file of files) {
+                const filePath = path.join(dirPath, file);
+                try {
+                    const stats = fs.statSync(filePath);
+                    if (!stats.isFile()) {
+                        continue;
+                    }
+                    if (this.isExecutable(filePath)) {
+                        executables.push(filePath);
+                    }
+                }
+                catch (error) {
+                    // Ignore inaccessible files
+                    continue;
+                }
+            }
+            return executables;
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    /**
+     * Get the most likely executable file in directory
+     */
+    static getPrimaryExecutable(dirPath) {
+        const executables = this.findExecutables(dirPath);
+        if (executables.length === 0) {
+            return null;
+        }
+        // Prefer files without extensions (Unix convention)
+        const noExtension = executables.filter(p => path.extname(p) === '');
+        if (noExtension.length > 0) {
+            return noExtension[0];
+        }
+        // Then choose common executable extensions
+        const commonExtensions = ['.exe', '.bin', '.app', '.out'];
+        for (const ext of commonExtensions) {
+            const withExt = executables.filter(p => path.extname(p).toLowerCase() === ext);
+            if (withExt.length > 0) {
+                return withExt[0];
+            }
+        }
+        // Return first executable file
+        return executables[0];
+    }
+    /**
+     * Batch analyze executable files in directory
+     */
+    static analyzeDirectory(dirPath) {
+        const executables = this.findExecutables(dirPath);
+        const results = [];
+        for (const executable of executables) {
+            const analysis = this.analyze(executable);
+            if (analysis) {
+                results.push({
+                    file: path.relative(dirPath, executable),
+                    analysis,
+                });
+            }
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=executable-analyzer.js.map

package/dist/runtime/go-adapter.d.ts

@@ -0,0 +1,19 @@
+import { RuntimeAdapter } from './adapter';
+import { ServiceConfig } from '../core/types';
+import { type ChildProcess } from 'child_process';
+export declare class GoAdapter implements RuntimeAdapter {
+    private process;
+    getSpawnArgs(config: ServiceConfig): {
+        command: string;
+        args: string[];
+    };
+    setup(config: ServiceConfig): Promise<void>;
+    private findGoBinary;
+    private isExecutable;
+    startService(config: ServiceConfig): Promise<ChildProcess>;
+    stopService(): Promise<void>;
+    getServiceStatus(): Promise<string>;
+    compile(config: ServiceConfig): Promise<boolean>;
+    test(config: ServiceConfig): Promise<boolean>;
+}
+//# sourceMappingURL=go-adapter.d.ts.map

package/dist/runtime/go-adapter.js

@@ -0,0 +1,190 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+export class GoAdapter {
+    process = null;
+    getSpawnArgs(config) {
+        const goPath = this.findGoBinary(config);
+        return {
+            command: goPath,
+            args: ['run', config.entry, ...(config.args || [])],
+        };
+    }
+    async setup(config) {
+        console.log(`[Go] Setting up service: ${config.name}`);
+        // Check if Go is installed
+        try {
+            const { execSync } = require('child_process');
+            execSync('go version', { stdio: 'ignore' });
+            console.log('[Go] Go is installed');
+        }
+        catch (error) {
+            throw new Error('Go is not installed or not in PATH. Please install Go from https://golang.org/dl/');
+        }
+        const servicePath = config.path || '.';
+        // Check go.mod file
+        const goModPath = path.join(servicePath, 'go.mod');
+        if (!fs.existsSync(goModPath)) {
+            console.log(`[Go] go.mod not found, creating basic go.mod for ${config.name}`);
+            try {
+                const { execSync } = require('child_process');
+                execSync(`go mod init ${config.name}`, {
+                    stdio: 'inherit',
+                    cwd: servicePath,
+                });
+            }
+            catch (error) {
+                console.warn(`[Go] Failed to create go.mod: ${error.message}`);
+            }
+        }
+        // Download dependencies
+        console.log('[Go] Downloading dependencies...');
+        try {
+            const { execSync } = require('child_process');
+            execSync('go mod tidy', {
+                stdio: 'inherit',
+                cwd: servicePath,
+            });
+            console.log('[Go] Dependencies downloaded successfully');
+        }
+        catch (error) {
+            console.warn(`[Go] Failed to download dependencies: ${error.message}`);
+        }
+        // Build executable (optional)
+        if (config.build) {
+            console.log('[Go] Building executable...');
+            try {
+                const { execSync } = require('child_process');
+                const outputName = config.output || config.name;
+                execSync(`go build -o ${outputName} ${config.entry}`, {
+                    stdio: 'inherit',
+                    cwd: servicePath,
+                });
+                console.log(`[Go] Executable built: ${outputName}`);
+            }
+            catch (error) {
+                console.warn(`[Go] Failed to build executable: ${error.message}`);
+            }
+        }
+        console.log(`[Go] Setup completed for service: ${config.name}`);
+    }
+    findGoBinary(config) {
+        // First check if there is a pre-built executable file
+        if (config.binary) {
+            const binaryPath = path.join(config.path || '.', config.binary);
+            if (fs.existsSync(binaryPath)) {
+                return binaryPath;
+            }
+        }
+        // Check if there is a build output
+        const possibleOutputs = [
+            config.name,
+            `./${config.name}`,
+            path.join(config.path || '.', config.name),
+            path.join(config.path || '.', 'main'),
+        ];
+        for (const output of possibleOutputs) {
+            if (fs.existsSync(output) && this.isExecutable(output)) {
+                return output;
+            }
+        }
+        // Default to using go run
+        return 'go';
+    }
+    isExecutable(filePath) {
+        try {
+            fs.accessSync(filePath, fs.constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async startService(config) {
+        const { command, args } = this.getSpawnArgs(config);
+        console.log(`[Go] Starting service: ${config.name}`);
+        console.log(`[Go] Command: ${command} ${args.join(' ')}`);
+        const childProcess = spawn(command, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: false,
+            env: {
+                ...process.env,
+                ...config.env,
+            },
+            cwd: config.path || '.',
+        });
+        childProcess.stdout?.on('data', (data) => {
+            console.log(`[Go:${config.name}] ${data.toString().trim()}`);
+        });
+        childProcess.stderr?.on('data', (data) => {
+            console.error(`[Go:${config.name}] ERR: ${data.toString().trim()}`);
+        });
+        childProcess.on('error', (error) => {
+            console.error(`[Go:${config.name}] Failed to start: ${error.message}`);
+        });
+        childProcess.on('exit', (code, signal) => {
+            console.log(`[Go:${config.name}] Process exited with code ${code}, signal ${signal}`);
+            this.process = null;
+        });
+        this.process = childProcess;
+        return childProcess;
+    }
+    async stopService() {
+        if (this.process) {
+            console.log('[Go] Stopping service');
+            this.process.kill();
+            this.process = null;
+        }
+    }
+    async getServiceStatus() {
+        if (!this.process) {
+            return 'stopped';
+        }
+        // Check if the process is still running
+        if (this.process.exitCode !== null) {
+            return 'exited';
+        }
+        try {
+            // Send signal 0 to check if the process exists
+            this.process.kill(0);
+            return 'running';
+        }
+        catch (error) {
+            return 'stopped';
+        }
+    }
+    async compile(config) {
+        console.log(`[Go] Compiling service: ${config.name}`);
+        try {
+            const { execSync } = require('child_process');
+            const outputName = config.output || config.name;
+            execSync(`go build -o ${outputName} ${config.entry}`, {
+                stdio: 'inherit',
+                cwd: config.path || '.',
+            });
+            console.log(`[Go] Successfully compiled: ${outputName}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`[Go] Compilation failed: ${error.message}`);
+            return false;
+        }
+    }
+    async test(config) {
+        console.log(`[Go] Running tests for service: ${config.name}`);
+        try {
+            const { execSync } = require('child_process');
+            execSync('go test ./...', {
+                stdio: 'inherit',
+                cwd: config.path || '.',
+            });
+            console.log('[Go] Tests passed');
+            return true;
+        }
+        catch (error) {
+            console.error(`[Go] Tests failed: ${error.message}`);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=go-adapter.js.map

package/dist/runtime/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Runtime Module Exports
+ * Provides unified interface for runtime functionality
+ */
+export { RuntimeAdapter } from './adapter';
+export { RuntimeDetector } from './detector';
+export { EnhancedRuntimeDetector } from './detector-advanced';
+export { ExecutableAnalyzer } from './executable-analyzer';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.js

@@ -0,0 +1,10 @@
+/**
+ * Runtime Module Exports
+ * Provides unified interface for runtime functionality
+ */
+// Export detectors
+export { RuntimeDetector } from './detector.js';
+export { EnhancedRuntimeDetector } from './detector-advanced.js';
+// Export executable analyzer
+export { ExecutableAnalyzer } from './executable-analyzer.js';
+//# sourceMappingURL=index.js.map

package/dist/runtime/node-adapter.d.ts

@@ -0,0 +1,10 @@
+import { RuntimeAdapter } from './adapter';
+import { ServiceConfig } from '../core/types';
+export declare class NodeAdapter implements RuntimeAdapter {
+    getSpawnArgs(config: ServiceConfig): {
+        command: string;
+        args: string[];
+    };
+    setup(config: ServiceConfig): Promise<void>;
+}
+//# sourceMappingURL=node-adapter.d.ts.map

package/dist/runtime/node-adapter.js

@@ -0,0 +1,23 @@
+import { execSync } from 'child_process';
+export class NodeAdapter {
+    getSpawnArgs(config) {
+        // Auto-detect runtime: try bun first, fallback to node
+        let command = 'bun';
+        try {
+            execSync('which bun', { stdio: 'ignore' });
+            command = 'bun';
+        }
+        catch {
+            command = 'node';
+        }
+        const args = command === 'bun' ? [config.entry, ...(config.args || [])] : [config.entry, ...(config.args || [])];
+        return {
+            command,
+            args,
+        };
+    }
+    async setup(config) {
+        // No special setup needed for Node/Bun
+    }
+}
+//# sourceMappingURL=node-adapter.js.map

package/dist/runtime/node.d.ts

@@ -0,0 +1,20 @@
+export interface AdapterOptions {
+    name: string;
+    cwd: string;
+    env?: Record<string, string>;
+    args?: string[];
+    runtime?: 'bun' | 'node';
+}
+export declare class NodeAdapter {
+    private options;
+    private process;
+    private requestId;
+    private pendingRequests;
+    private runtime;
+    constructor(options: AdapterOptions);
+    start(): Promise<void>;
+    call(method: string, params?: any): Promise<any>;
+    stop(): void;
+    isRunning(): boolean;
+}
+//# sourceMappingURL=node.d.ts.map