@loicngr/kobo 1.10.3 → 1.11.0

package/dist/server/services/agent/engines/codex/engine.js

@@ -1,10 +1,25 @@
 import { getPackageVersion } from '../../../../utils/paths.js';
+import { isWorkspacePermissionAllowed } from '../../../workspace-permission-policy-service.js';
+import { createStreamingBatcher } from '../../streaming-batcher.js';
 import { CODEX_CAPABILITIES } from './capabilities.js';
 import { createAppServerClient } from './client.js';
 import { createMapperState, emitSessionStarted, handleAgentMessageDelta, handleItemCompleted, handleItemStarted, handleRateLimitsUpdated, handleTurnCompleted, QUOTA_PATTERN, tryEmitQuota, } from './event-mapper.js';
 import { buildCodexOptions } from './options-builder.js';
 import { buildResponseForResolve, handleServerRequest } from './server-requests.js';
 import { spawnAppServer } from './spawn.js';
+import { createTurnLiveness } from './turn-liveness.js';
+/** Long enough for normal tool work, short enough to recover a lost turn event. */
+export const CODEX_TURN_IDLE_TIMEOUT_MS = 120_000;
+export const CODEX_GRACEFUL_INTERRUPT_TIMEOUT_MS = 3_000;
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+class CodexTurnTimeoutError extends Error {
+    constructor() {
+        super('Codex stopped reporting activity for this turn');
+        this.name = 'CodexTurnTimeoutError';
+    }
+}
 /**
  * Heuristic for detecting a stale/expired thread id on `thread/resume`.
  * Canonical wording isn't captured yet — when matched, the engine emits
@@ -34,7 +49,8 @@ export function createCodexEngine() {
             let discoveredSessionId = options.resumeFromEngineSessionId;
             let activeTurnId;
             let steerChain = Promise.resolve();
-            const safeEmit = (ev) => {
+            let gracefulInterruptPromise;
+            const emitDirect = (ev) => {
                 try {
                     onEvent(ev);
                 }
@@ -42,6 +58,8 @@ export function createCodexEngine() {
                     console.error('[codex-engine] onEvent handler threw:', err);
                 }
             };
+            const streamingBatcher = createStreamingBatcher(emitDirect);
+            const safeEmit = (ev) => streamingBatcher.push(ev);
             const child = spawnAppServer({ cwd: options.workingDir, signal: abortController.signal });
             if (child.stderr) {
                 child.stderr.setEncoding('utf8');
@@ -61,6 +79,14 @@ export function createCodexEngine() {
                 resolveTurnDone = resolve;
                 rejectTurnDone = reject;
             });
+            const turnLiveness = createTurnLiveness({
+                timeoutMs: CODEX_TURN_IDLE_TIMEOUT_MS,
+                onTimeout() {
+                    mapperState.sawErrorResult = true;
+                    safeEmit({ kind: 'error', category: 'other', message: 'Codex stopped reporting activity for this turn' });
+                    rejectTurnDone(new CodexTurnTimeoutError());
+                },
+            });
             abortController.signal.addEventListener('abort', () => {
                 const err = new Error('AbortError');
                 err.name = 'AbortError';
@@ -71,9 +97,23 @@ export function createCodexEngine() {
                 stdout: child.stdout,
                 clientInfo: { name: 'kobo', version: getPackageVersion() },
                 onNotification(method, params) {
+                    turnLiveness.activity();
                     // Ignored notifications — harmless bookkeeping by the server
-                    if (method === 'mcpServer/startupStatus/updated' ||
-                        method === 'thread/started' ||
+                    if (method === 'mcpServer/startupStatus/updated') {
+                        const status = (params ?? {});
+                        const rawStatus = String(status.status ?? status.state ?? 'starting').toLowerCase();
+                        const normalized = rawStatus.includes('error') || rawStatus.includes('fail')
+                            ? 'error'
+                            : rawStatus.includes('ready') || rawStatus.includes('running')
+                                ? 'ready'
+                                : 'starting';
+                        const serverName = String(status.serverName ?? status.name ?? status.id ?? 'MCP');
+                        const rawMessage = typeof status.message === 'string' ? status.message : undefined;
+                        const message = rawMessage?.replace(/(token|api[_-]?key|secret)\s*[:=]\s*\S+/gi, '$1=[redacted]');
+                        safeEmit({ kind: 'mcp:status', serverName, status: normalized, message });
+                        return;
+                    }
+                    if (method === 'thread/started' ||
                         method === 'thread/status/changed' ||
                         method === 'remoteControl/status/changed' ||
                         method === 'turn/started') {
@@ -144,8 +184,11 @@ export function createCodexEngine() {
                         emit: safeEmit,
                         register(callId, pending) {
                             pendingByCallId.set(callId, pending);
+                            turnLiveness.pause();
                         },
                         respondError: (reqId, code, message) => client.peer.respondError(reqId, code, message),
+                        respond: (reqId, result) => client.peer.respond(reqId, result),
+                        autoApprove: (toolName, payload) => isWorkspacePermissionAllowed(options.workspaceId, { engine: 'codex', toolName, payload }),
                     });
                 },
                 onError(err) {
@@ -185,7 +228,9 @@ export function createCodexEngine() {
                         collaborationMode,
                     });
                     activeTurnId = initialTurn.turnId;
+                    turnLiveness.start();
                     await turnDonePromise;
+                    turnLiveness.stop();
                     const reason = mapperState.sawErrorResult
                         ? 'error'
                         : mapperState.sawTurnInterrupted
@@ -198,6 +243,7 @@ export function createCodexEngine() {
                     });
                 }
                 catch (err) {
+                    turnLiveness.stop();
                     const error = err;
                     const message = error.message ?? String(err);
                     const isAbort = userInterrupted || error.name === 'AbortError' || abortController.signal.aborted;
@@ -205,6 +251,9 @@ export function createCodexEngine() {
                     if (isAbort) {
                         safeEmit({ kind: 'session:ended', reason: 'killed', exitCode: null });
                     }
+                    else if (error.name === 'CodexTurnTimeoutError') {
+                        safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
+                    }
                     else if (QUOTA_PATTERN.test(message)) {
                         tryEmitQuota(mapperState, safeEmit, message);
                         safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
@@ -219,6 +268,8 @@ export function createCodexEngine() {
                     }
                 }
                 finally {
+                    turnLiveness.stop();
+                    streamingBatcher.close();
                     iteratorRunning = false;
                     client.close();
                     try {
@@ -257,13 +308,23 @@ export function createCodexEngine() {
                 },
                 interrupt() {
                     userInterrupted = true;
-                    abortController.abort();
-                    if (discoveredSessionId) {
-                        client.interruptTurn({ threadId: discoveredSessionId }).catch(() => { });
-                    }
+                    if (gracefulInterruptPromise)
+                        return;
+                    gracefulInterruptPromise = (async () => {
+                        if (discoveredSessionId) {
+                            await Promise.race([
+                                client.interruptTurn({ threadId: discoveredSessionId }).catch(() => { }),
+                                wait(CODEX_GRACEFUL_INTERRUPT_TIMEOUT_MS),
+                            ]);
+                        }
+                        await Promise.race([turnDonePromise.catch(() => { }), wait(CODEX_GRACEFUL_INTERRUPT_TIMEOUT_MS)]);
+                        if (iteratorRunning)
+                            abortController.abort();
+                    })();
                 },
                 async stop() {
-                    abortController.abort();
+                    engineProcess.interrupt();
+                    await gracefulInterruptPromise;
                     try {
                         await iteratorPromise;
                     }
@@ -282,6 +343,7 @@ export function createCodexEngine() {
                     if (!pending)
                         return false;
                     pendingByCallId.delete(callId);
+                    turnLiveness.resume();
                     const result = buildResponseForResolve(pending, response);
                     client.peer.respond(pending.requestId, result);
                     return true;

package/dist/server/services/agent/engines/codex/server-requests.js

@@ -1,5 +1,5 @@
 export function handleServerRequest(args) {
-    const { method, params, requestId, emit, register, respondError } = args;
+    const { method, params, requestId, emit, register, respondError, respond, autoApprove } = args;
     const p = (params ?? {});
     const callId = typeof p.callId === 'string' ? p.callId : `srv_${requestId}`;
     if (method === 'mcpServer/elicitation/request') {
@@ -13,24 +13,34 @@ export function handleServerRequest(args) {
     // (`execCommandApproval`, `applyPatchApproval`) are kept for compat with
     // older Codex CLI builds that haven't transitioned to the v2 namespace.
     if (method === 'item/commandExecution/requestApproval' || method === 'execCommandApproval') {
+        const payload = { command: p.command, cwd: p.cwd, reason: p.reason };
+        if (autoApprove?.('Bash', payload)) {
+            respond?.(requestId, { decision: 'accept' });
+            return true;
+        }
         register(callId, { requestId, kind: 'command', payload: p });
         emit({
             kind: 'session:user-input-requested',
             requestKind: 'permission',
             toolCallId: callId,
             toolName: 'Bash',
-            payload: { command: p.command, cwd: p.cwd, reason: p.reason },
+            payload,
         });
         return true;
     }
     if (method === 'item/fileChange/requestApproval' || method === 'applyPatchApproval') {
+        const payload = { changes: p.changes, reason: p.reason };
+        if (autoApprove?.('Edit', payload)) {
+            respond?.(requestId, { decision: 'accept' });
+            return true;
+        }
         register(callId, { requestId, kind: 'file_change', payload: p });
         emit({
             kind: 'session:user-input-requested',
             requestKind: 'permission',
             toolCallId: callId,
             toolName: 'Edit',
-            payload: { changes: p.changes, reason: p.reason },
+            payload,
         });
         return true;
     }

package/dist/server/services/agent/engines/codex/turn-liveness.js

@@ -0,0 +1,53 @@
+/**
+ * Tracks a single active Codex turn. A pending user decision deliberately
+ * pauses the deadline: the agent is waiting on a human, not stalled.
+ */
+export function createTurnLiveness(input) {
+    let timer;
+    let active = false;
+    let paused = false;
+    let timedOut = false;
+    const arm = () => {
+        if (!active || paused || timedOut)
+            return;
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            if (!active || paused || timedOut)
+                return;
+            timedOut = true;
+            input.onTimeout();
+        }, input.timeoutMs);
+    };
+    return {
+        start() {
+            active = true;
+            paused = false;
+            timedOut = false;
+            arm();
+        },
+        activity() {
+            arm();
+        },
+        pause() {
+            paused = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+        },
+        resume() {
+            if (!active || !paused)
+                return;
+            paused = false;
+            arm();
+        },
+        stop() {
+            active = false;
+            paused = false;
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+        },
+    };
+}

