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

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

@@ -2,12 +2,118 @@
  * Thin adapter around pi's DefaultPackageManager.
  * Serializes operations (one at a time), forwards progress events,
  * and triggers session reload on success.
+ *
+ * Pi module resolution is delegated to the shared `ToolRegistry`
+ * (`resolveModule("pi-coding-agent")`). All strategy chains, caching,
+ * and diagnostic trails live there — see change: consolidate-tool-resolution.
  */
 import * as os from "node:os";
 import * as path from "node:path";
 import * as crypto from "node:crypto";
-import { pathToFileURL } from "node:url";
-import { execSync } from "node:child_process";
+import {
+  getDefaultRegistry,
+  ModuleResolutionError,
+  type ToolRegistry,
+  type Resolution,
+} from "@blackbelt-technology/pi-dashboard-shared/tool-registry/index.js";
+import {
+  getDefaultSubprocessAdapter,
+  type SubprocessAdapter,
+} from "@blackbelt-technology/pi-dashboard-shared/platform/subprocess-adapter.js";
+
+/**
+ * Resolve a command name through the tool registry's executor API.
+ * If the name is registered (e.g. "npm", "openspec", "pi"), returns
+ * the full executor argv — on Windows this is `[node.exe, <script>.js]`
+ * bypassing .cmd shims. Otherwise returns `[command, ...args]` verbatim
+ * so callers fall through to buildSafeArgv's generic handling.
+ *
+ * See change: consolidate-windows-spawn-and-platform-handlers.
+ */
+function resolveViaRegistry(
+  registry: ToolRegistry,
+  command: string,
+  args: readonly string[],
+): string[] {
+  if (registry.has(command)) {
+    const exec = registry.resolveExecutor(command);
+    if (exec.ok && exec.argv.length > 0) {
+      return [...exec.argv, ...args];
+    }
+  }
+  return [command, ...args];
+}
+
+/**
+ * Subclass of pi's `DefaultPackageManager` that routes every subprocess
+ * through our OS-aware `SubprocessAdapter`. Pi's upstream implementation
+ * spawns with `shell: process.platform === "win32"` and no `windowsHide`,
+ * which on Windows triggers Node issue #21825 — flashing cmd console
+ * every time pi shells out to npm / git / etc.
+ *
+ * This class overrides the three spawn methods pi exposes on its own
+ * class (`spawnCommand`, `spawnCaptureCommand`, `runCommandSync`) and
+ * delegates them to the adapter. Other methods inherit unchanged;
+ * pi's internal `runCommand` / `runCommandCapture` call the overridden
+ * methods via `this.spawnCommand(...)` so they pick up the safe
+ * behaviour automatically.
+ *
+ * Constructor factory takes the base `DefaultPackageManager` class as
+ * input so we can extend it dynamically at runtime (pi is loaded via
+ * the tool registry's `resolveModule`, not a static import).
+ *
+ * See change: consolidate-windows-spawn-and-platform-handlers.
+ */
+function createSafePackageManagerClass(
+  BaseClass: new (...args: any[]) => any,
+  adapter: SubprocessAdapter,
+  registry: ToolRegistry,
+): new (...args: any[]) => any {
+  return class SafePackageManager extends BaseClass {
+    // `spawnCommand` — used by pi for fire-and-forget installs where
+    // stdout/stderr are inherited (or piped for capture). Returns the
+    // live ChildProcess.
+    //
+    // Registry resolution: `command` arrives as "npm" / "git" etc.
+    // For registered executor tools this becomes `[node.exe, cli.js]`
+    // on Windows, bypassing .cmd entirely.
+    spawnCommand(command: string, args: readonly string[], options?: { cwd?: string; env?: NodeJS.ProcessEnv }) {
+      const [cmd, ...finalArgs] = resolveViaRegistry(registry, command, args);
+      return adapter.spawn(cmd, finalArgs, {
+        cwd: options?.cwd,
+        stdio: "inherit",
+      });
+    }
+
+    // `spawnCaptureCommand` — used by pi when it wants to read stdout /
+    // stderr programmatically (e.g. `npm root -g`, `npm view <pkg>`).
+    spawnCaptureCommand(command: string, args: readonly string[], options?: { cwd?: string; env?: NodeJS.ProcessEnv }) {
+      const [cmd, ...finalArgs] = resolveViaRegistry(registry, command, args);
+      return adapter.spawn(cmd, finalArgs, {
+        cwd: options?.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: options?.env ? { ...process.env, ...options.env } : process.env,
+      });
+    }
+
+    // `runCommandSync` — used for quick synchronous checks.
+    runCommandSync(command: string, args: readonly string[]) {
+      const [cmd, ...finalArgs] = resolveViaRegistry(registry, command, args);
+      const result = adapter.spawnSync<string>(cmd, finalArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+      });
+      if (result.status !== 0) {
+        const stderr = typeof result.stderr === "string" ? result.stderr : String(result.stderr ?? "");
+        const stdout = typeof result.stdout === "string" ? result.stdout : String(result.stdout ?? "");
+        throw new Error(`Failed to run ${command} ${args.join(" ")}: ${stderr || stdout}`);
+      }
+      const stdout = typeof result.stdout === "string" ? result.stdout : String(result.stdout ?? "");
+      return stdout.trim();
+    }
+  };
+}
+
 export interface ProgressEvent {
   type: "start" | "progress" | "complete" | "error";
   action: "install" | "remove" | "update" | "clone" | "pull";
@@ -15,39 +121,35 @@ export interface ProgressEvent {
   message?: string;
 }
 
-/** Lazily import pi's PackageManager (optional peer dependency). */
-let piModuleCache: { DefaultPackageManager: any; SettingsManager: any } | null = null;
-
-async function loadPiPackageManager() {
-  if (piModuleCache) return piModuleCache;
-
-  // Try direct import first (works if installed as a dependency)
-  try {
-    const mod = await import("@mariozechner/pi-coding-agent") as any;
-    if (mod.DefaultPackageManager) {
-      piModuleCache = { DefaultPackageManager: mod.DefaultPackageManager, SettingsManager: mod.SettingsManager };
-      return piModuleCache;
-    }
-  } catch { /* fall through to global resolution */ }
+/** Pi-coding-agent's public surface, as consumed by this wrapper. */
+interface PiModule {
+  DefaultPackageManager: any;
+  SettingsManager: any;
+}
 
-  // Resolve from global npm install (pi is typically installed globally)
-  for (const pkgName of ["@mariozechner/pi-coding-agent", "@oh-my-pi/pi-coding-agent"]) {
-    try {
-      const npmRoot = execSync("npm root -g", { encoding: "utf-8", timeout: 10_000 }).trim();
-      const entryPath = path.join(npmRoot, pkgName, "dist", "index.js");
-      const mod = await import(pathToFileURL(entryPath).href);
-      if (mod.DefaultPackageManager) {
-        piModuleCache = { DefaultPackageManager: mod.DefaultPackageManager, SettingsManager: mod.SettingsManager };
-        return piModuleCache;
-      }
-    } catch { /* fall through */ }
+/**
+ * Resolve pi's package-manager API via the ToolRegistry. Surface the
+ * diagnostic trail on failure so callers (routes) can show the real
+ * reason instead of a generic "not installed" message.
+ */
+async function loadPiPackageManager(registry: ToolRegistry = getDefaultRegistry()): Promise<PiModule> {
+  const { module } = await registry.resolveModule<PiModule>("pi-coding-agent");
+  if (!module.DefaultPackageManager) {
+    throw new Error(
+      "pi-coding-agent resolved but does not export DefaultPackageManager (unexpected package version)",
+    );
   }
+  return module;
+}
 
-  throw new Error(
-    "pi-coding-agent is not installed. Package management requires pi to be installed (globally or as a dependency)."
-  );
+/** Debug helper: expose the raw Resolution for diagnostic surfaces. */
+export function diagnosePiPackageManager(registry: ToolRegistry = getDefaultRegistry()): Resolution {
+  return registry.resolve("pi-coding-agent");
 }
 
+/** Re-export so route handlers can `instanceof`-check for the rich error. */
+export { ModuleResolutionError };
+
 export type PackageScope = "global" | "local";
 export type PackageAction = "install" | "remove" | "update";
 
@@ -65,6 +167,8 @@ export interface OperationResult {
   scope: PackageScope;
   success: boolean;
   error?: string;
+  /** On failure: full resolution trail if pi couldn't be loaded. */
+  diagnostics?: Resolution;
 }
 
 export type ProgressListener = (operationId: string, event: ProgressEvent) => void;
@@ -78,6 +182,11 @@ export class PackageManagerWrapper {
   private onComplete: CompleteListener | undefined;
   /** Called after successful operation; returns number of sessions reloaded. */
   private reloadSessions: (() => Promise<number>) | undefined;
+  private readonly registry: ToolRegistry;
+
+  constructor(registry: ToolRegistry = getDefaultRegistry()) {
+    this.registry = registry;
+  }
 
   setProgressListener(listener: ProgressListener | undefined) {
     this.onProgress = listener;
@@ -95,6 +204,24 @@ export class PackageManagerWrapper {
     return this.busy;
   }
 
+  /**
+   * Run an arbitrary async operation under the wrapper's busy-lock.
+   * Used by adjacent subsystems (e.g. PiCoreUpdater) to coordinate with
+   * extension install/update operations. Throws PackageOperationBusyError
+   * if a package operation is already running.
+   */
+  async runExclusive<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.busy) {
+      throw new PackageOperationBusyError();
+    }
+    this.busy = true;
+    try {
+      return await fn();
+    } finally {
+      this.busy = false;
+    }
+  }
+
   /**
    * Start a package operation. Returns the operationId immediately.
    * Progress and completion are delivered via listeners.
@@ -136,11 +263,63 @@ export class PackageManagerWrapper {
 
   // ── Internal ────────────────────────────────────────────────────
 
+  /**
+   * Per-cwd cache of DefaultPackageManager instances. Each instance holds
+   * its own SettingsManager + filesystem state; on Windows
+   * `listConfiguredPackages` can take several seconds on cold
+   * instantiation, so reusing the same instance across repeat calls
+   * (same cwd) eliminates the cost of the `/api/packages/recommended` +
+   * `/api/packages/installed` flows firing back-to-back.
+   *
+   * We also dedupe *in-flight* instantiations via `pmPending`: if two
+   * concurrent callers both ask for the same cwd before the first
+   * instantiation resolves, they share the same Promise instead of
+   * spawning parallel `DefaultPackageManager` constructions (which
+   * compete for the event loop and can double cold-start latency).
+   *
+   * `run()` invalidates the relevant entry after an install/remove/update
+   * so stale state never persists past a mutation.
+   */
+  private readonly pmCache = new Map<string, unknown>();
+  private readonly pmPending = new Map<string, Promise<unknown>>();
+
   private async createPackageManager(cwd?: string) {
-    const { DefaultPackageManager, SettingsManager } = await loadPiPackageManager();
     const effectiveCwd = cwd ?? process.cwd();
-    const settingsManager = SettingsManager.create(effectiveCwd, AGENT_DIR);
-    return new DefaultPackageManager({ cwd: effectiveCwd, agentDir: AGENT_DIR, settingsManager });
+    const cached = this.pmCache.get(effectiveCwd);
+    if (cached) return cached as any;
+    const inflight = this.pmPending.get(effectiveCwd);
+    if (inflight) return inflight as any;
+
+    const promise = (async () => {
+      const { DefaultPackageManager, SettingsManager } = await loadPiPackageManager(this.registry);
+      const settingsManager = SettingsManager.create(effectiveCwd, AGENT_DIR);
+      // Wrap pi's DefaultPackageManager in our SafePackageManager so
+      // every internal `spawn` / `spawnSync` / `runCommandSync` call
+      // routes through the OS-aware SubprocessAdapter. This is THE
+      // fix for cmd.exe flashes on Windows caused by pi's upstream
+      // `shell: true + no windowsHide` spawn pattern.
+      const SafePM = createSafePackageManagerClass(
+        DefaultPackageManager,
+        getDefaultSubprocessAdapter(),
+        this.registry,
+      );
+      const pm = new SafePM({ cwd: effectiveCwd, agentDir: AGENT_DIR, settingsManager });
+      this.pmCache.set(effectiveCwd, pm);
+      return pm;
+    })();
+    this.pmPending.set(effectiveCwd, promise);
+    try {
+      return await promise;
+    } finally {
+      this.pmPending.delete(effectiveCwd);
+    }
+  }
+
+  /** Drop the cached package manager for a cwd (after install/remove/update). */
+  private invalidatePackageManager(cwd?: string): void {
+    const effectiveCwd = cwd ?? process.cwd();
+    this.pmCache.delete(effectiveCwd);
+    this.pmPending.delete(effectiveCwd);
   }
 
   private async executeOperation(operationId: string, req: OperationRequest): Promise<void> {
@@ -174,6 +353,10 @@ export class PackageManagerWrapper {
 
       result.success = true;
 
+      // Invalidate the cached package manager for this cwd so future
+      // listInstalled() calls see the mutated settings.json.
+      this.invalidatePackageManager(req.cwd);
+
       // Reload all sessions after successful operation
       if (this.reloadSessions) {
         try {
@@ -184,7 +367,15 @@ export class PackageManagerWrapper {
         }
       }
     } catch (err: any) {
-      result.error = err?.message ?? String(err);
+      // Pi-not-found: surface the full Resolution trail to the caller
+      // so the UI can render per-strategy failure reasons instead of
+      // the old opaque "pi-coding-agent is not installed" message.
+      if (err instanceof ModuleResolutionError) {
+        result.error = err.message;
+        result.diagnostics = err.resolution;
+      } else {
+        result.error = err?.message ?? String(err);
+      }
     } finally {
       this.busy = false;
       this.onComplete?.(result);

package/packages/server/src/pi-core-checker.ts

@@ -0,0 +1,290 @@
+/**
+ * Pi core version checker.
+ *
+ * Discovers installed pi-ecosystem CORE packages (pi-coding-agent itself,
+ * pi-agent-dashboard, pi-model-proxy, and similar globally-installed CLI
+ * tooling) and compares their versions against the npm registry.
+ *
+ * Complements the existing PackageManagerWrapper, which only manages
+ * packages listed in `settings.json packages[]` (extensions, skills,
+ * prompts, themes).
+ *
+ * Discovery sources:
+ *   1. Global npm (`npm list -g --depth=0 --json`)
+ *   2. Managed install (`~/.pi-dashboard/node_modules/`) — Electron path
+ *
+ * Version fetch reuses `fetchPackageMeta()` from the npm-search proxy.
+ * Results are cached for 5 minutes.
+ */
+import { execFile } from "node:child_process"; // ban:child_process-ok pi-core check uses execFile + promisify for `npm list -g --json` output capture; refactoring to platform/spawn's Recipe engine is tracked tech debt
+import { promisify } from "node:util";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fetchPackageMeta } from "./npm-search-proxy.js";
+
+const execFileAsync = promisify(execFile);
+
+const CACHE_TTL_MS = 5 * 60 * 1000;
+const NPM_LIST_TIMEOUT_MS = 30_000;
+
+/** ~/.pi-dashboard/ — Electron managed install dir */
+const MANAGED_DIR = path.join(os.homedir(), ".pi-dashboard");
+const MANAGED_NODE_MODULES = path.join(MANAGED_DIR, "node_modules");
+
+/** Known core packages (not extensions). Order matters for display. */
+export const CORE_PACKAGE_NAMES: readonly string[] = [
+	"@mariozechner/pi-coding-agent",
+	"@oh-my-pi/pi-coding-agent",
+	"@blackbelt-technology/pi-agent-dashboard",
+	"@blackbelt-technology/pi-model-proxy",
+];
+
+/** Display name mapping for known packages. Falls back to package name. */
+const DISPLAY_NAMES: Readonly<Record<string, string>> = {
+	"@mariozechner/pi-coding-agent": "pi (core agent)",
+	"@oh-my-pi/pi-coding-agent": "pi (core agent — fork)",
+	"@blackbelt-technology/pi-agent-dashboard": "pi-dashboard",
+	"@blackbelt-technology/pi-model-proxy": "pi-model-proxy",
+};
+
+export interface PiCorePackage {
+	name: string;
+	displayName: string;
+	currentVersion: string;
+	latestVersion: string | null;
+	updateAvailable: boolean;
+	installSource: "global" | "managed";
+}
+
+export interface PiCoreStatus {
+	packages: PiCorePackage[];
+	updatesAvailable: number;
+	lastChecked: string;
+}
+
+/** Resolve display name for a package. */
+function resolveDisplayName(name: string): string {
+	return DISPLAY_NAMES[name] ?? name;
+}
+
+/**
+ * Heuristic to decide if a package is part of the pi ecosystem but NOT in
+ * the known-names list above. Matches bare-name pi packages on npm:
+ *   - bare `pi-<name>`
+ *   - scoped `@<scope>/pi-<name>`
+ * Note: extensions already managed by PackageManagerWrapper (via
+ * `settings.json packages[]`) are deliberately included if they are ALSO
+ * installed globally — the PiCoreChecker's discovery is a superset, and
+ * the UI layer decides which surface to show a package in.
+ */
+function looksLikePiEcosystem(name: string): boolean {
+	if (CORE_PACKAGE_NAMES.includes(name)) return true;
+	// `pi-foo` or `pi` bare-scoped
+	if (/^pi-[a-z0-9-]+$/i.test(name)) return true;
+	// scoped variant: `@scope/pi-foo`
+	if (/^@[^/]+\/pi-[a-z0-9-]+$/i.test(name)) return true;
+	return false;
+}
+
+export interface NpmListRunner {
+	/** Run `npm list -g --depth=0 --json` and return stdout. */
+	(): Promise<string>;
+}
+
+export interface PiCoreCheckerOptions {
+	/** Inject npm-list runner (for tests). */
+	npmList?: NpmListRunner;
+	/** Inject version fetcher (for tests). */
+	fetchLatest?: (packageName: string) => Promise<string | null>;
+	/** Override managed directory (for tests). */
+	managedDir?: string;
+}
+
+/** Default npm runner uses execFile for safety. */
+const defaultNpmList: NpmListRunner = async () => {
+	const { stdout } = await execFileAsync("npm", ["list", "-g", "--depth=0", "--json"], {
+		timeout: NPM_LIST_TIMEOUT_MS,
+		maxBuffer: 10 * 1024 * 1024,
+	});
+	return stdout;
+};
+
+const defaultFetchLatest = async (packageName: string): Promise<string | null> => {
+	const meta = await fetchPackageMeta(packageName);
+	return meta?.version ?? null;
+};
+
+export class PiCoreChecker {
+	private cache: { at: number; data: PiCoreStatus } | null = null;
+	private readonly npmList: NpmListRunner;
+	private readonly fetchLatest: (packageName: string) => Promise<string | null>;
+	private readonly managedNodeModules: string;
+
+	constructor(opts: PiCoreCheckerOptions = {}) {
+		this.npmList = opts.npmList ?? defaultNpmList;
+		this.fetchLatest = opts.fetchLatest ?? defaultFetchLatest;
+		this.managedNodeModules = opts.managedDir
+			? path.join(opts.managedDir, "node_modules")
+			: MANAGED_NODE_MODULES;
+	}
+
+	/** Invalidate the cache (e.g. after an update completes). */
+	invalidate(): void {
+		this.cache = null;
+	}
+
+	/** Get version status. Returns cached data within 5 min unless `refresh`. */
+	async getStatus(refresh = false): Promise<PiCoreStatus> {
+		const now = Date.now();
+		if (!refresh && this.cache && now - this.cache.at < CACHE_TTL_MS) {
+			return this.cache.data;
+		}
+
+		// Discover packages from both sources. Managed takes precedence on conflict.
+		const global = await this.discoverGlobal();
+		const managed = this.discoverManaged();
+
+		const byName = new Map<string, { version: string; source: "global" | "managed" }>();
+		for (const entry of global) byName.set(entry.name, { version: entry.version, source: "global" });
+		for (const entry of managed) byName.set(entry.name, { version: entry.version, source: "managed" });
+
+		// Fetch latest versions in parallel.
+		const entries = Array.from(byName.entries());
+		const withLatest = await Promise.all(
+			entries.map(async ([name, info]) => {
+				let latest: string | null = null;
+				try {
+					latest = await this.fetchLatest(name);
+				} catch {
+					latest = null;
+				}
+				const updateAvailable = latest !== null && latest !== info.version;
+				const pkg: PiCorePackage = {
+					name,
+					displayName: resolveDisplayName(name),
+					currentVersion: info.version,
+					latestVersion: latest,
+					updateAvailable,
+					installSource: info.source,
+				};
+				return pkg;
+			}),
+		);
+
+		// Sort: known core packages first (in CORE_PACKAGE_NAMES order), then
+		// alphabetically. Then updates-available bubble up.
+		withLatest.sort((a, b) => {
+			const ai = CORE_PACKAGE_NAMES.indexOf(a.name);
+			const bi = CORE_PACKAGE_NAMES.indexOf(b.name);
+			if (ai !== -1 || bi !== -1) {
+				if (ai === -1) return 1;
+				if (bi === -1) return -1;
+				return ai - bi;
+			}
+			return a.name.localeCompare(b.name);
+		});
+
+		const status: PiCoreStatus = {
+			packages: withLatest,
+			updatesAvailable: withLatest.filter((p) => p.updateAvailable).length,
+			lastChecked: new Date().toISOString(),
+		};
+		this.cache = { at: now, data: status };
+		return status;
+	}
+
+	/** Discover pi-ecosystem packages installed via `npm -g`. */
+	private async discoverGlobal(): Promise<Array<{ name: string; version: string }>> {
+		let stdout = "";
+		try {
+			stdout = await this.npmList();
+		} catch (err) {
+			// `npm list` exits non-zero when it has warnings — stdout may still be valid JSON.
+			// execFile throws with .stdout attached in that case.
+			const maybe = (err as { stdout?: string })?.stdout;
+			if (typeof maybe === "string" && maybe.length > 0) {
+				stdout = maybe;
+			} else {
+				console.warn("[pi-core-checker] npm list -g failed:", (err as Error).message);
+				return [];
+			}
+		}
+
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(stdout);
+		} catch (err) {
+			console.warn("[pi-core-checker] npm list -g: failed to parse JSON:", (err as Error).message);
+			return [];
+		}
+
+		const deps = (parsed as { dependencies?: Record<string, { version?: string; resolved?: string }> })?.dependencies;
+		if (!deps || typeof deps !== "object") return [];
+
+		const out: Array<{ name: string; version: string }> = [];
+		for (const [name, info] of Object.entries(deps)) {
+			if (!looksLikePiEcosystem(name)) continue;
+			const version = typeof info?.version === "string" ? info.version : undefined;
+			if (!version) continue;
+			out.push({ name, version });
+		}
+		return out;
+	}
+
+	/** Discover pi-ecosystem packages in ~/.pi-dashboard/node_modules/. */
+	private discoverManaged(): Array<{ name: string; version: string }> {
+		if (!existsSync(this.managedNodeModules)) return [];
+		const out: Array<{ name: string; version: string }> = [];
+		let entries: string[];
+		try {
+			entries = readdirSync(this.managedNodeModules);
+		} catch {
+			return [];
+		}
+
+		for (const entry of entries) {
+			if (entry.startsWith(".")) continue;
+			const full = path.join(this.managedNodeModules, entry);
+			if (entry.startsWith("@")) {
+				// Scoped: iterate one level deeper.
+				let sub: string[];
+				try {
+					sub = readdirSync(full);
+				} catch {
+					continue;
+				}
+				for (const pkg of sub) {
+					const pkgName = `${entry}/${pkg}`;
+					if (!looksLikePiEcosystem(pkgName)) continue;
+					const v = this.readVersion(path.join(full, pkg));
+					if (v) out.push({ name: pkgName, version: v });
+				}
+			} else {
+				if (!looksLikePiEcosystem(entry)) continue;
+				const v = this.readVersion(full);
+				if (v) out.push({ name: entry, version: v });
+			}
+		}
+		return out;
+	}
+
+	private readVersion(pkgDir: string): string | null {
+		try {
+			const pj = path.join(pkgDir, "package.json");
+			if (!existsSync(pj)) return null;
+			if (!statSync(pj).isFile()) return null;
+			const parsed = JSON.parse(readFileSync(pj, "utf-8"));
+			return typeof parsed?.version === "string" ? parsed.version : null;
+		} catch {
+			return null;
+		}
+	}
+}
+
+export const _internal = {
+	looksLikePiEcosystem,
+	resolveDisplayName,
+	DISPLAY_NAMES,
+	MANAGED_NODE_MODULES,
+};