@omega.js/desktop 0.1.0 → 0.51.0

package/dist/test/suites/build/auth-persistence-resolve.test.js

@@ -0,0 +1,119 @@
+// Build-layer tests for lib/auth-persistence.js `resolve()`: WHICH strategy a boot
+// settles on ([#907](https://github.com/Omega-JS-Stack/omega/issues/907)).
+//
+// The managers are plain objects and `available()` is stubbed, so the production
+// default is provable with no Electron and, above all, with no call into this box's
+// OS keychain. The real-manager half lives in the main suite, which now runs under
+// the forced test-mode strategy itself.
+
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const authPersistence = require(path.join(__dirname, '..', '..', '..', 'lib', 'auth-persistence.js'));
+
+// resolve() reports on the module logger; collect the lines instead of printing
+// them into THIS run's output.
+async function capture(lines, fn) {
+  const realLog = console.log;
+  const realWarn = console.warn;
+  console.log = (...args) => lines.push(args.join(' '));
+  console.warn = (...args) => lines.push(args.join(' '));
+  try {
+    return await fn();
+  } finally {
+    console.log = realLog;
+    console.warn = realWarn;
+  }
+}
+
+// Stand in for the OS vault, counting every time the boot asks it anything.
+function stubSafeStorage() {
+  const calls = { available: 0 };
+  const strategy = authPersistence._strategies.safeStorage;
+  const original = strategy.available;
+  strategy.available = async () => { calls.available += 1; return true; };
+  return { calls, restore: () => { strategy.available = original; } };
+}
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'auth-persistence resolve(): the production default, and the test-mode override',
+  tests: [
+    {
+      name: 'a production manager with no config still picks safeStorage; an unknown name warns to null',
+      run: async (ctx) => {
+        const vault = stubSafeStorage();
+        const lines = [];
+        try {
+          const active = await capture(lines, () => authPersistence.resolve({ config: {}, isTesting: () => false }));
+          ctx.expect(active.name).toBe('safeStorage');
+          ctx.expect(vault.calls.available).toBe(1);
+
+          const unknown = await capture(lines, () => authPersistence.resolve({
+            config:    { omega: { authPersistence: 'does-not-exist' } },
+            isTesting: () => false,
+          }));
+          ctx.expect(unknown).toBeNull();
+          ctx.expect(lines.join('\n')).toMatch(/unknown authPersistence strategy "does-not-exist"/);
+        } finally {
+          vault.restore();
+          authPersistence._active = null;
+        }
+      },
+    },
+    {
+      name: 'a testing manager gets none before any config read, and the vault is never asked',
+      run: async (ctx) => {
+        const vault = stubSafeStorage();
+        const lines = [];
+        try {
+          // An explicit consumer value too: the boot layer boots the brand's REAL config.
+          const active = await capture(lines, () => authPersistence.resolve({
+            config:    { omega: { authPersistence: 'safeStorage' } },
+            isTesting: () => true,
+          }));
+          ctx.expect(active).toBeNull();
+          ctx.expect(authPersistence.getActive()).toBeNull();
+          ctx.expect(vault.calls.available).toBe(0);
+          ctx.expect(lines.join('\n')).toMatch(/auth persistence: none \(test mode\)/);
+        } finally {
+          vault.restore();
+          authPersistence._active = null;
+        }
+      },
+    },
+    {
+      name: 'the boot lane is a test run too: the lane variable answers, over the word baked into its production artifact',
+      run: async (ctx) => {
+        const { isTesting, ENVIRONMENT_VAR } = require('../../../vendor/config/environment.js');
+        const vault = stubSafeStorage();
+        const lines = [];
+        const previous = process.env[ENVIRONMENT_VAR];
+        try {
+          // What the boot lane actually looks like from in here: the app under test is
+          // the consumer's PRODUCTION bundle, so the config it booted from carries
+          // `production`. The runner spawned it with the one input, main.js leaves an
+          // explicit one alone ([#925](https://github.com/Omega-JS-Stack/omega/issues/925)),
+          // and so the real isTesting() answers the lane, not the bake.
+          process.env[ENVIRONMENT_VAR] = 'testing';
+          const manager = {
+            config:    { environment: 'production', omega: { authPersistence: 'safeStorage' } },
+            isTesting,
+          };
+          ctx.expect(manager.isTesting()).toBe(true);
+
+          const active = await capture(lines, () => authPersistence.resolve(manager));
+          ctx.expect(active).toBeNull();
+          ctx.expect(vault.calls.available).toBe(0);
+          ctx.expect(lines.join('\n')).toMatch(/auth persistence: none \(test mode\)/);
+        } finally {
+          if (previous === undefined) delete process.env[ENVIRONMENT_VAR];
+          else process.env[ENVIRONMENT_VAR] = previous;
+          vault.restore();
+          authPersistence._active = null;
+        }
+      },
+    },
+  ],
+});

