Plugin System

// sertone-plugin-hello — minimal Node.js plugin
// No dependencies. Allows all requests, good quality on all responses.
// Run: node server.js

const http = require('http');

const PORT = process.env.PORT || 4001;

const routes = {
  'GET /sertone/info': (req, res) => {
    res.json({
      name: 'Hello World Plugin',
      version: '1.0.0',
      description: 'Allows all requests and reports all responses as good quality.',
      author: 'anonymous',
      fee_model: 'none',
    });
  },

  'POST /sertone/pre-request': (req, res) => {
    // Read and discard body (required to keep the connection clean)
    req.resume();
    req.on('end', () => res.json({ allow: true }));
  },

  'POST /sertone/post-response': (req, res) => {
    req.resume();
    req.on('end', () => res.json({ quality_signal: 1 }));
  },
};

// Minimal HTTP server with JSON helpers
const server = http.createServer((req, res) => {
  const key = `${req.method} ${req.url}`;
  res.json = (data) => {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(data));
  };
  if (routes[key]) {
    routes[key](req, res);
  } else {
    res.writeHead(404);
    res.end('Not found');
  }
});

server.listen(PORT, '0.0.0.0', () => {
  console.log(`Hello World plugin running on port ${PORT}`);
});

// sertone-plugin-ratelimiter — sliding window rate limiter
// No dependencies. Limits each consumer by wallet hash.
// Config via environment variables.

const http = require('http');

const PORT          = parseInt(process.env.PORT || '4001');
const MAX_REQUESTS  = parseInt(process.env.MAX_REQUESTS || '100');   // per window
const WINDOW_MS     = parseInt(process.env.WINDOW_MS || '3600000'); // 1 hour default

// Map: consumerHash -> array of request timestamps
const windows = new Map();

function getWindowCount(hash) {
  const now = Date.now();
  const cutoff = now - WINDOW_MS;
  const times = (windows.get(hash) || []).filter(t => t > cutoff);
  times.push(now);
  windows.set(hash, times);
  return times.length; // includes the current request
}

function timeUntilReset(hash) {
  const times = windows.get(hash) || [];
  if (times.length === 0) return 0;
  const oldest = Math.min(...times);
  return Math.ceil((oldest + WINDOW_MS - Date.now()) / 1000);
}

// Cleanup old entries every 10 minutes
setInterval(() => {
  const cutoff = Date.now() - WINDOW_MS;
  for (const [hash, times] of windows) {
    const filtered = times.filter(t => t > cutoff);
    if (filtered.length === 0) windows.delete(hash);
    else windows.set(hash, filtered);
  }
}, 10 * 60 * 1000);

function readBody(req) {
  return new Promise((resolve) => {
    let data = '';
    req.on('data', chunk => data += chunk);
    req.on('end', () => {
      try { resolve(JSON.parse(data)); } catch { resolve({}); }
    });
  });
}

const server = http.createServer(async (req, res) => {
  res.json = (data, status = 200) => {
    res.writeHead(status, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(data));
  };

  if (req.method === 'GET' && req.url === '/sertone/info') {
    return res.json({
      name: 'Rate Limiter',
      version: '1.0.0',
      description: `Limits each consumer to ${MAX_REQUESTS} requests per ${WINDOW_MS / 60000} minutes.`,
      author: 'anonymous',
      fee_model: 'none',
    });
  }

  if (req.method === 'POST' && req.url === '/sertone/pre-request') {
    const body = await readBody(req);
    const hash = body.consumer_wallet_hash || 'unknown';
    const count = getWindowCount(hash);

    if (count > MAX_REQUESTS) {
      const resetIn = timeUntilReset(hash);
      return res.json({
        allow: false,
        reason: `Rate limit exceeded (${MAX_REQUESTS} requests per ${WINDOW_MS / 60000} min). Resets in ${resetIn}s.`,
      });
    }

    return res.json({ allow: true });
  }

  if (req.method === 'POST' && req.url === '/sertone/post-response') {
    const body = await readBody(req);
    const signal = body.status_code >= 500 ? -1 : (body.latency_ms > 3000 ? 0 : 1);
    return res.json({ quality_signal: signal });
  }

  res.writeHead(404);
  res.end('Not found');
});

server.listen(PORT, '0.0.0.0', () => {
  console.log(`Rate Limiter plugin: max=${MAX_REQUESTS} per ${WINDOW_MS / 60000}min on port ${PORT}`);
});

# sertone-plugin-hello — minimal Python plugin
# No dependencies. Standard library only.
# Run: python3 plugin.py

import os
import json
from http.server import BaseHTTPRequestHandler, HTTPServer

PORT = int(os.environ.get('PORT', 4001))

