@yadurajfleetos/cli 0.18.0 → 0.18.2

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/auth.js

@@ -1,24 +1,20 @@
 import { createInterface } from 'node:readline/promises';
 import { createServer } from 'node:http';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
+import { spawn } from 'node:child_process';
 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, spinner } from '../ui.js';
-const execAsync = promisify(exec);
 async function openBrowserUrl(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);
+        if (platform === 'darwin')
+            spawn('open', [url], { stdio: 'ignore' });
+        else if (platform === 'win32')
+            spawn('cmd', ['/c', 'start', '""', url], { stdio: 'ignore' });
+        else
+            spawn('xdg-open', [url], { stdio: 'ignore' });
     }
     catch {
         // Ignore browser opener errors; URL is printed on screen

package/dist/commands/open.js

@@ -4,30 +4,26 @@
  * 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 { spawn } from 'node:child_process';
 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 = '';
+    let child;
     if (platform === 'darwin') {
-        cmd = `open "${url}"`;
+        child = spawn('open', [url], { stdio: 'ignore' });
     }
     else if (platform === 'win32') {
-        cmd = `start "" "${url}"`;
+        child = spawn('cmd', ['/c', 'start', '""', url], { stdio: 'ignore' });
     }
     else {
-        cmd = `xdg-open "${url}"`;
-    }
-    try {
-        await execAsync(cmd);
-    }
-    catch (err) {
-        throw new CliError(`Could not open browser automatically: ${String(err)}`, EXIT.failure);
+        child = spawn('xdg-open', [url], { stdio: 'ignore' });
     }
+    return new Promise((resolve, reject) => {
+        child.on('error', (err) => reject(new CliError(`Could not open browser automatically: ${err.message}`, EXIT.failure)));
+        child.on('close', () => resolve());
+    });
 }
 export const openCommand = {
     async run(args, flags) {

package/dist/commands/services.js

@@ -7,6 +7,7 @@ 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';
@@ -132,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;
@@ -185,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.
@@ -234,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);
@@ -304,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 = {
@@ -313,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)
@@ -346,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)}`);
     },
@@ -375,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));
@@ -396,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 = {
@@ -411,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;
@@ -421,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 = {
@@ -430,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 = '';
@@ -859,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) {
@@ -972,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));
@@ -179,22 +180,21 @@ 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', 'deploying'].includes(line.status)) {
-                    // The agent's own stage once the image leaves the control plane.
-                    // Before this, everything from "pull" to "health check passed" was
-                    // one line reading "waiting for the container", which is why a
-                    // 477-second deploy was indistinguishable from a hang.
+            // 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}`);
@@ -205,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/index.js

@@ -77,6 +77,10 @@ const OPTIONS = [
     // 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.18.0",
+  "version": "0.18.2",
   "description": "Fleet OS command-line interface for deploying and orchestrating services on user-owned hardware",
   "type": "module",
   "license": "MIT",