[walk test] runtime-node: doctor --quiet and --version

packages/runtime-node/src/cli.ts

@@ -2,10 +2,20 @@
 /**
  * `npx @autter/runtime-node doctor` — see doctor.ts.
  */
+import { SDK_IDENTITY } from "./compat.js";
 import { DOCTOR_USAGE, formatDoctorReport, parseDoctorArgs, runDoctor } from "./doctor.js";
 
+/** `autter-runtime --version` / `-v` / `version`: the installed SDK's name and version. */
+export function versionLine(): string {
+	return `${SDK_IDENTITY.name} ${SDK_IDENTITY.version}`;
+}
+
 async function main(argv: string[]): Promise<number> {
 	const [command, ...rest] = argv;
+	if (command === "--version" || command === "-v" || command === "version") {
+		console.log(versionLine());
+		return 0;
+	}
 	if (command !== "doctor") {
 		console.log(DOCTOR_USAGE);
 		return command === undefined || command === "--help" || command === "-h" ? 0 : 64;
@@ -20,7 +30,8 @@ async function main(argv: string[]): Promise<number> {
 		return 64;
 	}
 	const report = await runDoctor(parsed);
-	console.log(parsed.json ? JSON.stringify(report, null, 2) : formatDoctorReport(report));
+	const output = parsed.json ? JSON.stringify(report, null, 2) : formatDoctorReport(report, { quiet: parsed.quiet });
+	if (output) (report.exitCode === 0 ? console.log : console.error)(output);
 	return report.exitCode;
 }
 

packages/runtime-node/src/doctor.ts

@@ -25,6 +25,8 @@ export interface DoctorOptions {
 	key?: string;
 	features?: string[];
 	json?: boolean;
+	/** Print nothing when compatible, and only the problems otherwise (CI). */
+	quiet?: boolean;
 	cwd?: string;
 	timeoutMs?: number;
 }
@@ -161,7 +163,8 @@ export async function runDoctor(options: DoctorOptions = {}): Promise<DoctorRepo
 	};
 }
 
