@blackbelt-technology/pi-agent-dashboard 0.5.2 → 0.5.4

package/packages/shared/src/__tests__/bootstrap/scenarios-skipped.ts

@@ -1,125 +0,0 @@
-/**
- * Bulk-skip manifest for cells NOT yet covered by a family-test file.
- *
- * This is the "fail-closed by default" scaffold. Every cell in the
- * cube starts SKIPPED with a documented reason. As family-test files
- * are added, they call `register(cell, tag)` and the corresponding
- * skip entry is automatically overridden (because registration takes
- * precedence in the sweep).
- *
- * New cells added to the enumeration (by extending PLATFORMS,
- * DASH_LOCATIONS, etc. in `scenarios.ts`) will fail the cube-sweep
- * test until a decision is made here or in a family file.
- *
- * Call ordering invariant: this module MUST be imported before
- * `sweepCube()` runs. Family-test files can import-and-register after
- * this module runs — registration wins.
- */
-import { enumerateCube, skip, type ScenarioCell } from "./scenarios.js";
-
-/**
- * Classify why a given cell is not interesting / not reachable in
- * practice. Returns null when the cell is plausible and should be
- * covered by a family file — such cells get a generic placeholder
- * skip reason here so the cube sweep passes on day 1; families
- * replace the skip with registration as they land.
- */
-function skipReasonFor(cell: ScenarioCell): string {
-  // ── Combinations that are not real install layouts ────────────────
-
-  // AppImage tmp mount is Linux-only, and only occurs when dash ===
-  // "electron" via an AppImage package.
-  if (cell.pi === "appimage-tmp" && (cell.platform !== "linux" || cell.dash !== "electron")) {
-    return "appimage-tmp is Linux + electron only";
-  }
-
-  // "dev" dash implies a workspace checkout — only meaningful on
-  // developer machines (typically mac/linux). Windows dev happens but
-  // is rare; capture later if needed.
-  if (cell.dash === "dev" && cell.platform === "win32") {
-    return "dev monorepo on Windows — rare; capture if reported";
-  }
-
-  // "home-drift" env only meaningful on Windows (Git Bash sets $HOME
-  // differently from os.homedir). On posix, $HOME and os.homedir
-  // agree.
-  if (cell.env === "home-drift" && cell.platform !== "win32") {
-    return "home-drift is a Windows-specific phenomenon";
-  }
-
-  // Malformed settings.json doesn't depend on pi state — the parse
-  // failure happens regardless. One test per platform is enough.
-  if (cell.settings === "malformed" && cell.pi !== "present-valid") {
-    return "malformed settings: one pi state per platform is sufficient";
-  }
-
-  // Appimage + anything other than settings=missing is not a real
-  // first-run scenario (appimage is installed fresh).
-  if (cell.pi === "appimage-tmp" && cell.settings !== "missing") {
-    return "appimage fresh-run implies missing settings.json";
-  }
-
-  // spaces-unicode env is orthogonal to most axes — one scenario per
-  // platform proves the invariant. Skip most combinations.
-  if (cell.env === "spaces-unicode" && cell.pi !== "present-valid") {
-    return "spaces-unicode: covered once per platform via pi=present-valid";
-  }
-
-  // ── Refined skip reasons (post families B-K) ──────────────────────
-
-  // Dashboard-absent is only interesting when pi is present (K1).
-  // Other combinations — pi absent without dashboard, etc. — are
-  // pathological and not reachable by any real install mechanic.
-  if (cell.dash === "absent" && cell.pi !== "present-valid") {
-    return "dashboard-absent only meaningful when pi is present (K1)";
-  }
-
-  // Lock-file and instance-coordination cells land with proposal
-  // `single-dashboard-per-home`, which introduces a new axis (lock
-  // state) not modelled in this cube. The current cells remain
-  // skipped until that proposal extends the enumeration.
-
-  // TODO(unified-bootstrap-install): add three scenarios once this
-  // change's task 13 wires the bootstrap through the home-lock:
-  //   - B1-post:   "npm-g-dash-only + bootstrap install ran→ pi resolves
-  //                 via managed + bridge auto-registered". Requires
-  //                 extending the cube with a `bootstrap?: "pre"|"post"`
-  //                 axis or a new pi state `managed-installed-fresh`.
-  //   - B4:        "pi-dashboard installed via npm-g, extension resolves
-  //                 via node_modules lookup (findBundledExtension
-  //                 Strategy 2)". Requires a new `pi-ext-resolution`
-  //                 axis.
-  //   - L2:        "two simultaneous bootstraps" (requires lock from
-  //                 single-dashboard-per-home to be wired).
-  // Reason skipped today: requires lock from single-dashboard-per-home
-  // to be wired AND the cube to grow new axes. Track in harness
-  // follow-up. See change: unified-bootstrap-install tasks 2.3, 10.2,
-  // 11.2, 13.2.
-
-  // pi=malformed means partial install; resolution failure reason
-  // is identical across settings/env axes once pi state is fixed.
-  // E2 covers linux + win32; other combinations add no signal.
-  if (
-    cell.pi === "malformed"
-    && cell.settings !== "empty"
-    && !(cell.platform === "linux" || cell.platform === "win32")
-  ) {
-    return "malformed pi: E2 covers linux+win32 — other settings/env add no signal";
-  }
-
-  // Remaining cells are plausible combinations with no dedicated
-  // family test. Documented as deliberate skips rather than gaps.
-  return "not yet covered — add family coverage when a bug reports here";
-}
-
-/**
- * Apply bulk skips. Called at module load.
- */
-export function applyBulkSkips(): void {
-  for (const cell of enumerateCube()) {
-    skip(cell, skipReasonFor(cell));
-  }
-}
-
-// Apply on import so scenario consumers see the full manifest.
-applyBulkSkips();

