@loicngr/kobo 1.11.39 → 1.11.41

package/dist/server/db/search-schema.js

@@ -0,0 +1,53 @@
+/** Derived data only. The event log remains the source of truth. */
+export function initSearchSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS search_index_state (
+      id INTEGER PRIMARY KEY CHECK(id = 1), cursor TEXT NOT NULL DEFAULT '',
+      complete INTEGER NOT NULL DEFAULT 0, processed INTEGER NOT NULL DEFAULT 0,
+      total INTEGER NOT NULL DEFAULT -1, base_order INTEGER NOT NULL
+    );
+    INSERT OR IGNORE INTO search_index_state(id, base_order)
+      SELECT 1, COALESCE(MAX(rowid), 0) FROM ws_events;
+    CREATE TABLE IF NOT EXISTS search_changes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, event_id TEXT NOT NULL, operation TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_search_changes_event ON search_changes(event_id);
+    CREATE TABLE IF NOT EXISTS search_fragments (
+      event_id TEXT PRIMARY KEY, message_key TEXT NOT NULL,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      session_id TEXT, type TEXT NOT NULL, created_at TEXT NOT NULL,
+      event_order INTEGER NOT NULL, text TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_search_fragments_message ON search_fragments(message_key, event_order);
+    CREATE TABLE IF NOT EXISTS search_messages (
+      id INTEGER PRIMARY KEY, message_key TEXT NOT NULL UNIQUE,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      session_id TEXT, event_id TEXT NOT NULL, type TEXT NOT NULL,
+      created_at TEXT NOT NULL, text TEXT NOT NULL, normalized TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_search_messages_workspace ON search_messages(workspace_id, created_at DESC);
+    CREATE VIRTUAL TABLE IF NOT EXISTS search_messages_fts USING fts5(
+      normalized, content='search_messages', content_rowid='id', tokenize='trigram case_sensitive 1'
+    );
+    CREATE TRIGGER IF NOT EXISTS search_messages_insert AFTER INSERT ON search_messages BEGIN
+      INSERT INTO search_messages_fts(rowid, normalized) VALUES (new.id, new.normalized);
+    END;
+    CREATE TRIGGER IF NOT EXISTS search_messages_delete AFTER DELETE ON search_messages BEGIN
+      INSERT INTO search_messages_fts(search_messages_fts, rowid, normalized) VALUES ('delete', old.id, old.normalized);
+    END;
+    CREATE TRIGGER IF NOT EXISTS search_messages_update AFTER UPDATE ON search_messages BEGIN
+      INSERT INTO search_messages_fts(search_messages_fts, rowid, normalized) VALUES ('delete', old.id, old.normalized);
+      INSERT INTO search_messages_fts(rowid, normalized) VALUES (new.id, new.normalized);
+    END;
+    CREATE TRIGGER IF NOT EXISTS search_events_insert AFTER INSERT ON ws_events BEGIN
+      INSERT INTO search_changes(event_id, operation) VALUES(new.id, 'insert');
+    END;
+    CREATE TRIGGER IF NOT EXISTS search_events_update AFTER UPDATE ON ws_events BEGIN
+      INSERT INTO search_changes(event_id, operation) VALUES(old.id, 'update');
+      INSERT INTO search_changes(event_id, operation) SELECT new.id, 'update' WHERE new.id != old.id;
+    END;
+    CREATE TRIGGER IF NOT EXISTS search_events_delete AFTER DELETE ON ws_events BEGIN
+      INSERT INTO search_changes(event_id, operation) VALUES(old.id, 'delete');
+    END;
+  `);
+}

package/dist/server/index.js

@@ -18,6 +18,7 @@ import fsRouter from './routes/fs.js';
 import gitRouter from './routes/git.js';
 import healthRouter from './routes/health.js';
 import imagesRouter from './routes/images.js';
+import mcpRouter from './routes/mcp.js';
 import { migrationRouter } from './routes/migration.js';
 import notionRouter from './routes/notion.js';
 import pullRequestsRouter from './routes/pull-requests.js';
@@ -29,23 +30,27 @@ import usageRoutes from './routes/usage.js';
 import voiceRouter from './routes/voice.js';
 import workspaceTemplatesRouter from './routes/workspace-templates.js';
 import workspacesRouter from './routes/workspaces.js';
-import { getAvailableSkills, isAgentUnavailableError, reconcileOrphanSessions, restoreRetryCountsFromDb, sendMessage, setBackendPort, startAgent, startWatchdog, stopAgentAndWait, stopAllAgents, stopWatchdog, } from './services/agent/orchestrator.js';
+import { getAvailableSkills, reconcileOrphanSessions, restoreRetryCountsFromDb, setBackendPort, startAgent, startWatchdog, stopAgentAndWait, stopAllAgents, stopWatchdog, } from './services/agent/orchestrator.js';
 import * as autoLoopService from './services/auto-loop-service.js';
 import { startAwaitingUserReminder, stopAwaitingUserReminder } from './services/awaiting-user-reminder-service.js';
 import { runContentMigrationIfNeeded } from './services/content-migration-service.js';
 import * as cronService from './services/cron-service.js';
 import { createDailyDbBackupIfNeeded, createPreMigrationBackup, startDailyDbBackupScheduler, } from './services/db-backup-service.js';
 import { startDevServer, stopAllDevServers, stopDevServer } from './services/dev-server-service.js';
+import { reconcileMessageRequests } from './services/mcp-message-request-service.js';
 import { authorizeWsUpgrade, generateToken, getLanHostnames, getLanUrls, isAllowedOrigin, isAllowedRequestHost, resolveBindHost, resolveDevClientOrigin, resolveNetworkAccessEnvOverrides, resolveProxyHostname, } from './services/network-access-service.js';
 import { startPrWatcher, stopPrWatcher } from './services/pr-watcher-service.js';
 import * as quotaBackoffService from './services/quota-backoff-service.js';
+import { startSearchIndex, stopSearchIndex } from './services/search-service.js';
 import { getGlobalSettings, updateNetworkAccessSettings } from './services/settings-service.js';
 import { reloadDefaultTemplates } from './services/templates-service.js';
 import { createTerminal, destroyAllTerminals, getTerminal } from './services/terminal-service.js';
+import { startUpdateChecker, stopUpdateChecker } from './services/update-check-service.js';
 import { startUsagePoller, stopUsagePoller } from './services/usage/index.js';
 import * as wakeupService from './services/wakeup-service.js';
-import { emit, emitEphemeral, handleConnection, setMessageHandler } from './services/websocket-service.js';
-import { getActiveSession, getWorkspace, updateWorkspaceStatus } from './services/workspace-service.js';
+import { handleConnection, setMessageHandler } from './services/websocket-service.js';
+import { deliverWorkspaceMessage } from './services/workspace-message-service.js';
+import { getWorkspace } from './services/workspace-service.js';
 import { pruneWsEvents, resolveRetentionConfig } from './services/ws-events-retention-service.js';
 import { getChangelogPath, getClientSpaPath, getDbPath, getKoboHome, getPackageVersion, resolveSpaFile, } from './utils/paths.js';
 import { formatStartupBanner, readStartupNotes, startStartupSpinner, startupDebug } from './utils/startup-display.js';
@@ -69,6 +74,8 @@ catch (err) {
     console.error('[kobo] Pre-migration backup failed (continuing — daily backup remains as fallback):', err);
 }
 runMigrations(db);
+reconcileMessageRequests(db);
+startSearchIndex();
 // Event retention. OPT-IN: disabled by default, so this is a no-op until the
 // user sets a window in Settings → Worktrees. Deliberately not enabled by
 // default — turning it on for an existing install would delete months of
@@ -145,6 +152,7 @@ app.use('/api/*', networkAuthMiddleware);
 app.get('/api/health', (c) => c.json({ status: 'ok', version: getPackageVersion() }));
 // Mount route sub-routers
 app.route('/api/workspaces', workspacesRouter);
+app.route('/api/mcp', mcpRouter);
 app.route('/api/pull-requests', pullRequestsRouter);
 app.route('/api/workspaces', imagesRouter);
 app.route('/api/notion', notionRouter);
@@ -221,6 +229,7 @@ const server = serve({
     hostname: bindHost,
 }, (info) => {
     setBackendPort(info.port);
+    startUpdateChecker();
     stopStartupSpinner();
     const settings = getGlobalSettings();
     console.log(formatStartupBanner({
@@ -346,91 +355,11 @@ terminalWss.on('connection', (ws, workspaceId) => {
 setMessageHandler(async (type, payload) => {
     const p = payload;
     if (type === 'chat:message' && p?.workspaceId && p?.content) {
-        if (getWorkspace(p.workspaceId)?.status === 'compacting') {
-            emitEphemeral(p.workspaceId, 'chat:rejected', {
-                reason: 'compacting',
-                sessionId: p.sessionId,
-                content: p.content,
-                message: 'Workspace is compacting its context; wait until compaction finishes before sending a message',
-            });
-            return;
-        }
-        // Auto-loop owns the agent's turns. A user message means the user wants
-        // to redirect the conversation, so disable the loop (idempotent — the
-        // `autoloop:disabled` event is emitted with reason='user-action' so the
-        // frontend chip updates) and let the message through to the running
-        // session. The user can re-enable auto-loop manually once their
-        // intervention is done. Grooming phase (ready=0) is skipped — the loop
-        // hasn't started yet, so chat messages during grooming pass through
-        // untouched (the user can still answer the agent's questions).
-        const autoLoopStatus = autoLoopService.getStatus(p.workspaceId);
-        if (autoLoopStatus.auto_loop && autoLoopStatus.auto_loop_ready) {
-            autoLoopService.disable(p.workspaceId, 'user-action');
-        }
-        // Reject chat input while paused on canUseTool — sending here would spawn
-        // a parallel session and orphan the pending callback.
-        const wsRow = getWorkspace(p.workspaceId);
-        if (wsRow?.status === 'awaiting-user') {
-            emitEphemeral(p.workspaceId, 'chat:rejected', {
-                reason: 'awaiting-user',
-                sessionId: p.sessionId,
-                content: p.content,
-                message: 'Answer via the question panel — typing in chat would orphan the pending callback',
-            });
-            return;
-        }
-        // Prefer the session explicitly selected by the client (sessionId hint),
-        // falling back to the running/most-recent non-idle session so idle sessions
-        // never steal the tagging.
-        const activeSession = getActiveSession(p.workspaceId);
-        const sessionTag = p.sessionId ?? activeSession?.id ?? undefined;
         try {
-            await sendMessage(p.workspaceId, p.content, p.sessionId);
-            emit(p.workspaceId, 'user:message', { content: p.content, sender: 'user' }, sessionTag);
-            if (p.force)
-                emitEphemeral(p.workspaceId, 'chat:accepted', { sessionId: p.sessionId });
+            await deliverWorkspaceMessage(p.workspaceId, { ...p, content: p.content });
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            // Resume on every shape that means "no agent can receive this message"
-            // — the closed-stdin case included. Anything else (queue full, disk
-            // error, a stop in progress) surfaces to the user instead of silently
-            // respawning a fresh agent.
-            if (!isAgentUnavailableError(msg)) {
-                emitEphemeral(p.workspaceId, 'chat:rejected', { sessionId: p.sessionId, content: p.content, message: msg });
-                console.error(`[ws] chat:message failed for workspace ${p.workspaceId}:`, err);
-                return;
-            }
-            // Agent not running — resume the session hinted by the client if any,
-            // otherwise the most-recent active session.
-            try {
-                const workspace = getWorkspace(p.workspaceId);
-                if (workspace) {
-                    const worktreePath = workspace.worktreePath;
-                    // Plan mode blocks MCP tools — when the caller knows the message
-                    // requires them (e.g. grooming), it sets the override to bypass the
-                    // workspace default for this spawn only.
-                    const effectiveMode = p.agentPermissionModeOverride ?? workspace.agentPermissionMode;
-                    const started = startAgent(p.workspaceId, worktreePath, p.content, workspace.model, true, effectiveMode, p.sessionId, workspace.reasoningEffort);
-                    updateWorkspaceStatus(p.workspaceId, 'executing');
-                    const resumedSessionId = p.sessionId ?? started.agentSessionId;
-                    emit(p.workspaceId, 'user:message', { content: p.content, sender: 'user' }, resumedSessionId);
-                    if (p.force)
-                        emitEphemeral(p.workspaceId, 'chat:accepted', { sessionId: resumedSessionId });
-                }
-                else {
-                    emitEphemeral(p.workspaceId, 'chat:rejected', {
-                        sessionId: p.sessionId,
-                        content: p.content,
-                        message: `Workspace '${p.workspaceId}' not found`,
-                    });
-                }
-            }
-            catch (restartErr) {
-                const message = restartErr instanceof Error ? restartErr.message : String(restartErr);
-                emitEphemeral(p.workspaceId, 'chat:rejected', { sessionId: p.sessionId, content: p.content, message });
-                console.error('[ws] Failed to resume agent:', message);
-            }
+        catch (error) {
+            console.error(`[ws] chat:message failed for workspace ${p.workspaceId}:`, error);
         }
     }
     if (type === 'workspace:start' && p?.workspaceId) {
@@ -543,6 +472,7 @@ async function gracefulShutdown(signal, exitCode = 0) {
     if (isShuttingDown)
         return;
     isShuttingDown = true;
+    stopUpdateChecker();
     console.log(`\n[kobo] Received ${signal}, shutting down gracefully…`);
     const forceExitTimer = setTimeout(() => {
         console.error('[kobo] Graceful shutdown timed out; forcing exit');
@@ -608,6 +538,7 @@ async function gracefulShutdown(signal, exitCode = 0) {
     }
     finally {
         try {
+            await stopSearchIndex();
             await dailyBackupScheduler.stop();
             closeDb();
             console.log('[kobo] Database closed');

package/dist/server/middleware/network-auth-middleware.js

@@ -21,11 +21,15 @@ export const networkAuthMiddleware = async (c, next) => {
         return next();
     const address = getConnInfo(c).remote.address;
     const global = getGlobalSettings();
+    // MCP clients commonly send the shared token as an Authorization header.
+    const bearerToken = /^\/api\/mcp\/?$/.test(c.req.path)
+        ? c.req.header('Authorization')?.match(/^Bearer\s+(.+)$/i)?.[1]
+        : undefined;
     const decision = evaluateNetworkAccess({
         address,
         enabled: global.networkAccessEnabled,
         expectedToken: global.networkAccessToken,
-        providedToken: c.req.header('X-Kobo-Token'),
+        providedToken: c.req.header('X-Kobo-Token') ?? bearerToken,
         trustLoopback: !global.networkAccessBehindProxy,
     });
     if (decision.allow)

package/dist/server/routes/changelog.js

@@ -1,57 +1,12 @@
 import fs from 'node:fs';
 import { Hono } from 'hono';
+import { refreshUpdateCheck } from '../services/update-check-service.js';
 import { parseChangelog } from '../utils/changelog.js';
-import { getChangelogPath, getPackageVersion } from '../utils/paths.js';
+import { getChangelogPath } from '../utils/paths.js';
+export { _clearLatestVersionCache } from '../services/update-check-service.js';
 export { parseChangelog } from '../utils/changelog.js';
 /** Hono sub-router for the in-app "What's new" dialog. */
 const app = new Hono();
-/**
- * Latest version published to npm, looked up at most once a day.
- *
- * "What's new" tells the user what changed once they have upgraded; nothing
- * told them an upgrade existed. A self-hosted install would silently rot.
- *
- * Best-effort by construction: no network, a registry hiccup or an air-gapped
- * machine all resolve to null, and the client simply shows nothing.
- */
-const REGISTRY_URL = 'https://registry.npmjs.org/@loicngr/kobo/latest';
-const LATEST_TTL_MS = 24 * 60 * 60 * 1000;
-let latestCache = null;
-/** The lookup in progress, so two loads racing on a cold cache share one request. */
-let inFlight = null;
-async function fetchLatestVersion() {
-    if (latestCache && Date.now() - latestCache.fetchedAt < LATEST_TTL_MS)
-        return latestCache.version;
-    if (inFlight)
-        return inFlight;
-    inFlight = lookupLatestVersion().finally(() => {
-        inFlight = null;
-    });
-    return inFlight;
-}
-async function lookupLatestVersion() {
-    let version = null;
-    try {
-        const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(5_000) });
-        if (res.ok) {
-            const body = (await res.json());
-            if (typeof body.version === 'string')
-                version = body.version;
-        }
-    }
-    catch {
-        // Offline, blocked, or the registry is down. Not worth a log line on a
-        // path that runs on every app load.
-    }
-    // Cache the failure too: a machine with no network must not retry per load.
-    latestCache = { version, fetchedAt: Date.now() };
-    return version;
-}
-/** @internal test-only — drop the cached registry lookup. */
-export function _clearLatestVersionCache() {
-    latestCache = null;
-    inFlight = null;
-}
 // GET /api/changelog — current app version + parsed CHANGELOG.md sections,
 // powering the "What's new" dialog shown after an update, plus the latest
 // version published to npm so the UI can offer to upgrade.
@@ -64,7 +19,7 @@ app.get('/', async (c) => {
         catch {
             // No CHANGELOG.md shipped (or unreadable) — degrade to an empty list.
         }
-        return c.json({ currentVersion: getPackageVersion(), latestVersion: await fetchLatestVersion(), versions });
+        return c.json({ ...(await refreshUpdateCheck()), versions });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);

package/dist/server/routes/git.js

@@ -42,7 +42,7 @@ app.get('/files', (c) => {
 });
 // GET /api/git/orphan-worktrees?projectPath=<path> — list worktrees of a
 // project that are NOT attached to any Kōbō workspace yet.
-app.get('/orphan-worktrees', (c) => {
+app.get('/orphan-worktrees', async (c) => {
     try {
         const projectPath = c.req.query('projectPath');
         if (!projectPath) {
@@ -51,7 +51,7 @@ app.get('/orphan-worktrees', (c) => {
         const db = getDb();
         const rows = db.prepare('SELECT worktree_path FROM workspaces WHERE project_path = ?').all(projectPath);
         const attachedPaths = new Set(rows.map((r) => r.worktree_path).filter((p) => !!p));
-        const orphans = listOrphanWorktrees(projectPath, attachedPaths);
+        const orphans = await listOrphanWorktrees(projectPath, attachedPaths);
         return c.json(orphans);
     }
     catch (err) {

package/dist/server/routes/images.js

@@ -1,11 +1,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { DOCUMENT_EXTENSIONS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENT_REQUEST_BYTES, validateAttachments, } from '../../shared/attachments.js';
+import { attachmentReference, saveAttachments } from '../services/attachment-service.js';
 import * as imageService from '../services/image-service.js';
 import * as workspaceService from '../services/workspace-service.js';
-import { isPathInside } from '../utils/safe-path.js';
-/** Maximum allowed upload size for a single image (10 MB). */
-const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
+import { ensureDirectoryInside, isPathInside } from '../utils/safe-path.js';
+import { WorkspaceLifecycleBusyError, withWorkspaceLifecycleGuard } from '../utils/workspace-lifecycle-guard.js';
+const MAX_FILE_SIZE = MAX_ATTACHMENT_BYTES;
 /** MIME types accepted for image uploads. */
 const ALLOWED_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
 /** File extension → MIME type, used to serve uploaded images back to the frontend. */
@@ -18,8 +21,65 @@ const EXT_TO_MIME = {
 };
 /** Hono sub-router for workspace image upload and deletion. */
 const app = new Hono();
+// New chat uploads share formats, limits and storage with workspace creation.
+app.post('/:id/attachments', bodyLimit({ maxSize: MAX_ATTACHMENT_REQUEST_BYTES }), async (c) => {
+    try {
+        const { id } = c.req.param();
+        let form;
+        try {
+            form = await c.req.raw.formData();
+        }
+        catch {
+            return c.json({ error: 'Invalid multipart body' }, 400);
+        }
+        const files = form.getAll('attachment');
+        if (files.length !== 1 || !(files[0] instanceof File))
+            return c.json({ error: 'Expected one attachment file' }, 400);
+        const file = files[0];
+        const error = validateAttachments([file]);
+        if (error)
+            return c.json({ error: `Invalid attachment: ${error}`, code: error }, 400);
+        return await withWorkspaceLifecycleGuard(id, async () => {
+            const workspace = workspaceService.getWorkspace(id);
+            if (!workspace)
+                return c.json({ error: 'Workspace not found' }, 404);
+            if (workspace.worktreePurgedAt)
+                return c.json({ error: 'Restore the worktree before uploading files' }, 409);
+            const [saved] = await saveAttachments(workspace.worktreePath, [file]);
+            return c.json({ ...saved, path: saved.relativePath, reference: attachmentReference(saved) }, 201);
+        });
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : String(error) }, error instanceof WorkspaceLifecycleBusyError ? 409 : 500);
+    }
+});
+app.delete('/:id/attachments/:filename', async (c) => {
+    try {
+        const { id, filename } = c.req.param();
+        // Accept only the generated document layout, never a caller-supplied path.
+        if (!/^[A-Za-z0-9_-]{10}\.[a-z]+$/.test(filename) ||
+            !DOCUMENT_EXTENSIONS.includes(path.extname(filename))) {
+            return c.json({ error: 'Invalid attachment filename' }, 400);
+        }
+        return await withWorkspaceLifecycleGuard(id, async () => {
+            const workspace = workspaceService.getWorkspace(id);
+            if (!workspace)
+                return c.json({ error: 'Workspace not found' }, 404);
+            if (workspace.worktreePurgedAt)
+                return c.json({ error: 'Worktree is purged' }, 409);
+            const directory = ensureDirectoryInside(workspace.worktreePath, '.ai/attachments');
+            // unlink removes a replaced leaf symlink itself; it never follows it.
+            fs.unlinkSync(path.join(directory, filename));
+            return c.body(null, 204);
+        });
+    }
+    catch (error) {
+        const missing = error.code === 'ENOENT';
+        return c.json({ error: error instanceof Error ? error.message : String(error) }, error instanceof WorkspaceLifecycleBusyError ? 409 : missing ? 404 : 500);
+    }
+});
 // POST /:id/images — upload an image
-app.post('/:id/images', async (c) => {
+app.post('/:id/images', bodyLimit({ maxSize: MAX_ATTACHMENT_REQUEST_BYTES }), async (c) => {
     try {
         const { id } = c.req.param();
         const workspace = workspaceService.getWorkspace(id);
@@ -37,7 +97,7 @@ app.post('/:id/images', async (c) => {
         const arrayBuffer = await file.arrayBuffer();
         const buffer = Buffer.from(arrayBuffer);
         if (buffer.length > MAX_FILE_SIZE) {
-            return c.json({ error: `File too large (${(buffer.length / 1024 / 1024).toFixed(1)} MB). Max: 10 MB` }, 400);
+            return c.json({ error: `File too large (${(buffer.length / 1024 / 1024).toFixed(1)} MB). Max: 50 MB` }, 400);
         }
         const worktreePath = workspace.worktreePath;
         const result = await imageService.saveImage(worktreePath, buffer, file.name);

package/dist/server/routes/mcp.js

@@ -0,0 +1,47 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { EXTERNAL_MCP_TOOLS } from '../../shared/workspace-dialogue-tools.js';
+import { createMcpClientContext } from '../services/mcp-client-context.js';
+import { executeWorkspaceDialogueTool } from '../services/workspace-dialogue-service.js';
+const app = new Hono();
+app.use('*', bodyLimit({ maxSize: 1024 * 1024 }));
+app.all('/', async (c) => {
+    const server = new Server({ name: 'kobo-workspaces', version: '1.0.0' }, { capabilities: { tools: {} } });
+    const transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+        enableJsonResponse: true,
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: EXTERNAL_MCP_TOOLS }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        try {
+            const source = createMcpClientContext(c.req.header('X-Kobo-Client-Name'), c.req.header('X-Kobo-Client-Transport') === 'stdio' ? 'stdio' : 'http', c.req.header('X-Kobo-Client-Name-Encoding'));
+            const data = await executeWorkspaceDialogueTool(request.params.name, request.params.arguments ?? {}, source);
+            const structuredContent = data && typeof data === 'object' && !Array.isArray(data) ? data : undefined;
+            return {
+                content: [{ type: 'text', text: JSON.stringify(data) }],
+                ...(structuredContent ? { structuredContent } : {}),
+                ...(structuredContent?.accepted === false ? { isError: true } : {}),
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
+            };
+        }
+    });
+    try {
+        await server.connect(transport);
+        return await transport.handleRequest(c.req.raw);
+    }
+    catch (error) {
+        return c.json({ error: error instanceof Error ? error.message : String(error) }, 500);
+    }
+    finally {
+        await server.close();
+    }
+});
+export default app;

package/dist/server/routes/pull-requests.js

@@ -77,7 +77,7 @@ app.post('/diagnose', async (c) => {
         if (!pr)
             return c.json({ error: `Pull request #${prNumber} not found` }, 404);
         const workspaces = listWorkspaces(true).filter((workspace) => path.resolve(workspace.projectPath) === path.resolve(projectPath));
-        const report = prCheckout.diagnoseLocalState(projectPath, pr.headBranch, worktreesPath ?? null, attachedWorktreePaths(workspaces), workspaces);
+        const report = await prCheckout.diagnoseLocalState(projectPath, pr.headBranch, worktreesPath ?? null, attachedWorktreePaths(workspaces), workspaces);
         if (pr.isFork)
             report.blockers.push({ kind: 'fork-pr' });
         return c.json({ report, pr, fingerprint: await prCheckout.computeFingerprint(report) });

package/dist/server/routes/search.js

@@ -1,12 +1,20 @@
 import { Hono } from 'hono';
-import { searchEvents } from '../services/search-service.js';
+import { getSearchIndexStatus, searchEvents } from '../services/search-service.js';
 const DEFAULT_LIMIT = 50;
 const MAX_LIMIT = 200;
 const app = new Hono();
 // GET /api/search?q=...&limit=50&includeArchived=true
 // Search readable text across ws_events (user messages + agent outputs),
 // joined with workspaces. Returns up to `limit` snippets, most recent first.
-app.get('/', (c) => {
+app.get('/status', (c) => {
+    try {
+        return c.json(getSearchIndexStatus());
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : String(err) }, 503);
+    }
+});
+app.get('/', async (c) => {
     const qRaw = c.req.query('q') ?? '';
     const q = qRaw.trim();
     if (!q) {
@@ -22,12 +30,13 @@ app.get('/', (c) => {
     }
     const includeArchived = c.req.query('includeArchived') === 'true';
     try {
-        const results = searchEvents(q, { limit, includeArchived });
+        const results = await searchEvents(q, { limit, includeArchived }, c.req.raw.signal);
+        c.header('X-Kobo-Search-Partial', String(getSearchIndexStatus().state !== 'ready'));
         return c.json(results);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        return c.json({ error: message }, 500);
+        return c.json({ error: message }, 503);
     }
 });
 export default app;

package/dist/server/routes/settings.js

@@ -3,6 +3,7 @@ import { isValidSkillSuite } from '../../shared/skill-suite-prompts.js';
 import { getDb } from '../db/index.js';
 import { getBackendPort } from '../services/agent/orchestrator.js';
 import { DEFAULT_NOTION_INITIAL_PROMPT, DEFAULT_SENTRY_INITIAL_PROMPT, } from '../services/initial-prompt-template-service.js';
+import { getMcpConnectionInfo } from '../services/mcp-connection-info-service.js';
 import { generateToken, getLanUrls } from '../services/network-access-service.js';
 import { DEFAULT_REVIEW_PROMPT_TEMPLATE } from '../services/review-template-service.js';
 import { DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT } from '../services/settings-defaults.js';
@@ -82,6 +83,10 @@ app.get('/ws-events-retention-preview', (c) => {
         return c.json({ error: message }, 500);
     }
 });
+// GET /api/settings/mcp — protected connection metadata, without credentials
+app.get('/mcp', (c) => {
+    return c.json(getMcpConnectionInfo(getBackendPort(), settingsService.getGlobalSettings(), getDb().name));
+});
 // GET /api/settings/network — network access state + LAN URLs
 app.get('/network', (c) => {
     try {