@yadurajfleetos/cli 0.16.0 → 0.17.0

package/dist/commands/doctor.js

@@ -3,6 +3,37 @@ import { loadProfile } from '../config.js';
 import { c, relativeTime } from '../render.js';
 import { glyph, rule, task } from '../ui.js';
 const icon = (state) => state === 'ok' ? glyph.ok : state === 'warn' ? glyph.warn : glyph.fail;
+/**
+ * How full a node's disk is, from the right two numbers.
+ *
+ * It reported 615% used, which is arithmetic that cannot be right and quietly
+ * undermines every other line of the report. The denominator was `node.diskMb`
+ * — and the control plane says, in a comment directly above the field it sends
+ * instead:
+ *
+ *   Capacity. node.diskMb is FREE space and is what the scheduler places
+ *   against, so it is not the denominator for a "used of total" reading.
+ *
+ * Somebody wrote that warning and this divided by the wrong one anyway. Used
+ * over free exceeds 100% the moment a disk is more than half full, which is
+ * why the number looked wild rather than merely wrong.
+ *
+ * An agent too old to report a capacity gets no percentage at all. A missing
+ * figure is a gap somebody can fix; an invented one is a number people act on.
+ */
+export function diskUse(usedMb, totalMb) {
+    if (!totalMb || usedMb === undefined) {
+        return { state: 'ok', detail: 'capacity not reported by this agent' };
+    }
+    const percent = Math.round((usedMb / totalMb) * 100);
+    return {
+        state: percent >= 90 ? 'fail' : percent >= 80 ? 'warn' : 'ok',
+        detail: `${percent}% used · ${Math.round(usedMb / 1024)}GB of ${Math.round(totalMb / 1024)}GB`,
+        remedy: percent >= 80
+            ? 'Free space from Docker images/volumes before the node becomes unschedulable.'
+            : undefined,
+    };
+}
 /**
  * Services that answer on a health path but do not declare one.
  *
@@ -191,7 +222,7 @@ export const doctorCommand = {
             });
             for (const node of result.nodes) {
                 const runtime = node.telemetry?.runtime;
-                const diskPercent = node.diskMb ? Math.round(((node.telemetry?.diskUsedMb ?? 0) / node.diskMb) * 100) : 0;
+                const disk = diskUse(node.telemetry?.diskUsedMb, node.telemetry?.diskTotalMb);
                 // Redis intentionally retains the last heartbeat briefly, but a node
                 // that has stopped reporting must not have old host facts rendered as
                 // current failures. The heartbeat check above is the only actionable
@@ -207,7 +238,7 @@ export const doctorCommand = {
                 }
                 checks.push({ state: runtime?.dockerAvailable ? 'ok' : 'fail', label: `Docker ${node.name}`, detail: runtime?.dockerAvailable ? `available${runtime.dockerVersion ? ` · ${runtime.dockerVersion}` : ''}` : runtime?.dockerError ?? 'No Docker runtime reported', remedy: runtime?.dockerAvailable ? undefined : 'Start Docker, then inspect the local fleet-agent log.' });
                 checks.push({ state: runtime?.registryStatus === 'ok' ? 'ok' : runtime?.registryStatus === 'failed' ? 'fail' : 'warn', label: `registry ${node.name}`, detail: runtime?.registryStatus === 'ok' ? 'latest real image pull succeeded' : runtime?.registryError ?? 'not tested by a real image pull yet', remedy: runtime?.registryStatus === 'ok' ? undefined : 'Use a LAN-reachable REGISTRY_URL, then restart a service to run an authenticated pull.' });
-                checks.push({ state: diskPercent >= 90 ? 'fail' : diskPercent >= 80 ? 'warn' : 'ok', label: `disk ${node.name}`, detail: `${diskPercent}% used`, remedy: diskPercent >= 80 ? 'Free space from Docker images/volumes before the node becomes unschedulable.' : undefined });
+                checks.push({ ...disk, label: `disk ${node.name}` });
                 if (runtime?.lastReconcileError)
                     checks.push({ state: 'fail', label: `reconcile ${node.name}`, detail: runtime.lastReconcileError, remedy: 'Run `fleet logs <service> --follow` and inspect the deployment history.' });
             }

package/dist/commands/services.js

@@ -332,6 +332,24 @@ export const rescheduleCommand = {
         console.log(`${c.green('moved')} ${service.name} → ${c.bold(body.movedTo.name)}`);
     },
 };
+/**
+ * A building row, with what the builder is actually doing.
+ *
+ * Every field here has been travelling from buildx through Redis to the API for
+ * a while and stopping there, so this shows what already exists rather than
+ * measuring anything new. Emulation is called out because it is the usual
+ * answer to "why is this taking twenty minutes".
+ */
+function buildStatus(status, progress) {
+    const parts = [statusColour(status)];
+    if (progress.step && progress.ofSteps)
+        parts.push(c.dim(`${progress.step}/${progress.ofSteps}`));
+    if (progress.platform)
+        parts.push(c.dim(progress.platform));
+    if (progress.emulated)
+        parts.push(c.yellow('emulated'));
+    return parts.join(' ');
+}
 export const deploymentsCommand = {
     async run(args, flags) {
         const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
@@ -346,8 +364,10 @@ export const deploymentsCommand = {
             relativeTime(d.startedAt),
             d.gitSha?.slice(0, 7) ?? c.dim('—'),
             d.nodeName ?? c.dim('—'),
-            statusColour(d.status),
-            d.failureReason ?? '',
+            // "building" alone reads as stuck. The step counter is what tells a
+            // reader the difference between a slow build and a hung one.
+            d.progress ? buildStatus(d.status, d.progress) : statusColour(d.status),
+            d.failureReason ?? (d.progress?.detail ? c.dim(d.progress.detail) : ''),
         ])));
     },
 };

