@loicngr/kobo 2.1.23 → 2.1.25

package/dist/server/services/forge/types.js

@@ -1,4 +1,3 @@
-// src/server/services/forge/types.ts
 /**
  * True when nothing blocks merging the PR: it is open, CI is not failing or
  * in-flight (green `SUCCESS` or absent `null` — matching GitHub's "Ready to

package/dist/server/services/lifecycle-hook-service.js

@@ -3,7 +3,6 @@ import { getDb } from '../db/index.js';
 import { slugifyProjectName } from '../utils/project-slug.js';
 import { runScript } from '../utils/script-runner.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
-import { resolveInstance, sanitizeBranchName } from './dev-server-service.js';
 import { getEffectiveSettings, getGlobalSettings, getProjectSettings } from './settings-service.js';
 import { listWorkspaces } from './workspace-service.js';
 export const SHUTDOWN_SCRIPT_TIMEOUT_MS = 60_000;
@@ -55,7 +54,6 @@ export async function runLifecycleHook(event, workspaceId, extraEnv) {
             }
             return null;
         }
-        const instance = event === 'kobo-shutdown' ? resolveInstance(row.project_path, row.working_branch) : null;
         return await runScript({
             workspaceId,
             worktreePath,
@@ -70,12 +68,6 @@ export async function runLifecycleHook(event, workspaceId, extraEnv) {
                 branchName: row.working_branch,
                 sourceBranch: row.source_branch,
                 projectPath: row.project_path,
-                ...(event === 'kobo-shutdown'
-                    ? {
-                        projectName: instance?.projectName ?? '',
-                        instanceName: instance?.instanceName ?? sanitizeBranchName(row.working_branch),
-                    }
-                    : {}),
             },
             extraEnv: { ...extraEnv, KOBO_HOOK_EVENT: event },
         });

package/dist/server/services/mcp-message-delivery-service.js

@@ -4,7 +4,7 @@ import { broadcastPersistedEvent, persistWorkspaceEvent } from './websocket-serv
 import { deliverWorkspaceMessage } from './workspace-message-service.js';
 export async function deliverKeyedMcpMessage(workspaceId, key, message) {
     const db = getDb();
-    const request = reserveMessageRequest(db, workspaceId, key, message.content, message.sessionId);
+    const request = reserveMessageRequest(db, workspaceId, key, message.content, message.sessionId, message.attachments);
     if (!request.fresh)
         return request.result;
     let dispatched = false;

package/dist/server/services/mcp-message-request-service.js

@@ -1,9 +1,15 @@
 import { createHash } from 'node:crypto';
 import { nanoid } from 'nanoid';
-export function reserveMessageRequest(db, workspaceId, key, content, sessionId) {
-    const fingerprint = createHash('sha256')
-        .update(JSON.stringify([content, sessionId ?? null]))
-        .digest('hex');
+export function reserveMessageRequest(db, workspaceId, key, content, sessionId, attachments) {
+    // Keep text-only fingerprints compatible with receipts issued before attachment support.
+    const identity = [content, sessionId ?? null];
+    if (attachments?.length)
+        identity.push(attachments.map((file) => [
+            file.name,
+            file.mime_type,
+            createHash('sha256').update(file.data_base64).digest('hex'),
+        ]));
+    const fingerprint = createHash('sha256').update(JSON.stringify(identity)).digest('hex');
     return db
         .transaction(() => {
         const requestId = `mcp-${nanoid()}`;
@@ -23,7 +29,7 @@ export function reserveMessageRequest(db, workspaceId, key, content, sessionId)
                 accepted: false,
                 requestId: row.request_id,
                 code: 'idempotency_conflict',
-                message: 'This key was already used for different content or a different session',
+                message: 'This key was already used for different content, session or attachments',
             };
         else if (row.result_json) {
             result = JSON.parse(row.result_json);

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

@@ -1010,6 +1010,14 @@ const settingsMigrations = [
             }
         },
     },
+    {
+        version: 67,
+        name: 'opt-in-immediate-chat-messages',
+        migrate: ({ global }) => {
+            if (typeof global.forceImmediateMessages !== 'boolean')
+                global.forceImmediateMessages = 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;
@@ -1067,6 +1075,7 @@ function defaultSettings() {
             autoPurgeOnPrMerged: false,
             autoLoopMaxRetries: 5,
             agentWatchdogEnabled: false,
+            forceImmediateMessages: false,
             showProgressBars: true,
             stopDevServersOnShutdown: true,
             awaitingUserReminderMinutes: 0,
@@ -1218,6 +1227,8 @@ export function runSettingsMigrations(raw) {
     current.global.workflowPolicy = resolveWorkflowPolicy(current.global.workflowPolicy);
     if (!isMemoryMode(current.global.memoryMode))
         current.global.memoryMode = 'hybrid';
+    if (typeof current.global.forceImmediateMessages !== 'boolean')
+        current.global.forceImmediateMessages = false;
     if (typeof current.global.showProgressBars !== 'boolean')
         current.global.showProgressBars = true;
     if (typeof current.global.stopDevServersOnShutdown !== 'boolean')
@@ -1588,6 +1599,9 @@ export function updateGlobalSettings(input) {
     if ('stopDevServersOnShutdown' in data && typeof data.stopDevServersOnShutdown !== 'boolean') {
         delete data.stopDevServersOnShutdown;
     }
+    if ('forceImmediateMessages' in data && typeof data.forceImmediateMessages !== 'boolean') {
+        delete data.forceImmediateMessages;
+    }
     if ('showProgressBars' in data && typeof data.showProgressBars !== 'boolean') {
         delete data.showProgressBars;
     }
@@ -1659,6 +1673,7 @@ export function updateGlobalSettings(input) {
         'autoPurgeOnPrMerged',
         'autoLoopMaxRetries',
         'agentWatchdogEnabled',
+        'forceImmediateMessages',
         'showProgressBars',
         'stopDevServersOnShutdown',
         'awaitingUserReminderMinutes',

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

@@ -85,6 +85,7 @@ export async function executeWorkspaceDialogueTool(name, input, source = createM
     if (name === 'send_workspace_message' && args.idempotency_key)
         return deliverKeyedMcpMessage(workspaceId, args.idempotency_key, {
             content: args.content,
+            ...(args.attachments ? { attachments: args.attachments } : {}),
             sessionId: args.session_id,
             source,
         });
@@ -93,6 +94,7 @@ export async function executeWorkspaceDialogueTool(name, input, source = createM
             accepted: true,
             ...(await deliverWorkspaceMessage(workspaceId, {
                 content: args.content,
+                ...(args.attachments ? { attachments: args.attachments } : {}),
                 sessionId: args.session_id,
                 clientMessageId: `mcp-${nanoid()}`,
                 source,

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

@@ -1,5 +1,7 @@
-import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
+import { validateMcpAttachments } from '../../shared/mcp-attachments.js';
+import { assertWorkspaceLifecycleAvailable, withWorkspaceLifecycleGuard } from '../utils/workspace-lifecycle-guard.js';
 import { isAgentUnavailableError, isShuttingDown, sendMessage, startAgent } from './agent/orchestrator.js';
+import { attachmentReference, removeAttachments, saveAttachments } from './attachment-service.js';
 import { hasLoopMessage } from './auto-loop-message-service.js';
 import * as autoLoop from './auto-loop-service.js';
 import { createChatReceipt } from './chat-receipt-service.js';
@@ -7,10 +9,28 @@ import { emitEphemeral } from './websocket-service.js';
 import { getActiveSession, getWorkspace, updateWorkspaceStatus } from './workspace-service.js';
 /** Shared delivery for WebSocket chat and external MCP clients. */
 export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
