@loicngr/kobo 2.1.4 → 2.1.6

package/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.
 
+## 2.1.6
+
+- feat(subagents): add focused activity views
+
+## 2.1.5
+
+- fix(workspace): improve reliability and git controls
+
 ## 2.1.4
 
 - chore(deps): update server client and pwa packages

package/CONFIGURATION.md

@@ -751,9 +751,17 @@ both global (the database is single):
 | Events always kept per workspace | `0` | The most recent events of each workspace survive whatever their age. Set it (5000 is a good starting point) at the same time you enable retention, so an old but still-open workspace keeps a readable history. |
 
 The prune runs **at server startup and every 24 hours** while the backend stays
-running. Each pass reads the current settings and deletes in batches of 5,000
-rows. When enough pages have been freed, a `VACUUM` returns the space to the
-filesystem.
+running. Each pass reads the current settings, calculates the protected workspace
+tails once, and deletes in batches of 500 rows on a dedicated worker. Preview
+counts also run on that worker, so maintenance does not block HTTP or agent
+event handling. Shutdown waits for the worker to finish its current batch and
+reconcile affected metrics before closing the database.
+
+Freed database pages are reused for new events. Live maintenance performs a
+non-blocking WAL checkpoint and deliberately does not run a full `VACUUM`, which
+would hold SQLite's writer lock and interrupt live agents. To return database
+file space to the filesystem immediately, stop Kōbō and perform an explicit
+offline SQLite `VACUUM` after making a backup.
 
 **What it deletes:** eligible rows of `ws_events` — the recorded agent output.
 Affected session metrics and the derived search index are reconciled with the

package/dist/server/index.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
-import WebSocket, { WebSocketServer } from 'ws';
+import { WebSocketServer } from 'ws';
 import { closeDb, getDb } from './db/index.js';
 import { getPendingMigrations, runMigrations } from './db/migrations.js';
 import { hostCheckMiddleware } from './middleware/host-check-middleware.js';
@@ -49,14 +49,16 @@ import { startSearchIndex, stopSearchIndex } from './services/search-service.js'
 import { reconcileSessionHandoffs } from './services/session-handoff-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 { destroyAllTerminals } from './services/terminal-service.js';
+import { handleTerminalConnection } from './services/terminal-websocket-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 { 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 { resolveRetentionConfig } from './services/ws-events-retention-service.js';
+import { runWsEventsRetention, stopWsEventsRetention } from './services/ws-events-retention-worker-service.js';
 import { getChangelogPath, getClientSpaPath, getDbPath, getKoboHome, getPackageVersion, resolveSpaFile, } from './utils/paths.js';
 import { formatStartupBanner, readStartupNotes, startStartupSpinner, startupDebug } from './utils/startup-display.js';
 startupDebug(`[kobo] Kōbō home: ${getKoboHome()}`);
@@ -87,13 +89,13 @@ startSearchIndex();
 // conversation on the next upgrade, which is precisely why the UI shows a
 // count and asks first.
 // Best-effort — a failure must never block boot.
