@loicngr/kobo 1.3.0 → 1.4.0

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

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { readFileSync } from 'node:fs';
+import { getPackageVersion } from '../utils/paths.js';
 // Gherkin keywords (French and English)
 const GHERKIN_PATTERN = /^(Scénario|Étant donné|Quand|Alors|Scenario|Given|When|Then|Feature|Fonctionnalité|And|Et|But|Mais)/i;
 // C2: rpcIdCounter encapsulated in a closure to avoid module-level mutable state
@@ -53,10 +54,11 @@ export async function callMcpTool(mcpProcess, toolName, args) {
             return;
         }
         let buffer = '';
-        // C1: 30s timeout
+        // C1: 30s timeout — I7: kill the MCP process on timeout to avoid zombie
         const timeout = setTimeout(() => {
             mcpProcess.stdout?.removeListener('data', onData);
             mcpProcess.stdout?.removeListener('error', onError);
+            mcpProcess.kill();
             reject(new Error(`callMcpTool('${toolName}') timed out after 30s`));
         }, 30_000);
         const onData = (chunk) => {
@@ -155,7 +157,7 @@ async function initializeMcp(mcpProcess) {
         params: {
             protocolVersion: '2024-11-05',
             capabilities: {},
-            clientInfo: { name: 'kobo', version: '0.1.0' },
+            clientInfo: { name: 'kobo', version: getPackageVersion() },
         },
     });
     await new Promise((resolve, reject) => {
@@ -164,9 +166,10 @@ async function initializeMcp(mcpProcess) {
             return;
         }
         let buffer = '';
-        // C1: 10s timeout for initialization
+        // C1: 10s timeout for initialization — I7: kill the MCP process on timeout
         const timeout = setTimeout(() => {
             mcpProcess.stdout?.removeListener('data', onData);
+            mcpProcess.kill();
             reject(new Error('initializeMcp timed out after 10s'));
         }, 10_000);
         const onData = (chunk) => {

package/dist/server/services/pr-watcher-service.js

@@ -1,4 +1,4 @@
-import { getPrStatus } from '../utils/git-ops.js';
+import { getPrStatusAsync } from '../utils/git-ops.js';
 import { emitEphemeral } from './websocket-service.js';
 import { archiveWorkspace, listWorkspaces } from './workspace-service.js';
 // ── PR Watcher ────────────────────────────────────────────────────────────────
@@ -11,9 +11,10 @@ import { archiveWorkspace, listWorkspaces } from './workspace-service.js';
 // unarchived workspaces.
 const POLL_INTERVAL_MS = 30 * 1000; // 30 seconds
 let timer = null;
+let checking = false;
 /** Tracks the last known PR state per workspace to detect transitions. */
 const lastKnownState = new Map();
-function checkPrStatuses() {
+async function checkPrStatuses() {
     const workspaces = listWorkspaces(false); // non-archived only
     // Clean up entries for workspaces that no longer exist
     for (const id of lastKnownState.keys()) {
@@ -26,7 +27,7 @@ function checkPrStatuses() {
         if (['extracting', 'brainstorming', 'executing'].includes(ws.status))
             continue;
         try {
-            const pr = getPrStatus(ws.projectPath, ws.workingBranch);
+            const pr = await getPrStatusAsync(ws.projectPath, ws.workingBranch);
             if (!pr)
                 continue;
             const prev = lastKnownState.get(ws.id);
@@ -47,15 +48,35 @@ function checkPrStatuses() {
         }
     }
 }
+function scheduleNext() {
+    timer = setTimeout(async () => {
+        if (checking) {
+            // Previous run still in progress — skip and reschedule
+            scheduleNext();
+            return;
+        }
+        checking = true;
+        try {
+            await checkPrStatuses();
+        }
+        catch (err) {
+            console.error('[pr-watcher] Unexpected error in checkPrStatuses:', err);
+        }
+        finally {
+            checking = false;
+            scheduleNext();
+        }
+    }, POLL_INTERVAL_MS);
+    timer.unref?.();
+}
 export function startPrWatcher() {
     if (timer)
         return;
-    timer = setInterval(checkPrStatuses, POLL_INTERVAL_MS);
-    timer.unref?.();
+    scheduleNext();
 }
 export function stopPrWatcher() {
     if (timer) {
-        clearInterval(timer);
+        clearTimeout(timer);
         timer = null;
     }
 }

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

@@ -3,6 +3,9 @@ import { getDb } from '../db/index.js';
 // ── State ──────────────────────────────────────────────────────────────────────
 /** Maps each WS client to the set of workspaceIds they are subscribed to */
 const clients = new Map();
+/** I6: Per-workspace emit counter for periodic cleanup */
+const emitCounters = new Map();
+const EMIT_CLEANUP_THRESHOLD = 2000;
 let messageHandler = null;
 export function setMessageHandler(handler) {
     messageHandler = handler;
@@ -67,10 +70,21 @@ export function handleConnection(ws) {
                 ws.send(JSON.stringify({ type: 'error', payload: { message: `Unknown message type: ${type}` } }));
         }
     });
+    // Ping every 30s to keep the connection alive and detect stale clients
+    const pingInterval = setInterval(() => {
+        if (ws.readyState === ws.OPEN) {
+            ws.ping();
+        }
+        else {
+            clearInterval(pingInterval);
+        }
+    }, 30_000);
     ws.on('close', () => {
+        clearInterval(pingInterval);
         clients.delete(ws);
     });
     ws.on('error', () => {
+        clearInterval(pingInterval);
         clients.delete(ws);
     });
 }
@@ -87,6 +101,15 @@ export function emit(workspaceId, type, payload, sessionId) {
     try {
         const db = getDb();
         db.prepare('INSERT INTO ws_events (id, workspace_id, type, payload, session_id, created_at) VALUES (?, ?, ?, ?, ?, ?)').run(id, workspaceId, type, JSON.stringify(payload), sessionId ?? null, createdAt);
+        // I6: Periodic cleanup — increment counter and trigger cleanup when threshold is reached
+        const count = (emitCounters.get(workspaceId) ?? 0) + 1;
+        if (count >= EMIT_CLEANUP_THRESHOLD) {
+            cleanupOldEvents(workspaceId);
+            emitCounters.set(workspaceId, 0);
+        }
+        else {
+            emitCounters.set(workspaceId, count);
+        }
     }
     catch (err) {
         console.error(`[websocket-service] Failed to persist event (workspace=${workspaceId}, type=${type}):`, err);
@@ -148,16 +171,16 @@ export function handleSyncRequest(ws, lastEventId, workspaceIds) {
                 .all(...resolvedIds, lastRow.rowid);
         }
         else {
-            // lastEventId not found — send all events for subscribed workspaces
+            // I7: lastEventId not found — send events capped to avoid unbounded memory usage
             rows = db
-                .prepare(`SELECT * FROM ws_events WHERE workspace_id IN (${placeholders}) ORDER BY rowid ASC`)
+                .prepare(`SELECT * FROM ws_events WHERE workspace_id IN (${placeholders}) ORDER BY rowid ASC LIMIT 10000`)
                 .all(...resolvedIds);
         }
     }
     else {
-        // No lastEventId — send all events
+        // No lastEventId — send all events (capped to avoid unbounded memory usage)
         rows = db
-            .prepare(`SELECT * FROM ws_events WHERE workspace_id IN (${placeholders}) ORDER BY rowid ASC`)
+            .prepare(`SELECT * FROM ws_events WHERE workspace_id IN (${placeholders}) ORDER BY rowid ASC LIMIT 10000`)
             .all(...resolvedIds);
     }
     const events = rows.map((row) => {
@@ -178,6 +201,13 @@ export function handleSyncRequest(ws, lastEventId, workspaceIds) {
         };
     });
     ws.send(JSON.stringify({ type: 'sync:response', payload: { events } }));
+    // Trigger cleanup when the event count is high to prevent unbounded growth
+    const CLEANUP_THRESHOLD = 5000;
+    if (rows.length >= CLEANUP_THRESHOLD) {
+        for (const wid of resolvedIds) {
+            cleanupOldEvents(wid);
+        }
+    }
 }
 // ── Cleanup ────────────────────────────────────────────────────────────────────
 /**
@@ -210,3 +240,10 @@ export function getClientCount() {
 export function _getClients() {
     return clients;
 }
+/**
+ * Get the internal emit counters map — exposed for testing only.
+ * @internal
+ */
+export function _getEmitCounters() {
+    return emitCounters;
+}

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

@@ -88,19 +88,30 @@ export function updateWorkspaceStatus(id, status) {
 export function updateWorkspaceName(id, name) {
     const db = getDb();
     const now = new Date().toISOString();
-    db.prepare('UPDATE workspaces SET name = ?, updated_at = ? WHERE id = ?').run(name, now, id);
+    const result = db.prepare('UPDATE workspaces SET name = ?, updated_at = ? WHERE id = ?').run(name, now, id);
+    if (result.changes === 0) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
     return getWorkspace(id);
 }
 export function updateWorkspaceModel(id, model) {
     const db = getDb();
     const now = new Date().toISOString();
-    db.prepare('UPDATE workspaces SET model = ?, updated_at = ? WHERE id = ?').run(model, now, id);
+    const result = db.prepare('UPDATE workspaces SET model = ?, updated_at = ? WHERE id = ?').run(model, now, id);
+    if (result.changes === 0) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
     return getWorkspace(id);
 }
 export function updateWorkspacePermissionMode(id, permissionMode) {
     const db = getDb();
     const now = new Date().toISOString();
-    db.prepare('UPDATE workspaces SET permission_mode = ?, updated_at = ? WHERE id = ?').run(permissionMode, now, id);
+    const result = db
+        .prepare('UPDATE workspaces SET permission_mode = ?, updated_at = ? WHERE id = ?')
+        .run(permissionMode, now, id);
+    if (result.changes === 0) {
+        throw new Error(`Workspace '${id}' not found`);
+    }
     return getWorkspace(id);
 }
 export function updateDevServerStatus(id, status) {
@@ -127,6 +138,11 @@ export function createTask(workspaceId, data) {
     const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
     return mapTask(row);
 }
+export function getTask(taskId, workspaceId) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM tasks WHERE id = ? AND workspace_id = ?').get(taskId, workspaceId);
+    return row ? mapTask(row) : null;
+}
 export function listTasks(workspaceId) {
     const db = getDb();
     const rows = db

package/dist/server/utils/git-ops.js

@@ -1,4 +1,8 @@
-import { execFileSync } from 'node:child_process';
+import { execFile as execFileCb, execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFileCb);
 function git(repoPath, args) {
     return execFileSync('git', args, { cwd: repoPath, encoding: 'utf-8' }).trim();
 }
@@ -99,9 +103,26 @@ export function pushBranch(repoPath, branchName, remote = 'origin') {
         throw new Error(`Failed to push branch '${branchName}' to '${remote}': ${message}`);
     }
 }
+/** Try a git command with `base`, falling back to `origin/base` if the local ref is missing. */
+function resolveBase(repoPath, base) {
+    try {
+        git(repoPath, ['rev-parse', '--verify', base]);
+        return base;
+    }
+    catch {
+        try {
+            git(repoPath, ['rev-parse', '--verify', `origin/${base}`]);
+            return `origin/${base}`;
+        }
+        catch {
+            return base;
+        }
+    }
+}
 export function getCommitCount(repoPath, base, head) {
     try {
-        const output = git(repoPath, ['rev-list', '--count', `${base}..${head}`]);
+        const ref = resolveBase(repoPath, base);
+        const output = git(repoPath, ['rev-list', '--count', `${ref}..${head}`]);
         return parseInt(output, 10) || 0;
     }
     catch {
@@ -110,7 +131,8 @@ export function getCommitCount(repoPath, base, head) {
 }
 export function getStructuredDiffStatsBetween(repoPath, base, head) {
     try {
-        const output = git(repoPath, ['diff', '--shortstat', `${base}...${head}`]);
+        const ref = resolveBase(repoPath, base);
+        const output = git(repoPath, ['diff', '--shortstat', `${ref}...${head}`]);
         return parseDiffShortstat(output);
     }
     catch {
@@ -119,7 +141,8 @@ export function getStructuredDiffStatsBetween(repoPath, base, head) {
 }
 export function getCommitsBetween(repoPath, base, head) {
     try {
-        return git(repoPath, ['log', `${base}..${head}`, '--pretty=format:- %s (%h)', '--no-merges']);
+        const ref = resolveBase(repoPath, base);
+        return git(repoPath, ['log', `${ref}..${head}`, '--pretty=format:- %s (%h)', '--no-merges']);
     }
     catch {
         return '';
@@ -151,6 +174,107 @@ export function getPrStatus(repoPath, branchName) {
         return null;
     }
 }
+/** List files changed between base and HEAD (committed), plus working tree changes. */
+export function getChangedFiles(repoPath, base) {
+    const ref = resolveBase(repoPath, base);
+    const files = [];
+    const seen = new Set();
+    // Committed changes (base..HEAD)
+    try {
+        const output = git(repoPath, ['diff', '--name-status', `${ref}...HEAD`]);
+        for (const line of output.split('\n')) {
+            if (!line)
+                continue;
+            const [statusCode, ...pathParts] = line.split('\t');
+            const filePath = pathParts.join('\t').replace(/\/$/, '');
+            if (!filePath)
+                continue;
+            let status = 'modified';
+            if (statusCode?.startsWith('A'))
+                status = 'added';
+            else if (statusCode?.startsWith('D'))
+                status = 'deleted';
+            else if (statusCode?.startsWith('R'))
+                status = 'renamed';
+            files.push({ path: filePath, status });
+            seen.add(filePath);
+        }
+    }
+    catch {
+        // No commits yet
+    }
+    // Working tree changes (uncommitted)
+    try {
+        const output = git(repoPath, ['status', '--porcelain', '-uall']);
+        for (const line of output.split('\n')) {
+            if (!line)
+                continue;
+            const filePath = line.substring(3).replace(/\/$/, '');
+            if (!filePath || seen.has(filePath))
+                continue;
+            const x = line[0];
+            const y = line[1];
+            let status = 'modified';
+            if (x === '?' && y === '?')
+                status = 'added';
+            else if (x === 'A' || y === 'A')
+                status = 'added';
+            else if (x === 'D' || y === 'D')
+                status = 'deleted';
+            files.push({ path: filePath, status });
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return files;
+}
+/** Get the original content of a file at a given ref. Returns null if the file didn't exist. */
+export function getFileAtRef(repoPath, ref, filePath) {
+    const resolvedRef = resolveBase(repoPath, ref);
+    try {
+        return git(repoPath, ['show', `${resolvedRef}:${filePath}`]);
+    }
+    catch {
+        return null;
+    }
+}
+/** Get the current content of a file in the worktree. Returns null if the file doesn't exist. */
+export function getFileContent(repoPath, filePath) {
+    try {
+        return readFileSync(join(repoPath, filePath), 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export function getWorkingTreeStatus(repoPath) {
+    try {
+        const output = git(repoPath, ['status', '--porcelain']);
+        let staged = 0;
+        let modified = 0;
+        let untracked = 0;
+        for (const line of output.split('\n')) {
+            if (!line)
+                continue;
+            const x = line[0]; // index status
+            const y = line[1]; // worktree status
+            if (x === '?' && y === '?') {
+                untracked++;
+            }
+            else {
+                if (x !== ' ' && x !== '?')
+                    staged++;
+                if (y !== ' ' && y !== '?')
+                    modified++;
+            }
+        }
+        return { staged, modified, untracked };
+    }
+    catch {
+        return { staged: 0, modified: 0, untracked: 0 };
+    }
+}
 /** Count commits ahead of upstream. Returns -1 if no upstream is set. */
 export function getUnpushedCount(repoPath) {
     try {
@@ -172,3 +296,47 @@ export function getDiffStatsBetween(repoPath, base, head) {
         return '';
     }
 }
+// ── Async versions ───────────────────────────────────────────────────────────
+// Non-blocking alternatives for hot paths (pr-watcher, route handlers).
+// The sync versions above are kept for callers that haven't migrated yet.
+export async function getPrUrlAsync(repoPath, branchName) {
+    try {
+        const { stdout } = await execFileAsync('gh', ['pr', 'view', branchName, '--json', 'url', '--jq', '.url'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getPrStatusAsync(repoPath, branchName) {
+    try {
+        const { stdout } = await execFileAsync('gh', ['pr', 'view', branchName, '--json', 'state,url'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+        const raw = stdout.trim();
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        return { state: parsed.state, url: parsed.url };
+    }
+    catch {
+        return null;
+    }
+}
+/** Async version of getUnpushedCount. Returns -1 if no upstream is set. */
+export async function getUnpushedCountAsync(repoPath) {
+    try {
+        const { stdout } = await execFileAsync('git', ['rev-list', '@{u}..HEAD', '--count'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        });
+        return parseInt(stdout.trim(), 10) || 0;
+    }
+    catch {
+        return -1; // no upstream
+    }
+}

package/dist/server/utils/paths.js

@@ -85,6 +85,19 @@ export function getCompiledMcpServerPath() {
 export function getMcpServerSourcePath() {
     return getPackageAssetPath('src', 'mcp-server', 'kobo-tasks-server.ts');
 }
+/**
+ * Returns the version string from the root package.json. The result is cached
+ * after the first call so the file is only read once per process lifetime.
+ */
+let _cachedVersion = null;
+export function getPackageVersion() {
+    if (_cachedVersion)
+        return _cachedVersion;
+    const pkgPath = getPackageAssetPath('package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    _cachedVersion = pkg.version;
+    return _cachedVersion;
+}
 /**
  * Absolute path to the built Quasar SPA (src/client/dist/spa). Returns null
  * if the SPA has not been built yet.

package/dist/server/utils/process-tracker.js

@@ -39,8 +39,4 @@ export function killAll() {
 }
 export function initProcessCleanup() {
     process.on('exit', killAll);
-    process.on('SIGINT', () => {
-        killAll();
-        process.exit(0);
-    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.3.0",
+  "version": "1.4.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",
@@ -53,6 +53,7 @@
     "build:client": "cd src/client && npx quasar build",
     "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",
     "start": "node dist/server/index.js",
     "test": "vitest run --config vitest.config.ts --root .",
     "test:watch": "vitest --config vitest.config.ts --root .",
@@ -65,10 +66,10 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@hono/node-server": "^1.19.12",
+    "@hono/node-server": "^1.19.13",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.8.0",
-    "hono": "^4.12.10",
+    "hono": "^4.12.12",
     "nanoid": "^5.1.7",
     "ws": "^8.20.0"
   },