@loicngr/kobo 1.11.39 → 1.11.40

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

@@ -0,0 +1,137 @@
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+/** A zombie cannot mutate a checkout, even before its parent reaps it. */
+async function groupIsLive(pid) {
+    try {
+        process.kill(-pid, 0);
+    }
+    catch (err) {
+        if (err.code === 'ESRCH')
+            return false;
+        throw err;
+    }
+    const { stdout } = await execFileAsync('ps', ['-eo', 'pgid=,stat='], { timeout: 1000, encoding: 'utf8' });
+    return stdout.split('\n').some((line) => {
+        const [group, state] = line.trim().split(/\s+/);
+        return Number(group) === pid && !!state && !/^[ZX]/.test(state);
+    });
+}
+/**
+ * Stop the entire group on timeout, and retain the caller's mutation ownership
+ * until exit is confirmed. Inspection failures never authorize another mutation.
+ */
+export function runBoundedProcess(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: options.env,
+            detached: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdout = [];
+        let stdoutBytes = 0;
+        let stderr = Buffer.alloc(0);
+        let failure;
+        let closed = false;
+        let settled = false;
+        let code = null;
+        let signal = null;
+        let killTimer;
+        let pollTimer;
+        let checking = false;
+        let warned = false;
+        let escalatedAt;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(deadline);
+            clearTimeout(killTimer);
+            clearTimeout(pollTimer);
+            if (failure)
+                reject(failure);
+            else if (code === 0)
+                resolve(Buffer.concat(stdout, stdoutBytes).toString('utf8'));
+            else
+                reject(new Error(`${command} failed: ${stderr.toString('utf8').trim() || `exit code ${code ?? signal ?? 'unknown'}`}`));
+        };
+        const confirm = async () => {
+            if (settled || checking)
+                return;
+            checking = true;
+            try {
+                if (closed && (!child.pid || !(await groupIsLive(child.pid)))) {
+                    finish();
+                    return;
+                }
+                if (escalatedAt !== undefined && Date.now() - escalatedAt >= 5000 && !warned) {
+                    warned = true;
+                    console.error(`[process] ${command} has not exited after SIGKILL; retaining mutation ownership until exit is confirmed`);
+                }
+            }
+            catch (err) {
+                if (!warned) {
+                    warned = true;
+                    console.error(`[process] Cannot confirm ${command} process-group exit; retaining mutation ownership:`, err);
+                }
+            }
+            finally {
+                checking = false;
+            }
+            if (!settled)
+                pollTimer = setTimeout(() => void confirm(), 250);
+        };
+        const kill = (requestedSignal) => {
+            try {
+                if (child.pid)
+                    process.kill(-child.pid, requestedSignal);
+            }
+            catch (err) {
+                if (err.code !== 'ESRCH')
+                    console.error(`[process] ${requestedSignal} failed for ${command}:`, err);
+            }
+        };
+        const stop = (error) => {
+            if (failure || settled)
+                return;
+            failure = error;
+            kill('SIGTERM');
+            killTimer = setTimeout(() => {
+                kill('SIGKILL');
+                escalatedAt = Date.now();
+                void confirm();
+            }, options.graceMs ?? 5000);
+            void confirm();
+        };
+        const deadline = setTimeout(() => stop(new Error(`${command} timed out after ${options.timeoutMs}ms`)), options.timeoutMs);
+        child.stdout?.on('data', (chunk) => {
+            if (options.stdoutLimit === undefined)
+                return;
+            if (stdoutBytes + chunk.length > options.stdoutLimit) {
+                stop(new Error(`${command} output exceeded ${options.stdoutLimit} bytes`));
+                return;
+            }
+            stdout.push(chunk);
+            stdoutBytes += chunk.length;
+        });
+        child.stderr?.on('data', (chunk) => {
+            const limit = options.stderrLimit ?? 8192;
+            stderr = Buffer.concat([stderr, chunk]).subarray(-limit);
+        });
+        child.once('error', (err) => {
+            if (!child.pid) {
+                failure = new Error(`${command} failed to spawn: ${err.message}`);
+                finish();
+            }
+            else
+                stop(err);
+        });
+        child.once('close', (exitCode, exitSignal) => {
+            closed = true;
+            code = exitCode;
+            signal = exitSignal;
+            void confirm();
+        });
+    });
+}

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

