@omega.js/backend 0.1.0

package/dist/cli/commands/setup-tests/hosting-rewrites.js

@@ -0,0 +1,52 @@
+const BaseTest = require('./base-test');
+const jetpack = require('fs-jetpack');
+const _ = require('lodash');
+
+// The expected source pattern for omega_api hosting rewrite
+// Includes /omega/* routes, the legacy /backend-manager/* alias (kept so
+// migrating brands’ in-the-wild clients keep working), and root-level MCP
+// OAuth paths that Claude Chat sends directly (e.g. /authorize, /token, /.well-known/*)
+const OMEGA_API_SOURCE = '{/omega,/omega/**,/backend-manager,/backend-manager/**,/mcp,/mcp/**,/.well-known/oauth-protected-resource,/.well-known/oauth-authorization-server,/authorize,/token,/register}';
+
+class HostingRewritesTest extends BaseTest {
+  getName() {
+    return 'hosting rewrites have omega_api';
+  }
+
+  async run() {
+    const rewrites = this.self.firebaseJSON?.hosting?.rewrites || [];
+    const firstRewrite = rewrites[0];
+
+    // Check first rule is correct (matches current expected pattern)
+    const firstIsCorrect = firstRewrite?.source === OMEGA_API_SOURCE && firstRewrite?.function === 'omega_api';
+
+    // Check no duplicates exist (only one omega_api rule allowed)
+    const omegaApiCount = rewrites.filter(r => r.function === 'omega_api').length;
+
+    return firstIsCorrect && omegaApiCount === 1;
+  }
+
+  async fix() {
+    const hosting = this.self.firebaseJSON?.hosting || {};
+
+    // Set default
+    hosting.rewrites = hosting.rewrites || [];
+
+    // Remove any existing omega_api rewrites (handles legacy single-pattern rewrites too)
+    hosting.rewrites = hosting.rewrites.filter(rewrite => rewrite.function !== 'omega_api');
+
+    // Add to top with full pattern including MCP OAuth paths
+    hosting.rewrites.unshift({
+      source: OMEGA_API_SOURCE,
+      function: 'omega_api',
+    });
+
+    // Set
+    _.set(this.self.firebaseJSON, 'hosting.rewrites', hosting.rewrites);
+
+    // Write
+    jetpack.write(`${this.self.firebaseProjectPath}/firebase.json`, JSON.stringify(this.self.firebaseJSON, null, 2));
+  }
+}
+
+module.exports = HostingRewritesTest;

package/dist/cli/commands/setup-tests/index.js