-export function formatDoctorReport(report: DoctorReport): string {
+export function formatDoctorReport(report: DoctorReport, options: { quiet?: boolean } = {}): string {
+	if (options.quiet) return formatQuietDoctorReport(report);
 	const lines: string[] = [];
 	lines.push(`Autter Runtime doctor`);
 	lines.push(`  endpoint   ${report.endpoint}`);
@@ -211,7 +214,25 @@ export function formatDoctorReport(report: DoctorReport): string {
 	return lines.join("\n");
 }
 
+/** One line per problem, or nothing at all when everything is compatible. */
+function formatQuietDoctorReport(report: DoctorReport): string {
+	if (report.exitCode === 0) return "";
+	const lines: string[] = [];
+	if (!report.ingester && report.exitCode === 2) {
+		lines.push(`autter doctor: ingester unreachable at ${report.endpoint} (${report.ingesterError ?? "unknown error"})`);
+	}
+	if (report.key === "rejected") lines.push("autter doctor: ingest key rejected (401)");
+	if (report.key === "client_key") lines.push("autter doctor: a client/browser key was given; server SDKs need a server key");
+	for (const feature of report.features) {
+		if (feature.status === "incompatible") lines.push(`autter doctor: feature ${feature.id} is incompatible`);
+	}
+	for (const issue of report.issues) lines.push(`autter doctor: ${issue.message}`);
+	if (lines.length === 0) lines.push(`autter doctor: incompatible (exit ${report.exitCode})`);
+	return lines.join("\n");
+}
+
 export const DOCTOR_USAGE = `Usage: npx @autter/runtime-node doctor [options]
+       npx @autter/runtime-node --version
 
 Checks that your Autter SDKs, ingester and ClickHouse schema versions match.
 
@@ -220,6 +241,7 @@ Options:
   --key <key>         Also verify an ingest key (default: $AUTTER_RUNTIME_KEY)
   --features <a,b>    Only check these features (${COMPAT_MANIFEST.features.map((f) => f.id).join(", ")})
   --json              Machine-readable output
+  -q, --quiet         Print nothing when compatible, only the problems otherwise
   --timeout <ms>      Per-request timeout (default 5000)
 
 Exit codes: 0 compatible, 1 mismatch or rejected key, 2 ingester unreachable.`;
@@ -246,6 +268,10 @@ export function parseDoctorArgs(argv: string[], env: NodeJS.ProcessEnv = process
 			case "--json":
 				options.json = true;
 				break;
+			case "-q":
+			case "--quiet":
+				options.quiet = true;
+				break;
 			case "--timeout": {
 				const ms = Number(value());
 				if (!Number.isFinite(ms) || ms <= 0) return { error: "--timeout needs a positive number of ms" };
@@ -256,6 +282,7 @@ export function parseDoctorArgs(argv: string[], env: NodeJS.ProcessEnv = process
 				return { error: `unknown option ${arg}` };
 		}
 	}
+	if (options.json && options.quiet) return { error: "--json and --quiet cannot be combined" };
 	if (!options.key && env.AUTTER_RUNTIME_KEY) options.key = env.AUTTER_RUNTIME_KEY;
 	return options;
 }

packages/runtime-node/src/index.ts

@@ -102,4 +102,10 @@ export {
 	type IngesterCompatInfo,
 	type SdkIdentity,
 } from "./compat.js";
-export { runDoctor, type DoctorOptions, type DoctorReport } from "./doctor.js";
+export {
+	formatDoctorReport,
+	parseDoctorArgs,
+	runDoctor,
+	type DoctorOptions,
+	type DoctorReport,
+} from "./doctor.js";

packages/runtime-node/test/doctor-quiet.test.mjs

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { formatDoctorReport, parseDoctorArgs } from "../dist/index.js";
+
+const compatible = {
+	endpoint: "https://otlp.example.test",
+	sdks: [{ name: "@autter/runtime-node", version: "1.5.0" }],
+	ingester: { version: "1.5.0", schema: null },
+	features: [{ id: "logs", title: "Logs", status: "ok" }],
+	issues: [],
+	exitCode: 0,
+};
+
+test("--quiet and -q are parsed, and cannot be combined with --json", () => {
+	assert.deepEqual(parseDoctorArgs(["--quiet"], {}), { quiet: true });
+	assert.deepEqual(parseDoctorArgs(["-q", "--endpoint", "http://x"], {}), { quiet: true, endpoint: "http://x" });
+	assert.deepEqual(parseDoctorArgs(["--json", "--quiet"], {}), { error: "--json and --quiet cannot be combined" });
+});
+
+test("a quiet report is empty when everything is compatible", () => {
+	assert.equal(formatDoctorReport(compatible, { quiet: true }), "");
+	assert.match(formatDoctorReport(compatible), /Compatible\./);
+});
+
+test("a quiet report lists only the problems", () => {
+	const broken = {
+		...compatible,
+		key: "rejected",
+		features: [{ id: "traces", title: "Traces", status: "incompatible" }],
+		issues: [{ message: "ingester 1.3.0 is older than the SDK expects" }],
+		exitCode: 1,
+	};
+	assert.equal(
+		formatDoctorReport(broken, { quiet: true }),
+		[
+			"autter doctor: ingest key rejected (401)",
+			"autter doctor: feature traces is incompatible",
+			"autter doctor: ingester 1.3.0 is older than the SDK expects",
+		].join("\n"),
+	);
+	const unreachable = { ...compatible, ingester: null, ingesterError: "ECONNREFUSED", features: [], exitCode: 2 };
+	assert.equal(
+		formatDoctorReport(unreachable, { quiet: true }),
+		"autter doctor: ingester unreachable at https://otlp.example.test (ECONNREFUSED)",
+	);
+});
+
+test("the CLI prints its version and exits 0", async () => {
+	const { spawnSync } = await import("node:child_process");
+	const { fileURLToPath } = await import("node:url");
+	const { readFileSync } = await import("node:fs");
+	const cli = fileURLToPath(new URL("../dist/cli.js", import.meta.url));
+	const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+	for (const flag of ["--version", "-v", "version"]) {
+		const run = spawnSync(process.execPath, [cli, flag], { encoding: "utf8" });
+		assert.equal(run.status, 0, flag);
+		assert.equal(run.stdout.trim(), `@autter/runtime-node ${version}`);
+	}
+});