@loicngr/kobo 1.11.15 → 1.11.17

package/AGENTS.md

@@ -240,7 +240,7 @@ Sequence: `captureRestoreData` (best-effort forge lookup for PR number / URL / m
 
 ### Bulk workspace info refresh
 
-`GET /api/workspaces/info` returns `{ workspaces, prSnapshots, gitStats }` in one shot. The client polls this endpoint every 30 s so every non-archived workspace stays ≤ 30 s fresh without a per-card stats request. The server-side pr-watcher feeds the same caches (`lastKnownGitStats` map, PR snapshots) so the work is shared between the polling client and the watchdog loop.
+`GET /api/workspaces/info` returns `{ workspaces, prSnapshots, gitStats }` in one shot. The client polls this endpoint every 15 s so every non-archived workspace stays ≤ 15 s fresh without a per-card stats request. The poll is skipped while the browser tab is hidden and fires once immediately when the tab becomes visible again. The server-side pr-watcher feeds the same caches (`lastKnownGitStats` map, PR snapshots) so the work is shared between the polling client and the watchdog loop.
 
 ### File editing in the diff viewer
 

package/CHANGELOG.md

@@ -4,6 +4,19 @@ 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.17
+
+- feat(client): render in the design system's own type, palette and tokens (#34)
+- perf(client): stop re-rendering frozen content and racing stale requests (#33)
+- fix(client): make the review path usable and stop lying about navigation state (#32)
+- fix(git,db): serialize git writes, bound event history, verify irreversible ops (#31)
+- feat(client,server): tell the truth while working and when it fails (#30)
+- fix(agent): stop reporting a running agent when none exists (#29)
+
+## 1.11.16
+
+- feat(client): responsive mobile layout for drawer, settings nav and workspace toolbar (#28)
+
 ## 1.11.15
 
 - feat(agent): harden autonomous session lifecycle

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

@@ -3,7 +3,6 @@ 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 { runMigrations } from '../server/db/migrations.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';
 const workspaceId = process.env.KOBO_WORKSPACE_ID;
 const dbPath = process.env.KOBO_DB_PATH;
@@ -23,13 +22,15 @@ try {
     // KOBO_DB_PATH is passed). That would silently open a second connection
     // against the user's prod DB at ~/.config/kobo/kobo.db, which may not
     // even have the same schema as the dev DB the backend is using.
+    // On ouvre SANS migrer. Ce process est lancé une fois par workspace, sur le
+    // même fichier de base : `runMigrations` calcule l'ensemble des blocs
+    // appliqués AVANT de prendre le verrou, donc deux serveurs MCP démarrés
+    // ensemble peuvent rejouer le même bloc — et les blocs v2 à v19 ajoutent
+    // des colonnes sans garde d'existence. Un `duplicate column name` ici
+    // termine le process et prive l'agent de tous ses outils en pleine session.
+    // Le backend migre au démarrage, et il démarre nécessairement avant de
+    // pouvoir lancer ce serveur.
     db = getDb(dbPath);
-    // Defensive: run migrations to ensure the schema is at the latest version.
-    // The backend already ran them at boot, but this MCP server might be the
-    // first to touch the DB (e.g. tests, race at first boot, or KOBO_DB_PATH
-    // pointing somewhere the backend hasn't migrated). Idempotent — no-op if
-    // the DB is already at SCHEMA_VERSION.
-    runMigrations(db);
 }
 catch (err) {
     console.error('[kobo-tasks-server] Failed to open database:', err);

package/dist/server/db/migrations.js

@@ -604,6 +604,63 @@ export const migrations = [
             }
         },
     },
+    {
+        version: 36,
+        name: 'drop-metrics-delete-trigger-add-hot-indexes',
+        migrate: (db) => {
+            // The AFTER DELETE trigger installed by v34 re-aggregated the entire
+            // session for EVERY deleted row. Measured on an identical schema: 79.7 s
+            // for 20 000 events, 106.6 s through a cascade, with the SQLite write
+            // lock held for the whole duration — during which every WebSocket emit
+            // gives up after busy_timeout and loses the event for good.
+            // Metrics are now recomputed once, application-side, at the end of the
+            // transactions that delete events while keeping the session
+            // (recomputeSessionMetrics in workspace-service.ts).
+            db.exec('DROP TRIGGER IF EXISTS trg_ws_events_metrics_delete');
+            const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name));
+            const hasColumns = (table, needed) => {
+                if (!tables.has(table))
+                    return false;
+                const columns = new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+                return needed.every((column) => columns.has(column));
+            };
+            // Five hot paths measured as full table scans before this migration.
+            const indexes = [
+                {
+                    table: 'tasks',
+                    columns: ['workspace_id', 'sort_order'],
+                    sql: 'CREATE INDEX IF NOT EXISTS idx_tasks_workspace_sort ON tasks(workspace_id, sort_order)',
+                },
+                {
+                    table: 'agent_sessions',
+                    columns: ['workspace_id', 'started_at'],
+                    sql: 'CREATE INDEX IF NOT EXISTS idx_agent_sessions_workspace_started ON agent_sessions(workspace_id, started_at DESC)',
+                },
+                {
+                    table: 'agent_sessions',
+                    columns: ['engine_session_id'],
+                    sql: 'CREATE INDEX IF NOT EXISTS idx_agent_sessions_engine_session ON agent_sessions(engine_session_id)',
+                },
+                {
+                    table: 'workspaces',
+                    columns: ['archived_at', 'updated_at'],
+                    sql: 'CREATE INDEX IF NOT EXISTS idx_workspaces_archived_updated ON workspaces(archived_at, updated_at DESC)',
+                },
+                {
+                    table: 'session_event_metrics',
+                    columns: ['session_id'],
+                    sql: 'CREATE INDEX IF NOT EXISTS idx_session_event_metrics_session ON session_event_metrics(session_id)',
+                },
+            ];
+            // Column guards, not just table guards: several shipped migration tests
+            // build a stripped-down table (e.g. `workspaces(id, engine)`) and replay
+            // every later migration on top of it.
+            for (const index of indexes) {
+                if (hasColumns(index.table, index.columns))
+                    db.exec(index.sql);
+            }
+        },
+    },
 ];
 /** 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

@@ -125,45 +125,6 @@ export function initSchema(db) {
         output_tokens = MAX(output_tokens, excluded.output_tokens);
     END;
 
-    CREATE TRIGGER IF NOT EXISTS trg_ws_events_metrics_delete
-    AFTER DELETE ON ws_events
-    WHEN OLD.type = 'agent:event' AND OLD.session_id IS NOT NULL
-    BEGIN
-      DELETE FROM session_event_metrics
-      WHERE workspace_id = OLD.workspace_id AND session_id = OLD.session_id;
-
-      INSERT INTO session_event_metrics (
-        workspace_id, session_id, tool_calls, errors, input_tokens, output_tokens
-      )
-      SELECT
-        e.workspace_id,
-        e.session_id,
-        SUM(CASE WHEN json_extract(e.payload, '$.kind') = 'tool:call' THEN 1 ELSE 0 END),
-        SUM(CASE
-          WHEN json_extract(e.payload, '$.kind') = 'error'
-            OR (json_extract(e.payload, '$.kind') = 'tool:result'
-              AND json_extract(e.payload, '$.isError') = 1)
-          THEN 1 ELSE 0
-        END),
-        MAX(CASE
-          WHEN json_extract(e.payload, '$.kind') = 'usage'
-            AND json_type(e.payload, '$.inputTokens') IN ('integer', 'real')
-          THEN CAST(json_extract(e.payload, '$.inputTokens') AS INTEGER) ELSE 0
-        END),
-        MAX(CASE
-          WHEN json_extract(e.payload, '$.kind') = 'usage'
-            AND json_type(e.payload, '$.outputTokens') IN ('integer', 'real')
-          THEN CAST(json_extract(e.payload, '$.outputTokens') AS INTEGER) ELSE 0
-        END)
-      FROM ws_events e
-      JOIN agent_sessions s ON s.id = e.session_id AND s.workspace_id = e.workspace_id
-      WHERE e.workspace_id = OLD.workspace_id
-        AND e.session_id = OLD.session_id
-        AND e.type = 'agent:event'
-        AND json_valid(e.payload)
-      GROUP BY e.workspace_id, e.session_id;
-    END;
-
     CREATE TABLE IF NOT EXISTS workspace_permission_rules (
       id TEXT PRIMARY KEY,
       workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
@@ -236,5 +197,15 @@ export function initSchema(db) {
       ON ws_events(type, created_at DESC, id DESC);
     CREATE INDEX IF NOT EXISTS idx_workspace_chat_history_workspace_id_id
       ON workspace_chat_history(workspace_id, id DESC);
+    CREATE INDEX IF NOT EXISTS idx_tasks_workspace_sort
+      ON tasks(workspace_id, sort_order);
+    CREATE INDEX IF NOT EXISTS idx_agent_sessions_workspace_started
+      ON agent_sessions(workspace_id, started_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_agent_sessions_engine_session
+      ON agent_sessions(engine_session_id);
+    CREATE INDEX IF NOT EXISTS idx_workspaces_archived_updated
+      ON workspaces(archived_at, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_session_event_metrics_session
+      ON session_event_metrics(session_id);
   `);
 }

package/dist/server/index.js

@@ -25,7 +25,7 @@ import templatesRouter from './routes/templates.js';
 import usageRoutes from './routes/usage.js';
 import voiceRouter from './routes/voice.js';
 import workspacesRouter from './routes/workspaces.js';
-import { getAvailableSkills, reconcileOrphanSessions, restoreRetryCountsFromDb, sendMessage, setBackendPort, startAgent, startWatchdog, stopAgent, stopAllAgents, stopWatchdog, } from './services/agent/orchestrator.js';
+import { getAvailableSkills, isAgentUnavailableError, reconcileOrphanSessions, restoreRetryCountsFromDb, sendMessage, setBackendPort, startAgent, startWatchdog, stopAgent, stopAllAgents, stopWatchdog, } from './services/agent/orchestrator.js';
 import * as autoLoopService from './services/auto-loop-service.js';
 import { runContentMigrationIfNeeded } from './services/content-migration-service.js';
 import * as cronService from './services/cron-service.js';
@@ -41,6 +41,7 @@ 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 { pruneWsEvents, resolveRetentionConfig } from './services/ws-events-retention-service.js';
 import { getClientSpaPath, getDbPath, getKoboHome, getPackageVersion } from './utils/paths.js';
 console.log(`[kobo] Kōbō home: ${getKoboHome()}`);
 // Initialize DB + run migrations
@@ -53,12 +54,37 @@ try {
     if (pending.length > 0) {
         const result = await createPreMigrationBackup(db, getDbPath(), `v${pending[pending.length - 1]}`);
         console.log(`[kobo] Pre-migration backup before applying ${pending.length} migration(s): ${result.created}`);
+        if (result.deleted.length > 0) {
+            console.log(`[kobo] Rotated ${result.deleted.length} old pre-migration backup(s)`);
+        }
     }
 }
 catch (err) {
     console.error('[kobo] Pre-migration backup failed (continuing — daily backup remains as fallback):', err);
 }
 runMigrations(db);
+// Event retention. OPT-IN: disabled by default, so this is a no-op until the
+// user sets a window in Settings → Worktrees. When enabled it runs at boot
+// only: no session is alive yet, so the batched write lock disturbs nobody, and
+// the daily backup that follows snapshots an already-compacted file.
+// Best-effort — a failure must never block boot.
+try {
+    const retentionConfig = resolveRetentionConfig(getGlobalSettings());
+    if (retentionConfig.retentionDays > 0) {
+        const retentionStartedAt = Date.now();
+        const retention = pruneWsEvents(db, retentionConfig);
+        if (retention.deleted > 0 || retention.vacuumed) {
+            console.log(`[kobo] Event retention (${retentionConfig.retentionDays} d, keeping ${retentionConfig.keepPerWorkspace}/workspace): ` +
+                `${retention.deleted} agent event(s) permanently deleted, ` +
+                `${retention.sessionsRecomputed} session metric(s) recomputed, ` +
+                `${retention.vacuumed ? `VACUUM reclaimed ${retention.freePagesBefore - retention.freePagesAfter} page(s), ` : ''}` +
+                `${Date.now() - retentionStartedAt} ms`);
+        }
+    }
+}
+catch (err) {
+    console.error('[kobo] Event retention failed (continuing):', err);
+}
 // Daily DB backup (best-effort, fire-and-forget — never blocks boot).
 // Creates a WAL-safe snapshot alongside kobo.db if no backup exists in the
 // last 24h, and rotates out older backups beyond the retention window.
@@ -329,10 +355,11 @@ setMessageHandler(async (type, payload) => {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            // Only resume on the specific "No agent running" path. Other errors
-            // (stdin closed, process dead mid-write, etc.) should surface to the
-            // logs instead of silently respawning a fresh agent.
-            if (!msg.includes('No agent running')) {
+            // 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;
@@ -446,7 +473,7 @@ server.on('upgrade', (request, socket, head) => {
 });
 // Graceful shutdown handler
 let isShuttingDown = false;
-async function gracefulShutdown(signal) {
+async function gracefulShutdown(signal, exitCode = 0) {
     if (isShuttingDown)
         return;
     isShuttingDown = true;
@@ -517,7 +544,28 @@ async function gracefulShutdown(signal) {
     }
     clearTimeout(forceExitTimer);
     console.log('[kobo] Shutdown complete');
-    process.exit(0);
+    process.exit(exitCode);
 }
 process.on('SIGTERM', () => void gracefulShutdown('SIGTERM'));
 process.on('SIGINT', () => void gracefulShutdown('SIGINT'));
+// Fermeture du terminal parent : sans ce gestionnaire, Node termine le
+// process sans passer par l'arrêt propre, donc sans fermer la base.
+process.on('SIGHUP', () => void gracefulShutdown('SIGHUP'));
+// Un `EPIPE` sur stdout/stderr — typiquement quand la sortie est redirigée
+// vers un lecteur qui s'est fermé — est émis de façon asynchrone et tue le
+// process. On l'ignore : perdre une ligne de journal ne doit jamais arrêter
+// le serveur.
+process.stdout.on('error', () => { });
+process.stderr.on('error', () => { });
+// Filets de dernier recours. On ne poursuit PAS l'exécution après une
+// exception non capturée : l'état du process est indéterminé. On garantit
+// seulement une trace exploitable et une fermeture propre de la base et des
+// WebSockets — ce que la terminaison implicite de Node ne fait pas.
+process.on('uncaughtException', (err) => {
+    console.error('[kobo] Uncaught exception — shutting down:', err);
+    void gracefulShutdown('uncaughtException', 1);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('[kobo] Unhandled promise rejection — shutting down:', reason);
+    void gracefulShutdown('unhandledRejection', 1);
+});

package/dist/server/routes/git.js

@@ -20,15 +20,20 @@ app.get('/branches', (c) => {
         return c.json({ error: message }, 500);
     }
 });
-// GET /api/git/files?path=<worktreePath> — list a worktree's files (tracked +
-// untracked-but-not-ignored) for the chat's `@file` autocomplete.
+/** Hard ceiling on the worktree listing. `listWorktreeFiles` already truncates
+ *  at this value; exposing it lets a caller ask for LESS, never for more. */
+const MAX_WORKTREE_FILES = 5000;
+// GET /api/git/files?path=<worktreePath>&limit=<n> — list a worktree's files
+// (tracked + untracked-but-not-ignored) for the chat's `@file` autocomplete.
 app.get('/files', (c) => {
     try {
         const repoPath = c.req.query('path');
         if (!repoPath) {
             return c.json({ error: 'Missing required query parameter: path' }, 400);
         }
-        return c.json({ files: listWorktreeFiles(repoPath) });
+        const requested = Number.parseInt(c.req.query('limit') ?? '', 10);
+        const limit = Number.isFinite(requested) && requested > 0 ? Math.min(requested, MAX_WORKTREE_FILES) : MAX_WORKTREE_FILES;
+        return c.json({ files: listWorktreeFiles(repoPath, limit) });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);

package/dist/server/routes/health.js

@@ -6,6 +6,7 @@ import { getDb } from '../db/index.js';
 import { SCHEMA_VERSION } from '../db/migrations.js';
 import { resolveCodexBinary } from '../services/agent/engines/codex/spawn.js';
 import { getGlobalSettings, getProjectSettings, SETTINGS_SCHEMA_VERSION } from '../services/settings-service.js';
+import { readRecentLogs } from '../utils/logger.js';
 import { getDbPath, getKoboHome, getPackageVersion } from '../utils/paths.js';
 import { slugifyProjectName } from '../utils/project-slug.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
@@ -48,12 +49,27 @@ function safeFileSize(p) {
         return null;
     }
 }
+const VALID_LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+// GET /api/health/logs?limit=200&level=error — most recent entries, newest first.
+// Declared BEFORE any dynamic segment, per the route-ordering invariant.
+app.get('/logs', (c) => {
+    try {
+        const rawLimit = Number.parseInt(c.req.query('limit') ?? '', 10);
+        const limit = Number.isFinite(rawLimit) ? rawLimit : 200;
+        const rawLevel = c.req.query('level');
+        const level = VALID_LOG_LEVELS.includes(rawLevel) ? rawLevel : undefined;
+        return c.json({ entries: readRecentLogs(level ? { limit, level } : { limit }) });
+    }
+    catch (err) {
+        return c.json({ error: err instanceof Error ? err.message : 'Failed to read logs' }, 500);
+    }
+});
 // GET /api/health/report — detailed health diagnostics for the Health panel.
 app.get('/report', async (c) => {
     const db = getDb();
     const dbPath = getDbPath();
     const home = getKoboHome();
-    const cliChecks = Promise.all([checkClaudeCli(), checkCodexCli()]);
+    const cliChecks = Promise.all([checkClaudeCli(), checkCodexCli(), checkCli('gh'), checkCli('glab')]);
     // DB schema version
     const row = db.prepare('SELECT MAX(version) as v FROM schema_migrations').get();
     const dbSchemaVersion = row?.v ?? 0;
@@ -145,7 +161,7 @@ app.get('/report', async (c) => {
         .all();
     const settingsRow = db.prepare('SELECT COUNT(*) as n FROM workspaces').get();
     const archivedRow = db.prepare('SELECT COUNT(*) as n FROM workspaces WHERE archived_at IS NOT NULL').get();
-    const [claudeCli, codexCli] = await cliChecks;
+    const [claudeCli, codexCli, ghCli, glabCli] = await cliChecks;
     const report = {
         version: getPackageVersion(),
         koboHome: home,
@@ -158,6 +174,7 @@ app.get('/report', async (c) => {
         settings: { schemaVersion: SETTINGS_SCHEMA_VERSION },
         claudeCli,
         codexCli,
+        forgeCli: { gh: ghCli, glab: glabCli },
         workspaces: {
             total: settingsRow.n,
             archived: archivedRow.n,

package/dist/server/routes/settings.js

@@ -1,4 +1,5 @@
 import { Hono } from 'hono';
+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 { generateToken, getLanUrls } from '../services/network-access-service.js';
@@ -7,6 +8,7 @@ import { DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT } from '../services/settings-defaul
 import * as settingsService from '../services/settings-service.js';
 import { DEFAULT_CI_FIX_PROMPT_TEMPLATE, DEFAULT_FINALIZATION_PROMPT, DEFAULT_GIT_CONVENTIONS, DEFAULT_PR_PROMPT_TEMPLATE, } from '../services/settings-service.js';
 import { listTemplates, replaceAllTemplates } from '../services/templates-service.js';
+import { countPrunableWsEvents } from '../services/ws-events-retention-service.js';
 /** Hono sub-router for global and per-project settings CRUD. */
 const app = new Hono();
 // GET /api/settings — return full settings
@@ -47,6 +49,28 @@ app.get('/defaults', (c) => {
         changeSourceBranchScript: DEFAULT_CHANGE_SOURCE_BRANCH_SCRIPT,
     });
 });
+// GET /api/settings/ws-events-retention-preview?days=<n>&keep=<n>
+// Count what a retention window WOULD delete, without deleting anything. Backs
+// the confirmation dialog: enabling retention on a year-old database destroys
+// months of conversation in one go, and the user is entitled to the number
+// before agreeing to it.
+app.get('/ws-events-retention-preview', (c) => {
+    try {
+        const days = Number.parseInt(c.req.query('days') ?? '', 10);
+        const keep = Number.parseInt(c.req.query('keep') ?? '', 10);
+        if (!Number.isInteger(days) || days < 0 || !Number.isInteger(keep) || keep < 0) {
+            return c.json({ error: 'days and keep must be non-negative integers' }, 400);
+        }
+        const db = getDb();
+        const total = db.prepare('SELECT COUNT(*) AS c FROM ws_events').get().c;
+        const deletable = countPrunableWsEvents(db, { retentionDays: days, keepPerWorkspace: keep });
+        return c.json({ deletable, total });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return c.json({ error: message }, 500);
+    }
+});
 // GET /api/settings/network — network access state + LAN URLs
 app.get('/network', (c) => {
     try {