@gajae-code/coding-agent 0.15.4 → 0.15.6

package/src/session/session-manager.ts

@@ -8385,13 +8385,13 @@ export class SessionManager {
 			this.#usageStatistics = commit.usageStatistics;
 			this.#flushed = true;
 			this.#ensuredOnDisk = true;
-			this.#managedPersistExpectedIdentity = managedIdentityFromDescriptor(terminalDescriptor);
+			this.#managedPersistExpectedIdentity =
+				this.destination.kind === "managed" ? this.#captureManagedPersistIdentity(sessionFile) : undefined;
 			this.#lazyReopenSucceeded = true;
 			this.#lazyReopenFallbackReason = undefined;
 			initialized = true;
 			return true;
-		} catch (error) {
-			SessionManagerTestHooks.lastSidecarInitError = toError(error).message;
+		} catch {
 			return false;
 		} finally {
 			if (!initialized) {
@@ -8572,7 +8572,8 @@ export class SessionManager {
 				this.#lazyReopenFallbackReason = "bounded_first_open_descriptor_changed";
 				return false;
 			}
-			this.#managedPersistExpectedIdentity = managedIdentityFromDescriptor(finalDescriptor);
+			this.#managedPersistExpectedIdentity =
+				this.destination.kind === "managed" ? this.#captureManagedPersistIdentity(sessionFile) : undefined;
 			this.#sessionId = discovery.header.id;
 			this.#sessionName = discovery.header.title;
 			this.#titleSource = discovery.header.titleSource;
@@ -14945,9 +14946,27 @@ export class SessionManager {
 			this.#managedPersistExpectedIdentity = undefined;
 			return;
 		}
-		const descriptor = this.#managedTranscriptStore(sessionFile).descriptorExpected(path.basename(sessionFile));
-		if (!descriptor) throw new Error("managed_persist_identity_unavailable");
-		this.#managedPersistExpectedIdentity = managedIdentityFromDescriptor(descriptor);
+		this.#managedPersistExpectedIdentity = this.#captureManagedPersistIdentity(sessionFile);
+	}
+
+	/** Capture one descriptor-bound digest for a future metadata-drift comparison. */
+	#captureManagedPersistIdentity(sessionFile: string): ManagedFileIdentity {
+		const store = this.#managedTranscriptStore(sessionFile);
+		const relativePath = path.basename(sessionFile);
+		const bounded = store.captureBoundedAppendExpectation(relativePath);
+		const descriptor = store.descriptorExpected(relativePath);
+		if (!bounded || !descriptor) throw new Error("managed_persist_identity_unavailable");
+		const identity = managedIdentityFromDescriptor(descriptor);
+		if (
+			bounded.dev !== identity.dev.toString() ||
+			bounded.ino !== identity.ino.toString() ||
+			bounded.nlink !== identity.nlink.toString() ||
+			bounded.size !== String(identity.size) ||
+			bounded.mtimeNs !== identity.mtimeNs.toString() ||
+			bounded.ctimeNs !== identity.ctimeNs.toString()
+		)
+			throw new Error("managed_persist_identity_unavailable");
+		return { ...identity, sha256: bounded.sha256 };
 	}
 	/** Current transcript descriptor, or null when unavailable. */
 	#managedDescriptorSnapshotOrNull(): DescriptorSnapshot | null {
@@ -14997,7 +15016,7 @@ export class SessionManager {
 				} else store.replaceSync(relativePath, bytes);
 				const descriptor = store.descriptorExpected(relativePath);
 				if (!descriptor) throw new Error("managed_replace_identity_unavailable");
-				this.#managedPersistExpectedIdentity = managedIdentityFromDescriptor(descriptor);
+				this.#managedPersistExpectedIdentity = this.#captureManagedPersistIdentity(sessionFile);
 				this.#publishCommitMarkerFromCurrentTranscriptSync();
 				return;
 			}