+    // Keep the caller's original content unchanged for durable idempotency fingerprints.
+    message = { ...message };
     const receipt = createChatReceipt(workspaceId, message, hooks?.persist);
+    let saved = [];
+    let attachmentWorktree;
+    let dispatched = false;
+    const beforeDispatch = () => {
+        if (saved.length) {
+            assertWorkspaceLifecycleAvailable(workspaceId);
+            const current = getWorkspace(workspaceId);
+            if (!current || current.archivedAt || current.worktreePurgedAt || current.worktreePath !== attachmentWorktree)
+                throw new Error('Workspace changed before attachment delivery');
+            if (current.status === 'compacting' || current.status === 'awaiting-user' || isShuttingDown())
+                throw new Error('Workspace is not ready to receive a message');
+        }
+        hooks?.beforeDispatch?.();
+        dispatched = true;
+    };
     let reason;
     try {
-        if (!message.content.trim())
+        const attachments = validateMcpAttachments(message.attachments);
+        if (!message.content.trim() && !attachments.length)
             throw new Error('Message content must not be empty');
         if (isShuttingDown())
             throw new Error('Kōbō is shutting down');
@@ -21,6 +41,8 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
         if (workspace.archivedAt || workspace.worktreePurgedAt)
             throw new Error('Restore the workspace before sending a message');
         if (message.delivery === 'next_iteration') {
+            if (attachments.length)
+                throw new Error('Attachments require immediate delivery');
             if (!message.clientMessageId)
                 throw new Error('clientMessageId is required for queued delivery');
             const acceptedBefore = hasLoopMessage(workspaceId, message.clientMessageId);
@@ -45,11 +67,28 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             reason = 'awaiting-user';
             throw new Error('Answer the pending question or permission request before sending a chat message');
         }
+        if (attachments.length) {
+            attachmentWorktree = workspace.worktreePath;
+            await withWorkspaceLifecycleGuard(workspaceId, async () => {
+                const files = attachments.map((file) => new File([Buffer.from(file.data_base64, 'base64')], file.name, { type: file.mime_type }));
+                saved = await saveAttachments(workspace.worktreePath, files);
+            });
+            assertWorkspaceLifecycleAvailable(workspaceId);
+            const current = getWorkspace(workspaceId);
+            if (!current || current.archivedAt || current.worktreePurgedAt || current.worktreePath !== attachmentWorktree)
+                throw new Error('Workspace changed while saving attachments');
+            if (current.status === 'compacting' || current.status === 'awaiting-user' || isShuttingDown())
+                throw new Error('Workspace is not ready to receive a message');
+            message.content = [message.content.trim(), ...saved.map(attachmentReference)].filter(Boolean).join('\n\n');
+            // Binary data never belongs in the chat receipt or agent prompt.
+            delete message.attachments;
+        }
+        const trackDispatch = !!hooks?.beforeDispatch || saved.length > 0;
         const loop = autoLoop.getStatus(workspaceId);
         let sessionId = message.sessionId ?? getActiveSession(workspaceId)?.id;
         try {
-            if (hooks?.beforeDispatch)
-                await sendMessage(workspaceId, message.content, message.sessionId, hooks.beforeDispatch);
+            if (trackDispatch)
+                await sendMessage(workspaceId, message.content, message.sessionId, beforeDispatch);
             else
                 await sendMessage(workspaceId, message.content, message.sessionId);
         }
@@ -61,7 +100,7 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             const current = getWorkspace(workspaceId);
             if (!current || current.archivedAt || current.worktreePurgedAt)
                 throw new Error('Workspace is unavailable');
-            const started = startAgent(workspaceId, current.worktreePath, message.content, current.model, true, message.agentPermissionModeOverride ?? current.agentPermissionMode, message.sessionId, current.reasoningEffort, ...(hooks?.beforeDispatch ? [hooks.beforeDispatch] : []));
+            const started = startAgent(workspaceId, current.worktreePath, message.content, current.model, true, message.agentPermissionModeOverride ?? current.agentPermissionMode, message.sessionId, current.reasoningEffort, ...(trackDispatch ? [beforeDispatch] : []));
             updateWorkspaceStatus(workspaceId, 'executing');
             sessionId = message.sessionId ?? started.agentSessionId;
         }
