@nuxtagentic/automations 0.0.0-stage → 0.1.0

package/runtime/server/api/automations/[id]/endpoint.get.ts

@@ -0,0 +1,12 @@
+import { defineEventHandler, getRequestURL, getRouterParam } from 'h3'
+import { getAutomationContext } from '../../../utils/automation-context'
+export default defineEventHandler(async (event) => {
+  const context = await getAutomationContext(event)
+  const automation = await context.api.automation.get(Number(getRouterParam(event, 'id')))
+  if (automation.workspace !== context.workspace) {
+    throw new Error('Choose an automation in this workspace.')
+  }
+  return {
+    url: `${getRequestURL(event).origin}/api/automation-hooks/${context.ownerId}/${automation.id}/${automation.webhookToken}/${(automation.trigger as { slug: string }).slug}`,
+  }
+})

package/runtime/server/api/automations/[id]/run.post.ts

@@ -0,0 +1,30 @@
+import { readCommandBody } from '@nuxtagentic/integrations/runtime/server/utils/request-body'
+import { defineEventHandler, getRouterParam, setResponseStatus } from 'h3'
+import { assertGoogleMutation } from '@nuxtagentic/google/runtime/server/utils/google'
+import { toActionError } from '@nuxtagentic/integrations/runtime/server/utils/integration-context'
+import { getAutomationContext } from '../../../utils/automation-context'
+import { launchAutomation } from '../../../utils/automation-launch'
+export default defineEventHandler(async (event) => {
+  assertGoogleMutation(event)
+  try {
+    const context = await getAutomationContext(event)
+    const automation = await context.api.automation.get(Number(getRouterParam(event, 'id')))
+    const body = await readCommandBody<{ payload: unknown; errorPath?: boolean; eventId?: string }>(
+      event,
+      100000,
+    )
+    if (body.payload === undefined || JSON.stringify(body.payload).length > 100000) {
+      throw new Error('Provide a sample payload up to 100 KB.')
+    }
+    const result = await launchAutomation(
+      event,
+      context,
+      { automation, payload: body.payload, eventId: `test:${body.eventId || crypto.randomUUID()}` },
+      { test: true, forceError: !!body.errorPath },
+    )
+    setResponseStatus(event, 202)
+    return result
+  } catch (cause) {
+    throw toActionError(cause)
+  }
+})

package/runtime/server/api/automations/events.post.ts

@@ -0,0 +1,37 @@
+import { readCommandBody } from '@nuxtagentic/integrations/runtime/server/utils/request-body'
+import { defineEventHandler, setResponseStatus } from 'h3'
+import { assertGoogleMutation } from '@nuxtagentic/google/runtime/server/utils/google'
+import { toActionError } from '@nuxtagentic/integrations/runtime/server/utils/integration-context'
+import { getAutomationContext } from '../../utils/automation-context'
+import { emitAutomationEvent } from '../../utils/automation-launch'
+import { LOCAL_EVENTS } from '../../../shared/automation'
+import { INTEGRATION_CATALOG } from '@nuxtagentic/integrations/runtime/shared/catalog'
+export default defineEventHandler(async (event) => {
+  assertGoogleMutation(event)
+  try {
+    const context = await getAutomationContext(event)
+    const body = await readCommandBody<{ event: string; payload: unknown; id: string }>(
+      event,
+      100000,
+    )
+    if (
+      ![
+        ...LOCAL_EVENTS.map((entry) => entry.id),
+        ...INTEGRATION_CATALOG.flatMap((entry) => entry.triggers.map((trigger) => trigger.id)),
+      ].includes(body.event) ||
+      !body.id ||
+      body.id.length > 200 ||
+      JSON.stringify(body.payload ?? null).length > 100000
+    ) {
+      throw new Error('Provide a supported event, unique id and payload up to 100 KB.')
+    }
+    setResponseStatus(event, 202)
+    return await emitAutomationEvent(event, context, {
+      name: body.event,
+      payload: body.payload ?? {},
+      id: body.id,
+    })
+  } catch (cause) {
+    throw toActionError(cause)
+  }
+})

package/runtime/server/api/automations/runs/[id]/resume.post.ts

