@loicngr/kobo 1.11.39 → 1.11.40

package/dist/server/services/search-service.js

@@ -1,117 +1,111 @@
+import { Worker } from 'node:worker_threads';
 import { getDb } from '../db/index.js';
-/** Event types that carry user-authored or assistant-authored readable text. */
-const SEARCHABLE_TYPES = ['user:message', 'agent:event', 'agent:output'];
-const SNIPPET_CONTEXT = 100; // chars on each side of the match
-/**
- * Extract the readable text content of a ws_events payload, or `null` when
- * the event carries no natural-language content (system events, rate-limit
- * pings, etc.).
- */
-function extractReadableText(type, payload) {
-    if (!payload || typeof payload !== 'object')
-        return null;
-    const p = payload;
-    if (type === 'user:message') {
-        return typeof p.content === 'string' ? p.content : null;
-    }
-    if (type === 'agent:output') {
-        // Claude Code streams `{type: 'assistant', message: {content: [{type: 'text', text: '...'}, ...]}}`
-        const msg = p.message;
-        if (msg && Array.isArray(msg.content)) {
-            const parts = [];
-            for (const block of msg.content) {
-                if (block && typeof block === 'object') {
-                    const b = block;
-                    if (b.type === 'text' && typeof b.text === 'string')
-                        parts.push(b.text);
-                }
-            }
-            return parts.length > 0 ? parts.join('\n') : null;
+let active;
+let requestId = 0;
+/** Start lazily for service consumers, eagerly at server boot. Never opens another home directory. */
+export function startSearchIndex() {
+    const dbPath = getDb().name;
+    if (active?.dbPath === dbPath)
+        return;
+    if (active)
+        void stopSearchIndex();
+    const development = import.meta.url.endsWith('.ts');
+    const entry = new URL(`./search/worker.${development ? 'ts' : 'js'}`, import.meta.url);
+    const worker = development
+        ? new Worker(`const { workerData } = require('node:worker_threads'); import('tsx/esm/api').then(({ tsImport }) => tsImport(workerData.entry, workerData.parent));`, {
+            eval: true,
+            workerData: { dbPath, entry: entry.href, parent: import.meta.url },
+        })
+        : new Worker(entry, { workerData: { dbPath } });
+    const state = {
+        worker,
+        dbPath,
+        pending: new Map(),
+        status: { state: 'building', processed: 0, total: 0 },
+    };
+    active = state;
+    worker.unref();
+    const fail = (error) => {
+        state.status = { ...state.status, state: 'error', error: error.message };
+        for (const pending of state.pending.values()) {
+            pending.cleanup();
+            pending.reject(error);
         }
-    }
-    if (type === 'agent:event' && p.kind === 'message:text') {
-        return typeof p.text === 'string' ? p.text : null;
-    }
-    return null;
+        state.pending.clear();
+    };
+    worker.on('error', fail);
+    worker.on('exit', (code) => {
+        if (active === state)
+            fail(new Error(`Search worker stopped (${code})`));
+    });
+    worker.on('message', (message) => {
+        if (message.status)
+            state.status = message.status;
+        if (message.id !== undefined) {
+            const pending = state.pending.get(message.id);
+            if (!pending)
+                return;
+            state.pending.delete(message.id);
+            pending.cleanup();
+            if (message.error)
+                pending.reject(new Error(message.error));
+            else
+                pending.resolve(message.results ?? []);
+        }
+    });
 }
-function buildSnippet(text, matchIndex, query) {
-    const start = Math.max(0, matchIndex - SNIPPET_CONTEXT);
-    const end = Math.min(text.length, matchIndex + query.length + SNIPPET_CONTEXT);
-    const prefix = start > 0 ? '…' : '';
-    const suffix = end < text.length ? '…' : '';
-    return `${prefix}${text.slice(start, end).trim()}${suffix}`;
+export function getSearchIndexStatus() {
+    startSearchIndex();
+    return { ...active.status };
 }
-/**
- * Full-text-ish search across `ws_events.payload` joined with `workspaces`.
- *
- * - Trimmed empty queries return `[]` without hitting the database.
- * - SQLite does the first filter via `LIKE '%q%'` on the raw payload JSON.
- *   Results are then post-filtered in JS against the **readable** text
- *   (extracted from the JSON) to avoid false positives like matches inside
- *   field names or schema strings.
- * - Snippets are 100 chars of context on either side of the first match.
- */
-export function searchEvents(query, options = {}) {
-    const trimmed = query.trim();
-    if (trimmed.length === 0)
+export async function searchEvents(query, options = {}, signal) {
+    if (!query.trim())
         return [];
-    const { limit = 50, includeArchived = false } = options;
-    const db = getDb();
-    const typePlaceholders = SEARCHABLE_TYPES.map(() => '?').join(', ');
-    const archiveFilter = includeArchived ? '' : 'AND w.archived_at IS NULL';
-    const escapedQuery = trimmed.replace(/[\\%_]/g, '\\$&');
-    const likePattern = `%${escapedQuery}%`;
-    const needle = trimmed.toLowerCase();
-    const results = [];
-    const batchSize = Math.min(Math.max(limit * 3, 100), 500);
-    const statement = db.prepare(`SELECT e.id, e.workspace_id, e.session_id, e.type, e.created_at, e.payload,
-            w.name AS workspace_name, w.archived_at
-     FROM ws_events e
-     JOIN workspaces w ON e.workspace_id = w.id
-     WHERE e.type IN (${typePlaceholders})
-       AND e.payload LIKE ? ESCAPE '\\'
-       ${archiveFilter}
-       AND (? IS NULL OR e.created_at < ? OR (e.created_at = ? AND e.id < ?))
-     ORDER BY e.created_at DESC, e.id DESC
-     LIMIT ?`);
-    let cursorCreatedAt = null;
-    let cursorId = null;
-    while (results.length < limit) {
-        const rows = statement.all(...SEARCHABLE_TYPES, likePattern, cursorCreatedAt, cursorCreatedAt, cursorCreatedAt, cursorId, batchSize);
-        for (const row of rows) {
-            let parsed;
-            try {
-                parsed = JSON.parse(row.payload);
-            }
-            catch {
-                continue;
-            }
-            const text = extractReadableText(row.type, parsed);
-            if (!text)
-                continue;
-            const idx = text.toLowerCase().indexOf(needle);
-            if (idx < 0)
-                continue;
-            results.push({
-                eventId: row.id,
-                sessionId: row.session_id,
-                workspaceId: row.workspace_id,
-                workspaceName: row.workspace_name,
-                archived: row.archived_at !== null,
-                type: row.type,
-                timestamp: row.created_at,
-                snippet: buildSnippet(text, idx, trimmed),
-            });
-            if (results.length >= limit)
-                break;
-        }
-        if (rows.length < batchSize)
-            break;
-        const last = rows.at(-1);
-        if (!last)
-            break;
-        cursorCreatedAt = last.created_at;
-        cursorId = last.id;
+    if (signal?.aborted)
+        throw new Error('Search cancelled');
+    startSearchIndex();
+    const state = active;
+    if (state.status.state === 'error')
+        throw new Error(state.status.error ?? 'Search index unavailable');
+    const id = ++requestId;
+    return new Promise((resolve, reject) => {
+        const cancel = (message) => {
+            state.pending.delete(id);
+            cleanup();
+            state.worker.postMessage({ id, cancel: true });
+            reject(new Error(message));
+        };
+        const aborted = () => cancel('Search cancelled');
+        const timeout = setTimeout(() => cancel('Search timed out'), 10_000);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', aborted);
+        };
+        state.pending.set(id, { resolve, reject, cleanup });
+        signal?.addEventListener('abort', aborted, { once: true });
+        state.worker.postMessage({ id, query, options });
+    });
+}
+export async function stopSearchIndex() {
+    const state = active;
+    if (!state)
+        return;
+    active = undefined;
+    for (const pending of state.pending.values()) {
+        pending.cleanup();
+        pending.reject(new Error('Search index stopped'));
     }
-    return results;
+    state.pending.clear();
+    if (state.worker.threadId === -1)
+        return;
+    await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            void state.worker.terminate();
+        }, 5_000);
+        state.worker.once('exit', () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+        state.worker.postMessage({ stop: true });
+    });
 }

package/dist/server/services/update-check-service.js

@@ -0,0 +1,119 @@
+import { getPackageVersion } from '../utils/paths.js';
+import { broadcastAll } from './websocket-service.js';
+export const UPDATE_CHECK_INTERVAL_MS = 20 * 60 * 1000;
+const REGISTRY_URL = 'https://registry.npmjs.org/@loicngr/kobo/latest';
+const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+let latestVersion = null;
+let lastAttempt = null;
+let lastSuccessAt = null;
+let checkStatus = 'unknown';
+let inFlight = null;
+let controller = null;
+let timer = null;
+let running = false;
+let generation = 0;
+let stopped = false;
+export function getUpdateCheckSnapshot() {
+    return {
+        currentVersion: getPackageVersion(),
+        latestVersion,
+        lastAttemptAt: lastAttempt === null ? null : new Date(lastAttempt).toISOString(),
+        lastSuccessAt,
+        checkStatus,
+    };
+}
+/** Shared by HTTP loads and the single process-wide poller; failures are cached too. */
+export function refreshUpdateCheck() {
+    if (inFlight)
+        return inFlight;
+    if (stopped || (lastAttempt !== null && Date.now() - lastAttempt < UPDATE_CHECK_INTERVAL_MS)) {
+        return Promise.resolve(getUpdateCheckSnapshot());
+    }
+    lastAttempt = Date.now();
+    const owner = generation;
+    const abort = new AbortController();
+    controller = abort;
+    const timeout = setTimeout(() => abort.abort(), 5000);
+    timeout.unref?.();
+    const aborted = new Promise((_, reject) => {
+        abort.signal.addEventListener('abort', () => reject(new Error('Update lookup cancelled')), { once: true });
+    });
+    const lookup = (async () => {
+        const res = await fetch(REGISTRY_URL, { signal: abort.signal });
+        if (!res.ok)
+            throw new Error('Registry lookup failed');
+        const body = await res.json();
+        if (!body ||
+            typeof body !== 'object' ||
+            !('version' in body) ||
+            typeof body.version !== 'string' ||
+            !STABLE_VERSION.test(body.version)) {
+            throw new Error('Invalid registry version');
+        }
+        return body.version;
+    })();
+    inFlight = (async () => {
+        try {
+            const version = await Promise.race([lookup, aborted]);
+            if (owner !== generation)
+                return getUpdateCheckSnapshot();
+            latestVersion = version;
+            lastSuccessAt = new Date().toISOString();
+            checkStatus = 'success';
+        }
+        catch {
+            if (owner !== generation)
+                return getUpdateCheckSnapshot();
+            checkStatus = 'failed';
+        }
+        finally {
+            clearTimeout(timeout);
+            if (owner === generation) {
+                inFlight = null;
+                controller = null;
+            }
+        }
+        const snapshot = getUpdateCheckSnapshot();
+        broadcastAll('kobo:update-checked', snapshot);
+        return snapshot;
+    })();
+    return inFlight;
+}
+function scheduleNextCheck(owner) {
+    if (!running || owner !== generation)
+        return;
+    const delay = lastAttempt === null ? 0 : Math.max(0, UPDATE_CHECK_INTERVAL_MS - (Date.now() - lastAttempt));
+    timer = setTimeout(() => {
+        timer = null;
+        void refreshUpdateCheck().finally(() => scheduleNextCheck(owner));
+    }, delay);
+    timer.unref?.();
+}
+export function startUpdateChecker() {
+    if (running)
+        return;
+    running = true;
+    stopped = false;
+    const owner = generation;
+    void refreshUpdateCheck().finally(() => scheduleNextCheck(owner));
+}
+export function stopUpdateChecker() {
+    running = false;
+    if (timer)
+        clearTimeout(timer);
+    timer = null;
+    stopped = true;
+    generation++;
+    controller?.abort();
+    controller = null;
+    inFlight = null;
+}
+/** @internal test-only — clear the scheduler and registry cache. */
+export function _clearLatestVersionCache() {
+    stopUpdateChecker();
+    stopped = false;
+    latestVersion = null;
+    lastAttempt = null;
+    lastSuccessAt = null;
+    checkStatus = 'unknown';
+}

package/dist/server/services/websocket-service.js

@@ -5,10 +5,69 @@ import { getAllPersistedSnapshots } from './usage/db.js';
 // ── State ──────────────────────────────────────────────────────────────────────
 /** Maps each WS client to the set of workspaceIds they are subscribed to */
 const clients = new Map();
-/** Above this many bytes queued for a single client, we stop sending it events
- *  rather than growing the process heap on its behalf. It will catch up through
+/** Above this many bytes queued for a single client, we terminate the connection
+ *  before a later event can advance its cursor past an undelivered frame. It will catch up through
  *  `sync:request` on its next reconnect. */
 const MAX_BUFFERED_BYTES = 1024 * 1024;
+/** A dropped frame must end the connection so its replay cursor cannot skip it. */
+function sendFrame(ws, message) {
+    if (ws.readyState !== 1)
+        return;
+    if (ws.bufferedAmount > MAX_BUFFERED_BYTES) {
+        clients.delete(ws);
+        ws.terminate();
+        return;
+    }
+    try {
+        ws.send(message);
+    }
+    catch {
+        clients.delete(ws);
+        ws.terminate();
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function validMessage(value) {
+    if (!isRecord(value) || typeof value.type !== 'string')
+        return false;
+    const p = value.payload;
+    if (!isRecord(p))
+        return false;
+    if (value.type === 'sync:request') {
+        return ((p.lastEventId === undefined || typeof p.lastEventId === 'string') &&
+            (p.workspaceIds === undefined ||
+                (Array.isArray(p.workspaceIds) && p.workspaceIds.every((id) => typeof id === 'string' && id.length > 0))));
+    }
+    if (![
+        'subscribe',
+        'unsubscribe',
+        'chat:message',
+        'workspace:start',
+        'workspace:stop',
+        'devserver:start',
+        'devserver:stop',
+    ].includes(value.type))
+        return true;
+    if (typeof p.workspaceId !== 'string' || !p.workspaceId)
+        return false;
+    if (p.sessionId !== undefined && typeof p.sessionId !== 'string')
+        return false;
+    if (value.type === 'workspace:start' && p.prompt !== undefined && typeof p.prompt !== 'string')
+        return false;
+    if (value.type === 'chat:message') {
+        return (typeof p.content === 'string' &&
+            p.content.length > 0 &&
+            (p.sessionId === undefined || typeof p.sessionId === 'string') &&
+            (p.clientMessageId === undefined || (typeof p.clientMessageId === 'string' && p.clientMessageId.length > 0)) &&
+            (p.force === undefined || typeof p.force === 'boolean') &&
+            (p.agentPermissionModeOverride === undefined ||
+                (typeof p.agentPermissionModeOverride === 'string' &&
+                    ['plan', 'bypass', 'strict', 'interactive'].includes(p.agentPermissionModeOverride))));
+    }
+    return true;
+}
 let messageHandler = null;
 /** Register the handler that processes routed WS messages (e.g. chat:message, workspace:start). */
 export function setMessageHandler(handler) {
@@ -23,7 +82,7 @@ export function handleConnection(ws) {
     // immediately instead of waiting up to POLL_INTERVAL_MS for the next tick.
     try {
         for (const snap of getAllPersistedSnapshots()) {
-            ws.send(JSON.stringify({
+            sendFrame(ws, JSON.stringify({
                 type: 'usage:snapshot',
                 payload: { providerId: snap.providerId, snapshot: snap },
             }));
@@ -35,10 +94,18 @@ export function handleConnection(ws) {
     ws.on('message', (data) => {
         let msg;
         try {
-            msg = JSON.parse(data.toString());
+            const parsed = JSON.parse(data.toString());
+            if (!validMessage(parsed)) {
+                sendFrame(ws, JSON.stringify({
+                    type: 'error',
+                    payload: { message: 'Invalid message payload (check workspaceId and field types)' },
+                }));
+                return;
+            }
+            msg = parsed;
         }
         catch {
-            ws.send(JSON.stringify({ type: 'error', payload: { message: 'Invalid JSON' } }));
+            sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: 'Invalid JSON' } }));
             return;
         }
         const { type, payload } = msg;
@@ -46,23 +113,23 @@ export function handleConnection(ws) {
             case 'subscribe': {
                 const workspaceId = payload?.workspaceId;
                 if (!workspaceId) {
-                    ws.send(JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
+                    sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
                     return;
                 }
                 const subs = clients.get(ws);
                 subs?.add(workspaceId);
-                ws.send(JSON.stringify({ type: 'subscribed', payload: { workspaceId } }));
+                sendFrame(ws, JSON.stringify({ type: 'subscribed', payload: { workspaceId } }));
                 break;
             }
             case 'unsubscribe': {
                 const workspaceId = payload?.workspaceId;
                 if (!workspaceId) {
-                    ws.send(JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
+                    sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: 'Missing workspaceId' } }));
                     return;
                 }
                 const subs = clients.get(ws);
                 subs?.delete(workspaceId);
-                ws.send(JSON.stringify({ type: 'unsubscribed', payload: { workspaceId } }));
+                sendFrame(ws, JSON.stringify({ type: 'unsubscribed', payload: { workspaceId } }));
                 break;
             }
             case 'sync:request': {
@@ -89,13 +156,26 @@ export function handleConnection(ws) {
                         // Every other branch of this switch answers on failure; a routed
                         // message that vanishes silently leaves the user waiting forever.
                         const message = err instanceof Error ? err.message : String(err);
-                        ws.send(JSON.stringify({ type: 'error', payload: { message: `Failed to handle '${type}': ${message}` } }));
+                        if (type === 'chat:message' && isRecord(payload) && typeof payload.clientMessageId === 'string') {
+                            sendFrame(ws, JSON.stringify({
+                                type: 'chat:rejected',
+                                workspaceId: payload.workspaceId,
+                                payload: {
+                                    clientMessageId: payload.clientMessageId,
+                                    sessionId: payload.sessionId,
+                                    content: payload.content,
+                                    message,
+                                },
+                            }));
+                            return;
+                        }
+                        sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: `Failed to handle '${type}': ${message}` } }));
                     });
                 }
                 break;
             }
             default:
-                ws.send(JSON.stringify({ type: 'error', payload: { message: `Unknown message type: ${type}` } }));
+                sendFrame(ws, JSON.stringify({ type: 'error', payload: { message: `Unknown message type: ${type}` } }));
         }
     });
     // Heartbeat with a verdict. Pinging without ever waiting for a pong detected