@@ -71,6 +110,23 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
         return { sessionId };
     }
     catch (error) {
+        // Once dispatch may have happened, keep files available to the agent even if
+        // acknowledgement failed. Only remove files from a definitively rejected send.
+        if (saved.length && attachmentWorktree && !dispatched) {
+            const worktree = attachmentWorktree;
+            try {
+                await withWorkspaceLifecycleGuard(workspaceId, async () => {
+                    const current = getWorkspace(workspaceId);
+                    if (!current || current.worktreePurgedAt || current.worktreePath !== worktree)
+                        return;
+                    for (const warning of await removeAttachments(worktree, saved))
+                        console.warn(`[message-attachments] ${warning}`);
+                });
+            }
+            catch {
+                // A competing lifecycle operation owns the checkout now; do not touch it.
+            }
+        }
         receipt.reject(error instanceof Error ? error.message : String(error), reason);
         throw error;
     }

package/dist/server/utils/dev-server-instance.js

@@ -0,0 +1,58 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Sanitize a branch name for use as a Docker instance name.
+ * Replace `/` and `_` with `-`, lowercase.
+ */
+export function sanitizeBranchName(branch) {
+    return branch.toLowerCase().replace(/[/_]/g, '-');
+}
+/**
+ * Parse a `.env` file content into key=value pairs.
+ * Skips empty lines and comments (#). Handles quotes.
+ */
+export function parseEnvFile(content) {
+    const result = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        // Strip surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Resolve the dev-server instance config for a given project + branch.
+ * Looks in `<projectPath>/.container/instances/` for `.env` files.
+ */
+export function resolveInstance(projectPath, workingBranch) {
+    const instancesDir = path.join(projectPath, '.container', 'instances');
+    if (!existsSync(instancesDir))
+        return null;
+    const sanitized = sanitizeBranchName(workingBranch);
+    const files = readdirSync(instancesDir).filter((f) => f.endsWith('.env'));
+    for (const file of files) {
+        const content = readFileSync(path.join(instancesDir, file), 'utf-8');
+        const parsed = parseEnvFile(content);
+        if (parsed.INSTANCE_NAME &&
+            parsed.INSTANCE_NAME.toLowerCase() === sanitized &&
+            parsed.PROJECT_NAME &&
+            /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(parsed.PROJECT_NAME)) {
+            return {
+                instanceName: parsed.INSTANCE_NAME,
+                projectName: parsed.PROJECT_NAME,
+                httpPort: parsed.HTTP_PORT ?? '',
+            };
+        }
+    }
+    return null;
+}

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

@@ -1045,27 +1045,27 @@ export function getChangedFiles(repoPath, base, includeUntracked = false) {
     }
     return files;
 }
