@yadurajfleetos/cli 0.1.0

package/dist/commands/nodes.js

@@ -0,0 +1,76 @@
+import { request, requireFleet, CliError, EXIT } from '../api.js';
+import { c, table, statusColour, relativeTime, mb } from '../render.js';
+export const nodesCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [sub, target] = args;
+        if (!sub || sub === 'ls' || sub === 'list') {
+            const { body } = await request('GET', `/fleets/${fleetId}/nodes`);
+            if (flags.json)
+                return console.log(JSON.stringify(body.nodes, null, 2));
+            if (!body.nodes.length) {
+                console.log('No nodes yet. Run `fleet nodes pair` to add one.');
+                return;
+            }
+            console.log(table(['name', 'arch', 'tier', 'cpu', 'ram', 'services', 'seen', 'status'], body.nodes.map((n) => [
+                n.name,
+                n.arch,
+                n.reliabilityTier,
+                n.telemetry ? `${Math.round(n.telemetry.cpuPct)}%` : c.dim('—'),
+                n.telemetry ? `${mb(n.telemetry.ramUsedMb)}/${mb(n.ramMb)}` : mb(n.ramMb),
+                String(n.telemetry?.containers.length ?? 0),
+                relativeTime(n.lastHeartbeatAt),
+                statusColour(n.status),
+            ])));
+            return;
+        }
+        if (sub === 'pair') {
+            const { body } = await request('POST', `/fleets/${fleetId}/nodes/pair-token`, 
+            // Fastify requires a recognised media type for a POST. Supplying an
+            // explicit empty JSON object keeps this body-less operation portable
+            // through proxies and avoids Node fetch's implicit text/plain type.
+            { body: {} });
+            if (flags.json)
+                return console.log(JSON.stringify(body, null, 2));
+            console.log(`Run this on the machine you want to add:\n`);
+            console.log(`  ${c.cyan(body.install_command)}\n`);
+            console.log(c.dim(`The token is single-use and expires ${relativeTime(body.expires_at)}.`));
+            return;
+        }
+        if (sub === 'cordon' || sub === 'uncordon') {
+            if (!target)
+                throw new CliError(`usage: fleet nodes ${sub} <name>`, EXIT.usage);
+            const node = await findNode(fleetId, target);
+            await request('POST', `/fleets/${fleetId}/nodes/${node.id}/cordon`, {
+                body: { cordoned: sub === 'cordon' },
+            });
+            console.log(sub === 'cordon'
+                ? `${node.name} cordoned — running services stay put, nothing new is scheduled here`
+                : `${node.name} is schedulable again`);
+            return;
+        }
+        if (sub === 'rm' || sub === 'remove') {
+            if (!target)
+                throw new CliError('usage: fleet nodes rm <name>', EXIT.usage);
+            const node = await findNode(fleetId, target);
+            if (!flags.force && !flags.f) {
+                throw new CliError(`This revokes ${node.name}'s credentials and removes it from the fleet.\n` +
+                    `  Anything pinned to it will have nowhere to run. Re-run with --force if that is intended.`, EXIT.usage);
+            }
+            await request('DELETE', `/fleets/${fleetId}/nodes/${node.id}`);
+            console.log(`${node.name} removed and its agent credentials revoked`);
+            return;
+        }
+        throw new CliError('usage: fleet nodes [ls|pair|cordon|uncordon|rm]', EXIT.usage);
+    },
+};
+/** Names are what people type; ids are what the API wants. */
+async function findNode(fleetId, name) {
+    const { body } = await request('GET', `/fleets/${fleetId}/nodes`);
+    const match = body.nodes.find((n) => n.name === name || n.id === name || n.id.startsWith(name));
+    if (!match) {
+        throw new CliError(`No node called "${name}". Known nodes: ${body.nodes.map((n) => n.name).join(', ') || 'none'}`, EXIT.usage);
+    }
+    return match;
+}
+export { findNode };

package/dist/commands/open.js