-function runRetentionPass(context) {
+async function runRetentionPass(context) {
     try {
         const retentionConfig = resolveRetentionConfig(getGlobalSettings());
         if (retentionConfig.retentionDays <= 0)
             return;
         const retentionStartedAt = Date.now();
-        const retention = pruneWsEvents(db, retentionConfig);
+        const retention = await runWsEventsRetention(retentionConfig);
         if (retention.deleted > 0 || retention.vacuumed) {
             console.log(`[kobo] Event retention ${context} (${retentionConfig.retentionDays} d, keeping ${retentionConfig.keepPerWorkspace}/workspace): ` +
                 `${retention.deleted} agent event(s) permanently deleted, ` +
@@ -106,12 +108,12 @@ function runRetentionPass(context) {
         console.error('[kobo] Event retention failed (continuing):', err);
     }
 }
-runRetentionPass('at boot');
+void runRetentionPass('at boot');
 // Kōbō is a daemon people leave running for weeks, and `emit` writes a row per
 // agent event. Running the pass only at boot meant a window the user enabled
 // was not applied again until the next restart.
 const RETENTION_INTERVAL_MS = 24 * 60 * 60 * 1000;
-const retentionTimer = setInterval(() => runRetentionPass('daily'), RETENTION_INTERVAL_MS);
+const retentionTimer = setInterval(() => void runRetentionPass('daily'), RETENTION_INTERVAL_MS);
 retentionTimer.unref?.();
 // Check on boot and hourly so servers running longer than a day keep backing up.
 const dailyBackupScheduler = startDailyDbBackupScheduler(async () => {
@@ -278,87 +280,7 @@ wss.on('connection', (ws) => {
 });
 // Wire terminal WebSocket connections
 terminalWss.on('connection', (ws, workspaceId) => {
-    let currentPty = getTerminal(workspaceId);
-    let dataDisposable = null;
-    let exitDisposable = null;
-    function attachListeners(ptyInstance) {
-        // Dispose previous listeners to avoid stacking on reconnect
-        dataDisposable?.dispose();
-        exitDisposable?.dispose();
-        dataDisposable = ptyInstance.onData((output) => {
-            if (ws.readyState === WebSocket.OPEN) {
-                ws.send(Buffer.from(output), { binary: true });
-            }
-        });
-        exitDisposable = ptyInstance.onExit(({ exitCode }) => {
-            if (ws.readyState === WebSocket.OPEN) {
-                ws.send(JSON.stringify({ type: 'exited', code: exitCode }));
-                ws.close();
-            }
-        });
-    }
-    ws.on('close', () => {
-        dataDisposable?.dispose();
-        exitDisposable?.dispose();
-        dataDisposable = null;
-        exitDisposable = null;
-    });
-    ws.on('error', (err) => {
-        console.error(`[terminal] WebSocket error for workspace ${workspaceId}:`, err);
-    });
-    ws.on('message', (data, isBinary) => {
-        if (isBinary) {
-            if (currentPty) {
-                currentPty.write(data.toString());
-            }
-            return;
-        }
-        let msg;
-        try {
-            msg = JSON.parse(data.toString());
-        }
-        catch {
-            return; // Invalid JSON — ignore
-        }
-        if (msg.type === 'create') {
-            if (!currentPty) {
-                const workspace = getWorkspace(workspaceId);
-                if (!workspace) {
-                    ws.send(JSON.stringify({ type: 'error', message: 'Workspace not found' }));
-                    return;
-                }
-                if (workspace.archivedAt) {
-                    ws.send(JSON.stringify({ type: 'error', message: 'Workspace is archived' }));
-                    return;
-                }
-                const cwd = workspace.worktreePath;
-                try {
-                    currentPty = createTerminal(workspaceId, cwd);
-                }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    ws.send(JSON.stringify({ type: 'error', message }));
-                    return;
-                }
-            }
-            attachListeners(currentPty);
-            ws.send(JSON.stringify({ type: 'ready' }));
-            return;
-        }
-        if (msg.type === 'resize' && msg.cols && msg.rows) {
-            if (currentPty) {
-                const cols = Math.max(1, Math.floor(msg.cols));
-                const rows = Math.max(1, Math.floor(msg.rows));
-                try {
-                    currentPty.resize(cols, rows);
-                }
-                catch (err) {
-                    console.error(`[terminal] resize failed for workspace ${workspaceId}:`, err);
-                }
-            }
-            return;
-        }
-    });
+    handleTerminalConnection(ws, workspaceId, () => isShuttingDown);
 });
 // Wire websocket-service message handler to the agent orchestrator
 setMessageHandler(async (type, payload) => {
@@ -411,6 +333,10 @@ setMessageHandler(async (type, payload) => {
 });
 // Handle WebSocket upgrade requests on /ws path
 server.on('upgrade', (request, socket, head) => {
+    if (isShuttingDown) {
+        socket.destroy();
+        return;
+    }
     const { pathname } = new URL(request.url ?? '/', `http://localhost:${PORT}`);
     const wsGlobal = getGlobalSettings();
     // WebSockets are exempt from the same-origin policy and send no preflight,
@@ -495,7 +421,7 @@ async function gracefulShutdown(signal, exitCode = 0) {
     for (const client of terminalWss.clients)
         client.close(1001, 'Server shutting down');
     try {
-        destroyAllTerminals();
+        await destroyAllTerminals();
         console.log('[kobo] Terminals killed');
     }
     catch {
@@ -547,8 +473,15 @@ async function gracefulShutdown(signal, exitCode = 0) {
     }
     finally {
         try {
-            await stopSearchIndex();
-            await dailyBackupScheduler.stop();
+            const stopped = await Promise.allSettled([
+                stopWsEventsRetention(),
+                stopSearchIndex(),
+                dailyBackupScheduler.stop(),
+            ]);
+            for (const result of stopped) {
+                if (result.status === 'rejected')
+                    console.error('[kobo] Background service shutdown failed:', result.reason);
+            }
             closeDb();
             console.log('[kobo] Database closed');
         }

package/dist/server/routes/git.js

@@ -1,18 +1,17 @@
 import { Hono } from 'hono';
 import { getDb } from '../db/index.js';
 import { listOrphanWorktrees } from '../services/worktree-service.js';
-import { listBranches, listRemoteBranches, listWorktreeFiles } from '../utils/git-ops.js';
+import { listBranchesAsync, listRemoteBranchesAsync, listWorktreeFilesAsync } from '../utils/git-ops.js';
 /** Hono sub-router for git-related endpoints (branch listing). */
 const app = new Hono();
 // GET /api/git/branches?path=<repoPath> — list branches for a repo
-app.get('/branches', (c) => {
+app.get('/branches', async (c) => {
     try {
         const repoPath = c.req.query('path');
         if (!repoPath) {
             return c.json({ error: 'Missing required query parameter: path' }, 400);
         }
-        const local = listBranches(repoPath);
-        const remote = listRemoteBranches(repoPath);
+        const [local, remote] = await Promise.all([listBranchesAsync(repoPath), listRemoteBranchesAsync(repoPath)]);
         return c.json({ local, remote });
     }
     catch (err) {
@@ -20,12 +19,12 @@ app.get('/branches', (c) => {
         return c.json({ error: message }, 500);
     }
 });
-/** Hard ceiling on the worktree listing. `listWorktreeFiles` already truncates
+/** Hard ceiling on the worktree listing. `listWorktreeFilesAsync` 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) => {
+app.get('/files', async (c) => {
     try {
         const repoPath = c.req.query('path');
         if (!repoPath) {
@@ -33,7 +32,7 @@ app.get('/files', (c) => {
         }
         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) });
+        return c.json({ files: await listWorktreeFilesAsync(repoPath, limit) });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);

package/dist/server/routes/settings.js

@@ -11,8 +11,8 @@ 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 { getSuitePrompts } from '../services/skill-suite-prompts.js';
-import { listTemplates, replaceAllTemplates } from '../services/templates-service.js';
-import { countPrunableWsEvents } from '../services/ws-events-retention-service.js';
+import { listTemplates, replaceAllTemplates, validateTemplatesForReplacement } from '../services/templates-service.js';
+import { previewWsEventsRetention } from '../services/ws-events-retention-worker-service.js';
 /** Hono sub-router for global and per-project settings CRUD. */
 const app = new Hono();
 // GET /api/settings — return full settings, credentials masked
@@ -67,17 +67,15 @@ app.get('/defaults', (c) => {
 // 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) => {
+app.get('/ws-events-retention-preview', async (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 });
+        const preview = await previewWsEventsRetention({ retentionDays: days, keepPerWorkspace: keep });
+        return c.json(preview);
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -252,11 +250,23 @@ app.get('/export', (c) => {
 app.post('/import', async (c) => {
     try {
         const body = (await c.req.json());
-        // Validate settings first — throws on malformed payload before we touch disk.
+        // Validate templates before settings import writes anything. An invalid
+        // row must not leave an otherwise rejected bundle partially applied.
+        let validatedTemplates;
+        if (body?.templates !== undefined) {
+            try {
+                validatedTemplates = validateTemplatesForReplacement(body.templates);
+            }
+            catch (error) {
+                return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+            }
+        }
+        // Settings validates its section before writing. Each file is replaced
+        // atomically; this is not a transaction spanning the two files.
         settingsService.importConfigBundle(body);
-        if (body.templates !== undefined) {
-            // Accept missing templates (backward-compatible). Otherwise validate and replace.
-            replaceAllTemplates(body.templates);
+        if (validatedTemplates !== undefined) {
+            // Accept missing templates for backward-compatible bundles.
+            replaceAllTemplates(validatedTemplates);
         }
         return c.json({ ok: true });
     }