@opengeni/db 0.2.2 → 0.3.0

package/dist/index.js

@@ -26,6 +26,7 @@ import {
   sessionEvents,
   sessionGoals,
   sessionHistoryItems,
+  sessionMcpServers,
   sessionRecordings,
   sessionTurns,
   sessions,
@@ -38,7 +39,7 @@ import {
   workspaceMemberships,
   workspacePacks,
   workspaces
-} from "./chunk-PSX56ZTL.js";
+} from "./chunk-NZA6YVN7.js";
 import {
   migrate,
   runMigrations
@@ -144,12 +145,64 @@ function sanitizeEventPayload(payload) {
   }
   if (payload && typeof payload === "object") {
     const entries = Object.entries(payload).map(
-      ([key, value]) => [sanitizeEventString(key), sanitizeEventPayload(value)]
+      ([key, value]) => [sanitizeEventString(key), sanitizeSensitiveEventField(key, value)]
     );
     return Object.fromEntries(entries);
   }
   return payload;
 }
+function sanitizeSensitiveEventField(key, value) {
+  if (key === "mcpServers") {
+    return sanitizeSessionMcpServerList(value);
+  }
+  if (key === "mcpCredentialUpdates") {
+    return sanitizeMcpCredentialUpdateList(value);
+  }
+  return sanitizeEventPayload(value);
+}
+function sanitizeSessionMcpServerList(value) {
+  if (!Array.isArray(value)) {
+    return sanitizeEventPayload(value);
+  }
+  return value.map((item) => {
+    if (!isPlainObject(item)) {
+      return sanitizeEventPayload(item);
+    }
+    const { headers, headersEncrypted, ...rest } = item;
+    const cleaned = sanitizeEventPayload(rest);
+    const headerNames = safeHeaderNames(headers) ?? safeHeaderNames(headersEncrypted);
+    if (headerNames) {
+      cleaned.headerNames = headerNames;
+    }
+    return cleaned;
+  });
+}
+function sanitizeMcpCredentialUpdateList(value) {
+  if (!Array.isArray(value)) {
+    return sanitizeEventPayload(value);
+  }
+  return value.map((item) => {
+    if (!isPlainObject(item)) {
+      return sanitizeEventPayload(item);
+    }
+    const { headers, headersEncrypted, ...rest } = item;
+    const cleaned = sanitizeEventPayload(rest);
+    const headerNames = safeHeaderNames(headers) ?? safeHeaderNames(headersEncrypted);
+    if (headerNames) {
+      cleaned.headerNames = headerNames;
+    }
+    return cleaned;
+  });
+}
+function safeHeaderNames(value) {
+  if (!isPlainObject(value)) {
+    return null;
+  }
+  return Object.keys(value).map(sanitizeEventString).sort();
+}
+function isPlainObject(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
 
 // src/index.ts
 import { sql as sql2 } from "drizzle-orm";
@@ -388,6 +441,7 @@ var allWorkspacePermissions = [
   "api_keys:manage",
   "environments:manage",
   "environments:use",
+  "mcp_servers:attach",
   "goals:manage",
   "enrollments:read",
   "enrollments:manage"
@@ -2093,6 +2147,111 @@ function mapWorkspaceEnvironmentVariableMetadata(row) {
     updatedAt: row.updatedAt.toISOString()
   };
 }
+function mapSessionMcpServerMetadata(row) {
+  return {
+    id: row.serverId,
+    name: row.name ?? null,
+    url: row.url,
+    headerNames: Object.keys(row.headersEncrypted ?? {}).sort(),
+    credentialVersion: Number(row.credentialVersion)
+  };
+}
+async function sessionMcpServerMetadataForSessions(db, workspaceId, sessionIds) {
+  const grouped = /* @__PURE__ */ new Map();
+  if (sessionIds.length === 0) {
+    return grouped;
+  }
+  const rows = await db.select().from(sessionMcpServers).where(and(
+    eq(sessionMcpServers.workspaceId, workspaceId),
+    inArray(sessionMcpServers.sessionId, sessionIds)
+  )).orderBy(asc(sessionMcpServers.createdAt), asc(sessionMcpServers.serverId));
+  for (const row of rows) {
+    const list = grouped.get(row.sessionId) ?? [];
+    list.push(mapSessionMcpServerMetadata(row));
+    grouped.set(row.sessionId, list);
+  }
+  return grouped;
+}
+async function insertSessionMcpServers(db, input) {
+  if (input.servers.length === 0) {
+    return [];
+  }
+  const rows = await db.insert(sessionMcpServers).values(input.servers.map((server) => ({
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    serverId: server.id,
+    name: server.name ?? null,
+    url: server.url,
+    allowedTools: server.allowedTools ?? null,
+    timeoutMs: server.timeoutMs ?? null,
+    cacheToolsList: server.cacheToolsList ?? false,
+    headersEncrypted: server.headersEncrypted ?? {}
+  }))).returning();
+  return rows.map(mapSessionMcpServerMetadata);
+}
+async function createSessionMcpServers(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await insertSessionMcpServers(scopedDb, input)
+  );
+}
+async function listSessionMcpServerMetadata(db, workspaceId, sessionId) {
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const grouped = await sessionMcpServerMetadataForSessions(scopedDb, workspaceId, [sessionId]);
+    return grouped.get(sessionId) ?? [];
+  });
+}
+async function updateSessionMcpServerCredentials(db, input) {
+  return await withWorkspaceRls(db, input.workspaceId, async (scopedDb) => await scopedDb.transaction(
+    async (tx) => await updateSessionMcpServerCredentialsInTransaction(tx, input)
+  ));
+}
+async function updateSessionMcpServerCredentialsInTransaction(tx, input) {
+  const servers = [];
+  const missingIds = [];
+  for (const update of input.updates) {
+    const [row] = await tx.update(sessionMcpServers).set({
+      headersEncrypted: update.headersEncrypted,
+      credentialVersion: sql`${sessionMcpServers.credentialVersion} + 1`,
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(and(
+      eq(sessionMcpServers.workspaceId, input.workspaceId),
+      eq(sessionMcpServers.sessionId, input.sessionId),
+      eq(sessionMcpServers.serverId, update.id)
+    )).returning();
+    if (!row) {
+      missingIds.push(update.id);
+    } else {
+      servers.push(mapSessionMcpServerMetadata(row));
+    }
+  }
+  return { servers, missingIds };
+}
+async function listSessionMcpServersForRun(db, workspaceId, sessionId, encryptionKey) {
+  return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
+    const rows = await scopedDb.select().from(sessionMcpServers).where(and(
+      eq(sessionMcpServers.workspaceId, workspaceId),
+      eq(sessionMcpServers.sessionId, sessionId)
+    )).orderBy(asc(sessionMcpServers.createdAt), asc(sessionMcpServers.serverId));
+    return rows.map((row) => {
+      let headers;
+      try {
+        headers = Object.fromEntries(Object.entries(row.headersEncrypted ?? {}).map(([name, stored]) => [name, decryptEnvironmentValue(encryptionKey, stored)]));
+      } catch {
+        throw new Error("session MCP server credential decryption failed");
+      }
+      return {
+        ...mapSessionMcpServerMetadata(row),
+        ...row.allowedTools ? { allowedTools: row.allowedTools } : {},
+        ...row.timeoutMs ? { timeoutMs: row.timeoutMs } : {},
+        ...row.cacheToolsList ? { cacheToolsList: row.cacheToolsList } : {},
+        headers
+      };
+    });
+  });
+}
 async function createSession(db, input) {
   const id = crypto.randomUUID();
   return await withRlsContext(db, { accountId: input.accountId, workspaceId: input.workspaceId }, async (scopedDb) => {
@@ -2117,7 +2276,13 @@ async function createSession(db, input) {
     if (!row) {
       throw new Error("Failed to create session");
     }
-    return mapSession(row);
+    const mcpServers = await insertSessionMcpServers(scopedDb, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: row.id,
+      servers: input.mcpServers ?? []
+    });
+    return mapSession(row, mcpServers);
   });
 }
 async function createSessionWithIdempotencyKey(db, input) {
@@ -2145,7 +2310,13 @@ async function createSessionWithIdempotencyKey(db, input) {
       where: sql`${sessions.createIdempotencyKey} is not null`
     }).returning();
     if (inserted) {
-      return { session: mapSession(inserted), created: true };
+      const mcpServers = await insertSessionMcpServers(scopedDb, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: inserted.id,
+        servers: input.mcpServers ?? []
+      });
+      return { session: mapSession(inserted, mcpServers), created: true };
     }
     const [existing] = await scopedDb.select().from(sessions).where(and(
       eq(sessions.workspaceId, input.workspaceId),
@@ -2154,7 +2325,8 @@ async function createSessionWithIdempotencyKey(db, input) {
     if (!existing) {
       throw new Error("Failed to create session under idempotency key");
     }
-    return { session: mapSession(existing), created: false };
+    const grouped = await sessionMcpServerMetadataForSessions(scopedDb, input.workspaceId, [existing.id]);
+    return { session: mapSession(existing, grouped.get(existing.id) ?? []), created: false };
   });
 }
 async function getSessionByCreateIdempotencyKey(db, workspaceId, createIdempotencyKey) {
@@ -2163,13 +2335,17 @@ async function getSessionByCreateIdempotencyKey(db, workspaceId, createIdempoten
       eq(sessions.workspaceId, workspaceId),
       eq(sessions.createIdempotencyKey, createIdempotencyKey)
     )).limit(1);
