@jr2/cli 0.5.1 → 0.7.0

package/src/instance-check.ts

@@ -18,9 +18,15 @@ import {
   CUSTOM_PROVIDER_APIS,
   dispatchRefusals,
   doorRefusals,
+  gateLookWarnings,
+  gateScopeChecks,
+  standingPoolLines,
+  standingPoolRefusals,
   loadCharts,
   loadWorkflows,
   machineBodies,
+  mcpRefusals,
+  mcpUrlRefusals,
   openPartRefusals,
   partsOf,
   placementWalkOf,
@@ -106,7 +112,17 @@ export async function checkInstance(io: Io, root: string, config: JR2Config): Pr
   // and the door's walk cannot drift.
   // A zod `input` that no door reads (ADR-0033) is in the same listing, first: the door refuses it
   // with the same line.
-  const open = [...doorRefusals(workflows), ...openPartRefusals(workflows)];
+  // A standing Pool that is not the top Machine of its Workflow (ADR-0017) is in the listing too.
+  // An Agent's `mcp` list against the config's `mcp` block (ADR-0079) is in the same listing: a
+  // server name the block does not declare is refused as an Open part is, with its customize() line,
+  // and the door refuses the same lines. The urls are the host's alone (`.env`).
+  const open = [
+    ...doorRefusals(workflows),
+    ...standingPoolRefusals(workflows),
+    ...openPartRefusals(workflows),
+    ...mcpRefusals(workflows, config),
+    ...mcpUrlRefusals(config),
+  ];
   if (open.length) {
     for (const line of open) activity(io, `refusing: ${line}`);
     return undefined;
@@ -120,6 +136,15 @@ export async function checkInstance(io: Io, root: string, config: JR2Config): Pr
     for (const line of chartRefusals) activity(io, `refusing: ${line}`);
     return undefined;
   }
+  // Each `answer` item that names single Gates (ADR-0078) names Gates that the Workflow's Machines or
+  // its Chart files have: the door's own check, so a typo fails here and not at the first answer. A
+  // name that only a runtime Chart can have is a warning, because the host cannot see those Charts.
+  const gateScopes = gateScopeChecks(workflows, config, charts);
+  for (const line of gateScopes.warnings) activity(io, `warning: ${line}`);
+  if (gateScopes.errors.length) {
+    for (const line of gateScopes.errors) activity(io, `refusing: ${line}`);
+    return undefined;
+  }
   // What each same-Instance dispatch names resolves in this Assembly, and its slot schema matches
   // the callee's door (ADR-0071): the door's own check, so the publish would refuse the same lines.
   // The host cannot see the Orchestrator's volume, so a named Chart that is no Chart file here is a
@@ -130,8 +155,17 @@ export async function checkInstance(io: Io, root: string, config: JR2Config): Pr
     for (const line of dispatched.errors) activity(io, `refusing: ${line}`);
     return undefined;
   }
+  // A hooked Gate that a lost delivery can stop (ADR-0011, ADR-0054): no look and no `after` on its
+  // state, or a look that a package left Open and nobody bound. A warning, never a refusal: a person
+  // can still answer the Gate with `jr2 send`.
+  for (const line of gateLookWarnings(workflows)) activity(io, `warning: ${line}`);
+  // Each standing Pool (ADR-0017): the chain from each Hook that reaches it to its callee, and a
+  // warning when two of them dispatch to one Workflow, whose caps then add.
+  const standing = standingPoolLines(workflows, config.hooks);
+  for (const chain of standing.chains) activity(io, `standing: ${chain}`);
+  for (const line of standing.warnings) activity(io, `warning: ${line}`);
   // What each registered Machine runs outside itself (ADR-0067, ADR-0068): every Effect slot, with