@@ -1,6 +1,6 @@
 import { execFile as execFileCb, execFileSync } from 'node:child_process';
 import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, relative, resolve } from 'node:path';
 import { promisify } from 'node:util';
 import { resolvePathInside } from './safe-path.js';
 const execFileAsync = promisify(execFileCb);
@@ -922,6 +922,43 @@ export function localBranchExists(repoPath, name) {
 export function moveWorktree(projectPath, oldPath, newPath) {
     git(projectPath, ['worktree', 'move', oldPath, newPath]);
 }
+/** Git -z never quotes filenames; renames have a second source record. */
+function parsePorcelain(output) {
+    const records = output.split('\0');
+    const entries = [];
+    for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        if (!record)
+            continue;
+        const x = record[0];
+        const y = record[1];
+        entries.push({ path: record.slice(3), x, y });
+        if (x === 'R' || x === 'C' || y === 'R' || y === 'C')
+            i++;
+    }
+    return entries;
+}
+function parseNameStatus(output) {
+    const records = output.split('\0');
+    const files = [];
+    for (let i = 0; i < records.length - 1;) {
+        const code = records[i++];
+        let filePath = records[i++];
+        if (code.startsWith('R') || code.startsWith('C'))
+            filePath = records[i++];
+        if (!filePath)
+            continue;
+        const status = code.startsWith('R')
+            ? 'renamed'
+            : code.startsWith('A')
+                ? 'added'
+                : code.startsWith('D')
+                    ? 'deleted'
+                    : 'modified';
+        files.push({ path: filePath, status });
+    }
+    return files;
+}
 /** List files changed between base and HEAD (committed), plus working tree changes. */
 /**
  * List the worktree's files — tracked plus untracked-but-not-git-ignored.
@@ -931,10 +968,10 @@ export function moveWorktree(projectPath, oldPath, newPath) {
  */
 export function listWorktreeFiles(worktreePath, limit = 5000) {
     try {
-        const out = git(worktreePath, ['ls-files', '--cached', '--others', '--exclude-standard']);
+        const out = git(worktreePath, ['ls-files', '-z', '--cached', '--others', '--exclude-standard']);
         if (!out)
             return [];
-        const files = out.split('\n').filter((line) => line.length > 0);
+        const files = out.split('\0').filter((line) => line.length > 0);
         return files.length > limit ? files.slice(0, limit) : files;
     }
     catch {
@@ -947,7 +984,7 @@ export function listWorktreeFiles(worktreePath, limit = 5000) {
  */
 export function worktreeHasChanges(worktreePath) {
     try {
-        return git(worktreePath, ['status', '--porcelain']).length > 0;
+        return git(worktreePath, ['status', '--porcelain', '-z']).length > 0;
     }
     catch {
         return false;
@@ -958,7 +995,7 @@ export function worktreeHasChanges(worktreePath) {
  *  the worktree holds uncommitted work, "unknown" must never be read as
  *  "nothing to lose". */
 export function worktreeHasChangesStrict(worktreePath) {
-    return git(worktreePath, ['status', '--porcelain']).length > 0;
+    return git(worktreePath, ['status', '--porcelain', '-z']).length > 0;
 }
 export function getChangedFiles(repoPath, base, includeUntracked = false) {
     const ref = resolveBase(repoPath, base);
@@ -966,29 +1003,9 @@ export function getChangedFiles(repoPath, base, includeUntracked = false) {
     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');
-            if (!statusCode || pathParts.length === 0)
-                continue;
-            // For renames/copies (R100 old new), use the new path (last element)
-            const filePath = (statusCode.startsWith('R') || statusCode.startsWith('C')
-                ? pathParts[pathParts.length - 1]
-                : pathParts[0])?.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);
-        }
+        files.push(...parseNameStatus(git(repoPath, ['diff', '--name-status', '-z', `${ref}...HEAD`])));
+        for (const file of files)
+            seen.add(file.path);
     }
     catch {
         // No commits yet
@@ -1000,23 +1017,21 @@ export function getChangedFiles(repoPath, base, includeUntracked = false) {
     // we use `-uall` and surface them with status='added'.
     try {
         const flag = includeUntracked ? '-uall' : '-uno';
-        const output = git(repoPath, ['status', '--porcelain', flag]);
-        for (const line of output.split('\n')) {
-            if (!line)
+        const output = git(repoPath, ['status', '--porcelain', '-z', flag]);
+        for (const { path: filePath, x, y } of parsePorcelain(output)) {
+            if (seen.has(filePath))
                 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 = 'untracked';
+            else if (x === 'R' || y === 'R')
+                status = 'renamed';
             else if (x === 'A' || y === 'A')
                 status = 'added';
             else if (x === 'D' || y === 'D')
                 status = 'deleted';
             files.push({ path: filePath, status });
+            seen.add(filePath);
         }
     }
     catch {
@@ -1041,27 +1056,7 @@ export function getUnpushedChangedFiles(repoPath, branchName, remote = 'origin')
     }
     const files = [];
     try {
-        const output = git(repoPath, ['diff', '--name-status', `${remoteRef}..HEAD`]);
-        for (const line of output.split('\n')) {
-            if (!line)
-                continue;
-            const [statusCode, ...pathParts] = line.split('\t');
-            if (!statusCode || pathParts.length === 0)
-                continue;
-            const filePath = (statusCode.startsWith('R') || statusCode.startsWith('C')
-                ? pathParts[pathParts.length - 1]
-                : pathParts[0])?.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 });
-        }
+        files.push(...parseNameStatus(git(repoPath, ['diff', '--name-status', '-z', `${remoteRef}..HEAD`])));
     }
     catch {
         // Unlikely after the rev-parse check, but keep the happy path robust.
@@ -1113,27 +1108,7 @@ export function commitExists(repoPath, ref) {
 export function getChangedFilesBetween(repoPath, fromRef, toRef) {
     const files = [];
     try {
-        const output = git(repoPath, ['diff', '--name-status', `${fromRef}..${toRef}`]);
-        for (const line of output.split('\n')) {
-            if (!line)
-                continue;
-            const [statusCode, ...pathParts] = line.split('\t');
-            if (!statusCode || pathParts.length === 0)
-                continue;
-            const filePath = (statusCode.startsWith('R') || statusCode.startsWith('C')
-                ? pathParts[pathParts.length - 1]
-                : pathParts[0])?.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 });
-        }
+        files.push(...parseNameStatus(git(repoPath, ['diff', '--name-status', '-z', `${fromRef}..${toRef}`])));
     }
     catch {
         // invalid refs / no diff → empty list
@@ -1158,42 +1133,27 @@ export function getChangedFilesBetween(repoPath, fromRef, toRef) {
  * feedback in the UI.
  */
 export function rollbackFile(repoPath, branchName, filePath, remote = 'origin') {
-    const absPath = resolvePathInside(repoPath, filePath);
+    resolvePathInside(repoPath, filePath);
+    const absPath = resolve(repoPath, filePath);
+    filePath = relative(resolve(repoPath), absPath);
     const remoteRef = `${remote}/${branchName}`;
-    let remoteRefExists = false;
-    try {
-        git(repoPath, ['rev-parse', '--verify', remoteRef]);
-        remoteRefExists = true;
-    }
-    catch {
-        // Branch never pushed — fall through to HEAD.
-    }
-    if (remoteRefExists) {
-        try {
-            git(repoPath, ['cat-file', '-e', `${remoteRef}:${filePath}`]);
-            git(repoPath, ['checkout', remoteRef, '--', filePath]);
-            return 'remote';
-        }
-        catch {
-            // File doesn't exist at origin/<branch> (added locally) — fall through.
-        }
-    }
-    try {
-        git(repoPath, ['cat-file', '-e', `HEAD:${filePath}`]);
-        git(repoPath, ['checkout', 'HEAD', '--', filePath]);
+    // show-ref distinguishes an absent ref from repository/IO errors. Tree
+    // inspection must succeed before absence authorizes deletion.
+    const refs = git(repoPath, ['for-each-ref', '--format=%(refname)', `refs/remotes/${remoteRef}`]).split('\n');
+    const fileExistsAt = (ref) => git(repoPath, ['ls-tree', '-r', '-z', '--name-only', ref, '--', `:(literal)${filePath}`])
+        .split('\0')
+        .includes(filePath);
+    if (refs.includes(`refs/remotes/${remoteRef}`) && fileExistsAt(remoteRef)) {
+        git(repoPath, ['checkout', remoteRef, '--', `:(literal)${filePath}`]);
+        return 'remote';
+    }
+    if (fileExistsAt('HEAD')) {
+        git(repoPath, ['checkout', 'HEAD', '--', `:(literal)${filePath}`]);
         return 'head';
     }
-    catch {
-        // File is untracked OR has already been rolled back — delete it from
-        // disk if still present. Idempotent: if the file is already gone (race
-        // with a previous rollback, stale UI list, manual rm), we still return
-        // 'deleted' since the end state matches the user's intent. `rmSync`
-        // over `git clean -f` keeps the action narrow to one file.
-        if (existsSync(absPath)) {
-            rmSync(absPath, { force: true });
-        }
-        return 'deleted';
-    }
+    if (existsSync(absPath))
+        rmSync(absPath, { force: true });
+    return 'deleted';
 }
 /** @deprecated kept for backwards-compat with older imports — use `rollbackFile`. */
 export const rollbackFileToRemote = rollbackFile;
@@ -1213,7 +1173,7 @@ export function writeFileInWorktree(absPath, content) {
 /** Parse `git status --porcelain` into counts of staged, modified, and untracked files. */
 export function getWorkingTreeStatus(repoPath) {
     try {
-        return parseWorkingTreeStatus(git(repoPath, ['status', '--porcelain']));
+        return parseWorkingTreeStatus(git(repoPath, ['status', '--porcelain', '-z']));
     }
     catch {
         return { staged: 0, modified: 0, untracked: 0 };
@@ -1223,11 +1183,7 @@ function parseWorkingTreeStatus(output) {
     let staged = 0;
     let modified = 0;
     let untracked = 0;
-    for (const line of output.split('\n')) {
-        if (!line)
-            continue;
-        const x = line[0];
-        const y = line[1];
+    for (const { x, y } of parsePorcelain(output)) {
         if (x === '?' && y === '?') {
             untracked++;
         }
@@ -1247,17 +1203,9 @@ function parseWorkingTreeStatus(output) {
  */
 export function getWorkingTreeFiles(repoPath) {
     try {
-        const output = git(repoPath, ['status', '--porcelain']);
+        const output = git(repoPath, ['status', '--porcelain', '-z']);
         const files = [];
-        for (const line of output.split('\n')) {
-            if (!line)
-                continue;
-            const x = line[0];
-            const y = line[1];
-            let filePath = line.slice(3);
-            const arrowIdx = filePath.indexOf(' -> ');
-            if (arrowIdx !== -1)
-                filePath = filePath.slice(arrowIdx + 4);
+        for (const { path: filePath, x, y } of parsePorcelain(output)) {
             const untracked = x === '?' && y === '?';
             files.push({
                 path: filePath,
@@ -1436,7 +1384,7 @@ export async function getStructuredDiffStatsBetweenAsync(repoPath, base, head) {
 /** Non-blocking working-tree summary for request and polling hot paths. */
 export async function getWorkingTreeStatusAsync(repoPath) {
     try {
-        return parseWorkingTreeStatus(await gitAsync(repoPath, ['status', '--porcelain']));
+        return parseWorkingTreeStatus(await gitAsync(repoPath, ['status', '--porcelain', '-z']));
     }
     catch {
         return { staged: 0, modified: 0, untracked: 0 };

package/dist/server/utils/git-repo-lock.js

@@ -1,5 +1,6 @@
-import { execFileSync } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import path from 'node:path';
+import { promisify } from 'node:util';
 /**
  * One promise chain per shared git directory. Same mechanism as the per-worktree
  * lock in `image-service.ts`, keyed differently: remote refs, packed-refs and
@@ -8,6 +9,10 @@ import path from 'node:path';
  * are disjoint.
  */
 const locks = new Map();
+const execFileAsync = promisify(execFile);
+// Register operations in invocation order even when common-dir lookups finish
+// out of order. This queue covers resolution only, never the locked operation.
+let registrations = Promise.resolve();
 /**
  * Absolute path of the git directory shared by every worktree of a repository.
  *
@@ -15,15 +20,16 @@ const locks = new Map();
  * repository, git missing): a wrong key only costs parallelism, never
  * correctness, whereas throwing here would break every caller.
  */
-export function resolveGitCommonDir(repoPath) {
+export async function resolveGitCommonDir(repoPath) {
     try {
-        const out = execFileSync('git', ['rev-parse', '--git-common-dir'], {
+        const { stdout } = await execFileAsync('git', ['rev-parse', '--git-common-dir'], {
             cwd: repoPath,
             encoding: 'utf-8',
-            timeout: 15_000,
+            timeout: 10_000,
+            killSignal: 'SIGKILL',
             env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
-        }).trim();
-        return path.resolve(repoPath, out);
+        });
+        return path.resolve(repoPath, stdout.replace(/\n$/, ''));
     }
     catch {
         return path.resolve(repoPath);
@@ -31,15 +37,23 @@ export function resolveGitCommonDir(repoPath) {
 }
 /** Run `fn` with exclusive access to `repoPath`'s shared git directory. */
 export function withGitRepoLock(repoPath, fn) {
-    const key = resolveGitCommonDir(repoPath);
-    const previous = locks.get(key) ?? Promise.resolve();
-    // The second argument to .then() means: even if the previous operation in the
-    // queue rejected, still run fn — one failure must not block the whole queue.
-    const next = previous.then(fn, fn);
-    locks.set(key, next.then(() => { }, () => { }));
-    return next;
+    let next;
+    const registered = registrations.then(async () => {
+        const key = await resolveGitCommonDir(repoPath);
+        const previous = locks.get(key) ?? Promise.resolve();
+        next = previous.then(fn, fn);
+        const settled = next.then(() => { }, () => { });
+        locks.set(key, settled);
+        void settled.then(() => {
+            if (locks.get(key) === settled)
+                locks.delete(key);
+        });
+    });
+    registrations = registered.catch(() => { });
+    return registered.then(() => next);
 }
 /** Test-only: drop every queued chain so tests don't inherit each other's state. */
 export function _resetGitRepoLocksForTest() {
     locks.clear();
+    registrations = Promise.resolve();
 }

package/dist/shared/workspace-dialogue-tools.js

@@ -0,0 +1,89 @@
+const workspace = { type: 'string', minLength: 1, maxLength: 200, description: 'Workspace ID from list_workspaces.' };
+const session = {
+    type: 'string',
+    minLength: 1,
+    maxLength: 200,
+    description: 'Session ID from list_workspace_sessions.',
+};
+function tool(name, description, properties, required, readOnly = true) {
+    return {
+        name,
+        description,
+        inputSchema: { type: 'object', properties, required, additionalProperties: false },
+        annotations: { readOnlyHint: readOnly, destructiveHint: !readOnly, openWorldHint: !readOnly },
+    };
+}
+export const WORKSPACE_DISCOVERY_TOOL = tool('list_workspaces', 'Discover Kōbō workspaces and their current status.', {
+    include_archived: { type: 'boolean' },
+}, []);
+export const WORKSPACE_DIALOGUE_TOOLS = [
+    tool('get_workspace', 'Read workspace metadata, tasks and current agent session.', { workspace_id: workspace }, [
+        'workspace_id',
+    ]),
+    tool('list_workspace_sessions', 'List the sessions of a workspace to select a conversation.', { workspace_id: workspace }, ['workspace_id']),
+    tool('read_workspace_messages', 'Read a bounded chronological page of conversation fragments. Start without after_cursor; continue with nextCursor. Reuse the final cursor to poll for new replies. Concatenate assistant fragments with the same messageId and sessionId.', {
+        workspace_id: workspace,
+        session_id: session,
+        after_cursor: { type: 'string', minLength: 1, maxLength: 200 },
+        limit: { type: 'integer', minimum: 1, maximum: 200, description: 'Maximum source events scanned (default 100).' },
+    }, ['workspace_id']),
+    tool('send_workspace_message', 'Send a message to an agent, resuming it if needed. Returns acceptance, not the agent reply; read_workspace_messages retrieves replies. Uses the configured permission mode and pauses active auto-loop. Do not retry blindly after an ambiguous connection failure. Do not send to your own workspace.', {
+        workspace_id: workspace,
+        session_id: session,
+        content: { type: 'string', minLength: 1, maxLength: 100_000 },
+        idempotency_key: {
+            type: 'string',
+            minLength: 1,
+            maxLength: 200,
+            description: 'Generate once per intended message; reuse on retries to prevent duplicate dispatch, including after restart. Reuse with different content/session is rejected.',
+        },
+    }, ['workspace_id', 'content'], false),
+    tool('get_workspace_questions', 'Read pending questions and whether a human tool approval is blocking the workspace.', { workspace_id: workspace }, ['workspace_id']),
+    tool('answer_workspace_question', 'Answer the current pending question using its exact tool_call_id. Answer keys are question IDs for Codex, question text for Claude. Tool permission requests require human approval in Kōbō.', {
+        workspace_id: workspace,
+        tool_call_id: { type: 'string', minLength: 1, maxLength: 200 },
+        answers: { type: 'object', minProperties: 1, additionalProperties: { type: 'string' } },
+    }, ['workspace_id', 'tool_call_id', 'answers'], false),
+];
+export const EXTERNAL_MCP_TOOLS = [WORKSPACE_DISCOVERY_TOOL, ...WORKSPACE_DIALOGUE_TOOLS];
+/** The low-level MCP server checks the envelope; validate tool arguments here. */
+export function validateDialogueArguments(name, value) {
+    const definition = EXTERNAL_MCP_TOOLS.find((entry) => entry.name === name);
+    if (!definition)
+        throw new Error(`Unknown tool '${name}'`);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Tool arguments must be an object');
+    const args = value;
+    const properties = definition.inputSchema.properties;
+    for (const key of definition.inputSchema.required ?? [])
+        if (!Object.hasOwn(args, key))
+            throw new Error(`${key} is required`);
+    for (const [key, input] of Object.entries(args)) {
+        const property = properties[key];
+        if (!Object.hasOwn(properties, key))
+            throw new Error(`Unknown argument '${key}'`);
+        if (property.type === 'string') {
+            if (typeof input !== 'string' || !input.trim() || input.length > (property.maxLength ?? 100_000))
+                throw new Error(`${key} must be a non-empty string within its length limit`);
+        }
+        else if (property.type === 'boolean') {
+            if (typeof input !== 'boolean')
+                throw new Error(`${key} must be a boolean`);
+        }
+        else if (property.type === 'integer') {
+            if (typeof input !== 'number' ||
+                !Number.isInteger(input) ||
+                input < property.minimum ||
+                input > property.maximum)
+                throw new Error(`${key} is outside its allowed integer range`);
+        }
+        else if (!input ||
+            typeof input !== 'object' ||
+            Array.isArray(input) ||
+            Object.keys(input).length === 0 ||
+            Object.values(input).some((answer) => typeof answer !== 'string' || answer.length > 100_000)) {
+            throw new Error(`${key} must be a non-empty object of string answers`);
+        }
+    }
+    return args;
+}

package/dist/shared/workspace-message-types.js

@@ -0,0 +1,19 @@
+export function normalizeClientName(value) {
+    return ((typeof value === 'string'
+        ? Array.from(value
+            .replace(/[\p{Cc}\s]+/gu, ' ')
+            .replace(/\p{Cs}/gu, '�')
+            .trim())
+            .slice(0, 100)
+            .join('')
+        : '') || 'External MCP client');
+}
+/** Tolerant decoder for historical/untrusted payloads. Labels are not identities. */
+export function parseMessageSource(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const source = value;
+    if (source.kind !== 'mcp' || (source.transport !== 'http' && source.transport !== 'stdio'))
+        return undefined;
+    return { kind: 'mcp', clientName: normalizeClientName(source.clientName), transport: source.transport };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.11.39",
+  "version": "1.11.40",
   "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",
@@ -57,6 +57,7 @@
     "install-all": "npm install && cd src/client && npm install && cd src-pwa && npm install",
     "start": "node dist/server/index.js",
     "test": "vitest run --config vitest.config.ts --root .",
+    "test:mcp:live": "vitest run --config vitest.live.config.ts",
     "test:watch": "vitest --config vitest.config.ts --root .",
     "test:client": "cd src/client && npm test",
     "test:all": "npm test && npm run test:client",