{
  "id":             "my_plugin",
  "name":           "My Plugin",
  "version":        "1.0.0",
  "author":         "You",
  "description":    "Does something cool.",
  "entry_point":    "main.py",
  "router_prefix":  "/api/plugins/my_plugin",
  "static_prefix":  "/static/plugins/my_plugin",
  "watchdog":       false
}

from fastapi import APIRouter

core_context: dict = {}
plugin_router = APIRouter()

def init_plugin(context: dict):
    core_context.update(context)

@plugin_router.get("/hello")
async def hello():
    return {"message": "Hello from my_plugin!"}

{
  "id":             "hello_mesh",
  "name":           "Hello Mesh",
  "version":        "1.0.0",
  "author":         "MeshDash",
  "description":    "Interactive API explorer and plugin tutorial.",
  "entry_point":    "main.py",
  "router_prefix":  "/api/plugins/hello_mesh",
  "static_prefix":  "/static/plugins/hello_mesh",
  "watchdog":       true,
  "nav_menu": [{
    "label": "Hello Mesh",
    "icon":  "fa-graduation-cap",
    "href":  "/plugin/hello_mesh/index.html"
  }]
}

# MeshDash Configuration
MESHTASTIC_CONNECTION_TYPE=TCP
MESHTASTIC_HOST=192.168.1.50
MESHTASTIC_PORT=4403
WEBSERVER_PORT=8080
LOG_LEVEL=DEBUG
AUTH_SECRET_KEY=change_me_to_something_random_and_long
AUTH_TOKEN_EXPIRE_MINUTES=120
MAX_PACKETS_MEMORY=500
HISTORY_DAYS=7

import asyncio, time

core_context: dict = {}
plugin_router = APIRouter()

async def _my_background_task():
    while True:
        await asyncio.sleep(60)
        logger = core_context.get("logger")
        if logger: logger.info("Background tick")

def init_plugin(context: dict):
    core_context.update(context)
    loop = core_context.get("event_loop")   # the real uvicorn loop
    if loop is None: return

    # ✅ Correct — schedules on the running loop from a thread
    asyncio.run_coroutine_threadsafe(_my_background_task(), loop)

    # ❌ Wrong — get_event_loop() from a thread returns the wrong loop
    # asyncio.get_event_loop().create_task(_my_background_task())

import asyncio, time

async def _watchdog_heartbeat():
    while True:
        await asyncio.sleep(30)        # ping every 30 s (well within 120 s limit)
        wd  = core_context.get("plugin_watchdog")
        pid = core_context.get("plugin_id")
        if wd is not None and pid:
            wd[pid] = time.time()       # reset the timer

def init_plugin(context: dict):
    core_context.update(context)
    loop = core_context.get("event_loop")
    if loop:
        asyncio.run_coroutine_threadsafe(_watchdog_heartbeat(), loop)

def init_plugin(context: dict):
    core_context.update(context)
    log = context.get("logger")     # logging.getLogger("plugin.my_plugin")
    log.info("Plugin started")

# In your route handlers:
@plugin_router.get("/something")
async def something():
    log = core_context.get("logger")
    log.debug("Request received")
    log.warning("Something odd")
    log.error("Something broke")
    return {"ok": True}

async function checkStatus() {
    const res  = await fetch('/api/status');
    const data = await res.json();

    if (!data.is_system_ready) {
        showWarning('Radio not ready: ' + data.connection_status);
        return;
    }
    const node = data.local_node_info;
    console.log('Local node:', node.long_name, node.node_id);
}
checkStatus();

const history = await fetch(
    '/api/system/connection_history?limit=60'
).then(r => r.json());

// history is oldest-first, value: 0.9=up, 0.5=init, 0.1=down
const uptime = history.filter(h => h.value >= 0.9).length;
const pct    = ((uptime / history.length) * 100).toFixed(1);
console.log(`Uptime: ${pct}% over last ${history.length} samples`);

const nodes = await fetch('/api/nodes').then(r => r.json());
const nodeList = Object.values(nodes);

// Find nodes with GPS
const located = nodeList.filter(n => n.latitude && n.longitude);

// Find nodes seen in last 30 minutes
const recent = nodeList.filter(n =>
    n.last_heard > (Date.now()/1000) - 1800
);

// Find local node
const localNode = nodeList.find(n => n.isLocal);
console.log(`${nodeList.length} total, ${located.length} with GPS`);

const packets = await fetch(
    '/api/packets/history?limit=50'
).then(r => r.json());

// Group by packet type
const byType = packets.reduce((acc, p) => {
    const t = p.packet_type || 'Unknown';
    acc[t] = (acc[t] || 0) + 1;
    return acc;
}, {});

// Average SNR across all packets
const withSnr = packets.filter(p => p.rx_snr != null);
const avgSnr  = withSnr.reduce((s,p) => s + p.rx_snr, 0) / withSnr.length;
console.log(`Average SNR: ${avgSnr.toFixed(1)} dB`);

// Get last 20 messages on channel 0
const msgs = await fetch(
    '/api/messages/history?limit=20&channel=0'
).then(r => r.json());

