@yadurajfleetos/cli 0.17.2 → 0.18.1

package/dist/args.js

@@ -46,7 +46,7 @@ export const KNOWN_FLAGS = new Set([
     'plan', 'dry-run', 'force', 'dir', 'file', 'manifest',
     // per command
     'ai', 'all', 'apply', 'channel', 'deploy', 'email', 'events', 'f', 'follow', 'limit',
-    'name', 'node', 'only', 'out', 'password', 'secret', 'service', 'sha',
+    'name', 'node', 'only', 'out', 'password', 'project', 'secret', 'service', 'sha',
     'since', 'terminal', 'to', 'token', 'url',
 ]);
 /** The closest known flag to a mistyped one, or null when nothing is close. */

package/dist/commands/services.js

@@ -6,6 +6,8 @@ import { task, glyph } from '../ui.js';
 import { withLadder } from '../ladder.js';
 import { ask, canPrompt, confirm, selectOrThrow } from '../prompt.js';
 import { DEPLOY_STEPS, follow, phaseWalker, } from '../progress.js';
+import { planFromDiscovery, renderPlan, toAssistPlan } from '../deployment-plan.js';
+import { requireRunning } from '../deploy-wait.js';
 import { planFromManifest, projectNameFor } from '../plan.js';
 import { uploadContext, humanBytes } from '../archive.js';
 import { localSource } from '../source.js';
@@ -131,13 +133,51 @@ export const servicesCommand = {
         }
     },
 };
