@intentius/chant 0.124.13 → 0.124.15

package/dist/cli/handlers/promote.js

@@ -0,0 +1,342 @@
+/**
+ * `chant components promote --from <env> --to <env>` (#2530), `chant
+ * components rollback <env>` (#2531) and `chant components redeploy <env>`
+ * (#2604): deploy digests a release ledger already records, without a build.
+ * A promote takes them from another environment's ledger; a rollback takes an
+ * earlier release from the environment's own, and a redeploy the release it
+ * records as current. The
+ * mechanism lives in ../../components/promote.ts; these handlers read the
+ * ledger, print the plan, run it, and append the release records.
+ *
+ * Every component that deployed gets a record, even when a later component
+ * failed or stopped at a gate, so the ledger never misses a deploy that
+ * happened. Unlike an auto-recorded release, the record is what these
+ * commands are for, so a failed write is an error rather than a warning.
+ */
+import { resolve } from "node:path";
+import { readFileSync } from "node:fs";
+import { loadChantConfig } from "../../config.js";
+import { fetchLifecycle, getHeadCommit, pushLifecycle } from "../../lifecycle/git.js";
+import { appendReleaseRecord, readReleaseLedger, resolveRunId, } from "../../lifecycle/release-ledger.js";
+import { resolveComponentTargets } from "../../components/cli-support.js";
+import { applyConfigDefaults } from "../../components/config-defaults.js";
+import { fanOutRegistry } from "../../components/fan-out-support.js";
+import { renderDriverHuman } from "../../components/driver-output.js";
+import { ndjsonProgressSink } from "../../components/run-progress.js";
+import { parseDigestPins, planPromotion, planRollback, planRedeploy, withoutBuildSteps, runPromotion, promotionRecord, rollbackRecord, redeployRecord, gateApprover, } from "../../components/promote.js";
+import { summaryLedgerPrefix, writeGatedRunSummary } from "../../op/gate-summary.js";
+import { approveCommand, describeGateMismatch, gateIsSealed } from "../../op/gate.js";
+import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli.js";
+import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format.js";
+import { GATED_EXIT_CODE } from "./run.js";
+const PROMOTE_USAGE = "chant components promote --from <env> --to <env> [--component <name> [--digest <sha256:...>] | --digest <component>=<sha256:...> ...] [--dry-run] [--json]";
+const ROLLBACK_USAGE = "chant components rollback <env> --component <name> [--digest <sha256:...>] [--dry-run] [--json]";
+const REDEPLOY_USAGE = "chant components redeploy <env> --component <name> [--digest <sha256:...>] [--dry-run] [--json]";
+function renderPlan(verb, plan, removed) {
+    console.error(formatBold(verb === "promote" ? `promote ${plan.from} -> ${plan.to}` : `${verb} ${plan.to}`));
+    for (const item of plan.items) {
+        console.error(`  ${item.component}  ${item.digest}`);
+        console.error(`    released to ${plan.from} at ${item.source.timestamp} (run ${item.source.runId}, git ${item.source.gitSha.slice(0, 12)})`);
+        const kinds = removed.get(item.component) ?? [];
+        if (kinds.length > 0)
+            console.error(`    not run: ${kinds.join(", ")}`);
+    }
+    for (const skipped of plan.notPromoted) {
+        console.error(`  ${skipped.component}  not promoted: ${skipped.reason}`);
+    }
+}
+function planJson(plan, removed) {
+    return {
+        from: plan.from,
+        to: plan.to,
+        items: plan.items.map((i) => ({
+            component: i.component,
+            digest: i.digest,
+            source: i.source,
+            notRun: removed.get(i.component) ?? [],
+        })),
+        notPromoted: plan.notPromoted,
+    };
+}
+function resolveActor(ctx) {
+    return ctx.args.actor ?? process.env.GITHUB_ACTOR ?? process.env.GITLAB_USER_LOGIN ?? process.env.USER;
+}
+/** Config, params and the declared components, or the exit code of a refusal already printed. */
+async function loadProject(ctx, selector) {
+    const { args } = ctx;
+    const projectPath = resolve(".");
+    const { config } = await loadChantConfig(projectPath).catch(() => ({ config: {} }));
+    const paramsResolution = resolveCliBuildParams(config.buildParams, {
+        cli: parseParamFlags(args.param),
+        paramsFile: args.paramsFile,
+        verbose: args.verbose,
+    });
+    if (!paramsResolution.success) {
+        for (const message of paramsResolution.errors)
+            console.error(message);
+        return 1;
+    }
+    const targets = await resolveComponentTargets(projectPath, selector, args.sandbox, paramsResolution.provenance);
+    if (!targets.success) {
+        console.error(formatError({ message: targets.error ?? "Could not discover components" }));
+        return 1;
+    }
+    return { projectPath, config, targets: targets.targets };
+}
+async function readLedger(env) {
+    const ledger = await readReleaseLedger(env);
+    if (ledger.malformed > 0) {
+        console.error(formatWarning({ message: `${ledger.malformed} malformed line(s) in the "${env}" release ledger were skipped` }));
+    }
+    return ledger.records;
+}
+/**
+ * Prepare, run and record a plan. Shared by promote, rollback and redeploy,
+ * which differ only in how the plan was chosen, whether the publish step runs,
+ * and which field names the earlier release on the new record.
+ */
+async function deployPlan(ctx, verb, plan, project, actor, record) {
+    const { args } = ctx;
+    const byName = new Map(project.targets.map((c) => [c.name, applyConfigDefaults(c, project.config)]));
+    const prepared = [];
+    const removed = new Map();
+    const refusals = [];
+    for (const item of plan.items) {
+        // A rollback and a redeploy deploy a release this environment already
+        // received, so neither runs the publish step.
+        const result = withoutBuildSteps(byName.get(item.component), verb === "promote" ? {} : { pinDigest: item.digest, verb: `a ${verb}` });
+        if ("error" in result)
+            refusals.push(result.error);
+        else {
+            prepared.push(result.component);
+            removed.set(item.component, result.removed);
+        }
+    }
+    if (refusals.length > 0) {
+        for (const message of refusals)
+            console.error(formatError({ message }));
+        console.error(formatError({ message: `nothing was deployed` }));
+        return 1;
+    }
+    // The composition deployed is this checkout's. Say so when it is not the
+    // commit the artifact was built from.
+    const head = await getHeadCommit().catch(() => undefined);
+    for (const item of plan.items) {
+        if (head && head !== item.source.gitSha) {
+            console.error(formatWarning({
+                message: `${item.component}: the artifact was built from ${item.source.gitSha.slice(0, 12)}, ` +
+                    `but its deploy steps come from this checkout at ${head.slice(0, 12)}`,
+            }));
+        }
+    }
+    if (args.dryRun) {
+        if (args.json)
+            console.log(JSON.stringify(planJson(plan, removed), null, 2));
+        else
+            renderPlan(verb, plan, removed);
+        return 0;
+    }
+    if (!args.json)
+        renderPlan(verb, plan, removed);
+    const seededOutputs = {};
+    for (const file of args.seedOutputs ?? []) {
+        try {
+            Object.assign(seededOutputs, JSON.parse(readFileSync(resolve(file), "utf8")));
+        }
+        catch (err) {
+            console.error(formatError({ message: `--seed-outputs: could not read "${file}": ${err instanceof Error ? err.message : String(err)}` }));
+            return 1;
+        }
+    }
+    const registry = await fanOutRegistry(project.projectPath, project.config);
+    const run = await runPromotion({
+        plan,
+        components: prepared,
+        registry,
+        componentOutputs: seededOutputs,
+        ...(args.progressJson ? { onProgress: ndjsonProgressSink() } : {}),
+    });
+    if (!args.json)
+        renderDriverHuman(run);
+    // Record every component that deployed, whatever happened to the rest: a
+    // component that reached the environment and is missing from its ledger
+    // would be exactly the unrecorded deploy the ledger exists to rule out.
+    const deployed = plan.items.filter((item) => run.results.some((r) => r.component === item.component && r.status === "ok"));
+    const { runId, runOrigin } = resolveRunId(args.runId);
+    const timestamp = new Date().toISOString();
+    const recorded = [];
+    let recordError;
+    if (deployed.length > 0) {
+        try {
+            for (const item of deployed) {
+                const approver = gateApprover(run.results.find((r) => r.component === item.component));
+                const { record: written } = await appendReleaseRecord(record(item, plan.to, { runId, ...(runOrigin ? { runOrigin } : {}), actor: actor, timestamp, ...(approver ? { approver } : {}) }));
+                recorded.push(written);
+            }
+            await pushLifecycle();
+        }
+        catch (err) {
+            recordError = err instanceof Error ? err.message : String(err);
+        }
+    }
+    if (args.json) {
+        console.log(JSON.stringify({ ...planJson(plan, removed), run, recorded }, null, 2));
+    }
+    else {
+        for (const r of recorded) {
+            console.error(formatSuccess(verb === "promote"
+                ? `Promoted ${formatBold(r.component)} ${plan.from} -> ${plan.to}: ${r.digest}`
+                : verb === "rollback"
+                    ? `Rolled back ${formatBold(r.component)} in ${plan.to} to ${r.digest}`
+                    : `Redeployed ${formatBold(r.component)} in ${plan.to} at ${r.digest}`));
+        }
+    }
+    if (recordError !== undefined) {
+        console.error(formatError({
+            message: `deployed to "${plan.to}", but the release record was not written: ${recordError}`,
+            hint: `Pull the chant/lifecycle branch and check \`chant components status ${plan.to}\` before running this again.`,
+        }));
+        return 1;
+    }
+    if (run.status === "gated" && run.gate) {
+        const pending = run.gate;
+        console.error(formatWarning({ message: `component "${run.gatedComponent}" is gated on "${pending.gate}" — pending approval` }));
+        // #2574: an approval stands, but for another environment, plan or none.
+        const sealed = await gateIsSealed(pending.gate);
+        if (run.gateMismatch) {
+            console.error(formatWarning({ message: describeGateMismatch(pending.op, pending.gate, run.gateMismatch, sealed) }));
+        }
+        console.error(formatInfo(`approve : ${approveCommand(pending.op, pending.gate, pending.environment, undefined, sealed)}`));
+        console.error(formatInfo(`then run the same ${verb} again`));
+        writeGatedRunSummary({
+            sealed,
+            op: pending.op,
+            gate: pending.gate,
+            ...(pending.description ? { description: pending.description } : {}),
+            expiresAt: pending.expiresAt,
+            ...(pending.url ? { url: pending.url } : {}),
+            ...(pending.planDigest ? { planDigest: pending.planDigest } : {}),
+            ...(await summaryLedgerPrefix()),
+            ...(pending.environment ? { environment: pending.environment } : {}),
+        });
+        return GATED_EXIT_CODE;
+    }
+    if (run.status !== "ok") {
+        console.error(formatError({ message: `${verb} failed at "${run.failedComponent ?? "unknown"}"` }));
+        return 1;
+    }
+    return 0;
+}
+/** Refuse before anything deploys when nobody can be named on the record. */
+function actorOrRefuse(ctx) {
+    const actor = resolveActor(ctx);
+    if (!actor && !ctx.args.dryRun) {
+        console.error(formatError({
+            message: "Could not resolve --actor from the environment",
+            hint: "Pass --actor explicitly, or set GITHUB_ACTOR / GITLAB_USER_LOGIN / USER.",
+        }));
+        return 1;
+    }
+    return { actor };
+}
+export async function runComponentsPromote(ctx) {
+    const { args } = ctx;
+    const from = args.migrateFrom;
+    const to = args.migrateTo;
+    if (!from || !to) {
+        console.error(formatError({ message: "--from <env> and --to <env> are required", hint: PROMOTE_USAGE }));
+        return 1;
+    }
+    const who = actorOrRefuse(ctx);
+    if (typeof who === "number")
+        return who;
+    const project = await loadProject(ctx, args.component ?? "all");
+    if (typeof project === "number")
+        return project;
+    // Without --component, each --digest is <component>=<digest> (#2602): a
+    // generated promote job pins every component to the release its own
+    // pipeline run recorded, rather than whatever is latest in --from.
+    const digests = args.digests ?? (args.digest ? [args.digest] : []);
+    let pins;
+    if (!args.component && digests.length > 0) {
+        const parsed = parseDigestPins(digests);
+        if ("error" in parsed) {
+            console.error(formatError({ message: parsed.error, hint: PROMOTE_USAGE }));
+            return 1;
+        }
+        pins = parsed.pins;
+    }
+    else if (args.component && digests.length > 1) {
+        console.error(formatError({ message: "--component takes one --digest", hint: PROMOTE_USAGE }));
+        return 1;
+    }
+    await fetchLifecycle().catch(() => false);
+    const plan = planPromotion({
+        from,
+        to,
+        sourceRecords: await readLedger(from),
+        declared: project.targets.map((c) => c.name),
+        ...(args.component ? { component: args.component } : {}),
+        ...(args.component && args.digest ? { digest: args.digest } : {}),
+        ...(pins ? { pins } : {}),
+    });
+    if ("error" in plan) {
+        console.error(formatError({ message: plan.error, hint: PROMOTE_USAGE }));
+        return 1;
+    }
+    return deployPlan(ctx, "promote", plan, project, who.actor, promotionRecord);
+}
+export async function runComponentsRollback(ctx) {
+    const { args } = ctx;
+    const env = args.extraPositional;
+    if (!env || !args.component) {
+        console.error(formatError({ message: "an environment and --component <name> are required", hint: ROLLBACK_USAGE }));
+        return 1;
+    }
+    const who = actorOrRefuse(ctx);
+    if (typeof who === "number")
+        return who;
+    const project = await loadProject(ctx, args.component);
+    if (typeof project === "number")
+        return project;
+    await fetchLifecycle().catch(() => false);
+    const plan = planRollback({
+        env,
+        records: await readLedger(env),
+        declared: project.targets.map((c) => c.name),
+        component: args.component,
+        ...(args.digest ? { digest: args.digest } : {}),
+    });
+    if ("error" in plan) {
+        console.error(formatError({ message: plan.error, hint: ROLLBACK_USAGE }));
+        return 1;
+    }
+    return deployPlan(ctx, "rollback", plan, project, who.actor, rollbackRecord);
+}
+export async function runComponentsRedeploy(ctx) {
+    const { args } = ctx;
+    const env = args.extraPositional;
+    if (!env || !args.component) {
+        console.error(formatError({ message: "an environment and --component <name> are required", hint: REDEPLOY_USAGE }));
+        return 1;
+    }
+    const who = actorOrRefuse(ctx);
+    if (typeof who === "number")
+        return who;
+    const project = await loadProject(ctx, args.component);
+    if (typeof project === "number")
+        return project;
+    await fetchLifecycle().catch(() => false);
+    const plan = planRedeploy({
+        env,
+        records: await readLedger(env),
+        declared: project.targets.map((c) => c.name),
+        component: args.component,
+        ...(args.digest ? { digest: args.digest } : {}),
+    });
+    if ("error" in plan) {
+        console.error(formatError({ message: plan.error, hint: REDEPLOY_USAGE }));
+        return 1;
+    }
+    return deployPlan(ctx, "redeploy", plan, project, who.actor, redeployRecord);
+}