@@ -0,0 +1,23 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { assertGoogleMutation } from '@nuxtagentic/google/runtime/server/utils/google'
+import { getAutomationContext } from '../../../../utils/automation-context'
+import { executeAutomation } from '../../../../utils/automation-engine'
+
+export default defineEventHandler(async (event) => {
+  assertGoogleMutation(event)
+  const context = await getAutomationContext(event)
+  const run = await context.api.automationRun.get(Number(getRouterParam(event, 'id')))
+  if (run.workspace !== context.workspace || run.status !== 'waiting') {
+    throw new Error('This run is not waiting in this workspace.')
+  }
+  if (context.env?.AUTOMATION_RUNNER) {
+    throw new Error('Cloudflare resumes this run through its Workflow approval event.')
+  }
+  event.waitUntil(
+    executeAutomation(
+      { runId: run.id, ownerId: context.ownerId, workspace: context.workspace },
+      context,
+    ),
+  )
+  return { status: 'queued', runId: run.id }
+})

package/runtime/server/handlers/automation-hook.post.ts

@@ -0,0 +1,51 @@
+import {
+  createError,
+  defineEventHandler,
+  getHeader,
+  getRouterParam,
+  setHeader,
+  setResponseStatus,
+} from 'h3'
+import { tokenMatches } from '@nuxtagentic/integrations/runtime/server/utils/integration-crypto'
+import { toActionError } from '@nuxtagentic/integrations/runtime/server/utils/integration-context'
+import { getWebhookContext } from '../utils/automation-context'
+import { launchAutomation } from '../utils/automation-launch'
+import { readCommandBody } from '@nuxtagentic/integrations/runtime/server/utils/request-body'
+export default defineEventHandler(async (event) => {
+  setHeader(event, 'Cache-Control', 'no-store')
+  const ownerId = Number(getRouterParam(event, 'owner'))
+  const id = Number(getRouterParam(event, 'id'))
+  if (!Number.isSafeInteger(ownerId) || ownerId <= 0 || !Number.isSafeInteger(id) || id <= 0) {
+    throw createError({ statusCode: 404, statusMessage: 'Unknown webhook endpoint.' })
+  }
+  const context = await getWebhookContext(event, ownerId)
+  const automation = await context.api.automation.get(id).catch(() => null)
+  const trigger = automation?.trigger as { kind: string; slug: string } | undefined
+  if (
+    !automation ||
+    trigger?.kind !== 'webhook' ||
+    trigger.slug !== getRouterParam(event, 'slug') ||
+    !(await tokenMatches(getRouterParam(event, 'token') ?? '', automation.webhookToken))
+  ) {
+    throw createError({ statusCode: 404, statusMessage: 'Unknown webhook endpoint.' })
+  }
+  context.workspace = automation.workspace
+  try {
+    const payload = await readCommandBody<Record<string, unknown>>(event)
+    const eventId = getHeader(event, 'Idempotency-Key')
+    if (!eventId || eventId.length > 200) {
+      throw new Error(
+        'Send an Idempotency-Key header with a unique event ID (up to 200 characters).',
+      )
+    }
+    const result = await launchAutomation(event, context, {
+      automation,
+      payload,
+      eventId: `webhook:${eventId}`,
+    })
+    setResponseStatus(event, 202)
+    return result
+  } catch (cause) {
+    throw toActionError(cause)
+  }
+})

package/runtime/server/handlers/connect-hook.post.ts

