copilot-relay 0.3.0 → 0.3.2

package/README.md

@@ -134,14 +134,51 @@ it is reachable:
 ```text
 copilot-relay 0.2.5
   process    running (pid 93744, up 1h 16m)
+  version    0.2.5
   listening  http://127.0.0.1:4142
   health     ok (9ms)
   models     gpt-5.6-sol[1m], claude-opus-5
   upstream   not checked (use --deep)
   log        ~/.copilot-relay/logs/copilot-relay.2026-07-25.log
-  config     ~/.copilot-relay/config.yaml (logLevel=info, thinkEffort=max)
+  config     ~/.copilot-relay/config.yaml
+    host                    127.0.0.1
+    port                    4142
+    copilotBaseUrl          https://api.githubcopilot.com
+    claudeSetup             true
+    logLevel                info
+    logRetentionDays        3
+    thinkEffort             max
+    upstreamTimeoutSeconds  180
+    webSearchBackend        (unset — uses gptModel)
+    gptModel                gpt-5.6-sol
+    opusModel               claude-opus-5
+    host, port and claudeSetup take effect on restart; the rest hot-reload.
 ```
 
+The `config` block is every key `readAppConfig()` resolved, in
+`config.default.yaml` order. These are the values on disk: eight of them reload
+while the relay runs, while `host`, `port` and `claudeSetup` are read once at
+startup — the block says so rather than leaving you to discover it after an
+edit. `--json` emits the same values under `config`, with `webSearchBackend` as
+`null` when unset so the key set stays the same shape either way.
+
+The first line is the CLI you invoked; the `version` row is the build the
+running daemon reports about itself. They differ after an upgrade that has not
+been restarted yet — the new CLI is installed, the old process is still
+serving — and `status` says so rather than letting the header imply the upgrade
+took effect:
+
+```text
+  version    0.2.6 — MISMATCH, 0.3.0 is installed
+  ...
+  The running relay is 0.2.6; 0.3.0 is installed.
+  Restart it to serve the installed version: copilot-relay restart
+```
+
+A mismatch does not change the exit code: the relay works, it is just not the
+build you installed. A daemon older than v0.3.1 does not report a version at
+all, which shows as `unknown`.
+
 `--deep` additionally sends a real request through Copilot. That is the only
 check that proves the relay can actually serve Claude Code — a relay whose
 Copilot token expired an hour ago still answers `/healthz` and `/v1/models`,

package/dist/main.js

@@ -7,11 +7,11 @@ import os from "node:os";
 import path, { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { createAdaptorServer } from "@hono/node-server";
 import { createHash, randomUUID } from "node:crypto";
 import { Agent, fetch as fetch$1 } from "undici";
 import { events } from "fetch-event-stream";
-import { readFileSync } from "node:fs";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
@@ -708,6 +708,24 @@ const auth = defineCommand({
 	}
 });
 
+//#endregion
+//#region src/lib/version.ts
+const packageName = "copilot-relay";
+const readPackageVersion = () => {
+	let currentDir = dirname(fileURLToPath(import.meta.url));
+	while (true) {
+		try {
+			const packageJsonPath = resolve(currentDir, "package.json");
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			if (packageJson.name === packageName && typeof packageJson.version === "string") return packageJson.version;
+		} catch {}
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) return "unknown";
+		currentDir = parentDir;
+	}
+};
+const appVersion = readPackageVersion();
+
 //#endregion
 //#region src/lib/lifecycle.ts
 const execFileAsync = promisify(execFile);
@@ -772,7 +790,8 @@ const readRelayPidFileEntry = async () => {
 			host: payload.host,
 			pid,
 			port: payload.port,
-			startedAt: typeof payload.startedAt === "string" ? payload.startedAt : ""
+			startedAt: typeof payload.startedAt === "string" ? payload.startedAt : "",
+			...typeof payload.version === "string" && payload.version ? { version: payload.version } : {}
 		};
 	} catch {
 		return;
@@ -795,7 +814,8 @@ const writeRelayPidFile = async (config) => {
 		host: config.host,
 		pid: process.pid,
 		port: config.port,
-		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+		startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		version: appVersion
 	};
 	await fs.writeFile(paths.pidPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 384 });
 };
@@ -1759,24 +1779,6 @@ const validateUpstream = async (config, thinkEffort) => {
 	for (const model of getUpstreamModelIds()) await validateModelRequest(config, model, thinkEffort);
 };
 
-//#endregion
-//#region src/lib/version.ts
-const packageName = "copilot-relay";
-const readPackageVersion = () => {
-	let currentDir = dirname(fileURLToPath(import.meta.url));
-	while (true) {
-		try {
-			const packageJsonPath = resolve(currentDir, "package.json");
-			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-			if (packageJson.name === packageName && typeof packageJson.version === "string") return packageJson.version;
-		} catch {}
-		const parentDir = dirname(currentDir);
-		if (parentDir === currentDir) return "unknown";
-		currentDir = parentDir;
-	}
-};
-const appVersion = readPackageVersion();
-
 //#endregion
 //#region src/claude/utils.ts
 function mapOpenAIStopReasonToClaude(finishReason) {
@@ -3142,7 +3144,10 @@ const createServer = (config) => {
 		name: "copilot-relay",
 		status: "ok"
 	}));
