@yadurajfleetos/cli 0.1.0

package/README.md

@@ -0,0 +1,86 @@
+# Fleet OS CLI (`fleet`)
+
+The command-line interface for **Fleet OS** — git-push deploys onto hardware you already own.
+
+## Installation
+
+### Via npm (Global)
+```bash
+npm install -g @yadurajfleetos/cli
+```
+
+### Run Directly via npx
+```bash
+npx @yadurajfleetos/cli --help
+```
+
+### Build and Install from Source
+```bash
+git clone https://github.com/YadurajManu/BhaiMerra.git fleet-os
+cd fleet-os/cli
+npm install
+npm run build
+npm link
+```
+
+---
+
+## Quick Start
+
+### 1. Sign In
+```bash
+# Hosted control plane (default: https://fleetapi.plastikworld.xyz)
+fleet auth login
+
+# Self-hosted control plane
+fleet auth login --api https://fleetapi.example.com
+```
+
+### 2. Pair a Machine
+```bash
+fleet nodes pair
+```
+Run the generated `curl -fsSL ... | sh` command on the machine you want to add to your fleet.
+
+### 3. Check Fleet Status & Health
+```bash
+fleet status
+fleet doctor
+```
+
+### 4. Deploy a Service
+```bash
+# Validate manifest
+fleet validate
+
+# Apply services to fleet
+fleet apply
+
+# Plan and deploy a service
+fleet deploy web
+```
+
+---
+
+## Command Reference
+
+| Command | Description |
+| :--- | :--- |
+| `fleet auth login` | Sign in and save secure local session |
+| `fleet config show` | Show active control plane and selected fleet |
+| `fleet use <fleet>` | Choose default fleet |
+| `fleet nodes pair` | Generate single-use pairing token for a new node |
+| `fleet nodes` | List nodes, status, and resource usage |
+| `fleet doctor` | Diagnostic health check across cluster |
+| `fleet apply [file]` | Apply `fleet.yaml` manifest |
+| `fleet deploy <svc>` | Plan, build, schedule, and roll out a service |
+| `fleet logs <svc> -f` | Follow live container logs |
+| `fleet restart <svc>` | Restart a service |
+| `fleet rollback <svc>` | Roll back to previous deployment |
+| `fleet where <svc>` | Explain scheduler placement and candidate scores |
+
+---
+
+## License
+
+MIT License.

package/dist/api.js

