@sumicom/quicksave 0.8.14 → 0.8.16

package/dist/ai/codexAppServer/provider.js

@@ -3,13 +3,15 @@ import { fileURLToPath } from 'node:url';
 import { persistAttachments } from '../attachmentStore.js';
 import { buildSandboxMcpServerConfig, SANDBOX_MCP_NAME } from '../sandboxMcp.js';
 import { normalizePermissionLevelForAgent } from '../provider.js';
-import { queueStateFor } from '../queuedUserPrompts.js';
+import { makeQueuedUserPrompt, queueStateFor } from '../queuedUserPrompts.js';
 import { getEventStore } from '../../storage/eventStore.js';
 import { consumeAppServerStream } from './cardAdapter.js';
 import { codexApprovalResponse, codexApprovalToPermissionPrompt, } from './approvalMapping.js';
 import { detectCodexVersion, spawnAppServer } from './processManager.js';
 import { RuntimeOverrideStore } from './overrideStore.js';
 import { TokenAccounting } from './tokenAccounting.js';
+import { codexProtocolPreview } from './protocolLog.js';
+import { codexServerRequestInputId } from './serverRequestIds.js';
 const __ownDir = dirname(fileURLToPath(import.meta.url));
 const __aiDir = dirname(__ownDir);
 /**
@@ -71,10 +73,13 @@ export class CodexAppServerProvider {
             onExitedFire: callbacks.onSessionExited,
         });
         callbacks.onModelDetected(response.model);
+        void session.refreshGoalConfig().catch((err) => {
+            console.warn(`[codex-app] failed to refresh goal session=${response.thread.id.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`);
+        });
         // First-turn overrides from opts (effort etc.) get queued so drain()
         // attaches them to the next turn/start.
         overrideStore.enqueue(perTurnOverridesFromOpts(opts, response));
-        void session.runTurn(opts.prompt, opts.attachments);
+        scheduleInitialTurn(session, opts.prompt, opts.attachments);
         return { sessionId: response.thread.id, session };
     }
     async resumeSession(opts, cardBuilder, callbacks) {
@@ -102,11 +107,24 @@ export class CodexAppServerProvider {
             onExitedFire: callbacks.onSessionExited,
         });
         callbacks.onModelDetected(response.model);
+        void session.refreshGoalConfig().catch((err) => {
+            console.warn(`[codex-app] failed to refresh goal session=${response.thread.id.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`);
+        });
         overrideStore.enqueue(perTurnOverridesFromOpts(opts, response));
-        void session.runTurn(opts.prompt, opts.attachments);
+        scheduleInitialTurn(session, opts.prompt, opts.attachments);
         return { sessionId: response.thread.id, session };
     }
 }
+function scheduleInitialTurn(session, prompt, attachments) {
+    // Give SessionManager and messageHandler one macrotask to register the
+    // session and persist the mcpCorrId-backed registry entry before the model
+    // can call Quicksave's MCP tools. Without this, the first
+    // UpdateSessionStatus call in a fresh Codex turn can see `source: "unknown"`.
+    setTimeout(() => {
+        if (session.alive)
+            void session.runTurn(prompt, attachments);
+    }, 0);
+}
 export class CodexAppServerSession {
     handle;
     tokens;
@@ -118,6 +136,7 @@ export class CodexAppServerSession {
     pendingTurns = [];
     running = false;
     exited = false;
+    unsubscribeSessionNotifications = null;
     constructor(args) {
         this.handle = args.handle;
         this.tokens = args.tokens;
@@ -130,6 +149,9 @@ export class CodexAppServerSession {
         this.handle.rpc.setServerRequestHandler(async (req) => {
             return this.handleServerRequest(req);
         });
+        this.unsubscribeSessionNotifications = this.handle.rpc.onNotification((notification) => {
+            this.handleSessionNotification(notification);
+        });
         // If the child exits unexpectedly, mark us dead and notify SessionManager.
         this.handle.child.once('exit', () => {
             if (this.exited)
@@ -143,7 +165,7 @@ export class CodexAppServerSession {
     }
     sendUserMessage(prompt, attachments) {
         if (this.currentTurnId) {
-            this.pendingTurns.push({ prompt, attachments });
+            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
             this.callbacks.onQueueStateChange?.(this.threadId);
             return;
         }
@@ -153,7 +175,7 @@ export class CodexAppServerSession {
         if (this.currentTurnId)
             this.interrupt();
         if (this.running) {
-            this.pendingTurns.push({ prompt, attachments });
+            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
             this.callbacks.onQueueStateChange?.(this.threadId);
             return;
         }
@@ -168,11 +190,45 @@ export class CodexAppServerSession {
     hasPendingOverride() {
         return this.overrideStore.hasPending();
     }
+    async sendControlRequest(subtype, params) {
+        switch (subtype) {
+            case 'goal.get':
+            case 'thread/goal/get':
+                return this.refreshGoalConfigAndReturn();
+            case 'goal.set':
+            case 'goal.update':
+            case 'thread/goal/set': {
+                const response = await this.handle.rpc.request('thread/goal/set', this.goalSetParams(params));
+                this.emitGoalConfig(response.goal);
+                return response;
+            }
+            case 'goal.pause': {
+                const response = await this.handle.rpc.request('thread/goal/set', { threadId: this.threadId, status: 'paused' });
+                this.emitGoalConfig(response.goal);
+                return response;
+            }
+            case 'goal.resume': {
+                const response = await this.handle.rpc.request('thread/goal/set', { threadId: this.threadId, status: 'active' });
+                this.emitGoalConfig(response.goal);
+                return response;
+            }
+            case 'goal.clear':
+            case 'thread/goal/clear': {
+                const response = await this.handle.rpc.request('thread/goal/clear', { threadId: this.threadId });
+                this.emitGoalClearedConfig();
+                return response;
+            }
+            default:
+                throw new Error(`Unsupported Codex control request subtype: ${subtype}`);
+        }
+    }
+    async refreshGoalConfig() {
+        await this.refreshGoalConfigAndReturn();
+    }
     async listSlashCommands(opts) {
         const response = await this.handle.rpc.request('skills/list', {
             cwds: opts?.cwd ? [opts.cwd] : [],
             forceReload: opts?.forceReload === true,
-            perCwdExtraUserRoots: null,
         });
         return codexSkillsToSlashCommands(response, opts?.cwd);
     }
@@ -190,6 +246,8 @@ export class CodexAppServerSession {
             return;
         this.exited = true;
         this.pendingTurns = [];
+        this.unsubscribeSessionNotifications?.();
+        this.unsubscribeSessionNotifications = null;
         try {
             await this.cardBuilder.persistCards();
         }
@@ -216,7 +274,7 @@ export class CodexAppServerSession {
             return;
         if (this.running) {
             // Queue — only one turn at a time, preserving FIFO order.
-            this.pendingTurns.push({ prompt, attachments });
+            this.pendingTurns.push(makeQueuedUserPrompt(prompt, attachments));
             this.callbacks.onQueueStateChange?.(this.threadId);
             return;
         }
@@ -249,6 +307,16 @@ export class CodexAppServerSession {
         }
         return steered;
     }
+    /** Remove a single queued message by id. No-op (returns false) when the id is
+     * no longer queued — e.g. it already advanced into the active turn. */
+    deleteQueuedMessage(id) {
+        const index = this.pendingTurns.findIndex((q) => q.id === id);
+        if (index === -1)
+            return false;
+        this.pendingTurns.splice(index, 1);
+        this.callbacks.onQueueStateChange?.(this.threadId);
+        return true;
+    }
     async steerCurrentTurn(prompt, attachments, expectedTurnId, opts) {
         try {
             if (attachments && attachments.length > 0) {
@@ -308,6 +376,7 @@ export class CodexAppServerSession {
             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,
@@ -338,8 +407,64 @@ export class CodexAppServerSession {
             this.callbacks.onTurnSettled?.(this.threadId);
         }
     }
+    async refreshGoalConfigAndReturn() {
+        const response = await this.handle.rpc.request('thread/goal/get', { threadId: this.threadId });
+        if (response.goal) {
+            this.emitGoalConfig(response.goal);
+        }
+        else {
+            this.emitGoalClearedConfig();
+        }
+        return response;
+    }
+    goalSetParams(params) {
+        const out = { threadId: this.threadId };
+        const input = params ?? {};
+        if ('objective' in input) {
+            out.objective = normalizeGoalObjective(input.objective);
+        }
+        if ('status' in input) {
+            out.status = normalizeGoalStatusOrNull(input.status);
+        }
+        if ('tokenBudget' in input) {
+            out.tokenBudget = normalizeGoalTokenBudget(input.tokenBudget);
+        }
+        return out;
+    }
+    handleSessionNotification(notification) {
+        try {
+            switch (notification.method) {
+                case 'thread/goal/updated': {
+                    const params = notification.params;
+                    if (params.threadId !== this.threadId)
+                        return;
+                    this.emitGoalConfig(params.goal);
+                    return;
+                }
+                case 'thread/goal/cleared': {
+                    const params = notification.params;
+                    if (params.threadId !== this.threadId)
+                        return;
+                    this.emitGoalClearedConfig();
+                    return;
+                }
+                default:
+                    return;
+            }
+        }
+        catch (err) {
+            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)}`);
+        }
+    }
+    emitGoalConfig(goal) {
+        this.callbacks.onSessionConfigPatch?.(this.threadId, codexGoalToConfigPatch(goal));
+    }
+    emitGoalClearedConfig() {
+        this.callbacks.onSessionConfigPatch?.(this.threadId, clearedGoalConfigPatch());
+    }
     async handleServerRequest(req) {
         const requestIdStr = String(req.id);
+        const pendingRequestId = codexServerRequestInputId(this.threadId, requestIdStr);
         switch (req.method) {
             case 'item/commandExecution/requestApproval':
             case 'item/fileChange/requestApproval':
@@ -348,16 +473,313 @@ export class CodexAppServerSession {
             case 'applyPatchApproval': {
                 const method = req.method;
                 const prompt = codexApprovalToPermissionPrompt(method, requestIdStr, req.params);
-                const decision = await this.callbacks.handlePermissionRequest(this.threadId, prompt);
+                const decision = await this.callbacks.handlePermissionRequest(this.threadId, {
+                    ...prompt,
+                    requestId: pendingRequestId,
+                });
                 return codexApprovalResponse(method, req.params, decision);
             }
+            case 'item/tool/requestUserInput':
+                return this.handleToolRequestUserInput(req.params, pendingRequestId);
+            case 'mcpServer/elicitation/request':
+                return this.handleMcpServerElicitation(req.params, pendingRequestId);
+            case 'item/tool/call':
+                return unsupportedDynamicToolCallResponse(req.params);
+            case 'account/chatgptAuthTokens/refresh':
+                return unsupportedChatgptAuthTokensRefresh(req.params);
+            case 'attestation/generate':
+                return unsupportedAttestationGenerate(req.params);
             default:
                 // Unknown server request — refuse.
+                console.warn(`[codex-app] unsupported server request method=${req.method} id=${requestIdStr} params=${codexProtocolPreview(req.params)}`);
                 throw new Error(`unsupported server request method: ${req.method}`);
         }
     }
+    async handleToolRequestUserInput(params, requestId) {
+        const questions = params.questions ?? [];
+        const decision = await this.callbacks.handlePermissionRequest(this.threadId, {
+            requestId,
+            inputType: 'question',
+            toolName: 'AskUserQuestion',
+            toolInput: {
+                questions: questions.map(codexToolQuestionToPromptQuestion),
+            },
+            toolUseId: params.itemId,
+            title: questions[0]?.question ?? 'Codex needs input',
+            message: questions.length > 1 ? 'Codex needs answers before it can continue.' : undefined,
+            skipAutoApprove: true,
+        });
+        if (decision.action === 'deny')
+            return { answers: {} };
+        return codexToolAnswersFromResponse(questions, decision.response ?? '');
+    }
+    async handleMcpServerElicitation(params, requestId) {
+        const toolUseId = `mcp-elicitation:${requestId}`;
+        if (params.mode === 'url') {
+            const decision = await this.callbacks.handlePermissionRequest(this.threadId, {
+                requestId,
+                inputType: 'permission',
+                toolName: 'McpElicitation',
+                toolInput: {
+                    serverName: params.serverName,
+                    mode: params.mode,
+                    url: params.url,
+                    elicitationId: params.elicitationId,
+                },
+                toolUseId,
+                title: `Open MCP prompt from ${params.serverName}?`,
+                message: `${params.message}\n\n${params.url}`,
+                skipAutoApprove: true,
+            });
+            return {
+                action: decision.action === 'deny' ? 'decline' : 'accept',
+                content: null,
+                _meta: params._meta ?? null,
+            };
+        }
+        const fields = mcpElicitationFields(params.requestedSchema);
+        const decision = await this.callbacks.handlePermissionRequest(this.threadId, {
+            requestId,
+            inputType: 'question',
+            toolName: 'AskUserQuestion',
+            toolInput: {
+                serverName: params.serverName,
+                mode: params.mode,
+                message: params.message,
+                questions: fields.map((field) => field.question),
+            },
+            toolUseId,
+            title: params.message || `MCP prompt from ${params.serverName}`,
+            message: `MCP server: ${params.serverName}`,
+            skipAutoApprove: true,
+        });
+        if (decision.action === 'deny') {
+            return { action: 'decline', content: null, _meta: params._meta ?? null };
+        }
+        return {
+            action: 'accept',
+            content: mcpElicitationContentFromResponse(fields, decision.response ?? ''),
+            _meta: params._meta ?? null,
+        };
+    }
+}
+function codexToolQuestionToPromptQuestion(question) {
+    return {
+        id: question.id,
+        question: question.question,
+        header: question.header || undefined,
+        options: question.options?.map((option) => ({
+            label: option.label,
+            description: option.description || undefined,
+        })),
+        isSecret: question.isSecret || undefined,
+    };
+}
+function codexToolAnswersFromResponse(questions, responseText) {
+    const parts = questions.length > 1 ? responseText.split('\n') : [responseText];
+    const answers = {};
+    for (let i = 0; i < questions.length; i++) {
+        const question = questions[i];
+        if (!question?.id)
+            continue;
+        const answer = (parts[i] ?? '').trim();
+        answers[question.id] = { answers: answer ? [answer] : [] };
+    }
+    return { answers };
+}
+function mcpElicitationFields(schema) {
+    return Object.entries(schema.properties ?? {}).map(([key, prop]) => {
+        const primitive = prop;
+        const options = mcpOptionsForSchema(primitive);
+        const multiSelect = primitiveType(primitive) === 'array';
+        return {
+            key,
+            schema: primitive,
+            options,
+            multiSelect,
+            question: {
+                id: key,
+                question: primitiveTitle(primitive) ?? key,
+                header: key,
+                options: options?.map((option) => ({
+                    label: option.label,
+                    description: typeof option.value === 'string' && option.value !== option.label
+                        ? option.value
+                        : undefined,
+                })),
+                multiSelect,
+            },
+        };
+    });
+}
+function mcpElicitationContentFromResponse(fields, responseText) {
+    const parts = fields.length > 1 ? responseText.split('\n') : [responseText];
+    const content = {};
+    for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        const raw = (parts[i] ?? '').trim();
+        content[field.key] = parseMcpElicitationValue(field, raw);
+    }
+    return content;
+}
+function parseMcpElicitationValue(field, raw) {
+    if (field.multiSelect) {
+        const answers = raw ? raw.split(',').map((part) => part.trim()).filter(Boolean) : [];
+        return answers.map((answer) => mcpOptionValue(field.options, answer));
+    }
+    const mapped = mcpOptionValue(field.options, raw);
+    const type = primitiveType(field.schema);
+    if (type === 'boolean') {
+        if (/^(true|yes|y|1)$/i.test(String(mapped)))
+            return true;
+        if (/^(false|no|n|0)$/i.test(String(mapped)))
+            return false;
+        return Boolean(raw);
+    }
+    if (type === 'number' || type === 'integer') {
+        const n = Number(mapped);
+        return Number.isFinite(n) ? n : raw;
+    }
+    return mapped;
+}
+function mcpOptionValue(options, answer) {
+    const match = options?.find((option) => option.label === answer || option.value === answer);
+    return match ? match.value : answer;
+}
+function mcpOptionsForSchema(schema) {
+    const record = schema;
+    if (Array.isArray(record.oneOf)) {
+        return record.oneOf.map((option) => constOption(option)).filter((option) => !!option);
+    }
+    if (Array.isArray(record.enum)) {
+        const names = Array.isArray(record.enumNames) ? record.enumNames : [];
+        return record.enum.map((value, index) => ({
+            label: typeof names[index] === 'string' ? names[index] : String(value),
+            value: jsonPrimitive(value),
+        }));
+    }
+    const items = record.items;
+    if (items && Array.isArray(items.anyOf)) {
+        return items.anyOf.map((option) => constOption(option)).filter((option) => !!option);
+    }
+    if (items && Array.isArray(items.enum)) {
+        return items.enum.map((value) => ({ label: String(value), value: jsonPrimitive(value) }));
+    }
+    if (record.type === 'boolean') {
+        return [
+            { label: 'Yes', value: true },
+            { label: 'No', value: false },
+        ];
+    }
+    return null;
+}
+function constOption(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const option = value;
+    if (option.const === undefined)
+        return null;
+    return {
+        label: typeof option.title === 'string' ? option.title : String(option.const),
+        value: jsonPrimitive(option.const),
+    };
+}
+function jsonPrimitive(value) {
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) {
+        return value;
+    }
+    return String(value);
+}
+function primitiveType(schema) {
+    return schema.type;
+}
+function primitiveTitle(schema) {
+    const title = schema.title;
+    return typeof title === 'string' && title.trim() ? title : undefined;
+}
+function unsupportedDynamicToolCallResponse(params) {
+    const toolName = params.namespace ? `${params.namespace}:${params.tool}` : params.tool;
+    return {
+        success: false,
+        contentItems: [{
+                type: 'inputText',
+                text: `Dynamic tool calls are not supported by Quicksave: ${toolName}`,
+            }],
+    };
+}
+function unsupportedChatgptAuthTokensRefresh(params) {
+    throw new Error(`chatgptAuthTokens refresh is not supported by Quicksave (reason=${params.reason}). ` +
+        'Use Codex managed ChatGPT login or API key auth.');
+}
+function unsupportedAttestationGenerate(params) {
+    console.warn(`[codex-app] unsupported server request method=attestation/generate params=${codexProtocolPreview(params)}`);
+    throw new Error('attestation/generate is not supported by Quicksave');
+}
+function normalizeGoalObjective(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'string') {
+        throw new Error('goal objective must be a string');
+    }
+    const objective = value.trim();
+    if (!objective) {
+        throw new Error('goal objective must not be empty');
+    }
+    if (objective.length > 4000) {
+        throw new Error('goal objective must be 4000 characters or fewer');
+    }
+    return objective;
+}
+function normalizeGoalStatusOrNull(value) {
+    if (value === null)
+        return null;
+    if (typeof value === 'string' && isThreadGoalStatus(value))
+        return value;
+    throw new Error(`goal status must be one of: ${THREAD_GOAL_STATUSES.join(', ')}`);
+}
+function normalizeGoalTokenBudget(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        throw new Error('goal tokenBudget must be a non-negative number');
+    }
+    return value;
+}
+const THREAD_GOAL_STATUSES = [
+    'active',
+    'paused',
+    'blocked',
+    'usageLimited',
+    'budgetLimited',
+    'complete',
+];
+function isThreadGoalStatus(value) {
+    return THREAD_GOAL_STATUSES.includes(value);
+}
+function codexGoalToConfigPatch(goal) {
+    return {
+        codexGoalPresent: true,
+        codexGoalObjective: goal.objective,
+        codexGoalStatus: goal.status,
+        codexGoalTokenBudget: goal.tokenBudget,
+        codexGoalTokensUsed: goal.tokensUsed,
+        codexGoalTimeUsedSeconds: goal.timeUsedSeconds,
+        codexGoalCreatedAt: goal.createdAt,
+        codexGoalUpdatedAt: goal.updatedAt,
+    };
+}
+function clearedGoalConfigPatch() {
+    return {
+        codexGoalPresent: false,
+        codexGoalObjective: null,
+        codexGoalStatus: null,
+        codexGoalTokenBudget: null,
+        codexGoalTokensUsed: null,
+        codexGoalTimeUsedSeconds: null,
+        codexGoalCreatedAt: null,
+        codexGoalUpdatedAt: null,
+    };
 }
-// ── helpers ──
 function spawnCodexAppServer(opts) {
     return spawnAppServer({
         clientInfo: {
@@ -365,7 +787,7 @@ function spawnCodexAppServer(opts) {
             title: 'Quicksave Agent',
             version: '0.0.0',
         },
-        capabilities: { experimentalApi: true, optOutNotificationMethods: null },
+        capabilities: { experimentalApi: true, requestAttestation: false, optOutNotificationMethods: null },
     }, {
         extraArgs: buildCodexSandboxMcpConfigArgs({
             cwd: opts.cwd,
@@ -419,7 +841,6 @@ function seedOverrideStoreFromResponse(store, resp) {
         effort: resp.reasoningEffort ?? null,
         approvalPolicy: resp.approvalPolicy,
         sandboxPolicy: resp.sandbox,
-        permissionProfile: resp.permissionProfile,
         approvalsReviewer: resp.approvalsReviewer,
     });
 }
@@ -474,7 +895,6 @@ export function buildThreadStartParams(opts) {
         approvalPolicy: perm.approvalPolicy,
         approvalsReviewer: perm.approvalsReviewer,
         sandbox: perm.sandbox,
-        permissionProfile: null,
         config: null,
         serviceName: null,
         baseInstructions: null,
@@ -482,8 +902,7 @@ export function buildThreadStartParams(opts) {
         personality: null,
         ephemeral: null,
         sessionStartSource: null,
-        experimentalRawEvents: false,
-        persistExtendedHistory: true,
+        threadSource: null,
     };
 }
 export function buildThreadResumeParams(opts) {
@@ -491,8 +910,6 @@ export function buildThreadResumeParams(opts) {
     const perm = mapCodexPresetToInitialThreadOpts(preset, opts.sandboxed);
     return {
         threadId: opts.sessionId,
-        history: null,
-        path: null,
         model: opts.model ?? null,
         modelProvider: null,
         serviceTier: null,
@@ -500,13 +917,10 @@ export function buildThreadResumeParams(opts) {
         approvalPolicy: perm.approvalPolicy,
         approvalsReviewer: perm.approvalsReviewer,
         sandbox: perm.sandbox,
-        permissionProfile: null,
         config: null,
         baseInstructions: null,
         developerInstructions: opts.systemPrompt ?? null,
         personality: null,
-        excludeTurns: true,
-        persistExtendedHistory: true,
     };
 }
 function perTurnOverridesFromOpts(opts, resolved) {