@flowscripter/dynamic-cli-framework 9.0.3 → 9.1.0

package/src/service/upgrade/method/homebrew.ts

@@ -0,0 +1,165 @@
+import process from "node:process";
+import { existsSync, realpathSync } from "node:fs";
+import { basename, join } from "node:path";
+import type {
+  FetchService,
+  PrinterService,
+  SpawnService,
+} from "@flowscripter/dynamic-cli-framework-api";
+import semver, { type SemVer } from "semver";
+import type { HomebrewLocation } from "../UpgradeLocationsConfig.ts";
+import { describeSpawnFailure, spawnQuoted, type VersionLookupResult } from "./shared.ts";
+
+// `brew list --versions <formula>` prints the formula name followed by one or more installed
+// versions, each optionally prefixed with "v" and optionally suffixed with a "_N" revision.
+export function parseBrewInstalledVersions(output: string, formula: string): SemVer[] {
+  const tokens = output.trim().split(/\s+/).filter(Boolean);
+  if (tokens[0] === formula) {
+    tokens.shift();
+  }
+  const versions: SemVer[] = [];
+  for (const token of tokens) {
+    const version = semver.coerce(token.replace(/^v/i, "").replace(/_\d+$/, ""));
+    if (version) {
+      versions.push(version);
+    }
+  }
+  return versions;
+}
+
+function resolveRealExecutable(): string {
+  try {
+    return realpathSync(process.execPath);
+  } catch {
+    // process.execPath may not resolve on disk (e.g. a fabricated path in tests) - fall back to
+    // the unresolved path rather than treating that as "not installed".
+    return process.execPath;
+  }
+}
+
+// Homebrew relinks a formula's installed binary from its Cellar directory into a `bin/` symlink,
+// so resolving the running executable's real path confirms a homebrew install without spawning
+// `brew`, which has a slow cold start - avoiding it keeps the background upgrade-check
+// StartupTask (see UpgradeServiceProvider) fast even though it runs to completion.
+export function isRunningFromHomebrewCellar(formula: string): boolean {
+  return resolveRealExecutable().includes(`/Cellar/${formula}/`);
+}
+
+// The running executable lives in a version-specific Cellar directory, e.g.
+// "<prefix>/Cellar/<formula>/<version>/bin/<exe>", while "<prefix>/opt/<formula>" links to the
+// installed version, so the upgraded executable is "<prefix>/opt/<formula>/bin/<exe>".
+export function resolveHomebrewOptExecutable(
+  location: HomebrewLocation | undefined,
+): string | undefined {
+  if (!location) {
+    return undefined;
+  }
+  const { formula } = location;
+  const realExecutable = resolveRealExecutable();
+  const cellarIndex = realExecutable.indexOf(`/Cellar/${formula}/`);
+  if (cellarIndex === -1) {
+    return undefined;
+  }
+  const prefix = realExecutable.slice(0, cellarIndex);
+  const executable = join(prefix, "opt", formula, "bin", basename(realExecutable));
+  return existsSync(executable) ? executable : undefined;
+}
+
+export async function isHomebrewInstalled(
+  spawnService: SpawnService | undefined,
+  location: HomebrewLocation | undefined,
+): Promise<boolean> {
+  if (!spawnService || !location) {
+    return false;
+  }
+  const result = await spawnService.spawn(["brew", "list", "--versions", location.formula], {
+    mode: "ignore",
+    longRunning: false,
+  });
+  return result.ok;
+}
+
+export async function getLatestHomebrewVersion(
+  fetchService: FetchService | undefined,
+  location: HomebrewLocation | undefined,
+): Promise<VersionLookupResult> {
+  if (!location) {
+    return { ok: false, error: new Error("No homebrew location configured") };
+  }
+  if (!fetchService) {
+    return { ok: false, error: new Error("FetchService is not available") };
+  }
+  const { tap, formula } = location;
+  const [tapOwner, tapName] = tap.split("/");
+  if (!tapOwner || !tapName) {
+    return { ok: false, error: new Error(`Invalid homebrew tap '${tap}'`) };
+  }
+  try {
+    const response = await fetchService.fetch(
+      `https://raw.githubusercontent.com/${tapOwner}/homebrew-${tapName}/main/${formula}.rb`,
+    );
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: new Error(
+          `Failed to fetch homebrew formula for ${tap}/${formula}: HTTP ${response.status}`,
+        ),
+      };
+    }
+    const text = await response.text();
+    const version = /version\s+"v?([^"]+)"/.exec(text)?.[1];
+    if (!version) {
+      return {
+        ok: false,
+        error: new Error(`Could not parse version from homebrew formula ${tap}/${formula}`),
+      };
+    }
+    return { ok: true, version };
+  } catch (error) {
+    return {
+      ok: false,
+      error: new Error(`Failed to fetch homebrew formula for ${tap}/${formula}: ${error}`),
+    };
+  }
+}
+
+// The latest version is read from the tap's formula on GitHub, but `brew upgrade` only sees the
+// local tap clone, which is stale until `brew update` runs. A stale tap makes `brew upgrade`
+// exit 0 with "already installed", so update first and then confirm the installed version.
+export async function upgradeViaHomebrew(
+  spawnService: SpawnService,
+  printerService: PrinterService | undefined,
+  location: HomebrewLocation,
+  expectedVersion: string,
+): Promise<void> {
+  const { tap, formula } = location;
+  const updateResult = await spawnQuoted(spawnService, printerService, ["brew", "update"]);
+  if (!updateResult.ok) {
+    throw new Error(`brew update failed: ${describeSpawnFailure(updateResult)}`);
+  }
+  const result = await spawnQuoted(spawnService, printerService, [
+    "brew",
+    "upgrade",
+    `${tap}/${formula}`,
+  ]);
+  if (!result.ok) {
+    throw new Error(`brew upgrade failed: ${describeSpawnFailure(result)}`);
+  }
+
+  const lines: string[] = [];
+  const listResult = await spawnService.spawn(["brew", "list", "--versions", formula], {
+    mode: "wrapped",
+    longRunning: false,
+    onOutput: (line) => lines.push(line),
+  });
+  const installed = lines.join(" ").trim();
+  const expected = semver.coerce(expectedVersion);
+  const isExpectedInstalled = parseBrewInstalledVersions(installed, formula).some(
+    (version) => expected !== null && semver.eq(version, expected),
+  );
+  if (!listResult.ok || !isExpectedInstalled) {
+    throw new Error(
+      `brew upgrade completed but version ${expectedVersion} is not installed (installed: ${installed || "unknown"})`,
+    );
+  }
+}

