@omega.js/desktop 0.1.0

package/dist/test/suites/main/app-state.test.js

@@ -0,0 +1,197 @@
+// Main-process tests for lib/app-state.js — storage-backed launch flags + crash sentinel.
+//
+// The harness already booted Manager once, which incremented launchCount and seeded
+// state. We test by calling appState.reset() then re-initializing with crafted
+// storage state to simulate first-launch / repeat-launch / crash-recovery / upgrade.
+
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const STORAGE_KEY = 'appState';
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'app-state (main)',
+  cleanup: async (ctx) => {
+    // Restore a sane state for any later suites that look at appState.
+    ctx.manager.appState.reset();
+    // Mark _initialized=false so we can re-init cleanly.
+    ctx.manager.appState._initialized = false;
+    await ctx.manager.appState.initialize(ctx.manager);
+  },
+  tests: [
+    {
+      name: 'initialize ran during boot',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.appState._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'first launch: flags + counters seeded correctly',
+      run: async (ctx) => {
+        ctx.manager.appState.reset();
+        ctx.manager.appState._initialized = false;
+        await ctx.manager.appState.initialize(ctx.manager);
+
+        ctx.expect(ctx.manager.appState.isFirstLaunch()).toBe(true);
+        ctx.expect(ctx.manager.appState.getLaunchCount()).toBe(1);
+        ctx.expect(ctx.manager.appState.getInstalledAt()).toBeInstanceOf(Date);
+        ctx.expect(ctx.manager.appState.getLastLaunchAt()).toBeNull();
+        ctx.expect(ctx.manager.appState.recoveredFromCrash()).toBe(false);
+      },
+    },
+    {
+      name: 'second launch: not first, count incremented, lastLaunchAt populated',
+      run: async (ctx) => {
+        ctx.manager.appState.reset();
+        ctx.manager.appState._initialized = false;
+        await ctx.manager.appState.initialize(ctx.manager);
+
+        // Simulate a graceful quit from the first launch.
+        const after1 = ctx.manager.storage.get(STORAGE_KEY);
+        after1.sentinel  = false;
+        after1.lastQuitAt = Date.now();
+        ctx.manager.storage.set(STORAGE_KEY, after1);
+
+        // Boot again.
+        ctx.manager.appState._initialized = false;
+        await ctx.manager.appState.initialize(ctx.manager);
+
+        ctx.expect(ctx.manager.appState.isFirstLaunch()).toBe(false);
+        ctx.expect(ctx.manager.appState.getLaunchCount()).toBe(2);
+        ctx.expect(ctx.manager.appState.getLastLaunchAt()).toBeInstanceOf(Date);
+        ctx.expect(ctx.manager.appState.recoveredFromCrash()).toBe(false);
+      },
+    },
+    {
+      name: 'crash detection: previous launch left sentinel and no quit timestamp',
+      run: async (ctx) => {
+        // Seed storage with a "we were running and never gracefully quit" state.
+        ctx.manager.storage.set(STORAGE_KEY, {
+          installedAt:  Date.now() - 10000,
+          launchCount:  3,
+          lastLaunchAt: Date.now() - 1000,
+          lastQuitAt:   null,                 // never quit gracefully
+          sentinel:     true,                 // was running
+          version:      '1.0.0',
+        });
+
+        ctx.manager.appState._initialized = false;
+        await ctx.manager.appState.initialize(ctx.manager);
+
+        ctx.expect(ctx.manager.appState.recoveredFromCrash()).toBe(true);
+        ctx.expect(ctx.manager.appState.getLaunchCount()).toBe(4);
+      },
+    },
+    {
+      name: 'graceful quit: sentinel cleared on next boot, no crash flag',
+      run: async (ctx) => {
+        ctx.manager.storage.set(STORAGE_KEY, {
+          installedAt:  Date.now() - 10000,
+          launchCount:  5,
+          lastLaunchAt: Date.now() - 1000,
+          lastQuitAt:   Date.now() - 500,    // graceful quit happened
+          sentinel:     false,
+          version:      '1.0.0',
+        });
+
+        ctx.manager.appState._initialized = false;
+        await ctx.manager.appState.initialize(ctx.manager);
+
+        ctx.expect(ctx.manager.appState.recoveredFromCrash()).toBe(false);
+        ctx.expect(ctx.manager.appState.getLaunchCount()).toBe(6);
+      },
+    },
+    {
+      name: 'version upgrade: previousVersion populated when version changes',
+      run: async (ctx) => {
+        ctx.manager.storage.set(STORAGE_KEY, {
+          installedAt:  Date.now() - 10000,
+          launchCount:  10,
+          lastLaunchAt: Date.now() - 1000,
+          lastQuitAt:   Date.now() - 500,
+          sentinel:     false,
+          version:      '0.9.0',     // previous version
+        });
+
+        // Force the manager's reported version to differ.
+        const origConfig = ctx.manager.config.app;
+        ctx.manager.config.app = { ...origConfig, version: '1.0.0' };
+
+        try {
+          ctx.manager.appState._initialized = false;
+          await ctx.manager.appState.initialize(ctx.manager);
+
+          ctx.expect(ctx.manager.appState.getVersion()).toBe('1.0.0');
+          ctx.expect(ctx.manager.appState.getPreviousVersion()).toBe('0.9.0');
+          ctx.expect(ctx.manager.appState.wasUpgraded()).toBe(true);
+        } finally {
+          ctx.manager.config.app = origConfig;
+        }
+      },
+    },
+    {
+      name: 'no version change: wasUpgraded false, previousVersion preserved',
+      run: async (ctx) => {
+        // Seed with a previousVersion that should NOT be overwritten when version doesn't change.
+        ctx.manager.storage.set(STORAGE_KEY, {
+          installedAt:     Date.now() - 10000,
+          launchCount:     20,
+          lastLaunchAt:    Date.now() - 1000,
+          lastQuitAt:      Date.now() - 500,
+          sentinel:        false,
+          version:         '1.0.0',
+          previousVersion: '0.9.0',
+        });
+
+        const origConfig = ctx.manager.config.app;
+        ctx.manager.config.app = { ...origConfig, version: '1.0.0' };
+
+        try {
+          ctx.manager.appState._initialized = false;
+          await ctx.manager.appState.initialize(ctx.manager);
+
+          ctx.expect(ctx.manager.appState.wasUpgraded()).toBe(false);
+          // Should preserve the historical previousVersion rather than nuking it.
+          ctx.expect(ctx.manager.appState.getPreviousVersion()).toBe('0.9.0');
+        } finally {
+          ctx.manager.config.app = origConfig;
+        }
+      },
+    },
+    {
+      name: 'launchedFromDeepLink: defaults false, set/cleared via setter',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.appState.launchedFromDeepLink()).toBe(false);
+        ctx.manager.appState.setLaunchedFromDeepLink(true);
+        ctx.expect(ctx.manager.appState.launchedFromDeepLink()).toBe(true);
+        ctx.manager.appState.setLaunchedFromDeepLink(false);
+        ctx.expect(ctx.manager.appState.launchedFromDeepLink()).toBe(false);
+      },
+    },
+    {
+      name: 'launchedAtLogin returns a boolean',
+      run: (ctx) => {
+        ctx.expect(typeof ctx.manager.appState.launchedAtLogin()).toBe('boolean');
+      },
+    },
+    {
+      name: 'getLastQuitAt reads live storage (returns null when sentinel is active)',
+      run: async (ctx) => {
+        ctx.manager.appState.reset();
+        ctx.manager.appState._initialized = false;
+        await ctx.manager.appState.initialize(ctx.manager);
+        // After init, sentinel=true and lastQuitAt=null.
+        ctx.expect(ctx.manager.appState.getLastQuitAt()).toBeNull();
+      },
+    },
+    {
+      name: 'reset() wipes persisted state',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.storage.has(STORAGE_KEY)).toBe(true);
+        ctx.manager.appState.reset();
+        ctx.expect(ctx.manager.storage.has(STORAGE_KEY)).toBe(false);
+      },
+    },
+  ],
+});

