@agent-native/core 0.113.0 → 0.114.0

package/src/extensions/schema.ts

@@ -0,0 +1,269 @@
+/**
+ * Drizzle schema for the framework extensions system.
+ *
+ * Extensions are mini Alpine.js apps that run inside sandboxed iframes. They
+ * can call external APIs via a server-side proxy that resolves `${keys.NAME}`
+ * secret references. Extensions use the standard sharing model (private by
+ * default, shareable with org/others).
+ *
+ * The tables are auto-created at server boot via `ensureTable()` in store.ts,
+ * following the same pattern as `app_secrets`.
+ *
+ * NOTE: physical SQL table/column names stay as `tools`, `tool_data`,
+ * `tool_shares`, `tool_consents`, `tool_id`, etc. — additive-only schema
+ * policy means we never rename DB-level identifiers. The JS/TS surface is
+ * renamed to `extensions`/`extension*`; the DB-side names stay so existing
+ * deployed rows remain readable.
+ */
+
+import { table, text, integer, now } from "../db/schema.js";
+import { ownableColumns, createSharesTable } from "../sharing/schema.js";
+
+export const extensions = table("tools", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  description: text("description").notNull().default(""),
+  content: text("content").notNull().default(""),
+  icon: text("icon"),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+  hiddenAt: text("hidden_at"),
+  hiddenBy: text("hidden_by"),
+  ...ownableColumns(),
+});
+
+export const extensionShares = createSharesTable("tool_shares");
+
+export const extensionHides = table("tool_hidden_extensions", {
+  id: text("id").primaryKey(),
+  extensionId: text("tool_id").notNull(),
+  ownerEmail: text("owner_email").notNull(),
+  createdAt: text("created_at").notNull().default(now()),
+});
+
+export const extensionHistory = table("tool_history", {
+  id: text("id").primaryKey(),
+  extensionId: text("tool_id").notNull(),
+  version: integer("version").notNull(),
+  operation: text("operation").notNull(),
+  summary: text("summary").notNull().default(""),
+  name: text("name").notNull(),
+  description: text("description").notNull().default(""),
+  content: text("content").notNull().default(""),
+  icon: text("icon"),
+  actorEmail: text("actor_email"),
+  ownerEmail: text("owner_email").notNull().default("local@localhost"),
+  orgId: text("org_id"),
+  visibility: text("visibility").notNull().default("private"),
+  createdAt: text("created_at").notNull().default(now()),
+});
+
+export const EXTENSIONS_CREATE_SQL = `CREATE TABLE IF NOT EXISTS tools (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  content TEXT NOT NULL DEFAULT '',
+  icon TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  hidden_at TEXT,
+  hidden_by TEXT,
+  owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+  org_id TEXT,
+  visibility TEXT NOT NULL DEFAULT 'private'
+)`;
+
+export const EXTENSIONS_CREATE_SQL_PG = `CREATE TABLE IF NOT EXISTS tools (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  content TEXT NOT NULL DEFAULT '',
+  icon TEXT,
+  created_at TEXT NOT NULL DEFAULT now(),
+  updated_at TEXT NOT NULL DEFAULT now(),
+  hidden_at TEXT,
+  hidden_by TEXT,
+  owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+  org_id TEXT,
+  visibility TEXT NOT NULL DEFAULT 'private'
+)`;
+
+export const EXTENSION_SHARES_CREATE_SQL = `CREATE TABLE IF NOT EXISTS tool_shares (
+  id TEXT PRIMARY KEY,
+  resource_id TEXT NOT NULL,
+  principal_type TEXT NOT NULL,
+  principal_id TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'viewer',
+  created_by TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+)`;
+
+export const EXTENSION_SHARES_CREATE_SQL_PG = `CREATE TABLE IF NOT EXISTS tool_shares (
+  id TEXT PRIMARY KEY,
+  resource_id TEXT NOT NULL,
+  principal_type TEXT NOT NULL,
+  principal_id TEXT NOT NULL,
+  role TEXT NOT NULL DEFAULT 'viewer',
+  created_by TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT now()
+)`;
+
+export const extensionData = table("tool_data", {
+  id: text("id").primaryKey(),
+  extensionId: text("tool_id").notNull(),
+  collection: text("collection").notNull(),
+  itemId: text("item_id"),
+  data: text("data").notNull(),
+  ownerEmail: text("owner_email").notNull().default("local@localhost"),
+  scope: text("scope").notNull().default("user"),
+  orgId: text("org_id"),
+  scopeKey: text("scope_key").notNull().default("local@localhost"),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+});
+
+export const EXTENSION_DATA_CREATE_SQL = `CREATE TABLE IF NOT EXISTS tool_data (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  collection TEXT NOT NULL,
+  item_id TEXT,
+  data TEXT NOT NULL,
+  owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+  scope TEXT NOT NULL DEFAULT 'user',
+  org_id TEXT,
+  scope_key TEXT NOT NULL DEFAULT 'local@localhost',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+)`;
+
+export const EXTENSION_DATA_CREATE_SQL_PG = `CREATE TABLE IF NOT EXISTS tool_data (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  collection TEXT NOT NULL,
+  item_id TEXT,
+  data TEXT NOT NULL,
+  owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+  scope TEXT NOT NULL DEFAULT 'user',
+  org_id TEXT,
+  scope_key TEXT NOT NULL DEFAULT 'local@localhost',
+  created_at TEXT NOT NULL DEFAULT now(),
+  updated_at TEXT NOT NULL DEFAULT now()
+)`;
+
+export const EXTENSION_DATA_ITEM_INDEX_SQL = `CREATE UNIQUE INDEX IF NOT EXISTS tool_data_scoped_item_idx
+  ON tool_data (tool_id, collection, scope_key, item_id)`;
+
+export const EXTENSION_DATA_ITEM_INDEX_SQL_PG = `CREATE UNIQUE INDEX IF NOT EXISTS tool_data_scoped_item_idx
+  ON tool_data (tool_id, collection, scope_key, item_id)`;
+
+export const EXTENSION_DATA_DROP_OLD_INDEX_SQL = `DROP INDEX IF EXISTS tool_data_scope_item_idx`;
+export const EXTENSION_DATA_DROP_OLD_INDEX_SQL_PG = `DROP INDEX IF EXISTS tool_data_scope_item_idx`;
+
+export const EXTENSIONS_OWNER_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tools_owner_idx ON tools (owner_email)`;
+export const EXTENSIONS_ORG_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tools_org_idx ON tools (org_id)`;
+export const EXTENSIONS_UPDATED_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tools_updated_at_idx ON tools (updated_at)`;
+
+// Global (admin) hide: when set, the extension row is hidden from EVERYONE's
+// list, distinct from the per-user `tool_hidden_extensions` table. Additive
+// columns — see ensureExtensionsTables() for the idempotent ADD COLUMN run.
+export const EXTENSIONS_HIDDEN_AT_COLUMN_SQL = `ALTER TABLE tools ADD COLUMN IF NOT EXISTS hidden_at TEXT`;
+export const EXTENSIONS_HIDDEN_BY_COLUMN_SQL = `ALTER TABLE tools ADD COLUMN IF NOT EXISTS hidden_by TEXT`;
+export const EXTENSIONS_HIDDEN_AT_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tools_hidden_at_idx ON tools (hidden_at)`;
+export const EXTENSION_SHARES_RESOURCE_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tool_shares_resource_idx ON tool_shares (resource_id)`;
+
+export const EXTENSION_HIDES_CREATE_SQL = `CREATE TABLE IF NOT EXISTS tool_hidden_extensions (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  owner_email TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+)`;
+
+export const EXTENSION_HIDES_CREATE_SQL_PG = `CREATE TABLE IF NOT EXISTS tool_hidden_extensions (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  owner_email TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT now()
+)`;
+
+export const EXTENSION_HIDES_UNIQUE_INDEX_SQL = `CREATE UNIQUE INDEX IF NOT EXISTS tool_hidden_extensions_user_tool_idx
+  ON tool_hidden_extensions (owner_email, tool_id)`;
+
+export const EXTENSION_HIDES_OWNER_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tool_hidden_extensions_owner_idx
+  ON tool_hidden_extensions (owner_email)`;
+
+export const EXTENSION_HISTORY_CREATE_SQL = `CREATE TABLE IF NOT EXISTS tool_history (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  version INTEGER NOT NULL,
+  operation TEXT NOT NULL,
+  summary TEXT NOT NULL DEFAULT '',
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  content TEXT NOT NULL DEFAULT '',
+  icon TEXT,
+  actor_email TEXT,
+  owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+  org_id TEXT,
+  visibility TEXT NOT NULL DEFAULT 'private',
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+)`;
+
+export const EXTENSION_HISTORY_CREATE_SQL_PG = `CREATE TABLE IF NOT EXISTS tool_history (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  version INTEGER NOT NULL,
+  operation TEXT NOT NULL,
+  summary TEXT NOT NULL DEFAULT '',
+  name TEXT NOT NULL,
+  description TEXT NOT NULL DEFAULT '',
+  content TEXT NOT NULL DEFAULT '',
+  icon TEXT,
+  actor_email TEXT,
+  owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+  org_id TEXT,
+  visibility TEXT NOT NULL DEFAULT 'private',
+  created_at TEXT NOT NULL DEFAULT now()
+)`;
+
+export const EXTENSION_HISTORY_VERSION_INDEX_SQL = `CREATE UNIQUE INDEX IF NOT EXISTS tool_history_tool_version_idx
+  ON tool_history (tool_id, version)`;
+
+export const EXTENSION_HISTORY_CREATED_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tool_history_tool_created_idx
+  ON tool_history (tool_id, created_at)`;
+
+// ---------------------------------------------------------------------------
+// extension_consents — vestigial, kept for additive-schema compliance
+// ---------------------------------------------------------------------------
+//
+// Originally added for an audit-C1 per-(viewer, extension, content_hash)
+// consent gate that prompted viewers to "Run anyway" before non-author
+// extensions could execute. We removed the runtime gate after settling on
+// intra-org trust (extensions are shared between trusted teammates; the
+// org-level access controls are sufficient). The table is kept here so
+// deploys that already ran the migration stay healthy — additive-only schema
+// policy means we never drop. Physical name stays `tool_consents`.
+
+export const extensionConsents = table("tool_consents", {
+  viewerEmail: text("viewer_email").notNull(),
+  extensionId: text("tool_id").notNull(),
+  contentHash: text("content_hash").notNull(),
+  grantedAt: text("granted_at").notNull().default(now()),
+});
+
+export const EXTENSION_CONSENTS_CREATE_SQL = `CREATE TABLE IF NOT EXISTS tool_consents (
+  viewer_email TEXT NOT NULL,
+  tool_id TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  granted_at TEXT NOT NULL DEFAULT (datetime('now')),
+  PRIMARY KEY (viewer_email, tool_id, content_hash)
+)`;
+
+export const EXTENSION_CONSENTS_CREATE_SQL_PG = `CREATE TABLE IF NOT EXISTS tool_consents (
+  viewer_email TEXT NOT NULL,
+  tool_id TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  granted_at TEXT NOT NULL DEFAULT now(),
+  PRIMARY KEY (viewer_email, tool_id, content_hash)
+)`;
+
+export const EXTENSION_CONSENTS_VIEWER_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tool_consents_viewer_idx ON tool_consents (viewer_email, tool_id)`;

