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

package/src/modules/channel_discord/widgets/injection/connect/widget.client.tsx

@@ -0,0 +1,237 @@
+'use client'
+
+import * as React from 'react'
+import type { InjectionWidgetComponentProps } from '@open-mercato/shared/modules/widgets/injection'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { Button } from '@open-mercato/ui/primitives/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@open-mercato/ui/primitives/dialog'
+import { Input } from '@open-mercato/ui/primitives/input'
+import { Label } from '@open-mercato/ui/primitives/label'
+import { PasswordInput } from '@open-mercato/ui/primitives/password-input'
+
+type WidgetContext = Record<string, unknown> & {
+  reload?: () => void
+}
+
+type ConnectResponse = {
+  channelId?: string
+  error?: string
+  fieldErrors?: Record<string, string>
+}
+
+type FormState = {
+  displayName: string
+  botToken: string
+  applicationId: string
+  publicKey: string
+  guildId: string
+  defaultChannelId: string
+}
+
+const INITIAL_FORM: FormState = {
+  displayName: '',
+  botToken: '',
+  applicationId: '',
+  publicKey: '',
+  guildId: '',
+  defaultChannelId: '',
+}
+
+export default function ConnectDiscordWidget({
+  context,
+}: InjectionWidgetComponentProps<Record<string, unknown>, Record<string, unknown>>) {
+  const t = useT()
+  const widgetContext = context as WidgetContext | undefined
+  const [open, setOpen] = React.useState(false)
+  const [pending, setPending] = React.useState(false)
+  const [form, setForm] = React.useState<FormState>(INITIAL_FORM)
+  const [fieldErrors, setFieldErrors] = React.useState<Record<string, string>>({})
+  const { runMutation, retryLastMutation } = useGuardedMutation({
+    contextId: 'channel-discord-connect',
+    blockedMessage: t('channel_discord.connect.blocked', 'Connection blocked by validation'),
+  })
+  const mutationContext = React.useMemo(
+    () => ({ providerKey: 'discord', retryLastMutation }),
+    [retryLastMutation],
+  )
+
+  const update = React.useCallback(
+    <K extends keyof FormState>(key: K, value: FormState[K]) => {
+      setForm((current) => ({ ...current, [key]: value }))
+      setFieldErrors((current) => {
+        if (!current[key]) return current
+        const next = { ...current }
+        delete next[key]
+        return next
+      })
+    },
+    [],
+  )
+
+  const submit = React.useCallback(async () => {
+    if (pending) return
+    setPending(true)
+    setFieldErrors({})
+    try {
+      const response = await runMutation({
+        context: mutationContext,
+        mutationPayload: { providerKey: 'discord', displayName: form.displayName },
+        operation: () =>
+          apiCall<ConnectResponse>('/api/communication_channels/channels/connect/credentials', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+              providerKey: 'discord',
+              displayName: form.displayName.trim() || 'Discord',
+              credentials: {
+                botToken: form.botToken.trim(),
+                applicationId: form.applicationId.trim(),
+                publicKey: form.publicKey.trim(),
+                guildId: form.guildId.trim() || undefined,
+                defaultChannelId: form.defaultChannelId.trim() || undefined,
+              },
+            }),
+          }),
+      })
+      const body = response.result as ConnectResponse | undefined
+      if (!response.ok) {
+        setFieldErrors(body?.fieldErrors ?? {})
+        flash(body?.error ?? t('channel_discord.connect.failed', 'Could not connect Discord bot.'), 'error')
+        return
+      }
+      flash(t('channel_discord.connect.connected', 'Discord channel connected.'), 'success')
+      setOpen(false)
+      setForm(INITIAL_FORM)
+      widgetContext?.reload?.()
+    } finally {
+      setPending(false)
+    }
+  }, [form, mutationContext, pending, runMutation, t, widgetContext])
+
+  const onDialogKeyDown = React.useCallback(
+    (event: React.KeyboardEvent<HTMLDivElement>) => {
+      if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
+        event.preventDefault()
+        void submit()
+      }
+    },
+    [submit],
+  )
+
+  return (
+    <>
+      <Button type="button" variant="outline" onClick={() => setOpen(true)}>
+        {t('channel_discord.connect.button', 'Connect Discord')}
+      </Button>
+      <Dialog open={open} onOpenChange={setOpen}>
+        <DialogContent onKeyDown={onDialogKeyDown}>
+          <DialogHeader>
+            <DialogTitle>{t('channel_discord.connect.title', 'Connect Discord bot')}</DialogTitle>
+          </DialogHeader>
+
+          <div className="grid gap-4 py-2">
+            <Field
+              label={t('channel_discord.connect.fields.displayName', 'Display name')}
+              error={fieldErrors.displayName}
+            >
+              <Input
+                value={form.displayName}
+                onChange={(event) => update('displayName', event.target.value)}
+                aria-invalid={Boolean(fieldErrors.displayName)}
+              />
+            </Field>
+
+            <Field
+              label={t('channel_discord.connect.fields.botToken', 'Bot token')}
+              error={fieldErrors.botToken}
+            >
+              <PasswordInput
+                value={form.botToken}
+                onChange={(event) => update('botToken', event.target.value)}
+                aria-invalid={Boolean(fieldErrors.botToken)}
+              />
+            </Field>
+
+            <div className="grid gap-3 md:grid-cols-2">
+              <Field
+                label={t('channel_discord.connect.fields.applicationId', 'Application ID')}
+                error={fieldErrors.applicationId}
+              >
+                <Input
+                  value={form.applicationId}
+                  onChange={(event) => update('applicationId', event.target.value)}
+                  aria-invalid={Boolean(fieldErrors.applicationId)}
+                />
+              </Field>
+              <Field
+                label={t('channel_discord.connect.fields.publicKey', 'Public key')}
+                error={fieldErrors.publicKey}
+              >
+                <Input
+                  value={form.publicKey}
+                  onChange={(event) => update('publicKey', event.target.value)}
+                  aria-invalid={Boolean(fieldErrors.publicKey)}
+                />
+              </Field>
+            </div>
+
+            <div className="grid gap-3 md:grid-cols-2">
+              <Field
+                label={t('channel_discord.connect.fields.guildId', 'Guild (server) ID')}
+                error={fieldErrors.guildId}
+              >
+                <Input
+                  value={form.guildId}
+                  onChange={(event) => update('guildId', event.target.value)}
+                  aria-invalid={Boolean(fieldErrors.guildId)}
+                />
+              </Field>
+              <Field
+                label={t('channel_discord.connect.fields.defaultChannelId', 'Default channel ID')}
+                error={fieldErrors.defaultChannelId}
+              >
+                <Input
+                  value={form.defaultChannelId}
+                  onChange={(event) => update('defaultChannelId', event.target.value)}
+                  aria-invalid={Boolean(fieldErrors.defaultChannelId)}
+                />
+              </Field>
+            </div>
+          </div>
+
+          <DialogFooter>
+            <Button type="button" variant="outline" onClick={() => setOpen(false)} disabled={pending}>
+              {t('channel_discord.connect.cancel', 'Cancel')}
+            </Button>
+            <Button type="button" onClick={() => void submit()} disabled={pending}>
+              {pending
+                ? t('channel_discord.connect.connecting', 'Connecting...')
+                : t('channel_discord.connect.save', 'Connect')}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </>
+  )
+}
+
+function Field(props: { label: string; error?: string; children: React.ReactNode }) {
+  return (
+    <label className="grid gap-1.5">
+      <Label asChild>
+        <span>{props.label}</span>
+      </Label>
+      {props.children}
+      {props.error ? <span className="text-xs text-destructive">{props.error}</span> : null}
+    </label>
+  )
+}

