@blackbelt-technology/pi-agent-dashboard 0.3.0 → 0.4.0

package/packages/server/src/session-api.ts

@@ -11,6 +11,8 @@ import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/type
 import { spawnPiSession } from "./process-manager.js";
 import { loadConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import type { PendingForkRegistry } from "./pending-fork-registry.js";
+import type { BootstrapStateStore } from "./bootstrap-state.js";
+import type { BootstrapQueue } from "./bootstrap-queue.js";
 
 export interface SessionApiDeps {
   sessionManager: SessionManager;
@@ -18,6 +20,13 @@ export interface SessionApiDeps {
   browserGateway: BrowserGateway;
   pendingForkRegistry?: PendingForkRegistry;
   pendingDashboardSpawns?: Map<string, number>;
+  /**
+   * Bootstrap state + queue for degraded-mode gating. When omitted,
+   * session operations run normally (legacy behavior for tests that
+   * don't exercise the bootstrap flow). See change: unified-bootstrap-install.
+   */
+  bootstrapState?: BootstrapStateStore;
+  bootstrapQueue?: BootstrapQueue;
 }
 
 type IdParams = { Params: { id: string } };
@@ -30,7 +39,54 @@ function getSessionOrFail(sessionManager: SessionManager, id: string): { session
 }
 
 export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDeps) {
-  const { sessionManager, piGateway, browserGateway, pendingForkRegistry, pendingDashboardSpawns } = deps;
+  const { sessionManager, piGateway, browserGateway, pendingForkRegistry, pendingDashboardSpawns, bootstrapState, bootstrapQueue } = deps;
+
+  /**
+   * Gate pi-dependent operations on bootstrap status. Returns:
+   *   - null when ready (proceed).
+   *   - `{ code: 202, body: { status: "queued", ticketId } }` when installing;
+   *     the operation is enqueued and will run once status flips to "ready".
+   *   - `{ code: 503, body: { error } }` when failed.
+   * See change: unified-bootstrap-install §5.
+   */
+  function gateOrEnqueue<T>(handler: () => Promise<T>):
+    | null
+    | { code: 202; body: { status: "queued"; ticketId: string } }
+    | { code: 503; body: { error: string; bootstrap: "failed" | "version-too-old" } } {
+    if (!bootstrapState) return null;
+    const snap = bootstrapState.get();
+    // Block when pi version is below the configured minimum —
+    // even when status is "ready", a too-old pi must not run sessions.
+    // See change: unified-bootstrap-install §9.3.
+    if (
+      snap.status === "ready"
+      && snap.error?.message?.startsWith("pi version ")
+    ) {
+      return {
+        code: 503,
+        body: { error: snap.error.message, bootstrap: "version-too-old" },
+      };
+    }
+    if (snap.status === "ready") return null;
+    if (snap.status === "installing") {
+      if (!bootstrapQueue) {
+        return {
+          code: 202,
+          body: { status: "queued", ticketId: "" },
+        };
+      }
+      const ticket = bootstrapQueue.enqueue(handler);
+      return {
+        code: 202,
+        body: { status: "queued", ticketId: ticket.ticketId },
+      };
+    }
+    // status === "failed"
+    return {
+      code: 503,
+      body: { error: "pi not installed (bootstrap failed)", bootstrap: "failed" },
+    };
+  }
 
   // POST /api/session/:id/prompt
   fastify.post<IdParams & { Body: { text?: string; images?: any[] } }>(
@@ -160,14 +216,27 @@ export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDep
         reply.code(400);
         return { success: false, error: "cwd is required" } satisfies ApiResponse;
       }
-      const config = loadConfig();
-      const spawnResult = await spawnPiSession(cwd, { strategy: config.spawnStrategy });
-      if (spawnResult.process && spawnResult.pid) {
-        browserGateway.headlessPidRegistry.register(spawnResult.pid, cwd, spawnResult.process);
-      }
-      if (spawnResult.dashboardSpawned && spawnResult.success) {
-        pendingDashboardSpawns?.set(cwd, (pendingDashboardSpawns?.get(cwd) ?? 0) + 1);
+
+      const doSpawn = async () => {
+        const config = loadConfig();
+        const spawnResult = await spawnPiSession(cwd, { strategy: config.spawnStrategy });
+        if (spawnResult.process && spawnResult.pid) {
+          browserGateway.headlessPidRegistry.register(spawnResult.pid, cwd, spawnResult.process);
+        }
+        if (spawnResult.dashboardSpawned && spawnResult.success) {
+          pendingDashboardSpawns?.set(cwd, (pendingDashboardSpawns?.get(cwd) ?? 0) + 1);
+        }
+        return spawnResult;
+      };
+
+      // Bootstrap gate: if pi isn't ready, queue the spawn and return 202.
+      const gate = gateOrEnqueue(doSpawn);
+      if (gate) {
+        reply.code(gate.code);
+        return gate.body;
       }
+
+      const spawnResult = await doSpawn();
       if (!spawnResult.success) {
         reply.code(500);
         return { success: false, error: spawnResult.message } satisfies ApiResponse;

package/packages/server/src/session-bootstrap.ts

@@ -73,8 +73,22 @@ export async function discoverAndBroadcastSessions(deps: SessionBootstrapDeps):
     } as any);
   });
 
