'mkdir -p "$tool_root" || { status=$?; return "$status"; };',

'install_lock="$tool_root/.node-${node_version}-${node_arch}.lock";',

"lock_acquired=0;",

'lock_deadline=$((SECONDS + 300));',

"lock_deadline=$((SECONDS + 300));",

"while true; do",

'if mkdir "$install_lock" 2>/dev/null; then lock_acquired=1; printf "%s\\n" "$$" >"$install_lock/pid" || { status=$?; rm -rf "$install_lock"; return "$status"; }; break; fi;',

'if [ -x "$node_dir/bin/node" ] && [ -f "$ready_marker" ]; then break; fi;',

'if [ -n "$lock_pid" ] && kill -0 "$lock_pid" 2>/dev/null; then echo "timed out waiting for active macOS Node toolchain install lock: $install_lock pid=$lock_pid" >&2; return 1; fi;',

'echo "reclaiming stale macOS Node toolchain install lock: $install_lock" >&2;',

'rm -rf "$install_lock" || return 1;',

'lock_deadline=$((SECONDS + 300));',

"lock_deadline=$((SECONDS + 300));",

"fi;",

"sleep 1;",

"done;",

"release_install_lock() { if [ \"$lock_acquired\" = \"1\" ]; then rm -rf \"$install_lock\" 2>/dev/null || true; fi; };",

'release_install_lock() { if [ "$lock_acquired" = "1" ]; then rm -rf "$install_lock" 2>/dev/null || true; fi; };',

'if [ ! -x "$node_dir/bin/node" ] || [ ! -f "$ready_marker" ]; then',

'tmp_dir="$(mktemp -d)" || { release_install_lock; return 1; };',

'pkg="node-v${node_version}-darwin-${node_arch}.tar.gz";',

}

const parsed = Number(raw);

if (!Number.isSafeInteger(parsed)) {

throw new Error(`${name} must be a safe non-negative integer ${unit}, got ${JSON.stringify(raw)}`);

throw new Error(

`${name} must be a safe non-negative integer ${unit}, got ${JSON.stringify(raw)}`,

);

}

return parsed;

}

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

import { pathToFileURL } from "node:url";

import { promisify } from "node:util";

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

import { readPositiveIntEnv } from "./lib/env-limits.mjs";

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

const execFileAsync = promisify(execFile);

const PROBE_PID_WAIT_MS = readCronMcpCleanupProbePidWaitMs();

);

await this.phase("fresh.gateway-status", 240, () => this.verifyGatewayStatus());

this.status.freshGateway = "pass";

await this.phase(

"fresh.first-local-agent-turn",

this.agentTimeoutSeconds,

() => this.verifyLocalTurn(),

await this.phase("fresh.first-local-agent-turn", this.agentTimeoutSeconds, () =>

this.verifyLocalTurn(),

);

this.status.freshAgent = "pass";

}

);

await this.phase("upgrade.gateway-status", 240, () => this.verifyGatewayStatus());

this.status.upgradeGateway = "pass";

await this.phase(

"upgrade.first-local-agent-turn",

this.agentTimeoutSeconds,

() => this.verifyLocalTurn(),

await this.phase("upgrade.first-local-agent-turn", this.agentTimeoutSeconds, () =>

this.verifyLocalTurn(),

);

this.status.upgradeAgent = "pass";

}

await this.phase("fresh.gateway-restart", 420, () => this.gatewayAction("restart"));

await this.phase("fresh.gateway-status", 420, () => this.verifyGatewayReachable());

this.status.freshGateway = "pass";

await this.phase(

"fresh.first-agent-turn",

this.agentTimeoutSeconds,

() => this.verifyTurn(),

);

await this.phase("fresh.first-agent-turn", this.agentTimeoutSeconds, () => this.verifyTurn());

this.status.freshAgent = "pass";

}

this.status.upgradePrecheck = "latest-ref-fail";

}

await this.phase("upgrade.gateway-stop-before-update", 420, () => this.gatewayAction("stop"));

await this.phase(

"upgrade.update-dev",

this.updateTimeoutSeconds,

() => this.runDevChannelUpdate(),

await this.phase("upgrade.update-dev", this.updateTimeoutSeconds, () =>

this.runDevChannelUpdate(),

);

this.status.upgradeVersion = await this.extractLastVersion("upgrade.update-dev");

await this.phase("upgrade.verify-dev-channel", 120, () => this.verifyDevChannelUpdate());

await this.phase("upgrade.gateway-restart", 420, () => this.gatewayAction("restart"));

await this.phase("upgrade.gateway-status", 420, () => this.verifyGatewayReachable());

this.status.upgradeGateway = "pass";

await this.phase(

"upgrade.first-agent-turn",

this.agentTimeoutSeconds,

() => this.verifyTurn(),

);

await this.phase("upgrade.first-agent-turn", this.agentTimeoutSeconds, () => this.verifyTurn());

this.status.upgradeAgent = "pass";

}

}

