buddy-agent-harness 0.9.0 → 0.10.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "buddy-agent-harness",
-	"version": "0.9.0",
+	"version": "0.10.0",
 	"description": "Initialize standards-based agent configuration across agent harnesses",
 	"author": {
 		"name": "repobuddy"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "buddy-agent-harness",
-	"version": "0.9.0",
+	"version": "0.10.0",
 	"description": "Initialize standards-based agent configuration across agent harnesses",
 	"author": {
 		"name": "repobuddy"

package/.cursor-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "buddy-agent-harness",
-	"version": "0.9.0",
+	"version": "0.10.0",
 	"description": "Initialize standards-based agent configuration across agent harnesses",
 	"author": {
 		"name": "repobuddy"

package/dist/cli.mjs

@@ -18994,14 +18994,7 @@ const initCommand = command({
 });
 //#endregion
 //#region src/cli.ts
-/**
-* Read from the manifest rather than restated here: a version written into this call is a second
-* home for a number that already has one, and it stayed at `0.1.0` for five minor releases.
-*
-* `../package.json` resolves from `src/cli.ts` and from the bundled `dist/cli.mjs` alike — both sit
-* one directory under the package root.
-*/
-const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+const version = typeof __PACKAGE_VERSION__ !== "undefined" ? __PACKAGE_VERSION__ : JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 /**
 * A factory rather than a module-level constant: `cli()` builds state, and state built at import
 * time is shared by every later call in the process.

package/dist/index.d.mts

@@ -598,5 +598,43 @@ type InitializeResult = {
 };
 export declare function initializeHarnesses({ root, harnesses: preferred, copy, force }: InitializeOptions): InitializeResult;
 //#endregion
-export type { BridgeFinding, BridgeKind, BridgeProblem, BridgeReport, BridgeStatus, ConfigurationFault, ConfigurationProblem, DiagnoseMcpOptions, DiagnoseOptions, DiagnoseResult, DivergenceDirection, DivergenceReport, DoctorProblem, DoctorReport, Harness, HarnessName, HarnessScope, HarnessScopeName, InitializeOptions, InitializeResult, InstructionBridge, InstructionKind, InstructionProblem, InstructionReport, InstructionStatus, McpConfig, McpDirection, McpField, McpProblem, McpServer, McpTransport, Repair };
+//#region src/mcp-inventory/mcp-inventory.d.ts
+/** One configured MCP server, redacted of everything that could carry a credential. */
+type McpServerEntry = {
+  harness: HarnessName;
+  scope: HarnessScopeName;
+  /** The absolute path of the config file this entry was read from. */
+  configFile: string;
+  /** The name the server is declared under. */
+  name: string;
+  transport: McpTransport | undefined;
+  /** The command's basename, never its full path. */
+  command: string | undefined;
+  /** `args`, with any credential-bearing `--flag=value` pair dropped. */
+  args: readonly string[];
+  /** The URL's origin and path, never its query string. */
+  url: string | undefined;
+  enabled: boolean;
+};
+type ListMcpServersOptions = {
+  /** The project directory to read project-scope configuration from. */
+  projectDir: string;
+  /** Overrides `os.homedir()`, for a test that must not touch the real one. */
+  homeDir?: string;
+  /** Overrides `process.env`, for a test — read only for `CODEX_HOME` and `COPILOT_HOME`. */
+  env?: Readonly<Record<string, string | undefined>>;
+};
+/**
+ * Every MCP server configured for a project, across every supported harness and every scope that
+ * harness documents — without ever surfacing a credential.
+ *
+ * Reuses `diagnoseMcp`'s own parsing (`parseTarget`), model (`McpServer`), and redaction
+ * (`nonSecretArgs`, and the URL/command trimming this module adds) rather than re-reading or
+ * re-parsing any of the supported harnesses' MCP files. A harness with no file present, or one whose
+ * file does not parse, contributes no entries; this function reports an inventory, not a diagnosis,
+ * so it has nothing to say about why a file is missing or broken.
+ */
+export declare function listMcpServers(options: ListMcpServersOptions): McpServerEntry[];
+//#endregion
+export type { BridgeFinding, BridgeKind, BridgeProblem, BridgeReport, BridgeStatus, ConfigurationFault, ConfigurationProblem, DiagnoseMcpOptions, DiagnoseOptions, DiagnoseResult, DivergenceDirection, DivergenceReport, DoctorProblem, DoctorReport, Harness, HarnessName, HarnessScope, HarnessScopeName, InitializeOptions, InitializeResult, InstructionBridge, InstructionKind, InstructionProblem, InstructionReport, InstructionStatus, ListMcpServersOptions, McpConfig, McpDirection, McpField, McpProblem, McpServer, McpServerEntry, McpTransport, Repair };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/cli.ts","../src/harness-registry/instruction-bridge.ts","../src/harness-registry/mcp-config.ts","../src/harness-registry/nonstandard-artifact.ts","../src/harness-registry/harness-registry.ts","../src/diagnose-bridges/diagnose-instructions.ts","../src/diagnose-bridges/locator.ts","../src/diagnose-bridges/doctor-guidance.ts","../src/diagnose-bridges/git-bridge-state.ts","../src/diagnose-bridges/diagnose-bridges.ts","../src/diagnose-configuration/diagnose-configuration.ts","../src/diagnose-bridges/doctor.command.ts","../src/diagnose-mcp/diagnose-mcp.ts","../src/diagnose-mcp/mcp-model.ts","../src/diagnose-mcp/mcp-baseline.ts","../src/diagnose-mcp/mcp-sources.ts","../src/initialize-harnesses/init.command.ts","../src/skill-projection/skill-projection.ts","../src/initialize-harnesses/initialize-harnesses.ts"],"mappings":";;;;;;;;;;;;;wBAyCsB,IAAI,iBAAiB;;;;;;;;;;;;;;;KC7B/B;;;;;;EAOT;;EAEA;;;EAIA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;KCbS;;EAEX;;;;;;EAMA;;;;;EAKA;;;;;;EAMA;;;;;;;;;;;;;;;;;KCtBW;KAgBA;;;;;EAKX;;EAEA;EACA,MAAM;;;;KC/BK;;KAUA;;;;;;;;;;;;;;;;;;;;;;;;;KA0BA;EACX;EACA;EACA,oBAAoB;EACpB,YAAY;EACZ,uBAAuB;;KAGZ;EACX,MAAM;;EAEN,SAAS;;;;;EAKT,OAAO;;EAEP,aAAa;;;;;;;;;;;;;;;;;;;;;;qBAuBD,0BAA0B;;;;KCzE3B;;;;;;KAMA;KAEA;EACX,SAAS;;EAET;EACA,MAAM;EACN,QAAQ;;;;;;;;;;wBAkFO,qBACf,cACA,oBAAoB,WACpB;EACI,cAAc;EAAqB,UAAU;;;;;;;;;;;;;;;;;;;;KC5FtC;EAAa;EAAc;;KAE3B;;EAEX;;EAEA;;EAEA;;EAEA,WAAW;;;;;;;;;;KCfA;;;;;;;;;;;KAqBA;;;;;;;;;KAUA;;;;;;;;;KAoBA;KAOA;;KAOA,gBAAgB,gBAAgB,qBAAqB,qBAAqB,aAAa;;KAGvF,uBAAuB;;;;;;;;;;;;;;;;;;KAmBvB;;EAEX;;EAEA;;KAGW;EACX,SAAS;;EAET;;;;;;;EAOA,OAAO,IAAI,SAAS,cAAc;;;;;;EAMlC,YAAY,IAAI;;qBAwKJ,wBAAwB;qBA4CxB,6BAA6B;qBAuM7B,wBAAwB;qBAOxB;WACZ;WACA;;;;;;;;;;wBAmCe,kBAAkB;;;;KC5jBtB;;KAGA;;;;;;cAwBC;mBAIA;;mBAFK;EAEjB,YAAY;;;;;;EASZ,WAAW,eAAe;;;;;;;EAa1B,UAAU;;;;;;;;;EAaV,gBAAgB;;EAMhB,UAAU,gBAAgB;;;;;EAS1B,YAAY,gBAAgB,oBAAoB;;UAYxC;;;;;UAmBA;;;;KC5GG;KACA;KAEA;EACX,SAAS;;EAET;EACA,MAAM;EACN,QAAQ;;KAGG;EACX;;;;;EAKA,SAAS;EACT;;EAEA,QAAQ;;KAGG;EACX;EACA,WAAW;;KAGA;EACX;EACA,YAAY;;EAEZ;;KAGW;EACX,SAAS;;;;;EAKT,cAAc;EACd,YAAY;EACZ,UAAU;;;;;;;wBA2EK,kBAAkB,MAAM,WAAW,WAAgB,OAAO,kBAAkB;;;;;;;;;;;;;;;;;KC1GhF;;EAEX;EACA,SAAS;EACT;;EAEA,QAAQ;;;;KCfG;EACX;EACA,SAAS;EACT,cAAc;EACd,aAAa;;;;;EAKb;IAAY;IAAc,SAAS;IAAe;;;;;;;;;;EASlD,OAAO;;;;;;wBAOQ,kBACf,aACA,QAAQ,gBACR,gBAAe,yBACb;qBAgCU,eAAe,MAAI;;;;;;;;;;;;;;;;;;KC7CpB;EACX;EACA,KAAK;;EAEL;;wBAgCe,cAAc,MAAM,KAAK,OAAO,qBAAqB;;;;;;;;;;;;;;;;KClDzD;KAEA;EACX,YAAY;EACZ;EACA;EACA,MAAM,SAAS;EACf;EACA,UAAU,SAAS;EACnB;EACA;EACA;EACA;;;cAIY;KAaD,mBAAmB;;;;KCnCnB;;;;qBCAC;;;qBCAA,aAAa,MAAI;qBAoDjB,gBAAgB,MAAI;wBAMjB,WAAW;EAAgB,WAAW,gBAAgB;;;;;;;;;KCV1D;;;KCpDA;EACX;EACA,YAAY;EACZ;EACA,QAAQ;;KAEG;EACX;EACA,WAAW;EACX,QAAQ;EACR,QAAQ;;EAER,SAAS;;EAET;IAAc,MAAM;IAAa,YAAY;;EAC7C;EACA;;wBAGe,sBACf,MACA,WAAW,WACX,MACA,SACE,oBAAoB"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/cli.ts","../src/harness-registry/instruction-bridge.ts","../src/harness-registry/mcp-config.ts","../src/harness-registry/nonstandard-artifact.ts","../src/harness-registry/harness-registry.ts","../src/diagnose-bridges/diagnose-instructions.ts","../src/diagnose-bridges/locator.ts","../src/diagnose-bridges/doctor-guidance.ts","../src/diagnose-bridges/git-bridge-state.ts","../src/diagnose-bridges/diagnose-bridges.ts","../src/diagnose-configuration/diagnose-configuration.ts","../src/diagnose-bridges/doctor.command.ts","../src/diagnose-mcp/diagnose-mcp.ts","../src/diagnose-mcp/mcp-model.ts","../src/diagnose-mcp/mcp-baseline.ts","../src/diagnose-mcp/mcp-sources.ts","../src/initialize-harnesses/init.command.ts","../src/skill-projection/skill-projection.ts","../src/initialize-harnesses/initialize-harnesses.ts","../src/mcp-inventory/mcp-inventory.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from "node:fs";
 import { cli, command, exitCodes, z } from "clibuilder";
 import { homedir, platform } from "node:os";
-import { dirname, join, posix, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, posix, relative, resolve, sep } from "node:path";
 import { encode } from "@toon-format/toon";
 import { parse } from "smol-toml";
 import { execFileSync } from "node:child_process";
@@ -955,10 +955,10 @@ const skillInvocation = (version) => `npx -y ${commandInvocation}@^${version}`;
 */
 const launcherFor = (subcommand) => `scripts/${subcommand}.mjs`;
 /**
-* How a skill names its launcher: the path as the skill sees it, resolved by the agent against the
+* How a skill names its script: the path as the skill sees it, resolved by the agent against the
 * directory it read the `SKILL.md` from.
 *
-* `node` stays in front. The launcher ships without an executable bit, and its shebang does nothing
+* `node` stays in front. The script ships without an executable bit, and its shebang does nothing
 * on Windows, so naming the file alone would not run it.
 */
 const launcherInvocation = (subcommand) => `node ${launcherFor(subcommand)}`;
@@ -1323,7 +1323,7 @@ Diagnose it:
 ${launcherInvocation("doctor")}
 \`\`\`
 
-That path is relative to this skill's own directory. The launcher runs the CLI that shipped beside it against the current working directory, so nothing is downloaded. Fall back to \`${skillInvocation(version)} doctor\` when the launcher cannot be resolved or run, which is the case when the plugin was installed from git rather than npm and its dependencies were never installed.
+That path is relative to this skill's own directory: \`scripts/doctor.mjs\` is a self-contained bundle built from this package's source and shipped inside the skill folder through the npm package, so it runs against the current working directory with nothing downloaded and no \`node_modules\` needed. Fall back to \`${skillInvocation(version)} doctor\` when \`scripts/doctor.mjs\` is missing or cannot be run — the case for a skill installed from git rather than from the npm package, which does not carry the bundle.
 
 The command is read-only. It never repairs anything, so it is safe to run at any point, including from a session-start hook.
 
@@ -1831,9 +1831,25 @@ function credentialFields(server) {
 		...server.url && urlHoldsCredential(server.url) ? ["url"] : []
 	];
 }
+/**
+* `args` with any `--flag=value` pair dropped whose flag names a credential and whose value is a
+* literal rather than a reference — the same test `credentialKey` and `holdsLiteral` apply to `env`
+* and `headers`, applied here to the one field that carries names and values in a single string
+* instead of a map.
+*
+* A positional argument, or a flag with no `=`, passes through unfiltered: `-y` and a package name
+* are not a place a credential's value is written, and there is no key in either to test.
+*/
+function nonSecretArgs(args) {
+	return (args ?? []).filter((arg) => {
+		const at = arg.indexOf("=");
+		if (at === -1) return true;
+		return !(credentialKey(arg.slice(0, at)) && holdsLiteral(arg.slice(at + 1)));
+	});
+}
 //#endregion
 //#region src/diagnose-mcp/diagnose-mcp.ts
-function read(root, path) {
+function read$1(root, path) {
 	const absolute = join(root, path);
 	return existsSync(absolute) ? readFileSync(absolute, "utf8") : void 0;
 }
@@ -1884,7 +1900,7 @@ function diagnoseMcp({ root, git, cli }) {
 	const targets = /* @__PURE__ */ new Map();
 	const configs = [];
 	for (const config of targetsOf(root)) {
-		const parsed = parseTarget(config, read(root, config.path));
+		const parsed = parseTarget(config, read$1(root, config.path));
 		if (parsed.kind === "unreadable") {
 			add({ file: config.path }, "mcp-target-unreadable");
 			continue;
@@ -1894,7 +1910,7 @@ function diagnoseMcp({ root, git, cli }) {
 		targets.set(config.path, parsed.servers);
 		configs.push(config);
 	}
-	const golden = parseGoldenSet(read(root, goldenSetPath));
+	const golden = parseGoldenSet(read$1(root, goldenSetPath));
 	if (golden.kind === "unreadable") {
 		add({
 			file: goldenSetPath,
@@ -1906,7 +1922,7 @@ function diagnoseMcp({ root, git, cli }) {
 	reportSecrets(goldenSetPath, golden.servers);
 	const baseline = new McpBaseline({
 		git,
-		record: parseProjectionRecord(read(root, projectionRecordPath))
+		record: parseProjectionRecord(read$1(root, projectionRecordPath))
 	});
 	for (const config of configs) {
 		const servers = targets.get(config.path);
@@ -2690,14 +2706,7 @@ function activate({ addCommand }) {
 }
 //#endregion
 //#region src/cli.ts
-/**
-* Read from the manifest rather than restated here: a version written into this call is a second
-* home for a number that already has one, and it stayed at `0.1.0` for five minor releases.
-*
-* `../package.json` resolves from `src/cli.ts` and from the bundled `dist/cli.mjs` alike — both sit
-* one directory under the package root.
-*/
-const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+const version = typeof __PACKAGE_VERSION__ !== "undefined" ? __PACKAGE_VERSION__ : JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
 /**
 * A factory rather than a module-level constant: `cli()` builds state, and state built at import
 * time is shared by every later call in the process.
@@ -2730,6 +2739,135 @@ async function run(argv) {
 	}
 }
 //#endregion
-export { activate, bridgeRepairs, buildDoctorReport, diagnoseBridges, diagnoseInstructions, diagnoseMcp, doctorCommand, doctorRepairs, doctorSkill, goldenSetPath, harnessCommand, harnessRegistry, initCommand, initializeHarnesses, instructionRepairs, renderDoctorSkill, run };
+//#region src/mcp-inventory/mcp-inventory.ts
+/**
+* A public, redaction-safe inventory of configured MCP servers: what `diagnoseMcp` already knows how
+* to read, reshaped for a consumer that wants a list rather than a drift diagnosis.
+*
+* This is a **different question** than `doctor` answers, not a wider version of it. `doctor`
+* compares project-scope configuration against a golden set the user authors, and stays
+* project-scope only by design — see `apps/web/src/content/docs/agent-configuration/mcp-servers.md`
+* for why reading a user's home directory is a wider blast radius than diagnosis needs. An inventory
+* has no golden set to compare against and nothing to diagnose; it answers "what MCP servers does
+* this project, and this machine, already have configured", which is a question a consumer can only
+* answer by reading both scopes. Adding user scope here changes nothing about what `doctor` reads:
+* `diagnoseMcp` still touches `harness.project.mcpConfig` alone.
+*
+* Every field that could carry a credential is reduced before it leaves this module, the same
+* discipline `mcp-secrets.ts` documents for `doctor`'s own findings: `command` is trimmed to its
+* basename, `args` drops any `--flag=value` pair `nonSecretArgs` flags, and `url` is trimmed to its
+* origin and path. `env` and `headers` are not returned at all — a name alone does not say whether
+* the value behind it is a literal or a reference, and the safe answer is not to carry the map.
+*/
+/** Where a harness keeps its **user-scope** MCP configuration, as that harness documents it.
+*
+* Unlike `harnessRegistry`, this table is read only from here: it is not wired into `doctor`, and
+* adding a harness to it never changes what `doctor` reads. Codex and Copilot CLI each let their
+* whole configuration directory move via an environment variable — `CODEX_HOME` and `COPILOT_HOME`
+* — so those two resolve through `env` before falling back to the home directory; the rest do not
+* document one.
+*/
+function userScopeConfig(harness, home, env) {
+	switch (harness) {
+		case "claude-code": return {
+			file: join(home, ".claude.json"),
+			config: {
+				path: ".claude.json",
+				key: "mcpServers",
+				format: "json"
+			}
+		};
+		case "cursor": return {
+			file: join(home, ".cursor", "mcp.json"),
+			config: {
+				path: ".cursor/mcp.json",
+				key: "mcpServers",
+				format: "json"
+			}
+		};
+		case "codex": return {
+			file: join(env["CODEX_HOME"] || join(home, ".codex"), "config.toml"),
+			config: {
+				path: "config.toml",
+				key: "mcp_servers",
+				format: "toml"
+			}
+		};
+		case "copilot-cli": return {
+			file: join(env["COPILOT_HOME"] || join(home, ".copilot"), "mcp-config.json"),
+			config: {
+				path: "mcp-config.json",
+				key: "mcpServers",
+				format: "json"
+			}
+		};
+		case "gemini-cli": return {
+			file: join(home, ".gemini", "settings.json"),
+			config: {
+				path: ".gemini/settings.json",
+				key: "mcpServers",
+				format: "json",
+				shared: true
+			}
+		};
+		default: return;
+	}
+}
+function read(file) {
+	return existsSync(file) ? readFileSync(file, "utf8") : void 0;
+}
+/** A URL trimmed to its origin and path, dropping any query string a token could ride in on. */
+function safeUrl(value) {
+	if (!value) return void 0;
+	try {
+		const url = new URL(value);
+		return `${url.origin}${url.pathname}`;
+	} catch {
+		return;
+	}
+}
+function toEntry(harness, scope, file, name, server) {
+	return {
+		harness,
+		scope,
+		configFile: file,
+		name,
+		transport: server.transport,
+		command: server.command ? basename(server.command) : void 0,
+		args: nonSecretArgs(server.args),
+		url: safeUrl(server.url),
+		enabled: server.enabled !== false
+	};
+}
+function entriesFrom(harness, scope, file, config) {
+	const parsed = parseTarget(config, read(file));
+	if (parsed.kind !== "servers") return [];
+	return [...parsed.servers].map(([name, server]) => toEntry(harness, scope, file, name, server));
+}
+/**
+* Every MCP server configured for a project, across every supported harness and every scope that
+* harness documents — without ever surfacing a credential.
+*
+* Reuses `diagnoseMcp`'s own parsing (`parseTarget`), model (`McpServer`), and redaction
+* (`nonSecretArgs`, and the URL/command trimming this module adds) rather than re-reading or
+* re-parsing any of the supported harnesses' MCP files. A harness with no file present, or one whose
+* file does not parse, contributes no entries; this function reports an inventory, not a diagnosis,
+* so it has nothing to say about why a file is missing or broken.
+*/
+function listMcpServers(options) {
+	const home = options.homeDir ?? homedir();
+	const env = options.env ?? process.env;
+	const entries = [];
+	for (const harness of harnessRegistry) {
+		if (harness.deprecated) continue;
+		const project = harness.project.mcpConfig;
+		if (project) entries.push(...entriesFrom(harness.name, "project", join(options.projectDir, project.path), project));
+		const user = userScopeConfig(harness.name, home, env);
+		if (user) entries.push(...entriesFrom(harness.name, "user", user.file, user.config));
+	}
+	return entries;
+}
+//#endregion
+export { activate, bridgeRepairs, buildDoctorReport, diagnoseBridges, diagnoseInstructions, diagnoseMcp, doctorCommand, doctorRepairs, doctorSkill, goldenSetPath, harnessCommand, harnessRegistry, initCommand, initializeHarnesses, instructionRepairs, listMcpServers, renderDoctorSkill, run };
 
 //# sourceMappingURL=index.mjs.map