@sumicom/quicksave 0.8.16 → 0.8.18

package/dist/ai/codexAppServer/provider.js

@@ -5,7 +5,7 @@ import { buildSandboxMcpServerConfig, SANDBOX_MCP_NAME } from '../sandboxMcp.js'
 import { normalizePermissionLevelForAgent } from '../provider.js';
 import { makeQueuedUserPrompt, queueStateFor } from '../queuedUserPrompts.js';
 import { getEventStore } from '../../storage/eventStore.js';
-import { consumeAppServerStream } from './cardAdapter.js';
+import { createCodexTurnStreamConsumer, } from './cardAdapter.js';
 import { codexApprovalResponse, codexApprovalToPermissionPrompt, } from './approvalMapping.js';
 import { detectCodexVersion, spawnAppServer } from './processManager.js';
 import { RuntimeOverrideStore } from './overrideStore.js';
@@ -14,6 +14,13 @@ import { codexProtocolPreview } from './protocolLog.js';
 import { codexServerRequestInputId } from './serverRequestIds.js';
 const __ownDir = dirname(fileURLToPath(import.meta.url));
 const __aiDir = dirname(__ownDir);
+const CODEX_BUILT_IN_SLASH_COMMANDS = [
+    {
+        name: 'goal',
+        description: 'Manage Codex goal mode',
+        argumentHint: 'pause | resume | clear | set <objective>',
+    },
+];
 /**
  * Codex provider driving the JSON-RPC v2 `app-server` protocol.
  * Phase 2 of the migration — see
@@ -114,6 +121,29 @@ export class CodexAppServerProvider {
         scheduleInitialTurn(session, opts.prompt, opts.attachments);
         return { sessionId: response.thread.id, session };
     }
+    async listNativeSessions(opts) {
+        const handle = await spawnCodexNativeListAppServer();
+        try {
+            const [activeThreads, archivedThreads] = await Promise.all([
+                listCodexThreads(handle, opts?.cwd, false),
+                listCodexThreads(handle, opts?.cwd, true),
+            ]);
+            const byId = new Map();
+            for (const item of [
+                ...activeThreads.map((thread) => codexThreadToNativeSession(thread, false)),
+                ...archivedThreads.map((thread) => codexThreadToNativeSession(thread, true)),
+            ]) {
+                const existing = byId.get(item.sessionId);
+                if (!existing || item.lastInteractionAt > existing.lastInteractionAt) {
+                    byId.set(item.sessionId, item);
+                }
+            }
+            return Array.from(byId.values()).sort((a, b) => b.lastInteractionAt - a.lastInteractionAt);
+        }
+        finally {
+            await handle.shutdown().catch(() => { });
+        }
+    }
 }
 function scheduleInitialTurn(session, prompt, attachments) {
     // Give SessionManager and messageHandler one macrotask to register the
@@ -135,8 +165,13 @@ export class CodexAppServerSession {
     currentTurnId = null;
     pendingTurns = [];
     running = false;
+    startingRunTurn = false;
+    prestartedRunTurnId = null;
     exited = false;
+    turnConsumers = new Map();
+    settledTurnIds = new Set();
     unsubscribeSessionNotifications = null;
+    unsubscribeTransportClose = null;
     constructor(args) {
         this.handle = args.handle;
         this.tokens = args.tokens;
@@ -152,6 +187,9 @@ export class CodexAppServerSession {
         this.unsubscribeSessionNotifications = this.handle.rpc.onNotification((notification) => {
             this.handleSessionNotification(notification);
         });
+        this.unsubscribeTransportClose = this.handle.rpc.onClose(() => {
+            this.handleTransportClosed();
+        });
         // If the child exits unexpectedly, mark us dead and notify SessionManager.
         this.handle.child.once('exit', () => {
             if (this.exited)
@@ -164,9 +202,9 @@ export class CodexAppServerSession {
         return !this.exited;
     }
     sendUserMessage(prompt, attachments) {
-        if (this.currentTurnId) {
-            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
-            this.callbacks.onQueueStateChange?.(this.threadId);
+        const activeTurnId = this.currentTurnId;
+        if (activeTurnId) {
+            void this.steerOrQueue(prompt, attachments, activeTurnId);
             return;
         }
         void this.runTurn(prompt, attachments);
@@ -174,12 +212,7 @@ export class CodexAppServerSession {
     interruptThenSendUserMessage(prompt, attachments) {
         if (this.currentTurnId)
             this.interrupt();
-        if (this.running) {
-            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
-            this.callbacks.onQueueStateChange?.(this.threadId);
-            return;
-        }
-        void this.runTurn(prompt, attachments);
+        this.enqueueOrRunTurn(prompt, attachments);
     }
     getQueueState() {
         return queueStateFor(this.pendingTurns, this.currentTurnId !== null);
@@ -230,16 +263,20 @@ export class CodexAppServerSession {
             cwds: opts?.cwd ? [opts.cwd] : [],
             forceReload: opts?.forceReload === true,
         });
-        return codexSkillsToSlashCommands(response, opts?.cwd);
+        const skills = codexSkillsToSlashCommands(response, opts?.cwd)
+            .filter((command) => !CODEX_BUILT_IN_SLASH_COMMANDS.some((builtin) => builtin.name === command.name));
+        return [...CODEX_BUILT_IN_SLASH_COMMANDS, ...skills];
     }
     interrupt() {
-        if (!this.currentTurnId)
+        const turnId = this.currentTurnId;
+        if (!turnId)
             return;
         void this.handle.rpc
-            .request('turn/interrupt', { threadId: this.threadId, turnId: this.currentTurnId })
+            .request('turn/interrupt', { threadId: this.threadId, turnId })
             .catch(() => {
             /* best-effort */
         });