-  // Initial OpenSpec poll for all known directories
-  await Promise.all(
-    directoryService.knownDirectories().map((cwd) => directoryService.refreshOpenSpec(cwd)),
+  // Initial OpenSpec poll for all known directories.
+  //
+  // NOTE: `refreshOpenSpec` / `pollOpenSpec` is currently synchronous internally
+  // (spawnSync per change) — on Windows with many active changes (~19) and
+  // multiple pinned directories this can block the event loop for minutes,
+  // making the HTTP server unresponsive during startup. We intentionally do
+  // NOT await it here so HTTP + WebSocket startup completes immediately;
+  // openspec data populates in the background and pushes `openspec_update`
+  // broadcasts to browsers as each directory finishes.
+  //
+  // A proper fix is to migrate the openspec Recipe to async spawn; tracked
+  // separately. See change: consolidate-tool-resolution.
+  void Promise.all(
+    directoryService.knownDirectories().map(async (cwd) => {
+      try { await directoryService.refreshOpenSpec(cwd); }
+      catch (err) { console.error(`[dashboard] initial openspec poll failed for ${cwd}:`, err); }
+    }),
   );
 }

package/packages/server/src/session-diff.ts

@@ -2,8 +2,9 @@
  * Session diff extraction — scans session events for file changes
  * and optionally enriches with git diffs.
  */
-import { execSync } from "node:child_process";
-import { resolve, relative, isAbsolute } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, relative, isAbsolute, sep as pathSep } from "node:path";
+import * as git from "@blackbelt-technology/pi-dashboard-shared/platform/git.js";
 import type { DashboardEvent } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 import type { FileChangeEvent, FileDiffEntry, EditOperation } from "@blackbelt-technology/pi-dashboard-shared/diff-types.js";
 import { isGitRepo } from "./git-operations.js";
@@ -105,7 +106,11 @@ function normalizePath(rawPath: string, cwd: string): string | null {
     return null;
   }
 