-  // the plain data it carries — a command's argv, its timeout, the Repo Slot it runs in; an http
+  // the plain data it carries — a command's argv and its timeout; an http
   // Effect's method, its fixed target and the secrets it names — read, never run.
   for (const w of workflows) {
     const effects = partsOf([w.machine]).effects;
@@ -139,13 +173,10 @@ export async function checkInstance(io: Io, root: string, config: JR2Config): Pr
     activity(io, `effects: workflow "${w.name}" — what it runs outside itself (ADR-0067)`);
     for (const e of effects) {
       const where = e.path?.length ? ` (on ${e.path.map((k) => `"${k}"`).join(" → ")})` : "";
-      const slot = "slot" in e && e.slot !== undefined ? `, in Repo Slot "${e.slot}"` : "";
       if (e.kind === "http") {
         const names = e.secrets.length ? `, secrets ${e.secrets.map((n) => `"${n}"`).join(", ")}` : "";
         // Its body decides where it runs (ADR-0067): a Worktree file needs its Workspace's Sandbox Effector.
-        const where2 = e.file
-          ? `in the Sandbox Effector, a Worktree file as its body${slot}`
-          : "in the Instance Effector";
+        const where2 = e.file ? "in the Sandbox Effector, a Worktree file as its body" : "in the Instance Effector";
         activity(
           io,
           `  ${e.name}${where}: http ${e.method} ${e.target ? targetText({ target: e.target }) : "<open>"} — ${e.timeoutMs / 1000}s, ` +
@@ -165,8 +196,21 @@ export async function checkInstance(io: Io, root: string, config: JR2Config): Pr
         );
         continue;
       }
+      if (e.kind === "mcp") {
+        // The server's url and secret are the config's (ADR-0079): the line names the server, and
+        // its timeout is the server's unless the Effect sets one.
+        const asks =
+          e.op === "call" ? `call ${e.server ?? "<open>"}/${e.tool ?? "<open>"}` : `${e.op} ${e.server ?? "<open>"}`;
+        const timeout = e.timeoutMs > 0 ? `${e.timeoutMs / 1000}s` : "the server's timeout";
+        activity(
+          io,
+          `  ${e.name}${where}: mcp ${asks} — ${timeout}, in the Instance Effector${e.idempotent ? ", idempotent" : ""}`,
+        );
+        continue;
+      }
       if (e.kind === "push") {
         const opts = (["pin", "sign", "squash", "force"] as const).filter((k) => e[k]);
+        const slot = e.slot !== undefined ? `, in Repo Slot "${e.slot}"` : "";
         activity(
           io,
           `  ${e.name}${where}: push${opts.length ? ` (${opts.join(", ")})` : ""} — ${e.timeoutMs / 1000}s, ` +
@@ -175,11 +219,17 @@ export async function checkInstance(io: Io, root: string, config: JR2Config): Pr
         continue;
       }
       if (!("argv" in e)) continue;
+      if (e.cut) {
+        // A cut is a kit program: its argv is the kit's business, and its one choice is `expect`.
+        const expect = e.cut.expect ? ` (expect ${e.cut.expect})` : "";
+        activity(io, `  ${e.name}${where}: worktree${expect} — ${e.timeoutMs / 1000}s, in the Harness`);
+        continue;
+      }
       const names = e.secrets?.length ? `, secrets ${e.secrets.map((n) => `"${n}"`).join(", ")}` : "";
       const seat = e.secrets?.length ? `the Sandbox Effector${e.pin ? ", pinned" : ""}` : "the Harness";
       activity(
         io,
-        `  ${e.name}${where}: ${e.kind} ${JSON.stringify(e.argv)} — ${e.timeoutMs / 1000}s, in ${seat}${slot}${names}`,
+        `  ${e.name}${where}: ${e.kind} ${JSON.stringify(e.argv)} — ${e.timeoutMs / 1000}s, in ${seat}${names}`,
       );
     }
   }

package/src/instance.ts

@@ -11,10 +11,13 @@
 //     `config.name` > folder name): the Instance token is read from the in-cluster `jr2-instance`
 //     Secret and the `jr2-orchestrator` Service is port-forwarded for the life of the command —
 //     kube RBAC is the real gate, and no local state file can go stale (ADR-0019).
+//   - On the kube path the CLI says whom it acts for (ADR-0078): the user name a kube
+//     `SelfSubjectReview` gives for the context, sent as `jr2-on-behalf-of`. The Instance token is
+//     the Caller `token/instance`; the name says which person held it. With `--url` it says none.
 //   - Every resolution prints its target on stderr, so ambient-context drift stays visible.
 
 import { basename } from "node:path";
-import { loadConfig } from "@jr2/orchestrator/internal";
+import { loadConfig, ON_BEHALF_OF_MAX } from "@jr2/orchestrator/internal";
 import { INSTANCE_SECRET, kubectlKube, ORCHESTRATOR_PORT, ORCHESTRATOR_SERVICE } from "./kube.ts";
 import { assertKitVersion } from "./kit-version.ts";
 import { activity, type Io } from "./output.ts";
@@ -31,8 +34,9 @@ export function resolveRoot(cwd: string): string {
   return root;
 }
 
-/** Where to talk, as whom, and how to hang up (the port-forward lives only as long as the verb). */
-export type Target = { url: string; token?: string; close?: () => void };
+/** Where to talk, as whom, and how to hang up (the port-forward lives only as long as the verb).
+ * `onBehalfOf` is the party the CLI says it acts for (ADR-0078): on the kube path, the kube user. */
+export type Target = { url: string; token?: string; onBehalfOf?: string; close?: () => void };
 
 export type TargetOptions = {
   /** Explicit orchestrator address (`--url`); with `JR2_URL` the escape hatch past the kube path. */
@@ -90,6 +94,13 @@ export async function resolveTarget(io: Io, opts: TargetOptions): Promise<Target
       `not deployed here — right context? (context ${context}, namespace ${namespace}; \`jr2 up\` deploys)`,
     );
   }