@@ -0,0 +1,111 @@
+/**
+ * Test Registry
+ * Manages the order and execution of all setup tests
+ */
+
+const { isCustomProject, FIREBASE_ONLY_SETUP_CHECKS } = require('../../utils/project-type');
+
+// Import all test classes in the order they should run
+const IsFirebaseProjectTest = require('./is-firebase-project');
+const NodeVersionTest = require('./node-version');
+const NvmrcVersionTest = require('./nvmrc-version');
+const FirebaseCLITest = require('./firebase-cli');
+const FirebaseAuthTest = require('./firebase-auth');
+const JavaInstalledTest = require('./java-installed');
+const GcloudCliTest = require('./gcloud-cli');
+const FunctionsPackageTest = require('./functions-package');
+const FirebaseAdminTest = require('./firebase-admin');
+const FirebaseFunctionsTest = require('./firebase-functions');
+const OmegaBackendTest = require('./omega-backend');
+const NpmProjectScriptsTest = require('./npm-project-scripts');
+const OmegaConfigTest = require('./omega-config');
+const ProjectIdConsistencyTest = require('./project-id-consistency');
+const ServiceAccountTest = require('./service-account');
+const GitignoreTest = require('./gitignore');
+const EnvRuntimeConfigDeprecatedTest = require('./env-runtime-config-deprecated');
+const FirestoreRulesInJsonTest = require('./firestore-rules-in-json');
+const FirestoreIndexesInJsonTest = require('./firestore-indexes-in-json');
+const RealtimeRulesInJsonTest = require('./realtime-rules-in-json');
+const StorageRulesInJsonTest = require('./storage-rules-in-json');
+const RemoteconfigTemplateInJsonTest = require('./remoteconfig-template-in-json');
+const EmulatorConfigTest = require('./emulator-config');
+const HostingRewritesTest = require('./hosting-rewrites');
+const FirestoreIndexesSyncedTest = require('./firestore-indexes-synced');
+const StorageLifecyclePolicyTest = require('./storage-lifecycle-policy');
+const FirestoreRulesFileTest = require('./firestore-rules-file');
+const FirestoreIndexesFileTest = require('./firestore-indexes-file');
+const RealtimeRulesFileTest = require('./realtime-rules-file');
+const StorageRulesFileTest = require('./storage-rules-file');
+const RemoteconfigTemplateFileTest = require('./remoteconfig-template-file');
+const HostingFolderTest = require('./hosting-folder');
+const PublicHtmlFilesTest = require('./public-html-files');
+const FirestoreIndexesRequiredTest = require('./firestore-indexes-required');
+const ProjectDirectoriesTest = require('./project-directories');
+const LegacyTestsCleanupTest = require('./legacy-tests-cleanup');
+const MarketingCampaignsSeededTest = require('./marketing-campaigns-seeded');
+
+// The checks a custom-server target skips whole (#614) — the mode table names
+// them, this resolves each name to the class the list below instantiates.
+const FIREBASE_ONLY_CLASSES = new Set(FIREBASE_ONLY_SETUP_CHECKS.map((name) => require(`./${name}`)));
+
+/**
+ * Get all tests in the order they should run
+ *
+ * A custom-server backend (#584) has no Cloud Functions deploy and no
+ * emulator, so the checks that scaffold and maintain the Firebase-only
+ * artifacts are not part of its setup at all.
+ *
+ * @param {Object} context - The test context containing main and other dependencies
+ * @returns {Array} Array of test instances
+ */
+function getTests(context) {
+  const tests = [
+    new IsFirebaseProjectTest(context),
+    new NodeVersionTest(context),
+    new NvmrcVersionTest(context),
+    new FirebaseCLITest(context),
+    new FirebaseAuthTest(context),
+    new JavaInstalledTest(context),
+    new GcloudCliTest(context),
+    new FunctionsPackageTest(context),
+    new FirebaseAdminTest(context),
+    new FirebaseFunctionsTest(context),
+    new OmegaBackendTest(context),
+    new NpmProjectScriptsTest(context),
+    new OmegaConfigTest(context),
+    new ServiceAccountTest(context),
+    new ProjectIdConsistencyTest(context),
+    new GitignoreTest(context),
+    new EnvRuntimeConfigDeprecatedTest(context),
+    new FirestoreRulesInJsonTest(context),
+    new FirestoreIndexesInJsonTest(context),
+    new RealtimeRulesInJsonTest(context),
+    new StorageRulesInJsonTest(context),
+    new RemoteconfigTemplateInJsonTest(context),
+    new EmulatorConfigTest(context),
+    new HostingRewritesTest(context),
+    new StorageLifecyclePolicyTest(context),
+    new FirestoreRulesFileTest(context),
+    new FirestoreIndexesFileTest(context),
+    new FirestoreIndexesRequiredTest(context),
+    new FirestoreIndexesSyncedTest(context),
+    new RealtimeRulesFileTest(context),
+    new StorageRulesFileTest(context),
+    new RemoteconfigTemplateFileTest(context),
+    new HostingFolderTest(context),
+    new PublicHtmlFilesTest(context),
+    new ProjectDirectoriesTest(context),
+    new LegacyTestsCleanupTest(context),
+    new MarketingCampaignsSeededTest(context),
+  ];
+
+  if (!isCustomProject(context.main.firebaseProjectPath)) {
+    return tests;
+  }
+
+  return tests.filter((test) => !FIREBASE_ONLY_CLASSES.has(test.constructor));
+}
+
+module.exports = {
+  getTests,
+};

package/dist/cli/commands/setup-tests/is-firebase-project.js

@@ -0,0 +1,21 @@
+const BaseTest = require('./base-test');
+const jetpack = require('fs-jetpack');
+const chalk = require('chalk').default;
+
+class IsFirebaseProjectTest extends BaseTest {
+  getName() {
+    return 'is a firebase project';
+  }
+
+  async run() {
+    const exists = jetpack.exists(`${this.self.firebaseProjectPath}/firebase.json`);
+    return exists;
+  }
+
+  async fix() {
+    console.log(chalk.red(`This is not a firebase project. Please use ${chalk.bold('firebase-init')} to set up.`));
+    throw new Error('Not a Firebase project');
+  }
+}
+
+module.exports = IsFirebaseProjectTest;

