@yadurajfleetos/cli 0.6.0 → 0.7.0

package/dist/commands/index.js

@@ -10,7 +10,7 @@ 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, logsCommand, removeServiceCommand, restartCommand, rollbackCommand, rescheduleCommand, servicesCommand, validateCommand, whereCommand, } from './services.js';
+import { applyCommand, deployCommand, deploymentsCommand, initCommand, importCommand, explainCommand, logsCommand, removeServiceCommand, restartCommand, rollbackCommand, rescheduleCommand, servicesCommand, validateCommand, whereCommand, } from './services.js';
 export const commands = {
     up: upCommand,
     open: openCommand,
@@ -22,6 +22,7 @@ export const commands = {
     doctor: doctorCommand,
     init: initCommand,
     import: importCommand,
+    explain: explainCommand,
     validate: validateCommand,
     apply: applyCommand,
     status: statusCommand,

package/dist/commands/services.js

@@ -418,6 +418,15 @@ export const initCommand = {
             if (found.layout)
                 console.log(c.dim(`  ${found.layout}`));
             for (const s of found.services) {
+                // A manifest saying `build: ./web` against a directory with no
+                // Dockerfile is a deploy that fails at the first step. detect() has
+                // already worked out what the file should contain; writing it is the
+                // difference between a manifest and something that runs.
+                if (s.detection.dockerfile && !s.detection.hasDockerfile) {
+                    const target = join(process.cwd(), s.dir, 'Dockerfile');
+                    await writeFile(target, s.detection.dockerfile);
+                    console.log(`${c.green('created')} ${s.dir}/Dockerfile  ${c.dim(`(${s.detection.label}, port ${s.detection.port})`)}`);
+                }
                 console.log(c.dim(`  · ${s.name}  ${s.dir}  ${s.detection.label}`));
             }
             for (const db of found.databases) {
@@ -561,3 +570,78 @@ export const importCommand = {
         }
     },
 };
+/**
+ * Ask why a deployment failed.
+ *
+ * The wall of Docker output is still there underneath — this adds a reading of
+ * it, it does not replace the evidence. Printed at the moment of failure is the
+ * point; `fleet explain` exists for when you have come back to it later.
+ */
+export const explainCommand = {
+    async run(args, flags) {
+        const id = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+        let deploymentId = typeof flags.deploy === 'string' ? flags.deploy : '';
+        if (!deploymentId) {
+            const name = args[0];
+            if (!name)
+                throw new CliError('name a service, or pass --deploy <id>', EXIT.usage);
+            const service = await findService(id, name);
+            const { body } = await request('GET', `/services/${service.id}/deployments`);
+            // The most recent failure, which is what someone asking "why did that
+            // fail" means — not the most recent deployment, which may since have
+            // succeeded.
+            const failed = body.deployments.find((d) => d.status === 'failed');
+            if (!failed) {
+                throw new CliError(`"${name}" has no failed deployment to explain.`, EXIT.usage);
+            }
+            deploymentId = failed.id;
+        }
+        const out = await task('reading the failure', () => request('POST', `/fleets/${id}/deployments/${deploymentId}/explain`));
+        printExplanation(out.body);
+    },
+};
+/** Shared by `fleet explain` and by a deploy that just failed. */
+export function printExplanation(r) {
+    if (r.status === 'ok') {
+        console.log();
+        for (const line of wrapText(r.summary ?? '', 76))
+            console.log(`  ${line}`);
+        if (r.steps?.length) {
+            console.log();
+            r.steps.forEach((step, i) => console.log(`  ${c.dim(`${i + 1}.`)} ${step}`));
+        }
+        const seen = (r.hits ?? 1) > 1 ? `seen ${r.hits}× before` : 'first time this failure has been seen';
+        console.log(`\n  ${c.dim(`${r.cached ? 'cached' : 'explained'} · ${seen}`)}`);
+        if (r.usage)
+            console.log(`  ${c.dim(`${r.usage.used}/${r.usage.limit} explanations used today`)}`);
+        return;
+    }
+    if (r.status === 'rate_limited') {
+        const hours = Math.ceil((r.resetsInSec ?? 0) / 3600);
+        console.log(`\n  ${c.yellow('daily limit reached')} ${c.dim(`— ${r.limit} explanations a day, resets in ${hours}h.`)}`);
+        console.log(c.dim('  Answers already generated are still free to read.'));
+        return;
+    }
+    // disabled / not_worth_it / failed all carry a reason worth printing as-is.
+    if (r.reason)
+        console.log(`\n  ${c.dim(r.reason)}`);
+}
+/** Wrap to a width, on spaces, so a paragraph reads in a terminal. */
+function wrapText(text, width) {
+    const out = [];
+    for (const paragraph of text.split('\n')) {
+        let line = '';
+        for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+            if (line && line.length + word.length + 1 > width) {
+                out.push(line);
+                line = word;
+            }
+            else {
+                line = line ? `${line} ${word}` : word;
+            }
+        }
+        if (line)
+            out.push(line);
+    }
+    return out;
+}

package/dist/commands/up.js

@@ -63,6 +63,7 @@ export const upCommand = {
         // deploying one service of it and leaving the rest was never what anybody
         // wanted — it just meant typing the command again in the right order.
         const targets = args[0] ? [args[0]] : deployOrder(planned);
+        const isDatabase = new Set(planned.filter((p) => p.database).map((p) => p.name));
         if (!targets.length) {
             throw new CliError('The manifest declares no services to deploy.', EXIT.usage);
         }
@@ -74,12 +75,27 @@ export const upCommand = {
             }
             return service;
         });