@@ -0,0 +1,65 @@
+/**
+ * fleet open [service] — opens the deployed service in your default browser.
+ *
+ * Discovers the public HTTPS URL for the service and launches it via the
+ * platform's native opener (open on macOS, xdg-open on Linux, start on Windows).
+ */
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { request, requireFleet, CliError, EXIT } from '../api.js';
+import { c } from '../render.js';
+import { glyph } from '../ui.js';
+const execAsync = promisify(exec);
+async function openUrl(url) {
+    const platform = process.platform;
+    let cmd = '';
+    if (platform === 'darwin') {
+        cmd = `open "${url}"`;
+    }
+    else if (platform === 'win32') {
+        cmd = `start "" "${url}"`;
+    }
+    else {
+        cmd = `xdg-open "${url}"`;
+    }
+    try {
+        await execAsync(cmd);
+    }
+    catch (err) {
+        throw new CliError(`Could not open browser automatically: ${String(err)}`, EXIT.failure);
+    }
+}
+export const openCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [nameArg] = args;
+        const { body } = await request('GET', `/fleets/${fleetId}/services`);
+        if (!body.services.length) {
+            throw new CliError('No services in this fleet. Run `fleet up` to deploy one.', EXIT.usage);
+        }
+        let service;
+        if (nameArg) {
+            service = body.services.find((s) => s.name === nameArg || s.id === nameArg);
+            if (!service) {
+                throw new CliError(`No service called "${nameArg}". Known: ${body.services.map((s) => s.name).join(', ')}`, EXIT.usage);
+            }
+        }
+        else {
+            // If only one service exists, pick it. Otherwise ask user to specify.
+            if (body.services.length === 1) {
+                service = body.services[0];
+            }
+            else {
+                throw new CliError(`Multiple services available. Specify which to open:\n` +
+                    body.services.map((s) => `  fleet open ${s.name}`).join('\n'), EXIT.usage);
+            }
+        }
+        const rawUrl = service.domain ?? service.hostname;
+        if (!rawUrl) {
+            throw new CliError(`Service "${service.name}" does not have an assigned URL yet.`, EXIT.usage);
+        }
+        const url = rawUrl.startsWith('http') ? rawUrl : `https://${rawUrl}`;
+        console.log(`${glyph.ok} opening ${c.bold(service.name)} ${c.dim('→')} ${c.cyan(url)}`);
+        await openUrl(url);
+    },
+};

package/dist/commands/services.js

