@ccpocket/bridge 1.80.0 → 1.80.2

package/dist/codex-process.d.ts

@@ -112,6 +112,9 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private _agentRole;
     private stopped;
     private startModel;
+    private readiness;
+    private readinessError;
+    private readinessWaiters;
     private inputResolve;
     private pendingTurnId;
     private pendingTurnCompletion;
@@ -243,6 +246,7 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     listAvailableModelMetadata(): Promise<CodexModelMetadata[]>;
     start(projectPath: string, options?: CodexStartOptions): void;
     initializeOnly(projectPath: string): Promise<void>;
+    waitUntilReady(): Promise<void>;
     stop(): void;
     private prepareLaunch;
     private launchAppServer;
@@ -355,6 +359,9 @@ export declare class CodexProcess extends EventEmitter<CodexProcessEvents> {
     private respondToServerRequestError;
     private writeEnvelope;
     private rejectAllPending;
+    private resetReadiness;
+    private resolveReadiness;
+    private rejectReadiness;
     private setStatus;
     private emitMessage;
     private extractToolUseId;

package/dist/codex-process.js

@@ -6,6 +6,7 @@ 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";
+import { normalizeCodexServiceTierForClient, normalizeCodexServiceTierForRpc, } from "./codex-service-tier.js";
 import { resolvePlatformPath } from "./path-utils.js";
 export { buildCodexSpawnSpec };
 const DEFAULT_CODEX_MODEL = "gpt-5.5";
@@ -32,7 +33,7 @@ export function isCodexThreadWriterConflict(error) {
 }
 export function codexErrorMessage(error) {
     if (isCodexThreadWriterConflict(error)) {
-        return "This Codex thread is already open in another client. Close it there and try again.";
+        return "This Codex thread is already open in Codex Desktop or the Codex App. Close it there, then try again.";
     }
     return error instanceof Error ? error.message : String(error);
 }
@@ -63,6 +64,9 @@ export class CodexProcess extends EventEmitter {
     _agentRole = null;
     stopped = false;
     startModel;
+    readiness = "pending";
+    readinessError;
+    readinessWaiters = new Set();
     inputResolve = null;
     pendingTurnId = null;
     pendingTurnCompletion = null;
@@ -186,7 +190,7 @@ export class CodexProcess extends EventEmitter {
     }
     /** Update Codex speed for the next turn without restarting the thread. */
     setServiceTier(serviceTier) {
-        this._runtimeServiceTier = normalizeServiceTier(serviceTier);
+        this._runtimeServiceTier = normalizeCodexServiceTierForRpc(serviceTier);
         console.log(`[codex-process] Speed changed to: ${this.serviceTier}`);
     }
     /**
@@ -406,6 +410,7 @@ export class CodexProcess extends EventEmitter {
         if (this.transport) {
             this.stop();
         }
+        this.resetReadiness();
         this.prepareLaunch(projectPath, options);
         this.launchAppServer(projectPath, options);
         void this.bootstrap(projectPath, options);
@@ -414,13 +419,32 @@ export class CodexProcess extends EventEmitter {
         if (this.transport) {
             this.stop();
         }
-        this.prepareLaunch(projectPath);
-        this.launchAppServer(projectPath);
-        await this.initializeRpcConnection();
-        this.setStatus("idle");
+        this.resetReadiness();
+        try {
+            this.prepareLaunch(projectPath);
+            this.launchAppServer(projectPath);
+            await this.initializeRpcConnection();
+            this.setStatus("idle");
+            this.resolveReadiness();
+        }
+        catch (error) {
+            this.rejectReadiness(error);
+            throw error;
+        }
+    }
+    waitUntilReady() {
+        if (this.readiness === "ready")
+            return Promise.resolve();
+        if (this.readiness === "failed") {
+            return Promise.reject(this.readinessError);
+        }
+        return new Promise((resolve, reject) => {
+            this.readinessWaiters.add({ resolve, reject });
+        });
     }
     stop() {
         this.stopped = true;
+        this.rejectReadiness(new Error("codex app-server stopped"));
         if (this.inputResolve) {
             this.inputResolve({ text: "" });
             this.inputResolve = null;
@@ -453,7 +477,7 @@ export class CodexProcess extends EventEmitter {
         this._runtimeServiceTier =
             options?.serviceTier === undefined
                 ? undefined
-                : normalizeServiceTier(options.serviceTier);
+                : normalizeCodexServiceTierForRpc(options.serviceTier);
         this._approvalPolicy = options?.approvalPolicy;
         this._approvalsReviewer =
             options?.approvalsReviewer === undefined
@@ -996,7 +1020,7 @@ export class CodexProcess extends EventEmitter {
             if (requestedModel)
                 threadParams.model = requestedModel;
             if (options?.serviceTier !== undefined) {
-                threadParams.serviceTier = normalizeServiceTier(options.serviceTier);
+                threadParams.serviceTier = normalizeCodexServiceTierForRpc(options.serviceTier);
             }
             if (requestedReasoningEffort) {
                 // app-server applies reasoning effort on thread start via config overrides,
@@ -1094,7 +1118,7 @@ export class CodexProcess extends EventEmitter {
                     : requestedReasoningEffort
                         ? { modelReasoningEffort: requestedReasoningEffort }
                         : {}),
-                serviceTier: normalizeServiceTierForClient(resolvedSettings.serviceTier ?? options?.serviceTier),
+                serviceTier: normalizeCodexServiceTierForClient(resolvedSettings.serviceTier ?? options?.serviceTier),
                 ...(resolvedSettings.networkAccessEnabled !== undefined
                     ? { networkAccessEnabled: resolvedSettings.networkAccessEnabled }
                     : {}),
@@ -1107,6 +1131,7 @@ export class CodexProcess extends EventEmitter {
                 ...(cliJoin ? { codexCliJoin: cliJoin } : {}),
             });
             this.setStatus("idle");
+            this.resolveReadiness();
             // Fetch completion entities in background (non-blocking).
             this._projectPath = projectPath;
             setTimeout(() => {
@@ -1117,6 +1142,7 @@ export class CodexProcess extends EventEmitter {
             await this.runInputLoop(options);
         }
         catch (err) {
+            this.rejectReadiness(err);
             if (!this.stopped) {
                 const message = codexErrorMessage(err);
                 console.error("[codex-process] bootstrap error:", err);
@@ -2543,6 +2569,26 @@ export class CodexProcess extends EventEmitter {
             this.pendingTurnCompletion = null;
         }
     }
+    resetReadiness() {
+        this.rejectReadiness(new Error("codex app-server restarted"));
+        this.readiness = "pending";
+        this.readinessError = undefined;
+    }
+    resolveReadiness() {
+        if (this.readiness !== "pending")
+            return;
+        this.readiness = "ready";
+        for (const waiter of this.readinessWaiters)
+            waiter.resolve();
+        this.readinessWaiters.clear();
+    }
+    rejectReadiness(error) {
+        this.readiness = "failed";
+        this.readinessError = error;
+        for (const waiter of this.readinessWaiters)
+            waiter.reject(error);
+        this.readinessWaiters.clear();
+    }
     setStatus(status) {
         if (this._status !== status) {
             this._status = status;
@@ -2893,18 +2939,6 @@ function extractServiceTiers(raw) {
     }
     return tiers;
 }
-function normalizeServiceTier(value) {
-    const normalized = value.trim();
-    return !normalized || normalized === "standard" || normalized === "default"
-        ? null
-        : normalized;
-}
-function normalizeServiceTierForClient(value) {
-    if (typeof value !== "string")
-        return "standard";
-    const normalized = value.trim();
-    return !normalized || normalized === "default" ? "standard" : normalized;
-}
 function sanitizeCodexModel(value) {
     if (typeof value !== "string")
         return undefined;