@loicngr/kobo 1.11.39 → 1.11.40

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

@@ -0,0 +1,128 @@
+import { nanoid } from 'nanoid';
+import { validateDialogueArguments } from '../../shared/workspace-dialogue-tools.js';
+import { parseMessageSource } from '../../shared/workspace-message-types.js';
+import { getDb } from '../db/index.js';
+import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
+import { answerPendingQuestion, getPendingInputs } from './agent/orchestrator.js';
+import { createMcpClientContext } from './mcp-client-context.js';
+import { deliverKeyedMcpMessage } from './mcp-message-delivery-service.js';
+import { deliverWorkspaceMessage } from './workspace-message-service.js';
+import { getActiveSession, getWorkspace, listSessions, listTasks, listWorkspaces } from './workspace-service.js';
+function readableMessage(row) {
+    let payload;
+    try {
+        payload = JSON.parse(row.payload);
+    }
+    catch {
+        return [];
+    }
+    if (!payload || typeof payload !== 'object')
+        return [];
+    let text;
+    if (row.type === 'user:message' && typeof payload.content === 'string')
+        text = payload.content;
+    if (row.type === 'agent:event' && payload.kind === 'message:text' && typeof payload.text === 'string')
+        text = payload.text;
+    if (row.type === 'agent:output') {
+        const content = payload.message?.content;
+        if (Array.isArray(content))
+            text = content
+                .flatMap((block) => (block?.type === 'text' && typeof block.text === 'string' ? [block.text] : []))
+                .join('\n');
+    }
+    return text === undefined
+        ? []
+        : [
+            {
+                id: row.id,
+                sessionId: row.session_id,
+                role: row.type === 'user:message' ? 'user' : 'assistant',
+                text,
+                messageId: typeof payload.messageId === 'string' ? payload.messageId : row.id,
+                createdAt: row.created_at,
+                ...(parseMessageSource(payload.source) ? { source: parseMessageSource(payload.source) } : {}),
+                ...(typeof payload.clientMessageId === 'string' ? { clientMessageId: payload.clientMessageId } : {}),
+            },
+        ];
+}
+export async function executeWorkspaceDialogueTool(name, input, source = createMcpClientContext()) {
+    const args = validateDialogueArguments(name, input);
+    if (name === 'list_workspaces')
+        return listWorkspaces(args.include_archived === true).map((ws) => ({
+            id: ws.id,
+            name: ws.name,
+            status: ws.status,
+            projectPath: ws.projectPath,
+            archivedAt: ws.archivedAt,
+        }));
+    const workspaceId = args.workspace_id;
+    const workspace = getWorkspace(workspaceId);
+    if (!workspace)
+        throw new Error(`Workspace '${workspaceId}' not found`);
+    if (name === 'get_workspace')
+        return { workspace, tasks: listTasks(workspaceId), activeSession: getActiveSession(workspaceId) };
+    if (name === 'list_workspace_sessions')
+        return listSessions(workspaceId);
+    if (name === 'get_workspace_questions') {
+        const pending = getPendingInputs(workspaceId);
+        return {
+            questions: pending.filter((item) => item.kind === 'question'),
+            requiresHumanApproval: pending[0]?.kind === 'permission',
+        };
+    }
+    if (name === 'answer_workspace_question') {
+        assertWorkspaceLifecycleAvailable(workspaceId);
+        if (workspace.archivedAt || workspace.worktreePurgedAt)
+            throw new Error('Restore the workspace before answering a question');
+        const head = getPendingInputs(workspaceId)[0];
+        if (head?.kind !== 'question' || head.toolCallId !== args.tool_call_id)
+            throw new Error('The requested question is not the current pending question');
+        await answerPendingQuestion(workspaceId, args.answers, args.tool_call_id, {
+            source,
+        });
+        return { accepted: true };
+    }
+    if (name === 'send_workspace_message' && args.idempotency_key)
+        return deliverKeyedMcpMessage(workspaceId, args.idempotency_key, {
+            content: args.content,
+            sessionId: args.session_id,
+            source,
+        });
+    if (name === 'send_workspace_message')
+        return {
+            accepted: true,
+            ...(await deliverWorkspaceMessage(workspaceId, {
+                content: args.content,
+                sessionId: args.session_id,
+                clientMessageId: `mcp-${nanoid()}`,
+                source,
+            })),
+        };
+    const db = getDb();
+    let after = 0;
+    if (args.after_cursor) {
+        const cursor = db
+            .prepare('SELECT rowid FROM ws_events WHERE id = ? AND workspace_id = ?')
+            .get(args.after_cursor, workspaceId);
+        if (!cursor)
+            throw new Error('Unknown or expired history cursor for this workspace; restart reading without after_cursor');
+        after = cursor.rowid;
+    }
+    const limit = args.limit ?? 100;
+    const params = [workspaceId, after];
+    if (args.session_id)
+        params.push(args.session_id);
+    params.push(limit + 1);
+    const rows = db
+        .prepare(`SELECT id,session_id,type,payload,created_at FROM ws_events WHERE workspace_id = ? AND rowid > ?
+    ${args.session_id ? 'AND (session_id = ? OR session_id IS NULL)' : ''} ORDER BY rowid LIMIT ?`)
+        .all(...params);
+    const page = rows.slice(0, limit);
+    return {
+        messages: page.flatMap(readableMessage),
+        nextCursor: page.at(-1)?.id ?? args.after_cursor ?? null,
+        hasMore: rows.length > limit,
+        workspaceStatus: workspace.status,
+        activeSessionId: getActiveSession(workspaceId)?.id ?? null,
+    };
+}

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