package/src/modules/channel_discord/widgets/injection/connect/widget.ts

@@ -0,0 +1,16 @@
+import type { InjectionWidgetModule } from '@open-mercato/shared/modules/widgets/injection'
+import ConnectDiscordWidget from './widget.client'
+
+const widget: InjectionWidgetModule<Record<string, unknown>, Record<string, unknown>> = {
+  metadata: {
+    id: 'channel_discord.injection.connect',
+    title: 'Connect Discord',
+    description: 'Connects a Discord bot as a two-way communication channel.',
+    features: ['communication_channels.connect_user_channel'],
+    priority: 100,
+    enabled: true,
+  },
+  Widget: ConnectDiscordWidget,
+}
+
+export default widget

package/src/modules/channel_discord/widgets/injection-table.ts

@@ -0,0 +1,24 @@
+import type { ModuleInjectionTable } from '@open-mercato/shared/modules/widgets/injection'
+import { channelDiscordDetailWidgetSpotId } from '../integration'
+
+export const injectionTable: ModuleInjectionTable = {
+  'profile:communication-channels:connect': [
+    {
+      widgetId: 'channel_discord.injection.connect',
+      priority: 120,
+    },
+  ],
+  // The Discord integration's own detail page — the only spot in the product
+  // that is Discord-scoped by construction, which is what a per-channel AI
+  // setting needs (see the widget's file header).
+  [channelDiscordDetailWidgetSpotId]: [
+    {
+      widgetId: 'channel_discord.injection.ai-auto-reply',
+      priority: 40,
+      kind: 'group',
+      groupLabel: 'channel_discord.aiAutoReply.widget.title',
+    },
+  ],
+}
+
+export default injectionTable

