@sendly/cli 3.36.0 → 3.37.0

package/dist/commands/upgrade.js

@@ -1,67 +1,160 @@
 import { Command, Flags } from "@oclif/core";
 import { spawn } from "node:child_process";
 import { detectInstallPath, upgradeCommandFor, } from "../lib/detect-install-path.js";
-import { success, error, info } from "../lib/output.js";
+import { colors, success, error, info, spinner, divider, } from "../lib/output.js";
 /**
- * `sendly upgrade` — bring the CLI up to the latest version.
+ * `sendly upgrade` — bring the CLI up to the latest version with a guided,
+ * animated flow: an animated version check, a `vCURRENT → vLATEST` diff, and a
+ * success panel. The noisy package-manager output is hidden behind a spinner
+ * for Homebrew (which never needs sudo); for npm we keep inherited stdio so an
+ * auth/sudo prompt can never hang invisibly behind a spinner.
  *
- * Detects the install path (Homebrew vs npm-global vs unknown) and
- * executes the matching package-manager upgrade command. If the install
- * path is unknown we print both options for the user to pick.
+ * `--check` is a dry-run: it shows the detected install method and the command
+ * that would run, without changing anything.
  *
- * The `--check` flag does a dry-run: prints what would happen without
- * executing anything. Useful in restricted shells where we don't want
- * to trigger a brew/npm run accidentally.
- *
- * The unattended in-band update banner that prompts users to run this
- * comes from the `@oclif/plugin-warn-if-update-available` plugin wired
- * in package.json; this command is the companion action for that
- * banner.
+ * The unattended banner that nudges users to run this comes from the
+ * `@oclif/plugin-warn-if-update-available` plugin wired in package.json; this
+ * command is the companion action for that banner.
  */