@@ -0,0 +1,97 @@
+import { loadProfile, saveProfile } from './config.js';
+export class CliError extends Error {
+    exitCode;
+    detail;
+    constructor(message, exitCode = 1, detail) {
+        super(message);
+        this.exitCode = exitCode;
+        this.detail = detail;
+    }
+}
+/** Exit codes are a contract; scripts branch on them (docs/cli reference). */
+export const EXIT = {
+    ok: 0,
+    failure: 1,
+    usage: 2,
+    noEligibleNode: 3,
+    healthCheckFailed: 4,
+};
+export async function request(method, path, opts = {}) {
+    const profile = opts.profile ?? (await loadProfile());
+    if (!profile.api) {
+        throw new CliError('No control plane URL is configured. Run `fleet auth login --api https://your-api-host` or set FLEET_API.', EXIT.usage);
+    }
+    if (opts.auth !== false && !profile.accessToken) {
+        throw new CliError('Not signed in. Run `fleet auth login` first.', EXIT.usage);
+    }
+    const send = async (token) => fetch(profile.api.replace(/\/+$/, '') + path, {
+        method,
+        headers: {
+            ...(token ? { authorization: `Bearer ${token}` } : {}),
+            ...(opts.body ? { 'content-type': 'application/json' } : {}),
+        },
+        body: opts.body ? JSON.stringify(opts.body) : undefined,
+        signal: AbortSignal.timeout(20 * 60_000),
+    });
+    let res;
+    try {
+        res = await send(profile.accessToken);
+    }
+    catch (err) {
+        throw new CliError(`Could not reach ${profile.api}. Is the control plane running?\n  ${String(err)}`, EXIT.failure);
+    }
+    // Access tokens are short-lived; refresh once and retry rather than making
+    // the user log in again mid-command.
+    if (res.status === 401) {
+        if (profile.refreshToken) {
+            try {
+                const refreshed = await fetch(profile.api.replace(/\/+$/, '') + '/auth/refresh', {
+                    method: 'POST',
+                    headers: { 'content-type': 'application/json' },
+                    body: JSON.stringify({ refreshToken: profile.refreshToken }),
+                    signal: AbortSignal.timeout(15_000),
+                });
+                if (refreshed.ok) {
+                    const tokens = (await refreshed.json());
+                    await saveProfile({ ...profile, ...tokens });
+                    res = await send(tokens.accessToken);
+                }
+            }
+            catch {
+                // Fall through to a deliberate, actionable session-expired message.
+                // A network error while refreshing must not turn into a misleading
+                // "invalid token" response from the original request.
+            }
+        }
+        if (res.status === 401) {
+            throw new CliError('Your Fleet session has expired. Run `fleet auth login` to sign in again.', EXIT.usage);
+        }
+    }
+    const text = await res.text();
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        body = text;
+    }
+    if (res.status >= 400) {
+        const err = body.error;
+        throw new CliError(err?.message ?? `Request failed (${res.status})`, err?.code === 'no_eligible_node' ? EXIT.noEligibleNode : EXIT.failure, err?.detail);
+    }
+    return { status: res.status, body: body };
+}
+export async function requireFleet(explicit) {
+    if (explicit)
+        return explicit;
+    const profile = await loadProfile();
+    if (profile.fleetId)
+        return profile.fleetId;
+    const { body } = await request('GET', '/fleets');
+    if (body.fleets.length === 1)
+        return body.fleets[0].id;
+    if (!body.fleets.length)
+        throw new CliError('You have no fleets yet.', EXIT.usage);
+    throw new CliError(`You are in several fleets. Pass --fleet <id> or run \`fleet use <name>\`:\n` +
+        body.fleets.map((f) => `  ${f.name}  ${f.id}`).join('\n'), EXIT.usage);
+}

package/dist/args.js

@@ -0,0 +1,27 @@
+/**
+ * Minimal argument parser: no dependency, and the flag set is small and
+ * stable. Lives apart from the entrypoint so it can be tested without the
+ * entrypoint running.
+ */
+export function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith('-')) {
+            positional.push(arg);
+            continue;
+        }
+        const name = arg.replace(/^--?/, '');
+        const next = argv[i + 1];
+        // A flag followed by a non-flag takes it as a value; otherwise boolean.
+        if (next !== undefined && !next.startsWith('-')) {
+            flags[name] = next;
+            i++;
+        }
+        else {
+            flags[name] = true;
+        }
+    }
+    return { positional, flags };
+}

package/dist/commands/alerts.js

@@ -0,0 +1,53 @@
+import { request, requireFleet, CliError, EXIT } from '../api.js';
+import { c, table } from '../render.js';
+export const alertsCommand = {
+    async run(args, flags) {
+        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        const [sub] = args;
+        if (!sub || sub === 'ls' || sub === 'list') {
+            const { body } = await request('GET', `/fleets/${fleetId}/alert-rules`);
+            if (flags.json)
+                return console.log(JSON.stringify(body.rules, null, 2));
+            if (!body.rules.length) {
+                console.log('No alert rules. Failover will happen silently — add one with `fleet alerts add`.');
+                return;
+            }
+            console.log(table(['channel', 'target', 'events', 'enabled'], body.rules.map((r) => [
+                r.channelType,
+                r.target,
+                r.eventTypes.length ? r.eventTypes.join(', ') : c.dim('everything'),
+                r.enabled ? c.green('yes') : c.dim('no'),
+            ])));
+            return;
+        }
+        if (sub === 'add') {
+            const channelType = typeof flags.channel === 'string' ? flags.channel : 'webhook';
+            const url = typeof flags.url === 'string' ? flags.url : undefined;
+            const to = typeof flags.to === 'string' ? flags.to : undefined;
+            const secret = typeof flags.secret === 'string' ? flags.secret : undefined;
+            const eventTypes = typeof flags.events === 'string' ? flags.events.split(',').map((s) => s.trim()) : [];
+            if (!url && !to) {
+                throw new CliError('usage: fleet alerts add --channel webhook|discord|slack --url <url> [--secret <s>]\n' +
+                    '       fleet alerts add --channel email --to you@example.com', EXIT.usage);
+            }
+            await request('POST', `/fleets/${fleetId}/alert-rules`, {
+                body: { channelType, url, to, secret, eventTypes },
+            });
+            console.log(`${c.green('added')} ${channelType} alert rule`);
+            console.log(c.dim('  verify it with `fleet alerts test` before you need it'));
+            return;
+        }
+        if (sub === 'test') {
+            const { body } = await request('POST', `/fleets/${fleetId}/alert-rules/test`);
+            if (!body.results.length)
+                return console.log('no alert rules to test');
+            for (const r of body.results) {
+                console.log(r.ok ? `${c.green('ok')}    ${r.channel}` : `${c.red('fail')}  ${r.channel}  ${r.error}`);
+            }
+            if (body.delivered !== body.results.length)
+                process.exit(EXIT.failure);
+            return;
+        }
+        throw new CliError('usage: fleet alerts [ls|add|test]', EXIT.usage);
+    },
+};

