@opengeni/core 3.0.1 → 3.1.2

package/src/domain/connection-authority.ts

@@ -1,329 +0,0 @@
-import type {
-  ConnectionKind,
-  ConnectionStatus,
-  SessionTenancyVisibility,
-  UserResourceDelegation,
-  UserResourceGrantMode,
-  UserResourceGrantStatus,
-} from "@opengeni/contracts";
-import {
-  ConnectionAuthorityEnvelope,
-  ConnectionUseAttribution,
-  ConnectionUseAuthoritySnapshot,
-  type ConnectionUseAuthorizationResult,
-  type ConnectionAuthoritySelectionSource,
-  type ConnectionUseDenialReason,
-  type ConnectionUseSelectionSource,
-} from "@opengeni/contracts/connection-authority";
-
-export type ConnectionAuthorityCandidate = {
-  id: string;
-  organizationId: string;
-  workspaceId: string;
-  generation: number;
-  status: ConnectionStatus;
-  providerDomain: string;
-  kind: ConnectionKind;
-  subjectId: string | null;
-  ownerOrganizationMembershipId: string | null;
-};
-
-export type UserConnectionAuthorityCandidate = {
-  id: string;
-  organizationId: string;
-  resourceKind: "connection";
-  resourceId: string;
-  originWorkspaceId: string;
-  ownerSubjectId: string;
-  ownerOrganizationMembershipId: string;
-  ownerMembershipAuthorizationRevision: number;
-  generation: number;
-  status: "active" | "retained" | "revoked";
-};
-
-export class ConnectionAuthorityInvariantError extends Error {
-  constructor(readonly code: string) {
-    super(`connection authority invariant failed: ${code}`);
-    this.name = "ConnectionAuthorityInvariantError";
-  }
-}
-
-export function captureConnectionUseAuthority(input: {
-  organizationId: string;
-  targetWorkspaceId: string;
-  targetSessionId: string;
-  targetSessionVisibility: SessionTenancyVisibility;
-  targetSessionAuthorityEpoch: number;
-  acceptedWork:
-    | { kind: "turn"; turnId: string }
-    | {
-        kind: "scheduled_task";
-        taskId: string;
-        taskAuthorityRevision: number;
-        runId: string;
-      };
-  connection: ConnectionAuthorityCandidate;
-  authority?: unknown;
-  authorityWasOmitted?: boolean;
-  userAuthority?: UserConnectionAuthorityCandidate | null;
-  selectionSources: ConnectionUseSelectionSource[];
-}): ConnectionUseAuthoritySnapshot {
-  const authority = ConnectionAuthorityEnvelope.parse(input.authority ?? {});
-  const connection = input.connection;
-  if (connection.organizationId !== input.organizationId) {
-    throw new ConnectionAuthorityInvariantError("tenant_mismatch");
-  }
-  if (connection.status !== "active") {
-    throw new ConnectionAuthorityInvariantError("connection_status_inactive");
-  }
-
-  let authoritySource: ConnectionAuthoritySelectionSource;
-  let userDelegation: UserResourceDelegation | null = null;
-  if (authority.scope === "workspace") {
-    if (connection.subjectId !== null || connection.ownerOrganizationMembershipId !== null) {
-      throw new ConnectionAuthorityInvariantError("workspace_borrowed_personal_connection");
-    }
-    if (connection.workspaceId !== input.targetWorkspaceId) {
-      throw new ConnectionAuthorityInvariantError("workspace_connection_scope_mismatch");
-    }
-    authoritySource = input.authorityWasOmitted
-      ? "legacy_workspace_omission"
-      : "explicit_workspace";
-  } else {
-    const delegation = authority.userDelegation;
-    const resourceAuthority = input.userAuthority;
-    if (!delegation || !resourceAuthority) {
-      throw new ConnectionAuthorityInvariantError("user_authority_missing");
-    }
-    if (!connection.subjectId || !connection.ownerOrganizationMembershipId) {
-      throw new ConnectionAuthorityInvariantError("personal_owner_missing");
-    }
-    if (
-      resourceAuthority.id !== delegation.authorityId ||
-      resourceAuthority.organizationId !== input.organizationId ||
-      resourceAuthority.resourceKind !== "connection" ||
-      resourceAuthority.resourceId !== connection.id ||
-      resourceAuthority.originWorkspaceId !== connection.workspaceId ||
-      resourceAuthority.ownerSubjectId !== connection.subjectId ||
-      resourceAuthority.ownerOrganizationMembershipId !==
-        connection.ownerOrganizationMembershipId ||
-      resourceAuthority.generation !== delegation.authorityGeneration ||
-      resourceAuthority.status !== "active"
-    ) {
-      throw new ConnectionAuthorityInvariantError("user_authority_mismatch");
-    }
-    userDelegation = delegation;
-    authoritySource = "user_delegation";
-  }
-
-  return ConnectionUseAuthoritySnapshot.parse({
-    organizationId: input.organizationId,
-    originWorkspaceId: connection.workspaceId,
-    targetWorkspaceId: input.targetWorkspaceId,
-    targetSessionId: input.targetSessionId,
-    targetSessionVisibility: input.targetSessionVisibility,
-    targetSessionAuthorityEpoch: input.targetSessionAuthorityEpoch,
-    acceptedWork: input.acceptedWork,
-    connectionId: connection.id,
-    connectionGeneration: connection.generation,
-    connectionStatus: "active",
-    providerDomain: connection.providerDomain.toLowerCase(),
-    connectionKind: connection.kind,
-    scope: authority.scope,
-    ownerSubjectId: connection.subjectId,
-    ownerOrganizationMembershipId: connection.ownerOrganizationMembershipId,
-    ownerMembershipAuthorizationRevision:
-      authority.scope === "user" ? input.userAuthority!.ownerMembershipAuthorizationRevision : null,
-    authoritySource,
-    selectionSources: input.selectionSources,
-    userDelegation,
-  });
-}
-
-export type LiveConnectionUseState = {
-  organizationId: string;
-  targetWorkspaceId: string;
-  targetWorkspaceAccessActive: boolean;
-  session: {
-    id: string;
-    organizationId: string;
-    workspaceId: string;
-    visibility: SessionTenancyVisibility;
-    authorityEpoch: number;
-    active: boolean;
-  };
-  connection: ConnectionAuthorityCandidate | null;
-  ownerMembership: {
-    id: string;
-    organizationId: string;
-    subjectId: string;
-    status: "provisioning" | "active" | "suspended" | "revoked";
-    authorizationRevision: number;
-  } | null;
-  userAuthority: UserConnectionAuthorityCandidate | null;
-  grant: {
-    id: string;
-    authorityId: string;
-    organizationId: string;
-    workspaceId: string;
-    sessionId: string | null;
-    action: string;
-    mode: UserResourceGrantMode;
-    context: SessionTenancyVisibility;
-    authorityEpoch: number | null;
-    generation: number;
-    status: UserResourceGrantStatus;
-    expiresAt: string | null;
-    consumed: boolean;
-  } | null;
-};
-
-function denied(reason: ConnectionUseDenialReason): ConnectionUseAuthorizationResult {
-  return { status: "denied", reason };
-}
-
-/**
- * Revalidates every mutable fence immediately before provider use. Callers must
- * resolve the live state in one DB authority boundary; this pure function does
- * not cache, refresh, decrypt, or invoke a provider.
- */
-export function revalidateConnectionUseAuthority(input: {
-  snapshot: ConnectionUseAuthoritySnapshot;
-  live: LiveConnectionUseState;
-  now?: Date;
-}): ConnectionUseAuthorizationResult {
-  const snapshot = ConnectionUseAuthoritySnapshot.parse(input.snapshot);
-  const live = input.live;
-  const now = input.now ?? new Date();
-  if (
-    live.organizationId !== snapshot.organizationId ||
-    live.targetWorkspaceId !== snapshot.targetWorkspaceId
-  ) {
-    return denied("tenant_mismatch");
-  }
-  if (!live.targetWorkspaceAccessActive) return denied("workspace_access_inactive");
-  if (!live.session.active) return denied("session_inactive");
-  if (
-    live.session.id !== snapshot.targetSessionId ||
-    live.session.organizationId !== snapshot.organizationId ||
-    live.session.workspaceId !== snapshot.targetWorkspaceId
-  ) {
-    return denied("session_identity_changed");
-  }
-  if (live.session.visibility !== snapshot.targetSessionVisibility) {
-    return denied("session_visibility_changed");
-  }
-  if (live.session.authorityEpoch !== snapshot.targetSessionAuthorityEpoch) {
-    return denied("session_authority_epoch_changed");
-  }
-  const connection = live.connection;
-  if (!connection) return denied("connection_missing");
-  if (
-    connection.id !== snapshot.connectionId ||
-    connection.organizationId !== snapshot.organizationId ||
-    connection.workspaceId !== snapshot.originWorkspaceId ||
-    connection.providerDomain.toLowerCase() !== snapshot.providerDomain ||
-    connection.kind !== snapshot.connectionKind
-  ) {
-    return denied("connection_identity_changed");
-  }
-  if (connection.generation !== snapshot.connectionGeneration) {
-    return denied("connection_generation_changed");
-  }
-  if (connection.status !== "active") return denied("connection_status_inactive");
-  if (
-    connection.subjectId !== snapshot.ownerSubjectId ||
-    connection.ownerOrganizationMembershipId !== snapshot.ownerOrganizationMembershipId
-  ) {
-    return denied("connection_owner_changed");
-  }
-
-  if (snapshot.scope === "workspace") {
-    if (connection.subjectId !== null || connection.workspaceId !== snapshot.targetWorkspaceId) {
-      return denied("connection_owner_changed");
-    }
-    return {
-      status: "authorized",
-      attribution: ConnectionUseAttribution.parse({
-        organizationId: snapshot.organizationId,
-        workspaceId: snapshot.targetWorkspaceId,
-        sessionId: snapshot.targetSessionId,
-        connectionId: snapshot.connectionId,
-        connectionGeneration: snapshot.connectionGeneration,
-        scope: "workspace",
-        ownerSubjectId: null,
-        authorityId: null,
-        grantId: null,
-      }),
-    };
-  }
-
-  const delegation = snapshot.userDelegation!;
-  const membership = live.ownerMembership;
-  if (
-    !membership ||
-    membership.status !== "active" ||
-    membership.id !== snapshot.ownerOrganizationMembershipId ||
-    membership.organizationId !== snapshot.organizationId ||
-    membership.subjectId !== snapshot.ownerSubjectId ||
-    membership.authorizationRevision !== snapshot.ownerMembershipAuthorizationRevision
-  ) {
-    return denied("owner_membership_inactive");
-  }
-  const authority = live.userAuthority;
-  if (!authority) return denied("authority_missing");
-  if (
-    authority.id !== delegation.authorityId ||
-    authority.organizationId !== snapshot.organizationId ||
-    authority.resourceKind !== "connection" ||
-    authority.resourceId !== snapshot.connectionId ||
-    authority.originWorkspaceId !== snapshot.originWorkspaceId ||
-    authority.ownerSubjectId !== snapshot.ownerSubjectId ||
-    authority.ownerOrganizationMembershipId !== snapshot.ownerOrganizationMembershipId
-  ) {
-    return denied("authority_identity_changed");
-  }
-  if (authority.generation !== delegation.authorityGeneration) {
-    return denied("authority_generation_changed");
-  }
-  if (authority.status !== "active") return denied("authority_status_inactive");
-
-  const grant = live.grant;
-  if (!grant) return denied("grant_missing");
-  if (
-    grant.id !== delegation.grantId ||
-    grant.authorityId !== delegation.authorityId ||
-    grant.organizationId !== snapshot.organizationId ||
-    grant.workspaceId !== snapshot.targetWorkspaceId ||
-    grant.sessionId !== delegation.sessionId ||
-    grant.action !== "connection.use" ||
-    grant.mode !== delegation.mode ||
-    grant.context !== snapshot.targetSessionVisibility ||
-    grant.authorityEpoch !== delegation.authorityEpoch
-  ) {
-    return denied("grant_identity_changed");
-  }
-  if (grant.generation !== delegation.grantGeneration) {
-    return denied("grant_generation_changed");
-  }
-  if (grant.status !== "active") return denied("grant_status_inactive");
-  if (grant.expiresAt !== null && Date.parse(grant.expiresAt) <= now.getTime()) {
-    return denied("grant_expired");
-  }
-  if (grant.mode === "once" && grant.consumed) return denied("grant_already_consumed");
-
-  return {
-    status: "authorized",
-    attribution: ConnectionUseAttribution.parse({
-      organizationId: snapshot.organizationId,
-      workspaceId: snapshot.targetWorkspaceId,
-      sessionId: snapshot.targetSessionId,
-      connectionId: snapshot.connectionId,
-      connectionGeneration: snapshot.connectionGeneration,
-      scope: "user",
-      ownerSubjectId: snapshot.ownerSubjectId,
-      authorityId: delegation.authorityId,
-      grantId: delegation.grantId,
-    }),
-  };
-}

