@intentius/chant 0.124.97 → 0.124.98

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (223) hide show
  1. package/dist/audit/core.d.ts +29 -0
  2. package/dist/audit/core.d.ts.map +1 -1
  3. package/dist/audit/core.js +48 -11
  4. package/dist/audit/identity.d.ts +27 -0
  5. package/dist/audit/identity.d.ts.map +1 -0
  6. package/dist/audit/identity.js +36 -0
  7. package/dist/audit/report-html.d.ts +3 -1
  8. package/dist/audit/report-html.d.ts.map +1 -1
  9. package/dist/audit/report-html.js +1 -1
  10. package/dist/audit/report-model.d.ts +16 -0
  11. package/dist/audit/report-model.d.ts.map +1 -1
  12. package/dist/audit/report-model.js +5 -1
  13. package/dist/ci-agent.d.ts +17 -0
  14. package/dist/ci-agent.d.ts.map +1 -1
  15. package/dist/ci-agent.js +32 -0
  16. package/dist/ci-comment-allow.d.ts +88 -0
  17. package/dist/ci-comment-allow.d.ts.map +1 -0
  18. package/dist/ci-comment-allow.js +178 -0
  19. package/dist/ci-comment-commands.d.ts +12 -0
  20. package/dist/ci-comment-commands.d.ts.map +1 -1
  21. package/dist/ci-comment-commands.js +22 -0
  22. package/dist/ci-control.d.ts +6 -1
  23. package/dist/ci-control.d.ts.map +1 -1
  24. package/dist/ci-control.js +6 -1
  25. package/dist/ci-product.d.ts +3 -0
  26. package/dist/ci-product.d.ts.map +1 -1
  27. package/dist/ci-product.js +3 -0
  28. package/dist/cli/commands/audit.d.ts +3 -1
  29. package/dist/cli/commands/audit.d.ts.map +1 -1
  30. package/dist/cli/commands/audit.js +23 -6
  31. package/dist/cli/commands/import.d.ts +8 -1
  32. package/dist/cli/commands/import.d.ts.map +1 -1
  33. package/dist/cli/commands/import.js +31 -6
  34. package/dist/cli/handlers/agent.d.ts.map +1 -1
  35. package/dist/cli/handlers/agent.js +12 -2
  36. package/dist/cli/handlers/pr-comment.d.ts +6 -0
  37. package/dist/cli/handlers/pr-comment.d.ts.map +1 -1
  38. package/dist/cli/handlers/pr-comment.js +12 -0
  39. package/dist/cli/handlers/promote.d.ts.map +1 -1
  40. package/dist/cli/handlers/promote.js +53 -6
  41. package/dist/cli/main.d.ts.map +1 -1
  42. package/dist/cli/main.js +29 -6
  43. package/dist/cli/parse-args.d.ts.map +1 -1
  44. package/dist/cli/parse-args.js +23 -0
  45. package/dist/cli/registry.d.ts +8 -0
  46. package/dist/cli/registry.d.ts.map +1 -1
  47. package/dist/cloud-lister/mask.d.ts +30 -1
  48. package/dist/cloud-lister/mask.d.ts.map +1 -1
  49. package/dist/cloud-lister/mask.js +66 -3
  50. package/dist/components/driver.d.ts +8 -1
  51. package/dist/components/driver.d.ts.map +1 -1
  52. package/dist/components/driver.js +1 -0
  53. package/dist/components/product-pipeline.d.ts +23 -1
  54. package/dist/components/product-pipeline.d.ts.map +1 -1
  55. package/dist/components/product-pipeline.js +40 -7
  56. package/dist/components/product-plan.d.ts +20 -0
  57. package/dist/components/product-plan.d.ts.map +1 -1
  58. package/dist/components/product-plan.js +11 -1
  59. package/dist/control/applied.d.ts +8 -1
  60. package/dist/control/applied.d.ts.map +1 -1
  61. package/dist/control/applied.js +18 -2
  62. package/dist/control/dispatch.d.ts +52 -0
  63. package/dist/control/dispatch.d.ts.map +1 -1
  64. package/dist/control/dispatch.js +140 -4
  65. package/dist/control/train.d.ts +198 -0
  66. package/dist/control/train.d.ts.map +1 -0
  67. package/dist/control/train.js +294 -0
  68. package/dist/deep-observation.js +2 -2
  69. package/dist/floor-table.data.d.ts.map +1 -1
  70. package/dist/floor-table.data.js +11 -0
  71. package/dist/graph-detail.d.ts +9 -0
  72. package/dist/graph-detail.d.ts.map +1 -1
  73. package/dist/graph-detail.js +38 -13
  74. package/dist/graph-refs.d.ts +233 -3
  75. package/dist/graph-refs.d.ts.map +1 -1
  76. package/dist/graph-refs.js +106 -15
  77. package/dist/lint/post-synth.d.ts +22 -0
  78. package/dist/lint/post-synth.d.ts.map +1 -1
  79. package/dist/lint/rules/declarable-naming-convention.d.ts +12 -0
  80. package/dist/lint/rules/declarable-naming-convention.d.ts.map +1 -1
  81. package/dist/lint/rules/declarable-naming-convention.js +38 -8
  82. package/dist/lint/rules/imported-source.d.ts +20 -0
  83. package/dist/lint/rules/imported-source.d.ts.map +1 -0
  84. package/dist/lint/rules/imported-source.js +27 -0
  85. package/dist/lint/rules/no-unused-declarable.d.ts.map +1 -1
  86. package/dist/lint/rules/no-unused-declarable.js +3 -0
  87. package/dist/op/gate.d.ts +2 -0
  88. package/dist/op/gate.d.ts.map +1 -1
  89. package/dist/op/gate.js +8 -1
  90. package/dist/pr-forge-reads.d.ts +17 -0
  91. package/dist/pr-forge-reads.d.ts.map +1 -1
  92. package/dist/pr-forge-reads.js +55 -0
  93. package/dist/release-floors.d.ts +9 -1
  94. package/dist/release-floors.d.ts.map +1 -1
  95. package/dist/release-floors.js +9 -1
  96. package/dist/repo-path.d.ts +29 -0
  97. package/dist/repo-path.d.ts.map +1 -0
  98. package/dist/repo-path.js +81 -0
  99. package/dist/sensitive-key.d.ts +23 -0
  100. package/dist/sensitive-key.d.ts.map +1 -1
  101. package/dist/sensitive-key.js +37 -0
  102. package/dist/terraform/hcl2json.d.ts +7 -0
  103. package/dist/terraform/hcl2json.d.ts.map +1 -1
  104. package/dist/terraform/hcl2json.js +7 -0
  105. package/dist/wave-runtime.mjs +352 -345
  106. package/dist/workspace/catalog-edges.d.ts +147 -0
  107. package/dist/workspace/catalog-edges.d.ts.map +1 -0
  108. package/dist/workspace/catalog-edges.js +461 -0
  109. package/dist/workspace/compose-graph.d.ts +73 -3
  110. package/dist/workspace/compose-graph.d.ts.map +1 -1
  111. package/dist/workspace/declaration.d.ts +2 -0
  112. package/dist/workspace/declaration.d.ts.map +1 -1
  113. package/dist/workspace/declaration.js +1 -0
  114. package/dist/workspace/declaration.schema.json +6 -0
  115. package/dist/workspace/discover.d.ts +134 -0
  116. package/dist/workspace/discover.d.ts.map +1 -0
  117. package/dist/workspace/discover.js +372 -0
  118. package/dist/workspace/graph-cli.d.ts +20 -0
  119. package/dist/workspace/graph-cli.d.ts.map +1 -1
  120. package/dist/workspace/graph-cli.js +178 -20
  121. package/dist/workspace/graph.schema.json +195 -2
  122. package/dist/workspace/release-train.d.ts +214 -3
  123. package/dist/workspace/release-train.d.ts.map +1 -1
  124. package/dist/workspace/release-train.js +552 -16
  125. package/dist/workspace/repo-ref.d.ts +14 -0
  126. package/dist/workspace/repo-ref.d.ts.map +1 -1
  127. package/dist/workspace/repo-ref.js +26 -1
  128. package/dist/workspace/workspace-gates.d.ts +24 -0
  129. package/dist/workspace/workspace-gates.d.ts.map +1 -1
  130. package/dist/workspace/workspace-gates.js +29 -5
  131. package/dist/workspace/workspace-ledger.d.ts +31 -5
  132. package/dist/workspace/workspace-ledger.d.ts.map +1 -1
  133. package/dist/workspace/workspace-ledger.js +2 -1
  134. package/dist/workspace/workspace-run.d.ts +14 -0
  135. package/dist/workspace/workspace-run.d.ts.map +1 -1
  136. package/dist/workspace/workspace-run.js +2 -2
  137. package/dist/yaml.d.ts.map +1 -1
  138. package/dist/yaml.js +33 -8
  139. package/package.json +1 -1
  140. package/src/audit/core.test.ts +64 -1
  141. package/src/audit/core.ts +75 -10
  142. package/src/audit/identity.test.ts +31 -0
  143. package/src/audit/identity.ts +43 -0
  144. package/src/audit/report-html.ts +4 -2
  145. package/src/audit/report-model.ts +21 -1
  146. package/src/ci-agent.test.ts +32 -0
  147. package/src/ci-agent.ts +42 -0
  148. package/src/ci-comment-allow.test.ts +380 -0
  149. package/src/ci-comment-allow.ts +184 -0
  150. package/src/ci-comment-commands.ts +25 -0
  151. package/src/ci-control.ts +42 -0
  152. package/src/ci-product.ts +3 -0
  153. package/src/cli/commands/audit-parser-notice.test.ts +74 -0
  154. package/src/cli/commands/audit.test.ts +12 -0
  155. package/src/cli/commands/audit.ts +25 -7
  156. package/src/cli/commands/import-layout.test.ts +2 -1
  157. package/src/cli/commands/import.ts +29 -6
  158. package/src/cli/handlers/agent.ts +13 -2
  159. package/src/cli/handlers/pr-comment.ts +12 -0
  160. package/src/cli/handlers/promote.test.ts +68 -0
  161. package/src/cli/handlers/promote.ts +52 -6
  162. package/src/cli/main.test.ts +5 -0
  163. package/src/cli/main.ts +29 -6
  164. package/src/cli/parse-args.ts +18 -0
  165. package/src/cli/registry.ts +8 -0
  166. package/src/cloud-lister/kubernetes.k3d.e2e.test.ts +104 -0
  167. package/src/cloud-lister/mask-references.test.ts +132 -0
  168. package/src/cloud-lister/mask.ts +68 -3
  169. package/src/components/driver.ts +9 -1
  170. package/src/components/product-pipeline.ts +57 -7
  171. package/src/components/product-plan.ts +27 -2
  172. package/src/control/applied.ts +33 -3
  173. package/src/control/dispatch.ts +156 -5
  174. package/src/control/train.test.ts +215 -0
  175. package/src/control/train.ts +413 -0
  176. package/src/deep-observation.ts +2 -2
  177. package/src/floor-table.data.ts +6 -0
  178. package/src/graph-detail.ts +37 -12
  179. package/src/graph-refs.test.ts +45 -1
  180. package/src/graph-refs.ts +321 -14
  181. package/src/lint/post-synth.ts +20 -0
  182. package/src/lint/rules/declarable-naming-convention.test.ts +35 -1
  183. package/src/lint/rules/declarable-naming-convention.ts +35 -8
  184. package/src/lint/rules/imported-source.test.ts +22 -0
  185. package/src/lint/rules/imported-source.ts +31 -0
  186. package/src/lint/rules/no-unused-declarable.test.ts +16 -0
  187. package/src/lint/rules/no-unused-declarable.ts +7 -0
  188. package/src/op/gate.ts +10 -2
  189. package/src/pr-forge-reads.ts +62 -0
  190. package/src/release-floors.ts +13 -1
  191. package/src/repo-path.test.ts +72 -0
  192. package/src/repo-path.ts +103 -0
  193. package/src/sensitive-key.ts +38 -0
  194. package/src/terraform/hcl2json.ts +8 -0
  195. package/src/workspace/application-set.e2e.test.ts +405 -0
  196. package/src/workspace/catalog-edges.ts +507 -0
  197. package/src/workspace/ci-green-workflow.test.ts +2 -2
  198. package/src/workspace/cluster-join.e2e.test.ts +150 -0
  199. package/src/workspace/compose-graph.ts +74 -5
  200. package/src/workspace/declaration.schema.json +6 -0
  201. package/src/workspace/declaration.ts +3 -0
  202. package/src/workspace/discover.e2e.test.ts +122 -0
  203. package/src/workspace/discover.test.ts +225 -0
  204. package/src/workspace/discover.ts +406 -0
  205. package/src/workspace/external-secret-catalog.e2e.test.ts +98 -0
  206. package/src/workspace/external-secret-catalog.test.ts +142 -0
  207. package/src/workspace/graph-cli.ts +207 -21
  208. package/src/workspace/graph-contract.test.ts +92 -0
  209. package/src/workspace/graph.schema.json +195 -2
  210. package/src/workspace/helm-references.e2e.test.ts +135 -0
  211. package/src/workspace/identity-annotation-catalog.e2e.test.ts +91 -0
  212. package/src/workspace/identity-annotation-catalog.test.ts +139 -0
  213. package/src/workspace/release-train-repos.test.ts +304 -0
  214. package/src/workspace/release-train.test.ts +296 -0
  215. package/src/workspace/release-train.ts +631 -16
  216. package/src/workspace/repo-ref.ts +26 -1
  217. package/src/workspace/runs-on.test.ts +45 -0
  218. package/src/workspace/workspace-gates.ts +48 -5
  219. package/src/workspace/workspace-ledger.ts +28 -5
  220. package/src/workspace/workspace-run.test.ts +1 -1
  221. package/src/workspace/workspace-run.ts +2 -2
  222. package/src/yaml.test.ts +96 -8
  223. package/src/yaml.ts +36 -8