@@ -0,0 +1,58 @@
+import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
+import { isAgentUnavailableError, isShuttingDown, sendMessage, startAgent } from './agent/orchestrator.js';
+import * as autoLoop from './auto-loop-service.js';
+import { createChatReceipt } from './chat-receipt-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) {
+    const receipt = createChatReceipt(workspaceId, message, hooks?.persist);
+    let reason;
+    try {
+        if (!message.content.trim())
+            throw new Error('Message content must not be empty');
+        if (isShuttingDown())
+            throw new Error('Kōbō is shutting down');
+        assertWorkspaceLifecycleAvailable(workspaceId);
+        const workspace = getWorkspace(workspaceId);
+        if (!workspace)
+            throw new Error(`Workspace '${workspaceId}' not found`);
+        if (workspace.archivedAt || workspace.worktreePurgedAt)
+            throw new Error('Restore the workspace before sending a message');
+        if (workspace.status === 'compacting') {
+            reason = 'compacting';
+            throw new Error('Workspace is compacting its context; wait until compaction finishes before sending a message');
+        }
+        if (workspace.status === 'awaiting-user') {
+            reason = 'awaiting-user';
+            throw new Error('Answer the pending question or permission request before sending a chat message');
+        }
+        const loop = autoLoop.getStatus(workspaceId);
+        if (loop.auto_loop && loop.auto_loop_ready)
+            autoLoop.disable(workspaceId, 'user-action');
+        let sessionId = message.sessionId ?? getActiveSession(workspaceId)?.id;
+        try {
+            if (hooks?.beforeDispatch)
+                await sendMessage(workspaceId, message.content, message.sessionId, hooks.beforeDispatch);
+            else
+                await sendMessage(workspaceId, message.content, message.sessionId);
+        }
+        catch (error) {
+            if (!isAgentUnavailableError(error instanceof Error ? error.message : String(error)))
+                throw error;
+            // Re-read after asynchronous delivery: metadata may have changed meanwhile.
+            assertWorkspaceLifecycleAvailable(workspaceId);
+            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] : []));
+            updateWorkspaceStatus(workspaceId, 'executing');
+            sessionId = message.sessionId ?? started.agentSessionId;
+        }
+        receipt.accept(sessionId);
+        return { sessionId };
+    }
+    catch (error) {
+        receipt.reject(error instanceof Error ? error.message : String(error), reason);
+        throw error;
+    }
+}

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