@@ -0,0 +1,365 @@
+import { readFile, writeFile, access } from 'node:fs/promises';
+import { join } from 'node:path';
+import { request, requireFleet, CliError, EXIT } from '../api.js';
+import { c, table, statusColour, keyValues, relativeTime, mb } from '../render.js';
+import { task, splash, glyph } from '../ui.js';
+const manifestPath = (given) => given ?? 'fleet.yaml';
+async function readManifest(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        throw new CliError(`No ${path} here. Run \`fleet init\` to scaffold one.`, EXIT.usage);
+    }
+}
+export const validateCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const manifest = await readManifest(manifestPath(args[0]));
+        const body = await task(`checking ${manifestPath(args[0])}`, async () => (await request('POST', `/fleets/${fleetId}/services/validate`, { body: { manifest } })).body);
+        if (flags.json)
+            return console.log(JSON.stringify(body, null, 2));
+        if (!body.valid) {
+            console.error(c.red(`${body.issues.length} problem(s) in ${manifestPath(args[0])}:\n`));
+            for (const issue of body.issues)
+                console.error(`  ${c.bold(issue.path)}\n    ${issue.message}`);
+            process.exit(EXIT.usage);
+        }
+        console.log(c.green('valid') + `  ${body.services.length} service(s)`);
+        console.log(table(['service', 'placement', 'ram'], body.services.map((s) => [s.name, s.placement, mb(s.ramMb)])));
+        for (const w of body.warnings ?? [])
+            console.log(`\n${c.yellow('warning')}  ${w}`);
+    },
+};
+export const applyCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const manifest = await readManifest(manifestPath(args[0]));
+        const body = await task(`applying ${manifestPath(args[0])}`, async () => (await request('POST', `/fleets/${fleetId}/services`, { body: { manifest } })).body, {
+            done: (b) => b.created.length || b.updated.length
+                ? `applied ${b.created.length + b.updated.length} service(s)`
+                : 'no changes',
+        });
+        if (flags.json)
+            return console.log(JSON.stringify(body, null, 2));
+        if (body.created.length)
+            console.log(`${glyph.ok} ${c.green('created')}  ${body.created.join(', ')}`);
+        if (body.updated.length)
+            console.log(`${glyph.ok} ${c.cyan('updated')}  ${body.updated.join(', ')}`);
+        for (const w of body.warnings)
+            console.log(`${glyph.warn} ${c.yellow('warning')}  ${w}`);
+        if (body.created.length)
+            console.log(c.dim(`\nnext: fleet deploy ${body.created[0]}`));
+    },
+};
+export const servicesCommand = {
+    async run(_args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const { body } = await request('GET', `/fleets/${fleetId}/services`);
+        if (flags.json)
+            return console.log(JSON.stringify(body.services, null, 2));
+        if (!body.services.length)
+            return console.log('No services. Run `fleet apply` with a fleet.yaml.');
+        console.log(table(['service', 'url', 'placement', 'node', 'sha', 'status'], body.services.map((s) => [
+            s.name + (s.persistentVolume ? c.dim(' ⛁') : ''),
+            s.domain ?? s.hostname ?? c.dim('—'),
+            s.placementPolicy,
+            s.current?.nodeName ?? c.dim('—'),
+            s.current?.gitSha?.slice(0, 7) ?? c.dim('—'),
+            s.current ? statusColour(s.current.status) : c.dim('not deployed'),
+        ])));
+    },
+};
+async function findService(fleetId, name) {
+    const { body } = await request('GET', `/fleets/${fleetId}/services`);
+    const match = body.services.find((s) => s.name === name || s.id === name);
+    if (!match) {
+        throw new CliError(`No service called "${name}". Known: ${body.services.map((s) => s.name).join(', ') || 'none'}`, EXIT.usage);
+    }
+    return match;
+}
+async function deployPlan(fleetId, service) {
+    return (await request('GET', `/services/${service.id}/placement-preview`)).body.decision;
+}
+function printPlan(service, plan, gitSha) {
+    console.log(`\n${c.bold(`Plan for ${service.name}`)}`);
+    if (plan.outcome !== 'placed' || !plan.nodeName) {
+        console.log(`${c.red('  placement')}    ${plan.summary ?? 'No eligible node'}`);
+        for (const rejected of plan.rejected)
+            console.log(`  ${c.dim(rejected.nodeName.padEnd(12))} ${rejected.detail}`);
+        return false;
+    }
+    const winner = plan.candidates[0];
+    const source = service.repoUrl
+        ? `${service.repoUrl}${gitSha ? ` · ${gitSha.slice(0, 12)}` : ''}`
+        : gitSha ? gitSha.slice(0, 12) : 'service definition';
+    const target = plan.nodeName;
+    const reason = winner
+        ? `highest eligible score (${winner.score.toFixed(3)}; headroom ${winner.breakdown.headroom.toFixed(2)}, load ${winner.breakdown.load.toFixed(2)})`
+        : 'eligible for this service';
+    const url = service.domain ?? service.hostname ?? 'assigned after scheduling';
+    console.log(`  ${c.dim('source'.padEnd(12))} ${source}`);
+    console.log(`  ${c.dim('target'.padEnd(12))} ${c.signal(target)}`);
+    console.log(`  ${c.dim('reason'.padEnd(12))} ${reason}`);
+    console.log(`  ${c.dim('URL'.padEnd(12))} ${url.startsWith('http') ? url : `https://${url}`}`);
+    return true;
+}
+async function confirmDeploy() {
+    if (!process.stdin.isTTY)
+        return true;
+    const { createInterface } = await import('node:readline/promises');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question('  Continue? [y/N] ')).trim().toLowerCase() === 'y';
+    }
+    finally {
+        rl.close();
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * The deploy request returns once the image exists and a node has been chosen.
+ * The container starting is the agent's job and happens afterwards, so the CLI
+ * follows it to conclusion rather than reporting "scheduled" and leaving the
+ * operator to guess.
+ */
+async function waitUntilRunning(fleetId, name, timeoutMs = 180_000) {
+    await task(`waiting for ${c.bold(name)} to come up`, async (s) => {
+        s.hints([
+            'the agent picks up desired state on its next poll',
+            'a cold image pull takes as long as the node\'s uplink does',
+            'this clears once the agent reports the container running',
+        ]);
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const current = await findService(fleetId, name)
+                .then((svc) => svc.current)
+                .catch(() => null);
+            if (current?.status === 'running')
+                return;
+            if (current?.status === 'failed') {
+                throw new CliError(`"${name}" did not start. \`fleet deployments ${name}\` has the reason.`, EXIT.healthCheckFailed);
+            }
+            await sleep(2000);
+        }
+        throw new CliError(`"${name}" was scheduled but has not reported running. \`fleet deployments ${name}\` has the detail.`, EXIT.healthCheckFailed);
+    }, { done: () => `${c.bold(name)} is running` });
+}
+export const deployCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [name] = args;
+        if (!name)
+            throw new CliError('usage: fleet deploy <service> [--sha <git-sha>] [--no-wait]', EXIT.usage);
+        const service = await findService(fleetId, name);
+        const gitSha = typeof flags.sha === 'string' ? flags.sha : undefined;
+        const plan = await task('checking deployment plan', async () => deployPlan(fleetId, service));
+        const viable = plan.outcome === 'placed' && Boolean(plan.nodeName);
+        if (!flags.json)
+            printPlan(service, plan, gitSha);
+        if (flags.json && (flags.plan || flags['dry-run'])) {
+            console.log(JSON.stringify({ service: service.name, gitSha: gitSha ?? null, plan }, null, 2));
+            return;
+        }
+        if (!viable) {
+            if (flags.json)
+                console.log(JSON.stringify({ service: service.name, gitSha: gitSha ?? null, plan }, null, 2));
+            process.exitCode = EXIT.noEligibleNode;
+            return;
+        }
+        if (flags.plan || flags['dry-run'])
+            return;
+        if (!flags.yes && !flags.y && !(await confirmDeploy())) {
+            console.log(c.dim('Deployment cancelled. Re-run with --yes to skip confirmation.'));
+            return;
+        }
+        const body = await splash(`deploying ${c.bold(service.name)}${gitSha ? c.dim(` at ${gitSha.slice(0, 7)}`) : ''}`, async () => (await request('POST', `/services/${service.id}/deploy`, { body: { gitSha } })).body, {
+            // What the request involves, not a stage it has reached — the call is a
+            // single synchronous POST and the CLI cannot see inside it.
+            hints: [
+                'scoring every online node on headroom, reliability and load',
+                'building for every architecture an eligible node runs',
+                'the first multi-arch build is the slow one; layers cache after it',
+                'pushing the image to the fleet registry',
+            ],
+            done: (b) => `built and scheduled onto ${c.bold(b.placedOn.name)} ${c.dim(`score ${b.score?.toFixed(3)}`)}`,
+        });
+        if (flags.json)
+            return console.log(JSON.stringify(body, null, 2));
+        for (const w of body.warnings ?? [])
+            console.log(`${glyph.warn} ${c.yellow('warning')}  ${w}`);
+        if (body.url)
+            console.log(`${glyph.info} ${c.cyan(body.url)}`);
+        if (!flags['no-wait'])
+            await waitUntilRunning(fleetId, service.name);
+    },
+};
+export const whereCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [name] = args;
+        if (!name)
+            throw new CliError('usage: fleet where <service>', EXIT.usage);
+        const service = await findService(fleetId, name);
+        const { body } = await request('GET', `/services/${service.id}/placement-preview`);
+        const d = body.decision;
+        if (flags.json)
+            return console.log(JSON.stringify(d, null, 2));
+        if (d.outcome !== 'placed') {
+            console.log(c.red('no eligible node'));
+            console.log(`  ${d.summary}\n`);
+            console.log(table(['node', 'why not'], d.rejected.map((r) => [r.nodeName, `${c.dim(r.code)}  ${r.detail}`])));
+            process.exit(EXIT.noEligibleNode);
+        }
+        console.log(`${c.green('would place on')} ${c.bold(d.nodeName)}\n`);
+        console.log(table(['node', 'score', 'headroom', 'reliability', 'load', 'free'], d.candidates.map((cand) => [
+            cand.nodeName,
+            cand.score.toFixed(4),
+            cand.breakdown.headroom.toFixed(3),
+            cand.breakdown.reliability.toFixed(2),
+            cand.breakdown.load.toFixed(2),
+            mb(cand.freeRamMb),
+        ])));
+        if (d.rejected.length) {
+            console.log(`\n${c.dim('not eligible:')}`);
+            for (const r of d.rejected)
+                console.log(`  ${r.nodeName}  ${c.dim(r.code)}  ${r.detail}`);
+        }
+    },
+};
+export const rescheduleCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [name] = args;
+        if (!name)
+            throw new CliError('usage: fleet reschedule <service>', EXIT.usage);
+        const service = await findService(fleetId, name);
+        const { body } = await request('POST', `/services/${service.id}/reschedule`);
+        console.log(`${c.green('moved')} ${service.name} → ${c.bold(body.movedTo.name)}`);
+    },
+};
+export const deploymentsCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [name] = args;
+        if (!name)
+            throw new CliError('usage: fleet deployments <service>', EXIT.usage);
+        const service = await findService(fleetId, name);
+        const { body } = await request('GET', `/services/${service.id}/deployments`);
+        if (flags.json)
+            return console.log(JSON.stringify(body.deployments, null, 2));
+        console.log(table(['when', 'sha', 'node', 'status', 'note'], body.deployments.map((d) => [
+            relativeTime(d.startedAt),
+            d.gitSha?.slice(0, 7) ?? c.dim('—'),
+            d.nodeName ?? c.dim('—'),
+            statusColour(d.status),
+            d.failureReason ?? '',
+        ])));
+    },
+};
+export const restartCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [name] = args;
+        if (!name)
+            throw new CliError('usage: fleet restart <service>', EXIT.usage);
+        const service = await findService(fleetId, name);
+        const { body } = await request('POST', `/services/${service.id}/restart`, { body: {} });
+        if (flags.json)
+            return console.log(JSON.stringify(body, null, 2));
+        console.log(`${glyph.ok} ${c.green('restart scheduled')}  ${service.name} ${c.dim(body.deployment.id.slice(0, 8))}`);
+        if (!flags['no-wait'])
+            await waitUntilRunning(fleetId, service.name);
+    },
+};
+export const rollbackCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [name, deploymentId] = args;
+        if (!name)
+            throw new CliError('usage: fleet rollback <service> [deployment-id]', EXIT.usage);
+        const service = await findService(fleetId, name);
+        if (!flags.yes && !flags.y && !(await confirmDeploy())) {
+            console.log(c.dim('Rollback cancelled.'));
+            return;
+        }
+        const { body } = await request('POST', `/services/${service.id}/rollback`, { body: deploymentId ? { deploymentId } : {} });
+        if (flags.json)
+            return console.log(JSON.stringify(body, null, 2));
+        console.log(`${glyph.ok} ${c.green('rollback scheduled')}  ${service.name} ← ${c.dim(body.rolledBackTo.slice(0, 8))}`);
+        if (!flags['no-wait'])
+            await waitUntilRunning(fleetId, service.name);
+    },
+};
+export const logsCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [name] = args;
+        if (!name)
+            throw new CliError('usage: fleet logs <service> [--follow] [--since 1h]', EXIT.usage);
+        const service = await findService(fleetId, name);
+        if (flags.since)
+            console.error(c.dim('note: agent log tails are live snapshots; --since is limited to the current retained tail.'));
+        let previous = '';
+        const render = async () => {
+            const { body } = await request('GET', `/services/${service.id}/logs`);
+            const next = body.lines.join('\n');
+            if (!next) {
+                if (body.diagnostic)
+                    console.log(c.yellow(`waiting: ${body.diagnostic}`));
+                return;
+            }
+            const output = next.startsWith(previous) ? next.slice(previous.length) : next;
+            if (output)
+                process.stdout.write(output + (output.endsWith('\n') ? '' : '\n'));
+            previous = next;
+        };
+        await render();
+        if (!flags.follow && !flags.f)
+            return;
+        if (!process.stdout.isTTY)
+            throw new CliError('--follow needs an interactive terminal', EXIT.usage);
+        while (true) {
+            await sleep(2000);
+            await render();
+        }
+    },
+};
+export const initCommand = {
+    async run(args, flags) {
+        const { detect, manifestTemplate } = await import('../detect.js');
+        const path = manifestPath(args[0]);
+        try {
+            await access(path);
+            throw new CliError(`${path} already exists — not overwriting it.`, EXIT.usage);
+        }
+        catch (err) {
+            if (err instanceof CliError)
+                throw err;
+        }
+        // Infer the service name from the directory, which is right often enough
+        // to be useful and obvious enough to correct when it is not.
+        const name = (typeof flags.name === 'string' ? flags.name : '') ||
+            process.cwd().split('/').pop()?.toLowerCase().replace(/[^a-z0-9-]+/g, '-') ||
+            'app';
+        const d = await detect();
+        // Write a Dockerfile if we generated one and none exists.
+        if (d.dockerfile) {
+            await writeFile(join(process.cwd(), 'Dockerfile'), d.dockerfile);
+            console.log(`${c.green('created')} Dockerfile  ${c.dim(`(${d.label}, port ${d.port})`)}`);
+        }
+        await writeFile(path, manifestTemplate(name, d));
+        console.log(`${c.green('created')} ${path}`);
+        if (d.framework === 'unknown' && !d.hasDockerfile) {
+            console.log(c.dim('  could not detect framework — using defaults. Edit fleet.yaml to tune.'));
+        }
+        else if (d.hasDockerfile) {
+            console.log(c.dim(`  using existing Dockerfile (detected EXPOSE ${d.port})`));
+        }
+        else {
+            console.log(c.dim(`  detected ${c.bold(d.label)} → optimised Dockerfile + manifest`));
+        }
+        console.log(`\nNext:\n  fleet validate\n  fleet apply\n  fleet deploy ${name}`);
+        console.log(c.dim(`\n  …or just run: fleet up`));
+    },
+};

