@loicngr/kobo 1.7.6 → 1.7.8

package/dist/server/routes/workspaces.js

@@ -42,18 +42,16 @@ function isAgentPermissionMode(value) {
  *
  * Cascade: explicit body field → global default (validated) → 'bypass'.
  *
- * Legacy `defaultPermissionMode` values ('plan' / 'auto-accept') are honored:
- * 'plan' stays 'plan'; 'auto-accept' falls through to 'bypass' (the safest
- * non-plan default — matches the pre-refactor "skip prompts" behaviour).
+ * The per-engine default lives in `defaultPermissionModeByEngine[engineId]`
+ * (added in settings v20). If the engine id is missing or its entry is invalid,
+ * we fall back to 'bypass' (the safest non-plan default).
  */
-function resolveCreateAgentPermissionMode(bodyValue, _projectPath, globalSettings) {
+function resolveCreateAgentPermissionMode(bodyValue, _projectPath, globalSettings, engineId) {
     if (isAgentPermissionMode(bodyValue))
         return bodyValue;
-    const global = globalSettings.defaultPermissionMode;
+    const global = globalSettings.defaultPermissionModeByEngine?.[engineId];
     if (isAgentPermissionMode(global))
         return global;
-    if (global === 'plan')
-        return 'plan';
     return 'bypass';
 }
 app.get('/', (c) => {
@@ -82,10 +80,25 @@ app.post('/', migrationGuard, async (c) => {
         // engine is rejected up-front so we don't create orphan workspaces that
         // can't spawn an agent.
         if (body.engine) {
-            const validEngineIds = listEngines().map((e) => e.id);
+            const engines = listEngines();
+            const validEngineIds = engines.map((e) => e.id);
             if (!validEngineIds.includes(body.engine)) {
                 return c.json({ error: `Unknown engine '${body.engine}'. Valid engines: ${validEngineIds.join(', ')}` }, 400);
             }
+            // Cross-validate engine × permission mode: each engine declares which
+            // modes it supports via `capabilities.permissionModes`. The UI already
+            // filters, but API consumers can still send any combo. Reject up-front
+            // so we don't park workspaces in a permanently broken state (e.g. Codex
+            // workspaces with `interactive` mode hang on the first tool call).
+            if (body.agentPermissionMode) {
+                const engine = engines.find((e) => e.id === body.engine);
+                const supported = engine?.capabilities.permissionModes ?? [];
+                if (!supported.includes(body.agentPermissionMode)) {
+                    return c.json({
+                        error: `Engine '${body.engine}' does not support agentPermissionMode '${body.agentPermissionMode}'. Supported: ${supported.join(', ')}`,
+                    }, 400);
+                }
+            }
         }
         // Fetch the source branch from origin first — if this fails, block creation
         // immediately (no DB records created, user stays on the create page).
@@ -222,7 +235,7 @@ app.post('/', migrationGuard, async (c) => {
             worktreeOwned: !useReusedWorktree,
             model: body.model,
             reasoningEffort: body.reasoningEffort,
-            agentPermissionMode: resolveCreateAgentPermissionMode(body.agentPermissionMode, body.projectPath, globalSettings),
+            agentPermissionMode: resolveCreateAgentPermissionMode(body.agentPermissionMode, body.projectPath, globalSettings, body.engine ?? 'claude-code'),
             engine: body.engine,
             ...(useReusedWorktree ? {} : { worktreesPath: globalSettings.worktreesPath }),
         });
@@ -1451,6 +1464,17 @@ app.patch('/:id', migrationGuard, async (c) => {
             if (!isAgentPermissionMode(body.agentPermissionMode)) {
                 return c.json({ error: `Invalid agentPermissionMode. Must be one of: ${VALID_AGENT_PERMISSION_MODES.join(', ')}` }, 400);
             }
+            // Cross-validate against the engine's declared capabilities — see the
+            // POST route for the same guard. Prevents parking a workspace in a mode
+            // its engine cannot honour.
+            const engineId = workspace.engine;
+            const engine = listEngines().find((e) => e.id === engineId);
+            const supported = engine?.capabilities.permissionModes ?? [];
+            if (engine && !supported.includes(body.agentPermissionMode)) {
+                return c.json({
+                    error: `Engine '${engineId}' does not support agentPermissionMode '${body.agentPermissionMode}'. Supported: ${supported.join(', ')}`,
+                }, 400);
+            }
             updated = workspaceService.updateAgentPermissionMode(id, body.agentPermissionMode);
         }
         if (body.status) {

package/dist/server/services/agent/engines/claude-code/capabilities.js

@@ -4,14 +4,21 @@ export const CLAUDE_CODE_CAPABILITIES = {
     // ONE source of truth, consumed both by this file (for /api/engines and
     // for validation in POST /api/workspaces) and by the frontend selectors.
     models: CLAUDE_MODELS.map((m) => ({ id: m.id, label: m.label })),
+    // Reasoning effort values passed verbatim via `options.extraArgs.effort` to
+    // the Claude SDK. `auto` is a Kōbō sentinel meaning "let the SDK pick its
+    // default" (we omit the arg).
     effortLevels: [
         { id: 'auto', label: 'Auto' },
         { id: 'low', label: 'Low' },
         { id: 'medium', label: 'Medium' },
         { id: 'high', label: 'High' },
+        { id: 'xhigh', label: 'Extra High' },
+        { id: 'max', label: 'Max' },
     ],
     permissionModes: ['plan', 'bypass', 'strict', 'interactive'],
     supportsResume: true,
     supportsMcp: true,
     supportsSkills: true,
+    supportsSubagents: true,
+    supportsQuotaStatus: true,
 };

package/dist/server/services/agent/engines/codex/capabilities.js

@@ -0,0 +1,18 @@
+import { CODEX_MODELS } from '../../../../../shared/codex-models.js';
+export const CODEX_CAPABILITIES = {
+    models: CODEX_MODELS.map((m) => ({ id: m.id, label: m.label })),
+    effortLevels: [
+        { id: 'auto', label: 'Auto' },
+        { id: 'minimal', label: 'Minimal' },
+        { id: 'low', label: 'Low' },
+        { id: 'medium', label: 'Medium' },
+        { id: 'high', label: 'High' },
+        { id: 'xhigh', label: 'Extra High' },
+    ],
+    permissionModes: ['plan', 'bypass', 'strict', 'interactive'],
+    supportsResume: true,
+    supportsMcp: true,
+    supportsSkills: false,
+    supportsSubagents: true,
+    supportsQuotaStatus: true,
+};

package/dist/server/services/agent/engines/codex/client.js

@@ -0,0 +1,36 @@
+import { createJsonRpcPeer } from './jsonrpc/peer.js';
+export function createAppServerClient(opts) {
+    const peer = createJsonRpcPeer({
+        stdin: opts.stdin,
+        stdout: opts.stdout,
+        onNotification: opts.onNotification ?? (() => { }),
+        onServerRequest: opts.onServerRequest ?? (() => { }),
+        onError: opts.onError,
+    });
+    return {
+        peer,
+        async connect() {
+            // Without experimentalApi the server rejects collaborationMode (-32600).
+            const params = {
+                clientInfo: opts.clientInfo,
+                capabilities: { experimentalApi: true },
+            };
+            return peer.request('initialize', params);
+        },
+        startThread(params) {
+            return peer.request('thread/start', params);
+        },
+        resumeThread(params) {
+            return peer.request('thread/resume', params);
+        },
+        startTurn(params) {
+            return peer.request('turn/start', params);
+        },
+        async interruptTurn(params) {
+            await peer.request('turn/interrupt', params);
+        },
+        close() {
+            peer.close();
+        },
+    };
+}

package/dist/server/services/agent/engines/codex/engine.js

@@ -0,0 +1,276 @@
+import { getPackageVersion } from '../../../../utils/paths.js';
+import { CODEX_CAPABILITIES } from './capabilities.js';
+import { createAppServerClient } from './client.js';
+import { createMapperState, emitSessionStarted, handleAgentMessageDelta, handleItemCompleted, handleItemStarted, handleRateLimitsUpdated, handleTurnCompleted, QUOTA_PATTERN, tryEmitQuota, } from './event-mapper.js';
+import { buildCodexOptions } from './options-builder.js';
+import { buildResponseForResolve, handleServerRequest } from './server-requests.js';
+import { spawnAppServer } from './spawn.js';
+/**
+ * Heuristic for detecting a stale/expired thread id on `thread/resume`.
+ * Canonical wording isn't captured yet — when matched, the engine emits
+ * `error/resume_failed` so the orchestrator can restart with a fresh thread.
+ */
+export const RESUME_FAILED_PATTERN = /(thread\b.*\bnot found|session\b.*\bnot found|no\s+(such\s+)?thread|thread.*expired|conversation\b.*\bnot found|invalid\s+thread\s+id)/i;
+export function createCodexEngine() {
+    return {
+        id: 'codex',
+        displayName: 'OpenAI Codex',
+        capabilities: CODEX_CAPABILITIES,
+        async start(options, onEvent) {
+            const { threadParams, input, isResume, collaborationMode } = buildCodexOptions({
+                prompt: options.prompt,
+                model: options.model,
+                effort: options.effort,
+                agentPermissionMode: options.agentPermissionMode ?? 'bypass',
+                resumeFromEngineSessionId: options.resumeFromEngineSessionId,
+                workingDir: options.workingDir,
+                mcpServers: options.mcpServers,
+            });
+            const mapperState = createMapperState();
+            const abortController = new AbortController();
+            const pendingByCallId = new Map();
+            let iteratorRunning = false;
+            let userInterrupted = false;
+            let discoveredSessionId = options.resumeFromEngineSessionId;
+            const safeEmit = (ev) => {
+                try {
+                    onEvent(ev);
+                }
+                catch (err) {
+                    console.error('[codex-engine] onEvent handler threw:', err);
+                }
+            };
+            const child = spawnAppServer({ cwd: options.workingDir, signal: abortController.signal });
+            if (child.stderr) {
+                child.stderr.setEncoding('utf8');
+                child.stderr.on('data', (chunk) => {
+                    const text = chunk.toString();
+                    if (QUOTA_PATTERN.test(text)) {
+                        tryEmitQuota(mapperState, safeEmit, text.trim());
+                    }
+                    else {
+                        console.warn('[codex] stderr:', text.trimEnd());
+                    }
+                });
+            }
+            let resolveTurnDone;
+            let rejectTurnDone;
+            const turnDonePromise = new Promise((resolve, reject) => {
+                resolveTurnDone = resolve;
+                rejectTurnDone = reject;
+            });
+            abortController.signal.addEventListener('abort', () => {
+                const err = new Error('AbortError');
+                err.name = 'AbortError';
+                rejectTurnDone(err);
+            });
+            const client = createAppServerClient({
+                stdin: child.stdin,
+                stdout: child.stdout,
+                clientInfo: { name: 'kobo', version: getPackageVersion() },
+                onNotification(method, params) {
+                    // Ignored notifications — harmless bookkeeping by the server
+                    if (method === 'mcpServer/startupStatus/updated' ||
+                        method === 'thread/started' ||
+                        method === 'thread/status/changed' ||
+                        method === 'remoteControl/status/changed' ||
+                        method === 'turn/started') {
+                        return;
+                    }
+                    if (method === 'item/started') {
+                        const n = params;
+                        for (const ev of handleItemStarted(n.item, mapperState))
+                            safeEmit(ev);
+                        return;
+                    }
+                    if (method === 'item/completed') {
+                        const n = params;
+                        for (const ev of handleItemCompleted(n.item, mapperState))
+                            safeEmit(ev);
+                        return;
+                    }
+                    if (method === 'item/agentMessage/delta') {
+                        const n = params;
+                        for (const ev of handleAgentMessageDelta(n, mapperState))
+                            safeEmit(ev);
+                        return;
+                    }
+                    if (method === 'turn/completed') {
+                        const n = params;
+                        for (const ev of handleTurnCompleted(n, mapperState))
+                            safeEmit(ev);
+                        resolveTurnDone();
+                        return;
+                    }
+                    if (method === 'thread/tokenUsage/updated') {
+                        const p = params;
+                        if (p?.tokenUsage?.last) {
+                            const last = p.tokenUsage.last;
+                            safeEmit({
+                                kind: 'usage',
+                                inputTokens: last.inputTokens,
+                                outputTokens: last.outputTokens + last.reasoningOutputTokens,
+                                cacheRead: last.cachedInputTokens,
+                            });
+                        }
+                        return;
+                    }
+                    if (method === 'account/rateLimits/updated') {
+                        for (const ev of handleRateLimitsUpdated(params, mapperState))
+                            safeEmit(ev);
+                        return;
+                    }
+                    if (method === 'error') {
+                        const n = params;
+                        const msg = n?.message ?? 'unknown error';
+                        if (QUOTA_PATTERN.test(msg)) {
+                            tryEmitQuota(mapperState, safeEmit, msg);
+                        }
+                        else {
+                            mapperState.sawErrorResult = true;
+                            safeEmit({ kind: 'error', category: 'other', message: msg });
+                        }
+                        return;
+                    }
+                },
+                onServerRequest(id, method, params) {
+                    handleServerRequest({
+                        requestId: id,
+                        method,
+                        params,
+                        emit: safeEmit,
+                        register(callId, pending) {
+                            pendingByCallId.set(callId, pending);
+                        },
+                        respondError: (reqId, code, message) => client.peer.respondError(reqId, code, message),
+                    });
+                },
+                onError(err) {
+                    console.error('[codex] JSON-RPC transport error:', err);
+                    rejectTurnDone(err);
+                },
+            });
+            const iteratorPromise = (async () => {
+                iteratorRunning = true;
+                try {
+                    await client.connect();
+                    if (isResume && options.resumeFromEngineSessionId) {
+                        await client.resumeThread({
+                            threadId: options.resumeFromEngineSessionId,
+                            cwd: options.workingDir,
+                            persistExtendedHistory: false,
+                            ...(threadParams.model != null ? { model: threadParams.model } : {}),
+                            ...(threadParams.approvalPolicy != null ? { approvalPolicy: threadParams.approvalPolicy } : {}),
+                            ...(threadParams.sandbox != null ? { sandbox: threadParams.sandbox } : {}),
+                            ...(threadParams.modelReasoningEffort != null
+                                ? { modelReasoningEffort: threadParams.modelReasoningEffort }
+                                : {}),
+                            ...(threadParams.config != null ? { config: threadParams.config } : {}),
+                        });
+                    }
+                    else {
+                        const startResp = await client.startThread(threadParams);
+                        discoveredSessionId = startResp.thread.id;
+                    }
+                    for (const ev of emitSessionStarted(discoveredSessionId, mapperState))
+                        safeEmit(ev);
+                    // collaborationMode is sticky server-side — always send it explicitly,
+                    // never omit (would leave a Bypass turn stuck in a previous Plan mode).
+                    await client.startTurn({
+                        threadId: discoveredSessionId,
+                        input,
+                        collaborationMode,
+                    });
+                    await turnDonePromise;
+                    const reason = mapperState.sawErrorResult
+                        ? 'error'
+                        : mapperState.sawTurnInterrupted
+                            ? 'killed'
+                            : 'completed';
+                    safeEmit({
+                        kind: 'session:ended',
+                        reason,
+                        exitCode: reason === 'completed' ? 0 : null,
+                    });
+                }
+                catch (err) {
+                    const error = err;
+                    const message = error.message ?? String(err);
+                    const isAbort = userInterrupted || error.name === 'AbortError' || abortController.signal.aborted;
+                    const isResumeAttempt = options.resumeFromEngineSessionId !== undefined;
+                    if (isAbort) {
+                        safeEmit({ kind: 'session:ended', reason: 'killed', exitCode: null });
+                    }
+                    else if (QUOTA_PATTERN.test(message)) {
+                        tryEmitQuota(mapperState, safeEmit, message);
+                        safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
+                    }
+                    else if (isResumeAttempt && RESUME_FAILED_PATTERN.test(message)) {
+                        safeEmit({ kind: 'error', category: 'resume_failed', message });
+                        safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
+                    }
+                    else {
+                        safeEmit({ kind: 'error', category: 'spawn_failed', message });
+                        safeEmit({ kind: 'session:ended', reason: 'error', exitCode: null });
+                    }
+                }
+                finally {
+                    iteratorRunning = false;
+                    client.close();
+                    try {
+                        child.kill('SIGTERM');
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+            })();
+            const engineProcess = {
+                get pid() {
+                    return child.pid;
+                },
+                get engineSessionId() {
+                    return discoveredSessionId;
+                },
+                isAlive() {
+                    return iteratorRunning;
+                },
+                sendMessage() {
+                    throw new Error('sendMessage not supported in Codex app-server single-shot mode');
+                },
+                interrupt() {
+                    userInterrupted = true;
+                    abortController.abort();
+                    if (discoveredSessionId) {
+                        client.interruptTurn({ threadId: discoveredSessionId }).catch(() => { });
+                    }
+                },
+                async stop() {
+                    abortController.abort();
+                    try {
+                        await iteratorPromise;
+                    }
+                    catch {
+                        // swallow — best effort
+                    }
+                    try {
+                        child.stdin?.end();
+                    }
+                    catch {
+                        // swallow
+                    }
+                },
+                resolvePendingUserInput(callId, response) {
+                    const pending = pendingByCallId.get(callId);
+                    if (!pending)
+                        return false;
+                    pendingByCallId.delete(callId);
+                    const result = buildResponseForResolve(pending, response);
+                    client.peer.respond(pending.requestId, result);
+                    return true;
+                },
+            };
+            return engineProcess;
+        },
+    };
+}