const { app, BrowserWindow, Menu, dialog, ipcMain, shell, nativeImage, clipboard, crashReporter } = require('electron');

const os = require('os');

const path = require('path');

const fs = require('fs');

const https = require('https');

const log = require('electron-log/main');

const { openInFinder } = require('./finder-actions');

const agentServer = require('./agent-server');

log.transports.file.level = 'info';

log.transports.console.level = 'debug';

Object.assign(console, log.functions);

productName: 'OpenMarkdownReader',

companyName: 'jacobcole',

uploadToServer: false,

ignoreSystemCrashHandler: false,

rateLimit: false,

compress: true

process.on('uncaughtException', (error) => {

console.error('[UNCAUGHT EXCEPTION]', error.stack || error);

process.on('unhandledRejection', (reason) => {

console.error('[UNHANDLED REJECTION]', reason);

const CRASH_REASON_MAP = {

'clean-exit': 'Process exited cleanly',

'abnormal-exit': 'Process exited abnormally',

'killed': 'Process was killed (SIGTERM/SIGKILL — usually deliberate)',

'crashed': 'Process crashed (segfault, JS uncaught exception, etc.)',

'oom': 'Process ran out of memory',

'launch-failed': 'Process failed to launch',

'integrity-failure': 'Code signing integrity check failed'

const CRASH_EXIT_CODE_MAP = {

0: 'Clean exit',

9: 'SIGKILL (force-killed by OS or `kill -9`)',

11: 'SIGSEGV (segmentation fault)',

15: 'SIGTERM (deliberately stopped, e.g. `pkill`)',

'-1': 'Unknown'

function describeCrash(processType, details) {

function handleProcessCrash(processType, details, win) {

app.on('child-process-gone', (event, details) => {

console.error(`[CHILD PROCESS GONE] type=${details.type} name=${details.name || 'n/a'} reason=${details.reason} exitCode=${details.exitCode}`);

// Only show dialog for serious crashes — clean exit and 'killed' during shutdown are normal.

if (details.reason === 'clean-exit' || details.reason === 'killed') return;

handleProcessCrash(details.type || 'child', details, null);

const { getFileIdentity, detectFileMove } = require('./file-watch-utils');

const {

findNameCollisionInDirectory

} = require('./file-creation-utils');

const {

moveFileToDirectory

} = require('./file-move-utils');

let buildInfo = { version: '0.0.0', buildNumber: 0, gitHash: 'dev', buildDate: '' };

try {

const buildInfoPath = path.join(__dirname, 'build-info.json');

if (fs.existsSync(buildInfoPath)) {

buildInfo = JSON.parse(fs.readFileSync(buildInfoPath, 'utf8'));

}

} catch {

// Fall back to package.json version

try {

const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));

buildInfo.version = pkg.version;

} catch {}

const devTag = buildInfo.isDev ? ' [DEV]' : (buildInfo.channel ? ` [${buildInfo.channel}]` : '');

function isMASBuild() {

const windows = new Set();

let isReadOnlyMode = true; // Default to read-only

let watchFileMode = false; // Watch for external file changes

const fileWatchers = new Map(); // Track active file watchers

const fileWatchDebounceTimers = new Map(); // Track debounce timers per watcher

const fileWatchStates = new Map(); // Track watcher metadata (path/inode/search root)

const pendingOpenFiles = [];

function parseArgs(argv) {

const gotTheLock = app.requestSingleInstanceLock();

if (!gotTheLock) {

app.quit();

} else {

app.on('second-instance', (event, argv, workingDirectory) => {

// Someone tried to run a second instance, we should focus our window.

const win = getFocusedWindow();

if (win) {

if (win.isMinimized()) win.restore();

win.focus();

const args = parseArgs(argv);

// Apply flags to session

if (args.watch) {

watchFileMode = true;

windows.forEach(w => w.webContents.send('set-watch-mode', true));

}

if (args.theme) {

setTheme(args.theme);

}

if (args.monospace !== null) {

config.editorMonospace = args.monospace;

saveConfig();

broadcastSetting('editor-monospace', args.monospace);

}

// Open daily notes if requested

if (args.scratch) {

createDailyNote(win, 'scratch');

}

if (args.ref) {

createDailyNote(win, 'ref');

}

// Create new file if requested

if (args.newFile) {

win.webContents.send('new-file');

}

// Open any files passed

args.files.forEach(file => {

const fullPath = path.isAbsolute(file) ? file : path.join(workingDirectory, file);

openPathInWindow(win, fullPath, { forceEdit: args.edit });

});

setupMenu(); // Update menu checkmarks

}

});

const configPath = path.join(app.getPath('userData'), 'config.json');

let config = {

theme: 'system', // 'system', 'light', 'dark'

recentFiles: [], // Array of { path, type: 'file' | 'folder', timestamp }

maxRecentFiles: 10,

contentWidth: 900,

contentPadding: 20,

editorMonospace: false, // Use monospace font in editor

compactTables: false, // Compact table cells (nowrap + horizontal scroll)

restoreSession: true, // Whether to restore previous session on launch

session: null, // Saved session state: { windows: [{ tabs: [{filePath, fileName}], directory: dirPath }] }

cliCommandPath: null,

watchMode: false, // Watch for external file changes

dailyNotesFolder: null, // Path to folder for daily notes

dailyNotesFormat: 'YYYY-MM-DD', // Date format for filenames

dailyNotesTemplate: '', // Optional template for new daily notes

askedAboutDefaultApp: false // Whether we've asked to set as default

const CLI_COMMAND_NAMES = ['omr', 'openmd'];

const APP_BUNDLE_ID = 'com.jacobcole.openmarkdownreader';

function getCliScriptContents(commandName) {

function getCliImplementation() {

function getCliInstallCandidates() {

function isDirInPath(dirPath) {

const envPath = process.env.PATH || '';

return envPath.split(':').includes(dirPath);

function ensureWritableDir(dirPath, { create } = { create: false }) {

async function installCliCommand() {

async function uninstallCliCommand() {

function openPathInWindow(win, targetPath, options = {}) {

function loadConfig() {

function saveConfig() {

async function reviewUnsavedTabsOneByOne(win, unsavedTabs) {

function saveTabInRenderer(win, tabInfo) {

function addToRecent(filePath, type = 'file') {

function clearRecentFiles() {

watchFileMode = config.watchMode || false;

function cleanupFileWatchersForWindow(winId) {

function createWindow(filePath = null) {