@omega.js/desktop 0.51.0 → 0.53.0

package/dist/lib/client-bridge.js

@@ -1,374 +0,0 @@
-// Client bridge — main-process Firebase Auth, source of truth for renderers.
-//
-// This is @omega.js/desktop's analogue of BXM's background-service-worker auth role. The pattern:
-//
-//   1. Main runs its own Firebase Auth instance and is the source of truth.
-//   2. When a deep-link auth/token arrives, main calls signInWithCustomToken with that token,
-//      then BROADCASTS the token to all renderer windows so their @omega.js/client Firebase
-//      instances can sign in with the SAME token.
-//   3. On every renderer load, the renderer asks main "I'm at UID X (or null)" via the
-//      desktop:auth:sync-request IPC. Main compares with its own UID and either does nothing,
-//      tells the renderer to sign out, or fetches a fresh custom token from /omega
-//      and sends it to the renderer.
-//   4. Sign-out: any renderer can request sign-out via desktop:auth:sign-out. Main signs out
-//      its own Firebase + broadcasts desktop:auth:sign-out to all renderers.
-//
-// Firebase is BUNDLED by esbuild from @omega.js/desktop's module context (@omega.js/client owns it in @omega.js/desktop's
-// tree). If loading fails, the bridge stays in no-op mode and logs the reason.
-
-const LoggerLite = require('./logger-lite.js');
-const authPersistence = require('./auth-persistence.js');
-const { requiredPort } = require('../utils/url-helpers.js');
-
-const logger = new LoggerLite('client-bridge');
-
-const FIREBASE_APP_NAME = 'omega-auth';
-
-const bridge = {
-  _initialized:    false,
-  _manager:        null,
-  _firebase:       null,    // firebase/app
-  _firebaseAuth:   null,    // auth instance
-  _firebaseModule: null,    // firebase/auth namespace (signInWithCustomToken, signOut, ...)
-  _stateSubs:      new Set(), // main-side subscribers fn(user)
-  _ipcRegistered:  false,
-  _resolvedPlan:   null,    // renderer-resolved subscription { plan, active, trialing, cancelling }
-  _resolvedRoles:  null,    // renderer-resolved account roles { admin, betaTester, ... }
-
-  async initialize(manager) {
-    if (bridge._initialized) {
-      return;
-    }
-
-    bridge._manager = manager;
-
-    // Try to load firebase. If it's not installed, run in no-op mode.
-    const ok = await bridge._tryLoadFirebase();
-    if (!ok) {
-      logger.warn('firebase not installed — client-bridge running in no-op mode. `npm i firebase` to enable auth.');
-    }
-
-    bridge._registerIpc();
-
-    if (ok) {
-      // Boot Firebase Auth. With a persistence strategy active (lib/auth-persistence.js,
-      // default safeStorage), the session survives restarts — the restore lands async
-      // via onAuthStateChanged shortly after boot.
-      try {
-        const strategy = await authPersistence.resolve(manager);
-        bridge._firebaseAuth = bridge._getFirebaseAuth(strategy);
-        // onAuthStateChanged is the source of truth listener.
-        bridge._firebaseModule.onAuthStateChanged(bridge._firebaseAuth, (user) => {
-          bridge._handleAuthStateChange(user);
-        });
-        logger.log(`initialize — firebase loaded (persistence: ${strategy ? strategy.name : 'in-memory'})`);
-      } catch (e) {
-        logger.error('firebase init failed:', e.message);
-      }
-    }
-
-    bridge._initialized = true;
-  },
-
-  // Load firebase. Returns true on success. BUNDLED by esbuild from @omega.js/desktop's module context
-  // (@omega.js/client owns firebase in @omega.js/desktop's tree) — same treatment as json5 in main.js. In the
-  // webpack era it was a webpackIgnore'd runtime import(), which resolves relative to the CONSUMER's
-  // main.bundle.js: that walk never reaches @omega.js/desktop's node_modules when @omega.js/desktop is symlinked
-  // (`mgr install dev`) and depends on npm hoisting when installed — every dev app silently
-  // ran the bridge in no-op mode. Interop guards handle both namespace shapes (json5 precedent).
-  async _tryLoadFirebase() {
-    try {
-      const appMod  = require('firebase/app');
-      const authMod = require('firebase/auth');
-
-      bridge._firebase       = appMod.initializeApp ? appMod : (appMod.default || appMod);
-      bridge._firebaseModule = authMod.getAuth      ? authMod : (authMod.default || authMod);
-      return true;
-    } catch (e) {
-      logger.warn('firebase load failed:', e.message);
-      return false;
-    }
-  },
-
-  _getFirebaseAuth(strategy) {
-    if (bridge._firebaseAuth) return bridge._firebaseAuth;
-
-    const firebaseConfig = bridge._manager.config.cloud?.config;
-    if (!firebaseConfig || !Object.keys(firebaseConfig).length) {
-      throw new Error('cloud.config is empty — cannot initialize auth.');
-    }
-
-    const { initializeApp, getApp } = bridge._firebase;
-    const { getAuth, initializeAuth } = bridge._firebaseModule;
-
-    let app;
-    try { app = getApp(FIREBASE_APP_NAME); }
-    catch (e) { app = initializeApp(firebaseConfig, FIREBASE_APP_NAME); }
-
-    // With a storage strategy, boot auth on OUR persistence (session survives
-    // restarts); without one, firebase's Node default (in-memory) applies.
-    if (strategy && initializeAuth) {
-      bridge._firebaseAuth = initializeAuth(app, {
-        persistence: [authPersistence.buildFirebasePersistence(strategy)],
-      });
-    } else {
-      bridge._firebaseAuth = getAuth(app);
-    }
-
-    // A TESTING run talks to the LOCAL stack, never real auth — the same move
-    // getApiUrl() makes when it maps testing to localhost, and the same one
-    // @omega.js/extension's background SW makes for its emulator runs. Only an
-    // OMEGA_ENVIRONMENT=testing run reaches here; dev and production are untouched.
-    if (bridge._manager.isTesting()) {
-      const { connectAuthEmulator } = bridge._firebaseModule;
-      const port = bridge._authEmulatorPort();
-      logger.log(`testing run — connecting auth to the emulator on :${port}`);
-      connectAuthEmulator(bridge._firebaseAuth, `http://localhost:${port}`, { disableWarnings: true });
-    }
-
-    return bridge._firebaseAuth;
-  },
-
-  // The auth emulator's port, on the same chain getApiUrl() walks: the
-  // resolved-port env channel (N7), then the `dev.ports` map the bundle baked
-  // into OMEGA_BUILD_JSON
-  // ([#745](https://github.com/Omega-JS-Stack/omega/issues/745)). The classic
-  // 9099 used to sit under those two as a last resort; it is gone (#834),
-  // because nothing identity-checks what answers on it and a neighbouring
-  // project's emulator reads as an auth mystery rather than a port problem.
-  _authEmulatorPort() {
-    return requiredPort(bridge._manager, 'OMEGA_AUTH_PORT', 'auth');
-  },
-
-  _registerIpc() {
-    if (bridge._ipcRegistered) return;
-    const ipc = bridge._manager.ipc;
-
-    // Renderer asks main: "I'm at UID X (or null). Are we in sync?"
-    ipc.handle('desktop:auth:sync-request', async ({ contextUid }) => {
-      return bridge._handleSyncRequest(contextUid);
-    });
-
-    // Renderer asks main to sign out.
-    ipc.handle('desktop:auth:sign-out', async () => {
-      return bridge._handleSignOut();
-    });
-
-    // Renderer asks main for the current user (uid + email + displayName, no token).
-    ipc.handle('desktop:auth:get-user', () => {
-      const u = bridge._firebaseAuth?.currentUser;
-      return u ? bridge._snapshotUser(u) : null;
-    });
-
-    // Renderer pushes its @omega.js/client account resolution (auth().listen() settled:
-    // Firestore account fetched, subscription resolved). Main can't run Firestore,
-    // so this is how main-side plan gates learn the REAL plan — BXM's "browser
-    // contexts resolve, authority caches" split. UID-guarded: a stale push from a
-    // renderer that hasn't synced yet is dropped.
-    ipc.handle('desktop:auth:account-resolved', ({ uid, resolved, roles } = {}) => {
-      const mainUid = bridge._firebaseAuth?.currentUser?.uid || null;
-      if (!uid || uid !== mainUid) {
-        return { accepted: false };
-      }
-
-      const changed = JSON.stringify(resolved) !== JSON.stringify(bridge._resolvedPlan)
-        || JSON.stringify(roles || null) !== JSON.stringify(bridge._resolvedRoles);
-      bridge._resolvedPlan  = resolved || null;
-      bridge._resolvedRoles = roles || null;
-
-      if (changed) {
-        logger.log(`account resolved — plan=${resolved?.plan || '(none)'} active=${!!resolved?.active}`);
-        bridge._manager.ipc.broadcast('desktop:auth:plan-changed', { resolved: bridge._resolvedPlan, roles: bridge._resolvedRoles });
-        // Main-side subscribers see the same user snapshot again with plan now known.
-        const u = bridge._firebaseAuth?.currentUser;
-        bridge._stateSubs.forEach((fn) => {
-          try { fn(u ? bridge._snapshotUser(u) : null); } catch (e) { logger.error('onAuthChange subscriber threw:', e); }
-        });
-      }
-      return { accepted: true };
-    });
-
-    bridge._ipcRegistered = true;
-  },
-
-  _handleAuthStateChange(user) {
-    logger.log(`auth state → ${user ? user.email : 'signed out'}`);
-
-    // Sign-out (or a different user signing in) invalidates the cached resolution —
-    // renderers re-resolve and push fresh via desktop:auth:account-resolved.
-    if (!user) {
-      bridge._resolvedPlan = null;
-      bridge._resolvedRoles = null;
-    }
-
-    // Notify any main-side subscribers (consumer code that called manager.omega.onAuthChange).
-    const snap = user ? bridge._snapshotUser(user) : null;
-    bridge._stateSubs.forEach((fn) => {
-      try { fn(snap); } catch (e) { logger.error('onAuthChange subscriber threw:', e); }
-    });
-
-    // Tell renderers about the change so they can update UI / refresh menu items.
-    bridge._manager.ipc.broadcast('desktop:auth:state-changed', snap);
-
-    // Attribute Sentry events to the signed-in user (or clear on sign-out). When
-    // sentry is disabled (no DSN, dev mode, etc.) setUser is a documented no-op.
-    bridge._manager.sentry.setUser(snap);
-  },
-
-  // BXM's syncAuth pattern, ported to Electron.
-  async _handleSyncRequest(contextUid) {
-    if (!bridge._firebaseAuth) {
-      return { needsSync: false, reason: 'firebase-not-loaded' };
-    }
-
-    const bgUser = bridge._firebaseAuth.currentUser;
-    const bgUid = bgUser?.uid || null;
-
-    // Already in sync.
-    if (contextUid === bgUid) {
-      return { needsSync: false };
-    }
-
-    // Renderer signed in but main signed out → tell renderer to sign out.
-    if (!bgUser && contextUid) {
-      return { needsSync: true, signOut: true };
-    }
-
-    // Main signed in, renderer not (or different user) → fetch a fresh custom token + send.
-    try {
-      const token = await bridge._fetchCustomToken(bgUser);
-      return {
-        needsSync: true,
-        customToken: token,
-        user: bridge._snapshotUser(bgUser),
-      };
-    } catch (e) {
-      logger.error('sync-request: failed to fetch custom token:', e.message);
-      return { needsSync: false, error: e.message };
-    }
-  },
-
-  async _handleSignOut() {
-    try {
-      if (bridge._firebaseAuth?.currentUser) {
-        await bridge._firebaseModule.signOut(bridge._firebaseAuth);
-      }
-      bridge._manager.ipc.broadcast('desktop:auth:sign-out', {});
-      return { success: true };
-    } catch (e) {
-      logger.error('sign-out failed:', e.message);
-      return { success: false, error: e.message };
-    }
-  },
-
-  // Public API ──────────────────────────────────────────────────────────────────
-
-  // Called by lib/deep-link's auth/token built-in.
-  async handleAuthToken(token) {
-    if (!bridge._firebaseAuth) {
-      logger.warn('handleAuthToken called but firebase not loaded — ignoring.');
-      return { success: false, reason: 'firebase-not-loaded' };
-    }
-    if (!token) {
-      logger.warn('handleAuthToken called with no token — ignoring.');
-      return { success: false, reason: 'no-token' };
-    }
-
-    try {
-      const cred = await bridge._firebaseModule.signInWithCustomToken(bridge._firebaseAuth, token);
-      logger.log(`signed in: ${cred.user.email || cred.user.uid}`);
-
-      // Broadcast the token to renderers so they can sign in with the SAME token.
-      // Tokens expire in 1 hour and aren't stored.
-      bridge._manager.ipc.broadcast('desktop:auth:sign-in-with-token', { token });
-
-      return { success: true, user: bridge._snapshotUser(cred.user) };
-    } catch (e) {
-      logger.error('signInWithCustomToken failed:', e.message);
-      return { success: false, error: e.message };
-    }
-  },
-
-  // Subscribe to auth state changes on the main side (e.g. for menu/tray refresh).
-  onAuthChange(fn) {
-    bridge._stateSubs.add(fn);
-    return () => bridge._stateSubs.delete(fn);
-  },
-
-  // Snapshot of the current user (sync), or null.
-  getCurrentUser() {
-    const u = bridge._firebaseAuth?.currentUser;
-    return u ? bridge._snapshotUser(u) : null;
-  },
-
-  // The renderer-resolved subscription ({ plan, active, trialing, cancelling }) or null
-  // while no renderer has resolved yet. THE main-side plan source — consumer plan gates
-  // read this (@omega.js/client's resolveSubscription output, pushed via desktop:auth:account-resolved).
-  getResolvedPlan() {
-    return bridge._resolvedPlan;
-  },
-
-  // The renderer-resolved account roles ({ admin, betaTester, ... }) or null.
-  getResolvedRoles() {
-    return bridge._resolvedRoles;
-  },
-
-  // Fresh Firebase ID token for the signed-in user (async), or null when
-  // signed out / Firebase absent. For consumer main code calling
-  // authenticated backend routes (`Authorization: Bearer <token>`).
-  async getIdToken() {
-    const u = bridge._firebaseAuth?.currentUser;
-    return u ? u.getIdToken() : null;
-  },
-
-  // Force sign-out from main code.
-  async signOut() {
-    return bridge._handleSignOut();
-  },
-
-  // ─── Internals ────────────────────────────────────────────────────────────
-
-  _snapshotUser(user) {
-    return {
-      uid:           user.uid,
-      email:         user.email,
-      displayName:   user.displayName,
-      photoURL:      user.photoURL,
-      emailVerified: user.emailVerified,
-    };
-  },
-
-  // Fetch a fresh custom token for the currently-signed-in user via the shared
-  // @omega.js/client request layer. Mirrors BXM: POST <apiUrl>/omega/user/token —
-  // the route defaults uid to the authenticated caller and responds { token }
-  // at the top level.
-  async _fetchCustomToken(user) {
-    const { createRequest } = require('@omega.js/client/modules/request.js');
-
-    const request = createRequest({
-      getApiUrl: () => bridge._manager.getApiUrl(),
-      getIdToken: (force) => user.getIdToken(force),
-    });
-
-    const data = await request('/omega/user/token', { method: 'POST', body: {} });
-
-    const token = data?.token;
-    if (!token) {
-      throw new Error('@omega.js/backend response missing token.');
-    }
-    return token;
-  },
-
-  // Tear-down used by tests — wipes state but keeps registered IPC handlers
-  // (they're idempotent via `ipc.handle` duplicate-detection).
-  async _resetForTests() {
-    try {
-      if (bridge._firebaseAuth?.currentUser && bridge._firebaseModule?.signOut) {
-        await bridge._firebaseModule.signOut(bridge._firebaseAuth);
-      }
-    } catch (e) { /* ignore */ }
-    bridge._stateSubs.clear();
-  },
-};
-
-module.exports = bridge;