// Get DMs between two nodes
const dms = await fetch(
    '/api/messages/history?from_id=!a1b2c3d4&to_id=!e5f6a7b8&limit=50'
).then(r => r.json());

// Each message: from_id, to_id, channel, text, timestamp, rx_snr, rx_rssi
msgs.forEach(m => {
    const dt = new Date(m.timestamp * 1000).toLocaleTimeString();
    console.log(`[${dt}] ${m.from_id}: ${m.text}`);
});

async def send_to_mesh():
    cm = core_context.get("connection_manager")
    if not cm or not cm.is_ready.is_set():
        raise RuntimeError("Radio not ready")

    # Broadcast to all nodes on channel 0
    await cm.sendText("Hello mesh!", destinationId="^all", channelIndex=0)

    # Direct message to a specific node
    await cm.sendText("Private msg", destinationId="!ab12cd34", channelIndex=0)

const neighbors = await fetch('/api/neighbors').then(r => r.json());

const graph = {};
neighbors.forEach(n => {
    if (!graph[n.node_id]) graph[n.node_id] = [];
    graph[n.node_id].push({ id: n.neighbor_id, snr: n.snr });
});

// Find most connected nodes (potential relays)
const sorted = Object.entries(graph)
    .sort((a, b) => b[1].length - a[1].length);
console.log('Most connected:', sorted[0]);

const routes = await fetch(
    '/api/traceroutes?limit=20'
).then(r => r.json());

routes.forEach(r => {
    const hops = r.route_path?.length || 0;
    const dt = new Date(r.timestamp * 1000).toLocaleString();
    console.log(`${r.from_id} → ${r.to_id}: ${hops} hops @ ${dt}`);
});

const waypoints = await fetch('/api/waypoints').then(r => r.json());

// Convert to GeoJSON FeatureCollection for Leaflet/Mapbox
const geojson = {
    type: 'FeatureCollection',
    features: waypoints
        .filter(w => w.latitude && w.longitude)
        .map(w => ({
            type: 'Feature',
            geometry: { type: 'Point', coordinates: [w.longitude, w.latitude] },
            properties: { name: w.name, desc: w.description }
        }))
};
console.log(`${geojson.features.length} mappable waypoints`);

const node = await fetch('/api/local_node/full').then(r => r.json());
console.log('LoRa region:', node.lora_region);
console.log('Hop limit:',  node.lora_hop_limit);
console.log('TX power:',   node.lora_tx_power, 'dBm');
console.log('Reboots:',    node.reboot_count);

const channels = await fetch('/api/channels').then(r => r.json());

// Get active (non-disabled) channels
const active = channels.filter(c => c.role !== 'DISABLED');

// Build a channel picker dropdown
const select = document.getElementById('channel-select');
active.forEach(ch => {
    const opt = document.createElement('option');
    opt.value = ch.index;
    opt.textContent = `Ch ${ch.index}: ${ch.name}`;
    select.appendChild(opt);
});

const data = await fetch(
    '/api/metrics/averages?limit=48'
).then(r => r.json());

const history  = data.history.reverse(); // oldest first
const labels   = history.map(h =>
    new Date(h.timestamp * 1000).toLocaleTimeString()
);

new Chart(canvas, {
    type: 'line',
    data: {
        labels,
        datasets: [
            { label: 'Avg SNR (dB)',   data: history.map(h => h.average_snr)  },
            { label: 'Avg RSSI (dBm)', data: history.map(h => h.average_rssi) }
        ]
    }
});

{
  "plugin_id": "hello_mesh",
  "count":     12,
  "max":       250,
  "logs": [
    {"t": 1718000000.0, "lvl": "INFO",    "msg": "Plugin started"},
    {"t": 1718000030.0, "lvl": "DEBUG",   "msg": "Watchdog ping"},
    {"t": 1718000031.0, "lvl": "WARNING", "msg": "Something odd"},
    {"t": 1718000032.0, "lvl": "ERROR",   "msg": "Something broke"}
  ]
}

const es = new EventSource('/sse');

// React to new packets the instant they arrive
es.addEventListener('packet', e => {
    const pkt = JSON.parse(e.data);
    if (pkt.app_packet_type === 'Message') {
        addMessageToUI(pkt.fromId, pkt.decoded?.text, pkt.channel);
    }
    if (pkt.app_packet_type === 'Telemetry') {
        updateBatteryDisplay(pkt.fromId, pkt.decoded?.telemetry);
    }
});

// Node position updates for live map
es.addEventListener('node_update', e => {
    const node = JSON.parse(e.data);
    if (node.latitude && node.longitude)
        updateNodeOnMap(node.node_id, node.latitude, node.longitude);
});

// Track radio connection state
es.addEventListener('connection_status', e => {
    const status = JSON.parse(e.data);
    document.getElementById('status-badge').textContent = status;
    document.getElementById('status-badge').className =
        status === 'Connected' ? 'badge-green' : 'badge-red';
});

// Stats update periodically
es.addEventListener('stats', e => {
    const stats = JSON.parse(e.data);
    document.getElementById('pkt-count').textContent =
        stats.packets_received_session;
});

es.onerror = () => console.warn('SSE disconnected, auto-reconnecting…');