package/src/modules/channel_discord/workers/__tests__/discord-gateway.single-identify.test.ts

@@ -0,0 +1,88 @@
+import {
+  botTokenFingerprint,
+  findChannelWithSameBot,
+  type GatewayConnectionEntry,
+} from '../discord-gateway'
+import type { DiscordGatewayHandle } from '../../lib/discord-gateway-client'
+
+/**
+ * Regression guard for the duplicate-session half of #4977.
+ *
+ * The hub derives a channel's `externalIdentifier` by sniffing the credential
+ * bag for email-shaped keys (`username` / `email` / `fromAddress`), none of
+ * which a Discord credential bag has. Every reconnect therefore inserts a second
+ * active channel row for the same bot instead of healing the first, and QA
+ * observed the gateway opening two parallel WebSocket sessions with two distinct
+ * Discord session ids — defeating the single-identify-per-bot discipline that
+ * `concurrency: 1` exists to enforce.
+ *
+ * The real fix is hub-side (let the adapter supply an identity); this guard is
+ * the interim one that keeps the second socket from ever opening.
+ */
+function fakeEntry(
+  tenantId: string,
+  fingerprint: string | undefined,
+  active = true,
+): GatewayConnectionEntry {
+  const handle: DiscordGatewayHandle = { close: jest.fn(), isActive: () => active }
+  return { handle, tenantId, organizationId: null, botTokenFingerprint: fingerprint }
+}
+
+describe('botTokenFingerprint', () => {
+  it('is stable for the same token and different for another', () => {
+    expect(botTokenFingerprint('bot-token-a')).toBe(botTokenFingerprint('bot-token-a'))
+    expect(botTokenFingerprint('bot-token-a')).not.toBe(botTokenFingerprint('bot-token-b'))
+  })
+
+  it('never reveals the token it was derived from', () => {
+    const token = 'MTIzNDU2Nzg5.super.secret-bot-token'
+    const fingerprint = botTokenFingerprint(token)
+    expect(fingerprint).not.toContain(token)
+    expect(fingerprint).toMatch(/^[0-9a-f]{64}$/)
+  })
+})
+
+describe('findChannelWithSameBot', () => {
+  it('reports the channel already serving the same bot', () => {
+    const fingerprint = botTokenFingerprint('one-bot')
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-first', fakeEntry('t1', fingerprint)],
+    ])
+
+    expect(findChannelWithSameBot('chan-duplicate', fingerprint, connections)).toBe('chan-first')
+  })
+
+  it('does not treat a channel as its own duplicate', () => {
+    const fingerprint = botTokenFingerprint('one-bot')
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-first', fakeEntry('t1', fingerprint)],
+    ])
+
+    expect(findChannelWithSameBot('chan-first', fingerprint, connections)).toBeNull()
+  })
+
+  it('allows a different bot to connect alongside', () => {
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-first', fakeEntry('t1', botTokenFingerprint('bot-a'))],
+    ])
+
+    expect(findChannelWithSameBot('chan-other', botTokenFingerprint('bot-b'), connections)).toBeNull()
+  })
+
+  it('ignores a dead session so a genuinely lost connection can be replaced', () => {
+    const fingerprint = botTokenFingerprint('one-bot')
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-first', fakeEntry('t1', fingerprint, false)],
+    ])
+
+    expect(findChannelWithSameBot('chan-second', fingerprint, connections)).toBeNull()
+  })
+
+  it('ignores entries recorded before fingerprints existed', () => {
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-legacy', fakeEntry('t1', undefined)],
+    ])
+
+    expect(findChannelWithSameBot('chan-new', botTokenFingerprint('bot-a'), connections)).toBeNull()
+  })
+})

