@loicngr/kobo 1.7.13 → 1.7.15

package/dist/server/services/cleanup-script-service.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import { getDb } from '../db/index.js';
+import { worktreeHasChanges } from '../utils/git-ops.js';
+import { slugifyProjectName } from '../utils/project-slug.js';
+import { runScript, SCRIPT_TIMEOUT_MS } from '../utils/script-runner.js';
+import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
+import { getEffectiveSettings, getGlobalSettings, getProjectSettings, } from './settings-service.js';
+function getRow(workspaceId) {
+    const db = getDb();
+    const row = db
+        .prepare(`SELECT id, name, project_path, working_branch, source_branch, worktree_path, archived_at
+       FROM workspaces WHERE id = ?`)
+        .get(workspaceId);
+    return row ?? null;
+}
+function countPendingTasks(workspaceId) {
+    const db = getDb();
+    const row = db
+        .prepare("SELECT COUNT(*) AS c FROM tasks WHERE workspace_id = ? AND status != 'done'")
+        .get(workspaceId);
+    return row.c;
+}
+/**
+ * Pure decision: should the cleanup script run? Encodes the full matrix so it
+ * is unit-testable without a DB.
+ *
+ * - No script → never.
+ * - Auto-loop completion → always (every task is done by definition).
+ * - Otherwise the agent must have finished cleanly (`completed`).
+ * - A mid-loop `session:ended` (`wasAutoLoop`) never triggers — only the loop's
+ *   completion does.
+ * - `no-tasks` mode additionally requires zero pending tasks; `idle` does not.
+ */
+export function shouldRunCleanup(input) {
+    if (!input.script.trim())
+        return false;
+    if (input.autoLoopCompleted)
+        return true;
+    if (input.reason !== 'completed')
+        return false;
+    if (input.wasAutoLoop)
+        return false;
+    if (input.mode === 'no-tasks' && input.pendingTasks > 0)
+        return false;
+    return true;
+}
+/** Execute the cleanup script in a worktree, streaming `cleanup:*` WS events. */
+export function runCleanupScript(workspaceId, worktreePath, script, env) {
+    return runScript({
+        workspaceId,
+        worktreePath,
+        script,
+        eventPrefix: 'cleanup',
+        tmpFileName: '.cleanup-script.tmp',
+        env,
+        timeoutMs: SCRIPT_TIMEOUT_MS,
+    });
+}
+function trigger(workspaceId, decision) {
+    try {
+        const row = getRow(workspaceId);
+        if (!row || row.archived_at)
+            return;
+        const effective = getEffectiveSettings(row.project_path);
+        if (!shouldRunCleanup({
+            reason: decision.reason,
+            wasAutoLoop: decision.wasAutoLoop,
+            autoLoopCompleted: decision.autoLoopCompleted,
+            script: effective.cleanupScript,
+            mode: effective.cleanupScriptMode,
+            pendingTasks: countPendingTasks(workspaceId),
+        })) {
+            return;
+        }
+        const global = getGlobalSettings();
+        const projectSettings = getProjectSettings(row.project_path);
+        const projectSlug = global.worktreesPrefixByProject
+            ? slugifyProjectName(projectSettings?.displayName ?? '', row.project_path)
+            : undefined;
+        const worktreePath = row.worktree_path ??
+            resolveWorkspaceWorktreePath(row.project_path, row.working_branch, global.worktreesPath, projectSlug);
+        if (!fs.existsSync(worktreePath)) {
+            console.warn(`[cleanup-script-service] worktree missing, skipping cleanup: ${worktreePath}`);
+            return;
+        }
+        // Optional gate: only run when the worktree has uncommitted changes.
+        if (effective.cleanupScriptOnlyOnChanges && !worktreeHasChanges(worktreePath)) {
+            return;
+        }
+        // Best-effort: never let a cleanup failure break the calling flow.
+        void runCleanupScript(workspaceId, worktreePath, effective.cleanupScript, {
+            workspaceName: row.name,
+            branchName: row.working_branch,
+            sourceBranch: row.source_branch,
+            projectPath: row.project_path,
+        }).catch((err) => {
+            console.error('[cleanup-script-service] runCleanupScript failed:', err);
+        });
+    }
+    catch (err) {
+        console.error('[cleanup-script-service] trigger failed:', err);
+    }
+}
+/**
+ * Hook for orchestrator's `session:ended` handler. `wasAutoLoop` MUST be
+ * captured before `auto-loop-service.onSessionEnded` runs, since `disable()`
+ * clears the `auto_loop` flag.
+ */
+export function onSessionEnded(workspaceId, reason, opts) {
+    trigger(workspaceId, { reason, wasAutoLoop: opts.wasAutoLoop, autoLoopCompleted: false });
+}
+/**
+ * Hook for `auto-loop-service.disable()` with `reason='completed'` — the loop
+ * finished every task. Runs the cleanup regardless of trigger mode.
+ */
+export function onAutoLoopCompleted(workspaceId) {
+    trigger(workspaceId, { reason: 'completed', wasAutoLoop: false, autoLoopCompleted: true });
+}

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

