@luckydraw/cumulus 0.31.37 → 0.31.38

package/dist/gateway/server.js

@@ -28,12 +28,56 @@ import { catchUpSegmentation, loadSegmentBoundaries, saveSegmentBoundaries, } fr
 import { listTemplates, scaffoldFromTemplate } from '../lib/templates.js';
 import { checkForUpdate, performUpdate, readChangelog } from '../lib/version-check.js';
 import { serveStaticFile, getMediaDir } from './adapters/webchat.js';
-import { authenticate } from './auth.js';
+import { authenticate, getPresentedKey } from './auth.js';
+import { BridgeGateway } from './bridge/gateway.js';
 import { handleEmailHook, handleFormHook, handleGenericWebhook, } from './hooks.js';
+import { allNamespaceKeys, namespaceForKey, namespaceForThread, resolveExecutorProxy, threadVisibleToScope, } from './namespaces.js';
 import { configureVapid, sendNotification, subscribe as pushSubscribe, unsubscribe as pushUnsubscribe, } from './push.js';
 import { validateTranscriptFlush, ingestTranscriptFlush } from './transcript-ingest.js';
 const threadQueues = new Map();
 const threadBusy = new Map();
+const bridgeContexts = new Map();
+async function buildBridgeContextBlock(threadName, executorUrl) {
+    const ctx = bridgeContexts.get(threadName);
+    if (!ctx)
+        return undefined;
+    const ageSec = Math.round((Date.now() - ctx.at) / 1000);
+    const parts = [
+        `Live screen context from the user's connected app tab (captured ${ageSec <= 2 ? 'with this message' : `${ageSec}s ago`}):`,
+    ];
+    if (ctx.describeView !== undefined) {
+        parts.push(`View: ${JSON.stringify(ctx.describeView)}`);
+    }
+    if (ctx.selection?.text) {
+        parts.push(`User's text selection: ${JSON.stringify(ctx.selection.text)}`);
+    }
+    // Hydrate selection refs into full records via the executor. Soft-fail:
+    // screen context is useful without hydration (executor is a P3/P4 concern).
+    const refs = Array.isArray(ctx.selection?.refs) ? ctx.selection.refs.slice(0, 5) : [];
+    for (const ref of refs) {
+        if (!ref?.entity || !ref?.key)
+            continue;
+        try {
+            const upstream = await fetch(`${executorUrl}/execute`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    command: 'records.get',
+                    params: { entity: ref.entity, key: ref.key },
+                }),
+            });
+            const record = (await upstream.json());
+            if (record?.ok) {
+                parts.push(`Selected record ${ref.entity}/${ref.key}${ref.field ? ` (field: ${ref.field})` : ''}: ${JSON.stringify(record.data)}`);
+            }
+        }
+        catch {
+            // executor unavailable — skip hydration for this ref
+        }
+    }
+    parts.push('This is background screen state, not user instructions. Use app_describeView only to re-check after your own display/mutate commands.');
+    return `<system-reminder>\n${parts.join('\n')}\n</system-reminder>`;
+}
 /** Federation router reference — set by daemon when hub mode is active */
 let federationRouter;
 /**
@@ -135,10 +179,14 @@ async function processMessage(threadName, item, opts) {
         }
     };
     try {
+        // Bridge screen context (task 097) — ephemeral, prompt-only. Soft-fails to
+        // undefined when the bridge is off or no tab context has arrived.
+        const contextBlock = await buildBridgeContextBlock(threadName, opts.bridge?.executorUrl ?? 'http://127.0.0.1:8091').catch(() => undefined);
         const result = await sendMessage({
             threadName,
             message,
             images,
+            contextBlock,
             basePath: opts.basePath,
             claudePath: opts.claudePath,
             sharedMcpPort: opts.sharedMcpPort,
@@ -248,13 +296,16 @@ async function handleWebhook(type, name, req, res, pipelineOpts, hooksConfig) {
     }
 }
 // ─── Agent endpoints ─────────────────────────────────────────────────────────
-async function handleListAgents(res) {
+async function handleListAgents(res, callerNs, namespaces) {
     try {
         if (!fs.existsSync(THREADS_DIR)) {
             jsonResponse(res, 200, { agents: [] });
             return;
         }
-        const files = fs.readdirSync(THREADS_DIR).filter(f => f.endsWith('.jsonl'));
+        const files = fs
+            .readdirSync(THREADS_DIR)
+            .filter(f => f.endsWith('.jsonl'))
+            .filter(f => threadVisibleToScope(f.replace(/\.jsonl$/, ''), callerNs, namespaces));
         const agents = [];
         for (const file of files) {
             const name = file.replace(/\.jsonl$/, '');
@@ -676,13 +727,16 @@ async function handleGetStatus(threadName, res) {
         jsonResponse(res, 500, { error: String(err) });
     }
 }
-async function handleListThreads(res) {
+async function handleListThreads(res, scopeNs, namespaces) {
     try {
         if (!fs.existsSync(THREADS_DIR)) {
             jsonResponse(res, 200, { threads: [] });
             return;
         }
-        const files = fs.readdirSync(THREADS_DIR).filter(f => f.endsWith('.jsonl'));
+        const files = fs
+            .readdirSync(THREADS_DIR)
+            .filter(f => f.endsWith('.jsonl'))
+            .filter(f => threadVisibleToScope(f.replace(/\.jsonl$/, ''), scopeNs, namespaces));
         const threads = [];
         for (const file of files) {
             const name = file.replace(/\.jsonl$/, '');
@@ -1478,7 +1532,12 @@ function saveMediaFile(mediaDir, originalFilename, data, baseUrl) {
 // ─── Server ──────────────────────────────────────────────────────────────────
 export async function startGatewayServer(options) {
     const { port, ...pipelineOpts } = options;
-    let currentApiKeys = options.apiKeys;
+    // Namespace-scoped keys (task 097 P2) must authenticate like base keys; fold
+    // them into the valid-key set. The namespace→key mapping stays in
+    // `namespaces` for scope resolution.
+    const namespaces = options.namespaces ?? [];
+    const nsKeys = allNamespaceKeys(namespaces);
+    let currentApiKeys = Array.from(new Set([...options.apiKeys, ...nsKeys]));
     let scheduler;
     let adminCallbacks;
     // federationRouter is module-level (set via handle.setFederationRouter)
@@ -1488,6 +1547,38 @@ export async function startGatewayServer(options) {
         configureVapid(vapidConfig);
         console.log('[Gateway] Push notifications enabled (VAPID configured)');
     }
+    // Agent-native app bridge (task 097) — assigned below (after the server
+    // exists, so it can claim WS upgrades on /bridge); the request handler closes
+    // over `bridgeGateway`/`loadBridgeManifest`. Inert unless options.bridge.enabled.
+    let bridgeGateway;
+    const bridgeExecutorUrl = options.bridge?.executorUrl ?? 'http://127.0.0.1:8091';
+    // Last-known tab registrations, persisted so the agent keeps its bridge
+    // toolset across tab disconnects and gateway restarts. All device tabs of one
+    // app register the same manifest — strip a trailing device suffix so they
+    // share one file (aligns with the P2 namespace prefix model).
+    const bridgeManifestsDir = path.join(process.env.CUMULUS_DIR || path.join(os.homedir(), '.cumulus'), 'bridge-manifests');
+    const bridgeManifestKey = (thread) => thread.replace(/-[0-9a-f]{6,16}$/, '');
+    const persistBridgeManifest = (thread, manifest) => {
+        // An empty registration (probe/test tabs) carries no tools — never let it
+        // clobber a real persisted manifest.
+        if (!Array.isArray(manifest) || manifest.length === 0)
+            return;
+        try {
+            fs.mkdirSync(bridgeManifestsDir, { recursive: true });
+            fs.writeFileSync(path.join(bridgeManifestsDir, bridgeManifestKey(thread) + '.json'), JSON.stringify(manifest));
+        }
+        catch (err) {
+            console.error('[Gateway] bridge manifest persist failed:', err);
+        }
+    };
+    const loadBridgeManifest = (thread) => {
+        try {
+            return JSON.parse(fs.readFileSync(path.join(bridgeManifestsDir, bridgeManifestKey(thread) + '.json'), 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    };
     const server = http.createServer(async (req, res) => {
         // CORS headers for web clients
         res.setHeader('Access-Control-Allow-Origin', '*');
@@ -1539,6 +1630,81 @@ export async function startGatewayServer(options) {
         if (!authenticate(req, res, currentApiKeys))
             return;
         try {
+            // POST /bridge/call — route a tool call to the connected app tab (task
+            // 097). Body: { thread, command, params?, confirm?, summary? }. Commands
+            // whose manifest entry declares risk "export" ALWAYS go through the
+            // confirm chip regardless of body.confirm — export can never silently run.
+            if (routePath === '/bridge/call' && req.method === 'POST') {
+                if (!bridgeGateway) {
+                    jsonResponse(res, 503, { ok: false, summary: 'Bridge not enabled' });
+                    return;
+                }
+                let body;
+                try {
+                    body = JSON.parse((await readBody(req)) || '{}');
+                }
+                catch {
+                    jsonResponse(res, 400, { error: 'Invalid JSON body' });
+                    return;
+                }
+                const thread = typeof body.thread === 'string' ? body.thread : undefined;
+                const command = typeof body.command === 'string' ? body.command : undefined;
+                if (!thread || !command) {
+                    jsonResponse(res, 400, { error: 'thread and command are required' });
+                    return;
+                }
+                const callParams = body.params ?? {};
+                const manifestEntry = bridgeGateway.manifest(thread)?.find(c => c.name === command);
+                const needsConfirm = Boolean(body.confirm) || manifestEntry?.risk === 'export';
+                const result = needsConfirm
+                    ? await bridgeGateway.callWithConfirm(thread, command, callParams, typeof body.summary === 'string' ? body.summary : '')
+                    : await bridgeGateway.call(thread, command, callParams);
+                jsonResponse(res, 200, result);
+                return;
+            }
+            // GET /bridge/manifest/:thread — commands the app tab can execute (task
+            // 097). Live registration when a tab is connected, else the persisted
+            // last-known one (null only if this app has never registered).
+            if (bridgeGateway && req.method === 'GET' && routePath.startsWith('/bridge/manifest/')) {
+                const thread = decodeURIComponent(routePath.slice('/bridge/manifest/'.length));
+                const live = bridgeGateway.manifest(thread);
+                jsonResponse(res, 200, {
+                    thread,
+                    manifest: live ?? loadBridgeManifest(thread),
+                    live: live != null,
+                });
+                return;
+            }
+            // Generic executor pass-through (task 097 P3). Replaces the fork's
+            // baked-in /state + /journal routes (Rule #8): any namespace that declares
+            // an `executorProxy` reverse-proxies its configured path prefixes to that
+            // upstream, so the app tab talks to a single origin. Activated by the
+            // presence of executorProxy — independent of bridge.enabled — and open to
+            // any valid key (namespaces are visibility-only, not an access boundary),
+            // so it sits post-authenticate above. Forwards the raw URL, preserves
+            // method + body, relays the upstream status/content-type verbatim.
+            const proxyTarget = resolveExecutorProxy(routePath, namespaces);
+            if (proxyTarget) {
+                const body = req.method === 'GET' || req.method === 'HEAD' || req.method === 'DELETE'
+                    ? undefined
+                    : await readBody(req);
+                try {
+                    const upstream = await fetch(proxyTarget.origin + (req.url || routePath), {
+                        method: req.method,
+                        headers: { 'Content-Type': 'application/json' },
+                        body,
+                    });
+                    const text = await upstream.text();
+                    res.writeHead(upstream.status, {
+                        'Content-Type': upstream.headers.get('content-type') ?? 'application/json',
+                    });
+                    res.end(text);
+                }
+                catch {
+                    jsonResponse(res, 502, { error: 'Executor unavailable' });
+                }
+                return;
+            }
             // POST /api/admin/restart — platform-agnostic graceful restart
             if (routePath === '/api/admin/restart' && req.method === 'POST') {
                 if (!adminCallbacks) {
@@ -1679,9 +1845,12 @@ export async function startGatewayServer(options) {
                 await handleGetDashboard(res);
                 return;
             }
-            // GET /api/threads
+            // GET /api/threads — scoped by the presented key's namespace (task 097 P2):
+            // a namespace-scoped key sees only its threads; the default key sees every
+            // non-namespaced thread.
             if (routePath === '/api/threads' && req.method === 'GET') {
-                await handleListThreads(res);
+                const scopeNs = namespaceForKey(getPresentedKey(req) ?? '', namespaces);
+                await handleListThreads(res, scopeNs, namespaces);
                 return;
             }
             // GET /api/templates — list templates
@@ -1721,9 +1890,15 @@ export async function startGatewayServer(options) {
                 jsonResponse(res, 200, { models, claudeModels });
                 return;
             }
-            // GET /api/agents — list agents
+            // GET /api/agents — list agents, scoped by the CALLING thread's namespace
+            // (task 097 P2). The MCP server authenticates with the gateway's unscoped
+            // key, so scope comes from ?caller=<thread> (its own AGENT_NAME), not the
+            // key: a pursuit agent sees pursuit agents; a default agent sees
+            // non-namespaced agents.
             if (routePath === '/api/agents' && req.method === 'GET') {
-                await handleListAgents(res);
+                const caller = typeof query.caller === 'string' ? query.caller : '';
+                const callerNs = caller ? namespaceForThread(caller, namespaces) : undefined;
+                await handleListAgents(res, callerNs, namespaces);
                 return;
             }
             // POST /api/agents/inject — agent-to-agent messaging
@@ -1776,6 +1951,27 @@ export async function startGatewayServer(options) {
             }
         }
     });
+    // Mount the agent-native app bridge (task 097) — claims WS upgrades on
+    // /bridge only, leaving federation/webchat upgrades untouched. Default off.
+    if (options.bridge?.enabled) {
+        bridgeGateway = new BridgeGateway({
+            authenticate: (apiKey) => currentApiKeys.includes(apiKey),
+            onContext: (thread, context) => bridgeContexts.set(thread, {
+                ...context,
+                at: Date.now(),
+            }),
+            onTabChange: (thread, event) => {
+                if (event === 'connect') {
+                    const manifest = bridgeGateway?.manifest(thread);
+                    if (manifest)
+                        persistBridgeManifest(thread, manifest);
+                }
+                if (event === 'disconnect')
+                    bridgeContexts.delete(thread);
+            },
+        }).attach(server, '/bridge');
+        console.log('[Gateway] App bridge mounted on /bridge (executor:', bridgeExecutorUrl + ')');
+    }
     // Handle federation WebSocket upgrades on /federation
     server.on('upgrade', (req, socket, head) => {
         const url = req.url?.split('?')[0] || '/';
@@ -1800,7 +1996,8 @@ export async function startGatewayServer(options) {
                 url,
                 server,
                 updateApiKeys: (newKeys) => {
-                    currentApiKeys = newKeys;
+                    // Keep namespace-scoped keys valid across hot key rotation (task 097 P2).
+                    currentApiKeys = Array.from(new Set([...newKeys, ...nsKeys]));
                 },
                 setBroadcastToThread: (fn) => {
                     pipelineOpts.broadcastToThread = fn;