@@ -19961,7 +19980,7 @@ export class SessionManager {
 				const returnManagedDescriptor = managedInspectionStore?.descriptorExpected(path.basename(filePath));
 				if (!returnManagedDescriptor || !sameDescriptor(managedBoundedDescriptor, returnManagedDescriptor))
 					throw new Error("Could not open session: unstable");
-				manager.#managedPersistExpectedIdentity = managedIdentityFromDescriptor(returnManagedDescriptor);
+				manager.#managedPersistExpectedIdentity = manager.#captureManagedPersistIdentity(filePath);
 				const header = manager.#fileEntries.find(entry => entry.type === "session") as SessionHeader | undefined;
 				if (header?.cwd) manager.cwd = header.cwd;
 				manager.buildSessionContext();
@@ -20079,7 +20098,7 @@ export class SessionManager {
 					const finalDescriptor = store.descriptorExpected(path.basename(resolved));
 					if (!finalDescriptor || !sameDescriptor(capturedDescriptor, finalDescriptor))
 						throw new Error("source_changed");
-					boundedManager.#managedPersistExpectedIdentity = managedIdentityFromDescriptor(finalDescriptor);
+					boundedManager.#managedPersistExpectedIdentity = boundedManager.#captureManagedPersistIdentity(resolved);
 					boundedManager.buildSessionContext();
 					return boundedManager;
 				}

package/src/setup/provider-presets.json

@@ -4,7 +4,7 @@
   {"id":"glm","aliases":["zai","z-ai","bigmodel"],"name":"GLM / zAI","description":"OpenAI-compatible GLM endpoint from zAI/BigModel","compatibility":"openai","api":"openai-completions","providerId":"glm-proxy","baseUrl":"https://api.z.ai/api/paas/v4","apiKeyEnv":"ZAI_API_KEY","models":["glm-4.6"],"compat":{"supportsDeveloperRole":false,"supportsReasoningEffort":false,"thinkingFormat":"zai","reasoningContentField":"reasoning_content"}},
   {"id":"alibaba-token-plan","aliases":["alibaba","token-plan"],"name":"Alibaba Token Plan","description":"OpenAI-compatible Alibaba Token Plan endpoint","compatibility":"openai","api":"openai-completions","providerId":"alibaba-token-plan","baseUrl":"https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1","apiKeyEnv":"ALIBABA_TOKEN_PLAN_API_KEY","models":["qwen3.8-max-preview","qwen3.8-max","glm-5.2","deepseek-v4-pro"],"modelApi":{"qwen3.8-max-preview":"openai-responses","qwen3.8-max":"openai-responses","glm-5.2":"openai-completions","deepseek-v4-pro":"openai-completions"},"compat":{"supportsDeveloperRole":false}},
   {"id":"cline-pass","aliases":["clinepass","cline"],"name":"ClinePass","description":"ClinePass subscription models discovered from Cline's upstream models.dev catalog","compatibility":"openai","api":"openai-completions","providerId":"cline-pass","baseUrl":"https://api.cline.bot/api/v1","apiKeyEnv":"CLINE_API_KEY","discovery":{"type":"models-dev","modelsDevProvider":"cline-pass"},"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning"}},
-  {"id":"commandcode-goat","aliases":["commandcode","command-code","goat"],"name":"Command Code GOAT","description":"Command Code GOAT coding-plan models discovered from its OpenAI-compatible Provider API","compatibility":"openai","api":"openai-completions","providerId":"commandcode-goat","baseUrl":"https://api.commandcode.ai/provider/v1","apiKeyEnv":"CMD_API_KEY","discovery":{"type":"openai-models-list","apiByModelPrefix":{"claude-":"anthropic-messages"}},"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"reasoningContentField":"reasoning_content"}},
+  {"id":"commandcode-goat","aliases":["commandcode","command-code","goat"],"name":"Command Code GOAT","description":"Command Code GOAT coding-plan models discovered from its OpenAI-compatible Provider API","compatibility":"openai","api":"openai-completions","providerId":"commandcode-goat","baseUrl":"https://api.commandcode.ai/provider/v1","apiKeyEnv":"CMD_API_KEY","discovery":{"type":"openai-models-list","apiByModelPrefix":{"claude":"anthropic-messages","anthropic/claude":"anthropic-messages"}},"compat":{"supportsStore":false,"supportsDeveloperRole":false,"supportsReasoningEffort":false,"maxTokensField":"max_tokens","reasoningContentField":"reasoning_content"}},
   {"id":"litellm","aliases":["litellm-proxy"],"name":"LiteLLM Proxy","description":"OpenAI-compatible LiteLLM proxy endpoint (user-supplied base URL) with live model discovery","compatibility":"openai","api":"openai-completions","providerId":"litellm","parameterized":true,"apiKeyEnv":"LITELLM_API_KEY","discovery":{"type":"openai-models-list"}},
   {"id":"openai-compatible-proxy","aliases":["openai-proxy","compatible-proxy","custom-proxy"],"name":"OpenAI-Compatible Proxy","description":"Generic OpenAI-compatible gateway (OpenRouter, OpenCode Go, custom) with live model discovery","compatibility":"openai","api":"openai-completions","providerId":"openai-compatible-proxy","parameterized":true,"apiKeyEnv":"OPENAI_COMPATIBLE_API_KEY","discovery":{"type":"openai-models-list"}}
 ]

