let tempDir: string;

let codexAppServerClientFactoryForTest: CodexAppServerClientFactory | undefined;

const fastWait = { interval: 1, timeout: 5_000 } as const;

const appServerHarnessWait = { interval: 1, timeout: 120_000 } as const;

const activeAppServerAttemptsForTest = new Set<{

abortController?: AbortController;

promise: Promise<unknown>;

}>();

type RunCodexAppServerAttemptOptions = NonNullable<

Parameters<typeof runCodexAppServerAttemptImpl>[1]

options: RunCodexAppServerAttemptOptions = {},

) {

const clientFactory = options.clientFactory ?? codexAppServerClientFactoryForTest;

return runCodexAppServerAttemptImpl(

params,

const abortController = params.abortSignal ? undefined : new AbortController();

const trackedParams = abortController

? ({ ...params, abortSignal: abortController.signal } as EmbeddedRunAttemptParams)

: params;

const entry = {

abortController,

promise: undefined as unknown as Promise<unknown>,

};

const promise = runCodexAppServerAttemptImpl(

trackedParams,

clientFactory ? { ...options, clientFactory } : options,

);

).finally(() => {

activeAppServerAttemptsForTest.delete(entry);

});

entry.promise = promise;

activeAppServerAttemptsForTest.add(entry);

promise.catch(() => undefined);

return promise;

}

async function drainActiveAppServerAttemptsForTest(): Promise<void> {

const attempts = [...activeAppServerAttemptsForTest];

if (attempts.length === 0) {

return;

}

for (const attempt of attempts) {

attempt.abortController?.abort("test_cleanup");

}

await Promise.race([

Promise.allSettled(attempts.map((attempt) => attempt.promise)),

new Promise<void>((resolve) => setTimeout(resolve, 5_000)),

]);

}

function createParams(sessionFile: string, workspaceDir: string): EmbeddedRunAttemptParams {

const waitForServerRequestHandler = async () => {

await vi.waitFor(() => expect(handleServerRequest).toBeTypeOf("function"), {

interval: 1,

timeout: 30_000,

timeout: appServerHarnessWait.timeout,

});

return handleServerRequest!;

};

return {

request,

requests,

async waitForMethod(method: string, timeoutMs = 30_000) {

async waitForMethod(method: string, timeoutMs = appServerHarnessWait.timeout) {

await vi.waitFor(

() => {

if (!requests.some((entry) => entry.method === method)) {

});

afterEach(async () => {

await drainActiveAppServerAttemptsForTest();

await closeCodexSandboxExecServersForTests();

resetCodexAppServerClientFactoryForTest();

testing.resetOpenClawCodingToolsFactoryForTests();

resetCodexRateLimitCacheForTests();