@luckydraw/cumulus 0.27.17 → 0.27.19

package/dist/gateway/server.js

@@ -17,15 +17,14 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as os from 'os';
 import * as path from 'path';
-import { WebSocketServer } from 'ws';
 import { loadThreadConfig, saveThreadConfig } from '../lib/config.js';
 import { loadEmbeddings, generateMissingEmbeddings } from '../lib/embeddings.js';
-import { ExecutorRegistry } from '../lib/executor.js';
 import { sendMessage, getOrCreateThread, clearThreadCache, } from '../lib/gateway.js';
 import { catchUpSegmentation, loadSegmentBoundaries, saveSegmentBoundaries, } from '../lib/segments.js';
 import { listTemplates, scaffoldFromTemplate } from '../lib/templates.js';
 import { serveStaticFile } from './adapters/webchat.js';
 import { authenticate } from './auth.js';
+import { configureVapid, sendNotification, subscribe as pushSubscribe, unsubscribe as pushUnsubscribe, } from './push.js';
 const threadQueues = new Map();
 const threadBusy = new Map();
 function enqueue(threadName, item) {
@@ -86,7 +85,6 @@ async function processMessage(threadName, item, opts) {
             projectRoot: opts.projectRoot,
             extraMcpServers: opts.extraMcpServers,
             gatewayAgentsConfig: opts.gatewayAgentsConfig,
-            executorRegistry: opts.executorRegistry,
             signal: ac.signal,
             onToken: text => sendSSE('token', { text }),
             onSegment: segment => sendSSE('segment', segment),
@@ -204,7 +202,6 @@ async function handleAgentInject(req, res, pipelineOpts) {
             await getOrCreateThread(targetName);
             // Send as a message through the pipeline (fire-and-forget)
             threadBusy.set(targetName, true);
-            const broadcast = pipelineOpts.broadcastToThread;
             sendMessage({
                 threadName: targetName,
                 message: formatted,
@@ -214,35 +211,6 @@ async function handleAgentInject(req, res, pipelineOpts) {
                 projectRoot: pipelineOpts.projectRoot,
                 extraMcpServers: pipelineOpts.extraMcpServers,
                 gatewayAgentsConfig: pipelineOpts.gatewayAgentsConfig,
-                executorRegistry: pipelineOpts.executorRegistry,
-            })
-                .then(result => {
-                // Notify connected clients that new messages arrived on this thread
-                console.log(`[Gateway] Agent inject completed for "${targetName}", broadcast=${!!broadcast}, result=${!!result}`);
-                if (broadcast && result) {
-                    const newMessages = [];
-                    if (result.userMessage) {
-                        newMessages.push({ id: result.userMessage.id, role: 'user', content: formatted });
-                    }
-                    if (result.assistantMessage) {
-                        newMessages.push({
-                            id: result.assistantMessage.id,
-                            role: 'assistant',
-                            content: result.response,
-                        });
-                    }
-                    if (newMessages.length > 0) {
-                        console.log(`[Gateway] Broadcasting new_messages to "${targetName}": ${newMessages.length} messages`);
-                        broadcast(targetName, {
-                            type: 'new_messages',
-                            threadName: targetName,
-                            messages: newMessages,
-                        });
-                    }
-                }
-                else if (!broadcast) {
-                    console.warn(`[Gateway] No broadcast function — agent inject for "${targetName}" won't notify clients`);
-                }
             })
                 .catch(err => console.error(`[Gateway] agent inject error for ${targetName}:`, err))
                 .finally(() => {
@@ -354,7 +322,6 @@ function drainAgentQueue(threadName, pipelineOpts) {
         projectRoot: pipelineOpts.projectRoot,
         extraMcpServers: pipelineOpts.extraMcpServers,
         gatewayAgentsConfig: pipelineOpts.gatewayAgentsConfig,
-        executorRegistry: pipelineOpts.executorRegistry,
     })
         .catch(err => console.error(`[Gateway] agent queue drain error for ${threadName}:`, err))
         .finally(() => {
@@ -382,15 +349,6 @@ function parseRoute(url) {
             query,
         };
     }
-    // Match /api/device/:executorId/tool
-    const deviceMatch = pathPart.match(/^\/api\/device\/([^/]+)\/tool$/);
-    if (deviceMatch) {
-        return {
-            path: '/api/device/:executorId/tool',
-            params: { executorId: decodeURIComponent(deviceMatch[1]) },
-            query,
-        };
-    }
     return { path: pathPart, params: {}, query };
 }
 function readBody(req) {
@@ -426,27 +384,16 @@ async function handlePostMessage(threadName, req, res, opts) {
     drainQueue(threadName, opts).catch(err => console.error(`[Gateway] drain error:`, err));
 }
 async function handleGetHistory(threadName, query, res) {
-    const limit = Math.min(parseInt(query.limit || '50', 10) || 50, 500);
-    const hasOffset = query.offset !== undefined;
+    const limit = Math.min(parseInt(query.limit || '20', 10) || 20, 200);
     const offset = parseInt(query.offset || '0', 10) || 0;
     try {
         const thread = await getOrCreateThread(threadName);
         const all = await thread.history.getAll();
         const total = all.length;
-        // If no explicit offset, return the MOST RECENT messages (tail of history)
-        let slice;
-        let startIndex;
-        if (!hasOffset) {
-            startIndex = Math.max(0, total - limit);
-            slice = all.slice(startIndex);
-        }
-        else {
-            startIndex = offset;
-            slice = all.slice(offset, offset + limit);
-        }
+        const slice = all.slice(offset, offset + limit);
         const messages = slice.map((m, i) => ({
             id: m.id,
-            index: startIndex + i,
+            index: offset + i,
             role: m.role,
             content: m.content,
             timestamp: m.timestamp,
@@ -477,7 +424,7 @@ async function handleGetStatus(threadName, res) {
         jsonResponse(res, 500, { error: String(err) });
     }
 }
-async function handleListThreads(res, registry) {
+async function handleListThreads(res) {
     try {
         if (!fs.existsSync(THREADS_DIR)) {
             jsonResponse(res, 200, { threads: [] });
@@ -498,7 +445,7 @@ async function handleListThreads(res, registry) {
             catch {
                 // skip
             }
-            // Read thread config to include projectDir and executor info
+            // Read thread config to include projectDir if set
             const tc = await loadThreadConfig(name);
             const entry = {
                 name,
@@ -508,12 +455,6 @@ async function handleListThreads(res, registry) {
             if (tc.projectDir) {
                 entry.projectDir = tc.projectDir;
             }
-            // Include executor info
-            const executor = tc.executor || 'thundercat';
-            entry.executor = executor;
-            if (registry) {
-                entry.executorOnline = registry.isOnline(executor);
-            }
             threads.push(entry);
         }
         // Sort by last activity descending
@@ -530,46 +471,6 @@ async function handleListThreads(res, registry) {
         jsonResponse(res, 500, { error: String(err) });
     }
 }
-async function handleListExecutors(res, registry) {
-    try {
-        const executors = registry.listExecutors();
-        jsonResponse(res, 200, { executors });
-    }
-    catch (err) {
-        jsonResponse(res, 500, { error: String(err) });
-    }
-}
-/**
- * Route a device tool call to a remote executor.
- * The executor executes the tool locally and returns the result.
- */
-async function handleDeviceToolCall(executorId, req, res, registry) {
-    let body;
-    try {
-        const raw = await readBody(req);
-        body = JSON.parse(raw);
-    }
-    catch {
-        jsonResponse(res, 400, { error: 'Invalid JSON body' });
-        return;
-    }
-    if (!body.tool) {
-        jsonResponse(res, 400, { error: 'Missing tool name' });
-        return;
-    }
-    if (!registry.isOnline(executorId)) {
-        jsonResponse(res, 503, { error: `Device "${executorId}" is offline` });
-        return;
-    }
-    try {
-        const result = await registry.deviceToolCall(executorId, body.tool, body.args || {});
-        jsonResponse(res, 200, result);
-    }
-    catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        jsonResponse(res, 500, { error: errorMsg, isError: true });
-    }
-}
 async function handleDeleteThread(threadName, req, res) {
     const confirm = req.headers['x-confirm'];
     if (confirm !== 'delete') {
@@ -618,60 +519,6 @@ async function handleDeleteThread(threadName, req, res) {
         jsonResponse(res, 500, { error: String(err) });
     }
 }
-async function handleDeleteMessages(threadName, req, res) {
-    const confirm = req.headers['x-confirm'];
-    if (confirm !== 'delete') {
-        jsonResponse(res, 400, { error: 'Missing X-Confirm: delete header' });
-        return;
-    }
-    let body;
-    try {
-        const raw = await readBody(req);
-        body = JSON.parse(raw);
-    }
-    catch {
-        jsonResponse(res, 400, { error: 'Invalid JSON body' });
-        return;
-    }
-    if (!Array.isArray(body.messageIds) || body.messageIds.length === 0) {
-        jsonResponse(res, 400, { error: 'Missing or empty "messageIds" array' });
-        return;
-    }
-    const idsToDelete = new Set(body.messageIds);
-    try {
-        const filePath = path.join(THREADS_DIR, threadName + '.jsonl');
-        if (!fs.existsSync(filePath)) {
-            jsonResponse(res, 404, { error: 'Thread not found' });
-            return;
-        }
-        const raw = fs.readFileSync(filePath, 'utf-8');
-        const lines = raw.split('\n').filter(l => l.trim());
-        const kept = [];
-        let deleted = 0;
-        for (const line of lines) {
-            try {
-                const msg = JSON.parse(line);
-                if (msg.id && idsToDelete.has(msg.id)) {
-                    deleted++;
-                }
-                else {
-                    kept.push(line);
-                }
-            }
-            catch {
-                // Malformed line — keep it
-                kept.push(line);
-            }
-        }
-        fs.writeFileSync(filePath, kept.join('\n') + (kept.length > 0 ? '\n' : ''), 'utf-8');
-        // Clear in-memory cache so next request reads fresh data
-        clearThreadCache(threadName);
-        jsonResponse(res, 200, { deleted, remaining: kept.length });
-    }
-    catch (err) {
-        jsonResponse(res, 500, { error: String(err) });
-    }
-}
 async function handleSyncMessages(threadName, req, res) {
     let body;
     try {
@@ -759,14 +606,6 @@ async function handleUpdateThreadConfig(threadName, req, res) {
             updates.projectDir = body.projectDir;
         if (body.template !== undefined)
             updates.template = body.template;
-        if (body.executor !== undefined)
-            updates.executor = body.executor;
-        if (body.executorPaths !== undefined)
-            updates.executorPaths = body.executorPaths;
-        if (body.devices !== undefined)
-            updates.devices = body.devices;
-        if (body.gitRemoteUrl !== undefined)
-            updates.gitRemoteUrl = body.gitRemoteUrl;
         await saveThreadConfig(threadName, updates);
         const updated = await loadThreadConfig(threadName);
         jsonResponse(res, 200, { config: updated });
@@ -917,15 +756,95 @@ async function handleMigrate(req, res, opts) {
         jsonResponse(res, 500, { error: String(err) });
     }
 }
+// ─── Push notification handlers ─────────────────────────────────────────────
+function handleGetVapidKey(res, vapid) {
+    if (!vapid) {
+        jsonResponse(res, 404, { error: 'Push notifications not configured' });
+        return;
+    }
+    jsonResponse(res, 200, { publicKey: vapid.publicKey });
+}
+async function handlePushSubscribe(req, res) {
+    let body;
+    try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+    }
+    catch {
+        jsonResponse(res, 400, { error: 'Invalid JSON body' });
+        return;
+    }
+    if (!body.endpoint || !body.keys?.p256dh || !body.keys?.auth) {
+        jsonResponse(res, 400, {
+            error: 'Missing required fields: endpoint, keys.p256dh, keys.auth',
+        });
+        return;
+    }
+    const sub = {
+        endpoint: body.endpoint,
+        keys: { p256dh: body.keys.p256dh, auth: body.keys.auth },
+        createdAt: new Date().toISOString(),
+        label: body.label,
+    };
+    pushSubscribe(sub);
+    jsonResponse(res, 200, { subscribed: true });
+}
+async function handlePushUnsubscribe(req, res) {
+    let body;
+    try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+    }
+    catch {
+        jsonResponse(res, 400, { error: 'Invalid JSON body' });
+        return;
+    }
+    if (!body.endpoint) {
+        jsonResponse(res, 400, { error: 'Missing "endpoint"' });
+        return;
+    }
+    const removed = pushUnsubscribe(body.endpoint);
+    jsonResponse(res, 200, { removed });
+}
+async function handleNotify(req, res) {
+    let body;
+    try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+    }
+    catch {
+        jsonResponse(res, 400, { error: 'Invalid JSON body' });
+        return;
+    }
+    const title = body.title || 'Cumulus';
+    const notifBody = body.body || body.message || '';
+    if (!notifBody) {
+        jsonResponse(res, 400, { error: 'Missing "body" or "message"' });
+        return;
+    }
+    try {
+        const delivered = await sendNotification({
+            title,
+            body: notifBody,
+            threadName: body.threadName,
+            priority: body.priority,
+        });
+        jsonResponse(res, 200, { delivered });
+    }
+    catch (err) {
+        jsonResponse(res, 500, { error: String(err) });
+    }
+}
 // ─── Server ──────────────────────────────────────────────────────────────────
 export async function startGatewayServer(options) {
     const { port, ...pipelineOpts } = options;
     let currentApiKeys = options.apiKeys;
-    // Create or use provided executor registry
-    const executorRegistry = options.executorRegistry || new ExecutorRegistry();
-    pipelineOpts.executorRegistry = executorRegistry;
-    // Set up executor WebSocket server
-    const executorWss = new WebSocketServer({ noServer: true });
+    // Initialize VAPID for push notifications (if configured)
+    const vapidConfig = options.vapid;
+    if (vapidConfig) {
+        configureVapid(vapidConfig);
+        console.log('[Gateway] Push notifications enabled (VAPID configured)');
+    }
     const server = http.createServer(async (req, res) => {
         // CORS headers for web clients
         res.setHeader('Access-Control-Allow-Origin', '*');
@@ -946,6 +865,11 @@ export async function startGatewayServer(options) {
         if (req.method === 'GET' && serveStaticFile(req, res, currentApiKeys)) {
             return;
         }
+        // GET /api/push/vapid-key — public (no auth), returns VAPID public key
+        if (routePath === '/api/push/vapid-key' && req.method === 'GET') {
+            handleGetVapidKey(res, vapidConfig);
+            return;
+        }
         // All other routes require auth
         if (!authenticate(req, res, currentApiKeys))
             return;
@@ -975,22 +899,6 @@ export async function startGatewayServer(options) {
                 await handleDeleteThread(params.name, req, res);
                 return;
             }
-            // DELETE /api/thread/:name/messages
-            if (routePath === '/api/thread/:name/messages' && req.method === 'DELETE') {
-                await handleDeleteMessages(params.name, req, res);
-                return;
-            }
-            // GET /api/thread/:name/config — read thread config
-            if (routePath === '/api/thread/:name/config' && req.method === 'GET') {
-                try {
-                    const tc = await loadThreadConfig(params.name);
-                    jsonResponse(res, 200, tc);
-                }
-                catch (err) {
-                    jsonResponse(res, 500, { error: String(err) });
-                }
-                return;
-            }
             // PUT /api/thread/:name/config — update thread config (projectDir, template)
             if (routePath === '/api/thread/:name/config' && req.method === 'PUT') {
                 await handleUpdateThreadConfig(params.name, req, res);
@@ -998,12 +906,7 @@ export async function startGatewayServer(options) {
             }
             // GET /api/threads
             if (routePath === '/api/threads' && req.method === 'GET') {
-                await handleListThreads(res, executorRegistry);
-                return;
-            }
-            // GET /api/executors
-            if (routePath === '/api/executors' && req.method === 'GET') {
-                await handleListExecutors(res, executorRegistry);
+                await handleListThreads(res);
                 return;
             }
             // GET /api/templates — list templates
@@ -1021,16 +924,26 @@ export async function startGatewayServer(options) {
                 await handleAgentInject(req, res, pipelineOpts);
                 return;
             }
-            // POST /api/device/:executorId/tool — route device tool call to executor
-            if (routePath === '/api/device/:executorId/tool' && req.method === 'POST') {
-                await handleDeviceToolCall(params.executorId, req, res, executorRegistry);
-                return;
-            }
             // POST /api/migrate — sync thread + clone repo + set projectDir
             if (routePath === '/api/migrate' && req.method === 'POST') {
                 await handleMigrate(req, res, pipelineOpts);
                 return;
             }
+            // POST /api/push/subscribe — register push subscription
+            if (routePath === '/api/push/subscribe' && req.method === 'POST') {
+                await handlePushSubscribe(req, res);
+                return;
+            }
+            // DELETE /api/push/subscribe — remove push subscription
+            if (routePath === '/api/push/subscribe' && req.method === 'DELETE') {
+                await handlePushUnsubscribe(req, res);
+                return;
+            }
+            // POST /api/notify — send push notification
+            if (routePath === '/api/notify' && req.method === 'POST') {
+                await handleNotify(req, res);
+                return;
+            }
             // 404
             jsonResponse(res, 404, { error: 'Not found' });
         }
@@ -1041,40 +954,6 @@ export async function startGatewayServer(options) {
             }
         }
     });
-    // Handle executor WebSocket upgrades on /ws/executor
-    server.on('upgrade', (req, socket, head) => {
-        const url = req.url?.split('?')[0] || '/';
-        if (url !== '/ws/executor')
-            return; // let other handlers (webchat) handle non-executor paths
-        // Authenticate via query param
-        const queryApiKey = new URL(req.url || '/', `http://${req.headers.host}`).searchParams.get('apiKey');
-        if (!queryApiKey || !currentApiKeys.includes(queryApiKey)) {
-            socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
-            socket.destroy();
-            return;
-        }
-        executorWss.handleUpgrade(req, socket, head, (ws) => {
-            // Wait for registration message
-            const timeout = setTimeout(() => {
-                ws.close(1008, 'Registration timeout');
-            }, 10_000);
-            ws.once('message', (raw) => {
-                clearTimeout(timeout);
-                try {
-                    const data = JSON.parse(raw.toString());
-                    if (data.type === 'executor_register') {
-                        executorRegistry.register(data, ws);
-                    }
-                    else {
-                        ws.close(1008, 'Expected executor_register message');
-                    }
-                }
-                catch {
-                    ws.close(1008, 'Invalid registration message');
-                }
-            });
-        });
-    });
     return new Promise((resolve, reject) => {
         server.on('error', reject);
         server.listen(port, () => {
@@ -1086,23 +965,13 @@ export async function startGatewayServer(options) {
                 port: actualPort,
                 url,
                 server,
-                executorRegistry,
                 updateApiKeys: (newKeys) => {
                     currentApiKeys = newKeys;
                 },
-                setBroadcastToThread: (fn) => {
-                    pipelineOpts.broadcastToThread = fn;
-                },
                 close: async () => {
                     // Abort any in-flight message processing
                     threadQueues.clear();
                     threadBusy.clear();
-                    executorRegistry.shutdown();
-                    // Close executor WebSocket server
-                    for (const client of executorWss.clients) {
-                        client.close();
-                    }
-                    executorWss.close();
                     return new Promise(resolveClose => {
                         server.close(() => {
                             clearThreadCache();