export function runCommand(command, args, options = {}) {

return new Promise((resolve, reject) => {

const { timeoutKillGraceMs = 2000, timeoutMs = COMMAND_TIMEOUT_MS, ...spawnOptions } = options;

const {

resourceLabel,

resourceSampleIntervalMs = 1000,

resourceSampleOptions,

resourceSamples,

sampleProcessImpl = sampleProcess,

timeoutKillGraceMs = 2000,

timeoutMs = COMMAND_TIMEOUT_MS,

...spawnOptions

} = options;

const child = childProcess.spawn(command, args, {

stdio: ["ignore", "pipe", "pipe"],

...spawnOptions,

detached: spawnOptions.detached ?? process.platform !== "win32",

});

const startedAt = Date.now();

let stdout = { text: "", truncatedChars: 0 };

let stderr = { text: "", truncatedChars: 0 };

let timedOut = false;

let forceKillTimer;

let sampleTimer;

let resourceSampleInFlight = null;

const commandLabel = resourceLabel ?? [command, ...args.slice(0, 2)].join(" ");

const shouldSampleResources = Array.isArray(resourceSamples);

const collectResourceSample = () => {

if (!shouldSampleResources || !child.pid) {

return null;

}

resourceSampleInFlight ??= Promise.resolve()

.then(() => sampleProcessImpl(child.pid, resourceSampleOptions ?? {}))

.then((sample) => {

if (sample) {

resourceSamples.push({

...sample,

elapsedMs: Date.now() - startedAt,

label: commandLabel,

});

}

})

.catch(() => {})

.finally(() => {

resourceSampleInFlight = null;

});

return resourceSampleInFlight;

};

const stopResourceSampling = async () => {

clearInterval(sampleTimer);

await resourceSampleInFlight?.catch(() => {});

};

if (shouldSampleResources) {

void collectResourceSample();

sampleTimer = setInterval(

() => {

void collectResourceSample();

},

Math.max(100, resourceSampleIntervalMs),

);

sampleTimer.unref?.();

}

const timer = setTimeout(() => {

timedOut = true;

signalProcessGroup(child, "SIGTERM");

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

clearTimeout(timer);

clearTimeout(forceKillTimer);

reject(error);

void stopResourceSampling().finally(() => reject(error));

});

child.on("close", (status, signal) => {

clearTimeout(timer);

clearTimeout(forceKillTimer);

if (status === 0) {

resolve({

stdout: stdout.text,

stderr: stderr.text,

stdoutTruncatedChars: stdout.truncatedChars,

stderrTruncatedChars: stderr.truncatedChars,

});

return;

}

const detail = [

formatCapturedOutput("stdout", stdout),

formatCapturedOutput("stderr", stderr),

]

.filter(Boolean)

.join("\n")

.trim();

const failure = timedOut

? `timed out after ${timeoutMs}ms`

: `failed with ${signal || status}`;

reject(

new Error(

`${command} ${args.join(" ")} ${failure}${detail ? `\n${tailText(detail)}` : ""}`,

),

);

void stopResourceSampling().then(() => {

if (status === 0) {

resolve({

stdout: stdout.text,

stderr: stderr.text,

stdoutTruncatedChars: stdout.truncatedChars,

stderrTruncatedChars: stderr.truncatedChars,

});

return;

}

const detail = [

formatCapturedOutput("stdout", stdout),

formatCapturedOutput("stderr", stderr),

]

.filter(Boolean)

.join("\n")

.trim();

const failure = timedOut

? `timed out after ${timeoutMs}ms`

: `failed with ${signal || status}`;

reject(

new Error(

`${command} ${args.join(" ")} ${failure}${detail ? `\n${tailText(detail)}` : ""}`,

),

);

});

});

});

}

return runCommand(command.command, command.args, {

...command.options,

env,

resourceLabel: options.resourceLabel,

resourceSampleIntervalMs: options.resourceSampleIntervalMs,

resourceSampleOptions: options.resourceSampleOptions,

resourceSamples: options.resourceSamples,

timeoutMs: options.timeoutMs ?? COMMAND_TIMEOUT_MS,

});

}

let child;

const processSamples = [];

const commandSamples = [];

const commandResourceOptions = {

resourceSampleIntervalMs: 500,

resourceSamples: commandSamples,

};

let sampleInFlight = null;

let sampleTimer;

try {

console.log(`Kitchen Sink RPC walk using ${PLUGIN_SPEC} via ${runner.label}`);

await runOpenClaw(runner, ["plugins", "install", PLUGIN_SPEC], env, {

...commandResourceOptions,

resourceLabel: "plugins install",

timeoutMs: INSTALL_TIMEOUT_MS,

});

runner = resolveOpenClawRunner();

console.log(`Kitchen Sink RPC runtime runner: ${runner.label}`);

configureKitchenSink(env, port);

await runOpenClaw(runner, ["plugins", "enable", PLUGIN_ID], env, { timeoutMs: 60000 });

await runOpenClaw(runner, ["plugins", "enable", PLUGIN_ID], env, {

...commandResourceOptions,

resourceLabel: "plugins enable",

timeoutMs: 60000,

});

const inspect = parseJsonOutput(

(await runOpenClaw(runner, ["plugins", "inspect", PLUGIN_ID, "--runtime", "--json"], env))

.stdout,

(

await runOpenClaw(runner, ["plugins", "inspect", PLUGIN_ID, "--runtime", "--json"], env, {

...commandResourceOptions,

resourceLabel: "plugins inspect",

})

).stdout,

);

if (inspect?.plugin?.status !== "loaded") {

throw new Error(`Kitchen Sink plugin did not inspect as loaded: ${JSON.stringify(inspect)}`);

const finalSample = await sampleGateway();

assertResourceCeiling(finalSample);

const peakSample = summarizeProcessSamples(processSamples);

const commandPeakSample = summarizeProcessSamples(commandSamples);

assertResourceCeiling(peakSample);

assertNoErrorLogs(logPath);

commands: commandNames,

catalogTools: catalogToolIds.filter((id) => EXPECTED_TOOLS.includes(id)),

channelAccount,

commandPeakSample,

initialSample,

finalSample,

peakSample,