@ccpocket/bridge 1.71.0 → 1.72.1

package/dist/codex-process.d.ts

@@ -284,10 +284,10 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
             path: string;
         }>;
     }): Promise<void>;
-    approve(toolUseId?: string): void;
-    approveAlways(toolUseId?: string): void;
-    reject(toolUseId?: string, _message?: string): void;
-    answer(toolUseId: string, result: string): void;
+    approve(toolUseId?: string): boolean;
+    approveAlways(toolUseId?: string): boolean;
+    reject(toolUseId?: string, _message?: string): boolean;
+    answer(toolUseId: string, result: string): boolean;
     /**
      * Install a plugin or begin connector authentication proposed by Codex.
      * The elicitation remains pending while external app authentication is
@@ -326,6 +326,7 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private handlePlanRejected;
     private bootstrap;
     private resolveWritableRootsConfig;
+    private readConfigPermissions;
     private initializeRpcConnection;
     readProfileConfig(cwd?: string): Promise<CodexProfileConfig>;
     readConfigRequirements(): Promise<CodexConfigRequirements>;

package/dist/codex-process.js

@@ -1,7 +1,8 @@
 import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
+import { realpathSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { rm, writeFile } from "node:fs/promises";
 import { createCodexTransport, buildCodexSpawnSpec, } from "./codex-transport.js";
 import { codexCliJoinTarget } from "./codex-app-server-config.js";
@@ -144,7 +145,7 @@ export class CodexProcess extends EventEmitter {
         return this.transport?.isRunning ?? false;
     }
     get approvalPolicy() {
-        return this._approvalPolicy ?? "on-request";
+        return approvalPolicyForClient(this._approvalPolicy);
     }
     get approvalsReviewer() {
         return normalizeApprovalsReviewerForClient(this._approvalsReviewer);
@@ -595,73 +596,78 @@ export class CodexProcess extends EventEmitter {
         if (this.pendingPlanCompletion &&
             toolUseId === this.pendingPlanCompletion.toolUseId) {
             this.handlePlanApproved();
-            return;
+            return true;
         }
         const pending = this.resolvePendingApproval(toolUseId);
         if (!pending) {
             // Fallback: McpElicitation lives in pendingUserInputs
             if (this.approveUserInput(toolUseId, "Accept"))
-                return;
+                return true;
             console.log("[codex-process] approve() called but no pending permission requests");
-            return;
+            return false;
         }
         this.pendingApprovals.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "accept"));
-        this.emitToolResult(pending.toolUseId, "Approved");
+        this.emitToolResult(pending.toolUseId, "Approved", "approved");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
         }
+        return true;
     }
     approveAlways(toolUseId) {
         const pending = this.resolvePendingApproval(toolUseId);
         if (!pending) {
             // Fallback: McpElicitation lives in pendingUserInputs
-            if (this.approveUserInput(toolUseId, "Allow for this session"))
-                return;
+            if (this.approveUserInput(toolUseId, "Allow for this session")) {
+                return true;
+            }
             console.log("[codex-process] approveAlways() called but no pending permission requests");
-            return;
+            return false;
         }
         this.pendingApprovals.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, "acceptForSession"));
-        this.emitToolResult(pending.toolUseId, "Approved (always)");
+        this.emitToolResult(pending.toolUseId, "Approved (always)", "approved_for_session");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
         }
+        return true;
     }
     reject(toolUseId, _message) {
         // Check if this is a plan completion rejection
         if (this.pendingPlanCompletion &&
             toolUseId === this.pendingPlanCompletion.toolUseId) {
             this.handlePlanRejected(_message);
-            return;
+            return true;
         }
         const pending = this.resolvePendingApproval(toolUseId);
         if (!pending) {
             // Fallback: McpElicitation lives in pendingUserInputs
             if (this.rejectUserInput(toolUseId, "Decline"))
-                return;
+                return true;
             console.log("[codex-process] reject() called but no pending permission requests");
-            return;
+            return false;
         }
         this.pendingApprovals.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildApprovalResponse(pending, resolveApprovalRejectDecision(pending)));
-        this.emitToolResult(pending.toolUseId, "Rejected");
+        this.emitToolResult(pending.toolUseId, "Rejected", "rejected");
         if (this.pendingApprovals.size === 0) {
             this.setStatus("running");
         }
+        return true;
     }
     answer(toolUseId, result) {
         const pending = this.resolvePendingUserInput(toolUseId);
         if (!pending) {
             console.log("[codex-process] answer() called but no pending AskUserQuestion");
-            return;
+            return false;
         }
         this.pendingUserInputs.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
-        this.emitToolResult(pending.toolUseId, "Answered");
+        this.emitToolResult(pending.toolUseId, "Answered", "answered");
         if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
             this.setStatus("running");
         }
+        return true;
     }
     /**
      * Install a plugin or begin connector authentication proposed by Codex.
@@ -780,11 +786,12 @@ export class CodexProcess extends EventEmitter {
         };
     }
     /** Emit a synthetic tool_result so history replay can match it to a permission_request. */