@@ -0,0 +1,54 @@
+import { defineEventHandler, getRouterParam, setResponseStatus, toWebRequest } from 'h3'
+import { ConnectError } from '@cloudconfig/core/connect'
+import {
+  connectOf,
+  getDatabaseProvider,
+} from '@nuxtagentic/integrations/runtime/server/utils/integration-context'
+import { useRuntimeConfig } from '#imports'
+import { catalogTrigger, emitConnectionEvent } from '../utils/connection-events'
+
+/**
+ * App-level vendor webhooks (GitHub App, Slack, Shopify, …) at the URL
+ * `cloudconfig connect add` prints. Connect verifies the signature and finds
+ * the connections for the vendor account; this starts their automations.
+ */
+export default defineEventHandler(async (event) => {
+  const provider = getRouterParam(event, 'provider') ?? ''
+  const env = event.context.cloudflare?.env as Record<string, unknown> | undefined
+  const settings = useRuntimeConfig(event).cloudconfig as { d1Binding?: string; localDb?: string }
+  const database = await getDatabaseProvider(env, settings)
+  const connect = await connectOf({
+    database,
+    env,
+    request: new Request('https://events.internal'),
+  })
+  try {
+    const result = await connect.receiveWebhook(provider, toWebRequest(event))
+    if (result.response) {
+      return result.response
+    }
+    for (const delivery of result.deliveries) {
+      const name = catalogTrigger(provider, delivery.event, delivery.payload)
+      if (!name) {
+        continue
+      }
+      await emitConnectionEvent(event, connect, {
+        connection: delivery.connection,
+        context: { database, env },
+        delivery: {
+          name,
+          payload: delivery.payload,
+          id: delivery.deliveryId || crypto.randomUUID(),
+        },
+      })
+    }
+    setResponseStatus(event, 202)
+    return { received: result.deliveries.length }
+  } catch (cause) {
+    if (cause instanceof ConnectError) {
+      setResponseStatus(event, cause.status)
+      return { error: cause.message }
+    }
+    throw cause
+  }
+})

package/runtime/server/handlers/integration-hook.post.ts

@@ -0,0 +1,86 @@
+import {
+  createError,
+  defineEventHandler,
+  getHeader,
+  getRouterParam,
+  setHeader,
+  setResponseStatus,
+  toWebRequest,
+} from 'h3'
+import { ConnectError } from '@cloudconfig/core/connect'
+import {
+  connectOf,
+  getDatabaseProvider,
+  toActionError,
+} from '@nuxtagentic/integrations/runtime/server/utils/integration-context'
+import { getIntegrationDefinition } from '@nuxtagentic/integrations/runtime/shared/catalog'
+import { useRuntimeConfig } from '#imports'
+import { catalogTrigger, emitConnectionEvent } from '../utils/connection-events'
+
+/**
+ * Events for one connection, authenticated with that connection's own webhook
+ * secret: Connect's signature, a GitHub repository webhook signed with it, or
+ * the secret as a bearer token. The secret never appears in the URL.
+ */
+export default defineEventHandler(async (event) => {
+  setHeader(event, 'Cache-Control', 'no-store')
+  const uid = getRouterParam(event, 'uid') ?? ''
+  const env = event.context.cloudflare?.env as Record<string, unknown> | undefined
+  const settings = useRuntimeConfig(event).cloudconfig as { d1Binding?: string; localDb?: string }
+  const database = await getDatabaseProvider(env, settings)
+  const connect = await connectOf({
+    database,
+    env,
+    request: new Request('https://events.internal'),
+  })
+  let received
+  try {
+    received = await connect.receiveConnectionEvent(uid, toWebRequest(event))
+  } catch (cause) {
+    if (cause instanceof ConnectError) {
+      throw createError({
+        statusCode: cause.status === 401 ? 404 : cause.status,
+        statusMessage: 'Unknown event endpoint.',
+      })
+    }
+    throw cause
+  }
+  try {
+    const body = (received.payload ?? {}) as Record<string, unknown>
+    const githubEvent = getHeader(event, 'X-GitHub-Event')
+    const name = githubEvent
+      ? catalogTrigger(
+          'github',
+          body.action ? `${githubEvent}.${String(body.action)}` : githubEvent,
+          body,
+        )
+      : String(body.event ?? '')
+    // GitHub sends every subscribed event; ignore the ones no trigger listens for.
+    if (githubEvent && !name) {
+      return { runs: [] }
+    }
+    const provider = name.split('.')[0] ?? ''
+    if (!getIntegrationDefinition(provider)?.triggers.some((entry) => entry.id === name)) {
+      throw new Error('Choose an event supported by this integration.')
+    }
+    const delivery =
+      getHeader(event, 'X-GitHub-Delivery') ??
+      getHeader(event, 'Idempotency-Key') ??
+      String(body.id ?? '')
+    if (!delivery || delivery.length > 200) {
+      throw new Error('Send a unique event id or Idempotency-Key header, up to 200 characters.')
+    }
+    setResponseStatus(event, 202)
+    return await emitConnectionEvent(event, connect, {
+      connection: received.connection,
+      context: { database, env },
+      delivery: {
+        name,
+        payload: githubEvent ? body : (body.payload ?? {}),
+        id: delivery,
+      },
+    })
+  } catch (cause) {
+    throw toActionError(cause)
+  }
+})

