Merged in release/1.0.7 (pull request #5)

Release/1.0.7

deploy/set-artifact-name.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// Cross-platform script to set artifact naming based on version
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+// Read the package.json to get the version
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const version = packageJson.version;
+
+console.log(`Current version: ${version}`);
+
+// Determine the artifact suffix based on the version
+let artifactSuffix = '';
+
+if (version.includes('alpha')) {
+    artifactSuffix = `alpha-${version}-`;
+    console.log(`Detected alpha version, setting suffix to: ${artifactSuffix}`);
+} else if (version.includes('beta')) {
+    artifactSuffix = `beta-${version}-`;
+    console.log(`Detected beta version, setting suffix to: ${artifactSuffix}`);
+} else {
+    artifactSuffix = '';
+    console.log('Detected release version, no suffix will be added');
+}
+
+// Set the environment variable for the current process
+process.env.ARTIFACT_SUFFIX = artifactSuffix;
+
+console.log(`ARTIFACT_SUFFIX set to: '${artifactSuffix}'`);
+
+// If arguments are passed, execute the remaining command with the environment variable set
+if (process.argv.length > 2) {
+    const command = process.argv[2];
+    const args = process.argv.slice(3);
+    
+    console.log(`Executing: ${command} ${args.join(' ')}`);
+    
+    const child = spawn(command, args, {
+        stdio: 'inherit',
+        env: { ...process.env, ARTIFACT_SUFFIX: artifactSuffix },
+        shell: true
+    });
+    
+    child.on('close', (code) => {
+        process.exit(code);
+    });
+} else {
+    // Just setting the environment variable
+    console.log('Environment variable set. Use this script with additional arguments to run commands with the variable set.');
+}

deploy/set-artifact-name.ps1

@@ -0,0 +1,38 @@
+# PowerShell script to set artifact naming based on version
+param(
+    [string]$ConfigType = "imex"
+)
+
+# Read the package.json to get the version
+$packageJsonPath = Join-Path $PSScriptRoot "..\package.json"
+$packageJson = Get-Content $packageJsonPath | ConvertFrom-Json
+$version = $packageJson.version
+
+Write-Host "Current version: $version"
+
+# Determine the artifact suffix based on the version
+$artifactSuffix = ""
+
+if ($version -match "alpha") {
+    $artifactSuffix = "alpha-${version}-"
+    Write-Host "Detected alpha version, setting suffix to: $artifactSuffix"
+}
+elseif ($version -match "beta") {
+    $artifactSuffix = "beta-${version}-"
+    Write-Host "Detected beta version, setting suffix to: $artifactSuffix"
+}
+else {
+    $artifactSuffix = ""
+    Write-Host "Detected release version, no suffix will be added"
+}
+
+# Set the environment variable
+$env:ARTIFACT_SUFFIX = $artifactSuffix
+
+# Export for the current session
+[Environment]::SetEnvironmentVariable("ARTIFACT_SUFFIX", $artifactSuffix, "Process")
+
+Write-Host "ARTIFACT_SUFFIX set to: '$env:ARTIFACT_SUFFIX'"
+
+# Return the suffix for use in other scripts
+return $artifactSuffix

deploy/set-artifact-name.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Bash script to set artifact naming based on version
+
+# Get the directory where this script is located
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Read the package.json to get the version
+PACKAGE_JSON_PATH="$SCRIPT_DIR/../package.json"
+VERSION=$(node -p "require('$PACKAGE_JSON_PATH').version")
+
+echo "Current version: $VERSION"
+
+# Determine the artifact suffix based on the version
+ARTIFACT_SUFFIX=""
+
+if [[ $VERSION == *"alpha"* ]]; then
+    ARTIFACT_SUFFIX="alpha-${VERSION}-"
+    echo "Detected alpha version, setting suffix to: $ARTIFACT_SUFFIX"
+elif [[ $VERSION == *"beta"* ]]; then
+    ARTIFACT_SUFFIX="beta-${VERSION}-"
+    echo "Detected beta version, setting suffix to: $ARTIFACT_SUFFIX"
+else
+    ARTIFACT_SUFFIX=""
+    echo "Detected release version, no suffix will be added"
+fi
+
+# Export the environment variable
+export ARTIFACT_SUFFIX="$ARTIFACT_SUFFIX"
+
+echo "ARTIFACT_SUFFIX set to: '$ARTIFACT_SUFFIX'"
+
+# Also write to a temporary file for sourcing in other scripts
+echo "export ARTIFACT_SUFFIX='$ARTIFACT_SUFFIX'" > "$SCRIPT_DIR/.artifact-suffix.env"

deploy/test-artifact-naming-cross-platform.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// Cross-platform test script to demonstrate artifact naming for different versions
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('=== Artifact Naming Test (Cross-Platform) ===');
+console.log('');
+
+// Get current version
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const currentVersion = packageJson.version;
+
+console.log(`Current version: ${currentVersion}`);
+
+// Function to get artifact suffix
+function getArtifactSuffix(version) {
+    if (version.includes('alpha')) {
+        return `alpha-${version}-`;
+    } else if (version.includes('beta')) {
+        return `beta-${version}-`;
+    } else {
+        return '';
+    }
+}
+
+// Test scenarios
+const testVersions = [
+    '1.0.5',               // Release version
+    '1.0.5-alpha.2',       // Alpha version
+    '1.0.5-beta.1',        // Beta version
+    '2.0.0-alpha.1',       // Another alpha
+    '1.5.0-beta.3'         // Another beta
+];
+
+console.log('Test scenarios:');
+console.log('==================');
+
+testVersions.forEach(version => {
+    const suffix = getArtifactSuffix(version);
+    
+    // Different artifact names for different platforms
+    const windowsArtifact = `imex-partner-${suffix}x64.exe`;
+    const macArtifact = `imex-partner-${suffix}x64.dmg`;
+    const linuxArtifact = `imex-partner-${suffix}x64.AppImage`;
+    
+    console.log(`Version: ${version}`);
+    console.log(`  Suffix: '${suffix}'`);
+    console.log(`  Windows: ${windowsArtifact}`);
+    console.log(`  Mac: ${macArtifact}`);
+    console.log(`  Linux: ${linuxArtifact}`);
+    console.log('');
+});
+
+console.log('Current configuration will produce:');
+const currentSuffix = getArtifactSuffix(currentVersion);
+console.log(`  Windows: imex-partner-${currentSuffix}x64.exe`);
+console.log(`  Mac: imex-partner-${currentSuffix}x64.dmg`);
+console.log(`  Linux: imex-partner-${currentSuffix}x64.AppImage`);
+
+console.log('');
+console.log(`Platform detected: ${process.platform}`);
+console.log(`Architecture: ${process.arch}`);

deploy/test-artifact-naming.ps1

@@ -0,0 +1,48 @@
+# Test script to demonstrate artifact naming for different versions
+Write-Host "=== Artifact Naming Test ==="
+Write-Host ""
+
+# Test current version
+$packageJsonPath = ".\package.json"
+$packageJson = Get-Content $packageJsonPath | ConvertFrom-Json
+$currentVersion = $packageJson.version
+
+Write-Host "Current version: $currentVersion"
+
+# Function to get artifact suffix
+function Get-ArtifactSuffix($version) {
+    if ($version -match "alpha") {
+        return "alpha-${version}-"
+    } elseif ($version -match "beta") {
+        return "beta-${version}-"
+    } else {
+        return ""
+    }
+}
+
+# Test scenarios
+$testVersions = @(
+    "1.0.5",               # Release version
+    "1.0.5-alpha.2",       # Alpha version
+    "1.0.5-beta.1",        # Beta version
+    "2.0.0-alpha.1",       # Another alpha
+    "1.5.0-beta.3"         # Another beta
+)
+
+Write-Host "Test scenarios:"
+Write-Host "=================="
+
+foreach ($version in $testVersions) {
+    $suffix = Get-ArtifactSuffix $version
+    $artifactName = "imex-partner-${suffix}x64.exe"
+    
+    Write-Host "Version: $version"
+    Write-Host "  Suffix: '$suffix'"
+    Write-Host "  Result: $artifactName"
+    Write-Host ""
+}
+
+Write-Host "Current configuration will produce:"
+$currentSuffix = Get-ArtifactSuffix $currentVersion
+$currentArtifact = "imex-partner-${currentSuffix}x64.exe"
+Write-Host "  $currentArtifact"

deploy/test-artifact-naming.sh

@@ -0,0 +1,50 @@
+#!/bin/bash
+# Test script to demonstrate artifact naming for different versions on Mac
+
+echo "=== Artifact Naming Test (Mac) ==="
+echo ""
+
+# Get current version
+PACKAGE_JSON_PATH="./package.json"
+CURRENT_VERSION=$(node -p "require('$PACKAGE_JSON_PATH').version")
+
+echo "Current version: $CURRENT_VERSION"
+
+# Function to get artifact suffix
+get_artifact_suffix() {
+    local version=$1
+    if [[ $version == *"alpha"* ]]; then
+        echo "alpha-${version}-"
+    elif [[ $version == *"beta"* ]]; then
+        echo "beta-${version}-"
+    else
+        echo ""
+    fi
+}
+
+# Test scenarios
+TEST_VERSIONS=(
+    "1.0.5"               # Release version
+    "1.0.5-alpha.2"       # Alpha version
+    "1.0.5-beta.1"        # Beta version
+    "2.0.0-alpha.1"       # Another alpha
+    "1.5.0-beta.3"        # Another beta
+)
+
+echo "Test scenarios:"
+echo "=================="
+
+for version in "${TEST_VERSIONS[@]}"; do
+    suffix=$(get_artifact_suffix "$version")
+    artifact_name="imex-partner-${suffix}x64.dmg"
+    
+    echo "Version: $version"
+    echo "  Suffix: '$suffix'"
+    echo "  Result: $artifact_name"
+    echo ""
+done
+
+echo "Current configuration will produce:"
+current_suffix=$(get_artifact_suffix "$CURRENT_VERSION")
+current_artifact="imex-partner-${current_suffix}x64.dmg"
+echo "  $current_artifact"

electron-builder.imex.yml

@@ -22,8 +22,9 @@ win:
     endpoint: https://eus.codesigning.azure.net
     certificateProfileName: ImEXRPS
     codeSigningAccountName: ImEX
+    publisherName: ImEX Systems Inc.
 nsis:
-  artifactName: imex-partner-${arch}.${ext}
+  artifactName: imex-partner-${env.ARTIFACT_SUFFIX}${arch}.${ext}
   shortcutName: ${productName}
   uninstallDisplayName: ${productName}
   createDesktopShortcut: always
@@ -49,17 +50,9 @@ mac:
       arch:
         - x64
 dmg:
-  artifactName: imex-partner-${arch}.${ext}
+  artifactName: imex-partner-${env.ARTIFACT_SUFFIX}${arch}.${ext}
-linux:
-  target:
-    - AppImage
-    - snap
-    - deb
-  maintainer: electronjs.org
-  category: Utility
-  desktop: scripts/imex-shop-partner.desktop
 appImage:
-  artifactName: imex-partner-${arch}.${ext}
+  artifactName: imex-partner-${env.ARTIFACT_SUFFIX}${arch}.${ext}
 npmRebuild: false
 publish:
   provider: s3

electron-builder.rome.yml

@@ -22,8 +22,9 @@ win:
     endpoint: https://eus.codesigning.azure.net
     certificateProfileName: ImEXRPS
     codeSigningAccountName: ImEX
+    publisherName: ImEX Systems Inc.
 nsis:
-  artifactName: rome-partner-${arch}.${ext}
+  artifactName: rome-partner-${env.ARTIFACT_SUFFIX}${arch}.${ext}
   shortcutName: ${productName}
   uninstallDisplayName: ${productName}
   createDesktopShortcut: always
@@ -50,17 +51,9 @@ mac:
       arch:
         - x64
 dmg:
-  artifactName: rome-partner-${arch}.${ext}
+  artifactName: rome-partner-${env.ARTIFACT_SUFFIX}${arch}.${ext}
-linux:
-  target:
-    - AppImage
-    - snap
-    - deb
-  maintainer: electronjs.org
-  category: Utility
-  desktop: scripts/rome-shop-partner.desktop
 appImage:
-  artifactName: rome-partner-${arch}.${ext}
+  artifactName: rome-partner-${env.ARTIFACT_SUFFIX}${arch}.${ext}
 npmRebuild: false
 publish:
   provider: s3

electron.vite.config.ts

@@ -6,10 +6,18 @@ import react from "@vitejs/plugin-react";
 export default defineConfig({
   main: {
     plugins: [
-      externalizeDepsPlugin(),
+      externalizeDepsPlugin({
+        exclude: ["electron-store"],
+      }),
       sentryVitePlugin({
         org: "imex",
         project: "imex-partner",
+        sourcemaps: {
+          filesToDeleteAfterUpload: ["**.js.map"],
+        },
+        release: {
+          name: `bodyshop-desktop@${process.env.npm_package_version}`,
+        },
       }),
     ],
     build: {
@@ -32,6 +40,12 @@ export default defineConfig({
       sentryVitePlugin({
         org: "imex",
         project: "imex-partner",
+        sourcemaps: {
+          filesToDeleteAfterUpload: ["**.js.map"],
+        },
+        release: {
+          name: `bodyshop-desktop@${process.env.npm_package_version}`,
+        },
       }),
     ],
     build: {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "bodyshop-desktop",
-  "version": "1.0.4",
+  "version": "1.0.7",
   "description": "Shop Management System Partner",
   "main": "./out/main/index.js",
   "author": "Convenient Brands, LLC",
@@ -13,79 +13,79 @@
     "typecheck": "npm run typecheck:node && npm run typecheck:web",
     "start": "electron-vite preview",
     "dev": "electron-vite dev",
-    "build:imex": "electron-vite build --mode imex && electron-builder --config electron-builder.imex.yml",
+    "build:imex": "node deploy/set-artifact-name.js electron-vite build --mode imex && node deploy/set-artifact-name.js electron-builder --config electron-builder.imex.yml",
-    "build:rome": "electron-vite build --mode rome && electron-builder --config electron-builder.rome.yml",
+    "build:rome": "node deploy/set-artifact-name.js electron-vite build --mode rome && node deploy/set-artifact-name.js electron-builder --config electron-builder.rome.yml",
-    "build:imex:publish": "electron-vite build --mode imex && electron-builder --config electron-builder.imex.yml --publish always",
+    "build:imex:publish": "node deploy/set-artifact-name.js electron-vite build --mode imex && node deploy/set-artifact-name.js electron-builder --config electron-builder.imex.yml --publish always",
-    "build:rome:publish": "electron-vite build --mode rome && electron-builder --config electron-builder.rome.yml --publish always",
+    "build:rome:publish": "node deploy/set-artifact-name.js electron-vite build --mode rome && node deploy/set-artifact-name.js electron-builder --config electron-builder.rome.yml --publish always",
-    "build:imex:linux": "electron-vite build --mode imex && electron-builder --config electron-builder.imex.yml --linux",
+    "build:imex:linux": "node deploy/set-artifact-name.js electron-vite build --mode imex && node deploy/set-artifact-name.js electron-builder --config electron-builder.imex.yml --linux",
-    "build:rome:linux": "electron-vite build --mode rome && electron-builder --config electron-builder.rome.yml --linux",
+    "build:rome:linux": "node deploy/set-artifact-name.js electron-vite build --mode rome && node deploy/set-artifact-name.js electron-builder --config electron-builder.rome.yml --linux",
     "postinstall": "electron-builder install-app-deps",
-    "build:unpack": "electron-vite build --mode imex && electron-builder --dir",
+    "build:unpack": "node deploy/set-artifact-name.js electron-vite build --mode imex && node deploy/set-artifact-name.js electron-builder --dir",
-    "build:win": "electron-vite build --mode imex && electron-builder --win",
+    "build:win": "node deploy/set-artifact-name.js electron-vite build --mode imex && node deploy/set-artifact-name.js electron-builder --win",
-    "build:mac": "electron-vite build --mode imex && electron-builder --mac",
+    "build:mac": "node deploy/set-artifact-name.js electron-vite build --mode imex && node deploy/set-artifact-name.js electron-builder --mac",
-    "build:linux": "electron-vite build --mode imex && electron-builder --linux"
+    "build:linux": "node deploy/set-artifact-name.js electron-vite build --mode imex && node deploy/set-artifact-name.js electron-builder --linux"
   },
   "dependencies": {
     "@apollo/client": "^3.13.6",
-    "@electron-toolkit/preload": "^3.0.1",
+    "@electron-toolkit/preload": "^3.0.2",
     "@electron-toolkit/utils": "^4.0.0",
-    "@sentry/electron": "^6.5.0",
+    "@sentry/electron": "^7.2.0",
-    "@sentry/vite-plugin": "^3.3.1",
+    "@sentry/vite-plugin": "^4.5.0",
-    "axios": "^1.9.0",
+    "axios": "^1.12.2",
-    "dayjs": "^1.11.13",
+    "dayjs": "^1.11.18",
-    "electron-log": "^5.3.3",
+    "electron-log": "^5.4.3",
-    "electron-store": "^8.2.0",
     "electron-updater": "^6.6.2",
     "winax": "^3.6.2"
   },
   "devDependencies": {
     "@ant-design/v5-patch-for-react-19": "^1.0.3",
     "@electron-toolkit/eslint-config-prettier": "^3.0.0",
-    "@electron-toolkit/eslint-config-ts": "^3.0.0",
+    "@electron-toolkit/eslint-config-ts": "^3.1.0",
-    "@electron-toolkit/tsconfig": "^1.0.1",
+    "@electron-toolkit/tsconfig": "^2.0.0",
-    "@playwright/test": "^1.51.1",
+    "@playwright/test": "^1.56.1",
-    "@reduxjs/toolkit": "^2.6.1",
+    "@reduxjs/toolkit": "^2.9.1",
-    "@types/cors": "^2.8.17",
+    "@types/cors": "^2.8.19",
-    "@types/express": "^5.0.1",
+    "@types/express": "^5.0.3",
-    "@types/lodash": "^4.17.16",
+    "@types/lodash": "^4.17.20",
-    "@types/node": "^22.14.0",
+    "@types/node": "^24.9.1",
     "@types/node-cron": "^3.0.11",
-    "@types/react": "^19.1.0",
+    "@types/react": "^19.2.2",
-    "@types/react-dom": "^19.1.2",
+    "@types/react-dom": "^19.2.2",
     "@types/xml2js": "^0.4.14",
-    "@vitejs/plugin-react": "^4.3.4",
+    "@vitejs/plugin-react": "^5.0.4",
-    "antd": "^5.24.6",
+    "antd": "^5.27.6",
     "archiver": "^7.0.1",
     "chokidar": "^4.0.3",
     "cors": "^2.8.5",
+    "cross-env": "^10.1.0",
     "dbffile": "^1.12.0",
-    "electron": "^35.1.5",
+    "electron": "^38.3.0",
-    "electron-builder": "^25.1.8",
+    "electron-builder": "^26.0.12",
-    "electron-store": "^8.2.0",
+    "electron-store": "^11.0.2",
-    "electron-vite": "^3.1.0",
+    "electron-vite": "^4.0.1",
-    "eslint": "^9.24.0",
+    "eslint": "^9.38.0",
     "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-hooks": "^7.0.0",
-    "eslint-plugin-react-refresh": "^0.4.19",
+    "eslint-plugin-react-refresh": "^0.4.24",
     "express": "^5.1.0",
-    "firebase": "^11.6.0",
+    "firebase": "^12.4.0",
-    "graphql": "^16.10.0",
+    "graphql": "^16.11.0",
-    "graphql-request": "^7.1.2",
+    "graphql-request": "^7.3.1",
-    "i18next": "^24.2.3",
+    "i18next": "^25.6.0",
     "lodash": "^4.17.21",
-    "node-cron": "^3.0.3",
+    "node-cron": "^4.2.1",
-    "playwright": "^1.51.1",
+    "playwright": "^1.56.1",
-    "prettier": "^3.5.3",
+    "prettier": "^3.6.2",
-    "react": "^19.1.0",
+    "react": "^19.2.0",
-    "react-dom": "^19.1.0",
+    "react-dom": "^19.2.0",
-    "react-error-boundary": "^5.0.0",
+    "react-error-boundary": "^6.0.0",
-    "react-i18next": "^15.4.1",
+    "react-i18next": "^16.1.4",
     "react-redux": "^9.2.0",
-    "react-router": "^7.5.0",
+    "react-router": "^7.9.4",
     "redux-logger": "^3.0.6",
-    "typescript": "^5.8.3",
+    "typescript": "^5.9.3",
-    "vite": "6.2.6",
+    "vite": "7.1.11",
     "xml2js": "^0.6.2",
-    "xmlbuilder2": "^3.1.1"
+    "xmlbuilder2": "^4.0.0"
   }
 }

src/main/decoder/decode-ad1.ts

@@ -182,7 +182,9 @@ const DecodeAD1 = async (
   if (!rawAd1Data.ownr_ph1 || _.isEmpty(rawAd1Data.ownr_ph1)) {
     rawAd1Data.ownr_ph1 = rawAd1Data.ownr_ph2;
   }
-
+  if (rawAd1Data.clm_no === "") {
+    rawAd1Data.clm_no = undefined;
+  }
   let ownerRecord: OwnerRecordInterface;
   //Check if the owner information is there. If not, use the insured information as a fallback.
   if (

src/main/decoder/decoder.ts

@@ -157,6 +157,7 @@ async function ImportJob(filepath: string): Promise<void> {
     console.log("Available Job record to upload;", newAvailableJob);
 
     setAppProgressbar(0.95);
+    if (jobObject.clm_no) {
       const existingJobRecord: QueryJobByClmNoResult = await client.request(
         QUERY_JOB_BY_CLM_NO_TYPED,
         { clm_no: jobObject.clm_no },
@@ -166,6 +167,7 @@ async function ImportJob(filepath: string): Promise<void> {
         newAvailableJob.issupplement = true;
         newAvailableJob.jobid = existingJobRecord.jobs[0].id;
       }
+    }
 
     const insertRecordResult: InsertAvailableJobResult = await client.request(
       INSERT_AVAILABLE_JOB_TYPED,

src/main/graphql/graphql-client.ts

@@ -4,6 +4,7 @@ import { GraphQLClient, RequestMiddleware } from "graphql-request";
 import errorTypeCheck from "../../util/errorTypeCheck.js";
 import ipcTypes from "../../util/ipcTypes.json";
 import store from "../store/store.js";
+import getMainWindow from "../../util/getMainWindow.js";
 
 const requestMiddleware: RequestMiddleware = async (request) => {
   const token = await getTokenFromRenderer();
@@ -32,9 +33,9 @@ const client: GraphQLClient = new GraphQLClient(
 export async function getTokenFromRenderer(): Promise<string> {
   return new Promise((resolve) => {
     try {
-      const mainWindow = BrowserWindow.getAllWindows()[0]; //TODO: Filter to only main window once a proper key has been set.
+      const mainWindow = getMainWindow();
       //TODO: Verify that this will work if the app is minimized/closed.
-      mainWindow.webContents.send(ipcTypes.toRenderer.user.getToken);
+      mainWindow?.webContents.send(ipcTypes.toRenderer.user.getToken);
     } catch (error) {
       log.error(
         "Unable to send request to renderer process for token",

src/main/index.ts

@@ -36,6 +36,7 @@ import {
   setupKeepAliveTask,
 } from "./setup-keep-alive-task";
 import ensureWindowOnScreen from "./util/ensureWindowOnScreen";
+import ongoingMemoryDump, { dumpMemoryStatsToFile } from "../util/memUsage";
 
 const appIconToUse =
   import.meta.env.VITE_COMPANY === "IMEX" ? imexAppIcon : romeAppIcon;
@@ -45,6 +46,13 @@ Sentry.init({
 });
 
 log.initialize();
+
+// Configure log format to include process ID
+log.transports.file.format =
+  "[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] [PID:{processId}] {text}";
+log.transports.console.format =
+  "[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] [PID:{processId}] {text}";
+log.transports.file.maxSize = 50 * 1024 * 1024; // 50 MB
 const isMac: boolean = process.platform === "darwin";
 const protocol: string = "imexmedia";
 let isAppQuitting = false; //Needed on Mac as an override to allow us to fully quit the app.
@@ -53,6 +61,14 @@ let isKeepAliveLaunch = false; // Track if launched via keep-alive
 const localServer = new LocalServer();
 const gotTheLock = app.requestSingleInstanceLock();
 
+if (!gotTheLock) {
+  log.warn(
+    "Another instance is already running and could not obtain mutex lock. Exiting this instance.",
+  );
+  isAppQuitting = true;
+  app.quit(); // Quit the app if another instance is already running
+}
+
 function createWindow(): void {
   // Create the browser window.
   const { width, height, x, y } = store.get("app.windowBounds") as {
@@ -252,6 +268,27 @@ function createWindow(): void {
             {
               type: "separator",
             },
+            {
+              label: "Enable Memory Logging",
+              checked: store.get("settings.enableMemDebug") as boolean,
+              type: "checkbox",
+              click: (): void => {
+                const currentSetting = store.get(
+                  "settings.enableMemDebug",
+                ) as boolean;
+                store.set("settings.enableMemDebug", !currentSetting);
+                log.info("Enable Memory Logging set to", !currentSetting);
+              },
+            },
+            {
+              label: "Dump Memory Stats Now",
+              click: (): void => {
+                dumpMemoryStatsToFile();
+              },
+            },
+            {
+              type: "separator",
+            },
             // {
             //   label: "Decode Hardcoded Estimate",
             //   click: (): void => {
@@ -429,9 +466,6 @@ function createWindow(): void {
   }
 }
 
-if (!gotTheLock) {
-  app.quit(); // Quit the app if another instance is already running
-}
 // This method will be called when Electron has finished
 // initialization and is ready to create browser windows.
 // Some APIs can only be used after this event occurs.
@@ -439,6 +473,8 @@ app.whenReady().then(async () => {
   // Default open or close DevTools by F12 in development
   // and ignore CommandOrControl + R in production.
   // see https://github.com/alex8088/electron-toolkit/tree/master/packages/utils
+  log.debug("App is ready, initializing shortcuts and protocol handlers.");
+
   if (platform.isWindows) {
     app.setAppUserModelId("Shop Partner");
   }
@@ -470,21 +506,6 @@ app.whenReady().then(async () => {
     log.warn("Failed to register protocol handler.");
   }
 
-  // Add this event handler for second instance
-  app.on("second-instance", (_event: Electron.Event, argv: string[]) => {
-    const url = argv.find((arg) => arg.startsWith(`${protocol}://`));
-    if (url) {
-      if (url.startsWith(`${protocol}://keep-alive`)) {
-        log.info("Keep-alive protocol received, app is already running.");
-        // Do nothing if already running
-        return;
-      } else {
-        openInExplorer(url);
-      }
-    }
-    // No action taken if no URL is provided
-  });
-
   //Dynamically load ipcMain handlers once ready.
   try {
     const { initializeCronTasks } = await import("./ipc/ipcMainConfig");
@@ -531,7 +552,7 @@ app.whenReady().then(async () => {
 
   //Check for app updates.
   autoUpdater.logger = log;
-
+  autoUpdater.allowDowngrade = true;
   // if (import.meta.env.DEV) {
   //   // Useful for some dev/debugging tasks, but download can
   //   // not be validated because dev app is not signed
@@ -546,19 +567,19 @@ app.whenReady().then(async () => {
 
   autoUpdater.on("checking-for-update", () => {
     log.info("Checking for update...");
-    const mainWindow = BrowserWindow.getAllWindows()[0];
+    const mainWindow = getMainWindow();
     mainWindow?.webContents.send(ipcTypes.toRenderer.updates.checking);
   });
   autoUpdater.on("update-available", (info) => {
     log.info("Update available.", info);
-    const mainWindow = BrowserWindow.getAllWindows()[0];
+    const mainWindow = getMainWindow();
     mainWindow?.webContents.send(ipcTypes.toRenderer.updates.available, info);
   });
   autoUpdater.on("download-progress", (progress) => {
     log.info(`Download speed: ${progress.bytesPerSecond}`);
     log.info(`Downloaded ${progress.percent}%`);
     log.info(`Total downloaded ${progress.transferred}/${progress.total}`);
-    const mainWindow = BrowserWindow.getAllWindows()[0];
+    const mainWindow = getMainWindow();
     mainWindow?.webContents.send(
       ipcTypes.toRenderer.updates.downloading,
       progress,
@@ -566,7 +587,7 @@ app.whenReady().then(async () => {
   });
   autoUpdater.on("update-downloaded", (info) => {
     log.info("Update downloaded", info);
-    const mainWindow = BrowserWindow.getAllWindows()[0];
+    const mainWindow = getMainWindow();
     mainWindow?.webContents.send(ipcTypes.toRenderer.updates.downloaded, info);
   });
 
@@ -577,7 +598,8 @@ app.whenReady().then(async () => {
   }
 
   //The update itself will run when the bodyshop record is queried to know what release channel to use.
-  createWindow();
+  openMainWindow();
+  ongoingMemoryDump();
 
   app.on("activate", function () {
     openMainWindow();
@@ -595,6 +617,24 @@ app.on("open-url", (event: Electron.Event, url: string) => {
   }
 });
 
+// Add this event handler for second instance
+app.on("second-instance", (_event: Electron.Event, argv: string[]) => {
+  const url = argv.find((arg) => arg.startsWith(`${protocol}://`));
+  if (url) {
+    if (url.startsWith(`${protocol}://keep-alive`)) {
+      log.info(
+        "Keep-alive protocol received, app is already running. Nothing to do.",
+      );
+      // Do nothing if already running
+      return;
+    } else {
+      log.info("Received Media URL: ", url);
+      openInExplorer(url);
+    }
+  }
+  // No action taken if no URL is provided
+});
+
 // Quit when all windows are closed, except on macOS. There, it's common
 // for applications and their menu bar to stay active until the user quits
 // explicitly with Cmd + Q.
@@ -604,8 +644,7 @@ app.on("window-all-closed", () => {
   }
 });
 
-app.on("before-quit", (props) => {
+app.on("before-quit", () => {
-  console.log(props);
   preQuitMethods();
 });
 
@@ -635,7 +674,7 @@ function preQuitMethods(): void {
 }
 
 function openMainWindow(): void {
-  const mainWindow = BrowserWindow.getAllWindows()[0];
+  const mainWindow = getMainWindow();
   if (mainWindow) {
     mainWindow.show();
   } else {

src/main/ipc/ipcMainHandler.user.ts

@@ -20,10 +20,15 @@ const ipcMainHandleAuthStateChanged = async (
   user: User | null,
 ): Promise<void> => {
   Store.set("user", user);
+  log.debug("Received authentication state change from Renderer.", user);
+  await setReleaseChannel();
+  checkForAppUpdatesContinuously();
+};
+
+async function setReleaseChannel() {
   try {
     //Need to query the currently active shop, and store the metadata as well.
     //Also need to query the OP Codes for decoding reference.
-    log.debug("Received authentication state change from Renderer.", user);
     await handleShopMetaDataFetch();
     //Check for updates
     const bodyshop = Store.get("app.bodyshop");
@@ -33,6 +38,8 @@ const ipcMainHandleAuthStateChanged = async (
     } else if (bodyshop?.convenient_company?.toLowerCase() === "beta") {
       autoUpdater.channel = "beta";
       log.debug("Setting update channel to BETA channel.");
+    } else {
+      log.debug("Setting update channel to LATEST channel.");
     }
   } catch (error) {
     log.error(
@@ -44,8 +51,7 @@ const ipcMainHandleAuthStateChanged = async (
       "Error connecting to ImEX Online servers to get shop data. Please try again.",
     );
   }
-  checkForAppUpdatesContinuously();
+}
-};
 
 const handleShopMetaDataFetch = async (
   reloadWindow?: boolean,
@@ -89,7 +95,8 @@ const ipMainHandleResetPassword = async (): Promise<void> => {
 };
 
 export {
+  handleShopMetaDataFetch,
   ipcMainHandleAuthStateChanged,
   ipMainHandleResetPassword,
-  handleShopMetaDataFetch,
+  setReleaseChannel,
 };

src/main/ppc/ppc-handler.ts

@@ -14,7 +14,7 @@ const handlePartsPriceChangeRequest = async (
 ): Promise<void> => {
   //Route handler here only.
 
-  const { job } = req.body as { job: PpcJob };
+  const job = req.body as PpcJob;
   try {
     await generatePartsPriceChange(job);
     res.status(200).json({ success: true });

src/main/store/store.ts

@@ -9,6 +9,7 @@ const store = new Store({
       emsOutFilePath: null,
       qbFilePath: "",
       runWatcherOnStartup: true,
+      enableMemDebug: false,
       polling: {
         enabled: false,
         interval: 30000,

src/main/util/checkForAppUpdates.ts

@@ -1,19 +1,23 @@
 import { autoUpdater } from "electron-updater";
+import { setReleaseChannel } from "../ipc/ipcMainHandler.user";
 
-function checkForAppUpdatesContinuously(): void {
+let continuousUpdatesTriggered = false;
+
+async function checkForAppUpdatesContinuously(): Promise<void> {
+  if (!continuousUpdatesTriggered) {
+    continuousUpdatesTriggered = true;
     checkForAppUpdates();
     setInterval(
       () => {
-      checkForAppUpdatesContinuously();
+        checkForAppUpdates();
       },
       1000 * 60 * 30,
     );
   }
-function checkForAppUpdates(): void {
+}
-  autoUpdater.checkForUpdatesAndNotify({
+async function checkForAppUpdates(): Promise<void> {
-    title: "Shop Partner Update",
+  await setReleaseChannel();
-    body: "A new version of Shop Partner is available. Click to update.",
+  autoUpdater.checkForUpdates();
-  });
 }
 
-export { checkForAppUpdatesContinuously, checkForAppUpdates };
+export { checkForAppUpdates, checkForAppUpdatesContinuously };

src/main/watcher/watcher.ts

@@ -7,6 +7,7 @@ import errorTypeCheck from "../../util/errorTypeCheck";
 import ipcTypes from "../../util/ipcTypes.json";
 import ImportJob from "../decoder/decoder";
 import store from "../store/store";
+import getMainWindow from "../../util/getMainWindow";
 let watcher: FSWatcher | null;
 
 async function StartWatcher(): Promise<boolean> {
@@ -107,23 +108,23 @@ function addWatcherPath(path: string | string[]): void {
 
 function onWatcherReady(): void {
   if (watcher) {
-    const mainWindow = BrowserWindow.getAllWindows()[0]; //TODO: Filter to only main window once a proper key has been set.
+    const mainWindow = getMainWindow();
     new Notification({
       title: "Watcher Started",
       body: "Newly exported estimates will be automatically uploaded.",
     }).show();
     log.info("Confirmed watched paths:", watcher.getWatched());
-    mainWindow.webContents.send(ipcTypes.toRenderer.watcher.started);
+    mainWindow?.webContents.send(ipcTypes.toRenderer.watcher.started);
   }
 }
 
 async function StopWatcher(): Promise<boolean> {
-  const mainWindow = BrowserWindow.getAllWindows()[0]; //TODO: Filter to only main window once a proper key has been set.
+  const mainWindow = getMainWindow();
 
   if (watcher) {
     await watcher.close();
     log.info("Watcher stopped.");
-    mainWindow.webContents.send(ipcTypes.toRenderer.watcher.stopped);
+    mainWindow?.webContents.send(ipcTypes.toRenderer.watcher.stopped);
 
     new Notification({
       title: "Watcher Stopped",

src/renderer/src/components/Settings/PaintScale/usePaintScaleConfig.ts

@@ -1,25 +1,33 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect } from "react";
-import ipcTypes from '../../../../../util/ipcTypes.json';
+import ipcTypes from "../../../../../util/ipcTypes.json";
-import { PaintScaleConfig, PaintScaleType } from '../../../../../util/types/paintScale';
+import {
+  PaintScaleConfig,
+  PaintScaleType,
+} from "../../../../../util/types/paintScale";
 import { message } from "antd";
 import { useTranslation } from "react-i18next";
 
-type ConfigType = 'input' | 'output';
+type ConfigType = "input" | "output";
 
 export const usePaintScaleConfig = (configType: ConfigType) => {
-  const [paintScaleConfigs, setPaintScaleConfigs] = useState<PaintScaleConfig[]>([]);
+  const [paintScaleConfigs, setPaintScaleConfigs] = useState<
+    PaintScaleConfig[]
+  >([]);
   const { t } = useTranslation();
 
   // Get the appropriate IPC methods based on config type
-  const getConfigsMethod = configType === 'input'
+  const getConfigsMethod =
+    configType === "input"
       ? ipcTypes.toMain.settings.paintScale.getInputConfigs
       : ipcTypes.toMain.settings.paintScale.getOutputConfigs;
 
-  const setConfigsMethod = configType === 'input'
+  const setConfigsMethod =
+    configType === "input"
       ? ipcTypes.toMain.settings.paintScale.setInputConfigs
       : ipcTypes.toMain.settings.paintScale.setOutputConfigs;
 
-  const setPathMethod = configType === 'input'
+  const setPathMethod =
+    configType === "input"
       ? ipcTypes.toMain.settings.paintScale.setInputPath
       : ipcTypes.toMain.settings.paintScale.setOutputPath;
 
@@ -29,15 +37,19 @@ export const usePaintScaleConfig = (configType: ConfigType) => {
       .invoke(getConfigsMethod)
       .then((configs: PaintScaleConfig[]) => {
         // Ensure all configs have a pollingInterval and type (for backward compatibility)
-          const updatedConfigs = configs.map(config => ({
+        const defaultPolling = configType === "input" ? 1440 : 60;
+        const updatedConfigs = configs.map((config) => ({
           ...config,
-            pollingInterval: config.pollingInterval || 1440, // Default to 1440 seconds
+          pollingInterval: config.pollingInterval || defaultPolling, // Default to 1440 for input, 60 for output
           type: config.type || PaintScaleType.PPG, // Default type if missing
         }));
         setPaintScaleConfigs(updatedConfigs || []);
       })
       .catch((error) => {
-          console.error(`Failed to load paint scale ${configType} configs:`, error);
+        console.error(
+          `Failed to load paint scale ${configType} configs:`,
+          error,
+        );
       });
   }, [getConfigsMethod]);
 
@@ -47,25 +59,40 @@ export const usePaintScaleConfig = (configType: ConfigType) => {
       .invoke(setConfigsMethod, configs)
       .then(() => {
         // Notify main process to update cron job
-          if (configType === 'input') {
+        if (configType === "input") {
-            window.electron.ipcRenderer.send(ipcTypes.toMain.settings.paintScale.updateInputCron, configs);
+          window.electron.ipcRenderer.send(
-          } else if (configType === 'output') {
+            ipcTypes.toMain.settings.paintScale.updateInputCron,
-            window.electron.ipcRenderer.send(ipcTypes.toMain.settings.paintScale.updateOutputCron, configs);
+            configs,
+          );
+        } else if (configType === "output") {
+          window.electron.ipcRenderer.send(
+            ipcTypes.toMain.settings.paintScale.updateOutputCron,
+            configs,
+          );
         }
       })
       .catch((error) => {
-          console.error(`Failed to save paint scale ${configType} configs:`, error);
+        console.error(
+          `Failed to save paint scale ${configType} configs:`,
+          error,
+        );
       });
   };
 
   // New helper to check if a path is unique across input and output configs
   const checkPathUnique = async (newPath: string): Promise<boolean> => {
     try {
-      const inputConfigs: PaintScaleConfig[] = await window.electron.ipcRenderer.invoke(ipcTypes.toMain.settings.paintScale.getInputConfigs);
+      const inputConfigs: PaintScaleConfig[] =
-      const outputConfigs: PaintScaleConfig[] = await window.electron.ipcRenderer.invoke(ipcTypes.toMain.settings.paintScale.getOutputConfigs);
+        await window.electron.ipcRenderer.invoke(
+          ipcTypes.toMain.settings.paintScale.getInputConfigs,
+        );
+      const outputConfigs: PaintScaleConfig[] =
+        await window.electron.ipcRenderer.invoke(
+          ipcTypes.toMain.settings.paintScale.getOutputConfigs,
+        );
       const allConfigs = [...inputConfigs, ...outputConfigs];
       // Allow updating the current config even if its current value equals newPath.
-      return !allConfigs.some(config => config.path === newPath);
+      return !allConfigs.some((config) => config.path === newPath);
     } catch (error) {
       console.error("Failed to check unique path:", error);
       return false;
@@ -74,10 +101,11 @@ export const usePaintScaleConfig = (configType: ConfigType) => {
 
   // Handle adding a new paint scale config
   const handleAddConfig = (type: PaintScaleType) => {
+    const defaultPolling = configType === "input" ? 1440 : 60;
     const newConfig: PaintScaleConfig = {
       id: Date.now().toString(),
       type,
-      pollingInterval: 1440, // Default to 1440 seconds
+      pollingInterval: defaultPolling, // Default to 1440 for input, 60 for output
     };
     const updatedConfigs = [...paintScaleConfigs, newConfig];
     setPaintScaleConfigs(updatedConfigs);
@@ -86,7 +114,9 @@ export const usePaintScaleConfig = (configType: ConfigType) => {
 
   // Handle removing a config
   const handleRemoveConfig = (id: string) => {
-    const updatedConfigs = paintScaleConfigs.filter((config) => config.id !== id);
+    const updatedConfigs = paintScaleConfigs.filter(
+      (config) => config.id !== id,
+    );
     setPaintScaleConfigs(updatedConfigs);
     saveConfigs(updatedConfigs);
   };
@@ -94,7 +124,10 @@ export const usePaintScaleConfig = (configType: ConfigType) => {
   // Handle path selection (modified to check directory uniqueness)
   const handlePathChange = async (id: string) => {
     try {
-      const path: string | null = await window.electron.ipcRenderer.invoke(setPathMethod, id);
+      const path: string | null = await window.electron.ipcRenderer.invoke(
+        setPathMethod,
+        id,
+      );
       if (path) {
         const isUnique = await checkPathUnique(path);
         if (!isUnique) {

src/renderer/src/components/Settings/Settings.PaintScaleInputPaths.tsx

@@ -35,7 +35,7 @@ const SettingsPaintScaleInputPaths = (): JSX.Element => {
     handleRemoveConfig,
     handlePathChange,
     handlePollingIntervalChange,
-  } = usePaintScaleConfig("input");
+  } = usePaintScaleConfig("output");
 
   const [isModalVisible, setIsModalVisible] = useState(false);
   const [selectedType, setSelectedType] = useState<PaintScaleType | null>(null);

src/renderer/src/components/Settings/Settings.PaintScaleOutputPaths.tsx

@@ -33,7 +33,7 @@ const SettingsPaintScaleOutputPaths = (): JSX.Element => {
     handleRemoveConfig,
     handlePathChange,
     handlePollingIntervalChange,
-  } = usePaintScaleConfig("output");
+  } = usePaintScaleConfig("input");
 
   const [isModalVisible, setIsModalVisible] = useState(false);
   const [selectedType, setSelectedType] = useState<PaintScaleType | null>(null);

src/util/getMainWindow.ts

@@ -0,0 +1,5 @@
+import { BrowserWindow } from "electron";
+
+export default function getMainWindow(): BrowserWindow | null {
+  return BrowserWindow.getAllWindows()[0] || null;
+}

src/util/memUsage.ts

@@ -0,0 +1,309 @@
+import { BrowserWindow } from "electron";
+import log from "electron-log/main";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import Store from "../main/store/store";
+/**
+ * Human-readable memory/cpu/resource snapshot.
+ */
+export type MemoryUsageStats = {
+  timestamp: string;
+  label?: string;
+  uptimeSeconds: number;
+  pid: number;
+  memory: {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers?: number;
+  };
+  memoryPretty: {
+    rss: string;
+    heapTotal: string;
+    heapUsed: string;
+    external: string;
+    arrayBuffers?: string;
+  };
+  os: {
+    totalMem: number;
+    freeMem: number;
+    freeMemPercent: number;
+  };
+  cpuUsage?: NodeJS.CpuUsage;
+  resourceUsage?: NodeJS.ResourceUsage;
+  heapSpaces?: Array<import("v8").HeapSpaceInfo>;
+  heapSnapshotFile?: string;
+  custom?: Record<string, unknown>;
+};
+// (merged into top import)
+
+/**
+ * Options for dumpMemoryStats.
+ */
+export type DumpOptions = {
+  /**
+   * Call global.gc() before sampling if available (requires node run with --expose-gc).
+   */
+  runGc?: boolean;
+  /**
+   * Optional label to include in the returned snapshot.
+   */
+  label?: string;
+  includeHeapSpaces?: boolean;
+  writeHeapSnapshot?: boolean;
+  heapSnapshotDir?: string;
+};
+
+/**
+ * Convert bytes to a compact human readable string.
+ */
+function formatBytes(bytes: number): string {
+  if (!isFinite(bytes)) return String(bytes);
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let i = 0;
+  let val = bytes;
+  while (val >= 1024 && i < units.length - 1) {
+    val /= 1024;
+    i++;
+  }
+  return `${val.toFixed(2)} ${units[i]}`;
+}
+
+/**
+ * Asynchronously produce a memory / cpu / os snapshot.
+ *
+ * Example:
+ * const stats = await dumpMemoryStats({ runGc: true, label: 'before-heavy-task' });
+ */
+export async function dumpMemoryStats(
+  options: DumpOptions = {},
+): Promise<MemoryUsageStats> {
+  const {
+    runGc = false,
+    label,
+    includeHeapSpaces = true,
+    writeHeapSnapshot = true,
+    heapSnapshotDir,
+  } = options;
+
+  // Allow GC if requested and available to get a cleaner snapshot
+  if (runGc && typeof (global as any).gc === "function") {
+    try {
+      (global as any).gc();
+    } catch {
+      // ignore GC errors
+    }
+  }
+
+  // Let the event loop settle a tick so GC can complete if run
+  await new Promise((resolve) => setImmediate(resolve));
+
+  const mem = process.memoryUsage();
+  const totalMem = os.totalmem();
+  const freeMem = os.freemem();
+
+  const stats: MemoryUsageStats = {
+    timestamp: new Date().toISOString(),
+    label,
+    uptimeSeconds: Math.floor(process.uptime()),
+    pid: process.pid,
+    memory: {
+      rss: mem.rss,
+      heapTotal: mem.heapTotal,
+      heapUsed: mem.heapUsed,
+      external: mem.external,
+      arrayBuffers: mem.arrayBuffers,
+    },
+    memoryPretty: {
+      rss: formatBytes(mem.rss),
+      heapTotal: formatBytes(mem.heapTotal),
+      heapUsed: formatBytes(mem.heapUsed),
+      external: formatBytes(mem.external),
+      arrayBuffers:
+        mem.arrayBuffers !== undefined
+          ? formatBytes(mem.arrayBuffers)
+          : undefined,
+    },
+    os: {
+      totalMem,
+      freeMem,
+      freeMemPercent: Math.round((freeMem / totalMem) * 10000) / 100,
+    },
+    cpuUsage: process.cpuUsage ? process.cpuUsage() : undefined,
+    resourceUsage:
+      typeof process.resourceUsage === "function"
+        ? process.resourceUsage()
+        : undefined,
+    custom: {
+      numBrowserWindows: BrowserWindow.getAllWindows().length,
+    },
+  };
+
+  if (includeHeapSpaces) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const v8: typeof import("v8") = require("v8");
+      if (typeof v8.getHeapSpaceStatistics === "function") {
+        stats.heapSpaces = v8.getHeapSpaceStatistics();
+      }
+    } catch (err) {
+      log.warn("Failed to get heap space stats", err);
+    }
+  }
+
+  if (writeHeapSnapshot) {
+    try {
+      if (!runGc && typeof (global as any).gc === "function") {
+        try {
+          (global as any).gc();
+        } catch {
+          /* ignore */
+        }
+      }
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const v8: typeof import("v8") = require("v8");
+      if (typeof v8.writeHeapSnapshot === "function") {
+        const baseDir =
+          heapSnapshotDir || path.dirname(log.transports.file.getFile().path);
+
+        const dir = path.join(baseDir, "heap-snapshots");
+        fs.mkdirSync(dir, { recursive: true });
+        const fileName = `heap-${Date.now()}-${process.pid}.heapsnapshot`;
+        const filePath = path.join(dir, fileName);
+        const snapshotPath = v8.writeHeapSnapshot(filePath);
+        stats.heapSnapshotFile = snapshotPath;
+      } else {
+        log.warn("v8.writeHeapSnapshot not available");
+      }
+    } catch (err) {
+      log.warn("Failed to write heap snapshot", err);
+    }
+  }
+
+  return stats;
+}
+
+const memLogger = log.create({ logId: "mem-stat" });
+memLogger.transports.file.resolvePathFn = () => {
+  const filePath = path.join(
+    path.dirname(log.transports.file.getFile().path),
+    "memory-stats.log",
+  );
+  return filePath;
+};
+// Configure memory logger format to include process ID
+memLogger.transports.file.format =
+  "[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] [PID:{processId}] {text}";
+memLogger.transports.console.format =
+  "[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] [PID:{processId}] {text}";
+
+export async function dumpMemoryStatsToFile() {
+  try {
+    const stats = await dumpMemoryStats({ includeHeapSpaces: false });
+    memLogger.debug("[MemStat]:", stats);
+  } catch (error) {
+    log.warn("Unexpected error while writing memory stats log", error);
+  }
+}
+
+function ongoingMemoryDump() {
+  console.log(
+    `Memory logging set to ${Store.get("settings.enableMemDebug")}. Log file at ${memLogger.transports.file.getFile().path}`,
+  );
+
+  setInterval(
+    async () => {
+      // Also write each snapshot to a dedicated memory stats log file as JSON lines.
+      try {
+        const loggingEnabled = Store.get("settings.enableMemDebug");
+        log.debug(
+          "Checking if memory stats logging is enabled.",
+          loggingEnabled,
+        );
+        if (loggingEnabled) {
+          // Enforce heap snapshot folder size limit (< 1GB) before writing a new snapshot.
+          const MAX_DIR_BYTES = 5 * 1024 * 1024 * 1024; // 5GB
+          const TARGET_REDUCED_BYTES = Math.floor(MAX_DIR_BYTES * 0.9); // prune down to 90%
+          const baseDir = path.dirname(log.transports.file.getFile().path);
+          const heapDir = path.join(baseDir, "heap-snapshots");
+          try {
+            fs.mkdirSync(heapDir, { recursive: true });
+            const files = fs
+              .readdirSync(heapDir)
+              .filter((f) => f.endsWith(".heapsnapshot"));
+            let totalSize = 0;
+            const fileStats: Array<{
+              file: string;
+              size: number;
+              mtimeMs: number;
+            }> = [];
+            for (const file of files) {
+              try {
+                const stat = fs.statSync(path.join(heapDir, file));
+                if (stat.isFile()) {
+                  totalSize += stat.size;
+                  fileStats.push({
+                    file,
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                  });
+                }
+              } catch (e) {
+                log.warn("Failed to stat heap snapshot file", file, e);
+              }
+            }
+            if (totalSize > MAX_DIR_BYTES) {
+              // Sort oldest first and delete until below TARGET_REDUCED_BYTES.
+              fileStats.sort((a, b) => a.mtimeMs - b.mtimeMs);
+              let bytesAfter = totalSize;
+              for (const info of fileStats) {
+                if (bytesAfter <= TARGET_REDUCED_BYTES) break;
+                try {
+                  fs.unlinkSync(path.join(heapDir, info.file));
+                  bytesAfter -= info.size;
+                  log.warn(
+                    `Pruned heap snapshot '${info.file}' (${formatBytes(info.size)}) to reduce directory size. New size: ${formatBytes(bytesAfter)}.`,
+                  );
+                } catch (errDel) {
+                  log.warn(
+                    "Failed to delete heap snapshot file",
+                    info.file,
+                    errDel,
+                  );
+                }
+              }
+              if (bytesAfter > MAX_DIR_BYTES) {
+                // Still above hard cap; skip writing a new snapshot this cycle.
+                log.warn(
+                  `Heap snapshot directory still above hard cap (${formatBytes(bytesAfter)} > ${formatBytes(MAX_DIR_BYTES)}). Skipping new heap snapshot this cycle.`,
+                );
+                const stats = await dumpMemoryStats({
+                  includeHeapSpaces: false,
+                  writeHeapSnapshot: false,
+                });
+                memLogger.debug("[MemStat]:", stats);
+                return; // skip remainder; we already logged stats without snapshot.
+              }
+            }
+          } catch (dirErr) {
+            log.warn(
+              "Unexpected error while enforcing heap snapshot directory size limit",
+              dirErr,
+            );
+            // Continue; failure to enforce limit should not stop memory stats.
+          }
+          // Directory is within allowed bounds (or pruning succeeded); proceed normally.
+          const stats = await dumpMemoryStats({ includeHeapSpaces: false });
+          memLogger.debug("[MemStat]:", stats);
+        }
+      } catch (err) {
+        log.warn("Unexpected error while writing memory stats log", err);
+      }
+    },
+    15 * 60 * 1000,
+  ); // every 15 minutes
+}
+
+export default ongoingMemoryDump;

tests/heapPrune.test.ts

@@ -0,0 +1,62 @@
+import { test, expect } from "@playwright/test";
+import fs from "fs";
+import path from "path";
+
+// We import the module after setting up a temporary log path by monkey patching electron-log.
+// Since the project primarily uses Playwright for tests, we leverage its expect assertion library.
+
+// NOTE: This is a lightweight test that simulates the pruning logic indirectly by invoking the exported ongoingMemoryDump
+// function and creating artificial heap snapshot files exceeding the threshold.
+
+// Because ongoingMemoryDump sets an interval, we invoke its internal logic by importing the file and manually calling dumpMemoryStats.
+// For simplicity and to avoid altering production code for testability, we replicate the size enforcement logic here and assert behavior.
+
+function createDummySnapshots(dir: string, count: number, sizeBytes: number) {
+  fs.mkdirSync(dir, { recursive: true });
+  for (let i = 0; i < count; i++) {
+    const file = path.join(dir, `dummy-${i}.heapsnapshot`);
+    const fd = fs.openSync(file, "w");
+    // Write sizeBytes of zeros
+    const buf = Buffer.alloc(1024 * 1024, 0); // 1MB chunk
+    let written = 0;
+    while (written < sizeBytes) {
+      fs.writeSync(fd, buf, 0, Math.min(buf.length, sizeBytes - written));
+      written += Math.min(buf.length, sizeBytes - written);
+    }
+    fs.closeSync(fd);
+    // Stagger mtime for deterministic pruning ordering
+    const mtime = new Date(Date.now() - (count - i) * 1000);
+    fs.utimesSync(file, mtime, mtime);
+  }
+}
+
+test("heap snapshot directory pruning reduces size below simulated hard cap", async () => {
+  const baseDir = fs.mkdtempSync(path.join(process.cwd(), "heap-test-"));
+  const heapDir = path.join(baseDir, "heap-snapshots");
+  // Simulate oversize: 15 files of 5MB each = 75MB
+  createDummySnapshots(heapDir, 15, 5 * 1024 * 1024);
+  // Use smaller cap to keep test resource usage low.
+  const MAX_DIR_BYTES = 50 * 1024 * 1024; // 50MB simulated cap
+  const TARGET_REDUCED_BYTES = Math.floor(MAX_DIR_BYTES * 0.9);
+  const files = fs
+    .readdirSync(heapDir)
+    .filter((f) => f.endsWith(".heapsnapshot"));
+  let totalSize = 0;
+  const fileStats: Array<{ file: string; size: number; mtimeMs: number }> = [];
+  for (const file of files) {
+    const stat = fs.statSync(path.join(heapDir, file));
+    totalSize += stat.size;
+    fileStats.push({ file, size: stat.size, mtimeMs: stat.mtimeMs });
+  }
+  expect(totalSize).toBeGreaterThan(MAX_DIR_BYTES);
+  fileStats.sort((a, b) => a.mtimeMs - b.mtimeMs);
+  let bytesAfter = totalSize;
+  for (const info of fileStats) {
+    if (bytesAfter <= TARGET_REDUCED_BYTES) break;
+    fs.unlinkSync(path.join(heapDir, info.file));
+    bytesAfter -= info.size;
+  }
+  expect(bytesAfter).toBeLessThanOrEqual(TARGET_REDUCED_BYTES);
+  // Cleanup
+  fs.rmSync(baseDir, { recursive: true, force: true });
+});