package/src/service/upgrade/method/linuxScript.ts

@@ -0,0 +1,23 @@
+import process from "node:process";
+import type { PrinterService, SpawnService } from "@flowscripter/dynamic-cli-framework-api";
+import type { LinuxScriptLocation } from "../UpgradeLocationsConfig.ts";
+import { describeSpawnFailure, spawnQuoted } from "./shared.ts";
+
+export function isLinuxScriptInstall(): boolean {
+  return process.execPath.startsWith("/usr/local/bin/");
+}
+
+export async function upgradeViaLinuxScript(
+  spawnService: SpawnService,
+  printerService: PrinterService | undefined,
+  location: LinuxScriptLocation,
+): Promise<void> {
+  const result = await spawnQuoted(spawnService, printerService, [
+    "sh",
+    "-c",
+    `curl -fsSL ${location.scriptUrl} | sh`,
+  ]);
+  if (!result.ok) {
+    throw new Error(`Install script failed: ${describeSpawnFailure(result)}`);
+  }
+}

package/src/service/upgrade/method/shared.ts

@@ -0,0 +1,51 @@
+import type {
+  PrinterService,
+  SpawnResult,
+  SpawnService,
+} from "@flowscripter/dynamic-cli-framework-api";
+
+export type VersionLookupResult =
+  | { readonly ok: true; readonly version: string }
+  | { readonly ok: false; readonly error: Error };
+
+export function describeSpawnFailure(result: Extract<SpawnResult, { ok: false }>): string {
+  return "timedOut" in result
+    ? "timed out"
+    : (result.error?.message ?? `exit code ${result.exitCode}`);
+}
+
+// Mirrors SpawnInterfaceAdapter's plugin:add/plugin:remove pattern: wrap a spawned command's
+// output in a quoted, marked block that's cleared on success (so a clean install stays quiet)
+// but left on screen on failure (so the diagnostic output remains visible).
+export async function spawnQuoted(
+  spawnService: SpawnService,
+  printerService: PrinterService | undefined,
+  command: ReadonlyArray<string>,
+): Promise<SpawnResult> {
+  if (!printerService) {
+    return spawnService.spawn(command, { mode: "ignore" });
+  }
+
+  printerService.startQuote();
+  printerService.startMark();
+
+  // onOutput is synchronous and may be called concurrently for stdout/stderr lines, but
+  // printerService.info() is async and must not be invoked concurrently with itself - queue
+  // writes so they're applied one at a time, in call order.
+  let writeQueue: Promise<void> = Promise.resolve();
+  const onOutput = (line: string): void => {
+    writeQueue = writeQueue.then(() => printerService.info(`${line}\n`));
+  };
+
+  const result = await spawnService.spawn(command, { mode: "wrapped", onOutput });
+  await writeQueue;
+
+  printerService.endQuote();
+  printerService.endMark();
+  if (result.ok) {
+    await printerService.clearMarked();
+  } else {
+    printerService.discardMark();
+  }
+  return result;
+}

