balladeer 1.0.7 → 1.0.11

package/dist/release.d.ts

@@ -8,6 +8,12 @@
 export declare const CHECKOUT_COMMAND = "node packages/cli/dist/cli.js";
 /** The specifier every published surface names, which is a tag and never a pin. */
 export declare const PUBLISHED_SPECIFIER = "balladeer@latest";
+/**
+ * What a hook or MCP entry runs when no durable command is installed: the
+ * current major, so a 2.x is a choice a person makes and never a surprise at
+ * session start. The typed first command stays `@latest`.
+ */
+export declare const HOOK_SPECIFIER = "balladeer@1";
 /**
  * How to invoke this command, with no subcommand attached.
  *

package/dist/release.js

@@ -10,6 +10,12 @@ import { fileURLToPath } from "node:url";
 export const CHECKOUT_COMMAND = "node packages/cli/dist/cli.js";
 /** The specifier every published surface names, which is a tag and never a pin. */
 export const PUBLISHED_SPECIFIER = "balladeer@latest";
+/**
+ * What a hook or MCP entry runs when no durable command is installed: the
+ * current major, so a 2.x is a choice a person makes and never a surprise at
+ * session start. The typed first command stays `@latest`.
+ */
+export const HOOK_SPECIFIER = "balladeer@1";
 /**
  * How to invoke this command, with no subcommand attached.
  *

package/dist/remove-earlier.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Taking the earlier Balladeer off a laptop, so one server answers to the name.
+ *
+ * The July client registered a hosted MCP connector under the same name this
+ * product uses, `balladeer`, at the host's user scope; it installed a capture
+ * hook and a status line, wrote a fenced guidance block into the person's own
+ * CLAUDE.md and Codex AGENTS.md, dropped a managed BALLADEER.md beside them, and
+ * put a 0.x `balladeer` binary on PATH through Volta. Left in place, `/mcp`
+ * shows the old server with its 22 tools and this product's user-scope install
+ * refuses to write over a `balladeer` entry that is not its own, so the person
+ * sees the old Balladeer and never the new one.
+ *
+ * Every removal here proves ownership from the entry itself, the way the older
+ * client's own uninstall did: an HTTP connector under the reserved key, a hook
+ * that runs its capture script, a status line that names balladeer, the fence
+ * markers it wrote, the managed-by header. Anything else in those files is not
+ * touched. Each file is copied beside itself before it is changed, and the
+ * copy's path is reported, so the whole thing reverses by hand in a minute.
+ * The old binary is removed only through Volta, which is how it was installed,
+ * and only when the shim reports a version before 1.0.0.
+ */
+export type EarlierItem = Readonly<{
+    /** The file, in the form a person can go and open. */
+    path: string;
+    /** What was found there, bounded. */
+    found: string;
+    /** Takes it off. Returns the backup path when a file was changed. */
+    remove: () => string | undefined;
+}>;
+/** The git top level of a folder, or nothing when it is not inside a repository. */
+export declare function repositoryRootOf(cwd: string): string | undefined;
+/**
+ * The sentence the terminal and the day-one documents share about the earlier
+ * client, so a person who read ahead and a person who hits it are told one thing.
+ */
+export declare const EARLIER_INSTRUCTION = "If you used the earlier Balladeer on this machine, setup finds it, copies each file it changes beside itself, and removes the old server, hooks and guidance blocks (under your home and in this repository's own CLAUDE.md or AGENTS.md, where you commit the change) before pairing; `balladeer remove-earlier` does the same on its own.";
+/**
+ * What the older client left in the repository the person is standing in: a
+ * fence in its CLAUDE.md or AGENTS.md, a managed BALLADEER.md, or its Cursor
+ * rule. Committed once, these reach every clone and every teammate, which is
+ * why the home directory alone is not enough.
+ */
+export declare function findEarlierInRepository(root: string, now?: () => Date): EarlierItem[];
+export declare function findEarlier(options: {
+    home: string;
+    controlPlane: string;
+    environment: NodeJS.ProcessEnv;
+    /** The folder the command runs in; its repository is searched too. */
+    cwd?: string;
+    now?: () => Date;
+}): EarlierItem[];
+export type RemovalReport = Readonly<{
+    removed: readonly {
+        path: string;
+        found: string;
+        backup?: string;
+    }[];
+    failed: readonly {
+        path: string;
+        found: string;
+        reason: string;
+    }[];
+}>;
+/** Takes everything found off, one item at a time, and says what happened to each. */
+export declare function removeEarlier(items: readonly EarlierItem[]): RemovalReport;
+/** What a person reads, before and after. */
+export declare function describeEarlier(items: readonly EarlierItem[]): string[];
+export declare function describeRemoval(report: RemovalReport): string[];