package/dist/commands/auth.js

@@ -0,0 +1,101 @@
+import { createInterface } from 'node:readline/promises';
+import { request, CliError, EXIT } from '../api.js';
+import { loadProfile, saveProfile, configLocation } from '../config.js';
+import { c, keyValues } from '../render.js';
+import { banner } from '../mark.js';
+import { glyph, rule, task } from '../ui.js';
+async function prompt(question, silent = false) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    if (!silent) {
+        const answer = await rl.question(question);
+        rl.close();
+        return answer.trim();
+    }
+    // Passwords must not land in the terminal scrollback or a screen recording.
+    const stdout = process.stdout;
+    process.stdout.write(question);
+    const rlAny = rl;
+    rlAny._writeToOutput = () => { };
+    const answer = await rl.question('');
+    rl.close();
+    process.stdout.write('\n');
+    void stdout;
+    return answer.trim();
+}
+async function requiredPrompt(label, opts = {}) {
+    if (opts.hint)
+        console.log(c.dim(`  ${opts.hint}`));
+    const value = await prompt(`  ${c.dim(label.padEnd(18))}`, opts.silent);
+    if (!value)
+        throw new CliError(`${label.trim()} is required.`, EXIT.usage);
+    return value;
+}
+function validApi(value) {
+    try {
+        const url = new URL(value);
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new Error('scheme');
+        return url.toString().replace(/\/+$/, '');
+    }
+    catch {
+        throw new CliError('Control plane URL must begin with http:// or https://', EXIT.usage);
+    }
+}
+export const authCommand = {
+    async run(args, flags) {
+        const [sub] = args;
+        const profile = await loadProfile();
+        if (typeof flags.api === 'string')
+            profile.api = flags.api;
+        switch (sub) {
+            case 'login': {
+                const interactive = !flags.email && !flags.password;
+                if (interactive) {
+                    console.log(banner('secure control-plane sign in'));
+                    console.log(`\n${rule('sign in')}`);
+                }
+                if (!profile.api) {
+                    profile.api = validApi(await requiredPrompt('control plane URL', {
+                        hint: 'Example: https://fleetapi.yourdomain.com',
+                    }));
+                }
+                if (interactive) {
+                    console.log(`${c.dim('  control plane      ')}${c.cyan(profile.api)}`);
+                    console.log();
+                }
+                const email = (typeof flags.email === 'string' ? flags.email : '') ||
+                    (await requiredPrompt('email'));
+                const password = (typeof flags.password === 'string' ? flags.password : '') ||
+                    (await requiredPrompt('password', { silent: true, hint: 'Password is hidden while you type.' }));
+                const body = await task('verifying credentials', async () => (await request('POST', '/auth/login', { body: { email, password }, auth: false, profile })).body, { hints: ['the control plane never stores your password in this CLI'] });
+                await saveProfile({
+                    ...profile,
+                    accessToken: body.accessToken,
+                    refreshToken: body.refreshToken,
+                });
+                console.log(`\n${glyph.ok} ${c.signal('signed in')}  ${body.user.email}`);
+                console.log(c.dim(`  profile saved to ${configLocation()}`));
+                console.log(c.dim('  next: fleet status'));
+                return;
+            }
+            case 'logout': {
+                await saveProfile({ api: profile.api });
+                console.log('signed out');
+                return;
+            }
+            case 'whoami': {
+                const { body } = await request('GET', '/auth/me', { profile });
+                if (flags.json)
+                    return console.log(JSON.stringify(body, null, 2));
+                console.log(keyValues([
+                    ['email', body.user.email],
+                    ['control plane', profile.api],
+                    ...body.orgs.map((o) => [o.orgName, `${o.role} · ${o.plan}`]),
+                ]));
+                return;
+            }
+            default:
+                throw new CliError('usage: fleet auth login|logout|whoami', EXIT.usage);
+        }
+    },
+};

