bipy/pusher repository overview

docker run -d \
  --name pusher \
  -p 3333:3333 \
  -e TG_TOKEN=your_telegram_bot_token \
  -e CHAT_ID=your_chat_id \
  bipy/pusher:latest

docker run -d \
  --name pusher \
  -p 8080:8080 \
  -e TG_TOKEN=your_telegram_bot_token \
  -e CHAT_ID=your_chat_id \
  -e SERVER_HOST=0.0.0.0 \
  -e SERVER_PORT=8080 \
  -e SECURE_KEY=your_secure_password \
  bipy/pusher:latest

version: '3.8'

services:
  pusher:
    image: bipy/pusher:latest
    container_name: pusher
    restart: unless-stopped
    ports:
      - "3333:3333"
    environment:
      TG_TOKEN: "your_telegram_bot_token"
      CHAT_ID: "your_chat_id"
      SECURE_KEY: "your_secure_password"  # Optional
    # For production, use behind a reverse proxy with HTTPS

docker-compose up -d

# Clone the repository
git clone https://github.com/bipy/pusher.git
cd pusher

# Build the binary
go build -o pusher .

# Run with environment variables
export TG_TOKEN=your_telegram_bot_token
export CHAT_ID=your_chat_id
./pusher

{
  "text": "Your message here",
  "preview": false,
  "markdown": false
}

{
  "code": 0,
  "msg": "OK",
  "resp": null
}

# Without authentication
curl "http://localhost:3333/?text=Hello%20World"

# With authentication via query parameter
curl "http://localhost:3333/?text=Hello%20World&key=your_secure_password"

curl -I http://localhost:3333/pulse

# GET request
curl "http://localhost:3333/?text=Hello&key=your_secure_password"

# POST request
curl -X POST "http://localhost:3333/?key=your_secure_password" \
  -H "Content-Type: application/json" \
  -d '{"text": "Authenticated message"}'

# With Secure-Key header
curl -X POST http://localhost:3333/ \
  -H "Content-Type: application/json" \
  -H "Secure-Key: your_secure_password" \
  -d '{"text": "Authenticated message"}'

> **Note:** When `SECURE_KEY` is not set (empty), authentication is disabled and all requests are allowed.

---

## 💡 Usage Examples

### Basic cURL Examples

**Simple Message:**

```bash
curl -X POST http://localhost:3333/ \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello from Pusher!"}'

# GET with authentication
curl "http://localhost:3333/?text=Secure%20message&key=your_password"

# POST with authentication
curl -X POST "http://localhost:3333/?key=your_password" \
  -H "Content-Type: application/json" \
  -d '{"text": "Authenticated message"}'

curl "http://localhost:3333/?text=Check%20this%20out%20https://github.com&preview"

curl -X POST http://localhost:3333/ \
  -H "Content-Type: application/json" \
  -d '{"text": "*Bold* and _italic_ text", "markdown": true}'

# Simple message
http POST localhost:3333 text="Hello World"

# With authentication (query parameter - easier)
http POST "localhost:3333?key=your_password" text="Secure message"

# With authentication (header method)
http POST localhost:3333 text="Secure message" Secure-Key:your_password

# With markdown
http POST localhost:3333 text="**Important** update" markdown:=true

import requests

def send_telegram_message(text, markdown=False, secure_key=None):
    # Method 1: Using query parameter (simpler)
    params = {}
    if secure_key:
        params['key'] = secure_key
    
    response = requests.post(
        'http://localhost:3333/',
        params=params,
        json={
            'text': text,
            'markdown': markdown,
            'preview': False
        }
    )
    return response.json()

# Alternatively, using header authentication:
def send_with_header(text, secure_key=None):
    headers = {}
    if secure_key:
        headers['Secure-Key'] = secure_key
    
    response = requests.post(
        'http://localhost:3333/',
        json={'text': text},
        headers=headers
    )
    return response.json()

# Usage
send_telegram_message("Deployment successful! 🚀")
send_telegram_message("Secure message", secure_key="your_password")

// Method 1: Using query parameter (simpler, no custom headers)
async function sendTelegramMessage(text, options = {}) {
  const params = new URLSearchParams();
  if (options.secureKey) {
    params.append('key', options.secureKey);
  }
  
  const url = `http://localhost:3333/?${params}`;
  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text,
      preview: options.preview || false,
      markdown: options.markdown || false
    })
  });
  return response.json();
}

// Method 2: Using header authentication
async function sendWithHeader(text, secureKey) {
  const headers = {
    'Content-Type': 'application/json'
  };
  if (secureKey) {
    headers['Secure-Key'] = secureKey;
  }
  
  const response = await fetch('http://localhost:3333/', {
    method: 'POST',
    headers,
    body: JSON.stringify({ text })
  });
  return response.json();
}

// Usage
await sendTelegramMessage('Build completed successfully!');
await sendTelegramMessage('Secure message', { secureKey: 'your_password' });

#!/bin/bash

PUSHER_URL="http://localhost:3333/"
SECURE_KEY="your_secure_password"

# Method 1: Using query parameter (simpler)
function notify_simple() {
    local message="$1"
    curl -s -X POST "${PUSHER_URL}?key=${SECURE_KEY}" \
        -H "Content-Type: application/json" \
        -d "{\"text\": \"$message\"}"
}

# Method 2: Using header
function notify_header() {
    local message="$1"
    curl -s -X POST "$PUSHER_URL" \
        -H "Content-Type: application/json" \
        -H "Secure-Key: $SECURE_KEY" \
        -d "{\"text\": \"$message\"}"
}

# Usage
notify_simple "Backup completed at $(date)"

┌─────────────┐         ┌─────────────┐         ┌──────────────────┐
│   Client    │         │   Pusher    │         │  Telegram API    │
│             │         │             │         │                  │
│  HTTP GET   ├────────▶│  Echo Web   ├────────▶│  /sendMessage    │
│  HTTP POST  │         │  Framework  │         │                  │
└─────────────┘         └─────────────┘         └──────────────────┘
                               │
                               ├─ Authentication (optional)
                               ├─ Markdown Escaping
                               ├─ Message Splitting
                               ├─ Gzip Compression
                               └─ Error Handling

server {
    listen 443 ssl http2;
    server_name pusher.example.com;

    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location / {
        proxy_pass http://localhost:3333;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        
        # Rate limiting
        limit_req zone=pusher_limit burst=10 nodelay;
    }
}

# Check if service is running
curl -f http://localhost:3333/pulse || echo "Service down"

services:
  pusher:
    image: bipy/pusher:latest
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3333/pulse"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 5s

# Docker logs
docker logs -f pusher

# Follow logs with timestamps
docker logs -f --timestamps pusher

# Clone your fork
git clone https://github.com/yourusername/pusher.git
cd pusher

# Install dependencies
go mod download

# Run locally
export TG_TOKEN=your_token
export CHAT_ID=your_chat_id
go run main.go

MIT License

Copyright (c) 2021 bipy