@opengeni/api-router 3.0.1 → 3.1.2

package/src/routes/automations.ts

@@ -1,4 +1,5 @@
 import { environmentsEncryptionKeyBytes } from "@opengeni/config";
+import { modelUnavailableHttpException } from "@opengeni/core";
 import {
   AUTOMATION_WEBHOOK_MAX_BYTES,
   AUTOMATION_MAX_MATCHED_TRIGGERS,
@@ -15,6 +16,7 @@ import {
   type BundledSkillId,
 } from "@opengeni/contracts";
 import {
+  AutomationCredentialRestrictionConflictError,
   AutomationDeliveryConflictError,
   AutomationRevisionConflictError,
   createAutomationRun,
@@ -35,24 +37,47 @@ import {
   updateAutomationTrigger,
   withWorkspaceGatewayCustomModelReadLock,
   withWorkspaceOpenRouterCustomModelReadLock,
+  withWorkspaceProviderCustomModelReadLock,
   type AutomationSourceSecret,
 } from "@opengeni/db";
 import {
   automationRequestDigest,
+  automationCredentialRestrictionForGrant,
+  assertNotSiteClampedAgent,
   assertWorkspaceModelPolicyAllows,
   buildAutomationAcceptedExecution,
   canonicalConfiguredModel,
   creationInitiatorForGrant,
+  currentSiteSessionOrigin,
   workspaceCustomModelReference,
   lockActiveCustomModelForAdmission,
   requireAccessGrant,
   requireAutomationAdapter,
   requirePermission,
+  requireAutomationCredentialRestrictionPermissions,
   resolveWorkspaceCatalogSettings,
   type ApiRouteDeps,
 } from "@opengeni/core";
-import type { Hono } from "hono";
+import type { Context, Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
+import { parseRequestJson } from "../http/request-body";
+
+/**
+ * Create, change, delete or fire an automation: a workspace admin, but never
+ * a Site page (a tool it called) or an agent started from one. Site pages and
+ * their agents act with the page's reach, so no automation starts from a Site.
+ */
+async function requireAutomationWriter(
+  c: Context,
+  deps: ApiRouteDeps,
+  workspaceId: string,
+): Promise<AccessGrant> {
+  const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
+  if (currentSiteSessionOrigin())
+    throw new HTTPException(403, { message: "A Site page cannot create or change automations" });
+  await assertNotSiteClampedAgent(deps.db, grant, "automations");
+  return grant;
+}
 
 async function callerBundleSelection(
   deps: ApiRouteDeps,
@@ -85,9 +110,10 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.post("/v1/workspaces/:workspaceId/automations/sources", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
+    const grant = await requireAutomationWriter(c, deps, workspaceId);
     requirePermission(grant, "secrets:write");
-    const request = CreateAutomationSourceRequest.parse(await c.req.json());
+    const request = await parseRequestJson(c, CreateAutomationSourceRequest);
+    assertGenericTriggerMutable(request);
     requireAutomationAdapter(request.adapterId).validateSourceConfiguration(request.configuration);
     const key = requireEncryptionKey(deps);
     const source = await createAutomationSource(deps.db, {
@@ -102,8 +128,8 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.patch("/v1/workspaces/:workspaceId/automations/sources/:sourceId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
-    const request = UpdateAutomationSourceRequest.parse(await c.req.json());
+    const grant = await requireAutomationWriter(c, deps, workspaceId);
+    const request = await parseRequestJson(c, UpdateAutomationSourceRequest);
     const current = await requireSource(
       deps,
       grant.accountId,
@@ -139,7 +165,7 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.delete("/v1/workspaces/:workspaceId/automations/sources/:sourceId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
+    const grant = await requireAutomationWriter(c, deps, workspaceId);
     const current = await requireSource(
       deps,
       grant.accountId,
@@ -169,18 +195,18 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.post("/v1/workspaces/:workspaceId/automations/triggers", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
-    const request = CreateAutomationTriggerRequest.parse(await c.req.json());
+    const grant = await requireAutomationWriter(c, deps, workspaceId);
+    const request = await parseRequestJson(c, CreateAutomationTriggerRequest);
+    const credentialRestriction = await automationCredentialRestrictionForGrant(deps.db, grant);
+    requireAutomationCredentialRestrictionPermissions(
+      credentialRestriction,
+      request.sessionTemplate.firstPartyMcpPermissions,
+    );
     request.sessionTemplate.bundledSkillIds = await callerBundleSelection(
       deps,
       grant,
       request.sessionTemplate.bundledSkillIds,
     );
-    if (request.packInstallationId || request.packTemplateId) {
-      throw new HTTPException(409, {
-        message: "Pack-owned automation triggers must be created through their Pack setup API",
-      });
-    }
     const source = await requireSource(deps, grant.accountId, workspaceId, request.sourceId);
     assertGenericSourceMutable(source);
     if (source.status !== "active") {
@@ -223,6 +249,7 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
         createdBySubjectId: grant.subjectId,
         request: normalizedRequest,
         adapterId: adapter.id,
+        ...(credentialRestriction ? { credentialRestriction } : {}),
         ...(beforeCreateCommit ? { beforeCreateCommit } : {}),
       }),
       201,
@@ -231,8 +258,8 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.patch("/v1/workspaces/:workspaceId/automations/triggers/:triggerId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
-    const request = UpdateAutomationTriggerRequest.parse(await c.req.json());
+    const grant = await requireAutomationWriter(c, deps, workspaceId);
+    const request = await parseRequestJson(c, UpdateAutomationTriggerRequest);
     const existing = (await listAutomationTriggers(deps.db, workspaceId)).find(
       (trigger) => trigger.id === c.req.param("triggerId"),
     );
@@ -241,6 +268,13 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
         message: "automation trigger not found",
       });
     assertGenericTriggerMutable(existing);
+    const credentialRestriction =
+      existing.sessionTemplate.credentialRestriction ??
+      (await automationCredentialRestrictionForGrant(deps.db, grant));
+    requireAutomationCredentialRestrictionPermissions(
+      credentialRestriction,
+      (request.sessionTemplate ?? existing.sessionTemplate).firstPartyMcpPermissions,
+    );
     if (request.configuration) {
       requireAutomationAdapter(existing.adapterId).validateTriggerConfiguration(
         request.configuration,
@@ -306,6 +340,7 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
         triggerId: c.req.param("triggerId"),
         subjectId: grant.subjectId,
         request: normalizedRequest,
+        ...(credentialRestriction ? { credentialRestriction } : {}),
         ...(beforeUpdateCommit ? { beforeUpdateCommit } : {}),
       });
       if (!trigger)
@@ -323,7 +358,7 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.delete("/v1/workspaces/:workspaceId/automations/triggers/:triggerId", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
+    const grant = await requireAutomationWriter(c, deps, workspaceId);
     const expectedRevision = Number(c.req.query("expectedRevision"));
     if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 1) {
       throw new HTTPException(400, {
@@ -366,8 +401,9 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
 
   app.post("/v1/workspaces/:workspaceId/automations/sources/:sourceId/events", async (c) => {
     const workspaceId = c.req.param("workspaceId");
-    const grant = await requireAccessGrant(c, deps, workspaceId, "workspace:admin");
-    const request = TriggerAutomationManuallyRequest.parse(await c.req.json());
+    const grant = await requireAutomationWriter(c, deps, workspaceId);
+    const request = await parseRequestJson(c, TriggerAutomationManuallyRequest);
+    const credentialRestriction = await automationCredentialRestrictionForGrant(deps.db, grant);
     const source = await requireSource(deps, grant.accountId, workspaceId, c.req.param("sourceId"));
     if (source.status !== "active") {
       throw new HTTPException(409, {
@@ -384,15 +420,26 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
       payload: request.payload,
     });
     const bytes = new TextEncoder().encode(stableJson(request));
-    return c.json(
-      await acceptAutomationEvent(deps, source, {
-        deliveryKey:
-          request.deliveryId ?? `manual:${automationRequestDigest(source.adapterId, bytes)}`,
-        requestDigest: automationRequestDigest(source.adapterId, bytes),
-        normalizedEvent,
-      }),
-      202,
-    );
+    try {
+      return c.json(
+        await acceptAutomationEvent(deps, source, {
+          deliveryKey:
+            request.deliveryId ?? `manual:${automationRequestDigest(source.adapterId, bytes)}`,
+          requestDigest: automationRequestDigest(source.adapterId, bytes),
+          normalizedEvent,
+          ...(credentialRestriction ? { credentialRestriction } : {}),
+        }),
+        202,
+      );
+    } catch (error) {
+      if (
+        error instanceof AutomationDeliveryConflictError ||
+        error instanceof AutomationCredentialRestrictionConflictError
+      ) {
+        throw new HTTPException(409, { message: error.message });
+      }
+      throw error;
+    }
   });
 
   app.post("/v1/webhooks/automations/:endpointId", async (c) => {
@@ -456,7 +503,10 @@ export function registerAutomationRoutes(app: Hono, deps: ApiRouteDeps): void {
       });
       return c.json(result, 202);
     } catch (error) {
-      if (error instanceof AutomationDeliveryConflictError) {
+      if (
+        error instanceof AutomationDeliveryConflictError ||
+        error instanceof AutomationCredentialRestrictionConflictError
+      ) {
         throw new HTTPException(409, { message: error.message });
       }
       throw error;
@@ -471,9 +521,13 @@ export async function acceptAutomationEvent(
     deliveryKey: string;
     requestDigest: string;
     normalizedEvent: AutomationNormalizedEvent;
+    /** Canonical manual caller restriction, not normalized event metadata. */
+    credentialRestriction?: "developer_setup";
   },
 ) {
-  if (input.normalizedEvent.adapterId !== source.adapterId) {
+  const { credentialRestriction: _untrustedRestriction, ...eventData } = input.normalizedEvent;
+  const normalizedEvent = AutomationNormalizedEvent.parse(eventData);
+  if (normalizedEvent.adapterId !== source.adapterId) {
     throw new HTTPException(422, {
       message: "automation event adapter does not match source",
     });
@@ -485,7 +539,7 @@ export async function acceptAutomationEvent(
     sourceId: source.id,
   });
   const matchingByEvent = triggers.filter((trigger) =>
-    adapter.matches({ event: input.normalizedEvent, trigger }),
+    adapter.matches({ event: normalizedEvent, trigger }),
   );
   if (matchingByEvent.length > AUTOMATION_MAX_MATCHED_TRIGGERS) {
     throw new HTTPException(422, {
@@ -503,7 +557,10 @@ export async function acceptAutomationEvent(
           matchedTriggerRevisions: [],
           deliveryKey: input.deliveryKey,
           requestDigest: input.requestDigest,
-          normalizedEvent: input.normalizedEvent,
+          normalizedEvent,
+          ...(input.credentialRestriction
+            ? { credentialRestriction: input.credentialRestriction }
+            : {}),
           ignoredReason: "no_matching_triggers",
         })
       : await withWorkspaceGatewayCustomModelReadLock(
@@ -513,55 +570,72 @@ export async function acceptAutomationEvent(
             await withWorkspaceOpenRouterCustomModelReadLock(
               gatewayLockedDb,
               { accountId: source.accountId, workspaceId: source.workspaceId },
-              async (lockedDb) => {
-                const catalogSourceSettings = deps.catalogSourceSettings ?? deps.settings;
-                const catalogSettings = (
-                  await resolveWorkspaceCatalogSettings(lockedDb, catalogSourceSettings, {
+              async (openRouterLockedDb) =>
+                await withWorkspaceProviderCustomModelReadLock(
+                  openRouterLockedDb,
+                  {
                     accountId: source.accountId,
                     workspaceId: source.workspaceId,
-                  })
-                ).settings;
-                const matchingAtAcceptance = [];
-                for (const trigger of matchingByEvent) {
-                  try {
-                    const render = adapter.render({
-                      event: input.normalizedEvent,
-                      trigger,
-                      source,
+                    providerKind: "opper",
+                  },
+                  async (lockedDb) => {
+                    const catalogSourceSettings = deps.catalogSourceSettings ?? deps.settings;
+                    const catalogSettings = (
+                      await resolveWorkspaceCatalogSettings(lockedDb, catalogSourceSettings, {
+                        accountId: source.accountId,
+                        workspaceId: source.workspaceId,
+                      })
+                    ).settings;
+                    const matchingAtAcceptance = [];
+                    for (const trigger of matchingByEvent) {
+                      try {
+                        const render = adapter.render({
+                          event: normalizedEvent,
+                          trigger,
+                          source,
+                        });
+                        requireAutomationCredentialRestrictionPermissions(
+                          trigger.sessionTemplate.credentialRestriction ??
+                            input.credentialRestriction,
+                          render.sessionTemplate.firstPartyMcpPermissions,
+                        );
+                        const requestedModel =
+                          render.sessionTemplate.model ?? catalogSettings.openaiModel;
+                        const model = canonicalConfiguredModel(catalogSettings, requestedModel);
+                        if (!model) continue;
+                        await assertWorkspaceModelPolicyAllows(
+                          lockedDb,
+                          catalogSettings,
+                          source.workspaceId,
+                          model,
+                        );
+                        matchingAtAcceptance.push(trigger);
+                      } catch (error) {
+                        if (isUnprocessableEntity(error)) continue;
+                        throw error;
+                      }
+                    }
+                    return await recordAutomationEvent(lockedDb, {
+                      accountId: source.accountId,
+                      workspaceId: source.workspaceId,
+                      sourceId: source.id,
+                      sourceVersion: source.version,
+                      sourceConfiguration: source.configuration,
+                      matchedTriggerRevisions: matchingAtAcceptance.map((trigger) => ({
+                        triggerId: trigger.id,
+                        revision: trigger.revision,
+                      })),
+                      deliveryKey: input.deliveryKey,
+                      requestDigest: input.requestDigest,
+                      normalizedEvent,
+                      ...(input.credentialRestriction
+                        ? { credentialRestriction: input.credentialRestriction }
+                        : {}),
+                      ignoredReason:
+                        matchingAtAcceptance.length === 0 ? "no_executable_triggers" : null,
                     });
-                    const requestedModel =
-                      render.sessionTemplate.model ?? catalogSettings.openaiModel;
-                    const model = canonicalConfiguredModel(catalogSettings, requestedModel);
-                    if (!model) continue;
-                    await assertWorkspaceModelPolicyAllows(
-                      lockedDb,
-                      catalogSettings,
-                      source.workspaceId,
-                      model,
-                    );
-                    matchingAtAcceptance.push(trigger);
-                  } catch (error) {
-                    if (isUnprocessableEntity(error)) continue;
-                    throw error;
-                  }
-                }
-                return await recordAutomationEvent(lockedDb, {
-                  accountId: source.accountId,
-                  workspaceId: source.workspaceId,
-                  sourceId: source.id,
-                  sourceVersion: source.version,
-                  sourceConfiguration: source.configuration,
-                  matchedTriggerRevisions: matchingAtAcceptance.map((trigger) => ({
-                    triggerId: trigger.id,
-                    revision: trigger.revision,
-                  })),
-                  deliveryKey: input.deliveryKey,
-                  requestDigest: input.requestDigest,
-                  normalizedEvent: input.normalizedEvent,
-                  ignoredReason:
-                    matchingAtAcceptance.length === 0 ? "no_executable_triggers" : null,
-                });
-              },
+                  },
+                ),
             ),
         );
   const matching = await getAutomationTriggerRevisions(deps.db, {
@@ -573,6 +647,7 @@ export async function acceptAutomationEvent(
     version: stored.event.sourceVersion,
     configuration: stored.event.sourceConfiguration,
   };
+  const { credentialRestriction, ...acceptedEvent } = stored.event.normalizedEvent;
   const runIds: string[] = [];
   const triggerAutomationRun = deps.workflowClient.triggerAutomationRun;
   if (matching.length > 0 && !triggerAutomationRun) {
@@ -582,7 +657,7 @@ export async function acceptAutomationEvent(
   }
   for (const trigger of matching) {
     const render = adapter.render({
-      event: stored.event.normalizedEvent,
+      event: acceptedEvent,
       trigger,
       source: acceptedSource,
     });
@@ -592,8 +667,9 @@ export async function acceptAutomationEvent(
       source: acceptedSource,
       trigger,
       eventId: stored.event.id,
-      event: stored.event.normalizedEvent,
+      event: acceptedEvent,
       render,
+      ...(credentialRestriction ? { credentialRestriction } : {}),
     });
     const { run } = await createAutomationRun(deps.db, {
       accountId: source.accountId,
@@ -642,11 +718,12 @@ function workspaceCustomModelCommitGuard(input: {
       accountId: input.accountId,
       workspaceId: input.workspaceId,
       reference,
+      // Automation configuration carries no accepted Claude authority, so an
+      // organization Claude model is refused here (unchanged behaviour).
+      claudeAuthority: null,
     });
     if (!active) {
-      throw new HTTPException(422, {
-        message: `model is not available: ${input.modelId}`,
-      });
+      throw modelUnavailableHttpException(input.modelId);
     }
   };
 }
@@ -667,17 +744,13 @@ async function requireSource(
 }
 
 function assertGenericSourceMutable(source: AutomationSourceSecret): void {
-  if (source.packInstallationId) {
-    throw new HTTPException(409, {
-      message: "Pack-owned automation sources must be managed through their Pack setup API",
-    });
-  }
+  assertGenericTriggerMutable(source);
 }
 
-function assertGenericTriggerMutable(trigger: { packInstallationId: string | null }): void {
-  if (trigger.packInstallationId) {
+function assertGenericTriggerMutable(trigger: { adapterId: string }): void {
+  if (trigger.adapterId === "source-control.pull-request.v1") {
     throw new HTTPException(409, {
-      message: "Pack-owned automation triggers must be managed through their Pack setup API",
+      message: "PR Review automations must be managed through the PR Review setup API",
     });
   }
 }