fontastic 1.1.0 → 1.3.0

package/.github/workflows/claude-code-review.yml

@@ -12,12 +12,6 @@ on:
 
 jobs:
   claude-review:
-    # Optional: Filter by PR author
-    # if: |
-    #   github.event.pull_request.user.login == 'external-contributor' ||
-    #   github.event.pull_request.user.login == 'new-developer' ||
-    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
-
     runs-on: ubuntu-latest
     permissions:
       contents: read

package/.github/workflows/release-please.yml

@@ -0,0 +1,25 @@
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: write
+  pull-requests: write
+
+name: release-please
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: googleapis/release-please-action@v4.4.0
+        with:
+          token: ${{ secrets.RELEASE_PLEASE_TOKEN }}
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json

package/.github/workflows/release.yml

@@ -1,117 +1,14 @@
-name: Release
+name: Release Build
 
 on:
-  workflow_dispatch:
-    inputs:
-      bump:
-        description: 'Version bump type'
-        required: true
-        type: choice
-        options: [patch, minor, major]
+  release:
+    types: [published]
 
 permissions:
   contents: write
 
 jobs:
-  version:
-    runs-on: ubuntu-22.04
-    outputs:
-      version: ${{ steps.version.outputs.version }}
-    steps:
-      - name: Guard — owner only
-        if: github.actor != github.repository_owner
-        run: |
-          echo "Only the repository owner can trigger releases."
-          exit 1
-
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node 24
-        uses: actions/setup-node@v6
-        with:
-          node-version: '24'
-
-      - name: Configure git
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-      - name: Bump version
-        env:
-          BUMP: ${{ github.event.inputs.bump }}
-        run: |
-          npm version "$BUMP" --no-git-tag-version
-          node -e "const fs=require('fs');const app=JSON.parse(fs.readFileSync('./app/package.json'));app.version=require('./package.json').version;fs.writeFileSync('./app/package.json',JSON.stringify(app,null,2)+'\n');"
-
-      - name: Capture new version
-        id: version
-        run: echo "version=$(jq -r .version package.json)" >> "$GITHUB_OUTPUT"
-
-      - name: Generate changelog
-        run: |
-          node -e "
-          const { execSync } = require('child_process');
-          const fs = require('fs');
-
-          const lastTag = execSync('git describe --tags --abbrev=0').toString().trim();
-          const log = execSync('git log ' + lastTag + '..HEAD --format=%s').toString().trim();
-
-          const types = [
-            ['feat',     '### Features'],
-            ['fix',      '### Bug Fixes'],
-            ['refactor', '### Refactoring'],
-            ['revert',   '### Reverts'],
-            ['perf',     '### Performance'],
-          ];
-          const typeMap = Object.fromEntries(types.map(([k, v]) => [k, v]));
-
-          const pattern = /^(\w+)(\(.+?\))?(!)?: (.+)$/;
-          const groups = {};
-
-          for (const line of log.split('\n')) {
-            const m = line.match(pattern);
-            if (!m) continue;
-            const type = m[1];
-            const scope = m[2] ? m[2].slice(1, -1) : null;
-            const msg = m[4];
-            const label = typeMap[type];
-            if (!label) continue;
-            if (!groups[type]) groups[type] = [];
-            groups[type].push(scope ? '- **' + scope + '**: ' + msg : '- ' + msg);
-          }
-
-          const sections = types
-            .filter(([k]) => groups[k])
-            .map(([k, header]) => header + '\n' + groups[k].join('\n'))
-            .join('\n\n');
-
-          const body = sections || '_No conventional commits found since last release._';
-          fs.writeFileSync('CHANGELOG_BODY.md', body);
-          console.log('Changelog written.');
-          "
-
-      - name: Commit, tag, and push
-        env:
-          VERSION: ${{ steps.version.outputs.version }}
-        run: |
-          git add package.json app/package.json
-          git commit -m "[Bumped Version] ${VERSION}"
-          git push origin master
-          git tag "${VERSION}"
-          git push origin "${VERSION}"
-
-      - name: Create GitHub Release
-        env:
-          GH_TOKEN: ${{ github.token }}
-          VERSION: ${{ steps.version.outputs.version }}
-        run: gh release create "${VERSION}" --notes-file CHANGELOG_BODY.md --title "${VERSION}"
-
-
   build:
-    needs: version
     strategy:
       matrix:
         include:
@@ -126,7 +23,7 @@ jobs:
       - name: Checkout tag
         uses: actions/checkout@v6
         with:
-          ref: ${{ needs.version.outputs.version }}
+          ref: ${{ github.event.release.tag_name }}
 
       - name: Setup Node 24
         uses: actions/setup-node@v6
