@faable/faable 1.12.1 → 1.13.0

package/dist/commands/upgrade/index.js

@@ -0,0 +1,37 @@
+import ora from 'ora';
+import { version } from '../../config.js';
+import { isDevBuild, getLatestVersion, isNewerVersion, CLI_PACKAGE } from '../../lib/UpdateChecker.js';
+import { cmd } from '../../lib/cmd.js';
+import { log } from '../../log.js';
+
+const upgrade = {
+    command: "upgrade",
+    describe: "Upgrade the Faable CLI to the latest version",
+    handler: async () => {
+        if (isDevBuild(version)) {
+            log.warn("Development build, skipping self-upgrade");
+            return;
+        }
+        const latest = await getLatestVersion();
+        if (!latest) {
+            log.error("❌ Could not reach the npm registry to check for updates");
+            process.exit(1);
+        }
+        if (!isNewerVersion(latest, version)) {
+            log.info(`✅ Already on the latest version (${version})`);
+            return;
+        }
+        const spinner = ora(`Upgrading ${CLI_PACKAGE} ${version} → ${latest}`).start();
+        try {
+            await cmd(`npm install -g ${CLI_PACKAGE}@latest`, { timeout: 180_000 });
+            spinner.succeed(`Upgraded to ${latest}`);
+        }
+        catch {
+            spinner.fail("Upgrade failed");
+            log.error(`❌ Could not upgrade automatically. Try manually: npm install -g ${CLI_PACKAGE}@latest`);
+            process.exit(1);
+        }
+    },
+};
+
+export { upgrade };

package/dist/index.js

@@ -4,15 +4,21 @@ import { deploy } from './commands/deploy/index.js';
 import { link_deprecated } from './commands/link/index.js';
 import { login } from './commands/login/index.js';
 import { logout } from './commands/logout/index.js';
+import { upgrade } from './commands/upgrade/index.js';
 import { whoami } from './commands/whoami/index.js';
 import { version } from './config.js';
 import { Configuration } from './lib/Configuration.js';
+import { notifyIfUpdateAvailable } from './lib/UpdateChecker.js';
 import { log } from './log.js';
 
 const yg = yargs();
 yg.scriptName('faable')
-    .middleware(function (_argv) {
+    .middleware(async function (argv) {
     log.info(`Faable CLI ${version}`);
+    // `upgrade` does its own (forced) check
+    if (argv._[0] !== 'upgrade') {
+        await notifyIfUpdateAvailable(version);
+    }
 }, true)
     .option('c', {
     alias: 'config',
@@ -33,6 +39,7 @@ yg.scriptName('faable')
     .command(login)
     .command(logout)
     .command(whoami)
+    .command(upgrade)
     .command(link_deprecated)
     .demandCommand(1)
     .help()

package/dist/lib/UpdateChecker.js

@@ -0,0 +1,111 @@
+import { spawn } from 'child_process';
+import fs from 'fs-extra';
+import os from 'os';
+import path__default from 'path';
+import { log } from '../log.js';
+
+const CLI_PACKAGE = "@faable/faable";
+const REGISTRY_URL = `https://registry.npmjs.org/${CLI_PACKAGE}/latest`;
+// Hitting the registry at most once a day keeps the background refresh rare.
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPGRADE_FETCH_TIMEOUT_MS = 10_000;
+const cache_path = () => path__default.join(os.homedir(), ".faable", "update-check.json");
+// Local dev runs with the semantic-release placeholder version.
+const isDevBuild = (version) => version.startsWith("0.0.0");
+const isCacheStale = (cache, now) => {
+    if (!cache.last_check)
+        return true;
+    const last = new Date(cache.last_check).getTime();
+    return Number.isNaN(last) || now - last > CHECK_INTERVAL_MS;
+};
+const isNewerVersion = (latest, current) => {
+    const parse = (v) => {
+        const [core, prerelease] = v.replace(/^v/, "").split("-");
+        const [major = 0, minor = 0, patch = 0] = core.split(".").map(Number);
+        return { major, minor, patch, prerelease };
+    };
+    const a = parse(latest);
+    const b = parse(current);
+    if (a.major !== b.major)
+        return a.major > b.major;
+    if (a.minor !== b.minor)
+        return a.minor > b.minor;
+    if (a.patch !== b.patch)
+        return a.patch > b.patch;
+    // Same core version: the release wins over its own prereleases.
+    return !a.prerelease && !!b.prerelease;
+};
+const readCache = async () => {
+    try {
+        return await fs.readJSON(cache_path());
+    }
+    catch {
+        return {};
+    }
+};
+const writeCache = async (cache) => {
+    try {
+        await fs.ensureDir(path__default.dirname(cache_path()));
+        await fs.writeJSON(cache_path(), cache, { spaces: 2 });
+    }
+    catch {
+        // A read-only home dir shouldn't break the CLI.
+    }
+};
+// Refresh the cache from a detached child so the current run never waits on
+// the network (update-notifier pattern): the notice shows on the next run.
+const spawnBackgroundRefresh = () => {
+    const script = `fetch(${JSON.stringify(REGISTRY_URL)})
+    .then((r) => r.json())
+    .then((d) => require("fs").writeFileSync(${JSON.stringify(cache_path())},
+      JSON.stringify({ last_check: new Date().toISOString(), latest: d.version }, null, 2)))
+    .catch(() => {})`;
+    try {
+        spawn(process.execPath, ["-e", script], {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        }).unref();
+    }
+    catch {
+        // No update check is worth failing a command over.
+    }
+};
+/**
+ * Fetch the latest published version, updating the cache. Only used by
+ * `faable upgrade`, where the user explicitly asked and waiting is expected.
+ */
+const getLatestVersion = async () => {
+    try {
+        const res = await fetch(REGISTRY_URL, {
+            signal: AbortSignal.timeout(UPGRADE_FETCH_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return;
+        const data = (await res.json());
+        if (data.version) {
+            await writeCache({ last_check: new Date().toISOString(), latest: data.version });
+        }
+        return data.version;
+    }
+    catch {
+        return;
+    }
+};
+const notifyIfUpdateAvailable = async (current) => {
+    if (isDevBuild(current) || process.env.CI || process.env.GITHUB_ACTIONS) {
+        return;
+    }
+    const cache = await readCache();
+    if (cache.latest && isNewerVersion(cache.latest, current)) {
+        log.warn(`⬆️ Update available: ${current} → ${cache.latest}. Run \`faable upgrade\` to get the latest version.`);
+    }
+    if (isCacheStale(cache, Date.now())) {
+        // Stamp the attempt first so a failing child can't cause a spawn storm:
+        // whatever happens, the next refresh is a day away.
+        await writeCache({ ...cache, last_check: new Date().toISOString() });
+        spawnBackgroundRefresh();
+    }
+};
+
+export { CLI_PACKAGE, getLatestVersion, isCacheStale, isDevBuild, isNewerVersion, notifyIfUpdateAvailable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "1.12.1",
+  "version": "1.13.0",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",