async function closeFileHandles(handles) {

const results = await Promise.allSettled(

handles.filter(Boolean).map((handle) => handle.close()),

);

const results = await Promise.allSettled(handles.filter(Boolean).map((handle) => handle.close()));

const failedClose = results.find((result) => result.status === "rejected");

if (failedClose) {

throw failedClose.reason;

};

const terminateChild = () => {

killChild("SIGTERM");

killTimer = setTimeout(

() => {

killTimer = undefined;

killChild("SIGKILL");

timeoutReject?.();

},

options.killAfterMs ?? COMMAND_TIMEOUT_KILL_AFTER_MS,

);

killTimer = setTimeout(() => {

killTimer = undefined;

killChild("SIGKILL");

timeoutReject?.();

}, options.killAfterMs ?? COMMAND_TIMEOUT_KILL_AFTER_MS);

};

const timeout =

options.timeoutMs === undefined

return [...new Set(targets)];

}

const TOOLING_SCRIPT_PATH_PATTERN =

/^scripts\/(.+)\.(?:mjs|cjs|js|mts|cts|ts|sh|py|ps1)$/u;

const TOOLING_SCRIPT_PATH_PATTERN = /^scripts\/(.+)\.(?:mjs|cjs|js|mts|cts|ts|sh|py|ps1)$/u;

function resolveConventionalToolingTestTargets(changedPath, cwd = process.cwd()) {

const match = TOOLING_SCRIPT_PATH_PATTERN.exec(changedPath);

"OPENCLAW_TSDOWN_TIMEOUT_MS",

);

const heartbeatMs =

parseNonNegativeIntegerEnv(

env.OPENCLAW_TSDOWN_HEARTBEAT_MS,

"OPENCLAW_TSDOWN_HEARTBEAT_MS",

) ?? DEFAULT_HEARTBEAT_MS;

parseNonNegativeIntegerEnv(env.OPENCLAW_TSDOWN_HEARTBEAT_MS, "OPENCLAW_TSDOWN_HEARTBEAT_MS") ??

DEFAULT_HEARTBEAT_MS;

let timedOut = false;

let settled = false;

let lastOutputAt = Date.now();

import { asOptionalRecord } from "@openclaw/normalization-core/record-coerce";

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

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

import { HEARTBEAT_PROMPT } from "../../auto-reply/heartbeat.js";

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

import { registerLegacyContextEngine } from "../../context-engine/legacy.registration.js";

import {

buildSystemRunApprovalBinding,

buildSystemRunApprovalEnvBinding,

} from "../../infra/system-run-approval-binding.js";

import { HEARTBEAT_PROMPT } from "../../auto-reply/heartbeat.js";

import { resetLogger, setLoggerOverride } from "../../logging.js";

import { projectRecentChatDisplayMessages } from "../chat-display-projection.js";

import { ExecApprovalManager } from "../exec-approval-manager.js";

describe("resolveNpmReleaseCheckCommandTimeoutMs", () => {

it("parses only positive integer environment timeouts", () => {

expect(resolveNpmReleaseCheckCommandTimeoutMs({})).toBe(10 * 60 * 1000);

expect(resolveNpmReleaseCheckCommandTimeoutMs({ OPENCLAW_NPM_RELEASE_CHECK_COMMAND_TIMEOUT_MS: "" })).toBe(

10 * 60 * 1000,

);

expect(

resolveNpmReleaseCheckCommandTimeoutMs({ OPENCLAW_NPM_RELEASE_CHECK_COMMAND_TIMEOUT_MS: "" }),

).toBe(10 * 60 * 1000);

expect(

resolveNpmReleaseCheckCommandTimeoutMs({

OPENCLAW_NPM_RELEASE_CHECK_COMMAND_TIMEOUT_MS: "1234",

}),

).toBe(1234);

for (const raw of ["nope", "10m", "1e3", "0", "-1", "9007199254740992"]) {

expect(

() => resolveNpmReleaseCheckCommandTimeoutMs({

expect(() =>

resolveNpmReleaseCheckCommandTimeoutMs({

OPENCLAW_NPM_RELEASE_CHECK_COMMAND_TIMEOUT_MS: raw,

}),

).toThrow(`invalid OPENCLAW_NPM_RELEASE_CHECK_COMMAND_TIMEOUT_MS: ${raw}`);