+const REGISTRY_URL = "https://registry.npmjs.org/@sendly/cli";
+const CHANGELOG_URL = "https://sendly.live/docs/changelog";
+function bumpType(from, to) {
+    const a = from.split(".").map((n) => parseInt(n, 10));
+    const b = to.split(".").map((n) => parseInt(n, 10));
+    if (a.length < 3 || b.length < 3 || [...a, ...b].some(Number.isNaN))
+        return "";
+    if (b[0] > a[0])
+        return "major";
+    if (b[1] > a[1])
+        return "minor";
+    if (b[2] > a[2])
+        return "patch";
+    return "";
+}
+async function fetchLatest() {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 4000);
+        const res = await fetch(REGISTRY_URL, {
+            headers: { accept: "application/vnd.npm.install-v1+json" },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        return body["dist-tags"]?.latest ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function runCaptured(command) {
+    return new Promise((resolve) => {
+        const [bin, ...args] = command.split(" ");
+        const child = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        child.stdout?.on("data", (d) => (output += d.toString()));
+        child.stderr?.on("data", (d) => (output += d.toString()));
+        child.on("error", (err) => resolve({ code: 1, output: err.message }));
+        child.on("exit", (code) => resolve({ code: code ?? 1, output }));
+    });
+}
+function runInherited(command) {
+    return new Promise((resolve) => {
+        const [bin, ...args] = command.split(" ");
+        const child = spawn(bin, args, { stdio: "inherit" });
+        child.on("error", () => resolve(1));
+        child.on("exit", (code) => resolve(code ?? 1));
+    });
+}
 export default class Upgrade extends Command {
-    static description = "Upgrade Sendly CLI to the latest version using the package manager that installed it (Homebrew or npm).";
+    static description = "Upgrade the Sendly CLI to the latest version with a guided, animated flow.";
     static examples = [
         "<%= config.bin %> upgrade",
         "<%= config.bin %> upgrade --check",
     ];
     static flags = {
         check: Flags.boolean({
-            description: "Print the upgrade command for your install path without executing it",
+            description: "Show what would happen without changing anything",
             default: false,
         }),
     };
     async run() {
         const { flags } = await this.parse(Upgrade);
+        const current = this.config.version;
+        divider();
+        console.log(`  ${colors.highlight("⚡ Sendly CLI")}  ${colors.dim("upgrade")}`);
+        divider();
+        const spin = spinner("Checking for the latest version...").start();
+        const latest = await fetchLatest();
+        if (latest && latest === current) {
+            spin.succeed(`You're on the latest version ${colors.success.bold("v" + current)}`);
+            divider();
+            return;
+        }
+        if (latest) {
+            const kind = bumpType(current, latest);
+            spin.succeed(`Update available${kind ? " " + colors.dim(`(${kind})`) : ""}`);
+            console.log(`  ${colors.dim("v" + current)}  ${colors.primary("→")}  ${colors.success.bold("v" + latest)}`);
+            divider();
+        }
+        else {
+            spin.succeed("Ready to upgrade");
+        }
         const installPath = detectInstallPath();
         const command = upgradeCommandFor(installPath);
         if (installPath === "unknown") {
-            info("Can't detect how you installed the Sendly CLI. Pick the matching command:\n" +
-                "  • Homebrew: brew upgrade sendly\n" +
-                "  • npm:      npm install -g @sendly/cli@latest");
+            info("Can't detect how the CLI was installed. Run whichever matches:\n" +
+                `  ${colors.code("brew upgrade sendly")}                ${colors.dim("(Homebrew)")}\n` +
+                `  ${colors.code("npm install -g @sendly/cli@latest")}  ${colors.dim("(npm)")}`);
             return;
         }
         if (flags.check) {
-            info(`Detected install path: ${installPath}\nWould run: ${command}`);
+            info(`Install method: ${colors.bold(installPath)}\n` +
+                `Would run:      ${colors.code(command)}`);
             return;
         }
-        info(`Upgrading via ${installPath}: ${command}`);
-        const [bin, ...args] = command.split(" ");
-        const child = spawn(bin, args, { stdio: "inherit" });
-        await new Promise((resolve) => {
-            child.on("exit", (code) => {
-                if (code === 0) {
-                    success("Upgrade complete. Run `sendly --version` to confirm the new version.");
-                }
-                else {
-                    error(`Upgrade command exited with code ${code}. Try running \`${command}\` manually.`);
-                }
-                resolve();
-            });
-            child.on("error", (err) => {
-                error(`Failed to execute upgrade command: ${err.message}. Try running \`${command}\` manually.`);
-                resolve();
-            });
-        });
+        const via = installPath === "homebrew" ? "Homebrew" : "npm";
+        const target = latest ? ` to ${colors.success("v" + latest)}` : "";
+        if (installPath === "homebrew") {
+            // Homebrew never needs sudo, so it's safe to hide its output behind a
+            // spinner for a clean, animated upgrade.
+            const upSpin = spinner(`Upgrading via ${via}${target}...`).start();
+            const { code, output } = await runCaptured(command);
+            if (code === 0) {
+                upSpin.stop();
+                this.renderSuccess(via, latest);
+            }
+            else {
+                upSpin.fail(`Upgrade failed via ${via}`);
+                const tail = output.trim().split("\n").slice(-6).join("\n");
+                if (tail)
+                    console.log(colors.dim(tail));
+                error(`Try running it yourself: ${colors.code(command)}`);
+            }
+            return;
+        }
+        // npm: keep inherited stdio so any auth/sudo prompt stays visible.
+        info(`Upgrading via ${via}${target}`);
+        console.log(colors.dim(`  ${command}`));
+        divider();
+        const code = await runInherited(command);
+        if (code === 0) {
+            this.renderSuccess(via, latest);
+        }
+        else {
+            error(`Upgrade command exited with code ${code}. Try running it yourself: ${colors.code(command)}`);
+        }
+    }
+    renderSuccess(via, latest) {
+        success(latest
+            ? `Upgraded to ${colors.success.bold("v" + latest)} via ${via}`
+            : `Upgrade complete via ${via}`);
+        divider();
+        info(`What's new: ${colors.code(CHANGELOG_URL)}`);
+        info("Run `sendly --version` to confirm.");
+        divider();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade.js","sourceRoot":"","sources":["../../src/commands/upgrade.ts"],"names":[],"mappings":"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","sourcesContent":["import { Command, Flags } from \"@oclif/core\";\nimport { spawn } from \"node:child_process\";\nimport {\n  detectInstallPath,\n  upgradeCommandFor,\n} from \"../lib/detect-install-path.js\";\nimport {\n  colors,\n  success,\n  error,\n  info,\n  spinner,\n  divider,\n} from \"../lib/output.js\";\n\n/**\n * `sendly upgrade` — bring the CLI up to the latest version with a guided,\n * animated flow: an animated version check, a `vCURRENT → vLATEST` diff, and a\n * success panel. The noisy package-manager output is hidden behind a spinner\n * for Homebrew (which never needs sudo); for npm we keep inherited stdio so an\n * auth/sudo prompt can never hang invisibly behind a spinner.\n *\n * `--check` is a dry-run: it shows the detected install method and the command\n * that would run, without changing anything.\n *\n * The unattended banner that nudges users to run this comes from the\n * `@oclif/plugin-warn-if-update-available` plugin wired in package.json; this\n * command is the companion action for that banner.\n */\n\nconst REGISTRY_URL = \"https://registry.npmjs.org/@sendly/cli\";\nconst CHANGELOG_URL = \"https://sendly.live/docs/changelog\";\n\nfunction bumpType(from: string, to: string): \"major\" | \"minor\" | \"patch\" | \"\" {\n  const a = from.split(\".\").map((n) => parseInt(n, 10));\n  const b = to.split(\".\").map((n) => parseInt(n, 10));\n  if (a.length < 3 || b.length < 3 || [...a, ...b].some(Number.isNaN)) return \"\";\n  if (b[0] > a[0]) return \"major\";\n  if (b[1] > a[1]) return \"minor\";\n  if (b[2] > a[2]) return \"patch\";\n  return \"\";\n}\n\nasync function fetchLatest(): Promise<string | null> {\n  try {\n    const controller = new AbortController();\n    const timer = setTimeout(() => controller.abort(), 4000);\n    const res = await fetch(REGISTRY_URL, {\n      headers: { accept: \"application/vnd.npm.install-v1+json\" },\n      signal: controller.signal,\n    });\n    clearTimeout(timer);\n    if (!res.ok) return null;\n    const body = (await res.json()) as {\n      \"dist-tags\"?: { latest?: string };\n    };\n    return body[\"dist-tags\"]?.latest ?? null;\n  } catch {\n    return null;\n  }\n}\n\nfunction runCaptured(\n  command: string,\n): Promise<{ code: number; output: string }> {\n  return new Promise((resolve) => {\n    const [bin, ...args] = command.split(\" \");\n    const child = spawn(bin, args, { stdio: [\"ignore\", \"pipe\", \"pipe\"] });\n    let output = \"\";\n    child.stdout?.on(\"data\", (d) => (output += d.toString()));\n    child.stderr?.on(\"data\", (d) => (output += d.toString()));\n    child.on(\"error\", (err) => resolve({ code: 1, output: err.message }));\n    child.on(\"exit\", (code) => resolve({ code: code ?? 1, output }));\n  });\n}\n\nfunction runInherited(command: string): Promise<number> {\n  return new Promise((resolve) => {\n    const [bin, ...args] = command.split(\" \");\n    const child = spawn(bin, args, { stdio: \"inherit\" });\n    child.on(\"error\", () => resolve(1));\n    child.on(\"exit\", (code) => resolve(code ?? 1));\n  });\n}\n\nexport default class Upgrade extends Command {\n  static description =\n    \"Upgrade the Sendly CLI to the latest version with a guided, animated flow.\";\n\n  static examples = [\n    \"<%= config.bin %> upgrade\",\n    \"<%= config.bin %> upgrade --check\",\n  ];\n\n  static flags = {\n    check: Flags.boolean({\n      description: \"Show what would happen without changing anything\",\n      default: false,\n    }),\n  };\n\n  async run(): Promise<void> {\n    const { flags } = await this.parse(Upgrade);\n    const current = this.config.version;\n\n    divider();\n    console.log(\n      `  ${colors.highlight(\"⚡ Sendly CLI\")}  ${colors.dim(\"upgrade\")}`,\n    );\n    divider();\n\n    const spin = spinner(\"Checking for the latest version...\").start();\n    const latest = await fetchLatest();\n\n    if (latest && latest === current) {\n      spin.succeed(\n        `You're on the latest version ${colors.success.bold(\"v\" + current)}`,\n      );\n      divider();\n      return;\n    }\n\n    if (latest) {\n      const kind = bumpType(current, latest);\n      spin.succeed(\n        `Update available${kind ? \" \" + colors.dim(`(${kind})`) : \"\"}`,\n      );\n      console.log(\n        `  ${colors.dim(\"v\" + current)}  ${colors.primary(\"→\")}  ${colors.success.bold(\"v\" + latest)}`,\n      );\n      divider();\n    } else {\n      spin.succeed(\"Ready to upgrade\");\n    }\n\n    const installPath = detectInstallPath();\n    const command = upgradeCommandFor(installPath);\n\n    if (installPath === \"unknown\") {\n      info(\n        \"Can't detect how the CLI was installed. Run whichever matches:\\n\" +\n          `  ${colors.code(\"brew upgrade sendly\")}                ${colors.dim(\"(Homebrew)\")}\\n` +\n          `  ${colors.code(\"npm install -g @sendly/cli@latest\")}  ${colors.dim(\"(npm)\")}`,\n      );\n      return;\n    }\n\n    if (flags.check) {\n      info(\n        `Install method: ${colors.bold(installPath)}\\n` +\n          `Would run:      ${colors.code(command)}`,\n      );\n      return;\n    }\n\n    const via = installPath === \"homebrew\" ? \"Homebrew\" : \"npm\";\n    const target = latest ? ` to ${colors.success(\"v\" + latest)}` : \"\";\n\n    if (installPath === \"homebrew\") {\n      // Homebrew never needs sudo, so it's safe to hide its output behind a\n      // spinner for a clean, animated upgrade.\n      const upSpin = spinner(`Upgrading via ${via}${target}...`).start();\n      const { code, output } = await runCaptured(command);\n      if (code === 0) {\n        upSpin.stop();\n        this.renderSuccess(via, latest);\n      } else {\n        upSpin.fail(`Upgrade failed via ${via}`);\n        const tail = output.trim().split(\"\\n\").slice(-6).join(\"\\n\");\n        if (tail) console.log(colors.dim(tail));\n        error(`Try running it yourself: ${colors.code(command)}`);\n      }\n      return;\n    }\n\n    // npm: keep inherited stdio so any auth/sudo prompt stays visible.\n    info(`Upgrading via ${via}${target}`);\n    console.log(colors.dim(`  ${command}`));\n    divider();\n    const code = await runInherited(command);\n    if (code === 0) {\n      this.renderSuccess(via, latest);\n    } else {\n      error(\n        `Upgrade command exited with code ${code}. Try running it yourself: ${colors.code(command)}`,\n      );\n    }\n  }\n\n  private renderSuccess(via: string, latest: string | null): void {\n    success(\n      latest\n        ? `Upgraded to ${colors.success.bold(\"v\" + latest)} via ${via}`\n        : `Upgrade complete via ${via}`,\n    );\n    divider();\n    info(`What's new: ${colors.code(CHANGELOG_URL)}`);\n    info(\"Run `sendly --version` to confirm.\");\n    divider();\n  }\n}\n"]}