package/src/modules/channel_discord/workers/__tests__/discord-gateway.test.ts

@@ -0,0 +1,179 @@
+import {
+  buildGatewayChannelFilter,
+  isConnectionLive,
+  reconcileGatewayConnections,
+  type GatewayConnectionEntry,
+} from '../discord-gateway'
+import type { DiscordGatewayHandle } from '../../lib/discord-gateway-client'
+
+function fakeEntry(
+  tenantId: string,
+  active = true,
+  organizationId: string | null = null,
+): { entry: GatewayConnectionEntry; close: jest.Mock } {
+  const close = jest.fn()
+  const handle: DiscordGatewayHandle = { close, isActive: () => active }
+  return { entry: { handle, tenantId, organizationId }, close }
+}
+
+/**
+ * `GatewayJobPayload.organizationId` used to be accepted and silently discarded:
+ * the query filtered on tenant only, so a job scoped to one organization
+ * connected every organization in the tenant. A scope parameter that is declared
+ * and then thrown away is how multi-tenant defects start, so the filter is
+ * pinned here.
+ */
+describe('buildGatewayChannelFilter (scoped job payloads)', () => {
+  it('connects every active discord channel when the payload carries no scope', () => {
+    expect(buildGatewayChannelFilter({})).toEqual({
+      providerKey: 'discord',
+      isActive: true,
+      deletedAt: null,
+    })
+  })
+
+  it('narrows by tenant when the payload names one', () => {
+    expect(buildGatewayChannelFilter({ tenantId: 't1' })).toEqual({
+      providerKey: 'discord',
+      isActive: true,
+      deletedAt: null,
+      tenantId: 't1',
+    })
+  })
+
+  it('narrows by organization when the payload names one', () => {
+    expect(buildGatewayChannelFilter({ tenantId: 't1', organizationId: 'org-a' })).toEqual({
+      providerKey: 'discord',
+      isActive: true,
+      deletedAt: null,
+      tenantId: 't1',
+      organizationId: 'org-a',
+    })
+  })
+
+  it('treats an explicitly null organization as "no organization filter", not "tenant-wide channels only"', () => {
+    // The payload type allows `organizationId: null`; that is the absence of a
+    // filter, not a request for rows whose organization_id IS NULL.
+    expect(buildGatewayChannelFilter({ tenantId: 't1', organizationId: null })).toEqual({
+      providerKey: 'discord',
+      isActive: true,
+      deletedAt: null,
+      tenantId: 't1',
+    })
+  })
+})
+
+describe('reconcileGatewayConnections', () => {
+  it('closes + removes a connection whose channel dropped out of the active set', () => {
+    const a = fakeEntry('t1')
+    const b = fakeEntry('t1')
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-a', a.entry],
+      ['chan-b', b.entry],
+    ])
+
+    // chan-b is no longer active (deactivated / soft-deleted).
+    const removed = reconcileGatewayConnections(new Set(['chan-a']), connections)
+
+    expect(removed).toEqual(['chan-b'])
+    expect(b.close).toHaveBeenCalledTimes(1)
+    expect(a.close).not.toHaveBeenCalled()
+    expect(connections.has('chan-b')).toBe(false)
+    expect(connections.has('chan-a')).toBe(true)
+  })
+
+  it('keeps every connection when all channels are still active', () => {
+    const a = fakeEntry('t1')
+    const connections = new Map<string, GatewayConnectionEntry>([['chan-a', a.entry]])
+    const removed = reconcileGatewayConnections(new Set(['chan-a']), connections)
+    expect(removed).toEqual([])
+    expect(a.close).not.toHaveBeenCalled()
+    expect(connections.has('chan-a')).toBe(true)
+  })
+
+  it('a tenant-scoped refresh never tears down another tenant’s sockets', () => {
+    const t1 = fakeEntry('t1')
+    const t2 = fakeEntry('t2')
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-t1', t1.entry],
+      ['chan-t2', t2.entry],
+    ])
+
+    // Scoped refresh for t1 returns no active t1 channels, but must NOT touch t2.
+    const removed = reconcileGatewayConnections(new Set<string>(), connections, { tenantId: 't1' })
+
+    expect(removed).toEqual(['chan-t1'])
+    expect(t1.close).toHaveBeenCalledTimes(1)
+    expect(t2.close).not.toHaveBeenCalled()
+    expect(connections.has('chan-t2')).toBe(true)
+  })
+
+  it('an organization-scoped refresh never tears down a sibling organization’s sockets', () => {
+    // A job payload carrying `organizationId` used to be accepted and discarded:
+    // the query and the reconciliation both filtered on tenant only, so a refresh
+    // scoped to one organization would close every OTHER organization's sockets
+    // in the same tenant, because none of their channels appeared in the
+    // (tenant-wide) active set it compared against.
+    const orgA = fakeEntry('t1', true, 'org-a')
+    const orgB = fakeEntry('t1', true, 'org-b')
+    const tenantWide = fakeEntry('t1', true, null)
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-org-a', orgA.entry],
+      ['chan-org-b', orgB.entry],
+      ['chan-tenant-wide', tenantWide.entry],
+    ])
+
+    const removed = reconcileGatewayConnections(new Set<string>(), connections, {
+      tenantId: 't1',
+      organizationId: 'org-a',
+    })
+
+    expect(removed).toEqual(['chan-org-a'])
+    expect(orgA.close).toHaveBeenCalledTimes(1)
+    expect(orgB.close).not.toHaveBeenCalled()
+    expect(tenantWide.close).not.toHaveBeenCalled()
+    expect(connections.has('chan-org-b')).toBe(true)
+    expect(connections.has('chan-tenant-wide')).toBe(true)
+  })
+
+  it('an unscoped refresh still reconciles every tenant and organization', () => {
+    const orgA = fakeEntry('t1', true, 'org-a')
+    const otherTenant = fakeEntry('t2', true, 'org-z')
+    const connections = new Map<string, GatewayConnectionEntry>([
+      ['chan-org-a', orgA.entry],
+      ['chan-t2', otherTenant.entry],
+    ])
+
+    const removed = reconcileGatewayConnections(new Set<string>(), connections)
+
+    expect(removed.sort()).toEqual(['chan-org-a', 'chan-t2'])
+    expect(connections.size).toBe(0)
+  })
+})
+
+describe('isConnectionLive (refresh must not churn healthy sockets)', () => {
+  it('reports a running session as live so the refresh job leaves it alone', () => {
+    const live = fakeEntry('t1', true)
+    expect(isConnectionLive(live.entry)).toBe(true)
+  })
+
+  it('reports a stopped session as dead so the refresh job replaces it', () => {
+    const dead = fakeEntry('t1', false)
+    expect(isConnectionLive(dead.entry)).toBe(false)
+  })
+
+  it('treats a missing entry and a throwing handle as dead', () => {
+    expect(isConnectionLive(undefined)).toBe(false)
+    const throwing: GatewayConnectionEntry = {
+      tenantId: 't1',
+      organizationId: null,
+      handle: {
+        close: jest.fn(),
+        isActive: () => {
+          throw new Error('socket gone')
+        },
+      },
+    }
+    expect(isConnectionLive(throwing)).toBe(false)
+  })
+})