@omega.js/desktop 0.52.0 → 0.53.0

package/dist/gulp/tasks/build-config.js

@@ -15,12 +15,12 @@ const path    = require('path');
 const jetpack = require('fs-jetpack');
 const yaml    = require('js-yaml');
 const { deepMerge, enabledFormats, desktopArtifactName, sanitizeProductName, releasesRepo } = require('../../vendor/config/index.js');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 
 const { writeMacEntitlements } = require('../../lib/sign-helpers/entitlements.js');
 const { resolveAndCopy }       = require('../../lib/sign-helpers/resolve-icons.js');
 
-const logger = Manager.logger('build-config');
+const logger = build.logger('build-config');
 
 module.exports = function buildConfig(done) {
   Promise.resolve().then(async () => {
@@ -28,7 +28,7 @@ module.exports = function buildConfig(done) {
     const distRoot    = require('../../utils/dist-root.js')(projectRoot);
     const distPath    = path.join(distRoot, 'electron-builder.yml');
 
-    const config      = Manager.getConfig();
+    const config      = build.getConfig();
     const startupMode = config.startup?.mode || 'normal';
 
     // 1. Generate entitlements.mac.plist into dist/config/. Consumer overrides live at
@@ -51,7 +51,7 @@ module.exports = function buildConfig(done) {
     // (the cp142 rehearsal catch). The framework resolves the INSTALLED
     // electron from its own module context instead.
     try {
-      builderConfig.electronVersion = Manager.require('electron/package.json').version;
+      builderConfig.electronVersion = require('electron/package.json').version;
       logger.log(`electronVersion → ${builderConfig.electronVersion} (resolved from the installed electron)`);
     } catch (error) {
       logger.log('electronVersion not injected (electron unresolved) — electron-builder falls back to its own detection');
@@ -160,11 +160,11 @@ function expandYear(str) {
 // test assertions).
 function baseConfig(config, extras = {}) {
   // Seed `app` + `brand` so callers (including tests passing bare {}) can deref without
-  // optional-chaining at every site. Matches Manager.getConfig()'s own seeding.
+  // optional-chaining at every site. Matches build.getConfig()'s own seeding.
   config.app   = config.app   || {};
   config.brand = config.brand || {};
 
-  // Manager.getConfig() derives appId from the brand url/id; the literal here
+  // build.getConfig() derives appId from the brand url/id; the literal here
   // only backstops bare test configs. Copyright derives from the BRAND, never
   // a hardcoded company (friction #18).
   const appId       = config.app.appId       || 'app.omega.consumer';
@@ -444,13 +444,13 @@ function baseConfig(config, extras = {}) {
  *
  * @param {object} arch - The resolved per-platform arch lists (`{ mac, linux }`).
  * @param {object} [options]
- * @param {object} [options.mode] - The Manager's mode (`{ build, publish, … }`).
+ * @param {object} [options.mode] - The build module's mode (`{ build, publish, … }`).
  * @param {object} [options.logger] - Logger with `warn` (default: this task's).
  * @throws {Error} in build/publish mode, naming the offending config key.
  */
 function assertArchRules(arch, options) {
   options = options || {};
-  const mode = options.mode || Manager.getMode();
+  const mode = options.mode || build.getMode();
   const warn = (options.logger || logger).warn.bind(options.logger || logger);
 
   const violations = [];

package/dist/gulp/tasks/bundle.js

@@ -15,8 +15,8 @@
 // three entry shapes, the Electron platform/target pair, the externals, the
 // renderer's Node-builtin shim, and the OMEGA_BUILD_JSON bake.
 
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('bundle');
+const build = require('../../build.js');
+const logger = build.logger('bundle');
 const path = require('path');
 const glob = require('glob').globSync;
 const jetpack = require('fs-jetpack');
@@ -29,8 +29,8 @@ const buildJsonKit = require('../../vendor/devkit/build-json.js');
 const { emptyModulesPlugin } = require('../../vendor/devkit/empty-modules-plugin.js');
 const electronTargets = require('../../utils/electron-targets.js');
 
-const projectRoot   = Manager.getRootPath('project');
-const frameworkRoot = Manager.getRootPath();
+const projectRoot   = build.getRootPath('project');
+const frameworkRoot = build.getRootPath();
 const outputRoot    = require('../../utils/dist-root.js')(projectRoot);
 
 // The renderer runs with contextIsolation on: a browser-like environment with
@@ -73,7 +73,7 @@ function buildFacts({ pkg, mode, dev }) {
 }
 
 // The wrapper's `mode`, the same three keys on every OMEGA surface (#894).
-// Desktop's own `server` verdict stays inside the Manager, which is the only
+// Desktop's own `server` verdict stays inside the build module, which is the only
 // thing that reads it: an artifact records what it WAS BUILT as.
 function artifactMode(mode) {
   return { environment: mode.environment, build: mode.build, publish: mode.publish };
@@ -118,9 +118,9 @@ function composeClientBuildJson({ config, facts, pkg, mode, license }) {
 }
 
 module.exports = function bundleTask(done) {
-  const mode = Manager.getMode();
+  const mode = build.getMode();
   const isProd = mode.environment === 'production';
-  const config = Manager.getConfig();
+  const config = build.getConfig();
 
   // The renderer's @omega.js/client reads `config.dev` to reach the local
   // stack (N7). A renderer has no env and no filesystem walk of its own, so
@@ -149,7 +149,7 @@ module.exports = function bundleTask(done) {
   // license server (a key that cannot be answered for THROWS, which is what
   // gates a bad-key release); a dev build is keyless by definition and never
   // phones home. The answer is stamped into the build blob below.
-  const projectPackage = Manager.getPackage('project');
+  const projectPackage = build.getPackage('project');
   resolveLicenseStamp({ config, production: isProd })
     .then((license) => {
       // OMEGA_BUILD_JSON: frozen at build time. The NODE pair reads it as a
@@ -203,9 +203,9 @@ async function runBundles(buildJson, isProd) {
 
   // esbuild rejects with every error already formatted, so a failed build
   // surfaces through gulp's own callback rather than a hand-rolled reporter.
-  const results = await Promise.all(builds.map(async (build) => ({
-    name: build.name,
-    result: await bundle(build.options),
+  const results = await Promise.all(builds.map(async (entry) => ({
+    name: entry.name,
+    result: await bundle(entry.options),
   })));
 
   // The metafile is what the wrapper turns on for exactly this: what each
@@ -225,7 +225,7 @@ async function runBundles(buildJson, isProd) {
 // version they must compile for.
 function resolveTargets() {
   try {
-    return electronTargets(Manager.require('electron'), { logger });
+    return electronTargets(require('electron'), { logger });
   } catch (e) {
     logger.warn(`Could not resolve electron (${e.message}) — bundles compile with no syntax floor.`);
     return { node: null, chrome: null, electron: null };
@@ -300,13 +300,13 @@ const BAKED_SOURCE_KEYS = bakeSourceKeys('desktop');
  * @param {object} config - The target's resolved omega.json5 config.
  * @param {object} env - The build env.
  * @param {object} [options]
- * @param {object} [options.mode] - The Manager's mode (`{ build, publish, … }`).
+ * @param {object} [options.mode] - The build module's mode (`{ build, publish, … }`).
  * @param {object} [options.logger] - Logger with `warn` (default: this task's).
  * @throws {Error} in build/publish mode, naming every brand-level key and the config path that requires it.
  */
 function assertBakeRules(config, env, options) {
   options = options || {};
-  const mode = options.mode || Manager.getMode();
+  const mode = options.mode || build.getMode();
   const warn = (options.logger || logger).warn.bind(options.logger || logger);
 
   const violations = checkEnvRules(config, env, { target: 'desktop' })
@@ -469,7 +469,7 @@ function rendererBundle(shared) {
       format: 'iife',
       target: shared.targets.chrome,
       dev: shared.dev,
-      // Vendored core assets (#111) — mirrors the alias BXM/UJM use, so
+      // Vendored core assets (#111) — the same alias extension and web use, so
       // renderer code imports shared core modules by a stable name:
       //   import appShell from '__main_assets__/js/core/app-shell.js';
       alias: {
@@ -504,7 +504,7 @@ function nativeExternals() {
     'sqlite3',
   ];
 
-  const consumerPkg = Manager.getPackage('project');
+  const consumerPkg = build.getPackage('project');
   const declared = Object.assign({}, consumerPkg.dependencies || {}, consumerPkg.devDependencies || {});
 
   return Object.keys(declared).filter((name) => NATIVE.includes(name));

package/dist/gulp/tasks/defaults.js

@@ -7,13 +7,13 @@
 // tree, the locality warning. Idempotent and quiet: a converged target writes
 // nothing. The non-gulp verbs (`omega test`, `omega deploy`) call ensureTarget
 // themselves.
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('defaults');
+const build = require('../../build.js');
+const logger = build.logger('defaults');
 const { ensureTarget } = require('../../commands/lib/ensure-target.js');
 
 module.exports = async function defaults() {
   await ensureTarget({
-    projectDir: Manager.getRootPath('project'),
+    projectDir: build.getRootPath('project'),
     log: (line) => logger.log(line),
     warn: (line) => logger.warn(line),
   });

package/dist/gulp/tasks/distribute.js

@@ -1,6 +1,6 @@
 // STUB — stage consumer src/ + @omega.js/desktop dist/ into .desktop-build/ for the `bundle` task to consume.
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('distribute');
+const build = require('../../build.js');
+const logger = build.logger('distribute');
 
 module.exports = function distribute(done) {
   logger.log('distribute (stub)');

package/dist/gulp/tasks/html.js

@@ -4,7 +4,7 @@
 // Page template is FRAMEWORK-INTERNAL (`<framework>/dist/config/page-template.html`). Consumers don't ship
 // their own — every view goes through the same shell so the inset titlebar / draggable region /
 // css/js wiring stay consistent. If a consumer needs a different template they can fork via
-// `manager.windows` config, but we no longer look at `<consumer>/config/page-template.html`.
+// `omega.windows` config, but we no longer look at `<consumer>/config/page-template.html`.
 //
 // Body content is itself templated FIRST (so you can use {{ brand.name }} etc. inside the view),
 // then the result is injected into the page template's `{{ content }}` slot.
@@ -15,17 +15,17 @@
 // This lines up with the `bundle` task's entry naming so /assets/js/components/<page.name>.bundle.js
 // and /assets/css/components/<page.name>.bundle.css resolve correctly.
 
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('html');
+const build = require('../../build.js');
+const logger = build.logger('html');
 const path = require('path');
 const jetpack = require('fs-jetpack');
 
-const projectRoot = Manager.getRootPath('project');
-const packageRoot = Manager.getRootPath('main');
+const projectRoot = build.getRootPath('project');
+const packageRoot = build.getRootPath('main');
 const outputRoot  = require('../../utils/dist-root.js')(projectRoot);
 
-// We require the templating lib directly (rather than going through a Manager singleton)
-// because gulp tasks run pre-Electron, with only the build-time Manager available.
+// We require the templating lib directly (rather than going through the omega instance)
+// because gulp tasks run pre-Electron, with only the build module available.
 const templating = require('../../lib/templating.js');
 
 module.exports = function htmlTask(done) {
@@ -81,9 +81,9 @@ module.exports = function htmlTask(done) {
     const bodyContent = jetpack.read(src);
 
     // Two-pass render: first the body (so it can use {{ brand.name }} etc.), then the outer page.
-    const innerVars = templating.buildPageVars(pageName, { cacheBust }, Manager);
+    const innerVars = templating.buildPageVars(pageName, { cacheBust }, build);
     const renderedBody = templating.render(bodyContent, innerVars);
-    const outerVars = templating.buildPageVars(pageName, { cacheBust, content: renderedBody }, Manager);
+    const outerVars = templating.buildPageVars(pageName, { cacheBust, content: renderedBody }, build);
     const final = templating.render(pageTemplateContent, outerVars);
 
     const dest = path.join(outputRoot, 'views', rel);

package/dist/gulp/tasks/package-quick.js

@@ -15,9 +15,9 @@
 const path    = require('path');
 const jetpack = require('fs-jetpack');
 const yaml    = require('js-yaml');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 
-const logger = Manager.logger('package-quick');
+const logger = build.logger('package-quick');
 
 module.exports = function packageQuick(done) {
   const projectRoot = process.cwd();
@@ -29,7 +29,7 @@ module.exports = function packageQuick(done) {
 
   let builder;
   try {
-    builder = Manager.require('electron-builder');
+    builder = require('electron-builder');
   } catch (e) {
     return done(new Error(`Could not resolve electron-builder: ${e.message}`));
   }

package/dist/gulp/tasks/package.js

@@ -10,9 +10,9 @@
 
 const path    = require('path');
 const jetpack = require('fs-jetpack');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 
-const logger = Manager.logger('package');
+const logger = build.logger('package');
 
 module.exports = function packageApp(done) {
   const projectRoot = process.cwd();
@@ -25,7 +25,7 @@ module.exports = function packageApp(done) {
   // Resolve electron-builder from the consumer's node_modules first, then @omega.js/desktop's bundled one.
   let builder;
   try {
-    builder = Manager.require('electron-builder');
+    builder = require('electron-builder');
   } catch (e) {
     return done(new Error(`Could not resolve electron-builder: ${e.message}. Run \`npm i -D electron-builder\` in the consumer.`));
   }

package/dist/gulp/tasks/release.js

@@ -14,9 +14,9 @@
 
 const path    = require('path');
 const jetpack = require('fs-jetpack');
-const Manager = new (require('../../build.js'));
+const build = require('../../build.js');
 
-const logger = Manager.logger('release');
+const logger = build.logger('release');
 
 // The two warnings electron-publish prints when it uploads nothing: one per
 // release (`gitHubPublisher.getOrCreateRelease` returns null with its reason)
@@ -37,7 +37,7 @@ module.exports = function release(done) {
 
   let builder;
   try {
-    builder = Manager.require('electron-builder');
+    builder = require('electron-builder');
   } catch (e) {
     return done(new Error(`Could not resolve electron-builder: ${e.message}. Run \`npm i -D electron-builder\` in the consumer.`));
   }

package/dist/gulp/tasks/sass.js

@@ -10,21 +10,21 @@
 //   - <output-root>/assets/scss              → resolves bare 'brand' to the generated _brand.scss (#912)
 //   - <consumer>/src/assets/scss             → consumer's own modules
 
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('sass');
+const build = require('../../build.js');
+const logger = build.logger('sass');
 const path = require('path');
 const jetpack = require('fs-jetpack');
 const sass = require('sass');
 const { formatBytes } = require('../../vendor/devkit/bundle.js');
 const { composeBrandTokens, renderBrandScss } = require('../../vendor/devkit/brand-tokens.js');
 
-const projectRoot = Manager.getRootPath('project');
-const packageRoot = Manager.getRootPath('main');
+const projectRoot = build.getRootPath('project');
+const packageRoot = build.getRootPath('main');
 const outputRoot  = require('../../utils/dist-root.js')(projectRoot);
 
 module.exports = function sassTask(done) {
-  const isProd = Manager.getMode().environment === 'production';
-  const config = Manager.getConfig() || {};
+  const isProd = build.getMode().environment === 'production';
+  const config = build.getConfig() || {};
   const themeId = config.theme?.id || 'classy';
 
   // The brand partial ([#912](https://github.com/Omega-JS-Stack/omega/issues/912)):

package/dist/gulp/tasks/serve.js

@@ -4,12 +4,12 @@
 // Future passes will add: livereload websocket, watch + rebuild, renderer reload via webContents.reload(),
 // main reload via app.relaunch().
 
-const Manager = new (require('../../build.js'));
-const logger = Manager.logger('serve');
+const build = require('../../build.js');
+const logger = build.logger('serve');
 const { spawn } = require('child_process');
 const { watchEnvChain } = require('../../vendor/devkit/env-watch.js');
 
-const projectRoot = Manager.getRootPath('project');
+const projectRoot = build.getRootPath('project');
 
 module.exports = function serve(done) {
   // N7: resolve livereload (and CDP when requested) through the allocator —
@@ -22,7 +22,7 @@ module.exports = function serve(done) {
 
 async function resolveServePorts() {
   const { resolvePorts, envPort, CLASSIC_PORTS } = require('../../vendor/config/index.js');
-  const configPins = Manager.getConfig()?.ports || {};
+  const configPins = build.getConfig()?.ports || {};
 
   const wanted = { livereload: envPort('livereload') || CLASSIC_PORTS.livereload };
   const pins = {};

package/dist/hooks/notarize-artifacts.js

@@ -17,7 +17,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const Logger = require('../lib/logger');
+const Logger = require('../vendor/devkit/logger.js');
 const { submit, stapleAndProve, toolRunner } = require('./lib/notarize-tools.js');
 
 const logger = new Logger('notarize-artifacts');

package/dist/hooks/notarize.js

@@ -29,7 +29,7 @@
 const path = require('path');
 const fs   = require('fs');
 const { execute } = require('node-powertools');
-const Logger = require('../lib/logger');
+const Logger = require('../vendor/devkit/logger.js');
 const { stapleAndProve, toolRunner } = require('./lib/notarize-tools.js');
 
 const logger = new Logger('notarize');

package/dist/index.js

@@ -1,14 +1,11 @@
-// Default export — re-exports per-process Managers + version.
-// Most consumers should use the per-process subpath imports instead:
+// Default export: the build-time entry (version + the build module). Each Electron
+// process imports its own ready-made instance from its subpath instead:
 //   require('@omega.js/desktop/main')
-//   require('@omega.js/desktop/renderer')
+//   import omega from '@omega.js/desktop/renderer'
 //   require('@omega.js/desktop/preload')
 const package = require('../package.json');
 
 module.exports = {
-  version:  package.version,
-  Main:     require('./main.js'),
-  Renderer: require('./renderer.js'),
-  Preload:  require('./preload.js'),
-  Build:    require('./build.js'),
+  version: package.version,
+  build:   require('./build.js'),
 };

package/dist/lib/_environment-mixin.js

@@ -0,0 +1,50 @@
+// The main process's environment and backend-URL surface: methods mixed into
+// the `Omega` class (src/main.js) with `Object.assign(Omega.prototype, ...)`, so
+// they stay `omega.getEnvironment()`, `omega.getApiUrl()`, ... on the instance.
+
+const { getEnvironment, isDevelopment, isProduction, isTesting, getVersion } = require('../utils/mode-helpers.js');
+const { getFunctionsUrl, getApiUrl, getWebsiteUrl, getAuthUrl } = require('../utils/url-helpers.js');
+
+module.exports = {
+  // The environment surface (#817): @omega.js/config's ONE implementation,
+  // reading the process's OMEGA_ENVIRONMENT, then this instance's baked
+  // `config.environment`
+  getEnvironment() {
+    return getEnvironment.call(this);
+  },
+
+  isDevelopment() {
+    return isDevelopment.call(this);
+  },
+
+  isProduction() {
+    return isProduction.call(this);
+  },
+
+  isTesting() {
+    return isTesting.call(this);
+  },
+
+  getVersion() {
+    return getVersion();
+  },
+
+  // The backend URL helpers (utils/url-helpers.js): local in development and
+  // testing, the brand's hosts in production. `environment` overrides the
+  // running one.
+  getFunctionsUrl(environment) {
+    return getFunctionsUrl(this, environment);
+  },
+
+  getApiUrl(environment) {
+    return getApiUrl(this, environment);
+  },
+
+  getWebsiteUrl(environment) {
+    return getWebsiteUrl(this, environment);
+  },
+
+  getAuthUrl(environment, returnUrl) {
+    return getAuthUrl(this, environment, returnUrl);
+  },
+};

package/dist/lib/_lifecycle-mixin.js

@@ -0,0 +1,45 @@
+// The main process's quit/relaunch pair: methods mixed into the `Omega` class
+// (src/main.js) with `Object.assign(Omega.prototype, ...)`, so they stay
+// `omega.quit()` and `omega.relaunch()` on the instance.
+
+module.exports = {
+  // Force a real quit, bypassing per-window `hideOnClose`. Use this anywhere the
+  // app legitimately wants to exit (tray Quit, Cmd+Q from menu role:'quit',
+  // auto-updater install). Without `{ force: true }`, the close events still get
+  // trapped by hide-on-close handlers and the app stays running.
+  quit(options) {
+    options = options || {};
+
+    if (options.force) {
+      this._allowQuit = true;
+    }
+
+    try {
+      require('electron').app.quit();
+    } catch (e) { /* electron not available: no-op in test/headless */ }
+  },
+
+  // Force a relaunch: same gating as quit, but tells electron to start back up
+  // after exit. If an update has been downloaded, prefers `quitAndInstall()` so
+  // the user lands on the new version instead of the old one.
+  relaunch(options) {
+    options = options || {};
+
+    if (options.force) {
+      this._allowQuit = true;
+    }
+
+    const electron = require('electron');
+
+    // If updater downloaded a fresh build, install + relaunch via electron-updater
+    // (which calls `app.quit()` internally with the right post-quit script). Falls
+    // back to plain relaunch if updater hasn't downloaded anything.
+    const updaterStatus = this.autoUpdater.getStatus();
+    if (updaterStatus.code === 'downloaded') {
+      return this.autoUpdater.installNow();
+    }
+
+    electron.app.relaunch();
+    electron.app.quit();
+  },
+};