+        this.closeTurnAsInterrupted(turnId);
     }
     async kill() {
         if (this.exited)
@@ -248,6 +285,9 @@ export class CodexAppServerSession {
         this.pendingTurns = [];
         this.unsubscribeSessionNotifications?.();
         this.unsubscribeSessionNotifications = null;
+        this.unsubscribeTransportClose?.();
+        this.unsubscribeTransportClose = null;
+        this.closeTurnConsumersAsInterrupted();
         try {
             await this.cardBuilder.persistCards();
         }
@@ -267,8 +307,8 @@ export class CodexAppServerSession {
             // best-effort
         }
     }
-    /** Run a single turn end-to-end: cb.startNewTurn → cb.userMessage →
-     * turn/start → consume notifications → emit stream-end. */
+    /** Run a single explicit turn end-to-end: cb.startNewTurn → cb.userMessage
+     * → turn/start → wait for the session-routed turn consumer to settle. */
     async runTurn(prompt, attachments) {
         if (this.exited)
             return;
@@ -317,6 +357,22 @@ export class CodexAppServerSession {
         this.callbacks.onQueueStateChange?.(this.threadId);
         return true;
     }
+    async steerOrQueue(prompt, attachments, expectedTurnId) {
+        const steered = await this.steerCurrentTurn(prompt, attachments, expectedTurnId);
+        if (steered)
+            return;
+        this.enqueueOrRunTurn(prompt, attachments);
+    }
+    enqueueOrRunTurn(prompt, attachments) {
+        if (this.exited)
+            return;
+        if (this.running || this.currentTurnId) {
+            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
+            this.callbacks.onQueueStateChange?.(this.threadId);
+            return;
+        }
+        void this.runTurn(prompt, attachments);
+    }
     async steerCurrentTurn(prompt, attachments, expectedTurnId, opts) {
         try {
             if (attachments && attachments.length > 0) {
@@ -372,17 +428,24 @@ export class CodexAppServerSession {
                 input: attachmentsToCodexUserInput(prompt, attachments),
                 ...drained,
             };
-            const response = await this.handle.rpc.request('turn/start', params);
+            this.startingRunTurn = true;
+            this.prestartedRunTurnId = null;
+            let response;
+            try {
+                response = await this.handle.rpc.request('turn/start', params);
+            }
+            finally {
+                this.startingRunTurn = false;
+            }
             this.overrideStore.commit();
             turnId = response.turn.id;
             this.currentTurnId = turnId;
             cb.setCurrentTurnId(turnId);
-            const result = await consumeAppServerStream(this.handle.rpc, cb, {
-                sessionId: this.threadId,
-                threadId: this.threadId,
-                turnId,
-                tokens: this.tokens,
-            }, this.callbacks);
+            const prestartedTurnId = this.prestartedRunTurnId;
+            if (prestartedTurnId && prestartedTurnId !== turnId) {
+                console.warn(`[codex-app] turn/start response mismatch session=${this.threadId.slice(0, 8)} response=${turnId.slice(0, 8)} notification=${prestartedTurnId.slice(0, 8)}`);
+            }
+            const result = await this.beginTurnConsumer(turnId, { managedByRunTurn: true }).result;
             void result; // settled; stream-end already emitted by adapter
         }
         catch (err) {
@@ -396,15 +459,10 @@ export class CodexAppServerSession {
             });
         }
         finally {
-            this.currentTurnId = null;
-            try {
-                await cb.persistCards();
-            }
-            catch {
-                // best-effort
-            }
-            cb.clearCards();
-            this.callbacks.onTurnSettled?.(this.threadId);
+            this.startingRunTurn = false;
+            const lifecycleTurnId = turnId ?? this.prestartedRunTurnId;
+            this.prestartedRunTurnId = null;
+            await this.finishTurnLifecycle(lifecycleTurnId);
         }
     }
     async refreshGoalConfigAndReturn() {
@@ -431,8 +489,96 @@ export class CodexAppServerSession {
         }
         return out;
     }
+    beginTurnConsumer(turnId, opts) {
+        const existing = this.turnConsumers.get(turnId);
+        if (existing)
+            return existing;
+        this.settledTurnIds.delete(turnId);
+        const consumer = createCodexTurnStreamConsumer(this.cardBuilder, {
+            sessionId: this.threadId,
+            threadId: this.threadId,
+            turnId,
+            tokens: this.tokens,
+        }, this.callbacks);
+        this.turnConsumers.set(turnId, consumer);
+        void consumer.result.then(() => {
+            void this.handleTurnConsumerSettled(turnId, consumer, opts.managedByRunTurn).catch((err) => {
+                console.warn(`[codex-app] failed to settle turn consumer session=${this.threadId.slice(0, 8)} turn=${turnId.slice(0, 8)} error=${err instanceof Error ? err.message : String(err)}`);
+            });
+        });
+        return consumer;
+    }
+    async handleTurnConsumerSettled(turnId, consumer, managedByRunTurn) {
+        if (this.turnConsumers.get(turnId) === consumer) {
+            this.turnConsumers.delete(turnId);
+        }
+        this.rememberSettledTurn(turnId);
+        consumer.dispose();
+        if (managedByRunTurn)
+            return;
+        await this.finishTurnLifecycle(turnId);
+        this.drainPendingTurnsAfterObservedTurn();
+    }
+    async finishTurnLifecycle(turnId) {
+        const builderTurnId = this.cardBuilder.getCurrentTurnId();
+        const shouldClearCards = !turnId || !builderTurnId || builderTurnId === turnId;
+        if (!turnId || this.currentTurnId === turnId) {
+            this.currentTurnId = null;
+        }
+        try {
+            await this.cardBuilder.persistCards();
+        }
+        catch {
+            // best-effort
+        }
+        if (shouldClearCards) {
+            this.cardBuilder.clearCards();
+        }
+        this.callbacks.onTurnSettled?.(this.threadId);
+    }
+    drainPendingTurnsAfterObservedTurn() {
+        if (this.exited || this.running || this.currentTurnId || this.pendingTurns.length === 0) {
+            return;
+        }
+        const next = this.pendingTurns.shift();
+        this.callbacks.onQueueStateChange?.(this.threadId);
+        void this.runTurn(next.prompt, next.attachments);
+    }
+    closeTurnConsumersAsInterrupted() {
+        for (const consumer of this.turnConsumers.values()) {
+            consumer.closeAsInterrupted();
+        }
+    }
+    closeTurnAsInterrupted(turnId) {
+        const consumer = this.turnConsumers.get(turnId);
+        if (consumer) {
+            consumer.closeAsInterrupted();
+            return;
+        }
+        this.callbacks.emitStreamEnd({
+            sessionId: this.threadId,
+            turnId,
+            success: false,
+            interrupted: true,
+        });
+        void this.finishTurnLifecycle(turnId);
+    }
+    handleTransportClosed() {
+        this.closeTurnConsumersAsInterrupted();
+    }
+    rememberSettledTurn(turnId) {
+        this.settledTurnIds.add(turnId);
+        if (this.settledTurnIds.size <= 100)
+            return;
+        const oldest = this.settledTurnIds.values().next().value;
+        if (oldest)
+            this.settledTurnIds.delete(oldest);
+    }
     handleSessionNotification(notification) {
         try {
+            this.observeTokenUsageNotification(notification);
+            const turnId = this.ensureTurnConsumerForNotification(notification);
+            this.dispatchTurnNotification(notification, turnId);
             switch (notification.method) {
                 case 'thread/goal/updated': {
                     const params = notification.params;
@@ -456,6 +602,53 @@ export class CodexAppServerSession {
             console.warn(`[codex-app] failed to handle session notification method=${notification.method} session=${this.threadId.slice(0, 8)} params=${codexProtocolPreview(notification.params)} error=${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    observeTokenUsageNotification(notification) {
+        if (notification.method !== 'thread/tokenUsage/updated')
+            return;
+        if (!notificationBelongsToThread(notification.params, this.threadId))
+            return;
+        this.tokens.observe(notification.params);
+    }
+    ensureTurnConsumerForNotification(notification) {
+        if (!notificationBelongsToThread(notification.params, this.threadId))
+            return null;
+        const turnId = notificationTurnId(notification);
+        if (!turnId)
+            return null;
+        if (this.settledTurnIds.has(turnId))
+            return turnId;
+        const existing = this.turnConsumers.get(turnId);
+        if (existing)
+            return turnId;
+        if (!shouldCreateTurnConsumerForNotification(notification.method))
+            return turnId;
+        const managedByRunTurn = this.startingRunTurn || this.currentTurnId === turnId;
+        if (this.startingRunTurn) {
+            this.prestartedRunTurnId = turnId;
+        }
+        if (managedByRunTurn) {
+            this.currentTurnId = turnId;
+            this.cardBuilder.setCurrentTurnId(turnId);
+        }
+        else {
+            this.cardBuilder.startNewTurn(turnId);
+            this.currentTurnId = turnId;
+            this.callbacks.onQueueStateChange?.(this.threadId);
+        }
+        this.beginTurnConsumer(turnId, { managedByRunTurn });
+        return turnId;
+    }
+    dispatchTurnNotification(notification, turnId) {
+        if (!notificationBelongsToThread(notification.params, this.threadId))
+            return;
+        if (turnId) {
+            this.turnConsumers.get(turnId)?.dispatch(notification);
+            return;
+        }
+        for (const consumer of this.turnConsumers.values()) {
+            consumer.dispatch(notification);
+        }
+    }
     emitGoalConfig(goal) {
         this.callbacks.onSessionConfigPatch?.(this.threadId, codexGoalToConfigPatch(goal));
     }
@@ -563,6 +756,57 @@ export class CodexAppServerSession {
         };
     }
 }
+// ── helpers ──
+function notificationBelongsToThread(params, threadId) {
+    if (typeof params !== 'object' || params === null)
+        return true;
+    const candidate = params.threadId;
+    return typeof candidate !== 'string' || candidate === threadId;
+}
+function notificationTurnId(notification) {
+    switch (notification.method) {
+        case 'turn/started': {
+            const params = notification.params;
+            return params.turn?.id ?? null;
+        }
+        case 'turn/completed': {
+            const params = notification.params;
+            return params.turn?.id ?? null;
+        }
+        default: {
+            if (typeof notification.params !== 'object' || notification.params === null)
+                return null;
+            const candidate = notification.params.turnId;
+            return typeof candidate === 'string' && candidate.length > 0 ? candidate : null;
+        }
+    }
+}
+function shouldCreateTurnConsumerForNotification(method) {
+    switch (method) {
+        case 'turn/started':
+        case 'turn/completed':
+        case 'turn/plan/updated':
+        case 'item/started':
+        case 'item/autoApprovalReview/started':
+        case 'item/autoApprovalReview/completed':
+        case 'item/completed':
+        case 'item/agentMessage/delta':
+        case 'item/plan/delta':
+        case 'item/commandExecution/outputDelta':
+        case 'item/fileChange/outputDelta':
+        case 'item/fileChange/patchUpdated':
+        case 'item/mcpToolCall/progress':
+        case 'item/reasoning/summaryTextDelta':
+        case 'item/reasoning/summaryPartAdded':
+        case 'item/reasoning/textDelta':
+        case 'model/rerouted':
+        case 'model/verification':
+        case 'error':
+            return true;
+        default:
+            return false;
+    }
+}
 function codexToolQuestionToPromptQuestion(question) {
     return {
         id: question.id,
@@ -780,15 +1024,21 @@ function clearedGoalConfigPatch() {
         codexGoalUpdatedAt: null,
     };
 }
-function spawnCodexAppServer(opts) {
-    return spawnAppServer({
+function codexAppServerInit() {
+    return {
         clientInfo: {
             name: 'quicksave-agent',
             title: 'Quicksave Agent',
             version: '0.0.0',
         },
         capabilities: { experimentalApi: true, requestAttestation: false, optOutNotificationMethods: null },
-    }, {
+    };
+}
+function spawnCodexNativeListAppServer() {
+    return spawnAppServer(codexAppServerInit());
+}
+function spawnCodexAppServer(opts) {
+    return spawnAppServer(codexAppServerInit(), {
         extraArgs: buildCodexSandboxMcpConfigArgs({
             cwd: opts.cwd,
             sessionId: 'sessionId' in opts ? opts.sessionId : undefined,
@@ -796,6 +1046,42 @@ function spawnCodexAppServer(opts) {
         }),
     });
 }
+async function listCodexThreads(handle, cwd, archived) {
+    const threads = [];
+    let cursor = null;
+    do {
+        const params = {
+            cursor,
+            limit: 100,
+            sortKey: 'updated_at',
+            sortDirection: 'desc',
+            cwd: cwd ?? null,
+            archived,
+        };
+        const response = await handle.rpc.request('thread/list', params);
+        threads.push(...response.data.filter((thread) => !thread.ephemeral &&
+            thread.parentThreadId === null &&
+            (!cwd || thread.cwd === cwd)));
+        cursor = response.nextCursor;
+    } while (cursor);
+    return threads;
+}
+function codexThreadToNativeSession(thread, archived) {
+    return {
+        sessionId: thread.id,
+        cwd: thread.cwd,
+        agent: 'codex',
+        title: thread.name ?? undefined,
+        firstPrompt: thread.preview || undefined,
+        createdAt: codexSecondsToMs(thread.createdAt),
+        lastInteractionAt: codexSecondsToMs(thread.updatedAt),
+        gitBranch: thread.gitInfo?.branch ?? undefined,
+        archived,
+    };
+}
+function codexSecondsToMs(value) {
+    return value < 10_000_000_000 ? value * 1000 : value;
+}
 export function buildCodexSandboxMcpConfigArgs(opts) {
     const config = buildSandboxMcpServerConfig({
         ownDir: __aiDir,