package/src/domain/environments.ts

@@ -1,120 +0,0 @@
-import { environmentsEncryptionKeyBytes, type Settings } from "@opengeni/config";
-import {
-  variableSetVariableNameReservation,
-  type AccessGrant,
-  type VariableSet,
-} from "@opengeni/contracts";
-import { getVariableSet, recordAuditEvent, type Database } from "@opengeni/db";
-import { HTTPException } from "hono/http-exception";
-import { requirePermission } from "../access";
-
-export const MAX_ENVIRONMENTS_PER_WORKSPACE = 25;
-export const MAX_VARIABLES_PER_ENVIRONMENT = 100;
-
-// Names the platform itself injects into sandboxes (sandboxEnvironmentForRun,
-// collectGitIdentityEnvironment) plus loader/startup-injection vectors. These
-// can never be set as variable set variables, so the run-scoped
-// git auth block and git identity always win without silent collisions.
-export function assertAllowedVariableSetVariableName(name: string): void {
-  if (variableSetVariableNameReservation(name)) {
-    throw new HTTPException(422, {
-      message: `reserved variable set variable name / reserved environment variable name: ${name}`,
-    });
-  }
-}
-
-/** @deprecated use assertAllowedVariableSetVariableName */
-export const assertAllowedEnvironmentVariableName = assertAllowedVariableSetVariableName;
-
-export function requireVariableSetEncryption(settings: Settings): Uint8Array {
-  const key = environmentsEncryptionKeyBytes(settings);
-  if (!key) {
-    throw new HTTPException(503, {
-      message: "variable sets require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY",
-    });
-  }
-  return key;
-}
-
-/** @deprecated use requireVariableSetEncryption */
-export const requireEnvironmentEncryption = requireVariableSetEncryption;
-
-export async function requireVariableSetForApi(
-  db: Database,
-  grant: AccessGrant,
-  variableSetId: string,
-): Promise<VariableSet> {
-  const variableSet = await getVariableSet(
-    db,
-    {
-      accountId: grant.accountId,
-      workspaceId: grant.workspaceId,
-      subjectId: grant.subjectId,
-    },
-    variableSetId,
-  );
-  if (!variableSet) {
-    throw new HTTPException(404, { message: "variableSet not found" });
-  }
-  return variableSet;
-}
-
-/**
- * Validates an variableSet attachment supplied in a request payload (session
- * create, scheduled task create/update, pack enable). Requires the
- * `variable-sets:use` permission unless the attachment was already authorized
- * (pack-installation-inherited attachments), and maps a missing or
- * cross-variable set to 422 because the id is payload, not the route
- * target. RLS plus the workspace_id clause make cross-workspace ids
- * indistinguishable from missing ones.
- */
-export async function validateVariableSetAttachment(
-  deps: { settings: Settings; db: Database },
-  grant: AccessGrant,
-  workspaceId: string,
-  variableSetId: string,
-  options: { preauthorized?: boolean } = {},
-): Promise<VariableSet> {
-  requireVariableSetEncryption(deps.settings);
-  if (!options.preauthorized) {
-    requirePermission(grant, "variable-sets:attach");
-    requirePermission(grant, "variable-sets:use");
-  }
-  const variableSet = await getVariableSet(
-    deps.db,
-    { accountId: grant.accountId, workspaceId, subjectId: grant.subjectId },
-    variableSetId,
-  );
-  if (!variableSet) {
-    throw new HTTPException(422, { message: "unknown variableSetId" });
-  }
-  return variableSet;
-}
-
-export async function recordVariableSetAuditEvent(
-  db: Database,
-  input: {
-    grant: AccessGrant;
-    action:
-      | "variable_set.created"
-      | "variable_set.updated"
-      | "variable_set.deleted"
-      | "variable_set.variable.set"
-      | "variable_set.variable.deleted";
-    variableSetId: string;
-    variableName?: string;
-  },
-): Promise<void> {
-  await recordAuditEvent(db, {
-    accountId: input.grant.accountId,
-    workspaceId: input.grant.workspaceId,
-    subjectId: input.grant.subjectId,
-    action: input.action,
-    targetType: "workspace_variable_set",
-    targetId: input.variableSetId,
-    metadata: {
-      variableSetId: input.variableSetId,
-      ...(input.variableName ? { name: input.variableName } : {}),
-    },
-  });
-}

