@gajae-code/coding-agent 0.11.1 → 0.11.3

package/src/config/atomic-yaml-patch.ts

@@ -4,19 +4,40 @@ import * as path from "node:path";
 import { YAML } from "bun";
 import { withFileLock } from "./file-lock";
 
+export interface AtomicYamlExpectedPrecondition {
+	path: string;
+	hash: string;
+}
+
 export interface AtomicYamlSetPatch {
 	path: string;
 	op: "set";
 	value: unknown;
+	expected?: AtomicYamlExpectedPrecondition;
 }
 
 export interface AtomicYamlUnsetPatch {
 	path: string;
 	op: "unset";
+	expected?: AtomicYamlExpectedPrecondition;
 }
 
 export type AtomicYamlPatch = AtomicYamlSetPatch | AtomicYamlUnsetPatch;
 
+/** Raised when a compare-and-swap precondition no longer matches durable YAML. */
+export class AtomicYamlConflictError extends Error {
+	readonly code = "ATOMIC_YAML_CONFLICT";
+
+	constructor(
+		readonly path: string,
+		readonly expectedHash: string,
+		readonly actualHash: string,
+	) {
+		super(`Atomic YAML precondition failed for ${path}.`);
+		this.name = "AtomicYamlConflictError";
+	}
+}
+
 export interface AtomicYamlPatchRevision {
 	path: string;
 	beforeHash: string;
@@ -53,6 +74,8 @@ export interface AtomicYamlPatchOptions {
 	sleep?: (ms: number) => Promise<void>;
 	/** Test seam for Windows rename retry behavior. */
 	platform?: NodeJS.Platform;
+	/** Called under the config lock before patches are applied. */
+	validateRoot?: (root: unknown, patches: readonly AtomicYamlPatch[]) => void | Promise<void>;
 	/** Called under the config lock after a successful CAS restore. */
 	onRestored?: (patches: readonly AtomicYamlPatch[]) => void | Promise<void>;
 }
@@ -98,6 +121,16 @@ function assertPatch(patch: AtomicYamlPatch): void {
 	) {
 		throw new Error("Atomic YAML patches require a non-empty dotted path.");
 	}
+	if (
+		patch.expected &&
+		(typeof patch.expected.path !== "string" ||
+			patch.expected.path.length === 0 ||
+			patch.expected.path.split(".").some(part => !part) ||
+			typeof patch.expected.hash !== "string" ||
+			patch.expected.hash.length === 0)
+	) {
+		throw new Error("Atomic YAML patch preconditions require a non-empty dotted path and hash.");
+	}
 	if (patch.op === "set") {
 		if (patch.value === undefined) {
 			throw new TypeError(`Atomic YAML set patch for ${patch.path} cannot carry undefined; use unset instead.`);
@@ -148,6 +181,12 @@ export function deleteByPath(value: Record<string, unknown>, segments: readonly
 }
 
 function stableValue(value: unknown): string {
+	if (typeof value === "number") {
+		if (Number.isNaN(value)) return "NaN";
+		if (value === Infinity) return "Infinity";
+		if (value === -Infinity) return "-Infinity";
+		if (Object.is(value, -0)) return "-0";
+	}
 	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "undefined";
 	if (Array.isArray(value)) return `[${value.map(stableValue).join(",")}]`;
 	const object = value as Record<string, unknown>;
@@ -167,12 +206,22 @@ function cloneState(state: PathState): PathState {
 	return state.exists ? { exists: true, value: structuredClone(state.value) } : state;
 }
 
-async function readYaml(configPath: string): Promise<Record<string, unknown>> {
+/** Hash a dotted YAML path state for an expected-hash patch precondition. */
+export function atomicYamlPathHash(value: Record<string, unknown>, path: string): string {
+	return stateHash(stateAtPath(value, path.split(".")));
+}
+
+type YamlReadResult = {
+	current: Record<string, unknown>;
+	root: unknown;
+};
+
+async function readYaml(configPath: string): Promise<YamlReadResult> {
 	try {
-		const parsed = YAML.parse(await fs.readFile(configPath, "utf8"));
-		return record(parsed) ?? {};
+		const root = YAML.parse(await fs.readFile(configPath, "utf8"));
+		return { current: record(root) ?? {}, root };
 	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return {};
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return { current: {}, root: undefined };
 		throw error;
 	}
 }
@@ -254,8 +303,9 @@ function createReceipt(
 		async restore(): Promise<CasRestoreResult> {
 			if (discarded) return { status: "discarded" };
 			return await enqueueAtomicYamlOperation(configPath, async canonicalPath => {
+				if (discarded) return { status: "discarded" };
 				return await withFileLock(canonicalPath, async () => {
-					const current = await readYaml(canonicalPath);
+					const { current, root } = await readYaml(canonicalPath);
 					const conflicts = changes
 						.filter(
 							change =>
@@ -269,6 +319,7 @@ function createReceipt(
 							? { path: change.path, op: "set", value: structuredClone(change.before.value) }
 							: { path: change.path, op: "unset" },
 					);
+					await options.validateRoot?.(root, restorePatches);
 					const receipt = await applyPatchesUnderLock(canonicalPath, current, restorePatches, options);
 					await options.onRestored?.(restorePatches);
 					return { status: "restored", receipt };
@@ -286,6 +337,14 @@ async function applyPatchesUnderLock(
 ): Promise<CasReceipt> {
 	if (patches.length === 0) return createReceipt(configPath, [], options);
 
+	for (const patch of patches) {
+		if (!patch.expected) continue;
+		const actualHash = stateHash(stateAtPath(current, patch.expected.path.split(".")));
+		if (actualHash !== patch.expected.hash) {
+			throw new AtomicYamlConflictError(patch.expected.path, patch.expected.hash, actualHash);
+		}
+	}
+
 	const changesByPath = new Map<string, ReceiptChange>();
 	for (const patch of patches) {
 		const segments = patch.path.split(".");
@@ -329,9 +388,10 @@ export function applyAtomicYamlPatchesWithCurrent(
 	return enqueueAtomicYamlOperation(configPath, async canonicalPath => {
 		await fs.mkdir(path.dirname(canonicalPath), { recursive: true, mode: 0o700 });
 		return await withFileLock(canonicalPath, async () => {
-			const current = await readYaml(canonicalPath);
+			const { current, root } = await readYaml(canonicalPath);
 			const patches = await buildPatches(current);
 			for (const patch of patches) assertPatch(patch);
+			await options.validateRoot?.(root, patches);
 			return await applyPatchesUnderLock(canonicalPath, current, patches, options);
 		});
 	});
@@ -374,7 +434,8 @@ export function reserveAtomicYamlPatchSlot(
 		for (const patch of nextPatches) assertPatch(patch);
 		await fs.mkdir(path.dirname(canonicalPath), { recursive: true, mode: 0o700 });
 		return await withFileLock(canonicalPath, async () => {
-			const current = await readYaml(canonicalPath);
+			const { current, root } = await readYaml(canonicalPath);
+			await options.validateRoot?.(root, nextPatches);
 			return await applyPatchesUnderLock(canonicalPath, current, nextPatches, options);
 		});
 	});
@@ -393,7 +454,7 @@ export function reserveAtomicYamlUpdateSlot<T>(
 		const atomicUpdate = await update();
 		await fs.mkdir(path.dirname(canonicalPath), { recursive: true, mode: 0o700 });
 		return await withFileLock(canonicalPath, async () => {
-			const current = await readYaml(canonicalPath);
+			const { current } = await readYaml(canonicalPath);
 			const result = await atomicUpdate.apply(current);
 			if (atomicUpdate.shouldWrite?.(result) !== false) {
 				await writeAtomicYaml(canonicalPath, current, options);
@@ -414,10 +475,16 @@ export function applyAtomicYamlPatches(
 	options: AtomicYamlPatchOptions = {},
 ): Promise<CasReceipt> {
 	for (const patch of patches) assertPatch(patch);
-	const immutablePatches = patches.map(patch =>
-		patch.op === "set"
-			? ({ path: patch.path, op: "set", value: structuredClone(patch.value) } as const)
-			: ({ path: patch.path, op: "unset" } as const),
-	);
+	const immutablePatches = patches.map(patch => {
+		const expected = patch.expected ? { ...patch.expected } : undefined;
+		return patch.op === "set"
+			? ({
+					path: patch.path,
+					op: "set",
+					value: structuredClone(patch.value),
+					...(expected ? { expected } : {}),
+				} as const)
+			: ({ path: patch.path, op: "unset", ...(expected ? { expected } : {}) } as const);
+	});
 	return reserveAtomicYamlPatchSlot(configPath, () => immutablePatches, options);
 }

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);
+}