@gajae-code/coding-agent 0.11.1 → 0.11.2

package/src/config/file-lock.ts

@@ -1,5 +1,6 @@
 import type { Stats } from "node:fs";
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { isEnoent } from "@gajae-code/utils/fs-error";
 
 export interface FileLockOptions {
@@ -14,45 +15,93 @@ const DEFAULT_OPTIONS: Required<FileLockOptions> = {
 	retryDelayMs: 100,
 };
 
-interface LockInfo {
-	pid: number;
-	timestamp: number;
+type LockInfo = FileLockOwnerToken;
+
+/**
+ * Returns the OS-provided process start timestamp for PID-reuse detection.
+ * `ps` is available on the supported Unix hosts (macOS and Linux), unlike
+ * Linux's `/proc/<pid>/stat` pseudo-file.
+ */
+export function processStartTime(pid: number): string | null {
+	try {
+		const result = Bun.spawnSync(["ps", "-o", "lstart=", "-p", String(pid)], { stdout: "pipe", stderr: "ignore" });
+		if (result.exitCode !== 0) return null;
+		const startTime = new TextDecoder().decode(result.stdout).trim();
+		return startTime || null;
+	} catch {
+		return null;
+	}
 }
 
-function getLockPath(filePath: string): string {
-	return `${filePath}.lock`;
+let ownProcessStartTime: string | undefined;
+
+function currentProcessStartTime(): string {
+	if (ownProcessStartTime === undefined) ownProcessStartTime = processStartTime(process.pid) ?? "unknown";
+	return ownProcessStartTime;
+}
+
+function cachedProcessStartTime(owner: FileLockOwnerToken, cache?: Map<string, string | null>): string | null {
+	if (!cache) return processStartTime(owner.pid);
+	const key = `${owner.pid}:${owner.start_time ?? ""}`;
+	const cached = cache.get(key);
+	if (cached !== undefined || cache.has(key)) return cached ?? null;
+	const startTime = processStartTime(owner.pid);
+	cache.set(key, startTime);
+	return startTime;
+}
+
+function ownerIsAlive(owner: FileLockOwnerToken, startTimeCache?: Map<string, string | null>): boolean {
+	if (ownerLiveness(owner.pid) !== "alive") return false;
+	if (!owner.start_time) return true;
+	const currentStartTime = cachedProcessStartTime(owner, startTimeCache);
+	return currentStartTime === null || currentStartTime === owner.start_time;
 }
 
-async function writeLockInfo(lockPath: string): Promise<LockInfo> {
-	const info: LockInfo = { pid: process.pid, timestamp: Date.now() };
-	await Bun.write(`${lockPath}/info`, JSON.stringify(info));
-	return info;
+function writeLockInfo(lockPath: string): Promise<LockInfo> {
+	const info: LockInfo = { pid: process.pid, start_time: currentProcessStartTime(), timestamp: Date.now() };
+	return Bun.write(`${lockPath}/info`, JSON.stringify(info)).then(() => info);
 }
 
 async function readLockInfo(lockPath: string): Promise<LockInfo | null> {
+	let parsed: unknown;
 	try {
-		const content = await fs.readFile(`${lockPath}/info`, "utf-8");
-		return JSON.parse(content) as LockInfo;
-	} catch {
-		return null;
+		parsed = JSON.parse(await fs.readFile(`${lockPath}/info`, "utf-8"));
+	} catch (error) {
+		if (isEnoent(error) || error instanceof SyntaxError) return null;
+		throw error;
 	}
+
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+	const { pid, start_time, timestamp } = parsed as Partial<LockInfo>;
+	if (
+		typeof pid !== "number" ||
+		!Number.isInteger(pid) ||
+		pid <= 0 ||
+		typeof timestamp !== "number" ||
+		!Number.isFinite(timestamp) ||
+		(start_time !== undefined && (typeof start_time !== "string" || !start_time))
+	)
+		return null;
+	return { pid, start_time, timestamp };
 }
 
 /** @internal */
-export async function readFileLockInfoForGc(lockDir: string): Promise<{ pid: number; timestamp: number } | null> {
-	const info = await readLockInfo(lockDir);
-	if (!info) return null;
-	if (!Number.isFinite(info.pid) || info.pid <= 0) return null;
-	if (!Number.isFinite(info.timestamp)) return null;
-	return info;
+export async function readFileLockInfoForGc(lockDir: string): Promise<FileLockOwnerToken | null> {
+	return await readLockInfo(lockDir);
 }
 
 /** Owner identity stamped into a `<file>.lock/info` record. */
 export interface FileLockOwnerToken {
 	pid: number;
+	start_time?: string;
+
 	timestamp: number;
 }
 
+function getLockPath(filePath: string): string {
+	return `${filePath}.lock`;
+}
+
 /** Outcome of a guarded lock-dir removal attempt (`removeFileLockDirForGc`). */
 export type FileLockGcRemoval = "removed" | "owner_changed" | "missing";
 
@@ -91,7 +140,11 @@ export async function removeFileLockDirForGc(
 ): Promise<FileLockGcRemoval> {
 	const current = await readLockInfo(lockDir);
 	if (!current) return "missing";
-	if (current.pid !== expected.pid || current.timestamp !== expected.timestamp) {
+	if (
+		current.pid !== expected.pid ||
+		(expected.start_time !== undefined && current.start_time !== expected.start_time) ||
+		current.timestamp !== expected.timestamp
+	) {
 		return "owner_changed";
 	}
 	await fs.rm(lockDir, { recursive: true, force: true });
@@ -127,7 +180,11 @@ function sameStatToken(a: LockDirStatToken, b: LockDirStatToken): boolean {
 	return a.dev === b.dev && a.ino === b.ino && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
 }
 
-async function staleLockSnapshot(lockPath: string, staleMs: number): Promise<LockStaleSnapshot> {
+async function staleLockSnapshot(
+	lockPath: string,
+	staleMs: number,
+	startTimeCache?: Map<string, string | null>,
+): Promise<LockStaleSnapshot> {
 	const info = await readLockInfo(lockPath);
 	if (!info) {
 		try {
@@ -143,10 +200,9 @@ async function staleLockSnapshot(lockPath: string, staleMs: number): Promise<Loc
 	// Never reap a live owner by elapsed time: a long legitimate critical section must
 	// not have its lock stolen (#652). Reclaim a dead owner immediately. Only when owner
 	// liveness is indeterminate do we fall back to the staleMs elapsed-time heuristic.
-	const liveness = ownerLiveness(info.pid);
-	if (liveness === "alive") return { stale: false };
-	if (liveness === "dead" || Date.now() - info.timestamp > staleMs) {
-		return { stale: true, owner: { pid: info.pid, timestamp: info.timestamp } };
+	if (ownerIsAlive(info, startTimeCache)) return { stale: false };
+	if (ownerLiveness(info.pid) === "dead" || Date.now() - info.timestamp > staleMs) {
+		return { stale: true, owner: info };
 	}
 	return { stale: false };
 }
@@ -171,6 +227,7 @@ async function removeStaleLockForAcquire(lockPath: string, snapshot: LockStaleSn
 }
 
 async function tryAcquireLock(lockPath: string): Promise<LockInfo | null> {
+	await fs.mkdir(path.dirname(lockPath), { recursive: true });
 	try {
 		await fs.mkdir(lockPath);
 		return await writeLockInfo(lockPath);
@@ -183,42 +240,47 @@ async function tryAcquireLock(lockPath: string): Promise<LockInfo | null> {
 }
 
 async function releaseLock(lockPath: string, owner: FileLockOwnerToken): Promise<void> {
-	try {
-		await removeFileLockDirForGc(lockPath, owner);
-	} catch {
-		// Ignore errors on release
-	}
+	const outcome = await removeFileLockDirForGc(lockPath, owner);
+	if (outcome !== "removed") throw new Error(`Failed to release file lock: ${outcome}.`);
 }
 async function acquireLock(filePath: string, options: FileLockOptions = {}): Promise<() => Promise<void>> {
 	const opts = { ...DEFAULT_OPTIONS, ...options };
 	const lockPath = getLockPath(filePath);
-
+	const contentionStartTimes = new Map<string, string | null>();
 	for (let attempt = 0; attempt < opts.retries; attempt++) {
 		const owner = await tryAcquireLock(lockPath);
-		if (owner) {
-			return () => releaseLock(lockPath, owner);
-		}
-
-		const stale = await staleLockSnapshot(lockPath, opts.staleMs);
-		if (await removeStaleLockForAcquire(lockPath, stale)) {
-			continue;
-		}
+		if (owner) return () => releaseLock(lockPath, owner);
 
+		const stale = await staleLockSnapshot(lockPath, opts.staleMs, contentionStartTimes);
+		if (await removeStaleLockForAcquire(lockPath, stale)) continue;
 		await Bun.sleep(opts.retryDelayMs);
 	}
-
 	throw new Error(`Failed to acquire lock for ${filePath} after ${opts.retries} attempts`);
 }
 
+/**
+ * Serializes all contenders, including callers in the same process. Because this
+ * API exposes no ownership token, recursive acquisition is indistinguishable
+ * from independent async contention; code that already holds the lock must pass
+ * that fact through its own `lockHeld` path instead of acquiring it again.
+ */
 export async function withFileLock<T>(
 	filePath: string,
 	fn: () => Promise<T>,
 	options: FileLockOptions = {},
 ): Promise<T> {
 	const release = await acquireLock(filePath, options);
+	let result: T;
 	try {
-		return await fn();
-	} finally {
-		await release();
+		result = await fn();
+	} catch (operationError) {
+		try {
+			await release();
+		} catch (releaseError) {
+			throw new AggregateError([operationError, releaseError], "File lock operation and release both failed.");
+		}
+		throw operationError;
 	}
+	await release();
+	return result;
 }

package/src/config/keybindings.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import * as path from "node:path";
 import {
 	type Keybinding,
@@ -41,6 +41,7 @@ interface AppKeybindings {
 	"app.session.fork": true;
 	"app.session.resume": true;
 	"app.session.observe": true;
+	"app.session.dashboard": true;
 	"app.jobs.open": true;
 	"app.session.togglePath": true;
 	"app.session.toggleSort": true;
@@ -53,6 +54,13 @@ interface AppKeybindings {
 	"app.history.search": true;
 	"app.stt.toggle": true;
 	"app.irc.sidebar.toggle": true;
+	"app.transcript.browse": true;
+	"app.transcript.prevTurn": true;
+	"app.transcript.nextTurn": true;
+	"app.mode.cycle": true;
+	"app.tasks.toggle": true;
+	"app.queue.togglePane": true;
+	"app.message.sendNow": true;
 }
 
 export type AppKeybinding = keyof AppKeybindings;
@@ -65,6 +73,10 @@ export function defaultMessageQueueKeysForPlatform(platform: NodeJS.Platform = p
 	return platform === "win32" || platform === "darwin" ? "alt+q" : "alt+enter";
 }
 
+export function defaultClipboardPasteImageKeysForPlatform(platform: NodeJS.Platform = process.platform): KeyId {
+	return platform === "win32" ? "alt+v" : "ctrl+v";
+}
+
 /**
  * All keybindings definitions: TUI + app-specific.
  */
@@ -139,7 +151,7 @@ export const KEYBINDINGS = {
 		description: "Select queued message to edit",
 	},
 	"app.clipboard.pasteImage": {
-		defaultKeys: process.platform === "win32" ? "alt+v" : "ctrl+v",
+		defaultKeys: defaultClipboardPasteImageKeysForPlatform(),
 		description: "Paste image from clipboard",
 	},
 	"app.clipboard.copyLine": {
@@ -170,6 +182,10 @@ export const KEYBINDINGS = {
 		defaultKeys: "ctrl+s",
 		description: "Observe subagent sessions",
 	},
+	"app.session.dashboard": {
+		defaultKeys: [],
+		description: "Show all persisted sessions dashboard",
+	},
 
 	"app.jobs.open": {
 		defaultKeys: "alt+j",
@@ -219,6 +235,34 @@ export const KEYBINDINGS = {
 		defaultKeys: "alt+i",
 		description: "Toggle IRC sidebar",
 	},
+	"app.transcript.browse": {
+		defaultKeys: [],
+		description: "Browse the transcript",
+	},
+	"app.transcript.prevTurn": {
+		defaultKeys: [],
+		description: "Jump to previous user turn",
+	},
+	"app.transcript.nextTurn": {
+		defaultKeys: [],
+		description: "Jump to next user turn",
+	},
+	"app.mode.cycle": {
+		defaultKeys: [],
+		description: "Cycle interaction mode",
+	},
+	"app.tasks.toggle": {
+		defaultKeys: "alt+t",
+		description: "Toggle tasks pane",
+	},
+	"app.queue.togglePane": {
+		defaultKeys: [],
+		description: "Toggle message queue pane",
+	},
+	"app.message.sendNow": {
+		defaultKeys: [],
+		description: "Send message immediately",
+	},
 } as const satisfies KeybindingDefinitions;
 
 /**
@@ -304,13 +348,14 @@ function toKeybindingsConfig(value: unknown): KeybindingsConfig {
 
 	const config: KeybindingsConfig = {};
 	for (const [key, val] of Object.entries(value)) {
-		if (val === undefined) {
-			config[key] = undefined;
-		} else if (typeof val === "string") {
-			config[key] = val as KeyId;
-		} else if (Array.isArray(val) && val.every(v => typeof v === "string")) {
-			config[key] = val as KeyId[];
+		if (!(key in KEYBINDINGS) && !isLegacyKeybindingName(key)) {
+			logger.info("Ignoring unknown keybinding entry", { key });
+			continue;
 		}
+		if (val === undefined) config[key] = undefined;
+		else if (typeof val === "string") config[key] = val as KeyId;
+		else if (Array.isArray(val) && val.every(v => typeof v === "string")) config[key] = val as KeyId[];
+		else logger.info("Ignoring malformed keybinding entry", { key });
 	}
 	return config;
 }
@@ -381,28 +426,27 @@ function loadRawConfig(filePath: string): unknown {
 	}
 }
 
-/**
- * Migrate keybindings config file from old format to new.
- * Reads from agentDir/keybindings.json, migrates old names, and writes back.
- */
+/** 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 { config: migratedConfig, migrated } = migrateKeybindingNames(rawConfig);
+	if (rawConfig === null) return {};
+	const markerPath = `${filePath}.migration-v1`;
+	const { config: migratedConfig, migrated } = existsSync(markerPath)
+		? { config: toKeybindingsConfig(rawConfig), migrated: false }
+		: migrateKeybindingNames(rawConfig);
 	if (writeBack && migrated) {
 		const ordered = orderKeybindingsConfig(migratedConfig);
+		const tempPath = `${filePath}.${process.pid}.tmp`;
 		try {
-			writeFileSync(filePath, `${JSON.stringify(ordered, null, 2)}\n`, "utf-8");
+			copyFileSync(filePath, `${filePath}.bak`);
+			writeFileSync(tempPath, `${JSON.stringify(ordered, null, 2)}\n`, "utf-8");
+			renameSync(tempPath, filePath);
+			writeFileSync(markerPath, "v1\n", "utf-8");
 			logger.debug("Migrated keybindings config", { path: filePath });
 		} catch (error) {
 			logger.warn("Failed to write migrated keybindings config", { path: filePath, error: String(error) });
 		}
 	}
-
 	return migratedConfig;
 }
 

package/src/config/model-auth.ts

@@ -0,0 +1,9 @@
+export const kNoAuth = "N/A";
+
+export function isAuthenticated(apiKey: string | undefined | null): apiKey is string {
+	return Boolean(apiKey) && apiKey !== kNoAuth;
+}
+
+export function isAuthenticatedOrKeyless(apiKey: string | undefined | null): boolean {
+	return apiKey === kNoAuth || isAuthenticated(apiKey);
+}

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

@@ -0,0 +1,139 @@
+import { type ModelSelectorValue, normalizeModelSelectorValue } from "./model-selector-value";
+import type { Settings } from "./settings";
+
+export interface ConfiguredModelBindings {
+	modelRoles?: Record<string, ModelSelectorValue>;
+	agentModelOverrides?: Record<string, ModelSelectorValue>;
+}
+
+/** Synchronizes config-owned model bindings while preserving user edits. */
+export class ModelBindingsApplier {
+	#targetSettings: Settings | undefined;
+	#bindings: ConfiguredModelBindings | 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>();
+
+	setBindings(bindings: ConfiguredModelBindings | undefined): void {
+		this.#bindings = bindings && {
+			modelRoles: this.#cloneBindings(bindings.modelRoles),
+			agentModelOverrides: this.#cloneBindings(bindings.agentModelOverrides),
+		};
+	}
+
+	applyTo(targetSettings: Settings): void {
+		if (this.#targetSettings && this.#targetSettings !== targetSettings) {
+			this.#restoreTarget(this.#targetSettings);
+			this.#clearTargetLifecycle();
+		}
+		this.#targetSettings = targetSettings;
+		this.apply();
+	}
+
+	apply(): void {
+		const targetSettings = this.#targetSettings;
+		if (!targetSettings) return;
+		const bindings = this.#bindings;
+		const nextModelRoles = { ...(targetSettings.get("modelRoles") ?? {}) };
+		this.#sync(
+			nextModelRoles,
+			bindings?.modelRoles ?? {},
+			this.#appliedRoles,
+			this.#roleBaselines,
+			this.#lastAppliedRoles,
+		);
+		targetSettings.override("modelRoles", nextModelRoles);
+
+		const nextAgentOverrides = { ...(targetSettings.get("task.agentModelOverrides") ?? {}) };
+		this.#sync(
+			nextAgentOverrides,
+			bindings?.agentModelOverrides ?? {},
+			this.#appliedAgentOverrides,
+			this.#agentBaselines,
+			this.#lastAppliedAgentOverrides,
+		);
+		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,
+			{},
+			this.#appliedAgentOverrides,
+			this.#agentBaselines,
+			this.#lastAppliedAgentOverrides,
+		);
+		targetSettings.override("task.agentModelOverrides", agentOverrides);
+	}
+
+	#clearTargetLifecycle(): void {
+		this.#appliedRoles.clear();
+		this.#appliedAgentOverrides.clear();
+		this.#roleBaselines.clear();
+		this.#agentBaselines.clear();
+		this.#lastAppliedRoles.clear();
+		this.#lastAppliedAgentOverrides.clear();
+	}
+
+	#sync(
+		target: Record<string, ModelSelectorValue>,
+		configured: Record<string, ModelSelectorValue>,
+		applied: Set<string>,
+		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 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)!;
+			}
+			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)!);
+			}
+		}
+		applied.clear();
+		for (const key of configuredKeys) applied.add(key);
+	}
+
+	#cloneBindings(
+		bindings: Record<string, ModelSelectorValue> | undefined,
+	): Record<string, ModelSelectorValue> | undefined {
+		if (!bindings) return undefined;
+		const copy: Record<string, ModelSelectorValue> = {};
+		for (const [key, value] of Object.entries(bindings)) copy[key] = this.#clone(value)!;
+		return copy;
+	}
+
+	#clone(value: ModelSelectorValue | undefined): ModelSelectorValue | undefined {
+		return Array.isArray(value) ? [...value] : value;
+	}
+
+	#equal(left: ModelSelectorValue | undefined, right: ModelSelectorValue | undefined): boolean {
+		const leftSelectors = normalizeModelSelectorValue(left);
+		const rightSelectors = normalizeModelSelectorValue(right);
+		return (
+			leftSelectors.length === rightSelectors.length &&
+			leftSelectors.every((value, index) => value === rightSelectors[index])
+		);
+	}
+}