@hardfin/cli 0.1.0 → 0.1.1-dev.40

package/README.md

@@ -373,7 +373,8 @@ asking and ask before anything changes.
 
 A command is a read when its endpoint's method is GET, or for `hardfin api` when no other
 `--method` is given. Anything else is a write, and `hardfin_read` refuses it by naming
-`hardfin_write`. Both tools carry a title, the read-only or destructive hint, and a link to
+`hardfin_write`. The server asks the CLI's own parser what a call would run, so a flag whose
+value is `--help`, or a `--method` given twice, is placed by what the command would do. Both tools carry a title, the read-only or destructive hint, and a link to
 the API reference, which Claude's connector directory requires.
 
 A tool call runs the CLI itself, so an agent and a person get identical parsing, output and
@@ -392,6 +393,10 @@ The server uses whatever credential this machine holds, so an agent acts as the
 ran `hardfin login`. Give an agent an API key through `HARDFIN_API_KEY` when it should act
 as an integration instead.
 
+A call cannot set `--api-url`, `--api-key` or `--issuer-url`. Both tools refuse them, because
+a call that chose the host could send the credential to it. Set `HARDFIN_API_URL`,
+`HARDFIN_API_KEY` or `HARDFIN_ISSUER_URL` where the server is started.
+
 ## Diagnosing a problem
 
 `hardfin status` prints everything a support request needs, and is the first thing to send.
@@ -432,6 +437,11 @@ Only defects are reported. None of these are:
 - a mistake on the command line or in a settings file
 - being signed out, or a sign in that was cancelled or refused
 - the machine refusing a file, such as a full disk or a missing permission
+- anything from a run with no API key and no stored sign in, except a defect in `hardfin login`
+
+The last rule is there because package scanners install the CLI and run it in sandboxes. They
+never sign in, and their reports would bury the real ones. A defect while signing in is still
+reported, because that is the one thing a signed-out person is doing.
 
 A report carries the error, its stack trace, and what `hardfin status` would print at that
 moment. The command is named, and its flags are listed by name without their values.
@@ -447,7 +457,7 @@ organization appear only as their Hardfin keys.
 | Send reports to another Sentry project            | `HARDFIN_SENTRY_DSN`                       |
 
 `hardfin status` shows which of these is in effect. `hardfin __crash` fails on purpose, to
-check that a report arrives.
+check that a report arrives. It reports only when signed in or given an API key.
 
 ## Local configuration
 

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b1580db0-6822-5a25-b000-03705726eaf6")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b40d6c93-b462-5248-a0a0-bbc0f5456ba1")}catch(e){}}();
 import module from "node:module";
 //#region src/cli.ts
 module.enableCompileCache?.();
