proxitor 0.10.0 → 0.11.0

package/dist/cli.mjs

@@ -6,8 +6,8 @@ import * as tty$1 from "node:tty";
 import tty, { ReadStream } from "node:tty";
 import { formatWithOptions, styleText } from "node:util";
 import * as l$1 from "node:readline";
-import f from "node:readline";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import l__default from "node:readline";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unwatchFile, watchFile, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { createServer } from "node:net";
 import { STATUS_CODES, createServer as createServer$1 } from "node:http";
@@ -4603,7 +4603,7 @@ var V = class {
 					this.state = "cancel", this.close();
 				}, { once: true });
 			}
-			this.rl = f.createInterface({
+			this.rl = l__default.createInterface({
 				input: this.input,
 				tabSize: 2,
 				prompt: "",
@@ -17220,7 +17220,7 @@ const r = Object.create(null), i = (e) => globalThis.process?.env || import.meta
 		const e = i(true);
 		return Object.keys(e);
 	}
-}), t = typeof process < "u" && process.env && process.env.NODE_ENV || "", f$1 = [
+}), t = typeof process < "u" && process.env && process.env.NODE_ENV || "", f = [
 	["APPVEYOR"],
 	[
 		"AWS_AMPLIFY",
@@ -17312,7 +17312,7 @@ const r = Object.create(null), i = (e) => globalThis.process?.env || import.meta
 	]
 ];
 function b() {
-	if (globalThis.process?.env) for (const e of f$1) {
+	if (globalThis.process?.env) for (const e of f) {
 		const s = e[1] || e[0];
 		if (globalThis.process?.env[s]) return {
 			name: e[0].toLowerCase(),
@@ -17917,6 +17917,31 @@ const CACHE_HINTS = {
 	always: "All models",
 	skip: "Passthrough — leave client cache_control headers as-is"
 };
+const NORMALIZE_HINTS = {
+	on: "Rewrite cch → stable prefix cache",
+	off: "Passthrough — rewrite nothing"
+};
+async function askNormalizeVolatileSystem(message, current, opts) {
+	const options = [{
+		value: true,
+		label: "On",
+		hint: NORMALIZE_HINTS.on
+	}, {
+		value: false,
+		label: "Off",
+		hint: NORMALIZE_HINTS.off
+	}];
+	if (opts?.removable) options.push({
+		value: "reset",
+		label: "Reset / inherit",
+		hint: opts.resetHint ?? "Remove override"
+	});
+	return await select({
+		message,
+		initialValue: current ?? false,
+		options
+	});
+}
 async function askTriState(message, current, hints, opts) {
 	const options = [
 		{
@@ -18017,6 +18042,12 @@ async function collectCacheTriState(currentCc, currentTtl, globalTtl) {
 		cacheControlTtl: { value: ttl }
 	};
 }
+async function collectNormalizeVolatileSystem(currentNvs) {
+	const nvs = await askNormalizeVolatileSystem("Normalize volatile system (cch hash)", currentNvs, { removable: true });
+	if (typeof nvs === "symbol") return null;
+	if (nvs === "reset") return { normalizeVolatileSystem: { remove: true } };
+	return { normalizeVolatileSystem: { value: nvs } };
+}
 //#endregion
 //#region src/commands/config/add.ts
 const CUSTOM_PATTERN_VALUE = "__proxitor_custom_pattern__";
@@ -18119,13 +18150,24 @@ async function configureProviderAndSave(configPath, client, modelKey, isPattern)
 	const providerResult = await selectProvidersByMode(mode, providerOptions);
 	if (!providerResult) return;
 	override = providerResult;
-	override = await collectSessionAndCache(override);
+	override = await collectOptionalOverrides(override);
 	if (!await confirmAndSave(configPath, modelKey, override, client)) return;
 	outro("✓ Model override saved");
 }
-async function collectSessionAndCache(override) {
+async function collectOptionalOverrides(override) {
 	override = await collectSession(override);
 	override = await collectCache(override);
+	override = await collectNormalize(override);
+	return override;
+}
+async function collectNormalize(override) {
+	const want = await confirm({
+		message: "Configure normalizeVolatileSystem for this model?",
+		initialValue: false
+	});
+	if (isCancel(want) || !want) return override;
+	const result = await collectNormalizeVolatileSystem(override.normalizeVolatileSystem);
+	if (result && !("remove" in result.normalizeVolatileSystem)) override.normalizeVolatileSystem = result.normalizeVolatileSystem.value;
 	return override;
 }
 async function collectSession(override) {
@@ -18201,6 +18243,7 @@ function formatOverrideYaml(override) {
 	if (override.sessionId) parts.push(`sessionId: ${override.sessionId}`);
 	if (override.cacheControl) parts.push(`cacheControl: ${override.cacheControl}`);
 	if (override.cacheControlTtl) parts.push(`cacheControlTtl: ${override.cacheControlTtl}`);
+	if (override.normalizeVolatileSystem !== void 0) parts.push(`normalizeVolatileSystem: ${override.normalizeVolatileSystem}`);
 	return parts.join("\n    ") || "(empty)";
 }
 //#endregion
@@ -18276,6 +18319,10 @@ async function browseModelsCommand(client) {
 }
 //#endregion
 //#region src/commands/config/edit.ts
+function nvsHint(value) {
+	if (value === void 0) return "(inherit)";
+	return value ? "on" : "off";
+}
 function formatOverrideHint(override) {
 	if (!override) return "(empty)";
 	const parts = [];
@@ -18285,6 +18332,7 @@ function formatOverrideHint(override) {
 	}
 	if (override.sessionId) parts.push(`session: ${override.sessionId}`);
 	if (override.cacheControl) parts.push(`cache: ${override.cacheControl}`);
+	if (override.normalizeVolatileSystem !== void 0) parts.push(`normalize: ${nvsHint(override.normalizeVolatileSystem)}`);
 	if (override.headers) parts.push(`${Object.keys(override.headers).length} header(s)`);
 	return parts.join(", ") || "(empty)";
 }
@@ -18308,6 +18356,7 @@ function showCurrentConfig(modelKey, current) {
 	if (current.sessionId) log.info(`  sessionId: ${current.sessionId}`);
 	if (current.cacheControl) log.info(`  cacheControl: ${current.cacheControl}`);
 	if (current.cacheControlTtl) log.info(`  cacheControlTtl: ${current.cacheControlTtl}`);
+	if (current.normalizeVolatileSystem !== void 0) log.info(`  normalizeVolatileSystem: ${current.normalizeVolatileSystem}`);
 	if (current.headers) for (const [name, value] of Object.entries(current.headers)) log.info(`  headers.${name}: ${value}`);
 }
 async function editProvider(modelKey, current, client) {
@@ -18344,6 +18393,23 @@ async function editCacheControl(current, configPath) {
 	applyField(next, "cacheControlTtl", result.cacheControlTtl);
 	return next;
 }
+/** @internal */
+async function editNormalizeVolatileSystem(current) {
+	const result = await collectNormalizeVolatileSystem(current.normalizeVolatileSystem);
+	if (result === null) return current;
+	const next = { ...current };
+	applyField(next, "normalizeVolatileSystem", result.normalizeVolatileSystem);
+	return next;
+}
+async function applyFieldEdit(field, modelKey, current, client, configPath) {
+	switch (field) {
+		case "provider": return editProvider(modelKey, current, client);
+		case "sessionId": return editSessionId(current);
+		case "cacheControl": return editCacheControl(current, configPath);
+		case "normalizeVolatileSystem": return editNormalizeVolatileSystem(current);
+		default: return current;
+	}
+}
 /** Run the interactive "Edit model override" flow. */
 async function editOverrideCommand(client, configPath) {
 	intro("Edit Model Override");
@@ -18386,6 +18452,11 @@ async function editOverrideCommand(client, configPath) {
 					label: "Cache control",
 					hint: formatCacheHint(current.cacheControl, current.cacheControlTtl)
 				},
+				{
+					value: "normalizeVolatileSystem",
+					label: "Normalize volatile system",
+					hint: nvsHint(current.normalizeVolatileSystem)
+				},
 				{
 					value: "done",
 					label: "✓ Done"
@@ -18393,17 +18464,7 @@ async function editOverrideCommand(client, configPath) {
 			]
 		});
 		if (isCancel(field) || field === "done") break;
-		switch (field) {
-			case "provider":
-				current = await editProvider(modelKey, current, client);
-				break;
-			case "sessionId":
-				current = await editSessionId(current);
-				break;
-			case "cacheControl":
-				current = await editCacheControl(current, resolvedConfigPath);
-				break;
-		}
+		current = await applyFieldEdit(field, modelKey, current, client, resolvedConfigPath);
 	}
 	const save = await confirm({ message: "Save changes?" });
 	if (isCancel(save) || !save) {
@@ -19040,26 +19101,9 @@ async function normalizeVolatileSystemCommand(opts) {
 	const configPath = requireConfigPath(opts?.configPath);
 	const current = readConfigFile(configPath).normalizeVolatileSystem ?? DEFAULTS.normalizeVolatileSystem;
 	log.info(`Current: normalizeVolatileSystem = ${current}`);
-	const choice = await select({
-		message: "Normalize Claude Code's volatile cch hash in the system prompt? Stabilizes the prefix cache for non-Anthropic providers (qwen/glm/etc.).",
-		options: [
-			{
-				value: true,
-				label: "On",
-				hint: "rewrite cch → stable prefix"
-			},
-			{
-				value: false,
-				label: "Off",
-				hint: "passthrough"
-			},
-			{
-				value: "reset",
-				label: "Reset",
-				hint: `remove (default: ${DEFAULTS.normalizeVolatileSystem})`
-			}
-		],
-		initialValue: current
+	const choice = await askNormalizeVolatileSystem("Normalize Claude Code's volatile cch hash in the system prompt? Stabilizes the prefix cache for non-Anthropic providers (qwen/glm/etc.).", current, {
+		removable: true,
+		resetHint: `remove (default: ${DEFAULTS.normalizeVolatileSystem})`
 	});
 	if (typeof choice === "symbol") return;
 	const fields = {};
@@ -19200,7 +19244,7 @@ async function runConfigMenu(client) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.10.0";
+const version = "0.11.0";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -19438,6 +19482,142 @@ async function doctorCommand(opts = {}) {
 	return exitCode;
 }
 //#endregion
+//#region src/config-source.ts
+/** Default watcher: fs.watchFile polling; returns a stop function. */
+const watchStat = (filename, pollIntervalMs, onChange) => {
+	watchFile(filename, {
+		interval: pollIntervalMs,
+		persistent: false
+	}, onChange);
+	return () => unwatchFile(filename);
+};
+function fmt(value) {
+	if (value === void 0) return "unset";
+	if (value === true) return "on";
+	if (value === false) return "off";
+	return String(value);
+}
+const SCALAR_KEYS = [
+	"cacheControl",
+	"cacheControlTtl",
+	"sessionId",
+	"normalizeVolatileSystem",
+	"authType",
+	"verbose",
+	"bodyLimit",
+	"openrouterBaseUrl"
+];
+function canonicalEntries(record) {
+	if (!record) return "";
+	return JSON.stringify(Object.keys(record).sort().map((key) => [key, record[key]]));
+}
+/** Diff of cache-relevant fields; '' if nothing changed. */
+function summarizeChanges(prev, next) {
+	const parts = [];
+	for (const key of SCALAR_KEYS) if (prev[key] !== next[key]) parts.push(`${key}: ${fmt(prev[key])}→${fmt(next[key])}`);
+	if (JSON.stringify(buildProviderRouting(prev.provider)) !== JSON.stringify(buildProviderRouting(next.provider))) parts.push("provider routing");
+	if (canonicalEntries(prev.modelOverrides) !== canonicalEntries(next.modelOverrides)) {
+		const prevCount = prev.modelOverrides ? Object.keys(prev.modelOverrides).length : 0;
+		const nextCount = next.modelOverrides ? Object.keys(next.modelOverrides).length : 0;
+		parts.push(`modelOverrides: ${prevCount}→${nextCount}`);
+	}
+	if (canonicalEntries(prev.headers) !== canonicalEntries(next.headers)) parts.push("headers");
+	return parts.join(", ");
+}
+function createConfigSource(options) {
+	return new FileWatchingConfigSource(options);
+}
+var FileWatchingConfigSource = class {
+	current;
+	loadOptions;
+	load;
+	pollIntervalMs;
+	watch;
+	boundHost;
+	boundPort;
+	resolvedPath;
+	stopWatch;
+	loading = false;
+	pending = false;
+	watching = false;
+	constructor(options) {
+		this.current = options.initial;
+		this.loadOptions = options.loadOptions;
+		this.load = options.load ?? loadConfig;
+		this.pollIntervalMs = options.pollIntervalMs ?? 1e3;
+		this.watch = options.watch ?? watchStat;
+		this.boundHost = options.initial.host;
+		this.boundPort = options.initial.port;
+		this.resolvedPath = options.loadOptions.noConfig ? null : tryFindConfigFile(options.loadOptions.configPath);
+	}
+	get() {
+		return this.current;
+	}
+	async reload() {
+		if (this.loading) {
+			this.pending = true;
+			return { ok: true };
+		}
+		this.loading = true;
+		try {
+			const next = await this.load(this.loadOptions);
+			const restartNeeded = next.host !== this.boundHost || next.port !== this.boundPort;
+			let diff = "";
+			try {
+				diff = summarizeChanges(this.current, next);
+			} catch {
+				diff = "";
+			}
+			this.current = next;
+			if (restartNeeded) logger.warn("host/port changed — restart proxitor to apply (live reload does not re-bind the socket)");
+			logger.info(`Config reloaded${diff ? ` — ${diff}` : " (no material changes)"}`);
+			return { ok: true };
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			logger.error(`Config reload failed — keeping previous config: ${msg}`);
+			return {
+				ok: false,
+				error: msg
+			};
+		} finally {
+			this.loading = false;
+			if (this.pending) {
+				this.pending = false;
+				this.reload();
+			}
+		}
+	}
+	start() {
+		if (this.watching) return;
+		if (!this.resolvedPath) {
+			logger.info("Live config reload disabled (no config file)");
+			return;
+		}
+		this.watching = true;
+		const path = this.resolvedPath;
+		this.stopWatch = this.watch(path, this.pollIntervalMs, (curr, prev) => {
+			try {
+				this.onStat(path, curr, prev);
+			} catch {}
+		});
+	}
+	onStat(path, curr, prev) {
+		if (curr.nlink === 0) {
+			logger.warn(`config file disappeared — keeping current config (${path})`);
+			return;
+		}
+		if (curr.mtimeMs === prev.mtimeMs) return;
+		this.reload();
+	}
+	stop() {
+		if (this.watching) {
+			this.stopWatch?.();
+			this.stopWatch = void 0;
+			this.watching = false;
+		}
+	}
+};
+//#endregion
 //#region node_modules/.pnpm/@hono+node-server@2.0.4_hono@4.12.25/node_modules/@hono/node-server/dist/index.mjs
 var RequestError = class extends Error {
 	constructor(message, options) {
@@ -22832,20 +23012,23 @@ const injectChain = [
 	normalizeVolatileSystemMiddleware,
 	injectSessionId
 ];
-function createProxyServer(config, onReady) {
+function createProxyServer(source, onReady) {
 	const app = new Hono();
-	const globalRouting = buildProviderRouting(config.provider);
-	const modelOverrideKeys = Object.keys(config.modelOverrides ?? []);
 	app.use("*", async (c, next) => {
-		c.set("config", config);
+		c.set("config", source.get());
 		await next();
 	});
-	app.get("/health", (c) => c.json({
-		ok: true,
-		upstream: config.openrouterBaseUrl,
-		provider: globalRouting ?? "not configured",
-		modelOverrides: modelOverrideKeys
-	}));
+	app.get("/health", (c) => {
+		const config = source.get();
+		const globalRouting = buildProviderRouting(config.provider);
+		const modelOverrideKeys = Object.keys(config.modelOverrides ?? []);
+		return c.json({
+			ok: true,
+			upstream: config.openrouterBaseUrl,
+			provider: globalRouting ?? "not configured",
+			modelOverrides: modelOverrideKeys
+		});
+	});
 	for (const path of INJECT_PATHS) app.post(path, setupRequest, readBody, ...injectChain, buildUpstreamReq, forwardRequest);
 	app.all("*", setupRequest, readBody, resolveConfig, buildUpstreamReq, forwardRequest);
 	app.onError((err, c) => {
@@ -22856,20 +23039,22 @@ function createProxyServer(config, onReady) {
 			type: "proxy_internal_error"
 		} }, { status: 500 });
 	});
+	const initial = source.get();
 	return serve({
 		fetch: app.fetch,
-		port: config.port,
-		hostname: config.host
+		port: initial.port,
+		hostname: initial.host
 	}, onReady);
 }
 const SHUTDOWN_TIMEOUT_MS = 1e4;
-function startProxyServer(config, onReady) {
-	const server = createProxyServer(config, onReady);
+function startProxyServer(source, onReady) {
+	const server = createProxyServer(source, onReady);
 	let shuttingDown = false;
 	function shutdown(signal) {
 		if (shuttingDown) return;
 		shuttingDown = true;
 		logger.info(`${signal} received — draining active connections…`);
+		source.stop();
 		const timer = setTimeout(() => {
 			logger.warn("Forcing shutdown — drain timeout exceeded");
 			process.exit(1);
@@ -22987,17 +23172,24 @@ const startCommand = (0, import_cjs.command)({
 	},
 	handler: async ({ configPath, port, host, noConfig, openrouterKey, verbose }) => {
 		try {
-			const cfg = await loadConfig({
+			const loadOptions = {
 				configPath,
 				noConfig,
 				port,
 				host,
 				openrouterKey,
 				verbose
+			};
+			const cfg = await loadConfig(loadOptions);
+			const source = createConfigSource({
+				loadOptions,
+				initial: cfg
 			});
-			startProxyServer(cfg, () => {
+			source.start();
+			startProxyServer(source, () => {
 				logger.ready(`Proxitor proxy listening on ${cfg.host}:${cfg.port}`);
 				logger.info("Routing requests to OpenRouter");
+				if (source.resolvedPath) logger.info(`Watching ${source.resolvedPath} for changes (live reload)`);
 			});
 		} catch (error) {
 			logger.error("Failed to start proxy:", error);