@opengeni/core 0.28.0 → 1.0.0

package/src/domain/session-connection-accounts.ts

@@ -0,0 +1,67 @@
+import type { AccessGrant } from "@opengeni/contracts";
+import type { Settings } from "@opengeni/config";
+import { requireSession, requireWorkspace, type Database } from "@opengeni/db";
+import { settingsWithEnabledCapabilityMcpServers } from "./capabilities";
+import {
+  freezeConnectionAccounts,
+  personalConnectionDelegationSourceForGrant,
+} from "./personal-connection-delegations";
+import {
+  sessionToolsForConnectionAccounts,
+  settingsWithSessionMcpServerMetadata,
+} from "./sessions";
+import { workspaceSessionToolPolicyDefaultServerIdsFor } from "./session-tool-policy";
+
+/** Freeze the authenticated request's eligible accounts before starting voice.
+ * The resulting lease snapshot, not a later participant or ambient connection,
+ * supplies authority to both live delegations and automatic transcript handoff. */
+export async function freezeSessionRealtimeConnectionAccounts(input: {
+  db: Database;
+  settings: Settings;
+  grant: AccessGrant;
+  workspaceId: string;
+  sessionId: string;
+}) {
+  const { db, settings, grant, workspaceId, sessionId } = input;
+  const session = await requireSession(db, workspaceId, sessionId);
+  const capabilitySettings = await settingsWithEnabledCapabilityMcpServers(
+    db,
+    workspaceId,
+    settings,
+    {
+      subjectId: grant.subjectId,
+    },
+  );
+  const runtimeSettings = settingsWithSessionMcpServerMetadata(
+    capabilitySettings,
+    session.mcpServers,
+  );
+  const tools = sessionToolsForConnectionAccounts({
+    session,
+    runtimeMcpServers: runtimeSettings.mcpServers,
+    defaultMcpServerIds: workspaceSessionToolPolicyDefaultServerIdsFor(
+      capabilitySettings.mcpServers,
+      (await requireWorkspace(db, workspaceId)).settings,
+    ),
+  });
+  return await freezeConnectionAccounts({
+    db,
+    settings: runtimeSettings,
+    accountId: grant.accountId,
+    workspaceId,
+    tools,
+    resources: session.resources,
+    source: personalConnectionDelegationSourceForGrant(grant),
+    targetSessionId: sessionId,
+    googleDrivePublicationEnabled:
+      session.firstPartyMcpTools.includes("editable_artifact_export") &&
+      session.firstPartyMcpTools.includes("editable_artifact_export_status") &&
+      (!session.firstPartyMcpPermissions?.length ||
+        (session.firstPartyMcpPermissions.includes("artifacts:read") &&
+          session.firstPartyMcpPermissions.includes("artifacts:publish"))),
+    atlassianEnabled:
+      session.firstPartyMcpTools.some((tool) => tool.startsWith("atlassian_")) &&
+      (!session.firstPartyMcpPermissions?.length ||
+        session.firstPartyMcpPermissions.includes("connections:read")),
+  });
+}

package/src/domain/session-file-access.ts

@@ -0,0 +1,47 @@
+import type { AccessGrant, FileAsset } from "@opengeni/contracts";
+import {
+  getSessionAuthorityProjection,
+  getFilesForSubject,
+  readSessionFileAttachments,
+  withSessionRlsActorContext,
+} from "@opengeni/db";
+import type { SessionAuthorizationDependencies } from "../session-authorization";
+import {
+  requireSessionAuthorization,
+  withResolvedSessionAuthorization,
+} from "../session-authorization";
+
+/** A session attachment grant is never a generic file/Knowledge grant. */
+export async function readSessionAttachmentFiles(
+  deps: SessionAuthorizationDependencies,
+  grant: AccessGrant,
+  sessionId: string,
+  fileIds: readonly string[],
+): Promise<FileAsset[]> {
+  const authority = await getSessionAuthorityProjection(deps.db, grant.workspaceId, sessionId);
+  if (!authority) return [];
+  const authorization = await requireSessionAuthorization(deps, grant, {
+    sessionId,
+    operation: "session.read",
+    surface: "core",
+  });
+  const ordinary = await getFilesForSubject(deps.db, {
+    accountId: grant.accountId,
+    workspaceId: grant.workspaceId,
+    subjectId: grant.subjectId,
+    fileIds,
+  });
+  const missing = fileIds.filter((id) => !ordinary.some((file) => file.id === id));
+  const actor = authorization?.actor ?? { kind: "subject" as const, subjectId: grant.subjectId };
+  const read = () =>
+    readSessionFileAttachments(deps.db, {
+      accountId: grant.accountId,
+      workspaceId: grant.workspaceId,
+      fileIds: missing,
+      access: { sessionId, authorityEpoch: authority.authorityEpoch, actor },
+    });
+  const shared = authorization
+    ? await withResolvedSessionAuthorization(authorization, read)
+    : await withSessionRlsActorContext({ subjectId: grant.subjectId }, read);
+  return [...ordinary, ...shared];
+}

