@omega.js/desktop 0.52.0 → 0.54.0

package/dist/test/suites/build/deploy-direct.test.js

@@ -26,10 +26,10 @@ const COMMANDS = path.join(__dirname, '..', '..', '..', 'commands');
 const DEPLOY = path.join(COMMANDS, 'deploy.js');
 const WORKFLOW = path.join(__dirname, '..', '..', '..', 'defaults', '.github', 'workflows', 'build.yml');
 
-// The scripts every target gets from the scaffold, read from the one place that
-// declares them: expanding the workflow's command through THESE is what ties
+// The scripts every target gets from the scaffold, derived the one way the
+// scaffold derives them: expanding the workflow's command through THESE is what ties
 // the runner's step to the verb this laptop runs.
-const SCRIPTS = require(path.join(__dirname, '..', '..', '..', '..', 'package.json')).projectScripts;
+const SCRIPTS = require('../../../vendor/devkit/verb-scripts.js').projectScripts(require(path.join(__dirname, '..', '..', '..', '..', 'package.json')));
 
 const { directPlatform } = require(DEPLOY);
 
@@ -147,6 +147,7 @@ module.exports = defineCases({
         const resolved = require.resolve(DEPLOY);
         const cached = require.cache[resolved];
         delete require.cache[resolved];
+        const restoreTee = attachLogFile.mark();
 
         try {
           const deploy = require(resolved);
@@ -159,7 +160,7 @@ module.exports = defineCases({
           ctx.expect(ran).toEqual(['ensure-target']);
         } finally {
           // The verb tees this process' writers now (#873): hand them back.
-          attachLogFile.detach();
+          restoreTee();
           for (const restore of restores) restore();
           if (cached) require.cache[resolved] = cached;
           else delete require.cache[resolved];
@@ -206,6 +207,7 @@ module.exports = defineCases({
         const resolved = require.resolve(DEPLOY);
         const cached = require.cache[resolved];
         delete require.cache[resolved];
+        const restoreTee = attachLogFile.mark();
 
         try {
           const deploy = require(resolved);
@@ -229,7 +231,7 @@ module.exports = defineCases({
           ctx.expect(script.split(' ').filter((word) => word.startsWith('--'))).toEqual(['--local']);
         } finally {
           // The verb tees this process' writers now (#873): hand them back.
-          attachLogFile.detach();
+          restoreTee();
           deployRecord.recordDeploy = recordDeploy;
           for (const restore of restores) restore();
           if (cached) require.cache[resolved] = cached;

package/dist/test/suites/build/deploy-dispatch.test.js

@@ -108,6 +108,7 @@ async function runRelease(follower, options = {}, token = {}) {
   else process.env.GH_TOKEN = envToken;
   process.chdir(targetDir);
   delete require.cache[require.resolve(RELEASE)];
+  const restoreTee = attachLogFile.mark();
 
   let error = null;
   try {
@@ -117,7 +118,7 @@ async function runRelease(follower, options = {}, token = {}) {
   } finally {
     // The verb tees this process' writers: hand them back before the next
     // suite prints through a fixture that is about to be gone.
-    attachLogFile.detach();
+    restoreTee();
     console.log = previousLog;
     process.chdir(previousCwd);
     if (previousToken === undefined) delete process.env.GH_TOKEN;

package/dist/test/suites/build/deploy-hook.test.js

@@ -57,7 +57,7 @@ async function runDeploy(options) {
   fs.writeFileSync(path.join(tmp, 'package.json'), '{"name":"desktop-deploy-hook-test"}');
   fs.writeFileSync(
     path.join(tmp, 'hooks', 'deploy', 'pre.js'),
-    `module.exports = async (ctx) => { global.__omegaDeployHookRan.push('deploy/pre:' + (ctx.projectRoot === process.cwd() && typeof ctx.manager === 'object' && ctx.mode === 'production' ? 'ctx ok' : 'ctx wrong')); };`,
+    `module.exports = async (ctx) => { global.__omegaDeployHookRan.push('deploy/pre:' + (ctx.projectRoot === process.cwd() && typeof ctx.build === 'object' && ctx.mode === 'production' ? 'ctx ok' : 'ctx wrong')); };`,
   );
 
   const restores = [
@@ -69,10 +69,11 @@ async function runDeploy(options) {
   const origCwd = process.cwd();
 
   delete require.cache[resolved];
+  const restoreTee = attachLogFile.mark();
   global.__omegaDeployHookRan = ran;
 
   try {
-    // Required BEFORE the chdir: the verb builds its Manager at load time from
+    // Required BEFORE the chdir: the verb loads its build module at load time from
     // the real target; only the hook lookup reads cwd, at call time.
     const deploy = require(resolved);
     process.chdir(tmp);
@@ -80,7 +81,7 @@ async function runDeploy(options) {
     return ran;
   } finally {
     // The verb tees this process' writers now (#873): hand them back.
-    attachLogFile.detach();
+    restoreTee();
     process.chdir(origCwd);
     delete global.__omegaDeployHookRan;
     for (const restore of restores) restore();
@@ -116,6 +117,7 @@ async function runDriftedDeploy() {
   const origCwd = process.cwd();
 
   delete require.cache[resolved];
+  const restoreTee = attachLogFile.mark();
 
   try {
     const deploy = require(resolved);
@@ -124,7 +126,7 @@ async function runDriftedDeploy() {
     return ran;
   } finally {
     // The verb tees this process' writers now (#873): hand them back.
-    attachLogFile.detach();
+    restoreTee();
     process.chdir(origCwd);
     for (const restore of restores) restore();
     if (cached) require.cache[resolved] = cached;
@@ -139,7 +141,7 @@ module.exports = defineCases({
   description: 'deploy: the consumer\'s hooks/deploy/pre.js runs before the precheck (#899)',
   tests: [
     {
-      name: 'the hook runs after the scaffold and before the network precheck, with { manager, projectRoot, mode: production }',
+      name: 'the hook runs after the scaffold and before the network precheck, with { build, projectRoot, mode: production }',
       run: async (ctx) => {
         const ran = await runDeploy({});
         ctx.expect(ran).toEqual(['ensure-target', 'deploy/pre:ctx ok', 'precheck', 'STOP AT PRECHECK']);

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

@@ -0,0 +1,67 @@
+// Build-layer tests for the `dev` verb, what the target's `start` script runs:
+// clean, then the gulp default task (build, then launch electron), with the
+// `--` flags it was given forwarded to the gulp lane. No build-mode flag, and
+// never a shell-out back to `npm start` (that script IS this verb).
+
+const path = require('path');
+const fs   = require('fs');
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+const SRC      = path.join(__dirname, '..', '..', '..');
+const pipeline = require(path.join(SRC, 'utils', 'build-pipeline.js'));
+const dev      = require(path.join(SRC, 'commands', 'dev.js'));
+
+const stepsOf = (plan) => plan.steps.map((s) => (s.task ? `${s.type}:${s.task}` : s.type));
+
+module.exports = defineCases({
+  type: 'suite',
+  layer: 'build',
+  description: 'dev verb: clean, then the gulp default task',
+  tests: [
+    {
+      name: 'dev: clean → gulp default, no build-mode flag',
+      run: (ctx) => {
+        const plan = dev.plan({}, []);
+        ctx.expect(stepsOf(plan)).toEqual(['clean', 'gulp:default']);
+        ctx.expect(plan.env.OMEGA_BUILD_MODE).toBe(undefined);
+      },
+    },
+    {
+      name: 'dev forwards its `--` flags to the gulp lane (`npm start -- --remote-debugging-port=9222`)',
+      run: (ctx) => {
+        const plan = dev.plan({}, ['dev', '--remote-debugging-port=9222', 'stray', '--debug']);
+        ctx.expect(plan.steps[1].args).toEqual(['--remote-debugging-port=9222', '--debug']);
+        ctx.expect(pipeline.gulpCommand('default', plan.steps[1].args))
+          .toBe('npm run gulp -- default --remote-debugging-port=9222 --debug');
+      },
+    },
+    {
+      name: 'runPipeline runs the dev plan in order and leaves the build-mode flag unset',
+      run: async (ctx) => {
+        const log = [];
+        const record = (type) => (options, step) => { log.push(step.task ? `${type}:${step.task}` : type); };
+        const previous = process.env.OMEGA_BUILD_MODE;
+        delete process.env.OMEGA_BUILD_MODE;
+        try {
+          await pipeline.runPipeline(dev.plan({}, []), {}, { clean: record('clean'), gulp: record('gulp') });
+          ctx.expect(process.env.OMEGA_BUILD_MODE).toBe(undefined);
+        } finally {
+          if (previous !== undefined) process.env.OMEGA_BUILD_MODE = previous;
+        }
+        ctx.expect(log).toEqual(['clean', 'gulp:default']);
+      },
+    },
+    {
+      name: 'the CLI answers dev and its aliases, and the verb never shells back to `npm start`',
+      run: (ctx) => {
+        const { aliases } = require(path.join(SRC, 'cli.js')).config;
+        ctx.expect(aliases.dev).toEqual(['serve', 'start', '--dev']);
+
+        const source = fs.readFileSync(path.join(SRC, 'commands', 'dev.js'), 'utf8')
+          .replace(/\/\/[^\n]*/g, '')
+          .replace(/\/\*[\s\S]*?\*\//g, '');
+        ctx.expect(/npm (run )?start/.test(source)).toBe(false);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/ensure-target.test.js

@@ -13,13 +13,13 @@ const os = require('os');
 const jetpack = require('fs-jetpack');
 
 const SRC = path.join(__dirname, '..', '..', '..');
-const Manager = require(path.join(SRC, 'build.js'));
+const build = require(path.join(SRC, 'build.js'));
 const { ensureTarget } = require(path.join(SRC, 'commands', 'lib', 'ensure-target.js'));
 const { deployPrecheck } = require(path.join(SRC, 'commands', 'lib', 'deploy-precheck.js'));
 const cli = require(path.join(SRC, 'cli.js'));
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
-const package = Manager.getPackage('main');
+const package = build.getPackage('main');
 
 // A consumer whose peer deps are already satisfied — the steady state.
 function stageConsumer(dir) {
@@ -67,7 +67,7 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'refuses a workspace root, loudly, without writing a single file (#699)',
+      name: 'refuses a workspace root, loudly, leaving its AGENTS.md and .gitignore byte-identical (#699, #973)',
       run: async (ctx) => {
         // The accident: `omega deploy` at a workspace root scaffolded a whole
         // desktop target into it — gulpfile, src/, hooks/, workflows, rewritten
@@ -78,6 +78,12 @@ module.exports = defineCases({
         manifest.workspaces = ['packages/*'];
         jetpack.write(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
         const before = jetpack.read(manifestPath);
+        // A root's hand-authored AGENTS.md and .gitignore are what the marker
+        // merge rewrites in place: `#` headings and blank lines are its comments.
+        const agentsDoc = '# Monorepo\n\n## HARD RULES\n\n1. Rule one.\n';
+        const ignoreFile = '# Dependencies\nnode_modules/\n\n# Scratch\n.temp/\n';
+        jetpack.write(path.join(tmp, 'AGENTS.md'), agentsDoc);
+        jetpack.write(path.join(tmp, '.gitignore'), ignoreFile);
 
         try {
           let refusal = null;
@@ -92,9 +98,11 @@ module.exports = defineCases({
           ctx.expect(refusal.message).toMatch(/declares "workspaces"/);
           ctx.expect(refusal.message.includes(tmp)).toBe(true);
 
-          // Nothing scaffolded, and the manifest is byte-identical.
-          ctx.expect(jetpack.list(tmp)).toEqual(['package.json']);
+          // Nothing scaffolded, and every root file is byte-identical.
+          ctx.expect(jetpack.list(tmp).sort()).toEqual(['.gitignore', 'AGENTS.md', 'package.json']);
           ctx.expect(jetpack.read(manifestPath)).toBe(before);
+          ctx.expect(jetpack.read(path.join(tmp, 'AGENTS.md'))).toBe(agentsDoc);
+          ctx.expect(jetpack.read(path.join(tmp, '.gitignore'))).toBe(ignoreFile);
         } finally {
           fs.rmSync(tmp, { recursive: true, force: true });
         }

package/dist/test/suites/build/env-delivery.test.js

@@ -19,13 +19,13 @@ const { publishSecretKeys, bakeKeys, renderSecretsBlock, WORKFLOW_OWNED_KEYS } =
 const { composeTargetEnv } = require('../../../vendor/config/index.js');
 
 const SRC = path.join(__dirname, '..', '..', '..');
-const Manager = require(path.join(SRC, 'build.js'));
+const build = require(path.join(SRC, 'build.js'));
 const { ensureTarget } = require(path.join(SRC, 'commands', 'lib', 'ensure-target.js'));
 const bundleTask = require(path.join(SRC, 'gulp', 'tasks', 'bundle.js'));
 const { collectTargetSecrets } = require('../../../vendor/devkit/target-secrets.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
 
-const package = Manager.getPackage('main');
+const package = build.getPackage('main');
 
 /** A consumer whose peer deps are already satisfied — the steady state. */
 function stageConsumer() {

package/dist/test/suites/build/esm-only-dependency.test.js

@@ -4,8 +4,8 @@
 // Both Node bundles are CommonJS (`format: 'cjs'`, `platform: 'node'`), and
 // esbuild rewrites `import.meta` to `{}` in that output: a dependency doing
 // `createRequire(import.meta.url)` was handed `undefined` and threw
-// ERR_INVALID_ARG_VALUE the moment a packaged app booted (found porting an
-// electron-manager app that depends on yargs 18). @omega.js/devkit's `bundle()`
+// ERR_INVALID_ARG_VALUE the moment a packaged app booted (an app that depends
+// on yargs 18 does exactly that). @omega.js/devkit's `bundle()`
 // composes the answer for every cjs+node build, so nothing here wires it.
 //
 // The proof is a RUN, not a read of the bundle text: the fixture package

package/dist/test/suites/build/exports.test.js

@@ -3,10 +3,10 @@
 const path = require('path');
 const fs = require('fs');
 
-const Manager = require('../../../build.js');
+const build = require('../../../build.js');
 const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-const pkg = Manager.getPackage('main');
-const root = Manager.getRootPath('main');
+const pkg = build.getPackage('main');
+const root = build.getRootPath('main');
 
 module.exports = defineCases({
   type: 'group',
@@ -28,13 +28,14 @@ module.exports = defineCases({
       },
     },
     {
-      name: 'main / renderer / preload / build all loadable',
+      // main and preload load anywhere and export their instance; the renderer
+      // needs its preload's window.desktop, so omega.test.js loads it with one
+      name: 'main / preload / build all loadable',
       run: (ctx) => {
         const fromDist = (subpath) => path.join(root, 'dist', subpath);
-        ctx.expect(typeof require(fromDist('main.js'))).toBe('function');
-        ctx.expect(typeof require(fromDist('renderer.js'))).toBe('function');
-        ctx.expect(typeof require(fromDist('preload.js'))).toBe('function');
-        ctx.expect(typeof require(fromDist('build.js'))).toBe('function');
+        ctx.expect(typeof require(fromDist('main.js'))).toBe('object');
+        ctx.expect(typeof require(fromDist('preload.js'))).toBe('object');
+        ctx.expect(typeof require(fromDist('build.js'))).toBe('object');
       },
     },
     {

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

@@ -1,4 +1,4 @@
-// Build-layer tests for Manager.getConfig() — omega.json5 resolution + derived defaults.
+// Build-layer tests for build.getConfig() — omega.json5 resolution + derived defaults.
 // Stages a temp consumer dir with a config/omega.json5, sets process.cwd()
 // at it, and asserts the resolution + derivation rules.
 
@@ -43,8 +43,8 @@ function loadConfigInDir(dir) {
   }
   try {
     process.chdir(dir);
-    const Manager = require(path.join(__dirname, '..', '..', '..', 'build.js'));
-    return Manager.getConfig();
+    const build = require(path.join(__dirname, '..', '..', '..', 'build.js'));
+    return build.getConfig();
   } finally {
     process.chdir(oldCwd);
   }
@@ -53,7 +53,7 @@ function loadConfigInDir(dir) {
 module.exports = defineCases({
   type: 'suite',
   layer: 'build',
-  description: 'Manager.getConfig — omega.json5 resolution + derived defaults',
+  description: 'build.getConfig — omega.json5 resolution + derived defaults',
   tests: [
     {
       name: 'derives appId from the BRAND: reverse-domain of brand.url, else app.<brand.id> (friction #18)',

package/dist/test/suites/build/manifest-deps.test.js

@@ -24,7 +24,7 @@ const SOURCE_DIRS = ['lib', 'gulp'];
 // The two specifiers that are ALLOWED to be undeclared, each one required inside a
 // try/catch whose catch is the documented behaviour, not a crash:
 //   firebase        @omega.js/client's own dependency; the client bridge falls back
-//                   to no-op mode when it is not there (lib/client-bridge.js)
+//                   to no-op mode when it is not there (lib/auth.js)
 //   app-builder-bin electron-builder's own dependency; blockmap generation is
 //                   best-effort and warns-and-skips (lib/sign-helpers/update-info.js)
 const GUARDED = new Set(['firebase', 'app-builder-bin']);

package/dist/test/suites/build/merge-line-files.test.js

@@ -1,5 +1,5 @@
 // Build-layer tests for utils/merge-line-files.js — verify the .env / .gitignore merge convention
-// (BXM/UJM-style Default + Custom sections) AND the double-quote normalization for .env values.
+// (Default + Custom sections) AND the double-quote normalization for .env values.
 
 const path = require('path');
 const { mergeLineBasedFiles, normalizeEnvLine, DEFAULT_MARKER, CUSTOM_MARKER } =
@@ -222,17 +222,17 @@ ${CUSTOM_MARKER}
       },
     },
     {
-      name: 'normalizeEnvLine: empty value stays unquoted',
+      name: 'normalizeEnvLine: an empty value becomes KEY=""',
       run: (ctx) => {
-        ctx.expect(normalizeEnvLine('KEY=')).toBe('KEY=');
-        ctx.expect(normalizeEnvLine('KEY=   ')).toBe('KEY=');
+        ctx.expect(normalizeEnvLine('KEY=')).toBe('KEY=""');
+        ctx.expect(normalizeEnvLine('KEY=   ')).toBe('KEY=""');
       },
     },
     {
-      name: 'normalizeEnvLine: escapes embedded double quotes and backslashes',
+      name: 'normalizeEnvLine: keeps embedded quotes and backslashes as dotenv reads them',
       run: (ctx) => {
-        ctx.expect(normalizeEnvLine('KEY=he said "hi"')).toBe('KEY="he said \\"hi\\""');
-        ctx.expect(normalizeEnvLine('KEY=back\\slash')).toBe('KEY="back\\\\slash"');
+        ctx.expect(normalizeEnvLine('KEY=he said "hi"')).toBe('KEY="he said "hi""');
+        ctx.expect(normalizeEnvLine('KEY=back\\slash')).toBe('KEY="back\\slash"');
       },
     },
     {

package/dist/test/suites/build/migrate.test.js

@@ -0,0 +1,29 @@
+// migrateTarget: the desktop leg of the brand root's `omega migrate`. Desktop
+// carries no legacy move today, yet exposes the same entry as every framework,
+// so the manager's walk never special-cases a framework name.
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const SRC = path.join(__dirname, '..', '..', '..');
+const { migrateTarget } = require(path.join(SRC, 'commands', 'lib', 'migrate.js'));
+const defineCases = require('../../../vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  type: 'group',
+  layer: 'build',
+  description: 'migrateTarget: the desktop leg answers the shared shape, empty',
+  tests: [
+    {
+      name: 'report mode and execute both answer three empty lists',
+      run: (ctx) => {
+        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-migrate-'));
+
+        ctx.expect(migrateTarget(tmp)).toEqual({ due: [], changed: [], errors: [] });
+        ctx.expect(migrateTarget(tmp, { execute: true })).toEqual({ due: [], changed: [], errors: [] });
+        ctx.expect(fs.readdirSync(tmp)).toEqual([]);
+      },
+    },
+  ],
+});

package/dist/test/suites/build/omega-shell.test.js

@@ -39,8 +39,40 @@ module.exports = defineCases({
         ctx.expect(module.includes('data-shell-toggle')).toBe(true);
         ctx.expect(module.includes('data-shell-dismiss')).toBe(true);
         ctx.expect(module.includes("'shell.collapsed'")).toBe(true);
-        // client is a runtime dependency, so the specifier survives vendoring.
-        ctx.expect(module.includes("from '@omega.js/client'")).toBe(true);
+        // The shell is built FROM the runtime instance it is handed, so the
+        // vendored copy imports no runtime of its own.
+        ctx.expect(module.includes('export function createShell(omega)')).toBe(true);
+        ctx.expect(module.includes('@omega.js/client')).toBe(false);
+      },
+    },
+    {
+      // The renderer builds `omega.shell` from ITSELF, exactly as web's runtime
+      // does (`this.shell = createShell(this)`), off the vendored module
+      name: 'the renderer builds omega.shell with createShell(omega)',
+      run: (ctx) => {
+        const renderer = fs.readFileSync(path.join(PACKAGE_ROOT, 'dist', 'renderer.js'), 'utf8');
+        ctx.expect(renderer.includes("const { createShell } = require('./assets/js/core/app-shell.js');")).toBe(true);
+        ctx.expect(renderer.includes('this.shell = createShell(this);')).toBe(true);
+      },
+    },
+    {
+      // The same function object the renderer calls, and it builds the shell API
+      // off the instance's storage (an inert API when the page carries no shell)
+      name: 'createShell(omega) returns the shell API off the instance it is handed',
+      run: (ctx) => {
+        const { createShell } = require(path.join(PACKAGE_ROOT, 'dist', 'assets', 'js', 'core', 'app-shell.js'));
+        const savedDocument = globalThis.document;
+        globalThis.document = { querySelector: () => null };
+        try {
+          const shell = createShell({ storage: { get: () => null, set: () => {} } });
+          for (const name of ['isCollapsed', 'isOpen', 'setCollapsed', 'setOpen', 'toggleCollapsed', 'toggleOpen']) {
+            ctx.expect(typeof shell[name]).toBe('function');
+          }
+          ctx.expect(shell.isCollapsed()).toBe(false);
+        } finally {
+          if (savedDocument === undefined) delete globalThis.document;
+          else globalThis.document = savedDocument;
+        }
       },
     },
     {