-    emitToolResult(toolUseId, content) {
+    emitToolResult(toolUseId, content, permissionOutcome) {
         this.emitMessage({
             type: "tool_result",
             toolUseId,
             content,
+            ...(permissionOutcome ? { permissionOutcome } : {}),
         });
     }
     resolvePendingApproval(toolUseId) {
@@ -820,7 +827,9 @@ export class CodexProcess extends EventEmitter {
         }
         this.pendingUserInputs.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, result));
-        this.emitToolResult(pending.toolUseId, "Approved");
+        this.emitToolResult(pending.toolUseId, "Approved", result === "Allow for this session"
+            ? "approved_for_session"
+            : "approved");
         if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
             this.setStatus("running");
         }
@@ -860,7 +869,7 @@ export class CodexProcess extends EventEmitter {
             return false;
         this.pendingUserInputs.delete(pending.toolUseId);
         this.respondToServerRequest(pending.requestId, buildUserInputResponse(pending, resolveUserInputRejectResult(pending, result)));
-        this.emitToolResult(pending.toolUseId, "Rejected");
+        this.emitToolResult(pending.toolUseId, "Rejected", "rejected");
         if (this.pendingApprovals.size === 0 && this.pendingUserInputs.size === 0) {
             this.setStatus("running");
         }
@@ -929,12 +938,21 @@ export class CodexProcess extends EventEmitter {
                 ? (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;
+            // thread/resume preserves the thread's prior permission overrides when
+            // these fields are omitted. Custom mode and named profiles mean the
+            // current config.toml should win, so resolve it and pass the effective
+            // values explicitly on resume.
+            const configResumePermissions = options?.threadId &&
+                (effectiveCodexPermissionsMode === "custom" || options.profile)
+                ? await this.readConfigPermissions(projectPath, options.profile)
+                : undefined;
+            const effectiveApprovalsReviewer = autoReviewDisabled
+                ? "user"
+                : (configResumePermissions?.approvalsReviewer ??
+                    options?.approvalsReviewer);
             if (autoReviewDisabled) {
                 console.warn("[codex-process] Auto-review disabled by managed Browser Use policy");
             }
@@ -943,15 +961,17 @@ export class CodexProcess extends EventEmitter {
                     ? undefined
                     : normalizeApprovalsReviewerForAppServer(effectiveApprovalsReviewer);
             this._codexPermissionsMode = effectiveCodexPermissionsMode;
-            const requestedApprovalPolicy = options?.approvalPolicy
-                ? normalizeApprovalPolicy(options.approvalPolicy)
+            const configuredApprovalPolicy = configResumePermissions?.approvalPolicy ?? options?.approvalPolicy;
+            const requestedApprovalPolicy = configuredApprovalPolicy
+                ? normalizeApprovalPolicyForRpc(configuredApprovalPolicy)
                 : undefined;
             const requestedApprovalsReviewer = effectiveApprovalsReviewer === undefined
                 ? undefined
                 : normalizeApprovalsReviewerForAppServer(effectiveApprovalsReviewer);
             const requestedClientApprovalsReviewer = normalizeApprovalsReviewerForClient(effectiveApprovalsReviewer);
-            const requestedSandboxMode = options?.sandboxMode
-                ? normalizeSandboxMode(options.sandboxMode)
+            const configuredSandboxMode = configResumePermissions?.sandboxMode ?? options?.sandboxMode;
+            const requestedSandboxMode = configuredSandboxMode
+                ? normalizeSandboxMode(configuredSandboxMode)
                 : undefined;
             const threadParams = {
                 cwd: projectPath,
@@ -1025,14 +1045,15 @@ export class CodexProcess extends EventEmitter {
                 this.startModel = thread.model;
             }
             const resolvedSettings = extractResolvedSettingsFromThreadResponse(response);
+            const activeApprovalPolicy = resolvedSettings.approvalPolicy ?? requestedApprovalPolicy;
             const resolvedApprovalsReviewer = autoReviewDisabled
                 ? "user"
                 : resolvedSettings.approvalsReviewer;
             if (resolvedSettings.model) {
                 this.startModel = resolvedSettings.model;
             }
-            if (resolvedSettings.approvalPolicy) {
-                this._approvalPolicy = resolvedSettings.approvalPolicy;
+            if (activeApprovalPolicy) {
+                this._approvalPolicy = activeApprovalPolicy;
             }
             if (resolvedApprovalsReviewer) {
                 this._approvalsReviewer = normalizeApprovalsReviewerForAppServer(resolvedApprovalsReviewer);
@@ -1049,9 +1070,9 @@ export class CodexProcess extends EventEmitter {
                 ...(sanitizeCodexModel(this.startModel)
                     ? { model: sanitizeCodexModel(this.startModel) }
                     : {}),
-                ...(resolvedSettings.approvalPolicy ?? options?.approvalPolicy
+                ...(activeApprovalPolicy
                     ? {
-                        approvalPolicy: resolvedSettings.approvalPolicy ?? requestedApprovalPolicy,
+                        approvalPolicy: approvalPolicyForClient(activeApprovalPolicy),
                     }
                     : {}),
                 ...(resolvedApprovalsReviewer ?? effectiveApprovalsReviewer
@@ -1121,6 +1142,14 @@ export class CodexProcess extends EventEmitter {
         const configuredRoots = extractWritableRootsFromConfigRead(response);
         return normalizeWritableRoots([...configuredRoots, ...normalizedAdditional], this.platform);
     }
+    async readConfigPermissions(projectPath, profile) {
+        const projectLookupPaths = resolveConfigProjectLookupPaths(projectPath);
+        const response = await this.request("config/read", {
+            includeLayers: false,
+            cwd: projectPath,
+        });
+        return extractPermissionsFromConfigRead(response, projectLookupPaths, this.platform, profile);
+    }
     async initializeRpcConnection() {
         await this.request("initialize", {
             clientInfo: {
@@ -1365,7 +1394,7 @@ export class CodexProcess extends EventEmitter {
                     input,
                 };
                 if (this._approvalPolicy) {
-                    params.approvalPolicy = normalizeApprovalPolicy(this._approvalPolicy);
+                    params.approvalPolicy = normalizeApprovalPolicyForRpc(this._approvalPolicy);
                 }
                 if (this._approvalsReviewer) {
                     params.approvalsReviewer = normalizeApprovalsReviewerForAppServer(this._approvalsReviewer);
@@ -2591,6 +2620,122 @@ function extractWritableRootsFromConfigRead(response) {
         return [];
     return writableRoots.filter((root) => typeof root === "string");
 }
+function extractPermissionsFromConfigRead(response, projectLookupPaths, platform, profile) {
+    const config = asRecord(asRecord(response)?.config);
+    const profiles = asRecord(config?.profiles);
+    const configuredDefaultProfile = typeof config?.profile === "string" && config.profile.trim()
+        ? config.profile.trim()
+        : undefined;
+    const requestedProfile = profile?.trim() || undefined;
+    const selectedProfile = requestedProfile ?? configuredDefaultProfile;
+    const profileConfig = selectedProfile
+        ? asRecord(profiles?.[selectedProfile])
+        : undefined;
+    const configuredValue = (key) => profileConfig?.[key] ?? config?.[key];
+    const projectTrust = findProjectTrust(config, projectLookupPaths, platform);
+    return {
+        approvalPolicy: parseConfigApprovalPolicy(configuredValue("approval_policy")) ??
+            (projectTrust === "untrusted" ? "untrusted" : "on-request"),
+        approvalsReviewer: parseConfigApprovalsReviewer(configuredValue("approvals_reviewer")) ??
+            "user",
+        sandboxMode: parseConfigSandboxMode(configuredValue("sandbox_mode")) ??
+            (projectTrust !== undefined && platform !== "win32"
+                ? "workspace-write"
+                : "read-only"),
+    };
+}
+function findProjectTrust(config, projectLookupPaths, platform) {
+    const projects = asRecord(config?.projects);
+    if (!projects)
+        return undefined;
+    const projectEntries = Object.entries(projects);
+    for (const lookupPath of projectLookupPaths) {
+        const normalizedLookupPath = normalizeConfigPath(lookupPath, platform);
+        for (const [configuredPath, rawProject] of projectEntries) {
+            if (normalizeConfigPath(configuredPath, platform) !== normalizedLookupPath) {
+                continue;
+            }
+            const trustLevel = asRecord(rawProject)?.trust_level;
+            if (trustLevel === "trusted" || trustLevel === "untrusted") {
+                return trustLevel;
+            }
+        }
+    }
+    return undefined;
+}
+function resolveConfigProjectLookupPaths(projectPath) {
+    const lookupPaths = new Set();
+    let canonicalPath;
+    try {
+        canonicalPath = realpathSync(projectPath);
+        lookupPaths.add(canonicalPath);
+        lookupPaths.add(projectPath);
+    }
+    catch {
+        return [projectPath];
+    }
+    let candidate = canonicalPath;
+    while (true) {
+        try {
+            statSync(join(candidate, ".git"));
+            lookupPaths.add(candidate);
+            break;
+        }
+        catch {
+            const parent = dirname(candidate);
+            if (parent === candidate)
+                break;
+            candidate = parent;
+        }
+    }
+    return [...lookupPaths];
+}
+function normalizeConfigPath(value, platform) {
+    const normalized = resolvePlatformPath(value, platform);
+    return platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function parseConfigApprovalPolicy(value) {
+    switch (value) {
+        case "never":
+        case "on-request":
+        case "on-failure":
+        case "untrusted":
+            return value;
+        default:
+            return isGranularApprovalPolicy(value) ? { ...value } : undefined;
+    }
+}
+function isGranularApprovalPolicy(value) {
+    const granular = asRecord(asRecord(value)?.granular);
+    return (granular !== undefined &&
+        typeof granular.sandbox_approval === "boolean" &&
+        typeof granular.rules === "boolean" &&
+        typeof granular.mcp_elicitations === "boolean" &&
+        (granular.skill_approval === undefined ||
+            typeof granular.skill_approval === "boolean") &&
+        (granular.request_permissions === undefined ||
+            typeof granular.request_permissions === "boolean"));
+}
+function parseConfigApprovalsReviewer(value) {
+    switch (value) {
+        case "user":
+        case "auto_review":
+        case "guardian_subagent":
+            return value;
+        default:
+            return undefined;
+    }
+}
+function parseConfigSandboxMode(value) {
+    switch (value) {
+        case "read-only":
+        case "workspace-write":
+        case "danger-full-access":
+            return value;
+        default:
+            return undefined;
+    }
+}
 function normalizeWritableRoots(roots, platform) {
     const normalized = new Map();
     for (const root of roots) {
@@ -2618,6 +2763,16 @@ function normalizeApprovalPolicy(value) {
             return "never";
     }
 }
+function normalizeApprovalPolicyForRpc(value) {
+    return typeof value === "string" ? normalizeApprovalPolicy(value) : value;
+}
+function approvalPolicyForClient(value) {
+    // Mobile's legacy mode model cannot represent granular policies. They still
+    // request approval conditionally, so on-request is the closest UI projection.
+    return typeof value === "string"
+        ? value
+        : "on-request";
+}
 function normalizeApprovalsReviewerForAppServer(value) {
     switch (value) {
         case "auto_review":
@@ -2738,9 +2893,7 @@ function extractResolvedSettingsFromThreadResponse(response) {
     return {
         model: sanitizeCodexModel(response.model)
             ?? sanitizeCodexModel(thread?.model),
-        approvalPolicy: typeof response.approvalPolicy === "string"
-            ? response.approvalPolicy
-            : undefined,
+        approvalPolicy: parseConfigApprovalPolicy(response.approvalPolicy),
         approvalsReviewer: typeof response.approvalsReviewer === "string"
             ? response.approvalsReviewer
             : undefined,