@blackbelt-technology/pi-agent-dashboard 0.4.5 → 0.5.0

package/packages/shared/src/__tests__/doctor-format.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Doctor markdown formatter — section ordering, escaping, remediation list.
+ * See change: doctor-rich-output (design.md Decision 8).
+ */
+import { describe, it, expect } from "vitest";
+import {
+  formatDoctorReportMarkdown,
+  formatDoctorReportPlain,
+  type DoctorReport,
+  type DoctorCheck,
+} from "../doctor-core.js";
+
+function mkReport(checks: DoctorCheck[]): DoctorReport {
+  const summary = {
+    ok: checks.filter((c) => c.status === "ok").length,
+    warnings: checks.filter((c) => c.status === "warning").length,
+    errors: checks.filter((c) => c.status === "error").length,
+  };
+  return { checks, summary };
+}
+
+describe("formatDoctorReportMarkdown", () => {
+  it("emits one table per non-empty section in fixed order", () => {
+    const report = mkReport([
+      { name: "API key", section: "setup", status: "ok", message: "Configured" },
+      { name: "pi CLI", section: "pi-tooling", status: "ok", message: "v1" },
+      { name: "Electron", section: "runtime", status: "ok", message: "v40" },
+      {
+        name: "Managed install (~/.pi-dashboard)",
+        section: "diagnostics",
+        status: "ok",
+        message: "fine",
+      },
+    ]);
+    const md = formatDoctorReportMarkdown(report);
+    const runtimeIdx = md.indexOf("## Runtime");
+    const piIdx = md.indexOf("## PI Tooling");
+    const setupIdx = md.indexOf("## Setup");
+    const diagIdx = md.indexOf("## Diagnostics");
+    // Server section absent — skipped silently.
+    expect(md.includes("## Server")).toBe(false);
+    expect(runtimeIdx).toBeGreaterThan(0);
+    expect(runtimeIdx).toBeLessThan(piIdx);
+    expect(piIdx).toBeLessThan(setupIdx);
+    expect(setupIdx).toBeLessThan(diagIdx);
+  });
+
+  it("includes summary line", () => {
+    const report = mkReport([
+      { name: "Electron", section: "runtime", status: "ok", message: "v40" },
+      { name: "pi CLI", section: "pi-tooling", status: "error", message: "missing", detail: "x" },
+    ]);
+    const md = formatDoctorReportMarkdown(report);
+    expect(md).toMatch(/Summary:.*1 ok.*0 warning.*1 error/);
+  });
+
+  it("omits the Remediation section when all rows are ok", () => {
+    const report = mkReport([{ name: "Electron", section: "runtime", status: "ok", message: "v40" }]);
+    const md = formatDoctorReportMarkdown(report);
+    expect(md.includes("## Remediation")).toBe(false);
+  });
+
+  it("renders Remediation bullets for non-ok rows with suggestions", () => {
+    const report = mkReport([
+      {
+        name: "pi CLI",
+        section: "pi-tooling",
+        status: "error",
+        message: "Not found",
+        detail: "PATH searched",
+        suggestion: "Run setup wizard.",
+      },
+    ]);
+    const md = formatDoctorReportMarkdown(report);
+    expect(md).toContain("## Remediation");
+    expect(md).toContain("- **pi CLI** — Run setup wizard.");
+  });
+
+  it("escapes pipe / newline / backtick in detail so the table column count is preserved", () => {
+    const detail = "line1 | with pipe\nline2 with `backtick`";
+    const report = mkReport([
+      {
+        name: "Server launch test",
+        section: "server",
+        status: "error",
+        message: "boom",
+        detail,
+      },
+    ]);
+    const md = formatDoctorReportMarkdown(report);
+    // Find the row line in the output. Each row must have exactly 4 separators
+    // outside the leading/trailing ones — i.e. the row should start with `| `
+    // and contain exactly 5 `|` characters.
+    const tableRow = md
+      .split("\n")
+      .find((l) => l.startsWith("| ") && l.includes("Server launch test"));
+    expect(tableRow).toBeDefined();
+    // A 4-column row has 5 unescaped pipes. Count unescaped pipes.
+    const unescaped = tableRow!
+      .split("")
+      .reduce(
+        (acc, ch, i, arr) =>
+          ch === "|" && arr[i - 1] !== "\\" ? acc + 1 : acc,
+        0,
+      );
+    expect(unescaped).toBe(5);
+    // No literal newline inside the cell.
+    expect(tableRow!.includes("\n")).toBe(false);
+  });
+});
+
+describe("formatDoctorReportPlain (legacy)", () => {
+  it("contains the canonical header and summary footer", () => {
+    const report = mkReport([
+      { name: "Electron", section: "runtime", status: "ok", message: "v40" },
+    ]);
+    const out = formatDoctorReportPlain(report);
+    expect(out).toContain("PI Dashboard Doctor");
+    expect(out).toContain("1 passed, 0 warnings, 0 errors");
+  });
+});