package/dist/test/suites/build/auto-unlock.test.js

@@ -0,0 +1,105 @@
+// Build-layer tests for the SafeNet PIN watcher. The desktop it types into is
+// behind a driver seam, so what is proven here is the loop: the dialog is found,
+// the PIN and Enter go in, and the dialog closing (or not) is reported.
+
+const path = require('path');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const { startAutoUnlock } = require(path.join(__dirname, '..', '..', '..', 'lib', 'sign-helpers', 'auto-unlock.js'));
+
+// Milliseconds, so a case is over in well under a second.
+const FAST = { pollIntervalMs: 5, pollTimeoutMs: 500, preTypeDelayMs: 1, perCharDelayMs: 0, confirmMs: 60 };
+
+function fakeLogger() {
+  const lines = [];
+  return {
+    lines,
+    log:  (m) => lines.push(`log: ${m}`),
+    warn: (m) => lines.push(`warn: ${m}`),
+  };
+}
+
+async function waitFor(check, ms) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (check()) return;
+    await new Promise((r) => setTimeout(r, 5));
+  }
+  throw new Error(`waitFor: condition not met within ${ms}ms`);
+}
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'auto-unlock — the Token Logon watcher, typed and confirmed',
+  tests: [
+    {
+      name: 'the PIN and Enter go into the dialog, and the dialog closing is reported',
+      run: async (ctx) => {
+        const logger = fakeLogger();
+        const typed  = [];
+        let open = true;
+        const driver = {
+          findTokenLogonWindow: async () => (open ? 'Token Logon' : null),
+          typeText:   async (t) => typed.push(t),
+          pressEnter: async () => { typed.push('<Enter>'); open = false; },
+        };
+
+        const unlock = startAutoUnlock({ password: 'ab1', logger, driver, timings: FAST, platform: 'win32' });
+        await waitFor(() => logger.lines.some((l) => l.includes('dialog closed')), 2000);
+        unlock.stop();
+
+        ctx.expect(typed).toEqual(['a', 'b', '1', '<Enter>']);
+        ctx.expect(logger.lines.some((l) => l.includes('password typed + Enter pressed'))).toBe(true);
+        ctx.expect(logger.lines.some((l) => l.startsWith('warn:'))).toBe(false);
+      },
+    },
+    {
+      name: 'a dialog still open after typing is called out: the keystrokes did not reach it',
+      run: async (ctx) => {
+        // A locked console does exactly this ([#864](https://github.com/Omega-JS-Stack/omega/issues/864)):
+        // the window is enumerable, the keys land on the lock screen.
+        const logger = fakeLogger();
+        const driver = {
+          findTokenLogonWindow: async () => 'Token Logon',
+          typeText:   async () => {},
+          pressEnter: async () => {},
+        };
+
+        const unlock = startAutoUnlock({ password: 'ab1', logger, driver, timings: FAST, platform: 'win32' });
+        await waitFor(() => logger.lines.some((l) => l.includes('still open')), 2000);
+        unlock.stop();
+
+        const warning = logger.lines.find((l) => l.includes('still open'));
+        ctx.expect(warning.startsWith('warn:')).toBe(true);
+        ctx.expect(warning).toMatch(/keystrokes did not reach it/);
+        ctx.expect(warning).toMatch(/console session locked/);
+      },
+    },
+    {
+      name: 'no dialog within the poll window is a warning, and stop() ends the watch silently',
+      run: async (ctx) => {
+        const logger = fakeLogger();
+        const driver = {
+          findTokenLogonWindow: async () => null,
+          typeText:   async () => { throw new Error('nothing should be typed'); },
+          pressEnter: async () => { throw new Error('nothing should be typed'); },
+        };
+
+        startAutoUnlock({ password: 'ab1', logger, driver, timings: FAST, platform: 'win32' });
+        await waitFor(() => logger.lines.some((l) => l.includes('timed out')), 2000);
+
+        // Stopped watchers say nothing more: signtool finished on its own.
+        const quiet = fakeLogger();
+        const unlock = startAutoUnlock({ password: 'ab1', logger: quiet, driver, timings: FAST, platform: 'win32' });
+        unlock.stop();
+        await new Promise((r) => setTimeout(r, FAST.pollTimeoutMs + 50));
+        ctx.expect(quiet.lines.some((l) => l.startsWith('warn:'))).toBe(false);
+
+        // Off Windows, or with no PIN, the watcher is a no-op.
+        ctx.expect(typeof startAutoUnlock({ password: 'x', driver, platform: 'darwin' }).stop).toBe('function');
+        ctx.expect(typeof startAutoUnlock({ password: '', driver, platform: 'win32' }).stop).toBe('function');
+      },
+    },
+  ],
+});

