copilot-relay 0.2.1 → 0.2.3

package/README.md

@@ -36,8 +36,18 @@ Routing:
 
 | Requested model | Upstream model |
 | --- | --- |
-| contains `opus` | `claude-opus-4.8` |
-| anything else | `gpt-5.6-sol` |
+| contains `opus` | `claude-opus-5` |
+| `gpt-5.6-sol[1m]`, plain `gpt-5.6-sol`, or another non-Opus alias | `gpt-5.6-sol` |
+
+The relay advertises `gpt-5.6-sol[1m]` to Claude Code. The `[1m]` selector
+changes Claude Code's client-side context budgeting only; every Copilot request
+still uses `gpt-5.6-sol`, and the relay cannot enlarge GitHub Copilot's upstream
+capacity. An explicit CLI or API model override that bypasses the managed Claude
+settings is outside this guarantee.
+
+Claude Code can still show its built-in Haiku and Sonnet picker entries. The
+managed `model` field sets the startup default but does not restrict
+`availableModels`; selecting any non-Opus alias still follows the GPT route.
 
 ## Install & run
 
@@ -48,13 +58,18 @@ npx copilot-relay@latest restart
 npx copilot-relay@latest stop
 ```
 
-`start` writes `ANTHROPIC_BASE_URL` and a dummy `ANTHROPIC_AUTH_TOKEN` into `~/.claude/settings.json`.
+With `claudeSetup: true`, `start` manages `ANTHROPIC_BASE_URL`, a dummy
+`ANTHROPIC_AUTH_TOKEN` when auth is absent, and the configured GPT default via
+the top-level `model` field in `~/.claude/settings.json`. Exact
+`gpt-5.6-sol` model overrides are normalized to the Claude-facing
+`gpt-5.6-sol[1m]` identity; unrelated model choices are preserved.
 
 ## Config
 
 Config lives at `~/.copilot-relay/config.yaml` and is hot-reloaded:
 
 ```yaml
+configVersion: 2
 host: 127.0.0.1
 port: 4142
 copilotBaseUrl: https://api.githubcopilot.com
@@ -66,6 +81,10 @@ upstreamTimeoutSeconds: 180
 webSearchBackend:
 ```
 
+`configVersion` is managed by copilot-relay. It gates one-time migrations that
+update a shipped default on installs which already persisted the previous value;
+do not edit it.
+
 `logLevel` controls verbosity:
 
 | Level | Logs |
@@ -105,13 +124,17 @@ Upstream failures are logged at `error` with full request and response context i
 Unsupported Claude API requests are logged at `error` with the local method/path
 and detailed request payload.
 
-Logs are written to `~/.copilot-relay/logs/copilot-relay.log`; old `.log` files are cleaned according to `logRetentionDays`.
+Logs are written to `~/.copilot-relay/logs/copilot-relay.<local-date>.log`. The
+active file rotates at local midnight, and files older than `logRetentionDays`
+local calendar days are deleted. Rotation is what makes retention take effect:
+without it the single log file's mtime was refreshed by every append, so nothing
+ever aged out.
 
 Quick inspection:
 
 ```sh
