@mcpilotx/intentorch 0.5.0

package/dist/runtime/docker-adapter.js

@@ -0,0 +1,170 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+export class DockerAdapter {
+    process = null;
+    containerName;
+    constructor() {
+        this.containerName = '';
+    }
+    getSpawnArgs(config) {
+        // Docker adapter doesn't use traditional spawn, but starts containers
+        this.containerName = `mcp-${config.name}-${Date.now()}`;
+        const args = ['run', '-d', '--rm', '--name', this.containerName];
+        // Add environment variables
+        if (config.env) {
+            Object.entries(config.env).forEach(([key, value]) => {
+                args.push('-e', `${key}=${value}`);
+            });
+        }
+        // Add port mappings
+        if (config.ports) {
+            config.ports.forEach(port => {
+                args.push('-p', `${port}:${port}`);
+            });
+        }
+        // Add volume mappings
+        if (config.volumes) {
+            config.volumes.forEach(volume => {
+                args.push('-v', volume);
+            });
+        }
+        // Add working directory
+        if (config.workdir) {
+            args.push('-w', config.workdir);
+        }
+        // Add image and command
+        args.push(config.image || config.name);
+        if (config.args && config.args.length > 0) {
+            args.push(...config.args);
+        }
+        return {
+            command: 'docker',
+            args: args,
+        };
+    }
+    async setup(config) {
+        console.log(`[Docker] Setting up service: ${config.name}`);
+        // Check if Docker is installed
+        try {
+            const { execSync } = require('child_process');
+            execSync('docker --version', { stdio: 'ignore' });
+        }
+        catch (error) {
+            throw new Error('Docker is not installed or not in PATH');
+        }
+        // Check if image exists, pull if not
+        if (config.image) {
+            try {
+                const { execSync } = require('child_process');
+                execSync(`docker image inspect ${config.image}`, { stdio: 'ignore' });
+                console.log(`[Docker] Image ${config.image} already exists`);
+            }
+            catch (error) {
+                console.log(`[Docker] Pulling image: ${config.image}`);
+                try {
+                    const { execSync } = require('child_process');
+                    execSync(`docker pull ${config.image}`, { stdio: 'inherit' });
+                }
+                catch (pullError) {
+                    throw new Error(`Failed to pull Docker image ${config.image}: ${pullError.message}`);
+                }
+            }
+        }
+        // If Dockerfile exists, build image
+        if (config.dockerfile) {
+            const dockerfilePath = path.join(config.path || '.', config.dockerfile);
+            if (fs.existsSync(dockerfilePath)) {
+                console.log(`[Docker] Building image from ${dockerfilePath}`);
+                try {
+                    const { execSync } = require('child_process');
+                    const buildContext = config.buildContext || path.dirname(dockerfilePath);
+                    execSync(`docker build -t ${config.name} -f ${dockerfilePath} ${buildContext}`, {
+                        stdio: 'inherit',
+                        cwd: config.path || '.',
+                    });
+                }
+                catch (buildError) {
+                    throw new Error(`Failed to build Docker image: ${buildError.message}`);
+                }
+            }
+        }
+        console.log(`[Docker] Setup completed for service: ${config.name}`);
+    }
+    async startContainer(config) {
+        const { command, args } = this.getSpawnArgs(config);
+        console.log(`[Docker] Starting container: ${this.containerName}`);
+        console.log(`[Docker] Command: ${command} ${args.join(' ')}`);
+        const process = spawn(command, args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: false,
+        });
+        process.stdout?.on('data', (data) => {
+            console.log(`[Docker:${config.name}] ${data.toString().trim()}`);
+        });
+        process.stderr?.on('data', (data) => {
+            console.error(`[Docker:${config.name}] ERR: ${data.toString().trim()}`);
+        });
+        process.on('error', (error) => {
+            console.error(`[Docker:${config.name}] Failed to start: ${error.message}`);
+        });
+        process.on('exit', (code, signal) => {
+            console.log(`[Docker:${config.name}] Container exited with code ${code}, signal ${signal}`);
+            this.process = null;
+        });
+        this.process = process;
+        return process;
+    }
+    async stopContainer() {
+        if (this.process) {
+            console.log(`[Docker] Stopping container: ${this.containerName}`);
+            try {
+                const { execSync } = require('child_process');
+                execSync(`docker stop ${this.containerName}`, { stdio: 'ignore' });
+            }
+            catch (error) {
+                // Container may already be stopped
+            }
+            this.process.kill();
+            this.process = null;
+        }
+    }
+    async getContainerStatus() {
+        if (!this.containerName) {
+            return 'not_created';
+        }
+        try {
+            const { execSync } = require('child_process');
+            const output = execSync(`docker ps -a --filter "name=${this.containerName}" --format "{{.Status}}"`, {
+                encoding: 'utf-8',
+            }).trim();
+            if (output.includes('Up')) {
+                return 'running';
+            }
+            else if (output.includes('Exited')) {
+                return 'stopped';
+            }
+            else {
+                return 'not_found';
+            }
+        }
+        catch (error) {
+            return 'error';
+        }
+    }
+    async getContainerLogs(tail = 50) {
+        if (!this.containerName) {
+            return 'Container not created';
+        }
+        try {
+            const { execSync } = require('child_process');
+            return execSync(`docker logs --tail ${tail} ${this.containerName}`, {
+                encoding: 'utf-8',
+            });
+        }
+        catch (error) {
+            return `Failed to get logs: ${error.message}`;
+        }
+    }
+}
+//# sourceMappingURL=docker-adapter.js.map

