version: 0.10.0

fix: unlinking a file without handling the case of file not exist

gulpfile.ts

@@ -1,6 +1,5 @@
 import gulp from "gulp";
 import ts from "gulp-typescript";
-// @ts-ignore
 import clean from "gulp-clean";
 import fs from "fs";
 
@@ -30,7 +29,7 @@ gulp.task("assets", () => {
 });
 
 gulp.task("binary", () => {
-	return gulp.src("bin/**/*", { encoding: false }).pipe(gulp.dest("dist/electron/bin"));
+	return gulp.src(`bin/${process.platform}-${process.arch}/**/*`, { encoding: false }).pipe(gulp.dest("dist/electron/bin"));
 });
 
 gulp.task("locales", () => {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrewind",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "type": "module",
   "description": "Your second brain, superpowered.",
   "main": "dist/electron/index.js",
@@ -21,6 +21,7 @@
     "@alikia/random-key": "npm:@jsr/alikia__random-key",
     "@electron/remote": "^2.1.2",
     "@hono/node-server": "^1.13.7",
+    "@types/node-os-utils": "^1.3.4",
     "@unly/universal-language-detector": "^2.0.3",
     "better-sqlite3": "^11.6.0",
     "dayjs": "^1.11.13",
@@ -41,6 +42,7 @@
     "image-size": "^1.1.1",
     "jotai": "^2.11.0",
     "memory-cache": "^0.2.0",
+    "node-os-utils": "^1.3.7",
     "pino": "^9.6.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",

pages/rewind/index.tsx

@@ -34,7 +34,7 @@ function Image({ src }: { src: string }) {
 		<img
 			src={src}
 			alt="Current frame"
-			className="w-full h-full object-cover absolute inset-0"
+			className="w-full h-full object-contain absolute inset-0"
 		/>
 	);
 }
@@ -181,8 +181,6 @@ export default function RewindPage() {
 		const newIndex = Math.min(Math.max(currentIndex - delta, 0), timeline.length - 1);
 		const newFrameId = timeline[newIndex].id;
 
-		console.log(currentFrameId, lastAvaliableFrameId);
-
 		if (newFrameId !== currentFrameId) {
 			setCurrentFrameId(newFrameId);
 			// Preload adjacent images
@@ -212,9 +210,19 @@ export default function RewindPage() {
 	return (
 		<div
 			ref={containerRef}
-			className="w-screen h-screen relative dark:text-white overflow-hidden"
+			className="w-screen h-screen relative dark:text-white overflow-hidden bg-black"
 			onWheel={handleScroll}
 		>
+			<img
+				src={currentFrameId
+					? images[currentFrameId] ||
+					  (lastAvaliableFrameId.current ? images[lastAvaliableFrameId.current] : "")
+					: ""}
+				alt="background"
+				className="w-full h-full object-cover absolute inset-0 blur-lg"
+			/>
+
+			
 			{/* Current image */}
 			<Image
 				src={
@@ -225,6 +233,8 @@ export default function RewindPage() {
 				}
 			/>
 
+			
+
 			{/* Time capsule */}
 			<div
 				className="absolute bottom-8 left-8 bg-zinc-800 text-white bg-opacity-80 backdrop-blur-lg

src/electron/backend/encoding.ts

@@ -1,4 +1,3 @@
-import { Database } from "better-sqlite3";
 import { exec } from "child_process";
 import fs from "fs";
 import path, { join } from "path";
@@ -8,19 +7,22 @@ import { getEncodeCommand } from "../utils/index.js";
 import { getRecordingsDir, getEncodingTempDir, getScreenshotsDir } from "../utils/index.js";
 import cache from "memory-cache";
 import { ENCODING_FRAME_INTERVAL, RECORD_FRAME_RATE as FRAME_RATE } from "./consts.js";
+import { getDatabase } from "../utils/index.js";
 
 const THREE_MINUTES = 180;
 const MIN_FRAMES_TO_ENCODE = THREE_MINUTES * FRAME_RATE;
 const CONCURRENCY = 1;
 
 // Detect and insert encoding tasks
-export function checkFramesForEncoding(db: Database) {
+export function checkFramesForEncoding() {
+	const db = getDatabase();
 	const stmt = db.prepare(`
         SELECT id, imgFilename, createdAt
         FROM frame
-        WHERE encodeStatus = 0 AND imgFilename IS NOT NULL
-        ORDER BY createdAt ASC;
-    `);
+        WHERE encodeStatus = 0
+          AND imgFilename IS NOT NULL
+        ORDER BY createdAt;
+	`);
 	const frames = stmt.all() as Frame[];
 
 	const buffer: Frame[] = [];
@@ -32,12 +34,12 @@ export function checkFramesForEncoding(db: Database) {
 		const lastFramePath = join(getScreenshotsDir(), lastFrame.imgFilename!);
 		if (!fs.existsSync(framePath)) {
 			console.warn("File not exist:", frame.imgFilename);
-			deleteFrameFromDB(db, frame.id);
+			deleteFrameFromDB(frame.id);
 			continue;
 		}
 		if (!fs.existsSync(lastFramePath)) {
 			console.warn("File not exist:", lastFrame.imgFilename);
-			deleteFrameFromDB(db, lastFrame.id);
+			deleteFrameFromDB(lastFrame.id);
 			continue;
 		}
 		const currentFrameSize = sizeOf(framePath);
@@ -51,20 +53,24 @@ export function checkFramesForEncoding(db: Database) {
 		if (chunkConditionSatisfied) {
 			// Create new encoding task
 			const taskStmt = db.prepare(`
-				INSERT INTO encoding_task (status) VALUES (0);
+				INSERT INTO encoding_task (status)
+				VALUES (0);
 			`);
 			const taskId = taskStmt.run().lastInsertRowid;
 
 			// Insert frames into encoding_task_data
 			const insertStmt = db.prepare(`
-				INSERT INTO encoding_task_data (encodingTaskID, frame) VALUES (?, ?);
+				INSERT INTO encoding_task_data (encodingTaskID, frame)
+				VALUES (?, ?);
 			`);
 			for (const frame of buffer) {
 				insertStmt.run(taskId, frame.id);
 				db.prepare(
 					`
-					UPDATE frame SET encodeStatus = 1 WHERE id = ?;
-				`
+						UPDATE frame
+						SET encodeStatus = 1
+						WHERE id = ?;
+					`
 				).run(frame.id);
 			}
 			console.log(`Created encoding task ${taskId} with ${buffer.length} frames`);
@@ -73,28 +79,39 @@ export function checkFramesForEncoding(db: Database) {
 	}
 }
 
-function deleteEncodedScreenshots(db: Database) {
+function deleteEncodedScreenshots() {
+	const db = getDatabase();
 	// TODO: double-check that the frame was really encoded into the video
 	const stmt = db.prepare(`
-	    SELECT * FROM frame WHERE encodeStatus = 2 AND imgFilename IS NOT NULL;
+		SELECT *
+		FROM frame
+		WHERE encodeStatus = 2
+		  AND imgFilename IS NOT NULL;
 	`);
 	const frames = stmt.all() as Frame[];
 	for (const frame of frames) {
-		if (!frame.imgFilename) continue;
-		fs.unlinkSync(path.join(getScreenshotsDir(), frame.imgFilename));
+		const imgPath = path.join(getScreenshotsDir(), frame.imgFilename!);
+		if (fs.existsSync(imgPath)) {
+			fs.unlinkSync(imgPath);
+		}
 		const updateStmt = db.prepare(`
-			UPDATE frame SET imgFilename = NULL WHERE id = ?;
+			UPDATE frame
+			SET imgFilename = NULL
+			WHERE id = ?;
 		`);
 		updateStmt.run(frame.id);
 	}
 }
 
-function _deleteNonExistentScreenshots(db: Database) {
+function _deleteNonExistentScreenshots() {
+	const db = getDatabase();
 	const screenshotDir = getScreenshotsDir();
 	const filesInDir = new Set(fs.readdirSync(screenshotDir));
 
 	const dbStmt = db.prepare(`
-	    SELECT imgFilename FROM frame WHERE imgFilename IS NOT NULL;
+		SELECT imgFilename
+		FROM frame
+		WHERE imgFilename IS NOT NULL;
 	`);
 	const dbFiles = dbStmt.all() as { imgFilename: string }[];
 	const dbFileSet = new Set(dbFiles.map((f) => f.imgFilename));
@@ -107,14 +124,17 @@ function _deleteNonExistentScreenshots(db: Database) {
 	}
 }
 
-export async function deleteUnnecessaryScreenshots(db: Database) {
-	deleteEncodedScreenshots(db);
-	//deleteNonExistentScreenshots(db);
+export async function deleteUnnecessaryScreenshots() {
+	deleteEncodedScreenshots();
+	//deleteNonExistentScreenshots();
 }
 
-export function deleteFrameFromDB(db: Database, id: number) {
+export function deleteFrameFromDB(id: number) {
+	const db = getDatabase();
 	const deleteStmt = db.prepare(`
-		DELETE FROM frame WHERE id = ?;
+		DELETE
+		FROM frame
+		WHERE id = ?;
 	`);
 	deleteStmt.run(id);
 	console.log(`Deleted frame ${id} from database`);
@@ -136,16 +156,16 @@ function createMetaFile(frames: Frame[]) {
 }
 
 // Check and process encoding task
-export function processEncodingTasks(db: Database) {
+export function processEncodingTasks() {
+	const db = getDatabase();
 	let tasksPerforming = getTasksPerforming();
 	if (tasksPerforming.length >= CONCURRENCY) return;
 
 	const stmt = db.prepare(`
-        SELECT id, status
-        FROM encoding_task
-        WHERE status = 0
-        LIMIT ?
-    `);
+		SELECT id, status
+		FROM encoding_task
+		WHERE status = 0 LIMIT ?
+	`);
 
 	const tasks = stmt.all(CONCURRENCY - tasksPerforming.length) as EncodingTask[];
 
@@ -156,17 +176,19 @@ export function processEncodingTasks(db: Database) {
 
 		// Update task status as processing (1)
 		const updateStmt = db.prepare(`
-            UPDATE encoding_task SET status = 1 WHERE id = ?
-        `);
+			UPDATE encoding_task
+			SET status = 1
+			WHERE id = ?
+		`);
 		updateStmt.run(taskId);
 
 		const framesStmt = db.prepare(`
             SELECT frame.imgFilename, frame.id
             FROM encoding_task_data
-            JOIN frame ON encoding_task_data.frame = frame.id
+                     JOIN frame ON encoding_task_data.frame = frame.id
             WHERE encoding_task_data.encodingTaskID = ?
-            ORDER BY frame.createdAt ASC
-        `);
+            ORDER BY frame.createdAt
+		`);
 		const frames = framesStmt.all(taskId) as Frame[];
 
 		const metaFilePath = path.join(getEncodingTempDir(), `${taskId}_meta.txt`);
@@ -186,13 +208,19 @@ export function processEncodingTasks(db: Database) {
 				console.log(`Video ${videoPath} created successfully`);
 				// Update task status to complete (2)
 				const completeStmt = db.prepare(`
-                    UPDATE encoding_task SET status = 2 WHERE id = ?
-                `);
+					UPDATE encoding_task
+					SET status = 2
+					WHERE id = ?
+				`);
 				completeStmt.run(taskId);
 				for (let frameIndex = 0; frameIndex < frames.length; frameIndex++) {
 					const frame = frames[frameIndex];
 					const updateFrameStmt = db.prepare(`
-					    UPDATE frame SET videoPath = ?, videoFrameIndex = ?, encodeStatus = 2 WHERE id = ?
+						UPDATE frame
+						SET videoPath       = ?,
+							videoFrameIndex = ?,
+							encodeStatus    = 2
+						WHERE id = ?
 					`);
 					updateFrameStmt.run(`${taskId}.mp4`, frameIndex, frame.id);
 				}

src/electron/backend/init.ts

@@ -2,17 +2,17 @@ import * as path from "path";
 import { Database } from "better-sqlite3";
 import DB from "better-sqlite3";
 import { __dirname } from "../dirname.js";
-import { getDatabaseDir } from "../utils/index.js";
+import { getBinDir, getDatabaseDir } from "../utils/index.js";
 import { migrate } from "./migrate/index.js";
 
 function getLibSimpleExtensionPath() {
 	switch (process.platform) {
 		case "win32":
-			return path.join(__dirname, "bin", process.platform, "libsimple", "simple.dll");
+			return path.join(getBinDir(), "libsimple", "simple.dll");
 		case "darwin":
-			return path.join(__dirname, "bin", process.platform, "libsimple", "libsimple.dylib");
+			return path.join(getBinDir(), "libsimple", "libsimple.dylib");
 		case "linux":
-			return path.join(__dirname, "bin", process.platform, "libsimple", "libsimple.so");
+			return path.join(getBinDir(), "libsimple", "libsimple.so");
 		default:
 			throw new Error("Unsupported platform");
 	}
@@ -142,7 +142,7 @@ function init(db: Database) {
 
 export async function initDatabase() {
 	const dbPath = getDatabaseDir();
-	const db = new DB(dbPath, { verbose: console.log });
+	const db = new DB(dbPath);
 	const libSimpleExtensionPath = getLibSimpleExtensionPath();
 
 	db.loadExtension(libSimpleExtensionPath);

src/electron/backend/recognition.ts

@@ -0,0 +1,13 @@
+type RecognitionResult = RecognitionLine[];
+type Pixels = number;
+type OriginX = Pixels;
+type OriginY = Pixels;
+type Width = Pixels;
+type Height = Pixels;
+type Coordinates = [OriginX, OriginY, Width, Height];
+
+interface RecognitionLine {
+    text: string;
+    confidence?: number | number[];
+    position?: Coordinates;
+}

src/electron/backend/scheduler.ts

@@ -0,0 +1,253 @@
+import osu from "node-os-utils";
+
+type TaskId = string;
+type TaskFunction = () => void;
+
+interface Task {
+	id: TaskId;
+	func: TaskFunction;
+	interval?: number;
+	lastRun?: number;
+	nextRun?: number;
+	isPaused: boolean;
+	delayUntil?: number;
+	requiredSystemState: SystemState;
+}
+
+export interface TaskStatus {
+    status: "NOT_FOUND" | "PAUSED" | "DELAYED" | "SCHEDULED" | "IDLE";
+    until?: string;
+    nextRun?: string;
+}
+
+type SystemState = "ANY" | "LOW_POWER" | "IDLE";
+
+export class Scheduler {
+	private tasks: Map<TaskId, Task> = new Map();
+	private timer: NodeJS.Timeout | null = null;
+	private monitorTimer: NodeJS.Timeout | null = null;
+	private cpuUsage: number = 0;
+
+	constructor(private readonly minTickInterval: number = 500) {
+		this.start();
+	}
+
+	private start(): void {
+		this.scheduleNextTick();
+		this.monitorTimer = setInterval(() => this.monitor(), 1000);
+	}
+
+	private monitor(): void {
+	    osu.cpu.usage().then((cpuPercentage) => {
+	        this.cpuUsage = cpuPercentage / 100;
+	    })
+	}
+
+	private scheduleNextTick(): void {
+		if (this.timer) {
+			clearTimeout(this.timer);
+		}
+
+		const now = Date.now();
+		let nextTick = now + this.minTickInterval;
+
+		for (const task of this.tasks.values()) {
+            const isTaskPaused = task.isPaused;
+            const isTaskDelayed = task.delayUntil && now < task.delayUntil;
+			if (isTaskPaused || isTaskDelayed) {
+				continue;
+			}
+
+            const nextTaskEarlierThanNextTick = task.nextRun && task.nextRun < nextTick;
+			if (nextTaskEarlierThanNextTick) {
+				nextTick = task.nextRun!;
+			}
+		}
+
+		const delay = Math.max(0, nextTick - now);
+		this.timer = setTimeout(() => this.tick(), delay);
+	}
+
+	private tickSingleTask(
+		task: Task,
+		getNextTick: () => number,
+		updateNextTick: (nextTick: number) => void
+	): void {
+		const now = Date.now();
+		const isTaskPaused = task.isPaused;
+		const isTaskDelayed = task.delayUntil && now < task.delayUntil;
+
+		if (isTaskPaused || isTaskDelayed) {
+			return;
+		}
+
+		const taskRequiredLowPower = task.requiredSystemState === "LOW_POWER";
+		const cpuUsage = this.cpuUsage;
+		const isSystemLowPower = cpuUsage < 0.75;
+		const isTaskReadyForLowPowerRun = taskRequiredLowPower ? isSystemLowPower : true;
+		const reachedTaskNextRun = task.interval && task.nextRun && now >= task.nextRun;
+		const isTaskReadyForIntervalRun = reachedTaskNextRun && isTaskReadyForLowPowerRun;
+		
+		if (!isTaskReadyForLowPowerRun) {
+			this.delayTask(task.id, 1000)
+		}
+
+		if (isTaskReadyForIntervalRun) {
+			task.func();
+			task.lastRun = now;
+			task.nextRun = now + task.interval!;
+		}
+
+		const isTaskNextRunEarlierThanNextTick = task.nextRun && task.nextRun < getNextTick();
+		if (isTaskNextRunEarlierThanNextTick) {
+			updateNextTick(task.nextRun!);
+		}
+	}
+
+	private tick(): void {
+		const now = Date.now();
+		let nextTick = now + this.minTickInterval;
+
+		for (const task of this.tasks.values()) {
+			this.tickSingleTask(
+				task,
+				() => nextTick,
+				(v) => (nextTick = v)
+			);
+		}
+
+		this.scheduleNextTick();
+	}
+
+	/**
+	 * Add a new task to the scheduler.
+	 *
+	 * @param id A unique string identifier for the task.
+	 * @param func The function to be executed by the task.
+	 * @param interval The interval (in milliseconds) between task executions.
+	 * @param requiredSystemState The required system state for the task to run.
+	 */
+	addTask(id: TaskId, func: TaskFunction, interval?: number, requiredSystemState: SystemState = "ANY"): void {
+		this.tasks.set(id, {
+			id,
+			func,
+			interval,
+			isPaused: false,
+			lastRun: undefined,
+			nextRun: interval ? Date.now() + interval : undefined,
+			requiredSystemState: requiredSystemState,
+		});
+
+		this.scheduleNextTick();
+	}
+
+	/**
+	 * Trigger a task to execute immediately, regardless of its current state.
+	 *
+	 * If the task is paused or delayed, it will not be executed.
+	 *
+	 * @param id The unique string identifier for the task.
+	 */
+	triggerTask(id: TaskId): void {
+		const task = this.tasks.get(id);
+		if (task && !task.isPaused && (!task.delayUntil || Date.now() >= task.delayUntil)) {
+			task.func();
+			task.lastRun = Date.now();
+			if (task.interval) {
+				task.nextRun = Date.now() + task.interval;
+			}
+		}
+
+		this.scheduleNextTick();
+	}
+
+	/**
+	 * Pause a task, so that it will not be executed until it is resumed.
+	 *
+	 * @param id The unique string identifier for the task.
+	 */
+	pauseTask(id: TaskId): void {
+		const task = this.tasks.get(id);
+		if (task) {
+			task.isPaused = true;
+		}
+
+		this.scheduleNextTick();
+	}
+
+	/**
+	 * Resume a paused task, so that it can be executed according to its interval.
+	 *
+	 * @param id The unique string identifier for the task.
+	 */
+	resumeTask(id: TaskId): void {
+		const task = this.tasks.get(id);
+		if (task) {
+			task.isPaused = false;
+		}
+
+		this.scheduleNextTick();
+	}
+
+	/**
+	 * Delay a task from being executed for a specified amount of time.
+	 *
+	 * @param id The unique string identifier for the task.
+	 * @param delayMs The amount of time in milliseconds to delay the task's execution.
+	 */
+	delayTask(id: TaskId, delayMs: number): void {
+		const task = this.tasks.get(id);
+		if (task) {
+			task.delayUntil = Date.now() + delayMs;
+			if (task.nextRun) {
+				task.nextRun += delayMs;
+			}
+		}
+
+		this.scheduleNextTick();
+	}
+
+	setTaskInterval(id: TaskId, interval: number): void {
+		const task = this.tasks.get(id);
+		if (task) {
+			task.interval = interval;
+			task.nextRun = Date.now() + interval;
+		}
+
+		this.scheduleNextTick();
+	}
+
+	getTaskStatus(id: TaskId): TaskStatus {
+	    const task = this.tasks.get(id);
+	    if (!task) {
+	        return { status: "NOT_FOUND" };
+	    }
+	    if (task.isPaused) {
+	        return { status: "PAUSED" };
+	    }
+	    if (task.delayUntil && Date.now() < task.delayUntil) {
+	        return {
+	            status: "DELAYED",
+	            until: new Date(task.delayUntil).toLocaleString()
+	        };
+	    }
+	    if (task.nextRun) {
+	        return {
+	            status: "SCHEDULED",
+	            nextRun: new Date(task.nextRun).toLocaleString()
+	        };
+	    }
+	    return { status: "IDLE" };
+	}
+
+	stop(): void {
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		if (this.monitorTimer) {
+			clearTimeout(this.monitorTimer);
+			this.monitorTimer = null;
+		}
+	}
+}

src/electron/backend/screenshot.ts

@@ -1,25 +1,23 @@
 import screenshot from "screenshot-desktop";
-import { getScreenshotsDir } from "../utils/index.js";
+import { getDatabase, getScreenshotsDir } from "../utils/index.js";
 import { join } from "path";
-import { Database } from "better-sqlite3";
 import SqlString from "sqlstring";
 
-export function startScreenshotLoop(db: Database) {
-	return setInterval(() => {
-		const timestamp = new Date().getTime();
-		const screenshotDir = getScreenshotsDir();
-		const filename = `${timestamp}.png`;
-		const screenshotPath = join(screenshotDir, filename);
-		screenshot({ filename: screenshotPath, format: "png" })
-			.then(() => {
-				const SQL = SqlString.format(
-					"INSERT INTO frame (imgFilename, createdAt) VALUES (?, ?)",
-					[filename, new Date().getTime() / 1000]
-				);
-				db.exec(SQL);
-			})
-			.catch((err) => {
-				console.error(err);
-			});
-	}, 2000);
+export function takeScreenshot() {
+	const db = getDatabase();
+	const timestamp = new Date().getTime();
+	const screenshotDir = getScreenshotsDir();
+	const filename = `${timestamp}.png`;
+	const screenshotPath = join(screenshotDir, filename);
+	screenshot({ filename: screenshotPath, format: "png" })
+		.then(() => {
+			const SQL = SqlString.format(
+				"INSERT INTO frame (imgFilename, createdAt) VALUES (?, ?)",
+				[filename, new Date().getTime() / 1000]
+			);
+			db.exec(SQL);
+		})
+		.catch((err) => {
+			console.error(err);
+		});
 }

src/electron/index.ts

@@ -14,7 +14,7 @@ import initI18n from "./i18n.js";
 import { createMainWindow, createSettingsWindow } from "./createWindow.js";
 import { initDatabase } from "./backend/init.js";
 import { Database } from "better-sqlite3";
-import { startScreenshotLoop } from "./backend/screenshot.js";
+import { takeScreenshot } from "./backend/screenshot.js";
 import { __dirname } from "./dirname.js";
 import { hideDock } from "./utils/index.js";
 import {
@@ -27,16 +27,17 @@ import { serve } from "@hono/node-server";
 import { findAvailablePort } from "./utils/index.js";
 import cache from "memory-cache";
 import { generate as generateAPIKey } from "@alikia/random-key";
+import { Scheduler } from "./backend/scheduler.js";
 
 const i18n = initI18n();
 
 const t = i18n.t.bind(i18n);
 const port = process.env.PORT || "5173";
 const dev = !app.isPackaged;
+const scheduler = new Scheduler();
 
 let tray: null | Tray = null;
 let dbConnection: null | Database = null;
-let screenshotInterval: null | NodeJS.Timeout = null;
 
 let mainWindow: BrowserWindow | null;
 let settingsWindow: BrowserWindow | null;
@@ -109,10 +110,10 @@ app.on("ready", () => {
 		});
 	});
 	initDatabase().then((db) => {
-		screenshotInterval = startScreenshotLoop(db);
-		setInterval(checkFramesForEncoding, 5000, db);
-		setInterval(processEncodingTasks, 10000, db);
-		setInterval(deleteUnnecessaryScreenshots, 20000, db);
+		scheduler.addTask("screenshot", takeScreenshot, 2000);
+		scheduler.addTask("check-encoding", checkFramesForEncoding, 5000);
+		scheduler.addTask("process-encoding", processEncodingTasks, 10000, "LOW_POWER");
+		scheduler.addTask("delete-screenshots", deleteUnnecessaryScreenshots, 20000);
 		dbConnection = db;
 		cache.put("server:dbConnection", dbConnection);
 	});
@@ -126,7 +127,7 @@ app.on("ready", () => {
 
 app.on("will-quit", () => {
 	dbConnection?.close();
-	if (screenshotInterval) clearInterval(screenshotInterval);
+	scheduler.stop();
 });
 
 ipcMain.on("close-settings", () => {
@@ -134,8 +135,8 @@ ipcMain.on("close-settings", () => {
 });
 
 ipcMain.handle("request-api-info", () => {
-  return {
-    port: cache.get("server:port"),
-    apiKey: cache.get("server:APIKey")
-  };
+	return {
+		port: cache.get("server:port"),
+		apiKey: cache.get("server:APIKey")
+	};
 });

src/electron/utils/backend/index.ts

@@ -0,0 +1,6 @@
+import { Database } from "better-sqlite3";
+import cache from "memory-cache";
+
+export function getDatabase(): Database {
+	return cache.get("server:dbConnection");
+}

src/electron/utils/fs/index.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import fs from "fs";
 import { getUserDataDir } from "../platform/index.js";
+import { __dirname } from "../../dirname.js";
 
 export function createDataDir() {
 	const dataDir = getUserDataDir();
@@ -68,6 +69,10 @@ export function getLogDir() {
 	return logDir;
 }
 
+export function getBinDir() {
+	return path.join(__dirname, "bin");
+}
+
 export async function waitForFileExists(filePath: string, timeout: number = 10000): Promise<void> {
 	return new Promise((resolve, reject) => {
 		fs.access(filePath, fs.constants.F_OK, (err) => {

src/electron/utils/index.ts

@@ -3,3 +3,4 @@ export * from "./platform/index.js";
 export * from "./video/index.js";
 export * from "./network/index.js";
 export * from "./logging/index.js";
+export * from "./backend/index.js";

src/electron/utils/platform/index.ts

@@ -1,8 +1,7 @@
 import { join } from "path";
 import os from "os";
 import { app } from "electron";
-import { __dirname } from "../../dirname.js";
-import { logger } from "../index.js";
+import { getBinDir, logger } from "../index.js";
 
 export function getUserDataDir() {
 	switch (process.platform) {
@@ -41,13 +40,13 @@ export function getFFmpegPath() {
 	let path = "";
 	switch (process.platform) {
 		case "win32":
-			path = join(__dirname, "bin", process.platform, "ffmpeg.exe");
+			path = join(getBinDir(), "ffmpeg.exe");
 			break;
 		case "darwin":
-			path = join(__dirname, "bin", process.platform, "ffmpeg");
+			path = join(getBinDir(), "ffmpeg");
 			break;
 		case "linux":
-			path = join(__dirname, "bin", process.platform, "ffmpeg");
+			path = join(getBinDir(), "ffmpeg");
 			break;
 		default:
 			throw new Error("Unsupported platform");
@@ -55,3 +54,7 @@ export function getFFmpegPath() {
 	logger.info("FFmpeg path: %s", path);
 	return path;
 }
+
+export function getOCRitPath() {
+	const path = join(getBinDir(), "ocrit");
+}