@loicngr/kobo 1.2.0 → 1.4.0

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

@@ -0,0 +1,82 @@
+import { getPrStatusAsync } from '../utils/git-ops.js';
+import { emitEphemeral } from './websocket-service.js';
+import { archiveWorkspace, listWorkspaces } from './workspace-service.js';
+// ── PR Watcher ────────────────────────────────────────────────────────────────
+// Polls GitHub every POLL_INTERVAL_MS to detect merged/closed PRs and
+// automatically archive the corresponding workspace.
+//
+// Only archives on a STATE TRANSITION from OPEN → CLOSED/MERGED.
+// If a PR is already closed/merged when first seen (e.g. after unarchive),
+// it is recorded but NOT acted upon — prevents re-archiving manually
+// 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();
+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()) {
+        if (!workspaces.some((ws) => ws.id === id)) {
+            lastKnownState.delete(id);
+        }
+    }
+    for (const ws of workspaces) {
+        // Only check workspaces that are not actively running an agent
+        if (['extracting', 'brainstorming', 'executing'].includes(ws.status))
+            continue;
+        try {
+            const pr = await getPrStatusAsync(ws.projectPath, ws.workingBranch);
+            if (!pr)
+                continue;
+            const prev = lastKnownState.get(ws.id);
+            lastKnownState.set(ws.id, pr.state);
+            // Only archive on a transition FROM OPEN — not on first sight of CLOSED/MERGED
+            if (prev === 'OPEN' && (pr.state === 'MERGED' || pr.state === 'CLOSED')) {
+                console.log(`[pr-watcher] PR ${pr.state.toLowerCase()} for workspace '${ws.name}' — archiving`);
+                archiveWorkspace(ws.id);
+                lastKnownState.delete(ws.id);
+                emitEphemeral(ws.id, 'workspace:archived', {
+                    reason: `PR ${pr.state.toLowerCase()}`,
+                    prUrl: pr.url,
+                });
+            }
+        }
+        catch (err) {
+            console.error(`[pr-watcher] Failed to check PR for workspace '${ws.name}':`, err instanceof Error ? err.message : err);
+        }
+    }
+}
+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;
+    scheduleNext();
+}
+export function stopPrWatcher() {
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+}

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

@@ -50,13 +50,36 @@ Please:
 1. Review the PR description on GitHub and improve it if needed (add a proper summary, screenshots if relevant, a test plan)
 2. Verify that all acceptance criteria are checked
 3. Post a comment on the PR summarizing what was done and any follow-up items
