@opengeni/core 0.11.8 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "0.11.8",
+  "version": "0.12.0",
   "description": "OpenGeni framework-agnostic core: the domain, access, and billing layers (neutral access, off-HTTP V2 surface). Behavior-preserving extraction from apps/api — keeps Hono's HTTPException for error throwing (typed-errors cleanup deferred).",
   "license": "Apache-2.0",
   "repository": {
@@ -35,14 +35,14 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opengeni/codex": "^0.2.7",
-    "@opengeni/config": "^0.7.6",
-    "@opengeni/contracts": "^0.19.4",
-    "@opengeni/db": "^0.12.6",
-    "@opengeni/documents": "^0.2.36",
-    "@opengeni/events": "^0.3.27",
+    "@opengeni/config": "^0.7.7",
+    "@opengeni/contracts": "^0.20.0",
+    "@opengeni/db": "^0.13.0",
+    "@opengeni/documents": "^0.2.37",
+    "@opengeni/events": "^0.3.28",
     "@opengeni/observability": "^0.3.0",
-    "@opengeni/runtime": "^0.13.10",
-    "@opengeni/storage": "^0.2.30",
+    "@opengeni/runtime": "^0.13.11",
+    "@opengeni/storage": "^0.2.31",
     "hono": "^4.12.18"
   },
   "engines": {

package/src/dependencies.ts

@@ -106,6 +106,8 @@ export type AppDependencies = {
   managedAuth?: ManagedAuth | null;
   /** Injectable Codex HTTP transport for deterministic API/provider tests. */
   codexFetch?: typeof fetch;
+  /** Injectable Slack Web API transport for deterministic bot-connection tests. */
+  slackFetch?: typeof fetch;
   // The API process's OWN agent-loop-free sandbox client (constructed from
   // settings via @opengeni/runtime/sandbox). Undefined when sandboxBackend=none.
   // This is the foundation of the API-direct control plane: the API resumes

package/src/domain/scheduled-tasks.ts

@@ -6,6 +6,7 @@ import type {
   CreateScheduledTaskRequest as CreateScheduledTaskPayload,
   UpdateScheduledTaskRequest as UpdateScheduledTaskPayload,
 } from "@opengeni/contracts";
+import { OPENGENI_SLACK_BOT_SESSION_METADATA_KEY } from "@opengeni/contracts";
 import {
   createScheduledTask,
   deleteScheduledTask,
@@ -24,6 +25,10 @@ import type { ObjectStorageDependency } from "../dependencies";
 import { settingsWithEnabledCapabilityMcpServers } from "./capabilities";
 import { validateVariableSetAttachment } from "./environments";
 import { assertWorkspaceModelPolicyAllows, canonicalConfiguredModel } from "./sessions";
+import {
+  hasReservedOpenGeniSlackBotSessionMetadata,
+  validateOpenGeniSlackBotConnectionSelection,
+} from "./slack-bot";
 import {
   normalizeResources,
   validateFileResources,
@@ -197,7 +202,7 @@ export async function validatedScheduledTaskUpdate(input: {
     if (willHaveVariableSet) {
       requirePermission(input.grant, "variable-sets:use");
     }
-    update.agentConfig = await validateScheduledTaskAgentConfig({
+    const nextAgentConfig = await validateScheduledTaskAgentConfig({
       settings: input.settings,
       db: input.db,
       objectStorage: input.objectStorage,
@@ -206,6 +211,18 @@ export async function validatedScheduledTaskUpdate(input: {
       payload: { agentConfig: input.payload.agentConfig },
       ...(input.toolsProvided !== undefined ? { toolsProvided: input.toolsProvided } : {}),
     });
+    if (
+      input.existing.reusableSessionId &&
+      input.existing.runMode === "reusable_session" &&
+      (input.existing.agentConfig.slackBotConnectionId ?? null) !==
+        (nextAgentConfig.slackBotConnectionId ?? null)
+    ) {
+      throw new HTTPException(409, {
+        message:
+          "cannot change the OpenGeni Slack bot connection of a task with a live reusable session; recreate the task",
+      });
+    }
+    update.agentConfig = nextAgentConfig;
   }
   return update;
 }
@@ -355,11 +372,24 @@ async function validateScheduledTaskAgentConfig(input: {
   if (!prompt) {
     throw new HTTPException(422, { message: "scheduled task prompt is required" });
   }
+  if (hasReservedOpenGeniSlackBotSessionMetadata(input.payload.agentConfig.metadata)) {
+    throw new HTTPException(422, {
+      message: `${OPENGENI_SLACK_BOT_SESSION_METADATA_KEY} is reserved for scheduler routing`,
+    });
+  }
   await validateGitHubRepositorySelection(input.db, input.workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !input.objectStorage) {
     throw new HTTPException(503, { message: "object storage is not configured" });
   }
   await validateFileResources(input.db, input.workspaceId, resources);
+  if (input.payload.agentConfig.slackBotConnectionId) {
+    await validateOpenGeniSlackBotConnectionSelection(
+      input.db,
+      input.grant,
+      input.workspaceId,
+      input.payload.agentConfig.slackBotConnectionId,
+    );
+  }
   const requestedMaxDepth = input.payload.agentConfig.maxNestedAgentDepth;
   if (requestedMaxDepth !== undefined) {
     const workspace = await requireWorkspace(input.db, input.workspaceId);

package/src/domain/sessions.ts

@@ -9,6 +9,7 @@ import {
 import {
   CreateSessionRequest,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
+  OPENGENI_SLACK_BOT_SESSION_METADATA_KEY,
   SessionSpawnDenial,
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
@@ -92,6 +93,7 @@ import { requireSessionAuthorization } from "../session-authorization";
 import { swapActiveSandbox, type FleetContext } from "../sandbox/fleet";
 import { settingsWithEnabledCapabilityMcpServers } from "./capabilities";
 import { requireVariableSetEncryption, validateVariableSetAttachment } from "./environments";
+import { hasReservedOpenGeniSlackBotSessionMetadata } from "./slack-bot";
 import {
   assertToolRefsSubset,
   availableToolRefs,
@@ -1027,6 +1029,11 @@ export async function createSessionForRequest(
 ): Promise<Session> {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   const payload = CreateSessionRequest.parse(rawPayload);
+  if (hasReservedOpenGeniSlackBotSessionMetadata(payload.metadata)) {
+    throw new HTTPException(422, {
+      message: `${OPENGENI_SLACK_BOT_SESSION_METADATA_KEY} is reserved for scheduler routing`,
+    });
+  }
   // A committed keyed denial is the idempotent outcome even if mutable
   // resources, policy, authorization, or budget have changed since the first
   // attempt. Replay it before any of those checks, just as a keyed successful

package/src/domain/slack-bot.ts

@@ -0,0 +1,130 @@
+import {
+  OPENGENI_SLACK_BOT_CREDENTIAL_LABEL,
+  OPENGENI_SLACK_BOT_REQUIRED_SCOPES,
+  OPENGENI_SLACK_BOT_CREDENTIAL_ROLE,
+  OPENGENI_SLACK_BOT_SESSION_METADATA_KEY,
+  OpenGeniSlackBotConnectionMetadata,
+  type AccessGrant,
+  type ConnectionMetadata,
+  type OpenGeniSlackBotConnectionMetadata as OpenGeniSlackBotMetadata,
+  type Session,
+} from "@opengeni/contracts";
+import {
+  getConnectionMetadata,
+  type ConnectionMetadataWithVerification,
+  type Database,
+} from "@opengeni/db";
+import { HTTPException } from "hono/http-exception";
+import { requirePermission } from "../access";
+
+export function openGeniSlackBotMetadata(
+  metadata: Record<string, unknown>,
+): OpenGeniSlackBotMetadata | null {
+  const parsed = OpenGeniSlackBotConnectionMetadata.safeParse(metadata);
+  return parsed.success ? parsed.data : null;
+}
+
+export function isOpenGeniSlackBotConnection(
+  connection: ConnectionMetadata &
+    Partial<
+      Pick<ConnectionMetadataWithVerification, "verifiedInstallAt" | "verifiedInstallVersion">
+    >,
+): boolean {
+  const granted = new Set(connection.grantedScopes);
+  return (
+    connection.verifiedInstallAt != null &&
+    connection.verifiedInstallVersion === connection.version &&
+    connection.subjectId === null &&
+    connection.providerDomain === "slack.com" &&
+    connection.kind === "app_install" &&
+    granted.size === OPENGENI_SLACK_BOT_REQUIRED_SCOPES.length &&
+    OPENGENI_SLACK_BOT_REQUIRED_SCOPES.every((scope) => granted.has(scope)) &&
+    openGeniSlackBotMetadata(connection.metadata)?.credentialRole ===
+      OPENGENI_SLACK_BOT_CREDENTIAL_ROLE
+  );
+}
+
+export function hasReservedOpenGeniSlackBotMetadata(
+  metadata: Record<string, unknown> | null | undefined,
+): boolean {
+  return (
+    metadata?.credentialRole === OPENGENI_SLACK_BOT_CREDENTIAL_ROLE ||
+    metadata?.credentialLabel === OPENGENI_SLACK_BOT_CREDENTIAL_LABEL
+  );
+}
+
+export function hasReservedOpenGeniSlackBotSessionMetadata(
+  metadata: Record<string, unknown> | null | undefined,
+): boolean {
+  return Boolean(
+    metadata &&
+    Object.prototype.hasOwnProperty.call(metadata, OPENGENI_SLACK_BOT_SESSION_METADATA_KEY),
+  );
+}
+
+/**
+ * Internal, pre-authorized lookup used by the scheduler and Slack tool adapter.
+ * Public callers must perform their permission check before calling this helper.
+ */
+export async function requireOpenGeniSlackBotConnection(
+  db: Database,
+  workspaceId: string,
+  connectionId: string,
+): Promise<ConnectionMetadata> {
+  const connection = await getConnectionMetadata(db, workspaceId, connectionId, null);
+  if (!connection || !isOpenGeniSlackBotConnection(connection)) {
+    throw new HTTPException(422, {
+      message: "slackBotConnectionId must reference an OpenGeni Slack bot connection",
+    });
+  }
+  if (connection.status !== "active") {
+    throw new HTTPException(422, {
+      message: `OpenGeni Slack bot connection is not active (${connection.status})`,
+    });
+  }
+  return connection;
+}
+
+export async function validateOpenGeniSlackBotConnectionSelection(
+  db: Database,
+  grant: AccessGrant,
+  workspaceId: string,
+  connectionId: string,
+): Promise<ConnectionMetadata> {
+  requirePermission(grant, "connections:read");
+  return await requireOpenGeniSlackBotConnection(db, workspaceId, connectionId);
+}
+
+export function scheduledSlackBotConnectionId(
+  metadata: Record<string, unknown> | null | undefined,
+): string | null {
+  const value = metadata?.[OPENGENI_SLACK_BOT_SESSION_METADATA_KEY];
+  return typeof value === "string" && zUuid(value) ? value : null;
+}
+
+/**
+ * The scheduler writes the connection pointer together with immutable creator
+ * provenance. Requiring both prevents ordinary session metadata from becoming
+ * an authorization mechanism for a workspace-shared bot credential.
+ */
+export function isTrustedScheduledSlackBotSession(
+  session: Pick<Session, "createdBy" | "createdByContext" | "metadata">,
+): boolean {
+  const scheduledTaskId = session.metadata.scheduledTaskId;
+  const scheduledTaskRunId = session.metadata.scheduledTaskRunId;
+  return (
+    session.createdBy?.kind === "service" &&
+    session.createdBy.subjectId === "scheduler" &&
+    typeof scheduledTaskId === "string" &&
+    zUuid(scheduledTaskId) &&
+    typeof scheduledTaskRunId === "string" &&
+    zUuid(scheduledTaskRunId) &&
+    session.createdByContext.scheduledTaskId === scheduledTaskId &&
+    session.createdByContext.scheduledTaskRunId === scheduledTaskRunId &&
+    scheduledSlackBotConnectionId(session.metadata) !== null
+  );
+}
+
+function zUuid(value: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}

package/src/index.ts

@@ -60,6 +60,7 @@ export * from "./domain/resources";
 export * from "./domain/session-tool-policy";
 export * from "./domain/scheduled-tasks";
 export * from "./domain/sessions";
+export * from "./domain/slack-bot";
 export * from "./domain/workspace-members";
 export * from "./application/new-session-drafts";
 export * from "./application/session-commands";