@@ -34,6 +34,10 @@ export const DEFAULT_GIT_CONVENTIONS = `# Git conventions
 - Never skip hooks (--no-verify) unless the user explicitly asks
 - Always inspect \`git status\` and \`git diff\` before staging
 `;
+const CLEANUP_SCRIPT_MODES = ['idle', 'no-tasks'];
+export function isValidCleanupScriptMode(value) {
+    return typeof value === 'string' && CLEANUP_SCRIPT_MODES.includes(value);
+}
 export const DEFAULT_PR_PROMPT_TEMPLATE = `A pull request has been opened: {{pr_url}} (#{{pr_number}})
 
 Context:
@@ -80,6 +84,39 @@ export const DEFAULT_WORKSPACE_TAGS = [
     'notion',
     'sentry',
 ];
+/**
+ * Default git branch prefixes seeded on fresh install and on settings upgrade.
+ * Stored without the trailing `/` — it's a separator added at display time and
+ * when composing the working branch (`<prefix>/<slug>`). The first entry is the
+ * one pre-selected on the workspace creation page.
+ */
+export const DEFAULT_BRANCH_PREFIXES = ['feature', 'fix', 'hotfix', 'chore', 'refactor', 'docs', 'test'];
+/**
+ * Sanitize a raw branch-prefix list: trim, strip surrounding slashes, drop
+ * entries that aren't valid git branch segments, dedupe, cap length. Returns
+ * an empty array when nothing survives — callers decide the fallback.
+ */
+export function sanitizeBranchPrefixes(input) {
+    if (!Array.isArray(input))
+        return [];
+    const seen = new Set();
+    const result = [];
+    for (const raw of input) {
+        if (typeof raw !== 'string')
+            continue;
+        const value = raw.trim().replace(/^\/+|\/+$/g, '');
+        if (value.length === 0 || value.length > 50)
+            continue;
+        // Allow only characters safe in a git branch name; reject `..` runs.
+        if (!/^[A-Za-z0-9._/-]+$/.test(value) || value.includes('..'))
+            continue;
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
 const settingsMigrations = [
     {
         version: 1,
@@ -427,6 +464,72 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 26,
+        name: 'add-branch-prefixes',
+        migrate: ({ global }) => {
+            if (!Array.isArray(global.branchPrefixes)) {
+                global.branchPrefixes = [...DEFAULT_BRANCH_PREFIXES];
+            }
+        },
+    },
+    {
+        version: 27,
+        name: 'add-project-task-prompt',
+        migrate: ({ projects }) => {
+            for (const p of projects) {
+                if (typeof p.taskPromptTemplate !== 'string')
+                    p.taskPromptTemplate = '';
+            }
+        },
+    },
+    {
+        version: 28,
+        name: 'add-cleanup-script',
+        migrate: ({ global, projects }) => {
+            if (typeof global.cleanupScript !== 'string')
+                global.cleanupScript = '';
+            if (!isValidCleanupScriptMode(global.cleanupScriptMode))
+                global.cleanupScriptMode = 'no-tasks';
+            for (const p of projects) {
+                if (typeof p.cleanupScript !== 'string')
+                    p.cleanupScript = '';
+                // '' = inherit; any other value must be a valid mode.
+                if (p.cleanupScriptMode !== '' && !isValidCleanupScriptMode(p.cleanupScriptMode)) {
+                    p.cleanupScriptMode = '';
+                }
+            }
+        },
+    },
+    {
+        version: 29,
+        name: 'add-archive-script',
+        migrate: ({ global, projects }) => {
+            if (typeof global.archiveScript !== 'string')
+                global.archiveScript = '';
+            for (const p of projects) {
+                if (typeof p.archiveScript !== 'string')
+                    p.archiveScript = '';
+            }
+        },
+    },
+    {
+        version: 30,
+        name: 'add-global-setup-script',
+        migrate: ({ global }) => {
+            if (typeof global.setupScript !== 'string')
+                global.setupScript = '';
+        },
+    },
+    {
+        version: 31,
+        name: 'add-cleanup-script-only-on-changes',
+        migrate: ({ global }) => {
+            if (typeof global.cleanupScriptOnlyOnChanges !== 'boolean') {
+                global.cleanupScriptOnlyOnChanges = false;
+            }
+        },
+    },
 ];
 /** Current settings schema version — always equals the highest migration version. */
 export const SETTINGS_SCHEMA_VERSION = settingsMigrations.length > 0 ? settingsMigrations[settingsMigrations.length - 1].version : 0;
@@ -461,6 +564,11 @@ function defaultSettings() {
             notionInitialPromptTemplate: DEFAULT_NOTION_INITIAL_PROMPT,
             sentryInitialPromptTemplate: DEFAULT_SENTRY_INITIAL_PROMPT,
             gitConventions: DEFAULT_GIT_CONVENTIONS,
+            setupScript: '',
+            cleanupScript: '',
+            cleanupScriptMode: 'no-tasks',
+            cleanupScriptOnlyOnChanges: false,
+            archiveScript: '',
             editorCommand: '',
             browserNotifications: true,
             audioNotifications: true,
@@ -474,6 +582,7 @@ function defaultSettings() {
             notionMcpKey: '',
             sentryMcpKey: '',
             tags: [...DEFAULT_WORKSPACE_TAGS],
+            branchPrefixes: [...DEFAULT_BRANCH_PREFIXES],
             worktreesPath: WORKTREES_PATH,
             worktreesPrefixByProject: false,
             voiceEnabled: false,
@@ -510,6 +619,10 @@ function defaultProjectSettings(projectPath) {
         sentryInitialPromptTemplate: '',
         gitConventions: '',
         setupScript: '',
+        taskPromptTemplate: '',
+        cleanupScript: '',
+        cleanupScriptMode: '',
+        archiveScript: '',
         devServer: {
             startCommand: '',
             stopCommand: '',
@@ -586,6 +699,35 @@ function readSettings() {
     }
     return migrated;
 }
+/** Number of `settings.json.backup-*` files kept; older ones are rotated out. */
+const SETTINGS_BACKUP_KEEP = 5;
+/**
+ * Keep only the `SETTINGS_BACKUP_KEEP` most recent `settings.json.backup-*`
+ * files in `dir`, deleting the rest. Best-effort — never throws.
+ */
+function pruneSettingsBackups(dir) {
+    try {
+        const backups = fs
+            .readdirSync(dir)
+            .filter((f) => f.startsWith('settings.json.backup-'))
+            .map((f) => {
+            const full = path.join(dir, f);
+            return { path: full, mtimeMs: fs.statSync(full).mtimeMs };
+        })
+            .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        for (const entry of backups.slice(SETTINGS_BACKUP_KEEP)) {
+            try {
+                fs.unlinkSync(entry.path);
+            }
+            catch (err) {
+                console.error(`[settings] Failed to prune backup ${entry.path}:`, err);
+            }
+        }
+    }
+    catch (err) {
+        console.error('[settings] Failed to prune settings backups:', err);
+    }
+}
 function createSettingsBackupIfPresent() {
     if (!fs.existsSync(settingsFilePath))
         return;
@@ -594,6 +736,7 @@ function createSettingsBackupIfPresent() {
     settingsBackupSequence += 1;
     const backupPath = path.join(dir, `settings.json.backup-${stamp}-${settingsBackupSequence}`);
     fs.copyFileSync(settingsFilePath, backupPath);
+    pruneSettingsBackups(dir);
 }
 function writeSettings(settings, options) {
     ensureSettingsPathInitialized();
@@ -689,7 +832,11 @@ export function getEffectiveSettings(projectPath) {
             gitConventions: settings.global.gitConventions,
             sourceBranch: '',
             devServer: null,
-            setupScript: '',
+            setupScript: settings.global.setupScript,
+            cleanupScript: settings.global.cleanupScript,
+            cleanupScriptMode: settings.global.cleanupScriptMode,
+            cleanupScriptOnlyOnChanges: settings.global.cleanupScriptOnlyOnChanges,
+            archiveScript: settings.global.archiveScript,
             notionStatusProperty: settings.global.notionStatusProperty,
             notionInProgressStatus: settings.global.notionInProgressStatus,
         };
@@ -710,7 +857,11 @@ export function getEffectiveSettings(projectPath) {
         gitConventions: project.gitConventions || settings.global.gitConventions,
         sourceBranch: project.defaultSourceBranch,
         devServer: project.devServer,
-        setupScript: project.setupScript || '',
+        setupScript: project.setupScript || settings.global.setupScript,
+        cleanupScript: project.cleanupScript || settings.global.cleanupScript,
+        cleanupScriptMode: (project.cleanupScriptMode || settings.global.cleanupScriptMode),
+        cleanupScriptOnlyOnChanges: settings.global.cleanupScriptOnlyOnChanges,
+        archiveScript: project.archiveScript || settings.global.archiveScript,
         notionStatusProperty: settings.global.notionStatusProperty,
         notionInProgressStatus: settings.global.notionInProgressStatus,
     };
@@ -726,6 +877,13 @@ export function updateGlobalSettings(data) {
             delete data.skillSuite;
         }
     }
+    // Validate cleanupScriptMode: drop invalid values so the previous one stays.
+    if ('cleanupScriptMode' in data) {
+        if (!isValidCleanupScriptMode(data.cleanupScriptMode)) {
+            console.warn(`[settings] Invalid cleanupScriptMode rejected: ${data.cleanupScriptMode}`);
+            delete data.cleanupScriptMode;
+        }
+    }
     const allowedGlobalKeys = [
         'defaultModelByEngine',
         'dangerouslySkipPermissions',
@@ -734,6 +892,11 @@ export function updateGlobalSettings(data) {
         'notionInitialPromptTemplate',
         'sentryInitialPromptTemplate',
         'gitConventions',
+        'setupScript',
+        'cleanupScript',
+        'cleanupScriptMode',
+        'cleanupScriptOnlyOnChanges',
+        'archiveScript',
         'editorCommand',
         'browserNotifications',
         'audioNotifications',
@@ -747,6 +910,7 @@ export function updateGlobalSettings(data) {
         'notionMcpKey',
         'sentryMcpKey',
         'tags',
+        'branchPrefixes',
         'worktreesPath',
         'worktreesPrefixByProject',
         'voiceEnabled',
@@ -775,6 +939,12 @@ export function updateGlobalSettings(data) {
                 .filter((t) => t.length > 0 && t.length <= 50)))
             : settings.global.tags;
     }
+    if (filtered.branchPrefixes !== undefined) {
+        // Drop invalid entries; never let the list collapse to empty (the creation
+        // page needs at least one prefix) — fall back to the previous value.
+        const sanitized = sanitizeBranchPrefixes(filtered.branchPrefixes);
+        filtered.branchPrefixes = sanitized.length > 0 ? sanitized : settings.global.branchPrefixes;
+    }
     if (filtered.audioNotificationVolume !== undefined) {
         const v = Number(filtered.audioNotificationVolume);
         filtered.audioNotificationVolume = Number.isFinite(v) ? Math.max(0, Math.min(1, v)) : 1;
@@ -816,6 +986,14 @@ export function upsertProject(projectPath, data) {
             delete data.color;
         }
     }
+    // Validate cleanupScriptMode: '' means inherit; any other value must be a
+    // valid mode. Drop anything else so the stored value is preserved.
+    if ('cleanupScriptMode' in data) {
+        if (data.cleanupScriptMode !== '' && !isValidCleanupScriptMode(data.cleanupScriptMode)) {
+            console.warn(`[settings] Invalid cleanupScriptMode rejected for project '${projectPath}': ${data.cleanupScriptMode}`);
+            delete data.cleanupScriptMode;
+        }
+    }
     const allowedProjectKeys = [
         'displayName',
         'defaultSourceBranch',
@@ -827,6 +1005,10 @@ export function upsertProject(projectPath, data) {
         'sentryInitialPromptTemplate',
         'gitConventions',
         'setupScript',
+        'taskPromptTemplate',
+        'cleanupScript',
+        'cleanupScriptMode',
+        'archiveScript',
         'devServer',
         'e2e',
         'finalization',

package/dist/server/services/setup-script-service.js

@@ -1,85 +1,14 @@
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-import * as wsService from './websocket-service.js';
-const SETUP_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+import { runScript, SCRIPT_TIMEOUT_MS } from '../utils/script-runner.js';
+const SETUP_TIMEOUT_MS = SCRIPT_TIMEOUT_MS; // 5 minutes
 /** Execute a setup script in a worktree, streaming output via WebSocket. Resolves with the exit code. */
 export function runSetupScript(workspaceId, worktreePath, script, env, timeoutMs = SETUP_TIMEOUT_MS) {
-    return new Promise((resolve) => {
-        const scriptPath = path.join(worktreePath, '.ai', '.setup-script.tmp');
-        fs.mkdirSync(path.dirname(scriptPath), { recursive: true });
-        fs.writeFileSync(scriptPath, script, { mode: 0o755 });
-        const proc = spawn('bash', [scriptPath], {
-            cwd: worktreePath,
-            env: {
-                ...process.env,
-                WORKSPACE_ID: workspaceId,
-                WORKSPACE_NAME: env?.workspaceName ?? '',
-                BRANCH_NAME: env?.branchName ?? '',
-                SOURCE_BRANCH: env?.sourceBranch ?? '',
-                PROJECT_PATH: env?.projectPath ?? '',
-            },
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        const timeout = setTimeout(() => {
-            proc.kill('SIGKILL');
-            // Destroy pipes so the 'close' event fires immediately even if
-            // child processes (e.g. sleep) inherited the file descriptors.
-            proc.stdout?.destroy();
-            proc.stderr?.destroy();
-            wsService.emit(workspaceId, 'setup:output', {
-                text: '[kobo] Setup script timed out after 5 minutes',
-            });
-        }, timeoutMs);
-        const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[a-zA-Z]`, 'g');
-        const stripAnsi = (s) => s.replace(ansiPattern, '');
-        const emitLine = (text) => {
-            const trimmed = stripAnsi(text).trim();
-            if (trimmed) {
-                wsService.emit(workspaceId, 'setup:output', { text: trimmed });
-            }
-        };
-        proc.stdout.on('data', (data) => {
-            for (const line of data.toString().split('\n')) {
-                emitLine(line);
-            }
-        });
-        proc.stderr.on('data', (data) => {
-            for (const line of data.toString().split('\n')) {
-                emitLine(line);
-            }
-        });
-        let settled = false;
-        const finish = (exitCode) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeout);
-            try {
-                fs.unlinkSync(scriptPath);
-            }
-            catch {
-                /* best-effort */
-            }
-            if (exitCode === 0) {
-                wsService.emitEphemeral(workspaceId, 'setup:complete', {});
-            }
-            else {
-                wsService.emitEphemeral(workspaceId, 'setup:error', {
-                    exitCode,
-                    message: `Setup script exited with code ${exitCode}`,
-                });
-            }
-            resolve({ exitCode });
-        };
-        proc.on('error', (err) => {
-            wsService.emit(workspaceId, 'setup:output', {
-                text: `[kobo] Setup script failed to start: ${err.message}`,
-            });
-            finish(1);
-        });
-        proc.on('close', (code) => {
-            finish(code ?? 1);
-        });
+    return runScript({
+        workspaceId,
+        worktreePath,
+        script,
+        eventPrefix: 'setup',
+        tmpFileName: '.setup-script.tmp',
+        env,
+        timeoutMs,
     });
 }

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