-        if (resolved.length > 1) {
-            console.log(`\n  ${c.dim('deploying')} ${resolved.map((s) => c.bold(s.name)).join(c.dim(' → '))}\n`);
+        // A database that is already serving is left alone.
+        //
+        // Redeploying one replaces a running container for no reason, and every
+        // service that talks to it loses its connections while it restarts. It is
+        // in the plan so that a database which is *not* running comes back — which
+        // is the case that used to need `fleet up db` by name — not so that every
+        // deploy of the stack restarts the database underneath it. Naming it
+        // explicitly still redeploys it.
+        const skipped = args[0]
+            ? []
+            : resolved.filter((s) => isDatabase.has(s.name) && s.current?.status === 'running');
+        const toDeploy = resolved.filter((s) => !skipped.includes(s));
+        for (const s of skipped) {
+            console.log(`  ${c.dim('already running')}  ${c.bold(s.name)}`);
+        }
+        if (toDeploy.length > 1) {
+            console.log(`\n  ${c.dim('deploying')} ${toDeploy.map((s) => c.bold(s.name)).join(c.dim(' → '))}\n`);
         }
         const gitSha = typeof flags.sha === 'string' ? flags.sha : undefined;
         const deployed = [];
-        for (const service of resolved) {
+        for (const service of toDeploy) {
             const url = await deployOne(service, {
                 fleetId,
                 gitSha,
@@ -148,11 +164,18 @@ async function deployOne(service, opts) {
     if (opts.wait) {
         await task(`waiting for ${c.bold(service.name)} to come up`, async (s) => {
             s.hints([
+                'the image is built on the control plane, for every architecture in the fleet',
+                'building for a different architecture than the control plane is emulated, and slow',
                 'the agent picks up desired state on its next poll',
                 "a cold image pull takes as long as the node's uplink does",
                 'a service with a health check goes running once it passes, not before',
             ]);
-            const deadline = Date.now() + 180_000;
+            // Long, because this now covers the build as well as the rollout.
+            // The control plane answers as soon as a node is chosen and keeps
+            // building afterwards, so this is the window in which a multi-arch
+            // build has to finish - and an arm64 build emulated on an amd64 host
+            // is measured in tens of minutes, not minutes.
+            const deadline = Date.now() + 45 * 60_000;
             while (Date.now() < deadline) {
                 const { body } = await request('GET', `/fleets/${opts.fleetId}/services`);
                 const current = body.services.find((s) => s.id === service.id)?.current;

package/dist/compose.js

@@ -4,6 +4,14 @@ import { safeDatabaseName } from './dbnames.js';
 const ENGINE_IMAGES = {
     postgres: 'postgres',
     postgis: 'postgres',
+    // Postgres by another name. pgvector in particular is what anything doing
+    // embeddings runs, and leaving it unrecognised turned a managed database
+    // back into a container the reader has to look after themselves.
+    pgvector: 'postgres',
+    'ankane/pgvector': 'postgres',
+    'pgvector/pgvector': 'postgres',
+    'supabase/postgres': 'postgres',
+    'bitnami/postgresql': 'postgres',
     'timescale/timescaledb': 'postgres',
     mysql: 'mysql',
     mariadb: 'mariadb',

package/dist/detect.js

@@ -135,7 +135,7 @@ export async function detect(cwd = process.cwd()) {
             framework: 'unknown',
             label: 'existing Dockerfile',
             port,
-            healthPath: '/',
+            healthPath: null,
             dockerfile: null,
             hasDockerfile: true,
         };
@@ -175,7 +175,7 @@ export async function detect(cwd = process.cwd()) {
                 framework: 'node',
                 label: 'Node.js API',
                 port: 3000,
-                healthPath: '/health',
+                healthPath: null,
                 dockerfile: NODE_DOCKERFILE,
                 hasDockerfile: false,
             };
@@ -209,7 +209,7 @@ export async function detect(cwd = process.cwd()) {
             framework: 'python',
             label: isFastapi ? 'Python (FastAPI)' : isDjango ? 'Python (Django)' : isFlask ? 'Python (Flask)' : 'Python',
             port: 8000,
-            healthPath: '/health',
+            healthPath: null,
             dockerfile: pythonDF,
             hasDockerfile: false,
         };
@@ -223,7 +223,7 @@ export async function detect(cwd = process.cwd()) {
             framework: 'go',
             label: 'Go',
             port: 8080,
-            healthPath: '/healthz',
+            healthPath: null,
             dockerfile: GO_DOCKERFILE(moduleName),
             hasDockerfile: false,
         };
@@ -234,7 +234,7 @@ export async function detect(cwd = process.cwd()) {
             framework: 'rust',
             label: 'Rust',
             port: 8080,
-            healthPath: '/healthz',
+            healthPath: null,
             dockerfile: RUST_DOCKERFILE,
             hasDockerfile: false,
         };
@@ -255,7 +255,7 @@ export async function detect(cwd = process.cwd()) {
         framework: 'unknown',
         label: 'unknown project',
         port: 3000,
-        healthPath: '/',
+        healthPath: null,
         dockerfile: null,
         hasDockerfile: false,
     };

package/dist/discover.js

@@ -180,7 +180,18 @@ async function expand(root, globs) {
     }
     return [...dirs];
 }
-/** Conventional layouts, for repositories that declare no workspaces. */
+/**
+ * Candidate directories for a repository that declares no workspaces.
+ *
+ * Two shapes, because both are common and neither is declared anywhere. The
+ * first is a parent holding many packages - apps/, services/, packages/. The
+ * second is simply a few directories at the top level: backend/ beside
+ * landing_page/, or api/ beside web/. Looking only for the first meant a
+ * perfectly ordinary two-app repository was read as one unrecognised project.
+ *
+ * Only immediate children are considered. Walking deeper finds vendored
+ * copies, fixtures and examples, and proposes deploying them.
+ */
 async function conventionalDirs(root) {
     const dirs = [];
     for (const parent of ['apps', 'services', 'packages']) {
@@ -194,6 +205,18 @@ async function conventionalDirs(root) {
             /* not this layout */
         }
     }
+    if (dirs.length)
+        return dirs;
+    try {
+        for (const entry of await readdir(root, { withFileTypes: true })) {
+            if (!entry.isDirectory() || IGNORED.has(entry.name) || entry.name.startsWith('.'))
+                continue;
+            dirs.push(entry.name);
+        }
+    }
+    catch {
+        /* unreadable root is the caller's problem */
+    }
     return dirs;
 }
 /**
@@ -235,7 +258,7 @@ export async function discover(root = process.cwd()) {
     else {
         const conventional = await conventionalDirs(root);
         if (conventional.length) {
-            layout = 'apps/ and services/ directories';
+            layout = 'directories that look like services';
             candidates = conventional;
             notes.push(`no workspace file, but ${conventional.length} directories look like services`);
         }
@@ -310,10 +333,25 @@ export function manifestFromDiscovery(d, opts = {}) {
         lines.push(`  ${s.name}:`);
         lines.push(`    build: ${s.dir}`);
         lines.push('    placement: flexible');
-        if (s.detection.port !== 80)
-            lines.push(`    container_port: ${s.detection.port}`);
+        // Always written, never omitted as "the default". Leaving it out does not
+        // mean 80: an unset container port becomes 8080 on the node, so an nginx
+        // image serving 80 got its traffic forwarded to a closed port and answered
+        // 502 while every status in the system said running.
+        lines.push(`    container_port: ${s.detection.port}`);
         lines.push(`    resources: { ram: ${s.ramMb}Mi, cpu: 0.5 }`);
-        lines.push(`    health: { path: ${s.detection.healthPath} }`);
+        // Only where the framework genuinely answers at the path. A guessed one
+        // that is wrong does not fall back to "no check" — it fails for ever and
+        // the deploy never leaves "deploying", while the service runs correctly.
+        if (s.detection.healthPath) {
+            lines.push(`    health: { path: ${s.detection.healthPath} }`);
+        }
+        else {
+            lines.push('    # No health check: container state decides whether this');
+            lines.push('    # is up. Add one once you know a path that returns 2xx —');
+            lines.push('    #   health: { path: /healthz }');
+            lines.push('    # Note the probe runs from the node, not inside the');
+            lines.push('    # container, so the image needs nothing installed for it.');
+        }
         if (s.gpu) {
             lines.push('    gpu: true');
             questions.push(`${s.name}: ${s.gpu}, so it asks for a GPU — remove "gpu: true" if it runs on CPU.`);

package/dist/index.js

@@ -25,6 +25,7 @@ const GROUPS = [
             ['doctor', 'Check the control plane, nodes, services, ingress, and GitHub'],
             ['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'],
         ],
     ],
     [

package/dist/plan.js

@@ -33,10 +33,7 @@ export function projectNameFor(dir) {
  */
 export function planFromManifest(source) {
     const doc = parseYaml(source);
-    const services = doc?.services;
-    if (!services || typeof services !== 'object')
-        return [];
-    return Object.entries(services).map(([name, raw]) => {
+    const services = Object.entries(doc?.services ?? {}).map(([name, raw]) => {
         const body = (raw ?? {});
         return {
             name,
@@ -44,6 +41,21 @@ export function planFromManifest(source) {
             affinity: Array.isArray(body.affinity) ? body.affinity.filter((a) => typeof a === 'string') : [],
         };
     });
+    // Databases are deployed too.
+    //
+    // They used to be left out entirely, on the reasoning that applying the
+    // manifest creates them. It does — once. After that a database whose
+    // deployment has failed is never revived, because nothing puts it back in
+    // the plan: `fleet up` walked the whole stack, skipped it, and reported
+    // success while the database it depended on stayed dead and every service
+    // using it crash-looped. Recovering needed `fleet up db` by name, which is
+    // knowledge the command should not require.
+    const databases = Object.keys(doc?.databases ?? {}).map((name) => ({
+        name,
+        affinity: [],
+        database: true,
+    }));
+    return [...databases, ...services];
 }
 /**
  * Which secrets the manifest says it needs, and which services want each.

package/package.json

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