@gloom-sh/terminal 0.0.0-stage → 0.18.5

package/src/ui/qr.ts

@@ -0,0 +1,84 @@
+/**
+ * QR rendering for both hosts: half-block Unicode lines for the terminal, and
+ * an SVG data URI for the desktop web host, which must not draw shapes with
+ * cell characters and would render them with unscannable line gaps anyway.
+ *
+ * A QR code must be dark-on-light for phone cameras, so both outputs have to be
+ * painted with a dark foreground on a light background whatever the theme is.
+ */
+import qrcode from "qrcode-generator";
+
+/** Mandatory light border around the code: the QR spec requires 4 modules on every side. */
+const QUIET_ZONE_MODULES = 4;
+
+const BOTH_LIGHT = " ";
+const TOP_DARK = "\u2580"; // ▀
+const BOTTOM_DARK = "\u2584"; // ▄
+const BOTH_DARK = "\u2588"; // █
+
+/** Quiet zone included, so callers only deal with one coordinate space. */
+function qrGrid(text: string): { size: number; isDark: (row: number, col: number) => boolean } {
+  const qr = qrcode(0, "M");
+  qr.addData(text);
+  qr.make();
+
+  const moduleCount = qr.getModuleCount();
+  return {
+    size: moduleCount + QUIET_ZONE_MODULES * 2,
+    isDark: (row: number, col: number): boolean => {
+      const moduleRow = row - QUIET_ZONE_MODULES;
+      const moduleCol = col - QUIET_ZONE_MODULES;
+      if (moduleRow < 0 || moduleCol < 0 || moduleRow >= moduleCount || moduleCol >= moduleCount) {
+        return false;
+      }
+      return qr.isDark(moduleRow, moduleCol);
+    },
+  };
+}
+
+export function renderQrLines(text: string): string[] {
+  const { size, isDark } = qrGrid(text);
+
+  const lines: string[] = [];
+  for (let row = 0; row < size; row += 2) {
+    let line = "";
+    for (let col = 0; col < size; col += 1) {
+      const top = isDark(row, col);
+      // An odd total height leaves the last line with no bottom row; pad it light.
+      const bottom = row + 1 < size && isDark(row + 1, col);
+      line += top ? (bottom ? BOTH_DARK : TOP_DARK) : (bottom ? BOTTOM_DARK : BOTH_LIGHT);
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+/**
+ * One `background-image` value for the desktop host, and the modules across
+ * it, quiet zone included, so the host can draw each module in whole pixels.
+ * Runs of dark modules are merged into a single rect per run so the markup
+ * stays small, and `shape-rendering="crispEdges"` keeps module edges from
+ * being blurred away.
+ */
+export function renderQrSvgDataUri(text: string): { image: string; modules: number } {
+  const { size, isDark } = qrGrid(text);
+
+  let rects = "";
+  for (let row = 0; row < size; row += 1) {
+    let runStart: number | null = null;
+    for (let col = 0; col <= size; col += 1) {
+      const dark = col < size && isDark(row, col);
+      if (dark && runStart === null) runStart = col;
+      if (!dark && runStart !== null) {
+        rects += `<rect x="${runStart}" y="${row}" width="${col - runStart}" height="1"/>`;
+        runStart = null;
+      }
+    }
+  }
+
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" shape-rendering="crispEdges">`
+    + `<rect width="${size}" height="${size}" fill="#ffffff"/>`
+    + `<g fill="#000000">${rects}</g>`
+    + "</svg>";
+  return { image: `url("data:image/svg+xml,${encodeURIComponent(svg)}")`, modules: size };
+}

package/src/ui/resize-settle.ts

@@ -0,0 +1,128 @@
+import { useContext, useEffect, useRef, useState } from "react";
+import { isLiveResizing, onLiveResizeEnd } from "./live-resize";
+import { LivePaneFrameContext, type CellSize } from "./live-stretch";
+
+/**
+ * How long a box's size has to hold still before what is laid out in it
+ * settles at that size. A resize's content catches up every 100 ms
+ * (live-resize.ts), so a pane under the pointer stays resizing between its
+ * catch-ups.
+ */
+export const RESIZE_SETTLE_MS = 120;
+
+/**
+ * How far a box may stretch from the size its layout was made for, on either
+ * axis, before the layout is made again mid-resize: past this, tiles and
+ * blocks drawn in percentages of the old size would look squashed or pulled.
+ */
+const MAX_HELD_STRETCH = 1.5;
+
+export interface ResizeHold {
+  /** The box's size as it last rendered. */
+  size: CellSize;
+  /** While the box is resizing, the size its layout holds to; null at rest. */
+  held: CellSize | null;
+}
+
+function stretch(from: number, to: number): number {
+  return from > 0 && to > 0 ? Math.max(from / to, to / from) : Infinity;
+}
+
+/**
+ * The box rendered at `size`: the first change of a resize holds the layout at
+ * the size it had, later ones keep it there, and a stretch past
+ * MAX_HELD_STRETCH lays it out again at the new size (still resizing).
+ */
+export function nextResizeHold(state: ResizeHold, size: CellSize, maxStretch = MAX_HELD_STRETCH): ResizeHold {
+  if (state.size.width === size.width && state.size.height === size.height) return state;
+  const held = state.held ?? state.size;
+  const far = Math.max(stretch(held.width, size.width), stretch(held.height, size.height)) > maxStretch;
+  return { size, held: far ? size : held };
+}
+
+/** At rest: the layout takes the box's size. */
+export function settleResizeHold(state: ResizeHold): ResizeHold {
+  return state.held ? { size: state.size, held: null } : state;
+}
+
+export interface SettledLayoutSize extends CellSize {
+  /**
+   * The box is being resized: from the first move of a resize that has its
+   * pane's frame, or its first change of size, until it has held still for
+   * RESIZE_SETTLE_MS with the pointer let go. Nothing laid out in it should
+   * animate meanwhile.
+   */
+  resizing: boolean;
+}
+
+/**
+ * Desktop: the size to lay out a surface at whose content is placed in
+ * percentages of its box (a heat map's tiles), and whether that box is being
+ * resized. A pane resize, a divider, a maximise or restore and a window
+ * resize all change the box's size, often once a frame; laying the content
+ * out again at every one of them costs a full restyle and moves every tile
+ * each time. Instead, while the size changes the layout holds to the size it
+ * had and the box stretches it by CSS, and once the size has held still it is
+ * laid out once, at the size the box settled on. A stretch too far from the
+ * held size lays it out again on the way.
+ *
+ * `resizing` is the shared signal for anything that animates when its layout
+ * changes (a glide, a fade, a pulse): none of it while the size is changing.
+ * Off (`enabled: false`, the terminal), the size is the box's at once.
+ */
+export function useSettledLayoutSize(
+  width: number,
+  height: number,
+  { enabled = true }: { enabled?: boolean } = {},
+): SettledLayoutSize {
+  const [state, setState] = useState<ResizeHold>(() => ({ size: { width, height }, held: null }));
+  let current = state;
+  if (state.size.width !== width || state.size.height !== height) {
+    // Stored while rendering, so the render that has the new size already lays out at the held one.
+    current = enabled ? nextResizeHold(state, { width, height }) : { size: { width, height }, held: null };
+    setState(current);
+  }
+
+  // A resize that has this pane's frame: it holds still from the first move, before its content catches up.
+  const frame = useContext(LivePaneFrameContext);
+  const [framed, setFramed] = useState(false);
+  const framedRef = useRef(false);
+  useEffect(() => {
+    // Called on every move: only a resize starting or ending is news.
+    const follow = () => {
+      const next = enabled && frame !== null && frame.live() !== null;
+      if (next === framedRef.current) return;
+      framedRef.current = next;
+      setFramed(next);
+    };
+    follow();
+    return enabled ? frame?.subscribe(follow) : undefined;
+  }, [enabled, frame]);
+
+  useEffect(() => {
+    if (!state.held || framed) return;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    let stopWaiting: (() => void) | null = null;
+    const settle = () => {
+      timer = null;
+      // A box still under the pointer (a sidebar, a split) settles when it is let go, not when the pointer pauses.
+      if (isLiveResizing()) {
+        stopWaiting = onLiveResizeEnd(() => {
+          stopWaiting?.();
+          stopWaiting = null;
+          timer = setTimeout(settle, RESIZE_SETTLE_MS);
+        });
+        return;
+      }
+      setState(settleResizeHold);
+    };
+    timer = setTimeout(settle, RESIZE_SETTLE_MS);
+    return () => {
+      if (timer !== null) clearTimeout(timer);
+      stopWaiting?.();
+    };
+  }, [framed, state]);
+
+  const layout = current.held ?? current.size;
+  return { width: layout.width, height: layout.height, resizing: enabled && (current.held !== null || framed) };
+}

package/src/ui/scroll-box-axis.ts

@@ -0,0 +1,26 @@
+/**
+ * Which axes a ScrollBox scrolls on, decided from its props. The terminal and
+ * DOM hosts and the pane keyboard scroll registration all read it here, so a
+ * ScrollBox that omits `scrollY` behaves the same everywhere: it scrolls
+ * vertically, with the wheel and with the arrows, PageUp, PageDown, Home and
+ * End. Pass `scrollY={false}` to turn that off.
+ */
+interface ScrollBoxAxisProps {
+  scrollX?: unknown;
+  scrollY?: unknown;
+  height?: unknown;
+}
+
+/**
+ * A one-row strip that only scrolls sideways: tab bars, table headers and
+ * chart legends. It is not a vertical scroller even though `scrollY` is
+ * omitted.
+ */
+export function isHeaderStripScrollBox(props: ScrollBoxAxisProps): boolean {
+  return props.scrollX === true && props.scrollY !== true && props.height === 1;
+}
+
+/** Whether the ScrollBox scrolls vertically: unless `scrollY` is false, and never a header strip. */
+export function scrollBoxScrollsVertically(props: ScrollBoxAxisProps): boolean {
+  return props.scrollY !== false && !isHeaderStripScrollBox(props);
+}

package/src/ui/sticky-scroll.ts

@@ -0,0 +1,7 @@
+/**
+ * How far from the bottom, in px, a scroller still counts as at the bottom.
+ * A reader a few pixels short of it is following the list, not reading back.
+ * The DOM scroll box follows the bottom by this rule, and a list that shows
+ * "new below" controls reads the same line.
+ */
+export const STICKY_BOTTOM_THRESHOLD_PX = 4;

package/src/ui/toast.tsx

@@ -0,0 +1,147 @@
+import { createContext, useContext, type ComponentType, type ReactNode } from "react";
+
+/** @public */
+export interface ToastAction {
+  label: string;
+  onClick(): void;
+}
+
+/** @public */
+export interface ToastOptions {
+  title?: string;
+  subtitle?: string;
+  duration?: number;
+  action?: ToastAction;
+  /** Rendered next to `action`. Use for a dismissing counterpart such as snooze. */
+  secondaryAction?: ToastAction;
+}
+
+export interface ToastHost {
+  Viewport: ComponentType<{ position?: string }>;
+  success(body: string, options?: ToastOptions): string | number | undefined;
+  error(body: string, options?: ToastOptions): string | number | undefined;
+  info(body: string, options?: ToastOptions): string | number | undefined;
+  dismiss(id: string | number): void;
+  /** Runs the newest visible toast's action, for the keyboard. False when no toast has one. */
+  activateNewest?(): boolean;
+  /** Dismisses the newest visible toast, for the keyboard. False when none is showing. */
+  dismissNewest?(): boolean;
+}
+
+export type ToastTone = "success" | "error" | "info";
+
+interface ToastRecord {
+  id: number;
+  body: string;
+  tone: ToastTone;
+  options?: ToastOptions;
+}
+
+/** A host's toasts minus how they draw. Each renderer supplies its own `Viewport`. */
+export interface ToastStore extends Omit<ToastHost, "Viewport"> {
+  activateNewest(): boolean;
+  dismissNewest(): boolean;
+  subscribe(listener: () => void): () => void;
+  /** The toasts on screen, oldest first. The same array until something changes. */
+  getSnapshot(): readonly ToastRecord[];
+}
+
+const MAX_VISIBLE_TOASTS = 4;
+/** Small buffer above the visible cap so a dismissal can reveal a recent toast. */
+const MAX_RETAINED_TOASTS = 8;
+const DEFAULT_TOAST_DURATION_MS = 4_000;
+
+export function createToastStore(): ToastStore {
+  let nextToastId = 1;
+  let toasts: ToastRecord[] = [];
+  let visible: ToastRecord[] = [];
+  const listeners = new Set<() => void>();
+  const timers = new Map<number, ReturnType<typeof setTimeout>>();
+
+  const clearTimer = (id: number) => {
+    clearTimeout(timers.get(id));
+    timers.delete(id);
+  };
+  const publish = (next: ToastRecord[]) => {
+    toasts = next;
+    visible = next.slice(-MAX_VISIBLE_TOASTS);
+    for (const listener of listeners) listener();
+  };
+  const dismiss = (id: string | number) => {
+    const numericId = typeof id === "number" ? id : Number(id);
+    if (!Number.isFinite(numericId)) return;
+    clearTimer(numericId);
+    const next = toasts.filter((toast) => toast.id !== numericId);
+    if (next.length !== toasts.length) publish(next);
+  };
+  const add = (tone: ToastTone) => (body: string, options?: ToastOptions): number => {
+    const id = nextToastId++;
+    // Only the newest MAX_VISIBLE_TOASTS render, so anything past the cap is
+    // unreachable. Keeping it would let a dismissal resurface a stale toast.
+    const kept = [...toasts, { id, body, tone, options }].slice(-MAX_RETAINED_TOASTS);
+    for (const dropped of toasts) {
+      if (!kept.some((toast) => toast.id === dropped.id)) clearTimer(dropped.id);
+    }
+    publish(kept);
+    const duration = options?.duration ?? DEFAULT_TOAST_DURATION_MS;
+    // 0 and Infinity both mean "until dismissed".
+    if (Number.isFinite(duration) && duration > 0) {
+      timers.set(id, setTimeout(() => dismiss(id), duration));
+    }
+    return id;
+  };
+
+  return {
+    success: add("success"),
+    error: add("error"),
+    info: add("info"),
+    dismiss,
+    activateNewest() {
+      const toast = visible.findLast((entry) => entry.options?.action);
+      const action = toast?.options?.action;
+      if (!toast || !action) return false;
+      try {
+        action.onClick();
+      } finally {
+        dismiss(toast.id);
+      }
+      return true;
+    },
+    dismissNewest() {
+      const toast = visible.at(-1);
+      if (!toast) return false;
+      dismiss(toast.id);
+      return true;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getSnapshot: () => visible,
+  };
+}
+
+const ToastContext = createContext<ToastHost | null>(null);
+
+export function ToastHostProvider({
+  host,
+  children,
+}: {
+  host: ToastHost;
+  children: ReactNode;
+}) {
+  return <ToastContext value={host}>{children}</ToastContext>;
+}
+
+export function useToastHost(): ToastHost {
+  const host = useContext(ToastContext);
+  if (!host) throw new Error("useToastHost must be used inside ToastHostProvider");
+  return host;
+}
+
+export function ToastViewport(props: { position?: string }) {
+  const { Viewport } = useToastHost();
+  return <Viewport {...props} />;
+}

package/src/updater/channel.ts

@@ -0,0 +1,51 @@
+import type { AppConfig, UpdateChannel, UpdatesConfig } from "../types/config";
+import { isRecord } from "../utils/guards";
+import { isPrereleaseVersion } from "../utils/semver";
+
+/** Overrides the saved channel for one run: `GLOOMBERB_UPDATE_CHANNEL=nightly gloomberb`. */
+const UPDATE_CHANNEL_ENV = "GLOOMBERB_UPDATE_CHANNEL";
+
+/** What the nightly channel is, in the words the settings and docs use. */
+export const NIGHTLY_CHANNEL_SUMMARY = "a daily build of main that gets fixes first and can break";
+
+export function parseUpdateChannel(value: unknown): UpdateChannel | null {
+  if (typeof value !== "string") return null;
+  const channel = value.trim().toLowerCase();
+  return channel === "stable" || channel === "nightly" ? channel : null;
+}
+
+/** Only nightly is saved: stable is what an absent setting means. */
+export function sanitizeUpdatesConfig(value: unknown): UpdatesConfig | undefined {
+  if (!isRecord(value)) return undefined;
+  return parseUpdateChannel(value.channel) === "nightly" ? { channel: "nightly" } : undefined;
+}
+
+/** The config with `channel` saved, or without the setting when it is stable. */
+export function withUpdateChannel(config: AppConfig, channel: UpdateChannel): AppConfig {
+  const { updates: _previous, ...rest } = config;
+  return channel === "nightly" ? { ...rest, updates: { channel } } : rest;
+}
+
+/**
+ * Whether a downloaded update still follows `channel`'s rules: nightly takes
+ * any newer release, stable only a stable one. A nightly build downloaded
+ * before the switch back to stable does not fit, and is taken back rather
+ * than installed by the next restart.
+ */
+export function stagedUpdateFitsChannel(release: { version: string } | null | undefined, channel: UpdateChannel): boolean {
+  return channel === "nightly" || !release || !isPrereleaseVersion(release.version);
+}
+
+function readChannelOverride(): string | undefined {
+  // The browser and desktop views have no process; only the terminal reads it.
+  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env;
+  return env?.[UPDATE_CHANNEL_ENV];
+}
+
+/** The channel this run updates on: `GLOOMBERB_UPDATE_CHANNEL` when it names one, else the saved setting, else stable. */
+export function resolveUpdateChannel(
+  config: Pick<AppConfig, "updates">,
+  override: string | undefined = readChannelOverride(),
+): UpdateChannel {
+  return parseUpdateChannel(override) ?? config.updates?.channel ?? "stable";
+}

package/src/updater/command-names.ts

@@ -0,0 +1,180 @@
+import { lstatSync, symlinkSync } from "fs";
+import { lstat, readFile, readlink, stat, symlink, writeFile } from "fs/promises";
+import { basename, dirname, join, resolve } from "path";
+
+/**
+ * The terminal command is `gloom`. `gloomberb`, its name before 0.18.4, keeps
+ * working beside it, for scripts and habits.
+ *
+ * An install from before the rename has only `gloomberb`, and the ways it
+ * updates (the standalone binary replacing itself, the desktop app replacing
+ * its bundle) never add a command. So the new build adds `gloom` beside
+ * `gloomberb` when it runs. A `gloom` that is already there, whatever it is,
+ * is left alone, and a folder this user cannot write is skipped.
+ *
+ * The desktop app looks through PATH, which can hold a slow or unreachable
+ * network folder, so its half only reads and writes asynchronously and runs
+ * once the app is up.
+ */
+const COMMAND_NAME = "gloom";
+const LEGACY_COMMAND_NAME = "gloomberb";
+
+/** The file the desktop app's Windows command runs, which tells its `gloomberb.cmd` from another program's. */
+const WINDOWS_SHIM_ENTRY = "gloomberb-tui\\tui-entry.js";
+
+function pathExists(path: string): boolean {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    // Intentional ignore: a missing path, or one this user cannot see; either way nothing is added there.
+    return false;
+  }
+}
+
+function addSymlink(target: string, path: string): string | null {
+  try {
+    symlinkSync(target, path);
+    return path;
+  } catch {
+    // Intentional ignore: a read-only or root-owned folder keeps the command it has.
+    return null;
+  }
+}
+
+/**
+ * For the standalone binary, which updates by replacing itself: links the
+ * other name to it in its own folder, `gloom` beside a `gloomberb` installed
+ * before the rename (or `gloomberb` beside a `gloom`). Returns the link it
+ * added, or null. A binary under any other name is left as it is.
+ */
+export function linkStandaloneCommand(execPath: string): string | null {
+  const name = basename(execPath);
+  const other = name === COMMAND_NAME ? LEGACY_COMMAND_NAME : name === LEGACY_COMMAND_NAME ? COMMAND_NAME : null;
+  if (!other) return null;
+  const path = join(dirname(execPath), other);
+  if (pathExists(path)) return null;
+  // Relative, as install.sh links it, so the pair still works if the folder moves.
+  return addSymlink(name, path);
+}
+
+/** Homebrew's prefixes on Apple Silicon and on Intel. */
+export const HOMEBREW_PREFIXES = ["/opt/homebrew", "/usr/local"];
+
+/** Homebrew's command folders on Apple Silicon and on Intel. */
+const HOMEBREW_BINS = HOMEBREW_PREFIXES.map((prefix) => join(prefix, "bin"));
+
+/**
+ * Where a Mac keeps the desktop app's command: install.sh's folder, `~/bin`,
+ * Homebrew's, then the rest of PATH. A GUI app's PATH rarely has the first
+ * ones, so they are named outright.
+ */
+export function macCommandFolders(homeDir: string, pathEnv: string, homebrewBins: readonly string[] = HOMEBREW_BINS): string[] {
+  return [...new Set([
+    homeDir ? join(homeDir, ".local", "bin") : "",
+    homeDir ? join(homeDir, "bin") : "",
+    ...homebrewBins,
+    ...pathEnv.split(":"),
+  ].filter(Boolean))];
+}
+
+async function pathExistsAsync(path: string, followLinks = false): Promise<boolean> {
+  try {
+    await (followLinks ? stat(path) : lstat(path));
+    return true;
+  } catch {
+    // Intentional ignore: a missing path, or one this user cannot see; either way nothing is added there.
+    return false;
+  }
+}
+
+/**
+ * Next to a `gloomberb` link into an app bundle, adds `gloom` linked to the
+ * same bundle's `gloom`. The target is written the way Homebrew writes its
+ * own links, so a later `brew upgrade` sees the link as its own.
+ */
+async function linkMacCommand(folder: string): Promise<string | null> {
+  let target: string;
+  try {
+    target = await readlink(join(folder, LEGACY_COMMAND_NAME));
+  } catch {
+    // Intentional ignore: not there, or not a link; a standalone binary adds its own when it runs.
+    return null;
+  }
+  const absolute = resolve(folder, target);
+  if (!absolute.endsWith(`.app/Contents/Resources/${LEGACY_COMMAND_NAME}`)) return null;
+  const bundleCommand = join(dirname(absolute), COMMAND_NAME);
+  const path = join(folder, COMMAND_NAME);
+  if (!(await pathExistsAsync(bundleCommand, true)) || await pathExistsAsync(path)) return null;
+  try {
+    await symlink(bundleCommand, path);
+    return path;
+  } catch {
+    // Intentional ignore: a read-only or root-owned folder keeps the command it has.
+    return null;
+  }
+}
+
+/**
+ * Next to the desktop app's `gloomberb.cmd`, adds a `gloom.cmd` with the same
+ * contents. The command finds the app from its own folder, so the copy runs
+ * the same app.
+ */
+async function copyWindowsCommand(folder: string): Promise<string | null> {
+  let shim: string;
+  try {
+    shim = await readFile(join(folder, `${LEGACY_COMMAND_NAME}.cmd`), "utf8");
+  } catch {
+    // Intentional ignore: no gloomberb.cmd, so this PATH folder belongs to another program.
+    return null;
+  }
+  if (!shim.includes(WINDOWS_SHIM_ENTRY)) return null;
+  const path = join(folder, `${COMMAND_NAME}.cmd`);
+  if (await pathExistsAsync(path)) return null;
+  try {
+    await writeFile(path, shim, { flag: "wx" });
+    return path;
+  } catch {
+    // Intentional ignore: a folder this user cannot write keeps the command it has.
+    return null;
+  }
+}
+
+interface DesktopCommandOptions {
+  platform: string;
+  homeDir: string;
+  /** PATH as the app sees it. */
+  pathEnv: string;
+  /** `%LOCALAPPDATA%`, where the Windows installer puts the app by default (`Programs\Gloom`, `Programs\Gloomberb` before the rename). */
+  localAppData?: string;
+  /** Homebrew's command folders; tests pass none. */
+  homebrewBins?: readonly string[];
+}
+
+/**
+ * For the desktop app, which updates by replacing its bundle: adds `gloom`
+ * wherever an installer put the app's `gloomberb` command (install.sh and
+ * Homebrew links on a Mac, the installer's PATH folder on Windows). Resolves
+ * to the commands it added. Folders are looked at side by side, so a slow one
+ * holds up only itself.
+ */
+export async function linkDesktopCommands({
+  platform,
+  homeDir,
+  pathEnv,
+  localAppData,
+  homebrewBins = HOMEBREW_BINS,
+}: DesktopCommandOptions): Promise<string[]> {
+  let added: Array<string | null> = [];
+  if (platform === "darwin") {
+    added = await Promise.all(macCommandFolders(homeDir, pathEnv, homebrewBins).map(linkMacCommand));
+  } else if (platform === "win32") {
+    const folders = new Set([
+      localAppData ? join(localAppData, "Programs", "Gloom", "bin") : "",
+      localAppData ? join(localAppData, "Programs", "Gloomberb", "bin") : "",
+      ...pathEnv.split(";"),
+    ].filter(Boolean));
+    added = await Promise.all([...folders].map(copyWindowsCommand));
+  }
+  return added.filter((path): path is string => path !== null);
+}