@jr2/cli 0.3.0 → 0.4.1

package/src/commands/status.ts

@@ -1,8 +1,9 @@
 // `jr2 status [runId|abbrev]` (ADR-0009): print a run's status as JSON on stdout, reading through to the
 // store so a completed run still reports its terminal status + final context. A genuinely unknown run → 1.
 //
-// With NO run named, the verb answers about the INSTANCE instead (ADR-0048/0051): whether it has a
-// data plane at all, and every Repo resource's per-node state, so a Repo that will not clone — an
+// With NO run named, the verb answers about the INSTANCE instead (ADR-0048/0051/0069): every
+// Assembly a live run holds, the current one first, whether it has a data plane at all, and every Repo
+// resource's per-node state, so a Repo that will not clone — an
 // unregistered deploy key (ADR-0047), a wrong url, a git host outage — is discoverable by asking
 // the thing that knows, rather than by tailing pod logs. The Orchestrator serves either way; only
 // the Repo is degraded, and the cache agent retries it on its own.
@@ -10,10 +11,13 @@
 // Two output classes (ADR-0009 as amended): `status <runId>` is a RESULT verb — the RunStatus as one
 // JSON line on stdout, for the pipe. Bare `status` is a REPORT verb — a human table on stdout, or the
 // one object with `--json`.
+//
+// A run that binds a Chart (ADR-0070) carries `bound: true`; the verb says so beside the result as
+// `chart: bound`, with the route that draws the Machine the run binds, its Charts compiled in.
 
 import { parseArgs } from "node:util";
-import type { RepoStatus } from "@jr2/orchestrator";
-import { JR2Client } from "../client.ts";
+import type { AssemblyView, RepoStatus } from "@jr2/orchestrator";
+import { JR2Client, type FetchLike, type RunStatus, workflowPath } from "../client.ts";
 import { resolveTarget, TARGET_ARGS, targetOptions } from "../instance.ts";
 import { activity, result, type Io } from "../output.ts";
 import { resolveRunId } from "../run-id.ts";