package/dist/runtime/docker.d.ts

@@ -0,0 +1,17 @@
+export interface AdapterOptions {
+    name: string;
+    image: string;
+    env?: Record<string, string>;
+}
+export declare class DockerAdapter {
+    private options;
+    private process;
+    private requestId;
+    private pendingRequests;
+    constructor(options: AdapterOptions);
+    start(): Promise<void>;
+    call(method: string, params?: any): Promise<any>;
+    stop(): void;
+    isRunning(): boolean;
+}
+//# sourceMappingURL=docker.d.ts.map

package/dist/runtime/docker.js

@@ -0,0 +1,71 @@
+import { spawn } from 'child_process';
+export class DockerAdapter {
+    options;
+    process = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            console.log(`[RAL] Starting Docker service: ${this.options.name} (${this.options.image})`);
+            // Core command: docker run -i (interactive mode) --rm (remove after running)
+            // Map container stdio to host process
+            const args = ['run', '-i', '--rm', '--name', `mcp-${this.options.name}`];
+            // Inject environment variables
+            if (this.options.env) {
+                Object.entries(this.options.env).forEach(([k, v]) => {
+                    args.push('-e', `${k}=${v}`);
+                });
+            }
+            args.push(this.options.image);
+            this.process = spawn('docker', args, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.process.stdout?.on('data', (data) => {
+                const raw = data.toString().trim();
+                try {
+                    const json = JSON.parse(raw);
+                    if (json.id !== undefined && this.pendingRequests.has(json.id)) {
+                        const resolver = this.pendingRequests.get(json.id);
+                        resolver?.(json);
+                        this.pendingRequests.delete(json.id);
+                    }
+                }
+                catch (e) {
+                    console.log(`[Docker:${this.options.name}] ${raw}`);
+                }
+            });
+            this.process.stderr?.on('data', (data) => {
+                console.error(`[Docker:${this.options.name}] ERR: ${data.toString()}`);
+            });
+            // Listen for successful startup
+            this.process.on('spawn', () => resolve());
+            this.process.on('error', (err) => reject(new Error(`Docker start failed: ${err.message}`)));
+        });
+    }
+    async call(method, params = {}) {
+        if (!this.process) {
+            throw new Error(`Docker service ${this.options.name} is not running.`);
+        }
+        const id = ++this.requestId;
+        const request = { jsonrpc: '2.0', id, method, params };
+        return new Promise((resolve) => {
+            this.pendingRequests.set(id, resolve);
+            this.process?.stdin?.write(JSON.stringify(request) + '\n');
+        });
+    }
+    stop() {
+        if (this.process) {
+            // Force stop container
+            spawn('docker', ['stop', `mcp-${this.options.name}`]);
+            this.process.kill();
+            this.process = null;
+        }
+    }
+    isRunning() {
+        return this.process !== null;
+    }
+}
+//# sourceMappingURL=docker.js.map

package/dist/runtime/executable-analyzer.d.ts

@@ -0,0 +1,56 @@
+import { RuntimeType } from '../core/types';
+export interface ExecutableAnalysis {
+    type: RuntimeType;
+    confidence: number;
+    details: {
+        method: 'fileCommand' | 'magicNumber' | 'shebang' | 'permissions' | 'extension';
+        result: string;
+        rawOutput?: string;
+    };
+}
+export declare class ExecutableAnalyzer {
+    /**
+     * Analyze executable file type
+     */
+    static analyze(filePath: string): ExecutableAnalysis | null;
+    /**
+     * Use file command to detect file type (highest priority)
+     */
+    private static analyzeWithFileCommand;
+    /**
+     * Detect file type via magic numbers
+     */
+    private static analyzeWithMagicNumbers;
+    /**
+     * Analyze Shebang line
+     */
+    private static analyzeShebang;
+    /**
+     * Detect by file permissions
+     */
+    private static analyzeByPermissions;
+    /**
+     * Detect by file extension (last resort)
+     */
+    private static analyzeByExtension;
+    /**
+     * Check if file is executable
+     */
+    private static isExecutable;
+    /**
+     * Find executable files in directory
+     */
+    static findExecutables(dirPath: string): string[];
+    /**
+     * Get the most likely executable file in directory
+     */
+    static getPrimaryExecutable(dirPath: string): string | null;
+    /**
+     * Batch analyze executable files in directory
+     */
+    static analyzeDirectory(dirPath: string): Array<{
+        file: string;
+        analysis: ExecutableAnalysis;
+    }>;
+}
+//# sourceMappingURL=executable-analyzer.d.ts.map