Feature/folder search

.github/workflows/development.yml

@@ -20,9 +20,7 @@ jobs:
           node-version: 22
 
       - name: Setup pnpm
-        uses: pnpm/action-setup@v3
-        with:
-          version: 10
+        uses: pnpm/action-setup@v4
 
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
@@ -40,4 +38,35 @@ jobs:
         run: pnpm test:coverage
 
       - name: Build Electron app
-        run: pnpm dist
+        run: pnpm dist
+
+  security:
+    name: Security Audit
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: pnpm audit
+        run: pnpm audit --audit-level=high
+
+      - name: Run Trivy vulnerability scanner
+        uses: aquasecurity/trivy-action@v0.36.0
+        with:
+          scan-type: fs
+          scan-ref: .
+          severity: CRITICAL,HIGH
+          format: table
+          exit-code: 1

.github/workflows/production.yml

@@ -20,7 +20,7 @@ jobs:
           node-version: 22
 
       - name: Setup pnpm
-        uses: pnpm/action-setup@v3
+        uses: pnpm/action-setup@v4
         with:
           version: 10
 
@@ -40,4 +40,37 @@ jobs:
         run: pnpm test:coverage
 
       - name: Build Electron app
-        run: pnpm dist
+        run: pnpm dist
+
+  security:
+    name: Security Audit
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: pnpm audit
+        run: pnpm audit --audit-level=high
+
+      - name: Run Trivy vulnerability scanner
+        uses: aquasecurity/trivy-action@v0.36.0
+        with:
+          scan-type: fs
+          scan-ref: .
+          severity: CRITICAL,HIGH
+          format: table
+          exit-code: 1

.gitignore

@@ -1,8 +1,40 @@
-node_modules
-dist
-build
+# Dependencies
+node_modules/
+
+# Build outputs
+out/
+dist/
+build/
+release/
+*.tgz
+.vite/
+
+# Electron builder
+.cache/
+
+# Environment
 .env
-out 
-coverage
-release
-.vite/
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# OS artifacts
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Test coverage
+coverage/
+
+# Docusaurus
+docs/.docusaurus/
+docs/build/

.husky/pre-push

@@ -0,0 +1 @@
+pnpm test

.prettierignore

@@ -1,4 +1,9 @@
 node_modules
 dist
 .next
-build
+build
+out/
+release/
+coverage/
+docs/.docusaurus/
+docs/build/

apps/main-processor/tests/export.test.ts → apps/main-processor/__tests__/export.test.ts

@@ -1,7 +1,11 @@
 import { describe, it, expect } from 'vitest';
