@bli-cockpit/cli 0.2.50 → 0.2.51

package/dist/commands/memory-install-contract.js

@@ -42,6 +42,13 @@
  * env = { COCKPIT_DASHBOARD_URL = "https://…" }
  * ```
  *
+ * **The printed `command` is a bare name and is never written as-is.** The bin
+ * cannot know where it was installed, and it lives nested inside
+ * `@bli-cockpit/cli`'s `node_modules` rather than on PATH — so
+ * `withResolvedBinPath` re-points every command at the absolute path this
+ * machine resolved before anything is written. Skipping that step registered
+ * three hooks that answered `command not found` on every turn.
+ *
  * Nothing here touches the filesystem. The halves that do are
  * `memory-install-claude.ts` and `memory-install-codex.ts`.
  */
@@ -207,6 +214,54 @@ export function parsePrintedMemoryInstallConfig(stdout) {
         permissions_allow: allow ?? [...MEMORY_AUTO_APPROVE_TOOLS],
     };
 }
+/**
+ * Put THIS machine's resolved bin path into a config the bin printed.
+ *
+ * The printed contract says `command: "bli-memory-mcp"` — a bare name, because
+ * the bin has no idea where it was installed. `bli-memory-mcp` is a DEPENDENCY
+ * of `@bli-cockpit/cli`, nested inside its `node_modules`, and therefore **not
+ * on anybody's PATH**: a host handed the bare name answers `command not found`
+ * on every SessionStart, every prompt and every Stop. The installer is the only
+ * thing that knows the absolute path, so path qualification happens here and
+ * the printed strings are never written verbatim (BLI-3580; found by running
+ * the registered hook command in a simulated global install, not by reading
+ * the code).
+ *
+ * What the printed config still owns: which hook EVENTS exist, their
+ * subcommands, their timeouts, the server id and the allow-list. What this
+ * function owns: where the program is, and the per-platform launch shape.
+ *
+ * Returns null when a printed hook command cannot be understood well enough to
+ * re-point — the caller then falls back to the built-in template, which is
+ * always path-qualified. Guessing at a command we cannot parse would write a
+ * hook that runs something else.
+ */
+export function withResolvedBinPath(config, options) {
+    const quoted = shellQuoteBinPath(options.binPath);
+    const hooks = [];
+    for (const hook of config.hooks) {
+        const tail = hookSubcommandTail(hook.command);
+        if (!tail)
+            return null;
+        hooks.push({ ...hook, command: `${quoted} ${tail}` });
+    }
+    const entry = memoryMcpServerEntry(options);
+    return {
+        ...config,
+        // The bin's own env wins nothing and loses nothing: it prints `{}`, and the
+        // dashboard URL is a machine fact the installer holds.
+        mcp_server: { ...entry, env: { ...config.mcp_server.env, ...entry.env } },
+        hooks,
+    };
+}
+/**
+ * `…/bli-memory-mcp hook prompt` → `hook prompt`. The subcommand is the part we
+ * keep; everything before it is a path that may be wrong for this machine.
+ */
+function hookSubcommandTail(command) {
+    const match = /(^|\s)(hook\s+\S+.*)$/u.exec(command.trim());
+    return match?.[2]?.trim() ?? null;
+}
 function normalizeStringArray(value) {
     if (value === undefined)
         return [];

package/dist/commands/memory-install.js

@@ -17,8 +17,10 @@
  *
  * - **Where the server is.** `bli-memory-mcp` ships as a DEPENDENCY of
  *   `@bli-cockpit/cli`, so the canonical lookup is the `node_modules/.bin` on
- *   the way up from this CLI's own entry point; PATH is the fallback. Nobody
- *   ever installs a second global package. See `resolveMemoryMcpBin`.
+ *   the way up from THIS MODULE's own file — realpath-ed first, because a
+ *   global `cockpit` is a symlink and walking up from the symlink finds
+ *   nothing; PATH is the fallback. Nobody ever installs a second global
+ *   package. See `resolveMemoryMcpBin`, which carries the receipt.
  * - **No server, no write.** If the bin does not resolve, not one file is
  *   opened and the outcome is `skipped bin_missing` — see `no_bin_no_write`
  *   below for why a written-but-inert registration is the worse option.
@@ -32,10 +34,12 @@
  * - **Never claim an install it did not read back** (BLI-2541). Both halves
  *   re-read and re-parse; this module only aggregates what they proved.
  */
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { writeLine } from "./cli-io.js";
-import { builtinMemoryInstallConfig, isUnsafeBinPath, MEMORY_MCP_BIN, parsePrintedMemoryInstallConfig, } from "./memory-install-contract.js";
+import { builtinMemoryInstallConfig, isUnsafeBinPath, MEMORY_MCP_BIN, parsePrintedMemoryInstallConfig, withResolvedBinPath, } from "./memory-install-contract.js";
 import { defaultMemoryFileIo, } from "./memory-install-files.js";
 import { installClaudeMemoryIntegration, inspectClaudeMemoryIntegration, } from "./memory-install-claude.js";
 import { installCodexMemoryIntegration, inspectCodexMemoryIntegration, } from "./memory-install-codex.js";
@@ -140,6 +144,7 @@ async function resolveMemoryConfig(command, io, platform, deps) {
         platform,
         fileExists: deps.fileExists,
         cliEntryPoint: deps.cliEntryPoint,
+        realpath: deps.realpath,
     });
     if (!found) {
         return {
@@ -172,10 +177,35 @@ async function resolveMemoryConfig(command, io, platform, deps) {
     }
     const printed = await printedMemoryConfig(io, found.path);
     if (printed) {
+        // The bin prints a BARE command name — it cannot know where it was
+        // installed, and it is nested inside the CLI's node_modules rather than on
+        // PATH. Path-qualifying it here is what makes the registration runnable at
+        // all; see `withResolvedBinPath`.
+        const qualified = withResolvedBinPath(printed, {
+            binPath: found.path,
+            platform,
+            dashboardUrl,
+        });
+        if (qualified) {
+            return {
+                config: qualified,
+                source: "bin",
+                binTarget: { target: "bin", status: "already", reason: "bin_printed_config" },
+                bin_source: found.source,
+            };
+        }
+        // A printed hook command this installer cannot re-point. The template is
+        // always path-qualified, so it is the safe answer — and the reason says
+        // which of the two fallbacks happened.
         return {
-            config: printed,
-            source: "bin",
-            binTarget: { target: "bin", status: "already", reason: "bin_printed_config" },
+            config: builtinMemoryInstallConfig({ binPath: found.path, platform, dashboardUrl }),
+            source: "template",
+            binTarget: {
+                target: "bin",
+                status: "already",
+                reason: "bin_printed_config_unqualifiable",
+                detail: "the bin printed a hook command this installer could not re-point at the resolved path; the built-in shape was used",
+            },
             bin_source: found.source,
         };
     }
@@ -222,12 +252,11 @@ async function printedMemoryConfig(io, binPath) {
  *
  * **1. Beside the CLI that is running.** `bli-memory-mcp` ships as a DEPENDENCY
  * of `@bli-cockpit/cli`, so installing the CLI installs the server, and npm
- * links its bin into a `node_modules/.bin` on the path from this entry point up
- * to the install root — `…/@bli-cockpit/cli/node_modules/.bin` when it is
- * nested, `…/lib/node_modules/.bin` when npm hoists it. Walking up from
- * `process.argv[1]` finds it either way, and it is the ONLY lookup that cannot
- * find somebody else's `bli-memory-mcp`. Nobody ever runs `npm i -g` for a
- * second package.
+ * links its bin into a `node_modules/.bin` on the path from this package up to
+ * the install root — `…/@bli-cockpit/cli/node_modules/.bin` when it is nested,
+ * `…/lib/node_modules/.bin` when npm hoists it. It is the ONLY lookup that
+ * cannot find somebody else's `bli-memory-mcp`. Nobody ever runs `npm i -g` for
+ * a second package.
  *
  * **2. PATH, as a fallback**, for a linked checkout or a hand-installed server.
  * Done in this process rather than through `which`/`where`: it spawns nothing,
@@ -236,6 +265,26 @@ async function printedMemoryConfig(io, binPath) {
  * standard layouts, which is why the caller passes a PATH that already includes
  * it (`envWithNodeRuntimeOnPath`) — the launchd tick's PATH is otherwise
  * `/usr/bin:/bin:/usr/sbin:/sbin` and would find nothing.
+ *
+ * **What step 1 got wrong on the first real machine** (BLI-3580, CLI 0.2.50):
+ * it walked up from `process.argv[1]`, resolved with `path.resolve` and no
+ * symlink following. For a global install `argv[1]` is the SHIM — on Edward's
+ * Mac `/opt/homebrew/bin/cockpit`, a symlink into
+ * `/opt/homebrew/lib/node_modules/@bli-cockpit/cli/dist/cli.js`. The walk
+ * therefore started in `/opt/homebrew/bin`, went up through `/opt` to `/`, and
+ * never came within reach of the nested `.bin` that was sitting right there.
+ * Every machine reported `skipped bin_missing` with the server installed.
+ *
+ * Two changes, both in `besideAnchors` / `resolveBesideCli`:
+ *
+ *  - The anchor is **this module's own file** first (`import.meta.url`), which
+ *    is inside the installed package by construction and is never a shim. The
+ *    entry point (injected, or `argv[1]`) stays as a second anchor for a build
+ *    layout where this module has been bundled somewhere else.
+ *  - Every anchor is **realpath-ed** before the walk, so a symlinked entry
+ *    lands in the real tree. A path that will not resolve is used as given —
+ *    the same bounded silence `container-tag.ts` uses, because a path that
+ *    cannot be realpath-ed still identifies a directory well enough to look in.
  */
 export async function resolveMemoryMcpBin(options) {
     const exists = options.fileExists ?? defaultFileExists;
@@ -245,28 +294,66 @@ export async function resolveMemoryMcpBin(options) {
     const onPath = await resolveOnPath(options, exists);
     return onPath ? { path: onPath, source: "path" } : null;
 }
-async function resolveBesideCli(options, exists) {
+/**
+ * Where to start walking, in order of trustworthiness. This module's own
+ * location first: it is inside the installed package and cannot be a shim.
+ */
+function besideAnchors(options) {
+    const anchors = [];
+    const own = currentModulePath();
+    if (own)
+        anchors.push(own);
     const entry = options.cliEntryPoint ?? process.argv[1];
-    if (!entry)
+    if (entry)
+        anchors.push(entry);
+    return anchors;
+}
+function currentModulePath() {
+    try {
+        return fileURLToPath(import.meta.url);
+    }
+    catch {
+        // A bundler that dropped `import.meta` support. The entry-point anchor
+        // still covers it, so this is a narrowing rather than a failure.
         return null;
+    }
+}
+async function resolveBesideCli(options, exists) {
     const platformPath = options.platform === "win32" ? path.win32 : path.posix;
     const extensions = binExtensions(options.platform);
-    let directory = platformPath.dirname(platformPath.resolve(entry));
-    // Bounded walk: deep enough for `…/node_modules/@scope/pkg/dist/cli.js` plus
-    // a hoisted root above it, and it stops at the filesystem root anyway.
-    for (let depth = 0; depth < 12; depth += 1) {
-        for (const extension of extensions) {
-            const candidate = platformPath.join(directory, "node_modules", ".bin", `${MEMORY_MCP_BIN}${extension}`);
-            if (await exists(candidate))
-                return candidate;
+    const realpath = options.realpath ?? defaultRealpath;
+    for (const anchor of besideAnchors(options)) {
+        let directory = platformPath.dirname(realpath(platformPath.resolve(anchor)));
+        // Bounded walk: deep enough for `…/node_modules/@scope/pkg/dist/cli.js`
+        // plus a hoisted root above it, and it stops at the filesystem root anyway.
+        for (let depth = 0; depth < 12; depth += 1) {
+            for (const extension of extensions) {
+                const candidate = platformPath.join(directory, "node_modules", ".bin", `${MEMORY_MCP_BIN}${extension}`);
+                if (await exists(candidate))
+                    return candidate;
+            }
+            const parent = platformPath.dirname(directory);
+            if (parent === directory)
+                break;
+            directory = parent;
         }
-        const parent = platformPath.dirname(directory);
-        if (parent === directory)
-            break;
-        directory = parent;
     }
     return null;
 }
+/**
+ * `realpathSync.native` follows the symlink npm writes for a global bin. A
+ * path that does not resolve — a Windows path being reasoned about from a Mac
+ * in a test, a directory that has since moved — comes back unchanged rather
+ * than throwing, because the walk above can still look inside it.
+ */
+function defaultRealpath(value) {
+    try {
+        return fs.realpathSync.native(value);
+    }
+    catch {
+        return value;
+    }
+}
 async function resolveOnPath(options, exists) {
     // The TARGET platform's path rules, not the running one's. On a real machine
     // they are the same; asking for them explicitly is what lets the Windows

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.50");
+    writeLine(io?.stdout ?? process.stdout, "0.2.51");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.50",
+  "version": "0.2.51",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,7 +27,7 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.0",
+    "@bli-cockpit/memory-mcp": "0.1.1",
     "@bli-cockpit/telemetry-core": "0.1.26"
   }
 }