package/src/domain/host-mcp-authority-source-admission.ts

@@ -1,25 +0,0 @@
-import type { Settings } from "@opengeni/config";
-import type { McpServerConnectionRef } from "@opengeni/contracts";
-import { HTTPException } from "hono/http-exception";
-
-/**
- * Explicit host-owned MCP refs change which credential authority executes an
- * opaque connection id. Admit new external refs only after the operator has
- * completed the two-phase fleet rollout. Readers and inheritance remain
- * tolerant regardless of this switch, and markerless legacy refs retain their
- * bounded non-UUID compatibility path.
- */
-export function assertHostMcpAuthoritySourceAdmissionEnabled(
-  settings: Pick<Settings, "hostMcpAuthoritySourceAdmissionEnabled">,
-  connectionRef: McpServerConnectionRef | null | undefined,
-): void {
-  if (
-    connectionRef?.authoritySource === "host" &&
-    !settings.hostMcpAuthoritySourceAdmissionEnabled
-  ) {
-    throw new HTTPException(422, {
-      message:
-        "new host-owned MCP connection refs are not admitted; upgrade the complete API/worker/web fleet, then set OPENGENI_HOST_MCP_AUTHORITY_SOURCE_ADMISSION_ENABLED=true",
-    });
-  }
-}

package/src/domain/host-mcp-task-admission.ts