package/runtime/server/plugins/events.ts

@@ -0,0 +1,79 @@
+import { defineNitroPlugin } from 'nitropack/runtime'
+import { getRequestURL, getResponseStatus, readBody } from 'h3'
+import { getAutomationContext } from '../utils/automation-context'
+import { emitAutomationEvent } from '../utils/automation-launch'
+import { readJson } from '@nuxtagentic/integrations/runtime/server/utils/integration-adapters'
+
+/** Successful API calls that raise a built-in automation event. */
+const automationEventRoutes = [
+  { method: 'POST', path: /\/auth\/manage\/users$/, event: 'user.created' },
+  { method: 'POST', path: /\/auth\/ban-user$/, event: 'user.deactivated' },
+  { method: 'POST', path: /\/(?:files|file-content)$/, event: 'file.uploaded' },
+  { method: 'PATCH', path: /\/kanbanCards\/\d+$/, event: 'task.moved' },
+]
+
+async function readResponseBody(body: unknown) {
+  if (!(body instanceof Response)) {
+    return body
+  }
+  return body.ok ? readJson(body.clone()) : null
+}
+
+function eventPayload(name: string, row: Record<string, unknown>) {
+  if (name.startsWith('user.')) {
+    return { user: row.user ?? row }
+  }
+  return {
+    record: { model: name === 'task.moved' ? 'kanbanCard' : 'file', id: row.id },
+    data: row,
+  }
+}
+
+export default defineNitroPlugin((nitro) => {
+  nitro.hooks.hook('beforeResponse', async (event, response) => {
+    const path = getRequestURL(event).pathname
+    const name = automationEventRoutes.find(
+      (route) => route.method === event.method && route.path.test(path),
+    )?.event
+    if (!name) {
+      return
+    }
+    const body = await readResponseBody(response.body)
+    if (!body || getResponseStatus(event) >= 400) {
+      return
+    }
+    const row = body as Record<string, unknown>
+    if (name === 'task.moved') {
+      const input = await readBody<Record<string, unknown>>(event)
+      if (!Object.hasOwn(input ?? {}, 'status')) {
+        return
+      }
+    }
+    event.context.automationEvent = {
+      name,
+      payload: eventPayload(name, row),
+      id: crypto.randomUUID(),
+    }
+  })
+  nitro.hooks.hook('afterResponse', (event) => {
+    const candidate = event.context.automationEvent as
+      { name: string; payload: unknown; id: string } | undefined
+    if (!candidate) {
+      return
+    }
+    event.waitUntil(
+      (async () => {
+        const context = await getAutomationContext(event)
+        await emitAutomationEvent(event, context, {
+          name: candidate.name,
+          payload: candidate.payload,
+          id: candidate.id,
+        })
+      })().catch(() => {
+        console.warn(
+          '[automations] Could not dispatch a workspace event. Check the automation configuration.',
+        )
+      }),
+    )
+  })
+})

package/runtime/server/plugins/maintenance.ts

@@ -0,0 +1,20 @@
+import { defineNitroPlugin, useRuntimeConfig } from 'nitropack/runtime'
+import { runAutomationMaintenance, type MaintenanceDatabase } from '../utils/maintenance'
+
+/** Runs on the Worker's cron trigger; see `triggers.crons` in wrangler.jsonc. */
+export default defineNitroPlugin((nitro) => {
+  nitro.hooks.hook('cloudflare:scheduled', async ({ env }) => {
+    const bindings = env as Record<string, unknown>
+    const settings = useRuntimeConfig().cloudconfig as { d1Binding?: string } | undefined
+    const database = bindings[settings?.d1Binding ?? 'DB'] as MaintenanceDatabase | undefined
+    if (!database) {
+      console.error('[automations] Maintenance needs the D1 binding; it was skipped.')
+      return
+    }
+    const retentionDays = Number(bindings.NUXT_AUTOMATIONS_RUN_RETENTION_DAYS ?? 0)
+    const report = await runAutomationMaintenance(bindings, database, { retentionDays })
+    if (Object.values(report).some(Boolean)) {
+      console.log('[automations] Maintenance', JSON.stringify(report))
+    }
+  })
+})

