Fix: Usar URL interna para debug webhook receiver (bypass authentik)

server/api/events/stream.get.ts

@@ -40,6 +40,12 @@ export default defineEventHandler(async (event) => {
     },
     'message.status': (data: any) => {
       res.write(`event: message.status\ndata: ${JSON.stringify(data)}\n\n`)
+    },
+    'message.reaction': (data: any) => {
+      res.write(`event: message.reaction\ndata: ${JSON.stringify(data)}\n\n`)
+    },
+    'presence.update': (data: any) => {
+      res.write(`event: presence.update\ndata: ${JSON.stringify(data)}\n\n`)
     }
   }
 

server/api/messages/[instanceId]/chats.get.ts

@@ -12,6 +12,7 @@ interface ChatRow {
   unread_count: number
   last_message_at: Date | null
   last_message: string | null
+  last_message_type: string | null
 }
 
 export default defineEventHandler(async (event) => {

server/api/messages/[instanceId]/react.post.ts

@@ -0,0 +1,62 @@
+/**
+ * POST /api/messages/:instanceId/react
+ * Send a reaction to a message
+ */
+import { baileysManager } from '../../../services/baileys/manager'
+import { query } from '../../../utils/database'
+
+export default defineEventHandler(async (event) => {
+  const username = getHeader(event, 'x-authentik-username')
+  if (!username) {
+    throw createError({ statusCode: 401, message: 'Unauthorized' })
+  }
+
+  const instanceId = getRouterParam(event, 'instanceId')
+  if (!instanceId) {
+    throw createError({ statusCode: 400, message: 'Missing instanceId' })
+  }
+
+  const body = await readBody<{ messageId: string; emoji: string }>(event)
+  if (!body?.messageId) {
+    throw createError({ statusCode: 400, message: 'Missing messageId in request body' })
+  }
+
+  // emoji can be empty string to remove reaction
+  if (body.emoji === undefined) {
+    throw createError({ statusCode: 400, message: 'Missing emoji in request body' })
+  }
+
+  try {
+    // Get the message to find its JID
+    const msgResult = await query<{ raw_message: any }>(
+      `SELECT raw_message FROM messages WHERE instance_id = $1 AND message_id = $2`,
+      [instanceId, body.messageId]
+    )
+
+    if (msgResult.rows.length === 0) {
+      throw createError({ statusCode: 404, message: 'Message not found' })
+    }
+
+    const rawMessage = msgResult.rows[0].raw_message
+    const jid = rawMessage?.key?.remoteJid
+
+    if (!jid) {
+      throw createError({ statusCode: 400, message: 'Could not determine message JID' })
+    }
+
+    await baileysManager.sendReaction(instanceId, jid, body.messageId, body.emoji)
+
+    return { success: true, messageId: body.messageId, emoji: body.emoji }
+  } catch (error: any) {
+    console.error('[React API] Error sending reaction:', error)
+
+    if (error.statusCode) {
+      throw error
+    }
+
+    throw createError({
+      statusCode: 500,
+      message: error.message || 'Error sending reaction'
+    })
+  }
+})

server/api/presence/[instanceId]/[jid].get.ts

@@ -0,0 +1,42 @@
+/**
+ * GET /api/presence/:instanceId/:jid
+ * Get cached presence for a contact
+ */
+import { query } from '../../../utils/database'
+
+export default defineEventHandler(async (event) => {
+  const username = getHeader(event, 'x-authentik-username')
+  if (!username) {
+    throw createError({ statusCode: 401, message: 'Unauthorized' })
+  }
+
+  const instanceId = getRouterParam(event, 'instanceId')
+  const jid = getRouterParam(event, 'jid')
+
+  if (!instanceId || !jid) {
+    throw createError({ statusCode: 400, message: 'Missing instanceId or jid' })
+  }
+
+  try {
+    const result = await query<{ presence: string; last_seen: Date }>(
+      `SELECT presence, last_seen FROM presence_cache
+       WHERE instance_id = $1 AND jid = $2`,
+      [instanceId, jid]
+    )
+
+    if (result.rows.length === 0) {
+      return { presence: null, lastSeen: null }
+    }
+
+    return {
+      presence: result.rows[0].presence,
+      lastSeen: result.rows[0].last_seen
+    }
+  } catch (error: any) {
+    console.error('[Presence API] Error getting presence:', error)
+    throw createError({
+      statusCode: 500,
+      message: 'Error getting presence'
+    })
+  }
+})

server/api/presence/[instanceId]/send.post.ts

@@ -0,0 +1,44 @@
+/**
+ * POST /api/presence/:instanceId/send
+ * Send presence update (composing, recording, available, unavailable, paused)
+ */
+import { baileysManager } from '../../../services/baileys/manager'
+
+type PresenceType = 'composing' | 'recording' | 'available' | 'unavailable' | 'paused'
+
+const VALID_PRESENCES: PresenceType[] = ['composing', 'recording', 'available', 'unavailable', 'paused']
+
+export default defineEventHandler(async (event) => {
+  const username = getHeader(event, 'x-authentik-username')
+  if (!username) {
+    throw createError({ statusCode: 401, message: 'Unauthorized' })
+  }
+
+  const instanceId = getRouterParam(event, 'instanceId')
+  if (!instanceId) {
+    throw createError({ statusCode: 400, message: 'Missing instanceId' })
+  }
+
+  const body = await readBody<{ jid: string; presence: PresenceType }>(event)
+  if (!body?.jid) {
+    throw createError({ statusCode: 400, message: 'Missing jid in request body' })
+  }
+
+  if (!body?.presence || !VALID_PRESENCES.includes(body.presence)) {
+    throw createError({
+      statusCode: 400,
+      message: `Invalid presence. Must be one of: ${VALID_PRESENCES.join(', ')}`
+    })
+  }
+
+  try {
+    await baileysManager.sendPresence(instanceId, body.jid, body.presence)
+    return { success: true, jid: body.jid, presence: body.presence }
+  } catch (error: any) {
+    console.error('[Presence API] Error sending presence:', error)
+    throw createError({
+      statusCode: 500,
+      message: error.message || 'Error sending presence'
+    })
+  }
+})

server/api/presence/[instanceId]/subscribe.post.ts

@@ -0,0 +1,33 @@
+/**
+ * POST /api/presence/:instanceId/subscribe
+ * Subscribe to presence updates for a contact
+ */
+import { baileysManager } from '../../../services/baileys/manager'
+
+export default defineEventHandler(async (event) => {
+  const username = getHeader(event, 'x-authentik-username')
+  if (!username) {
+    throw createError({ statusCode: 401, message: 'Unauthorized' })
+  }
+
+  const instanceId = getRouterParam(event, 'instanceId')
+  if (!instanceId) {
+    throw createError({ statusCode: 400, message: 'Missing instanceId' })
+  }
+
+  const body = await readBody<{ jid: string }>(event)
+  if (!body?.jid) {
+    throw createError({ statusCode: 400, message: 'Missing jid in request body' })
+  }
+
+  try {
+    await baileysManager.subscribeToPresence(instanceId, body.jid)
+    return { success: true, jid: body.jid }
+  } catch (error: any) {
+    console.error('[Presence API] Error subscribing:', error)
+    throw createError({
+      statusCode: 500,
+      message: error.message || 'Error subscribing to presence'
+    })
+  }
+})

server/api/webhooks/[id]/test.post.ts

@@ -58,7 +58,16 @@ export default defineEventHandler(async (event) => {
     const controller = new AbortController()
     const timeout = setTimeout(() => controller.abort(), 10000)
 
-    const response = await fetch(webhook.url, {
+    // Check if the URL is pointing to our own debug receiver
+    // If so, use internal URL to bypass authentik
+    let targetUrl = webhook.url
+    if (webhook.url.includes('/api/debug/webhook-receiver')) {
+      // Use internal URL (works in Docker/local environments)
+      const internalPort = process.env.PORT || 3000
+      targetUrl = `http://localhost:${internalPort}/api/debug/webhook-receiver`
+    }
+
+    const response = await fetch(targetUrl, {
       method: 'POST',
       headers,
       body,

server/services/webhooks/dispatcher.ts

@@ -123,11 +123,19 @@ class WebhookDispatcher {
       headers['X-Webhook-Signature'] = `sha256=${signature}`
     }
 
+    // Check if the URL is pointing to our own debug receiver
+    // If so, use internal URL to bypass authentik
+    let targetUrl = webhook.url
+    if (webhook.url.includes('/api/debug/webhook-receiver')) {
+      const internalPort = process.env.PORT || 3000
+      targetUrl = `http://localhost:${internalPort}/api/debug/webhook-receiver`
+    }
+
     const controller = new AbortController()
     const timeout = setTimeout(() => controller.abort(), webhook.timeout_ms)
 
     try {
-      const response = await fetch(webhook.url, {
+      const response = await fetch(targetUrl, {
         method: 'POST',
         headers,
         body,