function readPackageArgValue(argv, index) {

const value = argv[index + 1];

if (value === undefined || value === "" || value.startsWith("--")) {

if (value === undefined || value === "" || value.startsWith("-")) {

throw new Error("missing value for --package");

}

return value;

if (arg === "--limit") {

const next = argv[index + 1];

if (!next || next.startsWith("--") || !/^\d+$/u.test(next)) {

if (!next || next.startsWith("-") || !/^\d+$/u.test(next)) {

throw new Error("Missing/invalid --limit value");

}

const parsed = Number(next);

if (arg === "--model") {

const next = argv[index + 1];

if (!next || next.startsWith("--")) {

if (!next || next.startsWith("-")) {

throw new Error("Missing --model value");

}

model = next;

if (packageDir === "--help" || packageDir === "-h") {

return { help: true, packageDir: "" };

}

if (!packageDir || packageDir.startsWith("--")) {

if (!packageDir || packageDir.startsWith("-")) {

throw new Error(usage());

}

const extraArg = args[1];

import { normalizeUpgradeSurvivorBaselineSpec } from "./lib/docker-e2e-plan.mjs";

import { compareReleaseVersions, parseReleaseVersion } from "./lib/npm-publish-plan.mjs";

function parseArgs(argv) {

export function parseArgs(argv) {

const args = new Map();

for (let index = 0; index < argv.length; index += 1) {

const arg = argv[index];

}

const key = arg.slice(2);

const value = argv[index + 1];

if (value === undefined || value.startsWith("--")) {

if (value === undefined || value.startsWith("-")) {

throw new Error(`missing value for --${key}`);

}

args.set(key, value);

});

expect(() => testing.parseArgs(["--model", "--dry-run"])).toThrow("Missing --model value");

expect(() => testing.parseArgs(["--model", "-h"])).toThrow("Missing --model value");

expect(() => testing.parseArgs(["--limit", "--dry-run"])).toThrow(

"Missing/invalid --limit value",

);

expect(() => testing.parseArgs(["--limit", "-h"])).toThrow("Missing/invalid --limit value");

expect(() => testing.parseArgs(["--wat"])).toThrow("Unknown argument: --wat");

});

expect(() => parseBulkBuildArgs(["--package", "--package", "extensions/slack"])).toThrow(

"missing value for --package",

);

expect(() => parseBulkBuildArgs(["--package", "-h"])).toThrow("missing value for --package");

expect(() => parseSingleBuildArgs(["--package"])).toThrow(

"usage: node scripts/lib/plugin-npm-runtime-build.mjs <package-dir>",

);

import { tmpdir } from "node:os";

import path from "node:path";

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

import { resolveBaselines } from "../../scripts/resolve-upgrade-survivor-baselines.mjs";

import { parseArgs, resolveBaselines } from "../../scripts/resolve-upgrade-survivor-baselines.mjs";

function withReleaseFixture<T>(releases: unknown[], fn: (file: string) => T): T {

const dir = mkdtempSync(path.join(tmpdir(), "openclaw-upgrade-baselines-"));

}

describe("scripts/resolve-upgrade-survivor-baselines", () => {

it("rejects short flag values before resolving baselines", () => {

expect(() => parseArgs(["--fallback", "-h"])).toThrow("missing value for --fallback");

expect(() => parseArgs(["--github-output", "-h"])).toThrow("missing value for --github-output");

});

it("keeps the single fallback baseline when no expanded request is provided", () => {

expect(resolveBaselines(new Map([["fallback", "2026.4.23"]]))).toEqual(["openclaw@2026.4.23"]);

});