@ccpocket/bridge 1.88.1 → 1.88.3

package/dist/codex-process.d.ts

@@ -121,6 +121,8 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private pendingTurnCompletion;
     private pendingApprovals;
     private pendingUserInputs;
+    private pendingRequestOrder;
+    private nextPendingRequestOrder;
     private lastTokenUsage;
     /** Full skill metadata from the last `skills/list` response. */
     private _skills;
@@ -320,9 +322,19 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
         toolName: string;
         input: Record<string, unknown>;
     } | undefined;
+    getPendingPermissions(): Array<{
+        toolUseId: string;
+        toolName: string;
+        input: Record<string, unknown>;
+    }>;
     /** Emit a synthetic tool_result so history replay can match it to a permission_request. */
     private emitToolResult;
     private resolvePendingApproval;
+    private rememberPendingRequest;
+    private forgetPendingRequest;
+    private oldestPendingRequestId;
+    private pendingRequestIdsInOrder;
+    private oldestApprovalCompatibleRequestId;
     private resolvePendingUserInput;
     /**
      * Approve a pending user-input request (McpElicitation fallback).

package/dist/codex-process.js

@@ -77,6 +77,8 @@ export class CodexProcess extends EventEmitter {
     pendingTurnCompletion = null;
     pendingApprovals = new Map();
     pendingUserInputs = new Map();
+    pendingRequestOrder = new Map();
+    nextPendingRequestOrder = 0;
     lastTokenUsage = null;
     /** Full skill metadata from the last `skills/list` response. */
     _skills = [];
@@ -663,6 +665,7 @@ export class CodexProcess extends EventEmitter {
         }
         this.pendingApprovals.clear();
         this.pendingUserInputs.clear();
+        this.pendingRequestOrder.clear();
         this.stdoutLineChunks = [];
         this.stdoutLineChars = 0;
         this.cleanupSteerTempPaths();
