@sanqianx/ai-coding-event-bridge-console 0.5.1 → 0.6.0

package/src/bridge/core/semver.js

@@ -0,0 +1,23 @@
+'use strict';
+
+function parse(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(String(version));
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3])
+  };
+}
+
+function compare(a, b) {
+  const pa = parse(a);
+  const pb = parse(b);
+  if (!pa || !pb) return null;
+  if (pa.major !== pb.major) return pa.major < pb.major ? -1 : 1;
+  if (pa.minor !== pb.minor) return pa.minor < pb.minor ? -1 : 1;
+  if (pa.patch !== pb.patch) return pa.patch < pb.patch ? -1 : 1;
+  return 0;
+}
+
+module.exports = { parse, compare };

package/src/bridge/core/turn-identity.js

@@ -0,0 +1,127 @@
+'use strict';
+
+// F-024: DevTask-Radar used to synthesize '(No captured user prompt for this
+// turn)' as fake user text. Synthetic evidence is forbidden anywhere downstream.
+const SYNTHETIC_PROMPT_MARKERS = [
+  '(no captured user prompt for this turn)',
+  '(no user prompt captured)',
+  'unknown-session'
+];
+
+function isSyntheticPrompt(content) {
+  if (typeof content !== 'string') return false;
+  const trimmed = content.trim().toLowerCase();
+  return SYNTHETIC_PROMPT_MARKERS.includes(trimmed);
+}
+
+function orderBySequence(events) {
+  return [...events].sort((a, b) => {
+    if (a.sequence !== b.sequence) return a.sequence - b.sequence;
+    return String(a.eventId || '').localeCompare(String(b.eventId || ''));
+  });
+}
+
+function isDuplicateEvent(a, b) {
+  if (!a || !b) return false;
+  if (a.eventKey && b.eventKey && a.eventKey === b.eventKey) return true;
+  return (
+    a.source === b.source &&
+    a.eventType === b.eventType &&
+    (a.sessionId || null) === (b.sessionId || null) &&
+    (a.turnId || null) === (b.turnId || null) &&
+    a.content === b.content &&
+    a.eventId !== undefined &&
+    a.eventId === b.eventId
+  );
+}
+
+/**
+ * Deterministic turn projection over ordered events. Mirrors the journal's
+ * durable projection: user_prompt opens a turn; assistant_response closes the
+ * matching open turn (by turnId, or by sessionId when the client did not
+ * provide a turn id). Assistant events that cannot be tied to an open turn are
+ * orphan evidence — they are kept, never turned into fake prompts.
+ */
+function deriveTurnState(events) {
+  const ordered = orderBySequence(events.filter((e) => e && typeof e === 'object'));
+  const openTurns = new Map();
+  const closedTurns = new Map();
+  const orphanAssistantEvents = [];
+
+  const findOpenTurnForAssistant = (event) => {
+    if (event.turnId && openTurns.has(event.turnId)) return openTurns.get(event.turnId);
+    if (event.turnId) return null;
+    if (!event.sessionId) return null;
+    const matches = [...openTurns.values()].filter((t) => t.sessionId === event.sessionId);
+    if (matches.length === 1) return matches[0];
+    return null;
+  };
+
+  for (const event of ordered) {
+    if (event.eventType === 'user_prompt') {
+      if (!event.turnId) continue; // unverifiable prompt: identity layer marks it, no fake turn
+      if (openTurns.has(event.turnId) || closedTurns.has(event.turnId)) {
+        const turn = openTurns.get(event.turnId) || closedTurns.get(event.turnId);
+        turn.userEvents.push(event);
+        continue;
+      }
+      openTurns.set(event.turnId, {
+        turnId: event.turnId,
+        sessionId: event.sessionId || null,
+        source: event.source,
+        startSequence: event.sequence,
+        endSequence: null,
+        userEvents: [event],
+        assistantEvents: []
+      });
+      continue;
+    }
+    if (event.eventType === 'assistant_response') {
+      const turn = findOpenTurnForAssistant(event);
+      if (!turn) {
+        orphanAssistantEvents.push(event);
+        continue;
+      }
+      turn.assistantEvents.push(event);
+      turn.endSequence = event.sequence;
+      openTurns.delete(turn.turnId);
+      closedTurns.set(turn.turnId, turn);
+      continue;
+    }
+    if (event.eventType === 'session_end' && event.sessionId) {
+      for (const turn of [...openTurns.values()]) {
+        if (turn.sessionId === event.sessionId) {
+          turn.endSequence = event.sequence;
+          openTurns.delete(turn.turnId);
+          closedTurns.set(turn.turnId, turn);
+        }
+      }
+    }
+  }
+
+  return {
+    openTurns: [...openTurns.values()],
+    closedTurns: [...closedTurns.values()],
+    orphanAssistantEvents
+  };
+}
+
+function assertNoSyntheticEvidence(events) {
+  for (const event of events) {
+    if (event && event.role === 'user' && isSyntheticPrompt(event.content)) {
+      throw new Error(`synthetic user prompt is forbidden: ${String(event.content).slice(0, 60)}`);
+    }
+    if (event && typeof event.sessionId === 'string' && event.sessionId.toLowerCase() === 'unknown-session') {
+      throw new Error('unknown-session is forbidden');
+    }
+  }
+  return true;
+}
+
+module.exports = {
+  isSyntheticPrompt,
+  orderBySequence,
+  isDuplicateEvent,
+  deriveTurnState,
+  assertNoSyntheticEvidence
+};