package/src/extensions/session-replay-iframe.ts

@@ -0,0 +1,131 @@
+import {
+  isTrustedSessionReplayIframeParentOrigin,
+  SESSION_REPLAY_IFRAME_PROBE,
+  SESSION_REPLAY_IFRAME_START,
+  SESSION_REPLAY_IFRAME_STOP,
+} from "../session-replay-iframe-protocol.js";
+
+export const RRWEB_RECORD_IFRAME_CDN_URL =
+  "https://cdn.jsdelivr.net/npm/@rrweb/record@2.1.0/umd/record.min.js";
+export const RRWEB_RECORD_IFRAME_SRI =
+  "sha384-MrD66HBNSykaP2N95+6hQCFlF5oH2tvL3TD/zyvHNkP/sAFWZx98DX9MEDy8MdVT";
+
+/**
+ * Installs the cooperative side of rrweb's cross-origin iframe protocol.
+ * Nothing is fetched or recorded until a trusted first-party parent asks the
+ * frame to start. rrweb then forwards its events directly to that parent.
+ */
+export function buildSessionReplayIframeBootstrap(): string {
+  const probeType = JSON.stringify(SESSION_REPLAY_IFRAME_PROBE);
+  const startType = JSON.stringify(SESSION_REPLAY_IFRAME_START);
+  const stopType = JSON.stringify(SESSION_REPLAY_IFRAME_STOP);
+  const scriptUrl = JSON.stringify(RRWEB_RECORD_IFRAME_CDN_URL);
+  const integrity = JSON.stringify(RRWEB_RECORD_IFRAME_SRI);
+
+  return `<script>
+    (function() {
+      var recorderStop = null;
+      var recorderLoad = null;
+      var startGeneration = 0;
+      var isTrustedParentOrigin = ${isTrustedSessionReplayIframeParentOrigin.toString()};
+
+      function stopRecorder() {
+        startGeneration += 1;
+        if (typeof recorderStop === 'function') {
+          try { recorderStop(); } catch (_) {}
+        }
+        recorderStop = null;
+      }
+
+      function getRecord() {
+        return window.rrwebRecord && typeof window.rrwebRecord.record === 'function'
+          ? window.rrwebRecord.record
+          : null;
+      }
+
+      function loadRecorder() {
+        if (recorderLoad) return recorderLoad;
+        recorderLoad = new Promise(function(resolve, reject) {
+          var script = document.createElement('script');
+          script.src = ${scriptUrl};
+          script.integrity = ${integrity};
+          script.crossOrigin = 'anonymous';
+          script.referrerPolicy = 'no-referrer';
+          script.async = true;
+          script.onload = function() {
+            var record = getRecord();
+            if (record) resolve(record);
+            else reject(new Error('rrweb recorder did not initialize'));
+          };
+          script.onerror = function() {
+            recorderLoad = null;
+            reject(new Error('rrweb recorder failed to load'));
+          };
+          document.head.appendChild(script);
+        });
+        return recorderLoad;
+      }
+
+      function validOptions(options) {
+        return !!options &&
+          typeof options === 'object' &&
+          typeof options.blockSelector === 'string' &&
+          typeof options.ignoreSelector === 'string' &&
+          typeof options.maskTextSelector === 'string' &&
+          typeof options.maskAllInputs === 'boolean' &&
+          typeof options.recordCanvas === 'boolean' &&
+          typeof options.collectFonts === 'boolean' &&
+          typeof options.inlineImages === 'boolean' &&
+          !!options.sampling && typeof options.sampling === 'object';
+      }
+
+      function startRecorder(options) {
+        if (!validOptions(options)) return;
+        stopRecorder();
+        var generation = startGeneration;
+        loadRecorder().then(function(record) {
+          if (generation !== startGeneration) return;
+          recorderStop = record({
+            blockSelector: options.blockSelector,
+            ignoreSelector: options.ignoreSelector,
+            maskTextClass: options.maskTextClass,
+            maskTextSelector: options.maskTextSelector,
+            maskAllInputs: options.maskAllInputs,
+            maskInputOptions: options.maskInputOptions,
+            recordCanvas: options.recordCanvas,
+            collectFonts: options.collectFonts,
+            inlineImages: options.inlineImages,
+            sampling: options.sampling,
+            recordCrossOriginIframes: true
+          }) || null;
+        }).catch(function() {});
+      }
+
+      window.addEventListener('message', function(event) {
+        if (event.source !== window.parent || !isTrustedParentOrigin(event.origin, window.location.href)) return;
+        var message = event.data;
+        if (!message || typeof message !== 'object') return;
+        if (message.type === ${startType}) startRecorder(message.options);
+        else if (message.type === ${stopType}) stopRecorder();
+      });
+      window.addEventListener('pagehide', stopRecorder);
+
+      if (window.parent !== window) {
+        window.parent.postMessage({ type: ${probeType} }, '*');
+      }
+    })();
+  </script>`;
+}
+
+export function injectSessionReplayIframeBootstrap(html: string): string {
+  const bootstrap = buildSessionReplayIframeBootstrap();
+  const headClose = html.search(/<\/head\s*>/i);
+  if (headClose >= 0) {
+    return `${html.slice(0, headClose)}${bootstrap}${html.slice(headClose)}`;
+  }
+  const bodyOpen = html.search(/<body(?:\s[^>]*)?>/i);
+  if (bodyOpen >= 0) {
+    return `${html.slice(0, bodyOpen)}${bootstrap}${html.slice(bodyOpen)}`;
+  }
+  return `${bootstrap}${html}`;
+}

