@timurproko/a1 0.1.8-dev.50ebb19 → 0.1.8-dev.510

package/bin/module-resolver.js

@@ -0,0 +1,138 @@
+/**
+ * One pi-tui module identity per process, decided at the loader.
+ *
+ * npm may materialize @earendil-works/pi-tui twice under A1's package root: as A1's own
+ * dependency at the node_modules root and nested inside @earendil-works/pi-coding-agent,
+ * whose shrinkwrap pins its own copy. Two copies means two of every TUI class: pinned Pi
+ * hands extensions the copy it resolves itself, so an extension's `instanceof` check and
+ * prototype patches would land on classes A1's renderer never uses, and extension chrome
+ * would silently vanish.
+ *
+ * Rather than repairing the layout after the fact, this module asks Node which copy pinned
+ * Pi resolves and installs a synchronous resolve hook that rewrites every pi-tui module URL,
+ * from any importer and in any form (bare specifier, subpath, or an absolute path into the
+ * other copy), to that one copy. When npm hoisted a single copy the two answers coincide and
+ * the hook changes nothing. The hook is registered by the bin/ entries before any A1 module
+ * loads, so the composition, the bundled Pi public artifact, and Pi's own extension loader
+ * all share one module. bin/module-identity.js keeps the launch-time assertion that it
+ * worked.
+ *
+ * This lives in bin/ (shipped, plain JS) because it inspects dependency resolution, which
+ * the Pi API boundary policy rightly forbids ordinary production code from touching.
+ */
+import { createRequire, registerHooks } from "node:module";
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const PACKAGE = "@earendil-works/pi-tui";
+const SEGMENT = `/node_modules/${PACKAGE}/`;
+
+/** @type {string | null} */
+let installed = null;
+
+/**
+ * The package root pinned Pi resolves `@earendil-works/pi-tui` to, as a real path.
+ * @param {string} packageRoot
+ * @returns {string}
+ */
+export function pinnedPiTuiPackageRoot(packageRoot) {
+  return pinnedPiTuiLayout(packageRoot).pinnedRoot;
+}
+
+/**
+ * Where pinned Pi lives and which pi-tui copy it resolves. The installation root is the directory
+ * whose node_modules holds pinned Pi; the hook rewrites only modules beneath it, so fixture trees
+ * and other release copies inspected from this process keep their own resolution.
+ * @param {string} packageRoot
+ * @returns {{ installationRoot: string; pinnedRoot: string }}
+ */
+export function pinnedPiTuiLayout(packageRoot) {
+  const piRoot = pinnedPiRoot(packageRoot);
+  const requireFromPi = createRequire(pathToFileURL(join(piRoot, "package.json")).href);
+  return {
+    installationRoot: dirname(dirname(dirname(piRoot))),
+    pinnedRoot: packageRootOf(canonical(requireFromPi.resolve(PACKAGE))),
+  };
+}
+
+// Rationale: pinned Pi exports no `./package.json` subpath, so its directory is found by walking
+// up from the package root the way Node itself would, never by reimplementing export resolution.
+/** @param {string} packageRoot */
+function pinnedPiRoot(packageRoot) {
+  let directory = packageRoot;
+  while (true) {
+    const candidate = join(directory, "node_modules", "@earendil-works", "pi-coding-agent");
+    if (existsSync(join(candidate, "package.json"))) return canonical(candidate);
+    const parent = dirname(directory);
+    if (parent === directory) throw new Error("pinned Pi is not installed beneath this package root");
+    directory = parent;
+  }
+}
+
+/**
+ * Install the resolve hook once per process. Returns the pinned package root URL. Idempotent:
+ * every bin/ entry calls it and only the first call registers.
+ * @param {string} packageRoot
+ * @returns {string}
+ */
+export function installPinnedPiTuiResolver(packageRoot) {
+  if (installed !== null) return installed;
+  const layout = pinnedPiTuiLayout(packageRoot);
+  registerHooks({
+    resolve(specifier, context, nextResolve) {
+      const result = nextResolve(specifier, context);
+      const rewritten = redirectToPinned(result.url, layout);
+      return rewritten === result.url ? result : { ...result, url: rewritten };
+    },
+  });
+  installed = pathToFileURL(layout.pinnedRoot).href.replace(/\/$/, "");
+  return installed;
+}
+
+/**
+ * Rewrite a resolved pi-tui module URL beneath the installation root to the pinned copy; any
+ * other URL is returned unchanged. Paths are compared as canonical real paths, never as URL
+ * strings: a temp directory reached by its short 8.3 name or a different drive-letter case is
+ * still the same installation.
+ * @param {string} url
+ * @param {{ installationRoot: string; pinnedRoot: string }} layout
+ * @returns {string}
+ */
+export function redirectToPinned(url, layout) {
+  if (!url.startsWith("file:")) return url;
+  const index = url.lastIndexOf(SEGMENT);
+  if (index < 0) return url;
+  const packagePath = canonical(fileURLToPath(url.slice(0, index + SEGMENT.length - 1)));
+  if (packagePath === layout.pinnedRoot || !isWithin(layout.installationRoot, packagePath)) return url;
+  return `${pathToFileURL(layout.pinnedRoot).href.replace(/\/$/, "")}${url.slice(index + SEGMENT.length - 1)}`;
+}
+
+/**
+ * @param {string} root
+ * @param {string} path
+ */
+function isWithin(root, path) {
+  const relativePath = relative(root, path);
+  return relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+
+/** @param {string} path */
+function canonical(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+
+/** @param {string} modulePath */
+function packageRootOf(modulePath) {
+  let directory = dirname(modulePath);
+  while (!directory.endsWith(join("node_modules", "@earendil-works", "pi-tui"))) {
+    const parent = dirname(directory);
+    if (parent === directory) throw new Error(`${modulePath} is not inside a ${PACKAGE} package`);
+    directory = parent;
+  }
+  return directory;
+}

package/bin/pinned-pi-public.d.ts

@@ -0,0 +1,3 @@
+export function configurePinnedPiPublicPackageEntry(entryUrl: string): { readonly root: string; readonly version: string };
+export function pinnedPiModuleUrl(relativeModule: string): string;
+export function resolvePinnedPiImport(specifier: string): string;

package/bin/pinned-pi-public.js

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, posix, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/**
+ * Bind the generated facade to the package reached through Pi's public entry.
+ * @param {string | URL} entryUrl
+ */
+export function configurePinnedPiPublicPackageEntry(entryUrl) {
+  const root = dirname(dirname(fileURLToPath(entryUrl)));
+  const manifest = JSON.parse(readFileSync(resolve(root, "package.json"), "utf8"));
+  if (manifest.name !== "@earendil-works/pi-coding-agent" || typeof manifest.version !== "string") {
+    throw new Error("pinned Pi public package identity is invalid");
+  }
+  process.env.PI_PACKAGE_DIR = root;
+  return { root, version: manifest.version };
+}
+
+/**
+ * Preserve one bundled Pi module's original public-package URL semantics.
+ * @param {string} relativeModule
+ */
+export function pinnedPiModuleUrl(relativeModule) {
+  if (typeof relativeModule !== "string" || relativeModule.includes("\\") || relativeModule.startsWith("/")
+    || posix.normalize(relativeModule).startsWith("../") || !relativeModule.endsWith(".js")) {
+    throw new Error("pinned Pi module identity is invalid");
+  }
+  return pathToFileURL(resolve(pinnedRoot(), "dist", relativeModule)).href;
+}
+
+/**
+ * Resolve documented Pi dependency exports from the pinned public package tree.
+ * @param {string} specifier
+ */
+export function resolvePinnedPiImport(specifier) {
+  if (typeof specifier !== "string" || specifier.includes("\\") || specifier.includes("\0")) {
+    throw new Error("pinned Pi import specifier is invalid");
+  }
+  const root = pinnedRoot();
+  if (specifier === "@earendil-works/pi-coding-agent") return pathToFileURL(resolve(root, "dist", "index.js")).href;
+  const match = /^(@[^/]+\/[^/]+|[^/]+)(\/.*)?$/.exec(specifier);
+  if (match === null) throw new Error(`pinned Pi import is invalid: ${specifier}`);
+  const packageName = match[1] ?? "";
+  const subpath = match[2]?.slice(1) ?? "";
+  const packageRoot = resolve(root, "node_modules", ...packageName.split("/"));
+  const manifestPath = resolve(packageRoot, "package.json");
+  if (!existsSync(manifestPath)) throw new Error(`pinned Pi dependency is unavailable: ${packageName}`);
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  const declaredTarget = exportedTarget(manifest.exports, subpath) ?? (subpath.length === 0 ? manifest.module ?? manifest.main : undefined);
+  const target = typeof declaredTarget === "string" && !declaredTarget.startsWith(".") ? `./${declaredTarget}` : declaredTarget;
+  if (typeof target !== "string" || !target.startsWith("./")) throw new Error(`pinned Pi dependency export is unavailable: ${specifier}`);
+  const path = resolve(packageRoot, target);
+  if (!path.startsWith(`${packageRoot}${sep}`) || !existsSync(path)) throw new Error(`pinned Pi dependency export is missing: ${specifier}`);
+  return pathToFileURL(path).href;
+}
+
+function pinnedRoot() {
+  const root = process.env.PI_PACKAGE_DIR;
+  if (!root || !existsSync(resolve(root, "package.json"))) throw new Error("pinned Pi public package directory is not configured");
+  return resolve(root);
+}
+
+/**
+ * @param {unknown} exports
+ * @param {string} subpath
+ * @returns {string | undefined}
+ */
+function exportedTarget(exports, subpath) {
+  const key = subpath.length === 0 ? "." : `./${subpath}`;
+  if (typeof exports === "string") return subpath.length === 0 ? exports : undefined;
+  if (!exports || typeof exports !== "object") return undefined;
+  const exact = /** @type {Record<string, unknown>} */ (exports)[key];
+  if (exact !== undefined) return importCondition(exact);
+  for (const [pattern, value] of Object.entries(exports)) {
+    const star = pattern.indexOf("*");
+    if (star < 0 || !key.startsWith(pattern.slice(0, star)) || !key.endsWith(pattern.slice(star + 1))) continue;
+    const matched = key.slice(star, key.length - (pattern.length - star - 1));
+    const target = importCondition(value);
+    return typeof target === "string" ? target.replaceAll("*", matched) : undefined;
+  }
+  return undefined;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function importCondition(value) {
+  if (typeof value === "string") return value;
+  if (!value || typeof value !== "object") return undefined;
+  const conditions = /** @type {{ import?: unknown; default?: unknown }} */ (value);
+  return importCondition(conditions.import ?? conditions.default);
+}

package/bin/release-cleanup.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+const { runReleaseCleanupWorker } = await import("../dist/foundation/release/index.js");
+
+runReleaseCleanupWorker().catch(error => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/bin/supervisor.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { runSupervisor } from "../dist/src/foundation/supervision/index.js";
+import { runSupervisor } from "../dist/foundation/supervision/index.js";
 
-runSupervisor().catch(error => {
+runSupervisor(process.argv.slice(2)).catch(error => {
   console.error(error instanceof Error ? error.stack ?? error.message : String(error));
   process.exitCode = 1;
 });

package/bin/sync-pi-tui-proxy.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// Compatibility: updaters older than 0.1.8-dev.479 run this entry from the tree they just
+// installed to point a terminal-package proxy that no longer exists at that tree. Those
+// updaters treat a missing file as a failure worth a stack trace on the user's terminal,
+// so the entry stays, does nothing, and exits successfully. Newer updaters never run it.
+process.exitCode = 0;

package/bin/ui.js

@@ -1,30 +1,75 @@
 #!/usr/bin/env node
 
-const { assertSinglePiTuiModuleAtLaunch } = await import("./module-identity.js");
-const { fileURLToPath } = await import("node:url");
+// Invariant: one terminal module identity per process, decided before any A1 or Pi module loads.
+const { installPinnedPiTuiResolver } = await import("./module-resolver.js");
+installPinnedPiTuiResolver(new URL("..", import.meta.url).pathname.replace(/^\/(.:)/, "$1").replace(/\/$/, ""));
+const startup = await import("../dist/foundation/startup/startup-runtime.js");
+startup.enableEnvironmentCompileCache(process.env);
+const { readLaunchContext } = await import("../dist/foundation/launch-context/index.js");
+const launchContext = readLaunchContext(process.env, "profile");
+const profile = launchContext.launchProfile;
+if (profile === undefined) throw new Error("A1 launch profile is missing");
+const { installFatalExit } = await import("../dist/foundation/terminal-cleanup/fatal-exit.js");
+const { resolveProductPaths } = await import("../dist/foundation/lifecycle/paths.js");
+const { join } = await import("node:path");
+/** @type {{ dispose(): void | Promise<unknown> } | undefined} */
+let runningApplication;
+const fatal = profile === "a1" ? installFatalExit({
+  directory: join(resolveProductPaths().runtimeDir, "crashes"),
+  ...(launchContext.releaseId === undefined ? {} : { releaseId: launchContext.releaseId }),
+  dispose: () => runningApplication?.dispose(),
+}) : undefined;
+const [{ fileURLToPath }, identity, descriptor] = await Promise.all([
+  import("node:url"),
+  import("./module-identity.js"),
+  import("../dist/foundation/startup/startup-descriptor.js"),
+]);
+const packageRootPath = fileURLToPath(new URL("..", import.meta.url));
+identity.configurePinnedPiPublicPackage(packageRootPath);
+// Performance: begin the exact launch graph together while the trace write is pending.
+// Direct owned-module entries avoid evaluating unrelated barrel exports before first paint.
+const modules = descriptor.loadDeclaredStartupGraph();
+await startup.markStartupPhase(process.env, "ui-entry");
+const [
+  { runSelectedInteractiveRuntime },
+  { parseSessionSelection },
+  { createConsoleProjectTrustPrompt },
+  { createConsoleSessionForkPrompt },
+  { runOwnedUi, terminateOwnedUiProcess },
+  { composeOwnedUi },
+] = await modules;
 
-// Before the composition loads pinned Pi's terminal stack: confirm A1 and Pi
-// resolve it to the same copy, so extensions and the owned UI share one module
-// identity (see bin/module-identity.js for the full story). Nothing is repaired
-// here — A1's package manifest decides which copy wins, and this only reports
-// when that stopped being true.
-assertSinglePiTuiModuleAtLaunch(fileURLToPath(new URL("..", import.meta.url)), message => process.stderr.write(message));
+// Compatibility: before the composition uses pinned Pi's terminal stack: confirm A1 and Pi
+// resolve it to the same copy, so extensions and the owned UI share one module identity.
+identity.assertSinglePiTuiModuleAtLaunch(packageRootPath, (/** @type {string} */ message) => process.stderr.write(message));
+await startup.markStartupPhase(process.env, "ui-modules-loaded");
 
-const { runSelectedInteractiveRuntime } = await import("../dist/src/features/launch/index.js");
-
-runSelectedInteractiveRuntime(process.env.A1_LAUNCH_PROFILE ?? "a1", {
-  ownedUi: async (profileId, ownedSurfaces) => {
-    const [{ runOwnedUi }, { composeOwnedUi }] = await Promise.all([
-      import("../dist/src/features/owned-ui/index.js"),
-      import("../dist/src/composition/index.js"),
-    ]);
-    const { application, settings } = await composeOwnedUi({ cwd: process.cwd(), profileId, ownedSurfaces });
-    return await runOwnedUi({ application, ...(settings === null ? {} : { settings }) });
-  },
+const sessionSelection = parseSessionSelection(process.argv.slice(2));
+Promise.resolve().then(() => {
+  if (sessionSelection && profile !== "a1") throw new Error("session selection requires the normal A1 profile");
+  return runSelectedInteractiveRuntime(profile, {
+    ownedUi: async (profileId, ownedSurfaces) => {
+      const { application, settings } = await composeOwnedUi({
+        cwd: process.cwd(),
+        profileId,
+        ownedSurfaces,
+        projectTrustPrompt: createConsoleProjectTrustPrompt(),
+        sessionForkPrompt: createConsoleSessionForkPrompt(),
+        ...(sessionSelection === undefined ? {} : { sessionSelection }),
+      });
+      runningApplication = application;
+      return await runOwnedUi({ application, ...(settings === null ? {} : { settings }) });
+    },
+  });
 }).then(
-  code => { process.exitCode = code; },
+  code => {
+    fatal?.remove();
+    return terminateOwnedUiProcess(code);
+  },
   error => {
-    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
-    process.exitCode = 1;
+    if (fatal && error?.name !== "PiSessionSelectionError") { fatal.fail(error); return; }
+    fatal?.remove();
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = error?.name === "PiSessionSelectionError" ? error.exitCode : 1;
   },
 );