@mcpilotx/intentorch 0.5.0

package/dist/runtime/node.js

@@ -0,0 +1,86 @@
+import { spawn, execSync } from 'child_process';
+export class NodeAdapter {
+    options;
+    process = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    runtime = 'bun';
+    constructor(options) {
+        this.options = options;
+        // Determine which runtime to use
+        if (options.runtime) {
+            this.runtime = options.runtime;
+        }
+        else {
+            // Auto-detect: try bun first, fallback to node
+            try {
+                execSync('which bun', { stdio: 'ignore' });
+                // Further verify that bun is executable
+                execSync('bun --version', { stdio: 'ignore' });
+                this.runtime = 'bun';
+            }
+            catch {
+                this.runtime = 'node';
+            }
+        }
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            console.log(`[RAL] Starting Node.js service: ${this.options.name} (using ${this.runtime})`);
+            const command = this.runtime === 'bun' ? 'bun' : 'node';
+            const args = this.runtime === 'bun' ? ['run', 'index.js'] : ['index.js'];
+            this.process = spawn(command, args, {
+                cwd: this.options.cwd,
+                env: { ...process.env, ...this.options.env },
+                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) {
+                    // Ignore non-JSON output (such as regular logs)
+                    console.log(`[${this.options.name}] ${raw}`);
+                }
+            });
+            this.process.stderr?.on('data', (data) => {
+                console.error(`[${this.options.name}] ERR: ${data.toString()}`);
+            });
+            this.process.on('spawn', () => resolve());
+            this.process.on('error', (err) => reject(err));
+        });
+    }
+    // Send MCP JSON-RPC request
+    async call(method, params = {}) {
+        if (!this.process) {
+            throw new Error(`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) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+    isRunning() {
+        return this.process !== null;
+    }
+}
+//# sourceMappingURL=node.js.map

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

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

package/dist/runtime/python-adapter.js

@@ -0,0 +1,102 @@
+import { VENVS_DIR } from '../core/constants.js';
+import * as path from 'path';
+import * as fs from 'fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../core/logger.js';
+const execAsync = promisify(exec);
+export class PythonAdapter {
+    getSpawnArgs(config) {
+        const venvPath = path.join(VENVS_DIR, config.name);
+        const pythonPath = path.join(venvPath, 'bin', 'python');
+        return {
+            command: pythonPath,
+            args: [config.entry, ...(config.args || [])],
+        };
+    }
+    async setup(config) {
+        const venvPath = path.join(VENVS_DIR, config.name);
+        try {
+            // Ensure virtual environment directory exists
+            if (!fs.existsSync(VENVS_DIR)) {
+                fs.mkdirSync(VENVS_DIR, { recursive: true });
+                logger.info(`Created virtual environments directory: ${VENVS_DIR}`);
+            }
+            // Check if virtual environment already exists
+            const venvExists = fs.existsSync(venvPath) &&
+                fs.existsSync(path.join(venvPath, 'bin', 'python'));
+            if (!venvExists) {
+                logger.info(`Creating Python virtual environment for ${config.name} at ${venvPath}`);
+                // Create virtual environment
+                const { stdout, stderr } = await execAsync(`python3 -m venv "${venvPath}"`);
+                if (stderr && !stderr.includes('created virtual environment')) {
+                    logger.warn(`Virtual environment creation warnings: ${stderr}`);
+                }
+                logger.info(`Virtual environment created successfully for ${config.name}`);
+            }
+            else {
+                logger.info(`Using existing virtual environment for ${config.name} at ${venvPath}`);
+            }
+            // Install dependencies (if requirements are configured)
+            const pythonConfig = config.runtimeConfig?.python;
+            if (pythonConfig?.dependencies) {
+                await this.installDependencies(config, venvPath);
+            }
+            logger.info(`Python setup completed for ${config.name}`);
+        }
+        catch (error) {
+            logger.error(`Failed to setup Python environment for ${config.name}: ${error.message}`, {
+                stack: error.stack,
+            });
+            throw new Error(`Python environment setup failed: ${error.message}`);
+        }
+    }
+    async installDependencies(config, venvPath) {
+        const pythonPath = path.join(venvPath, 'bin', 'python');
+        const pipPath = path.join(venvPath, 'bin', 'pip');
+        try {
+            // Check if pip is available
+            await execAsync(`${pipPath} --version`);
+            const pythonConfig = config.runtimeConfig?.python;
+            const deps = pythonConfig?.dependencies;
+            if (Array.isArray(deps) && deps.length > 0) {
+                logger.info(`Installing Python dependencies for ${config.name}: ${deps.join(', ')}`);
+                // Install each dependency
+                for (const dep of deps) {
+                    try {
+                        const { stdout, stderr } = await execAsync(`${pipPath} install "${dep}"`);
+                        logger.info(`Installed dependency: ${dep}`);
+                        if (stderr && stderr.includes('WARNING')) {
+                            logger.warn(`Installation warnings for ${dep}: ${stderr}`);
+                        }
+                    }
+                    catch (depError) {
+                        logger.error(`Failed to install dependency ${dep}: ${depError.message}`);
+                        // Continue installing other dependencies
+                    }
+                }
+                logger.info(`All dependencies installed for ${config.name}`);
+            }
+            else if (typeof deps === 'string' && deps.trim().endsWith('.txt')) {
+                // Handle requirements.txt file
+                const requirementsPath = path.isAbsolute(deps) ? deps : path.join(process.cwd(), deps);
+                if (fs.existsSync(requirementsPath)) {
+                    logger.info(`Installing dependencies from requirements file: ${requirementsPath}`);
+                    const { stdout, stderr } = await execAsync(`${pipPath} install -r "${requirementsPath}"`);
+                    if (stderr && stderr.includes('WARNING')) {
+                        logger.warn(`Requirements installation warnings: ${stderr}`);
+                    }
+                    logger.info(`Dependencies installed from requirements file for ${config.name}`);
+                }
+                else {
+                    logger.warn(`Requirements file not found: ${requirementsPath}`);
+                }
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to install dependencies for ${config.name}: ${error.message}`);
+            throw new Error(`Dependency installation failed: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=python-adapter.js.map

package/dist/runtime/python.d.ts

@@ -0,0 +1,17 @@
+export interface AdapterOptions {
+    name: string;
+    cwd: string;
+    env?: Record<string, string>;
+}
+export declare class PythonAdapter {
+    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=python.d.ts.map

package/dist/runtime/python.js

@@ -0,0 +1,72 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+export class PythonAdapter {
+    options;
+    process = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            console.log(`[RAL] Starting Python service: ${this.options.name}`);
+            // Automatically find python interpreter in virtual environment
+            const venvPath = path.join(this.options.cwd, 'venv', 'bin', 'python');
+            const pythonPath = fs.existsSync(venvPath) ? venvPath : 'python3';
+            // Start command, usually MCP Python services are started via main.py or -m module
+            // Here we assume entry is main.py (will be read from configuration later)
+            this.process = spawn(pythonPath, ['main.py'], {
+                cwd: this.options.cwd,
+                env: { ...process.env, ...this.options.env },
+                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(`[Python:${this.options.name}] ${raw}`);
+                }
+            });
+            this.process.stderr?.on('data', (data) => {
+                console.error(`[Python:${this.options.name}] ERR: ${data.toString()}`);
+            });
+            this.process.on('spawn', () => resolve());
+            this.process.on('error', (err) => reject(err));
+        });
+    }
+    async call(method, params = {}) {
+        if (!this.process) {
+            throw new Error(`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) {
+            this.process.kill();
+            this.process = null;
+        }
+    }
+    isRunning() {
+        return this.process !== null;
+    }
+}
+//# sourceMappingURL=python.js.map

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

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