package/src/domain/session-native-connection-replacement.ts

@@ -0,0 +1,64 @@
+import type { ConnectionMetadata, McpServerConnectionRef } from "@opengeni/contracts";
+import { connectionMetadataMatchesBinding } from "@opengeni/db/session-mcp-credential-rotation";
+
+/** Selection is restricted to the caller's already-authorized inventory. This
+ * projection grants no execution authority: subsequent admission and physical
+ * credential use still validate the exact native account normally. */
+export function nativeSessionConnectionReplacement(input: {
+  accountId: string;
+  workspaceId: string;
+  subjectId: string | null;
+  serverUrl: string;
+  replacementServerUrl?: string;
+  currentRef: McpServerConnectionRef | null;
+  nativeConnectionId: string;
+  connections: ConnectionMetadata[];
+}): McpServerConnectionRef {
+  const connection = input.connections.find(
+    (candidate) => candidate.id === input.nativeConnectionId,
+  );
+  if (
+    !connection ||
+    connection.accountId !== input.accountId ||
+    connection.status !== "active" ||
+    (connection.subjectId === null
+      ? connection.workspaceId !== input.workspaceId
+      : !input.subjectId || connection.subjectId !== input.subjectId || !connection.authorityId)
+  ) {
+    throw new Error("native connection unavailable");
+  }
+  const {
+    authoritySource: _authoritySource,
+    hostBinding: _hostBinding,
+    accountSelection: _accountSelection,
+    ...retained
+  } = input.currentRef ?? {};
+  // Preserve provider, resource, scope and selected-resource restrictions.
+  // Retired host identity is never interpreted as a native connection ID.
+  if (
+    input.currentRef &&
+    input.currentRef.providerDomain.toLowerCase() !== connection.providerDomain.toLowerCase()
+  )
+    throw new Error("native connection provider mismatch");
+  const ref: McpServerConnectionRef = {
+    ...retained,
+    ...(!input.currentRef?.resource && typeof connection.metadata.resource === "string"
+      ? { resource: connection.metadata.resource }
+      : {}),
+    connectionId: connection.id,
+    providerDomain: connection.providerDomain,
+    kind: connection.kind,
+    subjectScope: connection.subjectId === null ? "workspace" : "subject",
+  };
+  const destination = input.replacementServerUrl ?? input.serverUrl;
+  // A redirect must be explicitly requested and bound in the account metadata;
+  // the broker's legacy provider-host fallback is insufficient for rebinding.
+  if (
+    input.replacementServerUrl &&
+    (typeof connection.metadata.mcpUrl !== "string" || !connection.metadata.mcpUrl.trim())
+  )
+    throw new Error("native connection destination unavailable");
+  if (!connectionMetadataMatchesBinding(connection, ref, destination))
+    throw new Error("native connection binding mismatch");
+  return ref;
+}

package/src/domain/session-start-timing.ts

@@ -0,0 +1,55 @@
+import { withTraceContext, type Observability, type Span } from "@opengeni/observability";
+
+type SessionStartPhase =
+  | "workspace_read"
+  | "model_catalog_initial"
+  | "default_model"
+  | "model_catalog_effective"
+  | "capability_settings"
+  | "initiator_freeze"
+  | "allowance"
+  | "shell_insert"
+  | "initialize"
+  | "event_fanout"
+  | "workflow_wake"
+  | "session_reload";
+export type SessionStartObservability = Pick<Observability, "startSpan">;
+
+/** Content-free child spans around existing work; export is never joined and
+ * diagnostic failures cannot alter the lifecycle or its exact error. */
+export async function measureSessionStartPhase<T>(
+  observability: SessionStartObservability | null | undefined,
+  phase: SessionStartPhase,
+  work: () => Promise<T>,
+): Promise<T> {
+  let span: Span | undefined;
+  try {
+    span = observability?.startSpan(`core.session_start.${phase}`);
+  } catch {
+    // An unhealthy observer is not session authority.
+  }
+  const end = (outcome: "completed" | "failed") => {
+    try {
+      void Promise.resolve(span?.end({ attributes: { outcome } })).catch(() => undefined);
+    } catch {
+      // Never leak diagnostic errors or user content through an error field.
+    }
+  };
+  try {
+    const result = span ? withTraceContext(span, work) : work();
+    if (!span) return result;
+    return result.then(
+      (value) => {
+        end("completed");
+        return value;
+      },
+      (error) => {
+        end("failed");
+        throw error;
+      },
+    );
+  } catch (error) {
+    end("failed");
+    throw error;
+  }
+}