package/dist/cli/handlers/run-generate.js

@@ -0,0 +1,206 @@
+/**
+ * `chant run --generate <provider>` (#2533): the CLI for `generateOpsPipeline`
+ * (../../op/generate-pipeline.ts), the Op counterpart to `chant build
+ * --components --generate <lexicon>`.
+ *
+ * The generator is a library function with no caller of its own. A pipeline
+ * committed to a repository needs a named command that regenerates it, so a
+ * drift check (#2524 D14) can rerun that command and compare. This handler is
+ * that command and adds nothing to the generator's output beyond one header
+ * line: every file it writes is the generator's own `yaml`, byte for byte,
+ * under a first line carrying {@link GENERATED_MARKER} and the command that
+ * produced it.
+ *
+ * Where the specs come from:
+ *
+ *  - by default, every discovered Op that declares its own `schedule`, as a
+ *    bare `{ name }` spec. `generateOpsPipeline` fills the cron in from the Op
+ *    (`withOpSchedules`), so the result is exactly what a direct call with
+ *    those names returns;
+ *  - with `--spec <file>`, a JSON file holding either a `ScheduledOpSpec[]`
+ *    or `{ ops, options }`, for Ops triggered by a pull request or a push, a
+ *    finding mode, setup steps, or generator options. The file is passed to
+ *    the generator unchanged.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { discoverOps } from "../../op/discover.js";
+import { generateOpsPipeline, generateOpWavesPipeline } from "../../op/generate-pipeline.js";
+import { parseOpWavesSpec } from "../../op/op-waves-run.js";
+import { GENERATED_MARKER } from "../../discovery/files.js";
+import { findWorkspaceRoot } from "../../project-root.js";
+import { formatBold, formatError, formatSuccess } from "../format.js";
+/** Where each forge reads its pipeline files from, relative to the repository root. `--output` overrides it. */
+export const DEFAULT_OP_PIPELINE_DIRS = {
+    github: ".github/workflows",
+    forgejo: ".forgejo/workflows",
+    gitlab: ".",
+};
+/** The first line of every file this command writes. */
+export function opPipelineHeader(provider, specFile) {
+    const command = `chant run --generate ${provider}${specFile ? ` --spec ${specFile}` : ""}`;
+    return `# ${GENERATED_MARKER}. Regenerate with: ${command}\n`;
+}
+/** Read `--spec`: a `ScheduledOpSpec[]`, or `{ ops, options }`. Throws with the file named on anything else. */
+export function readOpSpecFile(path) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch (err) {
+        throw new Error(`--spec ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const shape = "an array of Op specs, or { \"ops\": [...], \"options\": {...} }";
+    const ops = Array.isArray(parsed) ? parsed : parsed?.ops;
+    if (!Array.isArray(ops))
+        throw new Error(`--spec ${path} must hold ${shape}`);
+    for (const [i, spec] of ops.entries()) {
+        if (typeof spec?.name !== "string") {
+            throw new Error(`--spec ${path}: entry ${i} has no "name". Each entry names the Op it generates a pipeline for.`);
+        }
+    }
+    const options = Array.isArray(parsed) ? undefined : parsed.options;
+    return { ops: ops, ...(options ? { options } : {}) };
+}
+/** True when a `--spec` file holds an Op waves spec (#3679) rather than a list of scheduled Ops. */
+function holdsOpWaves(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && parsed.waves !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `chant run --generate <provider> --spec <waves.json>` (#3679): one pipeline
+ * file of ordered, gated waves of Op runs. Its jobs read the same file.
+ */
+async function runOpWavesGenerate(ctx, provider, specPath) {
+    const { args } = ctx;
+    let spec;
+    let options;
+    try {
+        const text = readFileSync(resolve(specPath), "utf-8");
+        spec = parseOpWavesSpec(text, `--spec ${specPath}`);
+        const parsed = JSON.parse(text);
+        options = Array.isArray(parsed.waves) ? undefined : parsed.options;
+    }
+    catch (err) {
+        console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+        return 1;
+    }
+    const result = await generateOpWavesPipeline(spec, provider, { ...options, specFile: specPath.replace(/^\.\//, "") });
+    if (!result.success) {
+        console.error(formatError({ message: result.error ?? "Failed to generate the Op waves pipeline" }));
+        return 1;
+    }
+    const header = opPipelineHeader(provider, specPath);
+    const outDir = args.output ?? DEFAULT_OP_PIPELINE_DIRS[provider] ?? ".";
+    const files = (result.files ?? []).map((f) => ({ name: f.name, path: join(outDir, f.name), content: header + f.yaml }));
+    if (args.format === "json") {
+        console.log(JSON.stringify({ files, jobs: result.jobs ?? [] }, null, 2));
+        return 0;
+    }
+    for (const file of files) {
+        const target = resolve(file.path);
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, file.content);
+        console.error(formatSuccess(`wrote ${formatBold(file.path)}`));
+    }
+    return 0;
+}
+export async function runOpGenerate(ctx) {
+    const { args } = ctx;
+    const provider = args.generate;
+    const specPath = args.opsSpec;
+    if (specPath && holdsOpWaves(resolve(specPath)))
+        return runOpWavesGenerate(ctx, provider, specPath);
+    let ops;
+    let options;
+    if (specPath) {
+        try {
+            ({ ops, options } = readOpSpecFile(resolve(specPath)));
+        }
+        catch (err) {
+            console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+            return 1;
+        }
+    }
+    else {
+        const discovered = await discoverOps();
+        if (discovered.errors.length > 0) {
+            for (const e of discovered.errors)
+                console.error(formatError({ message: e }));
+            return 1;
+        }
+        ops = [...discovered.ops.entries()]
+            .filter(([, op]) => op.config.schedule)
+            .map(([name]) => name)
+            .sort()
+            .map((name) => ({ name }));
+        if (ops.length === 0) {
+            console.error(formatError({
+                message: "No Op declares a schedule, so there is nothing to generate",
+                hint: "Give an Op a `schedule`, or pass --spec <file.json> naming the Ops and their triggers.",
+            }));
+            return 1;
+        }
+    }
+    // Inside a workspace member (#2542), the files are the member's: filtered
+    // to its paths, run in its directory, named after it at the repository
+    // root's forge directory, and recorded as its generated files. The
+    // workspace module loads only when a declaration was found.
+    const found = findWorkspaceRoot(process.cwd());
+    let plan;
+    let memberPipeline;
+    if (found) {
+        memberPipeline = await import("../../workspace/member-pipeline.js");
+        try {
+            plan = memberPipeline.planMemberOpPipelines({ projectDir: process.cwd(), found, provider, output: args.output, specFile: specPath });
+        }
+        catch (err) {
+            console.error(formatError({ message: memberPipeline.describeError(err) }));
+            return 1;
+        }
+    }
+    const result = await generateOpsPipeline(ops, provider, plan ? { ...options, member: plan.member } : options);
+    if (!result.success) {
+        console.error(formatError({ message: result.error ?? "Failed to generate Op pipelines" }));
+        return 1;
+    }
+    if (plan && memberPipeline) {
+        const header = memberPipeline.generatedHeader(plan.command);
+        if (args.format === "json") {
+            const files = (result.files ?? []).map((f) => ({
+                name: f.name,
+                path: memberPipeline.repoRelative(plan.ctx, join(plan.outDir, f.name)),
+                content: header + f.yaml,
+            }));
+            console.log(JSON.stringify({ member: plan.member.name, files, jobs: result.jobs ?? [] }, null, 2));
+            return 0;
+        }
+        for (const path of memberPipeline.writeMemberOpPipelines(plan, result.files ?? [])) {
+            console.error(formatSuccess(`wrote ${formatBold(path)} for member ${formatBold(plan.member.name)}`));
+        }
+        return 0;
+    }
+    const header = opPipelineHeader(provider, specPath);
+    const outDir = args.output ?? DEFAULT_OP_PIPELINE_DIRS[provider] ?? ".";
+    const files = (result.files ?? []).map((f) => ({
+        name: f.name,
+        path: join(outDir, f.name),
+        content: header + f.yaml,
+    }));
+    if (args.format === "json") {
+        console.log(JSON.stringify({ files, jobs: result.jobs ?? [] }, null, 2));
+        return 0;
+    }
+    for (const file of files) {
+        const target = resolve(file.path);
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, file.content);
+        console.error(formatSuccess(`wrote ${formatBold(file.path)}`));
+    }
+    return 0;
+}

package/dist/cli/handlers/run-wave.js

@@ -0,0 +1,66 @@
+/**
+ * `chant run wave --spec <file> --wave <k>` (#3679): the command each job of
+ * a generated Op waves pipeline runs. See `../../op/op-waves-run.ts`.
+ */
+import { readFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { notifyOpWave } from "../../op/op-waves-notify.js";
+import { parseOpWavesSpec, recordOpWaveHeadPlans, runOpWave } from "../../op/op-waves-run.js";
+import { formatError } from "../format.js";
+export async function runOpWaveCommand(ctx) {
+    const { args } = ctx;
+    const specFile = args.opsSpec;
+    if (specFile && args.recordPlans) {
+        try {
+            const spec = parseOpWavesSpec(readFileSync(resolve(specFile), "utf-8"), `--spec ${specFile}`);
+            const plans = await recordOpWaveHeadPlans({ spec });
+            if (args.json)
+                console.log(JSON.stringify(plans, null, 2));
+            else
+                for (const w of plans.waves)
+                    console.error(`wave ${w.wave} (${w.name}) at ${plans.head.slice(0, 12)}: ${w.digest}`);
+            return 0;
+        }
+        catch (err) {
+            console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+            return 1;
+        }
+    }
+    if (!specFile || args.wave === undefined) {
+        console.error(formatError({
+            message: "`chant run wave` needs --spec <file> and --wave <k>",
+            hint: "Run it as a generated Op waves pipeline does: chant run wave --spec <file> --wave <k> [--decide | --share <i>]",
+        }));
+        return 1;
+    }
+    if (args.decide && args.share !== undefined) {
+        console.error(formatError({ message: "--decide and --share are two different jobs; pass one" }));
+        return 1;
+    }
+    let spec;
+    const job = args.share !== undefined ? { share: args.share } : {};
+    try {
+        const path = resolve(specFile);
+        spec = parseOpWavesSpec(readFileSync(path, "utf-8"), `--spec ${specFile}`);
+        const result = await runOpWave({
+            spec,
+            specFile: relative(process.cwd(), path),
+            wave: args.wave,
+            ...(args.decide ? { decide: true } : {}),
+            ...(args.share !== undefined ? { share: args.share } : {}),
+            ...(args.base ? { base: args.base } : {}),
+        });
+        if (args.json)
+            console.log(JSON.stringify(result, null, 2));
+        // #3761: tell people, when the spec says where. Delivery never changes the exit code.
+        await notifyOpWave(spec, args.wave, { result }, job);
+        return result.exitCode;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(formatError({ message }));
+        if (spec)
+            await notifyOpWave(spec, args.wave, { error: message }, job);
+        return 1;
+    }
+}