package/packages/shared/src/__tests__/install-managed-node-bootstrap-order.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Pin the call order in `installStandalone` (the Electron entry that
+ * the spec calls `installAllTools`):
+ *
+ *     installManagedNode(...) <  any sharedBootstrapInstall(...)
+ *
+ * We can't easily run installStandalone end-to-end here (it's Electron
+ * code, requires a packaged resources path, spawns real npm). So this
+ * is a script-text test that greps the dependency-installer source for
+ * the call sites and asserts their byte offsets are in the right order.
+ * If a refactor moves installManagedNode after the first npm install,
+ * the regression \u2014 a fresh Windows install having no managed Node when
+ * the very first install runs \u2014 cannot land silently.
+ *
+ * See change: embed-managed-node-runtime (task 4.3).
+ */
+import fs from "node:fs";
+import path from "node:path";
+import url from "node:url";
+import { describe, expect, it } from "vitest";
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+// packages/shared/src/__tests__/ \u2192 ../../../electron/src/lib/dependency-installer.ts
+const SOURCE_PATH = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "electron",
+  "src",
+  "lib",
+  "dependency-installer.ts",
+);
+
+describe("installStandalone call order", () => {
+  it("installManagedNode runs before sharedBootstrapInstall", () => {
+    const text = fs.readFileSync(SOURCE_PATH, "utf-8");
+
+    // Locate the installStandalone function body.
+    const fnIdx = text.indexOf("export async function installStandalone");
+    expect(fnIdx).toBeGreaterThan(-1);
+
+    // Scope the search to the function body — find its closing brace.
+    // Cheap bracket counter: starts after the first `{` after fnIdx.
+    const bodyStart = text.indexOf("{", fnIdx);
+    let depth = 0;
+    let bodyEnd = bodyStart;
+    for (let i = bodyStart; i < text.length; i++) {
+      const ch = text[i];
+      if (ch === "{") depth++;
+      else if (ch === "}") {
+        depth--;
+        if (depth === 0) {
+          bodyEnd = i;
+          break;
+        }
+      }
+    }
+    const body = text.slice(bodyStart, bodyEnd);
+
+    const managedIdx = body.indexOf("installManagedNode(");
+    const sharedIdx = body.indexOf("sharedBootstrapInstall(");
+
+    expect(managedIdx).toBeGreaterThan(-1);
+    expect(sharedIdx).toBeGreaterThan(-1);
+    expect(managedIdx).toBeLessThan(sharedIdx);
+  });
+});

