const harness = createStartedThreadHarness();

const warn = vi.spyOn(embeddedAgentLog, "warn").mockImplementation(() => undefined);

let resolveRefresh: (() => void) | undefined;

vi.spyOn(authBridge, "refreshCodexAppServerAuthTokens").mockImplementation(

async () =>

await new Promise<void>((resolve) => {

resolveRefresh = resolve;

}),

);

vi.spyOn(authBridge, "refreshCodexAppServerAuthTokens").mockImplementation(async () => {

await new Promise<void>((resolve) => {

resolveRefresh = resolve;

});

return {

accessToken: "access-token",

chatgptAccountId: "account-id",

chatgptPlanType: null,

};

});

const params = createParams(

path.join(tempDir, "session.jsonl"),

path.join(tempDir, "workspace"),

import { beforeEach, describe, expect, it, vi } from "vitest";

import { resolveOAuthDir } from "../config/paths.js";

import { MAX_DATE_TIMESTAMP_MS } from "../shared/number-coercion.js";

import { legacyOAuthSidecarTestUtils } from "./auth-profiles/legacy-oauth-sidecar.js";

import { resolveAuthStatePath, resolveAuthStorePath } from "./auth-profiles/paths.js";

import { getRuntimeAuthProfileStoreSnapshot } from "./auth-profiles/runtime-snapshots.js";

import {

allowKeychainPrompt: false,

});

const mainCred = mainStore.profiles[params.profileId];

const mainExpires = asDateTimestampMs(mainCred?.expires);

if (mainCred?.type !== "oauth") {

return null;

}

const mainExpires = asDateTimestampMs(mainCred.expires);

const localExpires = asDateTimestampMs(params.credential.expires);

if (

mainCred?.type === "oauth" &&

mainCred.provider === params.credential.provider &&

hasUsableOAuthCredential(mainCred) &&

mainExpires !== undefined &&

await markCodexFailureAt({ store, now: MAX_DATE_TIMESTAMP_MS, reason: "unknown" });

expect(store.usageStats?.["openai-codex:default"]?.cooldownUntil).toBe(MAX_DATE_TIMESTAMP_MS);

expect(store.usageStats?.["openai:default"]?.cooldownUntil).toBe(MAX_DATE_TIMESTAMP_MS);

});

it.each([

);

realBundledSourceTreeProbe = {

hasAccountInspect: bundled.hasBundledChannelEntryFeature("slack", "accountInspect"),

pluginIds: bundled.listBundledChannelPluginIds(),

pluginIds: [...bundled.listBundledChannelPluginIds()],

};

});

remainingMs: number | undefined,

expiresAt: number | undefined,

): ModelAuthExpiry | undefined {

if (asDateTimestampMs(expiresAt) === undefined || typeof remainingMs !== "number") {

const validExpiresAt = asDateTimestampMs(expiresAt);

if (validExpiresAt === undefined || typeof remainingMs !== "number") {

return undefined;

}

return { at: expiresAt, remainingMs, label: formatRemainingShort(remainingMs) };

return { at: validExpiresAt, remainingMs, label: formatRemainingShort(remainingMs) };

}

function providerDisplayName(provider: string): string {

pairedBAfterRevokeRevokedAtMs: pairedBAfterRevoke?.tokens?.operator?.revokedAtMs,

pairedBToken: pairedB?.tokens?.operator?.token,

revokeMessage: revoke.error?.message,

revokeOk: revoke.ok === true,

revokeOk: revoke.ok,

rotateMessage: rotate.error?.message,

rotateOk: rotate.ok === true,

rotateOk: rotate.ok,

token: deviceB.pairingToken,

};

} finally {

const res = await sendSharedTokenRotationPatch(ws);

sharedTokenRotationCase = {

closed: await closed,

ok: res.ok === true,

ok: res.ok,

};

} finally {

await closeWsAndWait(ws);

});

configSetRotationCase = {

closed: await closed,

setOk: setRes.ok === true,

setOk: setRes.ok,

};

} finally {

ws.close();

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import { resolveTimerTimeoutMs } from "../shared/number-coercion.js";

import { MAX_SAFE_TIMEOUT_DELAY_MS } from "../utils/timer-delay.js";

import { resolveRetryConfig, retryAsync } from "./retry.js";

vi.useFakeTimers();

const timeoutSpy = vi.spyOn(globalThis, "setTimeout");

const fn = vi.fn().mockRejectedValueOnce(new Error("boom")).mockResolvedValueOnce("ok");

const scheduledDelayMs = resolveTimerTimeoutMs(MAX_SAFE_TIMEOUT_DELAY_MS, 0, 0);

try {

const promise = retryAsync(fn, 2, 3_000_000_000);

await vi.advanceTimersByTimeAsync(MAX_SAFE_TIMEOUT_DELAY_MS);

await expect(promise).resolves.toBe("ok");

expect(timeoutSpy).toHaveBeenCalledWith(expect.any(Function), MAX_SAFE_TIMEOUT_DELAY_MS);

expect(timeoutSpy).toHaveBeenCalledWith(expect.any(Function), scheduledDelayMs);

} finally {

timeoutSpy.mockRestore();

vi.clearAllTimers();

.mockRejectedValueOnce(new Error("boom-1"))

.mockRejectedValueOnce(new Error("boom-2"))

.mockResolvedValueOnce("ok");

const scheduledDelayMs = resolveTimerTimeoutMs(MAX_SAFE_TIMEOUT_DELAY_MS, 0, 0);

try {

const promise = retryAsync(fn, 3, Number.MAX_VALUE);

await vi.advanceTimersByTimeAsync(MAX_SAFE_TIMEOUT_DELAY_MS);

await vi.advanceTimersByTimeAsync(MAX_SAFE_TIMEOUT_DELAY_MS);

await expect(promise).resolves.toBe("ok");

expect(timeoutSpy).toHaveBeenNthCalledWith(

1,

expect.any(Function),

MAX_SAFE_TIMEOUT_DELAY_MS,

);

expect(timeoutSpy).toHaveBeenNthCalledWith(

2,

expect.any(Function),

MAX_SAFE_TIMEOUT_DELAY_MS,

);

expect(timeoutSpy).toHaveBeenNthCalledWith(1, expect.any(Function), scheduledDelayMs);

expect(timeoutSpy).toHaveBeenNthCalledWith(2, expect.any(Function), scheduledDelayMs);

} finally {

timeoutSpy.mockRestore();

vi.clearAllTimers();