feat(sync): add result history and last-result log

lib/codex-cli/sync.ts

@@ -6,6 +6,12 @@ import {
 	getLastAccountsSaveTimestamp,
 	getStoragePath,
 } from "../storage.js";
+import {
+	appendSyncHistoryEntry,
+	cloneSyncHistoryEntry,
+	readLatestSyncHistorySync,
+	readSyncHistory,
+} from "../sync-history.js";
 import {
 	incrementCodexCliMetric,
 	makeAccountFingerprint,
@@ -100,6 +106,7 @@ interface ReconcileResult {
 }
 
 let lastCodexCliSyncRun: CodexCliSyncRun | null = null;
+let lastHistoryLoadAttempted = false;
 
 function createEmptySyncSummary(): CodexCliSyncSummary {
 	return {
@@ -114,21 +121,56 @@ function createEmptySyncSummary(): CodexCliSyncSummary {
 	};
 }
 
-function setLastCodexCliSyncRun(run: CodexCliSyncRun): void {
+async function setLastCodexCliSyncRun(run: CodexCliSyncRun): Promise<void> {
 	lastCodexCliSyncRun = run;
+	try {
+		await appendSyncHistoryEntry({
+			kind: "codex-cli-sync",
+			recordedAt: run.runAt,
+			run,
+		});
+	} catch (error) {
+		log.debug("Failed to record codex-cli sync history", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+	}
 }
 
 export function getLastCodexCliSyncRun(): CodexCliSyncRun | null {
-	return lastCodexCliSyncRun
-		? {
-				...lastCodexCliSyncRun,
-				summary: { ...lastCodexCliSyncRun.summary },
-			}
-		: null;
+	if (lastCodexCliSyncRun) {
+		return {
+			...lastCodexCliSyncRun,
+			summary: { ...lastCodexCliSyncRun.summary },
+		};
+	}
+
+	if (!lastHistoryLoadAttempted) {
+		lastHistoryLoadAttempted = true;
+		const latest = readLatestSyncHistorySync();
+		const cloned = cloneSyncHistoryEntry(latest);
+		if (cloned?.kind === "codex-cli-sync") {
+			lastCodexCliSyncRun = cloned.run;
+			return {
+				...cloned.run,
+				summary: { ...cloned.run.summary },
+			};
+		}
+		void readSyncHistory({ kind: "codex-cli-sync", limit: 1 })
+			.then((entries) => {
+				const latestCodexEntry = entries.at(-1);
+				if (latestCodexEntry?.kind === "codex-cli-sync") {
+					lastCodexCliSyncRun = latestCodexEntry.run;
+				}
+			})
+			.catch(() => undefined);
+	}
+
+	return null;
 }
 
 export function __resetLastCodexCliSyncRunForTests(): void {
 	lastCodexCliSyncRun = null;
+	lastHistoryLoadAttempted = false;
 }
 
 function buildIndexByAccountId(
@@ -527,7 +569,7 @@ export async function syncAccountStorageFromCodexCli(
 		const state = await loadCodexCliState();
 		if (!state) {
 			incrementCodexCliMetric("reconcileNoops");
-			setLastCodexCliSyncRun({
+			await setLastCodexCliSyncRun({
 				outcome:
 					(process.env.CODEX_MULTI_AUTH_SYNC_CODEX_CLI ?? "").trim() === "0"
 						? "disabled"
@@ -554,7 +596,7 @@ export async function syncAccountStorageFromCodexCli(
 
 		if (next.accounts.length === 0) {
 			incrementCodexCliMetric(changed ? "reconcileChanges" : "reconcileNoops");
-			setLastCodexCliSyncRun({
+			await setLastCodexCliSyncRun({
 				outcome: changed ? "changed" : "noop",
 				runAt: Date.now(),
 				sourcePath: state.path,
@@ -574,7 +616,7 @@ export async function syncAccountStorageFromCodexCli(
 
 		incrementCodexCliMetric(changed ? "reconcileChanges" : "reconcileNoops");
 		const activeFromSnapshots = readActiveFromSnapshots(state.accounts);
-		setLastCodexCliSyncRun({
+		await setLastCodexCliSyncRun({
 			outcome: changed ? "changed" : "noop",
 			runAt: Date.now(),
 			sourcePath: state.path,
@@ -596,7 +638,7 @@ export async function syncAccountStorageFromCodexCli(
 		};
 	} catch (error) {
 		incrementCodexCliMetric("reconcileFailures");
-		setLastCodexCliSyncRun({
+		await setLastCodexCliSyncRun({
 			outcome: "error",
 			runAt: Date.now(),
 			sourcePath: null,

lib/live-account-sync.ts

@@ -1,6 +1,7 @@
 import { type FSWatcher, promises as fs, watch as fsWatch } from "node:fs";
 import { basename, dirname } from "node:path";
 import { createLogger } from "./logger.js";
+import { appendSyncHistoryEntry } from "./sync-history.js";
 
 const log = createLogger("live-account-sync");
 
@@ -99,7 +100,6 @@ export class LiveAccountSync {
 	private reloadCount = 0;
 	private errorCount = 0;
 	private reloadInFlight: Promise<void> | null = null;
-
 	constructor(
 		reload: () => Promise<void>,
 		options: LiveAccountSyncOptions = {},
@@ -194,6 +194,24 @@ export class LiveAccountSync {
 		lastLiveAccountSyncSnapshot = this.getSnapshot();
 	}
 
+	private async recordHistory(
+		reason: "watch" | "poll" | "manual",
+		outcome: "success" | "error",
+		message?: string,
+	): Promise<void> {
+		const snapshot = this.getSnapshot();
+		const entry = {
+			kind: "live-account-sync" as const,
+			recordedAt: Date.now(),
+			reason,
+			outcome,
+			path: this.currentPath,
+			message,
+			snapshot,
+		};
+		await appendSyncHistoryEntry(entry);
+	}
+
 	private scheduleReload(reason: "watch" | "poll"): void {
 		if (!this.running) return;
 		if (this.debounceTimer) {
@@ -240,13 +258,19 @@ export class LiveAccountSync {
 					reason,
 					path: summarizeWatchPath(targetPath),
 				});
+				await this.recordHistory(reason, "success");
 			} catch (error) {
 				this.errorCount += 1;
 				log.warn("Live account sync reload failed", {
 					reason,
 					path: summarizeWatchPath(targetPath),
 					error: error instanceof Error ? error.message : String(error),
 				});
+				await this.recordHistory(
+					reason,
+					"error",
+					error instanceof Error ? error.message : String(error),
+				);
 			}
 		})();
 

lib/sync-history.ts

@@ -0,0 +1,210 @@
+import { promises as fs, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { CodexCliSyncRun } from "./codex-cli/sync.js";
+import type { LiveAccountSyncSnapshot } from "./live-account-sync.js";
+import { createLogger } from "./logger.js";
+import { getCodexLogDir } from "./runtime-paths.js";
+
+const log = createLogger("sync-history");
+
+type SyncHistoryKind = "codex-cli-sync" | "live-account-sync";
+
+export interface CodexCliSyncHistoryEntry {
+	kind: "codex-cli-sync";
+	recordedAt: number;
+	run: CodexCliSyncRun;
+}
+
+export interface LiveAccountSyncHistoryEntry {
+	kind: "live-account-sync";
+	recordedAt: number;
+	reason: "watch" | "poll" | "manual";
+	outcome: "success" | "error";
+	path: string | null;
+	message?: string;
+	snapshot: LiveAccountSyncSnapshot;
+}
+
+export type SyncHistoryEntry =
+	| CodexCliSyncHistoryEntry
+	| LiveAccountSyncHistoryEntry;
+
+interface SyncHistoryPaths {
+	directory: string;
+	historyPath: string;
+	latestPath: string;
+}
+
+const HISTORY_FILE_NAME = "sync-history.ndjson";
+const LATEST_FILE_NAME = "sync-history-latest.json";
+
+let historyDirOverride: string | null = null;
+let historyMutex: Promise<void> = Promise.resolve();
+let lastAppendError: string | null = null;
+let lastAppendPaths: SyncHistoryPaths | null = null;
+const pendingHistoryWrites = new Set<Promise<void>>();
+
+async function waitForPendingHistoryWrites(): Promise<void> {
+	if (pendingHistoryWrites.size === 0) return;
+	await Promise.allSettled(Array.from(pendingHistoryWrites));
+}
+
+function getHistoryDirectory(): string {
+	return historyDirOverride ?? getCodexLogDir();
+}
+
+export function getSyncHistoryPaths(): SyncHistoryPaths {
+	const directory = getHistoryDirectory();
+	return {
+		directory,
+		historyPath: join(directory, HISTORY_FILE_NAME),
+		latestPath: join(directory, LATEST_FILE_NAME),
+	};
+}
+
+function withHistoryLock<T>(fn: () => Promise<T>): Promise<T> {
+	const previous = historyMutex;
+	let release: () => void = () => {};
+	historyMutex = new Promise<void>((resolve) => {
+		release = resolve;
+	});
+	return previous.then(fn).finally(() => release());
+}
+
+async function ensureHistoryDir(directory: string): Promise<void> {
+	await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+}
+
+function serializeEntry(entry: SyncHistoryEntry): string {
+	return JSON.stringify(entry);
+}
+
+function cloneEntry<T extends SyncHistoryEntry | null>(entry: T): T {
+	if (!entry) return entry;
+	return JSON.parse(JSON.stringify(entry)) as T;
+}
+
+export async function appendSyncHistoryEntry(
+	entry: SyncHistoryEntry,
+): Promise<void> {
+	const writePromise = withHistoryLock(async () => {
+		const paths = getSyncHistoryPaths();
+		lastAppendPaths = paths;
+		await ensureHistoryDir(paths.directory);
+
+		const line = `${serializeEntry(entry)}\n`;
+		const latestContent = `${JSON.stringify(entry, null, 2)}\n`;
+		await fs.appendFile(paths.historyPath, line, {
+			encoding: "utf8",
+			mode: 0o600,
+		});
+		await fs.writeFile(paths.latestPath, latestContent, {
+			encoding: "utf8",
+			mode: 0o600,
+		});
+		lastAppendError = null;
+	});
+	pendingHistoryWrites.add(writePromise);
+	await writePromise
+		.catch((error) => {
+			lastAppendError = error instanceof Error ? error.message : String(error);
+			log.debug("Failed to append sync history", {
+				error: lastAppendError,
+			});
+		})
+		.finally(() => {
+			pendingHistoryWrites.delete(writePromise);
+		});
+}
+
+export async function readSyncHistory(
+	options: { limit?: number; kind?: SyncHistoryKind } = {},
+): Promise<SyncHistoryEntry[]> {
+	const { limit, kind } = options;
+	await waitForPendingHistoryWrites();
+	try {
+		const content = await fs.readFile(
+			getSyncHistoryPaths().historyPath,
+			"utf8",
+		);
+		const lines = content
+			.split(/\r?\n/)
+			.map((line) => line.trim())
+			.filter(Boolean);
+		const parsed = lines.map((line) => JSON.parse(line) as SyncHistoryEntry);
+		const filtered = kind
+			? parsed.filter((entry) => entry.kind === kind)
+			: parsed;
+		return typeof limit === "number" && limit > 0
+			? filtered.slice(-limit)
+			: filtered;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+			log.debug("Failed to read sync history", {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+		return [];
+	}
+}
+
+export function readLatestSyncHistorySync(): SyncHistoryEntry | null {
+	try {
+		const content = readFileSync(getSyncHistoryPaths().latestPath, "utf8");
+		return cloneEntry(JSON.parse(content) as SyncHistoryEntry);
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code && code !== "ENOENT") {
+			log.debug("Failed to read latest sync history", {
+				error: error instanceof Error ? error.message : String(error),
+			});
+		}
+		return null;
+	}
+}
+
+export function configureSyncHistoryForTests(directory: string | null): void {
+	historyDirOverride = directory ? directory.trim() : null;
+}
+
+export async function __resetSyncHistoryForTests(): Promise<void> {
+	const paths = getSyncHistoryPaths();
+	await waitForPendingHistoryWrites();
+	await withHistoryLock(async () => {
+		for (const target of [paths.historyPath, paths.latestPath]) {
+			for (let attempt = 0; attempt < 5; attempt += 1) {
+				try {
+					await fs.rm(target, { force: true });
+					break;
+				} catch (error) {
+					const code = (error as NodeJS.ErrnoException).code;
+					if (
+						(code !== "EBUSY" && code !== "EPERM" && code !== "ENOTEMPTY") ||
+						attempt === 4
+					) {
+						throw error;
+					}
+					await new Promise((resolve) =>
+						setTimeout(resolve, 25 * 2 ** attempt),
+					);
+				}
+			}
+		}
+	});
+	lastAppendError = null;
+	lastAppendPaths = null;
+}
+
+export function cloneSyncHistoryEntry(
+	entry: SyncHistoryEntry | null,
+): SyncHistoryEntry | null {
+	return cloneEntry(entry);
+}
+
+export function __getLastSyncHistoryErrorForTests(): string | null {
+	return lastAppendError;
+}
+
+export function __getLastSyncHistoryPathsForTests(): SyncHistoryPaths | null {
+	return lastAppendPaths ? { ...lastAppendPaths } : null;
+}