Toju/electron/diagnostics/high-memory-alert.store.ts

import * as fsp from 'fs/promises';
import * as path from 'path';

export type HighMemoryAlertReason = 'manual' | 'threshold';

export interface HighMemoryAlertRecord {
  logFilePath: string;
  detectedAt: number;
  peakWorkingSetKb: number;
  sessionId: string;
  reason?: HighMemoryAlertReason;
}

export function resolveHighMemoryAlertPath(userDataPath: string): string {
  return path.join(userDataPath, 'diagnostics', 'high-memory-pending.json');
}

export async function readHighMemoryAlert(userDataPath: string): Promise<HighMemoryAlertRecord | null> {
  try {
    const raw = await fsp.readFile(resolveHighMemoryAlertPath(userDataPath), 'utf8');
    const parsed = JSON.parse(raw) as Partial<HighMemoryAlertRecord>;

    if (
      typeof parsed.logFilePath !== 'string'
      || !parsed.logFilePath.trim()
      || typeof parsed.detectedAt !== 'number'
      || typeof parsed.peakWorkingSetKb !== 'number'
      || typeof parsed.sessionId !== 'string'
    ) {
      return null;
    }

    return {
      logFilePath: parsed.logFilePath,
      detectedAt: parsed.detectedAt,
      peakWorkingSetKb: parsed.peakWorkingSetKb,
      sessionId: parsed.sessionId,
      ...(parsed.reason === 'manual' || parsed.reason === 'threshold'
        ? { reason: parsed.reason }
        : {})
    };
  } catch {
    return null;
  }
}

export async function writeHighMemoryAlert(
  userDataPath: string,
  record: HighMemoryAlertRecord
): Promise<void> {
  const filePath = resolveHighMemoryAlertPath(userDataPath);

  await fsp.mkdir(path.dirname(filePath), { recursive: true });
  await fsp.writeFile(filePath, `${JSON.stringify(record, null, 2)}\n`, 'utf8');
}

export async function clearHighMemoryAlert(userDataPath: string): Promise<void> {
  try {
    await fsp.unlink(resolveHighMemoryAlertPath(userDataPath));
  } catch {
    // Missing pending alert is fine.
  }
}