-  return rel;
+  // Normalize to posix separators. These paths are embedded into git diff
+  // headers (`diff --git a/<path> b/<path>`) which expect forward slashes,
+  // and are also used by the client for display and URL construction.
+  // See change: fix-windows-server-parity.
+  return pathSep === "/" ? rel : rel.split(pathSep).join("/");
 }
 
 /**
@@ -130,32 +135,27 @@ export function enrichWithGitDiff(
 
   const enriched = files.map((file) => {
     try {
-      const diff = execSync(`git diff HEAD -- ${JSON.stringify(file.path)}`, {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: GIT_TIMEOUT,
-      }).trim();
+      // Delegate to the shared git tool module. The runner handles
+      // windowsHide, timeout, argv-array escaping (no shell), and the
+      // "no diff" exit-1 tolerance. See change: platform-command-executor.
+      const diff = git.diffOr({ cwd, path: file.path }).trim();
 
       if (diff) {
         return { ...file, gitDiff: diff };
       }
 
       // No diff from HEAD — try untracked (new file)
-      const status = execSync(`git status --porcelain -- ${JSON.stringify(file.path)}`, {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: GIT_TIMEOUT,
-      }).trim();
+      const status = git.statusPorcelainOr({ cwd, path: file.path }).trim();
 
       if (status.startsWith("??") || status.startsWith("A")) {
-        // Untracked or newly added — generate synthetic diff
-        const content = execSync(`cat ${JSON.stringify(resolve(cwd, file.path))}`, {
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"],
-          timeout: GIT_TIMEOUT,
-        });
+        // Untracked or newly added — generate synthetic diff.
+        // Read via fs.readFileSync rather than `cat` for cross-platform
+        // support (Windows has no `cat`). See change: fix-windows-server-parity.
+        const absPath = resolve(cwd, file.path);
+        if (!existsSync(absPath)) {
+          return file;
+        }
+        const content = readFileSync(absPath, "utf-8");
         const lines = content.split("\n");
         const diffLines = [
           `diff --git a/${file.path} b/${file.path}`,

package/packages/server/src/terminal-manager.ts

@@ -10,13 +10,19 @@ import type { WebSocket } from "ws";
 
 const DEFAULT_BUFFER_SIZE = 256 * 1024; // 256KB
 
+// Delegate shell detection to the shared platform primitive. Back-compat
+// wrapper preserved so callers (and tests) that import `detectShell` from
+// this module continue to work. See change: consolidate-platform-handlers.
+import {
+  detectShell as platformDetectShell,
+  getTerminalEnvHints as platformTerminalEnvHints,
+} from "@blackbelt-technology/pi-dashboard-shared/platform/shell.js";
+import { killProcess } from "@blackbelt-technology/pi-dashboard-shared/platform/process.js";
+
 /** Detect the appropriate shell for the current platform. */
 export function detectShell(platform?: string): string {
-  const p = platform ?? process.platform;
-  if (p === "win32") {
-    return process.env.COMSPEC || "powershell.exe";
-  }
-  return process.env.SHELL || "/bin/bash";
+  // Keep the old `platform?: string` signature; coerce to the shared primitive's opts.
+  return platformDetectShell(platform ? { platform: platform as NodeJS.Platform } : undefined);
 }
 
 /** Circular buffer for PTY output replay. */
@@ -110,10 +116,7 @@ export function createTerminalManager(options?: TerminalManagerOptions): Termina
     const shell = detectShell();
     const id = generateId();
 
