overmind-mcp 2.8.13 → 2.8.14

package/dist/bridge/OverBridgeServer.js

@@ -20,9 +20,16 @@
  */
 import http from 'node:http';
 import { URL } from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs';
 import { z } from 'zod';
 import { AgentRegistry } from './AgentRegistry.js';
 import { MessageLog } from './MessageLog.js';
+import { SessionStore } from './SessionStore.js';
+import { DirectiveParser } from './DirectiveParser.js';
+import { WebhookAdapter } from './WebhookAdapter.js';
+import { sanitizeAndParse, looksLikeWindowsPathIssue } from './JsonSanitizer.js';
+import { getOrCreateRequestId } from './RequestContext.js';
 import { createBridgeLogger, validateAgentName } from './utils.js';
 const JSON_RPC_ERRORS = {
     PARSE_ERROR: { code: -32700, message: 'Parse error' },
@@ -44,6 +51,10 @@ const RunAgentParams = z.object({
     mode: z.string().optional(),
     silent: z.boolean().optional(),
     metadata: z.record(z.string(), z.unknown()).optional(),
+    /** Clé externe pour SessionStore (phone, userId, etc.) — auto-résolution de sessionId */
+    externalKey: z.string().optional(),
+    /** Active le parsing de directives dans la réponse (default: true si enableDirectives) */
+    parseDirectives: z.boolean().optional(),
 });
 const A2AParams = z.object({
     fromAgent: z.string().min(1),
@@ -85,6 +96,9 @@ export class OverBridgeServer {
     registry;
     log;
     messageLog;
+    sessions;
+    directiveParser;
+    webhookAdapter;
     config;
     server;
     startTime = 0;
@@ -93,13 +107,22 @@ export class OverBridgeServer {
         this.config = config;
         this.log = logger ?? createBridgeLogger('overbridge-server');
         this.registry = new AgentRegistry(this.log);
+        this.directiveParser = new DirectiveParser({ logger: this.log });
+        this.webhookAdapter = new WebhookAdapter({ logger: this.log });
         if (config.enableMessageLog) {
             this.messageLog = new MessageLog(config.postgres, this.log);
         }
+        if (config.enableSessionStore) {
+            const defaultPath = path.join(process.env.HOME ?? process.env.USERPROFILE ?? '.', '.overmind', 'bridge', 'sessions.json');
+            this.sessions = new SessionStore({
+                persistPath: config.sessionStorePath ?? defaultPath,
+                ttlMs: config.sessionTtlMs,
+            }, this.log);
+        }
     }
     // ─── Lifecycle ───────────────────────────────────────────────────────────
     /**
-     * Démarre le serveur HTTP et initialise les dépendances (MessageLog, OverBridgeService).
+     * Démarre le serveur HTTP et initialise les dépendances (MessageLog, SessionStore, OverBridgeService).
      */
     async start() {
         this.startTime = Date.now();
@@ -107,7 +130,11 @@ export class OverBridgeServer {
         if (this.messageLog) {
             await this.messageLog.init();
         }
-        // 2) Connect OverBridgeService (MCP healthcheck)
+        // 2) Init SessionStore
+        if (this.sessions) {
+            await this.sessions.init();
+        }
+        // 3) Connect OverBridgeService (MCP healthcheck)
         try {
             const status = await this.service.connect(this.config.healthCheckIntervalMs);
             this.log.info(`🔌 OverBridgeService connected: ${status.status}`);
@@ -116,7 +143,7 @@ export class OverBridgeServer {
             this.log.warn(`⚠️  OverBridgeService connect failed: ${err.message}`);
             // On continue quand même, le serveur répondra avec erreurs si MCP down
         }
-        // 3) Démarre le serveur HTTP
+        // 4) Démarre le serveur HTTP
         this.server = http.createServer((req, res) => this.handleRequest(req, res));
         await new Promise((resolve) => {
             this.server.listen(this.config.port, this.config.host, () => resolve());
@@ -127,6 +154,15 @@ export class OverBridgeServer {
         this.log.info(`🚀 OverBridgeServer listening on ${url}`);
         this.log.info(`   POST ${url}/rpc   (JSON-RPC 2.0)`);
         this.log.info(`   GET  ${url}/health`);
+        if (this.config.enableWebhooks) {
+            this.log.info(`   POST ${url}/webhook/:provider   (voipms, twilio, discord, generic)`);
+        }
+        if (this.sessions) {
+            this.log.info(`   SessionStore: enabled (TTL ${(this.config.sessionTtlMs ?? 14_400_000) / 1000}s)`);
+        }
+        if (this.config.enableDirectives) {
+            this.log.info(`   DirectiveParser: enabled (SESSION_ID, CONTEXT_UPDATE, BRIDGE_NEXT)`);
+        }
         return { port, host: this.config.host, url };
     }
     /**
@@ -142,6 +178,9 @@ export class OverBridgeServer {
         if (this.messageLog) {
             await this.messageLog.close();
         }
+        if (this.sessions) {
+            await this.sessions.close();
+        }
     }
     /**
      * Expose le registry (pour tests / inspection).
@@ -155,9 +194,18 @@ export class OverBridgeServer {
     get messages() {
         return this.messageLog;
     }
+    /**
+     * Expose le SessionStore (pour tests / inspection).
+     */
+    get sessionStore() {
+        return this.sessions;
+    }
     // ─── HTTP Request Handler ───────────────────────────────────────────────
     async handleRequest(req, res) {
         const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+        const reqId = getOrCreateRequestId(req.headers);
+        // Set reqId header in response
+        res.setHeader('X-Request-Id', reqId);
         // CORS preflight
         if (req.method === 'OPTIONS') {
             this.writeCors(res);
@@ -174,15 +222,25 @@ export class OverBridgeServer {
             }
             // JSON-RPC endpoint
             if (req.method === 'POST' && url.pathname === '/rpc') {
-                await this.handleRpc(req, res);
+                await this.handleRpc(req, res, reqId);
+                return;
+            }
+            // Webhook endpoint (si activé) — /webhook/:provider
+            if (this.config.enableWebhooks && req.method === 'POST' && url.pathname.startsWith('/webhook/')) {
+                await this.handleWebhook(req, res, url, reqId);
+                return;
+            }
+            // File serve — /f/:filename (statique, comme bt-sms)
+            if (req.method === 'GET' && url.pathname.startsWith('/f/')) {
+                await this.handleStaticFile(req, res, url);
                 return;
             }
             // 404
-            this.writeJson(res, 404, { error: 'Not found', path: url.pathname });
+            this.writeJson(res, 404, { error: 'Not found', path: url.pathname, reqId });
         }
         catch (err) {
-            this.log.error(`💥 Unhandled error: ${err.message}`);
-            this.writeJson(res, 500, { error: 'Internal server error' });
+            this.log.error(`💥 Unhandled error: ${err.message} (reqId=${reqId})`);
+            this.writeJson(res, 500, { error: 'Internal server error', reqId });
         }
     }
     writeCors(res) {
@@ -194,6 +252,77 @@ export class OverBridgeServer {
         res.writeHead(status, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(body));
     }
+    // ─── /webhook/:provider Endpoint ─────────────────────────────────────────
+    async handleWebhook(req, res, url, reqId) {
+        // /webhook/:provider — extrait le provider du path
+        const parts = url.pathname.split('/').filter(Boolean);
+        const provider = (parts[1] ?? 'voipms');
+        const raw = await this.readBody(req);
+        let payload;
+        try {
+            payload = JSON.parse(raw);
+        }
+        catch {
+            // Tente sanitizer (VoIP.ms envoie parfois du form-encoded mal formé)
+            try {
+                payload = sanitizeAndParse(raw);
+            }
+            catch {
+                this.writeJson(res, 400, { error: 'Invalid JSON body', reqId });
+                return;
+            }
+        }
+        // Adapte via WebhookAdapter
+        const adapter = new WebhookAdapter({ provider, logger: this.log });
+        let normalized;
+        try {
+            normalized = adapter.adapt(payload);
+        }
+        catch (err) {
+            this.writeJson(res, 400, { error: err.message, reqId });
+            return;
+        }
+        // Auto-dispatch vers agent.run via internal call
+        this.log.info(`[reqId=${reqId}] 📨 Webhook ${provider} from ${normalized.externalKey}`);
+        // Cherche un agent par défaut (config-driven ou fallback premier agent)
+        // Pour l'instant on retourne le normalized et on log ; les utilisateurs
+        // peuvent soit :
+        //   1. Définir une config par-provider pour auto-dispatch
+        //   2. Appeler manuellement /rpc agent.run après réception
+        this.writeJson(res, 200, {
+            received: true,
+            reqId,
+            provider,
+            externalKey: normalized.externalKey,
+            promptPreview: normalized.prompt.slice(0, 200),
+            mediaCount: normalized.mediaUrls.length,
+            metadata: normalized.metadata,
+        });
+    }
+    // ─── /f/:filename Static File Serve ──────────────────────────────────────
+    async handleStaticFile(_req, res, url) {
+        const filename = url.pathname.slice(3); // strip /f/
+        if (!filename || filename.includes('..')) {
+            this.writeJson(res, 400, { error: 'Invalid filename' });
+            return;
+        }
+        // Le dossier est configuré via BRIDGE_STATIC_DIR env ou défaut './public'
+        const staticDir = process.env.BRIDGE_STATIC_DIR ?? './public';
+        const filepath = path.join(staticDir, filename);
+        if (!fs.existsSync(filepath)) {
+            this.writeJson(res, 404, { error: 'Not found' });
+            return;
+        }
+        const ext = path.extname(filepath).toLowerCase();
+        const mimeMap = {
+            '.html': 'text/html', '.pdf': 'application/pdf', '.png': 'image/png',
+            '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.json': 'application/json',
+            '.txt': 'text/plain', '.mp3': 'audio/mpeg', '.mp4': 'video/mp4',
+            '.gif': 'image/gif', '.wav': 'audio/wav', '.xml': 'text/xml',
+        };
+        res.setHeader('Content-Type', mimeMap[ext] ?? 'application/octet-stream');
+        fs.createReadStream(filepath).pipe(res);
+    }
     // ─── /health Endpoint ───────────────────────────────────────────────────
     async handleHealth(res) {
         const mcpHealth = await this.service.proxyAccess.healthCheck();
@@ -207,17 +336,26 @@ export class OverBridgeServer {
                 msgStats = null;
             }
         }
+        const sessionStats = this.sessions ? this.sessions.stats() : null;
         this.writeJson(res, 200, {
             status: mcpHealth.status,
             uptime: Date.now() - this.startTime,
             mcp: mcpHealth,
             agents: regStats,
             messages: msgStats,
-            version: '1.0.0',
+            sessions: sessionStats,
+            features: {
+                sessionStore: !!this.sessions,
+                directives: !!this.config.enableDirectives,
+                webhooks: !!this.config.enableWebhooks,
+                sanitizeJson: !!this.config.sanitizeJson,
+                messageLog: !!this.messageLog,
+            },
+            version: '1.1.0',
         });
     }
     // ─── /rpc Endpoint (JSON-RPC 2.0 Dispatcher) ────────────────────────────
-    async handleRpc(req, res) {
+    async handleRpc(req, res, reqId) {
         // Auth check
         if (this.config.authToken) {
             const auth = req.headers.authorization;
@@ -225,7 +363,7 @@ export class OverBridgeServer {
                 this.writeJson(res, 401, {
                     jsonrpc: '2.0',
                     id: null,
-                    error: { code: -32000, message: 'Unauthorized' },
+                    error: { code: -32000, message: 'Unauthorized', data: { reqId } },
                 });
                 return;
             }
@@ -234,12 +372,39 @@ export class OverBridgeServer {
         const raw = await this.readBody(req);
         let parsed;
         try {
+            // Try direct parse first
             parsed = JSON.parse(raw);
         }
         catch {
-            this.respondError(res, null, JSON_RPC_ERRORS.PARSE_ERROR);
-            return;
+            // Si sanitizer activé et body ressemble à un Windows path, on tente la repair
+            if (this.config.sanitizeJson && looksLikeWindowsPathIssue(raw)) {
+                try {
+                    parsed = sanitizeAndParse(raw);
+                    this.log.warn(`[reqId=${reqId}] ⚠️  JSON body sanitized (Windows path issue)`);
+                }
+                catch {
+                    this.respondError(res, null, JSON_RPC_ERRORS.PARSE_ERROR);
+                    return;
+                }
+            }
+            else {
+                this.respondError(res, null, JSON_RPC_ERRORS.PARSE_ERROR);
+                return;
+            }
         }
+        // Inject reqId into all calls (pour corrélation)
+        const injectReqId = (reqs) => {
+            const inject = (r) => {
+                if (!r.params)
+                    r.params = {};
+                r.params.__reqId = reqId;
+            };
+            if (Array.isArray(reqs))
+                reqs.forEach(inject);
+            else
+                inject(reqs);
+        };
+        injectReqId(parsed);
         // Batch ou single
         if (Array.isArray(parsed)) {
             if (parsed.length === 0) {
@@ -282,6 +447,16 @@ export class OverBridgeServer {
                     return this.methodMessageReplay(req);
                 case 'message.stats':
                     return this.methodMessageStats(req);
+                case 'session.get':
+                    return this.methodSessionGet(req);
+                case 'session.list':
+                    return this.methodSessionList(req);
+                case 'session.delete':
+                    return this.methodSessionDelete(req);
+                case 'session.stats':
+                    return this.methodSessionStats(req);
+                case 'webhook.sms':
+                    return this.methodWebhookSms(req);
                 case 'health.ping':
                     return { jsonrpc: '2.0', id: req.id ?? null, result: { pong: true, ts: Date.now() } };
                 default:
@@ -300,15 +475,26 @@ export class OverBridgeServer {
     // ─── RPC Methods ─────────────────────────────────────────────────────────
     /**
      * agent.run — Lance un agent (from client externe OU from autre agent).
+     * Avec support SessionStore (externalKey) et DirectiveParser.
      */
     async methodAgentRun(req) {
         const params = this.validateParams(RunAgentParams, req.params, req.id);
         if (!params.ok)
             return params.response;
-        const { agentName, runner, prompt, sessionId, path, model, mode, silent, metadata } = params.data;
+        const { agentName, runner, prompt, sessionId, path, model, mode, silent, metadata, externalKey, parseDirectives } = params.data;
         const validatedAgentName = validateAgentName(agentName);
+        const reqId = req.params?.__reqId;
         // Register
         this.registry.register(validatedAgentName, runner);
+        // SessionStore resolution (si externalKey fourni)
+        let effectiveSessionId = sessionId;
+        if (this.sessions && externalKey) {
+            const stored = this.sessions.get(externalKey, validatedAgentName);
+            if (stored) {
+                effectiveSessionId = stored.sessionId;
+                this.log.info(`[reqId=${reqId}] 🔗 Session restored for ${externalKey} → ${effectiveSessionId}`);
+            }
+        }
         // Persist (pending)
         let messageId;
         if (this.messageLog) {
@@ -317,39 +503,79 @@ export class OverBridgeServer {
                 toAgent: validatedAgentName,
                 runner: runner,
                 prompt,
-                sessionId,
-                metadata: metadata ?? null,
+                sessionId: effectiveSessionId,
+                metadata: { ...(metadata ?? {}), ...(reqId ? { reqId } : {}), ...(externalKey ? { externalKey } : {}) },
             });
         }
         // Run avec mutex (1 run par agent à la fois)
         const result = await this.registry.withLock(validatedAgentName, async () => {
-            this.registry.markBusy(validatedAgentName, sessionId);
+            this.registry.markBusy(validatedAgentName, effectiveSessionId);
             if (messageId && this.messageLog) {
-                await this.messageLog.markRunning(messageId, sessionId);
+                await this.messageLog.markRunning(messageId, effectiveSessionId);
             }
             try {
                 const agentResult = await this.service.runAgent({
                     runner: runner,
                     prompt,
                     agentName: validatedAgentName,
-                    sessionId,
+                    sessionId: effectiveSessionId,
                     path,
                     model,
                     mode,
                     silent,
                 });
-                const responseText = agentResult.content.map((c) => c.text).join('\n');
+                const rawResponseText = agentResult.content.map((c) => c.text).join('\n');
+                // ─── Directive parsing ─────────────────────────────────────────
+                let cleanText = rawResponseText;
+                let directives;
+                const shouldParseDirectives = parseDirectives ?? this.config.enableDirectives;
+                if (shouldParseDirectives) {
+                    directives = this.directiveParser.parse(rawResponseText);
+                    cleanText = directives.cleanText;
+                    for (const action of directives.actions) {
+                        if (action.kind === 'session' && this.sessions && externalKey) {
+                            this.sessions.updateSessionId(externalKey, validatedAgentName, action.sessionId, runner);
+                            this.log.info(`[reqId=${reqId}] 🔗 SESSION_ID directive → ${action.sessionId}`);
+                        }
+                        else if (action.kind === 'context' && this.sessions && externalKey) {
+                            this.sessions.updateContext(externalKey, validatedAgentName, action.patch);
+                            this.log.info(`[reqId=${reqId}] 📝 CONTEXT_UPDATE directive → ${JSON.stringify(action.patch)}`);
+                        }
+                        else if (action.kind === 'hint') {
+                            this.log.info(`[reqId=${reqId}] 💡 BRIDGE_HINT: ${action.text}`);
+                        }
+                    }
+                }
+                // Save session
+                if (this.sessions && externalKey && agentResult.sessionId) {
+                    this.sessions.set({
+                        externalKey,
+                        agentName: validatedAgentName,
+                        runner: runner,
+                        sessionId: agentResult.sessionId,
+                        context: directives?.actions.find((a) => a.kind === 'context')
+                            ? directives.actions.find((a) => a.kind === 'context').patch
+                            : undefined,
+                    });
+                }
                 if (messageId && this.messageLog) {
-                    await this.messageLog.markDone(messageId, responseText, agentResult.sessionId);
+                    await this.messageLog.markDone(messageId, cleanText, agentResult.sessionId);
                 }
                 this.registry.markIdle(validatedAgentName, !agentResult.isError);
                 if (!agentResult.isError)
                     this.registry.markOnline(validatedAgentName);
+                // Return content nettoyé des directives (si parsing activé)
+                const resultContent = shouldParseDirectives
+                    ? [{ type: 'text', text: cleanText }]
+                    : agentResult.content;
                 return {
                     messageId,
                     sessionId: agentResult.sessionId,
-                    content: agentResult.content,
+                    content: resultContent,
                     isError: agentResult.isError,
+                    directives: shouldParseDirectives
+                        ? directives?.actions.map((a) => a.kind)
+                        : undefined,
                 };
             }
             catch (err) {
@@ -589,6 +815,84 @@ export class OverBridgeServer {
         const stats = await this.messageLog.stats();
         return { jsonrpc: '2.0', id: req.id ?? null, result: stats };
     }
+    // ─── SessionStore RPC Methods ───────────────────────────────────────────
+    async methodSessionGet(req) {
+        if (!this.sessions) {
+            return { jsonrpc: '2.0', id: req.id ?? null, error: { code: -32003, message: 'SessionStore disabled' } };
+        }
+        const params = this.validateParams(z.object({ externalKey: z.string().min(1), agentName: z.string().min(1) }), req.params, req.id);
+        if (!params.ok)
+            return params.response;
+        const entry = this.sessions.get(params.data.externalKey, params.data.agentName);
+        return { jsonrpc: '2.0', id: req.id ?? null, result: { session: entry } };
+    }
+    async methodSessionList(_req) {
+        if (!this.sessions) {
+            return { jsonrpc: '2.0', id: _req.id ?? null, error: { code: -32003, message: 'SessionStore disabled' } };
+        }
+        const list = this.sessions.list();
+        const stats = this.sessions.stats();
+        return { jsonrpc: '2.0', id: _req.id ?? null, result: { sessions: list, stats } };
+    }
+    async methodSessionDelete(req) {
+        if (!this.sessions) {
+            return { jsonrpc: '2.0', id: req.id ?? null, error: { code: -32003, message: 'SessionStore disabled' } };
+        }
+        const params = this.validateParams(z.object({ externalKey: z.string().min(1), agentName: z.string().min(1) }), req.params, req.id);
+        if (!params.ok)
+            return params.response;
+        const deleted = this.sessions.delete(params.data.externalKey, params.data.agentName);
+        return { jsonrpc: '2.0', id: req.id ?? null, result: { deleted } };
+    }
+    async methodSessionStats(_req) {
+        if (!this.sessions) {
+            return { jsonrpc: '2.0', id: _req.id ?? null, error: { code: -32003, message: 'SessionStore disabled' } };
+        }
+        return { jsonrpc: '2.0', id: _req.id ?? null, result: this.sessions.stats() };
+    }
+    // ─── Webhook RPC Method (programmatic, sans passer par HTTP) ────────────
+    async methodWebhookSms(req) {
+        const params = this.validateParams(z.object({
+            provider: z.enum(['voipms', 'twilio', 'discord', 'generic']).default('voipms'),
+            payload: z.record(z.string(), z.unknown()),
+            externalKey: z.string().optional(),
+            /** Si fourni, dispatch automatique vers agent.run après adaptation */
+            autoDispatch: z.object({
+                agentName: z.string().min(1),
+                runner: z.string().min(1),
+                model: z.string().optional(),
+                mode: z.string().optional(),
+            }).optional(),
+        }), req.params, req.id);
+        if (!params.ok)
+            return params.response;
+        const adapter = new WebhookAdapter({ provider: params.data.provider, logger: this.log });
+        const normalized = adapter.adapt(params.data.payload);
+        const externalKey = params.data.externalKey ?? normalized.externalKey;
+        if (!params.data.autoDispatch) {
+            return {
+                jsonrpc: '2.0',
+                id: req.id ?? null,
+                result: { externalKey, prompt: normalized.prompt, mediaUrls: normalized.mediaUrls, metadata: normalized.metadata },
+            };
+        }
+        // Auto-dispatch vers agent.run
+        const innerReq = {
+            jsonrpc: '2.0',
+            id: req.id,
+            method: 'agent.run',
+            params: {
+                agentName: params.data.autoDispatch.agentName,
+                runner: params.data.autoDispatch.runner,
+                prompt: normalized.prompt,
+                model: params.data.autoDispatch.model,
+                mode: params.data.autoDispatch.mode,
+                externalKey,
+                metadata: { webhook: true, provider: params.data.provider, ...normalized.metadata },
+            },
+        };
+        return this.methodAgentRun(innerReq);
+    }
     // ─── Helpers ────────────────────────────────────────────────────────────
     /**
      * Valide les params d'une requête JSON-RPC via Zod.
@@ -625,14 +929,38 @@ export class OverBridgeServer {
             },
         };
     }
-    readBody(req) {
+    readBody(req, maxBytes) {
+        const limit = maxBytes ?? this.parseBodyLimit(this.config.jsonBodyLimit);
         return new Promise((resolve, reject) => {
             const chunks = [];
-            req.on('data', (chunk) => chunks.push(chunk));
+            let total = 0;
+            req.on('data', (chunk) => {
+                total += chunk.length;
+                if (total > limit) {
+                    req.destroy();
+                    reject(Object.assign(new Error('Request body too large'), { code: 'EBODYTOOLARGE' }));
+                    return;
+                }
+                chunks.push(chunk);
+            });
             req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
             req.on('error', reject);
         });
     }
+    /**
+     * Parse "10mb" / "1gb" en bytes.
+     */
+    parseBodyLimit(limit) {
+        if (!limit)
+            return 10 * 1024 * 1024; // 10mb default
+        const m = limit.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i);
+        if (!m)
+            return 10 * 1024 * 1024;
+        const num = Number(m[1]);
+        const unit = (m[2] ?? 'b').toLowerCase();
+        const mult = { b: 1, kb: 1024, mb: 1024 ** 2, gb: 1024 ** 3 };
+        return Math.floor(num * (mult[unit] ?? 1));
+    }
     /**
      * Parse le retour de agent_control pour extraire le status de l'agent distant.
      */