package/src/slash-commands/helpers/credential-switch.ts

@@ -131,7 +131,12 @@ export async function switchSessionCredentialCommand(runtime: SlashCommandRuntim
 	}
 
 	try {
-		authStorage.switchSessionCredential(provider, runtime.session.credentialSessionId, parsed.selector);
+		authStorage.switchSessionCredential(
+			provider,
+			runtime.session.credentialSessionId,
+			parsed.selector,
+			runtime.session.modelRegistry.getAuthStorageOwner?.(),
+		);
 	} catch (error) {
 		return error instanceof Error ? error.message : String(error);
 	}

package/src/task/executor.ts

@@ -1121,6 +1121,8 @@ export async function runSubprocessOnce(options: ExecutorOptions): Promise<Singl
 	const abortController = new AbortController();
 	const abortSignal = abortController.signal;
 	let activeSession: AgentSession | null = null;
+	let ownedModelRegistry: ModelRegistry | undefined;
+	let ownedAuthStorage: AuthStorage | undefined;
 	let unsubscribe: (() => void) | null = null;
 	let yieldCalled = false;
 	let pauseRequested = false;
@@ -1703,9 +1705,19 @@ export async function runSubprocessOnce(options: ExecutorOptions): Promise<Singl
 			checkAbort();
 			// Pin authStorage to modelRegistry.authStorage — mirrors the createAgentSession invariant.
 			const registryFromParent = options.modelRegistry !== undefined;
-			const modelRegistry =
-				options.modelRegistry ??
-				new ModelRegistry(options.authStorage ?? (await awaitAbortable(discoverAuthStorage())));
+			const registryAuthStorage =
+				options.authStorage ??
+				options.modelRegistry?.authStorage ??
+				(await awaitAbortable(discoverAuthStorage(settings.getAgentDir())));
+			if (options.modelRegistry === undefined && options.authStorage === undefined)
+				ownedAuthStorage = registryAuthStorage;
+			ownedModelRegistry = options.modelRegistry
+				? undefined
+				: new ModelRegistry(registryAuthStorage, path.join(settings.getAgentDir(), "models.yml"), settings, {
+						agentDir: settings.getAgentDir(),
+						automaticRefresh: false,
+					});
+			const modelRegistry = options.modelRegistry ?? ownedModelRegistry!;
 			const authStorage = modelRegistry.authStorage;
 			if (options.authStorage && options.authStorage !== authStorage) {
 				throw new Error(
@@ -2500,6 +2512,10 @@ export async function runSubprocessOnce(options: ExecutorOptions): Promise<Singl
 					// Ignore cleanup errors
 				}
 			}