package/src/extensions/slots/routes.ts

@@ -0,0 +1,126 @@
+/**
+ * HTTP handler for extension extension-point slots.
+ *
+ * Mounted at `/_agent-native/slots`. Routes:
+ *
+ *   GET    /:slotId/installs    — current user's installed widgets for a slot
+ *   GET    /:slotId/available   — extensions that declare this slot, scoped to user access
+ *   POST   /:slotId/install     — install a extension into a slot (body: { extensionId, position?, config? })
+ *   DELETE /:slotId/install/:extensionId — uninstall
+ *   GET    /extension/:extensionId        — list slot declarations for a specific extension
+ *   POST   /extension/:extensionId        — declare a slot target (body: { slotId, config? })
+ *   DELETE /extension/:extensionId/:slotId — remove a slot declaration
+ */
+
+import {
+  defineEventHandler,
+  getMethod,
+  setResponseStatus,
+  type H3Event,
+} from "h3";
+
+import { getOrgContext } from "../../org/context.js";
+import { getSession } from "../../server/auth.js";
+import { readBody } from "../../server/h3-helpers.js";
+import { recordChange } from "../../server/poll.js";
+import { runWithRequestContext } from "../../server/request-context.js";
+import {
+  addExtensionSlotTarget,
+  removeExtensionSlotTarget,
+  listSlotsForExtension,
+  listExtensionsForSlot,
+  installExtensionSlot,
+  uninstallExtensionSlot,
+  listSlotInstallsForUser,
+} from "./store.js";
+
+export function createSlotsHandler() {
+  return defineEventHandler(async (event: H3Event) => {
+    const method = getMethod(event);
+    const pathname = (event.url?.pathname || "")
+      .replace(/^\/+/, "")
+      .replace(/\/+$/, "");
+    const parts = pathname ? pathname.split("/") : [];
+
+    const session = await getSession(event).catch(() => null);
+    if (!session?.email) {
+      setResponseStatus(event, 401);
+      return { error: "Authentication required" };
+    }
+
+    const orgCtx = await getOrgContext(event).catch(() => null);
+    const userEmail = session.email;
+    const orgId = orgCtx?.orgId ?? session.orgId ?? undefined;
+
+    return runWithRequestContext({ userEmail, orgId }, () =>
+      dispatch(event, method, parts),
+    );
+  });
+}
+
+async function dispatch(
+  event: H3Event,
+  method: string,
+  parts: string[],
+): Promise<unknown> {
+  // GET /extension/:extensionId — list a extension's slot declarations
+  if (method === "GET" && parts.length === 2 && parts[0] === "extension") {
+    return listSlotsForExtension(parts[1]);
+  }
+
+  // POST /extension/:extensionId — declare a slot target { slotId, config? }
+  if (method === "POST" && parts.length === 2 && parts[0] === "extension") {
+    const body = await readBody(event);
+    const slotId = String(body?.slotId ?? "").trim();
+    if (!slotId) {
+      setResponseStatus(event, 400);
+      return { error: "slotId is required" };
+    }
+    const row = await addExtensionSlotTarget(parts[1], slotId, body?.config);
+    recordChange({ source: "action", type: "change" });
+    return row;
+  }
+
+  // DELETE /extension/:extensionId/:slotId — remove a slot declaration
+  if (method === "DELETE" && parts.length === 3 && parts[0] === "extension") {
+    await removeExtensionSlotTarget(parts[1], parts[2]);
+    recordChange({ source: "action", type: "change" });
+    return { ok: true };
+  }
+
+  // GET /:slotId/installs — current user's installs in slot
+  if (method === "GET" && parts.length === 2 && parts[1] === "installs") {
+    return listSlotInstallsForUser(parts[0]);
+  }
+
+  // GET /:slotId/available — extensions that declare this slot the user can install
+  if (method === "GET" && parts.length === 2 && parts[1] === "available") {
+    return listExtensionsForSlot(parts[0]);
+  }
+
+  // POST /:slotId/install — install { extensionId, position?, config? }
+  if (method === "POST" && parts.length === 2 && parts[1] === "install") {
+    const body = await readBody(event);
+    const extensionId = String(body?.extensionId ?? "").trim();
+    if (!extensionId) {
+      setResponseStatus(event, 400);
+      return { error: "extensionId is required" };
+    }
+    const row = await installExtensionSlot(extensionId, parts[0], {
+      position: body?.position,
+      config: body?.config,
+    });
+    recordChange({ source: "action", type: "change" });
+    return row;
+  }
+
+  // DELETE /:slotId/install/:extensionId — uninstall
+  if (method === "DELETE" && parts.length === 3 && parts[1] === "install") {
+    await uninstallExtensionSlot(parts[2], parts[0]);
+    recordChange({ source: "action", type: "change" });
+    return { ok: true };
+  }
+
+  setResponseStatus(event, 404);
+  return { error: "Not found" };
+}