-	app.get("/healthz", (c) => c.json({ ok: true }));
+	app.get("/healthz", (c) => c.json({
+		ok: true,
+		version: appVersion
+	}));
 	app.on(["GET", "HEAD"], "/api/hello", (c) => c.body(null, 200));
 	app.route("/v1", claudeRoutes);
 	app.notFound(async (c) => {
@@ -3315,6 +3320,19 @@ const exitCodes = {
 };
 const localProbeTimeoutMs = 5e3;
 const deepProbeTimeoutMs = 6e4;
+const toStatusConfig = (config) => ({
+	...config,
+	webSearchBackend: config.webSearchBackend ?? null
+});
+/**
+* True when the daemon is serving a different build than the invoked CLI.
+*
+* Pure and exported because it drives both the rendered warning and the
+* deliberate decision to leave the exit code at 0; both deserve direct
+* coverage. Undefined daemonVersion is not a mismatch - unknown is not
+* different, and claiming otherwise would warn on every pre-v0.3.1 daemon.
+*/
+const hasVersionMismatch = (status$1) => status$1.running && status$1.daemonVersion !== void 0 && status$1.daemonVersion !== status$1.version;
 /**
 * Status to exit code. Pure, because this mapping is the contract every
 * scripted caller depends on and deserves direct coverage.
@@ -3322,6 +3340,11 @@ const deepProbeTimeoutMs = 6e4;
 * 0 requires a live process *and* a passing health probe. Printing FAILED while
 * exiting 0 would make every scripted caller treat an unreachable relay as
 * fine. See #34.
+*
+* A version mismatch stays 0 on purpose (#43). The relay works; it is just not
+* the build that was installed. Mapping it to 2 would overstate it and break
+* every scripted caller that treats non-zero as broken. It is surfaced in the
+* text instead.
 */
 const resolveExitCode = (status$1) => !status$1.running ? exitCodes.notRunning : !status$1.health?.ok ? exitCodes.notUsable : status$1.deep && !status$1.deep.ok ? exitCodes.notUsable : exitCodes.running;
 const formatUptime = (startedAt) => {
@@ -3335,23 +3358,71 @@ const formatUptime = (startedAt) => {
 	return `${Math.floor(seconds / 86400)}d ${Math.floor(seconds % 86400 / 3600)}h`;
 };
 /**
+* Every config key with its position in the block, in config.default.yaml order
+* rather than alphabetical so it reads like the file it was resolved from.
+*
+* A Record keyed by StatusConfig rather than an array of keys: an array only
+* checks that each entry *is* a key, so a twelfth config key would type-check
+* while silently never appearing in `status` — the exact failure this command
+* exists to prevent. Keyed this way, adding one fails the build here.
+*/
+const configRowOrder = {
+	host: 0,
+	port: 1,
+	copilotBaseUrl: 2,
+	claudeSetup: 3,
+	logLevel: 4,
+	logRetentionDays: 5,
+	thinkEffort: 6,
+	upstreamTimeoutSeconds: 7,
+	webSearchBackend: 8,
+	gptModel: 9,
+	opusModel: 10
+};
+const configRowKeys = Object.keys(configRowOrder).sort((a, b) => configRowOrder[a] - configRowOrder[b]);
+/**
+* The resolved config, one key per line.
+*
+* These are the values on disk. That is not the same question as "what is the
+* running daemon honouring", and the footnote says so rather than leaving it
+* implied: applyRuntimeConfig() in start.ts hot-reloads eight of these keys,
+* never reads claudeSetup, and deliberately does not rebind the listening
+* socket when host or port changes. Printing all eleven without that line
+* would imply a live daemon had read values it has not.
+*
+* Only shown when running, because with nothing up every value applies at the
+* next start and the note would be noise.
+*/
+const renderConfig = (config, running) => {
+	const lines = configRowKeys.map((key) => {
+		const value = config[key];
+		const rendered = key === "webSearchBackend" && value === null ? "(unset — uses gptModel)" : String(value);
+		return `    ${key.padEnd(24)}${rendered}`;
+	});
+	if (running) lines.push("    host, port and claudeSetup take effect on restart; the rest hot-reload.");
+	return lines;
+};
+/**
 * Pure state-to-lines mapping, kept free of IO so it can be tested directly
 * without spawning a relay or opening a socket.
 */
 const renderStatus = (status$1) => {
 	const lines = [`copilot-relay ${status$1.version}`];
 	if (!status$1.running) {
-		lines.push("  process    not running", `  config     ${status$1.configPath} (logLevel=${status$1.logLevel}, thinkEffort=${status$1.thinkEffort})`, `  log        ${status$1.logPath}`, "", "  Start it with: copilot-relay start");
+		lines.push("  process    not running", `  log        ${status$1.logPath}`, `  config     ${status$1.configPath}`, ...renderConfig(status$1.config, false), "", "  Start it with: copilot-relay start");
 		return lines;
 	}
-	lines.push(`  process    running (pid ${status$1.pid}, up ${formatUptime(status$1.startedAt)})`, `  listening  ${status$1.baseUrl}`);
+	lines.push(`  process    running (pid ${status$1.pid}, up ${formatUptime(status$1.startedAt)})`);
+	lines.push(status$1.daemonVersion === void 0 ? "  version    unknown (daemon predates version reporting — restart to report it)" : hasVersionMismatch(status$1) ? `  version    ${status$1.daemonVersion} — MISMATCH, ${status$1.version} is installed` : `  version    ${status$1.daemonVersion}`);
+	lines.push(`  listening  ${status$1.baseUrl}`);
 	const health = status$1.health;
 	lines.push(health?.ok ? `  health     ok (${health.ms}ms)` : `  health     FAILED${health?.detail ? ` — ${health.detail}` : ""}`);
 	lines.push(status$1.models?.length ? `  models     ${status$1.models.join(", ")}` : "  models     unavailable");
 	if (status$1.deep) lines.push(status$1.deep.ok ? `  upstream   ok (${status$1.deep.ms}ms) — end-to-end Copilot round trip` : `  upstream   FAILED${status$1.deep.detail ? ` — ${status$1.deep.detail}` : ""}`);
 	else lines.push("  upstream   not checked (use --deep)");
-	lines.push(`  log        ${status$1.logPath}`, `  config     ${status$1.configPath} (logLevel=${status$1.logLevel}, thinkEffort=${status$1.thinkEffort})`);
+	lines.push(`  log        ${status$1.logPath}`, `  config     ${status$1.configPath}`, ...renderConfig(status$1.config, true));
 	if (status$1.health?.ok && status$1.deep && !status$1.deep.ok) lines.push("", "  The relay is listening but cannot reach Copilot.", "  Try: copilot-relay auth");
+	if (hasVersionMismatch(status$1)) lines.push("", `  The running relay is ${status$1.daemonVersion}; ${status$1.version} is installed.`, "  Restart it to serve the installed version: copilot-relay restart");
 	return lines;
 };
 const probe = async (url, init, timeoutMs) => {
@@ -3368,22 +3439,34 @@ const probe = async (url, init, timeoutMs) => {
 	};
 };
 const describeError = (error) => error instanceof Error ? error.name === "TimeoutError" ? "timed out" : error.message : String(error);
+/**
+* Probes /healthz, which also reports the daemon's own version.
+*
+* The version rides along on a probe `status` already makes, so asking what is
+* running costs nothing extra. Absent for a daemon older than v0.3.1, which is
+* itself informative, so it stays optional rather than defaulting to the
+* caller's version - that substitution is the bug. See #43.
+*/
 const checkHealth = async (baseUrl) => {
 	try {
-		const result = await probe(`${baseUrl}/healthz`, {}, localProbeTimeoutMs);
-		return result.ok ? {
-			ms: result.ms,
-			ok: true
-		} : {
-			detail: `http ${result.status}`,
-			ms: result.ms,
-			ok: false
+		const probeResult = await probe(`${baseUrl}/healthz`, {}, localProbeTimeoutMs);
+		const version = probeResult.body?.version;
+		return {
+			result: probeResult.ok ? {
+				ms: probeResult.ms,
+				ok: true
+			} : {
+				detail: `http ${probeResult.status}`,
+				ms: probeResult.ms,
+				ok: false
+			},
+			...typeof version === "string" && version ? { version } : {}
 		};
 	} catch (error) {
-		return {
+		return { result: {
 			detail: describeError(error),
 			ok: false
-		};
+		} };
 	}
 };
 const readModels = async (baseUrl) => {
@@ -3445,6 +3528,7 @@ const collectStatus = async (options) => {
 	const appConfig = await readAppConfig();
 	setLogLevel(appConfig.logLevel);
 	const base = {
+		config: toStatusConfig(appConfig),
 		configPath: paths.configPath,
 		logLevel: appConfig.logLevel,
 		logPath: getLogPath(),
@@ -3458,13 +3542,15 @@ const collectStatus = async (options) => {
 	};
 	const baseUrl = `http://${relay.host}:${relay.port}`;
 	const health = await checkHealth(baseUrl);
-	const models = health.ok ? await readModels(baseUrl) : [];
-	const deep = options.deep && health.ok ? await checkDeep(baseUrl, models[0] ?? appConfig.gptModel) : void 0;
+	const models = health.result.ok ? await readModels(baseUrl) : [];
+	const deep = options.deep && health.result.ok ? await checkDeep(baseUrl, models[0] ?? appConfig.gptModel) : void 0;
+	const daemonVersion = health.version ?? relay.version;
 	return {
 		...base,
 		baseUrl,
+		...daemonVersion ? { daemonVersion } : {},
 		...deep ? { deep } : {},
-		health,
+		health: health.result,
 		models,
 		pid: relay.pid,
 		port: relay.port,