@@ -27,8 +27,33 @@ function stable(value) {
 export function permissionFingerprint(payload) {
     return createHash('sha256').update(stable(payload)).digest('hex');
 }
+const CODEX_EDIT_FINGERPRINT_PREFIX = 'codex-edit-v2:';
+function operationFingerprint(request) {
+    if (request.engine !== 'codex' || request.toolName !== 'Edit')
+        return permissionFingerprint(request.payload);
+    const payload = request.payload;
+    if (payload?.operationApprovalAvailable !== true || !Array.isArray(payload.changes) || payload.changes.length === 0)
+        return null;
+    if (typeof payload.cwd !== 'string' ||
+        payload.changes.some((change) => !change ||
+            typeof change.path !== 'string' ||
+            typeof change.diff !== 'string' ||
+            !change.kind ||
+            !['add', 'delete', 'update'].includes(change.kind.type)))
+        return null;
+    return (CODEX_EDIT_FINGERPRINT_PREFIX +
+        permissionFingerprint({
+            changes: payload.changes,
+            cwd: payload.cwd,
+            grantRoot: payload.grantRoot ?? null,
+        }));
+}
 function toRule(row) {
     return {
+        active: !(row.scope === 'operation' &&
+            row.tool_name === 'Edit' &&
+            (row.engine ?? row.workspace_engine) === 'codex' &&
+            !String(row.fingerprint ?? '').startsWith(CODEX_EDIT_FINGERPRINT_PREFIX)),
         id: String(row.id),
         workspaceId: String(row.workspace_id),
         engine: row.engine,
@@ -42,13 +67,17 @@ function toRule(row) {
 }
 export function listWorkspacePermissionRules(workspaceId) {
     return getDb()
-        .prepare('SELECT * FROM workspace_permission_rules WHERE workspace_id=? ORDER BY created_at DESC')
+        .prepare(`SELECT rules.*, workspaces.engine AS workspace_engine
+        FROM workspace_permission_rules AS rules JOIN workspaces ON workspaces.id=rules.workspace_id
+        WHERE workspace_id=? ORDER BY rules.created_at DESC`)
         .all(workspaceId).map(toRule);
 }
 export function createWorkspacePermissionRule(workspaceId, request, scope) {
     const now = new Date().toISOString();
     const id = nanoid();
-    const fingerprint = scope === 'operation' ? permissionFingerprint(request.payload) : null;
+    const fingerprint = scope === 'operation' ? operationFingerprint(request) : null;
+    if (scope === 'operation' && fingerprint === null)
+        throw new Error('Exact operation details are unavailable');
     const displayLabel = scope === 'tool' ? request.toolName : `${request.toolName} — opération précise`;
     getDb()
         .prepare('INSERT INTO workspace_permission_rules (id,workspace_id,engine,tool_name,scope,fingerprint,display_label,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?)')
@@ -61,6 +90,7 @@ export function createWorkspacePermissionRule(workspaceId, request, scope) {
         scope,
         fingerprint,
         displayLabel,
+        active: true,
         createdAt: now,
         updatedAt: now,
     };
@@ -72,7 +102,7 @@ export function removeWorkspacePermissionRule(workspaceId, ruleId) {
 export function isWorkspacePermissionAllowed(workspaceId, request) {
     if (turnRules.get(workspaceId)?.has(turnKey(request)))
         return true;
-    const fingerprint = permissionFingerprint(request.payload);
+    const fingerprint = operationFingerprint(request);
     try {
         return Boolean(getDb()
             .prepare(`SELECT 1 FROM workspace_permission_rules WHERE workspace_id=? AND tool_name=? AND (engine IS NULL OR engine=?) AND (scope='tool' OR (scope='operation' AND fingerprint=?)) LIMIT 1`)

package/dist/server/services/worktree-restore-service.js

@@ -43,13 +43,13 @@ export async function restorePurgedWorktree(id) {
                     headCommitSha: savedHead(workspace.worktreePurgeRestoreData),
                 };
                 if (!workspace.worktreePurgedAt) {
-                    if (!isMatchingWorkspaceWorktree(input)) {
+                    if (!(await isMatchingWorkspaceWorktree(input))) {
                         throw new WorktreeRestoreError('not-purged', 'Workspace is not marked as purged and its checkout is missing or different.');
                     }
                     return { workspace, outcome: 'already-restored', source: 'existing-worktree' };
                 }
                 const checkout = await restoreWorktreeCheckoutUnlocked(input);
-                if (!isMatchingWorkspaceWorktree(input)) {
+                if (!(await isMatchingWorkspaceWorktree(input))) {
                     throw new WorktreeRestoreError('path-conflict', 'The recreated checkout does not match this workspace.');
                 }
                 // Preserve a valid checkout on DB failure. A retry or manual detection can