@tikoci/centrs 0.1.0 → 0.1.2

package/src/cli/common.ts

@@ -6,6 +6,8 @@
  * together.
  */
 
+import { CentrsError } from "../errors.ts";
+
 export interface CliCommandOption {
 	flag: string;
 	valueName?: string;
@@ -31,6 +33,68 @@ export function expectValue(
 	return value;
 }
 
+/** Flatten an option's `flag` field ("-X / --method") into individual `-`/`--` tokens. */
+export function knownFlags(options: readonly CliCommandOption[]): string[] {
+	const flags: string[] = [];
+	for (const option of options) {
+		for (const token of option.flag.split("/")) {
+			const trimmed = token.trim();
+			if (trimmed.startsWith("-")) {
+				flags.push(trimmed);
+			}
+		}
+	}
+	return flags;
+}
+
+function editDistance(a: string, b: string): number {
+	let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+	for (let i = 1; i <= a.length; i += 1) {
+		const curr = [i];
+		for (let j = 1; j <= b.length; j += 1) {
+			const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+			curr[j] = Math.min(
+				(curr[j - 1] ?? 0) + 1,
+				(prev[j] ?? 0) + 1,
+				(prev[j - 1] ?? 0) + cost,
+			);
+		}
+		prev = curr;
+	}
+	return prev[b.length] ?? 0;
+}
+
+/** Closest known flags to `arg` (Levenshtein ≤ 2 — tight enough to avoid noise), nearest first, capped at 3. */
+export function closestFlags(arg: string, flags: readonly string[]): string[] {
+	return [...new Set(flags)]
+		.map((flag) => ({ flag, distance: editDistance(arg, flag) }))
+		.filter(({ distance }) => distance <= 2)
+		.sort((left, right) => left.distance - right.distance)
+		.slice(0, 3)
+		.map(({ flag }) => flag);
+}
+
+/**
+ * Actionable "unknown flag" error: lists the closest canonical matches (and
+ * aliases) so humans and agents can recover (commands/AGENTS.md → "Did you
+ * mean?"). Shared seam — parsers pass their own `command` + option metadata.
+ */
+export function unknownFlagError(
+	command: string,
+	arg: string,
+	options: readonly CliCommandOption[],
+): CentrsError {
+	const suggestions = closestFlags(arg, knownFlags(options));
+	const hint =
+		suggestions.length > 0 ? ` Did you mean ${suggestions.join(", ")}?` : "";
+	return new CentrsError({
+		code: "input/invalid-command",
+		summary: `Unknown ${command} flag: ${arg}.${hint}`,
+		remediation: `Run \`centrs ${command} --help\` to see the supported flags${suggestions.length > 0 ? " and their aliases" : ""}.`,
+		context: { flag: arg, suggestions },
+	});
+}
+
 export function renderCommandHelp(
 	describe: string,
 	command: CliCommandMetadata,

package/src/cli/discover.ts

@@ -6,10 +6,12 @@
  */
 
 import {
+	DISCOVER_DEFAULT_TIMEOUT_MS,
 	type DiscoverOptions,
 	type DiscoverOutputFormat,
 	discover,
 	discoverOutputFormats,
+	MNDP_PORT,
 	renderDiscoverEnvelope,
 } from "../discover.ts";
 import { asCentrsError, formatCentrsErrorText } from "../errors.ts";
@@ -142,6 +144,29 @@ function parseDiscoverCliArgs(args: readonly string[]): DiscoverCliArgs {
 	return parsed;
 }
 
+/**
+ * A 15s passive listen looks like a hang on an interactive terminal, so print a
+ * one-line progress note to **stderr** for the human-facing text format on a
+ * TTY. Skipped when piped/redirected (not a TTY) and for the `--format
+ * json|yaml` structured modes, so machine consumers never see it. stderr is the
+ * sanctioned channel for discover scan progress (`docs/CONSTITUTION.md` → Result
+ * envelope).
+ */
+function emitDiscoverProgress(
+	options: DiscoverOptions,
+	format: DiscoverOutputFormat | undefined,
+): void {
+	if (format === "json" || format === "yaml" || !process.stderr.isTTY) {
+		return;
+	}
+	const windowMs = options.timeoutMs ?? DISCOVER_DEFAULT_TIMEOUT_MS;
+	const port = options.port ?? MNDP_PORT;
+	const hint = options.save ? "" : " (add --save to populate the CDB)";
+	process.stderr.write(
+		`Listening for MNDP neighbors for ${Math.round(windowMs / 1000)}s on UDP ${port}…${hint}\n`,
+	);
+}
+
 export async function runDiscoverCli(args: readonly string[]): Promise<number> {
 	let parsed: DiscoverCliArgs | undefined;
 	try {
@@ -160,6 +185,7 @@ export async function runDiscoverCli(args: readonly string[]): Promise<number> {
 			cdbPassword: parsed.cdbPassword,
 			env: Bun.env,
 		};
+		emitDiscoverProgress(options, parsed.format);
 		const envelope = await discover(options);
 		const format = parsed.format ?? "text";
 		const rendered = renderDiscoverEnvelope(envelope, format);

package/src/cli/execute.ts

@@ -13,6 +13,14 @@ import {
 	expectValue,
 	renderCommandHelp,
 } from "./common.ts";
+import {
+	buildTargetSelectionTips,
+	cdbFileFromArgs,
+	formatTipsText,
+	isMissingTargetError,
+	missingTargetError,
+	withTips,
+} from "./missing-target.ts";
 
 export const executeCommand: CliCommandMetadata = {
 	name: "execute",
@@ -241,6 +249,18 @@ export async function runExecuteCli(args: readonly string[]): Promise<number> {
 			console.log(renderCommandHelp(describeCentrs(), executeCommand));
 			return 0;
 		}
+		// No positional at all: lead with the missing-target guidance (CDB picker /
+		// discover) rather than the missing-command error — there is nothing to run
+		// without a device. A lone positional is treated as the target, so the
+		// "requires a command" path still fires for `execute <target>`.
+		if (!parsed.targetInput) {
+			throw missingTargetError({
+				command: "execute",
+				summary: "`centrs execute` requires a <target> and a RouterOS command.",
+				remediation:
+					'Pass the router host/identity then the command, e.g. `centrs execute 192.0.2.10 "/system/resource/print"`.',
+			});
+		}
 
 		const envelope = await executeEnvelope(parsed);
 		const resolvedFormat =
@@ -264,10 +284,16 @@ export async function runExecuteCli(args: readonly string[]): Promise<number> {
 		// Parse/usage errors land here too: surface them through the same typed
 		// envelope as every other runner (no raw message, no exit code 2).
 		const format = inferExecuteFormat(args, parsed);
+		const tips = isMissingTargetError(error)
+			? await buildTargetSelectionTips({
+					cdbFile: parsed?.cdbFile ?? cdbFileFromArgs(args),
+					env: Bun.env,
+				})
+			: [];
 		if (format === "json" || format === "yaml") {
-			const envelope = buildExecuteErrorEnvelope(
-				parsed ?? { command: "" },
-				error,
+			const envelope = withTips(
+				buildExecuteErrorEnvelope(parsed ?? { command: "" }, error),
+				tips,
 			);
 			console.error(
 				renderExecuteEnvelope(envelope, format, {
@@ -284,7 +310,7 @@ export async function runExecuteCli(args: readonly string[]): Promise<number> {
 							"Use `centrs execute --help` to inspect the supported command shape and flags.",
 					}),
 					{ verbose: parsed?.verbose ?? args.includes("--verbose") },
-				),
+				) + formatTipsText(tips),
 			);
 		}
 		return 1;

package/src/cli/missing-target.ts

@@ -0,0 +1,171 @@
+/**
+ * Shared "no `<router>` target" guidance for the CLI surfaces.
+ *
+ * Every command that takes a `<router>` (terminal, execute, retrieve, transfer,
+ * btest client) raises the same `input/invalid-command` error when the target is
+ * missing, tagged with `context.missingTarget`. Each runner then calls
+ * {@link buildTargetSelectionTips} to turn that bare usage error into actionable
+ * advice: list a few saved CDB devices to pass as `<router>`, or — when the
+ * registry is empty — point at `centrs discover --save`. Tips ride the envelope's
+ * `tips` channel (`docs/CONSTITUTION.md` → Result envelope); this module also
+ * renders them for the **text** error path, which `formatCentrsErrorText` does
+ * not surface on its own.
+ */
+
+import { buildTip, type Tip } from "../core/envelope.ts";
+import { defaultCdbPath, loadCdb } from "../devices.ts";
+import { CentrsError } from "../errors.ts";
+import { DEFAULT_RECORD_TARGET, identityFromComment } from "../resolver/cdb.ts";
+
+/** Cap on how many saved devices a single tip names before "(+N more)". */
+const MAX_LISTED_DEVICES = 8;
+
+export interface MissingTargetErrorInit {
+	command: string;
+	summary: string;
+	remediation: string;
+}
+
+/**
+ * The canonical "missing `<router>`" usage error. The `context.missingTarget`
+ * flag is the marker {@link isMissingTargetError} keys on so a runner knows to
+ * attach {@link buildTargetSelectionTips} output.
+ */
+export function missingTargetError(init: MissingTargetErrorInit): CentrsError {
+	return new CentrsError({
+		code: "input/invalid-command",
+		summary: init.summary,
+		remediation: init.remediation,
+		context: { missingTarget: true, command: init.command },
+	});
+}
+
+/** True for an error raised by {@link missingTargetError} (or one tagged like it). */
+export function isMissingTargetError(error: unknown): boolean {
+	return (
+		error instanceof CentrsError && error.context?.["missingTarget"] === true
+	);
+}
+
+export interface CdbInputs {
+	cdbFile?: string;
+	env?: Record<string, string | undefined>;
+}
+
+/**
+ * Pull the `--cdb-file` path out of raw args. Used by catch paths where the
+ * request never finished parsing (the missing-target throw happens mid-parse),
+ * so the request object is unavailable but the flag may still be on the command
+ * line. The CDB *password* is deliberately not extracted: a credential must
+ * never flow into the (logged) tip path, and the tips read only an unencrypted
+ * registry — an encrypted CDB falls back to generic guidance.
+ */
+export function cdbFileFromArgs(args: readonly string[]): string | undefined {
+	for (let index = 0; index < args.length; index += 1) {
+		if (args[index] === "--cdb-file") {
+			if (index + 1 >= args.length) return undefined;
+			const value = args[index + 1] as string; // bounds-checked above
+			if (value.startsWith("--")) return undefined;
+			return value;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Best-effort: inspect the CDB and turn "no `<router>`" into actionable tips —
+ * a list of saved targets when the registry has any, otherwise a pointer to
+ * `discover --save`. Never throws: an unreadable/encrypted CDB falls back to
+ * generic guidance, and a missing default CDB is reported as an empty registry
+ * (no file is created as a side effect of a usage error). The CDB password is
+ * intentionally never read here, so no credential can reach the rendered tip.
+ */
+export async function buildTargetSelectionTips(
+	inputs: CdbInputs,
+): Promise<Tip[]> {
+	const env = inputs.env ?? {};
+	const explicitCdb =
+		inputs.cdbFile !== undefined || env["CENTRS_CDB_FILE"] !== undefined;
+	if (!explicitCdb && !(await Bun.file(defaultCdbPath(env)).exists())) {
+		return [emptyRegistryTip()];
+	}
+
+	let entries: readonly { target: string; comment: string }[];
+	try {
+		const cdb = await loadCdb({
+			cdbFile: inputs.cdbFile,
+			env,
+		});
+		entries = cdb.entries.filter(
+			(entry) =>
+				entry.target.length > 0 && entry.target !== DEFAULT_RECORD_TARGET,
+		);
+	} catch {
+		return [unreadableRegistryTip()];
+	}
+
+	if (entries.length === 0) {
+		return [emptyRegistryTip()];
+	}
+
+	const handles = entries
+		.slice(0, MAX_LISTED_DEVICES)
+		.map((entry) => identityFromComment(entry.comment, entry.target));
+	const extra =
+		entries.length > MAX_LISTED_DEVICES
+			? ` (+${entries.length - MAX_LISTED_DEVICES} more)`
+			: "";
+	return [
+		buildTip(
+			"tip/select-target",
+			`Pass one of your ${entries.length} saved device(s) as <router>: ${handles.join(", ")}${extra}.`,
+			"Run `centrs devices list` for every saved target; <router> also resolves by identity=, mac=, or ip=.",
+		),
+	];
+}
+
+function emptyRegistryTip(): Tip {
+	return buildTip(
+		"tip/no-devices",
+		"No devices are saved in the CDB yet.",
+		"Run `centrs discover --save` to find RouterOS neighbors on the LAN and add them, then pass one as <router> (or `centrs devices add <target> --user … --password …`).",
+	);
+}
+
+function unreadableRegistryTip(): Tip {
+	return buildTip(
+		"tip/select-target",
+		"Could not read the CDB to list saved devices (it may be encrypted — pass --cdb-password).",
+		"Run `centrs devices list` to see saved targets, or `centrs discover --save` to find and add neighbors on the LAN.",
+	);
+}
+
+/**
+ * Render tips for the **text** error path (mirrors the `devices` "Tips:"
+ * footer). Returns "" for an empty list so callers can append unconditionally.
+ */
+export function formatTipsText(tips: readonly Tip[]): string {
+	if (tips.length === 0) {
+		return "";
+	}
+	const lines = ["", "Tips:"];
+	for (const tip of tips) {
+		lines.push(`  - [${tip.code}] ${tip.message}`);
+		if (tip.fix) {
+			lines.push(`    fix: ${tip.fix}`);
+		}
+	}
+	return lines.join("\n");
+}
+
+/**
+ * Return a copy of an envelope with `tips` attached (no-op for an empty list).
+ * The `as E` keeps the call site's envelope type when an error envelope declares
+ * `tips: []` (an empty tuple) — we only ever widen it to a populated list.
+ */
+export function withTips<E extends { tips: readonly Tip[] }>(
+	envelope: E,
+	tips: readonly Tip[],
+): E {
+	return tips.length > 0 ? ({ ...envelope, tips } as E) : envelope;
+}

package/src/cli/retrieve.ts

@@ -22,6 +22,14 @@ import {
 	expectValue,
 	renderCommandHelp,
 } from "./common.ts";
+import {
+	buildTargetSelectionTips,
+	cdbFileFromArgs,
+	formatTipsText,
+	isMissingTargetError,
+	missingTargetError,
+	withTips,
+} from "./missing-target.ts";
 
 export const retrieveCommand: CliCommandMetadata = {
 	name: "retrieve",
@@ -171,6 +179,12 @@ export async function runRetrieveCli(args: readonly string[]): Promise<number> {
 		return 0;
 	} catch (error) {
 		const format = inferRequestedFormat(args, request);
+		const tips = isMissingTargetError(error)
+			? await buildTargetSelectionTips({
+					cdbFile: request?.cdbFile ?? cdbFileFromArgs(args),
+					env: Bun.env,
+				})
+			: [];
 		if (format === "json" || format === "yaml") {
 			if (request?.group) {
 				const envelope = buildRetrieveFanoutErrorEnvelope(request, error);
@@ -180,9 +194,14 @@ export async function runRetrieveCli(args: readonly string[]): Promise<number> {
 					}),
 				);
 			} else {
-				const envelope = buildRetrieveErrorEnvelope(
-					request ?? fallbackRequestFromArgs(args),
-					error,
+				// When parsing failed before a request existed, build the error
+				// envelope from an empty request rather than reconstructing positionals
+				// from raw args — a credential value (e.g. the token after
+				// `--password` / `--cdb-password`) would otherwise be echoed as
+				// `meta.target.input`.
+				const envelope = withTips(
+					buildRetrieveErrorEnvelope(request ?? { path: "" }, error),
+					tips,
 				);
 				console.error(
 					renderRetrieveEnvelope(envelope, format, {
@@ -202,7 +221,7 @@ export async function runRetrieveCli(args: readonly string[]): Promise<number> {
 					{
 						verbose: request?.verbose ?? args.includes("--verbose"),
 					},
-				),
+				) + formatTipsText(tips),
 			);
 		}
 		return 1;
@@ -341,9 +360,17 @@ function parseRetrieveCliArgs(args: readonly string[]): RetrieveRequest & {
 		return request;
 	}
 
+	if (positional.length === 0) {
+		throw missingTargetError({
+			command: "retrieve",
+			summary: "`centrs retrieve` requires a <target> and a <routeros-path>.",
+			remediation:
+				"Pass the router host/identity then the RouterOS path, e.g. `centrs retrieve 192.0.2.10 /system/resource`.",
+		});
+	}
 	if (positional.length < 2) {
 		throw new Error(
-			"`centrs retrieve` requires both <target> and <routeros-path>.",
+			"`centrs retrieve` requires a <routeros-path> after the <target>.",
 		);
 	}
 
@@ -372,12 +399,3 @@ function inferRequestedFormat(
 	}
 	return "text";
 }
-
-function fallbackRequestFromArgs(args: readonly string[]): RetrieveRequest {
-	const positionals = args.filter((arg) => !arg.startsWith("-"));
-	return {
-		targetInput: positionals[0],
-		path: positionals[1] ?? "",
-		format: inferRequestedFormat(args),
-	};
-}

package/src/cli/terminal.ts

@@ -20,6 +20,14 @@ import {
 	expectValue,
 	renderCommandHelp,
 } from "./common.ts";
+import {
+	buildTargetSelectionTips,
+	cdbFileFromArgs,
+	formatTipsText,
+	isMissingTargetError,
+	missingTargetError,
+	withTips,
+} from "./missing-target.ts";
 
 export const terminalCommand: CliCommandMetadata = {
 	name: "terminal",
@@ -164,8 +172,14 @@ export async function runTerminalCli(args: readonly string[]): Promise<number> {
 		// error nor these renderers, so the alert is dismissed as a false positive
 		// repo-wide — see the matching dismissals on src/cli/{transfer,execute}.ts.
 		const format = inferRequestedFormat(args);
+		const tips = isMissingTargetError(error)
+			? await buildTargetSelectionTips({
+					cdbFile: request?.cdbFile ?? cdbFileFromArgs(args),
+					env: Bun.env,
+				})
+			: [];
 		if (format === "json" || format === "yaml") {
-			const envelope = buildTerminalErrorEnvelope(error);
+			const envelope = withTips(buildTerminalErrorEnvelope(error), tips);
 			console.error(
 				format === "yaml" ? toYaml(envelope) : JSON.stringify(envelope),
 			);
@@ -179,7 +193,7 @@ export async function runTerminalCli(args: readonly string[]): Promise<number> {
 							"Use `centrs terminal --help` for the supported command shape and flags.",
 					}),
 					{ verbose: args.includes("--verbose") },
-				),
+				) + formatTipsText(tips),
 			);
 		}
 		return 1;
@@ -272,8 +286,8 @@ function parseTerminalCliArgs(args: readonly string[]): ParsedTerminal {
 	}
 	const targetInput = positional[0];
 	if (!targetInput) {
-		throw asCentrsError(new Error("terminal requires a <router> target."), {
-			code: "input/invalid-command",
+		throw missingTargetError({
+			command: "terminal",
 			summary: "`centrs terminal` requires a <router> target.",
 			remediation:
 				"Pass the device MAC (or a CDB identity/ip) as the first argument; run `centrs terminal --help` for the shape.",

package/src/cli/transfer.ts

@@ -24,6 +24,14 @@ import {
 	expectValue,
 	renderCommandHelp,
 } from "./common.ts";
+import {
+	buildTargetSelectionTips,
+	cdbFileFromArgs,
+	formatTipsText,
+	isMissingTargetError,
+	missingTargetError,
+	withTips,
+} from "./missing-target.ts";
 
 /** Sub-verb aliases, resolved to canonical verbs silently (commands/AGENTS.md). */
 const VERB_ALIASES: Record<string, TransferVerb> = {
@@ -173,10 +181,19 @@ export async function runTransferCli(
 		// (CodeQL js/clear-text-logging).
 		const safeRequest = redactTransferRequest(request);
 		const format = inferRequestedFormat(args, safeRequest);
+		const tips = isMissingTargetError(error)
+			? await buildTargetSelectionTips({
+					cdbFile: safeRequest?.cdbFile ?? cdbFileFromArgs(args),
+					env: Bun.env,
+				})
+			: [];
 		if (format === "json" || format === "yaml") {
-			const envelope = buildTransferErrorEnvelope(
-				safeRequest ?? { verb: options.fixedVerb ?? "list" },
-				error,
+			const envelope = withTips(
+				buildTransferErrorEnvelope(
+					safeRequest ?? { verb: options.fixedVerb ?? "list" },
+					error,
+				),
+				tips,
 			);
 			console.error(
 				renderTransferEnvelope(envelope, format, {
@@ -193,7 +210,7 @@ export async function runTransferCli(
 							"Use `centrs transfer --help` to inspect the supported command shape and flags.",
 					}),
 					{ verbose: safeRequest?.verbose ?? args.includes("--verbose") },
-				),
+				) + formatTipsText(tips),
 			);
 		}
 		return 1;
@@ -367,13 +384,24 @@ function assemblePositionals(
 	} else {
 		targetInput = positional[0];
 		const rawVerb = positional[1];
-		if (!targetInput || !rawVerb) {
+		// A missing target gets the tagged missing-target error (CDB picker tip);
+		// a present target with no verb is a distinct "which verb?" usage error.
+		if (!targetInput) {
+			throw missingTargetError({
+				command: "transfer",
+				summary:
+					"`centrs transfer` requires a <router> target and a verb (upload|download|list|remove|mkdir|copy).",
+				remediation:
+					"Pass the target then a verb, e.g. `centrs transfer <router> list`; run `--help` for the full shape.",
+			});
+		}
+		if (!rawVerb) {
 			throw new CentrsError({
 				code: "input/invalid-command",
 				summary:
-					"`centrs transfer` requires <router> and a verb (upload|download|list|remove|mkdir|copy).",
+					"`centrs transfer` requires a verb after the <router> (upload|download|list|remove|mkdir|copy).",
 				remediation:
-					"Pass the target then a verb, e.g. `centrs transfer <router> list`; run `--help` for the full shape.",
+					"Pass a verb, e.g. `centrs transfer <router> list`; run `--help` for the full shape.",
 				context: { targetInput, verb: rawVerb },
 			});
 		}
@@ -382,8 +410,8 @@ function assemblePositionals(
 	}
 
 	if (!targetInput) {
-		throw new CentrsError({
-			code: "input/invalid-command",
+		throw missingTargetError({
+			command: "transfer",
 			summary: "`centrs transfer` requires a <router> target.",
 			remediation:
 				"Pass the router host/identity as the first argument; run `centrs transfer --help` for the command shape.",

package/src/cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 
+import { apiCommand, runApiCli } from "./cli/api.ts";
 import { btestCommand, runBtestCli } from "./cli/btest.ts";
 import { devicesCommand, runDevicesCli } from "./cli/devices.ts";
 import { discoverCommand, runDiscoverCli } from "./cli/discover.ts";
@@ -14,6 +15,7 @@ import { describeCentrs, plannedProtocols, plannedSurfaces } from "./index.ts";
 const commandSummaries: ReadonlyArray<{ name: string; summary: string }> = [
 	retrieveCommand,
 	executeCommand,
+	apiCommand,
 	transferCommand,
 	terminalCommand,
 	devicesCommand,
@@ -54,6 +56,9 @@ export async function runCli(
 		if (command === "execute") {
 			return await runExecuteCli(rest);
 		}
+		if (command === "api") {
+			return await runApiCli(rest);
+		}
 		if (command === "transfer") {
 			return await runTransferCli(rest);
 		}
@@ -80,6 +85,23 @@ export async function runCli(
 		if (command === "mcp") {
 			return await runMcpCli(rest);
 		}
+		// `stream` (and the `tail` shorthand) folded into `api --stream`.
+		if (command === "stream" || command === "tail") {
+			console.error(
+				formatCentrsErrorText(
+					asCentrsError(
+						new Error(`\`centrs ${command}\` has been folded into \`api\`.`),
+						{
+							code: "input/invalid-command",
+							summary: `\`centrs ${command}\` is no longer a command — open-ended follow is now \`api … --stream\`.`,
+							remediation:
+								"Use `centrs api <router> <endpoint> --stream` (native-api only), e.g. `centrs api edge1 ip/address --stream`.",
+						},
+					),
+				),
+			);
+			return 1;
+		}
 
 		console.error(
 			formatCentrsErrorText(

package/src/core/error-catalog.ts

@@ -218,6 +218,11 @@ export const errorCatalog: readonly ErrorCatalogEntry[] = [
 		summary:
 			"The RouterOS native API returned a !trap with no more specific mapping.",
 	},
+	{
+		code: "routeros/btest-connection-count-single-stream",
+		summary:
+			"Fewer TCP data connections were opened than --connection-count requested (e.g. authenticated multi-connection is not yet supported), so throughput will not scale to the full count.",
+	},
 	{
 		code: "routeros/btest-protocol",
 		summary: "A bandwidth-test (btest) packet could not be decoded.",
@@ -227,6 +232,11 @@ export const errorCatalog: readonly ErrorCatalogEntry[] = [
 		summary:
 			"The btest server refused a client because max-sessions is reached.",
 	},
+	{
+		code: "routeros/btest-udp-tx-size-ignored",
+		summary:
+			"For UDP --direction both, the btest wire protocol carries a single tx-size; --remote-udp-tx-size is ignored and --local-udp-tx-size is used for both directions.",
+	},
 	{
 		code: "routeros/command-failed",
 		summary: "RouterOS reported a command failure.",
@@ -415,6 +425,10 @@ export const errorCatalog: readonly ErrorCatalogEntry[] = [
 		code: "usage/invalid-concurrency",
 		summary: "The --concurrency value must be an integer >= 1.",
 	},
+	{
+		code: "usage/invalid-method",
+		summary: "The -X/--method value is not a supported HTTP method.",
+	},
 	{
 		code: "usage/missing-group",
 		summary: "The operation requires a non-empty --group value.",