@erichll/pi-sandbox 0.21.0 → 0.21.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.21.1 - 2026-09-26
+
+- Alias `@earendil-works/pi-tui` for the `jiti` instance that loads the
+  `pi-subagents` internals. `pi-subagents` imports that host peer from its
+  internal modules but does not ship it, and Pi's own extension loader aliases
+  it to the copy inside the running Pi package. The protected-mode loader
+  created its own `jiti` instance without that alias, so installs where the peer
+  is not hoisted next to the extension (for example the global
+  `~/.pi/agent/npm` tree) failed to load as soon as `subagents.provider` was
+  `pi-subagents` with `pi-subagents compatibility failure: Cannot find module
+  '@earendil-works/pi-tui'`. The alias is computed host-first from the running Pi
+  package (`process.argv[1]`, `PI_PACKAGE_DIR`) and falls back to plain
+  resolution from the extension tree; an unresolvable host peer still fails
+  closed with that explicit error.
+- Add regression coverage for host alias resolution, including a `jiti` load in
+  a tree where `@earendil-works/pi-tui` is unreachable without the alias.
+
 ## 0.21.0 - 2026-09-25
 
 - Support project-level configuration at `.pi/extensions/pi-sandbox/config.json`.

package/README.md

@@ -94,7 +94,10 @@ Supported modes:
 This provider supports the `pi-subagents >=0.66.0` line (validated through
 0.71.0) and fails closed if its public ceiling API, module layout, or internal
 discovery layout drifts. The peer dependency is a floor with no upper pin; the
-loader's explicit export and layout checks are the real gate.
+loader's explicit export and layout checks are the real gate. The loader also
+aliases `@earendil-works/pi-tui`, a host peer that the `pi-subagents` internals
+import but do not ship, to the copy inside the running Pi package, so installs
+where it is not hoisted next to the extension still load.
 Configure both the protection mode and a non-empty canonical whitelist:
 
 ```json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erichll/pi-sandbox",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "description": "Linux (bubblewrap) and macOS (Seatbelt) process sandbox for Pi backed by Anthropic's @anthropic-ai/sandbox-runtime. Fail-closed static filesystem policy plus per-connection network approval from pi-auto-review; sandboxes main-agent Bash and built-in subagent process trees.",
   "type": "module",
   "license": "Apache-2.0",

package/src/pi-subagents-native.ts

@@ -1,4 +1,5 @@
-import { readFile } from "node:fs/promises";
+import { readFile, realpath } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createJiti } from "jiti";
@@ -24,6 +25,10 @@ export const PI_SUBAGENTS_COMPAT_RANGE = ">=0.66.0";
 export const NATIVE_CHILD_TOOLS = ["bash", "read", "grep", "find", "ls"] as const;
 export const PI_SANDBOX_ACKNOWLEDGEMENT = "@erichll:pi-sandbox";
 
+const HOST_PI_PACKAGE = "@earendil-works/pi-coding-agent";
+/** Host peer that pi-subagents' internal modules import but that is not installed next to it. */
+const HOST_PI_TUI_PACKAGE = "@earendil-works/pi-tui";
+
 /**
  * Module extension of the installed pi-subagents layout. Source checkouts (and
  * the 0.66.0-0.69.0 npm line) ship `.ts` modules that need a TypeScript loader;
@@ -142,6 +147,89 @@ export function piSubagentsInternalModulePath(
   return `${relativePath.replace(/\.(?:ts|js)$/u, "")}${extension}`;
 }
 
+async function readPackageName(dir: string): Promise<string | undefined> {
+  try {
+    const manifest = JSON.parse(
+      await readFile(join(dir, "package.json"), "utf8"),
+    ) as { name?: unknown };
+    return typeof manifest?.name === "string" ? manifest.name : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Walk up from a Pi entry script (or a Pi package directory) to the running
+ * `@earendil-works/pi-coding-agent` root. Returns undefined for launchers whose
+ * entry is not a real file (compiled binaries, embedded SDK hosts).
+ */
+export async function findPiPackageRootFromEntry(
+  entryPath: string,
+): Promise<string | undefined> {
+  let dir = entryPath;
+  for (;;) {
+    if ((await readPackageName(dir)) === HOST_PI_PACKAGE) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+function resolveFrom(base: string, specifier: string): string | undefined {
+  try {
+    return createRequire(base).resolve(specifier);
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Alias map for the jiti instance that loads pi-subagents internals.
+ *
+ * pi-subagents imports `@earendil-works/pi-tui` from its internal modules but,
+ * as a peer dependency, does not ship it. Pi's own extension loader aliases that
+ * specifier to the copy inside the running Pi package (`getAliases()` in the
+ * host loader), so extensions loaded by Pi resolve it; our jiti instance is a
+ * separate resolver and would otherwise fall back to plain Node resolution,
+ * which fails for installs where pi-tui is neither hoisted next to the
+ * extension nor installed beside `@earendil-works/pi-subagents`.
+ *
+ * The alias is computed host-first so the loaded modules share the host's
+ * pi-tui instance, and degrades to an empty map when no copy is reachable: the
+ * hard failure then stays the explicit compatibility error raised on load.
+ */
+export async function resolvePiSubagentsHostAliases(
+  options: { entry?: string; moduleUrl?: string; env?: Record<string, string | undefined> } = {},
+): Promise<Record<string, string>> {
+  const bases: string[] = [];
+  const entry = options.entry ?? process.argv[1];
+  if (entry) {
+    const realEntry = await realpath(entry).catch(() => undefined);
+    const root = realEntry
+      ? await findPiPackageRootFromEntry(realEntry)
+      : undefined;
+    if (root) bases.push(join(root, "package.json"));
+  }
+  const packageDir = (options.env ?? process.env).PI_PACKAGE_DIR?.trim();
+  if (packageDir && (await readPackageName(packageDir)) === HOST_PI_PACKAGE) {
+    bases.push(join(packageDir, "package.json"));
+  }
+  // Extension-local resolution: the development checkout and installs that
+  // provide pi-tui beside the extension or beside pi-subagents.
+  bases.push(options.moduleUrl ?? import.meta.url);
+
+  const seen = new Set<string>();
+  for (const base of bases) {
+    if (seen.has(base)) continue;
+    seen.add(base);
+    const resolved = resolveFrom(base, HOST_PI_TUI_PACKAGE);
+    if (!resolved) continue;
+    const target = await realpath(resolved).catch(() => resolved);
+    return { [HOST_PI_TUI_PACKAGE]: target };
+  }
+  return {};
+}
+
 /** Load the public ceiling API and the discovery/config internals.
  * This intentionally fails closed on package version, export, or layout drift.
  */
@@ -163,6 +251,7 @@ export async function loadPiSubagentsNativeRuntime(
   const jiti = createJiti(import.meta.url, {
     interopDefault: false,
     fsCache: false,
+    alias: await resolvePiSubagentsHostAliases(),
   });
   const internal = (relative: string): string =>
     pathToFileURL(join(root, piSubagentsInternalModulePath(relative, extension))).href;