gloomberb 0.18.2 → 0.18.4

package/src/plugins/host-link.ts

@@ -1,6 +1,6 @@
 import { logFailure } from "../utils/log-failure";
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, symlinkSync, unlinkSync, type Stats } from "fs";
-import { basename, dirname, join, resolve } from "path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, realpathSync, rmSync, statSync, symlinkSync, unlinkSync, type Stats } from "fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
 
 import { installPluginHostResolver } from "./host-resolver";
 import { isPluginPackageName, pluginDirectoryNames } from "./plugin-names";
@@ -30,12 +30,15 @@ import { isPluginPackageName, pluginDirectoryNames } from "./plugin-names";
 // host-modules.ts), so one that imports it should fail to resolve.
 const LINKED_PACKAGES = ["gloomberb", "react"] as const;
 
-let cachedHostRoot: string | null | undefined;
-
 /**
- * Walks up from this module to the directory holding the `gloomberb` package.json.
- * @knipignore Also imported by the script host-resolver.test.ts compiles and runs.
+ * The names the host is published under: `gloomberb`, which plugins import
+ * as, and `@gloom-sh/terminal` once releases are also published under it.
  */
+const HOST_PACKAGE_NAMES: ReadonlySet<string> = new Set(["gloomberb", "@gloom-sh/terminal"]);
+
+let cachedHostRoot: string | null | undefined;
+
+/** Walks up from this module to the directory holding the host's package.json. */
 export function findHostPackageRoot(startDir: string = import.meta.dir): string | null {
   if (cachedHostRoot !== undefined && startDir === import.meta.dir) return cachedHostRoot;
   let dir = resolve(startDir);
@@ -44,7 +47,7 @@ export function findHostPackageRoot(startDir: string = import.meta.dir): string
     if (existsSync(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as { name?: string };
-        if (pkg.name === "gloomberb") {
+        if (pkg.name && HOST_PACKAGE_NAMES.has(pkg.name)) {
           if (startDir === import.meta.dir) cachedHostRoot = dir;
           return dir;
         }
@@ -105,11 +108,22 @@ function linkTarget(hostRoot: string, pkg: string): string | null {
   }
 }
 
-/** True when `path` is already a link pointing at `target`. Compared by real
- * path: Windows spells a junction's target its own way. */
+/**
+ * True when `path` is already a link pointing at `target`. Compared by real
+ * path, since Windows spells a junction's target its own way, and failing
+ * that by the folder's identity: one folder can still come back under two
+ * spellings (a short 8.3 name, another case). A link that is right must be
+ * left alone; rewriting it leaves a moment in which it is missing.
+ */
 function alreadyLinked(path: string, target: string): boolean {
   try {
-    return isLink(path, lstatSync(path)) && realpathSync(path) === realpathSync(target);
+    if (!isLink(path, lstatSync(path))) return false;
+    const linked = realpathSync(path);
+    const wanted = realpathSync(target);
+    if (process.platform === "win32" ? linked.toLowerCase() === wanted.toLowerCase() : linked === wanted) return true;
+    const a = statSync(path, { bigint: true });
+    const b = statSync(target, { bigint: true });
+    return a.ino !== 0n && a.ino === b.ino && a.dev === b.dev;
   } catch {
     // Intentional ignore: A missing or stale link is recreated by ensureDirLink.
     return false;
@@ -123,22 +137,42 @@ function isLink(path: string, stats: Stats): boolean {
   return stats.isDirectory() && realpathSync(path) !== join(realpathSync(dirname(path)), basename(path));
 }
 
+/**
+ * Links this process wrote, and the last one it failed to write, by link
+ * path. A crash report about a sibling plugin that did not resolve says
+ * whether its link was rewritten just before, or could not be.
+ */
+const linkWrites = new Map<string, { count: number; at: number }>();
+const linkFailures = new Map<string, { code: string; at: number }>();
+
+function errorCode(error: unknown): string {
+  const code = (error as { code?: unknown } | null)?.code;
+  return typeof code === "string" && code ? code : error instanceof Error ? error.name : "Error";
+}
+
 /**
  * Makes `linkPath` a directory symlink to `target`, replacing whatever is
  * there. A real directory means `bun install` fetched a second copy; replacing
  * it is the whole point, otherwise the plugin runs against a duplicate React.
- * Throws when the link cannot be made.
+ * Throws when the link cannot be made. Returns whether it wrote one.
  */
-function ensureDirLink(linkPath: string, target: string): void {
-  if (alreadyLinked(linkPath, target)) return;
-  mkdirSync(dirname(linkPath), { recursive: true });
-  const existing = lstatSync(linkPath, { throwIfNoEntry: false });
-  if (existing && isLink(linkPath, existing)) unlinkSync(linkPath);
-  else if (existing) rmSync(linkPath, { recursive: true, force: true });
-  // A directory symlink on Windows needs Developer Mode or admin rights, and
-  // without them every external plugin lost `gloomberb` and `react`. A
-  // junction needs neither; other platforms ignore the type.
-  symlinkSync(target, linkPath, process.platform === "win32" ? "junction" : "dir");
+function ensureDirLink(linkPath: string, target: string): boolean {
+  if (alreadyLinked(linkPath, target)) return false;
+  try {
+    mkdirSync(dirname(linkPath), { recursive: true });
+    const existing = lstatSync(linkPath, { throwIfNoEntry: false });
+    if (existing && isLink(linkPath, existing)) unlinkSync(linkPath);
+    else if (existing) rmSync(linkPath, { recursive: true, force: true });
+    // A directory symlink on Windows needs Developer Mode or admin rights, and
+    // without them every external plugin lost `gloomberb` and `react`. A
+    // junction needs neither; other platforms ignore the type.
+    symlinkSync(target, linkPath, process.platform === "win32" ? "junction" : "dir");
+  } catch (error) {
+    linkFailures.set(linkPath, { code: errorCode(error), at: Date.now() });
+    throw error;
+  }
+  linkWrites.set(linkPath, { count: (linkWrites.get(linkPath)?.count ?? 0) + 1, at: Date.now() });
+  return true;
 }
 
 /**
@@ -152,28 +186,24 @@ function ensureDirLink(linkPath: string, target: string): void {
  * Brokers plugin and cannot load without it.
  */
 export function missingPeerPlugins(pluginDir: string, pluginsDir: string = dirname(pluginDir)): string[] {
-  let peers: string[] = [];
+  return declaredPeerPlugins(pluginDir)
+    .filter((peer) => !pluginDirectoryNames(peer).some((name) => existsSync(join(pluginsDir, name))));
+}
+
+/** The sibling plugins a plugin declares as peer dependencies, by package name. */
+export function declaredPeerPlugins(pluginDir: string): string[] {
   try {
     const pkg = JSON.parse(readFileSync(join(pluginDir, "package.json"), "utf-8"));
-    peers = Object.keys(pkg.peerDependencies ?? {}).filter(isPluginPackageName);
+    return Object.keys(pkg.peerDependencies ?? {}).filter(isPluginPackageName);
   } catch {
     // Intentional ignore: Plugins may have no package manifest; loadExternalPlugin reports missing imports.
     return [];
   }
-  return peers.filter((peer) => !pluginDirectoryNames(peer).some((name) => existsSync(join(pluginsDir, name))));
 }
 
 export function installedPeerPlugins(pluginDir: string, pluginsDir: string = dirname(pluginDir)): Array<{ peer: string; directory: string }> {
-  let peers: string[] = [];
-  try {
-    const pkg = JSON.parse(readFileSync(join(pluginDir, "package.json"), "utf-8"));
-    peers = Object.keys(pkg.peerDependencies ?? {}).filter(isPluginPackageName);
-  } catch {
-    // Intentional ignore: Plugins may have no package manifest; loadExternalPlugin reports missing imports.
-    return [];
-  }
   const installed: Array<{ peer: string; directory: string }> = [];
-  for (const peer of peers) {
+  for (const peer of declaredPeerPlugins(pluginDir)) {
     // Declared by package name, installed under a directory named for the repo:
     // the two disagree while the plugin is mid-rename.
     const directory = pluginDirectoryNames(peer).find((name) => existsSync(join(pluginsDir, name)));
@@ -182,6 +212,91 @@ export function installedPeerPlugins(pluginDir: string, pluginsDir: string = dir
   return installed;
 }
 
+/**
+ * What is at a plugin's link to a sibling plugin, for a crash report about an
+ * import of the sibling that did not resolve. Paths are named relative to the
+ * plugins folder, never in full.
+ */
+export interface PeerLinkState {
+  /** The sibling's folder under the plugins folder, null when it is not installed. */
+  directory: string | null;
+  link: "missing" | "junction" | "symlink" | "directory" | "file";
+  /** Where the link points: a folder in the plugins folder, `elsewhere`, or `unreadable`. */
+  target: string | null;
+  /** The link resolves to the sibling's folder. */
+  linked: boolean;
+  /** Links this process wrote at that path, and when it last did. */
+  writes: number;
+  lastWriteAt?: number;
+  /** The error of the last failed attempt to write it. */
+  lastError?: string;
+}
+
+function describeTarget(linkPath: string, pluginsDir: string): string {
+  try {
+    const raw = readlinkSync(linkPath).replace(/^\\\\\?\\|^\\\?\?\\/, "");
+    const target = isAbsolute(raw) ? raw : resolve(dirname(linkPath), raw);
+    const inside = relative(pluginsDir, target);
+    return inside && !inside.startsWith("..") && !isAbsolute(inside) ? inside : "elsewhere";
+  } catch {
+    // Intentional ignore: a junction Bun cannot read back is reported as such.
+    return "unreadable";
+  }
+}
+
+export function describePeerLink(pluginDir: string, peer: string, pluginsDir: string = dirname(pluginDir)): PeerLinkState {
+  const directory = pluginDirectoryNames(peer).find((name) => existsSync(join(pluginsDir, name))) ?? null;
+  const linkPath = join(pluginDir, "node_modules", peer);
+  const write = linkWrites.get(linkPath);
+  const failure = linkFailures.get(linkPath);
+  const base = {
+    directory,
+    writes: write?.count ?? 0,
+    ...(write ? { lastWriteAt: write.at } : {}),
+    ...(failure && (!write || failure.at >= write.at) ? { lastError: failure.code } : {}),
+  };
+  let stats: Stats | undefined;
+  try {
+    stats = lstatSync(linkPath, { throwIfNoEntry: false });
+  } catch (error) {
+    return { ...base, link: "missing", target: null, linked: false, lastError: errorCode(error) };
+  }
+  if (!stats) return { ...base, link: "missing", target: null, linked: false };
+  let link: PeerLinkState["link"];
+  try {
+    link = isLink(linkPath, stats)
+      ? (process.platform === "win32" ? "junction" : "symlink")
+      : stats.isDirectory() ? "directory" : "file";
+  } catch {
+    // Intentional ignore: a link whose target is gone cannot be resolved to compare.
+    link = stats.isSymbolicLink() ? (process.platform === "win32" ? "junction" : "symlink") : "file";
+  }
+  const isLinkType = link === "junction" || link === "symlink";
+  return {
+    ...base,
+    link,
+    target: isLinkType ? describeTarget(linkPath, pluginsDir) : null,
+    linked: directory !== null && alreadyLinked(linkPath, join(pluginsDir, directory)),
+  };
+}
+
+/**
+ * Makes the link to one sibling plugin again, when it is not already right.
+ * Returns `yes` when it wrote one, `no` when the link was right, `no-sibling`
+ * when the sibling is not installed, and `failed:<code>` when the link could
+ * not be written.
+ */
+export function relinkPeerPlugin(pluginDir: string, peer: string, pluginsDir: string = dirname(pluginDir)): string {
+  const directory = pluginDirectoryNames(peer).find((name) => existsSync(join(pluginsDir, name)));
+  if (!directory) return "no-sibling";
+  try {
+    return ensureDirLink(join(pluginDir, "node_modules", peer), join(pluginsDir, directory)) ? "yes" : "no";
+  } catch (error) {
+    logFailure("plugin-host-link", "Peer runtime link creation failed")(error);
+    return `failed:${errorCode(error)}`;
+  }
+}
+
 /** What an import without an extension can name: the file, one with an extension Bun tries, or a folder's index. */
 const MODULE_SUFFIXES = ["", ".ts", ".tsx", ".js", ".jsx", ".mjs", "/index.ts", "/index.tsx", "/index.js"];
 
@@ -282,7 +397,7 @@ export function linkHostPackages(
       linked: peers,
       skipped: [...LINKED_PACKAGES],
       provider: "process",
-      error: "Could not locate the Gloomberb install.",
+      error: "Could not locate the Gloom install.",
     };
   }
 

package/src/plugins/installer.ts

@@ -5,7 +5,7 @@ import { execFile as execFileCallback, execFileSync, spawn } from "child_process
 import { promisify } from "util";
 import { findAbsorbedPlugin, type AbsorbedPlugin } from "./absorbed";
 import type { PluginPin } from "./marketplace/store";
-import { bunCommand } from "./dependencies";
+import { bunCommand, recordDependencyInstall } from "./dependencies";
 import { linkHostPackages, missingPeerPlugins } from "./host-link";
 import {
   findAbsorbedCheckout,
@@ -16,6 +16,7 @@ import {
   resolvePluginEntry,
 } from "./loader";
 import { pluginDirectoryNames } from "./plugin-names";
+import { gitInstallAdvice } from "./extracted-plugins";
 import { pluginFromModule } from "./plugin-export";
 import type { GloomPlugin } from "../types/plugin";
 import { cliStyles } from "../utils/cli-output";
@@ -137,12 +138,35 @@ function run(
   });
 }
 
+/** Whether a `git` command is on the PATH; plugins from GitHub need one to install or update. */
+export function gitInstalled(): boolean {
+  if (typeof Bun !== "undefined") return Bun.which("git") !== null;
+  return gitSucceeds(["--version"], process.cwd());
+}
+
+/** What a plugin install says when there is no git to run: what to install, then to try again. */
+function gitMissingMessage(platform: string = process.platform): string {
+  const advice = gitInstallAdvice(platform, true);
+  return `Git is not installed. Plugins from GitHub need it: ${advice}, then try again.`;
+}
+
+/**
+ * Runs git with its output kept off the terminal: progress, "Cloning into" and
+ * the detached-HEAD advice a pinned checkout prints are chatter, and a failure
+ * says what went wrong in its error, from git's last line.
+ */
 async function git(args: string[], cwd: string, quiet: boolean, failure: string): Promise<string> {
   // Quiet means the app owns the screen, or there is no terminal at all: a
   // repository that wants credentials fails instead of prompting on it.
   const env = quiet ? { ...process.env, GIT_TERMINAL_PROMPT: "0" } : undefined;
-  const result = await run("git", args, cwd, { stdout: "pipe", stderr: quiet ? "pipe" : "inherit" }, env)
-    .catch((): RunResult => { /* Intentional ignore: git immediately throws GitError when the command cannot start. */ return { code: null, stdout: "", stderr: "" }; });
+  let result: RunResult;
+  try {
+    result = await run("git", ["-c", "advice.detachedHead=false", ...args], cwd, { stdout: "pipe", stderr: "pipe" }, env);
+  } catch (error) {
+    // git could not start: almost always because it is not installed.
+    const missing = (error as NodeJS.ErrnoException | null)?.code === "ENOENT";
+    throw new GitError(failure, missing ? gitMissingMessage() : String(error));
+  }
   if (result.code !== 0) throw new GitError(failure, result.stderr);
   return result.stdout.trim();
 }
@@ -252,14 +276,15 @@ async function installDependencies(targetDir: string, quiet: boolean): Promise<v
   const output = quiet ? "pipe" : "inherit";
   const bun = bunCommand();
   const result = bun
-    ? await run(bun.command, ["install", "--production"], targetDir, { stdout: output, stderr: output }, bun.env).catch(logFailure("plugin-installer", "Plugin dependency installation failed", null))
+    ? await recordDependencyInstall(targetDir, () => run(bun.command, ["install", "--production"], targetDir, { stdout: output, stderr: output }, bun.env)
+      .catch(logFailure("plugin-installer", "Plugin dependency installation failed", null)))
     : null;
   if (result?.code !== 0 && !quiet) console.error(cliStyles.warning("Warning: failed to install plugin dependencies."));
 
   // After `bun install`, which prunes links it does not know about.
   const link = linkHostPackages(targetDir);
   if (link.error && !quiet) {
-    console.error(cliStyles.warning(`Warning: could not link the Gloomberb runtime (${link.error}).`));
+    console.error(cliStyles.warning(`Warning: could not link the Gloom runtime (${link.error}).`));
     console.error(cliStyles.muted("The plugin's \"gloomberb/*\" imports will not resolve."));
   }
 }
@@ -284,7 +309,7 @@ async function readPluginExport(targetDir: string): Promise<Pick<GloomPlugin, "i
  * never runs.
  */
 function refuseAbsorbed(absorbed: AbsorbedPlugin | null): void {
-  if (absorbed) fail(`${absorbed.name} is built into Gloomberb now.`);
+  if (absorbed) fail(`${absorbed.name} is built into Gloom now.`);
 }
 
 function describe(targetDir: string, directory: string, plugin: PluginDirectoryInfo["plugin"]): PluginDirectoryInfo {
@@ -302,7 +327,7 @@ export async function installPlugin(ref: string, options: PluginInstallOptions =
   const targetDir = join(PLUGINS_DIR, name);
 
   if (existsSync(targetDir)) {
-    fail(`Plugin "${name}" already exists.`, `Use "gloomberb update ${name}" to refresh it.`);
+    fail(`Plugin "${name}" already exists.`, `Use "gloom update ${name}" to refresh it.`);
   }
 
   say(cliStyles.accent(`Installing ${name}`));
@@ -561,7 +586,7 @@ export async function installListedPlugin(
   const known = listings ?? await loadRegistryListings();
   const listing = known.get(repo);
   const required = requiredGloomberb(listing?.minGloomberb);
-  if (required) fail(`${ref} needs Gloomberb ${required}, this is ${VERSION}.`, "Update Gloomberb first.");
+  if (required) fail(`${ref} needs Gloom ${required}, this is ${VERSION}.`, "Update Gloom first.");
   const reviewed = pin ?? listing?.pin;
   const installed = await installPlugin(ref, { ...shared, ...(reviewed ? { pin: reviewed } : {}) });
   const missing = missingPeerPlugins(installed.path);
@@ -610,7 +635,7 @@ export async function linkPlugin(sourcePath: string, options: PluginInstallOptio
   const targetDir = join(PLUGINS_DIR, name);
   const existing = lstatSync(targetDir, { throwIfNoEntry: false });
   if (existing && !existing.isSymbolicLink()) {
-    fail(`Plugin "${name}" is already installed.`, `Remove it first with "gloomberb remove ${name}".`);
+    fail(`Plugin "${name}" is already installed.`, `Remove it first with "gloom remove ${name}".`);
   }
   if (existing) rmSync(targetDir, { force: true });
   symlinkSync(source, targetDir, "dir");
@@ -618,7 +643,7 @@ export async function linkPlugin(sourcePath: string, options: PluginInstallOptio
   const plugin = await readPluginExport(source).catch(logFailure("plugin-installer", "Linked plugin validation failed", null));
   if (!options.quiet) {
     console.log(cliStyles.success(`Linked ${plugin?.name ?? name} from ${source}`));
-    console.log(cliStyles.muted(`Check it with "gloomberb plugin doctor ${name}".`));
+    console.log(cliStyles.muted(`Check it with "gloom plugin doctor ${name}".`));
   }
   return describe(source, name, plugin);
 }