@loicngr/kobo 1.11.6 → 1.11.8

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.11.8
+
+- fix(whip): preserve delivery and shortcut handling (#24)
+
+## 1.11.7
+
+- feat: add opt-in interactive whip (#23)
+
 ## 1.11.6
 
 - fix(git): continue paused operations

package/dist/server/routes/workspaces.js

@@ -51,6 +51,14 @@ const VALID_AGENT_PERMISSION_MODES = ['plan', 'bypass', 'strict', 'interactive']
 function isAgentPermissionMode(value) {
     return typeof value === 'string' && VALID_AGENT_PERMISSION_MODES.includes(value);
 }
+async function deliverAgentPrompt(workspace, workingDir, prompt) {
+    const delivery = await agentManager.sendMessageForFallback(workspace.id, prompt);
+    if (delivery.status === 'sent')
+        return { agentSessionId: delivery.sessionId };
+    const agent = agentManager.startAgent(workspace.id, workingDir, prompt, workspace.model, true, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
+    workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
+    return { agentSessionId: agent.agentSessionId };
+}
 /**
  * Resolve the unified permission mode for a new workspace.
  *
@@ -3138,24 +3146,16 @@ app.post('/:id/git/commit-with-agent', migrationGuard, async (c) => {
 5. Do NOT push the branch.
 
 When finished, report the commit SHA, its message, the files included, and the checks you ran.`;
-        const session = workspaceService.getActiveSession(workspace.id);
-        wsService.emit(workspace.id, 'user:message', { content: prompt, sender: 'user' }, session?.id ?? undefined);
         wakeupService.cancel(workspace.id, 'user-message');
         let messageSent = false;
         try {
-            agentManager.sendMessage(workspace.id, prompt);
+            const { agentSessionId } = await deliverAgentPrompt(workspace, workspace.worktreePath, prompt);
             messageSent = true;
+            wsService.emit(workspace.id, 'user:message', { content: prompt, sender: 'user' }, agentSessionId);
         }
-        catch {
-            try {
-                agentManager.startAgent(workspace.id, workspace.worktreePath, prompt, workspace.model, true, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
-                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
-                messageSent = true;
-            }
-            catch (resumeErr) {
-                const message = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
-                return c.json({ error: `Unable to ask the agent to commit: ${message}` }, 409);
-            }
+        catch (deliveryErr) {
+            const message = deliveryErr instanceof Error ? deliveryErr.message : String(deliveryErr);
+            return c.json({ error: `Unable to ask the agent to commit: ${message}` }, 409);
         }
         return c.json({ ok: true, messageSent });
     }
@@ -3229,27 +3229,18 @@ ${fileList}
 6. Report the summary: which files you touched, the key decisions you made, and the final test result.${cherryPickNote}
 
 Start now.`;
-        // Persist the prompt in the chat feed so the user sees what was dispatched.
-        const session = workspaceService.getActiveSession(workspace.id);
-        wsService.emit(workspace.id, 'user:message', { content: prompt, sender: 'user' }, session?.id ?? undefined);
         // Cancel any pending wakeup: the user is driving this turn, the
         // scheduler should not also wake the agent a few minutes later.
         wakeupService.cancel(workspace.id, 'user-message');
         let messageSent = false;
         try {
-            agentManager.sendMessage(workspace.id, prompt);
+            const { agentSessionId } = await deliverAgentPrompt(workspace, worktreePath, prompt);
             messageSent = true;
+            wsService.emit(workspace.id, 'user:message', { content: prompt, sender: 'user' }, agentSessionId);
         }
-        catch {
-            try {
-                agentManager.startAgent(workspace.id, worktreePath, prompt, workspace.model, true, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
-                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
-                messageSent = true;
-            }
-            catch (resumeErr) {
-                const resumeMsg = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
-                console.warn(`[workspaces] resolve-with-agent: agent resume failed: ${resumeMsg}`);
-            }
+        catch (deliveryErr) {
+            const deliveryMessage = deliveryErr instanceof Error ? deliveryErr.message : String(deliveryErr);
+            console.warn(`[workspaces] resolve-with-agent: agent resume failed: ${deliveryMessage}`);
         }
         return c.json({ ok: true, operation, files, messageSent });
     }
@@ -3524,29 +3515,18 @@ app.post('/:id/open-pr', async (c) => {
             diffStats,
             tasks,
         });
-        // Emit user:message into the chat feed
-        const session = workspaceService.getActiveSession(workspace.id);
-        wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, session?.id ?? undefined);
         // Cancel any pending wakeup: the user is driving this turn.
         wakeupService.cancel(workspace.id, 'user-message');
         // Send to the running agent, or resume the agent with the PR prompt
         let messageSent = false;
         try {
-            agentManager.sendMessage(workspace.id, rendered);
+            const { agentSessionId } = await deliverAgentPrompt(workspace, workspace.worktreePath, rendered);
             messageSent = true;
+            wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, agentSessionId);
         }
-        catch {
-            // Agent not running — resume it with the PR prompt
-            try {
-                const worktreePathForResume = workspace.worktreePath;
-                agentManager.startAgent(workspace.id, worktreePathForResume, rendered, workspace.model, true, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
-                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
-                messageSent = true;
-            }
-            catch (resumeErr) {
-                const resumeMsg = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
-                console.warn(`[workspaces] open-pr: PR created but agent resume failed: ${resumeMsg}`);
-            }
+        catch (deliveryErr) {
+            const deliveryMessage = deliveryErr instanceof Error ? deliveryErr.message : String(deliveryErr);
+            console.warn(`[workspaces] open-pr: PR created but agent resume failed: ${deliveryMessage}`);
         }
         return c.json({ ok: true, prNumber, prUrl, messageSent });
     }
@@ -3636,20 +3616,13 @@ app.post('/:id/start-review', async (c) => {
             const session = workspaceService.getActiveSession(workspace.id);
             emitSessionId = session?.id;
             try {
-                agentManager.sendMessage(workspace.id, rendered);
+                const delivery = await deliverAgentPrompt(workspace, worktreePath, rendered);
+                emitSessionId = delivery.agentSessionId;
                 messageSent = true;
             }
-            catch {
-                try {
-                    const agent = agentManager.startAgent(workspace.id, worktreePath, rendered, workspace.model, true /* resume */, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
-                    workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
-                    emitSessionId = agent?.agentSessionId ?? emitSessionId;
-                    messageSent = true;
-                }
-                catch (resumeErr) {
-                    const msg = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
-                    return c.json({ error: `Failed to dispatch review prompt: ${msg}` }, 500);
-                }
+            catch (deliveryErr) {
+                const message = deliveryErr instanceof Error ? deliveryErr.message : String(deliveryErr);
+                return c.json({ error: `Failed to dispatch review prompt: ${message}` }, 500);
             }
         }
         // Emit AFTER dispatch so the user:message lands in the correct session id —
@@ -3713,18 +3686,12 @@ app.post('/:id/start-ci-fix', migrationGuard, async (c) => {
         const session = workspaceService.getActiveSession(workspace.id);
         let emitSessionId = session?.id;
         try {
-            agentManager.sendMessage(workspace.id, rendered);
+            const delivery = await deliverAgentPrompt(workspace, workspace.worktreePath, rendered);
+            emitSessionId = delivery.agentSessionId;
         }
-        catch {
-            try {
-                const agent = agentManager.startAgent(workspace.id, workspace.worktreePath, rendered, workspace.model, true /* resume */, workspace.agentPermissionMode, undefined, workspace.reasoningEffort);
-                workspaceService.updateWorkspaceStatus(workspace.id, 'executing');
-                emitSessionId = agent?.agentSessionId ?? emitSessionId;
-            }
-            catch (resumeErr) {
-                const msg = resumeErr instanceof Error ? resumeErr.message : String(resumeErr);
-                return c.json({ error: `Failed to dispatch CI-fix prompt: ${msg}` }, 500);
-            }
+        catch (deliveryErr) {
+            const message = deliveryErr instanceof Error ? deliveryErr.message : String(deliveryErr);
+            return c.json({ error: `Failed to dispatch CI-fix prompt: ${message}` }, 500);
         }
         wsService.emit(workspace.id, 'user:message', { content: rendered, sender: 'user' }, emitSessionId);
         return c.json({ ok: true, failedChecksCount: failedChecks.length });
@@ -3836,18 +3803,49 @@ app.post('/:id/stop', migrationGuard, (c) => {
     }
 });
 // POST /api/workspaces/:id/interrupt — soft-interrupt agent (SIGINT, like Escape in Claude Code)
-app.post('/:id/interrupt', migrationGuard, (c) => {
+app.post('/:id/interrupt', migrationGuard, async (c) => {
     try {
         const id = c.req.param('id');
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace) {
             return c.json({ error: `Workspace '${id}' not found` }, 404);
         }
-        agentManager.interruptAgent(id);
+        const rawBody = await c.req.text();
+        let body = {};
+        if (rawBody.trim().length > 0) {
+            let parsed;
+            try {
+                parsed = JSON.parse(rawBody);
+            }
+            catch {
+                return c.json({ error: 'Request body must be valid JSON' }, 400);
+            }
+            if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                return c.json({ error: 'Request body must be a JSON object' }, 400);
+            }
+            body = parsed;
+        }
+        if (body.expectedSessionId !== undefined &&
+            (typeof body.expectedSessionId !== 'string' || body.expectedSessionId.trim().length === 0)) {
+            return c.json({ error: 'expectedSessionId must be a non-empty string when provided' }, 400);
+        }
+        if (body.disableAutoLoop !== undefined && typeof body.disableAutoLoop !== 'boolean') {
+            return c.json({ error: 'disableAutoLoop must be a boolean when provided' }, 400);
+        }
+        const options = {};
+        if (body.expectedSessionId !== undefined)
+            options.expectedSessionId = body.expectedSessionId;
+        if (body.disableAutoLoop !== undefined)
+            options.disableAutoLoop = body.disableAutoLoop;
+        agentManager.interruptAgent(id, options);
         return c.json({ status: 'interrupted' });
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
+        if (err instanceof agentManager.InterruptAgentError) {
+            const status = err.code === 'interrupt_failed' ? 500 : 409;
+            return c.json({ error: message, code: err.code }, status);
+        }
         return c.json({ error: message }, 500);
     }
 });

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

@@ -50,6 +50,14 @@ export function createCodexEngine() {
             let activeTurnId;
             let steerChain = Promise.resolve();
             let gracefulInterruptPromise;
+            let readySettled = false;
+            let resolveReady;
+            let rejectReady;
+            const readyPromise = new Promise((resolve, reject) => {
+                resolveReady = resolve;
+                rejectReady = reject;
+            });
+            void readyPromise.catch(() => { });
             const emitDirect = (ev) => {
                 try {
                     onEvent(ev);
@@ -60,7 +68,26 @@ export function createCodexEngine() {
             };
             const streamingBatcher = createStreamingBatcher(emitDirect);
             const safeEmit = (ev) => streamingBatcher.push(ev);
+            let rejectChildFailure;
+            const childFailurePromise = new Promise((_resolve, reject) => {
+                rejectChildFailure = reject;
+            });
+            void childFailurePromise.catch(() => { });
             const child = spawnAppServer({ cwd: options.workingDir, env: options.env, signal: abortController.signal });
+            child.on('error', (error) => {
+                const isExpectedAbort = abortController.signal.aborted && (error.code === 'ABORT_ERR' || error.name === 'AbortError');
+                if (isExpectedAbort)
+                    return;
+                console.error('[codex] child process error:', error);
+                rejectChildFailure(error);
+            });
+            child.once('exit', (code, signal) => {
+                if (!iteratorRunning || abortController.signal.aborted)
+                    return;
+                const detail = code === null ? `signal ${signal ?? 'unknown'}` : `code ${code}`;
+                rejectChildFailure(new Error(`Codex app-server exited unexpectedly with ${detail}`));
+            });
+            const waitForChild = (operation) => Promise.race([operation, childFailurePromise]);
             if (child.stderr) {
                 child.stderr.setEncoding('utf8');
                 child.stderr.on('data', (chunk) => {
@@ -87,6 +114,7 @@ export function createCodexEngine() {
                     rejectTurnDone(new CodexTurnTimeoutError());
                 },
             });
+            void turnDonePromise.catch(() => { });
             abortController.signal.addEventListener('abort', () => {
                 const err = new Error('AbortError');
                 err.name = 'AbortError';
@@ -199,9 +227,9 @@ export function createCodexEngine() {
             const iteratorPromise = (async () => {
                 iteratorRunning = true;
                 try {
-                    await client.connect();
+                    await waitForChild(client.connect());
                     if (isResume && options.resumeFromEngineSessionId) {
-                        await client.resumeThread({
+                        await waitForChild(client.resumeThread({
                             threadId: options.resumeFromEngineSessionId,
                             cwd: options.workingDir,
                             persistExtendedHistory: false,
@@ -212,24 +240,26 @@ export function createCodexEngine() {
                                 ? { modelReasoningEffort: threadParams.modelReasoningEffort }
                                 : {}),
                             ...(threadParams.config != null ? { config: threadParams.config } : {}),
-                        });
+                        }));
                     }
                     else {
-                        const startResp = await client.startThread(threadParams);
+                        const startResp = await waitForChild(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).
-                    const initialTurn = await client.startTurn({
+                    const initialTurn = await waitForChild(client.startTurn({
                         threadId: discoveredSessionId,
                         input,
                         collaborationMode,
-                    });
+                    }));
                     activeTurnId = initialTurn.turnId;
                     turnLiveness.start();
-                    await turnDonePromise;
+                    readySettled = true;
+                    resolveReady();
+                    await waitForChild(turnDonePromise);
                     turnLiveness.stop();
                     const reason = mapperState.sawErrorResult
                         ? 'error'
@@ -246,6 +276,10 @@ export function createCodexEngine() {
                     turnLiveness.stop();
                     const error = err;
                     const message = error.message ?? String(err);
+                    if (!readySettled) {
+                        readySettled = true;
+                        rejectReady(error);
+                    }
                     const isAbort = userInterrupted || error.name === 'AbortError' || abortController.signal.aborted;
                     const isResumeAttempt = options.resumeFromEngineSessionId !== undefined;
                     if (isAbort) {
@@ -292,6 +326,7 @@ export function createCodexEngine() {
                 },
                 sendMessage(text) {
                     const steer = async () => {
+                        await readyPromise;
                         if (!discoveredSessionId || !activeTurnId) {
                             throw new Error('Codex session is not ready to receive a message');
                         }