+import { mkdtemp, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
 import { buildDocument } from '../src/export/buildDocument';
 import { sanitizeCss } from '../src/export/sanitizeCss';
 import { getImage } from '../src/export/getImage';
+import { inlineImages } from '../src/export/inlineImage';
 
 describe('build html document', () => {
   it('wraps content in a valid HTML5 document shell', () => {
@@ -50,3 +54,17 @@ describe('get image of mime type', () => {
     expect(getImage('image.webp')).toBe('image/webp');
   });
 });
+
+describe('inline images for HTML export', () => {
+  it('keeps local images as base 64 data URIs', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'markdown-reader-export-'));
+    try {
+      const imagePath = join(dir, 'image.png');
+      await writeFile(imagePath, Buffer.from([137, 80, 78, 71]));
+      const html = await inlineImages(`<img src="${imagePath}"/>`);
+      expect(html).toContain('src="data:image/png;base64,');
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});

apps/main-processor/tests/file.test.ts → apps/main-processor/__tests__/file.test.ts

@@ -2,6 +2,7 @@ import { vi, describe, expect, it, beforeAll, afterAll } from 'vitest';
 import { writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
+import { getWatcherDiagnostics } from '../src/file';
 
 import { readFile, watchFile, unWatchFile } from '../src/file';
 
@@ -47,6 +48,7 @@ describe('File watcher', () => {
     writeFileSync(TEST_FILE, 'change after unwatch');
     await new Promise((r) => setTimeout(r, 200));
     expect(cb).not.toHaveBeenCalled();
+    expect(getWatcherDiagnostics().debounceTimers).toBe(0);
   });
 
   it('should protect from double call', async () => {
@@ -61,4 +63,23 @@ describe('File watcher', () => {
   it('should not crash if I unwatch a file which is not watched', async () => {
     await expect(unWatchFile('fake-file.txt')).resolves.toBeUndefined();
   });
+
+  it('should clean debounce timer references after unwatching', async () => {
+    const cb = vi.fn();
+    await watchFile(TEST_FILE, cb);
+    writeFileSync(TEST_FILE, 'change with pending debounce');
+    await new Promise((r) => setTimeout(r, 25));
+    await unWatchFile(TEST_FILE);
+    expect(getWatcherDiagnostics().debounceTimers).toBe(0);
+  });
+
+  it('does not call callback for a file unwatched during debounce', async () => {
+    const cb = vi.fn();
+    await watchFile(TEST_FILE, cb);
+    writeFileSync(TEST_FILE, 'change before immediate unwatch');
+    await new Promise((r) => setTimeout(r, 25));
+    await unWatchFile(TEST_FILE);
+    await new Promise((r) => setTimeout(r, 200));
+    expect(cb).not.toHaveBeenCalled();
+  });
 });

apps/main-processor/__tests__/folder-search.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { searchFolder } from '../src/folder-search';
+
+const DIR = join(tmpdir(), 'md-search-test');
+
+beforeAll(() => {
+  mkdirSync(DIR, { recursive: true });
+  writeFileSync(join(DIR, 'README.md'), '# Project\nThis project uses React.\nReact is great.');
+  writeFileSync(join(DIR, 'CHANGELOG.md'), '# Changes\nVersion 1.0 released.');
+  writeFileSync(join(DIR, 'notes.txt'), 'not a markdown file');
+});
+afterAll(() => {
+  rmSync(DIR, { recursive: true, force: true });
+});
+
+describe('search folder', () => {
+  it('should find matches in .md files and returns results', async () => {
+    const results = await searchFolder(DIR, 'React');
+    expect(results.length).toBeGreaterThan(0);
+    expect(results.some((r) => r.filePath.endsWith('README.md'))).toBe(true);
+  });
+
+  it('does not search non .md files', async () => {
+    const results = await searchFolder(DIR, 'not a markdown');
+    expect(results.every((r) => r.filePath.endsWith('.md'))).toBe(true);
+  });
+
+  it('should return empty array when query matches nothing', async () => {
+    const results = await searchFolder(DIR, 'xyznotfound');
+    expect(results).toHaveLength(0);
+  });
+
+  it('has search case insensitive', async () => {
+    const lower = await searchFolder(DIR, 'react');
+    const upper = await searchFolder(DIR, 'REACT');
+    expect(lower.length).toBe(upper.length);
+  });
+
+  it('returns an empty array if the directory does not exist', async () => {
+    const nonExistentDir = join(DIR, 'does-not-exist-folder');
+
+    const results = await searchFolder(nonExistentDir, 'React');
+    expect(results).toEqual([]);
+  });
+});

apps/main-processor/__tests__/folder.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { getFolder } from '../src/folder';
+
+describe('folder reader testing', async () => {
+  it('should enforce the recursion depth', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'markdown-reader-folder-'));
+    let current = root;
+    for (let index = 0; index < 12; index += 1) {
+      current = join(current, `level-${index}`);
+      await mkdir(current);
+      await writeFile(join(current, `file-${index}.md`), '# test', 'utf-8');
+    }
+
+    const tree = await getFolder(root, 2);
+    const first = tree.children?.find((child) => child.isDir);
+    const second = first?.children?.find((child) => child.isDir);
+    expect(second?.children).toEqual([]);
+  });
+});

apps/main-processor/tests/recent.test.ts → apps/main-processor/__tests__/recent.test.ts

@@ -1,9 +1,4 @@
-import { vi, describe, it, expect } from 'vitest';
-vi.mock('electron', () => ({
-  app: {
-    isPackaged: false,
-  },
-}));
+import { describe, it, expect } from 'vitest';
 import { RecentFile } from '@package/shared-types';
 import { addToRecentList } from '../src/recent/addToRecentList';
 import { getUniqueRecentFile } from '../src/recent/getUniqueRecentFile';

apps/main-processor/__tests__/settings.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import { validateSettings } from '../src/utils/helper/setting-helper';
+import { READING_WIDTHS } from '../src/utils/constants/setting-constants';
+import { THEMES } from '@package/shared-constants';
+describe('settings validation', () => {
+  it('accepts valid settings', () => {
+    expect(validateSettings({ fontSize: 18 })).toEqual({ fontSize: 18 });
+  });
+
+  it('rejects unknown keys', () => {
+    expect(() => validateSettings({ unexpected: true } as never)).toThrow('Unknown settings key');
+  });
+
+  it('rejects invalid values', () => {
+    expect(() => validateSettings({ fontSize: 100 })).toThrow('Invalid fontSize');
+  });
+
+  it('validates theme values', () => {
+    expect(validateSettings({ theme: THEMES[0] })).toEqual({ theme: THEMES[0] });
+    expect(() => validateSettings({ theme: 'unknown-theme' as never })).toThrow('Invalid theme');
+  });
+
+  it('validates readingWidth values', () => {
+    expect(READING_WIDTHS.has('default')).toBe(true);
+    expect(validateSettings({ readingWidth: 'default' })).toEqual({ readingWidth: 'default' });
+    expect(() => validateSettings({ readingWidth: 'full' as never })).toThrow(
+      'Invalid readingWidth'
+    );
+  });
+
+  it('validates boolean settings', () => {
+    expect(validateSettings({ lineNumbers: true })).toEqual({ lineNumbers: true });
+    expect(validateSettings({ showHiddenFiles: false })).toEqual({ showHiddenFiles: false });
+    expect(() => validateSettings({ lineNumbers: 'yes' as never })).toThrow('Invalid lineNumbers');
+    expect(() => validateSettings({ showHiddenFiles: 'no' as never })).toThrow(
+      'Invalid showHiddenFiles'
+    );
+  });
+
+  it('validates customCss values', () => {
+    expect(validateSettings({ customCss: '.markdown-body { color: red; }' })).toEqual({
+      customCss: '.markdown-body { color: red; }',
+    });
+    expect(() => validateSettings({ customCss: 42 as never })).toThrow('Invalid customCss');
+  });
+
+  it('validates zoom range', () => {
+    expect(validateSettings({ zoom: 50 })).toEqual({ zoom: 50 });
+    expect(validateSettings({ zoom: 200 })).toEqual({ zoom: 200 });
+    expect(() => validateSettings({ zoom: 49 })).toThrow('Invalid zoom');
+    expect(() => validateSettings({ zoom: 201 })).toThrow('Invalid zoom');
+  });
+
+  it('validates recentFilesLimit range', () => {
+    expect(validateSettings({ recentFilesLimit: 1 })).toEqual({ recentFilesLimit: 1 });
+    expect(validateSettings({ recentFilesLimit: 50 })).toEqual({ recentFilesLimit: 50 });
+    expect(() => validateSettings({ recentFilesLimit: 0 })).toThrow('Invalid recentFilesLimit');
+    expect(() => validateSettings({ recentFilesLimit: 51 })).toThrow('Invalid recentFilesLimit');
+  });
+});

apps/main-processor/setup.ts

@@ -0,0 +1,8 @@
+import { vi } from 'vitest';
+
+vi.mock('electron', () => ({
+  app: {
+    isPackaged: false,
+    getPath: vi.fn(),
+  },
+}));

apps/main-processor/src/export/inlineImage.ts

@@ -9,7 +9,7 @@ export async function inlineImages(html: string): Promise<string> {
 
   for (const match of matches) {
     const fullMatch = match[0];
-    const src = match[1];
+    const src = match[2];
 
     if (!src) continue;