package/dist/commands/config.js

@@ -0,0 +1,51 @@
+import { CliError, EXIT, request } from '../api.js';
+import { loadProfile, saveProfile } from '../config.js';
+import { c, keyValues } from '../render.js';
+import { glyph, rule, task } from '../ui.js';
+/** Keep credentials out of normal command output and screen recordings. */
+function profileRows(profile) {
+    return [
+        ['control plane', profile.api || c.yellow('not configured')],
+        ['fleet', profile.fleetName ?? profile.fleetId ?? c.yellow('not selected')],
+        ['signed in', profile.accessToken ? c.green('yes') : c.yellow('no')],
+    ];
+}
+export const configCommand = {
+    async run(args, flags) {
+        const [sub = 'show'] = args;
+        if (sub !== 'show')
+            throw new CliError('usage: fleet config show', EXIT.usage);
+        const profile = await loadProfile();
+        if (flags.json) {
+            return console.log(JSON.stringify({
+                api: profile.api || null,
+                fleetId: profile.fleetId ?? null,
+                fleetName: profile.fleetName ?? null,
+                signedIn: Boolean(profile.accessToken),
+            }, null, 2));
+        }
+        console.log(keyValues(profileRows(profile)));
+    },
+};
+export const useCommand = {
+    async run(args, flags) {
+        const [target] = args;
+        if (!target)
+            throw new CliError('usage: fleet use <fleet-name-or-id>', EXIT.usage);
+        const profile = await loadProfile();
+        const fleets = await task('finding fleets you can access', async () => (await request('GET', '/fleets')).body.fleets);
+        const matches = fleets.filter((fleet) => fleet.id === target || fleet.id.startsWith(target) || fleet.name === target);
+        if (!matches.length) {
+            throw new CliError(`No fleet called "${target}". Available: ${fleets.map((fleet) => fleet.name).join(', ') || 'none'}`, EXIT.usage);
+        }
+        if (matches.length > 1) {
+            throw new CliError(`"${target}" is ambiguous. Use one of:\n${matches.map((f) => `  ${f.name}  ${f.id}`).join('\n')}`, EXIT.usage);
+        }
+        const fleet = matches[0];
+        await saveProfile({ ...profile, fleetId: fleet.id, fleetName: fleet.name });
+        if (flags.json)
+            return console.log(JSON.stringify({ fleet }, null, 2));
+        console.log(`${glyph.ok} using ${c.signal(fleet.name)}  ${c.dim(`${fleet.role} · ${fleet.id}`)}`);
+    },
+};
+export { profileRows };

package/dist/commands/doctor.js