package/packages/shared/src/__tests__/install-managed-node.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Unit tests for `installManagedNode` from `bootstrap-install.ts`.
+ *
+ * Uses a real tmp HOME (per the global setup-home tripwire) and a
+ * real-on-disk fake bundled-node directory. The bundled-Node version
+ * is read via the `_readVersion` test seam so we never spawn `node`
+ * here.
+ *
+ * See change: embed-managed-node-runtime (task 2.4).
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { installManagedNode } from "../bootstrap-install.js";
+
+const isWin = process.platform === "win32";
+
+function makeFakeBundle(dir: string, opts?: { partial?: boolean }): void {
+  fs.mkdirSync(dir, { recursive: true });
+  if (isWin) {
+    fs.writeFileSync(path.join(dir, "node.exe"), "fake-node-binary");
+    if (!opts?.partial) {
+      fs.writeFileSync(path.join(dir, "npm.cmd"), "@echo off\nnpm");
+      fs.writeFileSync(path.join(dir, "npx.cmd"), "@echo off\nnpx");
+    }
+    fs.mkdirSync(path.join(dir, "node_modules", "npm", "bin"), {
+      recursive: true,
+    });
+    fs.writeFileSync(
+      path.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
+      "// npm-cli",
+    );
+  } else {
+    fs.mkdirSync(path.join(dir, "bin"), { recursive: true });
+    fs.writeFileSync(path.join(dir, "bin", "node"), "fake-node-binary");
+    fs.writeFileSync(path.join(dir, "bin", "npm"), "#!/bin/sh\nnpm");
+    fs.writeFileSync(path.join(dir, "bin", "npx"), "#!/bin/sh\nnpx");
+    fs.mkdirSync(path.join(dir, "lib", "node_modules", "npm", "bin"), {
+      recursive: true,
+    });
+    fs.writeFileSync(
+      path.join(dir, "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+      "// npm-cli",
+    );
+  }
+}
+
+describe("installManagedNode", () => {
+  let tmpRoot: string;
+  let bundledDir: string;
+  let managedDir: string;
+
+  beforeEach(() => {
+    tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "managed-node-test-"));
+    bundledDir = path.join(tmpRoot, "bundled");
+    managedDir = path.join(tmpRoot, "managed");
+    makeFakeBundle(bundledDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  });
+
+  it("first run: copies tree and writes .version marker", async () => {
+    const r = await installManagedNode({
+      bundledNodeDir: bundledDir,
+      managedDir,
+      _readVersion: () => "v22.12.0",
+    });
+    expect(r.ok).toBe(true);
+    expect(r.copied).toBe(true);
+    expect(r.version).toBe("v22.12.0");
+
+    const targetBinary = isWin
+      ? path.join(managedDir, "node", "node.exe")
+      : path.join(managedDir, "node", "bin", "node");
+    expect(fs.existsSync(targetBinary)).toBe(true);
+
+    const marker = fs.readFileSync(
+      path.join(managedDir, "node", ".version"),
+      "utf-8",
+    );
+    expect(marker.trim()).toBe("v22.12.0");
+  });
+
+  it("idempotent re-run with matching version is a no-op", async () => {
+    await installManagedNode({
+      bundledNodeDir: bundledDir,
+      managedDir,
+      _readVersion: () => "v22.12.0",
+    });
+    const targetBinary = isWin
+      ? path.join(managedDir, "node", "node.exe")
+      : path.join(managedDir, "node", "bin", "node");
+    const mtimeBefore = fs.statSync(targetBinary).mtimeMs;
+
+    // Wait one tick to ensure mtime would change if we recopied.
+    await new Promise((r) => setTimeout(r, 10));
+
+    const r = await installManagedNode({
+      bundledNodeDir: bundledDir,
+      managedDir,
+      _readVersion: () => "v22.12.0",
+    });
+    expect(r.ok).toBe(true);
+    expect(r.copied).toBe(false);
+    expect(r.reason).toMatch(/version matches/);
+    const mtimeAfter = fs.statSync(targetBinary).mtimeMs;
+    expect(mtimeAfter).toBe(mtimeBefore);
+  });
+
+  it("mismatched version triggers a re-copy", async () => {
+    await installManagedNode({
+      bundledNodeDir: bundledDir,
+      managedDir,
+      _readVersion: () => "v22.12.0",
+    });
+
+    // Bundle now reports a newer version.
+    const r = await installManagedNode({
+      bundledNodeDir: bundledDir,
+      managedDir,
+      _readVersion: () => "v22.13.0",
+    });
+    expect(r.ok).toBe(true);
+    expect(r.copied).toBe(true);
+    expect(r.version).toBe("v22.13.0");
+
+    const marker = fs.readFileSync(
+      path.join(managedDir, "node", ".version"),
+      "utf-8",
+    );
+    expect(marker.trim()).toBe("v22.13.0");
+  });
+
+  it("missing bundled source: no-op without error", async () => {
+    const r = await installManagedNode({
+      bundledNodeDir: null,
+      managedDir,
+    });
+    expect(r.ok).toBe(true);
+    expect(r.copied).toBe(false);
+    expect(r.reason).toMatch(/no bundled source/);
+    expect(fs.existsSync(path.join(managedDir, "node"))).toBe(false);
+  });
+
+  it("bundled binary missing: no-op (treat as no source)", async () => {
+    const emptyBundled = path.join(tmpRoot, "empty");
+    fs.mkdirSync(emptyBundled, { recursive: true });
+    const r = await installManagedNode({
+      bundledNodeDir: emptyBundled,
+      managedDir,
+      _readVersion: () => null,
+    });
+    expect(r.ok).toBe(true);
+    expect(r.copied).toBe(false);
+    expect(r.reason).toMatch(/bundled node binary/);
+  });
+
+  it("dir present but marker missing: re-copies (treats as mismatch)", async () => {
+    // Pretend a partial copy left behind a directory with no marker.
+    fs.mkdirSync(path.join(managedDir, "node", "leftover"), { recursive: true });
+
+    const r = await installManagedNode({
+      bundledNodeDir: bundledDir,
+      managedDir,
+      _readVersion: () => "v22.12.0",
+    });
+    expect(r.ok).toBe(true);
+    expect(r.copied).toBe(true);
+    // Leftover should be gone after the rm-then-copy.
+    expect(
+      fs.existsSync(path.join(managedDir, "node", "leftover")),
+    ).toBe(false);
+    expect(
+      fs.existsSync(path.join(managedDir, "node", ".version")),
+    ).toBe(true);
+  });
+
+  it("reports progress through the callback", async () => {
+    const events: Array<{ step: string; status: string }> = [];
+    await installManagedNode({
+      bundledNodeDir: bundledDir,
+      managedDir,
+      _readVersion: () => "v22.12.0",
+      progress: (p) => events.push({ step: p.step, status: p.status }),
+    });
+    expect(events.some((e) => e.step === "node-runtime" && e.status === "running")).toBe(true);
+    expect(events.some((e) => e.step === "node-runtime" && e.status === "done")).toBe(true);
+  });
+});