package/packages/shared/src/__tests__/bootstrap/scenarios.ts

@@ -1,132 +0,0 @@
-/**
- * Scenario registry — the authoritative record of which cells are
- * tested, which are explicitly skipped (with a reason), and which
- * are unknown (fail-closed on CI).
- *
- * See openspec/changes/bootstrap-resolution-harness/design.md §5.
- */
-
-/** The canonical axes for the scenario cube. */
-export const PLATFORMS = ["win32", "darwin", "linux"] as const;
-export const DASH_LOCATIONS = ["electron", "npm-g", "dev", "managed", "absent"] as const;
-export const PI_STATES = [
-  "absent",
-  "present-no-ext",
-  "present-stale-ext",
-  "present-valid",
-  "malformed",
-  "appimage-tmp",
-] as const;
-export const SETTINGS_STATES = ["missing", "empty", "valid", "malformed"] as const;
-export const ENV_STATES = ["normal", "spaces-unicode", "home-drift"] as const;
-
-export type Platform = (typeof PLATFORMS)[number];
-export type DashLocation = (typeof DASH_LOCATIONS)[number];
-export type PiState = (typeof PI_STATES)[number];
-export type SettingsState = (typeof SETTINGS_STATES)[number];
-export type EnvState = (typeof ENV_STATES)[number];
-
-export interface ScenarioCell {
-  platform: Platform;
-  dash: DashLocation;
-  pi: PiState;
-  settings: SettingsState;
-  env: EnvState;
-}
-
-export function cellKey(cell: ScenarioCell): string {
-  return [cell.platform, cell.dash, cell.pi, cell.settings, cell.env].join("/");
-}
-
-/** Parse a cell-key back into its components. */
-export function parseCellKey(key: string): ScenarioCell | null {
-  const parts = key.split("/");
-  if (parts.length !== 5) return null;
-  const [platform, dash, pi, settings, env] = parts;
-  if (!PLATFORMS.includes(platform as Platform)) return null;
-  if (!DASH_LOCATIONS.includes(dash as DashLocation)) return null;
-  if (!PI_STATES.includes(pi as PiState)) return null;
-  if (!SETTINGS_STATES.includes(settings as SettingsState)) return null;
-  if (!ENV_STATES.includes(env as EnvState)) return null;
-  return {
-    platform: platform as Platform,
-    dash: dash as DashLocation,
-    pi: pi as PiState,
-    settings: settings as SettingsState,
-    env: env as EnvState,
-  };
-}
-
-/**
- * Cells with an active test. Entries added by each family-test file
- * via `register(cell, describeSymbol)`.
- *
- * The value is a string tag identifying the test file — useful for
- * the cube-sweep error message ("cell X already covered by Y").
- */
-export const REGISTERED_SCENARIOS = new Map<string, string>();
-
-/**
- * Cells explicitly skipped with a documented reason. New cells added
- * to the enumeration that don't land in REGISTERED or SKIPPED will
- * fail CI (the fail-closed invariant).
- *
- * Format: key → human-readable reason.
- */
-export const SKIPPED_SCENARIOS = new Map<string, string>();
-
-/** Register a tested cell. Last-registered wins (tests may re-register during dev). */
-export function register(cell: ScenarioCell, tag: string): void {
-  REGISTERED_SCENARIOS.set(cellKey(cell), tag);
-}
-
-/** Skip a cell with a reason. Required before CI accepts the new cell. */
-export function skip(cell: ScenarioCell, reason: string): void {
-  if (!reason || reason.trim().length === 0) {
-    throw new Error(`SKIPPED_SCENARIOS entry for ${cellKey(cell)} requires a non-empty reason`);
-  }
-  SKIPPED_SCENARIOS.set(cellKey(cell), reason);
-}
-
-/** Mass-skip helper: all cells matching a partial pattern. */
-export function skipPattern(
-  partial: Partial<ScenarioCell>,
-  reason: string,
-): void {
-  for (const cell of enumerateCube()) {
-    let match = true;
-    for (const k of Object.keys(partial) as (keyof ScenarioCell)[]) {
-      if (cell[k] !== partial[k]) {
-        match = false;
-        break;
-      }
-    }
-    if (match) skip(cell, reason);
-  }
-}
-
-/**
- * Enumerate every combination. Order is stable (useful for snapshots
- * and for deterministic error messages).
- */
-export function enumerateCube(): ScenarioCell[] {
-  const out: ScenarioCell[] = [];
-  for (const platform of PLATFORMS) {
-    for (const dash of DASH_LOCATIONS) {
-      for (const pi of PI_STATES) {
-        for (const settings of SETTINGS_STATES) {
-          for (const env of ENV_STATES) {
-            out.push({ platform, dash, pi, settings, env });
-          }
-        }
-      }
-    }
-  }
-  return out;
-}
-
-/** Reset state — used only by tests that want to verify the cube logic itself. */
-export function __resetScenariosForTesting(): void {
-  REGISTERED_SCENARIOS.clear();
-  SKIPPED_SCENARIOS.clear();
-}

