@bli-cockpit/cli 0.2.56 → 0.2.58

package/dist/commands/mcp-bin-resolve.js

@@ -0,0 +1,102 @@
+/**
+ * Where an MCP server's bin lives on THIS machine, for any server shipped as a
+ * dependency of `@bli-cockpit/cli` (BLI-3580's `resolveMemoryMcpBin`,
+ * generalised for BLI-3706's `bli-tower` registration so the second server
+ * does not carry a second copy of this walk).
+ *
+ * Two steps, in this order — see `memory-install.ts`'s `resolveMemoryMcpBin`
+ * doc comment for the full BLI-3580 story of why the walk starts at THIS
+ * module's own file (never a shim) and realpath-resolves every anchor before
+ * walking:
+ *
+ *  1. Beside the CLI that is running — the ONLY lookup that cannot find
+ *     somebody else's copy of the bin.
+ *  2. PATH, as a fallback for a linked checkout or a hand-installed server.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export async function resolveMcpBin(options) {
+    const exists = options.fileExists ?? defaultFileExists;
+    const beside = await resolveBesideCli(options, exists);
+    if (beside)
+        return { path: beside, source: "cli_dependency" };
+    const onPath = await resolveOnPath(options, exists);
+    return onPath ? { path: onPath, source: "path" } : null;
+}
+function besideAnchors(options) {
+    const anchors = [];
+    const own = currentModulePath();
+    if (own)
+        anchors.push(own);
+    const entry = options.cliEntryPoint ?? process.argv[1];
+    if (entry)
+        anchors.push(entry);
+    return anchors;
+}
+function currentModulePath() {
+    try {
+        return fileURLToPath(import.meta.url);
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveBesideCli(options, exists) {
+    const platformPath = options.platform === "win32" ? path.win32 : path.posix;
+    const extensions = binExtensions(options.platform);
+    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", `${options.binName}${extension}`);
+                if (await exists(candidate))
+                    return candidate;
+            }
+            const parent = platformPath.dirname(directory);
+            if (parent === directory)
+                break;
+            directory = parent;
+        }
+    }
+    return null;
+}
+function defaultRealpath(value) {
+    try {
+        return fs.realpathSync.native(value);
+    }
+    catch {
+        return value;
+    }
+}
+async function resolveOnPath(options, exists) {
+    const platformPath = options.platform === "win32" ? path.win32 : path.posix;
+    const entries = (options.env["PATH"] ?? options.env["Path"] ?? "")
+        .split(platformPath.delimiter)
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    for (const entry of entries) {
+        for (const extension of binExtensions(options.platform)) {
+            const candidate = platformPath.join(entry, `${options.binName}${extension}`);
+            if (await exists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+/** npm writes `.cmd` (and `.ps1`) shims on Windows; POSIX gets the bare name. */
+function binExtensions(platform) {
+    return platform === "win32" ? [".cmd", ".exe", ".bat", ""] : [""];
+}
+async function defaultFileExists(file) {
+    const { stat } = await import("node:fs/promises");
+    try {
+        return (await stat(file)).isFile();
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -77,7 +77,13 @@ export async function inspectClaudeMemoryIntegration(options) {
         }),
     ];
 }