-    return row ? mapSession(row) : null;
+    if (!row) return null;
+    const grouped = await sessionMcpServerMetadataForSessions(scopedDb, workspaceId, [row.id]);
+    return mapSession(row, grouped.get(row.id) ?? []);
   });
 }
 async function getSession(db, workspaceId, sessionId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const [row] = await scopedDb.select().from(sessions).where(and(eq(sessions.workspaceId, workspaceId), eq(sessions.id, sessionId))).limit(1);
-    return row ? mapSession(row) : null;
+    if (!row) return null;
+    const grouped = await sessionMcpServerMetadataForSessions(scopedDb, workspaceId, [row.id]);
+    return mapSession(row, grouped.get(row.id) ?? []);
   });
 }
 async function getAnySessionInGroup(db, workspaceId, sandboxGroupId) {
@@ -2187,7 +2363,8 @@ async function listDistinctEnvironmentIdsInGroup(db, workspaceId, sandboxGroupId
 async function listSessions(db, workspaceId, limit = 50) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const rows = await scopedDb.select().from(sessions).where(eq(sessions.workspaceId, workspaceId)).orderBy(desc(sessions.createdAt), desc(sessions.id)).limit(limit);
-    return rows.map(mapSession);
+    const grouped = await sessionMcpServerMetadataForSessions(scopedDb, workspaceId, rows.map((row) => row.id));
+    return rows.map((row) => mapSession(row, grouped.get(row.id) ?? []));
   });
 }
 async function countActiveSessionsForWorkspace(db, workspaceId) {
@@ -2208,12 +2385,38 @@ async function requireSession(db, workspaceId, sessionId) {
   }
   return session;
 }
