@cat-factory/cli 0.8.5 → 0.9.0

package/dist/supervise-k3s.js

@@ -0,0 +1,130 @@
+/**
+ * A local Kubernetes cluster as a supervised dependency.
+ *
+ * WHY. A slept laptop takes the k3s control plane with it, and nothing brings it back. The failure
+ * is quiet in the worst way: the container engine's `unless-stopped` policy DOES retry the server
+ * node, so `docker ps` shows motion — but the load balancer in front of it boots, fails to resolve
+ * its now-missing upstream, exits 0, and is restarted forever. A zero exit code reads as healthy at
+ * a glance, so the cluster can sit dead for days while `kubectl` just times out and every
+ * environment provisioned through the Local k3s handler fails.
+ *
+ * WHAT THIS CAN AND CANNOT FIX. A cluster whose containers are merely STOPPED is repairable here:
+ * start it, wait for the apiserver. A cluster whose restart is blocked by a wedged cgroup
+ * (`runc create failed: ... cgroup.procs: device or resource busy`, the state a suspend can leave
+ * behind) is NOT: clearing it requires restarting the container engine itself, which would kill
+ * every other container — including the database this same supervisor depends on. So that case is
+ * detected and NAMED rather than retried. Looping on it would reproduce exactly the uselessness of
+ * the load-balancer restart loop this dependency exists to prevent.
+ */
+import { hasServerVersion, parseK3dClusters, parseKindClusters } from './k3s-probe.js';
+import { contextName } from './k3s-provision.js';
+import { OperatorActionRequiredError } from './supervise-runtime.js';
+const APISERVER_READY_TIMEOUT_MS = 120_000;
+const APISERVER_POLL_MS = 3_000;
+const CLUSTER_START_TIMEOUT_MS = 120_000;
+/**
+ * The cgroup-wedge signature. runc reports it when a dead container's cgroup was never torn down,
+ * so the new task cannot be created in it — the state a suspend/resume cycle can leave behind, and
+ * the one thing a start command can never talk its way out of.
+ */
+export function looksLikeCgroupWedge(output) {
+    const text = output.toLowerCase();
+    return (text.includes('device or resource busy') ||
+        (text.includes('cgroup') && text.includes('unable to apply cgroup configuration')));
+}
+/** The guidance printed when the wedge is hit — the only sequence that actually clears it. */
+export const CGROUP_WEDGE_GUIDANCE = 'the container runtime cannot restart this cluster: a stale cgroup is blocking it ' +
+    '(runc: "device or resource busy"). This does NOT clear on its own and no retry will fix it. ' +
+    'Restart the container engine (e.g. `docker desktop restart`, or Docker Desktop > Restart), ' +
+    'then start the cluster again. Note that this also bounces every other container.';
+/**
+ * Build the cluster dependency. `reachable` is judged from the apiserver's OWN version — the only
+ * signal that survives every intermediate lie (containers up but apiserver not listening, LB up but
+ * upstream missing, kubeconfig present but stale).
+ */
+export function createK3sClusterDependency(shell, opts) {
+    const context = contextName(opts.runtime, opts.cluster);
+    const readyTimeoutMs = opts.readyTimeoutMs ?? APISERVER_READY_TIMEOUT_MS;
+    const readyPollMs = opts.readyPollMs ?? APISERVER_POLL_MS;
+    const apiserverReachable = async () => {
+        const result = await shell.run('kubectl', [
+            'version',
+            '--output=json',
+            '--request-timeout=5s',
+            '--context',
+            context,
+        ]);
+        // A down apiserver still yields exit 1 plus the client half of the payload, so the parse — not
+        // the exit code — is what decides. `hasServerVersion` is true only when the server answered.
+        return hasServerVersion(result.stdout);
+    };
+    /** Is this cluster known to the runtime (i.e. stopped rather than deleted)? */
+    const clusterExists = async () => {
+        if (opts.runtime === 'k3d') {
+            const result = await shell.run('k3d', ['cluster', 'list', '--output', 'json']);
+            if (result.code !== 0)
+                return false;
+            return parseK3dClusters(result.stdout).includes(opts.cluster);
+        }
+        const result = await shell.run('kind', ['get', 'clusters']);
+        if (result.code !== 0)
+            return false;
+        return parseKindClusters(result.stdout).includes(opts.cluster);
+    };
+    /**
+     * Start a stopped cluster. k3d has a first-class `cluster start`; kind has none — a kind cluster
+     * is just its node containers, so they are started directly by their conventional names.
+     */
+    const startCluster = async () => {
+        if (opts.runtime === 'k3d') {
+            const result = await shell.run('k3d', ['cluster', 'start', opts.cluster], {
+                timeoutMs: CLUSTER_START_TIMEOUT_MS,
+            });
+            return { ok: result.code === 0, output: `${result.stdout}\n${result.stderr}` };
+        }
+        const result = await shell.run('docker', ['start', `${opts.cluster}-control-plane`], {
+            timeoutMs: CLUSTER_START_TIMEOUT_MS,
+        });
+        return { ok: result.code === 0, output: `${result.stdout}\n${result.stderr}` };
+    };
+    const waitForApiserver = async () => {
+        const deadline = Date.now() + readyTimeoutMs;
+        while (Date.now() < deadline) {
+            if (await apiserverReachable())
+                return true;
+            // Not `unref`'d — see the note on `systemClock`: an unref'd timer lets the process exit while
+            // this wait is the only thing outstanding, which is exactly mid-recovery.
+            await new Promise((resolve) => {
+                setTimeout(resolve, readyPollMs);
+            });
+        }
+        return false;
+    };
+    return {
+        label: `${opts.runtime} cluster "${opts.cluster}"`,
+        async ensure() {
+            if (await apiserverReachable())
+                return true;
+            // Absent from the runtime's list ⇒ deleted, not stopped. Creating one here would be a
+            // surprise (it owns RBAC + a service account); `cat-factory k3s` is the deliberate path.
+            if (!(await clusterExists()))
+                return false;
+            const started = await startCluster();
+            if (!started.ok) {
+                if (looksLikeCgroupWedge(started.output)) {
+                    throw new K3sWedgedError(CGROUP_WEDGE_GUIDANCE);
+                }
+                return false;
+            }
+            return await waitForApiserver();
+        },
+    };
+}
+/**
+ * Thrown when the cluster cannot be restarted without operator action. Distinct from a plain
+ * `false` (not ready, retry next cycle) precisely so the loop can stop repeating a hopeless step
+ * and surface the fix instead.
+ */
+export class K3sWedgedError extends OperatorActionRequiredError {
+}
+//# sourceMappingURL=supervise-k3s.js.map

