@loicngr/kobo 1.11.39 → 1.11.40

package/AGENTS.md

@@ -162,6 +162,18 @@ Every feature that touches the schema:
 
 ## WebSocket protocol
 
+### External MCP dialogue and update checks
+
+`POST /api/mcp` exposes stateless Streamable HTTP discovery/dialogue tools, behind the existing Host/Origin and network-token gates. The global stdio server forwards dialogue calls through this backend so agent runtime ownership remains centralized. `workspace-message-service.ts` shares delivery with WebSocket chat.
+
+Optional `send_workspace_message.idempotency_key` uses `mcp_message_requests` (migration v43). Reserve before dispatch, preserve fingerprints and terminal outcomes, and never automatically resend an unfinished request after restart. The user event and accepted receipt commit in one SQLite transaction; broadcast follows commit. Dispatch may precede persistence, so interrupted requests are explicitly `delivery_unknown`, not an exactly-once execution promise. The backend alone calls `reconcileMessageRequests` on startup. History retention does not delete the ledger; workspace deletion cascades it.
+
+MCP messages and question answers include optional `source: { kind: 'mcp', clientName, transport }`; keep it across live, sync, history and conversation grouping paths without changing legacy `sender` behavior. Client names are display labels, not authorization identities. Unicode HTTP labels use URI encoding with `X-Kobo-Client-Name-Encoding: uri`; stdio forwards the initialization name or `KOBO_MCP_CLIENT_NAME` override.
+
+`update-check-service.ts` owns the single immediate/every-20-minute npm release check. It is explicitly started/stopped by the backend, coalesces route/poller calls, and broadcasts ephemeral global `kobo:update-checked` events. The client update store also refreshes at reconnect. Do not reintroduce a per-tab registry poll or automatically install updates.
+
+The explicit `npm run test:mcp:live` / `make test-mcp-live` command requires `KOBO_LIVE_ENGINE` and `KOBO_LIVE_MODEL`, uses real credentials and disposable data, and must stay outside `make ci`. Normal CI uses deterministic transport/service tests.
+
 Clients subscribe to individual workspace ids. The server sends `WsEvent` objects:
 
 ```ts

package/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.11.40
+
+- feat(workspaces): add external MCP access and harden workspace flows
+
 ## 1.11.39
 
 - fix(deps): require Claude SDK with Fable 5.1 support

package/dist/mcp-server/kobo-tasks-handlers.js

@@ -4,7 +4,7 @@ import { nanoid } from 'nanoid';
 import * as cronService from '../server/services/cron-service.js';
 import * as settingsService from '../server/services/settings-service.js';
 import { slugifyProjectName } from '../server/utils/project-slug.js';
-import { resolveExistingPathInside } from '../server/utils/safe-path.js';
+import { ensureDirectoryInside, resolveExistingPathInside } from '../server/utils/safe-path.js';
 import { resolveWorkspaceWorktreePath } from '../server/utils/worktree-paths.js';
 import { MASKED_SECRET, SECRET_GLOBAL_KEYS } from '../shared/consts.js';
 /** Allowed task status values. */
@@ -404,7 +404,7 @@ export function readDocumentHandler(worktreePath, relPath) {
 }
 /**
  * Append a thought / decision / note to
- * `.ai/thoughts/logs/<YYYY-MM-DD>-<slug>.md`. Creates the directory if missing.
+ * `.ai/thoughts/logs/<YYYY-MM-DD>-<slug>-<timestamp>-<id>.md`. Creates the directory if missing.
  * Returns the path (worktree-relative) of the file actually written — useful
  * for the agent to reference it in chat.
  *
@@ -419,8 +419,7 @@ export function logThoughtHandler(worktreePath, data) {
     const content = data.content?.trim();
     if (!content)
         throw new Error('content is required');
-    const thoughtsDir = path.join(worktreePath, '.ai', 'thoughts', 'logs');
-    fs.mkdirSync(thoughtsDir, { recursive: true });
+    const thoughtsDir = ensureDirectoryInside(worktreePath, path.join('.ai', 'thoughts', 'logs'));
     const date = new Date().toISOString().slice(0, 10);
     const slug = title
         .toLowerCase()
@@ -430,12 +429,20 @@ export function logThoughtHandler(worktreePath, data) {
         .replace(/^-+|-+$/g, '')
         .slice(0, 60) || 'note';
     const tagSuffix = data.tag ? `-${data.tag.replace(/[^a-z0-9]+/gi, '-').toLowerCase()}` : '';
-    const filename = `${date}-${slug}${tagSuffix}.md`;
-    const abs = path.join(thoughtsDir, filename);
-    const relPath = `.ai/thoughts/logs/${filename}`;
     const header = `# ${title}\n\n_${new Date().toISOString()}_${data.tag ? ` · tag: \`${data.tag}\`` : ''}\n\n`;
