@omega.js/desktop 0.1.0

package/dist/test/suites/build/validate-config.test.js

@@ -0,0 +1,90 @@
+// Build-layer tests for config validation via @omega.js/config — @omega.js/desktop's integration
+// surface only. The engine semantics (required/type/match/enum, conditional required,
+// secrets, targets sanity) are deep-tested in the config package's own suite; here we
+// prove the vendored package loads from dist, the desktop refinements apply, and the
+// shipped defaults stay compatible with the shared schema.
+
+const { validateConfig, runSchema, formatErrors, loadConfig } = require('../../../vendor/config/index.js');
+
+const path = require('path');
+const Manager = require('../../../build.js');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+const root = Manager.getRootPath('main');
+
+// Minimal "good" config — passes every required check.
+const VALID = {
+  brand: { id: 'myapp', name: 'MyApp' },
+};
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'config validation — @omega.js/config integration',
+  tests: [
+    {
+      name: 'package loads with the full validation surface',
+      run: (ctx) => {
+        ctx.expect(typeof validateConfig).toBe('function');
+        ctx.expect(typeof runSchema).toBe('function');
+        ctx.expect(typeof formatErrors).toBe('function');
+      },
+    },
+    {
+      name: 'minimal valid config passes the shared schema',
+      run: (ctx) => {
+        const { errors } = validateConfig(VALID, { target: 'desktop' });
+        ctx.expect(errors).toEqual([]);
+      },
+    },
+    {
+      name: 'missing brand.id / brand.name are reported',
+      run: (ctx) => {
+        const { errors } = validateConfig({}, { target: 'desktop' });
+        ctx.expect(errors.some((e) => e.includes('brand.id is required'))).toBe(true);
+        ctx.expect(errors.some((e) => e.includes('brand.name is required'))).toBe(true);
+      },
+    },
+    {
+      name: 'desktop refinements apply only with target: desktop',
+      run: (ctx) => {
+        const cfg = { ...VALID, startup: { mode: 'tray-only' } };
+        // Without a target, startup.mode is just an unknown key — silent.
+        ctx.expect(validateConfig(cfg).errors).toEqual([]);
+        // With the desktop target, the enum refinement fires.
+        const { errors } = validateConfig(cfg, { target: 'desktop' });
+        ctx.expect(errors.some((e) => e.includes('startup.mode') && e.includes('not allowed'))).toBe(true);
+      },
+    },
+    {
+      name: 'platforms.win.signing.strategy enum enforced under desktop',
+      run: (ctx) => {
+        const cfg = { ...VALID, platforms: { win: { signing: { strategy: 'banana' } } } };
+        const { errors } = validateConfig(cfg, { target: 'desktop' });
+        ctx.expect(errors.some((e) => e.includes('platforms.win.signing.strategy'))).toBe(true);
+      },
+    },
+    {
+      name: 'secret-shaped keys are validation errors',
+      run: (ctx) => {
+        const { errors } = validateConfig({ ...VALID, updaterSecret: 'x' }, { target: 'desktop' });
+        ctx.expect(errors.some((e) => e.includes('looks like a secret'))).toBe(true);
+      },
+    },
+    {
+      name: 'formatErrors renders a numbered block',
+      run: (ctx) => {
+        ctx.expect(formatErrors([])).toBe('');
+        ctx.expect(formatErrors(['a', 'b'])).toBe('  1. a\n  2. b');
+      },
+    },
+    {
+      name: '@omega.js/desktop shipped defaults resolve + validate clean for desktop',
+      run: (ctx) => {
+        // Anything failing here means our defaults are incompatible with the shared schema.
+        const { errors, enabled } = loadConfig(path.join(root, 'dist', 'defaults'), 'desktop');
+        ctx.expect(errors).toEqual([]);
+        ctx.expect(enabled).toBe(true);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/verb-logs.test.js

@@ -0,0 +1,43 @@
+// Build-layer test for the verb log lane (#197): `omega test` tees its whole
+// run to <projectRoot>/logs/test.log, ANSI-stripped.
+//
+// This is the integration pin, and it needs no fixture: THIS process IS the
+// `omega test` run, so a line written from here must already be in the file the
+// verb opened. That also guards the regression the isolated-tee fix was for —
+// a suite that clobbers the singleton mid-run would leave the marker (written
+// after those suites) out of the file.
+
+const path = require('path');
+const fs   = require('fs');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'verb logs — the live run is teed to logs/test.log',
+  tests: [
+    {
+      name: 'the running `omega test` writes this line to logs/test.log, ANSI stripped',
+      run: (ctx) => {
+        // The tee deliberately declines under a runner (the runner captures its
+        // own output and wants no logs/ left in the workspace).
+        if (process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true') {
+          ctx.skip('the tee is a no-op in CI by design');
+          return;
+        }
+
+        const logPath = path.join(process.cwd(), 'logs', 'test.log');
+        ctx.expect(fs.existsSync(logPath)).toBe(true);
+
+        // Colored on the terminal; the file must hold the bare text.
+        const marker = `verb-log marker ${process.pid}`;
+        console.log(`\x1B[36m${marker}\x1B[0m`);
+
+        const line = fs.readFileSync(logPath, 'utf8')
+          .split('\n')
+          .find((entry) => entry.includes(marker));
+        ctx.expect(line).toBe(marker);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/wave5-pins.test.js

@@ -0,0 +1,35 @@
+// Source pins for wave-5 fixes whose behavior lives behind Electron SDK
+// surfaces the build layer can't execute (contextBridge). The renderer-layer
+// suite proves the HARNESS mirror; these pin the PRODUCTION sources.
+
+const path = require('path');
+const fs = require('fs');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const SRC = path.join(__dirname, '..', '..', '..');
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'wave-5 source pins (desktop)',
+  tests: [
+    {
+      // wave-5 F4: ipc.on returned ipcRenderer (useless across the bridge)
+      // and never tracked the wrapped handler.
+      name: 'preload ipc.on returns an unsubscribe closure over removeListener',
+      run: (ctx) => {
+        const source = fs.readFileSync(path.join(SRC, 'preload.js'), 'utf8');
+        const ipcBlock = source.slice(source.indexOf('ipc: {'), source.indexOf('storage: {'));
+        ctx.expect(ipcBlock.includes('removeListener(channel, wrapped)')).toBe(true);
+      },
+    },
+    {
+      // wave-5 F1: main.js must release the deep-link boot queue after full init.
+      name: 'main.js drains the deep-link boot queue via markManagerReady()',
+      run: (ctx) => {
+        const source = fs.readFileSync(path.join(SRC, 'main.js'), 'utf8');
+        ctx.expect(source.includes('deepLink.markManagerReady()')).toBe(true);
+      },
+    },
+  ],
+});

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

@@ -0,0 +1,364 @@
+// Main-layer tests for lib/analytics.js — disabled-without-creds path,
+// uuidv5 cross-platform identity, event-name normalization, queueing,
+// auth-bridge user_id flipping, IPC handlers.
+
+const { v5: uuidv5 } = require('uuid');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+async function reinit(ctx, env, configOverrides) {
+  ctx.manager.analytics.shutdown();
+  const saved = {
+    GOOGLE_ANALYTICS_SECRET: process.env.GOOGLE_ANALYTICS_SECRET,
+  };
+  for (const [k, v] of Object.entries(env || {})) {
+    if (v == null) delete process.env[k];
+    else process.env[k] = v;
+  }
+  const cfgOrig = ctx.manager.config.analytics;
+  if (configOverrides !== undefined) {
+    ctx.manager.config.analytics = configOverrides;
+  }
+  ctx.manager.analytics.initialize(ctx.manager);
+  return () => {
+    ctx.manager.analytics.shutdown();
+    for (const [k, v] of Object.entries(saved)) {
+      if (v == null) delete process.env[k];
+      else process.env[k] = v;
+    }
+    ctx.manager.config.analytics = cfgOrig;
+    ctx.manager.analytics.initialize(ctx.manager);
+  };
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'main',
+  description: 'analytics (main)',
+  cleanup: async (ctx) => {
+    ctx.manager.analytics.shutdown();
+    delete process.env.GOOGLE_ANALYTICS_SECRET;
+    ctx.manager.analytics.initialize(ctx.manager);
+  },
+  tests: [
+    {
+      name: 'analytics module wired on manager',
+      run: (ctx) => {
+        ctx.expect(ctx.manager.analytics).toBeDefined();
+      },
+    },
+    {
+      name: 'enabled=false: short-circuits, no measurementId, no clientId',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, {}, { enabled: false });
+        try {
+          ctx.expect(ctx.manager.analytics._enabled).toBe(false);
+          ctx.expect(ctx.manager.analytics._clientId).toBe(null);
+        } finally { await restore(); }
+      },
+    },
+    {
+      name: 'no measurement ID: disabled with warning, no clientId',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: '' } },
+        });
+        try {
+          ctx.expect(ctx.manager.analytics._enabled).toBe(false);
+        } finally { await restore(); }
+      },
+    },
+    {
+      name: 'no API secret: disabled (matches @omega.js/backend env-var convention)',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: null }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          ctx.expect(ctx.manager.analytics._enabled).toBe(false);
+        } finally { await restore(); }
+      },
+    },
+    {
+      name: 'fully configured: enabled, has clientId (uuidv5 of deviceId)',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          ctx.expect(ctx.manager.analytics._enabled).toBe(true);
+          ctx.expect(typeof ctx.manager.analytics._clientId).toBe('string');
+          ctx.expect(ctx.manager.analytics._clientId.length).toBe(36);
+          // Confirm it's a stable derivation: same deviceId + same namespace should
+          // produce the same uuidv5 every time.
+          const ns = ctx.manager.analytics._namespace;
+          const deviceId = ctx.manager.context.session.deviceId;
+          ctx.expect(ctx.manager.analytics._clientId).toBe(uuidv5(deviceId, ns));
+        } finally { await restore(); }
+      },
+    },
+    {
+      // #396: a missing deviceId is a broken boot order, never a runtime
+      // condition — an id minted here would persist nowhere and make every
+      // launch a new GA client, so initialize raises instead of limping.
+      name: 'no context.session.deviceId: initialize raises (the boot-order invariant)',
+      run: async (ctx) => {
+        const savedDeviceId = ctx.manager.context.session.deviceId;
+        const savedSecret   = process.env.GOOGLE_ANALYTICS_SECRET;
+        const savedConfig   = ctx.manager.config.analytics;
+
+        ctx.manager.analytics.shutdown();
+        ctx.manager.context.session.deviceId = null;
+        process.env.GOOGLE_ANALYTICS_SECRET  = 'fake-secret';
+        ctx.manager.config.analytics = { enabled: true, providers: { google: { id: 'G-TESTID12' } } };
+
+        try {
+          await ctx.expect(() => ctx.manager.analytics.initialize(ctx.manager)).toThrow(/boot sequence/);
+        } finally {
+          ctx.manager.context.session.deviceId = savedDeviceId;
+          ctx.manager.config.analytics = savedConfig;
+          if (savedSecret == null) delete process.env.GOOGLE_ANALYTICS_SECRET;
+          else process.env.GOOGLE_ANALYTICS_SECRET = savedSecret;
+          ctx.manager.analytics.shutdown();
+          ctx.manager.analytics.initialize(ctx.manager);
+        }
+      },
+    },
+    {
+      name: 'cross-platform identity: same firebase uid → same uuidv5 across surfaces',
+      run: async (ctx) => {
+        // The whole point: @omega.js/client and @omega.js/backend seeing the same firebase uid
+        // produce identical uuidv5 outputs for user_id, given same projectId namespace.
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          const a = ctx.manager.analytics;
+          const ns = a._namespace;
+          a.setUserId('firebase-uid-abc-123');
+          const expected = uuidv5('firebase-uid-abc-123', ns);
+          ctx.expect(a._userId).toBe(expected);
+          // Re-derive from a fresh uuidv5 call — must match (deterministic).
+          ctx.expect(uuidv5('firebase-uid-abc-123', ns)).toBe(expected);
+        } finally { await restore(); }
+      },
+    },
+    {
+      // wave-5 F5: a pre-init setUserId stored _pendingUid that initialize()
+      // never read — the uid was silently discarded.
+      name: 'setUserId before initialize is applied at init (pending uid)',
+      run: async (ctx) => {
+        // Hand-rolled (not reinit()): the helper's leading shutdown() would
+        // wipe the very _pendingUid this test plants.
+        const a = ctx.manager.analytics;
+        a.shutdown(); // _namespace null — the pre-init state
+
+        a.setUserId('early-uid-before-boot');
+        ctx.expect(a._pendingUid).toBe('early-uid-before-boot');
+
+        const savedSecret = process.env.GOOGLE_ANALYTICS_SECRET;
+        process.env.GOOGLE_ANALYTICS_SECRET = 'fake-secret';
+        const cfgOrig = ctx.manager.config.analytics;
+        ctx.manager.config.analytics = { enabled: true, providers: { google: { id: 'G-TESTID12' } } };
+        try {
+          a.initialize(ctx.manager);
+          ctx.expect(a._pendingUid).toBe(null);
+          ctx.expect(a._userId).toBe(uuidv5('early-uid-before-boot', a._namespace));
+        } finally {
+          a.shutdown();
+          if (savedSecret == null) delete process.env.GOOGLE_ANALYTICS_SECRET;
+          else process.env.GOOGLE_ANALYTICS_SECRET = savedSecret;
+          ctx.manager.config.analytics = cfgOrig;
+          a.initialize(ctx.manager);
+        }
+      },
+    },
+    {
+      name: 'setUserId(null) clears user_id',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          ctx.manager.analytics.setUserId('some-uid');
+          ctx.expect(ctx.manager.analytics._userId).not.toBe(null);
+          ctx.manager.analytics.setUserId(null);
+          ctx.expect(ctx.manager.analytics._userId).toBe(null);
+        } finally { await restore(); }
+      },
+    },
+    {
+      // The catalog owns the NAME now (#328 stage E): this module no longer
+      // normalizes free-typed strings, it fires canonical events and the shared
+      // adapters decide what GA4 is told. An uncatalogued name is a programmer
+      // error — logged and skipped rather than posted as junk.
+      name: 'the shared catalog decides the name; an unknown one never posts',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+
+        const a = ctx.manager.analytics;
+        const origSend = a._send;
+        const sent = [];
+        a._send = (descriptor) => { sent.push(descriptor); return true; };
+
+        try {
+          a.event('screen_view', { screen_name: 'Settings' });
+          ctx.expect(sent.length).toBe(1);
+          ctx.expect(sent[0].provider).toBe('ga4');
+          ctx.expect(sent[0].name).toBe('screen_view');
+          ctx.expect(sent[0].payload.screen_name).toBe('Settings');
+          // The enrichment desktop still owns rides the payload
+          ctx.expect(typeof sent[0].payload.session_id).toBe('string');
+          ctx.expect(typeof sent[0].payload.engagement_time_msec).toBe('number');
+
+          sent.length = 0;
+          a.event('Hello World!', { x: 1 });
+          ctx.expect(sent.length).toBe(0);
+        } finally {
+          a._send = origSend;
+          await restore();
+        }
+      },
+    },
+    {
+      name: '_enrichParams adds session_id + engagement_time_msec',
+      run: (ctx) => {
+        const params = ctx.manager.analytics._enrichParams({ custom: 'value' });
+        ctx.expect(params.custom).toBe('value');
+        ctx.expect(typeof params.session_id).toBe('string');
+        ctx.expect(typeof params.engagement_time_msec).toBe('number');
+        ctx.expect(params.engagement_time_msec >= 1).toBe(true);
+        ctx.expect('page_location' in params).toBe(true);
+        ctx.expect('page_title' in params).toBe(true);
+      },
+    },
+    {
+      name: 'event() with disabled analytics is a no-op (no throw)',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, {}, { enabled: false });
+        try {
+          // Should not throw.
+          ctx.manager.analytics.event('app_launch', { x: 1 });
+          ctx.expect(true).toBe(true);
+        } finally { await restore(); }
+      },
+    },
+    {
+      name: 'event() before init queues, queue is bounded',
+      run: (ctx) => {
+        const a = ctx.manager.analytics;
+        a.shutdown();   // back to uninitialized state
+        a.event('queued_one');
+        a.event('queued_two');
+        ctx.expect(a._queue.length).toBe(2);
+        ctx.manager.analytics.initialize(ctx.manager);   // restore for downstream tests
+      },
+    },
+    {
+      name: 'queue flushes on init',
+      run: async (ctx) => {
+        // Force a "before init" state with a couple of queued items.
+        ctx.manager.analytics.shutdown();
+        ctx.manager.analytics._queue.push({ name: 'x', params: {} });
+        ctx.manager.analytics._queue.push({ name: 'y', params: {} });
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          // After init, queue should be drained.
+          ctx.expect(ctx.manager.analytics._queue.length).toBe(0);
+        } finally { await restore(); }
+      },
+    },
+    {
+      name: 'auth bridge: setUserId fires on auth, clears on logout',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          const a = ctx.manager.analytics;
+          // Simulate auth bridge firing.
+          a._handleAuthChange({ uid: 'user-123' });
+          ctx.expect(a._userId).not.toBe(null);
+          // Logout.
+          a._handleAuthChange({ uid: null });
+          ctx.expect(a._userId).toBe(null);
+        } finally { await restore(); }
+      },
+    },
+    {
+      name: 'setUserProperties merges into _userProperties as { value: ... }',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          ctx.manager.analytics.setUserProperties({ plan: 'premium', custom_flag: true });
+          ctx.expect(ctx.manager.analytics._userProperties.plan).toEqual({ value: 'premium' });
+          ctx.expect(ctx.manager.analytics._userProperties.custom_flag).toEqual({ value: true });
+        } finally { await restore(); }
+      },
+    },
+    {
+      name: 'IPC handler desktop:analytics:status returns the JSON snapshot',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          const snap = await ctx.manager.ipc.invoke('desktop:analytics:status');
+          ctx.expect(snap.enabled).toBe(true);
+          ctx.expect(snap.measurementId).toBe('G-TESTID12');
+        } finally { await restore(); }
+      },
+    },
+    {
+      name: 'IPC listener desktop:analytics:event routes to analytics.event',
+      run: async (ctx) => {
+        const a = ctx.manager.analytics;
+        const origEvent = a.event;
+        let captured = null;
+        a.event = (name, params) => { captured = { name, params }; };
+        try {
+          // Simulate an inbound IPC call (renderer would do ipcRenderer.send).
+          const listeners = ctx.manager.ipc._listeners?.['desktop:analytics:event'];
+          ctx.expect(listeners).toBeDefined();
+          listeners.forEach((fn) => fn({ name: 'rendererEvent', params: { x: 1 } }));
+          ctx.expect(captured).toEqual({ name: 'rendererEvent', params: { x: 1 } });
+        } finally { a.event = origEvent; }
+      },
+    },
+    {
+      name: 'toJSON exposes safe inspection state (no secret)',
+      run: async (ctx) => {
+        const restore = await reinit(ctx, { GOOGLE_ANALYTICS_SECRET: 'fake-secret' }, {
+          enabled: true,
+          providers: { google: { id: 'G-TESTID12' } },
+        });
+        try {
+          const j = ctx.manager.analytics.toJSON();
+          ctx.expect(j.enabled).toBe(true);
+          ctx.expect(j.measurementId).toBe('G-TESTID12');
+          ctx.expect(typeof j.clientId).toBe('string');
+          ctx.expect('userId' in j).toBe(true);
+          ctx.expect('queueLength' in j).toBe(true);
+          // Secret must NOT leak.
+          ctx.expect('apiSecret' in j).toBe(false);
+          ctx.expect(JSON.stringify(j).indexOf('fake-secret')).toBe(-1);
+        } finally { await restore(); }
+      },
+    },
+  ],
+});