class PluginHandler(BaseHTTPRequestHandler):
    def log_message(self, fmt, *args):
        pass  # Silence default access log

    def _read_body(self):
        length = int(self.headers.get('Content-Length', 0))
        raw = self.rfile.read(length) if length > 0 else b'{}'
        try:
            return json.loads(raw)
        except Exception:
            return {}

    def _respond(self, data, status=200):
        body = json.dumps(data).encode()
        self.send_response(status)
        self.send_header('Content-Type', 'application/json')
        self.send_header('Content-Length', str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        if self.path == '/sertone/info':
            self._respond({
                'name': 'Hello World Plugin (Python)',
                'version': '1.0.0',
                'description': 'Allows all requests and reports good quality.',
                'author': 'anonymous',
                'fee_model': 'none',
            })
        else:
            self.send_error(404)

    def do_POST(self):
        self._read_body()  # consume body

        if self.path == '/sertone/pre-request':
            self._respond({'allow': True})
        elif self.path == '/sertone/post-response':
            self._respond({'quality_signal': 1})
        else:
            self.send_error(404)

if __name__ == '__main__':
    server = HTTPServer(('0.0.0.0', PORT), PluginHandler)
    print(f'Hello World plugin (Python) running on port {PORT}')
    server.serve_forever()

# sertone-plugin-logger — JSONL request logger with daily rotation
# No dependencies. Standard library only.
# Logs to /app/logs/YYYY-MM-DD.jsonl (mount as a volume to persist)

import os
import json
import time
import threading
from datetime import datetime, timezone
from http.server import BaseHTTPRequestHandler, HTTPServer
from pathlib import Path

PORT     = int(os.environ.get('PORT', 4001))
LOG_DIR  = Path(os.environ.get('LOG_DIR', '/app/logs'))
LOG_DIR.mkdir(parents=True, exist_ok=True)

_lock = threading.Lock()

def log_event(event_type, data):
    today = datetime.now(timezone.utc).strftime('%Y-%m-%d')
    entry = {'_type': event_type, '_ts': int(time.time() * 1000), **data}
    with _lock:
        with open(LOG_DIR / f'{today}.jsonl', 'a') as f:
            f.write(json.dumps(entry) + '\n')

class PluginHandler(BaseHTTPRequestHandler):
    def log_message(self, fmt, *args):
        pass

    def _read_body(self):
        length = int(self.headers.get('Content-Length', 0))
        raw = self.rfile.read(length) if length > 0 else b'{}'
        try:
            return json.loads(raw)
        except Exception:
            return {}

    def _respond(self, data, status=200):
        body = json.dumps(data).encode()
        self.send_response(status)
        self.send_header('Content-Type', 'application/json')
        self.send_header('Content-Length', str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        if self.path == '/sertone/info':
            logs = sorted(LOG_DIR.glob('*.jsonl'))
            self._respond({
                'name': 'Request Logger',
                'version': '1.0.0',
                'description': 'Logs all requests and responses to JSONL files.',
                'author': 'anonymous',
                'fee_model': 'none',
                'log_files': [f.name for f in logs[-7:]],
            })
        elif self.path.startswith('/logs/'):
            filename = self.path[6:]
            filepath = LOG_DIR / filename
            if filepath.exists() and filepath.parent == LOG_DIR:
                content = filepath.read_bytes()
                self.send_response(200)
                self.send_header('Content-Type', 'application/x-ndjson')
                self.send_header('Content-Length', str(len(content)))
                self.end_headers()
                self.wfile.write(content)
            else:
                self.send_error(404)
        else:
            self.send_error(404)

    def do_POST(self):
        body = self._read_body()

        if self.path == '/sertone/pre-request':
            log_event('request', body)
            self._respond({'allow': True})

        elif self.path == '/sertone/post-response':
            log_event('response', body)
            status = body.get('status_code', 200)
            latency = body.get('latency_ms', 0)
            signal = -1 if status >= 500 else (0 if latency > 3000 else 1)
            self._respond({'quality_signal': signal})

        else:
            self.send_error(404)

if __name__ == '__main__':
    server = HTTPServer(('0.0.0.0', PORT), PluginHandler)
    print(f'Logger plugin running on port {PORT}, logs in {LOG_DIR}')
    server.serve_forever()

// sertone-plugin-hello — minimal Go plugin
// Zero dependencies. Single binary. ~5 MB.
// Build: go build -o plugin . && ./plugin

package main

import (
	"encoding/json"
	"io"
	"log"
	"net/http"
	"os"
)

func main() {
	port := os.Getenv("PORT")
	if port == "" {
		port = "4001"
	}

	http.HandleFunc("/sertone/info", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet {
			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
			return
		}
		respond(w, map[string]any{
			"name":        "Hello World Plugin (Go)",
			"version":     "1.0.0",
			"description": "Allows all requests and reports good quality.",
			"author":      "anonymous",
			"fee_model":   "none",
		})
	})

	http.HandleFunc("/sertone/pre-request", func(w http.ResponseWriter, r *http.Request) {
		io.Copy(io.Discard, r.Body) // consume body
		respond(w, map[string]any{"allow": true})
	})

	http.HandleFunc("/sertone/post-response", func(w http.ResponseWriter, r *http.Request) {
		io.Copy(io.Discard, r.Body)
		respond(w, map[string]any{"quality_signal": 1})
	})

	log.Printf("Hello World plugin (Go) running on port %s", port)
	log.Fatal(http.ListenAndServe("0.0.0.0:"+port, nil))
}

func respond(w http.ResponseWriter, data any) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(data)
}