+4. Do NOT add a "Generated with Claude Code" footer or any AI attribution to the PR description
 `;
-/**
- * Bump when adding/removing/renaming fields in Settings that require a migration.
- * Each bump must come with a corresponding entry in `runSettingsMigrations()`.
- * Append-only — never renumber shipped versions.
- */
-export const SETTINGS_SCHEMA_VERSION = 1;
+const settingsMigrations = [
+    {
+        version: 1,
+        name: 'add-git-conventions',
+        migrate: ({ global, projects }) => {
+            if (typeof global.gitConventions !== 'string')
+                global.gitConventions = '';
+            for (const p of projects) {
+                if (typeof p.gitConventions !== 'string')
+                    p.gitConventions = '';
+            }
+        },
+    },
+    {
+        version: 2,
+        name: 'add-dangerously-skip-permissions',
+        migrate: ({ global, projects }) => {
+            if (typeof global.dangerouslySkipPermissions !== 'boolean')
+                global.dangerouslySkipPermissions = true;
+            for (const p of projects) {
+                if (typeof p.dangerouslySkipPermissions !== 'boolean')
+                    p.dangerouslySkipPermissions = 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;
 let settingsFilePath = getSettingsPath();
 /** Override the settings file path (used by tests). */
 export function _setSettingsPath(p) {
@@ -67,6 +90,7 @@ function defaultSettings() {
         schemaVersion: SETTINGS_SCHEMA_VERSION,
         global: {
             defaultModel: 'auto',
+            dangerouslySkipPermissions: true,
             prPromptTemplate: DEFAULT_PR_PROMPT_TEMPLATE,
             gitConventions: DEFAULT_GIT_CONVENTIONS,
         },
@@ -79,6 +103,7 @@ function defaultProjectSettings(projectPath) {
         displayName: '',
         defaultSourceBranch: '',
         defaultModel: '',
+        dangerouslySkipPermissions: true,
         prPromptTemplate: '',
         gitConventions: '',
         devServer: {
@@ -92,12 +117,10 @@ function pickKnownKeys(data, allowedKeys) {
 }
 /**
  * Apply migrations sequentially to bring an older settings object up to
- * SETTINGS_SCHEMA_VERSION. Each migration is append-only — never edit or
- * reorder shipped migrations. The returned object carries the bumped
- * schemaVersion; callers should persist it back to disk.
+ * SETTINGS_SCHEMA_VERSION. Append-only — never edit or reorder shipped entries.
+ * The returned object carries the bumped schemaVersion; callers persist it.
  */
 export function runSettingsMigrations(raw) {
-    // Ensure a baseline shape so we can safely read .global and .projects
     const current = raw;
     if (!current.global || typeof current.global !== 'object') {
         current.global = {};
@@ -105,20 +128,13 @@ export function runSettingsMigrations(raw) {
     if (!Array.isArray(current.projects)) {
         current.projects = [];
     }
-    // Detect legacy (pre-versioned) settings as v0
     let version = typeof current.schemaVersion === 'number' ? current.schemaVersion : 0;
-    // ── v0 → v1: ensure gitConventions field exists on global and every project
-    if (version < 1) {
-        if (typeof current.global.gitConventions !== 'string') {
-            current.global.gitConventions = '';
-        }
-        for (const p of current.projects) {
-            if (typeof p.gitConventions !== 'string')
-                p.gitConventions = '';
+    for (const m of settingsMigrations) {
+        if (version < m.version) {
+            m.migrate({ global: current.global, projects: current.projects });
+            version = m.version;
         }
-        version = 1;
     }
-    // Future migrations go here — increment SETTINGS_SCHEMA_VERSION in lockstep.
     current.schemaVersion = version;
     return current;
 }
@@ -177,6 +193,7 @@ export function getEffectiveSettings(projectPath) {
     if (!project) {
         return {
             model: settings.global.defaultModel,
+            dangerouslySkipPermissions: settings.global.dangerouslySkipPermissions,
             prPromptTemplate: settings.global.prPromptTemplate,
             gitConventions: settings.global.gitConventions,
             sourceBranch: '',
@@ -185,6 +202,7 @@ export function getEffectiveSettings(projectPath) {
     }
     return {
         model: project.defaultModel || settings.global.defaultModel,
+        dangerouslySkipPermissions: project.dangerouslySkipPermissions ?? settings.global.dangerouslySkipPermissions,
         prPromptTemplate: project.prPromptTemplate || settings.global.prPromptTemplate,
         gitConventions: project.gitConventions || settings.global.gitConventions,
         sourceBranch: project.defaultSourceBranch,
@@ -193,7 +211,7 @@ export function getEffectiveSettings(projectPath) {
 }
 export function updateGlobalSettings(data) {
     const settings = readSettings();
-    const allowedGlobalKeys = ['defaultModel', 'prPromptTemplate', 'gitConventions'];
+    const allowedGlobalKeys = ['defaultModel', 'dangerouslySkipPermissions', 'prPromptTemplate', 'gitConventions'];
     const filtered = pickKnownKeys(data, allowedGlobalKeys);
     settings.global = { ...settings.global, ...filtered };
     writeSettings(settings);
@@ -204,6 +222,7 @@ export function upsertProject(projectPath, data) {
         'displayName',
         'defaultSourceBranch',
         'defaultModel',
+        'dangerouslySkipPermissions',
         'prPromptTemplate',
         'gitConventions',
         'devServer',

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

@@ -22,6 +22,7 @@ function mapWorkspace(row) {
         notionUrl: row.notion_url,
         notionPageId: row.notion_page_id,
         model: row.model,
+        permissionMode: (row.permission_mode ?? 'auto-accept'),
         devServerStatus: row.dev_server_status,
         archivedAt: row.archived_at,
         createdAt: row.created_at,
@@ -87,13 +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();
+    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) {
@@ -120,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 '';
@@ -136,6 +159,135 @@ export function getPrUrl(repoPath, branchName) {
         return null;
     }
 }
+export function getPrStatus(repoPath, branchName) {
+    try {
+        const raw = execFileSync('gh', ['pr', 'view', branchName, '--json', 'state,url'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        }).trim();
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        return { state: parsed.state, url: parsed.url };
+    }
+    catch {
+        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 {
+        const output = execFileSync('git', ['rev-list', '@{u}..HEAD', '--count'], {
+            cwd: repoPath,
+            encoding: 'utf-8',
+        }).trim();
+        return parseInt(output, 10) || 0;
+    }
+    catch {
+        return -1; // no upstream
+    }
+}
 export function getDiffStatsBetween(repoPath, base, head) {
     try {
         return git(repoPath, ['diff', '--shortstat', `${base}...${head}`]);
@@ -144,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.2.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"
   },