package/dist/test/suites/build/boot-runner-timeout.test.js

@@ -0,0 +1,253 @@
+// Build-layer tests for the boot runner's budget
+// ([#907](https://github.com/Omega-JS-Stack/omega/issues/907)).
+//
+// A boot that blocks inside initialize() never reaches the harness, so the per-test
+// timeout in harness/boot-entry.js cannot fire and the spawn (which only resolved on
+// exit) hung `npx omega test` forever. The child is INJECTED here, so both verdicts
+// are provable without booting Electron: a child that never exits, and one that exits
+// the way a healthy run does.
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const { EventEmitter } = require('events');
+const jetpack = require('fs-jetpack');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const { runBootChild } = require(path.join(__dirname, '..', '..', 'runners', 'boot.js'));
+
+// A project root the runner reads its report clue from. `logLine` null writes no
+// logs/ at all, the boot that died before the logger ever opened a file.
+function seedRoot(logLine) {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-boot-budget-')));
+  if (logLine !== null) {
+    // A trailing blank line is what a log file actually ends with.
+    jetpack.write(path.join(root, 'logs', 'runtime.log'), `first line\n${logLine}\n\n`);
+  }
+  return root;
+}
+
+// The spawn seam's child: the surface runBootChild touches, and a record of every
+// signal it was sent.
+function fakeChild() {
+  const child = new EventEmitter();
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  child.signals = [];
+  child.kill = (signal) => { child.signals.push(signal || 'SIGTERM'); return true; };
+  return child;
+}
+
+// The runner reports on console.log; collect it instead of printing it into THIS run.
+async function capture(lines, fn) {
+  const realLog = console.log;
+  console.log = (line) => lines.push(String(line));
+  try {
+    return await fn();
+  } finally {
+    console.log = realLog;
+  }
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'boot runner budget: a boot with no harness output fails with a report instead of hanging',
+  tests: [
+    {
+      name: 'the budget fires: the report quotes the last runtime.log line, every boot test counts failed, the child is ended',
+      run: async (ctx) => {
+        const root = seedRoot('[@omega.js/desktop:startup] isLaunchHidden: true');
+        const specFile = path.join(root, 'spec.json');
+        jetpack.write(specFile, '{}');
+        const child = fakeChild();
+        const lines = [];
+        const started = Date.now();
+
+        const counts = await capture(lines, () => runBootChild({
+          electronBin:   '/not/spawned/electron',
+          args:          [root],
+          childEnv:      {},
+          effectiveRoot: root,
+          specFile,
+          skipEvents:    [],
+          testCount:     3,
+          spawnFn:       () => child,
+          timeoutMs:     1000,
+          killGraceMs:   20,
+        }));
+
+        // Resolved on its own timer, not at the child's leisure.
+        ctx.expect(Date.now() - started).toBeLessThan(5000);
+        ctx.expect(counts).toEqual({ passed: 0, failed: 3, skipped: 0 });
+
+        const report = lines.join('\n');
+        ctx.expect(report).toMatch(/✗ boot: no harness output after 1s/);
+        ctx.expect(report).toMatch(/last runtime\.log line: "\[@omega\.js\/desktop:startup\] isLaunchHidden: true"/);
+
+        // The child is ended, and escalated when the grace passes without it going.
+        ctx.expect(child.signals).toEqual(['SIGTERM']);
+        await sleep(60);
+        ctx.expect(child.signals).toEqual(['SIGTERM', 'SIGKILL']);
+
+        ctx.expect(fs.existsSync(specFile)).toBe(false);
+        jetpack.remove(root);
+      },
+    },
+    {
+      name: 'a missing runtime.log is reported as such, not a crash',
+      run: async (ctx) => {
+        const root = seedRoot(null);
+        const specFile = path.join(root, 'spec.json');
+        jetpack.write(specFile, '{}');
+        const child = fakeChild();
+        const lines = [];
+
+        const counts = await capture(lines, () => runBootChild({
+          electronBin:   '/not/spawned/electron',
+          args:          [root],
+          childEnv:      {},
+          effectiveRoot: root,
+          specFile,
+          skipEvents:    [],
+          testCount:     1,
+          spawnFn:       () => child,
+          timeoutMs:     20,
+          killGraceMs:   20,
+        }));
+
+        ctx.expect(counts.failed).toBe(1);
+        ctx.expect(lines.join('\n')).toMatch(/last runtime\.log line: "\(no runtime\.log\)"/);
+        jetpack.remove(root);
+      },
+    },
+    {
+      // The budget is IDLE time, never total run time: a boot suite that
+      // legitimately runs longer than the budget keeps going as long as it
+      // keeps talking, and only SILENCE for a whole budget fails the run.
+      name: 'harness output REARMS the budget, so a run past it is never killed',
+      run: async (ctx) => {
+        const root = seedRoot('[@omega.js/desktop:startup] isLaunchHidden: true');
+        const specFile = path.join(root, 'spec.json');
+        jetpack.write(specFile, '{}');
+        const child = fakeChild();
+        const lines = [];
+        const started = Date.now();
+
+        const counts = await capture(lines, async () => {
+          const pending = runBootChild({
+            electronBin:   '/not/spawned/electron',
+            args:          [root],
+            childEnv:      {},
+            effectiveRoot: root,
+            specFile,
+            skipEvents:    [],
+            testCount:     2,
+            spawnFn:       () => child,
+            timeoutMs:     400,
+            killGraceMs:   20,
+          });
+
+          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
+          await sleep(150);
+          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'a slow suite finishes', passed: true, duration: 12 })}\n`);
+          await sleep(150);
+          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'and another', passed: true, duration: 12 })}\n`);
+          await sleep(150);
+          child.emit('exit', 0);
+
+          return pending;
+        });
+
+        ctx.expect(Date.now() - started).toBeGreaterThan(400);
+        ctx.expect(counts).toEqual({ passed: 3, failed: 0, skipped: 0 });
+        ctx.expect(child.signals).toEqual([]);
+        ctx.expect(lines.join('\n').includes('no harness output')).toBe(false);
+        jetpack.remove(root);
+      },
+    },
+    {
+      // The timeout hands its counts to the caller, so a line arriving while
+      // the child is being killed must reach nothing at all: the report is
+      // already printed and the numbers already reported.
+      name: 'a line landing AFTER the timeout report changes nothing',
+      run: async (ctx) => {
+        const root = seedRoot('[@omega.js/desktop:startup] isLaunchHidden: true');
+        const specFile = path.join(root, 'spec.json');
+        jetpack.write(specFile, '{}');
+        const child = fakeChild();
+        const lines = [];
+
+        const counts = await capture(lines, async () => {
+          const settled = await runBootChild({
+            electronBin:   '/not/spawned/electron',
+            args:          [root],
+            childEnv:      {},
+            effectiveRoot: root,
+            specFile,
+            skipEvents:    [],
+            testCount:     2,
+            spawnFn:       () => child,
+            timeoutMs:     30,
+            killGraceMs:   20,
+          });
+
+          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'a late line', passed: true, duration: 12 })}\n`);
+          child.emit('exit', 0);
+          await sleep(40);
+
+          return settled;
+        });
+
+        ctx.expect(counts).toEqual({ passed: 0, failed: 2, skipped: 0 });
+        ctx.expect(lines.join('\n').includes('a late line')).toBe(false);
+        jetpack.remove(root);
+      },
+    },
+    {
+      name: 'a child that exits normally reports its results and clears the timer',
+      run: async (ctx) => {
+        const root = seedRoot('[@omega.js/desktop:startup] isLaunchHidden: true');
+        const specFile = path.join(root, 'spec.json');
+        jetpack.write(specFile, '{}');
+        const child = fakeChild();
+        const lines = [];
+
+        const counts = await capture(lines, async () => {
+          const pending = runBootChild({
+            electronBin:   '/not/spawned/electron',
+            args:          [root],
+            childEnv:      {},
+            effectiveRoot: root,
+            specFile,
+            skipEvents:    [],
+            testCount:     1,
+            spawnFn:       () => child,
+            timeoutMs:     50,
+            killGraceMs:   20,
+          });
+
+          child.stdout.emit('data', `__EM_TEST__${JSON.stringify({ event: 'result', name: 'the app boots', passed: true, duration: 12 })}\n`);
+          child.emit('exit', 0);
+
+          const settled = await pending;
+          // Past the budget: a timer the exit did not clear would report here.
+          await sleep(120);
+          return settled;
+        });
+
+        ctx.expect(counts).toEqual({ passed: 1, failed: 0, skipped: 0 });
+        ctx.expect(child.signals).toEqual([]);
+
+        const report = lines.join('\n');
+        ctx.expect(report).toMatch(/✓ the app boots/);
+        ctx.expect(report.includes('no harness output')).toBe(false);
+        jetpack.remove(root);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/brand-scss.test.js

@@ -0,0 +1,106 @@
+// Build-layer proof for the generated brand partial
+// ([#912](https://github.com/Omega-JS-Stack/omega/issues/912)): ONE hex in
+// `brand.color` decides both the compile-time accent Bootstrap derives from and
+// the runtime --omega-accent ramp, on a real fixture project through the real
+// sass task.
+//
+// Offline by construction: a temp consumer dir with a config and the scaffold's
+// own main.scss, compiled against this package's dist assets.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const jetpack = require('fs-jetpack');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const SRC = path.join(__dirname, '..', '..', '..');
+const SCAFFOLD_MAIN = path.join(SRC, 'defaults', 'src', 'assets', 'scss', 'main.scss');
+
+/** A consumer whose main.scss is the one the scaffold ships. */
+function stageConsumer(color) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-brand-scss-'));
+  const brand = color ? `{ id: "fixture", color: "${color}" }` : '{ id: "fixture" }';
+
+  jetpack.write(path.join(tmp, 'config', 'omega.json5'), `{ brand: ${brand}, targets: { desktop: {} } }`);
+  jetpack.copy(SCAFFOLD_MAIN, path.join(tmp, 'src', 'assets', 'scss', 'main.scss'));
+
+  return tmp;
+}
+
+/**
+ * Run the sass task with the fixture as the project root. Both the task and the
+ * build Manager resolve that root at REQUIRE time, so each run gets a fresh
+ * copy of both.
+ */
+function runSassIn(dir) {
+  const oldCwd = process.cwd();
+  for (const key of Object.keys(require.cache)) {
+    if (key.includes(`${path.sep}build.js`) || key.endsWith(`tasks${path.sep}sass.js`)) delete require.cache[key];
+  }
+
+  try {
+    process.chdir(dir);
+    const sassTask = require(path.join(SRC, 'gulp', 'tasks', 'sass.js'));
+    return new Promise((resolve, reject) => sassTask((error) => (error ? reject(error) : resolve())));
+  } finally {
+    process.chdir(oldCwd);
+  }
+}
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'brand scss (#912): brand.color drives $primary and the runtime accent ramp',
+  tests: [
+    {
+      name: 'brand.color writes the partial and paints the compiled bundle',
+      run: async (ctx) => {
+        const dir = stageConsumer('#ff0066');
+
+        try {
+          await runSassIn(dir);
+
+          const partial = fs.readFileSync(path.join(dir, 'dist', 'assets', 'scss', '_brand.scss'), 'utf8');
+          ctx.expect(partial.includes('$primary: #ff0066;')).toBe(true);
+
+          const css = fs.readFileSync(path.join(dir, 'dist', 'assets', 'css', 'main.bundle.css'), 'utf8');
+
+          // Bootstrap's primary compiled from the same hex...
+          ctx.expect(css.includes('--bs-primary: #ff0066')).toBe(true);
+
+          // ...and the runtime ramp, AFTER the token sheet's placeholder so it
+          // wins the cascade (a used module's css emits at its load position,
+          // which is why the scaffold includes the mixin instead).
+          ctx.expect(css.includes('--omega-accent: #ff0066')).toBe(true);
+          ctx.expect(css.includes('--omega-accent-hover: #db0058')).toBe(true);
+          ctx.expect(css.lastIndexOf('--omega-accent: #ff0066') > css.lastIndexOf('--omega-accent: #2563eb')).toBe(true);
+
+          // The dark variant rides the same stamps as the token sheet.
+          ctx.expect(/@media \(prefers-color-scheme: dark\)[\s\S]*?--omega-accent: #ff3385/.test(css)).toBe(true);
+          ctx.expect(/\[data-bs-theme=["']?dark["']?\][\s\S]*?--omega-accent: #ff3385/.test(css)).toBe(true);
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+    {
+      name: 'no brand.color compiles on the framework default',
+      run: async (ctx) => {
+        const dir = stageConsumer(null);
+
+        try {
+          await runSassIn(dir);
+
+          const partial = fs.readFileSync(path.join(dir, 'dist', 'assets', 'scss', '_brand.scss'), 'utf8');
+          ctx.expect(partial.includes('$primary: #2563eb;')).toBe(true);
+
+          const css = fs.readFileSync(path.join(dir, 'dist', 'assets', 'css', 'main.bundle.css'), 'utf8');
+          ctx.expect(css.includes('--bs-primary: #2563eb')).toBe(true);
+          ctx.expect(css.includes('--omega-accent: #2563eb')).toBe(true);
+        } finally {
+          fs.rmSync(dir, { recursive: true, force: true });
+        }
+      },
+    },
+  ],
+});