@@ -1,121 +0,0 @@
-import { HTTPException } from "hono/http-exception";
-import type { Settings } from "@opengeni/config";
-import type { ToolRef, ScheduledTask, AccessGrant } from "@opengeni/contracts";
-import {
-  hostMcpBindingMatchesSelection,
-  HostMcpCreateSelections,
-} from "@opengeni/contracts/host-mcp-bindings";
-import {
-  captureHostMcpTaskAuthorities,
-  getHostMcpBinding,
-  getHostMcpDelegation,
-  HostMcpDelegationAuthorityError,
-  inheritHostMcpTaskAuthoritiesFromAttempt,
-  type Database,
-} from "@opengeni/db";
-import { hasPermission, type AccessGrantAuthorization } from "../access";
-import { prepareHostMcpOwnerAuthorization } from "../application/host-mcp-owner";
-import { assertHostMcpAuthoritySourceAdmissionEnabled } from "./host-mcp-authority-source-admission";
-
-/** Internal closure, not a caller-provided callback or durable key dependency. */
-export function prepareHostMcpTaskAdmission(input: {
-  settings: Settings;
-  tools: ToolRef[];
-  grant: AccessGrant;
-  authorization?: AccessGrantAuthorization;
-  selections: unknown;
-}): (tx: Database, task: ScheduledTask) => Promise<void> {
-  const selections = HostMcpCreateSelections.parse(input.selections);
-  if (
-    !input.authorization ||
-    input.authorization.grant.accountId !== input.grant.accountId ||
-    input.authorization.grant.subjectId !== input.grant.subjectId ||
-    input.authorization?.grant.workspaceId !== input.grant.workspaceId ||
-    input.grant.metadata?.["sessionId"] ||
-    !hasPermission(input.authorization?.grant.permissions ?? [], "connections:read") ||
-    !hasPermission(input.grant.permissions, "connections:read")
-  )
-    throw new HTTPException(403, {
-      message: "Host task selection requires a verified owner",
-    });
-  const reauthorize = prepareHostMcpOwnerAuthorization(
-    input.authorization,
-    input.grant.workspaceId,
-    "connections:read",
-  );
-  const prepared = selections.map((selection) => {
-    const server = input.settings.mcpServers.find(
-      (candidate) => candidate.id === selection.serverId,
-    );
-    if (
-      !server?.url ||
-      server.connectionRef?.authoritySource !== "host" ||
-      !server.connectionRef.hostBinding ||
-      !input.tools.some((tool) => tool.kind === "mcp" && tool.id === selection.serverId)
-    )
-      throw new HTTPException(422, {
-        message: "Host task selection must match a selected configured server",
-      });
-    assertHostMcpAuthoritySourceAdmissionEnabled(input.settings, server.connectionRef);
-    return {
-      delegationId: selection.delegationId,
-      generation: selection.generation,
-      configured: structuredClone({
-        serverId: selection.serverId,
-        destinationUrl: server.url,
-        connectionRef: server.connectionRef,
-      }),
-    };
-  });
-  return async (tx, task) => {
-    const owner = await reauthorize(tx);
-    try {
-      const selected = [];
-      for (const selection of prepared) {
-        const delegation = await getHostMcpDelegation(tx, owner, selection.delegationId);
-        const binding = delegation
-          ? await getHostMcpBinding(tx, owner, delegation.bindingId)
-          : null;
-        if (!binding || !hostMcpBindingMatchesSelection(binding, selection.configured))
-          throw new HostMcpDelegationAuthorityError("Host task selection changed");
-        selected.push({
-          delegationId: selection.delegationId,
-          generation: selection.generation,
-          bindingId: binding.id,
-          bindingGeneration: binding.generation,
-          definition: binding.definition,
-        });
-      }
-      if (selected.length) await captureHostMcpTaskAuthorities(tx, owner, task, selected);
-    } catch (error) {
-      if (error instanceof HostMcpDelegationAuthorityError)
-        throw new HTTPException(403, { message: error.message });
-      throw error;
-    }
-  };
-}
-
-export function prepareInheritedHostMcpTaskAdmission(
-  settings: Settings,
-  tools: ToolRef[],
-  source: { sessionId: string; turnId: string; attemptId: string; executionGeneration: number },
-): (tx: Database, task: ScheduledTask) => Promise<void> {
-  const configured = settings.mcpServers.flatMap((server) => {
-    if (
-      !tools.some((tool) => tool.kind === "mcp" && tool.id === server.id) ||
-      server.connectionRef?.authoritySource !== "host" ||
-      !server.connectionRef.hostBinding ||
-      !server.url
-    )
-      return [];
-    assertHostMcpAuthoritySourceAdmissionEnabled(settings, server.connectionRef);
-    return [
-      structuredClone({
-        serverId: server.id,
-        destinationUrl: server.url,
-        connectionRef: server.connectionRef,
-      }),
-    ];
-  });
-  return (tx, task) => inheritHostMcpTaskAuthoritiesFromAttempt(tx, task, source, configured);
-}