-/**
- * List committed files between `origin/<branch>` and local HEAD — the set
- * of files the next `git push` would send. Working tree changes are NOT
- * included: uncommitted edits aren't about to be pushed. Returns an empty
- * list if there is no remote tracking branch yet.
- */
-export function getUnpushedChangedFiles(repoPath, branchName, remote = 'origin') {
-    const remoteRef = `${remote}/${branchName}`;
-    // Bail out cleanly if the remote branch doesn't exist (branch never pushed).
+/** Local changes relative to the pushed branch, including staged and working-tree edits. */
+export function getUnpushedChangedFiles(repoPath, branchName, remote = 'origin', sourceBranch = 'HEAD') {
+    let ref = `${remote}/${branchName}`;
     try {
-        git(repoPath, ['rev-parse', '--verify', remoteRef]);
+        git(repoPath, ['rev-parse', '--verify', ref]);
     }
     catch {
-        return [];
-    }
-    const files = [];
-    try {
-        files.push(...parseNameStatus(git(repoPath, ['diff', '--name-status', '-z', `${remoteRef}..HEAD`])));
+        ref = resolveBase(repoPath, sourceBranch);
     }
-    catch {
-        // Unlikely after the rev-parse check, but keep the happy path robust.
+    const files = parseNameStatus(git(repoPath, ['diff', '--name-status', '-z', ref, '--']));
+    const untracked = git(repoPath, ['ls-files', '--others', '--exclude-standard', '-z']);
+    return withUntrackedFiles(files, untracked);
+}
+/** Preserve NUL-delimited filenames and deduplicate tracked/untracked transitions. */
+function withUntrackedFiles(files, output) {
+    const seen = new Set(files.map((file) => file.path));
+    for (const filePath of output.split('\0')) {
+        if (filePath && !seen.has(filePath)) {
+            files.push({ path: filePath, status: 'untracked' });
+            seen.add(filePath);
+        }
     }
     return files;
 }
@@ -1555,16 +1555,25 @@ export async function getChangedFilesBetweenAsync(repoPath, fromRef, toRef) {
         return [];
     }
 }
-export async function getUnpushedChangedFilesAsync(repoPath, branchName, remote = 'origin') {
+/** Use the source branch until this working branch has been pushed for the first time. */
+export async function resolveUnpushedBaseAsync(repoPath, branchName, sourceBranch = 'HEAD', remote = 'origin') {
     const ref = `${remote}/${branchName}`;
     try {
         await gitAsync(repoPath, ['rev-parse', '--verify', ref]);
-        return parseNameStatus(await gitAsync(repoPath, ['diff', '--name-status', '-z', `${ref}..HEAD`]));
+        return ref;
     }
     catch {
-        return [];
+        return resolveBaseAsync(repoPath, sourceBranch);
     }
 }
+export async function getUnpushedChangedFilesAsync(repoPath, branchName, remote = 'origin', sourceBranch = 'HEAD') {
+    const ref = await resolveUnpushedBaseAsync(repoPath, branchName, sourceBranch, remote);
+    const [changes, untracked] = await Promise.all([
+        gitAsync(repoPath, ['diff', '--name-status', '-z', ref, '--']),
+        gitAsync(repoPath, ['ls-files', '--others', '--exclude-standard', '-z']),
+    ]);
+    return withUntrackedFiles(parseNameStatus(changes), untracked);
+}
 export async function getChangedFilesAsync(repoPath, base, includeUntracked = false) {
     const ref = await resolveBaseAsync(repoPath, base);
     const [committed, working] = await Promise.allSettled([

package/dist/server/utils/script-runner.js

@@ -2,6 +2,7 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import * as wsService from '../services/websocket-service.js';
+import { resolveInstance, sanitizeBranchName } from './dev-server-instance.js';
 import { getIndexLockPath } from './git-ops.js';
 import { ensureDirectoryInside } from './safe-path.js';
 /** Default wall-clock budget for a user script before it is force-killed. */
@@ -39,6 +40,8 @@ export function runScript(opts) {
         scriptDirectory = fs.mkdtempSync(path.join(storage, '.script-'));
         scriptPath = path.join(scriptDirectory, path.basename(tmpFileName));
         fs.writeFileSync(scriptPath, script, { mode: 0o700, flag: 'wx' });
+        // Resolve only from this workspace's persisted instance, never the host's env.
+        const instance = env?.projectPath && env.branchName ? resolveInstance(env.projectPath, env.branchName) : null;
         const proc = spawn('bash', [scriptPath], {
             cwd: worktreePath,
             env: {
@@ -49,8 +52,8 @@ export function runScript(opts) {
                 BRANCH_NAME: env?.branchName ?? '',
                 SOURCE_BRANCH: env?.sourceBranch ?? '',
                 PROJECT_PATH: env?.projectPath ?? '',
-                ...(env?.projectName !== undefined ? { PROJECT_NAME: env.projectName } : {}),
-                ...(env?.instanceName !== undefined ? { INSTANCE: env.instanceName } : {}),
+                PROJECT_NAME: instance?.projectName ?? '',
+                INSTANCE: instance?.instanceName ?? sanitizeBranchName(env?.branchName ?? ''),
             },
             stdio: ['ignore', 'pipe', 'pipe'],
             // Detached so this is the leader of its own process group: a script

package/dist/shared/forge-merge.js

@@ -0,0 +1,5 @@
+/** Explicit PR merge strategies. Availability is declared by each forge provider. */
+export const MERGE_METHODS = ['merge', 'squash', 'rebase'];
+export function isMergeMethod(value) {
+    return typeof value === 'string' && MERGE_METHODS.some((method) => method === value);
+}

package/dist/shared/mcp-attachments.js

@@ -0,0 +1,58 @@
+import { MAX_ATTACHMENTS, MAX_ATTACHMENTS_BYTES, validateAttachments } from './attachments.js';
+/** Inline upload budget for creation and message tools, including base64 expansion. */
+export const MAX_MCP_ATTACHMENT_REQUEST_BYTES = Math.ceil(MAX_ATTACHMENTS_BYTES / 3) * 4 + 1024 * 1024;
+export const MCP_ATTACHMENTS_SCHEMA = {
+    type: 'array',
+    maxItems: MAX_ATTACHMENTS,
+    description: 'Inline files/images: up to 10 files, 50 MiB decoded total. Send canonical base64 bytes, never a server file path.',
+    items: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', minLength: 1, maxLength: 255 },
+            mime_type: { type: 'string', maxLength: 200 },
+            data_base64: { type: 'string', minLength: 1, maxLength: Math.ceil(MAX_ATTACHMENTS_BYTES / 3) * 4 },
+        },
+        required: ['name', 'mime_type', 'data_base64'],
+        additionalProperties: false,
+    },
+};
+/** Validate types, names, canonical base64 and decoded bounds before any writes. */
+export function validateMcpAttachments(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > MAX_ATTACHMENTS)
+        throw new Error('attachments must contain at most 10 files');
+    const files = value;
+    const metadata = files.map((input) => {
+        if (!input || typeof input !== 'object' || Array.isArray(input))
+            throw new Error('Invalid attachment');
+        const file = input;
+        if (Object.keys(file).some((key) => !['name', 'mime_type', 'data_base64'].includes(key)))
+            throw new Error('Unknown attachment field');
+        if (typeof file.name !== 'string' || !file.name.trim() || file.name.length > 255 || file.name.includes('\0'))
+            throw new Error('Invalid attachment name');
+        if (typeof file.mime_type !== 'string' || file.mime_type.length > 200 || file.mime_type.includes('\0'))
+            throw new Error('Invalid attachment MIME type');
+        if (typeof file.data_base64 !== 'string' || file.data_base64.length > Math.ceil(MAX_ATTACHMENTS_BYTES / 3) * 4)
+            throw new Error('Invalid attachment data_base64');
+        if (/[/\\]/.test(file.name) || file.name === '.' || file.name === '..')
+            throw new Error('Attachment name must be a filename, not a path');
+        const data = file.data_base64;
+        if (data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(data))
+            throw new Error('Attachment data_base64 must be canonical base64');
+        // Reject non-zero pad bits too, before the server allocates decoded buffers.
+        const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+        if ((data.endsWith('==') && (alphabet.indexOf(data.at(-3)) & 15) !== 0) ||
+            (!data.endsWith('==') && data.endsWith('=') && (alphabet.indexOf(data.at(-2)) & 3) !== 0))
+            throw new Error('Attachment data_base64 must be canonical base64');
+        return {
+            name: file.name,
+            type: file.mime_type,
+            size: (data.length / 4) * 3 - (data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0),
+        };
+    });
+    const error = validateAttachments(metadata);
+    if (error)
+        throw new Error(`Invalid attachments: ${error}`);
+    return files;
+}

package/dist/shared/progress-bar-prompts.js

@@ -4,7 +4,7 @@ export const PROGRESS_BAR_PROMPT = `<kobo-progress-reporting>
 ${PROGRESS_BAR_PLAN_EXCEPTION}
 For each long-running activity (tests, audits, builds or delegated work), follow this reporting lifecycle:
 1. Call create_progress_bar with a clear label, current step and stable activity_key. Save its returned id and sequence; creating a bar is only the start of reporting.
-2. Call update_progress_bar with that id and an increasing sequence: update the same bar at each actual phase change or meaningful completed milestone, including during a long phase. Even without a measured percentage, report the current step; omit both current and total for step-only updates. Use measured numbers only when known. Never invent percentages, poll, send unchanged updates or start timer-driven reporting loops; follow tool retry guidance.
+2. Call update_progress_bar with that id and an increasing sequence: update the same bar at each actual phase change or meaningful completed milestone, including during a long phase. Even without a measured percentage, report the current step; omit both current and total for step-only updates. Use measured numbers only when known: when tests report a total or your activity has a fixed checklist, provide current and total together and advance current only as those items actually finish. A step-only update changes the label, not the gauge; null numbers mean no percentage is available. Never invent percentages, poll, send unchanged updates or start timer-driven reporting loops; follow tool retry guidance.
 3. Call finish_progress_bar on that id before your final report (or return to the parent) when the activity's succeeded/failed outcome is known. Do not declare ongoing background work finished merely because you are yielding control.
 Pass this requirement to all subagents when delegating: each reports and finishes its own long activity through inherited Kōbō MCP tools; the parent must not duplicate it. If a custom subagent lacks these tools, the parent reports its observed milestones and outcome instead. Subagents must not schedule or replace workspace wakeups; the parent coordinates follow-up.
 A dismissed bar stays hidden: continue without recreating it; dismissal is not cancellation. Reporting never substitutes for verification, and an interrupted reporter does not prove background work stopped. After resume, use new activity keys for new work; do not reopen finished activities.

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

@@ -1,6 +1,6 @@
-import { MAX_ATTACHMENTS, MAX_ATTACHMENTS_BYTES, validateAttachments } from './attachments.js';
+import { MAX_MCP_ATTACHMENT_REQUEST_BYTES, MCP_ATTACHMENTS_SCHEMA, validateMcpAttachments } from './mcp-attachments.js';
 /** Base64 expansion of the shared upload limit, plus bounded JSON metadata. */
-export const MAX_MCP_CREATION_REQUEST_BYTES = Math.ceil(MAX_ATTACHMENTS_BYTES / 3) * 4 + 1024 * 1024;
+export const MAX_MCP_CREATION_REQUEST_BYTES = MAX_MCP_ATTACHMENT_REQUEST_BYTES;
 const string = (maxLength = 200, minLength = 1) => ({ type: 'string', minLength, maxLength });
 const choice = (...values) => ({ type: 'string', enum: values });
 const object = (properties, required = []) => ({
@@ -58,11 +58,7 @@ const properties = {
     worktree_path: path,
     comparison_id: string(),
     creation_id: string(),
-    attachments: {
-        type: 'array',
-        maxItems: MAX_ATTACHMENTS,
-        items: object({ name: string(255), mime_type: string(200, 0), data_base64: string(Math.ceil(MAX_ATTACHMENTS_BYTES / 3) * 4) }, ['name', 'mime_type', 'data_base64']),
-    },
+    attachments: MCP_ATTACHMENTS_SCHEMA,
     pr_checkout: object({
         fingerprint: string(),
         decisions: object({
@@ -156,27 +152,7 @@ export function validateWorkspaceCreationArguments(name, input) {
             throw new Error('source_branch and working_branch are required unless using a PR or existing worktree');
         if (value.pr_checkout && !value.pr_url)
             throw new Error('pr_checkout requires pr_url');
-        const files = (value.attachments ?? []);
-        const metadata = files.map((file) => {
-            if (/[/\\]/.test(file.name) || file.name === '.' || file.name === '..')
-                throw new Error('Attachment name must be a filename, not a path');
-            const data = file.data_base64;
-            if (data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(data))
-                throw new Error('Attachment data_base64 must be canonical base64');
-            // Reject non-zero pad bits too, before the server allocates decoded buffers.
-            const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-            if ((data.endsWith('==') && (alphabet.indexOf(data.at(-3)) & 15) !== 0) ||
-                (!data.endsWith('==') && data.endsWith('=') && (alphabet.indexOf(data.at(-2)) & 3) !== 0))
-                throw new Error('Attachment data_base64 must be canonical base64');
-            return {
-                name: file.name,
-                type: file.mime_type,
-                size: (data.length / 4) * 3 - (data.endsWith('==') ? 2 : data.endsWith('=') ? 1 : 0),
-            };
-        });
-        const error = validateAttachments(metadata);
-        if (error)
-            throw new Error(`Invalid attachments: ${error}`);
+        validateMcpAttachments(value.attachments);
     }
     return value;
 }

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

@@ -1,3 +1,4 @@
+import { MCP_ATTACHMENTS_SCHEMA, validateMcpAttachments } from './mcp-attachments.js';
 const workspace = { type: 'string', minLength: 1, maxLength: 200, description: 'Workspace ID from list_workspaces.' };
 const session = {
     type: 'string',
@@ -27,17 +28,18 @@ export const WORKSPACE_DIALOGUE_TOOLS = [
         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.', {
+    tool('send_workspace_message', 'Send text and/or inline base64 files/images to an agent, resuming it if needed. Attachments use the same format as create_workspace (10 files, 50 MiB total). 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 },
+        content: { type: 'string', minLength: 0, maxLength: 100_000 },
+        attachments: MCP_ATTACHMENTS_SCHEMA,
         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.',
+            description: 'Generate once per intended message; reuse on retries to prevent duplicate dispatch, including after restart. Reuse with different content/session/attachments is rejected.',
         },
-    }, ['workspace_id', 'content'], false),
+    }, ['workspace_id'], 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,
@@ -62,8 +64,13 @@ export function validateDialogueArguments(name, value) {
         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))
+        if (key === 'attachments') {
+            validateMcpAttachments(input);
+        }
+        else if (property.type === 'string') {
+            if (typeof input !== 'string' ||
+                (property.minLength !== 0 && !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') {
@@ -85,5 +92,10 @@ export function validateDialogueArguments(name, value) {
             throw new Error(`${key} must be a non-empty object of string answers`);
         }
     }
+    if (name === 'send_workspace_message') {
+        if (!args.content?.trim() && !validateMcpAttachments(args.attachments).length)
+            throw new Error('Message content or attachments are required');
+        return { ...args, content: args.content ?? '' };
+    }
     return args;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "2.1.23",
+  "version": "2.1.25",
   "description": "Kōbō — local multi-workspace orchestrator for Claude Code and OpenAI Codex, with isolated Git worktrees, live review and optional automation.",
   "type": "module",
   "license": "GPL-3.0-or-later",