Mattermost Integration fuer AI-Workflows

# Docker Deployment (Standard)
docker run -d \
  --name mattermost \
  -e MM_SQLSETTINGS_DRIVERNAME=postgres \
  -e MM_SQLSETTINGS_DATASOURCE='postgres://...' \
  -p 8065:8065 \
  mattermost/mattermost-team-edition

# config.json
ServiceSettings:
  ListenAddress: ":8065"
  EnableOAuthServiceProvider: true
  EnableDeveloperMode: true

EmailSettings:
  SMTPServer: "mail.internal"
  SMTPPort: 587
  SendEmailNotifications: true

Plugins:
  Enabled: true
  AllowInsecureDownloadURL: false

Name: @claude-bot
Username: claude-bot
Icon: [Claude Logo]
Access Token: [Auto-Generated]

vault.py set shared mattermost CLAUDE_BOT_TOKEN "xxx-xxx-xxx"

Allgemein/
├── #general              — Announcements, alle
├── #random               — Off-topic
├── #dev-team             — Development

Operationen/
├── #ceo-dashboard        — KPIs, Haupt-Metriken (nur Joe liest)
├── #infra-alerts         — Uptime, CPU, Memory, Alerts
├── #deployments          — Git, CI/CD, Cloudflare Pages
├── #shop-orders          — Stripe/Gumroad Webhooks

Automation/
├── #echo-log             — Agent Outputs, Task Results
├── #n8n-runs             — n8n Workflow Executions
├── #social-media         — Twitter, LinkedIn Auto-Posts
├── #email-digest         — Incoming Emails

#ceo-dashboard:    Reader: CEO, Manager-Agent     | Poster: Bots only
#infra-alerts:     Reader: Everyone       | Poster: Monitoring Bots
#echo-log:         Reader: Everyone       | Poster: Bots only
#general:          Reader: Everyone       | Poster: Everyone

System Console → Integrations → Incoming Webhooks
→ Create
→ Select Channel: #shop-orders
→ Authorized Users: (leave empty = everyone)
→ Copy URL

curl -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "channel": "#shop-orders",
    "username": "Stripe",
    "icon_url": "https://stripe.com/logo.png",
    "text": "💳 Payment received: $49 USD\nCustomer: [email protected]\nProduct: P1 Playbook"
  }' \
  https://mattermost.internal:8065/hooks/xxx-uuid-xxx

{
  "channel": "#infra-alerts",
  "username": "Prometheus",
  "attachments": [
    {
      "color": "#FF0000",
      "title": "CPU High on .80",
      "text": "CPU: 87% | Memory: 92% | Disk: 74%",
      "fields": [
        {
          "title": "Server",
          "value": ".80 (Manager)",
          "short": true
        },
        {
          "title": "Duration",
          "value": "15 min",
          "short": true
        }
      ]
    }
  ]
}

System Console → Integrations → Outgoing Webhooks
→ Create
→ Select Channel: #general (oder Private)
→ Trigger Words: /backup
→ Callback URL: https://n8n.internal:5678/webhook/backup

{
  "token": "xxx",
  "team_id": "xxx",
  "team_domain": "ai-engineering",
  "channel_id": "xxx",
  "channel_name": "general",
  "timestamp": 1234567890,
  "user_id": "xxx",
  "user_name": "joe",
  "post_id": "xxx",
  "text": "/backup",
  "trigger_word": "backup"
}

{
  "response_type": "in_channel",
  "text": "✅ Backup gestartet. ID: `bkp-20260321-1430`",
  "goto_location": "https://mattermost.internal:8065/ai-engineering/channels/general"
}

import requests
import json

class MattermostBot:
    def __init__(self, base_url, username, token):
        self.base_url = base_url
        self.headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }
        self.username = username
        self._get_bot_id()

    def _get_bot_id(self):
        """Get bot's user ID"""
        resp = requests.get(
            f'{self.base_url}/api/v4/users/usernames?usernames={self.username}',
            headers=self.headers
        )
        self.bot_id = resp.json()[0]['id']

    def post_message(self, channel_id, message, attachments=None):
        """Post message to channel"""
        data = {
            'channel_id': channel_id,
            'message': message,
            'user_id': self.bot_id
        }
        if attachments:
            data['props'] = {'attachments': attachments}

        resp = requests.post(
            f'{self.base_url}/api/v4/posts',
            headers=self.headers,
            json=data
        )
        return resp.json()

    def get_channel(self, channel_name):
        """Resolve channel name to ID"""
        resp = requests.get(
            f'{self.base_url}/api/v4/teams/name/ai-engineering/channels/name/{channel_name}',
            headers=self.headers
        )
        return resp.json()['id']

from vault import get

token = get('shared', 'mattermost', 'CLAUDE_BOT_TOKEN')
bot = MattermostBot('https://mattermost.internal:8065', 'claude-bot', token)

channel_id = bot.get_channel('echo-log')
bot.post_message(channel_id, '✅ Task completed successfully')

import requests
import time

class MMPoller:
    def __init__(self, base_url, token, channel_id, bot_name):
        self.base_url = base_url
        self.headers = {'Authorization': f'Bearer {token}'}
        self.channel_id = channel_id
        self.bot_name = bot_name
        self.last_post_id = None

    def poll_mentions(self, interval=30):  # 30 sec = Joe's preference
        """Poll channel fuer @bot-mentions"""
        while True:
            try:
                # Hole letzte Posts
                resp = requests.get(
                    f'{self.base_url}/api/v4/channels/{self.channel_id}/posts',
                    headers=self.headers
                )
                posts = resp.json().get('posts', {})

                # Filtere nach mentions
                for post_id, post in posts.items():
                    if self.last_post_id and post_id <= self.last_post_id:
                        continue

                    message = post.get('message', '')
                    if f'@{self.bot_name}' in message:
                        self.handle_mention(post)
                        self.last_post_id = post_id

            except Exception as e:
                print(f'Poll error: {e}')

            time.sleep(interval)

    def handle_mention(self, post):
        """Process @mention"""
        user = post.get('user_id')
        message = post.get('message')
        print(f'[{user}] {message}')

