@pixelbyte-software/pixcode 1.49.7 → 1.49.9

package/server/services/hermes-gateway.js

@@ -15,6 +15,8 @@ const DEFAULT_PORT = 8642;
 const PORT_SCAN_LIMIT = 80;
 const STARTUP_TIMEOUT_MS = 30000;
 const FETCH_TIMEOUT_MS = 5000;
+const RUN_TIMEOUT_MS = 120000;
+const RUN_POLL_INTERVAL_MS = 1000;
 const LOG_LIMIT = 800;
 
 const gateways = new Map();
@@ -47,6 +49,10 @@ function makeApiServerKey() {
     return `pixcode-hermes-${randomBytes(24).toString('hex')}`;
 }
 
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 export function buildHermesGatewayEnv(baseEnv = process.env, options = {}) {
     const host = options.host || DEFAULT_HOST;
     const port = String(options.port || DEFAULT_PORT);
@@ -124,13 +130,127 @@ async function callGateway(gateway, endpoint, options = {}) {
     });
 }
 
+function extractRunId(body) {
+    if (!body || typeof body !== 'object') return null;
+    return body.run_id || body.runId || body.id || body.run?.id || null;
+}
+
+function extractRunStatus(body) {
+    if (!body || typeof body !== 'object') return null;
+    return body.status || body.state || body.run?.status || body.run?.state || null;
+}
+
+function extractTextFromValue(value) {
+    if (typeof value === 'string') return value;
+    if (!value) return null;
+
+    if (Array.isArray(value)) {
+        return value
+            .map(extractTextFromValue)
+            .filter(Boolean)
+            .join('\n')
+            .trim() || null;
+    }
+
+    if (typeof value === 'object') {
+        for (const key of ['text', 'content', 'message', 'output', 'response', 'result', 'final']) {
+            const text = extractTextFromValue(value[key]);
+            if (text) return text;
+        }
+    }
+
+    return null;
+}
+
+function extractRunOutput(body) {
+    if (!body || typeof body !== 'object') return null;
+
+    for (const key of ['output_text', 'output', 'response', 'result', 'message', 'messages', 'events', 'final']) {
+        const text = extractTextFromValue(body[key]);
+        if (text) return text;
+    }
+
+    return null;
+}
+
+function extractChatCompletionOutput(body) {
+    if (!body || typeof body !== 'object') return null;
+    const choices = Array.isArray(body.choices) ? body.choices : [];
+    for (const choice of choices) {
+        const text = extractTextFromValue(choice?.message?.content)
+            || extractTextFromValue(choice?.delta?.content)
+            || extractTextFromValue(choice?.text);
+        if (text) return text;
+    }
+    return extractTextFromValue(body.output_text)
+        || extractTextFromValue(body.output)
+        || extractTextFromValue(body.message)
+        || extractTextFromValue(body.response)
+        || null;
+}
+
+function recentGatewayLogText(gateway) {
+    if (!gateway?.logs?.length) return '';
+    return gateway.logs
+        .slice(-16)
+        .map((entry) => String(entry.chunk || '').trim())
+        .filter(Boolean)
+        .join('\n')
+        .trim();
+}
+
+function gatewayExitMessage(gateway, fallback = 'Hermes gateway is not running.') {
+    if (!gateway) return fallback;
+    const exit = gateway.exitSignal
+        ? `Hermes gateway exited with signal ${gateway.exitSignal}.`
+        : `Hermes gateway exited with code ${gateway.exitCode ?? 'unknown'}.`;
+    const logs = recentGatewayLogText(gateway);
+    return logs ? `${exit}\n${logs}` : (gateway.error || exit);
+}
+
+function makeRunRequest(options) {
+    const input = String(options.input || '').trim();
+    return {
+        session_id: options.sessionId || `pixcode-hermes-chat-${Date.now()}-${randomBytes(4).toString('hex')}`,
+        input,
+        instructions: options.instructions || [
+            'You are Hermes Agent running inside Pixcode.',
+            'Use Pixcode MCP tools when they help inspect projects, launch CLIs, or perform workspace actions.',
+            'Keep answers concise and include concrete next steps when work is blocked.',
+        ].join(' '),
+    };
+}
+
+function makeChatCompletionRequest(options) {
+    const input = String(options.input || '').trim();
+    const messages = Array.isArray(options.messages) ? options.messages : [
+        {
+            role: 'system',
+            content: options.instructions || [
+                'You are Hermes Agent running inside Pixcode.',
+                'Use Pixcode MCP tools when they help inspect projects, launch CLIs, or perform workspace actions.',
+                'Keep answers concise and include concrete next steps when work is blocked.',
+            ].join(' '),
+        },
+        {
+            role: 'user',
+            content: input,
+        },
+    ];
+    return {
+        model: options.model || 'hermes-agent',
+        messages,
+        stream: false,
+    };
+}
+
 async function waitForGatewayReady(gateway) {
     const started = Date.now();
     let lastError = null;
 
     while (Date.now() - started < STARTUP_TIMEOUT_MS) {
         if (!isGatewayRunning(gateway)) {
-            throw new Error(gateway.error || `Hermes gateway exited with code ${gateway.exitCode ?? 'unknown'}.`);
+            throw new Error(gatewayExitMessage(gateway));
         }
 
         try {
@@ -382,6 +502,130 @@ export async function probeHermesGateway(projectPath, options = {}) {
     return result;
 }
 
+export async function runHermesGatewayPrompt(projectPath, options = {}) {
+    const gateway = projectPath
+        ? gateways.get(normalizeProjectPath(projectPath))
+        : Array.from(gateways.values()).find(isGatewayRunning);
+
+    if (!isGatewayRunning(gateway)) {
+        throw new Error('Hermes gateway is not running.');
+    }
+
+    const input = String(options.input || '').trim();
+    if (!input) {
+        throw new Error('Hermes prompt is required.');
+    }
+
+    const chatRequest = makeChatCompletionRequest({ ...options, input });
+    const chat = await callGateway(gateway, '/v1/chat/completions', {
+        method: 'POST',
+        body: JSON.stringify(chatRequest),
+        timeoutMs: options.chatTimeoutMs || options.timeoutMs || RUN_TIMEOUT_MS,
+    }).catch((error) => {
+        if (!isGatewayRunning(gateway)) {
+            throw new Error(gatewayExitMessage(gateway));
+        }
+        throw error;
+    });
+
+    if (!isGatewayRunning(gateway)) {
+        throw new Error(gatewayExitMessage(gateway));
+    }
+
+    if (chat.ok) {
+        const message = extractChatCompletionOutput(chat.body);
+        return {
+            ok: true,
+            projectPath: gateway.projectPath,
+            baseUrl: gateway.baseUrl,
+            sessionId: options.sessionId || null,
+            runId: null,
+            status: 'completed',
+            message,
+            raw: chat.body,
+            transport: 'chat.completions',
+        };
+    }
+
+    if (chat.status && chat.status !== 404 && chat.status !== 405) {
+        throw new Error(`Hermes /v1/chat/completions failed with HTTP ${chat.status}: ${JSON.stringify(chat.body)}`);
+    }
+
+    const request = makeRunRequest({ ...options, input });
+    const create = await callGateway(gateway, '/v1/runs', {
+        method: 'POST',
+        body: JSON.stringify(request),
+        timeoutMs: options.createTimeoutMs || 15000,
+    }).catch((error) => {
+        if (!isGatewayRunning(gateway)) {
+            throw new Error(gatewayExitMessage(gateway));
+        }
+        throw error;
+    });
+
+    if (!isGatewayRunning(gateway)) {
+        throw new Error(gatewayExitMessage(gateway));
+    }
+
+    if (!create.ok) {
+        throw new Error(`Hermes /v1/runs failed with HTTP ${create.status}: ${JSON.stringify(create.body)}`);
+    }
+
+    const runId = extractRunId(create.body);
+    const initialStatus = extractRunStatus(create.body);
+    if (!runId) {
+        return {
+            ok: true,
+            projectPath: gateway.projectPath,
+            baseUrl: gateway.baseUrl,
+            sessionId: request.session_id,
+            runId: null,
+            status: initialStatus || 'completed',
+            message: extractRunOutput(create.body),
+            raw: create.body,
+            transport: 'runs',
+        };
+    }
+
+    const terminalStatuses = new Set(['completed', 'failed', 'cancelled', 'canceled']);
+    const started = Date.now();
+    let latest = create.body;
+    let status = initialStatus || 'queued';
+
+    while (!terminalStatuses.has(String(status)) && Date.now() - started < (options.timeoutMs || RUN_TIMEOUT_MS)) {
+        await sleep(options.pollIntervalMs || RUN_POLL_INTERVAL_MS);
+        const poll = await callGateway(gateway, `/v1/runs/${encodeURIComponent(runId)}`, {
+            timeoutMs: options.pollTimeoutMs || 15000,
+        });
+        if (!poll.ok) {
+            throw new Error(`Hermes /v1/runs/${runId} failed with HTTP ${poll.status}: ${JSON.stringify(poll.body)}`);
+        }
+        if (!isGatewayRunning(gateway)) {
+            throw new Error(gatewayExitMessage(gateway));
+        }
+        latest = poll.body;
+        status = extractRunStatus(latest) || status;
+    }
+
+    if (!terminalStatuses.has(String(status))) {
+        throw new Error(`Hermes run did not finish within ${Math.round((options.timeoutMs || RUN_TIMEOUT_MS) / 1000)}s: ${runId}`);
+    }
+
+    const message = extractRunOutput(latest);
+    return {
+        ok: status === 'completed',
+        projectPath: gateway.projectPath,
+        baseUrl: gateway.baseUrl,
+        sessionId: request.session_id,
+        runId,
+        status,
+        message,
+        error: status === 'completed' ? null : extractTextFromValue(latest?.error) || message || 'Hermes run failed.',
+        raw: latest,
+        transport: 'runs',
+    };
+}
+
 export function stopHermesGateway(projectPath) {
     const targets = projectPath
         ? [gateways.get(normalizeProjectPath(projectPath))].filter(Boolean)