@bli-cockpit/cli 0.2.117 → 0.2.121

package/dist/commands/mcp-stdio-probe.js

@@ -65,6 +65,15 @@ export async function probeMcpTool(request) {
     catch (error) {
         return { status: "no_answer", ms: elapsed(), reason: "spawn_failed", said: firstLine(errorText(error)) };
     }
+    const replies = listenForMcpReplies(child, timeoutMs);
+    try {
+        return await callMcpTool(request, replies, elapsed);
+    }
+    finally {
+        closeMcpProbe(child);
+    }
+}
+function listenForMcpReplies(child, timeoutMs) {
     const pending = new Map();
     /**
      * A reply that arrived before anyone asked for it. Nothing in the protocol
@@ -84,6 +93,17 @@ export async function probeMcpTool(request) {
     };
     child.on("error", ((error) => end("spawn_failed", firstLine(errorText(error)))));
     child.on("exit", ((code) => end("server_exited", `the server exited with code ${code ?? "null"} before answering`)));
+    readMcpStdout(child, pending, early, end);
+    const send = (message) => {
+        child.stdin?.write(`${JSON.stringify(message)}\n`);
+    };
+    return {
+        send,
+        awaitReply: (id) => awaitMcpReply(id, pending, early, () => ended, endWaiters, end, timeoutMs),
+        endedDetail: () => endedDetail(ended),
+    };
+}
+function readMcpStdout(child, pending, early, end) {
     let buffer = "";
     child.stdout?.on("data", (chunk) => {
         buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
@@ -104,33 +124,32 @@ export async function probeMcpTool(request) {
                 end("protocol_error", "the server wrote something to stdout that is not JSON-RPC");
                 return;
             }
-            const message = parsed;
-            const id = typeof message["id"] === "number" ? message["id"] : null;
-            if (id === null)
-                continue;
-            const waiter = pending.get(id);
-            if (!waiter) {
-                early.set(id, message);
-                continue;
-            }
-            pending.delete(id);
-            waiter(message);
+            deliverMcpReply(parsed, pending, early);
         }
     });
-    const send = (message) => {
-        child.stdin?.write(`${JSON.stringify(message)}\n`);
-    };
-    const awaitReply = (id) => new Promise((resolve) => {
+}
+function deliverMcpReply(message, pending, early) {
+    const id = typeof message["id"] === "number" ? message["id"] : null;
+    if (id === null)
+        return;
+    const waiter = pending.get(id);
+    if (!waiter) {
+        early.set(id, message);
+        return;
+    }
+    pending.delete(id);
+    waiter(message);
+}
+function awaitMcpReply(id, pending, early, getEnded, endWaiters, end, timeoutMs) {
+    return new Promise((resolve) => {
         const alreadyHere = early.get(id);
         if (alreadyHere) {
             early.delete(id);
             resolve(alreadyHere);
             return;
         }
-        if (ended) {
-            resolve(null);
-            return;
-        }
+        if (getEnded())
+            return resolve(null);
         const timer = setTimeout(() => {
             pending.delete(id);
             end("timed_out", `the server did not answer within ${timeoutMs} ms`);
@@ -147,62 +166,62 @@ export async function probeMcpTool(request) {
             resolve(message);
         });
     });
+}
+async function callMcpTool(request, replies, elapsed) {
+    replies.send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-06-18",
+            capabilities: {},
+            clientInfo: { name: "cockpit-doctor", version: "1" },
+        },
+    });
+    const initialized = await replies.awaitReply(1);
+    if (!initialized)
+        return { status: "no_answer", ms: elapsed(), ...replies.endedDetail() };
+    if (initialized["error"]) {
+        return {
+            status: "no_answer",
+            ms: elapsed(),
+            reason: "protocol_error",
+            said: firstLine(rpcErrorMessage(initialized)),
+        };
+    }
+    replies.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    replies.send({
+        jsonrpc: "2.0",
+        id: 2,
+        method: "tools/call",
+        params: { name: request.toolName, arguments: request.toolArguments },
+    });
+    const called = await replies.awaitReply(2);
+    if (!called)
+        return { status: "no_answer", ms: elapsed(), ...replies.endedDetail() };
+    if (called["error"]) {
+        return {
+            status: "no_answer",
+            ms: elapsed(),
+            reason: "protocol_error",
+            said: firstLine(rpcErrorMessage(called)),
+        };
+    }
+    const result = (called["result"] ?? {});
+    const said = firstLine((result.content ?? []).find((part) => part.type === "text")?.text ?? "");
+    if (result.isError !== true)
+        return { status: "answered", ms: elapsed(), said };
+    return { status: "refused", ms: elapsed(), reason: refusalReason(said), said };
+}
+function closeMcpProbe(child) {
     try {
-        send({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "initialize",
-            params: {
-                protocolVersion: "2025-06-18",
-                capabilities: {},
-                clientInfo: { name: "cockpit-doctor", version: "1" },
-            },
-        });
-        const initialized = await awaitReply(1);
-        if (!initialized)
-            return { status: "no_answer", ms: elapsed(), ...endedDetail(ended) };
-        if (initialized["error"]) {
-            return {
-                status: "no_answer",
-                ms: elapsed(),
-                reason: "protocol_error",
-                said: firstLine(rpcErrorMessage(initialized)),
-            };
-        }
-        send({ jsonrpc: "2.0", method: "notifications/initialized" });
-        send({
-            jsonrpc: "2.0",
-            id: 2,
-            method: "tools/call",
-            params: { name: request.toolName, arguments: request.toolArguments },
-        });
-        const called = await awaitReply(2);
-        if (!called)
-            return { status: "no_answer", ms: elapsed(), ...endedDetail(ended) };
-        if (called["error"]) {
-            return {
-                status: "no_answer",
-                ms: elapsed(),
-                reason: "protocol_error",
-                said: firstLine(rpcErrorMessage(called)),
-            };
-        }
-        const result = (called["result"] ?? {});
-        const said = firstLine((result.content ?? []).find((part) => part.type === "text")?.text ?? "");
-        if (result.isError !== true)
-            return { status: "answered", ms: elapsed(), said };
-        return { status: "refused", ms: elapsed(), reason: refusalReason(said), said };
+        child.stdin?.end();
+        child.kill();
     }
-    finally {
-        try {
-            child.stdin?.end();
-            child.kill();
-        }
-        catch (error) {
-            // The verdict is already decided; a child that will not close changes
-            // none of it. Not silent: the reason travels in the caller's log.
-            void error;
-        }
+    catch (error) {
+        // The verdict is already decided; a child that will not close changes
+        // none of it. Not silent: the reason travels in the caller's log.
+        void error;
     }
 }
 /**

package/dist/commands/memory-hook-performance.js

@@ -15,130 +15,163 @@ export async function readMemoryHookPerformance(options) {
     const directory = memoryHookSamplesDirectory(options.homeDir);
     const start = now.getTime() - 24 * HOUR_MS;
     const reasons = new Set();
-    const result = {
-        schema_version: "memory-hook-performance.v1",
-        window_start: new Date(start).toISOString(),
-        window_end: now.toISOString(),
-        sampling_since: null,
-        samples: 0,
-        outcomes: { printed: 0, empty: 0, timeouts: 0, failed: 0, skipped: 0 },
-        duration_by_cache: {
-            hit: blankHistogram(), miss: blankHistogram(), shared: blankHistogram(), unknown: blankHistogram(),
-        },
-        producer_versions: [],
-        invalid_samples: 0,
-        incomplete_samples: 0,
-        unreadable_samples: 0,
-        capped: false,
-        reasons: [],
-    };
-    const versions = new Map();
-    const started = performance.now();
-    let filesRead = 0;
+    const state = createSamplingState(now, start);
     try {
         const lease = await renewLease(directory, now, reasons);
-        result.sampling_since = lease.continuous_since;
+        state.result.sampling_since = lease.continuous_since;
         if (Date.parse(lease.continuous_since) > start)
             reasons.add("partial_window");
-        // Exactly the 25 hour directories touching this rolling 24-hour window.
-        // Timestamp filtering below trims both partial boundary hours.
-        hours: for (let offset = 0; offset <= 24; offset += 1) {
-            const hour = new Date(now.getTime() - offset * HOUR_MS).toISOString().slice(0, 13);
-            let entries;
-            try {
-                entries = await fs.opendir(path.join(directory, hour));
-            }
-            catch (error) {
-                if (error.code !== "ENOENT")
-                    reasons.add("read_failed");
+        await collectHourlySamples(directory, now, start, options, reasons, state);
+        await pruneExpiredHours(directory, now, reasons);
+    }
+    catch {
+        reasons.add("read_failed");
+    }
+    return finishSampling(state, reasons);
+}
+function createSamplingState(now, start) {
+    return {
+        result: {
+            schema_version: "memory-hook-performance.v1",
+            window_start: new Date(start).toISOString(),
+            window_end: now.toISOString(),
+            sampling_since: null,
+            samples: 0,
+            outcomes: { printed: 0, empty: 0, timeouts: 0, failed: 0, skipped: 0 },
+            duration_by_cache: {
+                hit: blankHistogram(),
+                miss: blankHistogram(),
+                shared: blankHistogram(),
+                unknown: blankHistogram(),
+            },
+            producer_versions: [],
+            invalid_samples: 0,
+            incomplete_samples: 0,
+            unreadable_samples: 0,
+            capped: false,
+            reasons: [],
+        },
+        versions: new Map(),
+        started: performance.now(),
+        filesRead: 0,
+    };
+}
+async function collectHourlySamples(directory, now, start, options, reasons, state) {
+    // Exactly the 25 hour directories touching this rolling 24-hour window.
+    // Timestamp filtering below trims both partial boundary hours.
+    hours: for (let offset = 0; offset <= 24; offset += 1) {
+        const hour = new Date(now.getTime() - offset * HOUR_MS).toISOString().slice(0, 13);
+        const entries = await openHourDirectory(directory, hour, reasons);
+        if (!entries)
+            continue;
+        for await (const entry of entries) {
+            if (!entry.isFile() || !SAMPLE_FILE.test(entry.name))
                 continue;
+            if (hasReachedReadLimit(options, state)) {
+                state.result.capped = true;
+                reasons.add("read_limit");
+                break hours;
             }
-            for await (const entry of entries) {
-                if (!entry.isFile() || !SAMPLE_FILE.test(entry.name))
-                    continue;
-                if (filesRead >= (options.maxFiles ?? HOOK_SAMPLE_READ_LIMIT) ||
-                    performance.now() - started >= (options.readBudgetMs ?? READ_BUDGET_MS)) {
-                    result.capped = true;
-                    reasons.add("read_limit");
-                    break hours;
-                }
-                filesRead += 1;
-                const file = path.join(directory, hour, entry.name);
-                let raw;
-                try {
-                    const stat = await fs.stat(file);
-                    if (stat.size > MAX_SAMPLE_BYTES) {
-                        result.invalid_samples += 1;
-                        continue;
-                    }
-                    raw = await fs.readFile(file, "utf8");
-                }
-                catch {
-                    result.unreadable_samples += 1;
-                    continue;
-                }
-                if (!raw.endsWith("\n")) {
-                    // Could be a live writer or one killed by the host. Leave it for the
-                    // next tick, and keep the incomplete observation out of every rate.
-                    result.incomplete_samples += 1;
-                    continue;
-                }
-                let parsed;
-                try {
-                    parsed = JSON.parse(raw);
-                }
-                catch {
-                    result.invalid_samples += 1;
-                    continue;
-                }
-                const sample = MemoryHookSampleSchema.safeParse(parsed);
-                if (!sample.success || sample.data.recorded_at.slice(0, 13) !== hour) {
-                    result.invalid_samples += 1;
-                    continue;
-                }
-                const at = Date.parse(sample.data.recorded_at);
-                if (at < start || at > now.getTime())
-                    continue;
-                const version = sample.data.producer_version;
-                if (!versions.has(version) && versions.size >= 16) {
-                    result.capped = true;
-                    reasons.add("read_limit");
-                    break hours;
-                }
-                result.samples += 1;
-                result.outcomes[sample.data.outcome] += 1;
-                addDuration(result.duration_by_cache[sample.data.embed_cache], sample.data.elapsed_ms);
-                versions.set(version, (versions.get(version) ?? 0) + 1);
+            state.filesRead += 1;
+            const shouldContinue = await readSample(path.join(directory, hour, entry.name), hour, now, start, reasons, state);
+            if (!shouldContinue) {
+                break hours;
             }
         }
-        await pruneExpiredHours(directory, now, reasons);
+    }
+}
+async function openHourDirectory(directory, hour, reasons) {
+    try {
+        return await fs.opendir(path.join(directory, hour));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            reasons.add("read_failed");
+        return null;
+    }
+}
+function hasReachedReadLimit(options, state) {
+    return state.filesRead >= (options.maxFiles ?? HOOK_SAMPLE_READ_LIMIT) ||
+        performance.now() - state.started >= (options.readBudgetMs ?? READ_BUDGET_MS);
+}
+async function readSample(file, hour, now, start, reasons, state) {
+    let raw;
+    try {
+        const stat = await fs.stat(file);
+        if (stat.size > MAX_SAMPLE_BYTES) {
+            state.result.invalid_samples += 1;
+            return true;
+        }
+        raw = await fs.readFile(file, "utf8");
     }
     catch {
-        reasons.add("read_failed");
+        state.result.unreadable_samples += 1;
+        return true;
+    }
+    if (!raw.endsWith("\n")) {
+        // Could be a live writer or one killed by the host. Leave it for the
+        // next tick, and keep the incomplete observation out of every rate.
+        state.result.incomplete_samples += 1;
+        return true;
+    }
+    return recordSample(raw, hour, now, start, reasons, state);
+}
+function recordSample(raw, hour, now, start, reasons, state) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
     }
-    if (!result.samples)
+    catch {
+        state.result.invalid_samples += 1;
+        return true;
+    }
+    const sample = MemoryHookSampleSchema.safeParse(parsed);
+    if (!sample.success || sample.data.recorded_at.slice(0, 13) !== hour) {
+        state.result.invalid_samples += 1;
+        return true;
+    }
+    const at = Date.parse(sample.data.recorded_at);
+    if (at < start || at > now.getTime())
+        return true;
+    const version = sample.data.producer_version;
+    if (!state.versions.has(version) && state.versions.size >= 16) {
+        state.result.capped = true;
+        reasons.add("read_limit");
+        return false;
+    }
+    state.result.samples += 1;
+    state.result.outcomes[sample.data.outcome] += 1;
+    addDuration(state.result.duration_by_cache[sample.data.embed_cache], sample.data.elapsed_ms);
+    state.versions.set(version, (state.versions.get(version) ?? 0) + 1);
+    return true;
+}
+function finishSampling(state, reasons) {
+    if (!state.result.samples)
         reasons.add("no_samples");
-    if (result.invalid_samples)
+    if (state.result.invalid_samples)
         reasons.add("invalid_samples");
-    if (result.incomplete_samples)
+    if (state.result.incomplete_samples)
         reasons.add("incomplete_samples");
-    if (result.unreadable_samples)
+    if (state.result.unreadable_samples)
         reasons.add("unreadable_samples");
-    result.producer_versions = [...versions].sort(([a], [b]) => a.localeCompare(b))
+    state.result.producer_versions = [...state.versions].sort(([a], [b]) => a.localeCompare(b))
         .map(([version, samples]) => ({ version, samples }));
-    result.reasons = [...reasons];
-    return result;
+    state.result.reasons = [...reasons];
+    return state.result;
 }
 async function renewLease(directory, now, reasons) {
     let continuousSince = now.toISOString();
     try {
         const previous = MemoryHookSamplingLeaseSchema.safeParse(JSON.parse(await fs.readFile(path.join(directory, "lease.json"), "utf8")));
-        if (!previous.success || Date.parse(previous.data.continuous_since) > now.getTime())
+        if (!previous.success || Date.parse(previous.data.continuous_since) > now.getTime()) {
             reasons.add("lease_invalid");
-        else if (Date.parse(previous.data.expires_at) <= now.getTime())
+        }
+        else if (Date.parse(previous.data.expires_at) <= now.getTime()) {
             reasons.add("lease_expired");
-        else
+        }
+        else {
             continuousSince = previous.data.continuous_since;
+        }
     }
     catch (error) {
         reasons.add(error.code === "ENOENT" ? "lease_absent" : "lease_invalid");
@@ -160,8 +193,9 @@ async function pruneExpiredHours(directory, now, reasons) {
         const entries = await fs.opendir(directory);
         let pruned = 0;
         for await (const entry of entries) {
-            if (!entry.isDirectory() || !HOUR_DIRECTORY.test(entry.name) || entry.name >= oldest)
+            if (!entry.isDirectory() || !HOUR_DIRECTORY.test(entry.name) || entry.name >= oldest) {
                 continue;
+            }
             // Cleanup belongs to the collector and cannot delay a prompt. A bounded
             // number of expired hours is enough to catch up over successive ticks.
             await fs.rm(path.join(directory, entry.name), { recursive: true, force: true });

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

@@ -84,21 +84,11 @@ export async function inspectClaudeMemoryIntegration(options) {
  * `matches` pair runs differs, both already parameters here.
  */
 export async function applyJsonTarget(input) {
+    const prepared = await readJsonTargetRoot(input);
+    if ("target" in prepared)
+        return prepared;
     const { file, options } = input;
-    const raw = await input.options.io.readText(file);
-    let root;
-    if (raw === null || !raw.trim()) {
-        root = {};
-    }
-    else {
-        const parsed = parseJsonRecord(raw);
-        if (!parsed) {
-            // Refuse rather than replace. A `~/.claude.json` that will not parse
-            // still holds the person's project history and their other servers.
-            return failure(input.target, file, "config_unreadable", "the file is not valid JSON; fix it and re-run");
-        }
-        root = parsed;
-    }
+    const { raw, root } = prepared;
     if (input.matches(root)) {
         return { target: input.target, status: "already", reason: "already_current", path: file };
     }
@@ -126,6 +116,17 @@ export async function applyJsonTarget(input) {
     }
     return { target: input.target, status: "installed", reason: "wrote_entry", path: file };
 }
+async function readJsonTargetRoot(input) {
+    const raw = await input.options.io.readText(input.file);
+    if (raw === null || !raw.trim())
+        return { raw, root: {} };
+    const root = parseJsonRecord(raw);
+    if (root)
+        return { raw, root };
+    // Refuse rather than replace. A `~/.claude.json` that will not parse
+    // still holds the person's project history and their other servers.
+    return failure(input.target, input.file, "config_unreadable", "the file is not valid JSON; fix it and re-run");
+}
 /** 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);

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

@@ -123,12 +123,7 @@ async function applyCodexMcpTable(options) {
 async function applyCodexSkills(options) {
     const directory = codexSkillDirectory(options.homeDir);
     const files = memoryCodexSkillFiles();
-    const stale = [];
-    for (const [relative, contents] of Object.entries(files)) {
-        const stored = await options.io.readText(path.join(directory, relative));
-        if (stored !== contents)
-            stale.push(relative);
-    }
+    const stale = await findStaleCodexSkillFiles(directory, files, options.io);
     if (stale.length === 0) {
         return {
             target: "codex_skills",
@@ -181,6 +176,15 @@ async function applyCodexSkills(options) {
         detail: `${stale.length} skill file(s) written`,
     };
 }
+async function findStaleCodexSkillFiles(directory, files, io) {
+    const stale = [];
+    for (const [relative, contents] of Object.entries(files)) {
+        const stored = await io.readText(path.join(directory, relative));
+        if (stored !== contents)
+            stale.push(relative);
+    }
+    return stale;
+}
 export function renderMemoryTable(config) {
     const entries = [
         ["command", config.mcp_server.command],

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

@@ -51,9 +51,10 @@ export async function resolveMemoryConfig(command, io, platform, deps) {
     }
     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.
+        // cannot be expressed safely in one 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. See `shellSafeBinPath` for what CAN be
+        // expressed, including the Windows separator normalisation of BLI-4136.
         return {
             config: null,
             source: "none",
@@ -61,7 +62,7 @@ export async function resolveMemoryConfig(command, io, platform, deps) {
                 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",
+                detail: "the resolved bin path cannot be expressed safely in a hook command; nothing was written",
             },
             bin_source: found.source,
         };