@omega.js/desktop 0.1.0

package/dist/test/suites/main/startup-paths-and-ua.test.js

@@ -0,0 +1,99 @@
+// Verifies the early-init customizations applied in main.js#initialize:
+//   - userData path gets an environment suffix: " (Testing)" under the test
+//     harness, " (Development)" in dev, untouched in production
+//   - app.userAgentFallback is set to a branded template via node-powertools.template
+//
+// These are observable side-effects of `manager.initialize()` so we just inspect
+// the live electron `app` after the harness boot.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'startup paths + global user agent',
+  tests: [
+    {
+      name: 'userData path includes "(Testing)" suffix under the test harness',
+      run: (ctx) => {
+        const { app } = require('electron');
+        const userData = app.getPath('userData');
+        // OMEGA_TEST_MODE=true → isTesting() → dedicated " (Testing)" dir, wiped at
+        // boot, so test runs never read or pollute dev ("(Development)") or
+        // production data on the same machine.
+        ctx.expect(typeof userData).toBe('string');
+        ctx.expect(userData.endsWith(' (Testing)')).toBe(true);
+      },
+    },
+    {
+      name: 'testing userData dir is freshly created (wiped at boot)',
+      run: (ctx) => {
+        const fs = require('fs');
+        const path = require('path');
+        const { app } = require('electron');
+        const userData = app.getPath('userData');
+        // The wipe ran before storage.initialize(); only files written by THIS
+        // boot may exist. A marker from a previous run must never survive.
+        const marker = path.join(userData, '__em-wipe-marker');
+        ctx.expect(fs.existsSync(marker)).toBe(false);
+        // Leave a marker so the NEXT run proves the wipe (self-perpetuating check).
+        fs.mkdirSync(userData, { recursive: true });
+        fs.writeFileSync(marker, String(Date.now()));
+      },
+    },
+    {
+      name: 'app.userAgentFallback is a non-empty string',
+      run: (ctx) => {
+        const { app } = require('electron');
+        ctx.expect(typeof app.userAgentFallback).toBe('string');
+        ctx.expect(app.userAgentFallback.length > 0).toBe(true);
+      },
+    },
+    {
+      name: 'userAgentFallback merge tags resolved (no leftover {placeholders})',
+      run: (ctx) => {
+        const { app } = require('electron');
+        // If node-powertools.template skipped a key, the literal `{...}` would remain.
+        ctx.expect(app.userAgentFallback).not.toMatch(/\{brand\.name\}/);
+        ctx.expect(app.userAgentFallback).not.toMatch(/\{app\.version\}/);
+        ctx.expect(app.userAgentFallback).not.toMatch(/\{chrome\}/);
+      },
+    },
+    {
+      name: 'userAgentFallback contains the brand name from config',
+      run: (ctx) => {
+        const { app } = require('electron');
+        const brand = ctx.manager.config?.brand?.name
+          || ctx.manager.config?.app?.productName
+          || 'App';
+        ctx.expect(app.userAgentFallback).toContain(brand);
+      },
+    },
+    {
+      name: 'userAgentFallback contains the chromium version from process.versions.chrome',
+      run: (ctx) => {
+        const { app } = require('electron');
+        ctx.expect(app.userAgentFallback).toContain(process.versions.chrome);
+      },
+    },
+    {
+      name: 'userAgentFallback shape matches the platform',
+      run: (ctx) => {
+        const { app } = require('electron');
+        const expectedFragment = process.platform === 'darwin' ? 'Macintosh; Intel Mac OS X'
+          : process.platform === 'win32'  ? 'Windows NT 10.0; Win64; x64'
+          : 'X11; Linux x86_64';
+        ctx.expect(app.userAgentFallback).toContain(expectedFragment);
+      },
+    },
+    {
+      name: 'userAgentFallback contains AppleWebKit + Chrome + Safari segments',
+      run: (ctx) => {
+        const { app } = require('electron');
+        ctx.expect(app.userAgentFallback).toContain('AppleWebKit/537.36');
+        ctx.expect(app.userAgentFallback).toContain('Chrome/');
+        ctx.expect(app.userAgentFallback).toContain('Safari/537.36');
+      },
+    },
+  ],
+});

