@open-mercato/channel-discord 0.6.8-develop.7090.1.4dbca7b350

package/src/modules/channel_discord/api/channels/[id]/ai-auto-reply/route.ts

@@ -0,0 +1,299 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { AwilixContainer } from 'awilix'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import type { CommandBus } from '@open-mercato/shared/lib/commands'
+import { isCrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { validateRouteMutationGuard } from '@open-mercato/core/modules/communication_channels/lib/route-mutation-guard'
+import { CHANNEL_DISCORD_AUTO_REPLY_AGENT_ID } from '../../../../ai-agents'
+import {
+  CHANNEL_DISCORD_CHANNEL_RESOURCE_KIND,
+  CHANNEL_DISCORD_UPDATE_AI_AUTO_REPLY_COMMAND_ID,
+  discordAiAutoReplySettingsSchema,
+  type UpdateAiAutoReplyInput,
+  type UpdateAiAutoReplyResult,
+} from '../../../../commands/update-ai-auto-reply'
+import {
+  findDiscordEligibleAgent,
+  listDiscordEligibleAgents,
+  missingAgentFeatures,
+  type AgentInvokingPrincipal,
+} from '../../../../lib/ai-agent-directory'
+import { CHANNEL_DISCORD_CONFIGURE_FEATURE, CHANNEL_DISCORD_VIEW_FEATURE } from '../../../../lib/ai-features'
+import { resolveDiscordAiPrincipal } from '../../../../lib/ai-service-principal'
+import { loadDiscordChannelForRequest } from '../../../../lib/channel-access'
+import { discordChannelStateSchema } from '../../../../lib/credentials'
+
+export const metadata = {
+  GET: {
+    requireAuth: true,
+    requireFeatures: [CHANNEL_DISCORD_VIEW_FEATURE],
+  },
+  PUT: {
+    requireAuth: true,
+    requireFeatures: [CHANNEL_DISCORD_CONFIGURE_FEATURE],
+  },
+}
+
+type RouteContext = {
+  params: Promise<{ id: string }> | { id: string }
+}
+
+function fieldError(field: string, message: string, extra?: Record<string, unknown>): Response {
+  return NextResponse.json(
+    { error: message, fieldErrors: { [field]: message }, ...extra },
+    { status: 400 },
+  )
+}
+
+/**
+ * The identity the auto-reply subscriber will run the chosen agent under, so both
+ * methods can answer "would the runtime accept this?" with the same grants the
+ * subscriber will present — the tenant's channel-bot user when it exists, the
+ * provider service principal otherwise.
+ */
+async function loadInvokingPrincipal(
+  container: AwilixContainer,
+  scope: { tenantId: string; organizationId: string | null },
+): Promise<AgentInvokingPrincipal> {
+  const em = (container.resolve('em') as EntityManager).fork()
+  return resolveDiscordAiPrincipal({
+    em,
+    resolver: { resolve: <T,>(name: string): T => container.resolve(name) as T },
+    scope,
+  })
+}
+
+/**
+ * Read a Discord channel's AI auto-reply settings plus everything the settings
+ * form needs to render itself: the eligible agents, whether the optional AI peer
+ * is installed at all, and the channel's `updatedAt` so the form can attach the
+ * optimistic-lock header on save.
+ */
+export async function GET(req: Request, context: RouteContext): Promise<Response> {
+  const { id } = await context.params
+  if (!z.string().uuid().safeParse(id).success) {
+    return NextResponse.json({ error: 'Invalid channel id' }, { status: 400 })
+  }
+
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub || !auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const container = await createRequestContainer()
+  const access = await loadDiscordChannelForRequest({ container, req, auth, channelId: id, mode: 'read' })
+  if ('response' in access) return access.response
+  const { channel } = access
+
+  const state = discordChannelStateSchema.safeParse(channel.channelState ?? {})
+  const directory = await listDiscordEligibleAgents()
+
+  // Every offered agent carries whether the auto-reply principal could actually
+  // invoke it. Without this the picker offers agents from other modules that the
+  // runtime will refuse, and the refusal only ever happens later in a background
+  // subscriber — so the operator sees "Auto-reply on" and silence.
+  const principal = directory.available
+    ? await loadInvokingPrincipal(container, {
+      tenantId: auth.tenantId as string,
+      organizationId: access.rbacOrganizationId,
+    })
+    : null
+  const agents = directory.available && principal
+    ? directory.agents.map((agent) => {
+      const missingFeatures = missingAgentFeatures(agent.requiredFeatures, principal)
+      return { ...agent, invocable: missingFeatures.length === 0, missingFeatures }
+    })
+    : []
+
+  return NextResponse.json({
+    id: channel.id,
+    channelId: channel.id,
+    displayName: channel.displayName,
+    updatedAt: channel.updatedAt ? channel.updatedAt.toISOString() : null,
+    aiAutoReplyEnabled: state.success ? Boolean(state.data.aiAutoReplyEnabled) : false,
+    aiAgentId: (state.success ? state.data.aiAgentId : undefined) ?? null,
+    // Why the last attempt produced nothing, so an armed channel that answers
+    // nothing says so instead of looking healthy.
+    aiAutoReplyLastError: (state.success ? state.data.aiAutoReplyLastError : undefined) ?? null,
+    aiAutoReplyLastErrorAt: (state.success ? state.data.aiAutoReplyLastErrorAt : undefined) ?? null,
+    defaultAgentId: CHANNEL_DISCORD_AUTO_REPLY_AGENT_ID,
+    aiAvailable: directory.available,
+    agents,
+  })
+}
+
+/**
+ * Write a Discord channel's AI auto-reply settings — the configuration path the
+ * subscriber was missing (issue #4778).
+ *
+ * The route is deliberately strict about *enabling*: it refuses to arm a channel
+ * whose AI peer is absent, one pointed at an agent the runtime would reject on
+ * shape, and one pointed at an agent the auto-reply principal is not authorized
+ * to invoke. All three would store a setting that can only fail later, inside a
+ * background subscriber where nobody sees the error — which is precisely how the
+ * feature ended up dormant in the first place. The three checks mirror, in order,
+ * what `runAiAgentObject` → `checkAgentPolicy` will ask at run time.
+ */
+export async function PUT(req: Request, context: RouteContext): Promise<Response> {
+  const { id } = await context.params
+  if (!z.string().uuid().safeParse(id).success) {
+    return NextResponse.json({ error: 'Invalid channel id' }, { status: 400 })
+  }
+
+  const auth = await getAuthFromRequest(req)
+  if (!auth?.sub || !auth?.tenantId) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+  const organizationId = (auth as { orgId?: string | null }).orgId ?? null
+
+  const rawBody = await req.json().catch(() => null)
+  if (rawBody == null || typeof rawBody !== 'object') {
+    return NextResponse.json({ error: 'Request body must be a JSON object' }, { status: 400 })
+  }
+
+  const parsed = discordAiAutoReplySettingsSchema.safeParse(rawBody)
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0]
+    const field = issue?.path.join('.') || 'aiAutoReplyEnabled'
+    return fieldError(field, issue?.message ?? 'Invalid AI auto-reply settings')
+  }
+
+  const container = await createRequestContainer()
+  // Authorize before the guard so a caller who may not touch this channel gets a
+  // masked 404 rather than a guard verdict about a record they cannot see. It
+  // also comes before the arming checks below, which need the channel's resolved
+  // organization to build the principal they judge the agent against.
+  const access = await loadDiscordChannelForRequest({ container, req, auth, channelId: id, mode: 'manage' })
+  if ('response' in access) return access.response
+
+  if (parsed.data.aiAutoReplyEnabled) {
+    const agentId = parsed.data.aiAgentId as string
+    const agent = await findDiscordEligibleAgent(agentId)
+    if (!agent) {
+      // No eligible agent under this id: either the optional AI peer is absent, or
+      // the agent is not object-mode and `runAiAgentObject` would reject it.
+      const directory = await listDiscordEligibleAgents()
+      return directory.available
+        ? fieldError('aiAgentId', 'channel_discord.aiAutoReply.errors.agentNotEligible')
+        : fieldError('aiAutoReplyEnabled', 'channel_discord.aiAutoReply.errors.aiUnavailable')
+    }
+
+    // Shape is not authorization. `checkAgentPolicy` enforces the agent's
+    // `requiredFeatures` against the auto-reply principal at run time, so arming a
+    // channel against an agent that principal cannot invoke stores a setting that
+    // can only fail later — inside a background subscriber, where the operator
+    // never sees it. Refuse here, naming the grants the tenant's channel-bot user
+    // is missing, rather than accepting a channel that would answer nothing.
+    const principal = await loadInvokingPrincipal(container, {
+      tenantId: auth.tenantId as string,
+      organizationId: access.rbacOrganizationId,
+    })
+    const missingFeatures = missingAgentFeatures(agent.requiredFeatures, principal)
+    if (missingFeatures.length > 0) {
+      return fieldError(
+        'aiAgentId',
+        'channel_discord.aiAutoReply.errors.agentFeaturesMissing',
+        { missingFeatures },
+      )
+    }
+  }
+
+  const guard = await validateRouteMutationGuard({
+    container,
+    req,
+    auth,
+    input: {
+      resourceKind: CHANNEL_DISCORD_CHANNEL_RESOURCE_KIND,
+      resourceId: id,
+      operation: 'update',
+      mutationPayload: { ...parsed.data },
+    },
+  })
+  if ('response' in guard) return guard.response
+
+  const commandBus = container.resolve('commandBus') as CommandBus
+  const input: UpdateAiAutoReplyInput = {
+    channelId: id,
+    settings: parsed.data,
+    scope: {
+      tenantId: auth.tenantId as string,
+      organizationId: access.rbacOrganizationId,
+      organizationIds: access.organizationIds,
+    },
+  }
+
+  let result: UpdateAiAutoReplyResult
+  try {
+    const executed = await commandBus.execute<UpdateAiAutoReplyInput, UpdateAiAutoReplyResult>(
+      CHANNEL_DISCORD_UPDATE_AI_AUTO_REPLY_COMMAND_ID,
+      {
+        input,
+        ctx: {
+          container,
+          auth: auth as never,
+          organizationScope: null,
+          selectedOrganizationId: organizationId,
+          organizationIds: organizationId ? [organizationId] : null,
+          request: req,
+        },
+      },
+    )
+    result = executed.result
+  } catch (err) {
+    // The optimistic-lock guard throws the shared structured 409 so the form's
+    // conflict bar renders the same way it does anywhere else in the product.
+    if (isCrudHttpError(err)) {
+      return NextResponse.json(err.body, { status: err.status })
+    }
+    throw err
+  }
+
+  if (result.status === 'not_found') {
+    return NextResponse.json({ error: 'Channel not found' }, { status: 404 })
+  }
+
+  await guard.afterSuccess()
+  return NextResponse.json(
+    {
+      channelId: result.channelId,
+      aiAutoReplyEnabled: result.aiAutoReplyEnabled,
+      aiAgentId: result.aiAgentId,
+      updatedAt: result.updatedAt,
+    },
+    { status: 200 },
+  )
+}
+
+export const openApi = {
+  tags: ['CommunicationChannels'],
+  methods: {
+    GET: {
+      summary: "Read a Discord channel's AI auto-reply configuration",
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 200, description: 'Current settings plus the agents this channel may be pointed at' },
+        { status: 400, description: 'Invalid channel id' },
+        { status: 401, description: 'Unauthorized' },
+        { status: 404, description: 'Channel not found, not a Discord channel in scope, or not the caller’s to see' },
+      ],
+    },
+    PUT: {
+      summary: "Update a Discord channel's AI auto-reply configuration",
+      tags: ['CommunicationChannels'],
+      responses: [
+        { status: 200, description: 'Settings stored' },
+        {
+          status: 400,
+          description:
+            'Invalid payload, AI module absent, agent not eligible, or the auto-reply principal lacks the agent’s required features',
+        },
+        { status: 401, description: 'Unauthorized' },
+        { status: 404, description: 'Channel not found, or not a Discord channel in this scope' },
+        { status: 409, description: 'The channel changed since the form was loaded' },
+      ],
+    },
+  },
+}

