@omega.js/manager 0.1.0

package/dist/lib/automation-client.js

@@ -0,0 +1,210 @@
+/**
+ * Automation client — drives the companion Chrome extension (extension/)
+ * over its WebSocket protocol. The manager side is the SERVER: it listens
+ * on the port the extension auto-connects to (ws://localhost:9876,
+ * reconnecting every 5s), then sends OMEGA_AUTOMATE commands and awaits
+ * OMEGA_AUTOMATE_RESULT responses by correlation id. The extension turns
+ * the commands into trusted CDP input events (chrome.debugger), so the
+ * automated pages can't tell a human from the manager.
+ *
+ * Port and timeouts are constructor-injectable (tests bind ephemeral
+ * ports; OMEGA_EXTENSION_PORT overrides the default when 9876 is taken —
+ * the extension side must be pointed at the same port).
+ *
+ * Usage:
+ *   const client = new AutomationClient();
+ *   await client.connect();
+ *   await client.navigate('https://example.com');
+ *   await client.click('#submit');
+ *   await client.type('input', 'hello');
+ *   const result = await client.evaluate('document.title');
+ *   await client.disconnect();
+ */
+const { WebSocketServer } = require('ws');
+
+const DEFAULT_PORT = 9876;
+const CONNECT_TIMEOUT = 15000;
+const COMMAND_TIMEOUT = 30000;
+
+let cmdCounter = 0;
+
+/** The port the extension protocol runs on (env-overridable). */
+function resolveExtensionPort() {
+  return Number(process.env.OMEGA_EXTENSION_PORT) || DEFAULT_PORT;
+}
+
+class AutomationClient {
+  constructor(options = {}) {
+    this.port = options.port || resolveExtensionPort();
+    this.connectTimeout = options.connectTimeout || CONNECT_TIMEOUT;
+    this.commandTimeout = options.commandTimeout || COMMAND_TIMEOUT;
+    this.wss = null;
+    this.ws = null;
+    this.pending = new Map(); // id → { resolve, reject, timeout }
+  }
+
+  /**
+   * Start the WebSocket server and wait for the extension to connect.
+   */
+  async connect() {
+    if (this.ws) {
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      this.wss = new WebSocketServer({ port: this.port });
+
+      const timeout = setTimeout(() => {
+        this.wss.close();
+        this.wss = null;
+        reject(new Error('Extension did not connect (timeout). Make sure the Omega extension is installed and enabled.'));
+      }, this.connectTimeout);
+
+      this.wss.on('error', (error) => {
+        clearTimeout(timeout);
+        if (error.code === 'EADDRINUSE') {
+          reject(new Error(`Port ${this.port} already in use`));
+        } else {
+          reject(error);
+        }
+      });
+
+      this.wss.on('connection', (ws) => {
+        clearTimeout(timeout);
+        this.ws = ws;
+
+        ws.on('message', (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            this._handleResponse(msg);
+          } catch {
+            // Ignore parse errors
+          }
+        });
+
+        ws.on('close', () => {
+          this.ws = null;
+          // Reject all pending commands
+          for (const [id, entry] of this.pending) {
+            clearTimeout(entry.timeout);
+            entry.reject(new Error('Extension disconnected'));
+            this.pending.delete(id);
+          }
+        });
+
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Disconnect and clean up.
+   */
+  async disconnect() {
+    if (this.ws) {
+      this.ws.terminate();
+      this.ws = null;
+    }
+    if (this.wss) {
+      for (const client of this.wss.clients) {
+        client.terminate();
+      }
+      await new Promise((resolve) => this.wss.close(resolve));
+      this.wss = null;
+    }
+  }
+
+  /**
+   * Send a single automation command and wait for the result.
+   */
+  async send(command, params = {}, target = {}) {
+    if (!this.ws) {
+      throw new Error('Not connected to extension');
+    }
+
+    const id = `cmd_${++cmdCounter}_${Date.now()}`;
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Command "${command}" timed out after ${this.commandTimeout}ms`));
+      }, this.commandTimeout);
+
+      this.pending.set(id, { resolve, reject, timeout });
+
+      this.ws.send(JSON.stringify({
+        type: 'OMEGA_AUTOMATE',
+        id,
+        command,
+        params,
+        target,
+      }));
+    });
+  }
+
+  /**
+   * Handle a response message from the extension.
+   */
+  _handleResponse(msg) {
+    if (msg.type === 'OMEGA_AUTOMATE_PROGRESS') {
+      // Progress events during sequences — informational only
+      return;
+    }
+
+    if (msg.type !== 'OMEGA_AUTOMATE_RESULT') {
+      return;
+    }
+
+    const entry = this.pending.get(msg.id);
+    if (!entry) {
+      return;
+    }
+
+    clearTimeout(entry.timeout);
+    this.pending.delete(msg.id);
+
+    if (msg.success) {
+      entry.resolve(msg.result);
+    } else {
+      const err = new Error(msg.error?.message || 'Automation command failed');
+      err.code = msg.error?.code;
+      entry.reject(err);
+    }
+  }
+
+  // =========================================================================
+  // Convenience methods
+  // =========================================================================
+
+  /** Navigate to a URL (opens a new tab when target.create is true). */
+  async navigate(url, target = {}) {
+    return this.send('navigate', { url }, target);
+  }
+
+  /** Click an element by CSS selector. */
+  async click(selector, options = {}) {
+    return this.send('click', { selector, ...options });
+  }
+
+  /** Type text into an element with trusted key events. */
+  async type(selector, text, options = {}) {
+    return this.send('type', { selector, text, ...options });
+  }
+
+  /** Read DOM content. */
+  async read(params = {}) {
+    return this.send('read', params);
+  }
+
+  /** Wait for an element, condition, or delay. */
+  async wait(params = {}) {
+    return this.send('wait', params);
+  }
+
+  /** Evaluate arbitrary JavaScript in the page context. */
+  async evaluate(expression) {
+    return this.send('evaluate', { expression });
+  }
+}
+
+module.exports = { AutomationClient, resolveExtensionPort, DEFAULT_PORT };

package/dist/lib/backend-marketing.js

@@ -0,0 +1,49 @@
+/**
+ * @omega.js/backend's marketing SSOT — the FIELDS + SEGMENTS dictionaries that
+ * define every custom field and segment @omega.js/backend expects in the marketing
+ * providers (SendGrid, Beehiiv), plus GROUP_KEYS, the unsubscribe groups its
+ * send path names. Required straight from the @omega.js/backend
+ * workspace package so the definitions can never drift from the code that
+ * consumes them at runtime (omega-manager climbed the filesystem into the
+ * sibling repo for the same reason — this is the same SSOT, resolved
+ * properly through the workspace).
+ *
+ * omega-manager also carried an OMEGA-owned `import_batch` field here; its
+ * only writer is the legacy-contact import script, which hasn't ported —
+ * the field rides that port.
+ */
+const { FIELDS, SEGMENTS, GROUP_KEYS, fieldsForProvider } = require('@omega.js/backend/dist/manager/libraries/email/constants.js');
+
+// Array shapes for handlers that iterate
+const BEM_FIELDS = Object.entries(FIELDS).map(([name, field]) => ({
+  name,
+  display: field.display,
+  type: field.type,
+  skip: field.skip || [],
+}));
+
+const BEM_SEGMENTS = Object.entries(SEGMENTS).map(([name, segment]) => ({
+  name,
+  display: segment.display,
+  conditions: segment.conditions,
+  logic: segment.logic || 'and',
+  skip: segment.skip || [],
+}));
+
+const BEM_FIELDS_BY_NAME = Object.fromEntries(BEM_FIELDS.map((field) => [field.name, field]));
+
+/**
+ * Fields a given provider should provision — @omega.js/backend's OWN view of its
+ * catalog (#695), so what OMEGA creates and what the backend's contact sync
+ * writes can never be two different lists.
+ */
+function fieldsFor(provider) {
+  return fieldsForProvider(provider).map((name) => BEM_FIELDS_BY_NAME[name]);
+}
+
+/** Segments a given provider should provision (honors each segment's skip list). */
+function segmentsFor(provider) {
+  return BEM_SEGMENTS.filter((segment) => !segment.skip.includes(provider));
+}
+
+module.exports = { BACKEND_FIELDS_MAP: FIELDS, BEM_FIELDS, BEM_SEGMENTS, BEM_GROUP_KEYS: GROUP_KEYS, fieldsFor, segmentsFor };

package/dist/lib/brand.js

@@ -0,0 +1,240 @@
+/**
+ * Brand-monorepo loading — resolve the brand root from any cwd inside it,
+ * load config/omega.json5 through @omega.js/config (whole-file merge, manager
+ * defaults as the lowest layer), enumerate enabled targets, and discover the
+ * target dirs under targets/.
+ *
+ * This replaces omega-manager's .brands/{id}/config.json + buildBrandConfig()
+ * pair: in the brand-monorepo world the brand's own omega.json5 IS the single
+ * source of user choices — the manager reads the same file every framework
+ * reads, no mirror to disperse.
+ *
+ * Target dir → target mapping, first match wins:
+ *   1. Declared — the dir's own config/omega.json5 lists exactly the target
+ *      under `targets` (key presence = enabled).
+ *   2. Directory convention — targets/website* → web, targets/backend* → backend,
+ *      targets/desktop* → desktop, targets/extension* → extension, targets/mobile* → mobile.
+ * Unmapped dirs surface as workspace-service warnings, never silent skips.
+ *
+ * A CUSTOM target (#603) is neither: the brand config declares it
+ * (`targets.<name>: { type: 'custom' }`) and its dir carries no framework. It
+ * is marked `custom: true` with `target` left NULL, which is what makes every
+ * framework service's `filter((entry) => entry.target)` skip it for free —
+ * only the ONE op that must see it (the workspace service) reads the flag.
+ *
+ * A backend entry also carries `projectType` (#584) — 'firebase' (Cloud
+ * Functions) or 'custom' (the same backend as its own server on a container
+ * host). That is a framework target either way; the mode only decides which
+ * verbs its framework can serve (framework-bin.js).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const JSON5 = require('json5');
+
+// resolveBrandRoot moved into @omega.js/config (cp73c) — the hierarchy walk
+// has ONE home there, alongside findBrandRoot and the env cascade.
+const { loadConfig, resolveConfigPath, getEnabledTargets, resolveBrandRoot, backendProjectType, normalizeTargetInstances } = require('../vendor/config/index.js');
+const { DEFAULTS, DIR_TARGETS, templateObject } = require('../config.js');
+const { customTargetDirs } = require('./custom-target.js');
+
+/**
+ * Read a target's raw omega.json5 (no merge, no validation) purely to see which
+ * targets it declares. Discovery must never throw — validation is the
+ * workspace service's job.
+ */
+function readDeclaredTargets(targetPath) {
+  const configPath = resolveConfigPath(targetPath);
+  if (!configPath) return null;
+
+  try {
+    const raw = JSON5.parse(fs.readFileSync(configPath, 'utf8'));
+    const targets = getEnabledTargets(raw);
+    return targets.length > 0 ? targets : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Map a target directory name to a target via the naming convention:
+ * exact match or `<name>-*` prefix (targets/website-docs → web).
+ */
+function targetFromDirName(dirName) {
+  for (const [prefix, target] of Object.entries(DIR_TARGETS)) {
+    if (dirName === prefix || dirName.startsWith(`${prefix}-`)) {
+      return target;
+    }
+  }
+  return null;
+}
+
+/**
+ * Discover the targets under {brandRoot}/targets.
+ *
+ * A brand still carrying `apps/` fails LOUDLY here (#443): the old shape is
+ * not a brand with zero targets, it is a brand that never ran the one-time
+ * rename, and walking it as empty would quietly do the wrong thing in every
+ * service downstream. The fix is a migration, run once, by hand — nothing
+ * heals it inside a run.
+ *
+ * @param {string} brandRoot - Absolute brand-monorepo root
+ * @returns {Array<{ name, dir, path, target, projectType, declaredTargets }>} -
+ *   One entry per target directory; `target` is null when unmapped (workspace
+ *   warns), and `projectType` rides the backend entry only (#584).
+ * @throws {Error} when the brand is still on the pre-#443 `apps/` shape
+ */
+function discoverTargets(brandRoot) {
+  // The brand file's own raw view — read here (never through loadBrand, which
+  // calls US) purely to learn which dirs are declared custom. Discovery must
+  // never throw: an unreadable brand file simply declares no custom targets,
+  // and the workspace service reports the real problem.
+  let customDirs = new Set();
+  // How the backend RUNS (#584) — 'firebase' (Cloud Functions) or 'custom'
+  // (its own server on a container host). Read from the same raw view, since
+  // it steers which verbs the fan-outs may dispatch at that target.
+  let backendMode = 'firebase';
+  try {
+    const brandConfigPath = resolveConfigPath(brandRoot);
+    if (brandConfigPath) {
+      const raw = JSON5.parse(fs.readFileSync(brandConfigPath, 'utf8'));
+      customDirs = new Set(customTargetDirs(raw));
+      backendMode = backendProjectType(normalizeTargetInstances(raw.targets?.backend)[0]);
+    }
+  } catch {
+    // Unreadable brand config — no custom declarations to honor
+  }
+
+  const targetsDir = path.join(brandRoot, 'targets');
+  if (!fs.existsSync(targetsDir)) {
+    if (fs.existsSync(path.join(brandRoot, 'apps'))) {
+      throw new Error(
+        `${brandRoot} still carries apps/ instead of targets/ (#443) — `
+        + 'run `npx omega manage --migration=targets-rename --execute` once, then `npm install`.',
+      );
+    }
+
+    return [];
+  }
+
+  const targets = [];
+
+  for (const entry of fs.readdirSync(targetsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name.startsWith('.')) continue;
+
+    const targetPath = path.join(targetsDir, entry.name);
+
+    // A custom target (#603) has no framework to map to — the brand's own
+    // declaration is the whole mapping, and `target` stays null on purpose
+    if (customDirs.has(entry.name)) {
+      targets.push({
+        name: entry.name,
+        dir: `targets/${entry.name}`,
+        path: targetPath,
+        target: null,
+        custom: true,
+        declaredTargets: null,
+      });
+      continue;
+    }
+
+    const declaredTargets = readDeclaredTargets(targetPath);
+
+    // Declared target wins; a single declaration is unambiguous, multiple
+    // declarations fall back to the directory convention as the tiebreaker.
+    let target = null;
+    if (declaredTargets && declaredTargets.length === 1) {
+      target = declaredTargets[0];
+    } else {
+      target = targetFromDirName(entry.name);
+      if (!target && declaredTargets) target = declaredTargets[0];
+    }
+
+    targets.push({
+      name: entry.name,
+      dir: `targets/${entry.name}`,
+      path: targetPath,
+      target,
+      // Backend only: the mode decides which verbs its framework can serve
+      // (#584). Every other target has one shape, so it carries no key.
+      ...(target === 'backend' ? { projectType: backendMode } : {}),
+      declaredTargets,
+    });
+  }
+
+  return targets;
+}
+
+/**
+ * Load a brand monorepo: config (manager defaults ← [company ←] brand file,
+ * whole-file merge with `{ domain }` templating applied), enabled targets,
+ * discovered target dirs.
+ *
+ * The COMPANY layer is @omega.js/config's, not ours (#83): loadConfig reads
+ * the brand's `.omega/company.json` stamp itself and folds the company file
+ * (minus `brands`) between the defaults and the brand file. The manager keeps
+ * the company config only as PROVENANCE — runManage hangs it on the loaded
+ * brand as `companyRoot`/`companyConfig` for services that ask "did this come
+ * from the company?" — never as a second fold.
+ *
+ * Config load failures (parse error, secret-shaped keys, legacy targets
+ * array) do NOT throw here — they land in `configError` so the workspace
+ * service reports them through the normal status flow.
+ *
+ * @param {string} brandRoot - Absolute brand-monorepo root
+ * @returns {{ root, id, config, configError, configErrors, enabledTargets, targets, files }}
+ */
+function loadBrand(brandRoot) {
+  let loaded = null;
+  let configError = null;
+
+  try {
+    loaded = loadConfig(brandRoot, undefined, { defaults: DEFAULTS });
+  } catch (error) {
+    configError = error.message;
+  }
+
+  let config = loaded ? loaded.config : { ...DEFAULTS, brand: { id: path.basename(brandRoot) } };
+
+  // Template `{ domain }` placeholders from brand.url (omega-manager parity)
+  const url = config.brand?.url || '';
+  const domain = url.replace(/^https?:\/\//, '');
+  if (domain) {
+    config = templateObject(config, {
+      domain,
+      domainDashed: domain.replace(/\./g, '-'),
+    });
+  }
+
+  return {
+    root: brandRoot,
+    id: config.brand?.id || path.basename(brandRoot),
+    config,
+    configError,
+    configErrors: loaded ? loaded.errors : [],
+    enabledTargets: loaded ? getEnabledTargets(loaded.config) : [],
+    targets: discoverTargets(brandRoot),
+    files: loaded ? loaded.files : null,
+  };
+}
+
+/**
+ * Resolve a brand image (brand.images.<key>) to an ABSOLUTE URL for external
+ * services (Stripe product images, Chatsy avatars, …). Config stores
+ * site-relative paths (served by the web build's static channel — the site
+ * itself absolutizes per environment); external surfaces can't resolve a
+ * relative path, so join against brand.url. Full URLs pass through.
+ * @param {object} brandConfig - merged brand config
+ * @param {string} key - images key ('brandmark' | 'social' | ...)
+ * @returns {string|null} absolute URL, or null when unresolvable
+ */
+function absoluteBrandImage(brandConfig, key) {
+  const value = brandConfig?.brand?.images?.[key] || null;
+  if (!value) return null;
+  if (/^https?:\/\//.test(value)) return value;
+
+  const base = String(brandConfig?.brand?.url || '').replace(/\/$/, '');
+  return base ? `${base}${value.startsWith('/') ? '' : '/'}${value}` : null;
+}
+
+module.exports = { resolveBrandRoot, loadBrand, discoverTargets, targetFromDirName, absoluteBrandImage };

package/dist/lib/bundle-id.js

@@ -0,0 +1,53 @@
+/**
+ * Bundle-identifier policy — reverse-DNS ids derived from the brand's web
+ * identity (Ian 2026-07-14: the prefix is the reverse domain, autoset at
+ * onboarding from the parent company when one exists, else the brand's own
+ * url).
+ *
+ *   deriveBundleIdPrefix('https://itwcreativeworks.com')   → 'com.itwcreativeworks'
+ *   deriveBundleIdPrefix('https://playground.omegajs.dev') → 'dev.omegajs.playground'
+ *   composeBundleId('com.itwcreativeworks', 'omega-playground')
+ *     → 'com.itwcreativeworks.omega.playground'
+ *
+ * Sanitization keeps ids legal on BOTH stores: Apple allows hyphens but
+ * Android package segments don't, so domain labels drop non-alphanumerics
+ * and brand-id hyphens become dots (each id word is its own segment).
+ */
+
+/**
+ * Reverse-DNS prefix from a company/brand url, or null when the url does
+ * not parse. `www.` is dropped; every other hostname label survives (a
+ * subdomain brand derives a subdomain-scoped prefix).
+ *
+ * @param {string} url - http(s) url (brand.url shape)
+ * @returns {string|null}
+ */
+function deriveBundleIdPrefix(url) {
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    return null;
+  }
+
+  const labels = hostname
+    .replace(/^www\./, '')
+    .split('.')
+    .map((label) => label.toLowerCase().replace(/[^a-z0-9]/g, ''))
+    .filter(Boolean);
+
+  return labels.length > 0 ? labels.reverse().join('.') : null;
+}
+
+/**
+ * Full bundle identifier: prefix + the brand id with hyphens as dots.
+ *
+ * @param {string} prefix - reverse-DNS prefix (config or derived)
+ * @param {string} brandId - brand.id ('omega-playground')
+ * @returns {string}
+ */
+function composeBundleId(prefix, brandId) {
+  return `${prefix}.${String(brandId).toLowerCase().replace(/-+/g, '.')}`;
+}
+
+module.exports = { deriveBundleIdPrefix, composeBundleId };

package/dist/lib/claude-settings.js

@@ -0,0 +1,125 @@
+/**
+ * Brand Claude settings ([#62](https://github.com/Omega-JS-Stack/omega/issues/62)):
+ * a brand's committed `.claude/settings.json` registers the omega marketplace
+ * that the INSTALLED `@omega.js/manager` package carries (the plugin is
+ * vendored into it at prepare time) and enables the plugin, so every session
+ * in that brand — anyone's, on any machine — loads the omega skills and hooks.
+ *
+ * Gated on a PUBLISHED install: the manager package must carry the vendored
+ * `.claude-plugin/marketplace.json` AND be a real installed directory. In the
+ * local era the brand's `@omega.js/manager` is a SYMLINK into the monorepo —
+ * whose packages/manager carries that same generated marketplace — so the
+ * link itself is the signal, and this is a silent no-op —
+ * the developer's own user-scope install serves those sessions, and the brand
+ * file must never point at a machine-specific monorepo path.
+ *
+ * Non-clobbering: only the two omega keys are ever written; every other
+ * setting in the file is preserved, and an already-correct file is not
+ * rewritten.
+ */
+const fs = require('node:fs');
+const { join } = require('node:path');
+const { isDeepStrictEqual } = require('node:util');
+const jetpack = require('fs-jetpack');
+
+const SETTINGS_FILE = join('.claude', 'settings.json');
+const MARKETPLACE_KEY = 'extraKnownMarketplaces';
+const PLUGIN_KEY = 'enabledPlugins';
+const MARKETPLACE_NAME = 'omega';
+const PLUGIN_ID = 'omega@omega';
+// Brand-root-relative on purpose: portable to every machine and every clone.
+const MANAGER_PATH = './node_modules/@omega.js/manager';
+const MANAGER_DIR = join('node_modules', '@omega.js', 'manager');
+const VENDORED_MARKETPLACE = join(MANAGER_DIR, '.claude-plugin', 'marketplace.json');
+
+/**
+ * The marketplace entry a brand's settings must carry.
+ *
+ * @returns {object} - The `extraKnownMarketplaces.omega` value
+ */
+function marketplaceEntry() {
+  return { source: { source: 'directory', path: MANAGER_PATH } };
+}
+
+/**
+ * Does this brand have a PUBLISHED manager install (one carrying the vendored
+ * plugin marketplace)?
+ *
+ * A LOCALLY LINKED manager never counts, whatever it carries: the monorepo's
+ * own packages/manager grows the vendored marketplace on every prepare/pack,
+ * and `omega i local` symlinks the brand at it — so the file resolves through
+ * the link and the marketplace check alone would write settings pointing at
+ * one developer's machine. The symlink IS the local era.
+ *
+ * @param {string} brandRoot - Absolute brand monorepo root
+ * @returns {boolean}
+ */
+function hasVendoredPlugin(brandRoot) {
+  let stats;
+  try {
+    stats = fs.lstatSync(join(brandRoot, MANAGER_DIR));
+  } catch {
+    return false; // nothing installed yet
+  }
+  if (stats.isSymbolicLink()) {
+    return false;
+  }
+
+  return jetpack.exists(join(brandRoot, VENDORED_MARKETPLACE)) === 'file';
+}
+
+/**
+ * Ensure the brand's `.claude/settings.json` registers and enables the omega
+ * plugin from its installed manager package.
+ *
+ * @param {string} brandRoot - Absolute brand monorepo root
+ * @returns {'skipped'|'present'|'created'|'healed'|'invalid'} - What happened
+ */
+function ensureClaudeSettings(brandRoot) {
+  if (!hasVendoredPlugin(brandRoot)) {
+    return 'skipped';
+  }
+
+  const file = join(brandRoot, SETTINGS_FILE);
+  const raw = jetpack.read(file);
+
+  let settings = {};
+  if (raw !== undefined) {
+    try {
+      settings = JSON.parse(raw);
+    } catch (error) {
+      // A consumer's own malformed file — expected external condition, and
+      // never ours to overwrite. The caller warns.
+      return 'invalid';
+    }
+  }
+
+  const marketplaces = settings[MARKETPLACE_KEY] || {};
+  const plugins = settings[PLUGIN_KEY] || {};
+  if (isDeepStrictEqual(marketplaces[MARKETPLACE_NAME], marketplaceEntry()) && plugins[PLUGIN_ID] === true) {
+    return 'present';
+  }
+
+  const updated = {
+    ...settings,
+    [MARKETPLACE_KEY]: { ...marketplaces, [MARKETPLACE_NAME]: marketplaceEntry() },
+    [PLUGIN_KEY]: { ...plugins, [PLUGIN_ID]: true },
+  };
+  jetpack.write(file, `${JSON.stringify(updated, null, 2)}\n`);
+
+  return raw === undefined ? 'created' : 'healed';
+}
+
+module.exports = {
+  SETTINGS_FILE,
+  MARKETPLACE_KEY,
+  PLUGIN_KEY,
+  MARKETPLACE_NAME,
+  PLUGIN_ID,
+  MANAGER_PATH,
+  MANAGER_DIR,
+  VENDORED_MARKETPLACE,
+  marketplaceEntry,
+  hasVendoredPlugin,
+  ensureClaudeSettings,
+};