package/dist/lib/logger.js

@@ -1,4 +0,0 @@
-// Shared devkit module — vendored into dist/vendor/devkit at prepare time by the
-// preparePackage `after` hook. This shim keeps the framework's internal require
-// paths stable while the implementation lives in @omega.js/devkit.
-module.exports = require('../vendor/devkit/logger.js');

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

@@ -1,213 +0,0 @@
-// Build-time tests for the Manager class (build.js).
-
-const Manager = require('../../../build.js');
-const defineCases = require('../../../vendor/devkit/test/define-cases.js');
-
-// The one input and the two lane flags that decide it, saved and restored
-// around every case that touches them (#817).
-const LANE_KEYS = ['OMEGA_ENVIRONMENT', 'OMEGA_BUILD_MODE', 'OMEGA_TEST_MODE', 'NODE_ENV'];
-
-/**
- * Run `fn` with exactly `vars` set on the lane keys (null clears them all).
- * @param {object|null} vars - the lane env for this case.
- * @param {function} fn - the body.
- * @returns {*} whatever `fn` returns.
- */
-function withEnvironment(vars, fn) {
-  const saved = {};
-  for (const key of LANE_KEYS) saved[key] = process.env[key];
-  try {
-    for (const key of LANE_KEYS) delete process.env[key];
-    Object.assign(process.env, vars || {});
-    return fn();
-  } finally {
-    for (const key of LANE_KEYS) {
-      if (saved[key] === undefined) delete process.env[key];
-      else process.env[key] = saved[key];
-    }
-  }
-}
-
-/**
- * What src/build.js resolves at LOAD for a given lane. build.js sets the input
- * once, at require time, so this loads a fresh copy of it per lane.
- * @param {object} vars - the lane env.
- * @returns {string} the resolved environment.
- */
-function laneEnvironment(vars) {
-  const buildPath = require.resolve('../../../build.js');
-  return withEnvironment(vars, () => {
-    const saved = require.cache[buildPath];
-    delete require.cache[buildPath];
-    try {
-      return require(buildPath).getEnvironment();
-    } finally {
-      if (saved) require.cache[buildPath] = saved;
-      else delete require.cache[buildPath];
-    }
-  });
-}
-
-module.exports = defineCases({
-  type: 'group', // independent tests; run all even on failure
-  layer: 'build',
-  description: 'Manager (build.js)',
-  tests: [
-    {
-      name: 'class is exported and instantiable',
-      run: (ctx) => {
-        ctx.expect(typeof Manager).toBe('function');
-        ctx.expect(new Manager()).toBeInstanceOf(Manager);
-      },
-    },
-    {
-      name: 'getMode returns the mode shape',
-      run: (ctx) => {
-        const mode = Manager.getMode();
-        ctx.expect(mode).toHaveProperty('build');
-        ctx.expect(mode).toHaveProperty('publish');
-        ctx.expect(mode).toHaveProperty('server');
-        ctx.expect(mode).toHaveProperty('environment');
-        ctx.expect(['development', 'testing', 'production']).toContain(mode.environment);
-      },
-    },
-    {
-      // The environment reads ONE input, `OMEGA_ENVIRONMENT`
-      // ([#817](https://github.com/Omega-JS-Stack/omega/issues/817)), and the
-      // lane that boots or builds this app sets it (src/build.js does, at load).
-      // Nothing sniffs NODE_ENV, app.isPackaged or OMEGA_TEST_MODE any more.
-      name: 'getEnvironment answers the one input, for each of the three names',
-      run: (ctx) => {
-        withEnvironment(null, () => {
-          for (const name of ['development', 'testing', 'production']) {
-            process.env.OMEGA_ENVIRONMENT = name;
-            ctx.expect(Manager.getEnvironment()).toBe(name);
-          }
-        });
-      },
-    },
-    {
-      // The bug this replaced: with no signal desktop's own copy answered
-      // 'production', so a plain `npm start` bundled itself as a production
-      // artifact, while @omega.js/extension's copy of the same function
-      // answered 'development' from the same inputs (#817).
-      name: 'the build lane resolves production, a dev boot resolves development',
-      run: (ctx) => {
-        const buildLane = laneEnvironment({ OMEGA_BUILD_MODE: 'true' });
-        ctx.expect(buildLane).toBe('production');
-
-        const devBoot = laneEnvironment({});
-        ctx.expect(devBoot).toBe('development');
-
-        // A lane that already named one keeps it, EXCEPT a build lane: a
-        // production build spawned from a test run still bakes production.
-        ctx.expect(laneEnvironment({ OMEGA_ENVIRONMENT: 'testing' })).toBe('testing');
-        ctx.expect(laneEnvironment({ OMEGA_ENVIRONMENT: 'testing', OMEGA_BUILD_MODE: 'true' })).toBe('production');
-      },
-    },
-    {
-      name: 'no input at all is a loud error naming OMEGA_ENVIRONMENT, never a default',
-      run: (ctx) => {
-        withEnvironment(null, () => {
-          delete process.env.OMEGA_ENVIRONMENT;
-          ctx.expect(() => Manager.getEnvironment()).toThrow(/OMEGA_ENVIRONMENT/);
-          process.env.OMEGA_ENVIRONMENT = 'staging';
-          ctx.expect(() => Manager.getEnvironment()).toThrow(/OMEGA_ENVIRONMENT/);
-        });
-      },
-    },
-    {
-      // The core invariant: is*() DERIVE from getEnvironment(), so they can
-      // NEVER disagree with it, and exactly one is always true.
-      name: 'invariant: is*() exactly matches getEnvironment() + mutually exclusive (every scenario)',
-      run: (ctx) => {
-        withEnvironment(null, () => {
-          for (const name of ['development', 'testing', 'production']) {
-            process.env.OMEGA_ENVIRONMENT = name;
-            const e = Manager.getEnvironment();
-            ctx.expect(e).toBe(name);
-            ctx.expect(Manager.isDevelopment()).toBe(e === 'development');
-            ctx.expect(Manager.isTesting()).toBe(e === 'testing');
-            ctx.expect(Manager.isProduction()).toBe(e === 'production');
-            const trueCount = [Manager.isDevelopment(), Manager.isTesting(), Manager.isProduction()].filter(Boolean).length;
-            ctx.expect(trueCount).toBe(1);
-          }
-        });
-      },
-    },
-    {
-      name: 'getPackage("main") resolves to @omega.js/desktop package.json',
-      run: (ctx) => {
-        const pkg = Manager.getPackage('main');
-        ctx.expect(pkg.name).toBe('@omega.js/desktop');
-        ctx.expect(pkg).toHaveProperty('version');
-        ctx.expect(pkg).toHaveProperty('exports');
-      },
-    },
-    {
-      name: 'getRootPath("main") returns a non-empty string',
-      run: (ctx) => {
-        const root = Manager.getRootPath('main');
-        ctx.expect(typeof root).toBe('string');
-        ctx.expect(root.length).toBeGreaterThan(0);
-      },
-    },
-    {
-      name: 'getLiveReloadPort defaults to 35729',
-      run: (ctx) => {
-        const prev = process.env.OMEGA_LIVERELOAD_PORT;
-        delete process.env.OMEGA_LIVERELOAD_PORT;
-        try {
-          ctx.expect(Manager.getLiveReloadPort()).toBe(35729);
-        } finally {
-          if (prev !== undefined) process.env.OMEGA_LIVERELOAD_PORT = prev;
-        }
-      },
-    },
-    {
-      name: 'getWindowsSignStrategy defaults to self-hosted when no config',
-      run: (ctx) => {
-        // No EM_WIN_SIGN_STRATEGY env-var support anymore — config is the only source.
-        // Run from a cwd with no omega.json5 to confirm the default.
-        const fs = require('fs'); const os = require('os'); const path = require('path');
-        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-strategy-'));
-        const orig = process.cwd();
-        try {
-          process.chdir(tmp);
-          ctx.expect(Manager.getWindowsSignStrategy()).toBe('self-hosted');
-        } finally {
-          process.chdir(orig);
-          fs.rmSync(tmp, { recursive: true, force: true });
-        }
-      },
-    },
-    {
-      name: 'getWindowsSignStrategy reads config platforms.windows.signing.strategy',
-      run: (ctx) => {
-        const fs = require('fs'); const os = require('os'); const path = require('path');
-        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'desktop-strategy-'));
-        fs.mkdirSync(path.join(tmp, 'config'), { recursive: true });
-        fs.writeFileSync(path.join(tmp, 'config', 'omega.json5'),
-          `{ targets: { desktop: { type: 'desktop', platforms: { windows: { signing: { strategy: 'cloud' } } } } } }`);
-        const orig = process.cwd();
-        try {
-          process.chdir(tmp);
-          ctx.expect(Manager.getWindowsSignStrategy()).toBe('cloud');
-        } finally {
-          process.chdir(orig);
-          fs.rmSync(tmp, { recursive: true, force: true });
-        }
-      },
-    },
-    {
-      name: 'logger returns a named logger',
-      run: (ctx) => {
-        const m = new Manager();
-        const logger = m.logger('test-name');
-        ctx.expect(logger.name).toBe('test-name');
-        ctx.expect(typeof logger.log).toBe('function');
-        ctx.expect(typeof logger.error).toBe('function');
-      },
-    },
-  ],
-});