package/packages/shared/src/__tests__/bootstrap-install-resolve-npm.test.ts

@@ -1,72 +0,0 @@
-/**
- * Regression: `resolveNpmArgv` from `bootstrap-install.ts` MUST consult
- * the injected `ToolRegistry` for `npm` before falling back to the
- * platform `npm` / `npm.cmd` PATH binary.
- *
- * The change `embed-managed-node-runtime` adds a managedRuntime
- * strategy to the npm chain in the registry. If a future refactor
- * accidentally bypasses the registry inside `resolveNpmArgv`, the
- * managed Node runtime would stop being preferred for shared bootstrap
- * spawns \u2014 the user-visible regression class this whole change exists
- * to prevent.
- *
- * See change: embed-managed-node-runtime (task 4.2).
- */
-import { describe, expect, it } from "vitest";
-import { resolveNpmArgv } from "../bootstrap-install.js";
-import type {
-  Resolution,
-  ToolRegistry,
-} from "../tool-registry/index.js";
-
-function fakeRegistry(opts: {
-  hasNpm?: boolean;
-  resolveResult?: Partial<Resolution>;
-}): ToolRegistry {
-  // Only the methods `resolveNpmArgv` actually calls.
-  return {
-    has: (name: string) => name === "npm" && (opts.hasNpm ?? true),
-    resolve: () =>
-      ({
-        name: "npm",
-        ok: true,
-        path: "/managed/node/bin/npm",
-        source: "managed",
-        tried: [],
-        resolvedAt: Date.now(),
-        ...opts.resolveResult,
-      }) as Resolution,
-  } as unknown as ToolRegistry;
-}
-
-describe("resolveNpmArgv", () => {
-  it("explicit npmArgv wins over registry", () => {
-    const argv = resolveNpmArgv({
-      npmArgv: ["/explicit/node", "/explicit/npm-cli.js"],
-      registry: fakeRegistry({}),
-    });
-    expect(argv).toEqual(["/explicit/node", "/explicit/npm-cli.js"]);
-  });
-
-  it("uses ToolRegistry.resolve('npm') when no explicit argv", () => {
-    const argv = resolveNpmArgv({
-      registry: fakeRegistry({
-        resolveResult: { ok: true, path: "/managed/node/bin/npm" } as Partial<Resolution>,
-      }),
-    });
-    expect(argv).toEqual(["/managed/node/bin/npm"]);
-  });
-
-  it("falls back to npm/npm.cmd on PATH when registry has no entry", () => {
-    const argv = resolveNpmArgv({
-      registry: {
-        has: () => false,
-        resolve: () => {
-          throw new Error("should not be called");
-        },
-      } as unknown as ToolRegistry,
-    });
-    expect(argv).toHaveLength(1);
-    expect(argv[0]).toMatch(/^npm(\.cmd)?$/);
-  });
-});

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

@@ -1,68 +0,0 @@
-/**
- * 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

@@ -1,192 +0,0 @@
-/**
- * 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);
-  });
-});