@@ -152,13 +49,12 @@ jobs:
       - name: Upload artifacts to release
         env:
           GH_TOKEN: ${{ github.token }}
-          VERSION: ${{ needs.version.outputs.version }}
         shell: bash
         run: |
           shopt -s nullglob
           files=(release/*.dmg release/*.AppImage release/*.exe release/*.zip release/*.deb release/*.rpm)
           if [ ${#files[@]} -gt 0 ]; then
-            gh release upload "${VERSION}" "${files[@]}" --clobber
+            gh release upload "${{ github.event.release.tag_name }}" "${files[@]}" --clobber
           else
             echo "No release artifacts found"
             exit 1

package/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.3.0"
+}

package/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Changelog
+
+## [1.3.0](https://github.com/tomshaw/fontastic/compare/fontastic-v1.2.0...fontastic-v1.3.0) (2026-03-15)
+
+
+### 🎉 Features
+
+* add smart collection preview functionality and enhance rule builder component ([436b162](https://github.com/tomshaw/fontastic/commit/436b16242ddae4eaaff3279d749b70dc79c9098c))
+* enhance application with secure storage and scan progress features ([7a2576b](https://github.com/tomshaw/fontastic/commit/7a2576b5484ce3d8ce1c06171f60608b43c3e42b))
+
+
+### 🛠️ Fixes
+
+* add height class to footer layout for improved display ([10da788](https://github.com/tomshaw/fontastic/commit/10da78803ba3ccec3cf9f76646a896a013a8935f))
+* adjust collection order handling in createParent and createChild methods ([3c9a0c4](https://github.com/tomshaw/fontastic/commit/3c9a0c4e2062a3c8a36b32f71193b01ddc57073e))
+* refactor footer component layout and enhance version handling ([dc0475e](https://github.com/tomshaw/fontastic/commit/dc0475ed4c67a326a7710894d9145731a7909b5d))
+* update collection order handling in createParent and createChild methods ([ce855d0](https://github.com/tomshaw/fontastic/commit/ce855d0664ab391fd15fed0bbffd16568a019699))
+* update footer layout to use grid for improved structure and responsiveness ([b2a4dac](https://github.com/tomshaw/fontastic/commit/b2a4dac434f9ea732180f32477854905c0fa80fb))
+
+
+### 🏗️ Refactor
+
+* standardize string quotes and improve code readability ([f352ddb](https://github.com/tomshaw/fontastic/commit/f352ddb248e6c7dc1e566917ebf57ebabdde3531))
+
+## [1.2.0](https://github.com/tomshaw/fontastic/compare/fontastic-v1.1.0...fontastic-v1.2.0) (2026-03-14)
+
+
+### 🎉 Features
+
+* **app:** enhance application plist patching and update icon handling ([297c052](https://github.com/tomshaw/fontastic/commit/297c052a2561962d8d6d1dd2f28f31bf5dcb66ba))
+* **app:** set application name to 'Fontastic' and add plist patching script ([af31cf6](https://github.com/tomshaw/fontastic/commit/af31cf61153b82c8a625755f5fc460b6d8205291))
+* **collection:** implement root collection creation request handling ([cba01d0](https://github.com/tomshaw/fontastic/commit/cba01d098998797d914c75f6cd32f814b3703fb0))
+* **navigation:** implement smart collection creation with input handling ([5cb72ae](https://github.com/tomshaw/fontastic/commit/5cb72ae9f576e0fb8dc1372ab411ea4e2d764191))
+* **release:** add release-please configuration and manifest files ([5cb72ae](https://github.com/tomshaw/fontastic/commit/5cb72ae9f576e0fb8dc1372ab411ea4e2d764191))
+
+
+### 🛠️ Fixes
+
+* **release:** update release configuration and manifest version ([759486b](https://github.com/tomshaw/fontastic/commit/759486b556982d90c5e3eaef38cfa0c214e7ac38))

package/README.md

@@ -23,6 +23,12 @@ Fontastic is an Electron-based font management and cataloging application built
 - Glyph inspector — browse and examine individual characters and Unicode points
 - Waterfall preview — compare text rendering across multiple sizes at a glance
 - Font table viewer — read raw OpenType and TrueType metadata tables
+- System theme sync — automatically matches OS light/dark mode via `nativeTheme`
+- Encrypted storage — API keys secured at rest using OS keychain via `safeStorage`
+- Scan progress — real-time font import progress streamed over `MessageChannelMain`
+- Power aware — pauses activity on system sleep and resumes on wake via `powerMonitor`
+- Session hardening — CSP headers, permission deny-list, and cache management via `session`
+- Accessibility — respects OS reduced motion and accent color via `systemPreferences`
 - Cross-platform — builds for Windows, macOS, and Linux
 
 ## Getting Started

package/app/Application.js

@@ -26,12 +26,12 @@ class Application {
             const systemManager = new SystemManager_1.default(this.machineId, this.isProduction);
             const configManager = new ConfigManager_1.default(systemManager);
             configManager.initialize();
+            const menuBuilder = new MenuBuilder_1.default(this.mainWindow, this.isProduction);
             const connectionManager = new ConnectionManager_1.default(configManager);
-            yield connectionManager.initialize();
+            // Initialize menu and database connection in parallel — menu doesn't depend on DB
+            yield Promise.all([connectionManager.initialize(), Promise.resolve(menuBuilder.initialize())]);
             const fontManager = new FontManager_1.default(systemManager, configManager, connectionManager);
-            const menuBuilder = new MenuBuilder_1.default(this.mainWindow, this.isProduction);
-            menuBuilder.initialize();
-            const messageHandler = new MessageHandler_1.default(systemManager, configManager, connectionManager, fontManager);
+            const messageHandler = new MessageHandler_1.default(systemManager, configManager, connectionManager, fontManager, this.mainWindow);
             messageHandler.initialize();
         });
     }

package/app/Application.ts

@@ -1,13 +1,12 @@
-import SystemManager from "./core/SystemManager";
-import ConfigManager from "./core/ConfigManager";
-import ConnectionManager from "./core/ConnectionManager";
-import FontManager from "./core/FontManager";
-import MessageHandler from "./core/MessageHandler";
-import MenuBuilder from "./core/menu/MenuBuilder";
-import { BrowserWindow } from "electron";
+import SystemManager from './core/SystemManager';
+import ConfigManager from './core/ConfigManager';
+import ConnectionManager from './core/ConnectionManager';
+import FontManager from './core/FontManager';
+import MessageHandler from './core/MessageHandler';
+import MenuBuilder from './core/menu/MenuBuilder';
+import { BrowserWindow } from 'electron';
 
 export default class Application {
-
   machineId: string;
   isProduction: boolean;
   mainWindow: BrowserWindow;
@@ -24,15 +23,16 @@ export default class Application {
     const configManager = new ConfigManager(systemManager);
     configManager.initialize();
 
+    const menuBuilder = new MenuBuilder(this.mainWindow, this.isProduction);
+
     const connectionManager = new ConnectionManager(configManager);
-    await connectionManager.initialize()
 
-    const fontManager = new FontManager(systemManager, configManager, connectionManager);
+    // Initialize menu and database connection in parallel — menu doesn't depend on DB
+    await Promise.all([connectionManager.initialize(), Promise.resolve(menuBuilder.initialize())]);
 
-    const menuBuilder = new MenuBuilder(this.mainWindow, this.isProduction);
-    menuBuilder.initialize();
+    const fontManager = new FontManager(systemManager, configManager, connectionManager);
 
-    const messageHandler = new MessageHandler(systemManager, configManager, connectionManager, fontManager);
+    const messageHandler = new MessageHandler(systemManager, configManager, connectionManager, fontManager, this.mainWindow);
     messageHandler.initialize();
   }
 }

package/app/config/database.js

@@ -146,7 +146,7 @@ exports.dbColumns = [
         searchable: true,
     },
     {
-        name: 'manufacturer',
+        name: 'manufacturer_url',
         searchable: true,
     },
     {

package/app/config/database.ts

@@ -145,7 +145,7 @@ export const dbColumns = [
     searchable: true,
   },
   {
-    name: 'manufacturer',
+    name: 'manufacturer_url',
     searchable: true,
   },
   {

package/app/config/mimes.js

@@ -3,41 +3,41 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.installable = exports.mimeTypes = exports.fontMimeTypes = void 0;
 exports.fontMimeTypes = [
     {
-        type: "font/ttf",
-        name: "TrueType",
+        type: 'font/ttf',
+        name: 'TrueType',
         description: "TrueType is an outline font standard developed by Apple in the late 1980s as a competitor to Adobe's Type 1 fonts used in PostScript. It has become the most common format for fonts on the classic Mac OS, macOS, and Microsoft Windows operating systems.",
-        installable: true
+        installable: true,
     },
     {
-        type: "font/otf",
-        name: "OpenType",
+        type: 'font/otf',
+        name: 'OpenType',
         description: "OpenType is a format for scalable computer fonts. It was built on its predecessor TrueType, retaining TrueType's basic structure and adding many intricate data structures for prescribing typographic behavior. OpenType is a registered trademark of Microsoft Corporation.",
-        installable: true
+        installable: true,
     },
     {
-        type: "font/woff",
-        name: "Web Open Font Format",
-        description: "The Web Open Font Format is a font format for use in web pages. WOFF files are OpenType or TrueType fonts, with format-specific compression applied and additional XML metadata added.",
-        installable: false
+        type: 'font/woff',
+        name: 'Web Open Font Format',
+        description: 'The Web Open Font Format is a font format for use in web pages. WOFF files are OpenType or TrueType fonts, with format-specific compression applied and additional XML metadata added.',
+        installable: false,
     },
     {
-        type: "font/woff2",
-        name: "Web Open Font Format 2",
-        description: "A WOFF2 file is a web font file created in the WOFF (Web Open Font Format) 2.0 format, an open format used to deliver webpage fonts on the fly. It is saved as a compressed container that supports TrueType (. TTF) and OpenType (. OTF) fonts. WOFF2 files also support font licensing metadata.",
-        installable: false
+        type: 'font/woff2',
+        name: 'Web Open Font Format 2',
+        description: 'A WOFF2 file is a web font file created in the WOFF (Web Open Font Format) 2.0 format, an open format used to deliver webpage fonts on the fly. It is saved as a compressed container that supports TrueType (. TTF) and OpenType (. OTF) fonts. WOFF2 files also support font licensing metadata.',
+        installable: false,
     },
     {
-        type: "font/ttc",
-        name: "TrueType Collection",
-        description: "TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common.",
-        installable: false
+        type: 'font/ttc',
+        name: 'TrueType Collection',
+        description: 'TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common.',
+        installable: false,
     },
     {
-        type: "font/dfont",
-        name: "Datafork TrueType",
-        description: "Datafork TrueType is a font wrapper used on Apple Macintosh computers running Mac OS X. It is a TrueType suitcase with the resource map in the data fork, rather than the resource fork as had been the case in Mac OS 9.",
-        installable: false
-    }
+        type: 'font/dfont',
+        name: 'Datafork TrueType',
+        description: 'Datafork TrueType is a font wrapper used on Apple Macintosh computers running Mac OS X. It is a TrueType suitcase with the resource map in the data fork, rather than the resource fork as had been the case in Mac OS 9.',
+        installable: false,
+    },
 ];
 exports.mimeTypes = exports.fontMimeTypes.map((item) => item.type);
 exports.installable = exports.fontMimeTypes.reduce((prev, curr) => {

package/app/config/mimes.ts

@@ -1,54 +1,60 @@
 interface Mime {
   type: string;
   name: string;
-  description: string,
-  installable: boolean
+  description: string;
+  installable: boolean;
 }
 
 export const fontMimeTypes: Mime[] = [
   {
-    type: "font/ttf",
-    name: "TrueType",
-    description: "TrueType is an outline font standard developed by Apple in the late 1980s as a competitor to Adobe's Type 1 fonts used in PostScript. It has become the most common format for fonts on the classic Mac OS, macOS, and Microsoft Windows operating systems.",
-    installable: true
+    type: 'font/ttf',
+    name: 'TrueType',
+    description:
+      "TrueType is an outline font standard developed by Apple in the late 1980s as a competitor to Adobe's Type 1 fonts used in PostScript. It has become the most common format for fonts on the classic Mac OS, macOS, and Microsoft Windows operating systems.",
+    installable: true,
   },
   {
-    type: "font/otf",
-    name: "OpenType",
-    description: "OpenType is a format for scalable computer fonts. It was built on its predecessor TrueType, retaining TrueType's basic structure and adding many intricate data structures for prescribing typographic behavior. OpenType is a registered trademark of Microsoft Corporation.",
-    installable: true
+    type: 'font/otf',
+    name: 'OpenType',
+    description:
+      "OpenType is a format for scalable computer fonts. It was built on its predecessor TrueType, retaining TrueType's basic structure and adding many intricate data structures for prescribing typographic behavior. OpenType is a registered trademark of Microsoft Corporation.",
+    installable: true,
   },
   {
-    type: "font/woff",
-    name: "Web Open Font Format",
-    description: "The Web Open Font Format is a font format for use in web pages. WOFF files are OpenType or TrueType fonts, with format-specific compression applied and additional XML metadata added.",
-    installable: false
+    type: 'font/woff',
+    name: 'Web Open Font Format',
+    description:
+      'The Web Open Font Format is a font format for use in web pages. WOFF files are OpenType or TrueType fonts, with format-specific compression applied and additional XML metadata added.',
+    installable: false,
   },
   {
-    type: "font/woff2",
-    name: "Web Open Font Format 2",
-    description: "A WOFF2 file is a web font file created in the WOFF (Web Open Font Format) 2.0 format, an open format used to deliver webpage fonts on the fly. It is saved as a compressed container that supports TrueType (. TTF) and OpenType (. OTF) fonts. WOFF2 files also support font licensing metadata.",
-    installable: false
+    type: 'font/woff2',
+    name: 'Web Open Font Format 2',
+    description:
+      'A WOFF2 file is a web font file created in the WOFF (Web Open Font Format) 2.0 format, an open format used to deliver webpage fonts on the fly. It is saved as a compressed container that supports TrueType (. TTF) and OpenType (. OTF) fonts. WOFF2 files also support font licensing metadata.',
+    installable: false,
   },
   {
-    type: "font/ttc",
-    name: "TrueType Collection",
-    description: "TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common.",
-    installable: false
+    type: 'font/ttc',
+    name: 'TrueType Collection',
+    description:
+      'TrueType Collection (TTC) is an extension of TrueType format that allows combining multiple fonts into a single file, creating substantial space savings for a collection of fonts with many glyphs in common.',
+    installable: false,
   },
   {
-    type: "font/dfont",
-    name: "Datafork TrueType",
-    description: "Datafork TrueType is a font wrapper used on Apple Macintosh computers running Mac OS X. It is a TrueType suitcase with the resource map in the data fork, rather than the resource fork as had been the case in Mac OS 9.",
-    installable: false
-  }
+    type: 'font/dfont',
+    name: 'Datafork TrueType',
+    description:
+      'Datafork TrueType is a font wrapper used on Apple Macintosh computers running Mac OS X. It is a TrueType suitcase with the resource map in the data fork, rather than the resource fork as had been the case in Mac OS 9.',
+    installable: false,
+  },
 ];
 
 export const mimeTypes: string[] = fontMimeTypes.map((item) => item.type);
 
-export const installable: Mime[] = fontMimeTypes.reduce((prev, curr) => {
+export const installable: string[] = fontMimeTypes.reduce((prev: string[], curr) => {
   if (curr.installable) {
     prev.push(curr.type);
   }
   return prev;
-}, []);
+}, []);

package/app/core/ConfigManager.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
 const database_1 = require("../config/database");
 const StorageType_1 = require("../enums/StorageType");
 const Store = require('electron-store');
@@ -26,6 +27,32 @@ class ConfigManager {
     clear() {
         return store.clear();
     }
+    // --- Safe Storage (OS keychain encryption) ---
+    setSecure(key, value) {
+        if (electron_1.safeStorage.isEncryptionAvailable()) {
+            const encrypted = electron_1.safeStorage.encryptString(value);
+            store.set(key, encrypted.toString('base64'));
+        }
+        else {
+            store.set(key, value);
+        }
+    }
+    getSecure(key) {
+        const raw = store.get(key);
+        if (!raw)
+            return null;
+        if (electron_1.safeStorage.isEncryptionAvailable() && typeof raw === 'string') {
+            try {
+                const buffer = Buffer.from(raw, 'base64');
+                return electron_1.safeStorage.decryptString(buffer);
+            }
+            catch (_a) {
+                // Fallback: value may have been stored before encryption was enabled
+                return raw;
+            }
+        }
+        return typeof raw === 'string' ? raw : null;
+    }
     toArray() {
         return store.store;
     }

package/app/core/ConfigManager.ts

@@ -1,3 +1,4 @@
+import { safeStorage } from 'electron';
 import SystemManager from './SystemManager';
 import { database } from '../config/database';
 import { StorageType } from '../enums/StorageType';
@@ -35,6 +36,33 @@ export default class ConfigManager {
     return store.clear();
   }
 
+  // --- Safe Storage (OS keychain encryption) ---
+
+  setSecure(key: string, value: string): void {
+    if (safeStorage.isEncryptionAvailable()) {
+      const encrypted = safeStorage.encryptString(value);
+      store.set(key, encrypted.toString('base64'));
+    } else {
+      store.set(key, value);
+    }
+  }
+
+  getSecure(key: string): string | null {
+    const raw = store.get(key);
+    if (!raw) return null;
+
+    if (safeStorage.isEncryptionAvailable() && typeof raw === 'string') {
+      try {
+        const buffer = Buffer.from(raw, 'base64');
+        return safeStorage.decryptString(buffer);
+      } catch {
+        // Fallback: value may have been stored before encryption was enabled
+        return raw;
+      }
+    }
+    return typeof raw === 'string' ? raw : null;
+  }
+
   toArray(): any {
     return store.store;
   }