package/src/bridge/index.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const packageInfo = require('../../package.json');
+const { bridgeHome } = require('./core/paths');
+const { Journal, JournalValidationError, JournalCorruptError, EVENT_SCHEMA, BOUNDARY_SCHEMA } = require('./core/journal');
+const { ConsumerRegistry } = require('./core/consumer-registry');
+const { compactJournal } = require('./core/compaction');
+const { ensureRuntimeHome } = require('./core/runtime-home');
+const semver = require('./core/semver');
+const { validateAndNormalizeEvent, EventSchemaError } = require('./core/event-schema');
+const {
+  normalizeGitUrl,
+  resolveRepoContext,
+  REPO_IDENTITY_SCHEMA,
+  buildRepoIdentityV1,
+  isValidRepoIdentityV1,
+  repoIdentityKey,
+  sameRepoIdentity,
+  workspaceIdFor
+} = require('./core/repo-context');
+const {
+  isSyntheticPrompt,
+  orderBySequence,
+  isDuplicateEvent,
+  deriveTurnState,
+  assertNoSyntheticEvidence
+} = require('./core/turn-identity');
+const { normalizeClaudeCode, normalizeCodex, normalizeOpenCode } = require('./core/normalizer');
+const projectRegistry = require('./core/project-registry');
+const commitProjection = require('./core/commit-projection');
+const { journalFor, globalJournalDir, projectJournalDir } = require('./core/journal-router');
+const { ConversationQuery } = require('./query/conversation-query');
+const claudeHookEntry = require('./connectors/claude-code/hook-entry');
+const claudeInstaller = require('./installers/claude-code/installer');
+const codexInstaller = require('./installers/codex/installer');
+const openCodeInstaller = require('./installers/opencode/installer');
+const zcodeInstaller = require('./installers/zcode/installer');
+const { createBridge } = require('./core/bridge');
+
+module.exports = {
+  packageName: packageInfo.name,
+  version: packageInfo.version,
+  bridgeHome,
+  Journal,
+  JournalValidationError,
+  JournalCorruptError,
+  EVENT_SCHEMA,
+  BOUNDARY_SCHEMA,
+  ConsumerRegistry,
+  compactJournal,
+  ensureRuntimeHome,
+  semver,
+  validateAndNormalizeEvent,
+  EventSchemaError,
+  normalizeGitUrl,
+  resolveRepoContext,
+  REPO_IDENTITY_SCHEMA,
+  buildRepoIdentityV1,
+  isValidRepoIdentityV1,
+  repoIdentityKey,
+  sameRepoIdentity,
+  workspaceIdFor,
+  isSyntheticPrompt,
+  orderBySequence,
+  isDuplicateEvent,
+  deriveTurnState,
+  assertNoSyntheticEvidence,
+  normalizeClaudeCode,
+  normalizeCodex,
+  normalizeOpenCode,
+  projectRegistry,
+  commitProjection,
+  journalFor,
+  globalJournalDir,
+  projectJournalDir,
+  ConversationQuery,
+  claudeHookEntry,
+  claudeInstaller,
+  createBridge,
+  installers: {
+    claudeCode: claudeInstaller,
+    codex: codexInstaller,
+    openCode: openCodeInstaller,
+    zcode: zcodeInstaller
+  }
+};