package/dist/remove-earlier.js

@@ -0,0 +1,378 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse } from "@iarna/toml";
+import { isOurEntry, writeJsonAtomically } from "./mcp-config.js";
+import { isOurUserEntry } from "./user-scope.js";
+const BEGIN = "<!-- balladeer:begin -->";
+const END = "<!-- balladeer:end -->";
+const MANAGED_HEADER = /^<!-- managed by Balladeer \(conventions v\d+\)/;
+function readJson(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function backup(path, now) {
+    const stamp = now().toISOString().replaceAll(/[:.]/g, "-");
+    const copy = `${path}.before-balladeer-${stamp}`;
+    copyFileSync(path, copy);
+    return copy;
+}
+/** Whether git holds this file's previous version, so no copy is needed and
+ * none is left in a working tree the person will commit from. */
+function gitTracked(path) {
+    try {
+        execFileSync("git", ["-C", dirname(path), "ls-files", "--error-unmatch", "--", path], {
+            stdio: ["ignore", "ignore", "ignore"],
+            timeout: 2000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The git top level of a folder, or nothing when it is not inside a repository. */
+export function repositoryRootOf(cwd) {
+    try {
+        return execFileSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 2000,
+        }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The older client's entry: whatever sits under the reserved key that is not
+ * one of this product's shapes. Nothing else has reason to claim the name. */
+function isEarlierConnector(entry, controlPlane) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+        return false;
+    return !isOurEntry(entry, controlPlane) && !isOurUserEntry(entry);
+}
+/** The command line an entry runs, or its URL, in the shape a person recognises. */
+function describeEntry(entry) {
+    const record = entry;
+    if (typeof record.url === "string")
+        return record.url;
+    const args = Array.isArray(record.args) ? record.args.map(String) : [];
+    return [String(record.command ?? ""), ...args].join(" ").trim().slice(0, 120);
+}
+/**
+ * The sentence the terminal and the day-one documents share about the earlier
+ * client, so a person who read ahead and a person who hits it are told one thing.
+ */
+export const EARLIER_INSTRUCTION = "If you used the earlier Balladeer on this machine, setup finds it, copies each file it changes beside itself, and removes the old server, hooks and guidance blocks (under your home and in this repository's own CLAUDE.md or AGENTS.md, where you commit the change) before pairing; `balladeer remove-earlier` does the same on its own.";
+function claudeConnector(home, controlPlane, now) {
+    const path = join(home, ".claude.json");
+    const root = readJson(path);
+    const servers = root?.mcpServers;
+    if (!servers || typeof servers !== "object" || Array.isArray(servers))
+        return [];
+    const entry = servers.balladeer;
+    if (!isEarlierConnector(entry, controlPlane))
+        return [];
+    return [
+        {
+            path,
+            found: `the earlier MCP server named balladeer (${describeEntry(entry)})`,
+            remove: () => {
+                const copy = backup(path, now);
+                const current = readJson(path) ?? {};
+                const { balladeer: _gone, ...rest } = (current.mcpServers ?? {});
+                writeJsonAtomically(path, JSON.stringify({ ...current, mcpServers: rest }, null, 2) + "\n");
+                return copy;
+            },
+        },
+    ];
+}
+const isEarlierHook = (command) => typeof command === "string" &&
+    /balladeer/i.test(command) &&
+    !/balladeer@(?:latest|\d+\.\d+\.\d+)\b/.test(command) &&
+    !/\bpackages[/\\]cli[/\\]dist[/\\]cli\.js\b/.test(command);
+function claudeSettings(home, now) {
+    const path = join(home, ".claude", "settings.json");
+    const root = readJson(path);
+    if (root === undefined)
+        return [];
+    const items = [];
+    const statusLine = root.statusLine;
+    if (statusLine && typeof statusLine.command === "string" && /balladeer/i.test(statusLine.command))
+        items.push({
+            path,
+            found: `the earlier status line (${statusLine.command})`,
+            remove: () => {
+                const copy = backup(path, now);
+                const { statusLine: _gone, ...rest } = readJson(path) ?? {};
+                writeJsonAtomically(path, JSON.stringify(rest, null, 2) + "\n");
+                return copy;
+            },
+        });
+    const hooks = root.hooks;
+    const earlier = [];
+    if (hooks && typeof hooks === "object")
+        for (const groups of Object.values(hooks))
+            if (Array.isArray(groups))
+                for (const group of groups)
+                    for (const hook of (group?.hooks ?? []))
+                        if (isEarlierHook(hook?.command))
+                            earlier.push(String(hook.command));
+    if (earlier.length > 0)
+        items.push({
+            path,
+            found: `${earlier.length} earlier hook${earlier.length === 1 ? "" : "s"} (${earlier[0]}${earlier.length > 1 ? ", ..." : ""})`,
+            remove: () => {
+                const copy = backup(path, now);
+                const current = readJson(path) ?? {};
+                const kept = {};
+                for (const [event, groups] of Object.entries((current.hooks ?? {}))) {
+                    if (!Array.isArray(groups)) {
+                        kept[event] = groups;
+                        continue;
+                    }
+                    const remaining = groups
+                        .map((group) => {
+                        const record = group;
+                        if (!Array.isArray(record?.hooks))
+                            return group;
+                        const hooksLeft = record.hooks.filter((h) => !isEarlierHook(h?.command));
+                        return hooksLeft.length === record.hooks.length
+                            ? group
+                            : hooksLeft.length === 0
+                                ? undefined
+                                : { ...record, hooks: hooksLeft };
+                    })
+                        .filter((group) => group !== undefined);
+                    if (remaining.length > 0)
+                        kept[event] = remaining;
+                }
+                writeJsonAtomically(path, JSON.stringify({ ...current, hooks: kept }, null, 2) + "\n");
+                return copy;
+            },
+        });
+    return items;
+}
+/**
+ * The fenced block the older client wrote into an instructions file: the
+ * person's own under their home, or the repository's own CLAUDE.md or
+ * AGENTS.md, which a team commits and every clone then serves. A tracked file
+ * gets no copy beside it; git holds the previous version, and the line the
+ * person reads says to commit the change.
+ */
+function fencedBlock(path, now) {
+    if (!existsSync(path))
+        return [];
+    const text = readFileSync(path, "utf8");
+    const begin = text.indexOf(BEGIN);
+    const end = text.indexOf(END, begin + BEGIN.length);
+    if (begin < 0 || end < 0)
+        return [];
+    const tracked = gitTracked(path);
+    return [
+        {
+            path,
+            found: "the earlier guidance block between its balladeer:begin and balladeer:end markers" +
+                (tracked ? " (git tracks this file: commit the change)" : ""),
+            remove: () => {
+                const copy = tracked ? undefined : backup(path, now);
+                const current = readFileSync(path, "utf8");
+                const b = current.indexOf(BEGIN);
+                const e = current.indexOf(END, b + BEGIN.length);
+                if (b < 0 || e < 0)
+                    return copy;
+                const before = current.slice(0, b).replace(/\n+$/, "\n");
+                const after = current.slice(e + END.length).replace(/^\n+/, "\n");
+                // What is left keeps one blank line where the block stood, and one
+                // newline at the end of the file, never a run of them.
+                const next = (before + after).replace(/^\n+/, "").replace(/\n{2,}$/, "\n");
+                writeJsonAtomically(path, next.trim().length === 0 ? "" : next);
+                return copy;
+            },
+        },
+    ];
+}
+/** The managed conventions file, recognised by its own first line. */
+function managedFile(path, now) {
+    if (!existsSync(path))
+        return [];
+    const first = readFileSync(path, "utf8").split("\n")[0] ?? "";
+    if (!MANAGED_HEADER.test(first))
+        return [];
+    const tracked = gitTracked(path);
+    return [
+        {
+            path,
+            found: "the earlier client's managed conventions file" +
+                (tracked ? " (git tracks this file: commit the change)" : ""),
+            remove: () => {
+                const copy = tracked ? undefined : backup(path, now);
+                unlinkSync(path);
+                return copy;
+            },
+        },
+    ];
+}
+/**
+ * What the older client left in the repository the person is standing in: a
+ * fence in its CLAUDE.md or AGENTS.md, a managed BALLADEER.md, or its Cursor
+ * rule. Committed once, these reach every clone and every teammate, which is
+ * why the home directory alone is not enough.
+ */
+export function findEarlierInRepository(root, now = () => new Date()) {
+    return [
+        ...fencedBlock(join(root, "CLAUDE.md"), now),
+        ...fencedBlock(join(root, "AGENTS.md"), now),
+        ...fencedBlock(join(root, ".claude", "CLAUDE.md"), now),
+        ...managedFile(join(root, "BALLADEER.md"), now),
+        ...managedFile(join(root, ".claude", "BALLADEER.md"), now),
+        ...managedFile(join(root, ".cursor", "rules", "balladeer.mdc"), now),
+    ];
+}
+function codexConfig(home, now) {
+    const path = join(home, ".codex", "config.toml");
+    if (!existsSync(path))
+        return [];
+    const text = readFileSync(path, "utf8");
+    let parsed;
+    try {
+        parsed = parse(text);
+    }
+    catch {
+        return [];
+    }
+    const servers = parsed.mcp_servers;
+    const entry = servers?.balladeer;
+    if (!entry || typeof entry.url !== "string")
+        return [];
+    // The table is removed as text, from its header to the next table header,
+    // so every other line in the file keeps its bytes. Our own block is fenced
+    // and never has a url, so it cannot match here.
+    const table = /^\[mcp_servers\.balladeer\]\r?\n(?:(?!\[)[^\n]*\r?\n?)*/m;
+    if (!table.test(text))
+        return [];
+    return [
+        {
+            path,
+            found: `the earlier MCP server named balladeer, at ${entry.url}`,
+            remove: () => {
+                const copy = backup(path, now);
+                const next = readFileSync(path, "utf8").replace(table, "");
+                parse(next);
+                writeJsonAtomically(path, next);
+                return copy;
+            },
+        },
+    ];
+}
+function cursorConnector(home, controlPlane, now) {
+    const path = join(home, ".cursor", "mcp.json");
+    const root = readJson(path);
+    const servers = root?.mcpServers;
+    const entry = servers?.balladeer;
+    if (!isEarlierConnector(entry, controlPlane))
+        return [];
+    return [
+        {
+            path,
+            found: `the earlier MCP server named balladeer (${describeEntry(entry)})`,
+            remove: () => {
+                const copy = backup(path, now);
+                const current = readJson(path) ?? {};
+                const { balladeer: _gone, ...rest } = (current.mcpServers ?? {});
+                writeJsonAtomically(path, JSON.stringify({ ...current, mcpServers: rest }, null, 2) + "\n");
+                return copy;
+            },
+        },
+    ];
+}
+/** The 0.x binary Volta installed for the older client. This product's own
+ * durable command is 1.x and lives under Volta too, so the version decides. */
+function voltaBinary(home, environment) {
+    const shim = join(home, ".volta", "bin", "balladeer");
+    if (!existsSync(shim))
+        return [];
+    let version;
+    try {
+        version = execFileSync(shim, ["--version"], {
+            encoding: "utf8",
+            env: environment,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 15_000,
+        }).trim();
+    }
+    catch {
+        return [];
+    }
+    if (!/^0\.\d+\.\d+/.test(version))
+        return [];
+    return [
+        {
+            path: shim,
+            found: `the earlier balladeer command, version ${version}`,
+            remove: () => {
+                execFileSync(join(home, ".volta", "bin", "volta"), ["uninstall", "balladeer"], {
+                    env: environment,
+                    stdio: ["ignore", "ignore", "ignore"],
+                    timeout: 60_000,
+                });
+                return undefined;
+            },
+        },
+    ];
+}
+export function findEarlier(options) {
+    const now = options.now ?? (() => new Date());
+    const { home, controlPlane } = options;
+    const codexHome = options.environment.CODEX_HOME?.trim() || join(home, ".codex");
+    const root = options.cwd === undefined ? undefined : repositoryRootOf(options.cwd);
+    return [
+        ...(root === undefined ? [] : findEarlierInRepository(root, now)),
+        ...claudeConnector(home, controlPlane, now),
+        ...claudeSettings(home, now),
+        ...fencedBlock(join(home, ".claude", "CLAUDE.md"), now),
+        ...managedFile(join(home, ".claude", "BALLADEER.md"), now),
+        ...codexConfig(home, now),
+        ...fencedBlock(join(codexHome, "AGENTS.md"), now),
+        ...fencedBlock(join(codexHome, "AGENTS.override.md"), now),
+        ...managedFile(join(codexHome, "BALLADEER.md"), now),
+        ...cursorConnector(home, controlPlane, now),
+        ...voltaBinary(home, options.environment),
+    ];
+}
+/** Takes everything found off, one item at a time, and says what happened to each. */
+export function removeEarlier(items) {
+    const removed = [];
+    const failed = [];
+    for (const item of items) {
+        try {
+            const copy = item.remove();
+            removed.push({ path: item.path, found: item.found, ...(copy ? { backup: copy } : {}) });
+        }
+        catch (error) {
+            failed.push({
+                path: item.path,
+                found: item.found,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return { removed, failed };
+}
+/** What a person reads, before and after. */
+export function describeEarlier(items) {
+    return items.map((item) => `  ${item.path}: ${item.found}`);
+}
+export function describeRemoval(report) {
+    const lines = report.removed.map((item) => `  Removed ${item.found} from ${item.path}${item.backup ? ` (copy kept at ${item.backup})` : ""}.`);
+    for (const item of report.failed)
+        lines.push(`  Could not remove ${item.found} from ${item.path}: ${item.reason}`);
+    return lines;
+}

package/dist/repository.d.ts

@@ -5,4 +5,13 @@
  * written to read like Balladeer's own assertion.
  */
 export declare function repositoryHint(cwd?: string): string;
+/**
+ * Every GitHub repository this folder's remotes point at, `origin` first and
+ * the rest in git's order, without repeats. A person working from a personal
+ * fork has `origin` on the fork and `upstream` on the repository the team
+ * connected; the session in that folder is about the team's repository, so
+ * matching stops at the first remote that has a connection rather than at
+ * `origin`. An empty list is a folder with no GitHub remote at all.
+ */
+export declare function repositoryHints(cwd?: string): readonly string[];
 export declare function hostHint(): string;

package/dist/repository.js

@@ -9,21 +9,47 @@ const HOST_HINT_PATTERN = /^[A-Za-z0-9.-]{1,63}$/;
  * written to read like Balladeer's own assertion.
  */
 export function repositoryHint(cwd = process.cwd()) {
-    let remote;
+    return repositoryHints(cwd)[0] ?? "unknown/unknown";
+}
+function git(cwd, args) {
     try {
-        remote = execFileSync("git", ["-C", cwd, "remote", "get-url", "origin"], {
+        return execFileSync("git", ["-C", cwd, ...args], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
     }
     catch {
-        return "unknown/unknown";
+        return undefined;
     }
+}
+function ownerName(remote) {
     const match = /github\.com[:/]+([A-Za-z0-9._-]{1,39})\/([A-Za-z0-9._-]{1,100}?)(?:\.git)?$/.exec(remote);
     if (!match)
-        return "unknown/unknown";
+        return undefined;
     const hint = `${match[1]}/${match[2]}`;
-    return REPOSITORY_HINT_PATTERN.test(hint) ? hint : "unknown/unknown";
+    return REPOSITORY_HINT_PATTERN.test(hint) ? hint : undefined;
+}
+/**
+ * Every GitHub repository this folder's remotes point at, `origin` first and
+ * the rest in git's order, without repeats. A person working from a personal
+ * fork has `origin` on the fork and `upstream` on the repository the team
+ * connected; the session in that folder is about the team's repository, so
+ * matching stops at the first remote that has a connection rather than at
+ * `origin`. An empty list is a folder with no GitHub remote at all.
+ */
+export function repositoryHints(cwd = process.cwd()) {
+    const names = git(cwd, ["remote"])
+        ?.split("\n")
+        .filter((name) => name.length > 0) ?? [];
+    const ordered = ["origin", ...names.filter((name) => name !== "origin")];
+    const hints = [];
+    for (const name of ordered) {
+        const url = git(cwd, ["remote", "get-url", name]);
+        const hint = url === undefined ? undefined : ownerName(url);
+        if (hint !== undefined && !hints.some((h) => h.toLowerCase() === hint.toLowerCase()))
+            hints.push(hint);
+    }
+    return hints;
 }
 export function hostHint() {
     const raw = hostname().split(".")[0] ?? "";

package/dist/self-update.d.ts

@@ -0,0 +1,11 @@
+export type SelfUpdateDeps = Readonly<{
+    environment: NodeJS.ProcessEnv;
+    now?: () => number;
+    run?: (command: string, args: readonly string[]) => void;
+}>;
+/**
+ * Start the update when the server named a newer release and none was
+ * started today. Answers whether one was started, for the caller's own
+ * record; the session hears nothing either way.
+ */
+export declare function startSelfUpdateIfDue(newer: string | undefined, deps: SelfUpdateDeps): boolean;

package/dist/self-update.js

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { HOOK_SPECIFIER } from "./release.js";
+import { configHome } from "./store.js";
+/**
+ * Bringing the durable command current without the session ever waiting.
+ *
+ * Robert, 22 September 2026: a session start has to be imperceptible, and an
+ * update must never hold the agent. So the hook, having served this session
+ * from the copy it has, only starts the install: a detached child on the
+ * current major, output discarded, at most once a day per laptop whatever it
+ * reports. The next session runs whatever that child installed. A child that
+ * fails changes nothing and is tried again the next day; `balladeer update`
+ * is the manual path. Nothing here reads the session or writes to it.
+ */
+const STAMP = "self-update.json";
+const DAY_MS = 24 * 60 * 60 * 1000;
+function stampPath(environment) {
+    return join(configHome(environment), STAMP);
+}
+function lastStarted(environment) {
+    const path = stampPath(environment);
+    if (!existsSync(path))
+        return 0;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return typeof parsed.startedAt === "number" ? parsed.startedAt : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function detached(command, args) {
+    const child = spawn(command, [...args], { detached: true, stdio: "ignore" });
+    child.on("error", () => undefined);
+    child.unref();
+}
+/**
+ * Start the update when the server named a newer release and none was
+ * started today. Answers whether one was started, for the caller's own
+ * record; the session hears nothing either way.
+ */
+export function startSelfUpdateIfDue(newer, deps) {
+    if (newer === undefined)
+        return false;
+    const now = deps.now ?? Date.now;
+    if (now() - lastStarted(deps.environment) < DAY_MS)
+        return false;
+    try {
+        mkdirSync(configHome(deps.environment), { recursive: true, mode: 0o700 });
+        writeFileSync(stampPath(deps.environment), JSON.stringify({ startedAt: now(), toward: newer }) + "\n", { mode: 0o600 });
+        (deps.run ?? detached)("npx", ["-y", HOOK_SPECIFIER, "install", "--json"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}