-  const fwd = await kube.portForward({ namespace, service: ORCHESTRATOR_SERVICE, port: ORCHESTRATOR_PORT, ...ctx });
-  return { url: fwd.url, token, close: fwd.close };
+  // The kube user, read beside the forward so it costs no time of its own. A name past the
+  // header's bound is cut, never sent whole to a refusal. A name that is not printable ASCII is not
+  // sent: a header value cannot carry it, and the claim is not worth a failed verb.
+  const [fwd, user] = await Promise.all([
+    kube.portForward({ namespace, service: ORCHESTRATOR_SERVICE, port: ORCHESTRATOR_PORT, ...ctx }),
+    kube.selfSubject(ctx),
+  ]);
+  const onBehalfOf = user && /^[\x20-\x7e]+$/.test(user) ? user.slice(0, ON_BEHALF_OF_MAX).trim() : undefined;
+  return { url: fwd.url, token, ...(onBehalfOf ? { onBehalfOf } : {}), close: fwd.close };
 }

package/src/kube.ts

@@ -4,7 +4,7 @@
 // `KubePort` is what target resolution consumes (tests inject a fake), `kubectlKube` is the real
 // one, shelling out to the same `kubectl` a human debugging the cluster would use.
 
-import { execFile, spawn } from "node:child_process";
+import { execFile, spawn, type ChildProcess } from "node:child_process";
 import { setTimeout as sleep } from "node:timers/promises";
 import { promisify } from "node:util";
 
