helix-assistant-cli 0.0.0-stage → 0.2.1

package/dist/client/agent-launcher.js

@@ -0,0 +1,339 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenFilePath = getTokenFilePath;
+exports.getOrGenerateWsToken = getOrGenerateWsToken;
+exports.isAgentProcessRunning = isAgentProcessRunning;
+exports.isAgentStarting = isAgentStarting;
+exports.findPythonAgentScript = findPythonAgentScript;
+exports.findPythonExecutable = findPythonExecutable;
+exports.probePort = probePort;
+exports.probeWebSocketAuth = probeWebSocketAuth;
+exports.killProcessOnPort = killProcessOnPort;
+exports.waitForAgentReady = waitForAgentReady;
+exports.spawnAgentDaemon = spawnAgentDaemon;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+const net_1 = __importDefault(require("net"));
+const ws_1 = __importDefault(require("ws"));
+let spawnedAgentProcess = null;
+let activeSpawnToken = null;
+let startupPromise = null;
+function getTokenFilePath() {
+    const appData = process.env.APPDATA ||
+        (process.platform === 'darwin'
+            ? path_1.default.join(process.env.HOME || '', 'Library/Application Support')
+            : path_1.default.join(process.env.HOME || '', '.config'));
+    const helixDir = path_1.default.join(appData, 'HELIX');
+    if (!fs_1.default.existsSync(helixDir)) {
+        try {
+            fs_1.default.mkdirSync(helixDir, { recursive: true });
+        }
+        catch { }
+    }
+    return path_1.default.join(helixDir, '.ws_token');
+}
+function getOrGenerateWsToken() {
+    if (activeSpawnToken)
+        return activeSpawnToken;
+    if (process.env.HELIX_WS_TOKEN) {
+        activeSpawnToken = process.env.HELIX_WS_TOKEN;
+        return activeSpawnToken;
+    }
+    const tokenFile = getTokenFilePath();
+    if (fs_1.default.existsSync(tokenFile)) {
+        try {
+            const saved = fs_1.default.readFileSync(tokenFile, 'utf-8').trim();
+            if (saved.length >= 16) {
+                activeSpawnToken = saved;
+                process.env.HELIX_WS_TOKEN = activeSpawnToken;
+                return activeSpawnToken;
+            }
+        }
+        catch { }
+    }
+    activeSpawnToken = crypto_1.default.randomBytes(32).toString('hex');
+    process.env.HELIX_WS_TOKEN = activeSpawnToken;
+    try {
+        fs_1.default.writeFileSync(tokenFile, activeSpawnToken, { encoding: 'utf-8', mode: 0o600 });
+    }
+    catch { }
+    return activeSpawnToken;
+}
+function isAgentProcessRunning() {
+    return spawnedAgentProcess !== null && !spawnedAgentProcess.killed;
+}
+function isAgentStarting() {
+    return startupPromise !== null;
+}
+function findPythonAgentScript() {
+    const candidates = [
+        path_1.default.resolve(process.cwd(), 'services/agent/main.py'),
+        path_1.default.resolve(__dirname, '../../../services/agent/main.py'),
+        path_1.default.resolve(__dirname, '../../../../services/agent/main.py'),
+        path_1.default.resolve(__dirname, '../../services/agent/main.py'),
+    ];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function findPythonExecutable(repoRoot) {
+    // Check explicit environment variable first
+    if (process.env.PYTHON_PATH && fs_1.default.existsSync(process.env.PYTHON_PATH)) {
+        return process.env.PYTHON_PATH;
+    }
+    // On Windows, prefer pythonw.exe so NO console terminal window is opened
+    if (process.platform === 'win32') {
+        const venvGuiCandidates = [
+            path_1.default.join(repoRoot, '.venv', 'Scripts', 'pythonw.exe'),
+            path_1.default.join(repoRoot, 'venv', 'Scripts', 'pythonw.exe'),
+            path_1.default.join(repoRoot, 'services', 'agent', '.venv', 'Scripts', 'pythonw.exe'),
+        ];
+        for (const venvGui of venvGuiCandidates) {
+            if (fs_1.default.existsSync(venvGui)) {
+                return venvGui;
+            }
+        }
+    }
+    // Check virtual environment candidates relative to repository root
+    const venvCandidates = [
+        path_1.default.join(repoRoot, '.venv', 'Scripts', 'python.exe'),
+        path_1.default.join(repoRoot, '.venv', 'bin', 'python'),
+        path_1.default.join(repoRoot, 'venv', 'Scripts', 'python.exe'),
+        path_1.default.join(repoRoot, 'venv', 'bin', 'python'),
+        path_1.default.join(repoRoot, 'services', 'agent', '.venv', 'Scripts', 'python.exe'),
+        path_1.default.join(repoRoot, 'services', 'agent', '.venv', 'bin', 'python'),
+    ];
+    for (const venvPython of venvCandidates) {
+        if (fs_1.default.existsSync(venvPython)) {
+            return venvPython;
+        }
+    }
+    // Fallback to system PATH executables
+    const systemCandidates = process.platform === 'win32'
+        ? ['pythonw', 'python', 'py']
+        : ['python', 'python3', 'py'];
+    return systemCandidates[0];
+}
+/**
+ * Probes a TCP port quietly without initiating a WebSocket handshake.
+ */
+function probePort(port, host = '127.0.0.1', timeoutMs = 800) {
+    return new Promise((resolve) => {
+        const socket = new net_1.default.Socket();
+        let settled = false;
+        socket.setTimeout(timeoutMs);
+        socket.once('connect', () => {
+            if (!settled) {
+                settled = true;
+                socket.destroy();
+                resolve(true);
+            }
+        });
+        socket.once('timeout', () => {
+            if (!settled) {
+                settled = true;
+                socket.destroy();
+                resolve(false);
+            }
+        });
+        socket.once('error', () => {
+            if (!settled) {
+                settled = true;
+                socket.destroy();
+                resolve(false);
+            }
+        });
+        try {
+            socket.connect(port, host);
+        }
+        catch {
+            if (!settled) {
+                settled = true;
+                resolve(false);
+            }
+        }
+    });
+}
+/**
+ * Probes the WebSocket endpoint with Authorization header.
+ * Returns:
+ *   'ready': 101 Switching Protocols (authenticated and connected)
+ *   'unauthorized': 401 Unauthorized (wrong token / rogue process on port)
+ *   'closed': Connection refused / port closed
+ */
+function probeWebSocketAuth(port = 8765, token, host = '127.0.0.1', timeoutMs = 1000) {
+    return new Promise((resolve) => {
+        let settled = false;
+        let timer = null;
+        const headers = {};
+        const effectiveToken = token || getOrGenerateWsToken();
+        if (effectiveToken) {
+            headers['Authorization'] = `Bearer ${effectiveToken}`;
+        }
+        let ws = null;
+        try {
+            ws = new ws_1.default(`ws://${host}:${port}`, { headers });
+        }
+        catch {
+            return resolve('closed');
+        }
+        const cleanup = () => {
+            if (timer)
+                clearTimeout(timer);
+            if (ws) {
+                ws.removeAllListeners();
+                ws.on('error', () => { });
+                try {
+                    if (ws.readyState === ws_1.default.OPEN) {
+                        ws.close();
+                    }
+                    else {
+                        ws.terminate();
+                    }
+                }
+                catch { }
+            }
+        };
+        timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                cleanup();
+                resolve('closed');
+            }
+        }, timeoutMs);
+        ws.once('open', () => {
+            if (!settled) {
+                settled = true;
+                cleanup();
+                resolve('ready');
+            }
+        });
+        ws.once('error', (err) => {
+            if (!settled) {
+                settled = true;
+                const msg = err.message || '';
+                cleanup();
+                if (msg.includes('401') || msg.includes('Unexpected server response: 401')) {
+                    resolve('unauthorized');
+                }
+                else {
+                    resolve('closed');
+                }
+            }
+        });
+    });
+}
+/**
+ * Terminates any rogue or orphaned process occupying the specified port.
+ */
+function killProcessOnPort(port = 8765) {
+    try {
+        if (process.platform === 'win32') {
+            (0, child_process_1.execSync)(`powershell -NoProfile -Command "$conn = Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue; if ($conn) { Stop-Process -Id $conn.OwningProcess -Force -ErrorAction SilentlyContinue }"`, { stdio: 'ignore', windowsHide: true });
+        }
+        else {
+            (0, child_process_1.execSync)(`fuser -k ${port}/tcp || lsof -ti tcp:${port} | xargs kill -9`, {
+                stdio: 'ignore',
+            });
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Waits until the agent service has completed startup and successfully accepts WebSocket authentication.
+ */
+async function waitForAgentReady(port = 8765, token, maxWaitMs = 45000, pollIntervalMs = 1000, onProgress) {
+    if (startupPromise) {
+        return startupPromise;
+    }
+    startupPromise = (async () => {
+        const startTime = Date.now();
+        try {
+            while (Date.now() - startTime < maxWaitMs) {
+                // If the spawned child process exited prematurely with an error code, abort
+                if (spawnedAgentProcess !== null && spawnedAgentProcess.exitCode !== null) {
+                    return false;
+                }
+                const authState = await probeWebSocketAuth(port, token);
+                if (authState === 'ready') {
+                    return true;
+                }
+                const elapsedSec = Math.floor((Date.now() - startTime) / 1000);
+                if (onProgress) {
+                    onProgress(elapsedSec);
+                }
+                await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            }
+            return false;
+        }
+        finally {
+            startupPromise = null;
+        }
+    })();
+    return startupPromise;
+}
+async function spawnAgentDaemon(port = 8765) {
+    const token = getOrGenerateWsToken();
+    // 1. Check if the agent is already up and authenticated
+    const currentStatus = await probeWebSocketAuth(port, token, '127.0.0.1', 500);
+    if (currentStatus === 'ready') {
+        return { success: true };
+    }
+    // 2. If port is occupied by an unauthorized process, clean it up
+    if (currentStatus === 'unauthorized') {
+        killProcessOnPort(port);
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    if (isAgentProcessRunning() || isAgentStarting()) {
+        return { success: true };
+    }
+    const scriptPath = findPythonAgentScript();
+    if (!scriptPath) {
+        return {
+            success: false,
+            error: 'No se encontró el script services/agent/main.py del agente Python.',
+        };
+    }
+    const agentDir = path_1.default.dirname(scriptPath);
+    const repoRoot = path_1.default.resolve(agentDir, '../..');
+    const pythonExec = findPythonExecutable(repoRoot);
+    try {
+        const child = (0, child_process_1.spawn)(pythonExec, ['main.py', '--ws-port', String(port), '--no-camera'], {
+            cwd: agentDir,
+            detached: true,
+            stdio: 'ignore', // run completely in background
+            windowsHide: true,
+            env: {
+                ...process.env,
+                HELIX_WS_TOKEN: token,
+                HELIX_DISABLE_CAMERA: '1',
+                CAMERA_ENABLED: 'false',
+                PYTHONUNBUFFERED: '1',
+                PYTHONIOENCODING: 'utf-8',
+                PYTHONPATH: repoRoot,
+            },
+        });
+        child.unref();
+        spawnedAgentProcess = child;
+        child.on('exit', () => {
+            spawnedAgentProcess = null;
+        });
+        return { success: true };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Error al invocar proceso Python: ${err.message}`,
+        };
+    }
+}

package/dist/client/types.d.ts

@@ -0,0 +1,88 @@
+export interface AgentMessage<T = unknown> {
+    type: string;
+    payload: T;
+    timestamp?: string;
+    request_id?: string;
+    error?: string;
+}
+export interface UserTextMessagePayload {
+    text: string;
+    conversation_id: string;
+    conversation_history: Array<{
+        role: 'user' | 'assistant';
+        content: string;
+    }>;
+    attachments?: Array<{
+        name: string;
+        mime_type: string;
+        size?: number;
+        data_base64: string;
+    }>;
+}
+export interface SkillSummary {
+    name: string;
+    description: string;
+    triggers?: string[];
+    instructions?: string;
+    custom?: boolean;
+}
+export interface McpToolSummary {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+}
+export interface McpServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    status?: 'connected' | 'idle' | 'connecting' | 'error';
+    error?: string;
+    tools?: McpToolSummary[];
+}
+export interface ProviderKeySlot {
+    slot: number;
+    health: 'healthy' | 'degraded' | 'cooldown' | 'unconfigured' | 'error';
+    configured: boolean;
+    masked?: string;
+}
+export interface ProviderSummary {
+    id: string;
+    name: string;
+    configured: boolean;
+    keys: ProviderKeySlot[];
+    models_available: number;
+}
+export interface ModelSummary {
+    id: string;
+    name?: string;
+    provider: string;
+    capabilities?: Record<string, boolean>;
+}
+export interface TaskSummary {
+    task_id: string;
+    prompt?: string;
+    status: 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED';
+    created_at?: string;
+    result?: string;
+    error?: string;
+}
+export interface HelixSettings {
+    voice_enabled?: boolean;
+    wake_word?: string;
+    mcp_servers?: McpServerConfig[];
+    default_model?: string | null;
+    preferred_provider?: string | null;
+    log_level?: string;
+    agent_ws_port?: number;
+    [key: string]: unknown;
+}
+export interface ConfirmationRequest {
+    id?: string;
+    request_id?: string;
+    action?: string;
+    description?: string;
+    risk_level?: 'LOW' | 'MEDIUM' | 'HIGH';
+    tool?: string;
+    arguments?: Record<string, unknown>;
+}

package/dist/client/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commands/apikey.d.ts

@@ -0,0 +1,3 @@
+import type { AgentClient } from '../client/agent-client';
+export declare function handleShowApiKey(client: AgentClient): Promise<void>;
+export declare function handleConfigApiKey(client: AgentClient): Promise<void>;

package/dist/commands/apikey.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleShowApiKey = handleShowApiKey;
+exports.handleConfigApiKey = handleConfigApiKey;
+const prompts_1 = __importDefault(require("prompts"));
+const chalk_1 = __importDefault(require("chalk"));
+const colors_1 = require("../ui/colors");
+const KNOWN_PROVIDERS = [
+    { title: 'OpenAI (GPT-4o, o1, o3-mini)', value: 'openai' },
+    { title: 'Anthropic (Claude 3.5 Sonnet, Claude 3.7)', value: 'anthropic' },
+    { title: 'Google (Gemini 2.0 Flash / Pro)', value: 'google' },
+    { title: 'Groq (Llama 3.3, DeepSeek R1)', value: 'groq' },
+    { title: 'Mistral AI (Mistral Large, Codestral)', value: 'mistral' },
+    { title: 'Ollama / Local Custom Provider', value: 'ollama' },
+];
+async function handleShowApiKey(client) {
+    console.log(`\n${(0, colors_1.BOLD)('🔑 Configuración Actual de API Keys:')}\n`);
+    try {
+        const providers = await client.getProviders();
+        if (!providers || providers.length === 0) {
+            console.log((0, colors_1.GRAY)('  No se encontraron proveedores registrados en el agente.\n'));
+            return;
+        }
+        for (const provider of providers) {
+            const statusIcon = provider.configured ? (0, colors_1.GREEN)('●') : (0, colors_1.GRAY)('○');
+            const providerTitle = provider.configured
+                ? chalk_1.default.greenBright.bold(provider.name || provider.id)
+                : chalk_1.default.gray(provider.name || provider.id);
+            console.log(`  ${statusIcon} ${providerTitle} ${(0, colors_1.DIM)(`(${provider.models_available || 0} modelos disponibles)`)}`);
+            if (provider.keys && provider.keys.length > 0) {
+                for (const slot of provider.keys) {
+                    let healthBadge;
+                    switch (slot.health) {
+                        case 'healthy':
+                            healthBadge = chalk_1.default.green('✔ Válida / Activa');
+                            break;
+                        case 'degraded':
+                            healthBadge = chalk_1.default.yellow('⚠ Degradada');
+                            break;
+                        case 'cooldown':
+                            healthBadge = chalk_1.default.red('⏳ Cooldown');
+                            break;
+                        case 'unconfigured':
+                            healthBadge = chalk_1.default.gray('○ No configurada');
+                            break;
+                        default:
+                            healthBadge = chalk_1.default.gray(slot.health);
+                    }
+                    const maskedText = slot.configured ? chalk_1.default.cyan('••••••••••••••••') : chalk_1.default.gray('vacío');
+                    console.log(`     ${(0, colors_1.GRAY)('Slot ' + slot.slot + ':')} ${maskedText}  [${healthBadge}]`);
+                }
+            }
+            else {
+                console.log(`     ${(0, colors_1.GRAY)('Sin slots de claves registrados')}`);
+            }
+            console.log('');
+        }
+    }
+    catch (error) {
+        console.log((0, colors_1.RED)(`  Error al consultar API keys del agente: ${error.message}\n`));
+    }
+}
+async function handleConfigApiKey(client) {
+    console.log(`\n${(0, colors_1.BOLD)('⚙️  Configurador Interactivo de API Keys')}\n`);
+    // 1. Select Provider
+    const providerAnswer = await (0, prompts_1.default)({
+        type: 'select',
+        name: 'provider',
+        message: 'Selecciona el proveedor de IA para configurar:',
+        choices: KNOWN_PROVIDERS,
+    });
+    const providerId = providerAnswer.provider;
+    if (!providerId) {
+        console.log((0, colors_1.YELLOW)('Operación cancelada.\n'));
+        return;
+    }
+    // 2. Select Slot
+    const slotAnswer = await (0, prompts_1.default)({
+        type: 'select',
+        name: 'slot',
+        message: `Selecciona el Slot para ${providerId.toUpperCase()}:`,
+        choices: [
+            { title: 'Slot 1 (Principal)', value: 1 },
+            { title: 'Slot 2 (Respaldo)', value: 2 },
+            { title: 'Slot 3 (Rotación)', value: 3 },
+            { title: 'Añadir nuevo Slot', value: 4 },
+        ],
+    });
+    const slotNumber = slotAnswer.slot;
+    if (!slotNumber) {
+        console.log((0, colors_1.YELLOW)('Operación cancelada.\n'));
+        return;
+    }
+    // 3. Prompt for API Key
+    const keyAnswer = await (0, prompts_1.default)({
+        type: 'password',
+        name: 'apiKey',
+        message: `Introduce la API Key para ${providerId.toUpperCase()} (Slot ${slotNumber}):`,
+        validate: (val) => (val && val.trim().length > 0 ? true : 'La API Key no puede estar vacía'),
+    });
+    const apiKey = keyAnswer.apiKey?.trim();
+    if (!apiKey) {
+        console.log((0, colors_1.YELLOW)('Operación cancelada.\n'));
+        return;
+    }
+    console.log((0, colors_1.CYAN)(`\n  Validando clave con ${providerId}...`));
+    try {
+        const health = await client.validateKey(providerId, slotNumber, apiKey);
+        if (health === 'healthy') {
+            console.log((0, colors_1.GREEN)(`\n  ✔ ¡API Key validada y guardada con éxito en el almacén seguro!`));
+            console.log((0, colors_1.DIM)(`  Proveedor: ${providerId} | Slot: ${slotNumber} | Estado: healthy\n`));
+        }
+        else {
+            console.log((0, colors_1.YELLOW)(`\n  ⚠ La clave fue procesada pero su estado es: ${health}\n`));
+        }
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`\n  ✖ Error al validar la API Key: ${err.message}\n`));
+    }
+}

package/dist/commands/browser.d.ts

@@ -0,0 +1,2 @@
+import type { AgentClient } from '../client/agent-client';
+export declare function handleBrowserCommand(client: AgentClient, args?: string): Promise<void>;

package/dist/commands/browser.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBrowserCommand = handleBrowserCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const colors_1 = require("../ui/colors");
+async function handleBrowserCommand(client, args) {
+    const parts = args ? args.trim().split(/\s+/) : [];
+    const subCommand = parts[0]?.toLowerCase();
+    const targetUrl = parts[1];
+    if (subCommand === 'open' && targetUrl) {
+        console.log((0, colors_1.CYAN)(`\n  Solicitando al agente abrir en navegador: ${targetUrl}...`));
+        client.sendUserText(`Por favor abre la siguiente URL en el navegador: ${targetUrl}`, `browser_${Date.now()}`);
+        console.log((0, colors_1.GREEN)(`  ✔ Comando enviado al agente.\n`));
+        return;
+    }
+    try {
+        const settings = await client.getSettings();
+        const engine = settings.browser_engine || 'chromium';
+        const headless = settings.browser_headless !== false;
+        console.log(`\n${(0, colors_1.BOLD)('🌐 Estado de Navegación y Browser Bridge:')}\n`);
+        console.log(`  Motor:       ${(0, colors_1.CYAN)(engine.toUpperCase())}`);
+        console.log(`  Modo:        ${headless ? chalk_1.default.yellow('Headless') : chalk_1.default.green('Ventana Visible')}`);
+        console.log(`  Descargas:   ${settings.block_downloads ? (0, colors_1.RED)('Bloqueadas') : (0, colors_1.GREEN)('Permitidas')}`);
+        console.log(`  Dominios:    ${settings.block_untrusted_domains ? (0, colors_1.YELLOW)('Filtrado Estricto') : (0, colors_1.GRAY)('Abierto')}`);
+        console.log(`\n  ${(0, colors_1.DIM)('Comandos disponibles:')}`);
+        console.log(`    ${(0, colors_1.CYAN)('/browser')}              ${(0, colors_1.DIM)('- Ver estado de navegación')}`);
+        console.log(`    ${(0, colors_1.CYAN)('/browser open <url>')}   ${(0, colors_1.DIM)('- Abrir URL con el agente')}\n`);
+    }
+    catch (err) {
+        console.log((0, colors_1.RED)(`  Error al consultar estado del navegador: ${err.message}\n`));
+    }
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { AgentClient } from '../client/agent-client';
+export declare function handleListMcp(client: AgentClient): Promise<void>;
+export declare function handleCreateMcp(client: AgentClient): Promise<void>;