package/src/service/upgrade/method/winget.ts

@@ -0,0 +1,64 @@
+import type { PrinterService, SpawnService } from "@flowscripter/dynamic-cli-framework-api";
+import type { WingetLocation } from "../UpgradeLocationsConfig.ts";
+import { describeSpawnFailure, spawnQuoted, type VersionLookupResult } from "./shared.ts";
+
+export async function isWingetInstalled(
+  spawnService: SpawnService | undefined,
+  location: WingetLocation | undefined,
+): Promise<boolean> {
+  if (!spawnService || !location) {
+    return false;
+  }
+  const result = await spawnService.spawn(["winget", "list", "--id", location.packageId], {
+    mode: "ignore",
+    longRunning: false,
+  });
+  return result.ok;
+}
+
+export async function getLatestWingetVersion(
+  spawnService: SpawnService | undefined,
+  location: WingetLocation | undefined,
+): Promise<VersionLookupResult> {
+  if (!location) {
+    return { ok: false, error: new Error("No winget location configured") };
+  }
+  if (!spawnService) {
+    return { ok: false, error: new Error("SpawnService is not available") };
+  }
+  const lines: string[] = [];
+  const result = await spawnService.spawn(["winget", "show", "--id", location.packageId], {
+    mode: "wrapped",
+    longRunning: false,
+    onOutput: (line) => lines.push(line),
+  });
+  if (!result.ok) {
+    return { ok: false, error: new Error(`winget show failed: ${describeSpawnFailure(result)}`) };
+  }
+  for (const line of lines) {
+    const match = /Version:\s*(\S+)/.exec(line);
+    if (match?.[1]) {
+      return { ok: true, version: match[1] };
+    }
+  }
+  return { ok: false, error: new Error("Could not parse version from winget output") };
+}
+
+export async function upgradeViaWinget(
+  spawnService: SpawnService,
+  printerService: PrinterService | undefined,
+  location: WingetLocation,
+): Promise<void> {
+  const result = await spawnQuoted(spawnService, printerService, [
+    "winget",
+    "upgrade",
+    "--id",
+    location.packageId,
+    "--silent",
+    "--accept-package-agreements",
+    "--accept-source-agreements",
+  ]);
+  if (!result.ok) {
+    throw new Error(`winget upgrade failed: ${describeSpawnFailure(result)}`);
+  }
+}