package/dist/test/suites/main/auth-flow.test.js

@@ -0,0 +1,196 @@
+// Main-process tests for lib/auth-flow.js — the openAuthFlow() sign-in round trip.
+// The dev loopback listener is REAL (http server on 127.0.0.1, real GETs simulate the
+// browser's redirect back); only the pieces that would leave the machine are stubbed
+// (shell.openExternal, omega.handleAuthToken, windows.get's show/focus surface).
+
+const http = require('http');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+// Minimal GET helper — resolves { status, body }.
+function get(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, (res) => {
+      let body = '';
+      res.on('data', (c) => { body += c; });
+      res.on('end', () => resolve({ status: res.statusCode, body }));
+    }).on('error', reject);
+  });
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// Stub the externals for one test body. Returns { opened, tokens, shown, restore }.
+function stubExternals(ctx) {
+  const electron = require('electron');
+  const opened = [];
+  const tokens = [];
+  const shown = [];
+  const origOpen = electron.shell.openExternal;
+  const origHandle = ctx.manager.omega.handleAuthToken;
+  const origShow = ctx.manager.windows.show;
+  electron.shell.openExternal = async (url) => { opened.push(url); };
+  ctx.manager.omega.handleAuthToken = (t) => { tokens.push(t); };
+  ctx.manager.windows.show = (name) => { shown.push(name); };
+  return {
+    opened,
+    tokens,
+    shown,
+    restore() {
+      electron.shell.openExternal = origOpen;
+      ctx.manager.omega.handleAuthToken = origHandle;
+      ctx.manager.windows.show = origShow;
+      ctx.manager.authFlow.cancel();
+    },
+  };
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'auth-flow (main)',
+  tests: [
+    {
+      name: 'initialize ran during boot',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.authFlow._initialized).toBe(true);
+      },
+    },
+    {
+      name: 'dev open(): binds a loopback listener and opens the chain ending at it',
+      run: async (ctx) => {
+        const stubs = stubExternals(ctx);
+        try {
+          const { url, port } = await ctx.manager.openAuthFlow();
+          ctx.expect(typeof port).toBe('number');
+          ctx.expect(stubs.opened[0]).toBe(url);
+
+          // Decompose: /signin → /token → http://127.0.0.1:<port>/auth/token?state=<nonce>
+          const signin = new URL(url);
+          ctx.expect(signin.pathname).toBe('/signin');
+          const tokenUrl = new URL(signin.searchParams.get('authReturnUrl'));
+          ctx.expect(tokenUrl.pathname).toBe('/token');
+          const returnUrl = new URL(tokenUrl.searchParams.get('authReturnUrl'));
+          ctx.expect(returnUrl.hostname).toBe('127.0.0.1');
+          ctx.expect(Number(returnUrl.port)).toBe(port);
+          ctx.expect(returnUrl.pathname).toBe('/auth/token');
+          ctx.expect(returnUrl.searchParams.get('state')).toBe(ctx.manager.authFlow._pending.nonce);
+        } finally {
+          stubs.restore();
+        }
+      },
+    },
+    {
+      name: 'valid browser return: 200 page, token → handleAuthToken, listener torn down, app surfaced',
+      run: async (ctx) => {
+        const stubs = stubExternals(ctx);
+        try {
+          const { port } = await ctx.manager.openAuthFlow();
+          const nonce = ctx.manager.authFlow._pending.nonce;
+
+          const res = await get(`http://127.0.0.1:${port}/auth/token?authToken=TOK-1&state=${nonce}`);
+          ctx.expect(res.status).toBe(200);
+          ctx.expect(res.body).toMatch(/Signed in/);
+          ctx.expect(stubs.tokens).toEqual(['TOK-1']);
+          ctx.expect(stubs.shown).toEqual(['main']);
+
+          // One-shot: the listener is gone.
+          ctx.expect(ctx.manager.authFlow._pending).toBeNull();
+          let refused = false;
+          await get(`http://127.0.0.1:${port}/auth/token?authToken=x&state=${nonce}`).catch(() => { refused = true; });
+          ctx.expect(refused).toBe(true);
+        } finally {
+          stubs.restore();
+        }
+      },
+    },
+    {
+      name: 'bad state or missing token: 400, no handleAuthToken, listener SURVIVES for the real return',
+      run: async (ctx) => {
+        const stubs = stubExternals(ctx);
+        try {
+          const { port } = await ctx.manager.openAuthFlow();
+          const nonce = ctx.manager.authFlow._pending.nonce;
+
+          const bad1 = await get(`http://127.0.0.1:${port}/auth/token?authToken=EVIL&state=wrong`);
+          ctx.expect(bad1.status).toBe(400);
+          const bad2 = await get(`http://127.0.0.1:${port}/auth/token?state=${nonce}`);
+          ctx.expect(bad2.status).toBe(400);
+          const lost = await get(`http://127.0.0.1:${port}/favicon.ico`);
+          ctx.expect(lost.status).toBe(404);
+          ctx.expect(stubs.tokens).toEqual([]);
+
+          // The legitimate return still lands.
+          const ok = await get(`http://127.0.0.1:${port}/auth/token?authToken=TOK-2&state=${nonce}`);
+          ctx.expect(ok.status).toBe(200);
+          ctx.expect(stubs.tokens).toEqual(['TOK-2']);
+        } finally {
+          stubs.restore();
+        }
+      },
+    },
+    {
+      name: 'a new open() supersedes the previous listener (single-flight)',
+      run: async (ctx) => {
+        const stubs = stubExternals(ctx);
+        try {
+          const first = await ctx.manager.openAuthFlow();
+          const second = await ctx.manager.openAuthFlow();
+
+          // The first port no longer answers (unless the OS re-issued the same port to the
+          // second listener, in which case the nonce changed anyway).
+          if (first.port !== second.port) {
+            let refused = false;
+            await get(`http://127.0.0.1:${first.port}/auth/token`).catch(() => { refused = true; });
+            ctx.expect(refused).toBe(true);
+          }
+          ctx.expect(ctx.manager.authFlow._pending.port).toBe(second.port);
+        } finally {
+          stubs.restore();
+        }
+      },
+    },
+    {
+      name: 'timeout tears the listener down; cancel() is idempotent',
+      run: async (ctx) => {
+        const stubs = stubExternals(ctx);
+        try {
+          const { port } = await ctx.manager.openAuthFlow({ timeoutMs: 50 });
+          ctx.expect(ctx.manager.authFlow._pending.port).toBe(port);
+          await sleep(150);
+          ctx.expect(ctx.manager.authFlow._pending).toBeNull();
+          ctx.manager.authFlow.cancel();
+          ctx.manager.authFlow.cancel();
+        } finally {
+          stubs.restore();
+        }
+      },
+    },
+    {
+      name: 'production open(): plain external open of getAuthUrl(), no listener',
+      run: async (ctx) => {
+        const stubs = stubExternals(ctx);
+        const m = ctx.manager;
+        const origIsProd = m.isProduction;
+        m.config.brand = m.config.brand || {};
+        const origUrl = m.config.brand.url;
+        m.isProduction = () => true;
+        m.config.brand.url = 'https://example.com';
+        try {
+          const { url, port } = await m.openAuthFlow();
+          ctx.expect(port).toBeUndefined();
+          ctx.expect(ctx.manager.authFlow._pending).toBeNull();
+          ctx.expect(stubs.opened[0]).toBe(url);
+          // Prod URL must ride the custom scheme, not a loopback return.
+          const signin = new URL(url);
+          const tokenUrl = new URL(signin.searchParams.get('authReturnUrl'));
+          const finalHop = tokenUrl.searchParams.get('authReturnUrl');
+          ctx.expect(finalHop).toBe(`${m.config.brand.id}://auth/token`);
+        } finally {
+          m.isProduction = origIsProd;
+          if (origUrl !== undefined) m.config.brand.url = origUrl; else delete m.config.brand.url;
+          stubs.restore();
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/main/auth-persistence.test.js

@@ -0,0 +1,167 @@
+// Main-process tests for lib/auth-persistence.js (pluggable session vault) and the
+// bridge's desktop:auth:account-resolved intake (renderer → main plan resolution cache).
+// The safeStorage strategy runs REAL (OS keychain + real file under userData) when
+// encryption is available in the test environment; adapter logic is covered against
+// a real in-memory strategy either way.
+
+const authPersistence = require('../../../lib/auth-persistence.js');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+function fakeStrategy() {
+  const store = new Map();
+  return {
+    name: 'fake',
+    store,
+    async available() { return true; },
+    async setItem(k, v) { store.set(k, v); },
+    async getItem(k) { return store.has(k) ? store.get(k) : null; },
+    async removeItem(k) { store.delete(k); },
+  };
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'auth-persistence (main)',
+  tests: [
+    {
+      name: 'resolve(): default is safeStorage; explicit none disables; unknown warns to null',
+      run: async (ctx) => {
+        const m = ctx.manager;
+        m.config.omega = m.config.omega || {};
+        const orig = m.config.omega.authPersistence;
+        try {
+          delete m.config.omega.authPersistence;
+          const def = await authPersistence.resolve(m);
+          // Default resolves to safeStorage when the OS vault is available, null otherwise —
+          // both are valid environments; assert it never picks something else.
+          if (def) ctx.expect(def.name).toBe('safeStorage');
+
+          m.config.omega.authPersistence = 'none';
+          ctx.expect(await authPersistence.resolve(m)).toBeNull();
+
+          m.config.omega.authPersistence = 'does-not-exist';
+          ctx.expect(await authPersistence.resolve(m)).toBeNull();
+        } finally {
+          if (orig !== undefined) m.config.omega.authPersistence = orig;
+          else delete m.config.omega.authPersistence;
+          await authPersistence.resolve(m); // restore the active strategy for later suites
+        }
+      },
+    },
+    {
+      name: 'register(): validates the strategy surface and makes it selectable',
+      run: async (ctx) => {
+        const m = ctx.manager;
+        ctx.expect(() => authPersistence.register('bad', {})).toThrow(/must implement/);
+
+        authPersistence.register('desktop-test-custom', fakeStrategy());
+        m.config.omega = m.config.omega || {};
+        const orig = m.config.omega.authPersistence;
+        try {
+          m.config.omega.authPersistence = 'desktop-test-custom';
+          const active = await authPersistence.resolve(m);
+          ctx.expect(active.name).toBe('desktop-test-custom');
+        } finally {
+          if (orig !== undefined) m.config.omega.authPersistence = orig;
+          else delete m.config.omega.authPersistence;
+          delete authPersistence._strategies['desktop-test-custom'];
+          await authPersistence.resolve(m);
+        }
+      },
+    },
+    {
+      name: 'firebase adapter: _set/_get/_remove round-trip JSON blobs over the strategy',
+      run: async (ctx) => {
+        const strategy = fakeStrategy();
+        const PersistenceClass = authPersistence.buildFirebasePersistence(strategy);
+        const p = new PersistenceClass();
+
+        ctx.expect(PersistenceClass.type).toBe('LOCAL');
+        ctx.expect(p.type).toBe('LOCAL');
+        ctx.expect(await p._isAvailable()).toBe(true);
+
+        const blob = { uid: 'u1', stsTokenManager: { refreshToken: 'rt' } };
+        await p._set('firebase:authUser:key:omega-auth', blob);
+        ctx.expect(await p._get('firebase:authUser:key:omega-auth')).toEqual(blob);
+
+        await p._remove('firebase:authUser:key:omega-auth');
+        ctx.expect(await p._get('firebase:authUser:key:omega-auth')).toBeNull();
+        ctx.expect(await p._get('never-set')).toBeNull();
+      },
+    },
+    {
+      name: 'safeStorage strategy: real encrypt/decrypt round-trip + garbage tolerance',
+      run: async (ctx) => {
+        const { safeStorage } = require('electron');
+        if (!safeStorage?.isEncryptionAvailable?.()) {
+          return; // OS vault unavailable in this environment — round-trip covered where it is
+        }
+        const s = authPersistence._strategies.safeStorage;
+        const KEY = 'desktop-test-roundtrip';
+        try {
+          await s.setItem(KEY, '{"hello":"world"}');
+          ctx.expect(await s.getItem(KEY)).toBe('{"hello":"world"}');
+
+          // On-disk value is ciphertext, not the plaintext.
+          const fs = require('fs');
+          const raw = fs.readFileSync(s._filePath(), 'utf8');
+          ctx.expect(raw.includes('hello')).toBe(false);
+
+          // Garbage ciphertext → null (treated as signed out), not a throw.
+          const map = JSON.parse(raw);
+          map[KEY] = Buffer.from('not-ciphertext').toString('base64');
+          fs.writeFileSync(s._filePath(), JSON.stringify(map));
+          ctx.expect(await s.getItem(KEY)).toBeNull();
+        } finally {
+          await s.removeItem(KEY);
+        }
+      },
+    },
+    {
+      name: 'bridge account-resolved intake: uid-guarded, cached, broadcast once per change, cleared on sign-out',
+      run: async (ctx) => {
+        const m = ctx.manager;
+        const bridge = m.omega;
+        const origAuth = bridge._firebaseAuth;
+        const origBroadcast = m.ipc.broadcast;
+        const broadcasts = [];
+        m.ipc.broadcast = (ch, payload) => { if (ch === 'desktop:auth:plan-changed') broadcasts.push(payload); };
+        try {
+          // Main signed out → any push is rejected.
+          bridge._firebaseAuth = { currentUser: null };
+          let res = await m.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', resolved: { plan: 'pro', active: true } });
+          ctx.expect(res.accepted).toBe(false);
+          ctx.expect(bridge.getResolvedPlan()).toBeNull();
+
+          // Matching uid → cached + broadcast.
+          bridge._firebaseAuth = { currentUser: { uid: 'u1', email: 'x@y.z' } };
+          res = await m.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', resolved: { plan: 'pro', active: true }, roles: { betaTester: true } });
+          ctx.expect(res.accepted).toBe(true);
+          ctx.expect(bridge.getResolvedPlan()).toEqual({ plan: 'pro', active: true });
+          ctx.expect(bridge.getResolvedRoles()).toEqual({ betaTester: true });
+          ctx.expect(broadcasts.length).toBe(1);
+
+          // Identical push → accepted but NO second broadcast.
+          await m.ipc.invoke('desktop:auth:account-resolved', { uid: 'u1', resolved: { plan: 'pro', active: true }, roles: { betaTester: true } });
+          ctx.expect(broadcasts.length).toBe(1);
+
+          // Mismatched uid (stale renderer) → dropped, cache intact.
+          res = await m.ipc.invoke('desktop:auth:account-resolved', { uid: 'other', resolved: { plan: 'max', active: true } });
+          ctx.expect(res.accepted).toBe(false);
+          ctx.expect(bridge.getResolvedPlan()).toEqual({ plan: 'pro', active: true });
+
+          // Sign-out clears the cache.
+          bridge._handleAuthStateChange(null);
+          ctx.expect(bridge.getResolvedPlan()).toBeNull();
+          ctx.expect(bridge.getResolvedRoles()).toBeNull();
+        } finally {
+          bridge._firebaseAuth = origAuth;
+          m.ipc.broadcast = origBroadcast;
+          bridge._resolvedPlan = null;
+          bridge._resolvedRoles = null;
+        }
+      },
+    },
+  ],
+});