package/src/modules/channel_discord/api/interactions/route.ts

@@ -0,0 +1,242 @@
+import { NextResponse } from 'next/server'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { createLogger } from '@open-mercato/shared/lib/logger'
+import { CommunicationChannel } from '@open-mercato/core/modules/communication_channels/data/entities'
+import { discordCredentialsSchema } from '../../lib/credentials'
+import { DISCORD_MESSAGE_FLAG_EPHEMERAL } from '../../lib/discord-rest'
+import type { DispatchableInteraction } from '../../lib/interactions-dispatch'
+import {
+  DEFAULT_INTERACTION_MESSAGES,
+  resolveDiscordInteraction,
+  screenInteractionRequest,
+  type InteractionCandidate,
+  type InteractionCandidateFilter,
+} from '../../lib/interactions-handler'
+import {
+  getInteractionDispatchQueue,
+  type InteractionDispatchJobPayload,
+} from '../../lib/interactions-queue'
+import { DiscordInteractionResponseType } from '../../lib/interactions-verify'
+
+const logger = createLogger('channel_discord').child({ component: 'interactions-route' })
+
+/**
+ * Discord Interactions endpoint (slash commands, buttons, PING handshake).
+ *
+ * This is a **provider-owned** signed route — the resolution to the spec's one
+ * "under negotiation" hub touch-point. Discord requires a *synchronous* PONG
+ * (`{ type: 1 }`) on the initial PING, which the hub's generic
+ * `api/post/webhook/[provider]` route cannot return (it 202-acks + enqueues). By
+ * shipping this route from the provider package we serve the handshake without
+ * changing the hub contract. Operators set the Interactions Endpoint URL to
+ * `/api/channel_discord/interactions`.
+ *
+ * Auth model: unauthenticated at the platform layer — Ed25519 signature
+ * verification IS the auth, and it is fail-closed (a tampered/missing signature
+ * verifies against no candidate channel → 401).
+ *
+ * Timing model: Discord closes an interaction that is not answered within three
+ * seconds, so a verified slash command / component press is answered with a
+ * DEFERRED acknowledgement and handed to `workers/discord-interactions.ts`,
+ * which does the two slow halves — writing the interaction into the hub's
+ * inbound queue and replacing the "thinking…" placeholder with a real message.
+ * The hand-off happens BEFORE the ack is returned, so a queue that cannot accept
+ * the job downgrades the response to a visible error instead of promising a
+ * follow-up nothing will send.
+ */
+export const metadata = {
+  // Pinned explicitly: this URL is operator-facing — it goes into the Discord
+  // application's Interactions Endpoint field — so it is part of this route's
+  // contract rather than a by-product of where the file happens to sit. It is
+  // the same path the folder derives, so the pin documents the contract instead
+  // of overriding it.
+  path: '/channel_discord/interactions',
+  POST: {
+    requireAuth: false,
+    // Unauthenticated by design. Unsigned traffic is now rejected before any
+    // candidate is loaded, so this bounds the residual case: a caller who does
+    // present well-formed, fresh headers and drives the narrowed candidate load
+    // repeatedly before the signature gate rejects them.
+    rateLimit: { points: 120, duration: 60, keyPrefix: 'discord_interactions' },
+  },
+}
+
+export async function POST(req: Request): Promise<Response> {
+  const rawBody = await req.text()
+  const signatureHex = req.headers.get('x-signature-ed25519')
+  const timestamp = req.headers.get('x-signature-timestamp')
+
+  // Screened here as well as inside `resolveDiscordInteraction` so that unsigned,
+  // malformed or stale traffic returns before the dictionary load below — this
+  // route is unauthenticated, so everything decidable from the request alone
+  // stays ahead of every other cost.
+  const screened = screenInteractionRequest({ signatureHex, timestamp })
+  if (screened) return NextResponse.json(screened.body, { status: screened.status })
+
+  const { t } = await resolveTranslations()
+
+  const result = await resolveDiscordInteraction({
+    rawBody,
+    signatureHex,
+    timestamp,
+    loadCandidates: loadInteractionCandidates,
+    messages: {
+      notDispatchable: t(
+        'channel_discord.interactions.notDispatchable',
+        DEFAULT_INTERACTION_MESSAGES.notDispatchable,
+      ),
+      unsupported: t('channel_discord.interactions.unsupported', DEFAULT_INTERACTION_MESSAGES.unsupported),
+    },
+  })
+
+  // A deferred acknowledgement is a promise of a follow-up. Enqueue it BEFORE
+  // answering: if the hand-off fails the user gets a visible error instead of a
+  // "thinking…" state nothing will ever replace.
+  if (result.dispatch && result.matchedChannel) {
+    const enqueued = await enqueueInteractionDispatch(result.dispatch, result.matchedChannel)
+    if (!enqueued) {
+      return NextResponse.json(
+        {
+          type: DiscordInteractionResponseType.CHANNEL_MESSAGE_WITH_SOURCE,
+          data: {
+            content: t(
+              'channel_discord.interactions.dispatchFailed',
+              'Open Mercato could not record this interaction right now. Please try again in a moment.',
+            ),
+            flags: DISCORD_MESSAGE_FLAG_EPHEMERAL,
+          },
+        },
+        { status: 200 },
+      )
+    }
+  }
+
+  return NextResponse.json(result.body, { status: result.status })
+}
+
+/**
+ * Hand the verified interaction to the dispatch worker. Returns `false` when the
+ * job could not be queued at all, which is the one case where the deferred ack
+ * must be downgraded to a visible reply.
+ */
+async function enqueueInteractionDispatch(
+  dispatch: DispatchableInteraction,
+  channel: InteractionCandidate,
+): Promise<boolean> {
+  const payload: InteractionDispatchJobPayload = {
+    channelId: channel.channelId,
+    channelType: channel.channelType,
+    tenantId: channel.tenantId,
+    organizationId: channel.organizationId,
+    credentialScope: channel.credentialScope,
+    interaction: dispatch,
+  }
+  try {
+    await getInteractionDispatchQueue().enqueue(payload as unknown as Record<string, unknown>)
+    return true
+  } catch (err) {
+    logger.error('failed to enqueue discord interaction dispatch', { err, channelId: channel.channelId })
+    return false
+  }
+}
+
+type CredentialsServiceLike = {
+  resolve: (
+    integrationId: string,
+    scope: { organizationId: string; tenantId: string; userId?: string | null },
+  ) => Promise<Record<string, unknown> | null>
+}
+
+async function loadInteractionCandidates(
+  filter: InteractionCandidateFilter,
+): Promise<InteractionCandidate[]> {
+  const container = await createRequestContainer()
+  const em = (container.resolve('em') as EntityManager).fork()
+
+  let credentialsService: CredentialsServiceLike | null = null
+  try {
+    credentialsService = container.resolve<CredentialsServiceLike>('integrationCredentialsService')
+  } catch {
+    credentialsService = null
+  }
+  if (!credentialsService) return []
+
+  const candidates: InteractionCandidate[] = []
+  try {
+    const rows = (await findWithDecryption(em, CommunicationChannel, {
+      providerKey: 'discord',
+      isActive: true,
+      deletedAt: null,
+    })) as CommunicationChannel[]
+
+    // Credentials are resolved per (tenant, organization, user) scope, and a
+    // tenant's Discord channels usually share one — cache within this request so
+    // N channel rows do not become N decrypts of the same credential bag.
+    const resolvedByScope = new Map<string, Record<string, unknown> | null>()
+
+    for (const channel of rows) {
+      if (!channel.credentialsRef) continue
+      const organizationId = channel.organizationId ?? channel.tenantId
+      const userId = channel.userId ?? null
+      const scopeKey = `${channel.tenantId}|${organizationId}|${userId ?? ''}`
+      if (!resolvedByScope.has(scopeKey)) {
+        try {
+          resolvedByScope.set(
+            scopeKey,
+            await credentialsService.resolve('channel_discord', {
+              tenantId: channel.tenantId,
+              organizationId,
+              userId,
+            }),
+          )
+        } catch {
+          resolvedByScope.set(scopeKey, null)
+        }
+      }
+      const parsed = discordCredentialsSchema.safeParse(resolvedByScope.get(scopeKey) ?? {})
+      if (!parsed.success) continue
+      // Narrowing only — the signature still decides. A body claiming an
+      // application nobody here owns simply verifies against nothing.
+      if (filter.applicationId && parsed.data.applicationId !== filter.applicationId) continue
+      candidates.push({
+        channelId: channel.id,
+        channelType: channel.channelType,
+        tenantId: channel.tenantId,
+        organizationId: channel.organizationId ?? null,
+        publicKey: parsed.data.publicKey,
+        applicationId: parsed.data.applicationId,
+        // The exact scope this row's credentials resolved under, so the worker
+        // re-resolves the same bag instead of guessing — and no token travels.
+        credentialScope: { tenantId: channel.tenantId, organizationId, userId },
+      })
+    }
+  } catch (err) {
+    logger.warn('failed to load discord interaction candidates', { err })
+    return []
+  }
+
+  return candidates
+}
+
+export const openApi = {
+  tags: ['ChannelDiscord'],
+  summary: 'Discord Interactions endpoint (slash commands, buttons, PING handshake)',
+  methods: {
+    POST: {
+      summary: 'Verify (Ed25519, fail-closed) and dispatch a Discord interaction',
+      tags: ['ChannelDiscord'],
+      responses: [
+        {
+          status: 200,
+          description:
+            'Verified interaction — PONG for the handshake, a deferred ack for a dispatched slash command / component / modal submission, an empty autocomplete result, or an ephemeral message when the interaction cannot be dispatched',
+        },
+        { status: 400, description: 'Verified but malformed interaction body' },
+        { status: 401, description: 'Signature verification failed against every candidate channel, or the signed timestamp is outside the replay window' },
+      ],
+    },
+  },
+}

package/src/modules/channel_discord/backend/channel_discord/channels/[id]/ai-auto-reply/page.meta.ts

@@ -0,0 +1,18 @@
+import type { PageMetadata } from '@open-mercato/shared/modules/registry'
+import { CHANNEL_DISCORD_CONFIGURE_FEATURE } from '../../../../../lib/ai-features'
+
+/**
+ * Settings surface for one Discord channel's AI auto-reply. Guarded by the same
+ * feature that gates connecting the bot — arming an agent to answer strangers on
+ * the tenant's behalf is a configuration act, not a viewing one — and kept out of
+ * the sidebar, because it is reached from the channel it configures.
+ */
+export const metadata: PageMetadata = {
+  requireAuth: true,
+  requireFeatures: [CHANNEL_DISCORD_CONFIGURE_FEATURE],
+  titleKey: 'channel_discord.aiAutoReply.page.title',
+  title: 'Discord AI auto-reply',
+  navHidden: true,
+}
+
+export default metadata