-async function findService(fleetId, name) {
+/**
+ * The service a name refers to, in a fleet where a name is no longer unique.
+ *
+ * Services are identified by (fleet, project, name), so two projects may both
+ * have a "backend". This used to take the first match, which meant a command
+ * could act on another project's service without saying so — the same class of
+ * mistake as the apply that silently took one over.
+ *
+ * Resolved in the order the operator's intent is clearest:
+ *
+ *   --project        an explicit answer, and an error if it does not match
+ *   the directory    the project a manifest here would apply as, which is how
+ *                    the service got its project in the first place
+ *   otherwise        refuse, and list the projects to choose between
+ *
+ * An id always wins: it identifies a row on its own and needs no project.
+ */
+/** `--project`, when the operator gave one. */
+const projectFlag = (flags) => typeof flags.project === 'string' ? flags.project : undefined;
+async function findService(fleetId, name, project) {
     const { body } = await request('GET', `/fleets/${fleetId}/services`);
-    const match = body.services.find((s) => s.name === name || s.id === name);
-    if (!match) {
+    const byId = body.services.find((s) => s.id === name);
+    if (byId)
+        return byId;
+    const matches = body.services.filter((s) => s.name === name);
+    if (!matches.length) {
         throw new CliError(`No service called "${name}". Known: ${body.services.map((s) => s.name).join(', ') || 'none'}`, EXIT.usage);
     }
-    return match;
+    if (matches.length === 1)
+        return matches[0];
+    if (project) {
+        const scoped = matches.find((s) => s.project === project);
+        if (scoped)
+            return scoped;
+        throw new CliError(`No service called "${name}" in project "${project}". ` +
+            `It exists in: ${matches.map((s) => s.project).join(', ')}.`, EXIT.usage);
+    }
+    // The project this directory would apply as. Not a guess: it is the same
+    // value `fleet apply` uses, so it names the service this directory owns.
+    const here = projectNameFor(process.cwd());
+    const local = matches.find((s) => s.project === here);
+    if (local)
+        return local;
+    throw new CliError(`"${name}" exists in more than one project: ${matches.map((s) => s.project).join(', ')}. ` +
+        `Say which with --project <name>.`, EXIT.usage);
 }
 async function deployPlan(fleetId, service) {
     return (await request('GET', `/services/${service.id}/placement-preview`)).body.decision;
@@ -184,27 +224,25 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
  * follows it to conclusion rather than reporting "scheduled" and leaving the
  * operator to guess.
  */
-async function waitUntilRunning(fleetId, name, timeoutMs = 180_000) {
+async function waitUntilRunning(fleetId, name, project) {
+    const service = await findService(fleetId, name, project);
     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',
+            "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` });
+        // The shared waiter, on the shared deadline. This used to be its own
+        // loop with its own three-minute deadline, which failed a deploy that
+        // reported running three seconds later.
+        await requireRunning(fleetId, service.id, name, {
+            onPoll: (status, elapsedMs) => {
+                if (!status)
+                    return;
+                s.update(`${c.bold(name)} · ${status} · ${Math.round(elapsedMs / 1000)}s`);
+            },
+        });
+    }, { done: () => 'running' });
 }
 /**
  * The build context a service declares, if any, read from the local manifest.
@@ -233,7 +271,7 @@ export const deployCommand = {
         const [name] = args;
         if (!name)
             throw new CliError('usage: fleet deploy <service> [--sha <git-sha>] [--no-wait] [--dir <path>]', EXIT.usage);
-        const service = await findService(fleetId, name);
+        const service = await findService(fleetId, name, projectFlag(flags));
         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);
@@ -275,7 +313,16 @@ export const deployCommand = {
                 onUnavailable: () => ladder.note(c.dim('live progress unavailable; continuing with the deploy request')),
             });
             try {
-                const result = (await request('POST', `/services/${service.id}/deploy`, { body: { gitSha, contextId } })).body;
+                const result = (await request('POST', `/services/${service.id}/deploy`, {
+                    body: {
+                        gitSha,
+                        contextId,
+                        // Was in KNOWN_FLAGS and read by nothing, so `--node` was
+                        // accepted and ignored and the scheduler picked whatever
+                        // scored highest.
+                        ...(typeof flags.node === 'string' ? { node: flags.node } : {}),
+                    },
+                })).body;
                 walker.finish(`scheduled onto ${result.placedOn.name}`);
                 return result;
             }
@@ -294,7 +341,7 @@ export const deployCommand = {
         if (body.url)
             console.log(`${glyph.info} ${c.cyan(body.url)}`);
         if (!flags['no-wait'])
-            await waitUntilRunning(fleetId, service.name);
+            await waitUntilRunning(fleetId, service.name, service.project);
     },
 };
 export const whereCommand = {
@@ -303,7 +350,7 @@ export const whereCommand = {
         const [name] = args;
         if (!name)
             throw new CliError('usage: fleet where <service>', EXIT.usage);
-        const service = await findService(fleetId, name);
+        const service = await findService(fleetId, name, projectFlag(flags));
         const { body } = await request('GET', `/services/${service.id}/placement-preview`);
         const d = body.decision;
         if (flags.json)
@@ -336,7 +383,7 @@ export const rescheduleCommand = {
         const [name] = args;
         if (!name)
             throw new CliError('usage: fleet reschedule <service>', EXIT.usage);
-        const service = await findService(fleetId, name);
+        const service = await findService(fleetId, name, projectFlag(flags));
         const { body } = await request('POST', `/services/${service.id}/reschedule`);
         console.log(`${c.green('moved')} ${service.name} → ${c.bold(body.movedTo.name)}`);
     },
@@ -365,7 +412,7 @@ export const deploymentsCommand = {
         const [name] = args;
         if (!name)
             throw new CliError('usage: fleet deployments <service>', EXIT.usage);
-        const service = await findService(fleetId, name);
+        const service = await findService(fleetId, name, projectFlag(flags));
         const { body } = await request('GET', `/services/${service.id}/deployments`);
         if (flags.json)
             return console.log(JSON.stringify(body.deployments, null, 2));
@@ -386,13 +433,13 @@ export const restartCommand = {
         const [name] = args;
         if (!name)
             throw new CliError('usage: fleet restart <service>', EXIT.usage);
-        const service = await findService(fleetId, name);
+        const service = await findService(fleetId, name, projectFlag(flags));
         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);
+            await waitUntilRunning(fleetId, service.name, service.project);
     },
 };
 export const rollbackCommand = {
@@ -401,7 +448,7 @@ export const rollbackCommand = {
         const [name, deploymentId] = args;
         if (!name)
             throw new CliError('usage: fleet rollback <service> [deployment-id]', EXIT.usage);
-        const service = await findService(fleetId, name);
+        const service = await findService(fleetId, name, projectFlag(flags));
         if (!flags.yes && !flags.y && !(await confirmDeploy())) {
             console.log(c.dim('Rollback cancelled.'));
             return;
@@ -411,7 +458,7 @@ export const rollbackCommand = {
             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);
+            await waitUntilRunning(fleetId, service.name, service.project);
     },
 };
 export const logsCommand = {
@@ -420,7 +467,7 @@ export const logsCommand = {
         const [name] = args;
         if (!name)
             throw new CliError('usage: fleet logs <service> [--follow] [--since 1h]', EXIT.usage);
-        const service = await findService(fleetId, name);
+        const service = await findService(fleetId, name, projectFlag(flags));
         if (flags.since)
             console.error(c.dim('note: agent log tails are live snapshots; --since is limited to the current retained tail.'));
         let previous = '';
@@ -449,36 +496,90 @@ export const logsCommand = {
     },
 };
 /**
- * The node to pin a database to, when there is only one it could be.
+ * The fleet's nodes, fetched once per process.
  *
- * A database has to name the node holding its data — that is the one decision
- * Fleet will not make for you, because moving a database moves its disk. But
- * on a fleet with a single node there is no decision to make, and writing
- * CHANGE_ME there meant `init` produced a manifest whose next command fails:
+ * `init` asks for a node for every database it found, and a repository with
+ * Postgres and Redis asked twice for a list that cannot change between the two
+ * questions.
+ */
+let nodeCache = null;
+async function fleetNodes(flags) {
+    if (nodeCache)
+        return nodeCache;
+    const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
+    const { body } = await request('GET', `/fleets/${fleetId}/nodes`);
+    nodeCache = body.nodes;
+    return nodeCache;
+}
+/** Free disk in MB, from whichever pair of numbers the agent reported. */
+function freeDiskMb(n) {
+    const used = n.telemetry?.diskUsedMb;
+    const total = n.telemetry?.diskTotalMb;
+    if (typeof used === 'number' && typeof total === 'number' && total > 0)
+        return total - used;
+    // node.diskMb is free space already. Falling back to it rather than
+    // inventing a capacity: an unavailable metric stays unavailable.
+    return typeof n.diskMb === 'number' ? n.diskMb : undefined;
+}
+/**
+ * Which node should hold a database's data.
+ *
+ * This replaces a function that answered only when the fleet had exactly one
+ * node and gave up otherwise — writing `node: CHANGE_ME` into a file whose very
+ * next command then failed on it. A fleet with two nodes is the common case,
+ * not the exceptional one, so "I cannot choose" was the usual answer.
  *
- *     error  The manifest names nodes that are not in this fleet
- *       services.db.node: no node named "CHANGE_ME" in this fleet
+ * Ranked on what a database actually needs from a machine: it must be able to
+ * hold the data, so free disk decides, and free RAM breaks ties. Metrics the
+ * agent did not report are left out of the comparison rather than defaulted —
+ * a node that reports no disk is not thereby a node with no disk.
  *
- * Best effort, and quiet about it. `init` otherwise needs no control plane at
- * all — it reads a directory — so a missing session, an unreachable server or
- * a fleet with several nodes all fall back to the placeholder rather than
- * turning a local command into one that requires the network.
+ * Returns undefined only when the fleet has no nodes at all, which is the one
+ * case no amount of scoring can fix.
  */
-async function theOnlyNode(flags) {
+export async function pickNodeForData(flags, what) {
+    let nodes;
     try {
-        const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
-        const { body } = await request('GET', `/fleets/${fleetId}/nodes`);
-        // Offline is fine: a node that is down still holds its disk, and that is
-        // what pinning is about. Only an empty fleet has nothing to choose.
-        if (body.nodes.length !== 1)
-            return undefined;
-        const only = body.nodes[0].name;
-        console.log(c.dim(`  · pinned the database to ${only}, the only node in this fleet`));
-        return only;
+        nodes = await fleetNodes(flags);
     }
     catch {
         return undefined;
     }
+    if (!nodes.length)
+        return undefined;
+    // An explicit --node is the operator's decision and outranks any scoring.
+    // It is still checked, because a typo silently ignored is how the wrong
+    // machine ends up holding the data.
+    const explicit = typeof flags.node === 'string' ? flags.node : undefined;
+    if (explicit) {
+        const match = nodes.find((n) => n.name === explicit);
+        if (!match) {
+            throw new CliError(`No node called "${explicit}" in this fleet. Known: ${nodes.map((n) => n.name).join(', ')}.`, EXIT.usage);
+        }
+        return { node: match.name, why: 'you named it with --node' };
+    }
+    if (nodes.length === 1) {
+        return { node: nodes[0].name, why: 'the only node in this fleet' };
+    }
+    // Offline is not disqualifying: a node that is down still holds its disk,
+    // and pinning is about where the data lives. It is a tie-breaker, not a gate.
+    const ranked = [...nodes].sort((a, b) => {
+        const live = Number(b.live ?? false) - Number(a.live ?? false);
+        if (live)
+            return live;
+        const disk = (freeDiskMb(b) ?? -1) - (freeDiskMb(a) ?? -1);
+        if (disk)
+            return disk;
+        return (b.ramMb ?? 0) - (a.ramMb ?? 0);
+    });
+    const best = ranked[0];
+    const disk = freeDiskMb(best);
+    const reasons = [
+        disk !== undefined ? `${Math.round(disk / 1024)}GB free` : 'free disk not reported',
+        best.live ? 'reporting' : 'not reporting',
+    ];
+    console.log(c.dim(`  · ${what} pinned to ${best.name} — ${reasons.join(', ')}; change it before applying if that is wrong`));
+    return { node: best.name, why: reasons.join(', ') };
 }
 /**
  * A second opinion on the draft, when --ai is given.
@@ -492,7 +593,16 @@ 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, services) {
+async function reviewed(draft, flags, services, 
+/**
+ * What discovery already settled.
+ *
+ * Sent so the model is told the facts rather than left to read them back out
+ * of the draft it is being asked to correct — a reviewer shown only YAML
+ * treats every line as a proposal, including the ones deterministic code
+ * already decided and will re-check afterwards regardless.
+ */
+plan) {
     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.
@@ -507,6 +617,7 @@ async function reviewed(draft, flags, services) {
         body: {
             draft: base,
             repoMap: map,
+            ...(plan ? { plan } : {}),
             ...(answers ? { answers } : {}),
             ...(parts ? { parts } : {}),
         },
@@ -686,14 +797,41 @@ export const initCommand = {
         const { discover, manifestFromDiscovery } = await import('../discover.js');
         const found = await discover();
         if (found.services.length > 1 || found.databases.length) {
+            // Resolved before the plan is built, so the plan can state where the
+            // data is going instead of describing a decision still to be made.
+            const chosen = found.databases.length
+                ? await pickNodeForData(flags, found.databases.map((d) => d.name).join(' and '))
+                : undefined;
             const drafted = manifestFromDiscovery(found, {
                 fleet: typeof flags.fleet === 'string' ? flags.fleet : undefined,
-                node: (typeof flags.node === 'string' ? flags.node : undefined) ??
-                    (found.databases.length ? await theOnlyNode(flags) : undefined),
+                // Resolved here, not deferred into the file. A database needs a node
+                // and `pickNodeForData` answers for any fleet that has one, so the
+                // placeholder is reachable only when the fleet has no nodes at all.
+                node: chosen?.node,
             });
+            // Said before the file appears, not after. Everything here is a
+            // projection of what discovery already established — nothing is
+            // re-detected, and nothing the discovery could not settle is filled in.
+            const plan = planFromDiscovery(found, {
+                project: projectNameFor(process.cwd()),
+                ...(chosen ? { node: chosen.node, nodeWhy: chosen.why } : {}),
+            });
+            for (const line of renderPlan(plan)) {
+                console.log(line ? c.dim(line) : '');
+            }
+            console.log('');
+            // Asked before anything is written, because writing is the side effect.
+            // `confirm` returns its `ifNoTerminal` answer when there is no tty, so a
+            // scripted `fleet init` keeps working exactly as it did.
+            if (!flags.yes &&
+                !flags.y &&
+                !(await confirm('Write this manifest?', { default: true, ifNoTerminal: true }))) {
+                console.log(c.dim('Nothing was written.'));
+                return;
+            }
             const questions = drafted.questions;
             const manifest = flags.ai
-                ? await reviewed(drafted.manifest, flags, found.services.map((s) => ({ name: s.name, dir: s.dir })))
+                ? await reviewed(drafted.manifest, flags, found.services.map((s) => ({ name: s.name, dir: s.dir })), toAssistPlan(plan))
                 : drafted.manifest;
             await writeFile(path, manifest);
             console.log(`${c.green('created')} ${path}`);
@@ -758,7 +896,7 @@ export const removeServiceCommand = {
         if (!name)
             throw new CliError('usage: fleet rm <service> [--yes]', EXIT.usage);
         const fleetId = await requireFleet(typeof flags.fleet === 'string' ? flags.fleet : undefined);
-        const service = await findService(fleetId, name);
+        const service = await findService(fleetId, name, projectFlag(flags));
         const confirmed = flags.yes === true || flags.y === true;
         if (!confirmed) {
             if (!process.stdin.isTTY) {
@@ -832,7 +970,7 @@ export const importCommand = {
                 // a manifest that must name a node, and on a one-node fleet there is
                 // nothing to choose. Without this, import wrote a placeholder and the
                 // very next command failed on it.
-                node: (typeof flags.node === 'string' ? flags.node : undefined) ?? (await theOnlyNode(flags)),
+                node: (await pickNodeForData(flags, 'the database'))?.node,
             });
         }
         catch (err) {
@@ -871,7 +1009,7 @@ export const explainCommand = {
             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 service = await findService(id, name, projectFlag(flags));
             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

package/dist/commands/up.js

@@ -14,6 +14,7 @@ import { c } from '../render.js';
 import { task, glyph } from '../ui.js';
 import { withLadder } from '../ladder.js';
 import { DEPLOY_STEPS, follow, phaseWalker } from '../progress.js';
+import { requireRunning } from '../deploy-wait.js';
 import { planFromManifest, deployOrder, projectNameFor } from '../plan.js';
 import { uploadContext, humanBytes } from '../archive.js';
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -99,6 +100,7 @@ export const upCommand = {
                 gitSha,
                 buildContext: buildContexts.get(service.name),
                 wait: !flags['no-wait'],
+                ...(typeof flags.node === 'string' ? { node: flags.node } : {}),
                 rootDir: typeof flags.file === 'string' ? dirname(flags.file) : rootDir,
             });
             deployed.push({ service, url });
@@ -137,7 +139,7 @@ async function deployOne(service, opts) {
         });
         try {
             const result = (await request('POST', `/services/${service.id}/deploy`, {
-                body: { gitSha: opts.gitSha, contextId },
+                body: { gitSha: opts.gitSha, contextId, ...(opts.node ? { node: opts.node } : {}) },
             })).body;
             // Deliberately not walker.finish().
             //
@@ -178,19 +180,22 @@ async function deployOne(service, opts) {
             // 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) {
-                // What the builder is doing, rather than a hint about what it might
-                // be doing. Every field here has been reaching /progress since the
-                // phase writer was added and nothing asked for it, so this loop sat
-                // cycling generic advice past a reader who could have been told the
-                // step number. Failures are swallowed: this is a label, and losing it
-                // must not end a deploy that is going fine.
-                const line = await request('GET', `/services/${service.id}/progress`)
-                    .then((r) => r.body)
-                    .catch(() => null);
-                if (line && ['queued', 'building', 'pushing'].includes(line.status)) {
-                    const parts = [line.status];
+            // The same waiter `fleet deploy` uses, on the same deadline. Two
+            // commands watching the same thing in two loops is how one of them
+            // ended up giving up at three minutes.
+            await requireRunning(opts.fleetId, service.id, service.name, {
+                onPoll: async () => {
+                    // What the builder is doing, rather than a hint about what it
+                    // might be doing. Every field here has been reaching /progress
+                    // since the phase writer was added and nothing asked for it.
+                    // Failures are swallowed: this is a label, and losing it must not
+                    // end a deploy that is going fine.
+                    const line = await request('GET', `/services/${service.id}/progress`)
+                        .then((r) => r.body)
+                        .catch(() => null);
+                    if (!line || !['queued', 'building', 'pushing', 'deploying'].includes(line.status))
+                        return;
+                    const parts = [line.phase ?? line.status];
                     if (line.step && line.ofSteps)
                         parts.push(`${line.step}/${line.ofSteps}`);
                     if (line.platform)
@@ -200,17 +205,8 @@ async function deployOne(service, opts) {
                     s.update(`${c.bold(service.name)} · ${parts.join(' · ')}`);
                     if (line.detail)
                         s.hints([line.detail]);
-                }
-                const { body } = await request('GET', `/fleets/${opts.fleetId}/services`);
-                const current = body.services.find((s) => s.id === service.id)?.current;
-                if (current?.status === 'running')
-                    return;
-                if (current?.status === 'failed') {
-                    throw new CliError(`"${service.name}" did not start. \`fleet deployments ${service.name}\` has the reason.`, EXIT.healthCheckFailed);
-                }
-                await sleep(2000);
-            }
-            throw new CliError(`"${service.name}" was scheduled but has not reported running.`, EXIT.healthCheckFailed);
+                },
+            });
         }, { done: () => `${c.bold(service.name)} is running` });
     }
     return deployResult.url;

package/dist/config.js

@@ -23,7 +23,7 @@ export async function loadProfile() {
     catch {
         // The public control plane is the useful default for a first-time install.
         // Self-hosters and CI can always override it with FLEET_API or --api.
-        return { api: fromEnv.api || 'https://fleetapi.plastikworld.xyz', ...fromEnv };
+        return { ...fromEnv, api: fromEnv.api || 'https://fleetapi.plastikworld.xyz' };
     }
 }
 export async function saveProfile(profile) {

package/dist/deploy-wait.js

@@ -0,0 +1,105 @@
+/**
+ * Waiting for a deploy to reach a terminal state, once, for every command.
+ *
+ * `fleet up` and `fleet deploy` both watched a deploy and drifted apart while
+ * doing it. `up` was widened to 45 minutes when it took over the build, because
+ * an arm64 image emulated on an amd64 control plane is measured in tens of
+ * minutes. `deploy` kept a three-minute deadline nobody revisited.
+ *
+ * A real deploy of landing-page started at 15:44:54 and reported running at
+ * 15:47:57 — 183 seconds. `fleet deploy` gave up at 181 and told the operator
+ * the service "was scheduled but has not reported running", about a service
+ * that was running. Two seconds of drift produced a false failure, and the
+ * message sent somebody to debug a healthy container.
+ *
+ * So the deadline is one constant and the loop is one function. Two commands
+ * waiting for the same thing in two places is how the drift happened, and
+ * sharing the constant without sharing the loop would only slow it down.
+ */
+import { request, CliError, EXIT } from './api.js';
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * How long a deploy may take before the CLI stops watching.
+ *
+ * Deliberately longer than the control plane's own BUILD_TIMEOUT_MS (20
+ * minutes): the client must not call a deploy dead while the server is still
+ * legitimately working on it. The server owns "this build is stuck"; this
+ * number only owns "nobody is watching any more".
+ */
+export const DEPLOY_READY_TIMEOUT_MS = 45 * 60_000;
+/** The service's current deployment status, or null when it cannot be read. */
+const liveStatus = (fleetId, serviceId) => request('GET', `/fleets/${fleetId}/services`)
+    .then((r) => r.body.services.find((s) => s.id === serviceId)?.current ?? null)
+    // Unreadable is not the same as failed: a blip must not end a deploy that
+    // is going fine, so this reads as "no answer yet" and the loop continues.
+    .catch(() => null);
+/**
+ * Wait until a service is running, has failed, or the deadline passes.
+ *
+ * Three behaviours the previous loops did not have:
+ *
+ * A service that is ALREADY running returns immediately. `fleet deploy` on an
+ * unchanged service creates no new deployment, so waiting for a transition
+ * meant waiting for something that could not happen.
+ *
+ * The deadline triggers one final authoritative read before failing. The bug
+ * this file exists for was a state change three seconds the wrong side of the
+ * deadline; a poll loop that gives up without looking one more time will always
+ * be able to miss by a second.
+ *
+ * And a timeout is reported as a timeout, carrying the last status seen —
+ * never as "has not reported running", which reads as a verdict on the service
+ * rather than on the waiting.
+ */
+export async function waitForRunning(fleetId, serviceId, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEPLOY_READY_TIMEOUT_MS;
+    const pollMs = opts.pollMs ?? 2000;
+    const currentOf = opts.read ?? liveStatus;
+    const startedAt = Date.now();
+    const deadline = startedAt + timeoutMs;
+    let last = null;
+    // Before waiting at all. A deploy that changed nothing has nothing to wait
+    // for, and the desired state is already the current one.
+    const already = await currentOf(fleetId, serviceId);
+    if (already?.status === 'running')
+        return { state: 'running' };
+    while (Date.now() < deadline) {
+        await opts.onPoll?.(last, Date.now() - startedAt);
+        const current = await currentOf(fleetId, serviceId);
+        last = current?.status ?? last;
+        if (current?.status === 'running')
+            return { state: 'running' };
+        if (current?.status === 'failed') {
+            return { state: 'failed', reason: current.failureReason ?? null };
+        }
+        await sleep(pollMs);
+    }
+    // One last look. The deadline is a decision to stop waiting, not evidence
+    // about the service, and the two are only ever a poll interval apart.
+    const settled = await currentOf(fleetId, serviceId);
+    if (settled?.status === 'running')
+        return { state: 'running' };
+    if (settled?.status === 'failed') {
+        return { state: 'failed', reason: settled.failureReason ?? null };
+    }
+    return { state: 'timeout', last: settled?.status ?? last, elapsedMs: Date.now() - startedAt };
+}
+/**
+ * The same wait, as an exception for callers that want one.
+ *
+ * Keeps the outcome type available to anything that would rather branch than
+ * catch, while giving the two commands the single line they had before.
+ */
+export async function requireRunning(fleetId, serviceId, name, opts = {}) {
+    const outcome = await waitForRunning(fleetId, serviceId, opts);
+    if (outcome.state === 'running')
+        return;
+    if (outcome.state === 'failed') {
+        throw new CliError(`"${name}" did not start${outcome.reason ? `: ${outcome.reason}` : '.'} ` +
+            `\`fleet deployments ${name}\` has the reason.`, EXIT.healthCheckFailed);
+    }
+    const minutes = Math.round(outcome.elapsedMs / 60_000);
+    throw new CliError(`Stopped watching "${name}" after ${minutes} minute${minutes === 1 ? '' : 's'}; ` +
+        `it was last ${outcome.last ?? 'not reporting a status'}. The deploy may still be running — ` +
+        `\`fleet deployments ${name}\` has the current state.`, EXIT.healthCheckFailed);
+}

package/dist/deployment-plan.js

@@ -0,0 +1,117 @@
+/**
+ * Project the discovery model onto the plan.
+ *
+ * Pure, and takes an already-resolved node rather than looking one up: node
+ * selection talks to the control plane and belongs to the caller, which leaves
+ * this testable without a fleet.
+ */
+export function planFromDiscovery(discovery, opts) {
+    const entries = [];
+    for (const svc of discovery.services) {
+        entries.push({
+            name: svc.name,
+            kind: 'service',
+            what: svc.detection.label,
+            ramMb: svc.ramMb,
+            // Discovery sizes a GPU service differently and gives everything else one
+            // default. That is a recommendation, not a measurement, and labelling it
+            // otherwise would be the invented precision this plan exists to avoid.
+            ramFrom: 'recommended',
+            placement: 'flexible',
+            // The engines this service's OWN dependencies imply. Discovery is already
+            // careful here — a frontend beside a backend must not claim to use the
+            // database — so this is a projection, not a second inference.
+            dependsOn: discovery.databases.filter((d) => svc.engines.includes(d.engine)).map((d) => d.name),
+            persistent: false,
+        });
+    }
+    for (const db of discovery.databases) {
+        entries.push({
+            name: db.name,
+            kind: 'database',
+            what: db.engine,
+            // Matches what `manifestFromDiscovery` writes, so the plan cannot
+            // describe a manifest different from the one produced.
+            ramMb: 512,
+            ramFrom: 'recommended',
+            placement: 'pinned',
+            ...(opts.node ? { node: opts.node } : {}),
+            ...(opts.nodeWhy ? { nodeWhy: opts.nodeWhy } : {}),
+            dependsOn: [],
+            // A database holds data by definition; that is why it is pinned at all.
+            persistent: true,
+        });
+    }
+    const limits = [];
+    if (discovery.databases.length) {
+        // Answered honestly rather than invented. `volume:` names a volume and
+        // `backup:` schedules a copy; neither carries a size, so a plan printing
+        // "20 GB" would describe a field the manifest cannot hold.
+        limits.push('storage size: unknown — a manifest can name a volume and a backup schedule, but has no field for its size');
+    }
+    return {
+        project: opts.project,
+        entries,
+        secrets: [...new Set(discovery.services.flatMap((s) => s.secrets))].sort(),
+        totalRamMb: entries.reduce((sum, e) => sum + e.ramMb, 0),
+        limits,
+    };
+}
+const size = (mb) => mb >= 1024 ? `${(mb / 1024).toFixed(mb % 1024 === 0 ? 0 : 2)} GiB` : `${mb} MiB`;
+/**
+ * The plan as lines, for the terminal.
+ *
+ * Returns them rather than printing, so a test can read exactly what a user
+ * would see.
+ */
+export function renderPlan(plan) {
+    const out = [`Deployment plan · ${plan.project}`];
+    const services = plan.entries.filter((e) => e.kind === 'service');
+    const databases = plan.entries.filter((e) => e.kind === 'database');
+    if (services.length) {
+        out.push('', 'Services');
+        for (const s of services) {
+            out.push(`  ${s.name}  ${s.what} · ${size(s.ramMb)} · ${s.placement}`);
+            if (s.dependsOn.length)
+                out.push(`    uses ${s.dependsOn.join(', ')}`);
+        }
+    }
+    if (databases.length) {
+        out.push('', 'Databases');
+        for (const d of databases) {
+            // An unresolved node is stated, not hidden. It is the one thing that
+            // stops the manifest deploying, and the reader should meet it here
+            // rather than three commands later.
+            const where = d.node ? `→ ${d.node}` : '→ no node chosen yet';
+            out.push(`  ${d.name}  ${d.what} · ${size(d.ramMb)} · pinned ${where}`);
+            if (d.nodeWhy)
+                out.push(`    ${d.nodeWhy}`);
+        }
+    }
+    if (plan.secrets.length) {
+        out.push('', `Secrets · ${plan.secrets.length} required`);
+        out.push(`  ${plan.secrets.join(', ')}`);
+        out.push('  values are never read or written into the manifest');
+    }
+    out.push('', `Memory · ${size(plan.totalRamMb)} across ${plan.entries.length} containers`);
+    out.push('  every figure is a starting point, not a measurement');
+    for (const limit of plan.limits)
+        out.push(`  ${limit}`);
+    return out;
+}
+export function toAssistPlan(plan) {
+    return {
+        project: plan.project,
+        entries: plan.entries.map((e) => ({
+            name: e.name,
+            kind: e.kind,
+            what: e.what,
+            ramMb: e.ramMb,
+            placement: e.placement,
+            ...(e.node ? { node: e.node } : {}),
+            dependsOn: e.dependsOn,
+            persistent: e.persistent,
+        })),
+        secrets: plan.secrets,
+    };
+}

package/dist/index.js

@@ -18,6 +18,7 @@ const GROUPS = [
             ['up [service]', 'Deploy the whole fleet.yaml, in dependency order'],
             ['init', 'Read the repository — monorepo, databases, secrets — and write a fleet.yaml'],
             ['init --ai', 'The same, then have the control plane review the draft against the repository'],
+            ['init --node <name>', 'Pin discovered databases to a specific node instead of the best-scoring one'],
             ['import [file]', 'Convert a docker-compose.yml into a fleet.yaml'],
             ['config show', 'Show the saved control plane and selected fleet'],
             ['use <fleet>', 'Select the default fleet for later commands'],
@@ -73,6 +74,13 @@ const GROUPS = [
 ];
 const OPTIONS = [
     ['--fleet <id>', 'Operate on a specific fleet'],
+    // Documented because it silently did nothing on `up` and `deploy` for a long
+    // time, and a flag that validates but is ignored is worse than one that errors.
+    ['--node <name>', 'Deploy onto this node, or say why the service cannot go there'],
+    // Needed since a service became (fleet, project, name): two projects may
+    // both have a "backend", and picking the first match silently acts on
+    // somebody else's.
+    ['--project <name>', 'Disambiguate when two projects have a service of the same name'],
     ['--api <url>', 'Control plane URL (default: saved profile)'],
     ['--json', 'Machine-readable output on stdout'],
     ['--plan, --dry-run', 'Show the deploy placement plan without changing anything'],

package/package.json

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