-tail -f ~/.copilot-relay/logs/copilot-relay.log
-grep -n "Failed to create\\|Startup preflight failed" ~/.copilot-relay/logs/copilot-relay.log
+tail -f ~/.copilot-relay/logs/copilot-relay.$(date +%F).log
+grep -n "Failed to create\\|Startup preflight failed" ~/.copilot-relay/logs/copilot-relay.*.log
 ```
 
 See [`docs/troubleshooting.md`](docs/troubleshooting.md) for common debugging workflows.

package/config.default.yaml

@@ -5,6 +5,10 @@
 # Most values hot-reload while the service is running. host and port still
 # require restart because the listening socket is already bound.
 
+# Config schema version. Managed by copilot-relay; do not edit.
+# Used to apply one-time migrations when a shipped default changes.
+configVersion: 2
+
 # Local host for the Claude Code-compatible HTTP server.
 host: 127.0.0.1
 
@@ -29,6 +33,9 @@ claudeSetup: true
 logLevel: info
 
 # Number of days to keep files in ~/.copilot-relay/logs.
+# Counted in local calendar days: 3 keeps today plus the previous two days.
+# The active log file is copilot-relay.<local-date>.log and rotates at local
+# midnight, which is what makes this setting take effect at all.
 logRetentionDays: 3
 
 # Default upstream thinking/reasoning effort sent to Copilot.
@@ -48,4 +55,4 @@ webSearchBackend:
 gptModel: gpt-5.6-sol
 
 # Upstream Copilot model used for requests containing "opus".
-opusModel: claude-opus-4.8
+opusModel: claude-opus-5

package/dist/main.js

@@ -57,8 +57,26 @@ const configPath = path.join(appDir, "config.yaml");
 const copilotTokenPath = path.join(appDir, "copilot_token.json");
 const githubTokenPath = path.join(appDir, "github_token");
 const logsDir = path.join(appDir, "logs");
-const logPath = path.join(logsDir, "copilot-relay.log");
+const logFileBaseName = "copilot-relay";
+const legacyLogPath = path.join(logsDir, `${logFileBaseName}.log`);
 const pidPath = path.join(appDir, "copilot-relay.pid");
+/**
+* Local-date stamp used in log file names.
+*
+* Local rather than UTC on purpose: `logRetentionDays` is a human-facing "how
+* many days do I keep" setting, and a UTC stamp would roll the active file over
+* in the middle of the local afternoon for anyone west of Greenwich.
+*/
+const formatLogDate = (date) => [
+	date.getFullYear(),
+	String(date.getMonth() + 1).padStart(2, "0"),
+	String(date.getDate()).padStart(2, "0")
+].join("-");
+/**
+* Path of the log file that owns `date`. Resolved per write rather than cached,
+* so a long-running relay rotates at local midnight with no timer to drift.
+*/
+const getLogPath = (date = /* @__PURE__ */ new Date()) => path.join(logsDir, `${logFileBaseName}.${formatLogDate(date)}.log`);
 const paths = {
 	appDir,
 	configPath,
@@ -70,7 +88,8 @@ const paths = {
 		path.join(homeDir, ".copilot-tennel.yaml")
 	],
 	legacyCopilotTokenPaths,
-	logPath,
+	legacyLogPath,
+	logFileBaseName,
 	logsDir,
 	pidPath
 };
@@ -103,8 +122,10 @@ async function ensureFile(filePath, options = {}) {
 //#endregion
 //#region src/lib/log.ts
 const logCleanupCheckIntervalMs = 3600 * 1e3;
+const millisecondsPerDay = 1440 * 60 * 1e3;
 let logRetentionDays = 3;
 let nextLogCleanupCheckAt = 0;
+const datedLogFilePattern = /* @__PURE__ */ new RegExp(`^${paths.logFileBaseName}\\.(\\d{4})-(\\d{2})-(\\d{2})\\.log$`);
 const consolaLevelByName = {
 	error: 0,
 	info: 3,
@@ -120,7 +141,22 @@ const setLogLevel = (level) => {
 	currentLogLevel = consolaLevelByName[level];
 	consola.level = consolaLevelByName[level];
 };
-const formatLogValue = (value) => typeof value === "string" ? value : inspect(value, { depth: null });
+/**
+* Render one logged value as a single physical line.
+*
+* `breakLength: Infinity` matters as much as the depth cap. The previous
+* `inspect(value, { depth: null })` pretty-printed each payload across
+* thousands of physical lines, which was both the dominant source of log volume
+* and the reason the `grep` recipes in docs/logging.md returned a fragment of an
+* object instead of the matching entry. One entry is now one line.
+*/
+const formatLogValue = (value) => typeof value === "string" ? value : inspect(value, {
+	breakLength: Infinity,
+	compact: true,
+	depth: 6,
+	maxArrayLength: 100,
+	maxStringLength: 4e3
+});
 const writeLogFile = async (level, values) => {
 	await fs.mkdir(paths.logsDir, { recursive: true });
 	await cleanupLogsIfDue();
@@ -129,7 +165,7 @@ const writeLogFile = async (level, values) => {
 		level,
 		values.map(formatLogValue).join(" ")
 	].join(" ");
-	await fs.appendFile(paths.logPath, `${line}\n`);
+	await fs.appendFile(getLogPath(), `${line}\n`);
 };
 const cleanupLogsIfDue = async () => {
 	const now = Date.now();
@@ -144,14 +180,31 @@ const wrapFileLog = (level, fn) => ((...args) => {
 consola.error = wrapFileLog("error", consola.error.bind(consola));
 consola.info = wrapFileLog("info", consola.info.bind(consola));
 consola.debug = wrapFileLog("debug", consola.debug.bind(consola));
+/**
+* Calendar day a log file belongs to, or undefined when its name carries no
+* date stamp.
+*
+* The filename stamp is preferred over mtime because mtime is rewritten by
+* backups, `cp`, and editors touching the file, any of which would silently
+* extend or shorten the retention window.
+*/
+const parseLogFileDate = (fileName) => {
+	const match = datedLogFilePattern.exec(fileName);
+	if (!match) return;
+	const [, year, month, day] = match;
+	const date = new Date(Number(year), Number(month) - 1, Number(day));
+	return date.getFullYear() === Number(year) && date.getMonth() === Number(month) - 1 && date.getDate() === Number(day) ? date : void 0;
+};
 const cleanupLogs = async (retentionDays) => {
 	logRetentionDays = retentionDays;
 	await fs.mkdir(paths.logsDir, { recursive: true });
-	const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+	const startOfToday = /* @__PURE__ */ new Date();
+	startOfToday.setHours(0, 0, 0, 0);
+	const cutoff = startOfToday.getTime() - (retentionDays - 1) * millisecondsPerDay;
 	const entries = await fs.readdir(paths.logsDir, { withFileTypes: true });
 	await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".log")).map(async (entry) => {
 		const filePath = `${paths.logsDir}/${entry.name}`;
-		if ((await fs.stat(filePath)).mtimeMs < cutoff) await fs.unlink(filePath);
+		if ((parseLogFileDate(entry.name)?.getTime() ?? (await fs.stat(filePath)).mtimeMs) < cutoff) await fs.rm(filePath, { force: true });
 	}));
 };
 const log = consola;
@@ -346,11 +399,27 @@ const runtimeState = {};
 const defaultReasoningEffort = "max";
 const defaultModelRouting = {
 	gptModel: "gpt-5.6-sol",
-	opusModel: "claude-opus-4.8"
+	opusModel: "claude-opus-5"
 };
 const isReasoningEffort = (value) => value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
-const getModelRouting = () => runtimeState.modelRouting ?? defaultModelRouting;
+const exactGpt56SolPattern = /^gpt-5\.6-sol(?:\[1m\])*$/i;
+const claudeContextModelId = "gpt-5.6-sol[1m]";
+const copilotModelId = "gpt-5.6-sol";
+const normalizeClaudeModelId = (model) => exactGpt56SolPattern.test(model) ? claudeContextModelId : model;
+const normalizeCopilotModelId = (model) => exactGpt56SolPattern.test(model) ? copilotModelId : model;
+const getConfiguredModelRouting = () => runtimeState.modelRouting ?? defaultModelRouting;
+const getModelRouting = () => {
+	const routing = getConfiguredModelRouting();
+	return {
+		gptModel: normalizeCopilotModelId(routing.gptModel),
+		opusModel: normalizeCopilotModelId(routing.opusModel)
+	};
+};
 const getExposedModelIds = () => {
+	const routing = getConfiguredModelRouting();
+	return [normalizeClaudeModelId(routing.gptModel), routing.opusModel];
+};
+const getUpstreamModelIds = () => {
 	const routing = getModelRouting();
 	return [routing.gptModel, routing.opusModel];
 };
@@ -366,14 +435,31 @@ const logLevels = [
 	"info",
 	"debug"
 ];
+/**
+* Schema version of ~/.copilot-relay/config.yaml.
+*
+* Bumped whenever a shipped default changes in a way that must reach installs
+* that already persisted the previous value. See supersededOpusModels.
+*/
+const currentConfigVersion = 2;
+/**
+* Opus defaults shipped by earlier releases.
+*
+* readAppConfig() writes the resolved config back to disk, so every install
+* that ever ran an older build has the superseded default sitting in its
+* config.yaml. Without this set, bumping defaultConfig.opusModel would only
+* ever reach fresh installs.
+*/
+const supersededOpusModels = new Set(["claude-opus-4.8"]);
 const defaultConfig = {
 	claudeSetup: true,
+	configVersion: currentConfigVersion,
 	copilotBaseUrl: "https://api.githubcopilot.com",
 	gptModel: "gpt-5.6-sol",
 	host: "127.0.0.1",
 	logLevel: "info",
 	logRetentionDays: 3,
-	opusModel: "claude-opus-4.8",
+	opusModel: "claude-opus-5",
 	port: 4142,
 	thinkEffort: defaultReasoningEffort,
 	upstreamTimeoutSeconds: 180,
@@ -457,6 +543,10 @@ const parseConfigYaml = (content) => {
 			case "claude_setup":
 				config.claudeSetup = unquoteYamlScalar(value);
 				break;
+			case "configVersion":
+			case "config_version":
+				config.configVersion = unquoteYamlScalar(value);
+				break;
 			case "copilotBaseUrl":
 			case "copilot_base_url":
 				config.copilotBaseUrl = unquoteYamlScalar(value);
@@ -511,6 +601,9 @@ const serializeConfig = (config) => [
 	"#",
 	"# This file is hot-reloaded while copilot-relay is running.",
 	"",
+	"# Config schema version. Managed by copilot-relay; do not edit.",
+	`configVersion: ${config.configVersion}`,
+	"",
 	"# Local host for the Claude Code-compatible HTTP server.",
 	`host: ${config.host}`,
 	"",
@@ -552,6 +645,17 @@ const serializeConfig = (config) => [
 	`opusModel: ${config.opusModel}`,
 	""
 ].join("\n");
+/**
+* Resolve opusModel, applying the one-time superseded-default migration.
+*
+* Gated on configVersion so it runs exactly once. Without that gate the rewrite
+* would re-run on every start, which would make a superseded model impossible
+* to pin deliberately - the user's edit would be reverted underneath them.
+*/
+const resolveOpusModel = (rawOpusModel, configVersion) => {
+	if (rawOpusModel === void 0) return defaultConfig.opusModel;
+	return configVersion < currentConfigVersion && supersededOpusModels.has(rawOpusModel) ? defaultConfig.opusModel : rawOpusModel;
+};
 async function readAppConfig() {
 	const raw = await readRawConfig();
 	const claudeSetup = normalizeBoolean(raw.claudeSetup);
@@ -561,14 +665,16 @@ async function readAppConfig() {
 	const port = normalizePort(raw.port);
 	const thinkEffort = normalizeThinkEffort(raw.thinkEffort);
 	const upstreamTimeoutSeconds = normalizeUpstreamTimeoutSeconds(raw.upstreamTimeoutSeconds);
+	const configVersion = normalizePositiveInteger(raw.configVersion) ?? 1;
 	const config = {
 		claudeSetup: claudeSetup ?? defaultConfig.claudeSetup,
+		configVersion: currentConfigVersion,
 		copilotBaseUrl: normalizeString(raw.copilotBaseUrl) ?? defaultConfig.copilotBaseUrl,
 		gptModel: normalizeString(raw.gptModel) ?? defaultConfig.gptModel,
 		host: host ?? defaultConfig.host,
 		logLevel: logLevel ?? defaultConfig.logLevel,
 		logRetentionDays: logRetentionDays$1 ?? defaultConfig.logRetentionDays,
-		opusModel: normalizeString(raw.opusModel) ?? defaultConfig.opusModel,
+		opusModel: resolveOpusModel(normalizeString(raw.opusModel), configVersion),
 		port: port ?? defaultConfig.port,
 		thinkEffort: thinkEffort ?? defaultConfig.thinkEffort,
 		upstreamTimeoutSeconds: upstreamTimeoutSeconds ?? defaultConfig.upstreamTimeoutSeconds,
@@ -806,13 +912,30 @@ const stopExistingRelay = async (config) => {
 
 //#endregion
 //#region src/lib/claude-settings.ts
+const knownModelEnvKeys = [
+	"ANTHROPIC_MODEL",
+	"ANTHROPIC_DEFAULT_SONNET_MODEL",
+	"ANTHROPIC_DEFAULT_HAIKU_MODEL",
+	"ANTHROPIC_DEFAULT_OPUS_MODEL",
+	"ANTHROPIC_DEFAULT_FABLE_MODEL",
+	"ANTHROPIC_SMALL_FAST_MODEL",
+	"CLAUDE_CODE_SUBAGENT_MODEL"
+];
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const hasMalformedModelOverride = (parsed) => {
+	if (parsed.model !== void 0 && typeof parsed.model !== "string") return true;
+	const env = parsed.env;
+	if (!isRecord$1(env)) return false;
+	return knownModelEnvKeys.some((key) => env[key] !== void 0 && typeof env[key] !== "string");
+};
+const hasPrimaryModelOverride = (parsed, env) => typeof parsed.model === "string" || typeof env.ANTHROPIC_MODEL === "string";
 /**
 * Update `~/.claude/settings.json` so its env block points Claude Code at the
-* running proxy. Preserves all unrelated keys (model overrides, plugins,
-* marketplaces, etc.). Sets a dummy auth token only if none is present.
+* running proxy. Preserves unrelated keys and model choices while normalizing
+* managed gpt-5.6-sol overrides. Sets a dummy auth token only if none is present.
 */
 async function applyClaudeConfig(input) {
-	const { configPath: configPath$1, baseUrl } = input;
+	const { configPath: configPath$1, baseUrl, gptModel } = input;
 	let raw = "";
 	let created = false;
 	try {
@@ -822,9 +945,19 @@ async function applyClaudeConfig(input) {
 		else throw error;
 	}
 	let parsed = {};
+	if (!created && raw.trim().length === 0) return {
+		configPath: configPath$1,
+		changed: false,
+		created: false
+	};
 	if (raw.trim().length > 0) try {
-		parsed = JSON.parse(raw);
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) parsed = {};
+		const value = JSON.parse(raw);
+		if (!isRecord$1(value) || value.env !== void 0 && !isRecord$1(value.env) || hasMalformedModelOverride(value)) return {
+			configPath: configPath$1,
+			changed: false,
+			created: false
+		};
+		parsed = value;
 	} catch {
 		return {
 			configPath: configPath$1,
@@ -832,12 +965,19 @@ async function applyClaudeConfig(input) {
 			created: false
 		};
 	}
-	const env = typeof parsed.env === "object" && parsed.env !== null && !Array.isArray(parsed.env) ? { ...parsed.env } : {};
+	const env = isRecord$1(parsed.env) ? { ...parsed.env } : {};
 	const previousBaseUrl = typeof env.ANTHROPIC_BASE_URL === "string" ? env.ANTHROPIC_BASE_URL : void 0;
+	const hadPrimaryModelOverride = hasPrimaryModelOverride(parsed, env);
+	const claudeGptModel = normalizeClaudeModelId(gptModel);
+	const shouldSeedTopLevelModel = !hadPrimaryModelOverride;
+	const nextModel = typeof parsed.model === "string" ? normalizeClaudeModelId(parsed.model) : void 0;
+	for (const key of knownModelEnvKeys) if (typeof env[key] === "string") env[key] = normalizeClaudeModelId(env[key]);
 	env.ANTHROPIC_BASE_URL = baseUrl;
 	if (typeof env.ANTHROPIC_AUTH_TOKEN !== "string" || !env.ANTHROPIC_AUTH_TOKEN) env.ANTHROPIC_AUTH_TOKEN = "dummy";
 	const next = {
 		...parsed,
+		...nextModel !== void 0 && { model: nextModel },
+		...shouldSeedTopLevelModel && { model: claudeGptModel },
 		env
 	};
 	const serialized = `${JSON.stringify(next, null, 2)}\n`;
@@ -1539,7 +1679,7 @@ async function shouldRetryWithResponses(response, signal, timeoutMs) {
 
 //#endregion
 //#region src/lib/preflight.ts
-const getUpstreamModelIds = async (config) => {
+const fetchUpstreamModelIds = async (config) => {
 	const provider = getCopilotProviderContext(config);
 	const signal = createCopilotRequestSignal(void 0, config.upstreamTimeoutMs);
 	const response = await fetchCopilot(provider, "/models", {
@@ -1554,8 +1694,8 @@ const getUpstreamModelIds = async (config) => {
 	return new Set((payload.data ?? []).map((model) => model.id).filter((id) => typeof id === "string" && id.length > 0));
 };
 const ensureRequiredModels = async (config) => {
-	const upstreamModels = await getUpstreamModelIds(config);
-	const requiredModels = getExposedModelIds();
+	const upstreamModels = await fetchUpstreamModelIds(config);
+	const requiredModels = getUpstreamModelIds();
 	const missingModels = requiredModels.filter((model) => !upstreamModels.has(model));
 	if (missingModels.length > 0) throw new Error(`Required Copilot model(s) unavailable upstream: ${missingModels.join(", ")}`);
 	log.info(`Upstream models available: ${requiredModels.join(", ")}`);
@@ -1589,7 +1729,7 @@ const validateModelRequest = async (config, model, thinkEffort) => {
 const validateUpstream = async (config, thinkEffort) => {
 	log.info("Running upstream preflight");
 	await ensureRequiredModels(config);
-	for (const model of getExposedModelIds()) await validateModelRequest(config, model, thinkEffort);
+	for (const model of getUpstreamModelIds()) await validateModelRequest(config, model, thinkEffort);
 };
 
 //#endregion
@@ -1865,7 +2005,7 @@ function translateToClaude(response, toolNameMapper = createClaudeToolNameMapper
 		id: response.id,
 		type: "message",
 		role: "assistant",
-		model: response.model,
+		model: normalizeClaudeModelId(response.model),
 		content: [
 			...allThinkingBlocks,
 			...allTextBlocks,
@@ -1945,7 +2085,7 @@ function translateChunkToClaudeEvents(chunk, state, toolNameMapper = createClaud
 				type: "message",
 				role: "assistant",
 				content: [],
-				model: chunk.model,
+				model: normalizeClaudeModelId(chunk.model),
 				stop_reason: null,
 				stop_sequence: null,
 				usage: {
@@ -2083,7 +2223,7 @@ const isClaudeCodeWebSearchTool = (tool) => tool.name === claudeCodeWebSearchToo
 const isClaudeWebSearchTool = (tool) => isAnthropicNativeWebSearchTool(tool) || isClaudeCodeWebSearchTool(tool);
 const hasClaudeWebSearch = (payload) => payload.tools?.some(isClaudeWebSearchTool) ?? false;
 const isClaudeWebSearchToolName = (name) => name === "web_search" || name === claudeCodeWebSearchToolName;
-const getWebSearchBackendModel = (config) => config.webSearchBackend?.trim() || getModelRouting().gptModel;
+const getWebSearchBackendModel = (config) => normalizeCopilotModelId(config.webSearchBackend?.trim() || getModelRouting().gptModel);
 const prepareClaudeWebSearchDecisionPayload = (payload) => {
 	if (!hasClaudeWebSearch(payload)) return payload;
 	return {
@@ -2257,7 +2397,7 @@ const createClaudeWebSearchResponse = (search) => {
 		type: "message",
 		role: "assistant",
 		content,
-		model: search.model,
+		model: normalizeClaudeModelId(search.model),
 		stop_reason: "end_turn",
 		stop_sequence: null,
 		usage: {
@@ -2845,7 +2985,8 @@ async function startRelay(appConfig) {
 	if (appConfig.claudeSetup) try {
 		const claudeResult = await applyClaudeConfig({
 			baseUrl,
-			configPath: claudeConfigPath$1
+			configPath: claudeConfigPath$1,
+			gptModel: appConfig.gptModel
 		});
 		if (claudeResult.changed) {
 			log.info(`claude settings ${claudeResult.created ? "created" : "updated"}: ${claudeResult.configPath}`);