@@ -41,6 +41,11 @@ export type KubePort = {
    * cluster could not answer at all — the two are different faults (ADR-0019), and a caller that
    * merged them would send a user with a dead VPN off to check a context that is correct. */
   readSecret(opts: { namespace: string; name: string; key: string; context?: string }): Promise<string | undefined>;
+  /** The user name that the API server gives the current credentials, from a `SelfSubjectReview`
+   * (`kubectl auth whoami`): the party the CLI says it acts for (ADR-0078). Undefined when the
+   * server does not answer it. Never rejects: the name is a claim the CLI adds, and a verb does not
+   * fail for want of it. */
+  selfSubject(opts: { context?: string }): Promise<string | undefined>;
   /** Forward a Service port to an ephemeral local port for the life of the command. */
   portForward(opts: {
     namespace: string;
@@ -50,6 +55,21 @@ export type KubePort = {
   }): Promise<{ url: string; close: () => void }>;
 };
 
+/**
+ * A long-lived kubectl child (a port-forward) ends with this process. Node does not end a child
+ * when it exits, so a verb that `process.exit`s, or that a signal handler ends, leaves the child
+ * alive, and it holds an API-server stream. Here the child is killed on this process's `exit`.
+ * Returns the kill, which is also what `close` calls; the hook goes when the child closes.
+ */
+export function endsWithProcess(child: ChildProcess): () => void {
+  const kill = () => {
+    if (child.exitCode === null && child.signalCode === null) child.kill();
+  };
+  process.once("exit", kill);
+  child.once("close", () => process.removeListener("exit", kill));
+  return kill;
+}
+
 const ctxArgs = (context?: string): string[] => (context ? ["--context", context] : []);
 
 /** The loosely-typed kube object shape the converge logic inspects: labels carry the instance's
@@ -1139,6 +1159,19 @@ export const kubectlKube: KubePort = {
     }
   },
 
+  async selfSubject({ context }) {
+    try {
+      const { stdout } = await exec(
+        "kubectl",
+        [...ctxArgs(context), "auth", "whoami", "-o", "jsonpath={.status.userInfo.username}", ...reachArgs],
+        { timeout: REACH_BUDGET_MS },
+      );
+      return stdout.trim() || undefined;
+    } catch {
+      return undefined; // a server without the API, or RBAC that refuses it: no claim, and no failure
+    }
+  },
+
   // `:port` asks kubectl for an ephemeral local port, announced on its stdout as
   // "Forwarding from 127.0.0.1:<local> -> <remote>" — parsed rather than raced.
   portForward({ namespace, service, port, context }) {
@@ -1151,13 +1184,14 @@ export const kubectlKube: KubePort = {
         `service/${service}`,
         `:${port}`,
       ]);
+      const kill = endsWithProcess(child);
       let out = "";
       let err = "";
       // The forward is long-lived by design, so the bound is on its FIRST BYTE, not on the child:
       // silence here is the same unreachable cluster the Secret read just survived, and a verb that
       // waits forever for the announcement has only moved the hang one line down.
       const gaveUp = setTimeout(() => {
-        child.kill();
+        kill();
         reject(new Error(`kubectl port-forward: no answer after ${REACH_BUDGET_MS / 1000}s`));
       }, REACH_BUDGET_MS);
       gaveUp.unref?.();
@@ -1172,7 +1206,7 @@ export const kubectlKube: KubePort = {
       child.stdout.on("data", (d: Buffer) => {
         out += d.toString();
         const m = /Forwarding from 127\.0\.0\.1:(\d+)/.exec(out);
-        if (m) done({ url: `http://127.0.0.1:${m[1]}`, close: () => child.kill() });
+        if (m) done({ url: `http://127.0.0.1:${m[1]}`, close: kill });
       });
       child.stderr.on("data", (d: Buffer) => (err += d.toString()));
       child.on("error", (e) => failed(new Error(`kubectl port-forward failed: ${e.message}`)));

package/src/landlock.ts

@@ -0,0 +1,129 @@
+// jr2 requires Landlock on every Sandbox node (ADR-0077). The Repo cache agent is the detector: its
+// DaemonSet has one pod on each Sandbox node, by the Sandboxes' own placement (ADR-0052), and on a
+// node without Landlock, or with an ABI below 3, the agent exits at start with a termination
+// message that names Landlock, the node and the probe's reason, which states the ABI it found
+// (`operator/internal/repocache/landlock.go`). jr2's minimum is ABI 3: under ABI 1 no confined
+// process can move a file into another folder, and under ABI 2 a confined process can truncate a
+// file of jr2's that it may not write. That pod never gets Ready, so the cache agent's
+// rollout never completes.
+//
+// `jr2 up` reads the DaemonSet's pods within the rollout wait it already makes, and refuses to
+// converge while any of them reports no Landlock. It names each node, the reason, and the fix: keep
+// the node out of the Sandbox nodes with `sandbox.nodeSelector` or a taint, or enable Landlock. There
+// is no check pod, no node label and no flag to skip it. A run after the fix converges.
+
+import { setTimeout as sleep } from "node:timers/promises";
+import type { KubeAdmin, RolloutTarget } from "./kube.ts";
+
+/** The start of the cache agent's termination message on a node without Landlock — the Go side's
+ * `LandlockMessagePrefix`. The two change together. */
+export const LANDLOCK_MESSAGE_PREFIX = "no Landlock on node ";
+
+/** How often `awaitCacheAgent` reads the DaemonSet's pods while the rollout wait runs. */
+const POLL_MS = 3000;
+
+type Terminated = { message?: string };
+type ContainerStatus = {
+  state?: { terminated?: Terminated };
+  lastState?: { terminated?: Terminated };
+};
+/** A cache agent pod, read for the node it runs on and its containers' termination messages. */
+export type CacheAgentPod = {
+  metadata: { name: string; deletionTimestamp?: string };
+  spec?: { nodeName?: string };
+  status?: { containerStatuses?: ContainerStatus[] };
+};
+
+/** One Sandbox node whose cache agent reports no Landlock, and the probe's reason. */
+export type NoLandlock = { node: string; reason: string };
+
+// The node, then the reason up to the sentence the agent ends its message with. Not anchored: with
+// `FallbackToLogsOnError` the message can be the agent's log line, which quotes it.
+const MESSAGE = /no Landlock on node ([^\s:]+): (.+?) — jr2 needs Landlock/;
+
+/** The Sandbox nodes whose cache agent reports no Landlock, each once, in node order. */
+export function nodesWithoutLandlock(pods: readonly CacheAgentPod[]): NoLandlock[] {
+  const found = new Map<string, string>();
+  for (const pod of pods) {
+    if (pod.metadata.deletionTimestamp) continue;
+    for (const s of pod.status?.containerStatuses ?? []) {
+      const message = s.state?.terminated?.message ?? s.lastState?.terminated?.message ?? "";
+      const match = MESSAGE.exec(message);
+      if (!match) continue;
+      const node = pod.spec?.nodeName ?? match[1]!;
+      if (!found.has(node)) found.set(node, match[2]!);
+    }
+  }
+  return [...found].sort(([a], [b]) => a.localeCompare(b)).map(([node, reason]) => ({ node, reason }));
+}
+
+/** The refusal (ADR-0077, ADR-0019): each node, its reason, and the fix. */
+export function landlockRefusal(nodes: readonly NoLandlock[]): Error {
+  return new Error(
+    [
+      `repo cache: ${nodes.length === 1 ? "a Sandbox node has" : `${nodes.length} Sandbox nodes have`} no Landlock, ` +
+        "and jr2 needs it on every Sandbox node (ADR-0077):",
+      ...nodes.map((n) => `  ${n.node}: ${n.reason}`),
+      "Keep each such node out of the Sandbox nodes with sandbox.nodeSelector or a taint (ADR-0052), or enable " +
+        "Landlock ABI 3 or later in its kernel (Linux 6.2 or later, or a kernel with a backport, with landlock in " +
+        "its lsm= list). Then run `jr2 up` again.",
+    ].join("\n"),
+  );
+}
+
+/**
+ * Wait for the cache agent's rollout, and refuse as soon as one of its pods reports no Landlock:
+ * a pod that exits at start never gets Ready, so the wait alone would only time out. `rollout` is
+ * the converge's own rollout wait (with its own diagnosis on failure); while it runs, the
+ * DaemonSet's pods are read every few seconds, one list call each. A failed rollout is read once
+ * more, so a Landlock refusal wins over the generic diagnosis.
+ */
+export async function awaitCacheAgent(
+  kube: KubeAdmin,
+  target: RolloutTarget,
+  rollout: () => Promise<void>,
+  opts: { pollMs?: number } = {},
+): Promise<void> {
+  const read = async (): Promise<NoLandlock[]> => {
+    try {
+      return nodesWithoutLandlock(
+        await kube.listJson<CacheAgentPod>({
+          kind: "pod",
+          selector: target.selector,
+          namespace: target.namespace,
+          ...(target.context ? { context: target.context } : {}),
+        }),
+      );
+    } catch {
+      // A read that fails is no evidence: the rollout wait still decides.
+      return [];
+    }
+  };
+  const stop = new AbortController();
+  const waited = rollout().then(
+    () => ({ ok: true as const }),
+    (err: unknown) => ({ ok: false as const, err }),
+  );
+  const polled = (async (): Promise<NoLandlock[] | undefined> => {
+    for (;;) {
+      try {
+        await sleep(opts.pollMs ?? POLL_MS, undefined, { signal: stop.signal });
+      } catch {
+        return undefined;
+      }
+      const nodes = await read();
+      if (nodes.length > 0) return nodes;
+    }
+  })();
+  const first = await Promise.race([waited, polled.then((nodes) => ({ nodes }))]);
+  stop.abort();
+  if ("nodes" in first) {
+    if (first.nodes) throw landlockRefusal(first.nodes);
+    // The poll stops only when aborted, so the rollout settled first.
+  }
+  const result = await waited;
+  if (result.ok) return;
+  const nodes = await read();
+  if (nodes.length > 0) throw landlockRefusal(nodes);
+  throw result.err;
+}

package/src/mount-wait.ts

@@ -0,0 +1,82 @@
+// The wait for the kubelet (ADR-0069, ADR-0078). The Orchestrator reads `jr2-images`, `jr2-held`
+// and the two digests Secrets through mounts, and the kubelet refreshes a mount on its own period,
+// about a minute. A write to one of them rolls no pod. So `GET /assembly` reports a digest of what
+// the process reads from each, and a command that wrote one waits until the Orchestrator reports
+// the digest of what the command wrote. Then the door's checks and the next provision read the new
+// data, a new Caller token or Hook secret works, and a rotated value has stopped working.
+
+import { configMapDigest, DIGEST_SECRETS, MOUNTED_CONFIGMAPS } from "@jr2/orchestrator/internal";
+import { activity, type Io } from "./output.ts";
+
+/**
+ * How long a command waits for the Orchestrator to read what it wrote, and how often it asks. The
+ * kubelet's period is about a minute by default. Exported so a test can shorten it.
+ */
+export const MAP_PROPAGATION = { budgetMs: 150_000, stepMs: 5_000 };
+
+/** The part of `GET /assembly` that this wait reads: the digest of each mount, by object name. A
+ * process that is not deployed reports no `mounts`, and has nothing to wait for. */
+export type MountsView = { mounts?: Record<string, string> };
+
+/** An applied object, read loosely: the fields that `mountedDigests` reads. */
+export type AppliedObject = {
+  kind?: string;
+  metadata?: { name?: string };
+  data?: Record<string, string>;
+  stringData?: Record<string, string>;
+};
+
+/**
+ * The digest of each object in `items` that the Orchestrator reads through a mount, by name: the
+ * mounted ConfigMaps by their `data`, and the digests Secrets by their `stringData`, which is the
+ * file content the kubelet writes.
+ */
+export function mountedDigests(items: readonly AppliedObject[]): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const item of items) {
+    const name = item.metadata?.name;
+    if (name === undefined) continue;
+    if (item.kind === "ConfigMap" && name in MOUNTED_CONFIGMAPS) out[name] = configMapDigest(item.data ?? {});
+    if (item.kind === "Secret" && name in DIGEST_SECRETS) out[name] = configMapDigest(item.stringData ?? {});
+  }
+  return out;
+}
+
+/** The names in `want` that are digests Secrets: what a new token or Hook secret waits for. */
+export function digestSecretsOf(want: Readonly<Record<string, string>>): Record<string, string> {
+  return Object.fromEntries(Object.entries(want).filter(([name]) => name in DIGEST_SECRETS));
+}
+
+/**
+ * Wait until the Orchestrator reports each digest in `want`, asking again each step until the
+ * budget ends. It says once, under `prefix`, which objects it waits for. Returns the last view and
+ * the names that were still older at the end: none when the wait succeeded.
+ */
+export async function awaitMounts<V extends MountsView>(
+  io: Io,
+  opts: { seen: V; view: () => Promise<V>; want: Readonly<Record<string, string>>; prefix: string },
+): Promise<{ seen: V; stale: string[] }> {
+  const { want } = opts;
+  const stale = (v: V): string[] =>
+    v.mounts ? Object.keys(want).filter((name) => v.mounts![name] !== want[name]) : [];
+  const deadline = Date.now() + MAP_PROPAGATION.budgetMs;
+  let seen = opts.seen;
+  let said = false;
+  for (let names = stale(seen); names.length; names = stale(seen)) {
+    if (Date.now() >= deadline) return { seen, stale: names };
+    if (!said)
+      activity(io, `${opts.prefix}: waiting for the kubelet to deliver ${names.join(", ")} to the Orchestrator`);
+    said = true;
+    await new Promise((ok) => setTimeout(ok, MAP_PROPAGATION.stepMs));
+    seen = await opts.view();
+  }
+  return { seen, stale: [] };
+}
+
+/** What a wait that ran out says, before the command's own consequence. */
+export function staleLine(names: readonly string[]): string {
+  return (
+    `after ${Math.round(MAP_PROPAGATION.budgetMs / 1000)}s the Orchestrator still reads an older ` +
+    `${names.join(", ")} from its mount — the kubelet has not refreshed it`
+  );
+}