package/src/bridge/installers/claude-code/installer.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { ensureRuntimeHome } = require('../../core/runtime-home');
+const { ConsumerRegistry } = require('../../core/consumer-registry');
+const { readJsonIfExists, writeJsonAtomicSync } = require('../../core/fs-utils');
+
+const HOOK_EVENTS = ['UserPromptSubmit', 'Stop'];
+
+class InstallerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'InstallerError';
+  }
+}
+
+function shimPathFor(homeDir) {
+  return path.join(homeDir, 'bin', 'bridge-hook.cjs');
+}
+
+function managedCommand(shimPath) {
+  return `node "${shimPath}"`;
+}
+
+function isManagedCommand(command, shimPath) {
+  return typeof command === 'string' && command.includes(shimPath);
+}
+
+function readSettings(settingsFile) {
+  const settings = readJsonIfExists(settingsFile);
+  if (settings === null) {
+    if (fs.existsSync(settingsFile)) {
+      throw new InstallerError(`settings file is not valid JSON: ${settingsFile}`);
+    }
+    return { hooks: {} };
+  }
+  if (typeof settings !== 'object' || settings === null) {
+    throw new InstallerError(`settings file must contain a JSON object: ${settingsFile}`);
+  }
+  if (!settings.hooks || typeof settings.hooks !== 'object') {
+    settings.hooks = {};
+  }
+  return settings;
+}
+
+function upsertManagedEntries(settings, shimPath) {
+  const command = managedCommand(shimPath);
+  const changed = [];
+  for (const eventName of HOOK_EVENTS) {
+    if (!Array.isArray(settings.hooks[eventName])) {
+      settings.hooks[eventName] = [];
+    }
+    const alreadyManaged = settings.hooks[eventName].some(
+      (group) =>
+        group &&
+        Array.isArray(group.hooks) &&
+        group.hooks.some((hook) => hook && hook.type === 'command' && isManagedCommand(hook.command, shimPath))
+    );
+    if (alreadyManaged) continue;
+    settings.hooks[eventName].push({
+      matcher: '*',
+      hooks: [{ type: 'command', command }]
+    });
+    changed.push(eventName);
+  }
+  return changed;
+}
+
+function removeManagedEntries(settings, shimPath) {
+  const removed = [];
+  for (const eventName of Object.keys(settings.hooks)) {
+    const groups = settings.hooks[eventName];
+    if (!Array.isArray(groups)) continue;
+    const kept = groups.filter(
+      (group) =>
+        !(
+          group &&
+          Array.isArray(group.hooks) &&
+          group.hooks.some((hook) => hook && hook.type === 'command' && isManagedCommand(hook.command, shimPath))
+        )
+    );
+    if (kept.length !== groups.length) removed.push(eventName);
+    if (kept.length === 0) {
+      delete settings.hooks[eventName];
+    } else {
+      settings.hooks[eventName] = kept;
+    }
+  }
+  return removed;
+}
+
+// Host-level consumer registration is owned by the host (Project-Knowledge
+// registers "project-knowledge" once via createBridge()). Connector
+// installers mutate the registry only on explicit opt-in:
+//   registerConsumer: true   -> register consumerName (legacy convenience)
+//   unregisterConsumer: true -> unregister consumerName during uninstall
+// Uninstalling a connector never deletes the shared runtime home.
+async function installClaudeCodeHook({ homeDir, consumerName, consumerMeta = {}, registerConsumer = false, settingsFile, version } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = settingsFile || path.join(os.homedir(), '.claude', 'settings.json');
+  const runtime = await ensureRuntimeHome({ homeDir: home, version });
+  const registry = new ConsumerRegistry(home);
+  if (consumerName && registerConsumer) {
+    await registry.registerConsumer(consumerName, consumerMeta);
+  }
+  const settings = readSettings(target);
+  const added = upsertManagedEntries(settings, shimPathFor(home));
+  writeJsonAtomicSync(target, settings);
+  return { added, settingsFile: target, runtime, consumers: (await registry.getConsumers()).map((c) => c.name) };
+}
+
+async function statusClaudeCodeHook({ homeDir, settingsFile } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = settingsFile || path.join(os.homedir(), '.claude', 'settings.json');
+  const settings = readSettings(target);
+  const shimPath = shimPathFor(home);
+  const managedEvents = [];
+  let thirdPartyCount = 0;
+  for (const eventName of Object.keys(settings.hooks || {})) {
+    const groups = settings.hooks[eventName];
+    if (!Array.isArray(groups)) continue;
+    let hasManaged = false;
+    for (const group of groups) {
+      for (const hook of (group && group.hooks) || []) {
+        if (hook && hook.type === 'command') {
+          if (isManagedCommand(hook.command, shimPath)) {
+            hasManaged = true;
+          } else {
+            thirdPartyCount++;
+          }
+        }
+      }
+    }
+    if (hasManaged) managedEvents.push(eventName);
+  }
+  const registry = new ConsumerRegistry(home);
+  return {
+    installed: HOOK_EVENTS.every((eventName) => managedEvents.includes(eventName)),
+    managedEvents,
+    thirdPartyCount,
+    consumers: (await registry.getConsumers()).map((c) => c.name)
+  };
+}
+
+async function repairClaudeCodeHook({ homeDir, consumerName, consumerMeta = {}, registerConsumer = false, settingsFile, version } = {}) {
+  return installClaudeCodeHook({ homeDir, consumerName, consumerMeta, registerConsumer, settingsFile, version });
+}
+
+async function uninstallClaudeCodeHook({ homeDir, consumerName, unregisterConsumer = false, settingsFile } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = settingsFile || path.join(os.homedir(), '.claude', 'settings.json');
+  const registry = new ConsumerRegistry(home);
+  const settings = readSettings(target);
+  const removed = removeManagedEntries(settings, shimPathFor(home));
+  writeJsonAtomicSync(target, settings);
+  let consumerUnregistered = false;
+  if (consumerName && unregisterConsumer) {
+    await registry.unregisterConsumer(consumerName);
+    consumerUnregistered = true;
+  }
+  return {
+    removed: true,
+    removedEvents: removed,
+    settingsFile: target,
+    consumerUnregistered,
+    consumers: (await registry.getConsumers()).map((c) => c.name)
+  };
+}
+
+module.exports = {
+  HOOK_EVENTS,
+  InstallerError,
+  installClaudeCodeHook,
+  statusClaudeCodeHook,
+  repairClaudeCodeHook,
+  uninstallClaudeCodeHook,
+  managedCommand,
+  isManagedCommand
+};

