create-electron-vite-react-ts 0.1.0

package/dist/main/main.js

@@ -0,0 +1,478 @@
+import { ipcMain, shell, app, BrowserWindow, Menu, screen } from "electron";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import __cjs_mod__ from "node:module";
+const __filename = import.meta.filename;
+const __dirname = import.meta.dirname;
+const require2 = __cjs_mod__.createRequire(import.meta.url);
+function parseDotEnv(content) {
+  const out = {};
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function readDotEnvFile(appRoot) {
+  const envPath = path.join(appRoot, ".env");
+  if (!fs.existsSync(envPath)) return {};
+  try {
+    return parseDotEnv(fs.readFileSync(envPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function parseEnvBoolean(value, defaultValue) {
+  if (value === void 0 || value === "") return defaultValue;
+  const v = value.trim().toLowerCase();
+  if (v === "1" || v === "true" || v === "yes") return true;
+  if (v === "0" || v === "false" || v === "no") return false;
+  return defaultValue;
+}
+function pickString(...vals) {
+  for (const v of vals) {
+    if (v !== void 0 && v !== "") return v;
+  }
+  return void 0;
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+function pad3(value) {
+  return String(value).padStart(3, "0");
+}
+function toDateStamp(date) {
+  return `${date.getFullYear()}${pad2(date.getMonth() + 1)}${pad2(date.getDate())}`;
+}
+function toTimeStamp(date) {
+  return `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}.${pad3(date.getMilliseconds())}`;
+}
+function resolveLoggerConfig(isDevelopment, isPackaged, appRoot) {
+  const dotEnv = readDotEnvFile(appRoot);
+  const enabledRaw = pickString(process.env.LOG_ENABLED, dotEnv.LOG_ENABLED);
+  const enabled = parseEnvBoolean(enabledRaw, true);
+  if (!enabled) {
+    return { enabled: false, file: false, console: false };
+  }
+  const fileRaw = pickString(process.env.LOG_FILE, dotEnv.LOG_FILE);
+  const consoleRaw = pickString(process.env.LOG_CONSOLE, dotEnv.LOG_CONSOLE);
+  return {
+    enabled: true,
+    file: parseEnvBoolean(fileRaw, !isPackaged),
+    console: parseEnvBoolean(consoleRaw, isDevelopment)
+  };
+}
+class AppLogger {
+  config;
+  isDevelopment;
+  logsDir;
+  logFile;
+  sessionId;
+  constructor(options) {
+    this.isDevelopment = options.isDevelopment;
+    this.sessionId = options.sessionId;
+    this.config = resolveLoggerConfig(options.isDevelopment, options.isPackaged, options.appRoot);
+    this.logsDir = path.join(options.appRoot, "logs");
+    this.logFile = path.join(this.logsDir, `system.${toDateStamp(/* @__PURE__ */ new Date())}.log`);
+  }
+  init() {
+    if (!this.config.enabled) return;
+    if (!this.config.file && !this.config.console) return;
+    if (this.config.file) {
+      fs.mkdirSync(this.logsDir, { recursive: true });
+    }
+    this.writeLine("SYSTEM", "=".repeat(112));
+    this.writeLine("SYSTEM", `Application Started | ${JSON.stringify({ devMode: this.isDevelopment, sessionId: this.sessionId })}`);
+    this.writeLine("SYSTEM", "=".repeat(112));
+    this.writeLine("LOGGER", "Logger ready");
+  }
+  info(level, message, meta = {}) {
+    const metaJson = JSON.stringify(meta);
+    if (!metaJson || metaJson === "{}") {
+      this.writeLine(level, message);
+    } else {
+      this.writeLine(level, `${message} | ${metaJson}`);
+    }
+  }
+  log(level, message) {
+    this.writeLine(level, message);
+  }
+  shutdown() {
+    if (!this.config.enabled) return;
+    if (!this.config.file && !this.config.console) return;
+    this.writeLine("INFO", "Logger shutting down");
+    this.writeLine("SYSTEM", "=".repeat(112));
+    this.writeLine("SYSTEM", `Application Ended | ${JSON.stringify({ sessionId: this.sessionId })}`);
+    this.writeLine("SYSTEM", "=".repeat(112) + "\n");
+  }
+  writeLine(level, body) {
+    if (!this.config.enabled) return;
+    if (!this.config.file && !this.config.console) return;
+    const line = `[${toTimeStamp(/* @__PURE__ */ new Date())}] [${level}] ${body}`;
+    if (this.config.file) {
+      fs.appendFileSync(this.logFile, `${line}
+`, "utf-8");
+    }
+    if (this.config.console) {
+      console.log(line);
+    }
+  }
+}
+const IPC_CHANNELS = {
+  /** `invoke(url: string)` — allows only `http:` / `https:`, then calls `shell.openExternal`. */
+  OPEN_EXTERNAL: "app:open-external"
+};
+function isAllowedExternalUrl(url) {
+  try {
+    const u = new URL(url);
+    return u.protocol === "http:" || u.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function registerIpcHandlers() {
+  ipcMain.handle(IPC_CHANNELS.OPEN_EXTERNAL, async (_event, raw) => {
+    if (typeof raw !== "string" || raw.length === 0) {
+      throw new Error("open-external: URL must be a non-empty string");
+    }
+    if (!isAllowedExternalUrl(raw)) {
+      throw new Error("open-external: only http(s) URLs are allowed");
+    }
+    await shell.openExternal(raw);
+  });
+}
+const __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+process.env.APP_ROOT = path.join(__dirname$1, "..", "..");
+const SCREEN_CENTER = parseEnvBoolean(
+  pickString(process.env.SCREEN_CENTER, readDotEnvFile(process.env.APP_ROOT).SCREEN_CENTER),
+  false
+);
+const ELECTRON_MENU_ENABLED = parseEnvBoolean(
+  pickString(
+    process.env.ELECTRON_MENU_ENABLED,
+    readDotEnvFile(process.env.APP_ROOT).ELECTRON_MENU_ENABLED
+  ),
+  true
+);
+const VITE_DEV_SERVER_URL = process.env["ELECTRON_RENDERER_URL"] || process.env["VITE_DEV_SERVER_URL"];
+const RUN_MODE = VITE_DEV_SERVER_URL ? "development" : "production";
+const IS_DEVELOPMENT = RUN_MODE === "development";
+const SESSION_ID = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+const MAIN_DIST = path.join(process.env.APP_ROOT, "dist");
+const RENDERER_DIST = path.join(process.env.APP_ROOT, "dist");
+process.env.VITE_PUBLIC = VITE_DEV_SERVER_URL ? path.join(process.env.APP_ROOT, "public") : RENDERER_DIST;
+let win;
+const WINDOW_STATE_FILE = `window-state.${RUN_MODE}.json`;
+const DEFAULT_WINDOW_SIZE = { width: 1200, height: 800 };
+const logger = new AppLogger({
+  appRoot: process.env.APP_ROOT,
+  isDevelopment: IS_DEVELOPMENT,
+  isPackaged: app.isPackaged,
+  sessionId: SESSION_ID
+});
+function getWindowStatePath() {
+  return path.join(app.getPath("userData"), WINDOW_STATE_FILE);
+}
+function readWindowState() {
+  try {
+    const filePath = getWindowStatePath();
+    if (!fs.existsSync(filePath)) return { normalized: null, raw: null };
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.width !== "number" || typeof parsed.height !== "number") {
+      return { normalized: null, raw: parsed };
+    }
+    return {
+      normalized: {
+        width: Math.max(400, Math.floor(parsed.width)),
+        height: Math.max(300, Math.floor(parsed.height)),
+        x: typeof parsed.x === "number" ? Math.floor(parsed.x) : void 0,
+        y: typeof parsed.y === "number" ? Math.floor(parsed.y) : void 0,
+        offsetX: typeof parsed.offsetX === "number" ? Math.floor(parsed.offsetX) : void 0,
+        offsetY: typeof parsed.offsetY === "number" ? Math.floor(parsed.offsetY) : void 0,
+        workAreaWidth: typeof parsed.workAreaWidth === "number" ? Math.floor(parsed.workAreaWidth) : void 0,
+        workAreaHeight: typeof parsed.workAreaHeight === "number" ? Math.floor(parsed.workAreaHeight) : void 0,
+        isMaximized: typeof parsed.isMaximized === "boolean" ? parsed.isMaximized : false,
+        displayId: typeof parsed.displayId === "number" ? parsed.displayId : void 0
+      },
+      raw: parsed
+    };
+  } catch {
+    return { normalized: null, raw: null };
+  }
+}
+function isVisibleOnAnyDisplay(bounds) {
+  return screen.getAllDisplays().some((display) => {
+    const area = display.workArea;
+    return bounds.x + bounds.width > area.x && bounds.x < area.x + area.width && bounds.y + bounds.height > area.y && bounds.y < area.y + area.height;
+  });
+}
+function getCenteredBoundsInDisplay(width, height, display) {
+  const area = display.workArea;
+  return {
+    x: Math.floor(area.x + (area.width - width) / 2),
+    y: Math.floor(area.y + (area.height - height) / 2)
+  };
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function normalizeStateToDisplay(state, display) {
+  const area = display.workArea;
+  const width = Math.max(state.width, 400);
+  const height = Math.max(state.height, 300);
+  const defaultCentered = getCenteredBoundsInDisplay(width, height, display);
+  const minX = area.x;
+  const maxX = area.x + area.width - width;
+  const minY = area.y;
+  const maxY = area.y + area.height - height;
+  const x = state.x === void 0 ? defaultCentered.x : width > area.width ? state.x : clamp(state.x, minX, maxX);
+  const y = state.y === void 0 ? defaultCentered.y : height > area.height ? state.y : clamp(state.y, minY, maxY);
+  const offsetX = x - area.x;
+  const offsetY = y - area.y;
+  return {
+    ...state,
+    width,
+    height,
+    x,
+    y,
+    offsetX,
+    offsetY,
+    workAreaWidth: area.width,
+    workAreaHeight: area.height,
+    displayId: display.id
+  };
+}
+function resolveDisplayForWindow(state) {
+  if (state.displayId !== void 0) {
+    const found = screen.getAllDisplays().find((d) => d.id === state.displayId);
+    if (found) return found;
+  }
+  return screen.getDisplayMatching({
+    x: state.x ?? 0,
+    y: state.y ?? 0,
+    width: state.width,
+    height: state.height
+  });
+}
+function applyScreenCenterIfNeeded(state) {
+  if (!SCREEN_CENTER) return state;
+  if (state.isMaximized) return state;
+  const w = state.width;
+  const h = state.height;
+  if (w <= 0 || h <= 0) return state;
+  const display = resolveDisplayForWindow(state);
+  const area = display.workArea;
+  if (w >= area.width || h >= area.height) return state;
+  const centered = getCenteredBoundsInDisplay(w, h, display);
+  return {
+    ...state,
+    x: centered.x,
+    y: centered.y,
+    offsetX: centered.x - area.x,
+    offsetY: centered.y - area.y,
+    workAreaWidth: area.width,
+    workAreaHeight: area.height,
+    displayId: display.id
+  };
+}
+function applyRelativePositionToDisplay(state, display) {
+  if (state.offsetX === void 0 || state.offsetY === void 0) {
+    return state;
+  }
+  const area = display.workArea;
+  return {
+    ...state,
+    x: area.x + state.offsetX,
+    y: area.y + state.offsetY
+  };
+}
+function getSafeWindowState() {
+  const savedState = readWindowState();
+  const saved = savedState.normalized;
+  const fallback = {
+    ...DEFAULT_WINDOW_SIZE,
+    ...saved
+  };
+  const primaryDisplay = screen.getPrimaryDisplay();
+  if (saved?.displayId !== void 0) {
+    const savedDisplay = screen.getAllDisplays().find((display) => display.id === saved.displayId);
+    if (!savedDisplay) {
+      const normalized2 = normalizeStateToDisplay(fallback, primaryDisplay);
+      return {
+        state: normalized2,
+        mode: "primary-fallback",
+        reason: "saved-display-missing",
+        requestedDisplayId: saved.displayId,
+        appliedDisplayId: primaryDisplay.id
+      };
+    }
+    const relativeAdjusted = applyRelativePositionToDisplay(fallback, savedDisplay);
+    const restoredRaw = {
+      ...relativeAdjusted,
+      displayId: savedDisplay.id
+    };
+    return {
+      state: restoredRaw,
+      mode: "restored",
+      reason: "restored-raw-same-display",
+      requestedDisplayId: saved.displayId,
+      appliedDisplayId: savedDisplay.id
+    };
+  }
+  if (saved?.x === void 0 || saved.y === void 0) {
+    const normalized2 = normalizeStateToDisplay(fallback, primaryDisplay);
+    return {
+      state: normalized2,
+      mode: "restored",
+      reason: "saved-position-missing",
+      requestedDisplayId: saved?.displayId,
+      appliedDisplayId: normalized2.displayId
+    };
+  }
+  const bounds = {
+    x: saved.x,
+    y: saved.y,
+    width: fallback.width,
+    height: fallback.height
+  };
+  if (!isVisibleOnAnyDisplay(bounds)) {
+    const normalized2 = normalizeStateToDisplay(fallback, primaryDisplay);
+    return {
+      state: normalized2,
+      mode: "primary-fallback",
+      reason: "offscreen-bounds",
+      requestedDisplayId: saved.displayId,
+      appliedDisplayId: primaryDisplay.id
+    };
+  }
+  const matchedDisplay = screen.getDisplayMatching(bounds);
+  const normalized = normalizeStateToDisplay(fallback, matchedDisplay);
+  const isChanged = normalized.width !== fallback.width || normalized.height !== fallback.height || normalized.x !== fallback.x || normalized.y !== fallback.y;
+  return {
+    state: normalized,
+    mode: "restored",
+    reason: isChanged ? "normalized-to-display" : "normal-restore",
+    requestedDisplayId: saved?.displayId,
+    appliedDisplayId: normalized.displayId
+  };
+}
+function saveWindowState(targetWindow) {
+  if (targetWindow.isDestroyed()) return null;
+  const isMaximized = targetWindow.isMaximized();
+  const bounds = isMaximized ? targetWindow.getNormalBounds() : targetWindow.getBounds();
+  const display = screen.getDisplayMatching(bounds);
+  const displayId = display.id;
+  const area = display.workArea;
+  const data = {
+    x: bounds.x,
+    y: bounds.y,
+    offsetX: bounds.x - area.x,
+    offsetY: bounds.y - area.y,
+    workAreaWidth: area.width,
+    workAreaHeight: area.height,
+    width: bounds.width,
+    height: bounds.height,
+    isMaximized,
+    displayId
+  };
+  fs.writeFileSync(getWindowStatePath(), JSON.stringify(data, null, 2), "utf-8");
+  return data;
+}
+function createWindow() {
+  logger.log("STARTUP", "Phase: Main window create");
+  const launchDecision = getSafeWindowState();
+  const beforeCenter = launchDecision.state;
+  const safeWindowState = applyScreenCenterIfNeeded(beforeCenter);
+  if (SCREEN_CENTER && !safeWindowState.isMaximized && (safeWindowState.x !== beforeCenter.x || safeWindowState.y !== beforeCenter.y)) {
+    logger.info("WINDOW", "SCREEN_CENTER: centered window on work area", {
+      displayId: safeWindowState.displayId,
+      before: `${beforeCenter.width}x${beforeCenter.height}@(${beforeCenter.x ?? "?"},${beforeCenter.y ?? "?"})`,
+      after: `${safeWindowState.width}x${safeWindowState.height}@(${safeWindowState.x ?? "?"},${safeWindowState.y ?? "?"})`
+    });
+  }
+  const restoredBounds = {
+    x: safeWindowState.x ?? 0,
+    y: safeWindowState.y ?? 0,
+    width: safeWindowState.width,
+    height: safeWindowState.height
+  };
+  win = new BrowserWindow({
+    show: false,
+    width: safeWindowState.width,
+    height: safeWindowState.height,
+    x: safeWindowState.x,
+    y: safeWindowState.y,
+    icon: path.join(process.env.VITE_PUBLIC, "electron-vite.svg"),
+    webPreferences: {
+      preload: path.join(__dirname$1, "..", "preload", "preload.js")
+    }
+  });
+  win.webContents.on("did-finish-load", () => {
+    win?.webContents.send("main-process-message", (/* @__PURE__ */ new Date()).toLocaleString());
+  });
+  if (VITE_DEV_SERVER_URL) {
+    logger.info("WINDOW", "Loading URL", { url: VITE_DEV_SERVER_URL });
+    win.loadURL(VITE_DEV_SERVER_URL);
+    win.webContents.openDevTools({ mode: "right" });
+  } else {
+    logger.info("WINDOW", "Loading file", {
+      path: path.join(RENDERER_DIST, "index.html")
+    });
+    win.loadFile(path.join(RENDERER_DIST, "index.html"));
+  }
+  win.once("ready-to-show", () => {
+    if (safeWindowState.isMaximized) {
+      logger.info("WINDOW", "Apply ready-to-show maximize");
+      win?.maximize();
+      win?.show();
+      logger.info("WINDOW", "Window show after maximize");
+      return;
+    }
+    win?.setBounds(restoredBounds, false);
+    win?.show();
+    logger.info("WINDOW", "Window show after bounds applied");
+  });
+  win.on("close", () => {
+    saveWindowState(win);
+    logger.info("SHUTDOWN", "Window state saved");
+  });
+}
+app.on("window-all-closed", () => {
+  logger.info("STARTUP", "Phase: window-all-closed");
+  if (process.platform !== "darwin") {
+    logger.log("SHUTDOWN", "Application quitting");
+    logger.shutdown();
+    app.quit();
+    win = null;
+  }
+});
+app.on("activate", () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  }
+});
+app.whenReady().then(() => {
+  logger.init();
+  if (!ELECTRON_MENU_ENABLED) {
+    Menu.setApplicationMenu(null);
+    logger.info("SYSTEM", "Application menu disabled (ELECTRON_MENU_ENABLED=false)");
+  }
+  logger.log("STARTUP", "Phase: IPC handlers register");
+  registerIpcHandlers();
+  createWindow();
+});
+export {
+  MAIN_DIST,
+  RENDERER_DIST,
+  VITE_DEV_SERVER_URL
+};

package/electron/dotenv.ts

@@ -0,0 +1,83 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+declare global {
+	namespace NodeJS {
+		interface ProcessEnv {
+			NODE_ENV: 'development' | 'test' | 'production'
+			readonly VITE_DEV_SERVER_URL: string
+			APP_ROOT: string
+			VITE_PUBLIC: string
+			LOG_ENABLED?: string
+			LOG_FILE?: string
+			LOG_CONSOLE?: string
+			SCREEN_CENTER?: string
+			ELECTRON_MENU_ENABLED?: string
+		}
+
+		interface Process {
+			electronApp: import('node:child_process').ChildProcess
+		}
+	}
+
+	interface ImportMeta {
+		/** shims Vite */
+		env: Record<string, unknown>
+	}
+
+	interface ElectronLoggerConfig {
+		enabled: boolean
+		file: boolean
+		console: boolean
+	}
+
+	/** Used in Renderer process, expose in `preload.ts` */
+	interface Window {
+		ipcRenderer: import('electron').IpcRenderer
+	}
+}
+
+export function parseDotEnv(content: string): Record<string, string> {
+	const out: Record<string, string> = {}
+	for (const line of content.split(/\r?\n/)) {
+		const trimmed = line.trim()
+		if (!trimmed || trimmed.startsWith('#')) continue
+		const eq = trimmed.indexOf('=')
+		if (eq === -1) continue
+		const key = trimmed.slice(0, eq).trim()
+		let value = trimmed.slice(eq + 1).trim()
+		if (
+			(value.startsWith('"') && value.endsWith('"')) ||
+			(value.startsWith("'") && value.endsWith("'"))
+		) {
+			value = value.slice(1, -1)
+		}
+		out[key] = value
+	}
+	return out
+}
+
+export function readDotEnvFile(appRoot: string): Record<string, string> {
+	const envPath = path.join(appRoot, '.env')
+	if (!fs.existsSync(envPath)) return {}
+	try {
+		return parseDotEnv(fs.readFileSync(envPath, 'utf-8'))
+	} catch {
+		return {}
+	}
+}
+
+export function parseEnvBoolean(value: string | undefined, defaultValue: boolean): boolean {
+	if (value === undefined || value === '') return defaultValue
+	const v = value.trim().toLowerCase()
+	if (v === '1' || v === 'true' || v === 'yes') return true
+	if (v === '0' || v === 'false' || v === 'no') return false
+	return defaultValue
+}
+
+export function pickString(...vals: (string | undefined)[]): string | undefined {
+	for (const v of vals) {
+		if (v !== undefined && v !== '') return v
+	}
+	return undefined
+}

package/electron/ipc.ts

@@ -0,0 +1,29 @@
+import { ipcMain, shell } from 'electron'
+
+/** IPC channel names shared by renderer and preload (single source of truth). */
+export const IPC_CHANNELS = {
+	/** `invoke(url: string)` — allows only `http:` / `https:`, then calls `shell.openExternal`. */
+	OPEN_EXTERNAL: 'app:open-external',
+} as const
+
+function isAllowedExternalUrl(url: string): boolean {
+	try {
+		const u = new URL(url)
+		return u.protocol === 'http:' || u.protocol === 'https:'
+	} catch {
+		return false
+	}
+}
+
+/** Registers IPC handlers in the main process (call once at startup). */
+export function registerIpcHandlers(): void {
+	ipcMain.handle(IPC_CHANNELS.OPEN_EXTERNAL, async (_event, raw: unknown) => {
+		if (typeof raw !== 'string' || raw.length === 0) {
+			throw new Error('open-external: URL must be a non-empty string')
+		}
+		if (!isAllowedExternalUrl(raw)) {
+			throw new Error('open-external: only http(s) URLs are allowed')
+		}
+		await shell.openExternal(raw)
+	})
+}

package/electron/logger.ts

@@ -0,0 +1,117 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { parseEnvBoolean, pickString, readDotEnvFile } from './dotenv'
+
+type LogLevel = 'SYSTEM' | 'LOGGER' | 'STARTUP' | 'WINDOW' | 'LOADING' | 'SHUTDOWN' | 'INFO' | 'WARN' | 'ERROR'
+
+type LoggerOptions = {
+	appRoot: string
+	isDevelopment: boolean
+	isPackaged: boolean
+	sessionId: string
+}
+
+type LogMeta = Record<string, unknown>
+
+function pad2(value: number) {
+	return String(value).padStart(2, '0')
+}
+
+function pad3(value: number) {
+	return String(value).padStart(3, '0')
+}
+
+function toDateStamp(date: Date) {
+	return `${date.getFullYear()}${pad2(date.getMonth() + 1)}${pad2(date.getDate())}`
+}
+
+function toTimeStamp(date: Date) {
+	return `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}.${pad3(date.getMilliseconds())}`
+}
+
+function resolveLoggerConfig(isDevelopment: boolean, isPackaged: boolean, appRoot: string): ElectronLoggerConfig {
+	const dotEnv = readDotEnvFile(appRoot)
+
+	const enabledRaw = pickString(process.env.LOG_ENABLED, dotEnv.LOG_ENABLED)
+	const enabled = parseEnvBoolean(enabledRaw, true)
+	if (!enabled) {
+		return { enabled: false, file: false, console: false }
+	}
+
+	const fileRaw = pickString(process.env.LOG_FILE, dotEnv.LOG_FILE)
+	const consoleRaw = pickString(process.env.LOG_CONSOLE, dotEnv.LOG_CONSOLE)
+
+	return {
+		enabled: true,
+		file: parseEnvBoolean(fileRaw, !isPackaged),
+		console: parseEnvBoolean(consoleRaw, isDevelopment),
+	}
+}
+
+class AppLogger {
+	private readonly config: ElectronLoggerConfig
+	private readonly isDevelopment: boolean
+	private readonly logsDir: string
+	private readonly logFile: string
+	private readonly sessionId: string
+
+	constructor(options: LoggerOptions) {
+		this.isDevelopment = options.isDevelopment
+		this.sessionId = options.sessionId
+		this.config = resolveLoggerConfig(options.isDevelopment, options.isPackaged, options.appRoot)
+		this.logsDir = path.join(options.appRoot, 'logs')
+		this.logFile = path.join(this.logsDir, `system.${toDateStamp(new Date())}.log`)
+	}
+
+	init() {
+		if (!this.config.enabled) return
+		if (!this.config.file && !this.config.console) return
+
+		if (this.config.file) {
+			fs.mkdirSync(this.logsDir, { recursive: true })
+		}
+		this.writeLine('SYSTEM', '='.repeat(112))
+		this.writeLine('SYSTEM', `Application Started | ${JSON.stringify({ devMode: this.isDevelopment, sessionId: this.sessionId })}`)
+		this.writeLine('SYSTEM', '='.repeat(112))
+		this.writeLine('LOGGER', 'Logger ready')
+	}
+
+	info(level: LogLevel, message: string, meta: LogMeta = {}) {
+		const metaJson = JSON.stringify(meta)
+		if (!metaJson || metaJson === '{}') {
+			this.writeLine(level, message)
+		} else {
+			this.writeLine(level, `${message} | ${metaJson}`)
+		}
+	}
+
+	log(level: LogLevel, message: string) {
+		this.writeLine(level, message)
+	}
+
+	shutdown() {
+		if (!this.config.enabled) return
+		if (!this.config.file && !this.config.console) return
+
+		this.writeLine('INFO', 'Logger shutting down')
+		this.writeLine('SYSTEM', '='.repeat(112))
+		this.writeLine('SYSTEM', `Application Ended | ${JSON.stringify({ sessionId: this.sessionId })}`)
+		this.writeLine('SYSTEM', '='.repeat(112) + '\n')
+	}
+
+	private writeLine(level: LogLevel, body: string) {
+		if (!this.config.enabled) return
+		if (!this.config.file && !this.config.console) return
+
+		const line = `[${toTimeStamp(new Date())}] [${level}] ${body}`
+		if (this.config.file) {
+			fs.appendFileSync(this.logFile, `${line}\n`, 'utf-8')
+		}
+		if (this.config.console) {
+			console.log(line)
+		}
+	}
+}
+
+export { AppLogger, resolveLoggerConfig }
+export type { LogLevel, LogMeta }