import os from "node:os";

import path from "node:path";

import { setTimeout as delay } from "node:timers/promises";

import { pathToFileURL } from "node:url";

import { promisify } from "node:util";

import { assert, connectGateway, type GatewayRpcClient, waitFor } from "./mcp-channels-harness.ts";

import type { GatewayRpcClient } from "./mcp-channels-harness.ts";

const execFileAsync = promisify(execFile);

const PROBE_PID_WAIT_MS = readPositiveInt(

process.env.OPENCLAW_CRON_MCP_CLEANUP_PID_WAIT_MS,

120_000,

);

type McpChannelsHarness = typeof import("./mcp-channels-harness.ts");

let mcpChannelsHarness: McpChannelsHarness | undefined;

type CronJob = { id?: string };

type CronRunResult = { ok?: boolean; enqueued?: boolean; runId?: string };

type AgentRunResult = { runId?: string; status?: string };

async function loadMcpChannelsHarness(): Promise<McpChannelsHarness> {

mcpChannelsHarness ??= await import("./mcp-channels-harness.ts");

return mcpChannelsHarness;

}

function readPositiveInt(raw: string | undefined, fallback: number): number {

const text = (raw ?? "").trim();

if (!/^\d+$/u.test(text)) {

return fallback;

}

const parsed = Number(text);

return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;

}

async function readProbePid(pidPath: string): Promise<number | undefined> {

try {

const raw = (await fs.readFile(pidPath, "utf-8")).trim();

}

}

async function waitForProbePid(pidPath: string): Promise<number | undefined> {

export async function waitForProbePid(

pidPath: string,

options: { pollMs?: number; timeoutMs?: number } = {},

): Promise<number | undefined> {

const timeoutMs = options.timeoutMs ?? PROBE_PID_WAIT_MS;

const pollMs = options.pollMs ?? 100;

const startedAt = Date.now();

while (Date.now() - startedAt < 600_000) {

while (Date.now() - startedAt < timeoutMs) {

const pid = await readProbePid(pidPath);

if (pid) {

return pid;

}

await delay(100);

await delay(pollMs);

}

return undefined;

}

gateway: GatewayRpcClient;

pidPath: string;

}): Promise<{ jobId: string; runId?: string; pid: number; status?: unknown }> {

const { assert, waitFor } = await loadMcpChannelsHarness();

const { gateway, pidPath } = params;

const job = await gateway.request<CronJob>("cron.add", {

name: "cron mcp cleanup docker e2e",

const pid = await waitForProbePid(pidPath);

assert(

pid,

`cron MCP probe did not start; missing pid file at ${pidPath}; events=${JSON.stringify(

`cron MCP probe did not start within ${PROBE_PID_WAIT_MS}ms; missing pid file at ${pidPath}; events=${JSON.stringify(

gateway.events.slice(-10),

)}`,

);

pidsPath: string;

exitPath: string;

}): Promise<{ runId: string; exitedPids: number[]; pids: number[] }> {

const { assert } = await loadMcpChannelsHarness();

const { gateway, pidPath, pidsPath, exitPath } = params;

await resetProbeFiles({ pidPath, pidsPath, exitPath });

}

async function main() {

const { assert, connectGateway } = await loadMcpChannelsHarness();

const gatewayUrl = process.env.GW_URL?.trim();

const gatewayToken = process.env.GW_TOKEN?.trim();

const stateDir = process.env.OPENCLAW_STATE_DIR?.trim() || path.join(os.homedir(), ".openclaw");

}

}

await main();

if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {

await main();

}