package/src/bridge/installers/codex/installer.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { ensureRuntimeHome } = require('../../core/runtime-home');
+const { ConsumerRegistry } = require('../../core/consumer-registry');
+
+class InstallerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'InstallerError';
+  }
+}
+
+function shimPathFor(homeDir) {
+  return path.join(homeDir, 'bin', 'bridge-hook.cjs');
+}
+
+function managedNotifyCommand(shimPath) {
+  return `["node", "${shimPath}"]`;
+}
+
+function isManagedNotifyLine(line, shimPath) {
+  return /^\s*notify\s*=/.test(line) && line.includes(shimPath);
+}
+
+/**
+ * Codex config.toml merge. The notify entry is a single TOML array; we install
+ * ours only when the key is absent, and refuse to displace a third-party
+ * notifier (report conflict instead). Uninstall removes the entry only when it
+ * is Bridge-managed.
+ */
+// Registry mutations are host-owned; registerConsumer/unregisterConsumer are
+// explicit opt-ins. Uninstall never deletes the shared runtime home.
+async function installCodexNotify({ homeDir, consumerName, consumerMeta = {}, registerConsumer = false, configFile, version } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = configFile || path.join(os.homedir(), '.codex', 'config.toml');
+  const runtime = await ensureRuntimeHome({ homeDir: home, version });
+  const registry = new ConsumerRegistry(home);
+  if (consumerName && registerConsumer) await registry.registerConsumer(consumerName, consumerMeta);
+
+  const existing = fs.existsSync(target) ? fs.readFileSync(target, 'utf8') : '';
+  const lines = existing.split(/\r?\n/);
+  let notifyIndex = -1;
+  let alreadyManaged = false;
+  let thirdParty = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^\s*notify\s*=/.test(lines[i])) {
+      notifyIndex = i;
+      if (isManagedNotifyLine(lines[i], shimPathFor(home))) alreadyManaged = true;
+      else thirdParty = true;
+      break;
+    }
+  }
+  if (thirdParty && !alreadyManaged) {
+    return {
+      installed: false,
+      conflict: true,
+      reason: 'third-party-notify-present',
+      settingsFile: target,
+      runtime
+    };
+  }
+  if (!alreadyManaged) {
+    const entry = `notify = ${managedNotifyCommand(shimPathFor(home))}`;
+    if (notifyIndex === -1) {
+      while (lines.length && lines[lines.length - 1].trim() === '') lines.pop();
+      lines.push('', entry);
+    } else {
+      lines[notifyIndex] = entry;
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, lines.join('\n').replace(/^\n/, '') + '\n');
+  }
+  return { installed: true, conflict: false, settingsFile: target, runtime };
+}
+
+async function statusCodexNotify({ homeDir, configFile } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = configFile || path.join(os.homedir(), '.codex', 'config.toml');
+  if (!fs.existsSync(target)) return { installed: false, thirdParty: false };
+  const line = fs.readFileSync(target, 'utf8').split(/\r?\n/).find(l => /^\s*notify\s*=/.test(l));
+  if (!line) return { installed: false, thirdParty: false };
+  return { installed: isManagedNotifyLine(line, shimPathFor(home)), thirdParty: !isManagedNotifyLine(line, shimPathFor(home)) };
+}
+
+async function uninstallCodexNotify({ homeDir, consumerName, unregisterConsumer = false, configFile } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = configFile || path.join(os.homedir(), '.codex', 'config.toml');
+  const registry = new ConsumerRegistry(home);
+  if (fs.existsSync(target)) {
+    const lines = fs.readFileSync(target, 'utf8').split(/\r?\n/);
+    const kept = lines.filter(line => !(isManagedNotifyLine(line, shimPathFor(home))));
+    if (kept.length !== lines.length) {
+      fs.writeFileSync(target, kept.join('\n').replace(/\n{3,}/g, '\n\n'));
+    }
+  }
+  let consumerUnregistered = false;
+  if (consumerName && unregisterConsumer) {
+    await registry.unregisterConsumer(consumerName);
+    consumerUnregistered = true;
+  }
+  return { removed: true, consumerUnregistered, consumers: (await registry.getConsumers()).map(c => c.name) };
+}
+
+module.exports = {
+  InstallerError,
+  installCodexNotify,
+  statusCodexNotify,
+  uninstallCodexNotify,
+  managedNotifyCommand,
+  isManagedNotifyLine
+};

