fraim 2.0.159 → 2.0.160

package/dist/src/ai-hub/openclaw-bridge.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenClawAiHubBridge = void 0;
+const express_1 = __importDefault(require("express"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const axios_1 = __importDefault(require("axios"));
+function lastMessage(messages, role) {
+    return [...messages].reverse().find((message) => message.role === role);
+}
+function buildStatusLine(run) {
+    const status = run.status.toUpperCase();
+    const phase = run.currentPhase ? ` | phase: ${run.currentPhase}` : '';
+    return `${status} | ${run.jobId} | ${run.hostId}${phase}`;
+}
+function buildStagesLine(run) {
+    if (!run.stages?.length)
+        return null;
+    const line = run.stages
+        .map((stage) => {
+        const marker = stage.state === 'done' ? '[done]' : stage.state === 'current' ? '[now]' : '[todo]';
+        return `${marker} ${stage.label}`;
+    })
+        .join(' | ');
+    return line || null;
+}
+function buildBridgeReply(run) {
+    const replyParts = [buildStatusLine(run)];
+    const employee = lastMessage(run.messages, 'employee');
+    if (employee?.text)
+        replyParts.push(employee.text);
+    const stages = buildStagesLine(run);
+    if (stages)
+        replyParts.push(`Stages: ${stages}`);
+    return replyParts.join('\n\n');
+}
+class OpenClawAiHubBridge {
+    constructor(options) {
+        this.app = (0, express_1.default)();
+        this.threads = new Map();
+        this.api = axios_1.default.create({
+            baseURL: options.hubBaseUrl.replace(/\/$/, ''),
+            timeout: 5000,
+            validateStatus: () => true,
+        });
+        this.defaultProjectPath = options.defaultProjectPath;
+        this.defaultHostId = options.defaultHostId || 'codex';
+        this.defaultJobId = options.defaultJobId;
+        this.pollingIntervalMs = options.pollingIntervalMs ?? 40;
+        this.pollingTimeoutMs = options.pollingTimeoutMs ?? 4000;
+        this.threadStatePath = options.threadStatePath ? path_1.default.resolve(options.threadStatePath) : undefined;
+        this.missingJobReplyText = options.missingJobReplyText || 'Send /fraim <job-id> <request> to start a FRAIM thread.';
+        this.loadThreadState();
+        this.app.use(express_1.default.json());
+        this.registerRoutes();
+    }
+    async start(port) {
+        if (this.httpServer)
+            return;
+        await new Promise((resolve) => {
+            this.httpServer = this.app.listen(port, '127.0.0.1', () => resolve());
+        });
+    }
+    async stop() {
+        if (!this.httpServer)
+            return;
+        await new Promise((resolve, reject) => {
+            this.httpServer?.close((error) => (error ? reject(error) : resolve()));
+        });
+        this.httpServer = undefined;
+    }
+    registerRoutes() {
+        this.app.get('/api/openclaw-bridge/health', (_req, res) => {
+            res.json({ status: 'ok', service: 'openclaw-ai-hub-bridge', threadCount: this.threads.size });
+        });
+        this.app.get('/api/openclaw-bridge/threads', async (req, res) => {
+            try {
+                const channelId = String(req.query.channelId || 'telegram').trim();
+                const threadId = String(req.query.threadId || '').trim();
+                if (!threadId)
+                    return res.status(400).json({ error: 'threadId is required.' });
+                const state = this.threads.get(this.threadKey(channelId, threadId));
+                if (!state)
+                    return res.status(404).json({ error: 'Thread not found.' });
+                const run = await this.fetchRun(state.runId);
+                return res.json(this.presentThread(state, run));
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not load thread.' });
+            }
+        });
+        this.app.post('/api/openclaw-bridge/messages', async (req, res) => {
+            try {
+                const inbound = this.normalizeInbound(req.body);
+                if (!inbound.threadId)
+                    return res.status(400).json({ error: 'threadId is required.' });
+                if (!inbound.text)
+                    return res.status(400).json({ error: 'text is required.' });
+                const key = this.threadKey(inbound.channelId, inbound.threadId);
+                let state = this.threads.get(key);
+                let run;
+                const startedNewRun = !state;
+                if (!state) {
+                    const hostId = inbound.hostId || this.defaultHostId;
+                    const projectPath = inbound.projectPath || this.defaultProjectPath;
+                    const jobId = inbound.jobId || this.defaultJobId;
+                    const start = await this.api.post('/api/ai-hub/runs', {
+                        projectPath,
+                        hostId,
+                        ...(jobId ? { jobId } : {}),
+                        instructions: inbound.text,
+                    });
+                    if (start.status !== 201) {
+                        const errorText = typeof start.data?.error === 'string' ? start.data.error : '';
+                        if (!jobId && /choose a fraim job/i.test(errorText)) {
+                            return res.json({
+                                ok: true,
+                                startedNewRun: false,
+                                thread: null,
+                                outboundMessages: [{ text: this.missingJobReplyText }],
+                            });
+                        }
+                        return res.status(start.status || 400).json(start.data);
+                    }
+                    run = start.data;
+                    state = {
+                        channelId: inbound.channelId,
+                        threadId: inbound.threadId,
+                        runId: run.id,
+                        hostId,
+                        jobId: run.jobId,
+                        projectPath,
+                        lastSeenAt: new Date().toISOString(),
+                    };
+                    this.threads.set(key, state);
+                    this.persistThreadState();
+                }
+                else {
+                    const continued = await this.api.post(`/api/ai-hub/runs/${state.runId}/messages`, {
+                        instructions: inbound.text,
+                    });
+                    if (continued.status !== 200) {
+                        return res.status(continued.status || 400).json(continued.data);
+                    }
+                    run = continued.data;
+                    state.lastSeenAt = new Date().toISOString();
+                    this.persistThreadState();
+                }
+                const settled = await this.waitForSettlement(run.id);
+                return res.json({
+                    ok: true,
+                    startedNewRun,
+                    thread: this.presentThread(state, settled),
+                    outboundMessages: [{ text: buildBridgeReply(settled) }],
+                });
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not process message.' });
+            }
+        });
+    }
+    normalizeInbound(body) {
+        const context = body.context || {};
+        const metadata = context.metadata || {};
+        const metaThreadId = typeof metadata.threadId === 'string' ? metadata.threadId : null;
+        const metaChatId = typeof metadata.chatId === 'string' ? metadata.chatId : null;
+        const metaSenderId = typeof metadata.senderId === 'string' ? metadata.senderId : null;
+        return {
+            ...body,
+            channelId: String(body.channelId || context.channelId || 'telegram').trim(),
+            threadId: String(body.threadId || context.threadId || metaThreadId || body.chatId || body.senderId || metaChatId || metaSenderId || '').trim(),
+            text: String(body.text || context.content || '').trim(),
+        };
+    }
+    async fetchRun(runId) {
+        const response = await this.api.get(`/api/ai-hub/runs/${runId}`);
+        if (response.status !== 200) {
+            throw new Error(`AI Hub returned ${response.status} while loading run ${runId}.`);
+        }
+        return response.data;
+    }
+    async waitForSettlement(runId) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < this.pollingTimeoutMs) {
+            const run = await this.fetchRun(runId);
+            if (run.status !== 'running')
+                return run;
+            await new Promise((resolve) => setTimeout(resolve, this.pollingIntervalMs));
+        }
+        return this.fetchRun(runId);
+    }
+    presentThread(state, run) {
+        return {
+            channelId: state.channelId,
+            threadId: state.threadId,
+            runId: state.runId,
+            hostId: state.hostId,
+            jobId: state.jobId,
+            projectPath: state.projectPath,
+            status: run.status,
+            currentPhase: run.currentPhase || null,
+            stages: run.stages || [],
+            totals: run.totals || null,
+            latestManagerMessage: lastMessage(run.messages, 'manager')?.text || null,
+            latestEmployeeMessage: lastMessage(run.messages, 'employee')?.text || null,
+            transcript: run.messages.map((message) => ({
+                role: message.role,
+                text: message.text,
+                createdAt: message.createdAt,
+            })),
+        };
+    }
+    threadKey(channelId, threadId) {
+        return `${channelId}:${threadId}`;
+    }
+    loadThreadState() {
+        if (!this.threadStatePath || !fs_1.default.existsSync(this.threadStatePath))
+            return;
+        try {
+            const raw = JSON.parse(fs_1.default.readFileSync(this.threadStatePath, 'utf8'));
+            for (const thread of raw.threads || []) {
+                this.threads.set(this.threadKey(thread.channelId, thread.threadId), thread);
+            }
+        }
+        catch {
+            // Ignore corrupt or partial state and start fresh.
+        }
+    }
+    persistThreadState() {
+        if (!this.threadStatePath)
+            return;
+        fs_1.default.mkdirSync(path_1.default.dirname(this.threadStatePath), { recursive: true });
+        fs_1.default.writeFileSync(this.threadStatePath, JSON.stringify({ threads: [...this.threads.values()] }, null, 2), 'utf8');
+    }
+}
+exports.OpenClawAiHubBridge = OpenClawAiHubBridge;