});

expect(env.OPENCLAW_TEST_FAST).toBe("1");

expect(env.OPENCLAW_EMBEDDED_ABORT_SETTLE_TIMEOUT_MS).toBe("2000");

expect(env.OPENCLAW_QA_PARENT_PID).toBe(String(process.pid));

expect(env.OPENCLAW_QA_TEMP_ROOT).toBe("/tmp/openclaw-qa");

expect(env.OPENCLAW_QA_STAGED_RUNTIME_ROOT).toBe(

OPENCLAW_SKIP_CANVAS_HOST: "1",

OPENCLAW_NO_RESPAWN: "1",

OPENCLAW_TEST_FAST: "1",

OPENCLAW_EMBEDDED_ABORT_SETTLE_TIMEOUT_MS: "2000",

OPENCLAW_QA_PARENT_PID: String(process.pid),

OPENCLAW_QA_TEMP_ROOT: params.tempRoot,

...(params.stagedBundledPluginsRoot

return [...buckets.entries()].map(([key, count]) => `${key}x${count}`).join(", ");

}

function buildConfigFixture(commandCase: CommandCase): Record<string, unknown> | null {

if (commandCase.id !== "configGetGatewayPort") {

return null;

}

const envPort = Number.parseInt(process.env.OPENCLAW_GATEWAY_PORT ?? "", 10);

const port = Number.isFinite(envPort) && envPort > 0 ? envPort : 32123;

return { gateway: { port } };

}

function buildRssHook(tmpDir: string): string {

const rssHookPath = path.join(tmpDir, "measure-rss.mjs");

writeFileSync(

const runRoot = mkdtempSync(path.join(os.tmpdir(), "openclaw-cli-bench-home-"));

const stateDir = path.join(runRoot, ".openclaw");

const configPath = path.join(stateDir, "openclaw.json");

const configFixture = buildConfigFixture(params.commandCase);

if (configFixture) {

mkdirSync(stateDir, { recursive: true });

writeFileSync(configPath, `${JSON.stringify(configFixture, null, 2)}\n`, "utf8");

}

const nodeArgs = [

"--import",

params.rssHookPath,

}

export const testing = {

buildConfigFixture,

collectFailedSamples,

parseNonNegativeInt,

parsePositiveInt,

} from "./lib/local-heavy-check-runtime.mjs";

const DEFAULT_WINDOWS_EXTENSION_CHUNK_SIZE = 8;

const DEFAULT_SHARD_HEARTBEAT_MS = 30_000;

const FAST_LOCAL_CHECK_MIN_CPUS = 12;

const FAST_LOCAL_CHECK_MIN_MEMORY_BYTES = 48 * 1024 ** 3;

const EXTENSION_TS_CONFIG = "config/tsconfig/oxlint.extensions.json";

async function runShard({ env, extraArgs, runner, shard }) {

console.error(`[oxlint:${shard.name}] starting`);

const startedAt = Date.now();

const heartbeatMs = resolveShardHeartbeatMs(env);

const child = spawn(process.execPath, [runner, ...shard.args, ...extraArgs], {

stdio: "inherit",

env: {

});

return await new Promise((resolve) => {

const heartbeat =

heartbeatMs > 0

? setInterval(() => {

const elapsedSeconds = Math.round((Date.now() - startedAt) / 1000);

console.error(`[oxlint:${shard.name}] still running after ${elapsedSeconds}s`);

}, heartbeatMs)

: null;

heartbeat?.unref();

const finish = (status) => {

if (heartbeat) {

clearInterval(heartbeat);

}

console.error(`[oxlint:${shard.name}] finished`);

resolve(status);

};

child.once("error", (error) => {

console.error(error);

resolve(1);

finish(1);

});

child.once("close", (status) => {

console.error(`[oxlint:${shard.name}] finished`);

resolve(status ?? 1);

finish(status ?? 1);

});

});

}

export function resolveShardHeartbeatMs(env) {

const rawValue = env.OPENCLAW_OXLINT_SHARD_HEARTBEAT_MS;

if (rawValue === undefined) {

return DEFAULT_SHARD_HEARTBEAT_MS;

}

const parsedValue = Number.parseInt(rawValue, 10);

return Number.isFinite(parsedValue) && parsedValue >= 0

? parsedValue

: DEFAULT_SHARD_HEARTBEAT_MS;

}

const SESSIONS_YIELD_INTERRUPT_CUSTOM_TYPE = "openclaw.sessions_yield_interrupt";

const SESSIONS_YIELD_CONTEXT_CUSTOM_TYPE = "openclaw.sessions_yield";

const SESSIONS_YIELD_ABORT_SETTLE_TIMEOUT_MS = process.env.OPENCLAW_TEST_FAST === "1" ? 250 : 2_000;

function resolveSessionsYieldAbortSettleTimeoutMs(): number {

const override = Number(process.env.OPENCLAW_EMBEDDED_ABORT_SETTLE_TIMEOUT_MS);

if (Number.isFinite(override) && override > 0) {

return override;

}

return process.env.OPENCLAW_TEST_FAST === "1" ? 250 : 2_000;

}

const SESSIONS_YIELD_ABORT_SETTLE_TIMEOUT_MS = resolveSessionsYieldAbortSettleTimeoutMs();

// Persist a hidden context reminder so the next turn knows why the runner stopped.

function buildSessionsYieldContextMessage(message: string): string {

import type { SubscribeEmbeddedAgentSessionParams } from "../../embedded-agent-subscribe.types.js";

import { log } from "../logger.js";

export const EMBEDDED_ABORT_SETTLE_TIMEOUT_MS =

process.env.OPENCLAW_TEST_FAST === "1" ? 250 : 2_000;

function resolveEmbeddedAbortSettleTimeoutMs(): number {

const override = Number(process.env.OPENCLAW_EMBEDDED_ABORT_SETTLE_TIMEOUT_MS);

if (Number.isFinite(override) && override > 0) {

return override;

}

return process.env.OPENCLAW_TEST_FAST === "1" ? 250 : 2_000;

}

export const EMBEDDED_ABORT_SETTLE_TIMEOUT_MS = resolveEmbeddedAbortSettleTimeoutMs();

type IdleAwareAgent = {

waitForIdle?: (() => Promise<void>) | undefined;

function seedChannelPkg(

pkgJsonPath: string,

opts: { id: string; docsPath: string; label?: string; blurb?: string },

opts: { id: string; docsPath: string; label?: string; blurb?: string; markdownCapable?: boolean },

): void {

const pluginDir = path.dirname(pkgJsonPath);

writeJsonFile(pkgJsonPath, {

label: opts.label ?? opts.id,

docsPath: opts.docsPath,

blurb: opts.blurb ?? "test blurb",

...(opts.markdownCapable !== undefined ? { markdownCapable: opts.markdownCapable } : {}),

},

},

});

expect(ids.has("telegram")).toBe(true);

});

it("keeps bundled package metadata when generated catalog entries are stale", () => {

const root = seedRoot("bcr-package-wins-");

const extensionsRoot = path.join(root, "dist", "extensions");

seedChannelPkg(path.join(extensionsRoot, "matrix", "package.json"), {

id: "matrix",

docsPath: "/channels/matrix",

label: "Matrix",

markdownCapable: true,

});

writeJsonFile(path.join(root, "dist", "channel-catalog.json"), {

entries: [

{

name: "@openclaw/matrix",

openclaw: {

channel: {

id: "matrix",

label: "Matrix",

docsPath: "/channels/matrix",

blurb: "stale generated entry",

},

},

},

],

});

useBundledPluginsDir(extensionsRoot);

const matrix = listBundledChannelCatalogEntries().find((entry) => entry.id === "matrix");

expect(matrix?.channel.markdownCapable).toBe(true);

});

it("falls back to dist/channel-catalog.json when the resolver returns undefined", () => {

// OPENCLAW_DISABLE_BUNDLED_PLUGINS, missing bundled tree, or an unresolvable

// package root all surface as undefined from resolveBundledPluginsDir. In

for (const entry of readOfficialCatalogFileSync()) {

const channelEntry = toBundledChannelEntry(entry);

if (channelEntry) {

entries.set(channelEntry.id, channelEntry);

entries.set(channelEntry.id, entries.get(channelEntry.id) ?? channelEntry);

}

}

if (entries.size === 0) {

).toBe(true);

});

it("uses activation source config to discover channel setup metadata after secret stripping", () => {

const { pluginDir, fullMarker, setupMarker } = writeExternalSetupChannelPlugin();

const plugins = listReadOnlyChannelPluginsForConfig(

{

channels: {

"external-chat": {},

},

plugins: {

load: { paths: [pluginDir] },

allow: ["external-chat"],

},

} as never,

{

activationSourceConfig: {

channels: {

"external-chat": { token: "configured" },

},

plugins: {

load: { paths: [pluginDir] },

allow: ["external-chat"],

},

} as never,

env: { ...process.env },

includePersistedAuthState: false,

includeSetupFallbackPlugins: true,

},

);

expectExternalChatSetupOnlyPluginLoaded({ plugins, setupMarker, fullMarker });

});

it("reuses default read-only channel plugin resolution for the same config", () => {

const { pluginDir, fullMarker, setupMarker } = writeExternalSetupChannelPlugin();

const cfg = {

}).plugins;

const bundledManifestRecords = listBundledChannelManifestRecords(manifestRecords);

const externalManifestRecords = listExternalChannelManifestRecords(manifestRecords);

const configuredChannelIds = uniqueStrings(

listConfiguredChannelIdsForReadOnlyScope({

const activationSourceConfig = options.activationSourceConfig ?? cfg;

const configuredChannelIds = uniqueStrings([

...listConfiguredChannelIdsForReadOnlyScope({

config: cfg,

activationSourceConfig: options.activationSourceConfig ?? cfg,

activationSourceConfig,

workspaceDir,

env,

includePersistedAuthState: options.includePersistedAuthState,

manifestRecords,

}),

).filter(isSafeManifestChannelId);

...(activationSourceConfig === cfg

? []

: listConfiguredChannelIdsForReadOnlyScope({

config: activationSourceConfig,

activationSourceConfig,

workspaceDir,

env,

includePersistedAuthState: options.includePersistedAuthState,

manifestRecords,

})),

]).filter(isSafeManifestChannelId);

const byId = new Map<string, ChannelPlugin>();

const loadFailures: ReadOnlyChannelPluginLoadFailure[] = [];