package/dist/runtime/rust-adapter.js

@@ -0,0 +1,267 @@
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+export class RustAdapter {
+    process = null;
+    getSpawnArgs(config) {
+        const rustBinary = this.findRustBinary(config);
+        return {
+            command: rustBinary,
+            args: [...(config.args || [])],
+        };
+    }
+    async setup(config) {
+        console.log(`[Rust] Setting up service: ${config.name}`);
+        // Check if Rust is installed
+        try {
+            const { execSync } = require('child_process');
+            execSync('cargo --version', { stdio: 'ignore' });
+            console.log('[Rust] Cargo is installed');
+        }
+        catch (error) {
+            throw new Error('Rust/Cargo is not installed or not in PATH. Please install Rust from https://rustup.rs/');
+        }
+        const servicePath = config.path || '.';
+        // Check Cargo.toml file
+        const cargoTomlPath = path.join(servicePath, 'Cargo.toml');
+        if (!fs.existsSync(cargoTomlPath)) {
+            console.log('[Rust] Cargo.toml not found, checking if this is a binary crate');
+            // Check if this is a single Rust file
+            if (config.entry && config.entry.endsWith('.rs')) {
+                console.log(`[Rust] Single Rust file detected: ${config.entry}`);
+                // For a single Rust file, we can compile directly using rustc
+            }
+            else {
+                console.log(`[Rust] Creating basic Cargo.toml for ${config.name}`);
+                try {
+                    const { execSync } = require('child_process');
+                    execSync(`cargo init --name ${config.name} --bin`, {
+                        stdio: 'inherit',
+                        cwd: servicePath,
+                    });
+                }
+                catch (error) {
+                    console.warn(`[Rust] Failed to create Cargo.toml: ${error.message}`);
+                }
+            }
+        }
+        // Build project
+        console.log('[Rust] Building project...');
+        try {
+            const { execSync } = require('child_process');
+            const rustConfig = config.runtimeConfig?.rust;
+            if (rustConfig?.release) {
+                execSync('cargo build --release', {
+                    stdio: 'inherit',
+                    cwd: servicePath,
+                });
+                console.log('[Rust] Release build completed');
+            }
+            else {
+                execSync('cargo build', {
+                    stdio: 'inherit',
+                    cwd: servicePath,
+                });
+                console.log('[Rust] Debug build completed');
+            }
+        }
+        catch (error) {
+            console.warn(`[Rust] Build failed: ${error.message}`);
+            // Continue, might just be a warning
+        }
+        // Run tests (optional)
+        const rustConfig = config.runtimeConfig?.rust;
+        if (rustConfig?.test) {
+            console.log('[Rust] Running tests...');
+            try {
+                const { execSync } = require('child_process');
+                execSync('cargo test', {
+                    stdio: 'inherit',
+                    cwd: servicePath,
+                });
+                console.log('[Rust] Tests passed');
+            }
+            catch (error) {
+                console.warn(`[Rust] Tests failed: ${error.message}`);
+            }
+        }
+        console.log(`[Rust] Setup completed for service: ${config.name}`);
+    }
+    findRustBinary(config) {
+        const servicePath = config.path || '.';
+        const rustConfig = config.runtimeConfig?.rust;
+        // First check if there is a pre-built executable file
+        if (rustConfig?.binary) {
+            const binaryPath = path.join(servicePath, rustConfig.binary);
+            if (fs.existsSync(binaryPath)) {
+                return binaryPath;
+            }
+        }
+        // Check for executable files in the target directory
+        const buildType = rustConfig?.release ? 'release' : 'debug';
+        const possiblePaths = [
+            path.join(servicePath, 'target', buildType, config.name),
+            path.join(servicePath, 'target', buildType, 'main'),
+            path.join(servicePath, config.name),
+            `./${config.name}`,
+        ];
+        for (const binaryPath of possiblePaths) {
+            if (fs.existsSync(binaryPath) && this.isExecutable(binaryPath)) {
+                return binaryPath;
+            }
+        }
+        // If it's a single Rust file, compile and run using rustc
+        if (config.entry && config.entry.endsWith('.rs')) {
+            const outputName = rustConfig?.output || config.name;
+            const outputPath = path.join(servicePath, outputName);
+            console.log(`[Rust] Compiling single file: ${config.entry}`);
+            try {
+                const { execSync } = require('child_process');
+                execSync(`rustc ${config.entry} -o ${outputPath}`, {
+                    stdio: 'inherit',
+                    cwd: servicePath,
+                });
+                if (fs.existsSync(outputPath)) {
+                    return outputPath;
+                }
+            }
+            catch (error) {
+                console.warn(`[Rust] Failed to compile single file: ${error.message}`);
+            }
+        }
+        // Finally try using cargo run
+        return 'cargo';
+    }
+    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(`[Rust] Starting service: ${config.name}`);
+        console.log(`[Rust] Command: ${command} ${args.join(' ')}`);
+        const finalArgs = command === 'cargo' ? ['run', '--', ...args] : args;
+        const finalCommand = command === 'cargo' ? 'cargo' : command;
+        const childProcess = spawn(finalCommand, finalArgs, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: false,
+            env: {
+                ...process.env,
+                ...config.env,
+                RUST_BACKTRACE: config.runtimeConfig?.rust?.debug ? 'full' : '0',
+            },
+            cwd: config.path || '.',
+        });
+        childProcess.stdout?.on('data', (data) => {
+            console.log(`[Rust:${config.name}] ${data.toString().trim()}`);
+        });
+        childProcess.stderr?.on('data', (data) => {
+            console.error(`[Rust:${config.name}] ERR: ${data.toString().trim()}`);
+        });
+        childProcess.on('error', (error) => {
+            console.error(`[Rust:${config.name}] Failed to start: ${error.message}`);
+        });
+        childProcess.on('exit', (code, signal) => {
+            console.log(`[Rust:${config.name}] Process exited with code ${code}, signal ${signal}`);
+            this.process = null;
+        });
+        this.process = childProcess;
+        return childProcess;
+    }
+    async stopService() {
+        if (this.process) {
+            console.log('[Rust] 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(`[Rust] Compiling service: ${config.name}`);
+        try {
+            const { execSync } = require('child_process');
+            const rustConfig = config.runtimeConfig?.rust;
+            const buildArgs = rustConfig?.release ? ['build', '--release'] : ['build'];
+            execSync(`cargo ${buildArgs.join(' ')}`, {
+                stdio: 'inherit',
+                cwd: config.path || '.',
+            });
+            console.log('[Rust] Successfully compiled');
+            return true;
+        }
+        catch (error) {
+            console.error(`[Rust] Compilation failed: ${error.message}`);
+            return false;
+        }
+    }
+    async test(config) {
+        console.log(`[Rust] Running tests for service: ${config.name}`);
+        try {
+            const { execSync } = require('child_process');
+            execSync('cargo test', {
+                stdio: 'inherit',
+                cwd: config.path || '.',
+            });
+            console.log('[Rust] Tests passed');
+            return true;
+        }
+        catch (error) {
+            console.error(`[Rust] Tests failed: ${error.message}`);
+            return false;
+        }
+    }
+    async check(config) {
+        console.log(`[Rust] Running cargo check for service: ${config.name}`);
+        try {
+            const { execSync } = require('child_process');
+            execSync('cargo check', {
+                stdio: 'inherit',
+                cwd: config.path || '.',
+            });
+            console.log('[Rust] Check passed');
+            return true;
+        }
+        catch (error) {
+            console.error(`[Rust] Check failed: ${error.message}`);
+            return false;
+        }
+    }
+    async clippy(config) {
+        console.log(`[Rust] Running cargo clippy for service: ${config.name}`);
+        try {
+            const { execSync } = require('child_process');
+            execSync('cargo clippy', {
+                stdio: 'inherit',
+                cwd: config.path || '.',
+            });
+            console.log('[Rust] Clippy passed');
+            return true;
+        }
+        catch (error) {
+            console.error(`[Rust] Clippy failed: ${error.message}`);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=rust-adapter.js.map