omnigateway 0.3.0 → 0.4.0

package/gateway.js

@@ -5235,7 +5235,7 @@ var require_dist = __commonJS(function(exports) {
 
 // apps/gateway/src/index.ts
 import { existsSync as existsSync2 } from "fs";
-import { resolve as resolve3 } from "path";
+import { dirname as dirname5, join as join6, resolve as resolve6 } from "path";
 
 // packages/control/src/adminAuth.ts
 import { hash, verify } from "@node-rs/argon2";
@@ -5403,6 +5403,7 @@ var FIELD_ORDER = [
   "requestedModel",
   "credentialId",
   "apiKeyId",
+  "plugin",
   "snapshotId",
   "attempt",
   "attempts",
@@ -25024,6 +25025,39 @@ CREATE TABLE usage_rollup (
 -- cannot drift into disagreeing about which rows count.
 `;
 
+// packages/store/src/sqlite/migrations/011_plugin_migrations.sql
+var _011_plugin_migrations_default = `-- The plugin migration ledger, kept deliberately apart from core's \`migrations\`.
+--
+-- Core's track is a single ascending integer owned by this repository. A plugin
+-- ships its own numbered migrations and knows nothing about ours, so the two
+-- cannot share a counter: if they did, installing a plugin would consume numbers
+-- that core's next migration then collides with, and the collision would surface
+-- as "migration already applied" on an upgrade rather than as anything legible.
+-- Core's next migration is 012 regardless of how many migrations any plugin
+-- ships, and a plugin's version 1 is its own version 1 forever.
+--
+-- The primary key is (plugin_id, version) rather than a surrogate id because
+-- that pair *is* the identity: applying the same version twice is the thing this
+-- table exists to prevent, and a uniqueness constraint states it once instead of
+-- leaving it to whichever code path happens to check first.
+--
+-- \`applied_at\` is milliseconds, matching every other timestamp in this schema.
+-- It is recorded for an operator reading the table during an incident, not read
+-- by the host: the host asks only whether a row exists.
+--
+-- Note what is *not* here: no row for the plugin's tables, and no cascade. A
+-- plugin's tables outlive its rows here on purpose \u2014 see \`PluginRepo.dropAll\`
+-- and \`orphanTables\`. Dropping a table because a plugin is currently absent
+-- destroys data irreversibly, and a restore is precisely the moment a plugin is
+-- most likely to be absent.
+CREATE TABLE plugin_migrations (
+  plugin_id TEXT NOT NULL,
+  version INTEGER NOT NULL,
+  applied_at INTEGER NOT NULL,
+  PRIMARY KEY (plugin_id, version)
+);
+`;
+
 // packages/store/src/sqlite/rollup.ts
 var HOUR_MS = 3600000;
 function hourOf(at) {
@@ -25258,7 +25292,8 @@ var MIGRATIONS = [
   { id: 7, sql: _007_quota_samples_default },
   { id: 8, sql: _008_body_logging_default },
   { id: 9, sql: _009_key_limits_default },
-  { id: 10, sql: _010_usage_rollup_default, after: rebuildRollup }
+  { id: 10, sql: _010_usage_rollup_default, after: rebuildRollup },
+  { id: 11, sql: _011_plugin_migrations_default }
 ];
 function openDb(path) {
   const db = new Database(path, { create: true });
@@ -25411,6 +25446,168 @@ function createMaintenanceRepo(db) {
     }
   };
 }
+// packages/store/src/sqlite/plugins.ts
+var PLUGIN_ID = /^[a-z][a-z0-9-]{0,31}$/;
+var TABLE_NAME = /^[a-z][a-z0-9_]{0,31}$/;
+var PLACEHOLDER = /\{\{([^{}]*)\}\}/g;
+var CORE_TABLES = [
+  "api_keys",
+  "credential_health",
+  "credentials",
+  "migrations",
+  "plugin_migrations",
+  "quota_samples",
+  "quota_windows",
+  "request_bodies",
+  "request_logs",
+  "settings",
+  "usage_daily",
+  "usage_rollup",
+  "virtual_models"
+];
+var CORE_TABLE_REFERENCE = new RegExp(`\\b(?:${CORE_TABLES.join("|")})\\b`);
+var PREFIX3 = "plugin_";
+function stripNoise(sql) {
+  let out = "";
+  let i = 0;
+  while (i < sql.length) {
+    const c = sql[i];
+    const next = sql[i + 1];
+    if (c === "'") {
+      i += 1;
+      while (i < sql.length) {
+        if (sql[i] === "'") {
+          if (sql[i + 1] === "'")
+            i += 2;
+          else
+            break;
+        } else
+          i += 1;
+      }
+      i += 1;
+      out += " ";
+    } else if (c === "-" && next === "-") {
+      while (i < sql.length && sql[i] !== `
+`)
+        i += 1;
+      out += " ";
+    } else if (c === "/" && next === "*") {
+      i += 2;
+      while (i < sql.length && !(sql[i] === "*" && sql[i + 1] === "/"))
+        i += 1;
+      i += 2;
+      out += " ";
+    } else {
+      out += c;
+      i += 1;
+    }
+  }
+  return out;
+}
+function tableFor(pluginId, name) {
+  return `"${PREFIX3}${pluginId}_${name}"`;
+}
+function prefixFor(pluginId) {
+  return `${PREFIX3}${pluginId}_`;
+}
+function assertPluginId(pluginId) {
+  if (!PLUGIN_ID.test(pluginId)) {
+    throw new Error(`plugin id ${JSON.stringify(pluginId)} is not a valid identifier`);
+  }
+}
+function prepare(pluginId, sql) {
+  assertPluginId(pluginId);
+  const expanded = sql.replace(PLACEHOLDER, (_match, name) => {
+    if (!TABLE_NAME.test(name)) {
+      throw new Error(`plugin table placeholder ${JSON.stringify(name)} must match ${TABLE_NAME.source}`);
+    }
+    return tableFor(pluginId, name);
+  });
+  const found = CORE_TABLE_REFERENCE.exec(stripNoise(expanded));
+  if (found !== null) {
+    throw new Error(`plugin sql may not reference the core table ${found[0]}`);
+  }
+  return expanded;
+}
+function toBinding(value, index) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || value instanceof Uint8Array) {
+    return value;
+  }
+  throw new Error(`plugin sql parameter ${index} is not a bindable value`);
+}
+var toBindings = (params) => (params ?? []).map(toBinding);
+function createPluginRepo(db) {
+  const pluginTables = () => db.query("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name").all().map((r) => r.name).filter((name) => name.startsWith(PREFIX3) && name !== "plugin_migrations");
+  const tablesOf = (pluginId) => {
+    const prefix = prefixFor(pluginId);
+    return pluginTables().filter((name) => name.startsWith(prefix));
+  };
+  const appliedVersions = (pluginId) => new Set(db.query("SELECT version FROM plugin_migrations WHERE plugin_id = ?").all(pluginId).map((r) => r.version));
+  return {
+    migrate(pluginId, migrations) {
+      assertPluginId(pluginId);
+      const done = appliedVersions(pluginId);
+      const applied = [];
+      const ordered = [...migrations].sort((a, b) => a.version - b.version);
+      for (const migration of ordered) {
+        if (done.has(migration.version))
+          continue;
+        try {
+          if (!Number.isSafeInteger(migration.version) || migration.version < 1) {
+            throw new Error("migration version must be a positive integer");
+          }
+          const sql = prepare(pluginId, migration.sql);
+          db.transaction(() => {
+            db.run(sql);
+            db.run("INSERT INTO plugin_migrations (plugin_id, version, applied_at) VALUES (?,?,?)", [pluginId, migration.version, Date.now()]);
+          })();
+          applied.push(migration.version);
+        } catch (error51) {
+          return {
+            applied,
+            failed: {
+              version: migration.version,
+              reason: error51 instanceof Error ? error51.message : String(error51)
+            }
+          };
+        }
+      }
+      return { applied };
+    },
+    run(pluginId, sql, params) {
+      db.run(prepare(pluginId, sql), toBindings(params));
+    },
+    all(pluginId, sql, params) {
+      return db.prepare(prepare(pluginId, sql)).all(...toBindings(params));
+    },
+    get(pluginId, sql, params) {
+      const row = db.prepare(prepare(pluginId, sql)).get(...toBindings(params));
+      return row === null || row === undefined ? null : row;
+    },
+    transaction(pluginId, fn) {
+      assertPluginId(pluginId);
+      return db.transaction(fn)();
+    },
+    listTables(pluginId) {
+      assertPluginId(pluginId);
+      return tablesOf(pluginId);
+    },
+    dropAll(pluginId) {
+      assertPluginId(pluginId);
+      const tables = tablesOf(pluginId);
+      db.transaction(() => {
+        for (const table of tables)
+          db.run(`DROP TABLE IF EXISTS "${table}"`);
+        db.run("DELETE FROM plugin_migrations WHERE plugin_id = ?", [pluginId]);
+      })();
+      return tables.length;
+    },
+    orphanTables(installedIds) {
+      const prefixes = installedIds.filter((id) => PLUGIN_ID.test(id)).map(prefixFor);
+      return pluginTables().filter((name) => !prefixes.some((p) => name.startsWith(p)));
+    }
+  };
+}
 // packages/rtk/src/catalog.ts
 var RTK_FILTER_IDS = [
   "git-diff",
@@ -25723,7 +25920,8 @@ async function createStore(opts) {
       keys: createKeyRepo(db, logger2),
       usage: createUsageRepo(db),
       bodies: createBodyRepo(db, opts.encryptionKey, bodiesDirFor(opts.path)),
-      maintenance: createMaintenanceRepo(db)
+      maintenance: createMaintenanceRepo(db),
+      plugins: createPluginRepo(db)
     };
   };
   let handle = open();
@@ -25796,6 +25994,22 @@ async function createStore(opts) {
       snapshotTo: (path) => handle.maintenance.snapshotTo(path),
       inspect: (path) => handle.maintenance.inspect(path)
     },
+    plugins: {
+      migrate: (pluginId, migrations) => handle.plugins.migrate(pluginId, migrations),
+      run: (pluginId, sql, params) => handle.plugins.run(pluginId, sql, params),
+      all(pluginId, sql, params) {
+        return handle.plugins.all(pluginId, sql, params);
+      },
+      get(pluginId, sql, params) {
+        return handle.plugins.get(pluginId, sql, params);
+      },
+      transaction(pluginId, fn) {
+        return handle.plugins.transaction(pluginId, fn);
+      },
+      listTables: (pluginId) => handle.plugins.listTables(pluginId),
+      dropAll: (pluginId) => handle.plugins.dropAll(pluginId),
+      orphanTables: (installedIds) => handle.plugins.orphanTables(installedIds)
+    },
     routing: {
       version: () => handle.db.query("PRAGMA data_version").get()?.data_version ?? 0,
       subscribe(listener) {
@@ -26211,6 +26425,13 @@ async function swapIn(deps, candidate) {
       reason: error51 instanceof Error ? error51.message : "unknown"
     });
   }
+  try {
+    await deps.reapplyPluginSchema?.();
+  } catch (error51) {
+    (deps.logger ?? noopLogger).warn("plugin schema not reapplied after the swap; restart", {
+      reason: error51 instanceof Error ? error51.message : "unknown"
+    });
+  }
   return {
     ok: true,
     counts: inspection.counts,
@@ -26584,13 +26805,89 @@ import {
   copyFileSync,
   mkdirSync,
   readdirSync,
+  readFileSync,
   realpathSync,
   renameSync,
   rmSync,
   statfsSync,
-  statSync
+  statSync,
+  writeFileSync
 } from "fs";
 import { join as join3 } from "path";
+
+// packages/plugin-api/src/version.ts
+var PLUGIN_API_VERSION = 1;
+var DASHBOARD_SDK_VERSION = "0.1.0";
+// packages/plugin-api/src/manifest.ts
+var CAPABILITIES = [
+  "storage",
+  "files",
+  "net:outbound",
+  "events:request",
+  "events:limit"
+];
+var ID_PATTERN = /^[a-z][a-z0-9-]{0,31}$/;
+var idSchema = exports_external.string().regex(ID_PATTERN, "id must match /^[a-z][a-z0-9-]{0,31}$/");
+var entrySchema = exports_external.string().min(1).refine((p) => !p.startsWith("/") && !p.split("/").includes(".."), {
+  message: "entry must be a relative path with no '..' segment"
+});
+var originSchema = exports_external.string().refine((value) => {
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return false;
+  }
+  if (url2.protocol !== "https:" && url2.protocol !== "http:")
+    return false;
+  if (url2.hostname === "")
+    return false;
+  if (url2.pathname !== "/" || url2.search !== "" || url2.hash !== "")
+    return false;
+  return value === url2.origin || value === `${url2.origin}/`;
+}, { message: "origin must be scheme://host with no path, query or fragment" });
+var navSchema = exports_external.object({
+  label: exports_external.string().min(1).max(32)
+}).strict();
+var manifestSchema = exports_external.object({
+  id: idSchema,
+  name: exports_external.string().min(1).max(64),
+  version: exports_external.string().min(1).max(32),
+  api: exports_external.number().int().nonnegative(),
+  sdk: exports_external.string().min(1).max(32).optional(),
+  server: entrySchema.optional(),
+  ui: entrySchema.optional(),
+  nav: navSchema.optional(),
+  capabilities: exports_external.array(exports_external.enum(CAPABILITIES)).default([]),
+  origins: exports_external.array(originSchema).min(1).optional(),
+  defaults: exports_external.record(exports_external.string(), exports_external.unknown()).optional()
+}).strict().refine((m) => m.server !== undefined || m.ui !== undefined, {
+  message: "manifest must declare a server entry, a ui entry, or both"
+}).refine((m) => m.ui === undefined || m.sdk !== undefined, {
+  message: "a ui entry requires an sdk range"
+}).refine((m) => !m.capabilities.includes("net:outbound") || m.origins !== undefined, {
+  message: "net:outbound requires origins"
+}).refine((m) => m.capabilities.includes("net:outbound") || m.origins === undefined, {
+  message: "origins requires the net:outbound capability"
+});
+function safeParseManifest(input) {
+  const parsed = manifestSchema.safeParse(input);
+  if (parsed.success)
+    return { ok: true, manifest: parsed.data };
+  const first = parsed.error.issues[0];
+  const path = first?.path.join(".") ?? "";
+  const message = first?.message ?? "invalid manifest";
+  return { ok: false, reason: path === "" ? message : `${path}: ${message}` };
+}
+function isApiCompatible(manifest) {
+  return manifest.api === PLUGIN_API_VERSION;
+}
+
+// packages/control/src/plugins.ts
+var MAX_PLUGIN_BYTES = 32 * 1024 * 1024;
+var decoder2 = new TextDecoder;
+
+// packages/control/src/nodeFs.ts
 function nodeDatabaseFs() {
   const dirBytes = (dir) => {
     let entries;
@@ -27870,9 +28167,15 @@ function logLimit(requested) {
 async function recentLogs(store, requested) {
   return store.usage.recent(logLimit(requested));
 }
+// packages/plugin-api/src/events.ts
+var WINDOW_MS2 = {
+  "1m": 60000,
+  "5h": 5 * 60 * 60 * 1000,
+  "1w": 7 * 24 * 60 * 60 * 1000
+};
 // apps/gateway/src/app.ts
-import { existsSync, realpathSync as realpathSync2 } from "fs";
-import { resolve as resolve2, sep as sep2 } from "path";
+import { existsSync, realpathSync as realpathSync3 } from "fs";
+import { resolve as resolve3, sep as sep3 } from "path";
 
 // node_modules/.bun/memoirist@0.4.0/node_modules/memoirist/dist/bun/index.js
 var Y = (v, b) => {
@@ -36713,13 +37016,13 @@ async function* streamResponse(response) {
   const body2 = response.body;
   if (!body2)
     return;
-  const reader = body2.getReader(), decoder2 = new TextDecoder;
+  const reader = body2.getReader(), decoder3 = new TextDecoder;
   try {
     for (;; ) {
       const { done, value } = await reader.read();
       if (done)
         break;
-      typeof value == "string" ? yield value : yield decoder2.decode(value);
+      typeof value == "string" ? yield value : yield decoder3.decode(value);
     }
   } finally {
     reader.releaseLock();
@@ -42237,12 +42540,12 @@ var _Elysia = class _Elysia2 {
     }), this) : (typeof this.server?.reload == "function" && this.server.reload(this.server || {}), this._handle = composeGeneralHandler(this), this);
   }
   get fetch() {
-    const fetch = this.config.aot ? composeGeneralHandler(this) : createDynamicHandler(this);
+    const fetch2 = this.config.aot ? composeGeneralHandler(this) : createDynamicHandler(this);
     return Object.defineProperty(this, "fetch", {
-      value: fetch,
+      value: fetch2,
       configurable: true,
       writable: true
-    }), fetch;
+    }), fetch2;
   }
   get modules() {
     return this.promisedModules;
@@ -43070,58 +43373,6 @@ function openaiRateLimitHeaders(headroom, now) {
   return headers;
 }
 
-// apps/gateway/src/quiesce.ts
-function createQuiesceLatch() {
-  let admitting = true;
-  let inFlight = 0;
-  let onIdle = null;
-  const settle = () => {
-    if (inFlight > 0 || onIdle === null)
-      return;
-    const resolve2 = onIdle;
-    onIdle = null;
-    resolve2();
-  };
-  return {
-    enter() {
-      if (!admitting)
-        return null;
-      inFlight++;
-      let released = false;
-      return () => {
-        if (released)
-          return;
-        released = true;
-        inFlight--;
-        settle();
-      };
-    },
-    isClosed: () => !admitting,
-    open() {
-      admitting = true;
-    },
-    async close(deadlineMs) {
-      admitting = false;
-      if (inFlight === 0)
-        return { drained: true, inFlight: 0 };
-      let timer;
-      const idle = new Promise((resolve2) => {
-        onIdle = resolve2;
-      });
-      const deadline = new Promise((resolve2) => {
-        timer = setTimeout(resolve2, deadlineMs);
-      });
-      try {
-        await Promise.race([idle, deadline]);
-      } finally {
-        clearTimeout(timer);
-        onIdle = null;
-      }
-      return { drained: inFlight === 0, inFlight };
-    }
-  };
-}
-
 // apps/gateway/src/ingress/schemas.ts
 var cacheControlSchema = exports_external.object({
   type: exports_external.literal("ephemeral"),
@@ -43264,6 +43515,225 @@ function apiErrorHandler(input) {
   return input.code === "NOT_FOUND" ? undefined : apiErrorResponse(input.error);
 }
 
+// apps/gateway/src/plugins/routes.ts
+var MOUNT_PREFIX = "/api/plugins";
+var ID_PATTERN2 = /^[a-z][a-z0-9-]{0,31}$/;
+var SEGMENT_PATTERN = /^[A-Za-z0-9._~-]+$/;
+var PARAM_PATTERN = /^:[A-Za-z][A-Za-z0-9_]*$/;
+function mountPath(id, path) {
+  if (!ID_PATTERN2.test(id))
+    return null;
+  if (!path.startsWith("/"))
+    return null;
+  const base = `${MOUNT_PREFIX}/${id}`;
+  if (path !== "/") {
+    for (const segment of path.slice(1).split("/")) {
+      if (segment === "." || segment === "..")
+        return null;
+      if (!SEGMENT_PATTERN.test(segment) && !PARAM_PATTERN.test(segment))
+        return null;
+    }
+  }
+  const mounted = `${base}${path}`;
+  if (mounted !== base && !mounted.startsWith(`${base}/`))
+    return null;
+  return mounted;
+}
+async function pluginRequest(request2, params) {
+  const url2 = new URL(request2.url);
+  const query = Object.fromEntries(url2.searchParams);
+  let body2 = null;
+  if (request2.method !== "GET") {
+    const text = await request2.text();
+    if (text.trim().length > 0) {
+      try {
+        body2 = JSON.parse(text);
+      } catch {
+        throw new GatewayError("BAD_REQUEST", "invalid JSON body");
+      }
+    }
+  }
+  return { params, query, body: body2 };
+}
+var CACHE_CONTROL_PATTERN = /^[A-Za-z0-9 ,=."'_-]{1,200}$/;
+function toResponse(result) {
+  const status2 = result.status ?? 200;
+  const headers = {};
+  if (result.cacheControl !== undefined && CACHE_CONTROL_PATTERN.test(result.cacheControl)) {
+    headers["cache-control"] = result.cacheControl;
+  }
+  if (result.bytes !== undefined) {
+    headers["content-type"] = result.contentType ?? "application/octet-stream";
+    return new Response(result.bytes, { status: status2, headers });
+  }
+  headers["content-type"] = "application/json";
+  return new Response(JSON.stringify(result.json ?? null), { status: status2, headers });
+}
+function isPluginResponse(value) {
+  return typeof value === "object" && value !== null;
+}
+function pluginRoutes(deps) {
+  const logger2 = deps.logger ?? noopLogger;
+  const app = new Elysia;
+  app.onError(apiErrorHandler);
+  for (const plugin of deps.plugins) {
+    for (const route of plugin.routes) {
+      const path = mountPath(plugin.id, route.path);
+      if (path === null) {
+        logger2.error("plugin route refused", { plugin: plugin.id });
+        continue;
+      }
+      const handle = async (context) => {
+        await requireAdmin(context.request, deps.admin);
+        const input = await pluginRequest(context.request, context.params);
+        try {
+          const result = await route.handler(input);
+          if (!isPluginResponse(result))
+            throw new Error("handler returned no response");
+          return toResponse(result);
+        } catch {
+          logger2.error("plugin route handler failed", { plugin: plugin.id });
+          return apiErrorResponse(new GatewayError("INTERNAL", "plugin route failed"));
+        }
+      };
+      switch (route.method) {
+        case "GET":
+          app.get(path, handle);
+          break;
+        case "POST":
+          app.post(path, handle);
+          break;
+        case "PUT":
+          app.put(path, handle);
+          break;
+        case "DELETE":
+          app.delete(path, handle);
+          break;
+        default:
+          logger2.error("plugin route method not supported", { plugin: plugin.id });
+          break;
+      }
+    }
+  }
+  return app;
+}
+
+// apps/gateway/src/plugins/ui.ts
+import { realpathSync as realpathSync2 } from "fs";
+import { join as join4, resolve as resolve2, sep as sep2 } from "path";
+var PLUGIN_ASSET_PREFIX = "/plugin-assets";
+function pluginCatalog(plugins) {
+  return plugins.map((plugin) => ({
+    id: plugin.id,
+    name: plugin.manifest.name,
+    version: plugin.manifest.version,
+    nav: plugin.manifest.nav === undefined ? null : plugin.manifest.nav,
+    ui: plugin.ui === undefined ? null : {
+      entry: plugin.ui.compatible ? `${PLUGIN_ASSET_PREFIX}/${plugin.id}/${plugin.ui.entry}` : null,
+      compatible: plugin.ui.compatible,
+      ...plugin.ui.reason === undefined ? {} : { reason: plugin.ui.reason }
+    }
+  }));
+}
+function pluginUiRoutes(deps) {
+  const logger2 = deps.logger ?? noopLogger;
+  const roots = new Map;
+  for (const plugin of deps.plugins) {
+    if (plugin.ui === undefined || !plugin.ui.compatible)
+      continue;
+    try {
+      roots.set(plugin.id, realpathSync2(join4(plugin.ui.dir, "ui")));
+    } catch {
+      logger2.warn("plugin ui directory is missing", { plugin: plugin.id });
+    }
+  }
+  return new Elysia().onError(apiErrorHandler).get("/api/plugins", async ({ request: request2 }) => {
+    await requireAdmin(request2, deps.admin);
+    return { plugins: pluginCatalog(deps.plugins) };
+  }).get(`${PLUGIN_ASSET_PREFIX}/:id/*`, ({ params, set: set2 }) => {
+    const notFound = () => {
+      set2.status = 404;
+      return { error: { code: "NOT_FOUND", message: "no such plugin asset" } };
+    };
+    const root = roots.get(params.id);
+    if (root === undefined)
+      return notFound();
+    let rest;
+    try {
+      rest = decodeURIComponent(params["*"] ?? "");
+    } catch {
+      return notFound();
+    }
+    let real;
+    try {
+      real = realpathSync2(resolve2(root, `./${rest}`));
+    } catch {
+      return notFound();
+    }
+    if (!real.startsWith(`${root}${sep2}`))
+      return notFound();
+    const file3 = Bun.file(real);
+    return new Response(file3, {
+      headers: {
+        "cache-control": "no-cache",
+        "content-type": real.endsWith(".js") ? "text/javascript; charset=utf-8" : real.endsWith(".css") ? "text/css; charset=utf-8" : file3.type
+      }
+    });
+  });
+}
+
+// apps/gateway/src/quiesce.ts
+function createQuiesceLatch() {
+  let admitting = true;
+  let inFlight = 0;
+  let onIdle = null;
+  const settle = () => {
+    if (inFlight > 0 || onIdle === null)
+      return;
+    const resolve3 = onIdle;
+    onIdle = null;
+    resolve3();
+  };
+  return {
+    enter() {
+      if (!admitting)
+        return null;
+      inFlight++;
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        inFlight--;
+        settle();
+      };
+    },
+    isClosed: () => !admitting,
+    open() {
+      admitting = true;
+    },
+    async close(deadlineMs) {
+      admitting = false;
+      if (inFlight === 0)
+        return { drained: true, inFlight: 0 };
+      let timer;
+      const idle = new Promise((resolve3) => {
+        onIdle = resolve3;
+      });
+      const deadline = new Promise((resolve3) => {
+        timer = setTimeout(resolve3, deadlineMs);
+      });
+      try {
+        await Promise.race([idle, deadline]);
+      } finally {
+        clearTimeout(timer);
+        onIdle = null;
+      }
+      return { drained: inFlight === 0, inFlight };
+    }
+  };
+}
+
 // apps/gateway/src/routes/admin.ts
 function adminRoutes(deps) {
   const logger2 = deps.logger ?? noopLogger;
@@ -43698,7 +44168,7 @@ function createBodyCollector(options) {
   const client = { request: null, response: null, truncated: false };
   const drain = async (stream2, entry) => {
     const reader = stream2.getReader();
-    const decoder2 = new TextDecoder;
+    const decoder3 = new TextDecoder;
     let bytes = 0;
     try {
       while (true) {
@@ -43713,11 +44183,11 @@ function createBodyCollector(options) {
           continue;
         }
         bytes += value.byteLength;
-        entry.responseText += decoder2.decode(value, { stream: true });
+        entry.responseText += decoder3.decode(value, { stream: true });
         if (bytes > MAX_CAPTURED_BODY_BYTES)
           entry.truncated = true;
       }
-      entry.responseText += decoder2.decode();
+      entry.responseText += decoder3.decode();
     } catch {
       entry.truncated = true;
     } finally {
@@ -45666,7 +46136,7 @@ async function routeLog(store, requestId, target, logger2 = noopLogger) {
     report(logger2, "failed to record request route", requestId, error51);
   }
 }
-async function finishLog(store, log, keyId, logger2 = noopLogger, bodies, debit) {
+async function finishLog(store, log, keyId, logger2 = noopLogger, bodies, debit, emit) {
   try {
     await store.usage.append({ ...log, apiKeyId: keyId });
   } catch (error51) {
@@ -45678,6 +46148,28 @@ async function finishLog(store, log, keyId, logger2 = noopLogger, bodies, debit)
       costUsd: log.costUsd
     });
   }
+  if (keyId !== null && emit !== undefined) {
+    try {
+      emit({
+        requestId: log.id,
+        apiKeyId: keyId,
+        provider: log.resolvedProvider,
+        model: log.resolvedModel ?? log.requestedModel,
+        tokens: {
+          input: log.inputTokens,
+          output: log.outputTokens,
+          cacheRead: log.cacheReadTokens,
+          cacheWrite: log.cacheWriteTokens
+        },
+        costUsd: log.costUsd,
+        durationMs: log.durationMs,
+        ok: log.errorCode === null && log.status < 400,
+        at: log.at
+      });
+    } catch (error51) {
+      report(logger2, "failed to emit plugin event", log.id, error51);
+    }
+  }
   if (bodies === undefined)
     return;
   try {
@@ -46176,12 +46668,12 @@ async function dispatch(request2, deps, signal, requestId) {
 function waitForCancellation(promise2, signal) {
   if (signal.aborted)
     return Promise.reject(signal.reason);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const abort = () => reject(signal.reason);
     signal.addEventListener("abort", abort, { once: true });
     promise2.then((value) => {
       signal.removeEventListener("abort", abort);
-      resolve2(value);
+      resolve3(value);
     }, (error51) => {
       signal.removeEventListener("abort", abort);
       reject(error51);
@@ -47078,8 +47570,8 @@ var KEEPALIVE_MS = 1e4;
 var KEEPALIVE = Symbol("keepalive");
 function withKeepalive(pending, ms) {
   let timer;
-  const tick = new Promise((resolve2) => {
-    timer = setTimeout(() => resolve2(KEEPALIVE), ms);
+  const tick = new Promise((resolve3) => {
+    timer = setTimeout(() => resolve3(KEEPALIVE), ms);
   });
   return Promise.race([pending, tick]).finally(() => clearTimeout(timer));
 }
@@ -47298,7 +47790,7 @@ async function handle(deps, rateLimiter, surface, request2) {
         reportRejection(deps.logger, requestId, completed, gatewayError, surface);
       }
       logged = true;
-      await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit);
+      await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit, deps.emit);
     };
     if (chatRequest.stream) {
       const frames = surface === "anthropic" ? anthropicStream(dispatched.events, requestId) : openaiStream(dispatched.events, requestId, Math.floor(deps.now() / 1000));
@@ -47339,7 +47831,7 @@ async function handle(deps, rateLimiter, surface, request2) {
     if (collector !== null && !logged)
       collector.client.response = rejection;
     if (!logged)
-      await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit);
+      await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit, deps.emit);
     if (!cancelled)
       reportRejection(deps.logger, requestId, completed, gatewayError, surface);
     return jsonResponse(rejection, HTTP_STATUS[gatewayError.code], {
@@ -47456,11 +47948,11 @@ function createApp(deps) {
     now,
     logger: logger2
   });
-  const staticDir = deps.staticDir ? resolve2(deps.staticDir) : undefined;
+  const staticDir = deps.staticDir ? resolve3(deps.staticDir) : undefined;
   let staticRoot;
   if (staticDir) {
     try {
-      staticRoot = realpathSync2(staticDir);
+      staticRoot = realpathSync3(staticDir);
     } catch {}
   }
   const latch = deps.latch ?? createQuiesceLatch();
@@ -47489,7 +47981,8 @@ function createApp(deps) {
     logger: logger2,
     ...deps.loadRegistry === undefined ? {} : { loadRegistry: deps.loadRegistry },
     discoveryMirrors: deps.discoveryMirrors === true,
-    bodyLoggingAllowed: deps.bodyLoggingAllowed === true
+    bodyLoggingAllowed: deps.bodyLoggingAllowed === true,
+    ...deps.emit === undefined ? {} : { emit: deps.emit }
   })).use(adminRoutes({
     store: deps.store,
     admin,
@@ -47502,6 +47995,7 @@ function createApp(deps) {
     ...deps.console === undefined ? {} : { console: deps.console }
   })).use(databaseRoutes({
     store: deps.store,
+    ...deps.reapplyPluginSchema === undefined ? {} : { reapplyPluginSchema: deps.reapplyPluginSchema },
     admin,
     latch,
     snapshots,
@@ -47516,6 +48010,14 @@ function createApp(deps) {
     http,
     now,
     logger: logger2
+  })).use(pluginRoutes({
+    admin,
+    plugins: deps.plugins ?? [],
+    logger: logger2
+  })).use(pluginUiRoutes({
+    admin,
+    plugins: deps.pluginUi ?? [],
+    logger: logger2
   })).get("/*", ({ path, request: request2, set: set2 }) => {
     const rawPath = new URL(request2.url).pathname;
     const error51 = () => {
@@ -47534,14 +48036,14 @@ function createApp(deps) {
     if (protectedPrefix)
       return error51();
     const requestedPath = decodedPath === "/" ? "/index.html" : decodedPath;
-    const filePath = resolve2(staticRoot, `.${requestedPath}`);
-    if (filePath !== staticRoot && !filePath.startsWith(`${staticRoot}${sep2}`))
+    const filePath = resolve3(staticRoot, `.${requestedPath}`);
+    if (filePath !== staticRoot && !filePath.startsWith(`${staticRoot}${sep3}`))
       return error51();
     let resolvedFilePath;
     try {
-      resolvedFilePath = realpathSync2(filePath);
+      resolvedFilePath = realpathSync3(filePath);
     } catch {}
-    if (resolvedFilePath && resolvedFilePath !== staticRoot && !resolvedFilePath.startsWith(`${staticRoot}${sep2}`)) {
+    if (resolvedFilePath && resolvedFilePath !== staticRoot && !resolvedFilePath.startsWith(`${staticRoot}${sep3}`)) {
       return error51();
     }
     const file3 = resolvedFilePath ? Bun.file(resolvedFilePath) : undefined;
@@ -47557,7 +48059,7 @@ function createApp(deps) {
     const isNavigation = request2.headers.get("accept")?.includes("text/html") ?? false;
     if (decodedPath.startsWith("/assets/") || !isNavigation)
       return error51();
-    const indexPath = resolve2(staticRoot, "index.html");
+    const indexPath = resolve3(staticRoot, "index.html");
     const index = Bun.file(indexPath);
     if (index.size === 0)
       return error51();
@@ -47588,8 +48090,8 @@ function createShutdown(deps) {
     for (const stop of deps.stopLoops)
       stop();
     let timer;
-    const abandoned = new Promise((resolve3) => {
-      timer = setTimeout(() => resolve3("timeout"), deps.stopDeadlineMs ?? STOP_DEADLINE_MS);
+    const abandoned = new Promise((resolve4) => {
+      timer = setTimeout(() => resolve4("timeout"), deps.stopDeadlineMs ?? STOP_DEADLINE_MS);
       timer.unref?.();
     });
     Promise.race([deps.stopServer(), abandoned]).then((outcome) => {
@@ -47717,6 +48219,334 @@ function startRefreshScheduler(deps) {
   return () => clearInterval(timer);
 }
 
+// apps/gateway/src/plugins/events.ts
+var DEFAULT_CAPACITY = 1000;
+var defaultScheduler = (run) => {
+  const timer = setTimeout(run, 0);
+  return () => clearTimeout(timer);
+};
+function createPluginEventBus(opts) {
+  const logger2 = opts.logger ?? noopLogger;
+  const capacity = opts.capacity ?? DEFAULT_CAPACITY;
+  const scheduler = opts.scheduler ?? defaultScheduler;
+  const requestHandlers = [];
+  const limitHandlers = [];
+  const queue = [];
+  let dropped = 0;
+  let handlerErrors = 0;
+  let draining = false;
+  let live = true;
+  let cancelDrain;
+  let droppedSinceReport = 0;
+  const errorsSinceReport = new Map;
+  const drain = () => {
+    draining = false;
+    cancelDrain = undefined;
+    if (!live)
+      return;
+    const batch = queue.splice(0, queue.length);
+    for (const item of batch) {
+      const handlers = item.name === "request:completed" ? requestHandlers : limitHandlers;
+      for (const handler of handlers) {
+        try {
+          handler.run(item.event);
+        } catch {
+          handlerErrors++;
+          errorsSinceReport.set(handler.pluginId, (errorsSinceReport.get(handler.pluginId) ?? 0) + 1);
+        }
+      }
+    }
+    for (const [pluginId, count] of errorsSinceReport) {
+      logger2.warn("plugin event handler failed", { plugin: pluginId, count });
+    }
+    errorsSinceReport.clear();
+    if (droppedSinceReport > 0) {
+      logger2.warn("plugin event queue overflowed", { count: droppedSinceReport });
+      droppedSinceReport = 0;
+    }
+  };
+  const schedule = () => {
+    if (draining || !live)
+      return;
+    draining = true;
+    cancelDrain = scheduler(drain);
+  };
+  const enqueue = (item, subscribers) => {
+    if (!live || subscribers === 0)
+      return;
+    if (queue.length >= capacity) {
+      dropped++;
+      droppedSinceReport++;
+      return;
+    }
+    queue.push(item);
+    schedule();
+  };
+  return {
+    onRequestCompleted(pluginId, run) {
+      requestHandlers.push({ pluginId, run });
+    },
+    onLimitReached(pluginId, run) {
+      limitHandlers.push({ pluginId, run });
+    },
+    emitRequestCompleted(event) {
+      enqueue({ name: "request:completed", event }, requestHandlers.length);
+    },
+    emitLimitReached(event) {
+      enqueue({ name: "limit:reached", event }, limitHandlers.length);
+    },
+    stats() {
+      return { dropped, handlerErrors, queued: queue.length };
+    },
+    stop() {
+      live = false;
+      queue.length = 0;
+      cancelDrain?.();
+      cancelDrain = undefined;
+      draining = false;
+    }
+  };
+}
+
+// apps/gateway/src/plugins/loader.ts
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
+import { join as join5, resolve as resolve5, sep as sep5 } from "path";
+
+// apps/gateway/src/plugins/capabilities.ts
+import { mkdir as mkdir2, readFile as readFile2, realpath, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname4, resolve as resolve4, sep as sep4 } from "path";
+async function resolveInside(root, path) {
+  const rootReal = await realpath(root);
+  const target = resolve4(rootReal, path);
+  const inside = (candidate) => candidate === rootReal || candidate.startsWith(`${rootReal}${sep4}`);
+  if (!inside(target))
+    throw new Error(`path is outside the plugin directory: ${path}`);
+  let probe2 = target;
+  for (;; ) {
+    try {
+      if (!inside(await realpath(probe2))) {
+        throw new Error(`path is outside the plugin directory: ${path}`);
+      }
+      return target;
+    } catch (error51) {
+      if (error51 instanceof Error && error51.message.includes("outside"))
+        throw error51;
+      const parent = dirname4(probe2);
+      if (parent === probe2 || probe2 === rootReal)
+        return target;
+      probe2 = parent;
+    }
+  }
+}
+function createPluginFiles(root) {
+  return {
+    async read(path) {
+      const target = await ensureRootThen(root, () => resolveInside(root, path));
+      try {
+        const data = await readFile2(target);
+        return new Uint8Array(data);
+      } catch {
+        return null;
+      }
+    },
+    async write(path, data) {
+      const target = await ensureRootThen(root, () => resolveInside(root, path));
+      await mkdir2(dirname4(target), { recursive: true });
+      await writeFile2(target, data);
+    },
+    async exists(path) {
+      const target = await ensureRootThen(root, () => resolveInside(root, path));
+      try {
+        await readFile2(target);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+async function ensureRootThen(root, then) {
+  await mkdir2(root, { recursive: true });
+  return then();
+}
+var PLUGIN_FETCH_TIMEOUT_MS = 30000;
+function createPluginFetch(origins, deps = {}) {
+  const fetchImpl = deps.fetchImpl ?? ((url2, init) => fetch(url2, init));
+  const allowed = new Set(origins.map((origin) => new URL(origin).origin));
+  const timeoutMs = deps.timeoutMs ?? PLUGIN_FETCH_TIMEOUT_MS;
+  return async (url2, init) => {
+    const parsed = new URL(url2);
+    if (!allowed.has(parsed.origin)) {
+      throw new Error(`origin ${parsed.origin} is not in the allowlist`);
+    }
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const signal = init?.signal === undefined || init.signal === null ? timeout : AbortSignal.any([init.signal, timeout]);
+    return fetchImpl(url2, { ...init, redirect: "manual", signal });
+  };
+}
+
+// apps/gateway/src/plugins/loader.ts
+var EVENT_MAX = 64;
+function sanitizeEvent(value) {
+  return value.replace(/[^A-Za-z0-9._:-]/g, "").slice(0, EVENT_MAX);
+}
+function createPluginLogger(id, logger2) {
+  const fields = (f) => ({
+    plugin: id,
+    ...f?.event === undefined ? {} : { reason: sanitizeEvent(f.event) },
+    ...f?.count === undefined ? {} : { count: f.count },
+    ...f?.durationMs === undefined ? {} : { durationMs: f.durationMs }
+  });
+  return {
+    debug: (message3, f) => logger2.debug(message3, fields(f)),
+    info: (message3, f) => logger2.info(message3, fields(f)),
+    warn: (message3, f) => logger2.warn(message3, fields(f)),
+    error: (message3, f) => logger2.error(message3, fields(f))
+  };
+}
+function createPluginStorage(store, id) {
+  return {
+    run: (sql, params) => store.plugins.run(id, sql, params === undefined ? [] : [...params]),
+    all: (sql, params) => store.plugins.all(id, sql, params === undefined ? [] : [...params]),
+    get: (sql, params) => store.plugins.get(id, sql, params === undefined ? [] : [...params]),
+    transaction: (fn) => store.plugins.transaction(id, fn)
+  };
+}
+function createPluginEvents(manifest, bus) {
+  const wantsRequest = manifest.capabilities.includes("events:request");
+  const wantsLimit = manifest.capabilities.includes("events:limit");
+  if (!wantsRequest && !wantsLimit)
+    return;
+  return {
+    ...wantsRequest ? { onRequestCompleted: (handler) => bus.onRequestCompleted(manifest.id, handler) } : {},
+    ...wantsLimit ? { onLimitReached: (handler) => bus.onLimitReached(manifest.id, handler) } : {}
+  };
+}
+function buildContext(deps) {
+  const { manifest, home } = deps;
+  const declared = manifest.capabilities;
+  return {
+    id: manifest.id,
+    now: deps.now,
+    logger: createPluginLogger(manifest.id, deps.logger),
+    ...declared.includes("storage") ? { storage: createPluginStorage(deps.store, manifest.id) } : {},
+    ...declared.includes("files") ? { files: createPluginFiles(join5(home, "data")) } : {},
+    ...declared.includes("net:outbound") ? { net: createPluginFetch(manifest.origins ?? []) } : {},
+    ...(() => {
+      const events = createPluginEvents(manifest, deps.events);
+      return events === undefined ? {} : { events };
+    })(),
+    config: manifest.defaults ?? {}
+  };
+}
+function reason(error51) {
+  return error51 instanceof Error ? error51.message : String(error51);
+}
+async function loadPlugins(deps) {
+  const logger2 = deps.logger ?? noopLogger;
+  const now = deps.now ?? Date.now;
+  const plugins = [];
+  const failures = [];
+  let entries;
+  try {
+    const dirents = await readdir2(deps.root, { withFileTypes: true });
+    entries = dirents.filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return { plugins, failures };
+  }
+  for (const id of entries.sort()) {
+    const home = join5(deps.root, id);
+    const fail2 = (why) => {
+      failures.push({ id, reason: why });
+      logger2.warn("plugin skipped", { plugin: id, reason: why });
+    };
+    let manifest;
+    try {
+      const raw = await readFile3(join5(home, "omni-plugin.json"), "utf8");
+      const parsed = safeParseManifest(JSON.parse(raw));
+      if (!parsed.ok) {
+        fail2(parsed.reason);
+        continue;
+      }
+      manifest = parsed.manifest;
+    } catch (error51) {
+      fail2(reason(error51));
+      continue;
+    }
+    if (manifest.id !== id) {
+      fail2(`manifest id ${manifest.id} does not match its directory ${id}`);
+      continue;
+    }
+    if (!isApiCompatible(manifest)) {
+      fail2(`plugin api ${manifest.api} is not supported by this host (api ${PLUGIN_API_VERSION})`);
+      continue;
+    }
+    let routes = [];
+    let migrations = [];
+    if (manifest.server !== undefined) {
+      const entry = resolve5(home, manifest.server);
+      if (entry !== home && !entry.startsWith(`${home}${sep5}`)) {
+        fail2(`server entry resolves outside the plugin directory`);
+        continue;
+      }
+      let definition;
+      try {
+        const module = await import(entry);
+        const candidate = module.default;
+        if (typeof candidate !== "object" || candidate === null || typeof candidate.setup !== "function") {
+          fail2("server entry has no default export with a setup function");
+          continue;
+        }
+        definition = candidate;
+      } catch (error51) {
+        fail2(reason(error51));
+        continue;
+      }
+      migrations = definition.migrations ?? [];
+      if (migrations.length > 0) {
+        const applied = deps.store.plugins.migrate(id, migrations);
+        if (applied.failed !== undefined) {
+          fail2(`migration ${applied.failed.version} failed: ${applied.failed.reason}`);
+          continue;
+        }
+      }
+      try {
+        const context = buildContext({
+          manifest,
+          home,
+          store: deps.store,
+          events: deps.events,
+          logger: logger2,
+          now
+        });
+        const result = await definition.setup(context);
+        routes = result?.routes ?? [];
+      } catch (error51) {
+        fail2(reason(error51));
+        continue;
+      }
+    }
+    const loaded = { id, manifest, routes, migrations };
+    if (manifest.ui !== undefined && manifest.sdk !== undefined) {
+      const UI_DIR = "ui/";
+      if (!manifest.ui.startsWith(UI_DIR)) {
+        fail2(`ui entry must live under ${UI_DIR}, got ${manifest.ui}`);
+        continue;
+      }
+      const compatible = Bun.semver.satisfies(deps.sdkVersion, manifest.sdk);
+      loaded.ui = {
+        dir: home,
+        entry: manifest.ui.slice(UI_DIR.length),
+        compatible,
+        ...compatible ? {} : { reason: `requires dashboard sdk ${manifest.sdk}, host ships ${deps.sdkVersion}` }
+      };
+    }
+    plugins.push(loaded);
+    logger2.info("plugin loaded", { plugin: id });
+  }
+  return { plugins, failures };
+}
+
 // apps/gateway/src/quota/poller.ts
 async function startQuotaPoller(deps) {
   const logger2 = deps.logger ?? noopLogger;
@@ -47790,8 +48620,8 @@ async function main() {
     if (config2.staticDir !== null)
       return config2.staticDir;
     const candidates = [
-      resolve3(import.meta.dir, "./public"),
-      resolve3(import.meta.dir, "../../dashboard/dist")
+      resolve6(import.meta.dir, "./public"),
+      resolve6(import.meta.dir, "../../dashboard/dist")
     ];
     return candidates.find((path) => existsSync2(path)) ?? candidates[1];
   }
@@ -47813,10 +48643,25 @@ async function main() {
   logger2.info(existsSync2(staticDir) ? "dashboard directory resolved" : "dashboard directory absent", {
     path: staticDir
   });
-  let shutdown = (reason) => {
-    logger2.error("shutdown requested before the gateway was serving", { reason });
+  let shutdown = (reason2) => {
+    logger2.error("shutdown requested before the gateway was serving", { reason: reason2 });
     process.exit(1);
   };
+  const installRoot = process.env.OMNI_ROOT ?? dirname5(config2.databasePath);
+  const pluginRoot = join6(installRoot, "plugins");
+  const pluginEvents = createPluginEventBus({ logger: logger2 });
+  const loadedPlugins = await loadPlugins({
+    root: pluginRoot,
+    store,
+    events: pluginEvents,
+    sdkVersion: DASHBOARD_SDK_VERSION,
+    logger: logger2,
+    now
+  });
+  for (const failure of loadedPlugins.failures) {
+    logger2.warn("plugin unavailable", { plugin: failure.id, reason: failure.reason });
+  }
+  logger2.info("plugins resolved", { count: loadedPlugins.plugins.length, path: pluginRoot });
   const app = createApp({
     store,
     baseUrl: config2.baseUrl,
@@ -47828,11 +48673,24 @@ async function main() {
     console: console2,
     discoveryMirrors: config2.exposeClaudeCodeAliases,
     bodyLoggingAllowed: config2.bodyLoggingAllowed,
+    plugins: loadedPlugins.plugins.map((plugin) => ({ id: plugin.id, routes: plugin.routes })),
+    pluginUi: loadedPlugins.plugins,
+    ...loadedPlugins.plugins.length === 0 ? {} : { emit: (event) => pluginEvents.emitRequestCompleted(event) },
+    reapplyPluginSchema: async () => {
+      for (const plugin of loadedPlugins.plugins) {
+        if (plugin.migrations.length === 0)
+          continue;
+        const applied = store.plugins.migrate(plugin.id, plugin.migrations);
+        if (applied.failed !== undefined) {
+          throw new Error(`plugin ${plugin.id} migration ${applied.failed.version}: ${applied.failed.reason}`);
+        }
+      }
+    },
     lifecycle: {
       env: process.env,
       fileExists: (path) => existsSync2(path),
       run: commandRunner,
-      stop: createDeferredStop((reason, mode) => shutdown(reason, mode))
+      stop: createDeferredStop((reason2, mode) => shutdown(reason2, mode))
     }
   });
   const stopMaintenance = startMaintenance({ store, now, logger: logger2 });
@@ -47849,7 +48707,7 @@ async function main() {
   logger2.info("omnigateway listening", { host: config2.host, port: config2.port });
   shutdown = createShutdown({
     logger: logger2,
-    stopLoops: [stopMaintenance, stopRefreshScheduler, stopQuotaPoller],
+    stopLoops: [stopMaintenance, stopRefreshScheduler, stopQuotaPoller, () => pluginEvents.stop()],
     stopServer: async () => {
       await app.stop();
     },