@bitkyc08/opencodex 2.66.0 → 2.67.0

package/src/oauth/store.ts

@@ -765,7 +765,7 @@ function serializeMutation<T>(work: () => Promise<T>, retainedValues: readonly u
   drainOAuthMutations();
   return result;
 }
-export function mutateStore<T>(fn:(store:AuthStore)=>T|Promise<T>, retainedValues: readonly unknown[] = [], options?: { waitMs?: number; assertBeforePersist?: () => void; scrubLegacyBackup?: (result: T) => readonly string[] }):Promise<T>{return serializeMutation(async()=>{const guard=await createOAuthFileLock({path:getAuthStoreLockPath(),staleAfterMs:30000}).acquire();try{
+export function mutateStore<T>(fn:(store:AuthStore)=>T|Promise<T>, retainedValues: readonly unknown[] = [], options?: { waitMs?: number; assertBeforePersist?: () => void; scrubLegacyBackup?: (result: T) => readonly string[]; finalizeResult?: (result: T, store: AuthStore) => void }):Promise<T>{return serializeMutation(async()=>{const guard=await createOAuthFileLock({path:getAuthStoreLockPath(),staleAfterMs:30000}).acquire();try{
     const { store, hadLegacy } = loadAuthStoreInternal();
     if (hadLegacy) backupLegacyOnce();
     const selections = new Map(Object.entries(store).map(([provider, set]) => [provider, {
@@ -798,6 +798,9 @@ export function mutateStore<T>(fn:(store:AuthStore)=>T|Promise<T>, retainedValue
         changedProviders.push(provider);
       }
     }
+    // Receipt-producing mutations need the revision assigned by the bookkeeping above, not the
+    // provisional value visible inside their callback. Finalization cannot await or mutate disk.
+    options?.finalizeResult?.(result, store);
     persist(store);
     if (scrubbedProviders.length > 0) scrubLegacyBackup(scrubbedProviders);
     for (const provider of changedProviders) publishAccountSelection(provider, "oauth");
@@ -819,63 +822,132 @@ export function getCredential(provider: string): OAuthCredentials | null {
  * active slot / whole set instead. An explicit add-account login can preserve the legacy slot;
  * an identity-less credential then gets its deterministic refresh-derived account id.
  */
-export async function saveCredential(
+export interface OAuthCredentialWriteReceipt {
+  provider: string;
+  accountId: string;
+  credentialGeneration: string;
+  selectionRevision: string | undefined;
+  previousActiveAccountId: string | undefined;
+  previousAccount: ProviderAccount | undefined;
+}
+
+export async function saveCredentialWithReceipt(
   provider: string,
   cred: OAuthCredentials,
   opts: { preserveIdentityless?: boolean; assertBeforePersist?: () => void } = {},
-): Promise<void> {
+): Promise<OAuthCredentialWriteReceipt | null> {
   const safe = normalizeCredential(cred);
-  if (!safe) return;
-  await mutateStore(store => {
+  if (!safe) return null;
+  return await mutateStore(store => {
     const set = store[provider];
+    const previousActiveAccountId = set?.activeAccountId;
+    const previousAccounts = new Map(
+      set?.accounts.map(account => [account.id, structuredClone(account)]) ?? [],
+    );
     // Login explicitly selects an account, including a re-login to the same slot.
     if (set) set.selectionRevision = randomUUID();
     const identity = safe.accountId ?? safe.email;
+    let accountId: string;
     if (!set || SINGLE_SLOT_PROVIDERS.has(provider)) {
       const id = newAccountId(safe);
       store[provider] = { activeAccountId: id, accounts: [{ id, credential: safe, addedAt: Date.now() }] };
-      return;
-    }
-    if (identity) {
+      accountId = id;
+    } else if (identity) {
       const existing = set.accounts.find(a => (a.credential.accountId ?? a.credential.email) === identity);
       if (existing) {
         existing.credential = safe;
         delete existing.needsReauth;
         set.activeAccountId = existing.id;
-        return;
+        accountId = existing.id;
+      } else {
+        // Legacy migration: a pre-identity row (no accountId/email) for this provider is the
+        // SAME human re-logging in after the identity extraction shipped — upgrading the
+        // active identity-less row in place prevents a stale duplicate that stays selectable
+        // and would re-refresh into a second row with the same identity.
+        const active = set.accounts.find(a => a.id === set.activeAccountId);
+        if (!opts.preserveIdentityless && active && active.credential.accountId === undefined && active.credential.email === undefined) {
+          active.credential = safe;
+          delete active.needsReauth;
+          accountId = active.id;
+        } else {
+          const id = distinctAccountId(safe, set.accounts);
+          set.accounts.push({ id, credential: safe, addedAt: Date.now() });
+          set.activeAccountId = id;
+          accountId = id;
+        }
       }
-      // Legacy migration: a pre-identity row (no accountId/email) for this provider is the
-      // SAME human re-logging in after the identity extraction shipped — upgrading the
-      // active identity-less row in place prevents a stale duplicate that stays selectable
-      // and would re-refresh into a second row with the same identity.
+    } else if (opts.preserveIdentityless) {
+      const id = distinctAccountId(safe, set.accounts);
+      set.accounts.push({ id, credential: safe, addedAt: Date.now() });
+      set.activeAccountId = id;
+      accountId = id;
+    } else {
+      // No identity during a normal login: replace the active slot in place.
       const active = set.accounts.find(a => a.id === set.activeAccountId);
-      if (!opts.preserveIdentityless && active && active.credential.accountId === undefined && active.credential.email === undefined) {
+      if (active) {
         active.credential = safe;
         delete active.needsReauth;
-        return;
+        accountId = active.id;
+      } else {
+        const id = distinctAccountId(safe, set.accounts);
+        set.accounts.push({ id, credential: safe, addedAt: Date.now() });
+        set.activeAccountId = id;
+        accountId = id;
       }
-      const id = distinctAccountId(safe, set.accounts);
-      set.accounts.push({ id, credential: safe, addedAt: Date.now() });
-      set.activeAccountId = id;
-      return;
     }
-    if (opts.preserveIdentityless) {
-      const id = distinctAccountId(safe, set.accounts);
-      set.accounts.push({ id, credential: safe, addedAt: Date.now() });
-      set.activeAccountId = id;
-      return;
+    return {
+      provider,
+      accountId,
+      credentialGeneration: credentialGeneration(safe),
+      selectionRevision: store[provider]?.selectionRevision,
+      previousActiveAccountId,
+      previousAccount: previousAccounts.get(accountId),
+    };
+  }, [provider, safe], {
+    assertBeforePersist: opts.assertBeforePersist,
+    finalizeResult: (receipt, store) => {
+      receipt.selectionRevision = store[provider]?.selectionRevision;
+    },
+  });
+}
+
+/** Ordinary callers do not acquire rollback authority merely by saving a credential. */
+export async function saveCredential(
+  provider: string,
+  cred: OAuthCredentials,
+  opts: { preserveIdentityless?: boolean; assertBeforePersist?: () => void } = {},
+): Promise<void> {
+  await saveCredentialWithReceipt(provider, cred, opts);
+}
+
+/** Compensate one owned login write without deleting or selecting over concurrent work. */
+export async function rollbackCredentialWriteIfMatch(
+  receipt: OAuthCredentialWriteReceipt,
+): Promise<"rolled-back" | "stale"> {
+  return await mutateStore(store => {
+    const set = store[receipt.provider];
+    const index = set?.accounts.findIndex(account => account.id === receipt.accountId) ?? -1;
+    if (!set || index < 0) return "stale" as const;
+    const current = set.accounts[index]!;
+    if (credentialGeneration(current.credential) !== receipt.credentialGeneration) return "stale" as const;
+    // A later explicit selection of the same account owns that choice. Do not remove or rewrite
+    // the selected slot underneath it; the failed login can report failure without erasing newer state.
+    if (set.activeAccountId === receipt.accountId
+      && set.selectionRevision !== receipt.selectionRevision) return "stale" as const;
+
+    if (receipt.previousAccount) set.accounts[index] = structuredClone(receipt.previousAccount);
+    else set.accounts.splice(index, 1);
+    if (set.accounts.length === 0) {
+      delete store[receipt.provider];
+      return "rolled-back" as const;
     }
-    // No identity during a normal login: replace the active slot in place.
-    const active = set.accounts.find(a => a.id === set.activeAccountId);
-    if (active) {
-      active.credential = safe;
-      delete active.needsReauth;
-    } else {
-      const id = distinctAccountId(safe, set.accounts);
-      set.accounts.push({ id, credential: safe, addedAt: Date.now() });
-      set.activeAccountId = id;
+    if (set.activeAccountId === receipt.accountId) {
+      const previousStillExists = receipt.previousActiveAccountId
+        && set.accounts.some(account => account.id === receipt.previousActiveAccountId);
+      set.activeAccountId = previousStillExists ? receipt.previousActiveAccountId! : set.accounts[0]!.id;
     }
-  }, [provider, safe], { assertBeforePersist: opts.assertBeforePersist });
+    return "rolled-back" as const;
+  }, [receipt]);
 }
 
 /**

package/src/remote-control/workspace-rpc.ts

@@ -16,15 +16,30 @@ import {
   frameRemoteWorkspaceRpcMessage,
 } from "./workspace-rpc-framing";
 
-const REMOTE_WORKSPACE_RPC_VERSION = 1 as const;
-const REMOTE_WORKSPACE_RPC_DEFAULT_TIMEOUT_MS = 30_000;
+// Old endpoints execute request frames immediately and cannot safely participate in prepare/grant.
+const REMOTE_WORKSPACE_RPC_VERSION = 2 as const;
+const REMOTE_WORKSPACE_RPC_DEFAULT_TIMEOUT_MS = 65_000;
+const REMOTE_WORKSPACE_RPC_MAX_TIMEOUT_MS = 120_000;
 const REMOTE_WORKSPACE_RPC_MAX_ACTIVE_REQUESTS = 8;
 interface RemoteWorkspaceRpcRequest {
   version: typeof REMOTE_WORKSPACE_RPC_VERSION;
-  kind: "request";
+  kind: "prepare";
+  timeoutMs: number;
   request: RemoteWorkspaceExecutionRequest;
 }
 
+interface RemoteWorkspaceRpcCancel {
+  version: typeof REMOTE_WORKSPACE_RPC_VERSION;
+  kind: "cancel";
+  requestId: string;
+}
+
+interface RemoteWorkspaceRpcGrant {
+  version: typeof REMOTE_WORKSPACE_RPC_VERSION;
+  kind: "grant";
+  requestId: string;
+}
+
 interface RemoteWorkspaceRpcResponse {
   version: typeof REMOTE_WORKSPACE_RPC_VERSION;
   kind: "response";
@@ -32,7 +47,7 @@ interface RemoteWorkspaceRpcResponse {
   result: RemoteWorkspaceToolResult;
 }
 
-type RemoteWorkspaceRpcMessage = RemoteWorkspaceRpcRequest | RemoteWorkspaceRpcResponse;
+type RemoteWorkspaceRpcMessage = RemoteWorkspaceRpcRequest | RemoteWorkspaceRpcResponse | RemoteWorkspaceRpcCancel | RemoteWorkspaceRpcGrant;
 
 interface PendingRequest {
   resolve(value: RemoteWorkspaceToolResult): void;
@@ -101,8 +116,14 @@ function parseMessage(value: Uint8Array): RemoteWorkspaceRpcMessage {
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("invalid remote workspace RPC message");
   const raw = parsed as Record<string, unknown>;
   if (raw.version !== REMOTE_WORKSPACE_RPC_VERSION) throw new Error("unsupported remote workspace RPC version");
-  if (raw.kind === "request") {
-    return { version: REMOTE_WORKSPACE_RPC_VERSION, kind: "request", request: parseRequest(raw.request) };
+  if (raw.kind === "prepare" && Number.isSafeInteger(raw.timeoutMs)
+    && (raw.timeoutMs as number) >= 1 && (raw.timeoutMs as number) <= REMOTE_WORKSPACE_RPC_MAX_TIMEOUT_MS) {
+    return {
+      version: REMOTE_WORKSPACE_RPC_VERSION,
+      kind: "prepare",
+      timeoutMs: raw.timeoutMs as number,
+      request: parseRequest(raw.request),
+    };
   }
   if (raw.kind === "response" && boundedIdentifier(raw.requestId)) {
     return {
@@ -112,6 +133,9 @@ function parseMessage(value: Uint8Array): RemoteWorkspaceRpcMessage {
       result: parseResult(raw.result),
     };
   }
+  if ((raw.kind === "cancel" || raw.kind === "grant") && boundedIdentifier(raw.requestId)) {
+    return { version: REMOTE_WORKSPACE_RPC_VERSION, kind: raw.kind, requestId: raw.requestId };
+  }
   throw new Error("invalid remote workspace RPC message kind");
 }
 
@@ -132,7 +156,8 @@ export class EncryptedRemoteWorkspaceTransport implements RemoteWorkspaceTranspo
 
   constructor(private readonly options: EncryptedRemoteWorkspaceTransportOptions) {
     this.timeoutMs = options.timeoutMs ?? REMOTE_WORKSPACE_RPC_DEFAULT_TIMEOUT_MS;
-    if (!boundedIdentifier(options.executorDeviceId) || !Number.isSafeInteger(this.timeoutMs) || this.timeoutMs < 1) {
+    if (!boundedIdentifier(options.executorDeviceId) || !Number.isSafeInteger(this.timeoutMs)
+      || this.timeoutMs < 1 || this.timeoutMs > REMOTE_WORKSPACE_RPC_MAX_TIMEOUT_MS) {
       throw new Error("invalid encrypted remote workspace transport options");
     }
   }
@@ -150,22 +175,38 @@ export class EncryptedRemoteWorkspaceTransport implements RemoteWorkspaceTranspo
     const response = new Promise<RemoteWorkspaceToolResult>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(request.requestId);
-        reject(new Error("remote workspace request timed out"));
+        void this.sendCancellation(request.requestId);
+        reject(new Error("remote workspace request timed out; executor cancellation was requested"));
       }, this.timeoutMs);
       this.pending.set(request.requestId, { resolve, reject, timer });
     });
+    const pending = this.pending.get(request.requestId)!;
+    // Observe the response immediately: transport backpressure must not defer timeout delivery
+    // or leave a rejected response promise unobserved while a write is still waiting to settle.
+    void this.prepareAndGrant(request, pending);
+    return await response;
+  }
+
+  private async prepareAndGrant(request: RemoteWorkspaceExecutionRequest, pending: PendingRequest): Promise<void> {
     try {
       await this.sendMessage(encodeMessage({
         version: REMOTE_WORKSPACE_RPC_VERSION,
-        kind: "request",
+        kind: "prepare",
+        timeoutMs: this.timeoutMs,
         request,
       }));
+      // Check again inside the serialized send queue: another write can delay this grant after
+      // prepare has settled. A request that has already timed out must never receive a grant.
+      await this.sendMessage(encodeMessage({
+        version: REMOTE_WORKSPACE_RPC_VERSION,
+        kind: "grant",
+        requestId: request.requestId,
+      }), () => this.pending.get(request.requestId) === pending);
     } catch {
       // A failed encrypted write consumes a directional counter. Continuing would make every
       // later frame undecryptable, so fail every pending operation instead of waiting for timeout.
       this.close("remote workspace send failed");
     }
-    return await response;
   }
 
   receiveCiphertext(value: Uint8Array): void {
@@ -193,8 +234,9 @@ export class EncryptedRemoteWorkspaceTransport implements RemoteWorkspaceTranspo
     this.pending.clear();
   }
 
-  private sendMessage(message: Uint8Array): Promise<void> {
+  private sendMessage(message: Uint8Array, shouldSend: () => boolean = () => true): Promise<void> {
     const operation = this.sendTail.then(async () => {
+      if (!shouldSend()) return;
       if (!this.online) throw new Error("remote workspace transport is closed");
       for (const frame of frameRemoteWorkspaceRpcMessage(message)) {
         await this.options.sendCiphertext(this.options.cipher.encrypt(frame));
@@ -203,6 +245,19 @@ export class EncryptedRemoteWorkspaceTransport implements RemoteWorkspaceTranspo
     this.sendTail = operation.catch(() => {});
     return operation;
   }
+
+  private async sendCancellation(requestId: string): Promise<void> {
+    try {
+      await this.sendMessage(encodeMessage({
+        version: REMOTE_WORKSPACE_RPC_VERSION,
+        kind: "cancel",
+        requestId,
+      }));
+    } catch {
+      // A failed encrypted write consumes the send counter; the session cannot safely continue.
+      this.close("remote workspace cancellation send failed");
+    }
+  }
 }
 
 export interface EncryptedRemoteWorkspaceExecutorEndpointOptions {
@@ -218,7 +273,12 @@ export interface EncryptedRemoteWorkspaceExecutorEndpointOptions {
 /** Executor-side endpoint. It accepts only authenticated, ordered E2EE session frames. */
 export class EncryptedRemoteWorkspaceExecutorEndpoint {
   private closed = false;
-  private readonly active = new Map<string, AbortController>();
+  private readonly active = new Map<string, {
+    controller: AbortController;
+    timer: ReturnType<typeof setTimeout>;
+    request: RemoteWorkspaceExecutionRequest;
+    started: boolean;
+  }>();
   private readonly reassembler = new RemoteWorkspaceRpcReassembler();
   private sendTail: Promise<void> = Promise.resolve();
 
@@ -240,7 +300,26 @@ export class EncryptedRemoteWorkspaceExecutorEndpoint {
     const requestPlaintext = this.reassembler.accept(this.options.cipher.decrypt(value));
     if (!requestPlaintext) return;
     const message = parseMessage(requestPlaintext);
-    if (message.kind !== "request") throw new Error("executor received a remote workspace response");
+    if (message.kind === "cancel") {
+      const active = this.active.get(message.requestId);
+      if (active) {
+        active.controller.abort();
+        if (!active.started) {
+          clearTimeout(active.timer);
+          this.active.delete(message.requestId);
+        }
+      }
+      return;
+    }
+    if (message.kind === "grant") {
+      const active = this.active.get(message.requestId);
+      if (!active || active.controller.signal.aborted) return;
+      if (active.started) throw new Error("duplicate remote workspace execution grant");
+      active.started = true;
+      await this.executeGranted(active.request, active.controller, active.timer);
+      return;
+    }
+    if (message.kind !== "prepare") throw new Error("executor received a remote workspace response");
     if (message.request.executorDeviceId !== this.options.executorDeviceId) {
       throw new Error("remote workspace encrypted request targeted another executor");
     }
@@ -255,12 +334,25 @@ export class EncryptedRemoteWorkspaceExecutorEndpoint {
       throw new Error("remote workspace executor request limit reached");
     }
     const controller = new AbortController();
-    this.active.set(message.request.requestId, controller);
+    const timer = setTimeout(() => {
+      controller.abort();
+      const active = this.active.get(message.request.requestId);
+      if (active && !active.started) this.active.delete(message.request.requestId);
+    }, message.timeoutMs);
+    this.active.set(message.request.requestId, { controller, timer, request: message.request, started: false });
+  }
+
+  private async executeGranted(
+    request: RemoteWorkspaceExecutionRequest,
+    controller: AbortController,
+    timer: ReturnType<typeof setTimeout>,
+  ): Promise<void> {
     let result: RemoteWorkspaceToolResult;
     try {
-      result = await this.options.executor.invoke(message.request, controller.signal);
+      result = await this.options.executor.invoke(request, controller.signal);
     } finally {
-      this.active.delete(message.request.requestId);
+      clearTimeout(timer);
+      this.active.delete(request.requestId);
     }
     if (this.closed) return;
     let responsePlaintext: Uint8Array;
@@ -268,14 +360,14 @@ export class EncryptedRemoteWorkspaceExecutorEndpoint {
       responsePlaintext = encodeMessage({
         version: REMOTE_WORKSPACE_RPC_VERSION,
         kind: "response",
-        requestId: message.request.requestId,
+        requestId: request.requestId,
         result,
       });
     } catch {
       responsePlaintext = encodeMessage({
         version: REMOTE_WORKSPACE_RPC_VERSION,
         kind: "response",
-        requestId: message.request.requestId,
+        requestId: request.requestId,
         result: { ok: false, error: "remote workspace result exceeded the encrypted frame limit" },
       });
     }
@@ -286,7 +378,10 @@ export class EncryptedRemoteWorkspaceExecutorEndpoint {
     if (this.closed) return;
     this.closed = true;
     this.reassembler.clear();
-    for (const controller of this.active.values()) controller.abort();
+    for (const active of this.active.values()) {
+      clearTimeout(active.timer);
+      active.controller.abort();
+    }
     this.active.clear();
     this.options.cipher.destroy();
   }

package/src/router.ts

@@ -627,6 +627,7 @@ function routeModelInternal(
   bypassCombos: boolean,
   policyEvidence?: PolicyRequestEvidence,
   allowCompactionNativeFallback = false,
+  preview = false,
 ): RouteResult {
   const slash = modelId.indexOf("/");
   // Policy namespace is system-reserved: an explicit `policy/<id>` or a
@@ -694,7 +695,7 @@ function routeModelInternal(
   }
 
   if (!bypassCombos && !preservesPhysicalComboProvider(config)) {
-    const combo = tryPickComboModel(config, modelId);
+    const combo = tryPickComboModel(config, modelId, preview);
     if (combo) {
       const concrete = `${combo.target.provider}/${combo.target.model}`;
       // The selected target is already a concrete provider/model reference. Resolve it without
@@ -894,6 +895,11 @@ export function routeModel(
   return routeWithDecisionTrace(config, modelId, route);
 }
 
+/** Resolve a route for capability inspection without creating combo selection state. */
+export function previewRouteModel(config: OcxConfig, modelId: string): RouteResult {
+  return routeWithDecisionTrace(config, modelId, routeModelInternal(config, modelId, false, undefined, false, true));
+}
+
 /**
  * Route a client-selected compaction model. Codex may send a bare native model
  * even when its ordinary turns are configured for another provider; in that

package/src/server/chat-completions.ts

@@ -341,7 +341,8 @@ async function handleChatCompletionsWithBudget(
   } else if (internalBody.store === undefined) {
     internalBody.store = false;
   }
-  if (settledRoute && internalBody.reasoning !== undefined) {
+  if (settledRoute && !settledRoute.combo && settledRoute.routeKind !== "policy"
+    && internalBody.reasoning !== undefined) {
     const { stripEmptyLadderEffort, supportedLadderFor } = await import("./effort-policy");
     const ladder = supportedLadderFor({ provider: settledRoute.provider, modelId: settledRoute.modelId });
     const next = stripEmptyLadderEffort(internalBody.reasoning, ladder);

package/src/server/index/claude-intercept-lifecycle.ts

@@ -1,6 +1,10 @@
 import type { Server } from "bun";
+import type { OcxConfig } from "../../types";
 import type { PickerRouteInput } from "../../claude/intercept/picker-models";
+import { observeClaudeDesktopMode, type ClaudeDesktopModeObservation } from "../../claude/desktop-first-party";
+import { firstPartyDesired, type ClaudeFirstPartyDesired } from "../../claude/first-party-settings";
 import {
+  claudeInterceptEnabled,
   startClaudeIntercept,
   type ClaudeInterceptHandle,
   type StartClaudeInterceptOptions,
@@ -19,6 +23,12 @@ export interface ClaudeInterceptLifecycle<T> {
   stop(): Promise<void>;
 }
 
+export function buildInterceptDesiredClients(config: OcxConfig, observed: ClaudeDesktopModeObservation): () => ClaudeFirstPartyDesired {
+  return () => claudeInterceptEnabled(config)
+    ? firstPartyDesired(config, observed)
+    : { desktop: false, cli: false };
+}
+
 /**
  * Routes for Desktop's Code-tab picker: the same inputs `/api/sync` gives the gateway profile
  * (src/server/management/config-routes.ts), read from the persisted config at call time. Dynamic
@@ -48,8 +58,11 @@ export function createClaudeInterceptLifecycle<T>(): ClaudeInterceptLifecycle<T>
     ownsListener: requestServer => listener !== null && requestServer === listener,
     start(options) {
       const dispatch = options.dispatch;
+      const observed = observeClaudeDesktopMode(options.config);
       pending = startClaudeIntercept<T>({
         ...options,
+        // A disabled Claude surface relays everything while the bound listener lives until restart.
+        desiredClients: buildInterceptDesiredClients(options.config, observed),
         loadPickerRoutes: options.loadPickerRoutes ?? loadPickerRoutesFromCatalog,
         dispatch: (req, requestServer) => {
           listener ??= requestServer;