package/dist/test/suites/main/startup.test.js

@@ -0,0 +1,129 @@
+// Main-process tests for lib/startup.js — launch mode + open-at-login.
+//
+// Note: in tests the harness passes skipWindowCreation:true, so the main.js
+// `applyEarly` and `windows.createNamed` calls aren't exercised — those paths
+// are smoke-tested separately via boot-sequence.test.js. Here we test the
+// startup module's own surface.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'startup (main)',
+  cleanup: (ctx) => {
+    // Restore default mode so no later suite is affected.
+    if (ctx.manager.config?.startup) {
+      ctx.manager.config.startup.mode = 'normal';
+    }
+  },
+  tests: [
+    {
+      name: 'initialize ran during boot',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.startup._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'getMode returns "normal" by default',
+      run: (ctx) => {
+        ctx.manager.config.startup.mode = 'normal';
+        ctx.expect(ctx.manager.startup.getMode()).toBe('normal');
+      },
+    },
+    {
+      name: 'getMode honors valid values',
+      run: (ctx) => {
+        for (const mode of ['normal', 'hidden']) {
+          ctx.manager.config.startup.mode = mode;
+          ctx.expect(ctx.manager.startup.getMode()).toBe(mode);
+        }
+      },
+    },
+    {
+      name: 'getMode falls back to "normal" for unknown values',
+      run: (ctx) => {
+        ctx.manager.config.startup.mode = 'banana';
+        ctx.expect(ctx.manager.startup.getMode()).toBe('normal');
+      },
+    },
+    {
+      name: 'getMode rejects deprecated tray-only as unknown (falls back to normal)',
+      run: (ctx) => {
+        // tray-only was folded into hidden; it's no longer a valid mode.
+        ctx.manager.config.startup.mode = 'tray-only';
+        ctx.expect(ctx.manager.startup.getMode()).toBe('normal');
+      },
+    },
+    {
+      name: 'isLaunchHidden true for hidden, false for normal',
+      run: (ctx) => {
+        ctx.manager.config.startup.mode = 'normal';
+        ctx.expect(ctx.manager.startup.isLaunchHidden()).toBe(false);
+        ctx.manager.config.startup.mode = 'hidden';
+        ctx.expect(ctx.manager.startup.isLaunchHidden()).toBe(true);
+      },
+    },
+    {
+      name: 'applyEarly is a no-op outside hidden mode',
+      run: (ctx) => {
+        ctx.manager.config.startup.mode = 'normal';
+        // Just confirm it doesn't throw.
+        ctx.manager.startup.applyEarly();
+        ctx.expect(true).toBe(true);
+      },
+    },
+    {
+      name: 'applyEarly does not throw for hidden mode',
+      run: (ctx) => {
+        ctx.manager.config.startup.mode = 'hidden';
+        ctx.manager.startup.applyEarly();
+        ctx.expect(true).toBe(true);
+      },
+    },
+    {
+      name: 'isOpenAtLogin returns a boolean (or null on platforms without support)',
+      run: (ctx) => {
+        const v = ctx.manager.startup.isOpenAtLogin();
+        ctx.expect(v === null || typeof v === 'boolean').toBe(true);
+      },
+    },
+    {
+      name: 'setOpenAtLogin runs without throwing',
+      run: (ctx) => {
+        // Set to false to avoid actually registering the test harness for login on the dev box.
+        ctx.manager.startup.setOpenAtLogin(false);
+        ctx.expect(true).toBe(true);
+      },
+    },
+    {
+      name: 'setOpenAtLogin accepts the object form { enabled, mode }',
+      run: (ctx) => {
+        // Object form should not throw and should round-trip the args/openAsHidden flags.
+        ctx.manager.startup.setOpenAtLogin({ enabled: false, mode: 'normal' });
+        ctx.manager.startup.setOpenAtLogin({ enabled: true,  mode: 'hidden' });
+        // Restore to disabled at end so we don't leave the test harness as a login item.
+        ctx.manager.startup.setOpenAtLogin(false);
+        ctx.expect(true).toBe(true);
+      },
+    },
+    {
+      name: 'wasLaunchedAtLogin returns a boolean',
+      run: (ctx) => {
+        ctx.expect(typeof ctx.manager.startup.wasLaunchedAtLogin()).toBe('boolean');
+      },
+    },
+    {
+      name: 'dev mode never registers open-at-login (and clears prior registration)',
+      run: (ctx) => {
+        // The harness runs unpackaged, so initialize() must have force-OFF'd the login item.
+        // Confirm the current OS state reflects that — getLoginItemSettings should report
+        // openAtLogin: false. (Note: returns null on platforms without LoginItemSettings.)
+        const live = ctx.manager.startup.isOpenAtLogin();
+        if (live !== null) {
+          ctx.expect(live).toBe(false);
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/main/stealth-window.test.js

@@ -0,0 +1,74 @@
+// Main-process tests for the global raw-BrowserWindow test stealth:
+// utils/stealth-window.js applied by main.js's `browser-window-created` hook
+// (registered during Manager.initialize step 1a-ii — this harness IS Testing
+// mode, so the hook is live).
+//
+// Named windows created through lib/window-manager have their own stealth path
+// (_surface — covered by window-manager.test.js); THESE tests prove windows
+// that never touch window-manager can't flash or steal focus during a test run.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'stealth-window — raw BrowserWindow stealth (main)',
+  tests: [
+    {
+      name: 'raw BrowserWindow is stealthed at creation (opacity 0, before any show)',
+      run: (ctx) => {
+        if (process.platform === 'linux') {
+          return ctx.skip('setOpacity is unsupported on Linux (getOpacity always returns 1)');
+        }
+        const { BrowserWindow } = require('electron');
+        const win = new BrowserWindow({ show: false, width: 120, height: 80 });
+        ctx.state.win = win;
+        ctx.expect(win.getOpacity()).toBe(0);
+      },
+    },
+    {
+      name: 'show() routes to showInactive — visible, never focused, still invisible',
+      run: (ctx) => {
+        if (process.platform === 'linux') {
+          return ctx.skip('setOpacity is unsupported on Linux');
+        }
+        const win = ctx.state.win;
+        win.show(); // raw consumers call show() — the stealth patch keeps it inactive
+        ctx.expect(win.isVisible()).toBe(true);
+        ctx.expect(win.isFocused()).toBe(false);
+        ctx.expect(win.getOpacity()).toBe(0);
+      },
+    },
+    {
+      name: 'focus() is a no-op',
+      run: (ctx) => {
+        if (process.platform === 'linux') {
+          return ctx.skip('setOpacity is unsupported on Linux');
+        }
+        const win = ctx.state.win;
+        win.focus();
+        ctx.expect(win.isFocused()).toBe(false);
+        win.destroy();
+      },
+    },
+    {
+      name: 'OMEGA_TEST_SHOW=1 opts out — raw windows are NOT stealthed at creation',
+      run: (ctx) => {
+        if (process.platform === 'linux') {
+          return ctx.skip('setOpacity is unsupported on Linux');
+        }
+        const { BrowserWindow } = require('electron');
+        process.env.OMEGA_TEST_SHOW = '1';
+        try {
+          // Never shown — opacity alone proves the hook skipped it, without any
+          // risk of activating the test process mid-run.
+          const win = new BrowserWindow({ show: false, width: 120, height: 80 });
+          ctx.expect(win.getOpacity()).toBe(1);
+          win.destroy();
+        } finally {
+          delete process.env.OMEGA_TEST_SHOW;
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/main/storage.test.js

@@ -0,0 +1,89 @@
+// Main-process tests for lib/storage.js — round-trip, dot-notation, persistence, broadcast.
+//
+// ctx.manager is a fully-initialized @omega.js/desktop Manager (skipWindowCreation: true).
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'storage (main)',
+  cleanup: async (ctx) => {
+    ctx.manager.storage.clear();
+  },
+  tests: [
+    {
+      name: 'set + get round-trip',
+      run: (ctx) => {
+        ctx.manager.storage.set('hello', 'world');
+        ctx.expect(ctx.manager.storage.get('hello')).toBe('world');
+      },
+    },
+    {
+      name: 'get returns default when missing',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.storage.get('nope', 'fallback')).toBe('fallback');
+        ctx.expect(ctx.manager.storage.get('nope')).toBeUndefined();
+      },
+    },
+    {
+      name: 'has reflects presence',
+      run: (ctx) => {
+        ctx.manager.storage.set('present', 1);
+        ctx.expect(ctx.manager.storage.has('present')).toBe(true);
+        ctx.expect(ctx.manager.storage.has('absent')).toBe(false);
+      },
+    },
+    {
+      name: 'delete removes the key',
+      run: (ctx) => {
+        ctx.manager.storage.set('temp', 'x');
+        ctx.manager.storage.delete('temp');
+        ctx.expect(ctx.manager.storage.has('temp')).toBe(false);
+      },
+    },
+    {
+      name: 'dot-notation nested paths',
+      run: (ctx) => {
+        ctx.manager.storage.set('window.main.bounds', { x: 10, y: 20, w: 800, h: 600 });
+        ctx.expect(ctx.manager.storage.get('window.main.bounds')).toEqual({ x: 10, y: 20, w: 800, h: 600 });
+        ctx.expect(ctx.manager.storage.get('window.main.bounds.w')).toBe(800);
+      },
+    },
+    {
+      name: 'onChange fires for the watched key',
+      run: async (ctx) => {
+        const calls = [];
+        const unsub = ctx.manager.storage.onChange('watched', (value, previous) => {
+          calls.push({ value, previous });
+        });
+        ctx.manager.storage.set('watched', 'first');
+        ctx.manager.storage.set('watched', 'second');
+        unsub();
+        ctx.manager.storage.set('watched', 'third'); // should NOT fire after unsub
+        ctx.expect(calls.length).toBe(2);
+        ctx.expect(calls[0].value).toBe('first');
+        ctx.expect(calls[1].value).toBe('second');
+        ctx.expect(calls[1].previous).toBe('first');
+      },
+    },
+    {
+      name: 'clear empties the store',
+      run: (ctx) => {
+        ctx.manager.storage.set('a', 1);
+        ctx.manager.storage.set('b', 2);
+        ctx.manager.storage.clear();
+        ctx.expect(ctx.manager.storage.has('a')).toBe(false);
+        ctx.expect(ctx.manager.storage.has('b')).toBe(false);
+      },
+    },
+    {
+      name: 'getPath returns the on-disk file location',
+      run: (ctx) => {
+        const p = ctx.manager.storage.getPath();
+        ctx.expect(typeof p).toBe('string');
+        ctx.expect(p).toMatch(/omega-storage\.json$/);
+      },
+    },
+  ],
+});

package/dist/test/suites/main/theme.test.js

@@ -0,0 +1,137 @@
+// Main-process tests for lib/theme.js — source/resolved round-trip, nativeTheme
+// wiring, persistence, change events (with dedupe), IPC handlers, validation.
+//
+// ctx.manager is a fully-initialized @omega.js/desktop Manager. Every test that mutates the theme
+// restores it; cleanup() resets to the pre-suite source and clears the persisted
+// override so later suites (and re-runs) start clean.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+let originalSource = null;
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'theme (main)',
+  cleanup: async (ctx) => {
+    if (originalSource) {
+      ctx.manager.theme.set(originalSource);
+    }
+    ctx.manager.storage.delete('theme.appearance');
+  },
+  tests: [
+    {
+      name: 'manager.theme is initialized with the full API surface',
+      run: (ctx) => {
+        originalSource = ctx.manager.theme.get();
+        ctx.expect(ctx.manager.theme._initialized).toBe(true);
+        ctx.expect(typeof ctx.manager.theme.get).toBe('function');
+        ctx.expect(typeof ctx.manager.theme.set).toBe('function');
+        ctx.expect(typeof ctx.manager.theme.resolved).toBe('function');
+        ctx.expect(typeof ctx.manager.theme.onChange).toBe('function');
+      },
+    },
+    {
+      name: 'get() returns a valid source and resolved() a concrete appearance',
+      run: (ctx) => {
+        ctx.expect(['system', 'light', 'dark'].includes(ctx.manager.theme.get())).toBe(true);
+        ctx.expect(['light', 'dark'].includes(ctx.manager.theme.resolved())).toBe(true);
+      },
+    },
+    {
+      name: 'set("dark") drives nativeTheme.themeSource, resolution, and persistence',
+      run: (ctx) => {
+        const { nativeTheme } = require('electron');
+        ctx.manager.theme.set('dark');
+        ctx.expect(ctx.manager.theme.get()).toBe('dark');
+        ctx.expect(ctx.manager.theme.resolved()).toBe('dark');
+        ctx.expect(nativeTheme.themeSource).toBe('dark');
+        ctx.expect(nativeTheme.shouldUseDarkColors).toBe(true);
+        ctx.expect(ctx.manager.storage.get('theme.appearance')).toBe('dark');
+      },
+    },
+    {
+      name: 'set("light") flips the resolution',
+      run: (ctx) => {
+        ctx.manager.theme.set('light');
+        ctx.expect(ctx.manager.theme.get()).toBe('light');
+        ctx.expect(ctx.manager.theme.resolved()).toBe('light');
+        ctx.expect(ctx.manager.storage.get('theme.appearance')).toBe('light');
+      },
+    },
+    {
+      name: 'set("system") returns to following the OS',
+      run: (ctx) => {
+        const { nativeTheme } = require('electron');
+        ctx.manager.theme.set('system');
+        ctx.expect(ctx.manager.theme.get()).toBe('system');
+        ctx.expect(nativeTheme.themeSource).toBe('system');
+        // In system mode the resolution is whatever the OS says — assert coherence,
+        // not a specific value (the test machine's OS preference is not ours to pin).
+        ctx.expect(ctx.manager.theme.resolved()).toBe(nativeTheme.shouldUseDarkColors ? 'dark' : 'light');
+      },
+    },
+    {
+      name: 'set() throws on anything outside system|light|dark',
+      run: (ctx) => {
+        let threw = false;
+        try {
+          ctx.manager.theme.set('auto');
+        } catch (e) {
+          threw = true;
+        }
+        ctx.expect(threw).toBe(true);
+
+        threw = false;
+        try {
+          ctx.manager.theme.set(undefined);
+        } catch (e) {
+          threw = true;
+        }
+        ctx.expect(threw).toBe(true);
+      },
+    },
+    {
+      name: 'onChange fires once per effective change (deduped) and unsubscribes',
+      run: (ctx) => {
+        ctx.manager.theme.set('light');
+
+        const calls = [];
+        const unsub = ctx.manager.theme.onChange((payload) => calls.push(payload));
+
+        ctx.manager.theme.set('dark');   // change → fires
+        ctx.manager.theme.set('dark');   // no-op → silent
+        ctx.manager.theme.set('light');  // change → fires
+
+        unsub();
+        ctx.manager.theme.set('dark');   // unsubscribed → silent
+
+        ctx.expect(calls.length).toBe(2);
+        ctx.expect(calls[0]).toEqual({ source: 'dark', resolved: 'dark' });
+        ctx.expect(calls[1]).toEqual({ source: 'light', resolved: 'light' });
+      },
+    },
+    {
+      name: 'desktop:theme:get / desktop:theme:set IPC handlers round-trip',
+      run: async (ctx) => {
+        const set = await ctx.manager.ipc.invoke('desktop:theme:set', { source: 'dark' });
+        ctx.expect(set).toEqual({ source: 'dark', resolved: 'dark' });
+
+        const got = await ctx.manager.ipc.invoke('desktop:theme:get');
+        ctx.expect(got).toEqual({ source: 'dark', resolved: 'dark' });
+      },
+    },
+    {
+      name: 'desktop:theme:set rejects invalid sources',
+      run: async (ctx) => {
+        let threw = false;
+        try {
+          await ctx.manager.ipc.invoke('desktop:theme:set', { source: 'midnight' });
+        } catch (e) {
+          threw = true;
+        }
+        ctx.expect(threw).toBe(true);
+      },
+    },
+  ],
+});