@phnx-labs/agents-cli 1.20.72 → 1.20.74

package/dist/lib/version.js

@@ -1,28 +1,111 @@
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 let cached = null;
+/** Read a `version` string from a package.json, or null if unreadable. */
+function readVersionAt(pkgPath) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return String(pkg.version || '') || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Well-known locations of the `agents` launcher for PATH-less GUI/launchd
+ * processes (the menu-bar helper inherits no login PATH). Also the anchor for
+ * recovering the on-disk install layout when the CLI runs as a Bun single-file
+ * binary — see {@link resolveInstalledLayout}.
+ */
+export function resolveAgentsBin() {
+    const home = os.homedir();
+    const candidates = [
+        path.join(home, '.local', 'bin', 'agents'),
+        '/opt/homebrew/bin/agents',
+        '/usr/local/bin/agents',
+        path.join(home, '.npm-global', 'bin', 'agents'),
+    ];
+    for (const c of candidates) {
+        try {
+            fs.accessSync(c, fs.constants.X_OK);
+            return c;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return null;
+}
+/**
+ * Pure derivation (no I/O) of an install's on-disk layout from the realpath of
+ * its `agents` launcher. A launcher lives at `<pkg>/dist/bin/agents`, so two
+ * levels up is `<pkg>/dist`. Exported for unit testing so the dirname chain the
+ * Bun-binary fallback depends on stays locked.
+ */
+export function installLayoutFromBin(realBin) {
+    const distDir = path.dirname(path.dirname(realBin)); // <pkg>/dist/bin/agents -> <pkg>/dist
+    return {
+        distDir,
+        entryPath: path.join(distDir, 'index.js'),
+        pkgJsonPath: path.join(distDir, '..', 'package.json'),
+    };
+}
+/**
+ * Resolve the on-disk install layout of the running CLI by following the
+ * `agents` launcher symlink.
+ *
+ * When the CLI runs as a Bun single-file executable, `import.meta.url` points
+ * inside the virtual bundle (`/$bunfs/…`), so sibling-relative resolution can't
+ * see the shipped `package.json`, `dist/index.js`, or `MenubarHelper.app` on
+ * disk. The launcher symlink points at the real files; walk up from it. Returns
+ * null when no launcher is found (dev/tsx runs, or a box without the helper) —
+ * callers keep their in-bundle resolution as the primary path and use this only
+ * as the fallback.
+ */
+export function resolveInstalledLayout() {
+    const bin = resolveAgentsBin();
+    if (!bin)
+        return null;
+    try {
+        const layout = installLayoutFromBin(fs.realpathSync(bin));
+        // Validate we landed on a real dist (guards an unexpected launcher layout).
+        if (fs.existsSync(layout.entryPath))
+            return layout;
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
 /**
  * Resolve the CLI version from the shipping package.json. Used by the daemon
  * to answer `IPCAction: 'version'` and by the client to detect daemon drift —
  * a dev-build CLI talking to a launchd-managed registry daemon would silently
  * get stale behavior without this check.
+ *
+ * Primary read is relative to this module; when that fails (the Bun single-file
+ * binary can't read its own bundled package.json), fall back to the on-disk
+ * install found via the launcher symlink so callers like the menu bar don't see
+ * a bogus `unknown`.
  */
 export function getCliVersion() {
     if (cached)
         return cached;
-    try {
-        const pkgPath = path.join(__dirname, '..', '..', 'package.json');
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        cached = String(pkg.version || 'unknown');
-    }
-    catch {
-        cached = 'unknown';
-    }
+    cached =
+        readVersionAt(path.join(__dirname, '..', '..', 'package.json')) ??
+            readInstalledPackageVersion() ??
+            'unknown';
     return cached;
 }
+/** Version from the on-disk install (Bun-binary fallback). */
+function readInstalledPackageVersion() {
+    const layout = resolveInstalledLayout();
+    return layout ? readVersionAt(layout.pkgJsonPath) : null;
+}
 /**
  * Read the version from package.json on disk every call, bypassing the cache.
  *
@@ -34,12 +117,7 @@ export function getCliVersion() {
  * 'unknown' on any error.
  */
 export function getCliVersionFresh() {
-    try {
-        const pkgPath = path.join(__dirname, '..', '..', 'package.json');
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-        return String(pkg.version || 'unknown');
-    }
-    catch {
-        return 'unknown';
-    }
+    return (readVersionAt(path.join(__dirname, '..', '..', 'package.json')) ??
+        readInstalledPackageVersion() ??
+        'unknown');
 }

package/dist/lib/versions.d.ts

@@ -216,6 +216,19 @@ export declare function getGlobalDefault(agent: AgentId): string | null;
  * Set the global default version for an agent.
  */
 export declare function setGlobalDefault(agent: AgentId, version: string | undefined): void;
+/**
+ * Get the preferred ISOLATED version for an agent — the copy a bare
+ * `agents run <agent>` falls back to when there is no global default.
+ */
+export declare function getIsolatedDefault(agent: AgentId): string | null;
+/**
+ * Set (or clear, with `undefined`) the preferred isolated version.
+ *
+ * Deliberately does NOT touch the launcher, the bare shim, the `~/.<agent>` config
+ * symlink or the global default — the five things `setDefaultVersion` does. This is
+ * a pointer inside the sandbox, so it stays inside the sandbox.
+ */
+export declare function setIsolatedDefault(agent: AgentId, version: string | undefined): void;
 /**
  * Mark an installed version as an isolated install (`agents add --isolated`).
  *
@@ -415,6 +428,17 @@ export declare function verifyInstalledBinaryLaunches(agent: AgentId, version: s
  *   4. Nothing runnable installed → install `latest`, pin it, return it.
  *   5. Give up → return null (caller surfaces a clear error).
  *
+ * Isolation boundary (both directions — steps 3/4 are the only mutating ones):
+ *   - An ISOLATED target gets step 2 and nothing else. Falling back would let
+ *     `agents run <agent>@<isolated>` silently repoint the user's NORMAL default,
+ *     and installing `latest` would materialize a version they never asked for.
+ *     A failed repair returns null so the caller says so plainly.
+ *   - An isolated version is never a fallback CANDIDATE either, whatever the
+ *     target is: promoting one to the global default is exactly what `agents use`
+ *     refuses and what removeVersion's promotion filter excludes, so it must not
+ *     happen here by the back door (the daemon's launch-health pass calls this
+ *     unattended every ~6h).
+ *
  * Gated to npm-package agents: their native binary ships as an optional per-arch
  * dependency whose tarball can extract partially (interrupted/raced install) —
  * the exact failure this repairs. Agents with a global/native binary (grok,