import http from "node:http";

import https from "node:https";

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

import { createDeferred } from "../../../../src/test-utils/deferred.js";

const { registerManagedProxyBrowserCdpBypassMock } = vi.hoisted(() => ({

registerManagedProxyBrowserCdpBypassMock: vi.fn<(url: string) => (() => void) | undefined>(

registerManagedProxyBrowserCdpBypassMock.mockImplementation(() => undefined);

});

function createDeferred<T = void>() {

let resolve: ((value: T | PromiseLike<T>) => void) | undefined;

let reject: ((reason?: unknown) => void) | undefined;

const promise = new Promise<T>((res, rej) => {

resolve = res;

reject = rej;

});

if (!resolve || !reject) {

throw new Error("Expected deferred callbacks to be initialized");

}

return { promise, resolve, reject };

}

async function withIsolatedNoProxyEnv(fn: () => Promise<void>) {

const origNoProxy = process.env.NO_PROXY;

const origNoProxyLower = process.env.no_proxy;

// Memory Core tests cover manager cache plugin behavior.

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

// Memory Core tests cover manager cache plugin behavior.

import { createDeferred } from "../../../../src/test-utils/deferred.js";

import {

closeManagedCacheEntries,

getOrCreateManagedCacheEntry,

};

}

function createDeferred<T>() {

let resolve: ((value: T | PromiseLike<T>) => void) | undefined;

let reject: ((reason?: unknown) => void) | undefined;

const promise = new Promise<T>((res, rej) => {

resolve = res;

reject = rej;

});

if (!resolve || !reject) {

throw new Error("Expected deferred callbacks to be initialized");

}

return { promise, resolve, reject };

}

describe("manager cache", () => {

const cachesForCleanup: ManagedCache<TestEntry>[] = [];

const first = createEntry("first");

const second = createEntry("second");

cachesForCleanup.push(cache);

const gate = createDeferred<void>();

const gate = createDeferred();

const pendingFirst = getOrCreateManagedCacheEntry({

cache: cache.cache,

import os from "node:os";

import path from "node:path";

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

import { createDeferred } from "../test-utils/deferred.js";

import { withEnv } from "../test-utils/env.js";

import {

applySessionStoreEntryPatch,

},

});

const createDeferred = <T>() => {

let resolve: ((value: T | PromiseLike<T>) => void) | undefined;

let reject: ((reason?: unknown) => void) | undefined;

const promise = new Promise<T>((res, rej) => {

resolve = res;

reject = rej;

});

if (!resolve || !reject) {

throw new Error("Expected deferred callbacks to be initialized");

}

return { promise, resolve, reject };

};

const firstStarted = createDeferred<void>();

const releaseFirst = createDeferred<void>();

const firstStarted = createDeferred();

const releaseFirst = createDeferred();

const p1 = updateSessionStoreEntry({

storePath,

// Session store writer tests cover serialized session writes and cleanup.

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

import { createDeferred } from "../../test-utils/deferred.js";

import {

clearSessionStoreCacheForTest,

getSessionStoreWriterQueueSizeForTest,

withSessionStoreWriterForTest,

} from "./store.js";

const createDeferred = <T>() => {

let resolve: ((value: T | PromiseLike<T>) => void) | undefined;

let reject: ((reason?: unknown) => void) | undefined;

const promise = new Promise<T>((nextResolve, nextReject) => {

resolve = nextResolve;

reject = nextReject;

});

if (!resolve || !reject) {

throw new Error("Expected deferred callbacks to be initialized");

}

return { promise, resolve, reject };

};

describe("session store writer", () => {

afterEach(() => {

clearSessionStoreCacheForTest();

});

it("serializes runtime writes through one in-process writer", async () => {

const storePath = "/tmp/openclaw-store.json";

const firstStarted = createDeferred<void>();

const releaseFirst = createDeferred<void>();

const firstStarted = createDeferred();

const releaseFirst = createDeferred();

const order: string[] = [];

const first = withSessionStoreWriterForTest(storePath, async () => {

*/

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

import type { ExecApprovalRequest, ExecApprovalResolved } from "../infra/exec-approvals.js";

import { createDeferred } from "./test-helpers.deferred.js";

import { createDeferred } from "../test-utils/deferred.js";

const listDevicePairingMock = vi.fn();

const loadApnsRegistrationMock = vi.fn();

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { enqueueCommandInLane, resetCommandQueueStateForTest } from "../process/command-queue.js";

import { CommandLane } from "../process/lanes.js";

import { createDeferred } from "../test-utils/deferred.js";

import { applyGatewayLaneConcurrency } from "./server-lanes.js";

import { createDeferred } from "./test-helpers.deferred.js";

describe("applyGatewayLaneConcurrency", () => {

afterEach(() => {

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

import { ErrorCodes } from "../../../packages/gateway-protocol/src/index.js";

import type { OpenClawConfig } from "../../config/types.openclaw.js";

import { createDeferred } from "../../test-utils/deferred.js";

import { withEnvAsync } from "../../test-utils/env.js";

import { withOpenClawTestState } from "../../test-utils/openclaw-test-state.js";

import { createDeferred } from "../test-helpers.deferred.js";

import { expectGatewayErrorResponse } from "./gateway-response.test-helpers.js";

import { modelsHandlers } from "./models.js";

import type { RespondFn } from "./types.js";

*/

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

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { createDeferred } from "../test-utils/deferred.js";

import type { GatewayModelChoice } from "./server-model-catalog.js";

import {

resetModelCatalogCacheForTest,

loadGatewayModelCatalog,

markGatewayModelCatalogStaleForReload,

} from "./server-model-catalog.js";

import { createDeferred } from "./test-helpers.deferred.js";

type LoadModelCatalogForTest = NonNullable<

NonNullable<Parameters<typeof loadGatewayModelCatalog>[0]>["loadModelCatalog"]

} from "../auto-reply/reply/dispatcher-registry.js";

import { createReplyDispatcher } from "../auto-reply/reply/reply-dispatcher.js";

import { getTotalQueueSize, resetCommandQueueStateForTest } from "../process/command-queue.js";

import { createDeferred } from "./test-helpers.deferred.js";

import { createDeferred } from "../test-utils/deferred.js";

async function flushMicrotasks(count = 10): Promise<void> {

for (let i = 0; i < count; i += 1) {

import type { GetReplyOptions } from "../auto-reply/get-reply-options.types.js";

import { clearConfigCache } from "../config/config.js";

import type { AgentModelConfig } from "../config/types.agents-shared.js";

import { createDeferred } from "../test-utils/deferred.js";

import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";

import { setMaxChatHistoryMessagesBytesForTest } from "./server-constants.js";

import type { GatewayRequestContext, RespondFn } from "./server-methods/shared-types.js";

);

};

function createDeferred<T>() {

let resolve: ((value: T | PromiseLike<T>) => void) | undefined;

let reject: ((reason?: unknown) => void) | undefined;

const promise = new Promise<T>((res, rej) => {

resolve = res;

reject = rej;

});

if (!resolve || !reject) {

throw new Error("Expected deferred callbacks to be initialized");

}

return { promise, resolve, reject };

}

async function withGatewayChatHarness(

run: (ctx: { ws: GatewaySocket; createSessionDir: () => Promise<string> }) => Promise<void>,

options?: { headers?: Record<string, string> },

test("chat.send returns in_flight when duplicate attachment send wins parsing race", async () => {

const sessionDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-gw-"));

const dispatchRelease = createDeferred<void>();

const dispatchRelease = createDeferred();

try {

testState.sessionStorePath = path.join(sessionDir, "sessions.json");

await writeSessionStore({

test("chat.send reuses only active WebChat text sends with the same system context", async () => {

const sessionDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-gw-"));

const dispatchRelease = createDeferred<void>();

const dispatchRelease = createDeferred();

try {

testState.sessionStorePath = path.join(sessionDir, "sessions.json");

await writeSessionStore({