def send_heartbeat(channel_id, agent_name, cpu, memory, tasks_done):
    """Send heartbeat message"""
    message = f"💚 @{agent_name} alive | CPU {cpu}% | RAM {memory}% | Tasks {tasks_done}/10"
    bot.post_message(channel_id, message)

heartbeat_missed = now() - last_heartbeat > 120 seconds
if heartbeat_missed:
    post_to_channel('#infra-alerts', f'⚠️ @{agent_name} Heartbeat verpasst!')

{
  "nodes": [
    {
      "name": "MM Webhook",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [100, 200],
      "webhookId": "xxx"
    },
    {
      "name": "Extract Text",
      "type": "n8n-nodes-base.set",
      "typeVersion": 1,
      "position": [300, 200],
      "parameters": {
        "values": {
          "text": "={{ $json.text }}",
          "user": "={{ $json.user_name }}",
          "channel": "={{ $json.channel_name }}"
        }
      }
    },
    {
      "name": "Process (LLM/etc)",
      "type": "n8n-nodes-base.openai",
      "typeVersion": 2,
      "position": [500, 200],
      "parameters": {
        "prompt": "Process: {{ $json.text }}"
      }
    },
    {
      "name": "Reply to MM",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [700, 200],
      "parameters": {
        "url": "https://mattermost.internal:8065/hooks/{{ $env.MM_WEBHOOK_ID }}",
        "method": "POST",
        "body": {
          "channel": "#{{ $json.channel }}",
          "username": "n8n Bot",
          "text": "{{ $json.response }}"
        }
      }
    }
  ]
}

{
  "name": "Post to Mattermost",
  "type": "n8n-nodes-base.httpRequest",
  "typeVersion": 4,
  "parameters": {
    "url": "=https://mattermost.internal:8065/api/v4/posts",
    "method": "POST",
    "authentication": "genericCredentialType",
    "genericCredentials": {
      "authenticationType": "bearerToken",
      "genericCredentials": "={{ $env.MM_BOT_TOKEN }}"
    },
    "sendBody": true,
    "body": {
      "channel_id": "=INFRA_ALERTS_CHANNEL_ID",
      "message": "=Workflow {{ $json.workflow_name }} finished in {{ $json.duration }}s"
    }
  }
}

# In Claude Code skill oder Agent
import requests

def post_to_mattermost(channel, message, attachments=None):
    token = vault.get('shared/mattermost/CLAUDE_BOT_TOKEN')
    url = 'https://mattermost.internal:8065/api/v4/posts'

    data = {
        'channel_id': get_channel_id(channel),
        'message': message
    }
    if attachments:
        data['props'] = {'attachments': attachments}

    resp = requests.post(
        url,
        headers={'Authorization': f'Bearer {token}'},
        json=data
    )
    return resp.json()

# Usage
post_to_mattermost('#echo-log', '✅ Deployment completed successfully')

# n8n Workflow
Input: MM Webhook (/analyze)
→ Extract arguments
→ Call Claude Code API
→ Wait for result
→ Post back to MM via Webhook

### ✅ Task Complete
**Agent:** Developer-Agent
**Task:** Deploy v1.2.3 to Production
**Duration:** 3m 42s
**Status:** Success

Details: Everything deployed successfully

### ❌ Task Failed
**Agent:** Infrastructure-Agent
**Task:** Database migration
**Error:** Connection timeout
**Log:** [paste error details]

Action: Retry after DB restart

| Metric | Value |
|--------|-------|
| Deployment | v1.2.3 |
| Duration | 2m 15s |
| Tests | 124/124 passed |
| Coverage | 92% |

vault.py set shared/mattermost/AGENT_TOKEN_JIM01 "xxx"
vault.py set shared/mattermost/AGENT_TOKEN_LISA01 "yyy"

#ceo-dashboard:
  - Readers: CEO, Manager-Agent (CEO/Manager only)
  - Posters: Bots only (Prometheus, Uptime Kuma)
  - Purpose: KPI review, daily standup

#infra-alerts:
  - Readers: All
  - Posters: Monitoring bots only
  - Purpose: Emergencies, downtimes, critical alerts

#general:
  - Readers: All
  - Posters: All
  - Purpose: Announcements, team updates

#ceo-dashboard:  30 days
#infra-alerts:   90 days
#echo-log:       7 days
#general:        Unlimited

Critical Alerts: All members notified
High Alerts:     Manager-Agent + responsible agent
Medium Alerts:   Channel only
Low Info:        No notification

# Test vom Server
curl -X POST https://mattermost.internal:8065/hooks/xxx \
  -H 'Content-Type: application/json' \
  -d '{"text": "Test"}'

# Response: 200 OK + "Post created"

# Check token
vault.py get shared/mattermost/CLAUDE_BOT_TOKEN

# Check API
curl -H "Authorization: Bearer $TOKEN" \
  https://mattermost.internal:8065/api/v4/users/me
# Response: Bot user info

# Check Process
ps aux | grep mattermost_poll.py

# Check Logs
tail -f /opt/logs/mattermost-poller.log

# Manual test
python3 -c "from poller import MMPoller; p = MMPoller(...); p.poll_mentions()"