package/src/output.ts

@@ -9,6 +9,7 @@
 import type { BuildPort } from "./build.ts";
 import type { FetchLike } from "./client.ts";
 import type { KubeAdmin, KubePort } from "./kube.ts";
+import type { WorkspaceKube } from "./workspaces.ts";
 import type { TypecheckPort } from "./typecheck.ts";
 
 export type Io = {
@@ -20,6 +21,8 @@ export type Io = {
   fetch?: FetchLike;
   /** Override the kube transport (tests inject a fake); default → `kubectl` subprocesses. */
   kube?: KubePort;
+  /** Override the cluster side of `jr2 workspace` (ADR-0009); default → `kubectl`. */
+  workspaces?: WorkspaceKube;
   /** Override the kube admin surface `jr2 up`/`down` converge through; default → `kubectl`. */
   kubeAdmin?: KubeAdmin;
   /** Override the image build port; default → pnpm + docker + kind subprocesses. */

package/src/sse.ts

@@ -4,7 +4,7 @@
 // more `data:` lines form the payload. We don't need ids, retry, or comments.
 //
 // Cancelling the reader in `finally` means a consumer that `break`s out of `for await` closes the
-// underlying HTTP connection — that is how `jr2 run` / `jr2 logs` detach without killing the run.
+// underlying HTTP connection — that is how `jr2 run` / `jr2 watch` detach without killing the run.
 
 export type SSEFrame = { event: string; data: string };