@@ -0,0 +1,141 @@
+import { CliError, EXIT, request, requireFleet } from '../api.js';
+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;
+async function reach(url) {
+    try {
+        const response = await fetch(url, { redirect: 'manual', signal: AbortSignal.timeout(8_000) });
+        return response.status >= 200 && response.status < 400
+            ? { ok: true, detail: `HTTPS answered ${response.status}` }
+            : { ok: false, detail: `HTTPS answered ${response.status}` };
+    }
+    catch (error) {
+        return { ok: false, detail: error instanceof Error ? error.message : String(error) };
+    }
+}
+/**
+ * A candid, read-only diagnosis. A check is never marked healthy merely
+ * because Fleet lacks enough telemetry to prove it — that is a warning with
+ * the next concrete product capability stated plainly.
+ */
+export const doctorCommand = {
+    async run(_args, flags) {
+        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([
+                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'),
+            ]);
+            const deploymentHistory = await Promise.all(services.body.services.map(async (service) => ({
+                service,
+                deployments: (await request('GET', `/services/${service.id}/deployments`)).body.deployments,
+            })));
+            const urls = services.body.services
+                .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 };
+        });
+        const checks = [
+            { state: 'ok', label: 'control plane', detail: profile.api },
+            { state: 'ok', label: 'signed in', detail: result.identity.user.email },
+            { state: 'ok', label: 'fleet access', detail: `${result.fleet.fleet.name} · ${result.fleet.role}` },
+        ];
+        if (!result.nodes.length) {
+            checks.push({ state: 'fail', label: 'nodes', detail: 'No nodes are paired.', remedy: 'Run `fleet nodes pair`, then run the printed command on a machine you own.' });
+        }
+        else {
+            const offline = result.nodes.filter((node) => node.status === 'offline' || !node.live);
+            const cordoned = result.nodes.filter((node) => node.status === 'cordoned');
+            const versions = new Set(result.nodes.map((node) => node.agentVersion).filter(Boolean));
+            checks.push({
+                state: offline.length ? 'fail' : cordoned.length ? 'warn' : 'ok',
+                label: 'nodes',
+                detail: offline.length
+                    ? `${offline.map((node) => `${node.name} (${relativeTime(node.lastHeartbeatAt)})`).join(', ')} not reporting`
+                    : cordoned.length
+                        ? `${result.nodes.length} paired; ${cordoned.map((node) => node.name).join(', ')} cordoned`
+                        : `${result.nodes.length} paired and reporting`,
+                remedy: offline.length ? 'Check the agent service and its outbound connection, then run `fleet doctor` again.' : undefined,
+            });
+            checks.push({
+                state: versions.size > 1 ? 'warn' : 'ok',
+                label: 'agent versions',
+                detail: versions.size ? [...versions].join(', ') : 'agent version not reported',
+                remedy: versions.size > 1 ? 'Update nodes so all agents run the same compatible release.' : undefined,
+            });
+            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;
+                // 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
+                // check until the agent resumes.
+                if (!node.live || !node.telemetry) {
+                    checks.push({
+                        state: 'warn',
+                        label: `runtime ${node.name}`,
+                        detail: 'Unavailable because this node is not reporting a current heartbeat.',
+                        remedy: 'Restart the agent, then run `fleet doctor` again for live Docker, registry, and disk checks.',
+                    });
+                    continue;
+                }
+                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 });
+                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.' });
+            }
+        }
+        const failed = result.deploymentHistory.flatMap(({ service, deployments }) => deployments.filter((deployment) => deployment.status === 'failed' || deployment.failureReason).slice(0, 1).map((deployment) => ({ service: service.name, deployment })));
+        checks.push(failed.length
+            ? {
+                state: 'fail',
+                label: 'deployments',
+                detail: failed.map(({ service, deployment }) => `${service}: ${deployment.failureReason ?? deployment.status}`).join('; '),
+                remedy: 'Run `fleet deployments <service>` for history and `fleet logs <service> --follow` for the current container tail.',
+            }
+            : { state: 'ok', label: 'deployments', detail: result.services.length ? 'No recorded deployment failures.' : 'No services declared yet.' });
+        if (!result.ingress.length) {
+            checks.push({ state: 'warn', label: 'ingress', detail: 'No public service hostname is configured yet.' });
+        }
+        else {
+            for (const service of result.ingress) {
+                checks.push({
+                    state: service.ok ? 'ok' : 'fail',
+                    label: `HTTPS ${service.name}`,
+                    detail: service.detail,
+                    remedy: service.ok ? undefined : 'Check the node is online, its advertised address is reachable, and the ingress domain resolves to this control plane.',
+                });
+            }
+        }
+        checks.push(result.github.configured && !result.github.error
+            ? { state: 'ok', label: 'GitHub App', detail: `${result.github.installations?.length ?? 0} installation(s) available` }
+            : {
+                state: 'warn',
+                label: 'GitHub App',
+                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({ 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));
+        console.log(`\n${rule(`doctor · ${result.fleet.fleet.name}`)}`);
+        for (const check of checks) {
+            console.log(`${icon(check.state)} ${c.bold(check.label.padEnd(18))} ${check.detail}`);
+            if (check.remedy)
+                console.log(`  ${c.dim(check.remedy)}`);
+        }
+        const failing = checks.filter((check) => check.state === 'fail').length;
+        const warnings = checks.filter((check) => check.state === 'warn').length;
+        console.log(`\n${failing ? c.red(`${failing} failed`) : c.green('no blocking failures')}${warnings ? c.dim(` · ${warnings} needs attention`) : ''}`);
+        if (failing)
+            process.exitCode = EXIT.failure;
+    },
+};