@@ -14,7 +14,7 @@ process.on("unhandledRejection", (error) => void toCrash(error));
 try {
 	const answer = await toQuickAnswer(process.argv.slice(2));
 	if (answer === void 0) {
-		const { toCli, toParseExitCode, wasReportAttempted } = await import("./program-CjKwnPeY.js");
+		const { toCli, toParseExitCode, wasReportAttempted } = await import("./program-C38xnnim.js");
 		try {
 			await toCli().parseAsync(process.argv);
 		} catch (error) {
@@ -33,7 +33,7 @@ async function toCrash(error) {
 	isCrashing = true;
 	process.stderr.write(`error: ${error instanceof Error ? error.message : String(error)}\n`);
 	try {
-		const { toReported } = await import("./program-CjKwnPeY.js");
+		const { toReported } = await import("./program-C38xnnim.js");
 		await toReported(error, false, void 0, "fatal");
 	} finally {
 		process.exit(1);
@@ -51,4 +51,4 @@ async function toQuickAnswer(args) {
 export {};
 
 //# sourceMappingURL=cli.js.map
-//# debugId=b1580db0-6822-5a25-b000-03705726eaf6
+//# debugId=b40d6c93-b462-5248-a0a0-bbc0f5456ba1

package/dist/{program-CjKwnPeY.js → program-C38xnnim.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="5a591d32-0d31-5357-b447-e33420753351")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="23617f68-b6d8-5249-bca7-f5585fdb94f2")}catch(e){}}();
 import { a as defineCommand, i as GLOBAL_FLAGS, r as ExitCode, t as toInvocation } from "./scrub-BN3gyBpR.js";
 import { n as toCompletion, t as toAnswer$1 } from "./completion-tree-rR_Rmeij.js";
 import { createRequire } from "node:module";
@@ -15,6 +15,114 @@ import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { createServer } from "node:http";
 import { createInterface as createInterface$1 } from "node:readline";
+//#region src/output/writer.ts
+/**
+* toText reads a value a caller supplied, which arrives typed as unknown. An object would
+* otherwise reach a request as the text "[object Object]".
+*/
+function toText(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (value === void 0 || value === null) return "";
+	return JSON.stringify(value);
+}
+/** writeData prints a command's result on stdout. */
+function writeData(value) {
+	if (typeof value === "string") {
+		process.stdout.write(value.endsWith("\n") ? value : `${value}\n`);
+		return;
+	}
+	process.stdout.write(`${JSON.stringify(value ?? null, null, 2)}\n`);
+}
+/** writeFailure prints why a command failed on stderr, with a code only a machine reading JSON sees. */
+function writeFailure(code, message, isJSON, errors, requestId, status) {
+	if (!isJSON) {
+		process.stderr.write(`error: ${message}${status === void 0 ? "" : ` (HTTP ${status})`}\n`);
+		for (const entry of errors?.slice(1) ?? []) process.stderr.write(`  ${entry.error} (${entry.statusCode})\n`);
+		if (requestId) process.stderr.write(`  request ${requestId}\n`);
+		return;
+	}
+	const payload = {
+		code,
+		message,
+		errors: errors ?? [{
+			error: message,
+			statusCode: 0
+		}],
+		requestId: requestId ?? null,
+		status: status ?? null
+	};
+	process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
+/** isJSONOutput decides whether this invocation prints machine-readable output. */
+function isJSONOutput(flags) {
+	if (flags["json"] === true) return true;
+	return !process.stdout.isTTY;
+}
+/** version is what this build reports, read from the published package manifest. */
+const version$1 = createRequire(import.meta.url)("../package.json").version;
+//#endregion
+//#region src/cli/parser.ts
+/** toParser builds the parser from the registry, and hands whatever it parses to onRun. */
+function toParser(entries, onRun, isSilent = false) {
+	const program = new Command();
+	program.name("hardfin").description("Call the Hardfin API from a terminal or an agent").version(version$1, "-v, --version").enablePositionalOptions();
+	toQuietParser(program, isSilent);
+	for (const flag of GLOBAL_FLAGS) program.option(`--${flag.name} <${flag.valueName}>`, flag.description);
+	for (const command of entries) program.addCommand(toProgram(program, command, onRun, isSilent), { hidden: command.hidden });
+	return program;
+}
+/** toProgram wires one registry command into the parser. */
+function toProgram(root, command, onRun, isSilent) {
+	const program = new Command(command.name).summary(command.summary).description(command.description ?? command.summary);
+	toQuietParser(program, isSilent);
+	for (const argument of command.arguments) {
+		const name = argument.variadic ? `${argument.name}...` : argument.name;
+		program.argument(argument.required ? `<${name}>` : `[${name}]`, argument.description);
+	}
+	for (const flag of command.flags) {
+		const short = flag.short ? `-${flag.short}, ` : "";
+		const value = flag.valueName ? ` <${flag.valueName}>` : "";
+		const option = new Option(`${short}--${flag.name}${value}`, flag.description);
+		if (flag.negatable) program.addOption(new Option(`--no-${flag.name}`, `${flag.description}, turned off`));
+		if (flag.repeatable) option.argParser(collect);
+		if (flag.defaultValue !== void 0) option.default(flag.defaultValue);
+		program.addOption(option);
+	}
+	for (const example of command.examples) program.addHelpText("after", `\n${example.description}:\n  $ ${example.command}`);
+	for (const subcommand of command.subcommands ?? []) program.addCommand(toProgram(root, subcommand, onRun, isSilent), { hidden: subcommand.hidden });
+	if (!command.run) return program;
+	program.action((...parsed) => {
+		const flags = parsed[parsed.length - 2] ?? {};
+		return onRun({
+			command,
+			args: parsed.slice(0, parsed.length - 2).flatMap(toArgumentList),
+			flags,
+			globals: root.opts()
+		});
+	});
+	return program;
+}
+/**
+* toQuietParser has the parser hand back its mistakes, so they are answered like any other
+* failure. A silent parser also keeps its help and version to itself, for a caller that only
+* wants to know what a command line means.
+*/
+function toQuietParser(program, isSilent) {
+	program.exitOverride().configureOutput({ outputError: () => void 0 });
+	if (isSilent) program.configureOutput({
+		writeOut: () => void 0,
+		writeErr: () => void 0
+	});
+}
+function toArgumentList(value) {
+	if (Array.isArray(value)) return value.map(String);
+	return value === void 0 ? [] : [toText(value)];
+}
+function collect(value, previous) {
+	return [...previous ?? [], value];
+}
+//#endregion
 //#region src/report/expected.ts
 /**
 * ExpectedFailure is a failure the CLI anticipated: the person's input, their network, their
@@ -474,51 +582,6 @@ function keep(issuer, document) {
 	} catch {}
 }
 //#endregion
-//#region src/output/writer.ts
-/**
-* toText reads a value a caller supplied, which arrives typed as unknown. An object would
-* otherwise reach a request as the text "[object Object]".
-*/
-function toText(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
-	if (value === void 0 || value === null) return "";
-	return JSON.stringify(value);
-}
-/** writeData prints a command's result on stdout. */
-function writeData(value) {
-	if (typeof value === "string") {
-		process.stdout.write(value.endsWith("\n") ? value : `${value}\n`);
-		return;
-	}
-	process.stdout.write(`${JSON.stringify(value ?? null, null, 2)}\n`);
-}
-/** writeFailure prints why a command failed on stderr, with a code only a machine reading JSON sees. */
-function writeFailure(code, message, isJSON, errors, requestId, status) {
-	if (!isJSON) {
-		process.stderr.write(`error: ${message}${status === void 0 ? "" : ` (HTTP ${status})`}\n`);
-		for (const entry of errors?.slice(1) ?? []) process.stderr.write(`  ${entry.error} (${entry.statusCode})\n`);
-		if (requestId) process.stderr.write(`  request ${requestId}\n`);
-		return;
-	}
-	const payload = {
-		code,
-		message,
-		errors: errors ?? [{
-			error: message,
-			statusCode: 0
-		}],
-		requestId: requestId ?? null,
-		status: status ?? null
-	};
-	process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
-}
-/** isJSONOutput decides whether this invocation prints machine-readable output. */
-function isJSONOutput(flags) {
-	if (flags["json"] === true) return true;
-	return !process.stdout.isTTY;
-}
-//#endregion
 //#region src/auth/grant.ts
 const TokenResponse = z.looseObject({
 	access_token: z.string(),
@@ -954,8 +1017,6 @@ function toErrorCode(error) {
 	if (error instanceof LockHeld) return "busy";
 	return "internal_error";
 }
-/** version is what this build reports, read from the published package manifest. */
-const version$1 = createRequire(import.meta.url)("../package.json").version;
 //#endregion
 //#region src/command/agent-guide.ts
 const agentGuideCommand = defineCommand({
@@ -2546,68 +2607,339 @@ async function runLogout(input) {
 	});
 	return ExitCode.OK;
 }
-const OFF = /* @__PURE__ */ new Set([
-	"0",
-	"false",
-	"off",
-	"no"
-]);
+//#endregion
+//#region src/command/operation.ts
 /**
-* toTelemetry decides whether defects are reported. A person's opt out wins over everything,
-* and a CLI run from a checkout reports only when its developer asks it to.
+* toEnum takes a value in any case, as the API does, and answers the spelling the document
+* lists, which is what a response always uses.
 */
-function toTelemetry(env = process.env, isCheckout = isRunFromCheckout()) {
-	const dsn = env["HARDFIN_SENTRY_DSN"] || "https://a4819e652e9fa63c0ab67e9febe44565@o1388102.ingest.us.sentry.io/4512176532684800";
-	const base = {
-		dsn,
-		environment: isCheckout ? "local" : version$1.includes("-dev.") ? "preview" : "production",
-		release: toRelease(version$1)
-	};
-	if (env["DO_NOT_TRACK"] && !OFF.has(env["DO_NOT_TRACK"].toLowerCase())) return {
-		...base,
-		enabled: false,
-		from: "DO_NOT_TRACK"
-	};
-	const asked = env["HARDFIN_TELEMETRY"]?.toLowerCase();
-	if (asked !== void 0 && OFF.has(asked)) return {
-		...base,
-		enabled: false,
-		from: "HARDFIN_TELEMETRY"
-	};
-	if (!isDsn(dsn)) return {
-		...base,
-		enabled: false,
-		from: "HARDFIN_SENTRY_DSN is not a valid DSN"
-	};
-	if (asked !== void 0) return {
-		...base,
-		enabled: true,
-		from: "HARDFIN_TELEMETRY"
-	};
-	return isCheckout ? {
-		...base,
-		enabled: false,
-		from: "run from a checkout"
-	} : {
-		...base,
-		enabled: true,
-		from: "default"
-	};
+function toEnum(values) {
+	return z.string().transform((value) => values.find((allowed) => allowed.toLowerCase() === value.toLowerCase()) ?? value).pipe(z.enum(values));
 }
-/**
-* isRunFromCheckout answers whether this CLI runs from a clone of its repository, as npm link
-* and node dist/cli.js do. The published package holds dist and nothing beside it.
-*/
-function isRunFromCheckout() {
-	return existsSync(fileURLToPath(new URL("../src", import.meta.url)));
+const UNSET_FLAG = {
+	name: "unset",
+	description: "A field to clear, named as its flag is, repeatable",
+	valueName: "field",
+	repeatable: true,
+	schema: z.array(z.string())
+};
+const INPUT_FLAG = {
+	name: "input",
+	description: "A file holding the JSON request body, or - for standard input. A flag given as well replaces its field",
+	valueName: "path",
+	schema: z.string()
+};
+const FILE_FLAG = {
+	name: "file",
+	description: "The file to upload",
+	valueName: "path",
+	schema: z.string()
+};
+const OUTPUT_FLAG = {
+	name: "output",
+	description: "Where to write the file, or - for standard output",
+	valueName: "path",
+	schema: z.string()
+};
+const JSON_FLAG = {
+	name: "json",
+	description: "Print machine-readable output, which is the default when stdout is not a terminal",
+	schema: z.boolean()
+};
+/** defineOperation turns one endpoint into the command that calls it. */
+function defineOperation(operation) {
+	const flags = [
+		...operation.queryFlags,
+		...operation.bodyFlags,
+		...operation.bodyFlags.some((flag) => flag.nullable) ? [UNSET_FLAG] : [],
+		...operation.bodyFlags.length > 0 ? [INPUT_FLAG] : [],
+		...operation.upload ? [...operation.upload.fields, FILE_FLAG] : [],
+		...operation.downloads ? [OUTPUT_FLAG] : [],
+		JSON_FLAG
+	];
+	return {
+		name: operation.name,
+		summary: operation.summary,
+		description: operation.description ?? operation.summary,
+		arguments: operation.pathParameters,
+		flags,
+		examples: operation.example ? [{
+			description: operation.summary,
+			command: operation.example
+		}] : [],
+		endpoint: {
+			method: operation.method,
+			path: operation.path
+		},
+		run: (input) => runOperation(operation, input)
+	};
 }
-/** isDsn answers whether a DSN can be read as the URL of a Sentry project. */
-function isDsn(dsn) {
-	try {
-		return new URL(dsn).host !== "";
-	} catch {
-		return false;
-	}
+async function runOperation(operation, input) {
+	const path = toPath(operation, input.args);
+	if (path === void 0) {
+		writeFailure("invalid_arguments", `this command takes ${operation.pathParameters.length} argument(s)`, input.isJSON);
+		return ExitCode.USAGE;
+	}
+	const given = toGivenBody(input.flags["input"]);
+	if (given instanceof InputFailure) {
+		writeFailure("invalid_input", given.message, input.isJSON);
+		return ExitCode.USAGE;
+	}
+	const missing = operation.bodyFlags.concat(operation.upload?.fields ?? []).filter((flag) => flag.required && input.flags[toOptionKey(flag.name)] === void 0 && !hasPath(given, flag.jsonPath));
+	if (missing.length > 0) {
+		writeFailure("missing_flag", `this command needs ${missing.map((flag) => `--${flag.name}`).join(", ")}`, input.isJSON);
+		return ExitCode.USAGE;
+	}
+	const body = toBody(operation, input.flags, given);
+	if (body instanceof Error) {
+		writeFailure("invalid_flag", body.message, input.isJSON);
+		return ExitCode.USAGE;
+	}
+	if (operation.bodyFlags.length > 0 && body === void 0) {
+		writeFailure("empty_request", `this command changes nothing unless a flag is given, such as ${operation.bodyFlags.slice(0, 3).map((flag) => `--${flag.name}`).join(", ")}. Run it with --help for the rest`, input.isJSON);
+		return ExitCode.USAGE;
+	}
+	let form;
+	if (operation.upload) {
+		const built = await toForm(operation.upload, input.flags);
+		if (built instanceof Error) {
+			writeFailure("invalid_input", built.message, input.isJSON);
+			return ExitCode.USAGE;
+		}
+		form = built;
+	}
+	try {
+		const envelope = await request$1({
+			apiUrl: input.resolved.settings.apiUrl,
+			credential: await toRequestCredential(input.resolved.settings, input.resolved.sources),
+			method: operation.method,
+			path,
+			query: toQuery(operation, input.flags),
+			body,
+			form,
+			downloads: operation.downloads
+		});
+		if (operation.downloads) return toWritten(envelope.data, input);
+		writeData(envelope.data);
+		return ExitCode.OK;
+	} catch (error) {
+		if (error instanceof NoCredential) {
+			writeFailure("not_signed_in", error.message, input.isJSON);
+			return ExitCode.NOT_AUTHENTICATED;
+		}
+		if (error instanceof RequestFailure) {
+			writeFailure(toStatusCode(error.status), error.message, input.isJSON, error.errors, error.requestId, error.status);
+			return error.status === 401 ? ExitCode.NOT_AUTHENTICATED : ExitCode.ERROR;
+		}
+		throw error;
+	}
+}
+/**
+* toWritten puts a downloaded file where it was asked for. A terminal is never written to,
+* because a person would otherwise have their session filled with a file's bytes.
+*/
+function toWritten(download, input) {
+	const asked = input.flags["output"];
+	const path = typeof asked === "string" ? asked : download.fileName ?? "-";
+	if (path === "-") {
+		if (process.stdout.isTTY) {
+			writeFailure("output_required", "this answer is a file, so name where to write it with --output, or send it on with a pipe", input.isJSON);
+			return ExitCode.USAGE;
+		}
+		process.stdout.write(download.bytes);
+		return ExitCode.OK;
+	}
+	writeFileSync(path, download.bytes);
+	writeData({
+		written: path,
+		bytes: download.bytes.length,
+		contentType: download.contentType
+	});
+	return ExitCode.OK;
+}
+/** toPath fills the path template from the positional arguments, in order. */
+function toPath(operation, args) {
+	if (args.length !== operation.pathParameters.length) return;
+	let path = operation.path;
+	for (const [index, parameter] of operation.pathParameters.entries()) path = path.replace(`{${parameter.name}}`, encodeURIComponent(args[index] ?? ""));
+	return path;
+}
+/** toQuery carries only the flags this invocation actually set. */
+function toQuery(operation, flags) {
+	const query = new URLSearchParams();
+	for (const flag of operation.queryFlags) {
+		const value = flags[toOptionKey(flag.name)];
+		if (value === void 0) continue;
+		const parsed = flag.schema.safeParse(value);
+		const carried = parsed.success ? parsed.data : value;
+		for (const entry of Array.isArray(carried) ? carried : [carried]) query.append(flag.queryName, toText(entry));
+	}
+	return query;
+}
+/** toOptionKey names the parsed flag, which the parser reports in camel case. */
+function toOptionKey(name) {
+	return name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+/** toForm builds the file part and its fields, which an upload endpoint takes. */
+async function toForm(upload, flags) {
+	const path = flags["file"];
+	if (typeof path !== "string") return /* @__PURE__ */ new Error("this command needs --file, the file to upload");
+	const form = new FormData();
+	try {
+		form.append(upload.filePart, await openAsBlob(path), basename(path));
+	} catch {
+		return /* @__PURE__ */ new Error(`${path} cannot be read`);
+	}
+	for (const field of upload.fields) {
+		const value = flags[toOptionKey(field.name)];
+		if (value !== void 0) {
+			const parsed = field.schema.safeParse(value);
+			form.append(field.jsonPath[0] ?? field.name, toText(parsed.success ? parsed.data : value));
+		}
+	}
+	return form;
+}
+/** toGivenBody reads the --input body, which a generated command takes only as a JSON object. */
+function toGivenBody(source) {
+	if (typeof source !== "string") return;
+	const read = toJSONInput(source);
+	if (read instanceof InputFailure) return read;
+	if (typeof read !== "object" || read === null || Array.isArray(read)) return new InputFailure(`the body in ${source === "-" ? "standard input" : source} must be a JSON object, such as {"name": "Acme"}`);
+	return read;
+}
+/** hasPath reports whether a body already holds a value at a field's path. */
+function hasPath(body, path) {
+	let holder = body;
+	for (const name of path) {
+		if (typeof holder !== "object" || holder === null || !(name in holder)) return false;
+		holder = holder[name];
+	}
+	return true;
+}
+/** toBody builds the request body from the --input body and the flags, a flag winning over its field. */
+function toBody(operation, flags, given) {
+	const body = given ? structuredClone(given) : {};
+	let hasField = given !== void 0;
+	for (const flag of operation.bodyFlags) {
+		const value = flags[toOptionKey(flag.name)];
+		if (value === void 0) continue;
+		if (flag.element) {
+			const elements = toElements(flag, Array.isArray(value) ? value.map(toText) : [toText(value)]);
+			if (elements instanceof Error) return elements;
+			set(body, flag.jsonPath, elements);
+			hasField = true;
+			continue;
+		}
+		const parsed = flag.schema.safeParse(value);
+		set(body, flag.jsonPath, parsed.success ? parsed.data : value);
+		hasField = true;
+	}
+	const cleared = toCleared(operation, flags, body);
+	if (cleared instanceof Error) return cleared;
+	return hasField || cleared ? body : void 0;
+}
+/** toCleared sends null for each field named by --unset, which is how a field is cleared. */
+function toCleared(operation, flags, body) {
+	const named = flags["unset"];
+	const names = Array.isArray(named) ? named.map(toText) : named === void 0 ? [] : [toText(named)];
+	for (const name of names) {
+		const flag = operation.bodyFlags.find((entry) => entry.name === name.replace(/^--/, ""));
+		if (!flag) return /* @__PURE__ */ new Error(`--unset names no field called ${name}`);
+		if (!flag.nullable) return /* @__PURE__ */ new Error(`--${flag.name} cannot be cleared, because the API does not accept null for it`);
+		set(body, flag.jsonPath, null);
+	}
+	return names.length > 0;
+}
+/** toElements reads the key=value pairs a repeated flag carries for one array element. */
+function toElements(flag, values) {
+	const elements = [];
+	for (const value of values) {
+		const element = {};
+		for (const pair of value.split(",")) {
+			const split = pair.indexOf("=");
+			if (split < 1) return /* @__PURE__ */ new Error(`--${flag.name} takes ${flag.element?.join("=, ") ?? ""}=, such as --${flag.name} ${flag.element?.[0] ?? "field"}=value. A value cannot contain a comma`);
+			const key = pair.slice(0, split).trim();
+			if (flag.element && !flag.element.includes(key)) return /* @__PURE__ */ new Error(`--${flag.name} has no field ${key}. It takes ${flag.element.join(", ")}`);
+			if (key in element) return /* @__PURE__ */ new Error(`--${flag.name} names ${key} twice in one element, so which one it takes is not clear`);
+			const value = pair.slice(split + 1).trim();
+			if (flag.elementUuids?.includes(key) && !z.uuid().safeParse(value).success) return /* @__PURE__ */ new Error(`--${flag.name} needs a UUID for ${key}, such as 3f2a9c1e-5b7d-4e8a-9c21-7d4e5f6a8b90, and ${value || "nothing"} is not one`);
+			element[key] = value;
+		}
+		elements.push(element);
+	}
+	return elements;
+}
+/** set writes a value at its path, building the objects a nested field needs. */
+function set(body, path, value) {
+	let holder = body;
+	for (const name of path.slice(0, -1)) {
+		holder[name] = holder[name] ?? {};
+		holder = holder[name];
+	}
+	holder[path[path.length - 1] ?? ""] = value;
+}
+const OFF = /* @__PURE__ */ new Set([
+	"0",
+	"false",
+	"off",
+	"no"
+]);
+/**
+* toTelemetry decides whether defects are reported. A person's opt out wins over everything,
+* and a CLI run from a checkout reports only when its developer asks it to.
+*/
+function toTelemetry(env = process.env, isCheckout = isRunFromCheckout()) {
+	const dsn = env["HARDFIN_SENTRY_DSN"] || "https://a4819e652e9fa63c0ab67e9febe44565@o1388102.ingest.us.sentry.io/4512176532684800";
+	const base = {
+		dsn,
+		environment: isCheckout ? "local" : version$1.includes("-dev.") ? "preview" : "production",
+		release: toRelease(version$1)
+	};
+	if (env["DO_NOT_TRACK"] && !OFF.has(env["DO_NOT_TRACK"].toLowerCase())) return {
+		...base,
+		enabled: false,
+		from: "DO_NOT_TRACK"
+	};
+	const asked = env["HARDFIN_TELEMETRY"]?.toLowerCase();
+	if (asked !== void 0 && OFF.has(asked)) return {
+		...base,
+		enabled: false,
+		from: "HARDFIN_TELEMETRY"
+	};
+	if (!isDsn(dsn)) return {
+		...base,
+		enabled: false,
+		from: "HARDFIN_SENTRY_DSN is not a valid DSN"
+	};
+	if (asked !== void 0) return {
+		...base,
+		enabled: true,
+		from: "HARDFIN_TELEMETRY"
+	};
+	return isCheckout ? {
+		...base,
+		enabled: false,
+		from: "run from a checkout"
+	} : {
+		...base,
+		enabled: true,
+		from: "default"
+	};
+}
+/**
+* isRunFromCheckout answers whether this CLI runs from a clone of its repository, as npm link
+* and node dist/cli.js do. The published package holds dist and nothing beside it.
+*/
+function isRunFromCheckout() {
+	return existsSync(fileURLToPath(new URL("../src", import.meta.url)));
+}
+/** isDsn answers whether a DSN can be read as the URL of a Sentry project. */
+function isDsn(dsn) {
+	try {
+		return new URL(dsn).host !== "";
+	} catch {
+		return false;
+	}
 }
 /**
 * toRelease names a version as Sentry knows it. Sentry refuses a slash in a release name, so
@@ -2939,9 +3271,10 @@ async function report(error, occasion, resolved) {
 	if (!isReportable(error)) return;
 	const telemetry = toTelemetry();
 	if (!telemetry.enabled) return;
+	const settings = resolved ?? toResolved();
+	if (!isSignedIn(settings) && occasion.invocation.command !== "login") return;
 	isAttempted = true;
 	try {
-		const settings = resolved ?? toResolved();
 		const status = settings ? await toStatus(settings) : void 0;
 		const secrets = [settings?.settings.apiKey, settings ? toCredential(settings.settings.issuerUrl)?.refreshToken : void 0];
 		return await (await import("./sentry-BM9Rvhhy.js")).send({
@@ -2955,6 +3288,16 @@ async function report(error, occasion, resolved) {
 		return;
 	}
 }
+/** isSignedIn reports whether this run holds an API key or a stored sign in. */
+function isSignedIn(resolved) {
+	if (!resolved) return false;
+	if (resolved.settings.apiKey) return true;
+	try {
+		return toCredential(resolved.settings.issuerUrl) !== void 0;
+	} catch {
+		return false;
+	}
+}
 /**
 * toResolved reads the settings again for a crash that happened before a command held them.
 * The global options are read from the command line, so the report describes the host the
@@ -3167,26 +3510,36 @@ const REFUSED_COMMANDS = /* @__PURE__ */ new Set([
 	"logout",
 	"mcp"
 ]);
-/** The global options, which sit before a command and take a value of their own. */
-const GLOBAL_OPTIONS_WITH_VALUES = new Set(GLOBAL_FLAGS.filter((flag) => flag.valueName).map((flag) => `--${flag.name}`));
 /**
-* toCommandName reads which command a call names. A global option sits before it, so
-* reading the first argument alone would let --issuer-url x logout through.
+* toParsed asks the CLI's own parser what a call would run, without running it. The server
+* decides from this answer and never from the words themselves, because a word such as
+* --help may be a flag's value, and a flag given twice takes its last value.
 */
-function toCommandName(args) {
-	for (let index = 0; index < args.length; index += 1) {
-		const argument = args[index] ?? "";
-		if (GLOBAL_OPTIONS_WITH_VALUES.has(argument)) {
-			index += 1;
-			continue;
-		}
-		if (argument.startsWith("-")) continue;
-		return argument;
+function toParsed(args, commands) {
+	let ran;
+	const parser = toParser(commands, (parsed) => {
+		ran = parsed;
+	}, true);
+	try {
+		parser.parse(args, { from: "user" });
+	} catch (error) {
+		if (!(error instanceof CommanderError)) throw error;
 	}
+	return {
+		ran,
+		globals: parser.opts()
+	};
 }
-/** toIsAskingForHelp reports whether a call only wants to read about a command. */
-function toIsAskingForHelp(args) {
-	return args.includes("--help") || args.includes("-h") || args[0] === "help";
+/**
+* toFixedOption names a global option a call tries to set. Where the CLI calls and what it
+* calls with are decided where the server is started, or a call could send the credential
+* to another host.
+*/
+function toFixedOption(parsed) {
+	const flag = GLOBAL_FLAGS.find((entry) => parsed.globals[toOptionKey(entry.name)] !== void 0);
+	if (!flag) return;
+	const variable = `HARDFIN_${flag.name.toUpperCase().replaceAll("-", "_")}`;
+	return `--${flag.name} cannot be set in a call, because it is fixed where this server is started. Leave it out, or set ${variable} in the server's environment`;
 }
 async function toToolResult(request, commands, run) {
 	const params = request.params;
@@ -3199,9 +3552,12 @@ async function toToolResult(request, commands, run) {
 	const refused = toRefusedArgument(args);
 	if (refused) return toError(refused);
 	const asked = args;
-	const command = toCommandName(asked) ?? "";
-	if (REFUSED_COMMANDS.has(command) && !toIsAskingForHelp(asked)) return toError(`${command} is run by a person at a terminal, not through this server. Run hardfin ${command} yourself, then call this tool again`);
-	if (name === READ_TOOL.name && toAccess(asked, commands) === "write") return toError(`this command changes data, so it runs through ${WRITE_TOOL.name}`);
+	const parsed = toParsed(asked, commands);
+	const fixed = toFixedOption(parsed);
+	if (fixed) return toError(fixed);
+	const command = parsed.ran?.command.name ?? "";
+	if (REFUSED_COMMANDS.has(command)) return toError(`${command} is run by a person at a terminal, not through this server. Run hardfin ${command} yourself, then call this tool again`);
+	if (name === READ_TOOL.name && toAccessOf(parsed) === "write") return toError(`this command changes data, so it runs through ${WRITE_TOOL.name}`);
 	const outcome = await run(asked, called?.input);
 	return {
 		content: [{
@@ -3224,46 +3580,14 @@ function toError(text) {
 const LOCAL_READS = /* @__PURE__ */ new Set([
 	"status",
 	"config",
-	"agent-guide",
-	"help"
+	"agent-guide"
 ]);
-/**
-* toAccess decides whether a call reads or changes data. A generated command answers by its
-* endpoint's method, hardfin api by the method it was given, and anything it cannot place is
-* treated as a change, so it is asked about.
-*/
-function toAccess(args, commands) {
-	if (toIsAskingForHelp(args)) return "read";
-	let level = commands;
-	let found;
-	for (let index = 0; index < args.length; index += 1) {
-		const word = args[index] ?? "";
-		if (GLOBAL_OPTIONS_WITH_VALUES.has(word)) {
-			index += 1;
-			continue;
-		}
-		if (word.startsWith("-")) continue;
-		const next = level.find((entry) => entry.name === word);
-		if (!next) break;
-		found = next;
-		level = next.subcommands ?? [];
-		if (level.length === 0) break;
-	}
-	if (!found) return "read";
-	if (found.endpoint) return found.endpoint.method === "GET" ? "read" : "write";
-	if (found.name === "api") return toApiMethod(args) === "GET" ? "read" : "write";
-	if (LOCAL_READS.has(found.name) || (found.subcommands?.length ?? 0) > 0) return "read";
-	return "write";
-}
-/** toApiMethod reads the method hardfin api was given, which is GET when none was. */
-function toApiMethod(args) {
-	for (let index = 0; index < args.length; index += 1) {
-		const word = args[index] ?? "";
-		if (word === "-X" || word === "--method") return (args[index + 1] ?? "GET").toUpperCase();
-		if (word.startsWith("--method=")) return word.slice(9).toUpperCase();
-		if (word.startsWith("-X") && word.length > 2) return word.slice(2).toUpperCase();
-	}
-	return "GET";
+function toAccessOf(parsed) {
+	if (!parsed.ran) return "read";
+	const { command, flags } = parsed.ran;
+	if (command.endpoint) return command.endpoint.method === "GET" ? "read" : "write";
+	if (command.name === "api") return toText(flags["method"] ?? "GET").toUpperCase() === "GET" ? "read" : "write";
+	return LOCAL_READS.has(command.name) ? "read" : "write";
 }
 /** The most one argument can hold, which Linux refuses past 128 KiB. */
 const ARGUMENT_BYTES = 131071;
@@ -3365,363 +3689,92 @@ async function serve(commands, run = toCliRunner()) {
 	}
 	await Promise.all(answering);
 }
-/** toAnswer replies to one line, and never rejects, because a rejection ends the server. */
-async function toAnswer(line, commands, run) {
-	let response;
-	let failure;
-	try {
-		response = await toResponse(toRequest(line), commands, run);
-	} catch (error) {
-		response = error instanceof ProtocolFailure ? toErrorResponse(error.id, error.code, error.message) : toErrorResponse(toRequestId(line), -32603, error instanceof Error ? error.message : String(error));
-		failure = error instanceof ProtocolFailure ? void 0 : error;
-	}
-	if (response) write(`${JSON.stringify(response)}\n`);
-	if (failure !== void 0) await report(failure, {
-		level: "error",
-		mechanism: "mcp.request",
-		mode: "mcp",
-		invocation: {
-			command: "mcp",
-			flags: []
-		}
-	});
-}
-/** toRequest reads one line, refusing what the protocol does not allow to be a request. */
-function toRequest(line) {
-	let parsed;
-	try {
-		parsed = JSON.parse(line);
-	} catch {
-		throw new ProtocolFailure(-32700, "this line is not JSON", null);
-	}
-	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new ProtocolFailure(-32600, "a request is a JSON object, and this server takes one per line", null);
-	const request = parsed;
-	if (typeof request.method !== "string") throw new ProtocolFailure(-32600, "a request names a method", toAllowedId(request.id));
-	if (request.id !== void 0 && request.id !== null && typeof request.id !== "string" && typeof request.id !== "number") throw new ProtocolFailure(-32600, "an id is a string, a number, or null", null);
-	return request;
-}
-function toAllowedId(id) {
-	return typeof id === "string" || typeof id === "number" ? id : null;
-}
-function toErrorResponse(id, code, message) {
-	return {
-		jsonrpc: "2.0",
-		id,
-		error: {
-			code,
-			message
-		}
-	};
-}
-/** toRequestId reads the id of a line that could not be answered, so a client is not left waiting. */
-function toRequestId(line) {
-	try {
-		return toAllowedId(JSON.parse(line).id);
-	} catch {
-		return null;
-	}
-}
-/** write puts a reply on stdout, and stops quietly when the client has gone. */
-function write(text) {
-	try {
-		process.stdout.write(text);
-	} catch {}
-}
-//#endregion
-//#region src/command/mcp.ts
-const mcpCommand = defineCommand({
-	name: "mcp",
-	summary: "Serve this CLI to an agent over the Model Context Protocol",
-	description: "Speaks the Model Context Protocol on standard input and output. It offers one tool, because every tool an agent is told about occupies its context for the whole session, and serves the commands as resources the agent reads only when it needs them.",
-	arguments: [],
-	flags: [{
-		name: "json",
-		description: "Accepted for consistency, and ignored, because the protocol decides the output",
-		schema: z.boolean()
-	}],
-	examples: [{
-		description: "Register with an agent",
-		command: "hardfin mcp"
-	}, {
-		description: "Add it to Claude Code",
-		command: "claude mcp add hardfin -- hardfin mcp"
-	}],
-	run: runMcp
-});
-async function runMcp(input) {
-	await serve(input.commands);
-	return ExitCode.OK;
-}
-//#endregion
-//#region src/command/operation.ts
-/**
-* toEnum takes a value in any case, as the API does, and answers the spelling the document
-* lists, which is what a response always uses.
-*/
-function toEnum(values) {
-	return z.string().transform((value) => values.find((allowed) => allowed.toLowerCase() === value.toLowerCase()) ?? value).pipe(z.enum(values));
-}
-const UNSET_FLAG = {
-	name: "unset",
-	description: "A field to clear, named as its flag is, repeatable",
-	valueName: "field",
-	repeatable: true,
-	schema: z.array(z.string())
-};
-const INPUT_FLAG = {
-	name: "input",
-	description: "A file holding the JSON request body, or - for standard input. A flag given as well replaces its field",
-	valueName: "path",
-	schema: z.string()
-};
-const FILE_FLAG = {
-	name: "file",
-	description: "The file to upload",
-	valueName: "path",
-	schema: z.string()
-};
-const OUTPUT_FLAG = {
-	name: "output",
-	description: "Where to write the file, or - for standard output",
-	valueName: "path",
-	schema: z.string()
-};
-const JSON_FLAG = {
-	name: "json",
-	description: "Print machine-readable output, which is the default when stdout is not a terminal",
-	schema: z.boolean()
-};
-/** defineOperation turns one endpoint into the command that calls it. */
-function defineOperation(operation) {
-	const flags = [
-		...operation.queryFlags,
-		...operation.bodyFlags,
-		...operation.bodyFlags.some((flag) => flag.nullable) ? [UNSET_FLAG] : [],
-		...operation.bodyFlags.length > 0 ? [INPUT_FLAG] : [],
-		...operation.upload ? [...operation.upload.fields, FILE_FLAG] : [],
-		...operation.downloads ? [OUTPUT_FLAG] : [],
-		JSON_FLAG
-	];
-	return {
-		name: operation.name,
-		summary: operation.summary,
-		description: operation.description ?? operation.summary,
-		arguments: operation.pathParameters,
-		flags,
-		examples: operation.example ? [{
-			description: operation.summary,
-			command: operation.example
-		}] : [],
-		endpoint: {
-			method: operation.method,
-			path: operation.path
-		},
-		run: (input) => runOperation(operation, input)
-	};
-}
-async function runOperation(operation, input) {
-	const path = toPath(operation, input.args);
-	if (path === void 0) {
-		writeFailure("invalid_arguments", `this command takes ${operation.pathParameters.length} argument(s)`, input.isJSON);
-		return ExitCode.USAGE;
-	}
-	const given = toGivenBody(input.flags["input"]);
-	if (given instanceof InputFailure) {
-		writeFailure("invalid_input", given.message, input.isJSON);
-		return ExitCode.USAGE;
-	}
-	const missing = operation.bodyFlags.concat(operation.upload?.fields ?? []).filter((flag) => flag.required && input.flags[toOptionKey(flag.name)] === void 0 && !hasPath(given, flag.jsonPath));
-	if (missing.length > 0) {
-		writeFailure("missing_flag", `this command needs ${missing.map((flag) => `--${flag.name}`).join(", ")}`, input.isJSON);
-		return ExitCode.USAGE;
-	}
-	const body = toBody(operation, input.flags, given);
-	if (body instanceof Error) {
-		writeFailure("invalid_flag", body.message, input.isJSON);
-		return ExitCode.USAGE;
-	}
-	if (operation.bodyFlags.length > 0 && body === void 0) {
-		writeFailure("empty_request", `this command changes nothing unless a flag is given, such as ${operation.bodyFlags.slice(0, 3).map((flag) => `--${flag.name}`).join(", ")}. Run it with --help for the rest`, input.isJSON);
-		return ExitCode.USAGE;
-	}
-	let form;
-	if (operation.upload) {
-		const built = await toForm(operation.upload, input.flags);
-		if (built instanceof Error) {
-			writeFailure("invalid_input", built.message, input.isJSON);
-			return ExitCode.USAGE;
-		}
-		form = built;
-	}
+/** toAnswer replies to one line, and never rejects, because a rejection ends the server. */
+async function toAnswer(line, commands, run) {
+	let response;
+	let failure;
 	try {
-		const envelope = await request$1({
-			apiUrl: input.resolved.settings.apiUrl,
-			credential: await toRequestCredential(input.resolved.settings, input.resolved.sources),
-			method: operation.method,
-			path,
-			query: toQuery(operation, input.flags),
-			body,
-			form,
-			downloads: operation.downloads
-		});
-		if (operation.downloads) return toWritten(envelope.data, input);
-		writeData(envelope.data);
-		return ExitCode.OK;
+		response = await toResponse(toRequest(line), commands, run);
 	} catch (error) {
-		if (error instanceof NoCredential) {
-			writeFailure("not_signed_in", error.message, input.isJSON);
-			return ExitCode.NOT_AUTHENTICATED;
-		}
-		if (error instanceof RequestFailure) {
-			writeFailure(toStatusCode(error.status), error.message, input.isJSON, error.errors, error.requestId, error.status);
-			return error.status === 401 ? ExitCode.NOT_AUTHENTICATED : ExitCode.ERROR;
-		}
-		throw error;
+		response = error instanceof ProtocolFailure ? toErrorResponse(error.id, error.code, error.message) : toErrorResponse(toRequestId(line), -32603, error instanceof Error ? error.message : String(error));
+		failure = error instanceof ProtocolFailure ? void 0 : error;
 	}
-}
-/**
-* toWritten puts a downloaded file where it was asked for. A terminal is never written to,
-* because a person would otherwise have their session filled with a file's bytes.
-*/
-function toWritten(download, input) {
-	const asked = input.flags["output"];
-	const path = typeof asked === "string" ? asked : download.fileName ?? "-";
-	if (path === "-") {
-		if (process.stdout.isTTY) {
-			writeFailure("output_required", "this answer is a file, so name where to write it with --output, or send it on with a pipe", input.isJSON);
-			return ExitCode.USAGE;
+	if (response) write(`${JSON.stringify(response)}\n`);
+	if (failure !== void 0) await report(failure, {
+		level: "error",
+		mechanism: "mcp.request",
+		mode: "mcp",
+		invocation: {
+			command: "mcp",
+			flags: []
 		}
-		process.stdout.write(download.bytes);
-		return ExitCode.OK;
-	}
-	writeFileSync(path, download.bytes);
-	writeData({
-		written: path,
-		bytes: download.bytes.length,
-		contentType: download.contentType
 	});
-	return ExitCode.OK;
-}
-/** toPath fills the path template from the positional arguments, in order. */
-function toPath(operation, args) {
-	if (args.length !== operation.pathParameters.length) return;
-	let path = operation.path;
-	for (const [index, parameter] of operation.pathParameters.entries()) path = path.replace(`{${parameter.name}}`, encodeURIComponent(args[index] ?? ""));
-	return path;
-}
-/** toQuery carries only the flags this invocation actually set. */
-function toQuery(operation, flags) {
-	const query = new URLSearchParams();
-	for (const flag of operation.queryFlags) {
-		const value = flags[toOptionKey(flag.name)];
-		if (value === void 0) continue;
-		const parsed = flag.schema.safeParse(value);
-		const carried = parsed.success ? parsed.data : value;
-		for (const entry of Array.isArray(carried) ? carried : [carried]) query.append(flag.queryName, toText(entry));
-	}
-	return query;
-}
-/** toOptionKey names the parsed flag, which the parser reports in camel case. */
-function toOptionKey(name) {
-	return name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }
-/** toForm builds the file part and its fields, which an upload endpoint takes. */
-async function toForm(upload, flags) {
-	const path = flags["file"];
-	if (typeof path !== "string") return /* @__PURE__ */ new Error("this command needs --file, the file to upload");
-	const form = new FormData();
+/** toRequest reads one line, refusing what the protocol does not allow to be a request. */
+function toRequest(line) {
+	let parsed;
 	try {
-		form.append(upload.filePart, await openAsBlob(path), basename(path));
+		parsed = JSON.parse(line);
 	} catch {
-		return /* @__PURE__ */ new Error(`${path} cannot be read`);
-	}
-	for (const field of upload.fields) {
-		const value = flags[toOptionKey(field.name)];
-		if (value !== void 0) {
-			const parsed = field.schema.safeParse(value);
-			form.append(field.jsonPath[0] ?? field.name, toText(parsed.success ? parsed.data : value));
-		}
+		throw new ProtocolFailure(-32700, "this line is not JSON", null);
 	}
-	return form;
-}
-/** toGivenBody reads the --input body, which a generated command takes only as a JSON object. */
-function toGivenBody(source) {
-	if (typeof source !== "string") return;
-	const read = toJSONInput(source);
-	if (read instanceof InputFailure) return read;
-	if (typeof read !== "object" || read === null || Array.isArray(read)) return new InputFailure(`the body in ${source === "-" ? "standard input" : source} must be a JSON object, such as {"name": "Acme"}`);
-	return read;
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new ProtocolFailure(-32600, "a request is a JSON object, and this server takes one per line", null);
+	const request = parsed;
+	if (typeof request.method !== "string") throw new ProtocolFailure(-32600, "a request names a method", toAllowedId(request.id));
+	if (request.id !== void 0 && request.id !== null && typeof request.id !== "string" && typeof request.id !== "number") throw new ProtocolFailure(-32600, "an id is a string, a number, or null", null);
+	return request;
 }
-/** hasPath reports whether a body already holds a value at a field's path. */
-function hasPath(body, path) {
-	let holder = body;
-	for (const name of path) {
-		if (typeof holder !== "object" || holder === null || !(name in holder)) return false;
-		holder = holder[name];
-	}
-	return true;
+function toAllowedId(id) {
+	return typeof id === "string" || typeof id === "number" ? id : null;
 }
-/** toBody builds the request body from the --input body and the flags, a flag winning over its field. */
-function toBody(operation, flags, given) {
-	const body = given ? structuredClone(given) : {};
-	let hasField = given !== void 0;
-	for (const flag of operation.bodyFlags) {
-		const value = flags[toOptionKey(flag.name)];
-		if (value === void 0) continue;
-		if (flag.element) {
-			const elements = toElements(flag, Array.isArray(value) ? value.map(toText) : [toText(value)]);
-			if (elements instanceof Error) return elements;
-			set(body, flag.jsonPath, elements);
-			hasField = true;
-			continue;
+function toErrorResponse(id, code, message) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code,
+			message
 		}
-		const parsed = flag.schema.safeParse(value);
-		set(body, flag.jsonPath, parsed.success ? parsed.data : value);
-		hasField = true;
-	}
-	const cleared = toCleared(operation, flags, body);
-	if (cleared instanceof Error) return cleared;
-	return hasField || cleared ? body : void 0;
+	};
 }
-/** toCleared sends null for each field named by --unset, which is how a field is cleared. */
-function toCleared(operation, flags, body) {
-	const named = flags["unset"];
-	const names = Array.isArray(named) ? named.map(toText) : named === void 0 ? [] : [toText(named)];
-	for (const name of names) {
-		const flag = operation.bodyFlags.find((entry) => entry.name === name.replace(/^--/, ""));
-		if (!flag) return /* @__PURE__ */ new Error(`--unset names no field called ${name}`);
-		if (!flag.nullable) return /* @__PURE__ */ new Error(`--${flag.name} cannot be cleared, because the API does not accept null for it`);
-		set(body, flag.jsonPath, null);
+/** toRequestId reads the id of a line that could not be answered, so a client is not left waiting. */
+function toRequestId(line) {
+	try {
+		return toAllowedId(JSON.parse(line).id);
+	} catch {
+		return null;
 	}
-	return names.length > 0;
 }
-/** toElements reads the key=value pairs a repeated flag carries for one array element. */
-function toElements(flag, values) {
-	const elements = [];
-	for (const value of values) {
-		const element = {};
-		for (const pair of value.split(",")) {
-			const split = pair.indexOf("=");
-			if (split < 1) return /* @__PURE__ */ new Error(`--${flag.name} takes ${flag.element?.join("=, ") ?? ""}=, such as --${flag.name} ${flag.element?.[0] ?? "field"}=value. A value cannot contain a comma`);
-			const key = pair.slice(0, split).trim();
-			if (flag.element && !flag.element.includes(key)) return /* @__PURE__ */ new Error(`--${flag.name} has no field ${key}. It takes ${flag.element.join(", ")}`);
-			if (key in element) return /* @__PURE__ */ new Error(`--${flag.name} names ${key} twice in one element, so which one it takes is not clear`);
-			const value = pair.slice(split + 1).trim();
-			if (flag.elementUuids?.includes(key) && !z.uuid().safeParse(value).success) return /* @__PURE__ */ new Error(`--${flag.name} needs a UUID for ${key}, such as 3f2a9c1e-5b7d-4e8a-9c21-7d4e5f6a8b90, and ${value || "nothing"} is not one`);
-			element[key] = value;
-		}
-		elements.push(element);
-	}
-	return elements;
+/** write puts a reply on stdout, and stops quietly when the client has gone. */
+function write(text) {
+	try {
+		process.stdout.write(text);
+	} catch {}
 }
-/** set writes a value at its path, building the objects a nested field needs. */
-function set(body, path, value) {
-	let holder = body;
-	for (const name of path.slice(0, -1)) {
-		holder[name] = holder[name] ?? {};
-		holder = holder[name];
-	}
-	holder[path[path.length - 1] ?? ""] = value;
+//#endregion
+//#region src/command/mcp.ts
+const mcpCommand = defineCommand({
+	name: "mcp",
+	summary: "Serve this CLI to an agent over the Model Context Protocol",
+	description: "Speaks the Model Context Protocol on standard input and output. It offers one tool, because every tool an agent is told about occupies its context for the whole session, and serves the commands as resources the agent reads only when it needs them.",
+	arguments: [],
+	flags: [{
+		name: "json",
+		description: "Accepted for consistency, and ignored, because the protocol decides the output",
+		schema: z.boolean()
+	}],
+	examples: [{
+		description: "Register with an agent",
+		command: "hardfin mcp"
+	}, {
+		description: "Add it to Claude Code",
+		command: "claude mcp add hardfin -- hardfin mcp"
+	}],
+	run: runMcp
+});
+async function runMcp(input) {
+	await serve(input.commands);
+	return ExitCode.OK;
 }
 //#endregion
 //#region src/command/commands.ts
@@ -6417,43 +6470,9 @@ function toRejectedFlag(command, flags) {
 //#region src/cli/program.ts
 /** toCli builds the parser from the registry, which is what every surface reads. */
 function toCli(entries = commands) {
-	const program = new Command();
-	program.name("hardfin").description("Call the Hardfin API from a terminal or an agent").version(version$1, "-v, --version").enablePositionalOptions();
-	toQuietParser(program);
-	for (const flag of GLOBAL_FLAGS) program.option(`--${flag.name} <${flag.valueName}>`, flag.description);
-	for (const command of entries) program.addCommand(toProgram(program, command), { hidden: command.hidden });
-	return program;
-}
-/** toProgram wires one registry command into the parser. */
-function toProgram(root, command) {
-	const program = new Command(command.name).summary(command.summary).description(command.description ?? command.summary);
-	toQuietParser(program);
-	for (const argument of command.arguments) {
-		const name = argument.variadic ? `${argument.name}...` : argument.name;
-		program.argument(argument.required ? `<${name}>` : `[${name}]`, argument.description);
-	}
-	for (const flag of command.flags) {
-		const short = flag.short ? `-${flag.short}, ` : "";
-		const value = flag.valueName ? ` <${flag.valueName}>` : "";
-		const option = new Option(`${short}--${flag.name}${value}`, flag.description);
-		if (flag.negatable) program.addOption(new Option(`--no-${flag.name}`, `${flag.description}, turned off`));
-		if (flag.repeatable) option.argParser(collect);
-		if (flag.defaultValue !== void 0) option.default(flag.defaultValue);
-		program.addOption(option);
-	}
-	for (const example of command.examples) program.addHelpText("after", `\n${example.description}:\n  $ ${example.command}`);
-	for (const subcommand of command.subcommands ?? []) program.addCommand(toProgram(root, subcommand), { hidden: subcommand.hidden });
-	if (!command.run) return program;
-	program.action(async (...parsed) => {
-		const flags = parsed[parsed.length - 2] ?? {};
-		const args = parsed.slice(0, parsed.length - 2).flatMap(toArgumentList);
-		process.exitCode = await toExitCode(root, command, args, flags);
+	return toParser(entries, async ({ command, args, flags, globals }) => {
+		process.exitCode = await toExitCode(globals, command, args, flags);
 	});
-	return program;
-}
-/** toQuietParser has the parser hand back its mistakes, so they are answered like any other failure. */
-function toQuietParser(program) {
-	program.exitOverride().configureOutput({ outputError: () => void 0 });
 }
 /** The parser's codes for a run that only showed help or the version, which is not a failure. */
 const SHOWN = /* @__PURE__ */ new Set([
@@ -6481,7 +6500,7 @@ function toParseCode(code) {
 		default: return "invalid_arguments";
 	}
 }
-async function toExitCode(root, command, args, flags) {
+async function toExitCode(globals, command, args, flags) {
 	const isJSON = isJSONOutput(flags);
 	const rejected = toRejectedFlag(command, flags);
 	if (rejected) {
@@ -6491,9 +6510,9 @@ async function toExitCode(root, command, args, flags) {
 	let resolved;
 	try {
 		resolved = toSettings({
-			apiUrl: root.opts()["apiUrl"],
-			apiKey: root.opts()["apiKey"],
-			issuerUrl: root.opts()["issuerUrl"]
+			apiUrl: globals["apiUrl"],
+			apiKey: globals["apiKey"],
+			issuerUrl: globals["issuerUrl"]
 		});
 		return await command.run?.({
 			args,
@@ -6512,13 +6531,6 @@ async function toExitCode(root, command, args, flags) {
 		return error instanceof ConfigFailure ? ExitCode.USAGE : ExitCode.ERROR;
 	}
 }
-function toArgumentList(value) {
-	if (Array.isArray(value)) return value.map(String);
-	return value === void 0 ? [] : [toText(value)];
-}
-function collect(value, previous) {
-	return [...previous ?? [], value];
-}
 /** toReported reports a defect, and tells a person at a terminal that it was reported. */
 async function toReported(error, isJSON, resolved, level = "error") {
 	const invocation = toInvocation(commands, process.argv.slice(2));
@@ -6534,5 +6546,5 @@ async function toReported(error, isJSON, resolved, level = "error") {
 //#endregion
 export { toCli, toParseExitCode, toReported, wasReportAttempted };
 
-//# sourceMappingURL=program-CjKwnPeY.js.map
-//# debugId=5a591d32-0d31-5357-b447-e33420753351
+//# sourceMappingURL=program-C38xnnim.js.map
+//# debugId=23617f68-b6d8-5249-bca7-f5585fdb94f2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hardfin/cli",
-    "version": "0.1.0",
+    "version": "0.1.1-dev.40",
     "description": "Command line interface for the Hardfin API",
     "license": "Apache-2.0",
     "author": "Hardfin, Inc.",