@ccpocket/bridge 1.68.2 → 1.69.1

package/dist/codex-process.d.ts

@@ -16,6 +16,11 @@ export interface CodexStartOptions {
     networkAccessEnabled?: boolean;
     webSearchMode?: "disabled" | "cached" | "live";
     collaborationMode?: "plan" | "default";
+    /**
+     * Managed Browser Use policy cached by Bridge metadata loading.
+     * `null` means app-server must read the policy before starting the thread.
+     */
+    autoReviewDisabledByPolicy?: boolean | null;
 }
 export interface CodexProcessEvents {
     message: [ServerMessage];
@@ -73,10 +78,25 @@ export interface CodexThreadSummary {
     name: string | null;
 }
 export type CodexThreadSourceKind = "cli" | "vscode" | "exec" | "appServer" | "subAgent" | "subAgentReview" | "subAgentCompact" | "subAgentThreadSpawn" | "subAgentOther" | "unknown";
+export declare class CodexRpcError extends Error {
+    readonly method: string;
+    readonly code: number | undefined;
+    readonly data: unknown;
+    constructor(method: string, error: {
+        code?: number;
+        message?: string;
+        data?: unknown;
+    });
+}
+export declare function isCodexThreadWriterConflict(error: unknown): boolean;
+export declare function codexErrorMessage(error: unknown): string;
 export interface CodexProfileConfig {
     profiles: string[];
     defaultProfile?: string;
 }
+export interface CodexConfigRequirements {
+    autoReviewDisabled: boolean;
+}
 export interface CodexModelMetadata {
     model: string;
     supportedReasoningEfforts: string[];
@@ -120,6 +140,7 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private _approvalPolicy;
     private _approvalsReviewer;
     private _codexPermissionsMode;
+    private _autoReviewDisabledByPolicy;
     private _collaborationMode;
     private _runtimeModel;
     private _runtimeModelReasoningEffort;
@@ -129,6 +150,8 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private lastResultText;
     /** Agent text received as deltas but not yet confirmed by item/completed. */
     private readonly pendingAgentTextByItemId;
+    /** Agent text confirmed by item/completed during the active turn. */
+    private readonly confirmedAgentTextByItemId;
     /** Suppresses late item/completed events after synthetic fallbacks. */
     private readonly syntheticAgentTextByItemId;
     private pendingPlanCompletion;
@@ -300,6 +323,7 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private resolveWritableRootsConfig;
     private initializeRpcConnection;
     readProfileConfig(cwd?: string): Promise<CodexProfileConfig>;
+    readConfigRequirements(): Promise<CodexConfigRequirements>;
     private fetchCompletionEntities;
     private scheduleCompletionFetchFromNotification;
     private _fetchCompletionEntitiesInternal;
@@ -312,6 +336,7 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private handleNotification;
     private isForeignThreadNotification;
     private handleTurnCompleted;
+    private prepareTurnCompletionAgentSummary;
     private finalizePendingAgentText;
     private cleanupSteerTempPaths;
     private processItemStarted;

package/dist/codex-process.js

@@ -11,6 +11,29 @@ const DEFAULT_CODEX_MODEL = "gpt-5.5";
 const COMPLETION_FETCH_COOLDOWN_MS = 1000;
 const UNKNOWN_AGENT_ITEM_ID = "__unknown_agent_message__";
 const CODEX_CLI_NOT_FOUND_MESSAGE = "Codex CLI is not installed or not available on PATH on the Bridge machine. Install it with `curl -fsSL https://chatgpt.com/codex/install.sh | sh`, then restart Bridge.";
+export class CodexRpcError extends Error {
+    method;
+    code;
+    data;
+    constructor(method, error) {
+        super(error.message ?? `RPC error ${error.code ?? ""}`.trim());
+        this.name = "CodexRpcError";
+        this.method = method;
+        this.code = error.code;
+        this.data = error.data;
+    }
+}
+export function isCodexThreadWriterConflict(error) {
+    return (error instanceof CodexRpcError &&
+        error.code === -32600 &&
+        /\b(active|live local)\s+writer\b/i.test(error.message));
+}
+export function codexErrorMessage(error) {
+    if (isCodexThreadWriterConflict(error)) {
+        return "This Codex thread is already open in another client. Close it there and try again.";
+    }
+    return error instanceof Error ? error.message : String(error);
+}
 function isCodexCliNotFoundError(err) {
     const code = err.code;
     return (code === "ENOENT" ||
@@ -71,6 +94,7 @@ export class CodexProcess extends EventEmitter {
     _approvalPolicy = undefined;
     _approvalsReviewer = undefined;
     _codexPermissionsMode;
+    _autoReviewDisabledByPolicy = false;
     _collaborationMode = "default";
     _runtimeModel;
     _runtimeModelReasoningEffort;
@@ -80,6 +104,8 @@ export class CodexProcess extends EventEmitter {
     lastResultText = null;
     /** Agent text received as deltas but not yet confirmed by item/completed. */
     pendingAgentTextByItemId = new Map();
+    /** Agent text confirmed by item/completed during the active turn. */
+    confirmedAgentTextByItemId = new Map();
     /** Suppresses late item/completed events after synthetic fallbacks. */
     syntheticAgentTextByItemId = new Map();
     pendingPlanCompletion = null;
@@ -169,7 +195,9 @@ export class CodexProcess extends EventEmitter {
      * Takes effect on the next `turn/start` RPC call.
      */
     setApprovalsReviewer(reviewer) {
-        this._approvalsReviewer = normalizeApprovalsReviewerForAppServer(reviewer);
+        this._approvalsReviewer = this._autoReviewDisabledByPolicy
+            ? "user"
+            : normalizeApprovalsReviewerForAppServer(reviewer);
         console.log(`[codex-process] Approvals reviewer changed to: ${this.approvalsReviewer}`);
     }
     /**
@@ -425,6 +453,8 @@ export class CodexProcess extends EventEmitter {
                 ? undefined
                 : normalizeApprovalsReviewerForAppServer(options.approvalsReviewer);
         this._codexPermissionsMode = options?.codexPermissionsMode;
+        this._autoReviewDisabledByPolicy =
+            options?.autoReviewDisabledByPolicy === true;
         this._collaborationMode = options?.collaborationMode ?? "default";
         this.lastPlanItemText = null;
         this.lastResultText = null;
@@ -434,6 +464,7 @@ export class CodexProcess extends EventEmitter {
         this._lastCompletionEntitiesSignature = null;
         this._launchStartedAt = Date.now();
         this.pendingAgentTextByItemId.clear();
+        this.confirmedAgentTextByItemId.clear();
         this.syntheticAgentTextByItemId.clear();
         this.pendingPlanCompletion = null;
         this._pendingPlanInput = null;
@@ -888,13 +919,31 @@ export class CodexProcess extends EventEmitter {
     async bootstrap(projectPath, options) {
         try {
             await this.initializeRpcConnection();
+            const autoReviewDisabled = options?.autoReviewDisabledByPolicy === null
+                ? (await this.readConfigRequirements()).autoReviewDisabled
+                : options?.autoReviewDisabledByPolicy === true;
+            this._autoReviewDisabledByPolicy = autoReviewDisabled;
+            const effectiveApprovalsReviewer = autoReviewDisabled
+                ? "user"
+                : options?.approvalsReviewer;
+            const effectiveCodexPermissionsMode = autoReviewDisabled && options?.codexPermissionsMode === "autoReview"
+                ? "default"
+                : options?.codexPermissionsMode;
+            if (autoReviewDisabled) {
+                console.warn("[codex-process] Auto-review disabled by managed Browser Use policy");
+            }
+            this._approvalsReviewer =
+                effectiveApprovalsReviewer === undefined
+                    ? undefined
+                    : normalizeApprovalsReviewerForAppServer(effectiveApprovalsReviewer);
+            this._codexPermissionsMode = effectiveCodexPermissionsMode;
             const requestedApprovalPolicy = options?.approvalPolicy
                 ? normalizeApprovalPolicy(options.approvalPolicy)
                 : undefined;
-            const requestedApprovalsReviewer = options?.approvalsReviewer === undefined
+            const requestedApprovalsReviewer = effectiveApprovalsReviewer === undefined
                 ? undefined
-                : normalizeApprovalsReviewerForAppServer(options.approvalsReviewer);
-            const requestedClientApprovalsReviewer = normalizeApprovalsReviewerForClient(options?.approvalsReviewer);
+                : normalizeApprovalsReviewerForAppServer(effectiveApprovalsReviewer);
+            const requestedClientApprovalsReviewer = normalizeApprovalsReviewerForClient(effectiveApprovalsReviewer);
             const requestedSandboxMode = options?.sandboxMode
                 ? normalizeSandboxMode(options.sandboxMode)
                 : undefined;
@@ -970,14 +1019,17 @@ export class CodexProcess extends EventEmitter {
                 this.startModel = thread.model;
             }
             const resolvedSettings = extractResolvedSettingsFromThreadResponse(response);
+            const resolvedApprovalsReviewer = autoReviewDisabled
+                ? "user"
+                : resolvedSettings.approvalsReviewer;
             if (resolvedSettings.model) {
                 this.startModel = resolvedSettings.model;
             }
             if (resolvedSettings.approvalPolicy) {
                 this._approvalPolicy = resolvedSettings.approvalPolicy;
             }
-            if (resolvedSettings.approvalsReviewer) {
-                this._approvalsReviewer = normalizeApprovalsReviewerForAppServer(resolvedSettings.approvalsReviewer);
+            if (resolvedApprovalsReviewer) {
+                this._approvalsReviewer = normalizeApprovalsReviewerForAppServer(resolvedApprovalsReviewer);
             }
             this._threadId = threadId;
             this._agentNickname = stringOrNull(thread?.agentNickname);
@@ -996,18 +1048,18 @@ export class CodexProcess extends EventEmitter {
                         approvalPolicy: resolvedSettings.approvalPolicy ?? requestedApprovalPolicy,
                     }
                     : {}),
-                ...(resolvedSettings.approvalsReviewer ?? options?.approvalsReviewer
+                ...(resolvedApprovalsReviewer ?? effectiveApprovalsReviewer
                     ? {
-                        approvalsReviewer: resolvedSettings.approvalsReviewer
-                            ? normalizeApprovalsReviewerForClient(resolvedSettings.approvalsReviewer)
+                        approvalsReviewer: resolvedApprovalsReviewer
+                            ? normalizeApprovalsReviewerForClient(resolvedApprovalsReviewer)
                             : requestedClientApprovalsReviewer,
                     }
                     : {}),
                 ...(resolvedSettings.sandboxMode ?? options?.sandboxMode
                     ? { sandboxMode: resolvedSettings.sandboxMode ?? requestedSandboxMode }
                     : {}),
-                ...(options?.codexPermissionsMode
-                    ? { codexPermissionsMode: options.codexPermissionsMode }
+                ...(effectiveCodexPermissionsMode
+                    ? { codexPermissionsMode: effectiveCodexPermissionsMode }
                     : {}),
                 ...(resolvedSettings.modelReasoningEffort
                     ? { modelReasoningEffort: resolvedSettings.modelReasoningEffort }
@@ -1038,7 +1090,7 @@ export class CodexProcess extends EventEmitter {
         }
         catch (err) {
             if (!this.stopped) {
-                const message = err instanceof Error ? err.message : String(err);
+                const message = codexErrorMessage(err);
                 console.error("[codex-process] bootstrap error:", err);
                 this.emitMessage({ type: "error", message: `Codex error: ${message}` });
                 this.emitMessage({
@@ -1090,6 +1142,23 @@ export class CodexProcess extends EventEmitter {
                 : undefined,
         };
     }
+    async readConfigRequirements() {
+        try {
+            const response = (await this.request("configRequirements/read"));
+            const requirements = asRecord(response.requirements);
+            const browserUse = asRecord(requirements?.browserUse ?? requirements?.browser_use);
+            return {
+                autoReviewDisabled: (browserUse?.disableAutoReview ??
+                    browserUse?.disable_auto_review) === true,
+            };
+        }
+        catch (err) {
+            if (err instanceof CodexRpcError && err.code === -32601) {
+                return { autoReviewDisabled: false };
+            }
+            throw err;
+        }
+    }
     async fetchCompletionEntities(projectPath) {
         if (this._completionFetchInFlight) {
             return this._completionFetchInFlight;
@@ -1403,8 +1472,7 @@ export class CodexProcess extends EventEmitter {
             return;
         this.pendingRpc.delete(envelope.id);
         if ("error" in envelope && envelope.error) {
-            const message = envelope.error.message ?? `RPC error ${envelope.error.code ?? ""}`;
-            pending.reject(new Error(message));
+            pending.reject(new CodexRpcError(pending.method, envelope.error));
             return;
         }
         pending.resolve(envelope.result);
@@ -1606,6 +1674,7 @@ export class CodexProcess extends EventEmitter {
                 }
                 this.lastResultText = null;
                 this.pendingAgentTextByItemId.clear();
+                this.confirmedAgentTextByItemId.clear();
                 this.syntheticAgentTextByItemId.clear();
                 this.setStatus("running");
                 break;
@@ -1737,10 +1806,24 @@ export class CodexProcess extends EventEmitter {
                 const message = stringValue(params.message);
                 if (!message)
                     break;
-                if (isInformationalGuardianApproval(message)) {
+                const approval = parseGuardianApproval(message);
+                if (approval?.risk === "low" &&
+                    isLowRiskAllowDecision(approval.reason)) {
                     console.debug("[codex-process] suppressed informational guardian approval notification");
                     break;
                 }
+                if (approval &&
+                    (approval.risk === "medium" || approval.risk === "high")) {
+                    this.emitMessage({
+                        type: "guardian_approval",
+                        risk: approval.risk,
+                        reason: approval.reason,
+                        ...(approval.authorization
+                            ? { authorization: approval.authorization }
+                            : {}),
+                    });
+                    break;
+                }
                 this.emitMessage({
                     type: "error",
                     errorCode: "codex_warning",
@@ -1791,7 +1874,11 @@ export class CodexProcess extends EventEmitter {
     }
     handleTurnCompleted(turn) {
         const status = String(turn?.status ?? "completed");
+        if (status === "completed") {
+            this.prepareTurnCompletionAgentSummary(turn);
+        }
         this.finalizePendingAgentText();
+        this.confirmedAgentTextByItemId.clear();
         const usage = this.lastTokenUsage;
         this.lastTokenUsage = null;
         if (status === "failed") {
@@ -1857,6 +1944,41 @@ export class CodexProcess extends EventEmitter {
         }
         this.cleanupSteerTempPaths();
     }
+    prepareTurnCompletionAgentSummary(turn) {
+        if (turn?.itemsView !== "summary" || !Array.isArray(turn.items))
+            return;
+        const summaryItem = [...turn.items]
+            .reverse()
+            .find((item) => typeof item === "object" &&
+            item !== null &&
+            normalizeItemType(item.type) ===
+                "agentmessage" &&
+            Boolean(extractAgentText(item)?.trim()));
+        if (!summaryItem)
+            return;
+        const itemId = typeof summaryItem.id === "string"
+            ? summaryItem.id
+            : UNKNOWN_AGENT_ITEM_ID;
+        const summaryText = extractAgentText(summaryItem);
+        if (!summaryText?.trim())
+            return;
+        const confirmedText = this.confirmedAgentTextByItemId.get(itemId);
+        if (confirmedText !== undefined) {
+            this.pendingAgentTextByItemId.delete(itemId);
+            this.lastResultText = confirmedText;
+            return;
+        }
+        if (itemId !== UNKNOWN_AGENT_ITEM_ID &&
+            !this.pendingAgentTextByItemId.has(itemId)) {
+            const unknownText = this.pendingAgentTextByItemId.get(UNKNOWN_AGENT_ITEM_ID);
+            if (unknownText &&
+                (summaryText.startsWith(unknownText) ||
+                    unknownText.startsWith(summaryText))) {
+                this.pendingAgentTextByItemId.delete(UNKNOWN_AGENT_ITEM_ID);
+            }
+        }
+        this.pendingAgentTextByItemId.set(itemId, summaryText);
+    }
     finalizePendingAgentText() {
         const pendingItems = [...this.pendingAgentTextByItemId.entries()];
         this.pendingAgentTextByItemId.clear();
@@ -1888,11 +2010,6 @@ export class CodexProcess extends EventEmitter {
         const itemType = normalizeItemType(item.type);
         switch (itemType) {
             case "commandexecution": {
-                const commandText = typeof item.command === "string"
-                    ? item.command
-                    : Array.isArray(item.command)
-                        ? item.command.map((part) => String(part)).join(" ")
-                        : "";
                 this.emitMessage({
                     type: "assistant",
                     message: {
@@ -1903,7 +2020,7 @@ export class CodexProcess extends EventEmitter {
                                 type: "tool_use",
                                 id: itemId,
                                 name: "Bash",
-                                input: { command: commandText },
+                                input: commandExecutionToolUseInput(item),
                             },
                         ],
                         model: this.getMessageModel(),
@@ -2021,13 +2138,20 @@ export class CodexProcess extends EventEmitter {
                 const completedText = extractAgentText(item);
                 const hasCompletedText = completedText?.trim().length > 0;
                 const directPendingText = this.pendingAgentTextByItemId.get(itemId);
+                const unknownPendingText = directPendingText === undefined
+                    ? this.pendingAgentTextByItemId.get(UNKNOWN_AGENT_ITEM_ID)
+                    : undefined;
                 const usedUnknownPendingText = !hasCompletedText && directPendingText === undefined;
+                const matchedUnknownPendingText = hasCompletedText &&
+                    Boolean(unknownPendingText &&
+                        (completedText?.startsWith(unknownPendingText) ||
+                            unknownPendingText.startsWith(completedText ?? "")));
                 const pendingText = usedUnknownPendingText
-                    ? (this.pendingAgentTextByItemId.get(UNKNOWN_AGENT_ITEM_ID) ?? "")
+                    ? (unknownPendingText ?? "")
                     : (directPendingText ?? "");
                 const text = hasCompletedText ? completedText : pendingText;
                 this.pendingAgentTextByItemId.delete(itemId);
-                if (usedUnknownPendingText) {
+                if (usedUnknownPendingText || matchedUnknownPendingText) {
                     this.pendingAgentTextByItemId.delete(UNKNOWN_AGENT_ITEM_ID);
                 }
                 if (!text.trim())
@@ -2047,6 +2171,7 @@ export class CodexProcess extends EventEmitter {
                     }
                 }
                 this.syntheticAgentTextByItemId.delete(itemId);
+                this.confirmedAgentTextByItemId.set(itemId, text);
                 this.lastResultText = text;
                 this.emitMessage({
                     type: "assistant",
@@ -2293,7 +2418,7 @@ export class CodexProcess extends EventEmitter {
     }
     request(method, params) {
         const id = this.rpcSeq++;
-        const envelope = { id, method, params };
+        const envelope = params === undefined ? { id, method } : { id, method, params };
         return new Promise((resolve, reject) => {
             this.pendingRpc.set(id, { resolve, reject, method });
             try {
@@ -2736,6 +2861,20 @@ function toToolUseInput(value) {
     }
     return { value };
 }
+function commandExecutionToolUseInput(item) {
+    const command = typeof item.command === "string"
+        ? item.command
+        : Array.isArray(item.command)
+            ? item.command.map((part) => String(part)).join(" ")
+            : "";
+    const pluginId = stringOrNull(item.pluginId ?? item.plugin_id);
+    const scriptPath = stringOrNull(item.scriptPath ?? item.script_path);
+    return {
+        command,
+        ...(pluginId ? { pluginId } : {}),
+        ...(scriptPath ? { scriptPath } : {}),
+    };
+}
 function toImageGenerationToolInput(item) {
     const input = {};
     const status = typeof item.status === "string" ? item.status : undefined;
@@ -3040,9 +3179,34 @@ function parseResultObject(rawResult) {
         return { byId: {}, byQuestion: {} };
     }
 }
-function isInformationalGuardianApproval(message) {
-    const normalized = message.trim().replace(/\s+/g, " ").toLowerCase();
-    return /^automatic approval review approved\b/.test(normalized);
+function parseGuardianApproval(message) {
+    const match = message
+        .trim()
+        .match(/^automatic approval review approved\s*\(([^)]*)\)\s*:\s*([\s\S]+)$/i);
+    if (!match)
+        return null;
+    const metadata = new Map();
+    for (const field of match[1].split(",")) {
+        const separator = field.indexOf(":");
+        if (separator === -1)
+            continue;
+        metadata.set(field.slice(0, separator).trim().toLowerCase(), field.slice(separator + 1).trim());
+    }
+    const risk = metadata.get("risk")?.toLowerCase();
+    const reason = match[2].trim();
+    if (!reason || (risk !== "low" && risk !== "medium" && risk !== "high")) {
+        return null;
+    }
+    const authorization = metadata.get("authorization");
+    return {
+        risk,
+        reason,
+        ...(authorization ? { authorization } : {}),
+    };
+}
+function isLowRiskAllowDecision(reason) {
+    const normalized = reason.trim().replace(/\s+/g, " ");
+    return /^auto-review returned a low[- ]risk allow decision\.?$/i.test(normalized);
 }
 function normalizeAnswerValues(value) {
     if (typeof value === "string") {