package/packages/shared/src/__tests__/installable-list.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mergeInstallableList, readInstallableList, writeInstallableList } from "../installable-list.js";
+import type { InstallableList } from "../installable-list.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// ── mergeInstallableList tests ──────────────────────────────────────────────
+
+describe("mergeInstallableList", () => {
+  it("keep-user-pin: user version wins when it differs from bundled", () => {
+    const existing: InstallableList = {
+      version: "1",
+      packages: [{ name: "tsx", version: "^4.0.0", required: true, kind: "npm" }],
+    };
+    const bundled: InstallableList = {
+      version: "2",
+      packages: [{ name: "tsx", version: "^5.0.0", required: true, kind: "npm" }],
+    };
+    const { list, warnings } = mergeInstallableList(existing, bundled);
+    const found = list.packages.find((p) => p.name === "tsx");
+    expect(found?.version).toBe("^4.0.0");
+    expect(warnings.length).toBeGreaterThan(0);
+    expect(warnings[0]).toContain("tsx");
+    expect(warnings[0]).toContain("^4.0.0");
+    expect(warnings[0]).toContain("^5.0.0");
+  });
+
+  it("drop-pin-warn: package in existing but not in bundled gets deprecated=true + warning", () => {
+    const existing: InstallableList = {
+      version: "1",
+      packages: [{ name: "old-tool", version: "^1.0.0", required: false, kind: "npm" }],
+    };
+    const bundled: InstallableList = { version: "2", packages: [] };
+    const { list, warnings } = mergeInstallableList(existing, bundled);
+    const found = list.packages.find((p) => p.name === "old-tool");
+    expect(found?.deprecated).toBe(true);
+    expect(warnings.length).toBeGreaterThan(0);
+    expect(warnings[0]).toContain("old-tool");
+  });
+
+  it("add-new-required: new required package from bundled is added as-is", () => {
+    const existing: InstallableList = { version: "1", packages: [] };
+    const bundled: InstallableList = {
+      version: "2",
+      packages: [{ name: "pi", version: "*", required: true, kind: "npm" }],
+    };
+    const { list, warnings } = mergeInstallableList(existing, bundled);
+    const found = list.packages.find((p) => p.name === "pi");
+    expect(found).toBeDefined();
+    expect(found?.required).toBe(true);
+    expect(found?.defaultOff).toBeFalsy();
+    expect(warnings).toHaveLength(0);
+  });
+
+  it("add-new-optional: new optional package from bundled is added with defaultOff=true", () => {
+    const existing: InstallableList = { version: "1", packages: [] };
+    const bundled: InstallableList = {
+      version: "2",
+      packages: [{ name: "openspec", version: "*", required: false, kind: "npm" }],
+    };
+    const { list, warnings } = mergeInstallableList(existing, bundled);
+    const found = list.packages.find((p) => p.name === "openspec");
+    expect(found).toBeDefined();
+    expect(found?.defaultOff).toBe(true);
+    expect(warnings).toHaveLength(0);
+  });
+
+  it("version marker in result comes from bundled", () => {
+    const existing: InstallableList = { version: "1", packages: [] };
+    const bundled: InstallableList = { version: "42", packages: [] };
+    const { list } = mergeInstallableList(existing, bundled);
+    expect(list.version).toBe("42");
+  });
+});
+
+// ── readInstallableList tests ───────────────────────────────────────────────
+// Use a real temp directory (HOME is already ephemeral in the test runner).
+
+describe("readInstallableList", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "installable-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("returns null when file is absent", async () => {
+    const result = await readInstallableList(tmpDir);
+    expect(result).toBeNull();
+  });
+
+  it("drops entries with invalid kind and warns", async () => {
+    const list: InstallableList = {
+      version: "1",
+      packages: [
+        { name: "good-pkg", version: "*", required: true, kind: "npm" },
+        { name: "bad-pkg", version: "*", required: true, kind: "unknown-kind" as any },
+      ],
+    };
+    // Write via writeInstallableList (bypasses the drop-invalid-kind guard).
+    const filePath = path.join(tmpDir, "installable.json");
+    fs.writeFileSync(filePath, JSON.stringify(list), "utf-8");
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const result = await readInstallableList(tmpDir);
+
+    expect(result).not.toBeNull();
+    expect(result!.packages.map((p) => p.name)).toEqual(["good-pkg"]);
+    expect(warnSpy).toHaveBeenCalledOnce();
+    expect(warnSpy.mock.calls[0]![0]).toContain("bad-pkg");
+  });
+
+  it("reads a valid file and returns the list", async () => {
+    const list: InstallableList = {
+      version: "3",
+      packages: [{ name: "tsx", version: "^5.0.0", required: true, kind: "npm" }],
+    };
+    await writeInstallableList(list, tmpDir);
+    const result = await readInstallableList(tmpDir);
+    expect(result).not.toBeNull();
+    expect(result!.version).toBe("3");
+    expect(result!.packages).toHaveLength(1);
+    expect(result!.packages[0]!.name).toBe("tsx");
+  });
+});

