@ccpocket/bridge 1.89.0 → 1.90.0

package/dist/codex-process.d.ts

@@ -107,6 +107,8 @@ export interface CodexModelMetadata {
 }
 export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private transport;
+    private reloadingProject;
+    private launchOptions;
     private _status;
     private _threadId;
     private _agentNickname;
@@ -264,6 +266,8 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     listAvailableModelMetadata(): Promise<CodexModelMetadata[]>;
     start(projectPath: string, options?: CodexStartOptions): void;
     initializeOnly(projectPath: string, timeoutMs?: number): Promise<void>;
+    trustProject(projectPath: string): Promise<void>;
+    trustProjectAndReload(projectPath: string): Promise<void>;
     readRateLimits(timeoutMs?: number): Promise<CodexRateLimitsResponse>;
     waitUntilReady(): Promise<void>;
     stop(): void;

package/dist/codex-process.js

@@ -1,3 +1,4 @@
+import { readCodexAppServerMode } from "./codex-app-server-config.js";
 import { CodexRecovery } from "./codex-recovery.js";
 import { EventEmitter } from "node:events";
 import { randomUUID } from "node:crypto";
@@ -63,6 +64,8 @@ function codexAppServerStartError(err) {
 }
 export class CodexProcess extends EventEmitter {
     transport = null;
+    reloadingProject = false;
+    launchOptions;
     _status = "starting";
     _threadId = null;
     _agentNickname = null;
@@ -140,7 +143,7 @@ export class CodexProcess extends EventEmitter {
         return this._status;
     }
     get isWaitingForInput() {
-        return this.inputResolve !== null;
+        return !this.reloadingProject && this.inputResolve !== null;
     }
     getMessageModel() {
         return sanitizeCodexModel(this.startModel) ?? "";
@@ -289,7 +292,7 @@ export class CodexProcess extends EventEmitter {
     cancelRecovery() { this.manualInputVersion++; this.recovery.cancel(); }
     noteManualInput() { this.manualInputVersion++; this.recovery.manualInput(); }
     canDispatchRecovery() {
-        return !this.stopped && this._threadId !== null && this.inputResolve !== null &&
+        return !this.stopped && !this.reloadingProject && this._threadId !== null && this.inputResolve !== null &&
             this.pendingTurnId === null && this.pendingTurnCompletion === null &&
             this.pendingApprovals.size === 0 && !this.hasBlockingUserInput() &&
             this.pendingPlanCompletion === null && this._pendingPlanInput === null;
@@ -620,6 +623,7 @@ export class CodexProcess extends EventEmitter {
         if (this.transport) {
             this.stop();
         }
+        this.launchOptions = options ? { ...options } : undefined;
         this.resetReadiness();
         this.prepareLaunch(projectPath, options);
         this.launchAppServer(projectPath, options);
@@ -642,6 +646,55 @@ export class CodexProcess extends EventEmitter {
             throw error;
         }
     }
+    async trustProject(projectPath) {
+        const response = await this.request("config/value/write", {
+            keyPath: `projects.${JSON.stringify(projectPath)}.trust_level`,
+            value: "trusted",
+            mergeStrategy: "replace",
+        });
+        if (response.overriddenMetadata != null)
+            throw new Error("Project trust is overridden by a higher-priority configuration");
+    }
+    async trustProjectAndReload(projectPath) {
+        if (readCodexAppServerMode() !== "private")
+            throw new Error("Live trust reload requires a private Codex app-server. Shared app-server sessions must be reopened after configuring project trust.");
+        if (!this._threadId || this.status !== "idle" || this.pendingTurnId || this.pendingApprovals.size || this.pendingUserInputs.size || this._pendingPlanInput) {
+            throw new Error("Wait until the Codex session is idle before trusting this project");
+        }
+        const options = {
+            ...this.launchOptions,
+            threadId: this._threadId,
+            model: this.model,
+            modelReasoningEffort: this._runtimeModelReasoningEffort,
+            serviceTier: this._runtimeServiceTier ?? undefined,
+            approvalPolicy: this._approvalPolicy,
+            approvalsReviewer: this._approvalsReviewer,
+            codexPermissionsMode: this._codexPermissionsMode,
+            collaborationMode: this._collaborationMode,
+        };
+        const recoveryEnabled = this.recovery.state.enabled;
+        this.reloadingProject = true;
+        this.setStatus("starting");
+        try {
+            await this.trustProject(projectPath);
+            await this._completionFetchInFlight;
+            // Only this session's transport is replaced. Late events from the old
+            // process must not clear the new transport or mark the session stopped.
+            this.transport?.removeAllListeners();
+            this.stop();
+            this.reloadingProject = false;
+            this.start(projectPath, options);
+            await this.waitUntilReady();
+            this.setRecoveryEnabled(recoveryEnabled);
+        }
+        catch (error) {
+            this.reloadingProject = false;
+            this.setStatus("idle");
+            if (this.inputResolve)
+                this.emit("input_ready");
+            throw error;
+        }
+    }
     async readRateLimits(timeoutMs = 10_000) {
         return (await this.request("account/rateLimits/read", undefined, timeoutMs));
     }