-async function listSessionEvents(db, workspaceId, sessionId, after = 0, limit = 500) {
+var POSTGRES_INT_MAX = 2147483647;
+async function listSessionEvents(db, workspaceId, sessionId, afterOrOptions = 0, legacyLimit = 500) {
+  const options = typeof afterOrOptions === "number" ? { after: afterOrOptions, limit: legacyLimit } : afterOrOptions;
+  const after = normalizeEventSequence(options.after, 0);
+  const limit = normalizeEventLimit(options.limit, 500);
+  const hasBefore = options.before !== void 0 && Number.isFinite(options.before);
+  const before = hasBefore ? Math.floor(options.before) : void 0;
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
-    const rows = await scopedDb.select().from(sessionEvents).where(and(eq(sessionEvents.workspaceId, workspaceId), eq(sessionEvents.sessionId, sessionId), gt(sessionEvents.sequence, after))).orderBy(asc(sessionEvents.sequence)).limit(limit);
-    return rows.map(mapEvent);
+    const filters = [
+      eq(sessionEvents.workspaceId, workspaceId),
+      eq(sessionEvents.sessionId, sessionId),
+      gt(sessionEvents.sequence, after)
+    ];
+    if (before !== void 0 && before <= POSTGRES_INT_MAX) {
+      filters.push(lt(sessionEvents.sequence, before));
+    }
+    const rows = await scopedDb.select().from(sessionEvents).where(and(...filters)).orderBy(hasBefore ? desc(sessionEvents.sequence) : asc(sessionEvents.sequence)).limit(limit);
+    return (hasBefore ? rows.reverse() : rows).map(mapEvent);
   });
 }