+			ownedModelRegistry?.dispose();
+			ownedModelRegistry = undefined;
+			ownedAuthStorage?.close();
+			ownedAuthStorage = undefined;
 		}
 
 		return {

package/src/telemetry/control.ts

@@ -0,0 +1,26 @@
+/** Process-wide emergency stop; it cannot be enabled by project dotenv files. */
+export const TELEMETRY_KILL_SWITCH_ENV = "GJC_DISABLE_TELEMETRY" as const;
+
+function isTruthy(value: string | undefined): boolean {
+	return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+
+export interface TelemetryStatus {
+	enabled: boolean;
+	disabledByKillSwitch: boolean;
+	reason: "enabled" | "setting_disabled" | "kill_switch";
+}
+
+export interface TelemetrySettingsReader {
+	get(path: "telemetry.enabled"): boolean;
+}
+
+export function getTelemetryStatus(settings: TelemetrySettingsReader): TelemetryStatus {
+	if (isTruthy(process.env[TELEMETRY_KILL_SWITCH_ENV])) {
+		return { enabled: false, disabledByKillSwitch: true, reason: "kill_switch" };
+	}
+	if (settings.get("telemetry.enabled") !== true) {
+		return { enabled: false, disabledByKillSwitch: false, reason: "setting_disabled" };
+	}
+	return { enabled: true, disabledByKillSwitch: false, reason: "enabled" };
+}

package/src/telemetry/events.ts

@@ -0,0 +1,142 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getTrustedAgentFile } from "@gajae-code/utils";
+
+export const TELEMETRY_SCHEMA_VERSION = 1 as const;
+export const TELEMETRY_INSTALL_ID_FILE = "telemetry-install-id" as const;
+
+export const TELEMETRY_EVENT_NAMES = [
+	"update_check_started",
+	"update_check_completed",
+	"update_install_started",
+	"update_install_completed",
+	"update_install_failed",
+] as const;
+
+export type TelemetryEventName = (typeof TELEMETRY_EVENT_NAMES)[number];
+
+export interface TelemetryEvent {
+	schemaVersion: typeof TELEMETRY_SCHEMA_VERSION;
+	event: TelemetryEventName;
+	installId: string;
+	occurredAt: string;
+	channel?: "stable" | "nightly";
+	result?: "available" | "up_to_date" | "installed" | "failed" | "skipped";
+	installMethod?: "bun" | "npm" | "binary" | "migrate";
+}
+
+type EventInput = {
+	event?: unknown;
+	installId?: unknown;
+	occurredAt?: unknown;
+	channel?: unknown;
+	result?: unknown;
+	installMethod?: unknown;
+	[key: string]: unknown;
+};
+
+const EVENT_NAMES = new Set<string>(TELEMETRY_EVENT_NAMES);
+const CHANNELS = new Set(["stable", "nightly"]);
+const RESULTS = new Set(["available", "up_to_date", "installed", "failed", "skipped"]);
+const INSTALL_METHODS = new Set(["bun", "npm", "binary", "migrate"]);
+const FORBIDDEN_KEY = /(?:prompt|argv|path|env|secret|account|model|provider|repo|error|hostname|username|machine|ip)/i;
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+function hasForbiddenKey(value: unknown, seen = new Set<object>()): boolean {
+	if (value === null || typeof value !== "object") return false;
+	if (seen.has(value)) return false;
+	seen.add(value);
+	for (const [key, child] of Object.entries(value)) {
+		if (FORBIDDEN_KEY.test(key) || hasForbiddenKey(child, seen)) return true;
+	}
+	return false;
+}
+
+function requireString(value: unknown, field: string): string {
+	if (typeof value !== "string" || value.length === 0 || value.length > 128) {
+		throw new Error(`invalid telemetry ${field}`);
+	}
+	return value;
+}
+
+/**
+ * Serialize only the versioned telemetry allowlist. Unknown fields are never
+ * emitted; forbidden fields anywhere in the input fail closed.
+ */
+export function serializeTelemetryEvent(input: unknown): string {
+	if (input === null || typeof input !== "object" || Array.isArray(input)) {
+		throw new Error("telemetry event must be an object");
+	}
+	if (hasForbiddenKey(input)) throw new Error("telemetry event contains forbidden data");
+	const value = input as EventInput;
+	const event = requireString(value.event, "event");
+	if (!EVENT_NAMES.has(event)) throw new Error("invalid telemetry event");
+	const installId = requireString(value.installId, "installId");
+	if (!UUID_V4.test(installId)) throw new Error("invalid telemetry installId");
+	const occurredAt = requireString(value.occurredAt, "occurredAt");
+	if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(occurredAt) || Number.isNaN(Date.parse(occurredAt))) {
+		throw new Error("invalid telemetry occurredAt");
+	}
+
+	const output: TelemetryEvent = {
+		schemaVersion: TELEMETRY_SCHEMA_VERSION,
+		event: event as TelemetryEventName,
+		installId,
+		occurredAt,
+	};
+	if (value.channel !== undefined) {
+		if (typeof value.channel !== "string" || !CHANNELS.has(value.channel))
+			throw new Error("invalid telemetry channel");
+		output.channel = value.channel as TelemetryEvent["channel"];
+	}
+	if (value.result !== undefined) {
+		if (typeof value.result !== "string" || !RESULTS.has(value.result)) throw new Error("invalid telemetry result");
+		output.result = value.result as TelemetryEvent["result"];
+	}
+	if (value.installMethod !== undefined) {
+		if (typeof value.installMethod !== "string" || !INSTALL_METHODS.has(value.installMethod)) {
+			throw new Error("invalid telemetry installMethod");
+		}
+		output.installMethod = value.installMethod as TelemetryEvent["installMethod"];
+	}
+	return `${JSON.stringify(output)}\n`;
+}
+
+async function writeNewInstallId(filePath: string, installId: string): Promise<void> {
+	const handle = await fs.open(filePath, "wx", 0o600);
+	try {
+		await handle.writeFile(`${installId}\n`, "utf8");
+	} finally {
+		await handle.close();
+	}
+}
+
+/** Load or create a random UUIDv4 that is not derived from machine data. */
+export async function getTelemetryInstallId(
+	filePath = getTrustedAgentFile(TELEMETRY_INSTALL_ID_FILE),
+): Promise<string> {
+	try {
+		const existing = (await Bun.file(filePath).text()).trim();
+		if (UUID_V4.test(existing)) {
+			await fs.chmod(filePath, 0o600);
+			return existing;
+		}
+		throw new Error("telemetry install ID is malformed");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+
+	await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+	const generated = randomUUID();
+	try {
+		await writeNewInstallId(filePath, generated);
+		return generated;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+		const existing = (await Bun.file(filePath).text()).trim();
+		if (!UUID_V4.test(existing)) throw new Error("telemetry install ID is malformed");
+		await fs.chmod(filePath, 0o600);
+		return existing;
+	}
+}

package/src/telemetry/index.ts

@@ -0,0 +1,3 @@
+export * from "./control";
+export * from "./events";
+export * from "./transport";

package/src/telemetry/transport.ts

@@ -0,0 +1,87 @@
+import { Settings } from "../config/settings";
+import { getTelemetryStatus } from "./control";
+import { getTelemetryInstallId, serializeTelemetryEvent, type TelemetryEvent, type TelemetryEventName } from "./events";
+
+export const TELEMETRY_ENDPOINT = "https://telemetry.gajae.dev/v1/events" as const;
+export const TELEMETRY_MAX_IN_FLIGHT = 2 as const;
+export const TELEMETRY_TIMEOUT_MS = 1500 as const;
+export const TELEMETRY_FLUSH_TIMEOUT_MS = 2000 as const;
+
+interface TelemetryTransportDependencies {
+	fetchImpl?: (input: string | URL, init?: RequestInit) => Promise<Response>;
+	endpoint?: string;
+}
+
+export type TelemetryDetails = Pick<TelemetryEvent, "channel" | "result" | "installMethod">;
+
+let inFlight = 0;
+const pendingTelemetry = new Set<Promise<void>>();
+
+/**
+ * Best-effort transport. The caller only schedules work; disabled telemetry,
+ * queue saturation, network errors, and non-2xx responses are all ignored.
+ */
+export function sendTelemetryEvent(
+	settings: Parameters<typeof getTelemetryStatus>[0],
+	event: TelemetryEvent,
+	deps: TelemetryTransportDependencies = {},
+): Promise<void> {
+	if (!getTelemetryStatus(settings).enabled || inFlight >= TELEMETRY_MAX_IN_FLIGHT) return Promise.resolve();
+	let body: string;
+	try {
+		body = serializeTelemetryEvent(event);
+	} catch {
+		return Promise.resolve();
+	}
+	inFlight++;
+	const fetchImpl = deps.fetchImpl ?? fetch;
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT_MS);
+	timeout.unref?.();
+	const delivery = fetchImpl(deps.endpoint ?? TELEMETRY_ENDPOINT, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body,
+		signal: controller.signal,
+		redirect: "error",
+	})
+		.catch(() => undefined)
+		.then(() => undefined)
+		.finally(() => {
+			clearTimeout(timeout);
+			inFlight--;
+		});
+	pendingTelemetry.add(delivery);
+	void delivery.finally(() => pendingTelemetry.delete(delivery));
+	return delivery;
+}
+
+export async function resetTelemetryTransportForTest(): Promise<void> {
+	await Promise.allSettled([...pendingTelemetry]);
+}
+
+/** Schedule an event without making telemetry part of the caller's lifecycle. */
+export function recordTelemetryEvent(event: TelemetryEventName, details: TelemetryDetails): Promise<void> {
+	const pending = (async () => {
+		const settings = await Settings.init();
+		if (!getTelemetryStatus(settings).enabled) return;
+		const installId = await getTelemetryInstallId();
+		await sendTelemetryEvent(settings, {
+			schemaVersion: 1,
+			event,
+			installId,
+			occurredAt: new Date().toISOString(),
+			...details,
+		});
+	})().catch(() => undefined);
+	pendingTelemetry.add(pending);
+	void pending.finally(() => pendingTelemetry.delete(pending));
+	return pending;
+}
+
+/** Wait briefly for accepted events so explicit process exits do not drop them. */
+export async function flushTelemetryEvents(timeoutMs = TELEMETRY_FLUSH_TIMEOUT_MS): Promise<void> {
+	const pending = [...pendingTelemetry];
+	if (pending.length === 0) return;
+	await Promise.race([Promise.allSettled(pending), Bun.sleep(timeoutMs)]);
+}