package/runtime/server/utils/agent-runner.ts

@@ -0,0 +1,15 @@
+import {
+  runSavedAgent as runApiAgent,
+  type AgentInvocation,
+} from '@cloudconfig/core/agents/runtime'
+import { createRetryingModelFetch } from '@nuxtagentic/agents/runtime/server/utils/model-fetch'
+export type { RunnableTool, AgentProviderKeys } from '@cloudconfig/core/agents/runtime'
+
+export async function runSavedAgent(options: AgentInvocation) {
+  if (import.meta.dev && options.agent.runtime && options.agent.runtime !== 'api') {
+    return (
+      await import('@nuxtagentic/agents/runtime/server/utils/run-local-agent')
+    ).runLocalAgent(options)
+  }
+  return runApiAgent({ ...options, fetch: createRetryingModelFetch(options.fetch) })
+}

package/runtime/server/utils/automation-context.ts

@@ -0,0 +1,77 @@
+import { useCloudConfigServer } from '#cloudconfig/server'
+import { useRuntimeConfig } from '#imports'
+import type { H3Event } from 'h3'
+import { createServerClient } from '@cloudconfig/core/server'
+import type { AgentsConfig } from '@cloudconfig/core/agents'
+import {
+  getAgentProviderKeys,
+  getAgentProviderKeysForEvent,
+} from '@nuxtagentic/agents/runtime/server/utils/agent-provider-keys'
+import {
+  backendConfig,
+  getDatabaseProvider,
+  getIntegrationContext,
+} from '@nuxtagentic/integrations/runtime/server/utils/integration-context'
+import type { IntegrationsConfig } from '@nuxtagentic/integrations/schema'
+import type { WorkspaceConfig } from '@nuxtagentic/workspace/schema'
+import type { AutomationsConfig } from '../../../schema'
+import type { AgentProviderKeys } from './agent-runner'
+
+export type AutomationBackend = {
+  models: AutomationsConfig['models'] &
+    IntegrationsConfig['models'] &
+    AgentsConfig['models'] &
+    WorkspaceConfig['models']
+}
+export interface AutomationJob {
+  ownerId: number
+  runId: number
+  workspace: string
+  forceError?: boolean
+}
+/** Who an automation acts as: its owner (their and the workspace's connections) or only the workspace. */
+export type AutomationRunAs = 'owner' | 'workspace'
+export function providerKeys(values: Record<string, unknown>): AgentProviderKeys {
+  return getAgentProviderKeys(values)
+}
+export async function getAutomationContext(event: H3Event) {
+  const context = await getIntegrationContext(event)
+  const api = await useCloudConfigServer<AutomationBackend>(event)
+  const keys = getAgentProviderKeysForEvent(event)
+  return { ...context, api, keys }
+}
+export async function createJobContext(
+  job: AutomationJob,
+  env: Record<string, unknown> | undefined,
+  options: {
+    keys?: AgentProviderKeys
+    localDb?: string
+    d1Binding?: string
+    runAs?: AutomationRunAs
+  } = {},
+) {
+  const database = await getDatabaseProvider(env, options)
+  const request = new Request('https://automation.internal')
+  const api = createServerClient(
+    backendConfig as AutomationBackend,
+    { request, env },
+    { db: database, getUser: () => ({ id: job.ownerId }) },
+  )
+  return {
+    api,
+    database,
+    request,
+    env,
+    ownerId: job.ownerId,
+    workspace: job.workspace,
+    ...(options.runAs ? { runAs: options.runAs } : {}),
+    keys: options.keys ?? providerKeys({ ...process.env, ...env }),
+  }
+}
+export async function getWebhookContext(event: H3Event, ownerId: number) {
+  const runtime = useRuntimeConfig(event)
+  const env = event.context.cloudflare?.env as Record<string, unknown> | undefined
+  const settings = runtime.cloudconfig as { d1Binding?: string; localDb?: string }
+  const keys = getAgentProviderKeysForEvent(event)
+  return createJobContext({ ownerId, workspace: '', runId: 0 }, env, { ...settings, keys })
+}