const args = process.argv.slice(2);

const command = args.shift();

export const CONFIG_COMMAND_TIMEOUT_MS = 120_000;

export const CONFIG_COMMAND_MAX_BUFFER_BYTES = 4 * 1024 * 1024;

function option(name, fallback) {

const index = args.indexOf(name);

};

}

function runOpenClaw(step) {

function errorCode(error) {

return error && typeof error === "object" && "code" in error ? String(error.code) : undefined;

}

export function runUpgradeSurvivorOpenClawStep(step, params = {}) {

const invocation = resolveUpgradeSurvivorOpenClawCommand(step.argv);

const result = spawnSync(invocation.command, invocation.args, {

const run = params.spawnSyncCommand ?? spawnSync;

const timeoutMs = params.timeoutMs ?? CONFIG_COMMAND_TIMEOUT_MS;

const maxBuffer = params.maxBufferBytes ?? CONFIG_COMMAND_MAX_BUFFER_BYTES;

const result = run(invocation.command, invocation.args, {

encoding: "utf8",

env: process.env,

killSignal: "SIGTERM",

maxBuffer,

shell: invocation.shell,

timeout: timeoutMs,

windowsVerbatimArguments: invocation.windowsVerbatimArguments,

});

const code = errorCode(result.error);

return {

id: step.id,

intent: step.intent,

command: invocation.commandLabel,

status: result.status,

signal: result.signal,

ok: result.status === 0,

ok: result.status === 0 && !result.error,

errorCode: code,

errorMessage: result.error?.message ? tail(result.error.message) : undefined,

stdout: tail(result.stdout),

stderr: tail(result.stderr),

};

if (!adaptedStep) {

continue;

}

const outcome = runOpenClaw(adaptedStep);

const outcome = runUpgradeSurvivorOpenClawStep(adaptedStep);

summary.steps.push(outcome);

writeJson(summaryPath, summary);

if (!outcome.ok) {

throw new Error(`baseline config recipe failed at ${step.id}`);

const detail = outcome.errorCode ?? outcome.signal ?? outcome.status ?? "unknown";

throw new Error(`baseline config recipe failed at ${step.id}: ${detail}`);

}

}

}

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

import { resolveUpgradeSurvivorOpenClawCommand } from "../../scripts/e2e/lib/upgrade-survivor/config-recipe.mjs";

import {

CONFIG_COMMAND_MAX_BUFFER_BYTES,

CONFIG_COMMAND_TIMEOUT_MS,

resolveUpgradeSurvivorOpenClawCommand,

runUpgradeSurvivorOpenClawStep,

} from "../../scripts/e2e/lib/upgrade-survivor/config-recipe.mjs";

describe("upgrade survivor config recipe command resolution", () => {

it("wraps Windows openclaw npm shims through cmd.exe", () => {

shell: false,

});

});

it("bounds baseline config commands and reports spawn errors", () => {

const calls: unknown[] = [];

const timeoutError = Object.assign(new Error("spawnSync openclaw ETIMEDOUT"), {

code: "ETIMEDOUT",

});

const outcome = runUpgradeSurvivorOpenClawStep(

{

argv: ["config", "validate"],

id: "validate",

intent: "validate",

},

{

spawnSyncCommand(command: string, args: string[], options: unknown) {

calls.push({ args, command, options });

return {

error: timeoutError,

signal: "SIGTERM",

status: null,

stderr: "still validating",

stdout: "partial output",

};

},

},

);

expect(calls).toHaveLength(1);

expect(calls[0]).toMatchObject({

args: ["config", "validate"],

command: "openclaw",

options: {

killSignal: "SIGTERM",

maxBuffer: CONFIG_COMMAND_MAX_BUFFER_BYTES,

timeout: CONFIG_COMMAND_TIMEOUT_MS,

},

});

expect(outcome).toMatchObject({

command: "openclaw config validate",

errorCode: "ETIMEDOUT",

errorMessage: "spawnSync openclaw ETIMEDOUT",

ok: false,

signal: "SIGTERM",

status: null,

stderr: "still validating",

stdout: "partial output",

});

});

});