@@ -154,7 +234,7 @@ function insertEventStatement() {
     }
     return cachedInsert.statement;
 }
-export function emit(workspaceId, type, payload, sessionId) {
+export function emit(workspaceId, type, payload, sessionId, options) {
     recordActivity(workspaceId, type, payload, sessionId);
     const id = nanoid();
     const createdAt = new Date().toISOString();
@@ -165,35 +245,48 @@ export function emit(workspaceId, type, payload, sessionId) {
         replayable = true;
     }
     catch (err) {
+        if (options?.requirePersistence)
+            throw err;
         console.error(`[websocket-service] Failed to persist event (workspace=${workspaceId}, type=${type}):`, err);
     }
     // Build the event object to send
     const event = { id, workspaceId, type, payload, sessionId, createdAt, replayable };
+    broadcastPersistedEvent(event);
+    return id;
+}
+/** Insert durably within the caller's transaction; broadcast only after commit. */
+export function persistWorkspaceEvent(workspaceId, type, payload, sessionId) {
+    const event = {
+        id: nanoid(),
+        workspaceId,
+        type,
+        payload,
+        sessionId,
+        createdAt: new Date().toISOString(),
+        replayable: true,
+    };
+    insertEventStatement().run(event.id, workspaceId, type, JSON.stringify(payload), sessionId ?? null, event.createdAt);
+    recordActivity(workspaceId, type, payload, sessionId);
+    return event;
+}
+export function broadcastPersistedEvent(event) {
     const message = JSON.stringify(event);
     // Broadcast to subscribed clients. Wrap `.send` in try/catch so a dropped
     // client doesn't throw and abort delivery to the remaining subscribers.
     let emitSendErrorLogged = false;
     for (const [ws, subs] of clients) {
-        if (subs.has(workspaceId) && ws.readyState === 1 /* WebSocket.OPEN */) {
-            if ((ws.bufferedAmount ?? 0) > MAX_BUFFERED_BYTES) {
-                if (!emitSendErrorLogged) {
-                    console.warn(`[ws] client backlogged, dropping live events (workspace=${workspaceId}, type=${type})`);
-                    emitSendErrorLogged = true;
-                }
-                continue;
-            }
+        if (subs.has(event.workspaceId) && ws.readyState === 1 /* WebSocket.OPEN */) {
             try {
-                ws.send(message);
+                sendFrame(ws, message);
             }
             catch (err) {
                 if (!emitSendErrorLogged) {
-                    console.warn(`[ws] emit send failed (workspace=${workspaceId}, type=${type}):`, err);
+                    console.warn(`[ws] emit send failed (workspace=${event.workspaceId}, type=${event.type}):`, err);
                     emitSendErrorLogged = true;
                 }
             }
         }
     }
-    return id;
 }
 /**
  * Broadcast an event to subscribed clients WITHOUT persisting to the database.
@@ -216,15 +309,8 @@ export function emitEphemeral(workspaceId, type, payload, sessionId) {
     let sendErrorLogged = false;
     for (const [ws, subs] of clients) {
         if (subs.has(workspaceId) && ws.readyState === 1 /* WebSocket.OPEN */) {
-            if ((ws.bufferedAmount ?? 0) > MAX_BUFFERED_BYTES) {
-                if (!sendErrorLogged) {
-                    console.warn(`[ws] client backlogged, dropping ephemeral event (workspace=${workspaceId}, type=${type})`);
-                    sendErrorLogged = true;
-                }
-                continue;
-            }
             try {
-                ws.send(message);
+                sendFrame(ws, message);
             }
             catch (err) {
                 if (!sendErrorLogged) {
@@ -248,7 +334,7 @@ export function handleSyncRequest(ws, lastEventId, workspaceIds) {
             return subs ? [...subs] : [];
         })();
     if (resolvedIds.length === 0) {
-        ws.send(JSON.stringify({ type: 'sync:empty', payload: { message: 'No subscriptions' } }));
+        sendFrame(ws, JSON.stringify({ type: 'sync:empty', payload: { message: 'No subscriptions' } }));
         return;
     }
     // Initial window size: on a fresh connection (no lastEventId), we only
@@ -329,14 +415,14 @@ export function handleSyncRequest(ws, lastEventId, workspaceIds) {
                 replayable: true,
             };
         });
-        ws.send(JSON.stringify({ type: 'sync:response', payload: { events, mode, truncated } }));
+        sendFrame(ws, JSON.stringify({ type: 'sync:response', payload: { events, mode, truncated } }));
     }
     catch (err) {
         // This handler runs inside ws's 'message' callback: an uncaught SQLite
         // error here used to reach the process, not the client.
         console.error('[ws] sync request failed:', err);
         try {
-            ws.send(JSON.stringify({
+            sendFrame(ws, JSON.stringify({
                 type: 'sync:error',
                 payload: { message: err instanceof Error ? err.message : String(err) },
             }));
@@ -372,7 +458,7 @@ export function broadcastAll(type, payload) {
     for (const client of clients.keys()) {
         if (client.readyState === 1 /* WebSocket.OPEN */) {
             try {
-                client.send(message);
+                sendFrame(client, message);
             }
             catch (err) {
                 // client dropped; next iteration will fail its .readyState check.