package/dist/supervise-k3s.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervise-k3s.js","sourceRoot":"","sources":["../src/supervise-k3s.ts"],"names":[],"mappings":"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"}

package/dist/supervise-runtime.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Effects half of `cat-factory supervise`: the health probe, the optional container dependency,
+ * the port reaper, the supervised child, and the loop that drives them from the pure decisions in
+ * `supervise.ts`.
+ *
+ * Everything the loop touches is behind a seam so `runSupervisor` can be driven by fakes — the
+ * same discipline `host-shell.ts` sets out for the k3s flow. Shell-outs go through {@link HostShell}
+ * rather than `node:child_process` directly; the one exception is the supervised child itself,
+ * which needs inherited stdio and a live handle, so it gets its own {@link ChildLauncher} seam.
+ */
+import { type HostShell } from './host-shell.js';
+import { type SuperviseConfig } from './supervise.js';
+/** Probes whether the supervised service is actually SERVING (not merely booted). */
+export interface HealthProbe {
+    serving(): Promise<boolean>;
+}
+/** A prerequisite the supervised service needs — a database container, a local cluster, … */
+export interface ServiceDependency {
+    /** Human-readable name for logs. */
+    readonly label: string;
+    /**
+     * Bring it up if needed; resolve `true` once it is ready, `false` to retry on the next cycle.
+     * Throw {@link OperatorActionRequiredError} for a state no retry can clear.
+     */
+    ensure(): Promise<boolean>;
+}
+/**
+ * Thrown by a dependency that cannot be repaired without a human. The loop prints the message ONCE
+ * and stops treating the step as retryable noise — the alternative is a watchdog that repeats a
+ * hopeless action forever, which is the exact pathology (a restart loop that reads as progress)
+ * this supervisor exists to end.
+ */
+export declare class OperatorActionRequiredError extends Error {
+}
+/** A running supervised child process. */
+export interface SupervisedChild {
+    readonly pid: number | undefined;
+    /** Kill the child AND its descendants. Never throws. */
+    kill(): Promise<void>;
+    /** Resolves when the process exits, with its code/signal. */
+    readonly exited: Promise<{
+        code: number | null;
+        signal: string | null;
+    }>;
+}
+/** Starts the supervised command. */
+export interface ChildLauncher {
+    start(): SupervisedChild;
+}
+/** Frees a port held by an orphaned listener, so a restart can bind it again. */
+export interface PortReaper {
+    /** Resolves with the PIDs actually killed (empty when the port was already free). */
+    reap(): Promise<string[]>;
+}
+/** Injectable clock, so tests never wait in real time. */
+export interface SuperviseClock {
+    now(): number;
+    /** Resolves after `ms`, or EARLY if `signal` aborts — so Ctrl-C isn't stuck behind a poll interval. */
+    sleep(ms: number, signal?: AbortSignal): Promise<void>;
+}
+/**
+ * NOTE the deliberately un-`unref`'d timers throughout this module. An `unref`'d timer does not keep
+ * the event loop alive, and while a spawned child DOES hold it open, that reference vanishes the
+ * moment the child dies — which is precisely when the supervisor must keep running. With `unref` the
+ * poll timer was then the only thing left, so Node exited 0 the instant its child was killed: a
+ * watchdog that died with its patient, silently and with a success code.
+ */
+export declare const systemClock: SuperviseClock;
+/**
+ * The real probe. "Serving" requires BOTH signals, because the two failure modes differ: a parked
+ * `node --watch` leaves nothing bound to the port, while a server that booted but wedged (or lost
+ * its DB pool) still holds the socket and only fails the HTTP check.
+ *
+ * Both address families are tried — a Node server on `0.0.0.0` answers on 127.0.0.1, but some dev
+ * servers bind IPv6 `::1` only, and probing one family would report a false outage.
+ */
+export declare function createHealthProbe(opts: {
+    port: number;
+    healthPath: string;
+}): HealthProbe;
+/**
+ * A `docker compose` service the supervised process needs. This is the piece that makes recovery
+ * work after the container engine itself restarted: the example compose files set no restart
+ * policy on Postgres, so anything that stops the engine leaves the DB down, and relaunching the
+ * server against a missing (or still-initialising) database just crashes it again in `migrate`.
+ */
+export declare function createComposeDependency(shell: HostShell, opts: {
+    /**
+     * Directory holding the `docker-compose.yml`. Passed as the shell-out's `cwd` on EVERY compose
+     * call, never merely stored: compose resolves its project file relative to the working
+     * directory, so a supervisor started from anywhere else would address no project at all and
+     * report a permanently un-ready database instead of restoring it.
+     */
+    dir: string;
+    service: string;
+    /** Overridable so tests don't wait out the real readiness budget. */
+    readyTimeoutMs?: number;
+    readyPollMs?: number;
+}): ServiceDependency;
+/**
+ * Frees the port before a restart. Killing the child tree usually suffices, but not always: a
+ * package-manager wrapper that is killed without its subtree leaves the real `node` orphaned and
+ * still holding the socket, and the relaunch then dies with `EADDRINUSE` — turning one outage into
+ * a restart loop. Reaping by PORT is the only check that covers an orphan we never had a handle on.
+ *
+ * It is also, unavoidably, the bluntest thing this supervisor does: reaping by port means SIGKILLing
+ * a process we were never handed. If `--port` names a port some unrelated service owns, that service
+ * is what dies. There is no portable way to prove descent from our own child, so the mitigation is
+ * disclosure rather than detection — every kill NAMES the pid and, where the platform will tell us,
+ * the command behind it, and `reap()` reports what it killed so the caller can log it. Callers only
+ * ever reap AFTER their own child is confirmed dead, so a healthy stack is never a candidate.
+ */
+export declare function createPortReaper(shell: HostShell, port: number, opts?: {
+    platform?: string;
+    log?: (message: string) => void;
+}): PortReaper;
+/**
+ * Launches the supervised command through a shell, with stdio inherited so its logs stay visible —
+ * the supervisor is meant to be a transparent wrapper, not a log proxy.
+ *
+ * The command is passed as ONE string with `shell: true` (rather than a command plus an args array,
+ * which trips Node's DEP0190) so a package-manager entry point resolves through its Windows `.cmd`
+ * shim. On POSIX the child gets its own process group, so killing it takes the whole tree.
+ */
+export declare function createChildLauncher(opts: {
+    command: string;
+    cwd: string;
+}): ChildLauncher;
+/** Everything `runSupervisor` needs. Every field is a seam; only `launcher` and `probe` are required. */
+export interface SupervisorDeps {
+    config: SuperviseConfig;
+    probe: HealthProbe;
+    launcher: ChildLauncher;
+    /** Checked in order before each restart — e.g. the database, then the local cluster. */
+    dependencies?: ServiceDependency[];
+    reaper?: PortReaper;
+    clock?: SuperviseClock;
+    log?: (message: string) => void;
+    /**
+     * Aborting stops the loop and, before returning, kills the supervised child and reaps the port.
+     * The loop OWNS the child handle, so shutdown has to live here: a signal handler outside it can
+     * only reach the port, which on POSIX kills the inner listener while leaving the package-manager
+     * wrapper and its `node --watch` alive and parked — a Ctrl-C that orphans exactly the process tree
+     * this command exists to manage.
+     */
+    stopSignal?: AbortSignal;
+    /** Stop after this many ticks — tests only; production runs until the process is signalled. */
+    maxTicks?: number;
+}
+/** How a finished supervisor run turned out. Useful for tests and for the command's exit code. */
+export interface SupervisorOutcome {
+    ticks: number;
+    repairs: number;
+    /** Dependencies that reported a state only an operator can clear, by label. */
+    blocked: string[];
+    /**
+     * Set when the supervisor STOPPED trying, with the reason. Restarting cannot fix a command that
+     * is simply broken, so `maxFailedStarts` consecutive restarts that never reached a serving state
+     * end the loop and report — the caller turns this into a non-zero exit.
+     */
+    gaveUp?: string;
+}
+/**
+ * Run the supervision loop: start the child, then probe on an interval and repair when the
+ * decisions in `supervise.ts` say so. Returns when `stopSignal` aborts, when the crash-loop budget
+ * is spent, or when `maxTicks` is reached (tests) — in production, otherwise never.
+ */
+export declare function runSupervisor(deps: SupervisorDeps): Promise<SupervisorOutcome>;
+//# sourceMappingURL=supervise-runtime.d.ts.map

package/dist/supervise-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervise-runtime.d.ts","sourceRoot":"","sources":["../src/supervise-runtime.ts"],"names":[],"mappings":"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"}