@@ -538,6 +538,36 @@ export function moveWorktree(projectPath, oldPath, newPath) {
     git(projectPath, ['worktree', 'move', oldPath, newPath]);
 }
 /** List files changed between base and HEAD (committed), plus working tree changes. */
+/**
+ * List the worktree's files — tracked plus untracked-but-not-git-ignored.
+ * Excludes `.git`, `node_modules`, and anything covered by `.gitignore`.
+ * Capped at `limit` entries to stay responsive on large monorepos.
+ * Returns [] on error (e.g. not a git repo).
+ */
+export function listWorktreeFiles(worktreePath, limit = 5000) {
+    try {
+        const out = git(worktreePath, ['ls-files', '--cached', '--others', '--exclude-standard']);
+        if (!out)
+            return [];
+        const files = out.split('\n').filter((line) => line.length > 0);
+        return files.length > limit ? files.slice(0, limit) : files;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * True when the worktree has any uncommitted change — modified, added, deleted
+ * or untracked files. Returns false on error (e.g. not a git repo).
+ */
+export function worktreeHasChanges(worktreePath) {
+    try {
+        return git(worktreePath, ['status', '--porcelain']).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
 export function getChangedFiles(repoPath, base, includeUntracked = false) {
     const ref = resolveBase(repoPath, base);
     const files = [];

package/dist/server/utils/paths.js

@@ -132,6 +132,10 @@ export function getPackageVersion() {
     _cachedVersion = pkg.version;
     return _cachedVersion;
 }
+/** Absolute path to the root CHANGELOG.md (read by the "What's new" dialog). */
+export function getChangelogPath() {
+    return getPackageAssetPath('CHANGELOG.md');
+}
 /**
  * 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/script-runner.js

@@ -0,0 +1,96 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as wsService from '../services/websocket-service.js';
+/** Default wall-clock budget for a user script before it is force-killed. */
+export const SCRIPT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Execute a user-provided bash script inside a worktree, streaming stdout/stderr
+ * line-by-line over WebSocket. Resolves with the exit code — never rejects.
+ * Shared mechanism behind the setup and cleanup script services.
+ */
+export function runScript(opts) {
+    const { workspaceId, worktreePath, script, eventPrefix, tmpFileName, env } = opts;
+    const timeoutMs = opts.timeoutMs ?? SCRIPT_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        const scriptPath = path.join(worktreePath, '.ai', tmpFileName);
+        fs.mkdirSync(path.dirname(scriptPath), { recursive: true });
+        fs.writeFileSync(scriptPath, script, { mode: 0o755 });
+        const proc = spawn('bash', [scriptPath], {
+            cwd: worktreePath,
+            env: {
+                ...process.env,
+                WORKSPACE_ID: workspaceId,
+                WORKSPACE_NAME: env?.workspaceName ?? '',
+                BRANCH_NAME: env?.branchName ?? '',
+                SOURCE_BRANCH: env?.sourceBranch ?? '',
+                PROJECT_PATH: env?.projectPath ?? '',
+            },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const timeout = setTimeout(() => {
+            proc.kill('SIGKILL');
+            // Destroy pipes so the 'close' event fires immediately even if
+            // child processes (e.g. sleep) inherited the file descriptors.
+            proc.stdout?.destroy();
+            proc.stderr?.destroy();
+            wsService.emit(workspaceId, `${eventPrefix}:output`, {
+                text: `[kobo] Script timed out after ${Math.round(timeoutMs / 60000)} minutes`,
+            });
+        }, timeoutMs);
+        const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[a-zA-Z]`, 'g');
+        const stripAnsi = (s) => s.replace(ansiPattern, '');
+        // Track whether the script printed anything — lets the UI show a terse
+        // "Done" instead of a near-empty card when a script runs silently.
+        let outputEmitted = false;
+        const emitLine = (text) => {
+            const trimmed = stripAnsi(text).trim();
+            if (trimmed) {
+                outputEmitted = true;
+                wsService.emit(workspaceId, `${eventPrefix}:output`, { text: trimmed });
+            }
+        };
+        proc.stdout.on('data', (data) => {
+            for (const line of data.toString().split('\n')) {
+                emitLine(line);
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            for (const line of data.toString().split('\n')) {
+                emitLine(line);
+            }
+        });
+        let settled = false;
+        const finish = (exitCode) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            try {
+                fs.unlinkSync(scriptPath);
+            }
+            catch {
+                /* best-effort */
+            }
+            if (exitCode === 0) {
+                wsService.emitEphemeral(workspaceId, `${eventPrefix}:complete`, { hadOutput: outputEmitted });
+            }
+            else {
+                wsService.emitEphemeral(workspaceId, `${eventPrefix}:error`, {
+                    exitCode,
+                    message: `Script exited with code ${exitCode}`,
+                });
+            }
+            resolve({ exitCode });
+        };
+        proc.on('error', (err) => {
+            wsService.emit(workspaceId, `${eventPrefix}:output`, {
+                text: `[kobo] Script failed to start: ${err.message}`,
+            });
+            finish(1);
+        });
+        proc.on('close', (code) => {
+            finish(code ?? 1);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.7.13",
+  "version": "1.7.15",
   "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",
@@ -13,6 +13,7 @@
     "src/mcp-server/",
     "AGENTS.md",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "publishConfig": {