-    fs.writeFileSync(abs, header + content + (content.endsWith('\n') ? '' : '\n'), 'utf-8');
-    return { path: relPath };
+    for (let attempt = 0; attempt < 5; attempt++) {
+        const filename = `${date}-${slug}${tagSuffix}-${Date.now()}-${nanoid(10)}.md`;
+        const abs = path.join(thoughtsDir, filename);
+        try {
+            fs.writeFileSync(abs, header + content + (content.endsWith('\n') ? '' : '\n'), { encoding: 'utf-8', flag: 'wx' });
+            return { path: `.ai/thoughts/logs/${filename}` };
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+        }
+    }
+    throw new Error('Could not allocate a unique thought filename');
 }
 /**
  * Aggregate `usage` events from `ws_events` to report how many tokens and

package/dist/mcp-server/kobo-tasks-server.js

@@ -3,7 +3,9 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { getDb } from '../server/db/index.js';
+import { WORKSPACE_DIALOGUE_TOOLS } from '../shared/workspace-dialogue-tools.js';
 import { createTaskHandler, cronListHandler, deleteTaskHandler, getDevServerStatusHandler, getSessionUsageHandler, getSettingsHandler, getTicketSourcesHandler, getWorkspaceInfoHandler, listDocumentsHandler, listTasksHandler, listWorkspaceImagesHandler, listWorkspacesHandler, logThoughtHandler, markAutoLoopReadyHandler, markTaskDoneHandler, readDocumentHandler, readWorkspaceEventsCsvHandler, setWorkspaceAgentDescriptionHandler, updateTaskHandler, } from './kobo-tasks-handlers.js';
+import { callWorkspaceDialogueTool } from './workspace-dialogue-client.js';
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
 const dbPath = process.env.KOBO_DB_PATH;
 const settingsPath = process.env.KOBO_SETTINGS_PATH;
@@ -94,9 +96,12 @@ async function notifyAgentDescriptionUpdated() {
 /** Generic HTTP request to the Kobo backend, returning parsed JSON or null. */
 async function backendRequest(method, pathname, body) {
     const url = `${backendUrl}${pathname}`;
-    const init = { method };
+    const headers = process.env.KOBO_NETWORK_TOKEN
+        ? { 'X-Kobo-Token': process.env.KOBO_NETWORK_TOKEN }
+        : {};
+    const init = { method, headers };
     if (body !== undefined) {
-        init.headers = { 'Content-Type': 'application/json' };
+        headers['Content-Type'] = 'application/json';
         init.body = JSON.stringify(body);
     }
     const res = await fetch(url, init);
@@ -475,6 +480,7 @@ const WORKSPACE_SCOPED_TOOLS = [
     },
 ];
 const GLOBAL_TOOLS = [
+    ...WORKSPACE_DIALOGUE_TOOLS,
     {
         name: 'list_workspaces',
         description: 'List Kōbō workspaces with their id, title, status, and creation date. Works even when the Kōbō backend server is not running (reads the database directly). Use this to discover existing workspaces before creating one or targeting one with archive_workspace/stop_workspace.',
@@ -594,6 +600,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return fail(`Tool '${name}' requires a workspace-bound MCP session (KOBO_WORKSPACE_ID not set).`);
     }
     try {
+        if (WORKSPACE_DIALOGUE_TOOLS.some((tool) => tool.name === name)) {
+            if (workspaceId && a.workspace_id === workspaceId && name === 'send_workspace_message')
+                return fail('Use the normal conversation to communicate in your own workspace.');
+            return await callWorkspaceDialogueTool(backendUrl, name, a, process.env.KOBO_NETWORK_TOKEN, process.env.KOBO_MCP_CLIENT_NAME ?? server.getClientVersion()?.name);
+        }
         if (name === 'list_tasks') {
             return ok(listTasksHandler(db, workspaceId));
         }

package/dist/mcp-server/workspace-dialogue-client.js

@@ -0,0 +1,28 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { validateDialogueArguments } from '../shared/workspace-dialogue-tools.js';
+import { normalizeClientName } from '../shared/workspace-message-types.js';
+/** Stateless HTTP bridge: external stdio clients never own agent runtime state. */
+export async function callWorkspaceDialogueTool(backendUrl, name, args, token, clientName) {
+    const arguments_ = validateDialogueArguments(name, args);
+    const client = new Client({ name: 'kobo-stdio-bridge', version: '1.0.0' });
+    const signal = AbortSignal.timeout(30_000);
+    const transport = new StreamableHTTPClientTransport(new URL(`${backendUrl.replace(/\/$/, '')}/api/mcp`), {
+        requestInit: {
+            signal,
+            headers: {
+                ...(token ? { 'X-Kobo-Token': token } : {}),
+                'X-Kobo-Client-Name': encodeURIComponent(normalizeClientName(clientName)),
+                'X-Kobo-Client-Name-Encoding': 'uri',
+                'X-Kobo-Client-Transport': 'stdio',
+            },
+        },
+    });
+    try {
+        await client.connect(transport, { signal });
+        return await client.callTool({ name, arguments: arguments_ }, undefined, { signal });
+    }
+    finally {
+        await client.close();
+    }
+}

package/dist/server/db/mcp-message-schema.js

@@ -0,0 +1,16 @@
+/** v43 schema shared by fresh installs and the append-only migration. */
+export function initMcpMessageSchema(db) {
+    db.exec(`CREATE TABLE IF NOT EXISTS mcp_message_requests (
+    workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+    idempotency_key TEXT NOT NULL,
+    request_id TEXT NOT NULL UNIQUE,
+    fingerprint TEXT NOT NULL,
+    state TEXT NOT NULL CHECK (state IN ('reserved','dispatching','accepted','rejected','unknown')),
+    result_json TEXT,
+    event_id TEXT,
+    session_id TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (workspace_id, idempotency_key)
+  )`);
+}

package/dist/server/db/migrations.js

@@ -1,4 +1,6 @@
+import { initMcpMessageSchema } from './mcp-message-schema.js';
 import { initSchema } from './schema.js';
+import { initSearchSchema } from './search-schema.js';
 /** Ordered registry of all schema migrations. Append new entries at the end. */
 export const migrations = [
     {
@@ -740,6 +742,8 @@ export const migrations = [
     CREATE INDEX IF NOT EXISTS idx_workspace_activity_created ON workspace_activity(created_at);`);
         },
     },
+    { version: 42, name: 'index-logical-search-messages', migrate: initSearchSchema },
+    { version: 43, name: 'durable-mcp-message-requests', migrate: initMcpMessageSchema },
 ];
 /** Current schema version — always equals the highest migration version. */
 export const SCHEMA_VERSION = migrations.length > 0 ? migrations[migrations.length - 1].version : 1;

package/dist/server/db/schema.js

@@ -1,3 +1,5 @@
+import { initMcpMessageSchema } from './mcp-message-schema.js';
+import { initSearchSchema } from './search-schema.js';
 /** Create all tables and indexes for a fresh install. Not used for upgrades -- see migrations.ts. */
 export function initSchema(db) {
     db.exec(`
@@ -221,4 +223,6 @@ export function initSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_session_event_metrics_session
       ON session_event_metrics(session_id);
   `);
+    initSearchSchema(db);
+    initMcpMessageSchema(db);
 }

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/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;