@@ -684,6 +687,8 @@ export class CodexProcess extends EventEmitter {
         this.pendingTurnCompletion = null;
         this.pendingApprovals.clear();
         this.pendingUserInputs.clear();
+        this.pendingRequestOrder.clear();
+        this.nextPendingRequestOrder = 0;
         this.cleanupSteerTempPaths();
         this.lastTokenUsage = null;
         this.startModel = sanitizeCodexModel(options?.model);
@@ -838,21 +843,25 @@ export class CodexProcess extends EventEmitter {
         }
     }
     approve(toolUseId) {
+        const targetToolUseId = toolUseId ?? this.oldestApprovalCompatibleRequestId();
+        if (!targetToolUseId)
+            return false;
         // Check if this is a plan completion approval
         if (this.pendingPlanCompletion &&
-            toolUseId === this.pendingPlanCompletion.toolUseId) {
+            targetToolUseId === this.pendingPlanCompletion.toolUseId) {
             this.handlePlanApproved();
             return true;
         }
-        const pending = this.resolvePendingApproval(toolUseId);
+        const pending = this.resolvePendingApproval(targetToolUseId);
         if (!pending) {
             // Fallback: McpElicitation lives in pendingUserInputs
-            if (this.approveUserInput(toolUseId, "Accept"))
+            if (this.approveUserInput(targetToolUseId, "Accept"))
                 return true;
             console.log("[codex-process] approve() called but no pending permission requests");
             return false;
         }
         this.pendingApprovals.delete(pending.toolUseId);
+        this.forgetPendingRequest(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "accept"));
         this.emitToolResult(pending.toolUseId, "Approved", "approved");
         if (this.pendingApprovals.size === 0 &&
@@ -863,16 +872,25 @@ export class CodexProcess extends EventEmitter {
         return true;
     }
     approveAlways(toolUseId) {
-        const pending = this.resolvePendingApproval(toolUseId);
+        const targetToolUseId = toolUseId ?? this.oldestApprovalCompatibleRequestId();
+        if (!targetToolUseId)
+            return false;
+        if (this.pendingPlanCompletion &&
+            targetToolUseId === this.pendingPlanCompletion.toolUseId) {
+            this.handlePlanApproved();
+            return true;
+        }
+        const pending = this.resolvePendingApproval(targetToolUseId);
         if (!pending) {
             // Fallback: McpElicitation lives in pendingUserInputs
-            if (this.approveUserInput(toolUseId, "Allow for this session")) {
+            if (this.approveUserInput(targetToolUseId, "Allow for this session")) {
                 return true;
             }
             console.log("[codex-process] approveAlways() called but no pending permission requests");
             return false;
         }
         this.pendingApprovals.delete(pending.toolUseId);
+        this.forgetPendingRequest(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "acceptForSession"));
         this.emitToolResult(pending.toolUseId, "Approved (always)", "approved_for_session");
         if (this.pendingApprovals.size === 0 &&
@@ -883,21 +901,25 @@ export class CodexProcess extends EventEmitter {
         return true;
     }
     reject(toolUseId, _message) {
+        const targetToolUseId = toolUseId ?? this.oldestApprovalCompatibleRequestId();
+        if (!targetToolUseId)
+            return false;
         // Check if this is a plan completion rejection
         if (this.pendingPlanCompletion &&
-            toolUseId === this.pendingPlanCompletion.toolUseId) {
+            targetToolUseId === this.pendingPlanCompletion.toolUseId) {
             this.handlePlanRejected(_message);
             return true;
         }
-        const pending = this.resolvePendingApproval(toolUseId);
+        const pending = this.resolvePendingApproval(targetToolUseId);
         if (!pending) {
             // Fallback: McpElicitation lives in pendingUserInputs
-            if (this.rejectUserInput(toolUseId, "Decline"))
+            if (this.rejectUserInput(targetToolUseId, "Decline"))
                 return true;
             console.log("[codex-process] reject() called but no pending permission requests");
             return false;
         }
         this.pendingApprovals.delete(pending.toolUseId);
+        this.forgetPendingRequest(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, resolveApprovalRejectDecision(pending)));
         this.emitToolResult(pending.toolUseId, "Rejected", "rejected");
         if (this.pendingApprovals.size === 0 &&
@@ -914,8 +936,9 @@ export class CodexProcess extends EventEmitter {
             return false;
         }
         this.pendingUserInputs.delete(pending.toolUseId);
+        this.forgetPendingRequest(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
-        this.emitToolResult(pending.toolUseId, "Answered", "answered");
+        this.emitToolResult(pending.toolUseId, questionAnswerResultForHistory(pending, result), "answered");
         if (this.pendingApprovals.size === 0 &&
             !this.hasBlockingUserInput() &&
             !this.pendingPlanCompletion) {
@@ -1014,9 +1037,11 @@ export class CodexProcess extends EventEmitter {
         }
     }
     getPendingPermission(toolUseId) {
-        // Check plan completion first
+        const selectedToolUseId = toolUseId ?? this.oldestPendingRequestId();
+        if (!selectedToolUseId)
+            return undefined;
         if (this.pendingPlanCompletion) {
-            if (!toolUseId || toolUseId === this.pendingPlanCompletion.toolUseId) {
+            if (selectedToolUseId === this.pendingPlanCompletion.toolUseId) {
                 return {
                     toolUseId: this.pendingPlanCompletion.toolUseId,
                     toolName: "ExitPlanMode",
@@ -1024,7 +1049,7 @@ export class CodexProcess extends EventEmitter {
                 };
             }
         }
-        const pending = this.resolvePendingApproval(toolUseId);
+        const pending = this.pendingApprovals.get(selectedToolUseId);
         if (pending) {
             return {
                 toolUseId: pending.toolUseId,
@@ -1032,7 +1057,7 @@ export class CodexProcess extends EventEmitter {
                 input: { ...pending.input },
             };
         }
-        const pendingAsk = this.resolvePendingUserInput(toolUseId);
+        const pendingAsk = this.pendingUserInputs.get(selectedToolUseId);
         if (!pendingAsk)
             return undefined;
         return {
@@ -1041,6 +1066,11 @@ export class CodexProcess extends EventEmitter {
             input: { ...pendingAsk.input },
         };
     }
+    getPendingPermissions() {
+        return this.pendingRequestIdsInOrder()
+            .map((toolUseId) => this.getPendingPermission(toolUseId))
+            .filter((request) => request !== undefined);
+    }
     /** Emit a synthetic tool_result so history replay can match it to a permission_request. */
     emitToolResult(toolUseId, content, permissionOutcome) {
         this.emitMessage({
@@ -1056,6 +1086,39 @@ export class CodexProcess extends EventEmitter {
         const first = this.pendingApprovals.values().next();
         return first.done ? undefined : first.value;
     }
+    rememberPendingRequest(toolUseId) {
+        this.pendingRequestOrder.set(toolUseId, this.nextPendingRequestOrder++);
+    }
+    forgetPendingRequest(toolUseId) {
+        this.pendingRequestOrder.delete(toolUseId);
+    }
+    oldestPendingRequestId() {
+        return this.pendingRequestIdsInOrder()[0];
+    }
+    pendingRequestIdsInOrder() {
+        const pendingIds = new Set([
+            ...this.pendingApprovals.keys(),
+            ...this.pendingUserInputs.keys(),
+            ...(this.pendingPlanCompletion
+                ? [this.pendingPlanCompletion.toolUseId]
+                : []),
+        ]);
+        return [...pendingIds].sort((a, b) => (this.pendingRequestOrder.get(a) ?? Number.MAX_SAFE_INTEGER) -
+            (this.pendingRequestOrder.get(b) ?? Number.MAX_SAFE_INTEGER));
+    }
+    oldestApprovalCompatibleRequestId() {
+        const pendingIds = new Set([
+            ...this.pendingApprovals.keys(),
+            ...[...this.pendingUserInputs.values()]
+                .filter((request) => request.kind !== "questions")
+                .map((request) => request.toolUseId),
+            ...(this.pendingPlanCompletion
+                ? [this.pendingPlanCompletion.toolUseId]
+                : []),
+        ]);
+        return [...pendingIds].sort((a, b) => (this.pendingRequestOrder.get(a) ?? Number.MAX_SAFE_INTEGER) -
+            (this.pendingRequestOrder.get(b) ?? Number.MAX_SAFE_INTEGER))[0];
+    }
     resolvePendingUserInput(toolUseId) {
         if (toolUseId)
             return this.pendingUserInputs.get(toolUseId);
@@ -1070,7 +1133,7 @@ export class CodexProcess extends EventEmitter {
      */
     approveUserInput(toolUseId, result) {
         const pending = this.resolvePendingUserInput(toolUseId);
-        if (!pending)
+        if (!pending || pending.kind === "questions")
             return false;
         if (pending.kind === "tool_suggestion") {
             if (pending.input.installState === "needs_auth") {
@@ -1082,6 +1145,7 @@ export class CodexProcess extends EventEmitter {
             return true;
         }
         this.pendingUserInputs.delete(pending.toolUseId);
+        this.forgetPendingRequest(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
         this.emitToolResult(pending.toolUseId, "Approved", result === "Allow for this session"
             ? "approved_for_session"
@@ -1104,6 +1168,7 @@ export class CodexProcess extends EventEmitter {
     }
     resolveToolSuggestion(pending, toolResult) {
         this.pendingUserInputs.delete(pending.toolUseId);
+        this.forgetPendingRequest(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, {
             action: "accept",
             content: null,
@@ -1125,9 +1190,10 @@ export class CodexProcess extends EventEmitter {
      */
     rejectUserInput(toolUseId, result) {
         const pending = this.resolvePendingUserInput(toolUseId);
-        if (!pending)
+        if (!pending || pending.kind === "questions")
             return false;
         this.pendingUserInputs.delete(pending.toolUseId);
+        this.forgetPendingRequest(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, resolveUserInputRejectResult(pending, result)));
         this.emitToolResult(pending.toolUseId, "Rejected", "rejected");
         if (this.pendingApprovals.size === 0 &&
@@ -1147,6 +1213,8 @@ export class CodexProcess extends EventEmitter {
         const planText = this.pendingPlanCompletion?.planText ?? "";
         const resolvedToolUseId = this.pendingPlanCompletion?.toolUseId;
         this.pendingPlanCompletion = null;
+        if (resolvedToolUseId)
+            this.forgetPendingRequest(resolvedToolUseId);
         this._collaborationMode = "default";
         console.log("[codex-process] Plan approved, switching to Default mode");
         // Emit synthetic tool_result so history replay knows this approval is resolved
@@ -1172,6 +1240,8 @@ export class CodexProcess extends EventEmitter {
     handlePlanRejected(feedback) {
         const resolvedToolUseId = this.pendingPlanCompletion?.toolUseId;
         this.pendingPlanCompletion = null;
+        if (resolvedToolUseId)
+            this.forgetPendingRequest(resolvedToolUseId);
         console.log("[codex-process] Plan rejected, continuing in Plan mode");
         // Stay in Plan mode
         // Emit synthetic tool_result so history replay knows this approval is resolved
@@ -1882,6 +1952,7 @@ export class CodexProcess extends EventEmitter {
                         ? { reason: params.reason }
                         : {}),
                 };
+                this.rememberPendingRequest(toolUseId);
                 this.pendingApprovals.set(toolUseId, {
                     requestId: id,
                     toolUseId,
@@ -1909,6 +1980,7 @@ export class CodexProcess extends EventEmitter {
                         ? { reason: params.reason }
                         : {}),
                 };
+                this.rememberPendingRequest(toolUseId);
                 this.pendingApprovals.set(toolUseId, {
                     requestId: id,
                     toolUseId,
@@ -1940,6 +2012,7 @@ export class CodexProcess extends EventEmitter {
                         isSecret: q.isSecret,
                     })),
                 };
+                this.rememberPendingRequest(toolUseId);
                 this.pendingUserInputs.set(toolUseId, {
                     requestId: id,
                     toolUseId,
@@ -1947,6 +2020,7 @@ export class CodexProcess extends EventEmitter {
                     questions: questions.map((q) => ({
                         id: q.id,
                         question: q.question,
+                        isSecret: q.isSecret,
                     })),
                     input,
                     kind: "questions",
@@ -1971,6 +2045,7 @@ export class CodexProcess extends EventEmitter {
                         ? { reason: params.reason }
                         : {}),
                 };
+                this.rememberPendingRequest(toolUseId);
                 this.pendingApprovals.set(toolUseId, {
                     requestId: id,
                     toolUseId,
@@ -1994,6 +2069,7 @@ export class CodexProcess extends EventEmitter {
                 const toolName = elicitation.kind === "tool_suggestion"
                     ? "ToolSuggestion"
                     : "McpElicitation";
+                this.rememberPendingRequest(toolUseId);
                 this.pendingUserInputs.set(toolUseId, {
                     requestId: id,
                     toolUseId,
@@ -2306,6 +2382,7 @@ export class CodexProcess extends EventEmitter {
         // Plan mode: emit synthetic plan approval and wait for user decision
         if (this._collaborationMode === "plan" && this.lastPlanItemText) {
             const toolUseId = `plan_${randomUUID()}`;
+            this.rememberPendingRequest(toolUseId);
             this.pendingPlanCompletion = {
                 toolUseId,
                 planText: this.lastPlanItemText,
@@ -2932,6 +3009,7 @@ export class CodexProcess extends EventEmitter {
         const approval = [...this.pendingApprovals.values()].find((entry) => entry.requestId === requestId);
         if (approval) {
             this.pendingApprovals.delete(approval.toolUseId);
+            this.forgetPendingRequest(approval.toolUseId);
             this.emitMessage({
                 type: "permission_resolved",
                 toolUseId: approval.toolUseId,
@@ -2940,6 +3018,7 @@ export class CodexProcess extends EventEmitter {
         const inputRequest = [...this.pendingUserInputs.values()].find((entry) => entry.requestId === requestId);
         if (inputRequest) {
             this.pendingUserInputs.delete(inputRequest.toolUseId);
+            this.forgetPendingRequest(inputRequest.toolUseId);
             this.emitMessage({
                 type: "permission_resolved",
                 toolUseId: inputRequest.toolUseId,
@@ -2981,6 +3060,49 @@ function buildUserInputResponse(pending, rawResult) {
     }
     return buildElicitationResponse(pending, rawResult);
 }
+/** Keep secret question values out of the replayable transcript. */
+function questionAnswerResultForHistory(pending, rawResult) {
+    if (pending.kind !== "questions" ||
+        !pending.questions.some((question) => question.isSecret)) {
+        return rawResult;
+    }
+    const parsed = parseResultObject(rawResult);
+    const structuredResult = isJsonObjectOrArray(rawResult);
+    const answers = {};
+    for (const [index, question] of pending.questions.entries()) {
+        const candidate = parsed.byId[question.id] ?? parsed.byQuestion[question.question];
+        const fallback = index === 0 && candidate === undefined && !structuredResult
+            ? plainAnswerValue(rawResult)
+            : null;
+        const values = normalizeAnswerValues(candidate ?? fallback);
+        if (question.isSecret) {
+            if (values.length > 0)
+                answers[question.id] = { redacted: true };
+        }
+        else if (values.length > 0) {
+            answers[question.id] = values;
+        }
+    }
+    return JSON.stringify({ answers });
+}
+function isJsonObjectOrArray(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed !== null && typeof parsed === "object";
+    }
+    catch {
+        return false;
+    }
+}
+function plainAnswerValue(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "string" ? parsed : null;
+    }
+    catch {
+        return value;
+    }
+}
 function resolveUserInputRejectResult(pending, fallback) {
     if (pending.kind !== "elicitation_approval")
         return fallback;