@hypit/hypit 0.1.3 → 0.1.5

package/packages/cli/src/arguments.ts

@@ -18,6 +18,7 @@ type RawOptions = {
   readonly presentation: CliOutputOptions;
   readonly workspaceRoot?: string;
   readonly assetRoots: readonly string[];
+  readonly endpoints: readonly string[];
   readonly packageRoot?: string;
   readonly runtimeProfile?: string;
   readonly follow: boolean;
@@ -36,6 +37,7 @@ type RawOptions = {
   readonly watch: boolean;
   readonly readyFile?: string;
   readonly workerOwner?: string;
+  readonly executionRoot?: string;
   readonly reason?: string;
   readonly slot?: string;
   readonly credentialFile?: string;
@@ -155,9 +157,15 @@ export function parseCommand(argv: readonly string[]): CliCommand {
         ...optionalProject(options),
       };
     }
+    case "logs": {
+      const [build, rest] = requiredPositional(tail, "logs requires one Build id");
+      const options = commandOptions(command, rest, "--runtime", "--workspace", "--lines");
+      return { command, build, lines: options.lines, presentation: options.presentation,
+        ...optionalProject(options), ...optionalRuntime(options) };
+    }
     case "status": {
       const [build, rest] = requiredPositional(tail, "status requires one Build id");
-      const options = commandOptions(command, rest, "--runtime", "--watch", "--max-wait-ms", "--limit");
+      const options = commandOptions(command, rest, "--runtime", "--workspace", "--watch", "--max-wait-ms", "--limit");
       if (!options.watch && options.maxWaitMs !== undefined) {
         throw new Error("--max-wait-ms applies to status --watch");
       }
@@ -172,7 +180,7 @@ export function parseCommand(argv: readonly string[]): CliCommand {
       };
     }
     case "activity": {
-      const options = commandOptions(command, tail, "--runtime", "--watch", "--jsonl", "--limit");
+      const options = commandOptions(command, tail, "--runtime", "--workspace", "--watch", "--jsonl", "--limit");
       if (options.presentation.jsonl === true && !options.watch) {
         throw new Error("--jsonl applies only to activity --watch");
       }
@@ -189,7 +197,7 @@ export function parseCommand(argv: readonly string[]): CliCommand {
     }
     case "cancel": {
       const [build, rest] = requiredPositional(tail, "cancel requires one Build id");
-      const options = commandOptions(command, rest, "--runtime", "--reason");
+      const options = commandOptions(command, rest, "--runtime", "--workspace", "--reason");
       return {
         command,
         build,
@@ -205,22 +213,26 @@ export function parseCommand(argv: readonly string[]): CliCommand {
     case "auth": return parseAuthCommand(tail);
     case "doctor": {
       const [profile, rest] = optionalPositional(tail);
-      const options = commandOptions(command, rest, "--workspace", "--limit");
+      const options = commandOptions(command, rest, "--workspace", "--runtime", "--limit", "--endpoint");
+      if (profile !== undefined && options.runtimeProfile !== undefined) {
+        throw new Error("doctor accepts the Runtime Profile either positionally or with --runtime, not both");
+      }
       return {
         command,
+        ...(options.endpoints.length === 0 ? {} : { endpoints: options.endpoints }),
         presentation: options.presentation,
         limit: options.limit,
         ...optionalProject(options),
-        ...runtimeOption(profile),
+        ...runtimeOption(profile ?? options.runtimeProfile),
       };
     }
     case "paths": {
-      const options = commandOptions(command, tail, "--runtime");
+      const options = commandOptions(command, tail, "--runtime", "--workspace");
       return { command, presentation: options.presentation, ...optionalRuntime(options) };
     }
     case "_worker": {
       const [profile, rest] = requiredPositional(tail, "internal Worker launch is incomplete");
-      const options = commandOptions(command, rest, "--ready-file", "--worker-owner", "--package-root");
+      const options = commandOptions(command, rest, "--ready-file", "--worker-owner", "--package-root", "--execution-root");
       if (options.readyFile === undefined || options.workerOwner === undefined) {
         throw new Error("internal Worker launch is incomplete");
       }
@@ -229,6 +241,7 @@ export function parseCommand(argv: readonly string[]): CliCommand {
         profile,
         readyFile: options.readyFile,
         workerOwner: options.workerOwner,
+        ...(options.executionRoot === undefined ? {} : { executionRoot: options.executionRoot }),
         presentation: options.presentation,
         ...optionalPackageRoot(options),
       };
@@ -244,7 +257,7 @@ function parseResultCommand(tail: readonly string[]): ProjectResultCommand | Exe
   }
   const [build, rest] = requiredPositional(values, `result ${action} requires one Build id`);
   if (action === "finish" || action === "discard") {
-    const options = commandOptions(`result ${action}`, rest, "--runtime");
+    const options = commandOptions(`result ${action}`, rest, "--runtime", "--workspace");
     return { command: "result", action, build, presentation: options.presentation, ...optionalRuntime(options) };
   }
   const options = commandOptions("result edit", rest,
@@ -302,11 +315,11 @@ function parseRuntimeCommand(tail: readonly string[]): RuntimeSelectionCommand |
   }
   const [profile, rest] = optionalPositional(values);
   const allowed = action === "up" || action === "down"
-    ? ["--runtime", "--max-wait-ms"] as const
+    ? action === "up" ? ["--runtime", "--max-wait-ms", "--endpoint"] as const : ["--runtime", "--max-wait-ms"] as const
     : action === "status"
       ? ["--runtime", "--limit"] as const
       : ["--runtime", "--lines"] as const;
-  const options = commandOptions(`runtime ${action}`, rest, ...allowed);
+  const options = commandOptions(`runtime ${action}`, rest, "--workspace", ...allowed);
   rejectDuplicateProfile("runtime", profile, options.runtimeProfile);
   const runtime = runtimeOption(profile ?? options.runtimeProfile);
   const common = {
@@ -314,9 +327,10 @@ function parseRuntimeCommand(tail: readonly string[]): RuntimeSelectionCommand |
     action,
     presentation: options.presentation,
     ...runtime,
+    ...optionalProject(options),
   };
   if (action === "up" || action === "down") {
-    return { ...common, action, ...(options.maxWaitMs === undefined ? {} : { maxWaitMs: options.maxWaitMs }) };
+    return { ...common, action, ...(action === "up" && options.endpoints.length > 0 ? { endpoints: options.endpoints } : {}), ...(options.maxWaitMs === undefined ? {} : { maxWaitMs: options.maxWaitMs }) };
   }
   if (action === "status") return { ...common, action, limit: options.limit };
   return { ...common, action, lines: options.lines };
@@ -329,7 +343,7 @@ function parseProgramsCommand(tail: readonly string[]): ProgramsCommand {
   }
   const [profile, rest] = optionalPositional(values);
   const options = commandOptions(`programs ${action}`, rest,
-    "--runtime", "--limit", "--max-wait-ms");
+    "--runtime", "--workspace", "--limit", "--max-wait-ms", "--endpoint");
   if (action !== "up" && options.maxWaitMs !== undefined) {
     throw new Error("--max-wait-ms applies to programs up");
   }
@@ -337,10 +351,12 @@ function parseProgramsCommand(tail: readonly string[]): ProgramsCommand {
   const runtime = runtimeOption(profile ?? options.runtimeProfile);
   const common = {
     command: "programs" as const,
+    ...(options.endpoints.length === 0 ? {} : { endpoints: options.endpoints }),
     action,
     presentation: options.presentation,
     limit: options.limit,
     ...runtime,
+    ...optionalProject(options),
   };
   return action === "up"
     ? { ...common, action, ...(options.maxWaitMs === undefined ? {} : { maxWaitMs: options.maxWaitMs }) }
@@ -362,7 +378,7 @@ function parseAuthCommand(tail: readonly string[]): AuthCommand {
   }
   const [endpoint, rest] = requiredPositional(values, `auth ${action} requires one Endpoint instance`);
   const options = commandOptions(`auth ${action}`, rest,
-    "--runtime", "--slot", ...(action === "login" ? ["--from"] as const : []),
+    "--runtime", "--workspace", "--slot", ...(action === "login" ? ["--from"] as const : []),
     ...(action === "status" ? ["--limit"] as const : []));
   const common = {
     command: "auth" as const,
@@ -398,6 +414,7 @@ function parseOptions(values: readonly string[]): RawOptions {
   let runtimeProfile: string | undefined;
   let follow = false;
   let maxWaitMs: number | undefined;
+  const endpoints: string[] = [];
   let outputName: string | undefined;
   let title: string | undefined;
   let note: string | undefined;
@@ -416,6 +433,7 @@ function parseOptions(values: readonly string[]): RawOptions {
   let watch = false;
   let readyFile: string | undefined;
   let workerOwner: string | undefined;
+  let executionRoot: string | undefined;
   let reason: string | undefined;
   let slot: string | undefined;
   let credentialFile: string | undefined;
@@ -424,7 +442,7 @@ function parseOptions(values: readonly string[]): RawOptions {
   for (let index = 0; index < values.length; index += 1) {
     const item = values[index]!;
     if (!item.startsWith("--")) throw new Error(`unexpected positional argument ${item}`);
-    const repeatable = [
+    const repeatable = item === "--endpoint" || [
       "--json", "--jsonl", "--watch", "--verbose", "--debug",
       "--no-color", "--follow", "--asset-root", "--highlight",
     ].includes(item);
@@ -445,6 +463,7 @@ function parseOptions(values: readonly string[]): RawOptions {
       index += 1;
       continue;
     }
+    if (item === "--endpoint") { endpoints.push(optionValue(values, index, "--endpoint requires an Endpoint name")); index += 1; continue; }
     if (item === "--workspace") {
       workspaceRoot = resolve(optionValue(values, index, "--workspace requires a directory")); index += 1; continue;
     }
@@ -501,6 +520,9 @@ function parseOptions(values: readonly string[]): RawOptions {
     if (item === "--worker-owner") {
       workerOwner = optionValue(values, index, "--worker-owner requires an identity"); index += 1; continue;
     }
+    if (item === "--execution-root") {
+      executionRoot = resolve(optionValue(values, index, "--execution-root requires a path")); index += 1; continue;
+    }
     if (item === "--reason") {
       reason = optionValue(values, index, "--reason requires text"); index += 1; continue;
     }
@@ -522,6 +544,7 @@ function parseOptions(values: readonly string[]): RawOptions {
     presentation: { json: json || jsonl, ...(jsonl ? { jsonl: true } : {}), color, verbose },
     assetRoots,
     follow,
+    endpoints,
     highlightedOutputs,
     clearTitle,
     clearNote,
@@ -541,6 +564,7 @@ function parseOptions(values: readonly string[]): RawOptions {
     ...(destination === undefined ? {} : { destination }),
     ...(readyFile === undefined ? {} : { readyFile }),
     ...(workerOwner === undefined ? {} : { workerOwner }),
+    ...(executionRoot === undefined ? {} : { executionRoot }),
     ...(reason === undefined ? {} : { reason }),
     ...(slot === undefined ? {} : { slot }),
     ...(credentialFile === undefined ? {} : { credentialFile }),
@@ -576,7 +600,7 @@ function optionalProject(options: RawOptions): ProjectOption {
 }
 
 function optionalRuntime(options: RawOptions): RuntimeOption {
-  return runtimeOption(options.runtimeProfile);
+  return { ...runtimeOption(options.runtimeProfile), ...optionalProject(options) };
 }
 
 function runtimeOption(profile: string | undefined): RuntimeOption {

package/packages/cli/src/build-planning.ts

@@ -24,7 +24,12 @@ export function createCatalogDescriptor(options: {
     if (item.ref.kind === "operation-result") {
       throw new Error(`public output ${item.name} was not lowered to a stable Record or Logical Output`);
     }
-    return item.ref.kind === "logical-output" ? [{ name: item.name, ref: item.ref }] : [];
+    if (item.ref.kind !== "logical-output") return [];
+    const outputId = item.ref.id;
+    const element = options.compilation.provenance.elements.find((element) => element.outputs.some((output) => output.id === outputId));
+    const authored = element?.outputs.find((output) => output.id === outputId);
+    const displayName = element?.components.find((component) => component.id === authored?.component)?.local;
+    return [{ name: item.name, ref: item.ref, ...(displayName === undefined ? {} : { displayName }) }];
   });
   const names = new Set<string>();
   const outputs = new Set<string>();
@@ -416,9 +421,10 @@ export function assertPlannedRequests(
   }
 }
 
-export async function preflightPlan(host: NodeRuntimeHost, state: BuildState) {
+export async function preflightPlan(host: NodeRuntimeHost, state: BuildState, providers: readonly PlanProviderView[]) {
   const capabilities = demandedCapabilities(state);
-  const result = await host.preflight({ capabilities });
+  const endpoints = [...new Set(providers.flatMap((item) => item.status === "resolved" && item.endpoint !== undefined ? [item.endpoint] : []))];
+  const result = await host.preflight({ endpoints });
   return {
     ok: !result.diagnostics.some((item) => item.severity === "error"),
     capabilities: capabilities.map(capabilityName),

package/packages/cli/src/command.ts

@@ -4,7 +4,7 @@ type CommandBase = {
   readonly presentation: CliOutputOptions;
 };
 
-export type RuntimeOption = {
+export type RuntimeOption = ProjectOption & {
   readonly runtimeProfile: string | undefined;
 };
 
@@ -72,6 +72,7 @@ export type ProjectResultCommand =
     });
 
 export type ExecutionCommand =
+  | (CommandBase & RuntimeOption & { readonly command: "logs"; readonly build: string; readonly lines: number })
   | (CommandBase & RuntimeOption & {
       readonly command: "status";
       readonly build: string;
@@ -115,6 +116,7 @@ export type RuntimeOperationCommand =
   | (CommandBase & RuntimeOption & {
       readonly command: "runtime";
       readonly action: "up";
+      readonly endpoints?: readonly string[];
       readonly maxWaitMs?: number;
     })
   | (CommandBase & RuntimeOption & {
@@ -136,12 +138,14 @@ export type RuntimeOperationCommand =
 export type ProgramsCommand =
   | (CommandBase & RuntimeOption & {
       readonly command: "programs";
+      readonly endpoints?: readonly string[];
       readonly action: "up";
       readonly maxWaitMs?: number;
       readonly limit: number;
     })
   | (CommandBase & RuntimeOption & {
       readonly command: "programs";
+      readonly endpoints?: readonly string[];
       readonly action: "down" | "status";
       readonly limit: number;
     });
@@ -182,6 +186,7 @@ export type EnvironmentCommand =
     })
   | (CommandBase & ProjectOption & RuntimeOption & {
       readonly command: "doctor";
+      readonly endpoints?: readonly string[];
       readonly limit: number;
     });
 
@@ -190,6 +195,7 @@ export type WorkerCommand = CommandBase & {
   readonly profile: string;
   readonly readyFile: string;
   readonly workerOwner: string;
+  readonly executionRoot?: string;
   readonly packageRoot?: string;
 };
 

package/packages/cli/src/commands/environment.ts

@@ -10,9 +10,27 @@ import { acquireOAuthCredential } from "../oauth.js";
 import { writeCliOutput } from "../output.js";
 import type { CliIo } from "../output.js";
 import { hypitHostStateRoot, hypitProjectStateRoot } from "../paths.js";
-import type { CliRuntimeController } from "../runtime-port.js";
+import type { CliManagedProgramReport, CliRuntimeController } from "../runtime-port.js";
 import type { OperationalWriter } from "./types.js";
 
+function programRecord(item: CliManagedProgramReport) {
+  return {
+    ...item,
+    state: item.state.state,
+    ...(item.state.state === "ready" ? {} : { stateDetail: item.state.detail }),
+  };
+}
+
+function programDescription(item: CliManagedProgramReport): string {
+  const details = [...new Set([
+    ...(item.state.state === "ready" ? [] : [item.state.detail]),
+    ...(item.detail === undefined ? [] : [item.detail]),
+  ])];
+  return `${item.id}: ${item.state.state}${details.length === 0 ? "" : ` — ${details.join("; ")}`}`
+    + (item.pid === undefined ? "" : ` · PID ${item.pid}`)
+    + (item.logPath === undefined ? "" : ` · log ${item.logPath}`);
+}
+
 export function isEnvironmentCommand(args: CliCommand): args is EnvironmentCommand {
   return args.command === "paths" || args.command === "packages" || args.command === "doctor"
     || args.command === "programs" || args.command === "auth"
@@ -23,6 +41,7 @@ export function isEnvironmentCommand(args: CliCommand): args is EnvironmentComma
 export async function runEnvironmentCommand(input: {
   readonly args: EnvironmentCommand;
   readonly runtimeProfile: string | undefined;
+  readonly runtimeSelectionFile: string | undefined;
   readonly io: CliIo;
   readonly distribution: CliDistribution;
   readonly projectRoot: string;
@@ -32,11 +51,16 @@ export async function runEnvironmentCommand(input: {
   readonly write: OperationalWriter;
 }): Promise<void> {
   const {
-    args, runtimeProfile, io, distribution, projectRoot, packageRootForProject, runtimeHost, runtimeController, write,
+    args, runtimeProfile, runtimeSelectionFile, io, distribution, projectRoot, packageRootForProject, runtimeHost, runtimeController, write,
   } = input;
+  const profileSource: "none" | "argument" | "project" = runtimeProfile === undefined
+    ? "none" : runtimeSelectionFile === undefined ? "argument" : "project";
+  const selectionDescription = profileSource === "argument"
+    ? "command argument (this invocation only)"
+    : runtimeSelectionFile ?? "none";
   const reportProgramProgress = args.presentation.json
     ? undefined
-    : (event: { readonly id: string; readonly phase: "checking" | "installing" | "starting" | "waiting" | "ready" }): void => {
+    : (event: { readonly id: string; readonly phase: "checking" | "installing" | "starting" | "waiting" | "ready"; readonly logPath?: string }): void => {
       if (!args.presentation.verbose && event.phase !== "installing" && event.phase !== "starting") return;
       const verb = {
         checking: "Checking",
@@ -45,12 +69,12 @@ export async function runEnvironmentCommand(input: {
         waiting: "Waiting for",
         ready: "Ready",
       }[event.phase];
-      io.write(`  · ${verb} ${event.id}\n`);
+      io.write(`  · ${verb} ${event.id}${event.logPath === undefined ? "" : ` · log ${event.logPath}`}\n`);
     };
   const reportPackageProgress = args.presentation.json
     ? undefined
-    : (event: { readonly specifier: string; readonly phase: "checking" | "installing" | "ready" }): void => {
-      if (event.phase === "installing") io.write(`  · Installing ${event.specifier}\n`);
+    : (event: { readonly specifier: string; readonly phase: "checking" | "installing" | "ready"; readonly logPath?: string }): void => {
+      if (event.phase === "installing") io.write(`  · Installing ${event.specifier}${event.logPath === undefined ? "" : ` · log ${event.logPath}`}\n`);
     };
   const reportCredentialProgress = args.presentation.json
     ? io.writeProgress
@@ -63,6 +87,8 @@ export async function runEnvironmentCommand(input: {
     const machine = {
       format: "hypit.cli-paths@1" as const,
       project: projectRoot,
+      profileSource,
+      selectionFile: resolve(projectRoot, ".hypit/runtime"),
       projectState: hypitProjectStateRoot(projectRoot),
       ...(runtimeProfile === undefined ? {} : { profile: runtimeProfile }),
       ...(runtimePaths === undefined ? {} : { runtimeData: runtimePaths.runtimeDataRoot }),
@@ -74,11 +100,14 @@ export async function runEnvironmentCommand(input: {
       ["Project", machine.project],
       ["Project state", machine.projectState],
       ["Runtime Profile", machine.profile ?? "not selected"],
+      ["Runtime selection", selectionDescription],
       ["Runtime data", machine.runtimeData ?? "not selected"],
       ["Host state", machine.hostState],
       ["Machine packages", machine.machinePackages],
       ["Distribution", machine.distribution ?? "embedded"],
-    ]);
+    ], runtimeProfile === undefined
+      ? ["Select an existing Profile with hypit runtime use <profile> --workspace <project>, or create one with hypit runtime init."]
+      : []);
     return;
   }
 
@@ -97,10 +126,13 @@ export async function runEnvironmentCommand(input: {
       action: args.action,
       package: args.package,
       ready,
+      ...(reports[0] === undefined ? {} : { installation: reports[0].root }),
+      ...(reports[0]?.logPath === undefined ? {} : { logPath: reports[0].logPath }),
     }, args.action === "install" ? "Machine package is ready" : "Machine package status",
     ready ? "success" : "warning", [
       ["Package", args.package],
       ["Ready", String(ready)],
+      ...(args.presentation.verbose && reports[0] !== undefined ? [["Installation", reports[0].root] as const] : []),
     ]);
     if (!ready) io.setExitCode?.(1);
     return;
@@ -109,7 +141,7 @@ export async function runEnvironmentCommand(input: {
   if (args.command === "doctor") {
     const profile = runtimeProfile === undefined ? undefined : resolve(runtimeProfile);
     const [runtimeResult, projectResult] = await Promise.all([
-      profile === undefined ? undefined : (await runtimeHost(profile)).doctor(),
+      profile === undefined ? undefined : (await runtimeHost(profile)).doctor(args.endpoints === undefined ? {} : { endpoints: args.endpoints }),
       distribution.diagnoseProjectResults(projectRoot, {
         packageRoot: await packageRootForProject(),
         ...(distribution.packageRoot === undefined
@@ -122,10 +154,11 @@ export async function runEnvironmentCommand(input: {
       format: "hypit.cli-doctor@1" as const,
       ok: !diagnostics.some((item) => item.severity === "error"),
       project: projectRoot,
+      profileSource,
+      ...(runtimeSelectionFile === undefined ? {} : { selectionFile: runtimeSelectionFile }),
       ...(profile === undefined ? {} : { profile }),
       diagnosticCount: diagnostics.length,
-      diagnostics: diagnostics.slice(0, args.limit),
-      ...(diagnostics.length <= args.limit ? {} : { omittedDiagnostics: diagnostics.length - args.limit }),
+      diagnostics,
     };
     writeCliOutput(io, args.presentation, { kind: "doctor", machine });
     if (!machine.ok) io.setExitCode?.(1);
@@ -137,21 +170,27 @@ export async function runEnvironmentCommand(input: {
     const profile = resolve(runtimeProfile);
     const host = await runtimeHost(profile);
     if (args.action === "up") {
-      await host.prepare(reportPackageProgress === undefined ? {} : { onProgress: reportPackageProgress });
+      await host.prepare({ ...(args.endpoints === undefined ? {} : { endpoints: args.endpoints }), ...(reportPackageProgress === undefined ? {} : { onProgress: reportPackageProgress }) });
     }
     const controller = await runtimeController(profile);
     const result = args.action === "up"
       ? await controller.programs.up({
+        ...(args.endpoints === undefined ? {} : { endpoints: args.endpoints }),
         ...(args.maxWaitMs === undefined ? {} : { maxWaitMs: args.maxWaitMs }),
         ...(reportProgramProgress === undefined ? {} : { onProgress: reportProgramProgress }),
       })
       : args.action === "down"
-        ? await controller.programs.down()
-        : await controller.programs.report();
+        ? await controller.programs.down(args.endpoints === undefined ? {} : { endpoints: args.endpoints })
+        : await controller.programs.report(args.endpoints === undefined ? {} : { endpoints: args.endpoints });
     const ready = result.programs.every((item) => item.state.state === "ready");
     const desiredState = args.action === "down" ? !result.programs.some((item) => item.state.state === "ready") : ready;
     const lifecycleOk = args.action === "status" || desiredState;
-    const shownPrograms = result.programs.filter((item) => item.state.state !== "ready").slice(0, args.limit);
+    const needsAttention = (item: typeof result.programs[number]) => args.action === "down"
+      ? item.state.state === "ready" : item.state.state !== "ready";
+    const relevant = result.programs.filter((item) => args.presentation.verbose || args.action === "status" || needsAttention(item));
+    const urgent = relevant.filter(needsAttention);
+    const shownPrograms = [...urgent, ...relevant.filter((item) => !needsAttention(item)).slice(0, Math.max(0, args.limit - urgent.length))];
+    const omittedPrograms = relevant.length - shownPrograms.length;
     const title = args.action === "up"
       ? desiredState ? "External programs ready" : "External programs need attention"
       : args.action === "down"
@@ -161,19 +200,17 @@ export async function runEnvironmentCommand(input: {
       format: "hypit.cli-programs@1",
       action: args.action,
       ready,
-      programs: result.programs.slice(0, args.limit).map((item) => ({
-        id: item.id,
-        state: item.state.state,
-        ...(args.presentation.verbose && item.action !== undefined ? { action: item.action } : {}),
-      })),
-      ...(result.programs.length <= args.limit ? {} : { omittedPrograms: result.programs.length - args.limit }),
+      programCount: result.programs.length,
+      readyCount: result.programs.filter((item) => item.state.state === "ready").length,
+      programs: shownPrograms.map(programRecord),
+      ...(omittedPrograms === 0 ? {} : { omittedPrograms }),
     }, title,
     args.action === "status" ? ready ? "success" : "info" : lifecycleOk ? "success" : "warning", [
       ...(!args.presentation.verbose && lifecycleOk && args.action !== "status" ? [] : [
         ["Programs", String(result.programs.length)] as const,
         ["Ready", String(result.programs.filter((item) => item.state.state === "ready").length)] as const,
       ]),
-    ], shownPrograms.map((item) => `${item.id}: ${item.state.state}`));
+    ], shownPrograms.map(programDescription).concat(omittedPrograms === 0 ? [] : [`${omittedPrograms} more programs · use --limit <count>`]));
     if (!lifecycleOk) io.setExitCode?.(1);
     return;
   }
@@ -186,11 +223,12 @@ export async function runEnvironmentCommand(input: {
       const packageRoot = await packageRootForProject();
       const host = await runtimeHost(profile, packageRoot);
       const prepared = await host.prepare(
-        reportPackageProgress === undefined ? {} : { onProgress: reportPackageProgress },
+        { ...(args.endpoints === undefined ? {} : { endpoints: args.endpoints }), ...(reportPackageProgress === undefined ? {} : { onProgress: reportPackageProgress }) },
       );
-      const validated = await host.createRuntime();
+      const validated = await host.createRuntime(args.endpoints === undefined ? {} : { endpoints: args.endpoints });
       await validated.close();
       const external = await controller.programs.up({
+        ...(args.endpoints === undefined ? {} : { endpoints: args.endpoints }),
         ...(args.maxWaitMs === undefined ? {} : { maxWaitMs: args.maxWaitMs }),
         ...(reportProgramProgress === undefined ? {} : { onProgress: reportProgramProgress }),
       });
@@ -207,6 +245,7 @@ export async function runEnvironmentCommand(input: {
         programs: {
           total: external.programs.length,
           ready: external.programs.filter((item) => item.state.state === "ready").length,
+          items: external.programs.filter((item) => args.presentation.verbose || item.state.state !== "ready").map(programRecord),
         },
       }, ok ? "Local Runtime ready" : "Local Runtime needs attention", ok ? "success" : "warning", [
         ...(!args.presentation.verbose && ok ? [] : [
@@ -214,7 +253,8 @@ export async function runEnvironmentCommand(input: {
           ["Worker", processState.state] as const,
           ["Managed programs", `${external.programs.filter((item) => item.state.state === "ready").length}/${external.programs.length} ready`] as const,
         ]),
-      ]);
+      ], external.programs.filter((item) => args.presentation.verbose || item.state.state !== "ready")
+        .map(programDescription));
       if (!ok) io.setExitCode?.(1);
       return;
     }
@@ -271,13 +311,12 @@ export async function runEnvironmentCommand(input: {
         attention,
         worker: {
           state: worker.state,
-          ...(worker.configuration === undefined ? {} : { configuration: worker.configuration }),
         },
         builds: counts,
         programs: {
           total: external.programs.length,
           ready: external.programs.length - unavailable.length,
-          unavailable: unavailable.slice(0, args.limit).map((item) => ({ id: item.id, state: item.state.state })),
+          unavailable: unavailable.map(programRecord),
         },
         capacity: {
           active: activity.capacity.length,
@@ -297,7 +336,7 @@ export async function runEnvironmentCommand(input: {
           ["Capacity in use", String(activity.capacity.length)] as const,
         ] : []),
       ], [
-        ...unavailable.slice(0, args.limit).map((item) => `${item.id}: ${item.state.state}`),
+        ...unavailable.map(programDescription),
       ]);
     } finally {
       if (runtime !== undefined) await runtime.close();