@@ -32,7 +36,7 @@ export async function status(args: string[], io: Io): Promise<number> {
   const target = await resolveTarget(io, targetOptions(values));
   try {
     const client = new JR2Client(target.url, io.fetch, target.token);
-    if (given === undefined) return await instanceStatus(client, io, values.json === true);
+    if (given === undefined) return await instanceStatus(client, io, target.url, values.json === true);
     const ref = await resolveRunId(client, given);
     if (!ref.ok) {
       activity(io, ref.message);
@@ -44,18 +48,32 @@ export async function status(args: string[], io: Io): Promise<number> {
       return 1;
     }
     result(io, s);
+    const note = boundActivity(s);
+    if (note) activity(io, note);
     return 0;
   } finally {
     target.close?.();
   }
 }
 
+/** The `chart: bound` line for a run that binds a Chart (ADR-0070), or undefined for one that binds
+ * none. The Workflow name rides the route as one encoded segment. */
+export function boundActivity(s: RunStatus): string | undefined {
+  if (s.bound !== true) return undefined;
+  const route = `GET ${workflowPath(s.workflow)}/runs/${encodeURIComponent(s.runId)}/machine`;
+  // A drifted run's Chart may no longer admit (D-B): the route then draws the slot's own subgraph
+  // and names why in `chartsNotDrawn`, so the line does not claim more than the route draws.
+  if (s.status === "drifted") return `chart: bound, drifted — ${route} names each Chart it cannot draw`;
+  return `chart: bound — ${route} draws the Machine this run binds`;
+}
+
 /**
- * The instance's own status: the data-plane switch and every Repo resource. As a table on stdout —
+ * The instance's own status: the held Assemblies, the data-plane switch and every Repo resource. As a table on stdout —
  * every node's state per Repo, and every node whose last attempt FAILED spelled out with git's own
  * error, since that is the line a human acts on — or, with `--json`, as the one object (extensible:
- * the instance has more to report eventually). An instance with no data plane says so — "no
- * registered Machine composes a Sandbox" is the answer, not an empty list.
+ * the instance has more to report eventually). An instance with no data plane says so — "it runs
+ * outside a cluster" is the answer, not an empty list. A deployed Orchestrator always has one: it
+ * wires its kube client whatever the current Assembly composes (ADR-0069).
  *
  * Two failures, two consequences (ADR-0004/0051): a cache that is ABSENT on the node (a cold clone
  * failed) parks every Workspace that needs it there; a cache that is PRESENT but whose last fetch
@@ -65,18 +83,76 @@ export async function status(args: string[], io: Io): Promise<number> {
  * Exit 0 even with Repos failing: this is a report, and a degraded Repo is a state the instance
  * is serving in, not a failure of the asking.
  */
-async function instanceStatus(client: JR2Client, io: Io, json: boolean): Promise<number> {
-  const report = await client.repos();
+async function instanceStatus(client: JR2Client, io: Io, url: string, json: boolean): Promise<number> {
+  const report = { assembly: await readAssembly(io.fetch ?? globalThis.fetch, url), ...(await client.repos()) };
   if (json) result(io, report);
   else io.stdout(renderInstanceStatus(report));
   return 0;
 }
 
-/** The human table — one line per Repo, one per node under it, then the hints for what was seen. */
-export function renderInstanceStatus({ dataPlane, repos }: { dataPlane: boolean; repos: RepoStatus[] }): string {
-  let out = dataPlane
+/** `GET /assembly` (ADR-0069): open, like `GET /workflows`, so it needs no token. An answer that
+ * cannot be read is reported as the reason, never as a failure of the verb. */
+async function readAssembly(fetchImpl: FetchLike, url: string): Promise<AssemblyView | { error: string }> {
+  try {
+    const res = await fetchImpl(`${url.replace(/\/+$/, "")}/assembly`);
+    if (!res.ok) return { error: `GET /assembly answered HTTP ${res.status}` };
+    // Read loosely: a `held` that is absent or not a list reads as none held, so a report never
+    // fails on the shape of one field (ADR-0048: a report is not a failure of the asking).
+    const view = (await res.json()) as Partial<AssemblyView>;
+    return {
+      kitVersion: view.kitVersion ?? "",
+      current: view.current ?? null,
+      held: Array.isArray(view.held) ? view.held : [],
+    };
+  } catch (e) {
+    return { error: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+/**
+ * The Assembly lines (ADR-0069): one per Assembly a live run holds, the current one first and so
+ * marked, each with how many live runs hold it — or why there is none. A run holds the Assembly it
+ * started under, so after a publish the previous one stays on the volume while a run still holds it.
+ * The current Assembly prints first, whatever order `held` uses; the other held Assemblies follow
+ * in the server's order.
+ */
+function assemblyLines(view: AssemblyView | { error: string } | undefined): string {
+  if (view === undefined) return "";
+  if ("error" in view) return `assembly: unknown — ${view.error}\n`;
+  const current = view.current;
+  const heldList = view.held;
+  const line = (hash: string, kitVersion: string, runs: number, isCurrent: boolean): string =>
+    `assembly: ${hash} (kit v${kitVersion}${isCurrent ? ", current" : ""}), ` +
+    `${runs} live run${runs === 1 ? "" : "s"} hold${runs === 1 ? "s" : ""} it\n`;
+  let out = "";
+  if (current) {
+    const runs = heldList.find((h) => h.hash === current.hash)?.runs.length ?? 0;
+    out += line(current.hash, current.kitVersion, runs, true);
+  } else {
+    out += "assembly: none — `jr2 up` publishes\n";
+  }
+  for (const held of heldList) {
+    if (held.hash === current?.hash) continue;
+    out += line(held.hash, held.kitVersion, held.runs.length, false);
+  }
+  return out;
+}
+
+/** The human table — the held Assemblies, current first, one line per Repo, one per node under it, then the
+ * hints for what was seen. */
+export function renderInstanceStatus({
+  assembly,
+  dataPlane,
+  repos,
+}: {
+  assembly?: AssemblyView | { error: string };
+  dataPlane: boolean;
+  repos: RepoStatus[];
+}): string {
+  let out = assemblyLines(assembly);
+  out += dataPlane
     ? "data plane: yes\n"
-    : "data plane: none — this instance has no data plane (no registered Machine composes a Sandbox)\n";
+    : "data plane: none — this Orchestrator runs outside a cluster, so it provisions no Sandbox (ADR-0069)\n";
   let absent = 0;
   let stale = 0;
   for (const repo of repos) {