omnigateway 0.3.0 → 0.4.0

package/bin/omni.js

@@ -114,7 +114,7 @@ function formatBytes(bytes) {
 }
 
 // apps/cli/src/run.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 
 // packages/control/src/adminAuth.ts
@@ -19551,6 +19551,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) {
@@ -19785,7 +19818,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 });
@@ -19938,6 +19972,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 table2 of tables)
+          db.run(`DROP TABLE IF EXISTS "${table2}"`);
+        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",
@@ -20250,7 +20446,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();
@@ -20323,6 +20520,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) {
@@ -20727,6 +20940,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,
@@ -21028,13 +21248,594 @@ import {
   copyFileSync,
   mkdirSync,
   readdirSync,
+  readFileSync,
   realpathSync,
   renameSync,
   rmSync,
   statfsSync,
-  statSync
+  statSync,
+  writeFileSync
 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
+
+// packages/control/src/plugins.ts
+import { Buffer as Buffer2 } from "buffer";
+import { basename as basename2, join as join3, resolve as resolve2, sep as sep2 } 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 PLUGINS_DIRNAME = "plugins";
+function pluginsDir(root) {
+  return join3(root, PLUGINS_DIRNAME);
+}
+var MANIFEST_FILENAME = "omni-plugin.json";
+var MAX_PLUGIN_BYTES = 32 * 1024 * 1024;
+var ID_PATTERN2 = /^[a-z][a-z0-9-]{0,31}$/;
+var NPM_TARBALL_ROOT = "package";
+function readManifest(fs, home) {
+  const raw = fs.readText(join3(home, MANIFEST_FILENAME));
+  if (raw === null) {
+    return { check: "manifest", reason: `no ${MANIFEST_FILENAME}`, fatal: true };
+  }
+  let document;
+  try {
+    document = JSON.parse(raw);
+  } catch (error51) {
+    const detail = error51 instanceof Error ? error51.message : String(error51);
+    return {
+      check: "manifest",
+      reason: `${MANIFEST_FILENAME} is not valid JSON: ${detail}`,
+      fatal: true
+    };
+  }
+  const parsed = safeParseManifest(document);
+  if (!parsed.ok)
+    return { check: "manifest", reason: parsed.reason, fatal: true };
+  return parsed.manifest;
+}
+function checkEntry(fs, home, entry, label2, fatal) {
+  const target = resolve2(home, entry);
+  if (target !== home && !target.startsWith(`${home}${sep2}`)) {
+    return {
+      check: "entry",
+      reason: `${label2} entry resolves outside the plugin directory`,
+      fatal
+    };
+  }
+  if (!fs.isFile(target)) {
+    return { check: "entry", reason: `${label2} entry ${entry} does not exist`, fatal };
+  }
+  return null;
+}
+function verifyPlugin(deps, root, id) {
+  const home = join3(pluginsDir(root), id);
+  if (!ID_PATTERN2.test(id) || !deps.fs.isDirectory(home)) {
+    throw new GatewayError("BAD_REQUEST", `no plugin "${id}" installed under ${pluginsDir(root)}`);
+  }
+  return reportFor(deps, home, id);
+}
+function reportFor(deps, home, id) {
+  const problems = [];
+  const read = readManifest(deps.fs, home);
+  if (!("id" in read)) {
+    problems.push(read);
+    return { id, path: home, manifest: null, problems, loadable: false };
+  }
+  const manifest = read;
+  if (manifest.id !== id) {
+    problems.push({
+      check: "id",
+      reason: `manifest id ${manifest.id} does not match its directory ${id}`,
+      fatal: true
+    });
+  }
+  if (!isApiCompatible(manifest)) {
+    problems.push({
+      check: "api",
+      reason: `plugin api ${manifest.api} is not supported by this host (api ${PLUGIN_API_VERSION})`,
+      fatal: true
+    });
+  }
+  if (manifest.server !== undefined) {
+    const problem = checkEntry(deps.fs, home, manifest.server, "server", true);
+    if (problem !== null)
+      problems.push(problem);
+  }
+  if (manifest.ui !== undefined) {
+    const problem = checkEntry(deps.fs, home, manifest.ui, "ui", false);
+    if (problem !== null)
+      problems.push(problem);
+  }
+  const sdk = sdkProblem(deps, manifest);
+  if (sdk !== null)
+    problems.push(sdk);
+  return {
+    id,
+    path: home,
+    manifest,
+    problems,
+    loadable: !problems.some((problem) => problem.fatal)
+  };
+}
+function sdkProblem(deps, manifest) {
+  if (manifest.ui === undefined || manifest.sdk === undefined)
+    return null;
+  if (deps.sdkVersion === undefined)
+    return null;
+  if (Bun.semver.satisfies(deps.sdkVersion, manifest.sdk))
+    return null;
+  return {
+    check: "sdk",
+    reason: `requires dashboard sdk ${manifest.sdk}, host ships ${deps.sdkVersion}`,
+    fatal: false
+  };
+}
+function listPlugins(deps, root) {
+  const dir = pluginsDir(root);
+  const summaries = [];
+  for (const entry of [...deps.fs.readdir(dir)].sort()) {
+    const home = join3(dir, entry);
+    if (!deps.fs.isDirectory(home))
+      continue;
+    if (!ID_PATTERN2.test(entry)) {
+      summaries.push({
+        id: entry,
+        path: home,
+        manifest: null,
+        problems: [
+          {
+            check: "id",
+            reason: `directory name ${entry} is not a valid plugin id`,
+            fatal: true
+          }
+        ],
+        loadable: false,
+        name: null,
+        version: null,
+        api: null,
+        sdk: null,
+        capabilities: [],
+        origins: []
+      });
+      continue;
+    }
+    const report = reportFor(deps, home, entry);
+    const manifest = report.manifest;
+    summaries.push({
+      ...report,
+      name: manifest?.name ?? null,
+      version: manifest?.version ?? null,
+      api: manifest?.api ?? null,
+      sdk: manifest?.sdk ?? null,
+      capabilities: manifest?.capabilities ?? [],
+      origins: manifest?.origins ?? []
+    });
+  }
+  return summaries;
+}
+var BLOCK = 512;
+var decoder2 = new TextDecoder;
+function fieldText(header, offset, length) {
+  const slice = header.subarray(offset, offset + length);
+  const end = slice.indexOf(0);
+  return decoder2.decode(end === -1 ? slice : slice.subarray(0, end));
+}
+function fieldOctal(header, offset, length) {
+  const text = fieldText(header, offset, length).trim();
+  if (text.length === 0)
+    return 0;
+  const value = Number.parseInt(text, 8);
+  return Number.isSafeInteger(value) && value >= 0 ? value : -1;
+}
+function isSafeArchivePath(path) {
+  if (path.length === 0 || path.startsWith("/") || path.includes("\x00"))
+    return false;
+  if (path.includes("\\"))
+    return false;
+  return !path.split("/").includes("..");
+}
+function readTar(bytes) {
+  const files = new Map;
+  let total = 0;
+  let longName = null;
+  let offset = 0;
+  while (offset + BLOCK <= bytes.length) {
+    const header = bytes.subarray(offset, offset + BLOCK);
+    if (header.every((byte) => byte === 0))
+      break;
+    const size = fieldOctal(header, 124, 12);
+    if (size < 0)
+      throw new GatewayError("BAD_REQUEST", "archive has an unreadable entry size");
+    const type = String.fromCharCode(header[156] ?? 0);
+    const name = fieldText(header, 0, 100);
+    const prefix = fieldText(header, 345, 155);
+    offset += BLOCK;
+    total += size;
+    if (total > MAX_PLUGIN_BYTES) {
+      throw new GatewayError("BAD_REQUEST", `archive unpacks to more than ${MAX_PLUGIN_BYTES} bytes`);
+    }
+    if (offset + size > bytes.length) {
+      throw new GatewayError("BAD_REQUEST", `archive is truncated: entry ${name || "(unnamed)"} declares ${size} bytes and the archive ends before them`);
+    }
+    const data = bytes.subarray(offset, offset + size);
+    offset += Math.ceil(size / BLOCK) * BLOCK;
+    if (type === "1" || type === "2") {
+      throw new GatewayError("BAD_REQUEST", `archive contains a link (${name}); plugin packages must be plain files`);
+    }
+    if (type === "L") {
+      longName = decoder2.decode(data).replace(/\0+$/, "");
+      continue;
+    }
+    if (type === "K" || type === "x" || type === "g")
+      continue;
+    if (type !== "0" && type !== "\x00") {
+      longName = null;
+      continue;
+    }
+    const path = longName ?? (prefix.length > 0 ? `${prefix}/${name}` : name);
+    longName = null;
+    if (!isSafeArchivePath(path)) {
+      throw new GatewayError("BAD_REQUEST", `archive contains an unsafe path: ${path}`);
+    }
+    files.set(path, new Uint8Array(data));
+  }
+  return files;
+}
+function gunzipIfNeeded(bytes) {
+  if (bytes[0] !== 31 || bytes[1] !== 139)
+    return bytes;
+  try {
+    return Bun.gunzipSync(new Uint8Array(bytes));
+  } catch (error51) {
+    const detail = error51 instanceof Error ? error51.message : String(error51);
+    throw new GatewayError("BAD_REQUEST", `could not decompress the archive: ${detail}`);
+  }
+}
+function stripRoot(files) {
+  const roots = new Set;
+  for (const path of files.keys()) {
+    const slash = path.indexOf("/");
+    if (slash <= 0)
+      return { files, claimedId: null };
+    roots.add(path.slice(0, slash));
+  }
+  const [only] = [...roots];
+  if (roots.size !== 1 || only === undefined)
+    return { files, claimedId: null };
+  const stripped = new Map;
+  for (const [path, bytes] of files)
+    stripped.set(path.slice(only.length + 1), bytes);
+  return { files: stripped, claimedId: only === NPM_TARBALL_ROOT ? null : only };
+}
+function readTree(fs, dir, prefix = "") {
+  const files = new Map;
+  let total = 0;
+  for (const entry of fs.readdir(dir)) {
+    const path = join3(dir, entry);
+    const relative = prefix.length === 0 ? entry : `${prefix}/${entry}`;
+    if (fs.isDirectory(path)) {
+      for (const [nested, bytes2] of readTree(fs, path, relative))
+        files.set(nested, bytes2);
+      continue;
+    }
+    const bytes = fs.readBytes(path);
+    if (bytes === null)
+      continue;
+    total += bytes.byteLength;
+    if (total > MAX_PLUGIN_BYTES) {
+      throw new GatewayError("BAD_REQUEST", `${dir} holds more than ${MAX_PLUGIN_BYTES} bytes`);
+    }
+    files.set(relative, bytes);
+  }
+  return files;
+}
+var DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
+var NPM_PACKUMENT_ACCEPT = "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*";
+var NPM_NAME_PATTERN = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+var EXACT_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)*$/;
+var SRI_ALGORITHMS = ["sha512", "sha384", "sha256"];
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  return value;
+}
+function asString(value) {
+  return typeof value === "string" ? value : null;
+}
+function parseNpmSpec(spec) {
+  const at = spec.lastIndexOf("@");
+  const name = at <= 0 ? spec : spec.slice(0, at);
+  const version2 = at <= 0 ? null : spec.slice(at + 1);
+  if (name.length > 214 || !NPM_NAME_PATTERN.test(name))
+    return null;
+  return { name, version: version2 };
+}
+function registryUrl(deps) {
+  const raw = deps.registry ?? DEFAULT_NPM_REGISTRY;
+  let url2;
+  try {
+    url2 = new URL(raw);
+  } catch {
+    throw new GatewayError("BAD_REQUEST", `registry ${raw} is not a URL`);
+  }
+  if (url2.protocol !== "https:") {
+    throw new GatewayError("BAD_REQUEST", `plugins may only be installed over https; ${raw} is not`);
+  }
+  return url2;
+}
+function packumentUrl(registry2, name) {
+  return `${registry2.href.replace(/\/+$/, "")}/${name.replace("/", "%2f")}`;
+}
+function resolveDist(document, spec) {
+  const root = asRecord(document);
+  if (root === null) {
+    throw new GatewayError("BAD_REQUEST", `the registry's answer for ${spec.name} is not a package`);
+  }
+  const versions2 = asRecord(root.versions);
+  if (versions2 === null) {
+    throw new GatewayError("BAD_REQUEST", `the registry lists no versions of ${spec.name}`);
+  }
+  let wanted = spec.version;
+  if (wanted === null) {
+    const tags = asRecord(root["dist-tags"]);
+    wanted = tags === null ? null : asString(tags.latest);
+    if (wanted === null) {
+      throw new GatewayError("BAD_REQUEST", `the registry names no dist-tags.latest for ${spec.name}; install ${spec.name}@<exact version>`);
+    }
+  }
+  const entry = asRecord(versions2[wanted]);
+  if (entry === null) {
+    throw new GatewayError("BAD_REQUEST", `the registry has no version ${wanted} of ${spec.name}`);
+  }
+  const dist = asRecord(entry.dist);
+  const tarball = dist === null ? null : asString(dist.tarball);
+  if (dist === null || tarball === null) {
+    throw new GatewayError("BAD_REQUEST", `the registry's entry for ${spec.name}@${wanted} names no tarball`);
+  }
+  return {
+    version: wanted,
+    dist: { tarball, integrity: asString(dist.integrity), shasum: asString(dist.shasum) }
+  };
+}
+function checkTarballUrl(tarball, registry2, what) {
+  let url2;
+  try {
+    url2 = new URL(tarball);
+  } catch {
+    throw new GatewayError("BAD_REQUEST", `the registry gave ${what} a tarball that is not a URL`);
+  }
+  if (url2.protocol !== "https:") {
+    throw new GatewayError("BAD_REQUEST", `plugins may only be installed over https; the registry points ${what} at ${tarball}`);
+  }
+  if (url2.host !== registry2.host) {
+    throw new GatewayError("BAD_REQUEST", `registry ${registry2.host} points ${what} at ${url2.host}; ` + "install that URL directly if it is the one you meant");
+  }
+}
+function digestsFor(dist, what) {
+  const digests = [];
+  if (dist.integrity !== null) {
+    for (const entry of dist.integrity.trim().split(/\s+/)) {
+      const dash = entry.indexOf("-");
+      const algorithm = dash === -1 ? "" : entry.slice(0, dash);
+      const value = dash === -1 ? "" : entry.slice(dash + 1);
+      if (value.length === 0)
+        continue;
+      const known = SRI_ALGORITHMS.find((candidate) => candidate === algorithm);
+      if (known === undefined)
+        continue;
+      digests.push({
+        algorithm: known,
+        expected: Buffer2.from(value, "base64").toString("hex"),
+        source: `${known} integrity`
+      });
+    }
+  }
+  if (digests.length === 0 && dist.shasum !== null && /^[0-9a-f]{40}$/i.test(dist.shasum)) {
+    digests.push({ algorithm: "sha1", expected: dist.shasum.toLowerCase(), source: "sha1 shasum" });
+  }
+  if (digests.length === 0) {
+    throw new GatewayError("BAD_REQUEST", `the registry advertises no usable integrity or shasum for ${what}; ` + "refusing to install bytes nothing vouches for");
+  }
+  return digests;
+}
+function verifyDigests(bytes, digests, what) {
+  for (const digest of digests) {
+    const actual = new Bun.CryptoHasher(digest.algorithm).update(bytes).digest("hex");
+    if (actual === digest.expected)
+      return;
+  }
+  const first = digests[0];
+  throw new GatewayError("BAD_REQUEST", `${what} does not match the ${first?.source ?? "digest"} the registry advertised; ` + "the download was corrupted or the registry served something else");
+}
+async function npmPayload(deps, spec) {
+  if (spec.version !== null && !EXACT_VERSION_PATTERN.test(spec.version)) {
+    throw new GatewayError("BAD_REQUEST", `${spec.name}@${spec.version} is not an exact version; this installer resolves no ranges ` + `or tags \u2014 install ${spec.name}@1.2.3, or ${spec.name} for the registry's latest`);
+  }
+  const fetchBytes = deps.fetchBytes;
+  if (fetchBytes === undefined) {
+    throw new GatewayError("BAD_REQUEST", "this caller cannot install from a registry");
+  }
+  const registry2 = registryUrl(deps);
+  const document = parseJson(await fetchBytes(packumentUrl(registry2, spec.name), NPM_PACKUMENT_ACCEPT), `the registry's answer for ${spec.name}`);
+  const { version: version2, dist } = resolveDist(document, spec);
+  const what = `${spec.name}@${version2}`;
+  checkTarballUrl(dist.tarball, registry2, what);
+  const digests = digestsFor(dist, what);
+  const bytes = await fetchBytes(dist.tarball);
+  verifyDigests(bytes, digests, what);
+  return stripRoot(readTar(gunzipIfNeeded(bytes)));
+}
+function parseJson(bytes, what) {
+  try {
+    return JSON.parse(decoder2.decode(bytes));
+  } catch (error51) {
+    const detail = error51 instanceof Error ? error51.message : String(error51);
+    throw new GatewayError("BAD_REQUEST", `${what} is not valid JSON: ${detail}`);
+  }
+}
+async function loadPayload(deps, spec) {
+  if (spec.startsWith("http://")) {
+    throw new GatewayError("BAD_REQUEST", "plugins may only be installed over https");
+  }
+  if (spec.startsWith("https://")) {
+    if (deps.fetchBytes === undefined) {
+      throw new GatewayError("BAD_REQUEST", "this caller cannot install from a URL");
+    }
+    return stripRoot(readTar(gunzipIfNeeded(await deps.fetchBytes(spec))));
+  }
+  const source = resolve2(spec);
+  if (deps.fs.isDirectory(source)) {
+    const files = readTree(deps.fs, source);
+    const claimed = basename2(source);
+    return { files, claimedId: ID_PATTERN2.test(claimed) ? claimed : null };
+  }
+  const bytes = deps.fs.readBytes(source);
+  if (bytes !== null)
+    return stripRoot(readTar(gunzipIfNeeded(bytes)));
+  const npm = parseNpmSpec(spec);
+  if (npm !== null)
+    return npmPayload(deps, npm);
+  throw new GatewayError("BAD_REQUEST", `no directory or archive at ${source}, and "${spec}" is not a package name`);
+}
+async function installPlugin(deps, root, spec) {
+  const payload = await loadPayload(deps, spec);
+  const raw = payload.files.get(MANIFEST_FILENAME);
+  if (raw === undefined) {
+    throw new GatewayError("BAD_REQUEST", `${spec} has no ${MANIFEST_FILENAME} at its root`);
+  }
+  let document;
+  try {
+    document = JSON.parse(decoder2.decode(raw));
+  } catch (error51) {
+    const detail = error51 instanceof Error ? error51.message : String(error51);
+    throw new GatewayError("BAD_REQUEST", `${MANIFEST_FILENAME} is not valid JSON: ${detail}`);
+  }
+  const parsed = safeParseManifest(document);
+  if (!parsed.ok)
+    throw new GatewayError("BAD_REQUEST", `invalid ${MANIFEST_FILENAME}: ${parsed.reason}`);
+  const manifest = parsed.manifest;
+  const targetId = payload.claimedId ?? manifest.id;
+  if (manifest.id !== targetId) {
+    throw new GatewayError("BAD_REQUEST", `manifest id ${manifest.id} does not match its directory ${targetId}; ` + "rename one of them so the gateway loads what you installed");
+  }
+  const dir = pluginsDir(root);
+  const target = join3(dir, targetId);
+  const replaced = deps.fs.isDirectory(target);
+  const staging = join3(dir, `.staging-${targetId}`);
+  deps.fs.rm(staging);
+  try {
+    for (const [path, bytes] of payload.files) {
+      const destination = join3(staging, path);
+      deps.fs.mkdir(join3(destination, ".."));
+      deps.fs.writeBytes(destination, bytes);
+    }
+    deps.fs.rm(target);
+    deps.fs.rename(staging, target);
+  } finally {
+    deps.fs.rm(staging);
+  }
+  return {
+    id: targetId,
+    name: manifest.name,
+    version: manifest.version,
+    path: target,
+    replaced,
+    restartRequired: true
+  };
+}
+function removePlugin(deps, root, id, options = {}) {
+  if (!ID_PATTERN2.test(id)) {
+    throw new GatewayError("BAD_REQUEST", `"${id}" is not a valid plugin id`);
+  }
+  const target = join3(pluginsDir(root), id);
+  const present = deps.fs.isDirectory(target);
+  const purge = options.purge === true;
+  if (purge && deps.store === undefined) {
+    throw new GatewayError("INTERNAL", "purging a plugin's data needs a database");
+  }
+  const tables = purge && deps.store !== undefined ? deps.store.plugins.listTables(id) : [];
+  if (!present && tables.length === 0) {
+    throw new GatewayError("BAD_REQUEST", `no plugin "${id}" installed under ${pluginsDir(root)}`);
+  }
+  if (present)
+    deps.fs.rm(target);
+  if (purge && deps.store !== undefined)
+    deps.store.plugins.dropAll(id);
+  return { id, removed: present, droppedTables: tables };
+}
+function orphanPluginTables(deps, root, store) {
+  const installed = listPlugins(deps, root).map((plugin) => plugin.id);
+  return store.plugins.orphanTables(installed);
+}
+
+// packages/control/src/nodeFs.ts
 function nodeDatabaseFs() {
   const dirBytes = (dir) => {
     let entries;
@@ -21045,7 +21846,7 @@ function nodeDatabaseFs() {
     }
     let total = 0;
     for (const entry of entries) {
-      const path = join3(dir, entry.name);
+      const path = join4(dir, entry.name);
       if (entry.isDirectory()) {
         total += dirBytes(path);
         continue;
@@ -21098,6 +21899,96 @@ function nodeDatabaseFs() {
     dirBytes
   };
 }
+function nodePluginFs() {
+  return {
+    readdir: (dir) => {
+      try {
+        return readdirSync(dir);
+      } catch {
+        return [];
+      }
+    },
+    readText: (path) => {
+      try {
+        return readFileSync(path, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    readBytes: (path) => {
+      try {
+        return new Uint8Array(readFileSync(path));
+      } catch {
+        return null;
+      }
+    },
+    writeBytes: (path, bytes) => {
+      writeFileSync(path, bytes);
+    },
+    isDirectory: (path) => {
+      try {
+        return statSync(path).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    isFile: (path) => {
+      try {
+        return statSync(path).isFile();
+      } catch {
+        return false;
+      }
+    },
+    mkdir: (dir) => {
+      mkdirSync(dir, { recursive: true });
+    },
+    rm: (path) => {
+      rmSync(path, { force: true, recursive: true });
+    },
+    rename: (from, to) => renameSync(from, to)
+  };
+}
+function nodeFetchBytes(options = {}) {
+  const impl = options.fetchImpl ?? fetch;
+  const maxBytes = options.maxBytes ?? MAX_PLUGIN_BYTES;
+  return async (url2, accept) => {
+    if (!url2.startsWith("https://")) {
+      throw new GatewayError("BAD_REQUEST", `plugins may only be fetched over https; ${url2} is not`);
+    }
+    const response = await impl(url2, {
+      headers: accept === undefined ? {} : { accept },
+      redirect: "follow"
+    });
+    if (!response.ok) {
+      throw new GatewayError("BAD_REQUEST", `${url2} answered ${response.status}`);
+    }
+    const reader = response.body?.getReader();
+    if (reader === undefined)
+      return new Uint8Array(0);
+    const chunks = [];
+    let total = 0;
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value === undefined)
+        continue;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel();
+        throw new GatewayError("BAD_REQUEST", `${url2} sent more than ${maxBytes} bytes`);
+      }
+      chunks.push(value);
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return bytes;
+  };
+}
 // packages/control/src/oauth/pkce.ts
 function randomToken() {
   return Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url");
@@ -22305,9 +23196,9 @@ function requirePositional(parsed, index, name) {
 }
 
 // apps/cli/src/context.ts
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
 import { homedir } from "os";
-import { isAbsolute, join as join4, resolve as resolve2 } from "path";
+import { isAbsolute, join as join5, resolve as resolve3 } from "path";
 class CliError extends Error {
   exitCode;
   constructor(message, exitCode = 1) {
@@ -22316,21 +23207,21 @@ class CliError extends Error {
     this.exitCode = exitCode;
   }
 }
-var DEFAULT_ROOT = join4(homedir(), ".config", "omnigateway");
+var DEFAULT_ROOT = join5(homedir(), ".config", "omnigateway");
 function looksLikeRoot(dir) {
-  return existsSync(join4(dir, ".env")) || existsSync(join4(dir, "omnigateway.db")) || existsSync(join4(dir, "apps", "gateway", "src", "index.ts"));
+  return existsSync(join5(dir, ".env")) || existsSync(join5(dir, "omnigateway.db")) || existsSync(join5(dir, "apps", "gateway", "src", "index.ts"));
 }
 function resolveRoot(flags, env2, cwd) {
   const withEnvFile = (root, source) => {
-    const envFile = join4(root, ".env");
+    const envFile = join5(root, ".env");
     return { root, source, envFile: existsSync(envFile) ? envFile : null };
   };
   if (flags.root !== undefined && flags.root.length > 0) {
-    return withEnvFile(resolve2(cwd, flags.root), "flag");
+    return withEnvFile(resolve3(cwd, flags.root), "flag");
   }
   const fromEnv = env2.OMNI_ROOT;
   if (typeof fromEnv === "string" && fromEnv.length > 0) {
-    return withEnvFile(resolve2(cwd, fromEnv), "env");
+    return withEnvFile(resolve3(cwd, fromEnv), "env");
   }
   if (looksLikeRoot(cwd))
     return withEnvFile(cwd, "cwd");
@@ -22361,7 +23252,7 @@ function createContext(parsed, options = {}) {
   const processEnv = options.env ?? process.env;
   const cwd = options.cwd ?? process.cwd();
   const root = resolveRoot({ root: stringFlag(parsed.values, "root") }, processEnv, cwd);
-  const fileEnv = root.envFile === null ? {} : parseEnvFile(readFileSync(root.envFile, "utf8"));
+  const fileEnv = root.envFile === null ? {} : parseEnvFile(readFileSync2(root.envFile, "utf8"));
   const env2 = { ...processEnv, ...fileEnv };
   const rawDbFlag = stringFlag(parsed.values, "db");
   const dbFlag = rawDbFlag === undefined || rawDbFlag.trim().length === 0 ? undefined : rawDbFlag;
@@ -22377,7 +23268,7 @@ function createContext(parsed, options = {}) {
     configError = error51 instanceof Error ? error51.message : "invalid configuration";
   }
   const configuredPath = dbFlag ?? config2?.databasePath ?? "omnigateway.db";
-  const databasePath = isAbsolute(configuredPath) ? configuredPath : resolve2(root.root, configuredPath);
+  const databasePath = isAbsolute(configuredPath) ? configuredPath : resolve3(root.root, configuredPath);
   const warnings = suppressedDbPath === null ? [] : [
     `ignoring OMNI_DB_PATH=${suppressedDbPath} from the environment because --root was given; using ${databasePath}`
   ];
@@ -22603,21 +23494,21 @@ async function pollUntilAuthorized(flows, start, deps) {
 }
 
 // apps/cli/src/service.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname3, join as join6 } from "path";
 var UNIT_NAME2 = "omnigateway.service";
 function unitPath(scope) {
-  return scope === "system" ? join5("/etc/systemd/system", UNIT_NAME2) : join5(homedir2(), ".config", "systemd", "user", UNIT_NAME2);
+  return scope === "system" ? join6("/etc/systemd/system", UNIT_NAME2) : join6(homedir2(), ".config", "systemd", "user", UNIT_NAME2);
 }
 function systemctlArgs(scope, args) {
   return scope === "system" ? ["systemctl", ...args] : ["systemctl", "--user", ...args];
 }
 function pidFile(stateDir) {
-  return join5(stateDir, "gateway.pid");
+  return join6(stateDir, "gateway.pid");
 }
 function logFile(stateDir) {
-  return join5(stateDir, "gateway.log");
+  return join6(stateDir, "gateway.log");
 }
 function supervisedLogFile(deps) {
   const configured = deps.logFile?.trim();
@@ -22625,8 +23516,8 @@ function supervisedLogFile(deps) {
 }
 function defaultStateDir(env2) {
   const xdg = env2.XDG_STATE_HOME;
-  const base = typeof xdg === "string" && xdg.length > 0 ? xdg : join5(homedir2(), ".local", "state");
-  return join5(base, "omnigateway");
+  const base = typeof xdg === "string" && xdg.length > 0 ? xdg : join6(homedir2(), ".local", "state");
+  return join6(base, "omnigateway");
 }
 function unitFile(input) {
   return `[Unit]
@@ -22637,7 +23528,7 @@ Wants=network-online.target
 [Service]
 Type=simple
 WorkingDirectory=${input.root}
-EnvironmentFile=${join5(input.root, ".env")}
+EnvironmentFile=${join6(input.root, ".env")}
 ExecStart=${input.bun} ${input.entrypoint}
 Restart=on-failure
 RestartSec=2
@@ -22653,7 +23544,7 @@ function readPid(stateDir) {
   const file2 = pidFile(stateDir);
   if (!existsSync2(file2))
     return null;
-  const pid = Number(readFileSync2(file2, "utf8").trim());
+  const pid = Number(readFileSync3(file2, "utf8").trim());
   return Number.isInteger(pid) && pid > 0 ? pid : null;
 }
 function livePid(deps) {
@@ -22719,7 +23610,7 @@ async function start(deps, input) {
     env: { ...input.env, OMNI_LOG_FILE: file2 },
     logFile: file2
   });
-  writeFileSync(pidFile(deps.stateDir), `${pid}
+  writeFileSync2(pidFile(deps.stateDir), `${pid}
 `);
   return { supervisor: "pidfile", pid, healthy: await waitForHealth(deps, input.baseUrl) };
 }
@@ -22765,7 +23656,7 @@ async function install(deps, input) {
     throw new Error(`${path} already exists; pass --force to replace it`);
   }
   mkdirSync2(dirname3(path), { recursive: true });
-  writeFileSync(path, unitFile({ root: deps.root, bun: input.bun, entrypoint: input.entrypoint }));
+  writeFileSync2(path, unitFile({ root: deps.root, bun: input.bun, entrypoint: input.entrypoint }));
   const reload = await deps.run(systemctlArgs(deps.scope, ["daemon-reload"]));
   let enabled = false;
   if (input.enable) {
@@ -23716,6 +24607,168 @@ ${candidates}${excluded}`;
     });
   }
 };
+// packages/plugin-api/src/events.ts
+var WINDOW_MS2 = {
+  "1m": 60000,
+  "5h": 5 * 60 * 60 * 1000,
+  "1w": 7 * 24 * 60 * 60 * 1000
+};
+// apps/cli/src/commands/plugins.ts
+function pluginDeps() {
+  return { fs: nodePluginFs(), sdkVersion: DASHBOARD_SDK_VERSION };
+}
+function installDeps(ctx, args) {
+  const flag = stringFlag(args.values, "registry");
+  const raw = flag ?? ctx.env.OMNI_PLUGIN_REGISTRY;
+  const registry2 = raw === undefined || raw.trim().length === 0 ? undefined : raw.trim();
+  return {
+    ...pluginDeps(),
+    fetchBytes: nodeFetchBytes(),
+    ...registry2 === undefined ? {} : { registry: registry2 }
+  };
+}
+function pluginState(ctx, plugin) {
+  if (!plugin.loadable)
+    return state(ctx, false, "will not load");
+  if (plugin.problems.length > 0)
+    return paint(ctx, "yellow", "loads, with warnings");
+  return state(ctx, true, "ok");
+}
+var pluginList = {
+  usage: "plugin list",
+  summary: "List installed plugins and whether the gateway would load each one",
+  async run(_args, { ctx, writer }) {
+    const root = ctx.root.root;
+    const plugins = listPlugins(pluginDeps(), root);
+    emit(ctx, writer, { pluginsDir: pluginsDir(root), plugins }, () => {
+      if (plugins.length === 0) {
+        return `no plugins installed; unpack one into ${pluginsDir(root)} with: omni plugin install <path-or-package>`;
+      }
+      const rows = plugins.map((plugin) => [
+        plugin.id,
+        plugin.name ?? "\u2014",
+        plugin.version ?? "\u2014",
+        plugin.api === null ? "\u2014" : String(plugin.api),
+        plugin.sdk ?? "\u2014",
+        plugin.capabilities.length === 0 ? "\u2014" : plugin.capabilities.join(","),
+        pluginState(ctx, plugin)
+      ]);
+      const body2 = table([
+        { header: "ID" },
+        { header: "NAME" },
+        { header: "VERSION" },
+        { header: "API" },
+        { header: "SDK" },
+        { header: "CAPABILITIES" },
+        { header: "STATE" }
+      ], rows);
+      const notes = plugins.flatMap((plugin) => plugin.problems.map((problem) => `${plugin.id}: ${paint(ctx, problem.fatal ? "red" : "yellow", problem.reason)}`));
+      return notes.length === 0 ? body2 : `${body2}
+
+${notes.join(`
+`)}`;
+    });
+  }
+};
+var pluginVerify = {
+  usage: "plugin verify <id>",
+  summary: "Run every load-time check on one plugin without loading it",
+  async run(args, { ctx, writer }) {
+    const id = requirePositional(args, 0, "plugin id");
+    const report = verifyPlugin(pluginDeps(), ctx.root.root, id);
+    emit(ctx, writer, report, () => {
+      const manifest = report.manifest;
+      const head = fields([
+        ["id", report.id],
+        ["path", report.path],
+        ["name", manifest?.name ?? "\u2014"],
+        ["version", manifest?.version ?? "\u2014"],
+        ["api", manifest === null ? "\u2014" : String(manifest.api)],
+        ["sdk", manifest?.sdk ?? "\u2014"],
+        ["server", manifest?.server ?? "\u2014"],
+        ["ui", manifest?.ui ?? "\u2014"],
+        [
+          "capabilities",
+          manifest === null || manifest.capabilities.length === 0 ? "\u2014" : manifest.capabilities.join(",")
+        ],
+        ["origins", manifest?.origins?.join(",") ?? "\u2014"]
+      ]);
+      if (report.problems.length === 0) {
+        return `${head}
+
+${state(ctx, true, "ok")}: this plugin would load`;
+      }
+      const lines = report.problems.map((problem) => `  ${paint(ctx, problem.fatal ? "red" : "yellow", problem.check)}  ${problem.reason}`);
+      const verdict = report.loadable ? paint(ctx, "yellow", "this plugin would load, with the warnings above") : state(ctx, false, "this plugin would be skipped at boot");
+      return `${head}
+
+${lines.join(`
+`)}
+
+${verdict}`;
+    });
+    if (!report.loadable)
+      throw new CliError(`plugin "${id}" would not load`);
+  }
+};
+var pluginInstall = {
+  usage: "plugin install <path|tarball|https url|package[@version]> [--registry <url>]",
+  summary: "Unpack a plugin into this installation, running nothing from it",
+  options: { registry: { type: "string" } },
+  async run(args, { ctx, writer }) {
+    const spec = requirePositional(args, 0, "plugin directory, tarball, url, or package name");
+    const result = await installPlugin(installDeps(ctx, args), ctx.root.root, spec);
+    emit(ctx, writer, result, () => {
+      note(ctx, writer, paint(ctx, "dim", "no code from the package was executed; verify it before restarting"));
+      const verb = result.replaced ? "replaced" : "installed";
+      return [
+        `${verb} ${result.name} ${result.version} at ${result.path}`,
+        paint(ctx, "yellow", "restart the gateway for this to take effect: omni restart")
+      ].join(`
+`);
+    });
+  }
+};
+var pluginRemove = {
+  usage: "plugin remove <id> [--purge]",
+  summary: "Remove a plugin, optionally dropping its stored data too",
+  options: { purge: { type: "boolean" } },
+  async run(args, { ctx, writer, prompt }) {
+    const id = requirePositional(args, 0, "plugin id");
+    const purge = boolFlag(args.values, "purge");
+    const question = purge ? `remove plugin "${id}" AND permanently drop its stored data?` : `remove plugin "${id}"? its stored data is kept`;
+    if (!await prompt.confirm(question))
+      throw new CliError("cancelled");
+    const deps = purge ? { fs: nodePluginFs(), store: await ctx.store() } : { fs: nodePluginFs() };
+    const result = removePlugin(deps, ctx.root.root, id, { purge });
+    emit(ctx, writer, result, () => {
+      const lines = [];
+      lines.push(result.removed ? `removed ${id}` : `no directory for ${id} to remove`);
+      if (purge) {
+        lines.push(result.droppedTables.length === 0 ? "no stored tables to drop" : `dropped ${result.droppedTables.length} table(s): ${result.droppedTables.join(", ")}`);
+      } else {
+        lines.push(paint(ctx, "dim", "stored tables and migration history kept; --purge drops them"));
+      }
+      lines.push(paint(ctx, "yellow", "restart the gateway for this to take effect: omni restart"));
+      return lines.join(`
+`);
+    });
+  }
+};
+function doctorPluginDeps() {
+  return pluginDeps();
+}
+function pluginDoctorLines(ctx, plugins) {
+  return plugins.map((plugin) => {
+    const version2 = plugin.version === null ? "" : ` ${plugin.version}`;
+    const api2 = plugin.api === null ? "api ?" : `api ${plugin.api}`;
+    const sdk = plugin.sdk === null ? "no ui" : `sdk ${plugin.sdk}`;
+    const reasons = plugin.problems.filter((problem) => problem.fatal).map((p) => p.reason);
+    const warnings = plugin.problems.length - reasons.length;
+    const verdict = reasons.length > 0 ? state(ctx, false, `will not load: ${reasons.join("; ")}`) : warnings > 0 ? paint(ctx, "yellow", `loads, ${warnings} warning(s); see omni plugin verify ${plugin.id}`) : state(ctx, true, "ok");
+    return `${plugin.id}${version2} (${api2}, ${sdk}) ${verdict}`;
+  });
+}
 
 // apps/cli/src/commands/quota.ts
 var WINDOW_ORDER = {
@@ -23820,7 +24873,7 @@ import { existsSync as existsSync5 } from "fs";
 
 // apps/cli/src/runtime.ts
 import { closeSync as closeSync2, existsSync as existsSync4, openSync as openSync2 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var runCommand = async (argv) => {
   const proc = Bun.spawn([...argv], { stdout: "pipe", stderr: "pipe" });
   const [stdout, stderr, code] = await Promise.all([
@@ -23877,9 +24930,9 @@ function processAlive(pid) {
 }
 function gatewayEntrypoint(root, cliDir = import.meta.dir) {
   const candidates = [
-    join6(root, "apps", "gateway", "src", "index.ts"),
-    join6(cliDir, "..", "gateway.js"),
-    join6(cliDir, "gateway.js")
+    join7(root, "apps", "gateway", "src", "index.ts"),
+    join7(cliDir, "..", "gateway.js"),
+    join7(cliDir, "gateway.js")
   ];
   return candidates.find((path) => existsSync4(path)) ?? null;
 }
@@ -24016,6 +25069,15 @@ async function rollupState(ctx) {
     return null;
   }
 }
+async function orphanTables(ctx) {
+  if (ctx.configError !== null || !existsSync5(ctx.databasePath))
+    return null;
+  try {
+    return orphanPluginTables(doctorPluginDeps(), ctx.root.root, await ctx.store());
+  } catch {
+    return null;
+  }
+}
 var doctor = {
   usage: "doctor",
   summary: "Check what this CLI resolved, and whether it can do anything with it",
@@ -24026,6 +25088,8 @@ var doctor = {
     const unit = unitInstalled(deps);
     const status2 = await status(deps);
     const usageRollup = await rollupState(ctx);
+    const plugins = listPlugins(doctorPluginDeps(), deps.root);
+    const orphans = await orphanTables(ctx);
     const checks3 = {
       root: deps.root,
       rootSource: ctx.root.source,
@@ -24040,6 +25104,9 @@ var doctor = {
       supervisor: status2.supervisor,
       running: status2.running,
       consoleSource: consoleSource(deps).source,
+      pluginsDir: pluginsDir(deps.root),
+      plugins,
+      orphanPluginTables: orphans,
       warnings: ctx.warnings
     };
     emit(ctx, writer, checks3, () => {
@@ -24061,6 +25128,11 @@ var doctor = {
         ["systemd unit", unit ? deps.scope : paint(ctx, "dim", "none")],
         ["gateway", ok(status2.running, status2.running ? "running" : "stopped")],
         ["console log", sourceHint(checks3.consoleSource)],
+        ...plugins.length === 0 ? [["plugins", paint(ctx, "dim", "none")]] : pluginDoctorLines(ctx, plugins).map((line, index) => [index === 0 ? "plugins" : "", line]),
+        [
+          "orphan plugin tables",
+          orphans === null ? paint(ctx, "dim", "not checked") : orphans.length === 0 ? ok(true, "none") : paint(ctx, "yellow", `${orphans.length}: ${orphans.join(", ")}`)
+        ],
         ...checks3.warnings.map((warning) => ["ignored", paint(ctx, "yellow", warning)])
       ]);
     });
@@ -24141,7 +25213,7 @@ var settingsSet = {
 };
 
 // apps/cli/src/commands/setup.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var OPTIONS = {
   dir: { type: "string" },
   key: { type: "string" },
@@ -24173,7 +25245,7 @@ ${f.contents}`).join(`
   }
 }
 function at(dir, file2) {
-  return { path: join7(dir, file2.path), contents: file2.contents };
+  return { path: join8(dir, file2.path), contents: file2.contents };
 }
 async function promptMapping(models, prompt) {
   const choices = models.map(({ model }) => model.id).join(", ");
@@ -24207,11 +25279,11 @@ var setupClaude = {
   options: OPTIONS,
   async run(args, { ctx, writer, prompt, setupFs }) {
     const models = await described(ctx);
-    const dir = stringFlag(args.values, "dir") ?? join7(setupFs.homeDir, ".claude");
+    const dir = stringFlag(args.values, "dir") ?? join8(setupFs.homeDir, ".claude");
     const key = stringFlag(args.values, "key");
     const dryRun2 = boolFlag(args.values, "dry-run");
     const mapping = await promptMapping(models, prompt);
-    const path = join7(dir, "settings.json");
+    const path = join8(dir, "settings.json");
     const file2 = claudeSettings(models, {
       baseUrl: baseUrl(ctx),
       discoveryMirrors: ctx.config().exposeClaudeCodeAliases,
@@ -24466,6 +25538,10 @@ var COMMANDS = {
   "keys create": keysCreate,
   "keys limits": keysLimits,
   "keys revoke": keysRevoke,
+  "plugin list": pluginList,
+  "plugin verify": pluginVerify,
+  "plugin install": pluginInstall,
+  "plugin remove": pluginRemove,
   "settings get": settingsGet,
   "settings set": settingsSet,
   "setup claude": setupClaude,
@@ -24521,6 +25597,7 @@ var GROUPS = [
   { title: "Accounts", prefixes: ["connect", "credentials "] },
   { title: "Models", prefixes: ["models "] },
   { title: "Keys", prefixes: ["keys "] },
+  { title: "Plugins", prefixes: ["plugin "] },
   { title: "Configuration", prefixes: ["settings ", "admin ", "db "] },
   { title: "Reports", prefixes: ["usage", "quota"] }
 ];
@@ -24577,10 +25654,10 @@ async function readHidden() {
   stdin.setRawMode?.(true);
   stdin.resume();
   try {
-    const decoder2 = new TextDecoder;
+    const decoder3 = new TextDecoder;
     let line = "";
     for await (const chunk of stdin) {
-      const text = decoder2.decode(chunk, { stream: true });
+      const text = decoder3.decode(chunk, { stream: true });
       for (const char of text) {
         if (char === "\r" || char === `
 `)
@@ -24601,10 +25678,10 @@ async function readHidden() {
   }
 }
 async function readLine() {
-  const decoder2 = new TextDecoder;
+  const decoder3 = new TextDecoder;
   let line = "";
   for await (const chunk of process.stdin) {
-    const text = decoder2.decode(chunk, { stream: true });
+    const text = decoder3.decode(chunk, { stream: true });
     const newline = text.indexOf(`
 `);
     if (newline >= 0)
@@ -24700,10 +25777,10 @@ async function run(argv, writer, options = {}) {
     setupFs: options.setupFs ?? {
       homeDir: homedir3(),
       cwd: process.cwd(),
-      read: (path) => existsSync6(path) ? readFileSync3(path, "utf8") : null,
+      read: (path) => existsSync6(path) ? readFileSync4(path, "utf8") : null,
       write: (path, contents) => atomicWriteFile(path, contents, {
         mkdir: (directory) => mkdirSync3(directory, { recursive: true }),
-        write: (temporary, data) => writeFileSync2(temporary, data),
+        write: (temporary, data) => writeFileSync3(temporary, data),
         rename: renameSync2,
         remove: (temporary) => rmSync3(temporary, { force: true })
       })