redkite 0.1.12 → 0.1.13

package/src/cli/viewer.ts

@@ -5,6 +5,7 @@ import {
   elapsed,
   emptyModel,
   keysOf,
+  paintTags,
   render,
   type Model,
   type Step,
@@ -113,7 +114,7 @@ export function createViewer(
     stream.write(ALTERNATE_OFF);
     // The alternate screen takes every frame with it, so the run has to be
     // written again on the screen the person keeps
-    for (const line of summary(model)) stream.write(`${line}\n`);
+    for (const line of summary(model, colour)) stream.write(`${line}\n`);
   };
 
   // What a second press means is not the view's to decide: the same key
@@ -191,18 +192,18 @@ export function createViewer(
 
 // One line per step and whatever was said outside them, which is the record a
 // person scrolls back to after the deploy is over
-function summary(model: Model): string[] {
+function summary(model: Model, colour: boolean): string[] {
   const rows = model.steps.map((step) => {
     const glyph = step.state === "done" ? "✔" : step.state === "failed" ? "✘" : "·";
     const said = step.note ? `: ${step.note}` : "";
     const took = elapsed(step.ended ?? model.now, step.started);
 
-    return `${glyph} ${step.label}${said} (${took})`;
+    return paintTags(`${glyph} ${step.label}${said} (${took})`, colour);
   });
 
   return [
     ...rows,
-    ...model.messages.map((message) => message.text),
+    ...model.messages.map((message) => paintTags(message.text, colour)),
     ...whatFailed(model),
   ];
 }

package/src/deploy.ts

@@ -26,7 +26,7 @@ import { pluginSteps } from "./plugin.js";
 import { readEnv, readRef, type SecretStores } from "./secrets/refs.js";
 import { ensureService } from "./services/ensure.js";
 import { plannedServices } from "./services/planned.js";
-import type { Source } from "./source.js";
+import { describeRef, describeRepo, type Source } from "./source.js";
 import { topologyFor, type AppTopology, type Topology } from "./topology.js";
 import type { AppSpec, Deployment } from "./types.js";
 
@@ -305,13 +305,16 @@ async function checkAll(context: Context, health: Omit<HealthDeps, "probe">) {
   const results = await Promise.all(
     context.config.apps.map(async (app) => {
       const target = appOf(topology, app.name);
+
+      // A step of its own for each app, rather than lines said beside the swap:
+      // every attempt lands on it, and a crash log gives it a file
       const deps: HealthDeps = {
         ...health,
         probe: async (container, url) => {
           const result = await docker.run(`exec ${container} curl -s ${url}`);
           return { code: result.code, output: result.stdout };
         },
-        log,
+        task: log.step(`Health check of ${app.name}`),
       };
 
       const healthy = await healthcheck(target.container, target.port, app.health, deps);
@@ -444,7 +447,7 @@ async function clone(
   if (!app.repo) return undefined;
 
   const ref = refOf(app, branch);
-  const what = `${app.repo}, ${ref.kind} ${ref.name}`;
+  const what = `${describeRepo(app.repo)} ${describeRef(ref)}`;
   const task = log.step(`Cloning ${app.name}`);
 
   try {
@@ -457,7 +460,7 @@ async function clone(
     });
 
     // Said again at the end, where it outlasts the details that replaced it
-    task.done(`${what} at ${source.release.slice(0, 7)}`);
+    task.done(`${what} -> ${source.release.slice(0, 7)}`);
     return source;
   } catch (error) {
     task.fail(`${app.name} could not clone ${what}`);

package/src/health.ts

@@ -1,4 +1,4 @@
-import { silent, type Log } from "./log.js";
+import { silent, type Task } from "./log.js";
 import type { HealthSpec } from "./types.js";
 
 const RETRIES = 10;
@@ -16,7 +16,9 @@ export type Probe = (
 export type HealthDeps = {
   probe: Probe;
   sleep: (ms: number) => Promise<void>;
-  log?: Log;
+  // The step the check reports on. Every attempt is said on it, so a check that
+  // gave up shows what the container answered each time rather than only that
+  task?: Task;
 };
 
 // One loop for every app. The two copies it replaces had already drifted: the
@@ -30,22 +32,28 @@ export async function healthcheck(
 ): Promise<boolean> {
   const retries = spec.retries ?? RETRIES;
   const ceiling = spec.intervalMs ?? INTERVAL_MS;
-  const log = deps.log ?? silent;
+  const task = deps.task ?? silent.step("");
   const delay = spec.delayMs ?? DELAY_MS;
+  const url = `localhost:${port}${spec.path}`;
 
+  task.detail(`probing ${container} at ${url}`);
   if (delay > 0) await deps.sleep(delay);
 
   let backoff = FIRST_BACKOFF_MS;
 
   for (let attempt = 1; attempt <= retries; attempt += 1) {
-    const url = `localhost:${port}${spec.path}`;
     const { code, output } = await deps.probe(container, url);
+    const said = (message: string) => task.detail(`attempt ${attempt} of ${retries}: ${message}`);
 
-    if (code === 0 && passes(spec, output, log, container)) {
-      log.done(`${container} is healthy`);
+    if (code === 0 && passes(spec, output, said)) {
+      task.done(`${container} healthy after ${attempt} ${attempt === 1 ? "attempt" : "attempts"}`);
       return true;
     }
 
+    // Nothing answered at all, which is a container still starting or one that
+    // is listening somewhere other than where the check asks
+    if (code !== 0) said(`no answer on ${url}`);
+
     if (attempt === retries) break;
 
     // Doubling from a quarter second means a container that starts quickly
@@ -54,30 +62,29 @@ export async function healthcheck(
     backoff = Math.min(backoff * 2, ceiling);
   }
 
-  log.fail(`${container} failed its health check after ${retries} attempts`);
+  task.fail(`${container} unhealthy after ${retries} attempts`);
   return false;
 }
 
 // A body that parses but fails the predicate is a retry, not a verdict. The
 // container may still be warming up, and the caller has a retry budget for it
-function passes(
-  spec: HealthSpec,
-  output: string,
-  log: Log,
-  container: string,
-) {
+function passes(spec: HealthSpec, output: string, said: (message: string) => void) {
   let body: unknown;
 
   try {
     body = JSON.parse(output);
   } catch {
-    log.warn(`${container} returned a body that is not JSON: ${output}`);
+    said(`answered with something that is not JSON: ${output}`);
+    return false;
+  }
+
+  if (typeof body !== "object" || body === null) {
+    said(`answered with JSON that is not an object: ${output}`);
     return false;
   }
 
-  if (typeof body !== "object" || body === null) return false;
   if (spec.expect(body as Record<string, unknown>)) return true;
 
-  log.warn(`${container} is not healthy yet: ${output}`);
+  said(`not healthy yet: ${output}`);
   return false;
 }

package/src/log.ts

@@ -1,8 +1,26 @@
 // The shape progress is reported through. The library only knows this much, so
 // a deploy driven from somewhere without a terminal supplies its own.
 
+// A short label a terminal can draw as a tag, such as the host a repository
+// lives on. Marked with private-use characters, which nothing a command prints
+// uses, so a log finds one without guessing at brackets somebody typed
+const TAG_OPEN = "\uE000";
+const TAG_CLOSE = "\uE001";
+
+export const TAGS = /\uE000([^\uE000\uE001]*)\uE001/g;
+
+export function tag(label: string) {
+  return `${TAG_OPEN}${label}${TAG_CLOSE}`;
+}
+
+// For a log that has no way to draw one: a file, a pipe, a CI log
+export function untagged(text: string) {
+  return text.replaceAll(TAGS, "[$1]");
+}
+
 // Work that is still running. Announced when it starts, because the thing worth
-// knowing during a four minute build is which step is the four minutes
+// knowing during a four minute build is which step is the four minutes. What it
+// says may carry a tag, which a log that draws plain text passes through untagged
 export type Task = {
   // What the step is doing right now, replacing whatever it said before
   detail(message: string): void;

package/src/source.ts

@@ -1,4 +1,5 @@
 import type { Host } from "./host.js";
+import { tag } from "./log.js";
 
 // Getting the source onto the machine that builds it. A repository the host
 // clones for itself over the forwarded agent, so no tree crosses the wire: a
@@ -45,6 +46,29 @@ const REVISION: Record<RefKind, (name: string) => string> = {
   commit: (name) => `${name}^{commit}`,
 };
 
+// Hosts common enough to be worth a tag in place of their name
+const HOSTS: Record<string, string> = { "github.com": "GH" };
+
+// user@host:path, or scheme://user@host/path, with the .git every clone URL ends
+// in. Anything that is not one of those, a directory for instance, has no host
+const REMOTE = /^(?:[a-z][a-z0-9+.-]*:\/\/)?(?:[^@/]+@)?([^:/]+)[:/](.+?)(?:\.git)?\/?$/;
+
+// How a repository is named on screen: the host as a tag where it is a known
+// one, and the path without the .git that says nothing a person needs
+export function describeRepo(repo: string) {
+  const match = REMOTE.exec(repo);
+  if (!match?.[1] || !match[2]) return repo.replace(/\.git$/, "");
+
+  const known = HOSTS[match[1]];
+  return known ? `${tag(known)} ${match[2]}` : `${match[1]}:${match[2]}`;
+}
+
+// A branch is what is tracked nearly always, so it goes by its name alone. A tag
+// or a commit is a pin, and says which kind it is
+export function describeRef(ref: Ref) {
+  return ref.kind === "branch" ? ref.name : `${ref.kind} ${ref.name}`;
+}
+
 // accept-new rather than no: a host key that changes is still worth refusing
 const GIT_SSH = "ssh -o StrictHostKeyChecking=accept-new";