package/dist/commands/status.js

@@ -0,0 +1,81 @@
+import { request, requireFleet } from '../api.js';
+import { c, table, statusColour, mb, relativeTime } from '../render.js';
+/**
+ * One screen that answers "is my fleet fine?" — the command people will run
+ * most, so it leads with what is wrong rather than burying it in a table.
+ */
+export const statusCommand = {
+    async run(_args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [map, events] = await Promise.all([
+            request('GET', `/fleets/${fleetId}/placement-map`),
+            request('GET', `/fleets/${fleetId}/events?limit=5`),
+        ]);
+        if (flags.json) {
+            return console.log(JSON.stringify({ nodes: map.body.nodes, events: events.body.events }, null, 2));
+        }
+        const nodes = map.body.nodes;
+        const offline = nodes.filter((n) => n.status === 'offline');
+        const pinnedDown = nodes.flatMap((n) => n.services.filter((s) => s.status === 'pinned_unavailable').map((s) => ({ node: n.name, service: s.name })));
+        if (!nodes.length) {
+            console.log('No nodes in this fleet yet.');
+            console.log(c.dim('  Run `fleet nodes pair` and install the agent on a machine you own.'));
+            return;
+        }
+        // Anything needing a human goes first, in the colour that says so.
+        if (pinnedDown.length) {
+            for (const p of pinnedDown) {
+                console.log(`${c.red('CRITICAL')}  ${c.bold(p.service)} is down and was not moved — pinned to ${p.node}`);
+            }
+            console.log();
+        }
+        else if (offline.length) {
+            console.log(`${c.yellow('degraded')}  ${offline.map((n) => n.name).join(', ')} offline\n`);
+        }
+        else {
+            console.log(`${c.green('healthy')}  ${nodes.length} node(s), all reporting\n`);
+        }
+        console.log(table(['node', 'arch', 'tier', 'free ram', 'load', 'services', 'status'], nodes.map((n) => [
+            n.name,
+            n.arch,
+            n.reliabilityTier,
+            `${mb(n.freeRamMb)}/${mb(n.ramMb)}`,
+            n.loadFactor === null ? c.dim('—') : `${Math.round(n.loadFactor * 100)}%`,
+            n.services.length
+                ? n.services
+                    .map((s) => s.status === 'pinned_unavailable' ? c.red(s.name) : s.policy === 'pinned' ? c.yellow(s.name) : s.name)
+                    .join(' ')
+                : c.dim('—'),
+            statusColour(n.status),
+        ])));
+        if (map.body.unplaced.length) {
+            console.log(`\n${c.yellow('unplaced')}  ${map.body.unplaced.join(', ')}`);
+        }
+        if (events.body.events.length) {
+            console.log(`\n${c.dim('recent')}`);
+            for (const e of events.body.events) {
+                const arrow = e.from ? `${e.from} → ${e.to}` : `→ ${e.to}`;
+                console.log(`  ${relativeTime(e.at).padEnd(9)} ${e.service.padEnd(12)} ${c.dim(e.reason)} ${arrow}`);
+            }
+        }
+    },
+};
+export const eventsCommand = {
+    async run(_args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const limit = typeof flags.limit === 'string' ? flags.limit : '30';
+        const { body } = await request('GET', `/fleets/${fleetId}/events?limit=${limit}`);
+        if (flags.json)
+            return console.log(JSON.stringify(body.events, null, 2));
+        if (!body.events.length)
+            return console.log('no events yet');
+        console.log(table(['when', 'service', 'reason', 'from', 'to', 'score'], body.events.map((e) => [
+            relativeTime(e.at),
+            e.service,
+            e.reason === 'failover' ? c.yellow(e.reason) : e.reason,
+            e.from ?? c.dim('—'),
+            e.to ?? c.dim('—'),
+            typeof e.detail?.score === 'number' ? e.detail.score.toFixed(3) : c.dim('—'),
+        ])));
+    },
+};