package/dist/server/services/agent/event-router.js

@@ -6,5 +6,9 @@ export function routeEvent(workspaceId, agentSessionId, event) {
         emitEphemeral(workspaceId, 'agent:event', event);
         return;
     }
+    if (event.kind === 'mcp:status' && event.status !== 'error') {
+        emitEphemeral(workspaceId, 'agent:event', event);
+        return;
+    }
     emit(workspaceId, 'agent:event', event, agentSessionId);
 }

package/dist/server/services/agent/orchestrator.js

@@ -11,6 +11,7 @@ import { getEffectiveSettings } from '../settings-service.js';
 import { refreshNow } from '../usage/poller.js';
 import * as wakeupService from '../wakeup-service.js';
 import { emit, emitEphemeral } from '../websocket-service.js';
+import * as permissionPolicyService from '../workspace-permission-policy-service.js';
 import { getWorkspace as getWs, markWorkspaceUnread, updateWorkspaceStatus, } from '../workspace-service.js';
 import { resolveEngine } from './engines/registry.js';
 import { routeEvent } from './event-router.js';
@@ -554,6 +555,10 @@ function handleEvent(workspaceId, agentSessionId, ev) {
         tasksDoneSnapshot.delete(workspaceId);
         taskStateSnapshot.delete(workspaceId);
         clearPendingForSession(workspaceId, agentSessionId);
+        // A completed/failed SDK session cannot resolve canUseTool anymore. Drop
+        // its persisted prompts too, otherwise a reconnect resurrects a panel
+        // whose backend callback has already been discarded.
+        purgeAllPersistedUserInputRequests(workspaceId, agentSessionId);
         // Must run BEFORE autoLoopService.onSessionEnded → spawnNextIteration →
         // startAgent, otherwise startAgent throws "Agent already running" because
         // the just-ended controller is still in the map.
@@ -698,6 +703,8 @@ function onSessionEnded(workspaceId, agentSessionId, exitCode, reason, resumeFai
  * query the controller via `_getControllers()` for tests.
  */
 export function startAgent(workspaceId, workingDir, prompt, model, resume = false, agentPermissionMode, existingSessionId, reasoningEffort) {
+    // "For this turn" never survives a new agent session.
+    permissionPolicyService.clearTurnPermissions(workspaceId);
     // Zombie detection: an SDK iterator hung on a never-resolved canUseTool
     // callback can leave its controller in the map after the workspace is
     // logically idle. Evict it instead of refusing the new session.
@@ -1019,6 +1026,16 @@ export async function answerPendingPermission(workspaceId, decision) {
     const response = decision.decision === 'allow'
         ? { kind: 'permission-allow' }
         : { kind: 'permission-deny', reason: decision.reason };
+    if (decision.decision === 'allow' && (decision.scope === 'operation' || decision.scope === 'tool')) {
+        permissionPolicyService.createWorkspacePermissionRule(workspaceId, { engine: ws.engine ?? 'claude-code', toolName: head.toolName, payload: head.toolInput }, decision.scope);
+    }
+    if (decision.decision === 'allow' && decision.scope === 'turn') {
+        permissionPolicyService.allowPermissionForTurn(workspaceId, {
+            engine: ws.engine ?? 'claude-code',
+            toolName: head.toolName,
+            payload: head.toolInput,
+        });
+    }
     const resolved = engineProcess.resolvePendingUserInput(decision.toolCallId, response);
     if (!resolved) {
         throw new Error(`No pending callback for toolCallId '${decision.toolCallId}'`);

package/dist/server/services/agent/streaming-batcher.js

@@ -0,0 +1,34 @@
+/** Coalesces token deltas before they reach WebSocket persistence. */
+export function createStreamingBatcher(emit, options = {}) {
+    const windowMs = options.windowMs ?? 40;
+    const pending = new Map();
+    const flush = (messageId) => {
+        const entry = pending.get(messageId);
+        if (!entry)
+            return;
+        clearTimeout(entry.timer);
+        pending.delete(messageId);
+        emit({ kind: 'message:text', messageId, text: entry.text, streaming: true });
+    };
+    return {
+        push(event) {
+            if (event.kind === 'message:text' && event.streaming) {
+                const entry = pending.get(event.messageId);
+                if (entry) {
+                    entry.text += event.text;
+                    return;
+                }
+                const timer = setTimeout(() => flush(event.messageId), windowMs);
+                pending.set(event.messageId, { text: event.text, timer });
+                return;
+            }
+            if (event.kind === 'message:end')
+                flush(event.messageId);
+            emit(event);
+        },
+        close() {
+            for (const messageId of [...pending.keys()])
+                flush(messageId);
+        },
+    };
+}

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

@@ -269,6 +269,25 @@ export async function extractNotionPage(notionUrl) {
         mcpProcess.kill();
     }
 }
+/** Lightweight MCP/auth smoke test; does not read a user page or mutate Notion. */
+export async function testNotionConnection() {
+    const startedAt = Date.now();
+    const global = getGlobalSettings();
+    const mcpProcess = spawnNotionMcp(global.notionMcpKey);
+    try {
+        await initializeMcp(mcpProcess);
+        await callMcpTool(mcpProcess, 'API-get-users', { page_size: 1 });
+        return {
+            ok: true,
+            durationMs: Date.now() - startedAt,
+            detail: 'MCP connection and Notion authentication succeeded',
+        };
+    }
+    finally {
+        mcpProcess.stdin?.end();
+        mcpProcess.kill();
+    }
+}
 export async function listNotionUsers() {
     const global = getGlobalSettings();
     const mcpProcess = spawnNotionMcp(global.notionMcpKey);

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

@@ -61,7 +61,7 @@ export function searchEvents(query, options = {}) {
     // realistic datasets, without scanning the entire table.
     const dbLimit = Math.max(limit * 3, 100);
     const rows = db
-        .prepare(`SELECT e.workspace_id, e.type, e.created_at, e.payload,
+        .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
@@ -88,6 +88,8 @@ export function searchEvents(query, options = {}) {
         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,

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

@@ -13,6 +13,26 @@ export function parseSentryUrl(url) {
     }
     return match[1];
 }
+/** Lightweight MCP/auth smoke test; does not access or mutate an issue. */
+export async function testSentryConnection() {
+    const startedAt = Date.now();
+    const global = getGlobalSettings();
+    const config = readSentryMcpConfig(global.sentryMcpKey);
+    const mcpProcess = spawnMcpProcess(config.command, config.args, config.env);
+    try {
+        await initializeMcp(mcpProcess);
+        await callMcpTool(mcpProcess, 'whoami', {});
+        return {
+            ok: true,
+            durationMs: Date.now() - startedAt,
+            detail: 'MCP connection and Sentry authentication succeeded',
+        };
+    }
+    finally {
+        mcpProcess.stdin?.end();
+        mcpProcess.kill();
+    }
+}
 const SENTRY_CONFIG_ERROR = "Sentry MCP server not configured in ~/.claude.json — add an enabled 'sentry' entry under mcpServers";
 /**
  * Return the first enabled (`disabled !== true`) MCP server entry from

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

@@ -750,6 +750,24 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 46,
+        name: 'add-integration-enabled-switches',
+        migrate: ({ global }) => {
+            if (typeof global.notionEnabled !== 'boolean')
+                global.notionEnabled = true;
+            if (typeof global.sentryEnabled !== 'boolean')
+                global.sentryEnabled = true;
+        },
+    },
+    {
+        version: 47,
+        name: 'add-thinking-block-visibility',
+        migrate: ({ global }) => {
+            if (typeof global.showThinkingBlocks !== 'boolean')
+                global.showThinkingBlocks = true;
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -837,6 +855,9 @@ function defaultSettings() {
             defaultPermissionModeByEngine: { 'claude-code': 'plan', codex: 'plan' },
             notionMcpKey: '',
             sentryMcpKey: '',
+            notionEnabled: true,
+            sentryEnabled: true,
+            showThinkingBlocks: true,
             tags: [...DEFAULT_WORKSPACE_TAGS],
             branchPrefixes: [...DEFAULT_BRANCH_PREFIXES],
             worktreesPath: WORKTREES_PATH,
@@ -1219,6 +1240,9 @@ export function updateGlobalSettings(data) {
         'defaultPermissionModeByEngine',
         'notionMcpKey',
         'sentryMcpKey',
+        'notionEnabled',
+        'sentryEnabled',
+        'showThinkingBlocks',
         'tags',
         'branchPrefixes',
         'worktreesPath',

package/dist/server/services/workspace-permission-policy-service.js

@@ -0,0 +1,86 @@
+import { createHash } from 'node:crypto';
+import { nanoid } from 'nanoid';
+import { getDb } from '../db/index.js';
+const turnRules = new Map();
+function turnKey(request) {
+    return `${request.engine}\u0000${request.toolName}`;
+}
+export function allowPermissionForTurn(workspaceId, request) {
+    const rules = turnRules.get(workspaceId) ?? new Set();
+    rules.add(turnKey(request));
+    turnRules.set(workspaceId, rules);
+}
+export function clearTurnPermissions(workspaceId) {
+    turnRules.delete(workspaceId);
+}
+function stable(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(',')}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stable(record[key])}`)
+        .join(',')}}`;
+}
+export function permissionFingerprint(payload) {
+    return createHash('sha256').update(stable(payload)).digest('hex');
+}
+function toRule(row) {
+    return {
+        id: String(row.id),
+        workspaceId: String(row.workspace_id),
+        engine: row.engine,
+        toolName: String(row.tool_name),
+        scope: row.scope,
+        fingerprint: row.fingerprint,
+        displayLabel: String(row.display_label),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+export function listWorkspacePermissionRules(workspaceId) {
+    return getDb()
+        .prepare('SELECT * FROM workspace_permission_rules WHERE workspace_id=? ORDER BY created_at DESC')
+        .all(workspaceId).map(toRule);
+}
+export function createWorkspacePermissionRule(workspaceId, request, scope) {
+    const now = new Date().toISOString();
+    const id = nanoid();
+    const fingerprint = scope === 'operation' ? permissionFingerprint(request.payload) : null;
+    const displayLabel = scope === 'tool' ? request.toolName : `${request.toolName} — opération précise`;
+    getDb()
+        .prepare('INSERT INTO workspace_permission_rules (id,workspace_id,engine,tool_name,scope,fingerprint,display_label,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?)')
+        .run(id, workspaceId, request.engine, request.toolName, scope, fingerprint, displayLabel, now, now);
+    return {
+        id,
+        workspaceId,
+        engine: request.engine,
+        toolName: request.toolName,
+        scope,
+        fingerprint,
+        displayLabel,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export function removeWorkspacePermissionRule(workspaceId, ruleId) {
+    return (getDb().prepare('DELETE FROM workspace_permission_rules WHERE id=? AND workspace_id=?').run(ruleId, workspaceId)
+        .changes > 0);
+}
+export function isWorkspacePermissionAllowed(workspaceId, request) {
+    if (turnRules.get(workspaceId)?.has(turnKey(request)))
+        return true;
+    const fingerprint = permissionFingerprint(request.payload);
+    try {
+        return Boolean(getDb()
+            .prepare(`SELECT 1 FROM workspace_permission_rules WHERE workspace_id=? AND tool_name=? AND (engine IS NULL OR engine=?) AND (scope='tool' OR (scope='operation' AND fingerprint=?)) LIMIT 1`)
+            .get(workspaceId, request.toolName, request.engine, fingerprint));
+    }
+    catch (error) {
+        if (error instanceof Error && /no such table/i.test(error.message))
+            return false;
+        throw error;
+    }
+}

package/dist/server/utils/paths.js

@@ -137,10 +137,10 @@ export function getChangelogPath() {
     return getPackageAssetPath('CHANGELOG.md');
 }
 /**
- * Absolute path to the built Quasar SPA (src/client/dist/spa). Returns null
+ * Absolute path to the built Quasar PWA (src/client/dist/pwa). Returns null
  * if the SPA has not been built yet.
  */
 export function getClientSpaPath() {
-    const spa = getPackageAssetPath('src', 'client', 'dist', 'spa');
-    return fs.existsSync(spa) ? spa : null;
+    const pwa = getPackageAssetPath('src', 'client', 'dist', 'pwa');
+    return fs.existsSync(pwa) ? pwa : null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.10.3",
+  "version": "1.11.0",
   "description": "Kōbō — multi-workspace agent manager for Claude Code. Orchestrates isolated git worktrees with dev servers, Notion integration, and MCP tools.",
   "type": "module",
   "license": "GPL-3.0-or-later",
@@ -9,7 +9,7 @@
   },
   "files": [
     "dist/",
-    "src/client/dist/spa/",
+    "src/client/dist/pwa/",
     "src/mcp-server/",
     "AGENTS.md",
     "README.md",
@@ -51,7 +51,7 @@
     "dev": "KOBO_ENFORCE_LOCAL_HOME=1 KOBO_HOME=./data PORT=3300 tsx watch src/server/index.ts",
     "dev:client": "cd src/client && KOBO_BACKEND_PORT=3300 npx quasar dev",
     "dev:all": "concurrently \"npm run dev\" \"npm run dev:client\"",
-    "build:client": "cd src/client && npx quasar build",
+    "build:client": "cd src/client && npx quasar build -m pwa",
     "build:server": "npx tsc && chmod +x dist/server/index.js",
     "build": "npm run build:client && npm run build:server",
     "install-all": "npm install && cd src/client && npm install",

package/src/client/dist/pwa/assets/ActivityFeed-D9EfbRqv.css

@@ -0,0 +1 @@
+.markdown-message[data-v-1b7bd8ca]{color:#e0e0e0;word-break:break-word;overflow-wrap:anywhere;min-width:0;max-width:100%;font-size:13px;line-height:1.55}.markdown-message[data-v-1b7bd8ca] *{max-width:100%}.markdown-message[data-v-1b7bd8ca] p{margin:0 0 .5em}.markdown-message[data-v-1b7bd8ca] p:last-child{margin-bottom:0}.markdown-message[data-v-1b7bd8ca] pre{background:#00000059;border-radius:4px;margin:.5em 0;padding:.5em .75em;overflow-x:auto}.markdown-message[data-v-1b7bd8ca] code{word-break:break-all;background:#0000004d;border-radius:3px;padding:.1em .3em;font-size:.9em}.markdown-message[data-v-1b7bd8ca] pre code{background:0 0;padding:0}.markdown-message[data-v-1b7bd8ca] ul,.markdown-message[data-v-1b7bd8ca] ol{margin:.25em 0 .5em;padding-left:1.5em}.markdown-message[data-v-1b7bd8ca] li{margin:.15em 0}.markdown-message[data-v-1b7bd8ca] a{color:#7986cb;text-decoration:underline}.markdown-message[data-v-1b7bd8ca] .document-link{color:#9fa8da;cursor:pointer;-webkit-text-decoration:underline dotted;text-decoration:underline dotted}.markdown-message[data-v-1b7bd8ca] .document-link:hover{color:#c5cae9;-webkit-text-decoration:underline;text-decoration:underline}.markdown-message[data-v-1b7bd8ca] h1,.markdown-message[data-v-1b7bd8ca] h2,.markdown-message[data-v-1b7bd8ca] h3,.markdown-message[data-v-1b7bd8ca] h4,.markdown-message[data-v-1b7bd8ca] h5,.markdown-message[data-v-1b7bd8ca] h6{margin:.5em 0 .3em;font-weight:600;line-height:1.3}.markdown-message[data-v-1b7bd8ca] h1{font-size:1.25em}.markdown-message[data-v-1b7bd8ca] h2{font-size:1.15em}.markdown-message[data-v-1b7bd8ca] h3{font-size:1.08em}.markdown-message[data-v-1b7bd8ca] h4,.markdown-message[data-v-1b7bd8ca] h5,.markdown-message[data-v-1b7bd8ca] h6{font-size:1em}.markdown-message[data-v-1b7bd8ca] blockquote{color:#ffffffb3;border-left:3px solid #fff3;margin:.5em 0;padding-left:.75em}.markdown-message[data-v-1b7bd8ca] table{border-collapse:collapse;margin:.5em 0}.markdown-message[data-v-1b7bd8ca] th,.markdown-message[data-v-1b7bd8ca] td{border:1px solid #ffffff26;padding:.25em .5em}.tool-row[data-v-fc912366]{border-radius:4px;margin:0;font-size:12px}.tool-header[data-v-fc912366]{color:#bbb;cursor:default;align-items:center;gap:10px;min-width:0;padding:5px 10px;display:flex}.tool-row:not(.tool-row-generic) .tool-header[data-v-fc912366],.tool-row--toggleable .tool-header[data-v-fc912366]{cursor:pointer}.tool-row:has(.tool-diff) .tool-header[data-v-fc912366]{cursor:pointer}.tool-row:not(.tool-row-generic) .tool-header[data-v-fc912366]:hover,.tool-row--toggleable .tool-header[data-v-fc912366]:hover{background:#ffffff08}.tool-icon[data-v-fc912366]{color:#9fbce0;flex-shrink:0}.tool-name[data-v-fc912366]{color:#d0d0d0;flex-shrink:0;font-weight:600}.tool-arg[data-v-fc912366],.tool-path[data-v-fc912366]{color:#999;text-overflow:ellipsis;white-space:nowrap;min-width:0;max-width:100%;font-family:SF Mono,Menlo,Consolas,monospace;font-size:11.5px;overflow:hidden}.tool-open-diff[data-v-fc912366]{flex-shrink:0}.tool-path[data-v-fc912366],.tool-arg[data-v-fc912366]{flex:1}.tool-stat-add[data-v-fc912366]{color:#66bb6a;flex-shrink:0;font-size:11px;font-weight:600}.tool-stat-del[data-v-fc912366]{color:#ef5350;flex-shrink:0;font-size:11px;font-weight:600}.tool-diff[data-v-fc912366]{background:#0003;border-radius:4px;max-height:400px;margin-top:4px;padding:8px 0;font-family:SF Mono,Menlo,Consolas,monospace;font-size:11px;line-height:1.5;overflow:auto}.diff-line[data-v-fc912366]{white-space:pre;color:#bbb;padding:0 12px}.diff-sign[data-v-fc912366]{color:#555;-webkit-user-select:none;user-select:none;width:14px;display:inline-block}.diff-add[data-v-fc912366]{color:#c8e6c9;background:#66bb6a1a}.diff-add .diff-sign[data-v-fc912366]{color:#66bb6a}.diff-del[data-v-fc912366]{color:#ffcdd2;background:#ef53501a}.diff-del .diff-sign[data-v-fc912366]{color:#ef5350}.tool-output[data-v-fc912366]{color:#aaa;white-space:pre-wrap;background:#00000026;border-radius:4px;max-height:8em;margin-top:4px;padding:6px 10px;font-family:SF Mono,Menlo,Consolas,monospace;font-size:11px;overflow:auto}.markdown-message[data-v-f34be4c5]{color:#e0e0e0;word-break:break-word;overflow-wrap:anywhere;min-width:0;max-width:100%;font-size:13px;line-height:1.55}.markdown-message[data-v-f34be4c5] *{max-width:100%}.markdown-message[data-v-f34be4c5] img{-o-object-fit:contain;object-fit:contain;cursor:zoom-in;background:#0003;border-radius:4px;max-width:180px;max-height:100px;margin:.3em 0;display:block}.markdown-message[data-v-f34be4c5] code{word-break:break-all}.markdown-message[data-v-f34be4c5] p{margin:0 0 .4em}.markdown-message[data-v-f34be4c5] p:last-child{margin-bottom:0}.markdown-message[data-v-f34be4c5] code{background:#00000040;border-radius:3px;padding:.1em .3em}.markdown-message[data-v-f34be4c5] h1,.markdown-message[data-v-f34be4c5] h2,.markdown-message[data-v-f34be4c5] h3,.markdown-message[data-v-f34be4c5] h4,.markdown-message[data-v-f34be4c5] h5,.markdown-message[data-v-f34be4c5] h6{margin:.4em 0 .25em;font-weight:600;line-height:1.3}.markdown-message[data-v-f34be4c5] h1{font-size:1.25em}.markdown-message[data-v-f34be4c5] h2{font-size:1.15em}.markdown-message[data-v-f34be4c5] h3{font-size:1.08em}.markdown-message[data-v-f34be4c5] h4,.markdown-message[data-v-f34be4c5] h5,.markdown-message[data-v-f34be4c5] h6{font-size:1em}.markdown-user-prompt[data-v-f34be4c5]{color:#aaa;font-size:12px;font-style:italic}.markdown-user-prompt[data-v-f34be4c5] p{margin:0 0 .4em}.markdown-user-prompt[data-v-f34be4c5] code{background:#ffffff14;border-radius:3px;padding:.1em .3em;font-style:normal}.image-lightbox-img{-o-object-fit:contain;object-fit:contain;cursor:zoom-out;background:#0000004d;border-radius:4px;max-width:92vw;max-height:92vh;display:block}.turn-card[data-v-6b8d8e3e]{border:1px solid #ffffff14;border-left:3px solid var(--turn-accent);background:#ffffff05;border-radius:6px;min-width:0;max-width:100%;margin:14px 0;overflow:hidden}.turn-card--highlighted[data-v-6b8d8e3e]{animation:1.8s ease-out search-highlight-6b8d8e3e}@keyframes search-highlight-6b8d8e3e{0%,45%{box-shadow:0 0 0 2px #818cf8f2,0 0 22px #818cf873}to{box-shadow:none}}.turn-header[data-v-6b8d8e3e]{color:#888;background:#ffffff08;border-bottom:1px solid #ffffff0d;align-items:center;gap:8px;padding:8px 14px;font-size:11px;display:flex}.turn-badge[data-v-6b8d8e3e]{letter-spacing:.3px;border-radius:3px;padding:2px 8px;font-size:11px;font-weight:700}.turn-badge-user[data-v-6b8d8e3e]{color:#ce93d8;background:#ce93d826}.turn-badge-agent[data-v-6b8d8e3e]{color:#7986cb;background:#7986cb26}.turn-badge-system[data-v-6b8d8e3e]{color:#bdbdbd;background:#75757533;font-style:italic}.turn-badge-session[data-v-6b8d8e3e]{color:#9e9e9e;background:#61616133}.turn-badge-script[data-v-6b8d8e3e]{color:#4db6ac;background:#4db6ac26}.turn-time[data-v-6b8d8e3e]{color:#666;font-family:SF Mono,Menlo,Consolas,monospace;font-size:11px}.turn-time-arrow[data-v-6b8d8e3e]{opacity:.7;margin:0 -2px}.turn-time-updated[data-v-6b8d8e3e]{color:#8891a3}.turn-actions[data-v-6b8d8e3e]{color:#777;font-size:11px}.turn-body[data-v-6b8d8e3e]{flex-direction:column;gap:12px;min-width:0;padding:14px 18px;display:flex}.turn-body[data-v-6b8d8e3e]>*{min-width:0;max-width:100%}.turn-body[data-v-6b8d8e3e] .tool-row+.tool-row{margin-top:-8px}.turn-scroll-top[data-v-6b8d8e3e]{justify-content:flex-start;padding:0 8px 6px;display:flex}.turn-scroll-top-btn[data-v-6b8d8e3e]{opacity:.5;transition:opacity .15s}.turn-scroll-top-btn[data-v-6b8d8e3e]:hover{opacity:1}.activity-feed-wrap[data-v-0cdc51af]{width:100%;height:100%;position:relative}.activity-feed-scroll[data-v-0cdc51af]{width:100%;height:100%}.activity-feed-nav-cluster[data-v-0cdc51af]{z-index:2;align-items:center;gap:8px;display:flex;position:absolute;bottom:14px;right:14px}.activity-feed-compacting[data-v-0cdc51af]{z-index:3;background:var(--kobo-surface);border:1px solid var(--kobo-border);border-radius:6px;align-items:center;gap:8px;padding:6px 14px;display:flex;position:absolute;top:12px;left:50%;transform:translate(-50%);box-shadow:0 4px 16px #00000059}.fade-enter-active[data-v-0cdc51af],.fade-leave-active[data-v-0cdc51af]{transition:opacity .16s}.fade-enter-from[data-v-0cdc51af],.fade-leave-to[data-v-0cdc51af]{opacity:0}.activity-feed-nav-btn[data-v-0cdc51af]{opacity:.8;transition:opacity .12s}.activity-feed-nav-btn[data-v-0cdc51af]:hover{opacity:1}.content-origin-marker[data-v-0cdc51af]{pointer-events:none;width:0;height:0;margin:0;padding:0}.activity-feed-scroll[data-v-0cdc51af] .q-scrollarea__content{max-width:100%;overflow-x:hidden}.activity-feed-switching[data-v-0cdc51af]{justify-content:center;align-items:center;width:100%;height:100%;display:flex}