-    const env = { ...process.env } as Record<string, string>;
-    if (process.platform === "win32" && !env.TERM) {
-      env.TERM = "cygwin";
-    }
+    const env = { ...process.env, ...platformTerminalEnvHints() } as Record<string, string>;
 
     const p = pty.spawn(shell, [], {
       cwd,
@@ -211,18 +214,56 @@ export function createTerminalManager(options?: TerminalManagerOptions): Termina
   function kill(id: string): void {
     const entry = entries.get(id);
     if (!entry) throw new Error(`Terminal ${id} not found`);
-    // Interactive shells (e.g. bash on Linux) ignore SIGTERM.
-    // Use SIGHUP which shells honor, then escalate to SIGKILL.
-    entry.pty.kill("SIGHUP");
-    const escalation = setTimeout(() => {
-      if (entries.has(id)) {
-        try { entry.pty.kill("SIGKILL"); } catch {}
+
+    // Windows: node-pty's kill(signal) uses TerminateProcess on the shell
+    // handle, which (a) ignores the signal string, and (b) does not kill
+    // child processes of the shell (python.exe, node.exe, etc.). Worse, its
+    // onExit callback is not always fired after external kills, so the
+    // terminal entry would stay in the map forever — which is exactly why
+    // the X button "doesn't work" on Windows. Route through platform's
+    // killProcess() so taskkill /F /T /PID does a genuine tree kill.
+    //
+    // POSIX: keep the SIGHUP → SIGKILL idiom — interactive shells honor
+    // SIGHUP, giving them a chance to clean up tty state before we escalate.
+    if (process.platform === "win32") {
+      const pid = entry.pty.pid;
+      if (typeof pid === "number") {
+        void killProcess(pid, { timeoutMs: 2000 }).catch(() => { /* surfaced via onExit fallback below */ });
+      } else {
+        try { entry.pty.kill(); } catch { /* best-effort */ }
+      }
+    } else {
+      entry.pty.kill("SIGHUP");
+      const escalation = setTimeout(() => {
+        if (entries.has(id)) {
+          try { entry.pty.kill("SIGKILL"); } catch {}
+        }
+      }, 1000);
+      const disposeEsc = entry.pty.onExit(() => {
+        clearTimeout(escalation);
+        disposeEsc.dispose();
+      });
+    }
+
+    // Fallback cleanup: if node-pty's onExit doesn't fire within 3s (common
+    // on Windows ConPTY after external termination), simulate it so the
+    // terminal entry is removed, clients are disconnected, and the server
+    // broadcasts terminal_removed. Without this, the X click never
+    // completes from the user's perspective.
+    const fallback = setTimeout(() => {
+      const stale = entries.get(id);
+      if (!stale) return; // onExit already ran
+      stale.session = { ...stale.session, status: "ended" };
+      for (const ws of stale.clients) {
+        try { ws.close(); } catch { /* ignore */ }
       }
-    }, 1000);
-    // Clear escalation timeout if the process exits promptly
-    const dispose = entry.pty.onExit(() => {
-      clearTimeout(escalation);
-      dispose.dispose();
+      stale.clients.clear();
+      entries.delete(id);
+      options?.onExit?.(id);
+    }, 3000);
+    const disposeFb = entry.pty.onExit(() => {
+      clearTimeout(fallback);
+      disposeFb.dispose();
     });
   }
 

package/packages/server/src/tunnel.ts

@@ -7,7 +7,15 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { execSync, spawn, type ChildProcess } from "node:child_process";
+import { execSync, spawn, type ChildProcess } from "@blackbelt-technology/pi-dashboard-shared/platform/exec.js";
+import { ToolResolver } from "@blackbelt-technology/pi-dashboard-shared/platform/binary-lookup.js";
+import {
+  isProcessAlive,
+  killProcess,
+  killPidWithGroup,
+} from "@blackbelt-technology/pi-dashboard-shared/platform/process.js";
+
+const zrokResolver = new ToolResolver({ processExecPath: process.execPath });
 import type { TunnelStatus } from "@blackbelt-technology/pi-dashboard-shared/rest-api.js";
 import { CONFIG_FILE } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 
@@ -37,13 +45,10 @@ let pendingCreate: Promise<string | null> | null = null;
 // ── Binary Detection ────────────────────────────────────────────────
 
 function checkZrokOnPath(): boolean {
-  const cmd = process.platform === "win32" ? "where zrok" : "which zrok";
-  try {
-    execSync(cmd, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
+  // Delegate binary lookup to the shared platform primitive (handles the
+  // where/which split on Windows vs Unix, managed-bin search, and login
+  // shell fallback). See change: consolidate-platform-handlers.
+  return zrokResolver.which("zrok") !== null;
 }
 
 /**
@@ -93,30 +98,22 @@ export function removeZrokPid(): void {
 
 // ── Stale Process Cleanup ───────────────────────────────────────────
 
-/**
- * Check if a process is alive by sending signal 0.
- */
-function isProcessAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Clean up stale zrok processes from previous server runs.
- * Reads PID file, kills process if running, removes PID file.
+ * Reads PID file, kills process if running (via the platform helper so
+ * Windows uses `taskkill /F /T /PID`), removes PID file.
+ * See change: route-kill-paths-through-platform.
  */
-export function cleanupStaleZrok(): void {
+export async function cleanupStaleZrok(): Promise<void> {
   const pid = readZrokPid();
   if (pid === null) return;
 
   if (isProcessAlive(pid)) {
     try {
-      process.kill(pid, "SIGTERM");
-      console.log(`Killed stale zrok process (PID ${pid})`);
+      const result = await killProcess(pid, { timeoutMs: 2000 });
+      if (result.ok) {
+        console.log(`Killed stale zrok process (PID ${pid})`);
+      }
     } catch (err: any) {
       console.warn(`Failed to kill stale zrok process (PID ${pid}): ${err.message}`);
     }
@@ -222,7 +219,10 @@ export function scavengeOrphanZrokProcesses(port: number): number[] {
     if (!Number.isFinite(pid) || pid <= 0) continue;
     if (pid === process.pid) continue; // never kill ourselves
     try {
-      process.kill(pid, "SIGTERM");
+      // Group-kill on Unix so zrok's child workers die with it; taskkill /T
+      // already handles the tree on Windows (killPidWithGroup routes the
+      // platform-correct path).
+      killPidWithGroup(pid, "SIGTERM");
       killed.push(pid);
       console.log(`Scavenged orphan zrok process (PID ${pid})`);
     } catch {
@@ -336,8 +336,16 @@ function _createTunnelInner(
       if (!resolved) {
         resolved = true;
         console.warn("zrok tunnel creation timed out (30s)");
-        try { child.kill("SIGTERM"); } catch {}
-        setTimeout(() => { try { child.kill("SIGKILL"); } catch {} }, 2_000);
+        try {
+          if (child.pid != null) killPidWithGroup(child.pid, "SIGTERM");
+          else child.kill("SIGTERM");
+        } catch { /* already dead */ }
+        setTimeout(() => {
+          try {
+            if (child.pid != null) killPidWithGroup(child.pid, "SIGKILL");
+            else child.kill("SIGKILL");
+          } catch { /* already dead */ }
+        }, 2_000);
         if (token && !callerProvidedToken) releaseShare(token);
         removeZrokPid();
         resolve(null);
@@ -417,7 +425,13 @@ export async function deleteTunnel(port?: number): Promise<void> {
 
   if (child) {
     try {
-      child.kill("SIGTERM");
+      if (child.pid != null) {
+        // Route through the platform helper so Windows gets taskkill
+        // semantics (tree-kill). See change: route-kill-paths-through-platform.
+        await killProcess(child.pid, { timeoutMs: 2000 });
+      } else {
+        child.kill("SIGTERM");
+      }
     } catch (err: any) {
       console.warn(`zrok tunnel cleanup failed: ${err.message}`);
     }

package/packages/shared/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-shared",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Shared types and utilities for pi-dashboard",
   "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
   "exports": {
     "./*.js": "./src/*.ts",
     "./*": "./src/*"
@@ -10,6 +13,10 @@
   "files": [
     "src/"
   ],
-  "dependencies": {},
-  "devDependencies": {}
+  "dependencies": {
+    "bonjour-service": "^1.3.0"
+  },
+  "devDependencies": {
+    "memfs": "^4.57.2"
+  }
 }

package/packages/shared/src/__tests__/{tool-resolver.test.ts → binary-lookup.test.ts}

@@ -5,28 +5,37 @@ import { describe, it, expect, vi, beforeEach } from "vitest";
 import path from "node:path";
 import os from "node:os";
 
-const { mockExecSync, mockExistsSync } = vi.hoisted(() => ({
+const { mockExecSync, mockSpawnSync, mockExistsSync } = vi.hoisted(() => ({
   mockExecSync: vi.fn(),
+  mockSpawnSync: vi.fn(),
   mockExistsSync: vi.fn(),
 }));
 
-vi.mock("node:child_process", () => ({ execSync: mockExecSync }));
+vi.mock("node:child_process", () => ({ execSync: mockExecSync, spawnSync: mockSpawnSync }));
 vi.mock("node:fs", () => ({ existsSync: mockExistsSync }));
 
-import { ToolResolver } from "../tool-resolver.js";
+import { ToolResolver } from "../platform/binary-lookup.js";
 
 const MANAGED_BIN = path.join(os.homedir(), ".pi-dashboard", "node_modules", ".bin");
 
+// On Windows, ToolResolver.which() appends ".cmd" to the binary name when
+// probing managed bin / extra dirs (shim convention for npm-installed bins).
+// Unix has no extension. Tests must mirror this so assertions line up with
+// what the implementation actually queries.
+const BIN_EXT = process.platform === "win32" ? ".cmd" : "";
+
 describe("ToolResolver", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockExistsSync.mockReturnValue(false);
     mockExecSync.mockImplementation(() => { throw new Error("not found"); });
+    // Default: spawnSync (used by whereAllLines) reports not found.
+    mockSpawnSync.mockReturnValue({ status: 1, stdout: "", stderr: "" });
   });
 
   describe("which()", () => {
     it("finds binary in managed bin first", () => {
-      const managedPi = path.join(MANAGED_BIN, "pi");
+      const managedPi = path.join(MANAGED_BIN, "pi" + BIN_EXT);
       mockExistsSync.mockImplementation((p: string) => p === managedPi);
 
       const resolver = new ToolResolver();
@@ -35,21 +44,28 @@ describe("ToolResolver", () => {
 
     it("finds binary in extra bin dirs before system PATH", () => {
       const extraDir = "/custom/bin";
-      const extraPi = path.join(extraDir, "pi");
+      const extraPi = path.join(extraDir, "pi" + BIN_EXT);
       mockExistsSync.mockImplementation((p: string) => p === extraPi);
 
       const resolver = new ToolResolver({ extraBinDirs: [extraDir] });
       expect(resolver.which("pi")).toBe(extraPi);
     });
 
-    it("falls back to system PATH via which", () => {
-      mockExecSync.mockImplementation((cmd: string) => {
-        if (typeof cmd === "string" && cmd.includes("which pi")) return "/usr/bin/pi\n";
-        throw new Error("not found");
+    it("falls back to system PATH via which/where", () => {
+      // Resolver uses `where` on Windows, `which` on Unix via spawnSync
+      // (not execSync — see whereAllLines in platform/tools.ts).
+      const lookupCmd = process.platform === "win32" ? "where" : "which";
+      const expected = process.platform === "win32" ? "C:\\Windows\\pi.exe" : "/usr/bin/pi";
+      mockSpawnSync.mockImplementation((cmd: string, args: string[]) => {
+        // argv[0] is 'where'/'which', argv[1] is the target binary.
+        if (cmd === lookupCmd && args?.[0] === "pi") {
+          return { status: 0, stdout: expected + "\n", stderr: "" };
+        }
+        return { status: 1, stdout: "", stderr: "" };
       });
 
       const resolver = new ToolResolver();
-      expect(resolver.which("pi")).toBe("/usr/bin/pi");
+      expect(resolver.which("pi")).toBe(expected);
     });
 
     it("tries login shell when enabled and PATH fails", () => {
@@ -123,7 +139,7 @@ describe("ToolResolver", () => {
     });
 
     it("falls back to which(node) when no context paths", () => {
-      const managedNode = path.join(MANAGED_BIN, "node");
+      const managedNode = path.join(MANAGED_BIN, "node" + BIN_EXT);
       mockExistsSync.mockImplementation((p: string) => p === managedNode);
 
       const resolver = new ToolResolver();
@@ -143,7 +159,11 @@ describe("ToolResolver", () => {
 
     it("does not duplicate managed bin if already present", () => {
       const resolver = new ToolResolver();
-      const env = resolver.buildSpawnEnv({ PATH: `${MANAGED_BIN}:/usr/bin` });
+      // Use the platform's PATH delimiter (`;` on Windows, `:` on Unix) so
+      // MANAGED_BIN is parsed as its own PATH entry — otherwise on Windows
+      // `${MANAGED_BIN}:/usr/bin` is treated as one single (broken) path.
+      const existingPath = [MANAGED_BIN, "/usr/bin"].join(path.delimiter);
+      const env = resolver.buildSpawnEnv({ PATH: existingPath });
       const count = env.PATH!.split(path.delimiter).filter(p => p === MANAGED_BIN).length;
       expect(count).toBe(1);
     });