+function normalizeEventSequence(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+function normalizeEventLimit(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(0, Math.floor(value));
+}
 async function getSessionEvent(db, workspaceId, eventId) {
   return await withWorkspaceRls(db, workspaceId, async (scopedDb) => {
     const [row] = await scopedDb.select().from(sessionEvents).where(and(eq(sessionEvents.workspaceId, workspaceId), eq(sessionEvents.id, eventId))).limit(1);
@@ -2348,6 +2551,20 @@ async function applyContextCompaction(db, input) {
         eq(sessionHistoryItems.active, true),
         lt(sessionHistoryItems.position, input.boundaryPosition)
       ));
+      if (input.replacementItems && input.replacementItems.length > 0) {
+        await tx.insert(sessionHistoryItems).values(input.replacementItems.map((entry) => ({
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          turnId: null,
+          position: entry.position,
+          item: sanitizeEventPayload(entry.item),
+          active: true
+        }))).onConflictDoUpdate({
+          target: [sessionHistoryItems.workspaceId, sessionHistoryItems.sessionId, sessionHistoryItems.position],
+          set: { active: true }
+        });
+      }
       await tx.insert(sessionHistoryItems).values({
         accountId: input.accountId,
         workspaceId: input.workspaceId,
@@ -4482,7 +4699,9 @@ async function appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessi
     if (!sessionRow) {
       throw new Error(`Session not found: ${sessionId}`);
     }
-    const built = build(mapSession(sessionRow));
+    const built = await build(mapSession(sessionRow), {
+      updateSessionMcpServerCredentials: async (updates) => await updateSessionMcpServerCredentialsInTransaction(tx, { workspaceId, sessionId, updates })
+    });
     if (built.events.length === 0) {
       return [];
     }
@@ -4519,7 +4738,7 @@ async function appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessi
 function sessionSubject(workspaceId, sessionId) {
   return `workspaces.${workspaceId}.sessions.${sessionId}.events`;
 }
-function mapSession(row) {
+function mapSession(row, mcpServers = []) {
   return {
     id: row.id,
     accountId: row.accountId,
@@ -4542,6 +4761,7 @@ function mapSession(row) {
     activeEpoch: Number(row.activeEpoch),
     environmentId: row.environmentId,
     firstPartyMcpPermissions: row.firstPartyMcpPermissions ?? null,
+    mcpServers,
     parentSessionId: row.parentSessionId ?? null,
     createIdempotencyKey: row.createIdempotencyKey ?? null,
     temporalWorkflowId: row.temporalWorkflowId,
@@ -4962,6 +5182,7 @@ export {
   createScheduledTaskRun,
   createSession,
   createSessionGoal,
+  createSessionMcpServers,
   createSessionWithIdempotencyKey,
   createSocialConnection,
   createSocialPost,
@@ -5062,6 +5283,8 @@ export {
   listScheduledTasks,
   listSessionEvents,
   listSessionIdsInGroup,
+  listSessionMcpServerMetadata,
+  listSessionMcpServersForRun,
   listSessionTurns,
   listSessions,
   listSocialConnections,
@@ -5145,6 +5368,7 @@ export {
   updateScheduledTask,
   updateScheduledTaskRun,
   updateSessionGoal,
+  updateSessionMcpServerCredentials,
   updateSessionTitle,
   updateWorkspace,
   updateWorkspaceEnvironment,