ciscollm-cli 1.3.1 → 1.3.3

package/dist/cli/commands/runCommand.js

@@ -0,0 +1,635 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAction = runAction;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const MultiAgentCoordinator_1 = require("../../core/agent/MultiAgentCoordinator");
+const PlinkSerial_1 = require("../../infrastructure/protocols/PlinkSerial");
+const SshSession_1 = require("../../infrastructure/protocols/SshSession");
+const TelnetSession_1 = require("../../infrastructure/protocols/TelnetSession");
+const LLMClient_1 = require("../../infrastructure/llm/LLMClient");
+const AgentLoop_1 = require("../../core/agent/AgentLoop");
+const ui_1 = require("../ui/ui");
+const dashboard_1 = require("../../server/dashboard");
+async function runAction(options, coordinatorWrapper, dashboardWrapper, cleanup) {
+    let provider = options.provider;
+    let localType = options.localType;
+    if (localType) {
+        localType = localType.toLowerCase().trim();
+        if (localType === 'llmstudio') {
+            localType = 'lmstudio';
+        }
+    }
+    let apiKey = options.api_key || options.apiKey;
+    let model = options.model;
+    let endpoint = options.endpoint;
+    let protocol = options.protocol;
+    let com = options.com;
+    let baud = options.baud;
+    let host = options.host;
+    let port = options.port;
+    let username = options.username;
+    let privateKey;
+    if (options.privateKey) {
+        privateKey = (0, fs_1.readFileSync)(options.privateKey, 'utf8');
+    }
+    let netconfPassphrase = options.passphrase;
+    let password = options.envPassword
+        ? (process.env.CISCOLLM_PASS || '')
+        : options.password;
+    let goal = options.goal;
+    let strictCommandRef = options.strictCommandRef === true;
+    let refTelemetry = options.refTelemetry !== false;
+    let nonInteractive = options.nonInteractive === true;
+    let rbacRole = options.rbacRole || 'admin';
+    let dashboardPort = options.dashboardPort ? parseInt(options.dashboardPort, 10) : 3000;
+    if (nonInteractive) {
+        process.env.CISCOLLM_NON_INTERACTIVE = 'true';
+    }
+    ui_1.logger.banner();
+    if (goal && !localType && provider === 'local') {
+        const { chosenLocalType } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'chosenLocalType',
+                message: chalk_1.default.cyan('Select Local LLM Service:'),
+                choices: [
+                    { name: `${chalk_1.default.green('●')} Ollama          ${chalk_1.default.dim('(http://127.0.0.1:11434/v1)')}`, value: 'ollama' },
+                    { name: `${chalk_1.default.magenta('●')} LM Studio       ${chalk_1.default.dim('(http://127.0.0.1:1234/v1)')}`, value: 'lmstudio' },
+                    { name: `${chalk_1.default.yellow('●')} OpenRouter      ${chalk_1.default.dim('(Cloud API)')}`, value: '__cloud__' }
+                ],
+                default: 'ollama'
+            }
+        ]);
+        if (chosenLocalType === '__cloud__') {
+            provider = 'cloud';
+            localType = undefined;
+            if (!apiKey) {
+                const { key } = await inquirer_1.default.prompt([{ type: 'password', name: 'key', message: 'OpenRouter API Key:' }]);
+                apiKey = key;
+            }
+        }
+        else {
+            localType = chosenLocalType;
+        }
+    }
+    if (!localType)
+        localType = 'ollama';
+    if (!goal) {
+        const detectedComs = await PlinkSerial_1.PlinkSerialSession.listAvailableComPorts();
+        let currentStep = 'PROVIDER';
+        const history = [];
+        const answers = {
+            provider: provider || 'local',
+            localType: localType || 'ollama',
+            apiKey: apiKey || '',
+            model: model || '',
+            endpoint: endpoint || '',
+            protocol: protocol || 'serial',
+            com: com || '',
+            baud: baud || '9600',
+            host: host || '',
+            port: port || '',
+            username: username || '',
+            password: password || '',
+            goal: ''
+        };
+        const goForward = (nextStep) => {
+            history.push(currentStep);
+            currentStep = nextStep;
+        };
+        const goBack = () => {
+            if (history.length > 0) {
+                currentStep = history.pop();
+            }
+            else {
+                ui_1.logger.warn('Already at the first step.');
+            }
+        };
+        const refreshConsole = () => {
+            console.clear();
+            ui_1.logger.banner();
+            if (detectedComs.length > 0) {
+                ui_1.logger.info('Detected active COM ports on system:');
+                for (const port of detectedComs) {
+                    console.log(`   ${chalk_1.default.yellow('•')} ${chalk_1.default.yellow(port)}`);
+                }
+            }
+            console.log('');
+        };
+        while (currentStep !== 'CONFIRMATION') {
+            refreshConsole();
+            switch (currentStep) {
+                case 'PROVIDER': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'provider',
+                            message: 'Select LLM Provider:',
+                            choices: [
+                                { name: 'Local (Ollama / LM Studio)', value: 'local' },
+                                { name: 'Cloud (OpenRouter)', value: 'cloud' }
+                            ],
+                            default: answers.provider
+                        }
+                    ]);
+                    answers.provider = ans.provider;
+                    if (answers.provider === 'local') {
+                        goForward('LOCAL_TYPE');
+                    }
+                    else {
+                        goForward('API_KEY');
+                    }
+                    break;
+                }
+                case 'LOCAL_TYPE': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'localType',
+                            message: 'Select Local LLM Service:',
+                            choices: [
+                                { name: 'Ollama', value: 'ollama' },
+                                { name: 'LM Studio', value: 'lmstudio' },
+                                { name: chalk_1.default.dim('< Go Back'), value: '__back__' }
+                            ],
+                            default: answers.localType
+                        }
+                    ]);
+                    if (ans.localType === '__back__') {
+                        goBack();
+                    }
+                    else {
+                        answers.localType = ans.localType;
+                        goForward('MODEL');
+                    }
+                    break;
+                }
+                case 'API_KEY': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'apiKey',
+                            message: 'Enter OpenRouter API Key (or type "back" to go back):',
+                            default: answers.apiKey || undefined
+                        }
+                    ]);
+                    if (ans.apiKey.trim().toLowerCase() === 'back') {
+                        goBack();
+                    }
+                    else {
+                        answers.apiKey = ans.apiKey;
+                        goForward('MODEL');
+                    }
+                    break;
+                }
+                case 'MODEL': {
+                    const defaultModel = answers.model || (answers.provider === 'cloud'
+                        ? 'nvidia/nemotron-3-super-120b-a12b:free'
+                        : 'qwen3.5:4b');
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'model',
+                            message: 'Enter LLM Model Name (or type "back" to go back):',
+                            default: defaultModel
+                        }
+                    ]);
+                    if (ans.model.trim().toLowerCase() === 'back') {
+                        goBack();
+                    }
+                    else {
+                        answers.model = ans.model;
+                        goForward('ENDPOINT');
+                    }
+                    break;
+                }
+                case 'ENDPOINT': {
+                    const defaultEndpoint = answers.endpoint || (answers.provider === 'cloud'
+                        ? 'https://openrouter.ai/api/v1'
+                        : (answers.localType === 'lmstudio'
+                            ? 'http://127.0.0.1:1234/v1'
+                            : 'http://127.0.0.1:11434/v1'));
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'endpoint',
+                            message: 'Enter LLM API Endpoint URL (or type "back" to go back):',
+                            default: defaultEndpoint
+                        }
+                    ]);
+                    if (ans.endpoint.trim().toLowerCase() === 'back') {
+                        goBack();
+                    }
+                    else {
+                        answers.endpoint = ans.endpoint;
+                        goForward('PROTOCOL');
+                    }
+                    break;
+                }
+                case 'PROTOCOL': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'protocol',
+                            message: 'Select Connection Protocol:',
+                            choices: [
+                                { name: 'serial', value: 'serial' },
+                                { name: 'ssh', value: 'ssh' },
+                                { name: 'telnet', value: 'telnet' },
+                                { name: chalk_1.default.dim('< Go Back'), value: '__back__' }
+                            ],
+                            default: answers.protocol
+                        }
+                    ]);
+                    if (ans.protocol === '__back__') {
+                        goBack();
+                    }
+                    else {
+                        answers.protocol = ans.protocol;
+                        if (answers.protocol === 'serial') {
+                            goForward('SERIAL_COM');
+                        }
+                        else {
+                            goForward('IP_HOST');
+                        }
+                    }
+                    break;
+                }
+                case 'SERIAL_COM': {
+                    if (detectedComs.length > 0) {
+                        const choices = detectedComs.map(port => {
+                            const match = /^(COM\d+)\b/i.exec(port);
+                            const portValue = match ? match[1].toUpperCase() : port;
+                            return { name: port, value: portValue };
+                        });
+                        choices.push({ name: 'Enter COM port(s) manually', value: '__manual__' });
+                        choices.push({ name: chalk_1.default.dim('< Go Back'), value: '__back__' });
+                        const ans = await inquirer_1.default.prompt([
+                            {
+                                type: 'checkbox',
+                                name: 'coms',
+                                message: 'Select COM Port(s) (Use Space to select, Enter to confirm):',
+                                choices: choices,
+                                validate: (input) => {
+                                    if (input.length === 0) {
+                                        return 'You must select at least one option.';
+                                    }
+                                    if (input.includes('__back__') && input.length > 1) {
+                                        return 'Cannot select "< Go Back" along with other ports.';
+                                    }
+                                    if (input.includes('__manual__') && input.length > 1) {
+                                        return 'Cannot select "Enter COM port(s) manually" along with other ports.';
+                                    }
+                                    return true;
+                                }
+                            }
+                        ]);
+                        if (ans.coms.includes('__back__')) {
+                            goBack();
+                        }
+                        else if (ans.coms.includes('__manual__')) {
+                            const manualAns = await inquirer_1.default.prompt([
+                                {
+                                    type: 'input',
+                                    name: 'com',
+                                    message: 'Enter COM Port name(s) (comma-separated, e.g. COM3 or COM3,COM4):',
+                                    validate: (input) => input.trim().length > 0 ? true : 'COM port is required.'
+                                }
+                            ]);
+                            answers.com = manualAns.com;
+                            goForward('SERIAL_BAUD');
+                        }
+                        else {
+                            answers.com = ans.coms.join(',');
+                            goForward('SERIAL_BAUD');
+                        }
+                    }
+                    else {
+                        const ans = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'com',
+                                message: 'Enter COM Port name(s) (comma-separated, e.g. COM3 or COM3,COM4) (or type "back" to go back):',
+                                default: answers.com || undefined,
+                                validate: (input) => {
+                                    if (input.trim().toLowerCase() === 'back')
+                                        return true;
+                                    return input.trim().length > 0 ? true : 'COM port is required.';
+                                }
+                            }
+                        ]);
+                        if (ans.com.trim().toLowerCase() === 'back') {
+                            goBack();
+                        }
+                        else {
+                            answers.com = ans.com;
+                            goForward('SERIAL_BAUD');
+                        }
+                    }
+                    break;
+                }
+                case 'SERIAL_BAUD': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'baud',
+                            message: 'Select Serial Baud Rate:',
+                            choices: [
+                                '9600', '19200', '38400', '57600', '115200',
+                                { name: chalk_1.default.dim('< Go Back'), value: '__back__' }
+                            ],
+                            default: answers.baud
+                        }
+                    ]);
+                    if (ans.baud === '__back__') {
+                        goBack();
+                    }
+                    else {
+                        answers.baud = ans.baud;
+                        goForward('GOAL');
+                    }
+                    break;
+                }
+                case 'IP_HOST': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'host',
+                            message: 'Enter Target IP address(es) / Hostname(s) (comma-separated) (or type "back" to go back):',
+                            default: answers.host || undefined,
+                            validate: (input) => {
+                                if (input.trim().toLowerCase() === 'back')
+                                    return true;
+                                return input.trim().length > 0 ? true : 'Host address is required.';
+                            }
+                        }
+                    ]);
+                    if (ans.host.trim().toLowerCase() === 'back') {
+                        goBack();
+                    }
+                    else {
+                        answers.host = ans.host;
+                        goForward('IP_PORT');
+                    }
+                    break;
+                }
+                case 'IP_PORT': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'port',
+                            message: 'Enter Connection Port (leave empty for default) (or type "back" to go back):',
+                            default: answers.port || undefined
+                        }
+                    ]);
+                    if (ans.port.trim().toLowerCase() === 'back') {
+                        goBack();
+                    }
+                    else {
+                        answers.port = ans.port;
+                        goForward('IP_USER');
+                    }
+                    break;
+                }
+                case 'IP_USER': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'username',
+                            message: 'Enter Device Username (leave empty if none) (or type "back" to go back):',
+                            default: answers.username || undefined
+                        }
+                    ]);
+                    if (ans.username.trim().toLowerCase() === 'back') {
+                        goBack();
+                    }
+                    else {
+                        answers.username = ans.username;
+                        goForward('IP_PASS');
+                    }
+                    break;
+                }
+                case 'IP_PASS': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'password',
+                            name: 'password',
+                            message: 'Enter Device Password (or type "back" to go back):',
+                            default: answers.password || undefined
+                        }
+                    ]);
+                    if (ans.password === 'back') {
+                        goBack();
+                    }
+                    else {
+                        answers.password = ans.password;
+                        goForward('GOAL');
+                    }
+                    break;
+                }
+                case 'GOAL': {
+                    const ans = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'goal',
+                            message: 'Enter Execution Goal / Intent (or type "back" to go back):',
+                            default: answers.goal || undefined,
+                            validate: (input) => {
+                                if (input.trim().toLowerCase() === 'back')
+                                    return true;
+                                return input.trim().length > 0 ? true : 'Execution goal is required.';
+                            }
+                        }
+                    ]);
+                    if (ans.goal.trim().toLowerCase() === 'back') {
+                        goBack();
+                    }
+                    else {
+                        answers.goal = ans.goal;
+                        goForward('CONFIRMATION');
+                    }
+                    break;
+                }
+                case 'CONFIRMATION':
+                    break;
+            }
+        }
+        // Show configuration confirmation wizard summary
+        refreshConsole();
+        console.log(chalk_1.default.bold.yellow('=== CISCOLLM CONFIGURATION CONFIRMATION ==='));
+        console.log(`• Provider:         ${chalk_1.default.green(answers.provider.toUpperCase())}`);
+        if (answers.provider === 'local') {
+            console.log(`• Local Type:       ${chalk_1.default.green(answers.localType.toUpperCase())}`);
+        }
+        console.log(`• Model:            ${chalk_1.default.green(answers.model || 'qwen3.5:4b')}`);
+        console.log(`• Endpoint URL:     ${chalk_1.default.green(answers.endpoint)}`);
+        console.log(`• Protocol:         ${chalk_1.default.green(answers.protocol.toUpperCase())}`);
+        if (answers.protocol === 'serial') {
+            console.log(`• COM Port(s):      ${chalk_1.default.green(answers.com)}`);
+            console.log(`• Baud Rate:        ${chalk_1.default.green(answers.baud)}`);
+        }
+        else {
+            console.log(`• Host IP(s):       ${chalk_1.default.green(answers.host)}`);
+            console.log(`• Connection Port:  ${chalk_1.default.green(answers.port || '(default)')}`);
+            console.log(`• Login Username:   ${chalk_1.default.green(answers.username || '(none)')}`);
+        }
+        console.log(`• Execution Goal:   ${chalk_1.default.cyan(answers.goal)}`);
+        console.log(chalk_1.default.bold.yellow('==========================================='));
+        const confirmAns = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'confirm',
+                message: 'Do you want to proceed with this configuration?',
+                choices: [
+                    { name: 'Yes, start execution', value: 'yes' },
+                    { name: 'Edit Execution Goal', value: 'edit_goal' },
+                    { name: 'Restart Wizard', value: 'restart' },
+                    { name: 'Cancel and Exit', value: 'cancel' }
+                ]
+            }
+        ]);
+        if (confirmAns.confirm === 'yes') {
+            provider = answers.provider;
+            localType = answers.localType;
+            apiKey = answers.apiKey;
+            model = answers.model;
+            endpoint = answers.endpoint;
+            protocol = answers.protocol;
+            com = answers.com;
+            baud = answers.baud;
+            host = answers.host;
+            port = answers.port;
+            username = answers.username;
+            password = answers.password;
+            goal = answers.goal;
+        }
+        else if (confirmAns.confirm === 'edit_goal') {
+            answers.goal = '';
+            currentStep = 'GOAL';
+            // Loop back to prompt goal
+            // Wait, we need to restart the wizard loop! Let's re-run this function or let the while loop run.
+            // Because currentStep is set to 'GOAL' and answers are preserved, calling runAction again is easiest.
+            options.goal = undefined;
+            return runAction(options, coordinatorWrapper, dashboardWrapper, cleanup);
+        }
+        else if (confirmAns.confirm === 'restart') {
+            options.goal = undefined;
+            return runAction({ ...options, provider: undefined, localType: undefined, model: undefined, endpoint: undefined, protocol: undefined, com: undefined, host: undefined, username: undefined, password: undefined }, coordinatorWrapper, dashboardWrapper, cleanup);
+        }
+        else {
+            ui_1.logger.info('Configuration wizard cancelled.');
+            process.exit(0);
+        }
+    }
+    ui_1.logger.info(`Initializing system link in [${provider.toUpperCase()}] mode using ${protocol.toUpperCase()}...`);
+    ui_1.logger.info(`Command reference policy: strict=${strictCommandRef ? 'on' : 'off'}, telemetry=${refTelemetry ? 'on' : 'off'}`);
+    coordinatorWrapper.active = new MultiAgentCoordinator_1.MultiAgentCoordinator();
+    try {
+        dashboardWrapper.server = (0, dashboard_1.startDashboardServer)(coordinatorWrapper.active, dashboardPort);
+    }
+    catch (e) {
+        ui_1.logger.warn(`Failed to auto-start live Visual Control Dashboard: ${e.message}`);
+    }
+    try {
+        if (protocol === 'serial') {
+            if (!com) {
+                throw new Error('COM port (-c, --com) is required for serial protocol connections.');
+            }
+            const ports = com.split(',').map((p) => p.trim()).filter((p) => p.length > 0);
+            for (const port of ports) {
+                const session = new PlinkSerial_1.PlinkSerialSession(port, parseInt(baud, 10));
+                coordinatorWrapper.active.registerSession(port, session);
+            }
+        }
+        else if (protocol === 'ssh') {
+            if (!host || !username) {
+                throw new Error('Host (--host) and Username (-u, --username) are required for SSH connections.');
+            }
+            const hosts = host.split(',').map((h) => h.trim()).filter((h) => h.length > 0);
+            for (const h of hosts) {
+                const session = new SshSession_1.SshSession({
+                    host: h,
+                    port: port ? parseInt(port, 10) : 22,
+                    username: username,
+                    password: password
+                });
+                coordinatorWrapper.active.registerSession(h, session);
+            }
+        }
+        else if (protocol === 'telnet') {
+            if (!host) {
+                throw new Error('Host (--host) is required for Telnet connections.');
+            }
+            const hosts = host.split(',').map((h) => h.trim()).filter((h) => h.length > 0);
+            for (const h of hosts) {
+                const session = new TelnetSession_1.TelnetSession({
+                    host: h,
+                    port: port ? parseInt(port, 10) : 23,
+                    username: username,
+                    password: password
+                });
+                coordinatorWrapper.active.registerSession(h, session);
+            }
+        }
+        else {
+            throw new Error(`Unsupported connection protocol type: ${protocol}`);
+        }
+        if (provider === 'local' && !endpoint) {
+            if (localType === 'lmstudio') {
+                endpoint = 'http://127.0.0.1:1234/v1';
+                ui_1.logger.info(`LM Studio endpoint: ${chalk_1.default.cyan(endpoint)}`);
+            }
+            else {
+                endpoint = 'http://127.0.0.1:11434/v1';
+                ui_1.logger.info(`Ollama endpoint: ${chalk_1.default.cyan(endpoint)}`);
+            }
+        }
+        const localAIClient = new LLMClient_1.LLMClient(provider, endpoint, model, apiKey, localType);
+        const llmSpinner = (0, ui_1.createSpinner)('Preflight check: validating LLM endpoint reachability...').start();
+        try {
+            await localAIClient.ensureReachable();
+            const setupOk = await localAIClient.setupModelIfNeeded(status => {
+                llmSpinner.text = `LLM preflight: ${status}`;
+            });
+            if (setupOk) {
+                llmSpinner.succeed('LLM endpoint is reachable and model is ready.');
+            }
+            else {
+                llmSpinner.warn('LLM endpoint is reachable (model auto-load skipped/not supported by this provider).');
+            }
+        }
+        catch (err) {
+            llmSpinner.fail('LLM endpoint preflight failed.');
+            throw err;
+        }
+        const connSpinner = (0, ui_1.createSpinner)('Connecting to target network devices...').start();
+        try {
+            await coordinatorWrapper.active.connectAll();
+            connSpinner.succeed('All hardware sessions synchronized successfully.');
+        }
+        catch (err) {
+            connSpinner.fail('Connection failed.');
+            throw err;
+        }
+        const agent = new AgentLoop_1.CiscoAgentLoop(localAIClient, coordinatorWrapper.active, {
+            strictReferenceMode: strictCommandRef,
+            referenceTelemetry: refTelemetry,
+            rbacRole: rbacRole
+        });
+        await agent.run(goal);
+    }
+    catch (err) {
+        ui_1.logger.critical(`Execution Error: ${err.message}`);
+    }
+    finally {
+        await cleanup();
+        ui_1.logger.info('Session Terminated. Pipelines detached.');
+        process.exit(0);
+    }
+}
+//# sourceMappingURL=runCommand.js.map