@@ -8,15 +8,54 @@
8
8
  * the one `--pin <member>=<label|digest>` picks. It refuses unless every
9
9
  * `chant` member of the declaration has a release, so a train never leaves a
10
10
  * member out. It is written to `_members/_workspace/<env>/trains.jsonl`.
11
+ *
12
+ * A train's digest (#4037) is over the member release digests and nothing
13
+ * else, so the same picks always give the same train digest, whatever the
14
+ * environment, actor or time. The member releases are named, never copied
15
+ * or changed.
16
+ *
17
+ * `chant workspace train promote <env>` (#4037) promotes a train: each
18
+ * member's `chant components promote --to <env> --release <its digest>`,
19
+ * under the member's own chant, producers first. With `--gate <name>`,
20
+ * every member plans first (`--plan-only`), one workspace gate fact covers
21
+ * each member's release gates with its change set and release, and nothing
22
+ * deploys until `chant workspace run approve <name>` approves it. The
23
+ * promote is a workspace run record that names the train.
24
+ *
25
+ * A train can pin `repo` members too (#5119): each one's releases are read
26
+ * at its pinned revision through that repository's own `chant release list
27
+ * --json`. A train of `repo` members is promoted from the control repo, one
28
+ * member repository at a time: each call dispatches a member, or moves on
29
+ * from its answer in `_control/applied.jsonl` (`--continue`). Each member
30
+ * keeps its own gate (../control/train.ts has the jobs on both sides).
11
31
  */
32
+ import { spawn } from "node:child_process";
12
33
  import { randomUUID } from "node:crypto";
13
34
  import { resolve } from "node:path";
14
35
  import { formatError } from "../cli/format.js";
36
+ import { CHANT_EXIT } from "../exit-codes.js";
37
+ import { computePlanDigest } from "../lifecycle/plan-digest.js";
15
38
  import { readAllReleases, readCuts } from "../lifecycle/release-store.js";
39
+ import { WORKSPACE_GATE_ENV, WORKSPACE_RUN_ENV } from "../op/workspace-run-env.js";
16
40
  import { readDeclaration, WorkspaceReadError } from "./declaration.js";
41
+ import { REPO_KIND } from "./kinds.js";
17
42
  import { locateWorkspace } from "./which-chant.js";
18
- import { appendWorkspaceLine, readWorkspaceLines } from "./workspace-ledger.js";
43
+ import { appendWorkspaceLine, appendWorkspaceRun, readWorkspaceLines, readWorkspaceRuns } from "./workspace-ledger.js";
44
+ import { appendWorkspaceGatePending, readWorkspaceGate, workspaceGateDigest } from "./workspace-gates.js";
19
45
  import { actorFromEnv } from "../actor.js";
46
+ import { NEXT_RELEASE } from "../release-floors.js";
47
+ /**
48
+ * The digest of a train (#4037): over each member's name and release digest,
49
+ * sorted by member. The commit and the label are the release's own, and the
50
+ * release digest already covers the commit, so they stay out, as do the
51
+ * environment, the id, the actor and the time.
52
+ */
53
+ export function trainDigest(members) {
54
+ const subject = [...members]
55
+ .map((m) => ({ member: m.member, releaseDigest: m.releaseDigest }))
56
+ .sort((a, b) => (a.member < b.member ? -1 : a.member > b.member ? 1 : 0));
57
+ return computePlanDigest("release-train", { members: subject });
58
+ }
20
59
  const TRAINS_FILE = "trains.jsonl";
21
60
  /**
22
61
  * Pick each member's release, pure. `pins` maps a member to a label or a
@@ -28,25 +67,41 @@ export function pickTrain(members, pins = new Map()) {
28
67
  const picked = [];
29
68
  for (const name of pins.keys()) {
30
69
  if (!members.some((m) => m.member === name))
31
- problems.push(`--pin ${name}: not a chant member of the workspace`);
70
+ problems.push(`--pin ${name}: not a chant or repo member of the workspace`);
32
71
  }
33
72
  for (const m of members) {
73
+ if (m.problem !== undefined) {
74
+ problems.push(`member ${m.member}: ${m.problem}`);
75
+ continue;
76
+ }
34
77
  const pin = pins.get(m.member);
35
78
  const r = pin === undefined ? m.releases[0] : m.releases.find((x) => x.releaseDigest === pin || x.label === pin);
36
79
  if (!r) {
37
- problems.push(pin === undefined ? `member ${m.member} has no release; cut one with chant release cut in its directory` : `member ${m.member} has no release ${pin}`);
80
+ const where = m.repo !== undefined ? `in ${m.repo}` : "in its directory";
81
+ problems.push(pin === undefined ? `member ${m.member} has no release; cut one with chant release cut ${where}` : `member ${m.member} has no release ${pin}`);
38
82
  continue;
39
83
  }
40
84
  picked.push(r);
41
85
  }
86
+ // #4037: a train names at least one release, so its digest never covers nothing.
87
+ if (members.length === 0)
88
+ problems.push("the workspace declares no chant or repo member, so a train has nothing to pin");
42
89
  return problems.length > 0 ? { problems } : { members: picked };
43
90
  }
44
- /** Every `chant` member's releases, newest cut first, read from its ledger. */
45
- export async function readMemberReleases(cwd) {
91
+ /**
92
+ * Every `chant` member's releases, newest cut first, read from its ledger,
93
+ * and every `repo` member's, read through that repository's own
94
+ * `chant release list --json` at its pinned revision (#5119).
95
+ */
96
+ export async function readMemberReleases(cwd, opts = {}) {
46
97
  const located = locateWorkspace(cwd);
47
98
  const declaration = readDeclaration(located.tree, "", { rootChant: true });
48
99
  const out = [];
49
100
  for (const m of declaration.members) {
101
+ if (m.kind === REPO_KIND && m.repo !== null) {
102
+ out.push(await (opts.readRepo ?? readRepoReleases)(m.name, m.repo, located.rootOnDisk));
103
+ continue;
104
+ }
50
105
  if (m.kind !== "chant")
51
106
  continue;
52
107
  const loc = { cwd: located.rootOnDisk, member: m.dir === "." ? "." : m.name };
@@ -62,20 +117,402 @@ export async function readMemberReleases(cwd) {
62
117
  }
63
118
  return out;
64
119
  }
120
+ /** Starts one chant command in `cwd` and gives back what it printed. */
121
+ function spawnChant(command, argv, cwd) {
122
+ const [bin, ...pre] = command;
123
+ return new Promise((done) => {
124
+ const child = spawn(bin, [...pre, ...argv], { cwd, stdio: ["ignore", "pipe", "pipe"], env: process.env });
125
+ const out = [];
126
+ const err = [];
127
+ child.stdout.on("data", (b) => out.push(b));
128
+ child.stderr.on("data", (b) => err.push(b));
129
+ child.on("error", (e) => done({ exitCode: 127, stdout: "", stderr: `could not start ${bin}: ${e.message}` }));
130
+ child.on("close", (code) => done({ exitCode: code ?? 1, stdout: Buffer.concat(out).toString("utf8"), stderr: Buffer.concat(err).toString("utf8") }));
131
+ });
132
+ }
133
+ /**
134
+ * The releases of a `repo` member (#5119), read the way its graph is read
135
+ * (#3168): chant fetches the pinned revision into the user's cache, brings
136
+ * that repository's `chant/lifecycle` into the cache clone, and runs
137
+ * `chant release list --json` in the workspace root at the revision, under
138
+ * the chant that resolves there. Nothing is written in the other
139
+ * repository. A read that fails says why, and stops the train.
140
+ */
141
+ export async function readRepoReleases(member, ref, workspaceRoot, opts = {}) {
142
+ const { fetchRepoAt, fetchRepoLifecycle, redactUrl } = await import("./repo-ref.js");
143
+ const url = redactUrl(ref.url);
144
+ const base = { member, releases: [], repo: url };
145
+ const fetched = fetchRepoAt(ref, workspaceRoot, opts.env);
146
+ if (!fetched.ok)
147
+ return { ...base, problem: fetched.message };
148
+ const lifecycle = fetchRepoLifecycle(ref, workspaceRoot, opts.env);
149
+ if (!lifecycle.ok)
150
+ return { ...base, problem: lifecycle.message };
151
+ const { resolveToolchain } = await import("./member-commands.js");
152
+ const command = opts.command ?? resolveToolchain(fetched.dir, fetched.worktree).command;
153
+ const r = await spawnChant(command, ["release", "list", "--json"], fetched.dir);
154
+ let doc;
155
+ try {
156
+ doc = JSON.parse(r.stdout);
157
+ }
158
+ catch {
159
+ doc = null;
160
+ }
161
+ const { RELEASES_SCHEMA_ID } = await import("./releases.js");
162
+ if (!doc || doc.$schema !== RELEASES_SCHEMA_ID) {
163
+ const tail = r.stderr.trim().split("\n").slice(-3).join("; ");
164
+ return { ...base, problem: `chant release list in ${url} at ${ref.rev.slice(0, 12)} exited ${r.exitCode} and printed no releases document${tail ? `: ${tail}` : ""}` };
165
+ }
166
+ if (doc.error)
167
+ return { ...base, problem: `chant release list in ${url} at ${ref.rev.slice(0, 12)}: ${String(doc.error.code)}: ${String(doc.error.message)}` };
168
+ const entries = Array.isArray(doc.releases) ? doc.releases : [];
169
+ const releases = [];
170
+ // The document lists the newest cut first; a release no cut names comes last and is not one a train takes.
171
+ for (const e of entries) {
172
+ if (typeof e.releaseDigest !== "string" || typeof e.commit !== "string" || !Array.isArray(e.cuts) || e.cuts.length === 0)
173
+ continue;
174
+ releases.push({ member, releaseDigest: e.releaseDigest, commit: e.commit, label: typeof e.label === "string" ? e.label : null, repo: { url, rev: ref.rev } });
175
+ }
176
+ return { ...base, releases };
177
+ }
65
178
  function isTrain(v) {
66
179
  const t = v;
67
180
  return typeof t === "object" && t !== null && t.version === 1 && typeof t.id === "string" && typeof t.env === "string" && Array.isArray(t.members);
68
181
  }
69
182
  export async function readReleaseTrains(cwd, env) {
70
- return readWorkspaceLines(cwd, env, TRAINS_FILE, isTrain);
183
+ const { records, malformed } = await readWorkspaceLines(cwd, env, TRAINS_FILE, isTrain);
184
+ return { records: records.map((t) => ({ ...t, trainDigest: t.trainDigest ?? trainDigest(t.members) })), malformed };
185
+ }
186
+ /** The train `ref` names, by id or digest, else the newest. Null when there is none. */
187
+ export function findTrain(trains, ref) {
188
+ if (ref === undefined)
189
+ return trains.at(-1) ?? null;
190
+ return trains.filter((t) => t.id === ref || t.trainDigest === ref).at(-1) ?? null;
71
191
  }
72
192
  export async function appendReleaseTrain(cwd, record) {
73
193
  return appendWorkspaceLine(cwd, record.env, TRAINS_FILE, record, `Release train: ${record.env} ${record.id}`);
74
194
  }
75
- const USAGE = "chant workspace train <env> [--pin <member>=<label|digest>]... [--dry-run] [--json] | chant workspace train list <env> [--json]";
195
+ /** The first chant that writes {@link ReleaseTrainRecord.trainDigest} and has `chant workspace train promote` (#4037). */
196
+ export const TRAIN_PROMOTE_FLOOR = NEXT_RELEASE;
197
+ // ── Promote ──────────────────────────────────────────────────────────────────
198
+ /** What a step of a train's promote runs in each member: `chant components promote`. */
199
+ export const TRAIN_STEP_OP = "components promote";
200
+ function isMemberReleasePlan(v) {
201
+ const p = v;
202
+ return typeof p === "object" && p !== null && typeof p.releaseDigest === "string" && typeof p.op === "string" && Array.isArray(p.gates) && (p.changeSet === null || typeof p.changeSet === "string");
203
+ }
204
+ /**
205
+ * The covers a workspace gate needs for one member's release (#4037): one
206
+ * per release gate, bound to the member's change set, the environment and
207
+ * the release. None for an empty change set, which passes without an
208
+ * approval, nor for a promote that declares no gate.
209
+ */
210
+ export function releaseCovers(member, env, plan) {
211
+ if (plan.changeSet === null || plan.empty === true)
212
+ return [];
213
+ return plan.gates.map((gate) => ({ member, op: plan.op, gate, planDigest: plan.changeSet, environment: env, releaseDigest: plan.releaseDigest }));
214
+ }
215
+ const promoteArgv = (env, m, extra = []) => ["components", "promote", "--to", env, "--release", m.releaseDigest, ...extra, "--json"];
216
+ /** The JSON a member's promote printed, or null. */
217
+ function parseJson(stdout) {
218
+ const at = stdout.indexOf("{");
219
+ if (at < 0)
220
+ return null;
221
+ try {
222
+ return JSON.parse(stdout.slice(at));
223
+ }
224
+ catch {
225
+ return null;
226
+ }
227
+ }
228
+ /** The member run and the gate a member's `promote --json` output names. */
229
+ function promoteOutcome(stdout) {
230
+ const doc = parseJson(stdout);
231
+ const runId = doc?.recorded?.find((r) => typeof r.runId === "string")?.runId;
232
+ const g = doc?.run?.gate;
233
+ return {
234
+ run: typeof runId === "string" ? runId : null,
235
+ ...(g && typeof g.gate === "string"
236
+ ? { gate: { op: typeof g.op === "string" ? g.op : TRAIN_STEP_OP, name: g.gate, planDigest: typeof g.planDigest === "string" ? g.planDigest : null, environment: typeof g.environment === "string" ? g.environment : null } }
237
+ : {}),
238
+ };
239
+ }
240
+ /**
241
+ * Promote a release train (#4037). Each member's release is promoted with
242
+ * `chant components promote --to <env> --release <digest>` under its own
243
+ * chant, producers first, stopping at the first member that does not pass.
244
+ *
245
+ * With a workspace gate, each member plans first and deploys nothing; the
246
+ * covers of every member's release gates are recorded as one pending fact
247
+ * naming the train, and the run ends gated. Once an approval of exactly
248
+ * those covers stands, the same call promotes every member under the gate,
249
+ * so each release gate takes the approval in place of its own where the
250
+ * member opts in at base. A member whose plan moved since then plans a
251
+ * change set the approval does not cover, and stops at its own gate.
252
+ */
253
+ export async function promoteTrain(query) {
254
+ const now = query.now ?? (() => new Date().toISOString());
255
+ const { records } = await readReleaseTrains(query.cwd, query.env);
256
+ const train = findTrain(records, query.train);
257
+ if (!train) {
258
+ return {
259
+ kind: "refused",
260
+ message: query.train === undefined ? `no release train is recorded for ${query.env}; record one with chant workspace train ${query.env}` : `no release train ${query.train} is recorded for ${query.env}`,
261
+ };
262
+ }
263
+ if (train.members.length === 0)
264
+ return { kind: "refused", message: `release train ${train.id} pins no member, so there is nothing to promote` };
265
+ const across = train.members.filter((m) => m.repo !== undefined);
266
+ if (across.length > 0) {
267
+ if (across.length < train.members.length) {
268
+ return { kind: "refused", message: `release train ${train.id} pins repo members (${across.map((m) => m.member).join(", ")}) and chant members (${train.members.filter((m) => !m.repo).map((m) => m.member).join(", ")}); a promote runs chant members here and dispatches repo members, so record a train of one kind` };
269
+ }
270
+ return promoteAcrossRepos(query, train, now);
271
+ }
272
+ if (query.continue)
273
+ return { kind: "refused", message: "--continue advances a train of repo members, and this train pins chant members" };
274
+ const { defaultReadGraph, defaultRunMember, orderTargets } = await import("./workspace-run.js");
275
+ const read = await (query.readGraph ?? defaultReadGraph)(query.cwd);
276
+ if ("error" in read)
277
+ return { kind: "refused", message: `the workspace graph could not be read: ${read.error}` };
278
+ const { graph } = read;
279
+ const missing = train.members.filter((m) => !graph.members.some((g) => g.name === m.member && g.status === "composed"));
280
+ if (missing.length > 0)
281
+ return { kind: "refused", message: `release train ${train.id} pins ${missing.map((m) => m.member).join(", ")}, which the workspace graph does not compose` };
282
+ const order = orderTargets(train.members.map((m) => ({ member: m.member, op: TRAIN_STEP_OP })), graph.links).map((t) => train.members.find((m) => m.member === t.member));
283
+ if (query.dryRun)
284
+ return { kind: "planned", train, order: order.map((m) => m.member) };
285
+ const id = `ws-${randomUUID()}`;
286
+ const started = now();
287
+ const citation = { id: train.id, digest: train.trainDigest };
288
+ const steps = order.map((m) => ({ target: `${m.member}/${TRAIN_STEP_OP}`, member: m.member, op: TRAIN_STEP_OP, status: "not-run", exitCode: null, memberRun: null }));
289
+ const runMember = query.runMember ?? ((m, argv, e) => defaultRunMember(query.cwd, m, argv, e));
290
+ const dirOf = (member) => graph.members.find((g) => g.name === member).dir;
291
+ const finish = async (status, pending, approved, gatherCovers) => {
292
+ const record = { version: 1, id, started, ended: now(), status, env: query.env, gate: query.gate ?? null, dependentsOf: null, steps, train: citation };
293
+ let written = pending;
294
+ let ledgerError = null;
295
+ try {
296
+ if (gatherCovers && query.gate && !written)
297
+ written = await appendWorkspaceGatePending(query.cwd, { gate: query.gate, run: id, timestamp: record.ended, covers: gatherCovers, train: citation });
298
+ await appendWorkspaceRun(query.cwd, record);
299
+ }
300
+ catch (err) {
301
+ ledgerError = err instanceof Error ? err.message : String(err);
302
+ }
303
+ return { kind: "ran", train, record, pending: written, approved, ledgerError };
304
+ };
305
+ // With a workspace gate: every member plans before any deploys.
306
+ let approved = null;
307
+ if (query.gate) {
308
+ const covers = [];
309
+ for (let i = 0; i < order.length; i++) {
310
+ const m = order[i];
311
+ const step = steps[i];
312
+ const result = await runMember({ name: m.member, dir: dirOf(m.member) }, promoteArgv(query.env, m, ["--plan-only"]), { [WORKSPACE_RUN_ENV]: id });
313
+ query.onOutput?.(`${step.target} --plan-only`, result);
314
+ const plan = parseJson(result.stdout);
315
+ if (result.exitCode !== 0 || !isMemberReleasePlan(plan) || plan.releaseDigest !== m.releaseDigest) {
316
+ step.status = "fail";
317
+ step.exitCode = result.exitCode;
318
+ return finish("fail", null, null);
319
+ }
320
+ covers.push(...releaseCovers(m.member, query.env, plan));
321
+ }
322
+ if (covers.length > 0) {
323
+ const digest = workspaceGateDigest(covers);
324
+ const { pending, approvals } = await readWorkspaceGate(query.cwd, query.gate);
325
+ if (approvals.some((a) => a.digest === digest && workspaceGateDigest(a.covers) === digest)) {
326
+ approved = digest;
327
+ }
328
+ else {
329
+ // Nothing deployed; each member with a cover waits on the workspace gate.
330
+ for (const step of steps) {
331
+ const c = covers.find((x) => x.member === step.member);
332
+ if (c)
333
+ step.gate = { op: c.op, name: c.gate, planDigest: c.planDigest, environment: c.environment ?? null };
334
+ step.status = c ? "gated" : "not-run";
335
+ }
336
+ const standing = pending.filter((p) => p.digest === digest).at(-1) ?? null;
337
+ return finish("gated", standing, null, covers);
338
+ }
339
+ }
340
+ }
341
+ const env = { [WORKSPACE_RUN_ENV]: id, ...(query.gate ? { [WORKSPACE_GATE_ENV]: query.gate } : {}) };
342
+ let status = "ok";
343
+ for (let i = 0; i < order.length; i++) {
344
+ const m = order[i];
345
+ const step = steps[i];
346
+ const result = await runMember({ name: m.member, dir: dirOf(m.member) }, promoteArgv(query.env, m), env);
347
+ query.onOutput?.(step.target, result);
348
+ step.exitCode = result.exitCode;
349
+ step.status = result.exitCode === 0 ? "ok" : result.exitCode === CHANT_EXIT.waiting ? "gated" : "fail";
350
+ const found = promoteOutcome(result.stdout);
351
+ step.memberRun = found.run;
352
+ if (found.gate)
353
+ step.gate = found.gate;
354
+ if (step.status !== "ok") {
355
+ status = step.status;
356
+ break;
357
+ }
358
+ }
359
+ return finish(status, null, approved);
360
+ }
361
+ // ── Across repositories (#5119) ──────────────────────────────────────────────
362
+ /** What a step of a train's promote across repositories runs in the member repository: its train job's `chant run --release`. */
363
+ export const TRAIN_REPO_STEP_OP = "run --release";
364
+ /** The answers after which the next member is dispatched. */
365
+ const TRAIN_PASSES = ["applied", "unchanged"];
366
+ /** The member links in the declaration: producer to consumer, which a promote across repositories orders by. */
367
+ async function declarationLinks(cwd) {
368
+ const declaration = readDeclaration(locateWorkspace(cwd).tree, "", { rootChant: true });
369
+ return declaration.members.flatMap((m) => m.links.map((l) => ({ consumer: m.name, producer: l.member, status: "declared" })));
370
+ }
371
+ /** Dispatches with the forge's API and the member's token from the environment ({@link trainTokenEnv}). */
372
+ export const defaultTrainDispatcher = async (member, d) => {
373
+ const { dispatchTrainMember, trainMemberTarget, trainProductOf } = await import("../control/train.js");
374
+ await dispatchTrainMember(trainMemberTarget(member.repo), d, { words: trainProductOf() });
375
+ };
376
+ async function defaultReadAnswers(cwd) {
377
+ const { gitControlAppliedLedger, parseControlApplied } = await import("../control/applied.js");
378
+ return parseControlApplied(await gitControlAppliedLedger({ cwd }).read()).records;
379
+ }
380
+ /** Each run's newest line: a promote across repositories appends its run again as each member answers. */
381
+ export function latestRuns(runs) {
382
+ const at = new Map();
383
+ runs.forEach((r, i) => at.set(r.id, i));
384
+ return runs.filter((r, i) => at.get(r.id) === i);
385
+ }
386
+ /**
387
+ * Promote a train of `repo` members (#5119) from the control repo, one
388
+ * member repository at a time, producers first. Each call does one step and
389
+ * returns:
390
+ *
391
+ * - With no promote of the train in flight, it starts one: a workspace run
392
+ * record citing the train, and a dispatch into the first member
393
+ * repository, whose step is `dispatched`. `--continue` starts nothing.
394
+ * - With one in flight, `--continue` reads the control repo's apply records
395
+ * for the member it waits on. `applied` or `unchanged` passes the step
396
+ * and dispatches the next member, or ends the run `ok`. `waiting` ends it
397
+ * `gated` at the member's own gate, and `failed` or `partial` ends it
398
+ * `fail`, the step saying why. An answer for another release fails the
399
+ * step. With no answer yet nothing is written. Without `--continue` it
400
+ * refuses, naming the member it waits on.
401
+ *
402
+ * Each member keeps its own gate: no workspace gate covers members in other
403
+ * repositories, so `--gate` is refused.
404
+ */
405
+ async function promoteAcrossRepos(query, train, now) {
406
+ if (query.gate)
407
+ return { kind: "refused", message: `release train ${train.id} pins repo members, and each keeps its own gate: a workspace gate covers members of this repository only, so drop --gate` };
408
+ const { orderTargets } = await import("./workspace-run.js");
409
+ const links = await (query.readLinks ?? declarationLinks)(query.cwd);
410
+ const order = orderTargets(train.members.map((m) => ({ member: m.member, op: TRAIN_REPO_STEP_OP })), links).map((t) => train.members.find((m) => m.member === t.member));
411
+ if (query.dryRun)
412
+ return { kind: "planned", train, order: order.map((m) => m.member) };
413
+ const runs = latestRuns((await readWorkspaceRuns(query.cwd, query.env)).records).filter((r) => r.train?.id === train.id);
414
+ const inFlight = runs.filter((r) => r.status === "dispatched").at(-1) ?? null;
415
+ if (!inFlight && query.continue)
416
+ return { kind: "idle", train, message: `no promote of release train ${train.id} to ${query.env} is in flight, so there is nothing to continue` };
417
+ if (inFlight && !query.continue) {
418
+ const waiting = inFlight.steps.find((s) => s.status === "dispatched")?.member ?? "a member";
419
+ return { kind: "refused", message: `promote ${inFlight.id} of release train ${train.id} is in flight and waits on ${waiting}; it continues when that member answers (chant workspace train promote ${query.env} ${train.id} --continue)` };
420
+ }
421
+ const dispatch = query.dispatch ?? defaultTrainDispatcher;
422
+ const record = inFlight
423
+ ? { ...inFlight, steps: inFlight.steps.map((s) => ({ ...s })) }
424
+ : {
425
+ version: 1,
426
+ id: `ws-${randomUUID()}`,
427
+ started: now(),
428
+ ended: now(),
429
+ status: "dispatched",
430
+ env: query.env,
431
+ gate: null,
432
+ dependentsOf: null,
433
+ steps: order.map((m) => ({ target: `${m.member}/${TRAIN_REPO_STEP_OP}`, member: m.member, op: TRAIN_REPO_STEP_OP, status: "not-run", exitCode: null, memberRun: null, repo: m.repo.url })),
434
+ train: { id: train.id, digest: train.trainDigest },
435
+ };
436
+ const memberOf = (name) => train.members.find((m) => m.member === name);
437
+ /** Dispatch the first step not run yet, or end the run ok when none is left. */
438
+ const next = async () => {
439
+ const step = record.steps.find((s) => s.status === "not-run");
440
+ if (!step) {
441
+ record.status = "ok";
442
+ return;
443
+ }
444
+ const m = memberOf(step.member);
445
+ try {
446
+ await dispatch({ name: m.member, repo: m.repo.url }, { member: m.member, env: query.env, train: train.id, run: record.id, releaseDigest: m.releaseDigest, commit: m.commit });
447
+ step.status = "dispatched";
448
+ record.status = "dispatched";
449
+ }
450
+ catch (err) {
451
+ step.status = "fail";
452
+ step.reason = `the dispatch into ${m.repo.url} was not taken: ${err instanceof Error ? err.message : String(err)}`;
453
+ record.status = "fail";
454
+ }
455
+ };
456
+ if (!inFlight)
457
+ await next();
458
+ else {
459
+ const step = record.steps.find((s) => s.status === "dispatched");
460
+ if (!step)
461
+ return { kind: "idle", train, message: `promote ${record.id} of release train ${train.id} waits on no member` };
462
+ const answers = (await (query.readAnswers ?? defaultReadAnswers)(query.cwd)).filter((a) => a.member === step.member && a.train?.train === train.id && a.train.run === record.id);
463
+ const answer = answers.sort((a, b) => Date.parse(a.at) - Date.parse(b.at)).at(-1);
464
+ if (!answer)
465
+ return { kind: "waiting", train, record: inFlight, member: step.member };
466
+ const m = memberOf(step.member);
467
+ step.outcome = answer.outcome;
468
+ if (answer.train.releaseDigest !== m.releaseDigest || answer.train.env !== query.env) {
469
+ step.status = "fail";
470
+ step.reason = `${step.member} answered for release ${answer.train.releaseDigest} in ${answer.train.env}, and the train pins ${m.releaseDigest} in ${query.env}`;
471
+ record.status = "fail";
472
+ }
473
+ else if (TRAIN_PASSES.includes(answer.outcome)) {
474
+ step.status = "ok";
475
+ await next();
476
+ }
477
+ else {
478
+ step.status = answer.outcome === "waiting" ? "gated" : "fail";
479
+ step.reason = answer.outcome === "waiting" ? `${step.member}'s run waits at its own gate; approve it there, then promote the train again` : `${step.member}'s run ended ${answer.outcome} at ${answer.sha.slice(0, 12)}`;
480
+ record.status = answer.outcome === "waiting" ? "gated" : "fail";
481
+ }
482
+ }
483
+ record.ended = now();
484
+ let ledgerError = null;
485
+ try {
486
+ await appendWorkspaceRun(query.cwd, record);
487
+ }
488
+ catch (err) {
489
+ ledgerError = err instanceof Error ? err.message : String(err);
490
+ }
491
+ return { kind: "ran", train, record, pending: null, approved: null, ledgerError };
492
+ }
493
+ const USAGE = "chant workspace train <env> [--pin <member>=<label|digest>]... [--dry-run] [--json] | chant workspace train list <env> [--json] | chant workspace train promote <env> [<train id|digest>] [--gate <name>] [--continue] [--dry-run] [--json]";
494
+ /** Each train with the runs that promoted it, oldest first. */
495
+ export function trainsWithPromotions(trains, runs) {
496
+ const latest = latestRuns(runs);
497
+ return trains.map((t) => ({
498
+ ...t,
499
+ promotions: latest
500
+ .filter((r) => r.train?.id === t.id)
501
+ .map((r) => ({
502
+ run: r.id,
503
+ started: r.started,
504
+ ended: r.ended,
505
+ status: r.status,
506
+ gate: r.gate,
507
+ members: r.steps.map((s) => ({ member: s.member, status: s.status, memberRun: s.memberRun, ...(s.repo !== undefined ? { repo: s.repo } : {}), ...(s.outcome !== undefined ? { outcome: s.outcome } : {}), ...(s.reason !== undefined ? { reason: s.reason } : {}) })),
508
+ })),
509
+ }));
510
+ }
76
511
  export async function runWorkspaceTrain(ctx) {
77
512
  const words = ctx.args.positionals ?? [];
78
513
  const rest = words[0] === "train" ? words.slice(1) : words;
514
+ if (rest[0] === "promote")
515
+ return runTrainPromote(ctx, rest.slice(1));
79
516
  const listing = rest[0] === "list";
80
517
  const env = listing ? rest[1] : rest[0];
81
518
  if (!env) {
@@ -87,13 +524,17 @@ export async function runWorkspaceTrain(ctx) {
87
524
  if (listing) {
88
525
  const root = locateWorkspace(cwd).rootOnDisk;
89
526
  const { records } = await readReleaseTrains(root, env);
527
+ const listed = trainsWithPromotions(records, (await readWorkspaceRuns(root, env)).records);
90
528
  if (ctx.args.json)
91
- console.log(JSON.stringify({ env, trains: records }, null, 2));
92
- else if (records.length === 0)
529
+ console.log(JSON.stringify({ env, trains: listed }, null, 2));
530
+ else if (listed.length === 0)
93
531
  console.log(`No release train recorded for ${env}.`);
94
- else
95
- for (const t of records)
96
- console.log(`${t.timestamp} ${t.id} ${t.members.map((m) => `${m.member}@${m.label ?? m.releaseDigest.slice(0, 19)}`).join(" ")}`);
532
+ else {
533
+ for (const t of listed) {
534
+ const last = t.promotions.at(-1);
535
+ console.log(`${t.timestamp} ${t.id} ${t.trainDigest} ${t.members.map((m) => `${m.member}@${m.label ?? m.releaseDigest.slice(0, 19)}`).join(" ")}${last ? ` promoted: ${last.status}` : ""}`);
536
+ }
537
+ }
97
538
  return 0;
98
539
  }
99
540
  const pins = new Map();
@@ -108,21 +549,21 @@ export async function runWorkspaceTrain(ctx) {
108
549
  const root = locateWorkspace(cwd).rootOnDisk;
109
550
  const picked = pickTrain(await readMemberReleases(root), pins);
110
551
  if ("problems" in picked) {
111
- console.error(formatError({ message: `no release train for ${env}: every chant member needs a release`, hint: USAGE }));
552
+ console.error(formatError({ message: `no release train for ${env}: every chant and repo member needs a release`, hint: USAGE }));
112
553
  for (const p of picked.problems)
113
554
  console.error(` ${p}`);
114
555
  return 1;
115
556
  }
116
557
  const actor = ctx.args.actor ?? actorFromEnv();
117
- const record = { version: 1, id: `train-${randomUUID()}`, env, timestamp: new Date().toISOString(), actor, members: picked.members };
558
+ const record = { version: 1, id: `train-${randomUUID()}`, env, timestamp: new Date().toISOString(), actor, members: picked.members, trainDigest: trainDigest(picked.members) };
118
559
  if (!ctx.args.dryRun)
119
560
  await appendReleaseTrain(root, record);
120
561
  if (ctx.args.json)
121
562
  console.log(JSON.stringify({ ...record, written: !ctx.args.dryRun }, null, 2));
122
563
  else {
123
- console.log(`${ctx.args.dryRun ? "Would record" : "Recorded"} release train ${record.id} for ${env}:`);
564
+ console.log(`${ctx.args.dryRun ? "Would record" : "Recorded"} release train ${record.id} for ${env}, digest ${record.trainDigest}:`);
124
565
  for (const m of record.members)
125
- console.log(` ${m.member.padEnd(24)} ${m.label ?? "(no label)"} ${m.releaseDigest} ${m.commit.slice(0, 12)}`);
566
+ console.log(` ${m.member.padEnd(24)} ${m.label ?? "(no label)"} ${m.releaseDigest} ${m.commit.slice(0, 12)}${m.repo ? ` ${m.repo.url}` : ""}`);
126
567
  }
127
568
  return 0;
128
569
  }
@@ -133,3 +574,98 @@ export async function runWorkspaceTrain(ctx) {
133
574
  return 1;
134
575
  }
135
576
  }
577
+ async function runTrainPromote(ctx, words) {
578
+ const [env, ref] = words;
579
+ if (!env) {
580
+ console.error(formatError({ message: "chant workspace train promote needs an environment", hint: USAGE }));
581
+ return 1;
582
+ }
583
+ const cwd = resolve(".");
584
+ // The root's chant promotes the train (ws-021), as it runs a workspace run.
585
+ const { handToRootChant } = await import("./which-chant.js");
586
+ const handed = await handToRootChant(cwd, undefined);
587
+ if (handed !== undefined)
588
+ return handed;
589
+ const { args } = ctx;
590
+ let outcome;
591
+ try {
592
+ outcome = await promoteTrain({
593
+ cwd: locateWorkspace(cwd).rootOnDisk,
594
+ env,
595
+ ...(ref !== undefined ? { train: ref } : {}),
596
+ ...(args.gate !== undefined ? { gate: args.gate } : {}),
597
+ ...(args.dryRun ? { dryRun: true } : {}),
598
+ ...(args.continueTrain ? { continue: true } : {}),
599
+ onOutput: args.json
600
+ ? undefined
601
+ : (target, r) => {
602
+ process.stderr.write(`── ${target} (exit ${r.exitCode})\n`);
603
+ if (r.stderr)
604
+ process.stderr.write(r.stderr.endsWith("\n") ? r.stderr : `${r.stderr}\n`);
605
+ },
606
+ });
607
+ }
608
+ catch (err) {
609
+ if (!(err instanceof WorkspaceReadError))
610
+ throw err;
611
+ console.error(formatError({ message: `${err.code}: ${err.describe()}`, hint: USAGE }));
612
+ return 1;
613
+ }
614
+ if (outcome.kind === "refused") {
615
+ if (args.json)
616
+ console.log(JSON.stringify({ status: "refused", message: outcome.message }, null, 2));
617
+ console.error(formatError({ message: outcome.message, hint: USAGE }));
618
+ return 1;
619
+ }
620
+ if (outcome.kind === "idle") {
621
+ if (args.json)
622
+ console.log(JSON.stringify({ status: "idle", train: outcome.train.id, message: outcome.message }, null, 2));
623
+ else
624
+ console.log(outcome.message);
625
+ return 0;
626
+ }
627
+ if (outcome.kind === "waiting") {
628
+ if (args.json)
629
+ console.log(JSON.stringify({ ...outcome.record, waitingOn: outcome.member }, null, 2));
630
+ else
631
+ console.log(`release train ${outcome.train.id} to ${env}: promote ${outcome.record.id} waits on ${outcome.member}, which has not answered yet`);
632
+ return 0;
633
+ }
634
+ if (outcome.kind === "planned") {
635
+ if (args.json)
636
+ console.log(JSON.stringify({ status: "planned", train: outcome.train, order: outcome.order }, null, 2));
637
+ else {
638
+ console.log(`chant workspace train promote would promote ${outcome.train.id} (${outcome.train.trainDigest}) to ${env}, in order:`);
639
+ for (const member of outcome.order) {
640
+ const m = outcome.train.members.find((x) => x.member === member);
641
+ console.log(` ${member.padEnd(24)} ${m.label ?? "(no label)"} ${m.releaseDigest}`);
642
+ }
643
+ }
644
+ return 0;
645
+ }
646
+ const { record, pending, approved, ledgerError } = outcome;
647
+ if (args.json)
648
+ console.log(JSON.stringify({ ...record, pending, approved, ledgerError }, null, 2));
649
+ else {
650
+ console.log(`release train ${outcome.train.id} to ${env}: ${record.status}${approved ? ` (workspace gate "${record.gate}" approved ${approved})` : ""}`);
651
+ for (const s of record.steps)
652
+ console.log(` ${s.member.padEnd(24)} ${s.status}${s.memberRun ? ` (run ${s.memberRun})` : ""}${s.gate ? ` gate ${s.gate.name}` : ""}${s.repo ? ` ${s.repo}` : ""}${s.reason ? ` ${s.reason}` : ""}`);
653
+ if (record.status === "dispatched") {
654
+ const at = record.steps.find((s) => s.status === "dispatched");
655
+ if (at)
656
+ console.log(`Dispatched ${at.member}. The control repo continues the train when it answers: chant workspace train promote ${env} ${outcome.train.id} --continue`);
657
+ }
658
+ if (record.status === "gated" && pending) {
659
+ console.log(`Workspace gate "${pending.gate}" is pending over ${pending.covers.length} release gate(s) of ${new Set(pending.covers.map((c) => c.member)).size} member(s), digest ${pending.digest}. Nothing was deployed.`);
660
+ console.log(` Approve: chant workspace run approve ${pending.gate} --plan ${pending.digest}`);
661
+ console.log(` Then run the same chant workspace train promote again. The approval stands in only for members that set acceptWorkspaceGates: true at base.`);
662
+ }
663
+ if (ledgerError)
664
+ console.error(formatError({ message: `the workspace run record was not written: ${ledgerError}` }));
665
+ }
666
+ if (record.status === "fail")
667
+ return 1;
668
+ if (record.status === "gated")
669
+ return CHANT_EXIT.waiting;
670
+ return 0;
671
+ }