@timurproko/a1 0.1.8-dev.130 → 0.1.8-dev.134

package/README.md

@@ -6,6 +6,20 @@
 npm install --global @timurproko/a1@latest
 ```
 
+Any channel can also be installed or updated directly with npm, without the
+`a1 update` commands:
+
+```sh
+# dev channel (next tag)
+npm install -g @timurproko/a1@next
+
+# stable release
+npm install -g @timurproko/a1@latest
+
+# exact version
+npm install -g @timurproko/a1@0.1.8-dev.107
+```
+
 ## Use
 
 ```sh

package/bin/module-identity.js

@@ -87,7 +87,7 @@ function followProxyReExport(resolvedPath) {
  * no CommonJS condition, so an ordinary require cannot name it. From there a
  * require resolves pi-tui, which publishes no `exports` map at all.
  */
-function resolvePinnedPiTui(packageRoot) {
+export function resolvePinnedPiTui(packageRoot) {
   let directory = packageRoot;
   while (true) {
     const candidate = join(directory, "node_modules", "@earendil-works", "pi-coding-agent");

package/bin/pi-tui.d.ts

@@ -3,4 +3,4 @@
  * file, so TypeScript reads this declaration and follows it to pinned Pi's
  * nested pi-tui copy — the same module the proxy re-exports at runtime.
  */
-export * from "../node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui/dist/index.js";
+export * from "../node_modules/@earendil-works/pi-coding-agent/node_modules/@earendil-works/pi-tui/dist/index.d.ts";

package/bin/pi-tui.js

@@ -12,10 +12,14 @@
  * plain import specifier in a module carries no such restriction, so the hop
  * through this file is what makes the nested copy nameable from the manifest.
  *
- * When the nested copy is missing (a layout pinned Pi's shrinkwrap does not
- * produce), this import fails loudly at launch instead of silently rendering
- * without extension chrome. bin/module-identity.js reports the same condition
- * before the composition loads.
+ * npm does not materialize one layout: `npm ci` keeps pinned Pi's shrinkwrapped
+ * nested copy, while a global install hoists pi-tui to the root and produces no
+ * nested copy. bin/sync-pi-tui-proxy.js therefore rewrites this file's one
+ * re-export on postinstall to whatever pinned Pi resolves in the tree npm
+ * actually built; the path below is the dev-checkout (`npm ci`) shape. When the
+ * target is missing anyway, this import fails loudly at launch instead of
+ * silently rendering without extension chrome, and bin/module-identity.js
+ * reports the same condition before the composition loads.
  *
  * This lives in bin/ (shipped, plain JS) because it names a path inside
  * node_modules, which the Pi API boundary policy rightly forbids ordinary

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

@@ -0,0 +1,97 @@
+/**
+ * Point the `#pi-tui` proxy at the copy pinned Pi actually resolves.
+ *
+ * The proxy (bin/pi-tui.js) re-exports one static path, but npm does not
+ * materialize one layout: `npm ci` against A1's lockfile keeps pinned Pi's
+ * shrinkwrapped nested pi-tui copy, while a global `npm install -g` of the
+ * published tarball hoists pi-tui to A1's node_modules root and materializes
+ * no nested copy at all. A static path can only name one of those layouts —
+ * whichever the other layout lacks, the proxy's import fails at launch and
+ * extension UI never renders.
+ *
+ * This script runs on postinstall, asks Node what pinned Pi resolves
+ * `@earendil-works/pi-tui` to — the copy Pi's extension loader hands to
+ * extensions — and rewrites the proxy's single re-export (and its declaration
+ * twin) to that file. Whatever tree npm built, the proxy names the module Pi
+ * uses, so A1's renderer and Pi's extensions share one class identity.
+ *
+ * It never fails an install: a tree in which pinned Pi or its pi-tui cannot
+ * be resolved is reported on stderr and left untouched, and launch's
+ * module-identity check names the same condition to the user.
+ *
+ * This lives in bin/ (shipped, plain JS) because it inspects and names
+ * dependency resolution, which the Pi API boundary policy rightly forbids
+ * ordinary production code from touching.
+ */
+import { readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { resolvePinnedPiTui } from "./module-identity.js";
+
+const RE_EXPORT_LINE = /^export \* from "[^"]+";$/m;
+
+/**
+ * Rewrite the proxy pair under packageRoot/bin to re-export the pi-tui module
+ * pinned Pi resolves. Returns a discriminated outcome; never throws.
+ */
+export function syncPiTuiProxy(packageRoot) {
+  // resolvePinnedPiTui answers with a canonical real path, so the directory the
+  // relative specifier is computed from must be canonical too (Windows short
+  // names, symlinked installs).
+  const canonicalRoot = canonical(packageRoot);
+  let target;
+  try {
+    target = resolvePinnedPiTui(canonicalRoot);
+  } catch (error) {
+    return { kind: "unresolved", message: error instanceof Error ? error.message : String(error) };
+  }
+
+  const binDirectory = join(canonicalRoot, "bin");
+  const runtimeSpecifier = relativeSpecifier(binDirectory, target);
+  const declarationSpecifier = runtimeSpecifier.replace(/\.js$/, ".d.ts").replace(/\.d\.d\.ts$/, ".d.ts");
+  const changed = [];
+  for (const [file, specifier] of [
+    ["pi-tui.js", runtimeSpecifier],
+    ["pi-tui.d.ts", declarationSpecifier],
+  ]) {
+    if (rewriteReExport(join(binDirectory, file), specifier)) changed.push(file);
+  }
+  return { kind: "synced", target, changed };
+}
+
+function canonical(path) {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
+
+function relativeSpecifier(fromDirectory, toFile) {
+  const specifier = relative(fromDirectory, toFile).split("\\").join("/");
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+
+/** Replace the file's single re-export line; returns whether the file changed. */
+function rewriteReExport(file, specifier) {
+  let source;
+  try {
+    source = readFileSync(file, "utf8");
+  } catch {
+    return false;
+  }
+  const line = `export * from "${specifier}";`;
+  if (source.includes(line) || !RE_EXPORT_LINE.test(source)) return false;
+  writeFileSync(file, source.replace(RE_EXPORT_LINE, line));
+  return true;
+}
+
+const invokedDirectly = process.argv[1] !== undefined
+  && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (invokedDirectly) {
+  const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+  const outcome = syncPiTuiProxy(packageRoot);
+  if (outcome.kind === "unresolved") {
+    process.stderr.write(`a1: could not point #pi-tui at pinned Pi's copy (${outcome.message}); extension UI may not render.\n`);
+  }
+}

package/dist/cli/version-stats.d.ts

@@ -3,6 +3,11 @@ interface VersionProcessResult {
     readonly stdout: string;
 }
 type VersionProcessRunner = (command: string, arguments_: readonly string[]) => Promise<VersionProcessResult>;
+type RegistryFetcher = (url: string) => Promise<{
+    readonly ok: boolean;
+    readonly status: number;
+    text(): Promise<string>;
+}>;
 interface VersionOutput {
     stdout(message: string): void;
     stderr(message: string): void;
@@ -11,6 +16,7 @@ export interface VersionStatsOptions {
     readonly packageRoot: string;
     readonly output?: VersionOutput;
     readonly runner?: VersionProcessRunner;
+    readonly fetcher?: RegistryFetcher;
 }
 export declare function runVersionStats(options: VersionStatsOptions): Promise<number>;
 export {};

package/dist/cli/version-stats.js

@@ -20,13 +20,24 @@ export async function runVersionStats(options) {
         output.stderr(`${PRODUCT_TEXT.diagnostic(`could not read its installed version: ${message(error)}`)}\n`);
         return 1;
     }
-    const remote = await queryDistTags(runner);
+    const remote = await queryDistTags(runner, options.fetcher ?? defaultRegistryFetcher);
     output.stdout(`Current: ${installed}\nDevelop: ${remote.develop ?? "unavailable"}\nRelease: ${remote.release ?? "unavailable"}\n`);
     if (remote.error)
         output.stderr(`${PRODUCT_TEXT.diagnostic(`could not resolve npm dist-tags: ${remote.error}`)}\n`);
     return 0;
 }
-async function queryDistTags(runner) {
+// npm view respects the user's .npmrc registry and proxy, so it stays primary; the direct
+// registry fetch below covers npm CLI versions whose --json output shape we cannot parse.
+async function queryDistTags(runner, fetcher) {
+    const fromNpm = await queryDistTagsViaNpm(runner);
+    if (fromNpm.error === null)
+        return fromNpm;
+    const fromRegistry = await queryDistTagsViaRegistry(fetcher);
+    if (fromRegistry.error === null)
+        return fromRegistry;
+    return unavailable(`${fromNpm.error}; registry fallback failed: ${fromRegistry.error}`);
+}
+async function queryDistTagsViaNpm(runner) {
     let result;
     try {
         result = await runner("npm", ["view", PRODUCT_TEXT.packageName, "dist-tags", "--json"]);
@@ -37,12 +48,34 @@ async function queryDistTags(runner) {
     if (result.code !== 0)
         return unavailable(`npm exited with status ${result.code ?? "unknown"}`);
     try {
-        const metadata = JSON.parse(result.stdout);
-        if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata))
-            throw new TypeError("npm returned a non-object dist-tags value");
+        const parsed = JSON.parse(result.stdout);
+        // npm 12 wraps `npm view <pkg> dist-tags --json` output in a one-element array; older npm returns the bare object.
+        const metadata = Array.isArray(parsed) && parsed.length === 1 ? parsed[0] : parsed;
+        return parseDistTags(metadata, "npm");
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+}
+async function queryDistTagsViaRegistry(fetcher) {
+    try {
+        const response = await fetcher(`https://registry.npmjs.org/-/package/${encodeURIComponent(PRODUCT_TEXT.packageName)}/dist-tags`);
+        if (!response.ok)
+            return unavailable(`registry responded with status ${response.status}`);
+        return parseDistTags(JSON.parse(await response.text()), "registry");
+    }
+    catch (error) {
+        return unavailable(message(error));
+    }
+}
+function parseDistTags(metadata, source) {
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
+        return unavailable(`${source} returned a non-object dist-tags value`);
+    }
+    try {
         const tags = metadata;
-        const release = parseVersion(tags.latest, "npm latest");
-        const develop = tags.next === undefined ? null : parseVersion(tags.next, "npm development channel");
+        const release = parseVersion(tags.latest, `${source} latest`);
+        const develop = tags.next === undefined ? null : parseVersion(tags.next, `${source} development channel`);
         return { release, develop, error: null };
     }
     catch (error) {
@@ -52,6 +85,7 @@ async function queryDistTags(runner) {
 function unavailable(error) {
     return { release: null, develop: null, error };
 }
+const defaultRegistryFetcher = async (url) => await fetch(url, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(10_000) });
 function createVersionProcessRunner() {
     return async (command, arguments_) => await new Promise((resolvePromise, rejectPromise) => {
         const child = process.platform === "win32"

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-25T16:56:36.512Z",
+  "builtAt": "2026-08-25T18:22:19.065Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",

package/dist/native/linux-x64/manifest.json

@@ -5,11 +5,11 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T16:56:38.746Z",
+  "builtAt": "2026-08-25T18:22:33.863Z",
   "artifact": {
     "filename": "process-guardian",
-    "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",
-    "size": 415696
+    "sha256": "ee8a00eaaf79c707459bbbfb52518e9739314967049fbe5fa625f36ce33db9ee",
+    "size": 414568
   },
   "provenance": {
     "language": "Rust",

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T16:59:38.976Z",
+  "builtAt": "2026-08-25T18:23:18.046Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "da0fe2ae613bf33949d317b1221ed5047f0929ae2fc90c91f7dfe2f4b7e27ea4",
+    "sha256": "2f13a4c73ed082a13cf9947be6f363c3c800eaf40e22ea9ae4674299d7f51cdd",
     "size": 172544
   },
   "provenance": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.130",
+  "version": "0.1.8-dev.134",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",
@@ -21,6 +21,7 @@
     "node": ">=22.19.0 <25"
   },
   "scripts": {
+    "postinstall": "node bin/sync-pi-tui-proxy.js",
     "clean": "node scripts/clean.mjs",
     "build": "npm run clean && tsc -p tsconfig.build.json && node scripts/development/build-process-guardian.mjs",
     "build:process-guardian": "node scripts/development/build-process-guardian.mjs",