Webhook integration

const express = require('express');
const crypto = require('crypto');
const fetch = require('node-fetch');
 
const app = express();
app.use(express.json());
 
const ASGARD_API_KEY = process.env.ASGARD_API_KEY;
const ASGARD_BASE_URL = 'https://api.asgard-ai.com';
const NAMESPACE = 'your-namespace';
const BOT_PROVIDER = 'your-bot-provider';
const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET;
 
/**
 * Verify the webhook signature (HMAC-SHA256)
 */
function verifySignature(payload, signature, secret) {
  const expected = `sha256=${crypto
    .createHmac('sha256', secret)
    .update(JSON.stringify(payload))
    .digest('hex')}`;
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}
 
/**
 * Receive a GitHub push event and trigger an Asgard workflow
 */
app.post('/webhook/github', async (req, res) => {
  const signature = req.headers['x-hub-signature-256'];
 
  // verify the signature
  if (!verifySignature(req.body, signature, WEBHOOK_SECRET)) {
    return res.status(401).json({ error: 'Signature verification failed' });
  }
 
  const { repository, pusher, commits } = req.body;
  const channelId = `github-${repository.name}`;
  const messageId = `push-${Date.now()}`;
 
  // build the message to send to Asgard
  const message = `GitHub push: ${pusher.name} pushed ${commits.length} commit(s) to ${repository.full_name}`;
 
  try {
    const asgardUrl = `${ASGARD_BASE_URL}/generic/ns/${NAMESPACE}/bot-provider/${BOT_PROVIDER}/message/sse`;
 
    const asgardResponse = await fetch(asgardUrl, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-KEY': ASGARD_API_KEY,
      },
      body: JSON.stringify({
        customChannelId: channelId,
        customMessageId: messageId,
        text: message,
        action: 'NONE',
      }),
    });
 
    if (!asgardResponse.ok) {
      throw new Error(`Asgard API error: ${asgardResponse.status}`);
    }
 
    // read Asgard's streamed response
    const reader = asgardResponse.body.getReader();
    const decoder = new TextDecoder();
    let buffer = '';
    let result = '';
 
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
 
      buffer += decoder.decode(value, { stream: true });
      const lines = buffer.split('\n');
      buffer = lines.pop() || '';
 
      for (const line of lines) {
        if (!line.startsWith('data:')) continue;
        const jsonStr = line.slice(5).trim();
        if (!jsonStr) continue;
 
        try {
          const event = JSON.parse(jsonStr);
          if (event.eventType === 'asgard.message.complete') {
            result = event.fact.messageComplete.message.text;
          }
          if (event.eventType === 'asgard.run.done') {
            return res.json({ success: true, result });
          }
        } catch (_) {}
      }
    }
 
    res.json({ success: true, result });
  } catch (error) {
    console.error('Could not forward to Asgard:', error);
    res.status(500).json({ error: error.message });
  }
});
 
app.listen(3000, () => {
  console.log('Webhook server listening on http://localhost:3000');
});