package/src/extensions/slots/schema.ts

@@ -0,0 +1,87 @@
+/**
+ * Drizzle schema for the extension-points slot system.
+ *
+ * Two tables:
+ *
+ * - `extension_slots`     — declarations: "extension X can render in slot Y".
+ *                           Authored once per extension, regardless of installer.
+ *                           Physical SQL name stays `tool_slots` (additive-only).
+ * - `extension_slot_installs` — per-user installs: "user U wants extension X in
+ *                               slot Y at position N". Always scoped by
+ *                               owner_email. Physical SQL name stays
+ *                               `tool_slot_installs`.
+ *
+ * Neither table spreads `ownableColumns()` — they're not first-class shareable
+ * resources. Access to the underlying extension flows through the existing
+ * `extensions` table sharing model; install rows are personal preferences
+ * scoped to the installing user.
+ */
+
+import { table, text, integer, now } from "../../db/schema.js";
+
+export const extensionSlots = table("tool_slots", {
+  id: text("id").primaryKey(),
+  extensionId: text("tool_id").notNull(),
+  slotId: text("slot_id").notNull(),
+  config: text("config"),
+  createdAt: text("created_at").notNull().default(now()),
+});
+
+export const extensionSlotInstalls = table("tool_slot_installs", {
+  id: text("id").primaryKey(),
+  extensionId: text("tool_id").notNull(),
+  slotId: text("slot_id").notNull(),
+  ownerEmail: text("owner_email").notNull(),
+  orgId: text("org_id"),
+  position: integer("position").notNull().default(0),
+  config: text("config"),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+});
+
+export const EXTENSION_SLOTS_CREATE_SQL = `CREATE TABLE IF NOT EXISTS tool_slots (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  slot_id TEXT NOT NULL,
+  config TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+)`;
+
+export const EXTENSION_SLOTS_CREATE_SQL_PG = `CREATE TABLE IF NOT EXISTS tool_slots (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  slot_id TEXT NOT NULL,
+  config TEXT,
+  created_at TEXT NOT NULL DEFAULT now()
+)`;
+
+export const EXTENSION_SLOTS_BY_SLOT_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tool_slots_by_slot_idx ON tool_slots (slot_id)`;
+export const EXTENSION_SLOTS_BY_EXTENSION_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tool_slots_by_tool_idx ON tool_slots (tool_id)`;
+export const EXTENSION_SLOTS_UNIQUE_INDEX_SQL = `CREATE UNIQUE INDEX IF NOT EXISTS tool_slots_unique_idx ON tool_slots (tool_id, slot_id)`;
+
+export const EXTENSION_SLOT_INSTALLS_CREATE_SQL = `CREATE TABLE IF NOT EXISTS tool_slot_installs (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  slot_id TEXT NOT NULL,
+  owner_email TEXT NOT NULL,
+  org_id TEXT,
+  position INTEGER NOT NULL DEFAULT 0,
+  config TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+)`;
+
+export const EXTENSION_SLOT_INSTALLS_CREATE_SQL_PG = `CREATE TABLE IF NOT EXISTS tool_slot_installs (
+  id TEXT PRIMARY KEY,
+  tool_id TEXT NOT NULL,
+  slot_id TEXT NOT NULL,
+  owner_email TEXT NOT NULL,
+  org_id TEXT,
+  position INTEGER NOT NULL DEFAULT 0,
+  config TEXT,
+  created_at TEXT NOT NULL DEFAULT now(),
+  updated_at TEXT NOT NULL DEFAULT now()
+)`;
+
+export const EXTENSION_SLOT_INSTALLS_BY_USER_SLOT_INDEX_SQL = `CREATE INDEX IF NOT EXISTS tool_slot_installs_by_user_slot_idx ON tool_slot_installs (owner_email, slot_id)`;
+export const EXTENSION_SLOT_INSTALLS_UNIQUE_INDEX_SQL = `CREATE UNIQUE INDEX IF NOT EXISTS tool_slot_installs_unique_idx ON tool_slot_installs (owner_email, tool_id, slot_id)`;