-async function applyJsonTarget(input) {
+/**
+ * Exported for `tower-mcp-claude.ts` (BLI-3706): the read/refuse-if-unparseable
+ * /apply/dry-run/write/read-back-verify sequence is identical for a SECOND
+ * server's `mcpServers` entry — only which target id and which `apply`/
+ * `matches` pair runs differs, both already parameters here.
+ */
+export async function applyJsonTarget(input) {
     const { file, options } = input;
     const raw = await input.options.io.readText(file);
     let root;
@@ -120,7 +126,8 @@ async function applyJsonTarget(input) {
     }
     return { target: input.target, status: "installed", reason: "wrote_entry", path: file };
 }
-async function inspectJsonTarget(input) {
+/** Exported for `tower-mcp-claude.ts` (BLI-3706) — see `applyJsonTarget`'s note. */
+export async function inspectJsonTarget(input) {
     const raw = await input.io.readText(input.file);
     if (raw === null || !raw.trim()) {
         return { target: input.target, status: "missing", reason: "file_absent", path: input.file };
@@ -140,7 +147,8 @@ async function inspectJsonTarget(input) {
         path: input.file,
     };
 }
-function applyMcpServer(root, config) {
+/** Exported for `tower-mcp-claude.ts` (BLI-3706) — the `mcpServers` shape has nothing memory-specific about it. */
+export function applyMcpServer(root, config) {
     const servers = asRecord(root["mcpServers"]) ?? {};
     servers[config.server_id] = {
         command: config.mcp_server.command,
@@ -152,13 +160,13 @@ function applyMcpServer(root, config) {
     root["mcpServers"] = servers;
     return root;
 }
-function readMcpServer(root, serverId) {
+export function readMcpServer(root, serverId) {
     const servers = asRecord(root["mcpServers"]);
     if (!servers)
         return null;
     return asRecord(servers[serverId]);
 }
-function mcpServerMatches(root, config) {
+export function mcpServerMatches(root, config) {
     const entry = readMcpServer(root, config.server_id);
     if (!entry)
         return false;

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

@@ -0,0 +1,140 @@
+import { builtinMemoryInstallConfig, isUnsafeBinPath, MEMORY_MCP_BIN, parsePrintedMemoryInstallConfig, withResolvedBinPath, } from "./memory-install-contract.js";
+import { resolveMcpBin } from "./mcp-bin-resolve.js";
+import { resolveDashboardUrl } from "./memory-install-report.js";
+import { envWithNodeRuntimeOnPath } from "../scheduled-self-update.js";
+/**
+ * `bli-memory-mcp` ships as a DEPENDENCY of `@bli-cockpit/cli` — see
+ * `mcp-bin-resolve.ts` (BLI-3706's generalisation of this BLI-3580 lookup,
+ * shared with `bli-tower`'s registration) for the full two-step walk and the
+ * BLI-3580 story of why it starts at that module's own file rather than
+ * `process.argv[1]`.
+ */
+export async function resolveMemoryMcpBin(options) {
+    return resolveMcpBin({ ...options, binName: MEMORY_MCP_BIN });
+}
+/**
+ * **`no_bin_no_write`.** When `bli-memory-mcp` cannot be resolved, this command
+ * writes NOTHING — not the MCP entry, not the hooks, not the Codex table, not
+ * the skills.
+ *
+ * An earlier revision wrote the registration anyway, on the reasoning that a
+ * correct shape waiting for the package is better than nothing. It is not:
+ * Claude Code RUNS a registered hook. Three hooks pointing at a binary that
+ * does not exist would print a hook failure on every SessionStart, every
+ * prompt and every Stop, on every intern machine, until the package shipped —
+ * a self-inflicted outage in the one surface people look at all day.
+ *
+ * So an absent bin is `skipped bin_missing`: a receipt, not a write. The daily
+ * self-heal retries tomorrow, and the first tick after the package lands does
+ * the whole registration at once.
+ */
+export async function resolveMemoryConfig(command, io, platform, deps) {
+    const dashboardUrl = await resolveDashboardUrl(command, deps);
+    const found = await resolveMemoryMcpBin({
+        env: envWithNodeRuntimeOnPath(io.env ?? process.env),
+        platform,
+        fileExists: deps.fileExists,
+        cliEntryPoint: deps.cliEntryPoint,
+        realpath: deps.realpath,
+    });
+    if (!found) {
+        return {
+            config: null,
+            source: "none",
+            binTarget: {
+                target: "bin",
+                status: "skipped",
+                reason: "bin_missing",
+                detail: `${MEMORY_MCP_BIN} is not installed beside this CLI or on PATH; nothing was written, and the next daily run will try again`,
+            },
+        };
+    }
+    if (isUnsafeBinPath(found.path)) {
+        // A hook command is a shell string by the platform's design. A path that
+        // cannot be quoted safely is not escaped cleverly, and it is not swapped
+        // for a bare name that may resolve to something else either — the install
+        // refuses and says why.
+        return {
+            config: null,
+            source: "none",
+            binTarget: {
+                target: "bin",
+                status: "failed",
+                reason: "bin_path_unsafe",
+                detail: "the resolved bin path contains characters that cannot appear in a hook command; nothing was written",
+            },
+            bin_source: found.source,
+        };
+    }
+    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: 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,
+        };
+    }
+    return {
+        config: builtinMemoryInstallConfig({
+            binPath: found.path,
+            platform,
+            dashboardUrl,
+        }),
+        source: "template",
+        binTarget: {
+            target: "bin",
+            status: "already",
+            reason: "bin_present_template_used",
+            detail: "the bin did not print a usable --print-config; the built-in shape was used",
+        },
+        bin_source: found.source,
+    };
+}
+/**
+ * Asks the server for its own shape. Arguments go as an ARRAY — nothing is
+ * interpolated into a command line — and on Windows the captured runner routes
+ * a `.cmd` shim through ComSpec with its own escaping (process-runner.ts).
+ */
+async function printedMemoryConfig(io, binPath) {
+    const exec = io.exec;
+    if (!exec)
+        return null;
+    try {
+        const result = await exec(binPath, ["--print-config", "--claude"]);
+        if (result.code !== 0)
+            return null;
+        return parsePrintedMemoryInstallConfig(result.stdout);
+    }
+    catch {
+        // Deliberately silent here: the caller reports
+        // `bin_present_template_used`, which is the same information with a name
+        // on it, and this path is reached on every machine that has an older bin.
+        return null;
+    }
+}

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

@@ -0,0 +1,89 @@
+import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, } from "../local-state.js";
+export async function resolveDashboardUrl(command, deps) {
+    if (command.dashboardUrl)
+        return command.dashboardUrl;
+    const paths = getCollectorRuntimePaths(deps.homeDir ?? command.homeDir);
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    return config?.dashboard_url ?? DEFAULT_DASHBOARD_URL;
+}
+export function aggregate(targets) {
+    const failed = targets.filter((target) => target.status === "failed");
+    if (failed.length > 0) {
+        return {
+            status: "failed",
+            // The first named reason, not a count: an operator needs the reason, and
+            // the per-target list beside it carries the rest.
+            reason: failed[0]?.reason ?? "unknown_failure",
+        };
+    }
+    if (targets.some((target) => target.status === "would_install")) {
+        return { status: "would_install", reason: "dry_run" };
+    }
+    if (targets.some((target) => target.status === "installed")) {
+        return { status: "installed", reason: "wrote_entry" };
+    }
+    if (targets.some((target) => target.status === "mismatch" || target.status === "missing")) {
+        return { status: "missing", reason: "entry_absent" };
+    }
+    // BLI-3706: checked BEFORE `skipped`, not after. `bli-tower` registering
+    // beside `bli-memory` on this same command means a machine can be fully
+    // "already" registered for one server while the other's bin is not here
+    // yet — that machine's OWN state must not read as "skipped" (nothing is
+    // happening) when something plainly already is. `skipped` only wins the
+    // whole outcome when NOTHING on this machine has ever reached "already"
+    // either — the original one-server case (a fresh machine, bin missing,
+    // nothing written at all) still returns "skipped" via the fallback below.
+    if (targets.some((target) => target.status === "already")) {
+        return { status: "already", reason: "already_current" };
+    }
+    const skipped = targets.find((target) => target.status === "skipped");
+    if (skipped) {
+        // Not a failure and not a success: nothing was written, on purpose, and
+        // the next daily run will try again. `bin_missing` is the only one today.
+        return { status: "skipped", reason: skipped.reason };
+    }
+    return { status: "already", reason: "already_current" };
+}
+/**
+ * Both branches log, and neither carries a path — a home directory names a
+ * person, and this line ends up in `sync.err.log` on every machine.
+ */
+export function logMemoryOutcome(outcome, platform) {
+    const fields = {
+        status: outcome.status,
+        reason: outcome.reason,
+        config_source: outcome.config_source,
+        bin_found: outcome.bin_found,
+        platform,
+        installed_count: outcome.targets.filter((target) => target.status === "installed").length,
+        already_count: outcome.targets.filter((target) => target.status === "already").length,
+        failed: outcome.targets
+            .filter((target) => target.status === "failed")
+            .map((target) => `${target.target}:${target.reason}`),
+    };
+    // stderr on both branches: launchd captures it to sync.err.log, and stdout is
+    // reserved for `--json`.
+    console.error(outcome.status === "failed"
+        ? "[memory-install] BLI Memory is not fully registered on this machine"
+        : "[memory-install] BLI Memory registration converged", JSON.stringify(fields));
+}
+export function memoryOutcomeLines(outcome) {
+    const headline = outcome.status === "installed"
+        ? "BLI Memory registered on this machine."
+        : outcome.status === "already"
+            ? "BLI Memory is already registered on this machine."
+            : outcome.status === "would_install"
+                ? "BLI Memory would be registered (dry run; nothing was written)."
+                : outcome.status === "missing"
+                    ? "BLI Memory is not registered on this machine."
+                    : outcome.status === "skipped"
+                        ? "BLI Memory was not registered and nothing was written: the bli-memory-mcp server is not on this machine yet."
+                        : `BLI Memory is not fully registered: ${outcome.reason}.`;
+    const lines = [headline];
+    for (const target of outcome.targets) {
+        const where = target.path ? ` ${target.path}` : "";
+        const detail = target.detail ? ` — ${target.detail}` : "";
+        lines.push(`  ${target.target}: ${target.status} (${target.reason})${where}${detail}`);
+    }
+    return lines;
+}