package/dist/cli/commands/setup-tests/java-installed.js

@@ -0,0 +1,27 @@
+const BaseTest = require('./base-test');
+const powertools = require('node-powertools');
+const { javaInstallHint } = require('./helpers');
+
+class JavaInstalledTest extends BaseTest {
+  getName() {
+    return 'Java is installed (required by Firebase emulators)';
+  }
+
+  getWarning() {
+    return [
+      'Java is required by the Firebase Firestore emulator (used for testing).',
+      `Install with: ${javaInstallHint()}`,
+    ];
+  }
+
+  async run() {
+    try {
+      await powertools.execute('java -version', { log: false });
+      return true;
+    } catch (error) {
+      return 'warn';
+    }
+  }
+}
+
+module.exports = JavaInstalledTest;

package/dist/cli/commands/setup-tests/legacy-tests-cleanup.js

@@ -0,0 +1,43 @@
+const BaseTest = require('./base-test');
+const jetpack = require('fs-jetpack');
+const chalk = require('chalk').default;
+
+// Legacy test files that should be removed from consuming projects
+const LEGACY_FILES = [
+  'test/accounts.json',
+  'test/backend-manager-tests.js',
+];
+
+class LegacyTestsCleanupTest extends BaseTest {
+  getName() {
+    return 'remove legacy test files';
+  }
+
+  async run() {
+    const self = this.self;
+
+    // Check if any legacy files exist
+    for (const file of LEGACY_FILES) {
+      const filePath = `${self.firebaseProjectPath}/${file}`;
+      if (jetpack.exists(filePath)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  async fix() {
+    const self = this.self;
+
+    for (const file of LEGACY_FILES) {
+      const filePath = `${self.firebaseProjectPath}/${file}`;
+      if (jetpack.exists(filePath)) {
+        jetpack.remove(filePath);
+        console.log(chalk.yellow(`Removed legacy file: ${file}`));
+      }
+    }
+  }
+}
+
+module.exports = LegacyTestsCleanupTest;

package/dist/cli/commands/setup-tests/marketing-campaigns-seeded.js

@@ -0,0 +1,230 @@
+const BaseTest = require('./base-test');
+const chalk = require('chalk').default;
+const _ = require('lodash');
+const { buildSeedCampaigns } = require('./helpers/seed-campaigns');
+
+class MarketingCampaignsSeededTest extends BaseTest {
+  getName() {
+    return 'marketing campaigns seeded in Firestore';
+  }
+
+  getWarning() {
+    // Under --offline the opt-in is overridden, so "pass the flag" would be
+    // the wrong remedy — name the flag that suppressed the write instead.
+    if (this.isOffline) {
+      return [
+        'live campaign seeding skipped (--offline) — re-run `npx omega test --seed-campaigns` without --offline to seed/enforce',
+      ];
+    }
+
+    return [
+      'live campaign seeding is opt-in — run `npx omega test --seed-campaigns` to seed/enforce',
+    ];
+  }
+
+  async run() {
+    // demo-* projects are emulator-only — live Firestore doesn't exist and the
+    // generated fake service account authenticates nowhere (the first .get()
+    // threw gRPC 16 UNAUTHENTICATED and halted setup — friction #8's class).
+    // Emulator runs seed campaigns through the shared seed module at boot.
+    if (this.isDemoProject) {
+      console.log(chalk.dim(`  demo-* project (${this.self.projectId}) — live campaign seeding skipped (emulator seeds on boot)`));
+      return true;
+    }
+
+    const admin = this._getAdmin();
+
+    if (!admin) {
+      return true; // Can't connect — skip gracefully
+    }
+
+    const seeds = buildSeedCampaigns();
+
+    for (const seed of seeds) {
+      const doc = await admin.firestore().doc(`marketing-campaigns/${seed.id}`).get();
+
+      // Doc doesn't exist → fail
+      if (!doc.exists) {
+        return this._driftVerdict();
+      }
+
+      // Check enforced fields + missing defaults
+      const data = doc.data();
+
+      for (const [path, expected] of Object.entries(seed.enforced)) {
+        const actual = _.get(data, path);
+
+        if (!_.isEqual(actual, expected)) {
+          return this._driftVerdict();
+        }
+      }
+
+      // Check for missing fields that should exist from seed
+      if (hasMissingFields(data, seed.doc)) {
+        return this._driftVerdict();
+      }
+    }
+
+    return true;
+  }
+
+  async fix() {
+    if (this.isDemoProject) {
+      return; // run() never fails demo projects; never touch live Firestore here
+    }
+
+    // Belt for a future direct caller: run() already warns instead of failing
+    // when the flag is absent, so the runner can never reach this fix.
+    if (!this._seedingRequested()) {
+      return;
+    }
+
+    const admin = this._getAdmin();
+
+    if (!admin) {
+      console.log(chalk.yellow('  ⚠ No Firebase connection — skipping campaign seeding'));
+      console.log(chalk.yellow('    Run from a project with service-account.json to seed'));
+      return;
+    }
+
+    const seeds = buildSeedCampaigns();
+
+    for (const seed of seeds) {
+      const docRef = admin.firestore().doc(`marketing-campaigns/${seed.id}`);
+      const doc = await docRef.get();
+
+      // Doc doesn't exist → create it
+      if (!doc.exists) {
+        await docRef.set(seed.doc);
+        console.log(chalk.green(`  + Created ${chalk.cyan(seed.id)}: ${seed.doc.settings.name}`));
+        continue;
+      }
+
+      // Doc exists → fill missing defaults + enforce required fields
+      const data = doc.data();
+      const updates = {};
+
+      // Fill missing fields from seed defaults (never overwrite existing values)
+      fillMissing(data, seed.doc, updates, '');
+
+      // Enforce required fields (always overwrite to match seed)
+      for (const [path, expected] of Object.entries(seed.enforced)) {
+        const actual = _.get(data, path);
+
+        if (!_.isEqual(actual, expected)) {
+          _.set(updates, path, expected);
+          console.log(chalk.yellow(`  ↻ ${seed.id}: ${chalk.cyan(path)} ${chalk.dim(JSON.stringify(actual))} → ${chalk.bold(JSON.stringify(expected))}`));
+        }
+      }
+
+      if (Object.keys(updates).length) {
+        updates.metadata = {
+          updated: {
+            timestamp: new Date().toISOString(),
+            timestampUNIX: Math.round(Date.now() / 1000),
+          },
+        };
+
+        await docRef.set(updates, { merge: true });
+      } else {
+        console.log(chalk.dim(`  ✓ ${seed.id} — all enforced fields correct`));
+      }
+    }
+  }
+
+  /**
+   * The verdict for a missing/drifted seed. Reads run on every live project,
+   * but writing 5 docs into a REAL project's Firestore is opt-in: without the
+   * flag a drift warns (non-blocking, and the runner never fixes a 'warn'),
+   * with the flag it fails so fix() seeds/enforces.
+   */
+  _driftVerdict() {
+    return this._seedingRequested() ? false : 'warn';
+  }
+
+  /**
+   * True when the run opted into live seeding with `--seed-campaigns`.
+   * `--offline` overrides the opt-in: it promises NO live mutations for the
+   * whole run, and fix() writes real Firestore docs (#284).
+   */
+  _seedingRequested() {
+    const argv = this.self.argv || {};
+
+    if (this.isOffline) {
+      return false;
+    }
+
+    return !!(argv.seedCampaigns || argv['seed-campaigns']);
+  }
+
+  _getAdmin() {
+    try {
+      const { initFirebase } = require('../firebase-init');
+      const { admin } = initFirebase({
+        firebaseProjectPath: this.self.firebaseProjectPath,
+        emulator: false,
+      });
+
+      return admin;
+    } catch (e) {
+      console.log(chalk.dim(`  (firebase-init failed: ${e.message})`));
+      return null;
+    }
+  }
+}
+
+/**
+ * Check if the live doc is missing any fields defined in the seed.
+ */
+function hasMissingFields(live, seed, prefix) {
+  for (const [key, seedValue] of Object.entries(seed)) {
+    if (key === 'metadata') {
+      continue;
+    }
+
+    const path = prefix ? `${prefix}.${key}` : key;
+    const liveValue = _.get(live, path);
+
+    if (liveValue === undefined) {
+      return true;
+    }
+
+    if (_.isPlainObject(seedValue) && _.isPlainObject(liveValue)) {
+      if (hasMissingFields(live, seedValue, path)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Recursively fill missing fields from seed into updates.
+ * Only sets fields that don't exist in the live doc — never overwrites.
+ * Skips metadata (managed separately).
+ */
+function fillMissing(live, seed, updates, prefix) {
+  for (const [key, seedValue] of Object.entries(seed)) {
+    if (key === 'metadata') {
+      continue;
+    }
+
+    const path = prefix ? `${prefix}.${key}` : key;
+    const liveValue = _.get(live, path);
+
+    // If live doc is missing this field entirely, set it from seed
+    if (liveValue === undefined) {
+      _.set(updates, path, seedValue);
+      console.log(chalk.blue(`  + ${path}: ${chalk.dim('(missing)')} → ${chalk.bold(JSON.stringify(seedValue).slice(0, 80))}`));
+      continue;
+    }
+
+    // If both are plain objects, recurse to check nested fields
+    if (_.isPlainObject(seedValue) && _.isPlainObject(liveValue)) {
+      fillMissing(live, seedValue, updates, path);
+    }
+  }
+}
+
+module.exports = MarketingCampaignsSeededTest;

package/dist/cli/commands/setup-tests/node-version.js

@@ -0,0 +1,60 @@
+const BaseTest = require('./base-test');
+const chalk = require('chalk').default;
+
+/**
+ * Local Node vs the pinned Cloud Functions runtime.
+ *
+ * The runtime pin (framework `omega.functionsRuntime`) is what Firebase runs
+ * in the cloud; the laptop only has to meet the framework's dev floor
+ * (`engines.node >=22`). Local OLDER than the runtime warns — the emulator
+ * can't faithfully run runtime-era code. Local NEWER is fine (deploys are
+ * unaffected — Firebase provides the runtime) and gets a dim parity note.
+ * A target pin drifted from the framework runtime is healed by fix().
+ */
+class NodeVersionTest extends BaseTest {
+  getName() {
+    return `Node.js vs pinned Cloud Functions runtime (v${this.context.packageJSON.omega.functionsRuntime})`;
+  }
+
+  async run() {
+    const runtimeMajor = parseInt(this.context.packageJSON.omega.functionsRuntime, 10);
+    const targetPin = parseInt((this.context.package.engines || {}).node, 10);
+    const localVer = process.versions.node;
+    const localMajor = parseInt(localVer, 10);
+
+    // #15: a wrong RUNNING Node no longer halts the whole setup — the
+    // remaining checks complete and this lands in the summary as a warning
+    // (manage runs spawn setup under the target's own .nvmrc Node, so this
+    // fires mostly in standalone shells).
+    if (localMajor < runtimeMajor) {
+      this._warning = `running Node ${localVer} but the pinned Cloud Functions runtime is ${runtimeMajor} — use Node >=${runtimeMajor} (nvm users: ${chalk.bold(`nvm use ${runtimeMajor}`)})`;
+      return 'warn';
+    }
+
+    if (localMajor > runtimeMajor) {
+      console.log(chalk.dim(`  local Node ${localVer} > functions runtime ${runtimeMajor} — deploys unaffected (Firebase provides the runtime); use Node ${runtimeMajor} locally for exact emulator parity`));
+    }
+
+    // Target pin must match the framework's runtime — drift (or a missing pin)
+    // heals via fix(), keeping the staged functions manifest correct.
+    return targetPin === runtimeMajor;
+  }
+
+  getWarning() {
+    return this._warning ? [this._warning] : [];
+  }
+
+  async fix() {
+    const runtime = String(parseInt(this.context.packageJSON.omega.functionsRuntime, 10));
+
+    const manifest = this.readTargetManifest();
+    manifest.engines = manifest.engines || {};
+    manifest.engines.node = runtime;
+    this.writeTargetManifest();
+    this.restage();
+
+    console.log(chalk.yellow(`engines.node restamped to ${runtime} (the pinned Cloud Functions runtime)`));
+  }
+}
+
+module.exports = NodeVersionTest;

package/dist/cli/commands/setup-tests/npm-project-scripts.js

@@ -0,0 +1,42 @@
+const BaseTest = require('./base-test');
+const { frameworkOwnedScripts } = require('../../utils/project-type');
+
+class NpmProjectScriptsTest extends BaseTest {
+  getName() {
+    return 'has all @omega.js/backend project scripts';
+  }
+
+  async run() {
+    // frameworkOwnedScripts is the ONE home of which keys this framework owns
+    // and at what value (#689) — the same call ensure-target's scaffold makes,
+    // so a check and a verb can never disagree about a target's scripts.
+    const projectScripts = frameworkOwnedScripts(this.self.firebaseProjectPath);
+    const consumerScripts = this.context.package.scripts || {};
+
+    for (const [name, command] of Object.entries(projectScripts)) {
+      if (consumerScripts[name] !== command) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  async fix() {
+    const projectScripts = frameworkOwnedScripts(this.self.firebaseProjectPath);
+
+    // Fresh-read first: npm-driven fixes rewrote the manifest earlier in
+    // this run — writing the boot-time snapshot would clobber their installs
+    // (cp195 journey catch: this exact fix erased firebase-admin/functions)
+    const manifest = this.readTargetManifest();
+    manifest.scripts = manifest.scripts || {};
+
+    for (const [name, command] of Object.entries(projectScripts)) {
+      manifest.scripts[name] = command;
+    }
+
+    this.writeTargetManifest();
+  }
+}
+
+module.exports = NpmProjectScriptsTest;

package/dist/cli/commands/setup-tests/nvmrc-version.js

@@ -0,0 +1,36 @@
+const BaseTest = require('./base-test');
+const jetpack = require('fs-jetpack');
+const chalk = require('chalk').default;
+const wonderfulVersion = require('wonderful-version');
+
+class NvmrcVersionTest extends BaseTest {
+  getName() {
+    return '.nvmrc file has proper version';
+  }
+
+  async run() {
+    // Authored at the TARGET ROOT (src/dist pillar); the stage step carries a
+    // copy into functions/ for firebase-tools' runtime detection. Compared
+    // against the pinned Cloud Functions runtime (omega.functionsRuntime),
+    // NOT engines.node — engines is the dev floor (>=22), not a version.
+    const runtimeVer = this.context.packageJSON.omega.functionsRuntime;
+    const nvmrcVer = jetpack.read(`${this.self.firebaseProjectPath}/.nvmrc`);
+
+    // Check to ensure nvmrc is greater than or equal to the runtime version
+    return wonderfulVersion.is(nvmrcVer, '>=', runtimeVer);
+  }
+
+  async fix() {
+    const v = this.context.packageJSON.omega.functionsRuntime;
+
+    jetpack.write(`${this.self.firebaseProjectPath}/.nvmrc`, `v${v}/*`);
+    this.restage();
+
+    // #15: the pin is now correct — the fix IS complete and the run
+    // continues (manage runs spawn setup under the target's own Node; only a
+    // standalone shell needs the nvm switch, for NEXT time).
+    console.log(chalk.yellow(`.nvmrc pinned to v${v}/* — standalone shells: run ${chalk.bold(`nvm use ${v}`)}`));
+  }
+}
+
+module.exports = NvmrcVersionTest;

package/dist/cli/commands/setup-tests/omega-backend.js

@@ -0,0 +1,42 @@
+const BaseTest = require('./base-test');
+const chalk = require('chalk').default;
+const wonderfulVersion = require('wonderful-version');
+const powertools = require('node-powertools');
+const { getLatestVersion } = require('../../../vendor/devkit/npm-registry.js');
+const helpers = require('./helpers');
+
+class OmegaBackendTest extends BaseTest {
+  getName() {
+    return 'using updated @omega.js/backend';
+  }
+
+  async run() {
+    const pkg = '@omega.js/backend';
+    const latest = await this.getPkgVersion(pkg);
+    const mine = this.context.package.dependencies[pkg];
+
+    // Get level difference
+    const levelDifference = wonderfulVersion.levelDifference(latest, mine);
+
+    // Log if major version mismatch
+    if (!helpers.isLocal(mine) && levelDifference === 'major') {
+      console.log(chalk.red(`Version ${chalk.bold(latest)} of ${chalk.bold(pkg)} available but you must install this manually because it is a major update.`));
+    }
+
+    // Ensure the version is up to date
+    return helpers.isLocal(mine) || wonderfulVersion.is(mine, '>=', latest) || levelDifference === 'major';
+  }
+
+  async fix() {
+    await this.installPkg('@omega.js/backend');
+
+    console.log(chalk.green(`Process has exited since a new version of @omega.js/backend was installed. Run ${chalk.bold('npx bm setup')} again.`));
+    process.exit(0);
+  }
+
+  async getPkgVersion(packageName) {
+    return (await getLatestVersion(packageName)) || '0.0.0';
+  }
+}
+
+module.exports = OmegaBackendTest;