package/dist/commands/up.js

@@ -188,6 +188,27 @@ async function deployOne(service, opts) {
             // is measured in tens of minutes, not minutes.
             const deadline = Date.now() + 45 * 60_000;
             while (Date.now() < deadline) {
+                // What the builder is doing, rather than a hint about what it might
+                // be doing. Every field here has been reaching /progress since the
+                // phase writer was added and nothing asked for it, so this loop sat
+                // cycling generic advice past a reader who could have been told the
+                // step number. Failures are swallowed: this is a label, and losing it
+                // must not end a deploy that is going fine.
+                const line = await request('GET', `/services/${service.id}/progress`)
+                    .then((r) => r.body)
+                    .catch(() => null);
+                if (line && ['queued', 'building', 'pushing'].includes(line.status)) {
+                    const parts = [line.status];
+                    if (line.step && line.ofSteps)
+                        parts.push(`${line.step}/${line.ofSteps}`);
+                    if (line.platform)
+                        parts.push(line.platform);
+                    if (line.emulated)
+                        parts.push('emulated');
+                    s.update(`${c.bold(service.name)} · ${parts.join(' · ')}`);
+                    if (line.detail)
+                        s.hints([line.detail]);
+                }
                 const { body } = await request('GET', `/fleets/${opts.fleetId}/services`);
                 const current = body.services.find((s) => s.id === service.id)?.current;
                 if (current?.status === 'running')

package/dist/detect.js

@@ -45,11 +45,12 @@ const hasDep = (pkg, name) => {
     return Boolean(deps?.[name] || devDeps?.[name]);
 };
 // ── Dockerfile templates ────────────────────────────────────────────────
-const NEXTJS_DOCKERFILE = `# --- Build ---
+const NEXTJS_DOCKERFILE = `# syntax=docker/dockerfile:1
+# --- Build ---
 FROM node:22-alpine AS builder
 WORKDIR /app
 COPY package*.json ./
-RUN npm ci
+RUN --mount=type=cache,target=/root/.npm npm ci
 COPY . .
 RUN npm run build
 
@@ -63,11 +64,12 @@ COPY --from=builder /app/public ./public
 EXPOSE 3000
 CMD ["node", "server.js"]
 `;
-const VITE_DOCKERFILE = `# --- Build ---
+const VITE_DOCKERFILE = `# syntax=docker/dockerfile:1
+# --- Build ---
 FROM node:22-alpine AS builder
 WORKDIR /app
 COPY package*.json ./
-RUN npm ci
+RUN --mount=type=cache,target=/root/.npm npm ci
 COPY . .
 RUN npm run build
 
@@ -77,32 +79,57 @@ COPY --from=builder /app/dist /usr/share/nginx/html
 EXPOSE 80
 CMD ["nginx", "-g", "daemon off;"]
 `;
-const NODE_DOCKERFILE = `FROM node:22-alpine
+const NODE_DOCKERFILE = `# syntax=docker/dockerfile:1
+FROM node:22-alpine
 WORKDIR /app
 COPY package*.json ./
-RUN npm ci --omit=dev
+RUN --mount=type=cache,target=/root/.npm npm ci --omit=dev
 COPY . .
 EXPOSE 3000
 CMD ["node", "src/index.js"]
 `;
-const PYTHON_DOCKERFILE = (entry, usesPoetry) => `FROM python:3.12-slim
+/**
+ * `--mount=type=cache` rather than `--no-cache-dir`.
+ *
+ * The two look interchangeable and are opposites. `--no-cache-dir` tells pip to
+ * keep no wheel cache *inside the layer*, which keeps the image small and makes
+ * every rebuild download and recompile from nothing. A BuildKit cache mount
+ * lives outside the image entirely — it is not a layer, so it adds nothing to
+ * the final size — and survives between builds, so a rebuild that changes only
+ * application source reuses every wheel it already has.
+ *
+ * That is the difference between a two-minute rebuild and a twenty-minute one
+ * for anything with `cryptography` or `psycopg2` in it, and more again when the
+ * build is emulated.
+ *
+ * The syntax line is required: `RUN --mount` is a Dockerfile frontend feature,
+ * and without it an older builder fails on the flag rather than ignoring it.
+ */
+const PYTHON_DOCKERFILE = (entry, usesPoetry) => `# syntax=docker/dockerfile:1
+FROM python:3.12-slim
 WORKDIR /app
 ${usesPoetry
     ? `COPY pyproject.toml poetry.lock* ./
-RUN pip install --no-cache-dir poetry && poetry config virtualenvs.create false && poetry install --no-interaction --no-ansi --no-dev`
+RUN --mount=type=cache,target=/root/.cache/pip \\
+    --mount=type=cache,target=/root/.cache/pypoetry \\
+    pip install poetry && poetry config virtualenvs.create false && poetry install --no-interaction --no-ansi --no-dev`
     : `COPY requirements*.txt ./
-RUN pip install --no-cache-dir -r requirements.txt`}
+RUN --mount=type=cache,target=/root/.cache/pip \\
+    pip install -r requirements.txt`}
 COPY . .
 EXPOSE 8000
 CMD ["python", "-m", "${entry}"]
 `;
-const GO_DOCKERFILE = (module) => `# --- Build ---
+const GO_DOCKERFILE = (module) => `# syntax=docker/dockerfile:1
+# --- Build ---
 FROM golang:1.24-alpine AS builder
 WORKDIR /app
 COPY go.mod go.sum* ./
-RUN go mod download
+RUN --mount=type=cache,target=/go/pkg/mod go mod download
 COPY . .
-RUN CGO_ENABLED=0 go build -o /server .
+RUN --mount=type=cache,target=/go/pkg/mod \\
+    --mount=type=cache,target=/root/.cache/go-build \\
+    CGO_ENABLED=0 go build -o /server .
 
 # --- Run ---
 FROM alpine:3.21
@@ -110,13 +137,21 @@ COPY --from=builder /server /server
 EXPOSE 8080
 CMD ["/server"]
 `;
-const RUST_DOCKERFILE = `# --- Build ---
+const RUST_DOCKERFILE = `# syntax=docker/dockerfile:1
+# --- Build ---
 FROM rust:1.87-slim AS builder
 WORKDIR /app
 COPY Cargo.toml Cargo.lock* ./
-RUN mkdir src && echo 'fn main(){}' > src/main.rs && cargo build --release && rm -rf src
+RUN --mount=type=cache,target=/usr/local/cargo/registry \\
+    mkdir src && echo 'fn main(){}' > src/main.rs && cargo build --release && rm -rf src
 COPY . .
-RUN cargo build --release
+# Only the registry is cached, deliberately. A cache mount on /app/target would
+# speed the compile up and put the binary somewhere the runtime stage cannot
+# copy from: a mount is not part of the image, so "COPY --from=builder
+# /app/target/release/*" would find an empty directory and the image would
+# build cleanly and contain nothing.
+RUN --mount=type=cache,target=/usr/local/cargo/registry \\
+    cargo build --release
 
 # --- Run ---
 FROM debian:bookworm-slim

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yadurajfleetos/cli",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Fleet OS command-line interface for deploying and orchestrating services on user-owned hardware",
   "type": "module",
   "license": "MIT",