package/src/bridge/installers/opencode/installer.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { ensureRuntimeHome } = require('../../core/runtime-home');
+const { ConsumerRegistry } = require('../../core/consumer-registry');
+
+const PLUGIN_FILE_NAME = 'ai-coding-event-bridge.js';
+
+function shimPathFor(homeDir) {
+  return path.join(homeDir, 'bin', 'bridge-hook.cjs');
+}
+
+function pluginSource(shimPath) {
+  return `// Installed by @sanqianx/ai-coding-event-bridge. Captures user/assistant
+// lifecycle events into the local durable Bridge journal via the stable shim.
+// No HTTP endpoint is required; removing the file removes the integration.
+const { spawn } = require('child_process');
+module.exports = {
+  id: 'ai-coding-event-bridge',
+  init() {
+    return {
+      event(event) {
+        if (!event || (event.type !== 'user' && event.type !== 'assistant')) return;
+        const payload = {
+          type: event.type,
+          sessionId: event.sessionID || event.sessionId || null,
+          turnId: event.turnID || event.turnId || null,
+          cwd: event.cwd || process.cwd(),
+          text: typeof event.text === 'string' ? event.text : null
+        };
+        const child = spawn('node', [${JSON.stringify(shimPath)}], { stdio: ['pipe', 'ignore', 'ignore'] });
+        child.on('error', () => {});
+        child.stdin.write(JSON.stringify(payload));
+        child.stdin.end();
+      }
+    };
+  }
+};
+`;
+}
+
+// Registry mutations are host-owned; registerConsumer/unregisterConsumer are
+// explicit opt-ins. Uninstall removes only the managed plugin file and never
+// touches third-party plugins or the shared runtime home.
+async function installOpenCodePlugin({ homeDir, consumerName, consumerMeta = {}, registerConsumer = false, pluginsDir, version } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = pluginsDir || path.join(os.homedir(), '.config', 'opencode', 'plugin');
+  const runtime = await ensureRuntimeHome({ homeDir: home, version });
+  const registry = new ConsumerRegistry(home);
+  if (consumerName && registerConsumer) await registry.registerConsumer(consumerName, consumerMeta);
+  fs.mkdirSync(target, { recursive: true });
+  const file = path.join(target, PLUGIN_FILE_NAME);
+  fs.writeFileSync(file, pluginSource(shimPathFor(home)));
+  return { installed: true, pluginFile: file, runtime };
+}
+
+async function statusOpenCodePlugin({ homeDir, pluginsDir } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = pluginsDir || path.join(os.homedir(), '.config', 'opencode', 'plugin');
+  const file = path.join(target, PLUGIN_FILE_NAME);
+  const exists = fs.existsSync(file);
+  let managed = false;
+  let thirdPartyFiles = 0;
+  if (fs.existsSync(target)) {
+    for (const entry of fs.readdirSync(target)) {
+      if (entry === PLUGIN_FILE_NAME) continue;
+      if (entry.endsWith('.js') || entry.endsWith('.ts')) thirdPartyFiles++;
+    }
+  }
+  if (exists) {
+    managed = fs.readFileSync(file, 'utf8').includes('ai-coding-event-bridge');
+  }
+  return { installed: managed && exists, pluginFile: file, thirdPartyFiles };
+}
+
+async function uninstallOpenCodePlugin({ homeDir, consumerName, unregisterConsumer = false, pluginsDir } = {}) {
+  const home = homeDir || path.join(os.homedir(), '.ai-coding-event-bridge');
+  const target = pluginsDir || path.join(os.homedir(), '.config', 'opencode', 'plugin');
+  const registry = new ConsumerRegistry(home);
+  const file = path.join(target, PLUGIN_FILE_NAME);
+  try {
+    fs.rmSync(file, { force: true });
+  } catch (_) {
+    // Already gone.
+  }
+  let consumerUnregistered = false;
+  if (consumerName && unregisterConsumer) {
+    await registry.unregisterConsumer(consumerName);
+    consumerUnregistered = true;
+  }
+  return { removed: true, consumerUnregistered, consumers: (await registry.getConsumers()).map(c => c.name) };
+}
+
+module.exports = { installOpenCodePlugin, statusOpenCodePlugin, uninstallOpenCodePlugin, PLUGIN_FILE_NAME };