@gajae-code/coding-agent 0.18.11 → 0.19.0

package/src/config/keybindings.ts

@@ -1,4 +1,17 @@
-import { copyFileSync, existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import {
+	closeSync,
+	constants,
+	existsSync,
+	fchmodSync,
+	fstatSync,
+	ftruncateSync,
+	lstatSync,
+	openSync,
+	readFileSync,
+	renameSync,
+	unlinkSync,
+	writeSync,
+} from "node:fs";
 import * as path from "node:path";
 import {
 	type Keybinding,
@@ -469,22 +482,156 @@ function loadRawConfig(filePath: string): unknown {
 	}
 }
 
+const KEYBINDINGS_MARKER_MODE = 0o600;
+
+type KeybindingsLeaf = "absent" | "file" | "symlink" | "other";
+
+function keybindingsLeaf(filePath: string): KeybindingsLeaf {
+	try {
+		const stat = lstatSync(filePath);
+		if (stat.isSymbolicLink()) return "symlink";
+		if (stat.isFile()) return "file";
+		return "other";
+	} catch (error) {
+		if (isEnoent(error)) return "absent";
+		throw error;
+	}
+}
+
+function writeAllSync(fd: number, content: string | Buffer): void {
+	const buffer = typeof content === "string" ? Buffer.from(content) : content;
+	let offset = 0;
+	while (offset < buffer.length) {
+		const wrote = writeSync(fd, buffer, offset, buffer.length - offset);
+		if (wrote <= 0) throw new Error("keybindings migration write was incomplete");
+		offset += wrote;
+	}
+}
+
+/** Create a new file. O_NOFOLLOW refuses a final symlink. A set mode is fchmod'd. */
+function writeExclusiveNoFollow(filePath: string, content: string | Buffer, mode: number | undefined): void {
+	const noFollow = process.platform === "win32" ? 0 : (constants.O_NOFOLLOW ?? 0);
+	const fd = openSync(filePath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | noFollow, mode ?? 0o666);
+	try {
+		writeAllSync(fd, content);
+		if (mode !== undefined && process.platform !== "win32") fchmodSync(fd, mode);
+	} finally {
+		closeSync(fd);
+	}
+}
+
+/** Copy bytes to the backup. A final symlink at either path is not opened for write. */
+function copyKeybindingsBackup(
+	source: string,
+	dest: string,
+	sourceKind: KeybindingsLeaf,
+	destKind: KeybindingsLeaf,
+): void {
+	const noFollow = process.platform === "win32" ? 0 : (constants.O_NOFOLLOW ?? 0);
+	// A symlinked config is still backed up from its target. The backup path itself stays no-follow.
+	const sourceFlags = constants.O_RDONLY | (sourceKind === "file" ? noFollow : 0);
+	const srcFd = openSync(source, sourceFlags);
+	try {
+		const stat = fstatSync(srcFd);
+		if (!stat.isFile()) throw new Error("keybindings migration target is not a regular file");
+		const bytes = readFileSync(srcFd);
+		const mode = stat.mode & 0o777;
+		if (destKind === "absent") {
+			writeExclusiveNoFollow(dest, bytes, mode);
+			return;
+		}
+		const fd = openSync(dest, constants.O_WRONLY | noFollow);
+		try {
+			const destStat = fstatSync(fd);
+			if (!destStat.isFile()) throw new Error("keybindings migration target is not a regular file");
+			if (destStat.dev === stat.dev && destStat.ino === stat.ino) return;
+			ftruncateSync(fd, 0);
+			writeAllSync(fd, bytes);
+			if (process.platform !== "win32") fchmodSync(fd, mode);
+		} finally {
+			closeSync(fd);
+		}
+	} finally {
+		closeSync(srcFd);
+	}
+}
+
+function migrationMarkerState(markerPath: string): { present: boolean; kind: KeybindingsLeaf } {
+	const kind = keybindingsLeaf(markerPath);
+	// A symlink is not a completed marker. existsSync only preserves the historical
+	// skip when that link already names a real target. The write path never opens it.
+	const present = kind === "file" || kind === "other" || (kind === "symlink" && existsSync(markerPath));
+	return { present, kind };
+}
+
+function writeMigratedKeybindings(
+	filePath: string,
+	markerPath: string,
+	markerKind: KeybindingsLeaf,
+	body: string,
+): void {
+	const tempPath = `${filePath}.${process.pid}.tmp`;
+	const bakPath = `${filePath}.bak`;
+	const bakKind = keybindingsLeaf(bakPath);
+	const tempKind = keybindingsLeaf(tempPath);
+	const sourceKind = keybindingsLeaf(filePath);
+	if (
+		bakKind === "symlink" ||
+		bakKind === "other" ||
+		tempKind === "symlink" ||
+		tempKind === "other" ||
+		(sourceKind !== "file" && sourceKind !== "symlink")
+	) {
+		throw new Error("keybindings migration target is not a regular file");
+	}
+	if (tempKind === "file") unlinkSync(tempPath);
+	if (keybindingsLeaf(filePath) !== sourceKind) {
+		throw new Error("keybindings migration target is not a regular file");
+	}
+	const mode = sourceKind === "file" ? lstatSync(filePath).mode & 0o777 : undefined;
+	try {
+		copyKeybindingsBackup(filePath, bakPath, sourceKind, bakKind);
+		writeExclusiveNoFollow(tempPath, body, mode);
+		const current = lstatSync(filePath);
+		if (sourceKind === "file" && (current.isSymbolicLink() || !current.isFile())) {
+			throw new Error("keybindings migration target is not a regular file");
+		}
+		renameSync(tempPath, filePath);
+		if (markerKind === "absent") writeExclusiveNoFollow(markerPath, "v1\n", KEYBINDINGS_MARKER_MODE);
+	} catch (error) {
+		if (keybindingsLeaf(tempPath) === "file") {
+			try {
+				unlinkSync(tempPath);
+			} catch {
+				// Best-effort removal of the unreplaced temp file.
+			}
+		}
+		throw error;
+	}
+}
+
 /** Migrate legacy keybindings once, preserving the original file as .bak. */
 function loadKeybindingsConfig(filePath: string, writeBack: boolean): KeybindingsConfig {
 	const rawConfig = loadRawConfig(filePath);
 	if (rawConfig === null) return {};
 	const markerPath = `${filePath}.migration-v1`;
-	const { config: migratedConfig, migrated } = existsSync(markerPath)
+	let markerKind: KeybindingsLeaf = "absent";
+	let markerPresent = false;
+	try {
+		const marker = migrationMarkerState(markerPath);
+		markerKind = marker.kind;
+		markerPresent = marker.present;
+	} catch (error) {
+		logger.warn("Failed to read keybindings migration marker", { path: markerPath, error: String(error) });
+		return toKeybindingsConfig(rawConfig);
+	}
+	const { config: migratedConfig, migrated } = markerPresent
 		? { config: toKeybindingsConfig(rawConfig), migrated: false }
 		: migrateKeybindingNames(rawConfig);
 	if (writeBack && migrated) {
 		const ordered = orderKeybindingsConfig(migratedConfig);
-		const tempPath = `${filePath}.${process.pid}.tmp`;
 		try {
-			copyFileSync(filePath, `${filePath}.bak`);
-			writeFileSync(tempPath, `${JSON.stringify(ordered, null, 2)}\n`, "utf-8");
-			renameSync(tempPath, filePath);
-			writeFileSync(markerPath, "v1\n", "utf-8");
+			writeMigratedKeybindings(filePath, markerPath, markerKind, `${JSON.stringify(ordered, null, 2)}\n`);
 			logger.debug("Migrated keybindings config", { path: filePath });
 		} catch (error) {
 			logger.warn("Failed to write migrated keybindings config", { path: filePath, error: String(error) });

package/src/config/model-bindings-applier.ts

@@ -10,12 +10,14 @@ export interface ConfiguredModelBindings {
 export class ModelBindingsApplier {
 	#targetSettings: Settings | undefined;
 	#bindings: ConfiguredModelBindings | undefined;
+	#lastAppliedRoles = new Map<string, ModelSelectorValue>();
+	#lastAppliedAgentOverrides = new Map<string, ModelSelectorValue>();
+	#manualRoles = new Map<string, ModelSelectorValue | undefined>();
+	#manualAgentOverrides = new Map<string, ModelSelectorValue | undefined>();
 	#appliedRoles = new Set<string>();
 	#appliedAgentOverrides = new Set<string>();
 	#roleBaselines = new Map<string, ModelSelectorValue | undefined>();
 	#agentBaselines = new Map<string, ModelSelectorValue | undefined>();
-	#lastAppliedRoles = new Map<string, ModelSelectorValue>();
-	#lastAppliedAgentOverrides = new Map<string, ModelSelectorValue>();
 
 	/** The currently configured bindings (as installed at startup), for baseline lookup. */
 	getBindings(): ConfiguredModelBindings | undefined {
@@ -71,6 +73,8 @@ export class ModelBindingsApplier {
 		this.#targetSettings = targetSettings;
 		const bindings = this.#bindings;
 		if (!targetSettings) return;
+		for (const role of Object.keys(bindings?.modelRoles ?? {})) this.#manualRoles.delete(role);
+		for (const role of Object.keys(bindings?.agentModelOverrides ?? {})) this.#manualAgentOverrides.delete(role);
 		const modelRoles = { ...(targetSettings.get("modelRoles") ?? {}) };
 		this.#forceSync(
 			modelRoles,
@@ -98,6 +102,13 @@ export class ModelBindingsApplier {
 		baselines: Map<string, ModelSelectorValue | undefined>,
 		lastApplied: Map<string, ModelSelectorValue>,
 	): void {
+		const configuredKeys = new Set(Object.keys(configured));
+		for (const key of applied) {
+			if (configuredKeys.has(key)) continue;
+			const baseline = baselines.get(key);
+			if (baseline === undefined) delete target[key];
+			else target[key] = this.#clone(baseline)!;
+		}
 		for (const [key, value] of Object.entries(configured)) {
 			if (!baselines.has(key)) baselines.set(key, this.#clone(target[key]));
 			target[key] = this.#clone(value)!;
@@ -111,82 +122,109 @@ export class ModelBindingsApplier {
 		const targetSettings = this.#targetSettings;
 		if (!targetSettings) return;
 		const bindings = this.#bindings;
-		const nextModelRoles = { ...(targetSettings.get("modelRoles") ?? {}) };
 		this.#sync(
-			nextModelRoles,
+			targetSettings,
+			"modelRoles",
 			bindings?.modelRoles ?? {},
-			this.#appliedRoles,
-			this.#roleBaselines,
 			this.#lastAppliedRoles,
+			this.#manualRoles,
+			this.#roleBaselines,
 		);
-		targetSettings.override("modelRoles", nextModelRoles);
-
-		const nextAgentOverrides = { ...(targetSettings.get("task.agentModelOverrides") ?? {}) };
 		this.#sync(
-			nextAgentOverrides,
+			targetSettings,
+			"task.agentModelOverrides",
 			bindings?.agentModelOverrides ?? {},
-			this.#appliedAgentOverrides,
-			this.#agentBaselines,
 			this.#lastAppliedAgentOverrides,
+			this.#manualAgentOverrides,
+			this.#agentBaselines,
 		);
-		targetSettings.override("task.agentModelOverrides", nextAgentOverrides);
 	}
 
 	#restoreTarget(targetSettings: Settings): void {
-		const modelRoles = { ...(targetSettings.get("modelRoles") ?? {}) };
-		this.#sync(modelRoles, {}, this.#appliedRoles, this.#roleBaselines, this.#lastAppliedRoles);
-		targetSettings.override("modelRoles", modelRoles);
-
-		const agentOverrides = { ...(targetSettings.get("task.agentModelOverrides") ?? {}) };
 		this.#sync(
-			agentOverrides,
+			targetSettings,
+			"task.agentModelOverrides",
 			{},
-			this.#appliedAgentOverrides,
-			this.#agentBaselines,
 			this.#lastAppliedAgentOverrides,
+			this.#manualAgentOverrides,
+			this.#agentBaselines,
 		);
-		targetSettings.override("task.agentModelOverrides", agentOverrides);
+		this.#sync(targetSettings, "modelRoles", {}, this.#lastAppliedRoles, this.#manualRoles, this.#roleBaselines);
 	}
 
 	#clearTargetLifecycle(): void {
-		this.#appliedRoles.clear();
-		this.#appliedAgentOverrides.clear();
-		this.#roleBaselines.clear();
-		this.#agentBaselines.clear();
 		this.#lastAppliedRoles.clear();
 		this.#lastAppliedAgentOverrides.clear();
+		this.#manualRoles.clear();
+		this.#manualAgentOverrides.clear();
+		this.#roleBaselines.clear();
+		this.#agentBaselines.clear();
 	}
 
 	#sync(
-		target: Record<string, ModelSelectorValue>,
+		targetSettings: Settings,
+		settingPath: "modelRoles" | "task.agentModelOverrides",
 		configured: Record<string, ModelSelectorValue>,
-		applied: Set<string>,
-		baselines: Map<string, ModelSelectorValue | undefined>,
 		lastApplied: Map<string, ModelSelectorValue>,
+		manualOverrides: Map<string, ModelSelectorValue | undefined>,
+		baselines: Map<string, ModelSelectorValue | undefined>,
 	): void {
 		const configuredKeys = new Set(Object.keys(configured));
-		for (const key of applied) {
-			if (configuredKeys.has(key)) continue;
-			const previous = lastApplied.get(key);
-			if (previous !== undefined && this.#equal(target[key], previous)) {
-				const baseline = baselines.get(key);
-				if (baseline === undefined) delete target[key];
-				else target[key] = this.#clone(baseline)!;
+		const current = (targetSettings.get(settingPath) ?? {}) as Record<string, ModelSelectorValue>;
+		const global = (targetSettings.getGlobal(settingPath) ?? {}) as Record<string, ModelSelectorValue>;
+		const runtime = targetSettings.getOverride(settingPath) ?? {};
+		for (const key of configuredKeys) {
+			if (!lastApplied.has(key) && !baselines.has(key)) baselines.set(key, this.#clone(runtime[key]));
+		}
+
+		// Manual bindings remain authoritative, but their cached values must follow
+		// later edits and removals from the runtime override slots.
+		for (const key of manualOverrides.keys()) {
+			manualOverrides.set(key, this.#clone(runtime[key]));
+		}
+
+		// Keep existing non-global values that belong to another runtime layer.
+		for (const [key, value] of Object.entries(current)) {
+			if (configuredKeys.has(key) || lastApplied.has(key) || manualOverrides.has(key)) continue;
+			if (!this.#equal(value, global[key])) manualOverrides.set(key, this.#clone(value)!);
+		}
+
+		// A value changed while our previous overlay was active is a manual edit.
+		for (const [key, previous] of lastApplied) {
+			const currentValue = current[key];
+			if (!Object.hasOwn(runtime, key) || !Object.hasOwn(current, key)) {
+				manualOverrides.set(key, undefined);
+			} else if (!this.#equal(runtime[key], previous)) {
+				manualOverrides.set(key, this.#clone(runtime[key])!);
+			} else if (!this.#equal(currentValue, previous)) {
+				manualOverrides.set(key, this.#clone(currentValue)!);
 			}
-			baselines.delete(key);
-			lastApplied.delete(key);
 		}
-		for (const [key, value] of Object.entries(configured)) {
-			const previous = lastApplied.get(key);
-			if (!baselines.has(key)) baselines.set(key, this.#clone(target[key]));
-			if (previous === undefined || this.#equal(target[key], previous)) {
-				const appliedValue = this.#clone(value)!;
-				target[key] = appliedValue;
-				lastApplied.set(key, this.#clone(appliedValue)!);
+
+		const nextOverrides: Record<string, ModelSelectorValue> = {};
+		for (const [key, value] of Object.entries(runtime)) {
+			if (!lastApplied.has(key) && !configuredKeys.has(key)) nextOverrides[key] = this.#clone(value)!;
+		}
+		for (const [key, baseline] of baselines) {
+			if (!configuredKeys.has(key)) {
+				if (baseline !== undefined) nextOverrides[key] = this.#clone(baseline)!;
+				baselines.delete(key);
 			}
 		}
-		applied.clear();
-		for (const key of configuredKeys) applied.add(key);
+		for (const [key, value] of manualOverrides) {
+			if (value === undefined) delete nextOverrides[key];
+			else nextOverrides[key] = this.#clone(value)!;
+		}
+		lastApplied.clear();
+		for (const [key, value] of Object.entries(configured)) {
+			if (manualOverrides.has(key)) continue;
+			const appliedValue = this.#clone(value)!;
+			nextOverrides[key] = appliedValue;
+			lastApplied.set(key, this.#clone(appliedValue)!);
+		}
+
+		if (Object.keys(nextOverrides).length === 0) targetSettings.clearOverride(settingPath);
+		else targetSettings.override(settingPath, nextOverrides);
 	}
 
 	#cloneBindings(

package/src/config/model-discovery-manager.ts

@@ -100,6 +100,16 @@ export class ModelDiscoveryManager<TProvider extends DiscoveryProvider> {
 		const state = this.#states.get(provider);
 		return state === undefined ? undefined : this.#snapshot(state);
 	}
+
+	/** Retain accepted discovery evidence for unchanged providers during a local reload. */
+	retainStatesFrom(source: ModelDiscoveryManager<TProvider>, providers: ReadonlySet<string>): void {
+		for (const provider of this.#providers) {
+			if (!providers.has(provider.provider)) continue;
+			const state = source.#states.get(provider.provider);
+			if (state) this.#states.set(provider.provider, this.#snapshot(state));
+		}
+	}
+
 	invalidate(provider: string): void {
 		this.#invalidate(provider);
 		this.#states.delete(provider);