package/dist/commands/down.js

@@ -0,0 +1,50 @@
+/**
+ * fleet down <service> — cleanly stops and tears down a running service deployment.
+ *
+ * Marks active deployments as stopped and instructs the assigned node agent
+ * to unassign and remove the container on its next reconciliation cycle.
+ */
+import { request, requireFleet, CliError, EXIT } from '../api.js';
+import { c } from '../render.js';
+import { glyph } from '../ui.js';
+async function confirmTeardown(name) {
+    if (!process.stdin.isTTY)
+        return true;
+    const { createInterface } = await import('node:readline/promises');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const ans = await rl.question(`  Stop and tear down ${c.bold(name)}? [y/N] `);
+        return ans.trim().toLowerCase() === 'y';
+    }
+    finally {
+        rl.close();
+    }
+}
+export const downCommand = {
+    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 down <service> [--yes]', EXIT.usage);
+        const { body: listBody } = await request('GET', `/fleets/${fleetId}/services`);
+        const service = listBody.services.find((s) => s.name === name || s.id === name);
+        if (!service) {
+            throw new CliError(`No service called "${name}". Known: ${listBody.services.map((s) => s.name).join(', ') || 'none'}`, EXIT.usage);
+        }
+        if (!flags.yes && !flags.y && !(await confirmTeardown(service.name))) {
+            console.log(c.dim('Teardown cancelled.'));
+            return;
+        }
+        const { body } = await request('POST', `/services/${service.id}/stop`, { body: {} });
+        if (flags.json)
+            return console.log(JSON.stringify(body, null, 2));
+        if (body.stopped === 0) {
+            console.log(`${glyph.info} ${body.message ?? `"${service.name}" is not currently running.`}`);
+            return;
+        }
+        console.log(`${glyph.ok} ${c.yellow('stopped')}  ${c.bold(service.name)}`);
+        if (body.note) {
+            console.log(c.dim(`  ${body.note}`));
+        }
+    },
+};

package/dist/commands/index.js

@@ -0,0 +1,34 @@
+import { authCommand } from './auth.js';
+import { nodesCommand } from './nodes.js';
+import { statusCommand, eventsCommand } from './status.js';
+import { alertsCommand } from './alerts.js';
+import { configCommand, useCommand } from './config.js';
+import { doctorCommand } from './doctor.js';
+import { upCommand } from './up.js';
+import { openCommand } from './open.js';
+import { downCommand } from './down.js';
+import { applyCommand, deployCommand, deploymentsCommand, initCommand, logsCommand, restartCommand, rollbackCommand, rescheduleCommand, servicesCommand, validateCommand, whereCommand, } from './services.js';
+export const commands = {
+    up: upCommand,
+    open: openCommand,
+    down: downCommand,
+    auth: authCommand,
+    config: configCommand,
+    use: useCommand,
+    doctor: doctorCommand,
+    init: initCommand,
+    validate: validateCommand,
+    apply: applyCommand,
+    status: statusCommand,
+    nodes: nodesCommand,
+    services: servicesCommand,
+    deploy: deployCommand,
+    where: whereCommand,
+    reschedule: rescheduleCommand,
+    deployments: deploymentsCommand,
+    logs: logsCommand,
+    restart: restartCommand,
+    rollback: rollbackCommand,
+    events: eventsCommand,
+    alerts: alertsCommand,
+};