package/packages/shared/src/__tests__/managed-node-path.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Unit tests for `prependManagedNodeToPath` and friends.
+ *
+ * Real tmp HOME (per setup-home tripwire) so `getManagedDir()` resolves
+ * under the tmp tree. We create / remove the managed Node binary on
+ * disk to flip the present/absent branches.
+ *
+ * See change: embed-managed-node-runtime (task 2.5).
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  getManagedNodeBinDir,
+  getManagedNodeBinary,
+  isManagedNodePresent,
+  prependManagedNodeToPath,
+} from "../platform/managed-node-path.js";
+import { getManagedDir } from "../managed-paths.js";
+
+const isWin = process.platform === "win32";
+
+describe("getManagedNodeBinDir", () => {
+  it("returns <managedDir>/node on Windows", () => {
+    const env = { homedir: "/fake/home" };
+    expect(getManagedNodeBinDir(env, "win32")).toBe(
+      path.join("/fake/home", ".pi-dashboard", "node"),
+    );
+  });
+
+  it("returns <managedDir>/node/bin on Unix", () => {
+    const env = { homedir: "/fake/home" };
+    expect(getManagedNodeBinDir(env, "linux")).toBe(
+      path.join("/fake/home", ".pi-dashboard", "node", "bin"),
+    );
+    expect(getManagedNodeBinDir(env, "darwin")).toBe(
+      path.join("/fake/home", ".pi-dashboard", "node", "bin"),
+    );
+  });
+});
+
+describe("getManagedNodeBinary", () => {
+  it("uses node.exe on Windows", () => {
+    expect(getManagedNodeBinary({ homedir: "/h" }, "win32")).toBe(
+      path.join("/h", ".pi-dashboard", "node", "node.exe"),
+    );
+  });
+
+  it("uses bin/node on Unix", () => {
+    expect(getManagedNodeBinary({ homedir: "/h" }, "linux")).toBe(
+      path.join("/h", ".pi-dashboard", "node", "bin", "node"),
+    );
+  });
+});
+
+describe("prependManagedNodeToPath", () => {
+  let tmpHome: string;
+  let origHome: string | undefined;
+
+  beforeEach(() => {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "managed-node-path-"));
+    origHome = process.env.HOME;
+    process.env.HOME = tmpHome;
+  });
+
+  afterEach(() => {
+    if (origHome === undefined) delete process.env.HOME;
+    else process.env.HOME = origHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  function installFakeManagedNode(): string {
+    // os.homedir() reads HOME on Unix and USERPROFILE on Windows. The
+    // setup-home tripwire only sets HOME, so on Windows tests we set
+    // USERPROFILE here too.
+    if (isWin) process.env.USERPROFILE = tmpHome;
+    const dir = getManagedNodeBinDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const binary = getManagedNodeBinary();
+    fs.writeFileSync(binary, "fake");
+    return dir;
+  }
+
+  it("no-op (returns clone) when managed runtime is absent", () => {
+    const base = { PATH: "/usr/bin:/bin", FOO: "bar" };
+    const out = prependManagedNodeToPath(base);
+    expect(out).not.toBe(base);
+    expect(out.PATH).toBe("/usr/bin:/bin");
+    expect(out.FOO).toBe("bar");
+  });
+
+  it("does not mutate process.env", () => {
+    const beforePath = process.env.PATH;
+    prependManagedNodeToPath();
+    expect(process.env.PATH).toBe(beforePath);
+  });
+
+  it("prepends managed Node bin dir when present", () => {
+    const dir = installFakeManagedNode();
+    const base = { PATH: "/usr/bin:/bin", X: "y" };
+    const out = prependManagedNodeToPath(base);
+    expect(out).not.toBe(base);
+    expect(out.PATH?.startsWith(dir)).toBe(true);
+    expect(out.PATH).toBe(`${dir}${path.delimiter}/usr/bin:/bin`);
+    expect(out.X).toBe("y");
+  });
+
+  it("does not double-prepend when dir already at head", () => {
+    const dir = installFakeManagedNode();
+    const initial = `${dir}${path.delimiter}/usr/bin`;
+    const base = { PATH: initial };
+    const out = prependManagedNodeToPath(base);
+    expect(out.PATH).toBe(initial);
+  });
+
+  it("isManagedNodePresent flips with the binary on disk", () => {
+    expect(isManagedNodePresent()).toBe(false);
+    installFakeManagedNode();
+    expect(isManagedNodePresent()).toBe(true);
+  });
+});