diff --git a/packages/renderer-extension/src/renderer-binding-probe.ts b/packages/renderer-extension/src/renderer-binding-probe.ts index c8f6eca47d..eb8b687d42 100644 --- a/packages/renderer-extension/src/renderer-binding-probe.ts +++ b/packages/renderer-extension/src/renderer-binding-probe.ts @@ -603,9 +603,17 @@ interface MountedComposer { hostId: string | null; usageRequestGeneration: number; draftUsageClient: RendererModelClient | null; + draftUsageAccount: RendererCodexAccountState["usageAccount"]; commandRequestGeneration: number; } +interface DraftUsageRequest { + client: RendererModelClient | null; + account: RendererCodexAccountState["usageAccount"]; + generation: number; + pending: boolean; +} + interface MountedCatalogRequest { client: RendererModelClient; hostId: string; @@ -777,10 +785,8 @@ export function installRendererBindingProbe( // composerId belongs to the logical draft and survives DOM replacement. const pendingDefaultPreferences = new Map(); const catalogRequests = new WeakMap(); - const draftUsageRequests = new WeakMap< - MountedComposer, - { client: RendererModelClient | null; generation: number; pending: boolean } - >(); + const draftUsageRequests = new WeakMap(); + const deferredCodexDraftUsage = new WeakSet(); const pendingReplacements = new Map(); let disposed = false; const disposeReasoningSoftWrap = installReasoningTranscriptSoftWrap(document); @@ -926,14 +932,20 @@ export function installRendererBindingProbe( const codexAccountsForHost = (hostId: string | null): RendererCodexAccountState | null => { if (!hostId) return null; const client = modelClientForHost(hostId); - if (!client) return null; + if (!client) { + const state = harnessAvailabilityByHost.get(hostId); + if (state?.codexAccounts) { + state.codexAccounts.dispose(); + state.codexAccounts = null; + } + return null; + } const state = hostHarnessAvailabilityState(hostId); if (state.codexAccounts?.client !== client) { state.codexAccounts?.dispose(); - state.codexAccounts = new RendererCodexAccountState(client, () => { + const accounts = new RendererCodexAccountState(client, () => { queueMicrotask(() => { - if (disposed || hostHarnessAvailabilityState(hostId).codexAccounts?.client !== client) - return; + if (disposed || harnessAvailabilityByHost.get(hostId)?.codexAccounts !== accounts) return; for (const mounted of mountedByComposer.values()) { if (mounted.hostId !== hostId) continue; renderMounted(mounted); @@ -941,6 +953,7 @@ export function installRendererBindingProbe( } }); }); + state.codexAccounts = accounts; } return state.codexAccounts; }; @@ -1058,6 +1071,13 @@ export function installRendererBindingProbe( : "installing"; }; + const clearDraftUsageSnapshot = (mounted: MountedComposer): void => { + mounted.draftUsageAccount = null; + mounted.usage = null; + mounted.accountCredits = null; + mounted.accountCreditsSupported = false; + }; + const renderMounted = (mounted: MountedComposer): void => { if (!isMountedComposer(mounted.composer)) return; restorePendingDraftPreference(mounted); @@ -1070,12 +1090,23 @@ export function installRendererBindingProbe( : EMPTY_PLUGINS, ); const accounts = composerCodexAccounts(mounted.composer); + const selection = controller.get(mounted.composer); + if ( + selection.agent === "codex" && + threadIdFromComposerModelTarget(mounted.modelTarget) === null && + mounted.draftUsageAccount && + mounted.draftUsageAccount !== accounts?.usageAccount + ) { + clearDraftUsageSnapshot(mounted); + mounted.draftUsageClient = null; + mounted.usageRequestGeneration += 1; + } const currentCodexAccount = accounts?.accounts.find( ({ accountId }) => accountId === accounts.readyAccountId, ); const externalSubmissionReady = renderComposerAgentControl( mounted.control, - controller.get(mounted.composer), + selection, composerAdapterState(mounted), controller.isSwitching(mounted.composer) || mounted.ownershipStatus === "loading", composerAvailability(mounted), @@ -1240,35 +1271,43 @@ export function installRendererBindingProbe( } }; + const canRefreshDraftUsage = (mounted: MountedComposer): boolean => + controller.get(mounted.composer).phase === "draft" && + !controller.isSwitching(mounted.composer) && + !controller.isSubmissionPending(mounted.composer) && + threadIdFromComposerModelTarget(mounted.modelTarget) === null; + const refreshDraftUsage = async (mounted: MountedComposer): Promise => { - const state = controller.get(mounted.composer); - if ( - state.phase !== "draft" || - controller.isSwitching(mounted.composer) || - controller.isSubmissionPending(mounted.composer) || - threadIdFromComposerModelTarget(mounted.modelTarget) - ) + const agent = controller.get(mounted.composer).agent; + if (!canRefreshDraftUsage(mounted)) { + if ( + agent === "codex" && + threadIdFromComposerModelTarget(mounted.modelTarget) === null && + controller.isSubmissionPending(mounted.composer) + ) { + deferredCodexDraftUsage.add(mounted); + } return; - const agent = state.agent; + } const accounts = agent === "codex" ? composerCodexAccounts(mounted.composer) : null; - const accountId = accounts?.readyAccountId; + const account = accounts?.usageAccount ?? null; const client = composerClient(mounted); const hostId = mounted.hostId; const previous = draftUsageRequests.get(mounted); - if ( - agent !== "codex" && - previous?.pending && + const sameScope = + previous?.generation === mounted.usageRequestGeneration && previous.client === client && - previous.generation === mounted.usageRequestGeneration - ) - return; + previous.account === account; + if (sameScope && previous.pending) return; + deferredCodexDraftUsage.delete(mounted); const generation = ++mounted.usageRequestGeneration; - const request = { client, generation, pending: true }; + const request: DraftUsageRequest = { client, account, generation, pending: true }; draftUsageRequests.set(mounted, request); mounted.draftUsageClient = null; - mounted.usage = null; - mounted.accountCredits = null; - mounted.accountCreditsSupported = false; + // Keep the last snapshot on screen while the same Codex Account refreshes. + if (account === null || mounted.draftUsageAccount !== account) { + clearDraftUsageSnapshot(mounted); + } renderMounted(mounted); const isCurrent = (): boolean => !disposed && @@ -1277,23 +1316,27 @@ export function installRendererBindingProbe( mounted.composer.isConnected && mountedByComposer.get(mounted.composer) === mounted && mounted.usageRequestGeneration === generation && - controller.get(mounted.composer).agent === agent && - controller.get(mounted.composer).phase === "draft" && - !controller.isSwitching(mounted.composer) && - !controller.isSubmissionPending(mounted.composer) && - !threadIdFromComposerModelTarget(mounted.modelTarget); + controller.get(mounted.composer).agent === agent; try { if (!client) return; if (agent === "codex") { - if (!accountId || !client.inspectCodexAccountUsage) return; - const result = await client.inspectCodexAccountUsage({ accountId }); + if (!account) return; + const usageRequest = accounts?.inspectUsage(account); + if (!usageRequest) return; + const result = await usageRequest; if ( !isCurrent() || - composerCodexAccounts(mounted.composer) !== accounts || - accounts?.readyAccountId !== accountId || - result.accountId !== accountId + composerCodexAccounts(mounted.composer)?.usageAccount !== account || + result.accountId !== account.accountId ) return; + if (!canRefreshDraftUsage(mounted)) { + if (controller.isSubmissionPending(mounted.composer)) + deferredCodexDraftUsage.add(mounted); + return; + } + deferredCodexDraftUsage.delete(mounted); + mounted.draftUsageAccount = account; mounted.usage = result.usage; mounted.accountCredits = result.accountCredits ?? null; } else { @@ -1302,15 +1345,19 @@ export function installRendererBindingProbe( harnessId: harnessIdSchema.parse(agent), refresh: true, }); - if (!isCurrent() || result.harnessId !== agent) return; + if (!isCurrent() || !canRefreshDraftUsage(mounted) || result.harnessId !== agent) return; mounted.accountCredits = result.account?.credits ?? null; } mounted.draftUsageClient = client; renderMounted(mounted); } catch { - // Unknown quota stays empty instead of retaining another Account or Harness's values. + // A failed refresh leaves the current snapshot intact. Scope changes clear it above. } finally { request.pending = false; + // A failed in-flight read may still have a later refresh waiting on it. + if (deferredCodexDraftUsage.has(mounted) && isCurrent() && canRefreshDraftUsage(mounted)) { + scheduleScan(); + } } }; @@ -2304,9 +2351,7 @@ export function installRendererBindingProbe( for (const candidate of mountedByComposer.values()) { if (controller.get(candidate.composer).composerId !== composerId) continue; candidate.usageRequestGeneration += 1; - candidate.usage = null; - candidate.accountCredits = null; - candidate.accountCreditsSupported = false; + clearDraftUsageSnapshot(candidate); usageRefreshAttempts.delete(candidate.composer); const timer = usageRefreshTimers.get(candidate.composer); if (timer !== undefined) { @@ -2715,18 +2760,36 @@ export function installRendererBindingProbe( reloadMountedOwnershipForHost(); // Draft quota follows the concrete client, including connections without notifications. for (const mounted of mountedByComposer.values()) { - const client = composerClient(mounted); + const agent = controller.get(mounted.composer).agent; + const isCodexDraft = + agent === "codex" && threadIdFromComposerModelTarget(mounted.modelTarget) === null; + const accounts = isCodexDraft ? composerCodexAccounts(mounted.composer) : null; + const account = accounts?.usageAccount; + if (isCodexDraft && !accounts && draftUsageRequests.delete(mounted)) { + mounted.draftUsageClient = null; + } + if (isCodexDraft && mounted.draftUsageAccount && mounted.draftUsageAccount !== account) { + renderMounted(mounted); + } + if (!canRefreshDraftUsage(mounted)) continue; const request = draftUsageRequests.get(mounted); - const state = controller.get(mounted.composer); + // Submission can defer a ready Account's quota refresh or its reply. + if ( + account && + (deferredCodexDraftUsage.has(mounted) || (request && request.account !== account)) + ) { + void refreshDraftUsage(mounted); + continue; + } + const client = composerClient(mounted); if ( - state.phase === "draft" && mounted.draftUsageClient !== client && (!request || request.client !== client || request.generation !== mounted.usageRequestGeneration || (retryDraftUsage && !request.pending)) ) { - if (state.agent === "codex") void loadCodexAccountsForHost(mounted.hostId); + if (agent === "codex") void loadCodexAccountsForHost(mounted.hostId); else void refreshDraftUsage(mounted); } } @@ -2986,6 +3049,7 @@ export function installRendererBindingProbe( hostId: inherited?.hostId ?? hostId, usageRequestGeneration: 0, draftUsageClient: null, + draftUsageAccount: inherited?.draftUsageAccount ?? null, commandRequestGeneration: 0, }; mountedByComposer.set(composer, mounted); @@ -3219,7 +3283,10 @@ export function installRendererBindingProbe( const onBeforeInput = (event: InputEvent): void => { const composer = composerForTarget(event.target); if (!composer) return; - controller.clearPendingSubmission(composer); + if (controller.isSubmissionPending(composer)) { + controller.clearPendingSubmission(composer); + scheduleScan(true); + } const mounted = mountedByComposer.get(composer); if (mounted) pendingDefaultPreferences.set(controller.get(mounted.composer).composerId, false); if (mounted && isOwnershipSubmissionBlocked(mounted.ownershipStatus)) return; diff --git a/packages/renderer-extension/src/renderer-codex-account-state.ts b/packages/renderer-extension/src/renderer-codex-account-state.ts index dc94a1d04e..0d2e394704 100644 --- a/packages/renderer-extension/src/renderer-codex-account-state.ts +++ b/packages/renderer-extension/src/renderer-codex-account-state.ts @@ -1,4 +1,8 @@ -import type { CodexAccountListResult, CodexAccountSummary } from "@codexhost/shared-contracts"; +import type { + CodexAccountListResult, + CodexAccountSummary, + CodexAccountUsageResult, +} from "@codexhost/shared-contracts"; import type { RendererModelClient } from "./renderer-model-client.js"; export function resolveCurrentCodexAccountId( @@ -21,6 +25,8 @@ export function shouldApplyCodexAccountSnapshot( return next.revision >= current.revision; } +type CodexUsageAccount = { readonly accountId: string }; + /** One Host-wide current Account snapshot; no Composer or draft override. */ export class RendererCodexAccountState { accounts: readonly CodexAccountSummary[] = []; @@ -30,6 +36,12 @@ export class RendererCodexAccountState { instanceId: string | undefined; #hasSnapshot = false; #request: Promise | null = null; + #usageAccount: + | (CodexUsageAccount & { + email: string | undefined; + pending: Promise | null; + }) + | null = null; readonly #unsubscribe: (() => void) | undefined; constructor( @@ -54,6 +66,22 @@ export class RendererCodexAccountState { ); } + /** Identity of the ready Account on this Host instance. */ + get usageAccount(): CodexUsageAccount | null { + return this.#usageAccount; + } + + inspectUsage(account: CodexUsageAccount): Promise | null { + const current = this.#usageAccount; + if (current !== account || !this.client.inspectCodexAccountUsage) return null; + current.pending ??= this.client + .inspectCodexAccountUsage({ accountId: current.accountId }) + .finally(() => { + current.pending = null; + }); + return current.pending; + } + refresh(): Promise { if (this.#request) return this.#request; this.#request = Promise.resolve() @@ -84,12 +112,23 @@ export class RendererCodexAccountState { ) { return false; } + const instanceChanged = this.instanceId !== result.instanceId; this.#hasSnapshot = true; this.accounts = result.accounts; this.currentAccountId = result.currentAccountId; this.phase = result.phase; this.revision = result.revision; this.instanceId = result.instanceId; + const accountId = this.readyAccountId; + // Some native Accounts share the fallback ID "current". + const email = this.accounts.find(({ accountId: id }) => id === accountId)?.email; + if ( + instanceChanged || + (this.#usageAccount?.accountId ?? null) !== accountId || + this.#usageAccount?.email !== email + ) { + this.#usageAccount = accountId === null ? null : { accountId, email, pending: null }; + } return true; } } diff --git a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts index 39174c9cb2..1e6cd5c419 100644 --- a/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts +++ b/packages/renderer-extension/test/renderer-binding-probe-host-catalog.test.ts @@ -3,6 +3,9 @@ import { harnessPluginDescriptorSchema, harnessModelRefSchema, harnessThinkingOptionIdSchema, + type AccountCreditsSnapshot, + type CodexAccountListResult, + type CodexAccountUsageResult, } from "@codexhost/shared-contracts"; import { afterEach, assert, describe, expect, it, vi } from "vitest"; @@ -12,6 +15,7 @@ import { rendererModelSelectionFailed, type RendererModelControlView, } from "../src/renderer-model-picker.js"; +import type { RendererModelClient } from "../src/renderer-model-client.js"; import type { RendererRequestOptions } from "../src/renderer-request-sender.js"; import type { installRendererSidebarAgentIcons } from "../src/renderer-sidebar-agent-icons.js"; import type { RendererConnectionDiagnostics } from "../src/settings/connections-page.js"; @@ -23,6 +27,7 @@ const testState = vi.hoisted(() => ({ editor: null as unknown as Element, sendButton: null as unknown as HTMLButtonElement, renderedModelViews: [] as RendererModelControlView[], + renderedCredits: [] as Array, selectModel: null as null | ((modelId: string) => void), selectThinking: null as null | ((thinkingOptionId: string) => void), getConnectionDiagnostics: null as null | (() => RendererConnectionDiagnostics | null), @@ -82,8 +87,12 @@ vi.mock("../src/renderer-composer-dom.js", async (importOriginal) => { _switching: unknown, _availability: unknown, modelView: RendererModelControlView, + _permissionModeView: unknown, + _usage: unknown, + accountCredits: AccountCreditsSnapshot | null, ) => { testState.renderedModelViews.push({ ...modelView }); + testState.renderedCredits.push(accountCredits); }, reconcileComposerNativeControls: vi.fn(), disposeComposerAgentControl: vi.fn(), @@ -214,6 +223,7 @@ function installFakeBrowser(): void { testState.editor = editor; testState.sendButton = sendButton; testState.renderedModelViews = []; + testState.renderedCredits = []; testState.selectModel = null; testState.selectThinking = null; testState.getConnectionDiagnostics = null; @@ -295,6 +305,424 @@ afterEach(() => { vi.clearAllMocks(); }); +describe("Renderer binding Codex draft quota", () => { + type AccountClient = Pick< + RendererModelClient, + "listCodexAccounts" | "inspectCodexAccountUsage" | "subscribeCodexAccounts" + >; + const account: CodexAccountListResult = { + version: 2, + currentAccountId: "test-account", + phase: "ready", + revision: 1, + accounts: [{ accountId: "test-account", label: "Test account" }], + }; + const quota = (usedPercent: number): CodexAccountUsageResult => ({ + accountId: "test-account", + usage: null, + accountCredits: { usedPercent, periodType: "weekly" }, + freshness: "live", + observedAt: null, + }); + + async function mountWithAccountClient(accountClient: AccountClient) { + const hostDefaults = { + listHarnessPlugins: async () => ({ plugins: [] }), + inspectThread: async () => { + throw new Error("Thread ownership unavailable"); + }, + }; + let host = { ...hostDefaults, ...accountClient }; + let connected = true; + const { installRendererBindingProbe } = await import("../src/renderer-binding-probe.js"); + const probe = installRendererBindingProbe({ enabledAgents: ["codex"], defaultAgent: "codex" }); + const replaceClient = (replacement: AccountClient): void => { + host = { ...hostDefaults, ...replacement }; + }; + const setAdapter = (replacement?: AccountClient): void => { + if (replacement) replaceClient(replacement); + probe.setAdapter( + { state: "ready", reason: "ready", modelUpdates: 0, hook: "request-bridge" }, + undefined, + undefined, + { currentHostId: () => "local", clientForHost: () => (connected ? host : null) } as never, + ); + }; + setAdapter(); + return { + setAdapter, + replaceClient, + setConnected(value: boolean) { + connected = value; + }, + }; + } + + function flushFrame(): void { + for (const callback of testState.animationFrames.splice(0)) callback(performance.now()); + } + + function scanAfterMutation(): void { + const notify = testState.notifyMutations; + assert(notify); + notify([{ type: "attributes", target: testState.composer } as unknown as MutationRecord]); + flushFrame(); + } + + function submitDraft(): void { + const submit = testState.documentListeners.get("submit"); + assert(submit); + const event = new Event("submit", { cancelable: true }); + submit(event); + expect(event.defaultPrevented).toBe(false); + } + + function resumeDraft(): void { + const beforeInput = testState.documentListeners.get("beforeinput"); + assert(beforeInput); + beforeInput(new Event("beforeinput")); + flushFrame(); + } + + it("does not retry the account list on DOM changes for an existing Thread with failed ownership", async () => { + installFakeBrowser(); + const listCodexAccounts = vi.fn(async () => account); + await mountWithAccountClient({ listCodexAccounts }); + await vi.waitFor(() => expect(listCodexAccounts).toHaveBeenCalled()); + await new Promise((resolve) => setImmediate(resolve)); + + const readsBeforeScan = listCodexAccounts.mock.calls.length; + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + + expect(listCodexAccounts).toHaveBeenCalledTimes(readsBeforeScan); + }); + + it("keeps the same Codex Account's quota visible while refreshing it", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const initial = quota(8); + const inspectCodexAccountUsage = vi.fn(async () => initial); + await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + }); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)).toEqual(initial.accountCredits), + ); + + const pending = Promise.withResolvers(); + inspectCodexAccountUsage.mockReturnValue(pending.promise); + const readsBeforeFocus = inspectCodexAccountUsage.mock.calls.length; + const rendersBeforeFocus = testState.renderedCredits.length; + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(readsBeforeFocus + 1), + ); + const hidQuota = testState.renderedCredits + .slice(rendersBeforeFocus) + .some((credits) => credits === null); + const updated = quota(18); + pending.resolve(updated); + expect(hidQuota).toBe(false); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)).toEqual(updated.accountCredits), + ); + }); + + it.each(["adapter", "Host epoch"])( + "starts a new quota request after changing the %s on the same client", + async (change) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const oldQuota = Promise.withResolvers(); + const currentQuota = quota(18); + const inspectCodexAccountUsage = vi + .fn(async () => currentQuota) + .mockReturnValueOnce(oldQuota.promise); + let notifyAccount: ((snapshot: CodexAccountListResult) => void) | undefined; + const { setAdapter } = await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + subscribeCodexAccounts: (listener) => { + notifyAccount = listener; + return () => undefined; + }, + }); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1)); + + if (change === "adapter") { + setAdapter(); + } else { + assert(notifyAccount); + notifyAccount({ ...account, instanceId: "next-host" }); + } + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + oldQuota.resolve(quota(8)); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18); + }, + ); + + it("hides old quota while the replacement client reads its Account list", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const oldQuota = Promise.withResolvers(); + const initial = quota(8); + const inspectCodexAccountUsage = vi.fn(async () => initial); + const { setAdapter } = await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + }); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)).toEqual(initial.accountCredits), + ); + inspectCodexAccountUsage.mockReturnValue(oldQuota.promise); + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2)); + + const replacementAccount = Promise.withResolvers(); + const replacementQuota = quota(18); + setAdapter({ + listCodexAccounts: () => replacementAccount.promise, + inspectCodexAccountUsage: async () => replacementQuota, + }); + expect(testState.renderedCredits.at(-1) === null).toBe(true); + oldQuota.resolve(initial); + await new Promise((resolve) => setImmediate(resolve)); + expect(testState.renderedCredits.at(-1) === null).toBe(true); + replacementAccount.resolve(account); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)).toEqual(replacementQuota.accountCredits), + ); + }); + + it("loads a changed Account once when typing resumes after an abandoned submission", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + let currentAccount = account; + let notifyAccount: ((snapshot: CodexAccountListResult) => void) | undefined; + const inspectCodexAccountUsage = vi.fn(async ({ accountId }: { accountId: string }) => ({ + ...quota(accountId === "test-account" ? 8 : 18), + accountId, + })); + await mountWithAccountClient({ + listCodexAccounts: async () => currentAccount, + inspectCodexAccountUsage, + subscribeCodexAccounts: (listener) => { + notifyAccount = listener; + return () => undefined; + }, + }); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + assert(notifyAccount); + submitDraft(); + currentAccount = { + ...account, + currentAccountId: "new-account", + revision: 2, + accounts: [{ accountId: "new-account", label: "New account" }], + }; + notifyAccount(currentAccount); + await new Promise((resolve) => setImmediate(resolve)); + flushFrame(); + expect(testState.renderedCredits.at(-1)).toBeNull(); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + + resumeDraft(); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + expect(inspectCodexAccountUsage).toHaveBeenLastCalledWith({ accountId: "new-account" }); + }); + + it.each([ + { completion: "during", expectedUsage: 18, expectedReads: 2 }, + { completion: "after", expectedUsage: 8, expectedReads: 1 }, + { completion: "failed", expectedUsage: undefined, expectedReads: 1 }, + ] as const)( + "reconciles quota on resuming an abandoned submission ($completion)", + async ({ completion, expectedUsage, expectedReads }) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const firstQuota = Promise.withResolvers(); + const inspectCodexAccountUsage = vi + .fn(async () => quota(18)) + .mockReturnValueOnce(firstQuota.promise); + await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + }); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1)); + submitDraft(); + if (completion !== "after") { + if (completion === "during") firstQuota.resolve(quota(8)); + else firstQuota.reject(new Error("Usage query failed")); + await new Promise((resolve) => setImmediate(resolve)); + } + flushFrame(); + expect(testState.renderedCredits.at(-1)).toBeNull(); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + + resumeDraft(); + if (completion === "after") firstQuota.resolve(quota(8)); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(expectedUsage), + ); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(expectedReads); + }, + ); + + it("invalidates old quota when the Host client changes during submission", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const { replaceClient } = await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage: async () => quota(8), + }); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + submitDraft(); + const listCodexAccounts = vi.fn(async () => account); + const inspectCodexAccountUsage = vi.fn(async () => quota(18)); + replaceClient({ listCodexAccounts, inspectCodexAccountUsage }); + scanAfterMutation(); + expect(testState.renderedCredits.at(-1) === null).toBe(true); + await new Promise((resolve) => setImmediate(resolve)); + expect(listCodexAccounts).not.toHaveBeenCalled(); + expect(inspectCodexAccountUsage).not.toHaveBeenCalled(); + + resumeDraft(); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + }); + + it.each(["loaded", "pending"] as const)( + "reloads %s quota after the same client reconnects during submission", + async (status) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const oldQuota = Promise.withResolvers(); + const inspectCodexAccountUsage = vi + .fn(async () => quota(18)) + .mockReturnValueOnce(oldQuota.promise); + const { setConnected } = await mountWithAccountClient({ + listCodexAccounts: async () => account, + inspectCodexAccountUsage, + }); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1)); + if (status === "loaded") { + oldQuota.resolve(quota(8)); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + } + submitDraft(); + + setConnected(false); + scanAfterMutation(); + expect(testState.renderedCredits.at(-1)).toBeNull(); + setConnected(true); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + + resumeDraft(); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + if (status === "pending") oldQuota.resolve(quota(8)); + await new Promise((resolve) => setImmediate(resolve)); + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + }, + ); + + it("performs one deferred focus refresh after the draft resumes", async () => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const listCodexAccounts = vi.fn(async () => account); + const inspectCodexAccountUsage = vi.fn(async () => quota(18)).mockResolvedValueOnce(quota(8)); + await mountWithAccountClient({ listCodexAccounts, inspectCodexAccountUsage }); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + submitDraft(); + const accountReads = listCodexAccounts.mock.calls.length; + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => expect(listCodexAccounts).toHaveBeenCalledTimes(accountReads + 1)); + await new Promise((resolve) => setImmediate(resolve)); + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(1); + + resumeDraft(); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + }); + + it.each(["fails", "succeeds"] as const)( + "settles a deferred focus refresh when the in-flight quota request %s after resuming", + async (outcome) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const inFlight = Promise.withResolvers(); + const listCodexAccounts = vi.fn(async () => account); + const inspectCodexAccountUsage = vi + .fn(async () => quota(18)) + .mockResolvedValueOnce(quota(8)) + .mockReturnValueOnce(inFlight.promise); + await mountWithAccountClient({ listCodexAccounts, inspectCodexAccountUsage }); + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(8)); + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2)); + submitDraft(); + const accountReads = listCodexAccounts.mock.calls.length; + window.dispatchEvent(new Event("focus")); + await vi.waitFor(() => expect(listCodexAccounts).toHaveBeenCalledTimes(accountReads + 1)); + await new Promise((resolve) => setImmediate(resolve)); + + resumeDraft(); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(2); + if (outcome === "fails") inFlight.reject(new Error("Usage query failed")); + else inFlight.resolve(quota(12)); + await new Promise((resolve) => setImmediate(resolve)); + flushFrame(); + await vi.waitFor(() => + expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(outcome === "fails" ? 18 : 12), + ); + scanAfterMutation(); + await new Promise((resolve) => setImmediate(resolve)); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(outcome === "fails" ? 3 : 2); + }, + ); + + it.each(["draft", "Thread"] as const)( + "uses the ready Account without reading its list again when the composer resumes as a %s", + async (target) => { + installFakeBrowser(); + testState.modelTarget = ["default", "client-new-thread:quota"]; + const firstAccount = Promise.withResolvers(); + const listCodexAccounts = vi.fn(() => firstAccount.promise); + const inspectCodexAccountUsage = vi.fn(async () => quota(18)); + await mountWithAccountClient({ listCodexAccounts, inspectCodexAccountUsage }); + await vi.waitFor(() => expect(listCodexAccounts).toHaveBeenCalledTimes(1)); + submitDraft(); + firstAccount.resolve(account); + await new Promise((resolve) => setImmediate(resolve)); + flushFrame(); + expect(inspectCodexAccountUsage).not.toHaveBeenCalled(); + + if (target === "Thread") testState.modelTarget = ["conversation", "thread-a"]; + resumeDraft(); + if (target === "draft") { + await vi.waitFor(() => expect(testState.renderedCredits.at(-1)?.usedPercent).toBe(18)); + } + await new Promise((resolve) => setImmediate(resolve)); + expect(listCodexAccounts).toHaveBeenCalledTimes(1); + expect(inspectCodexAccountUsage).toHaveBeenCalledTimes(target === "draft" ? 1 : 0); + }, + ); +}); + describe("Renderer binding Host-scoped Claude catalogs", () => { it("loads remote sidebar artwork before any Composer opens on that Host", async () => { installFakeBrowser(); diff --git a/packages/renderer-extension/test/renderer-codex-account-state.test.ts b/packages/renderer-extension/test/renderer-codex-account-state.test.ts index a43e94f6f9..9ab1541855 100644 --- a/packages/renderer-extension/test/renderer-codex-account-state.test.ts +++ b/packages/renderer-extension/test/renderer-codex-account-state.test.ts @@ -1,4 +1,4 @@ -import { describe, expect, it, vi } from "vitest"; +import { assert, describe, expect, it, vi } from "vitest"; import { RendererCodexAccountState, shouldApplyCodexAccountSnapshot, @@ -19,6 +19,15 @@ const snapshot = (currentAccountId: string | null, revision: number, instanceId accounts: currentAccountId ? [account(currentAccountId)] : [], }); +const fallbackAccountSnapshot = ( + revision: number, + instanceId?: string, + email = "first@example.test", +) => ({ + ...snapshot("current", revision, instanceId), + accounts: [{ ...account("current"), email }], +}); + function createState(sendRequest: (method: string, params: unknown) => Promise) { const client = createRendererModelClient([{ sendRequest }]); if (!client) throw new Error("Test client is unavailable"); @@ -39,6 +48,52 @@ describe("Host-scoped Codex Account state", () => { expect(state.readyAccountId).toBe("default"); }); + it.each([ + ["Account", snapshot("other", 3)], + [ + "Account email under the fallback ID", + fallbackAccountSnapshot(3, "host-a", "second@example.test"), + ], + ["Host instance", fallbackAccountSnapshot(1, "host-b")], + ] as const)("shares pending usage across drafts until the %s changes", async (_, replacement) => { + let accounts: ReturnType = fallbackAccountSnapshot(1); + const oldUsage = Promise.withResolvers(); + const newUsage = Promise.withResolvers(); + const inspectUsage = vi + .fn<() => Promise>() + .mockReturnValueOnce(oldUsage.promise) + .mockReturnValueOnce(newUsage.promise); + const state = createState(async (method) => { + return method === "codexhost/account/list" ? accounts : inspectUsage(); + }); + await state.refresh(); + const firstAccount = state.usageAccount; + assert(firstAccount); + const first = state.inspectUsage(firstAccount); + assert(first); + + accounts = fallbackAccountSnapshot(2); + await state.refresh(); + expect(state.inspectUsage(firstAccount)).toBe(first); + expect(inspectUsage).toHaveBeenCalledTimes(1); + + accounts = replacement; + await state.refresh(); + const nextAccount = state.usageAccount; + assert(nextAccount); + expect(state.inspectUsage(firstAccount)).toBeNull(); + const next = state.inspectUsage(nextAccount); + assert(next); + + const usage = { accountId: "current", usage: null, freshness: "live", observedAt: null }; + oldUsage.resolve(usage); + await first; + expect(state.inspectUsage(nextAccount)).toBe(next); + newUsage.resolve({ ...usage, accountId: replacement.currentAccountId }); + await next; + expect(inspectUsage).toHaveBeenCalledTimes(2); + }); + it("does not inherit another Host's Account state when the remote API is absent", async () => { const local = createState(async () => snapshot("default", 1)); const remote = createState(async () => {