@yadurajfleetos/cli 0.10.2 → 0.12.0

package/dist/api.js

@@ -24,17 +24,27 @@ export async function request(method, path, opts = {}) {
     if (opts.auth !== false && !profile.accessToken) {
         throw new CliError('Not signed in. Run `fleet auth login` first.', EXIT.usage);
     }
+    // A POST with nothing to send still needs a content type.
+    //
+    // Fastify answers 415 to a POST that arrives without one, so every bodyless
+    // POST from this CLI failed before reaching its route — including `fleet
+    // alerts test`, the command the CLI itself recommends for checking alerts
+    // work before an incident. Sending an empty object costs two bytes and makes
+    // the request well-formed, rather than leaving each such route to remember
+    // to accept a shape nothing sends.
+    const writes = method === 'POST' || method === 'PUT' || method === 'PATCH';
+    const payload = opts.raw ? opts.raw.data : writes || opts.body ? JSON.stringify(opts.body ?? {}) : undefined;
     const send = async (token) => fetch(profile.api.replace(/\/+$/, '') + path, {
         method,
         headers: {
             ...(token ? { authorization: `Bearer ${token}` } : {}),
             ...(opts.raw
                 ? { 'content-type': opts.raw.contentType }
-                : opts.body
+                : payload !== undefined
                     ? { 'content-type': 'application/json' }
                     : {}),
         },
-        body: opts.raw ? opts.raw.data : opts.body ? JSON.stringify(opts.body) : undefined,
+        body: payload,
         signal: AbortSignal.timeout(20 * 60_000),
     });
     let res;

package/dist/commands/doctor.js

@@ -3,6 +3,56 @@ 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;
+/**
+ * Services that answer on a health path but do not declare one.
+ *
+ * `fleet init` writes this into every manifest it generates:
+ *
+ *   # No health check: container state decides whether this is up.
+ *   # Add one once you know a path that returns 2xx —
+ *
+ * That is a research task handed to the reader, about a program the node is
+ * already running. The node does the research now -- it asks the container
+ * which of a handful of paths answers -- and this is where the answer is
+ * reported, because the sweep settles seconds after a deploy returns and there
+ * is nothing useful to say while it is still running.
+ *
+ * The negative result is deliberately not a warning. A service where nothing
+ * answered is a service whose manifest is already correct, and telling somebody
+ * their correct configuration is a problem is how a health report gets ignored.
+ *
+ * Separated from the command so both outcomes can be tested without a control
+ * plane -- and the one that matters is the suggestion, which a fleet whose
+ * services all declare health checks never produces.
+ */
+export function healthPathCheck(services) {
+    const swept = services.filter((s) => s.discoveredHealth);
+    const answering = swept
+        .map((s) => ({
+        name: s.name,
+        // The first 2xx-3xx, which is the order the node tried them in: a
+        // dedicated endpoint before "/", because a check that renders the whole
+        // application every ten seconds is the worse of two working answers.
+        path: s.discoveredHealth.find((c) => c.status >= 200 && c.status < 400)?.path,
+    }))
+        .filter((s) => Boolean(s.path));
+    if (!answering.length) {
+        return {
+            state: 'ok',
+            label: 'health paths',
+            detail: swept.length
+                ? `${swept.length} service(s) without a health check answered nothing — container state is the only evidence, as declared.`
+                : 'Every service declares a health check, or none has been swept yet.',
+        };
+    }
+    const named = answering.map((s) => `${s.name} → ${s.path}`).join(', ');
+    return {
+        state: 'warn',
+        label: 'health paths',
+        detail: `${named}. These answer 2xx but declare no health check, so a deploy is confirmed on container state alone.`,
+        remedy: `Add \`health: { path: ${answering[0].path} }\` to ${answering[0].name} in fleet.yaml. Without one, a container that starts and then fails every request still counts as a successful deploy.`,
+    };
+}
 /**
  * A build failure carries the whole buildx transcript. One summary line
  * belongs in a health report; `fleet deployments` is where the rest lives.
@@ -29,6 +79,38 @@ const ORIGIN_UNREACHABLE = new Set([502, 503, 504, 520, 521, 522, 523, 524, 525,
  * What does indicate a broken path is the edge answering on the origin's
  * behalf, or nothing answering at all.
  */
+/**
+ * Whether this fleet can tell anybody something went wrong.
+ *
+ * A fleet with no alert rules fails silently, and the only way to find out is
+ * an outage. This one had none while its services went down four times in an
+ * afternoon: the empty state existed, and lived inside `fleet alerts`, a
+ * subcommand you only run once you already suspect the answer.
+ *
+ * Separated from the command so both outcomes can be tested without a control
+ * plane — the one that matters is the warning, and it is the one a live check
+ * against a working fleet never exercises.
+ */
+export function alertCheck(rules) {
+    const live = rules.filter((r) => r.enabled);
+    if (live.length) {
+        return {
+            state: 'ok',
+            label: 'alerts',
+            detail: `${live.length} rule(s): ${[...new Set(live.map((r) => r.channelType))].join(', ')}`,
+        };
+    }
+    return {
+        state: 'warn',
+        label: 'alerts',
+        // Disabled and absent are different mistakes: one was set up and turned
+        // off, the other never existed, and the person reading needs to know which.
+        detail: rules.length
+            ? 'Every alert rule is disabled — failures will pass unreported.'
+            : 'No alert rules. A node going down or a deploy failing will tell nobody.',
+        remedy: 'Add one with `fleet alerts add --channel email --to you@example.com`, then prove it with `fleet alerts test`.',
+    };
+}
 async function reach(url) {
     try {
         const response = await fetch(url, { redirect: 'manual', signal: AbortSignal.timeout(8_000) });
@@ -60,13 +142,14 @@ export const doctorCommand = {
         const profile = await loadProfile();
         const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
         const result = await task('checking Fleet health', async () => {
-            const [identity, fleet, nodes, services, github, health] = await Promise.all([
+            const [identity, fleet, nodes, services, github, health, alerts] = await Promise.all([
                 request('GET', '/auth/me'),
                 request('GET', `/fleets/${fleetId}`),
                 request('GET', `/fleets/${fleetId}/nodes`),
                 request('GET', `/fleets/${fleetId}/services`),
                 request('GET', `/fleets/${fleetId}/github/status`),
                 request('GET', '/healthz'),
+                request('GET', `/fleets/${fleetId}/alert-rules`),
             ]);
             const deploymentHistory = await Promise.all(services.body.services.map(async (service) => ({
                 service,
@@ -76,7 +159,7 @@ export const doctorCommand = {
                 .map((service) => ({ name: service.name, hostname: service.domain ?? service.hostname }))
                 .filter((service) => Boolean(service.hostname));
             const ingress = await Promise.all(urls.map(async (service) => ({ ...service, ...(await reach(`https://${service.hostname}`)) })));
-            return { identity: identity.body, fleet: fleet.body, nodes: nodes.body.nodes, services: services.body.services, github: github.body, health: health.body, deploymentHistory, ingress };
+            return { identity: identity.body, fleet: fleet.body, nodes: nodes.body.nodes, services: services.body.services, github: github.body, health: health.body, alerts: alerts.body.rules, deploymentHistory, ingress };
         });
         const checks = [
             { state: 'ok', label: 'control plane', detail: profile.api },
@@ -171,6 +254,8 @@ export const doctorCommand = {
                 detail: result.github.error ?? 'Not configured; public repositories can still deploy.',
                 remedy: 'Set GITHUB_APP_ID and GITHUB_APP_PRIVATE_KEY, restart the control plane, then connect repositories in Dashboard → Settings.',
             });
+        checks.push(healthPathCheck(result.services));
+        checks.push(alertCheck(result.alerts));
         checks.push({ state: 'ok', label: 'control-plane version', detail: result.health.version ?? 'version not reported' });
         if (flags.json)
             return console.log(JSON.stringify({ fleetId, checks }, null, 2));

package/dist/commands/index.js

@@ -5,12 +5,13 @@ import { alertsCommand } from './alerts.js';
 import { configCommand, useCommand } from './config.js';
 import { doctorCommand } from './doctor.js';
 import { upCommand } from './up.js';
+import { tuneCommand } from './tune.js';
 import { openCommand } from './open.js';
 import { downCommand } from './down.js';
 import { unpairCommand, agentCommand } from './unpair.js';
 import { secretsCommand } from './secrets.js';
 import { backupCommand, backupsCommand, restoreCommand } from './backups.js';
-import { applyCommand, deployCommand, deploymentsCommand, initCommand, importCommand, explainCommand, logsCommand, removeServiceCommand, restartCommand, rollbackCommand, rescheduleCommand, servicesCommand, validateCommand, whereCommand, } from './services.js';
+import { applyCommand, deployCommand, deploymentsCommand, initCommand, diagnoseCommand, importCommand, explainCommand, logsCommand, removeServiceCommand, restartCommand, rollbackCommand, rescheduleCommand, servicesCommand, validateCommand, whereCommand, } from './services.js';
 export const commands = {
     up: upCommand,
     open: openCommand,
@@ -20,7 +21,9 @@ export const commands = {
     config: configCommand,
     use: useCommand,
     doctor: doctorCommand,
+    tune: tuneCommand,
     init: initCommand,
+    diagnose: diagnoseCommand,
     import: importCommand,
     explain: explainCommand,
     validate: validateCommand,

package/dist/commands/services.js

@@ -462,7 +462,7 @@ async function theOnlyNode(flags) {
  * appeared with different ports and no explanation is worse than one with a
  * mistake in it -- at least the mistake is yours to find.
  */
-async function reviewed(draft, flags) {
+async function reviewed(draft, flags, services) {
     const { repoMap } = await import('../repomap.js');
     const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
     // The second pass is a different, smaller question.
@@ -473,14 +473,27 @@ async function reviewed(draft, flags) {
     // just given was discarded. Applying an answer needs the manifest it applies
     // to and the answer, not the evidence that produced it: the model has
     // already read the repository and written its conclusions down.
-    const review = (base, map, answers) => task(answers ? 'applying your answers' : 'reading the repository for a second opinion', async () => request('POST', `/fleets/${fleetId}/manifest/assist`, {
-        body: { draft: base, repoMap: map, ...(answers ? { answers } : {}) },
+    const review = (base, map, answers, parts) => task(answers ? 'applying your answers' : 'reading the repository for a second opinion', async () => request('POST', `/fleets/${fleetId}/manifest/assist`, {
+        body: {
+            draft: base,
+            repoMap: map,
+            ...(answers ? { answers } : {}),
+            ...(parts ? { parts } : {}),
+        },
     }), { done: () => (answers ? 'done' : 'reviewed') });
     let map;
     let out;
     try {
         map = await repoMap();
-        out = (await review(draft, map)).body;
+        // Evidence per service, so each is reviewed at full depth rather than
+        // every service being trimmed to fit one request. The whole-repository
+        // map still goes along: a service is judged partly by what surrounds it,
+        // and the tree is how the model knows what else exists.
+        const parts = await Promise.all(services.map(async (svc) => ({
+            service: svc.name,
+            map: await repoMap(join(process.cwd(), svc.dir)),
+        })));
+        out = (await review(draft, map, undefined, parts)).body;
     }
     catch (err) {
         console.log(`${glyph.warn} ${c.yellow('review skipped')}  ${err instanceof Error ? err.message : 'the control plane could not be reached'}`);
@@ -567,6 +580,52 @@ async function answerQuestions(questions, flags) {
     }
     return Object.keys(answers).length ? answers : null;
 }
+/**
+ * Ask the control plane why something is wrong.
+ *
+ * Distinct from `explain`, which reads a failure log you already have. This
+ * goes and finds the evidence: the deployment history, what the node says it
+ * is running, the container's output, whether the public address answers.
+ */
+export const diagnoseCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const question = args.join(' ').trim();
+        if (!question) {
+            throw new CliError('usage: fleet diagnose "<what is wrong>"\n' +
+                '   eg: fleet diagnose "why is backend returning 502?"', EXIT.usage);
+        }
+        const { body } = await task('looking', async () => request('POST', `/fleets/${fleetId}/diagnose`, { body: { question } }), 
+        // What it looked at, so the wait is legible rather than a spinner.
+        { done: (r) => ('calls' in r.body ? `looked at ${r.body.calls.length} thing(s)` : 'done') });
+        if (flags.json)
+            return console.log(JSON.stringify(body, null, 2));
+        if (body.status === 'disabled') {
+            return console.log(`${glyph.warn} ${c.yellow('unavailable')}  ${body.reason}`);
+        }
+        // What it looked at, always — the reader can repeat any of it by hand, and
+        // a diagnosis you cannot retrace is a diagnosis you have to take on faith.
+        for (const call of body.calls) {
+            const detail = Object.values(call.args)[0];
+            console.log(c.dim(`  · ${call.tool}${detail ? ` ${String(detail)}` : ''}`));
+        }
+        if (body.status === 'inconclusive') {
+            console.log(`\n${glyph.warn} ${c.yellow('inconclusive')}  ${body.reason}`);
+            return;
+        }
+        console.log(`\n${body.summary}\n`);
+        for (const f of body.findings) {
+            console.log(`  ${c.bold(f.claim)}`);
+            console.log(c.dim(`    ${f.evidence}`));
+        }
+        if (body.next.length) {
+            console.log(`\n  ${c.dim('next')}`);
+            for (const n of body.next)
+                console.log(`  ${glyph.info ?? '·'} ${n}`);
+        }
+        console.log(c.dim(`\n  ${body.model}`));
+    },
+};
 export const initCommand = {
     async run(args, flags) {
         const { detect, manifestTemplate } = await import('../detect.js');
@@ -596,7 +655,9 @@ export const initCommand = {
                     (found.databases.length ? await theOnlyNode(flags) : undefined),
             });
             const questions = drafted.questions;
-            const manifest = flags.ai ? await reviewed(drafted.manifest, flags) : drafted.manifest;
+            const manifest = flags.ai
+                ? await reviewed(drafted.manifest, flags, found.services.map((s) => ({ name: s.name, dir: s.dir })))
+                : drafted.manifest;
             await writeFile(path, manifest);
             console.log(`${c.green('created')} ${path}`);
             if (found.layout)

package/dist/commands/tune.js

@@ -0,0 +1,61 @@
+import { request, requireFleet } from '../api.js';
+import { c } from '../render.js';
+import { glyph, rule } from '../ui.js';
+import { asQuantity, tuneRam, MIN_OBSERVATION_HOURS } from '../tune.js';
+/**
+ * Reservations, checked against what the services actually used.
+ *
+ * It proposes and never applies. Every number here is the system inferring
+ * something about a machine, and the lesson of every inference this project has
+ * shipped is that one leaving its evidence needs a person between it and the
+ * manifest — a review once invented a node from a compose service name, and
+ * once replaced a `build:` with `image: nginx:alpine` and served the welcome
+ * page over somebody's site. Both were caught by a guardrail. A person reading
+ * a diff is the cheapest guardrail there is.
+ */
+export const tuneCommand = {
+    async run(_args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const { body } = await request('GET', `/fleets/${fleetId}/services`);
+        const advice = body.services.map((s) => tuneRam(s));
+        if (flags.json)
+            return console.log(JSON.stringify({ fleetId, advice }, null, 2));
+        console.log(`\n${rule('tune · reservations against measured use')}`);
+        const advised = advice.filter((a) => a.verdict === 'advise');
+        const tight = advice.filter((a) => a.verdict === 'tight');
+        const waiting = advice.filter((a) => a.verdict === 'too-soon' || a.verdict === 'no-data');
+        for (const a of advice) {
+            if (a.verdict === 'advise') {
+                console.log(`${glyph.warn} ${c.bold(a.name.padEnd(18))} reserves ${asQuantity(a.from)}, peaks at ${a.peak}MB` +
+                    ` → ${c.bold(asQuantity(a.to))}`);
+            }
+            else if (a.verdict === 'tight') {
+                console.log(`${glyph.warn} ${c.bold(a.name.padEnd(18))} peaks at ${a.peak}MB of ${asQuantity(a.requestRamMb)}` +
+                    ` — close to its limit, which is also where the kernel kills it`);
+            }
+            else if (a.verdict === 'fits') {
+                console.log(`${glyph.ok} ${c.bold(a.name.padEnd(18))} peaks at ${a.peak}MB — about right`);
+            }
+            else if (a.verdict === 'too-soon') {
+                console.log(`${glyph.info} ${c.dim(a.name.padEnd(18))} ${c.dim(`watched for ${a.hours}h; needs ${MIN_OBSERVATION_HOURS}h`)}`);
+            }
+            else {
+                console.log(`${glyph.info} ${c.dim(a.name.padEnd(18))} ${c.dim('not measured yet')}`);
+            }
+        }
+        if (advised.length) {
+            console.log(`\n  ${c.dim('edit fleet.yaml, then')} fleet up`);
+            for (const a of advised) {
+                if (a.verdict !== 'advise')
+                    continue;
+                console.log(`  ${c.dim(`${a.name}:`)} resources: { ram: ${asQuantity(a.to)} }`);
+            }
+        }
+        if (!advised.length && !tight.length) {
+            console.log(`\n  ${c.dim(waiting.length === advice.length
+                ? 'Nothing has been watched long enough to advise on yet.'
+                : 'Every measured reservation is about right.')}`);
+        }
+        console.log();
+    },
+};

package/dist/compose.js

@@ -1,6 +1,6 @@
 import { parse as parseYaml } from 'yaml';
 import { safeDatabaseName } from './dbnames.js';
-import { injectedUrl, pointsAt } from './dburl.js';
+import { pointsAt } from './dburl.js';
 /** Images Fleet manages as databases rather than as plain containers. */
 const ENGINE_IMAGES = {
     postgres: 'postgres',
@@ -310,10 +310,17 @@ export function composeToFleet(source, opts = {}) {
             if (target) {
                 const [composeName, fleetName] = target;
                 const engine = dbEngines.get(composeName);
-                const url = engine ? injectedUrl(fleetName, engine) : null;
-                if (url) {
-                    plain.push([k, url]);
-                    notes.push(`${name}: ${k} now points at the managed ${engine} — it named the compose service "${composeName}", which Fleet runs as "${fleetName}" with a password it generates.`);
+                if (engine) {
+                    // A reference, not a computed URL.
+                    //
+                    // This used to build the connection string here, which meant the CLI
+                    // carrying a copy of the control plane's engine table — ports,
+                    // schemes, default users — kept honest by a test that caught it
+                    // getting postgres's user wrong. The control plane resolves this at
+                    // apply time from the table it owns, so the copy is gone and the
+                    // manifest says what it means rather than a value that has to match.
+                    plain.push([k, `\${db:${fleetName}.url}`]);
+                    notes.push(`${name}: ${k} now points at the managed ${engine} — it named the compose service "${composeName}", which Fleet runs as "${fleetName}" and fills in when the manifest is applied.`);
                     continue;
                 }
             }

package/dist/dburl.js

@@ -1,5 +1,5 @@
 /**
- * The connection URL Fleet will inject for a managed database.
+ * Recognising a connection string that names a managed database.
  *
  * `uses: [db]` gives a service DATABASE_URL and friends. An imported compose
  * file usually has its own variable for the same thing — MONGODB_URI,
@@ -15,35 +15,6 @@
  * in the control plane that reads this file and fails when the two disagree,
  * which is the only thing that makes duplicating it acceptable.
  */
-/** Mirrors ENGINES in control-plane/src/manifest/databases.ts. */
-export const ENGINE_WIRE = {
-    postgres: { scheme: 'postgres', port: 5432, defaultUser: 'postgres', usesPassword: true, usesDatabase: true },
-    mysql: { scheme: 'mysql', port: 3306, defaultUser: 'app', usesPassword: true, usesDatabase: true },
-    mariadb: { scheme: 'mysql', port: 3306, defaultUser: 'app', usesPassword: true, usesDatabase: true },
-    redis: { scheme: 'redis', port: 6379, defaultUser: '', usesPassword: false, usesDatabase: false },
-    mongo: { scheme: 'mongodb', port: 27017, defaultUser: 'app', usesPassword: true, usesDatabase: true },
-};
-/** Mirrors passwordRefFor: the secret name a database's password lives under. */
-export const passwordRefFor = (name) => `${name.toUpperCase().replace(/[^A-Z0-9]+/g, '_')}_PASSWORD`;
-/**
- * The URL a service will see, written the way the manifest can carry it.
- *
- * The password is a `${secret:NAME}` reference rather than a value: it is
- * generated by the control plane and never known here, and a manifest is a
- * file people commit.
- */
-export function injectedUrl(dbName, engine) {
-    const spec = ENGINE_WIRE[engine];
-    if (!spec)
-        return null;
-    const auth = spec.usesPassword
-        ? `${encodeURIComponent(spec.defaultUser)}:\${secret:${passwordRefFor(dbName)}}@`
-        : '';
-    // `database` defaults to the declaration's own name, and the host is that
-    // same name: containers resolve each other by service name on the node.
-    const path = spec.usesDatabase ? `/${dbName}` : '';
-    return `${spec.scheme}://${auth}${dbName}:${spec.port}${path}`;
-}
 /** Does this value look like a connection URL aimed at `host`? */
 export function pointsAt(value, host) {
     // Scheme-relative on purpose: an app may hold a mongodb+srv:// or a

package/dist/index.js

@@ -27,6 +27,7 @@ const GROUPS = [
             ['apply [file]', 'Apply a fleet.yaml to the fleet'],
             ['deploy <service>', 'Build, schedule, and roll out'],
             ['explain <service>', 'Read a failed deploy and say what to do about it'],
+            ['diagnose "<question>"', 'Investigate why something is wrong, and cite what it looked at'],
         ],
     ],
     [
@@ -37,6 +38,7 @@ const GROUPS = [
             ['services', 'List services and where they are running'],
             ['nodes', 'List nodes'],
             ['where <service>', 'Explain where a service would be placed, and why'],
+            ['tune', 'Compare each reservation with the memory the service actually used'],
             ['deployments <service>', 'Deployment history'],
             ['logs <service> --follow', 'Follow the latest agent-reported container tail'],
             ['events', 'Unified event timeline'],

package/dist/tune.js

@@ -0,0 +1,61 @@
+/**
+ * What a service should reserve, from what it has been seen using.
+ *
+ * `fleet init` writes `resources: { ram: 512Mi }` because 512Mi is a round
+ * number and nothing in a repository says otherwise. Measured on the fleet this
+ * was written for: a steady 60MB and 20MB against exactly that reservation. The
+ * scheduler plans capacity around the number in the manifest for the life of
+ * the service, so the gap is invisible on one node and is the difference
+ * between a service fitting and `no_eligible_node` on a fleet where it matters.
+ *
+ * The judgement lives here rather than in the command so both outcomes can be
+ * tested without a control plane — and the outcome that matters is the refusal,
+ * which a fleet with weeks of history never produces.
+ */
+/**
+ * How long a service must have been watched before its peak means anything.
+ *
+ * A service observed for four minutes has not been observed; it has been
+ * glanced at. Nothing that runs a nightly job, or serves a morning, has shown
+ * its peak yet, and advising a reservation from that is how a tuned fleet
+ * starts OOM-killing at 3am.
+ */
+export const MIN_OBSERVATION_HOURS = 24;
+/**
+ * Headroom over the observed peak.
+ *
+ * Double, which is generous, and deliberately so. The cost of too much headroom
+ * is capacity the scheduler reserves and does not use; the cost of too little
+ * is the kernel killing a container in production. Those are not symmetric, and
+ * a tool that trims to the bone the first time it is run does not get run twice.
+ */
+const HEADROOM = 2;
+/** Reservations are read by people. 118 is a measurement; 128 is a decision. */
+function round(mb) {
+    const steps = [64, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096];
+    return steps.find((s) => s >= mb) ?? Math.ceil(mb / 1024) * 1024;
+}
+export function tuneRam(svc, now = Date.now()) {
+    if (svc.observedRamPeakMb === null || !svc.observedRamSince) {
+        return { verdict: 'no-data', name: svc.name };
+    }
+    const hours = (now - new Date(svc.observedRamSince).getTime()) / 3_600_000;
+    if (hours < MIN_OBSERVATION_HOURS) {
+        return { verdict: 'too-soon', name: svc.name, hours: Math.max(0, Math.round(hours * 10) / 10) };
+    }
+    const peak = svc.observedRamPeakMb;
+    // Near its limit. Not a saving, and worth saying out loud: the reservation is
+    // also the container's hard limit, so a service peaking at four fifths of it
+    // is one traffic spike from being killed.
+    if (peak >= svc.requestRamMb * 0.8) {
+        return { verdict: 'tight', name: svc.name, peak, requestRamMb: svc.requestRamMb };
+    }
+    const want = round(peak * HEADROOM);
+    if (want >= svc.requestRamMb)
+        return { verdict: 'fits', name: svc.name, peak };
+    return { verdict: 'advise', name: svc.name, from: svc.requestRamMb, to: want, peak };
+}
+/** Megabytes as a manifest writes them. */
+export function asQuantity(mb) {
+    return mb % 1024 === 0 ? `${mb / 1024}Gi` : `${mb}Mi`;
+}

package/package.json

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