@trillboards/edge-sdk 0.2.1 → 0.2.3

package/dist/mcp-server.js

@@ -0,0 +1,1264 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * MCP Server for Trillboards Edge SDK
+ *
+ * A Model Context Protocol (MCP) server that allows AI agents to discover,
+ * configure, and diagnose edge devices. Communicates with the Edge Agent's
+ * StatusServer via HTTP (localhost:9090) using JSON-RPC 2.0 over stdio.
+ *
+ * Uses ONLY Node.js built-in modules — zero external dependencies.
+ *
+ * Claude Desktop config:
+ *   {
+ *     "mcpServers": {
+ *       "trillboards-edge": {
+ *         "command": "npx",
+ *         "args": ["-y", "@trillboards/edge-sdk", "mcp"],
+ *         "env": { "EDGE_STATUS_PORT": "9090" }
+ *       }
+ *     }
+ *   }
+ *
+ * Bin entry for package.json (to be added separately):
+ *   "trillboards-edge-mcp": "./dist/mcp-server.js"
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = main;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const readline = __importStar(require("readline"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process = __importStar(require("child_process"));
+// ─── Configuration ──────────────────────────────────────────────────────────
+const STATUS_PORT = parseInt(process.env.EDGE_STATUS_PORT || '9090', 10);
+const STATUS_HOST = process.env.EDGE_STATUS_HOST || 'localhost';
+const SERVER_VERSION = '0.2.3';
+const PROTOCOL_VERSION = '2024-11-05';
+const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10 MB
+// ─── JSON-RPC Error Codes ──────────────────────────────────────────────────
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const INTERNAL_ERROR = -32603;
+// ─── HTTP Helpers ──────────────────────────────────────────────────────────
+/**
+ * Fetch JSON from the local StatusServer.
+ * Uses Node.js built-in http module — no external dependencies.
+ */
+function fetchStatus(statusPath = '/status', port = STATUS_PORT) {
+    return new Promise((resolve, reject) => {
+        const req = http.get({
+            hostname: STATUS_HOST,
+            port,
+            path: statusPath,
+            timeout: 5000,
+            headers: { Accept: 'application/json' },
+        }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume(); // drain the response
+                reject(new Error(`StatusServer returned HTTP ${res.statusCode} for ${statusPath}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk.toString();
+            });
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(data));
+                }
+                catch {
+                    reject(new Error(`Invalid JSON from StatusServer: ${data.slice(0, 200)}`));
+                }
+            });
+        });
+        req.on('error', (err) => {
+            reject(new Error(`Cannot connect to Edge Agent StatusServer at ${STATUS_HOST}:${port} — ${err.message}. ` +
+                'Is the edge agent running? Start it with: trillboards-edge start --config trillboards.config.json'));
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error(`StatusServer request timed out after 5s (${STATUS_HOST}:${port}${statusPath})`));
+        });
+    });
+}
+/**
+ * POST JSON to the local StatusServer.
+ */
+function postToAgent(agentPath, body, port = STATUS_PORT) {
+    return new Promise((resolve, reject) => {
+        const payload = JSON.stringify(body);
+        const req = http.request({
+            hostname: STATUS_HOST,
+            port,
+            path: agentPath,
+            method: 'POST',
+            timeout: 10000,
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+            },
+        }, (res) => {
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk.toString();
+            });
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 400) {
+                    reject(new Error(`Agent returned HTTP ${res.statusCode}: ${data.slice(0, 500)}`));
+                    return;
+                }
+                try {
+                    resolve(data ? JSON.parse(data) : { ok: true });
+                }
+                catch {
+                    reject(new Error(`Invalid JSON response: ${data.slice(0, 200)}`));
+                }
+            });
+        });
+        req.on('error', (err) => {
+            reject(new Error(`Cannot POST to Edge Agent at ${STATUS_HOST}:${port}${agentPath} — ${err.message}`));
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error(`POST to ${agentPath} timed out after 10s`));
+        });
+        req.write(payload);
+        req.end();
+    });
+}
+// ─── Tool Definitions ──────────────────────────────────────────────────────
+const TOOL_DEFINITIONS = [
+    {
+        name: 'get-device-status',
+        description: 'Returns full device status from the Edge Agent StatusServer. ' +
+            'Includes device identity, capability tier, subsystem health, ' +
+            'sensing pipeline state, connection status, and uptime.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'get-audience-live',
+        description: 'Returns live audience sensing data from the edge device. ' +
+            'Includes face count, attention scores, VAS (Viewability Attention Score), ' +
+            'evidence grade, demographics, dwell time, and ambient conditions.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'configure-sensing',
+        description: 'Push configuration changes to the running edge agent. ' +
+            'Accepts a partial config object that will be deep-merged with the current config. ' +
+            'Use this to adjust sensing parameters, camera settings, model execution providers, etc.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                config: {
+                    type: 'object',
+                    description: 'Partial configuration to merge. Example: {"camera":{"fps":10},"models":{"executionProvider":"openvino"}}',
+                    additionalProperties: true,
+                },
+            },
+            required: ['config'],
+        },
+    },
+    {
+        name: 'run-benchmark',
+        description: 'Run a quick performance benchmark on the edge device. ' +
+            'Measures camera FPS, ML inference latency, memory usage, and dropped frames ' +
+            'over the specified duration.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                duration: {
+                    type: 'number',
+                    description: 'Benchmark duration in seconds. Default: 10. Min: 3, Max: 120.',
+                    minimum: 3,
+                    maximum: 120,
+                },
+            },
+        },
+    },
+    {
+        name: 'diagnose-hardware',
+        description: 'Run system diagnostics on the edge device. ' +
+            'Checks camera, audio, GPU/NPU, disk space, network, system temperature, ' +
+            'ONNX runtime, and model files. Returns structured pass/warn/fail results.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'list-models',
+        description: 'List installed ONNX models on the edge device. ' +
+            'Returns model names, file sizes, file paths, and whether each model is loaded.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'get-buffer-stats',
+        description: 'Get signal buffer statistics from the edge agent. ' +
+            'Shows buffered signal count, capacity, backend type (sqlite/json), ' +
+            'oldest/newest timestamps, and breakdown by evidence grade.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+];
+// ─── Tool Implementations ──────────────────────────────────────────────────
+async function toolGetDeviceStatus() {
+    const status = await fetchStatus('/status');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(status, null, 2),
+            },
+        ],
+    };
+}
+async function toolGetAudienceLive() {
+    const status = await fetchStatus('/status');
+    // Extract audience-relevant fields from the full status payload.
+    // The StatusServer exposes a flat status object; we cherry-pick sensing fields.
+    const audience = {
+        timestamp: Date.now(),
+        // Face detection
+        faceCount: status.faceCount ?? status.avgFaceCount ?? 0,
+        maxFaceCount: status.maxFaceCount ?? 0,
+        // Attention
+        attentionScore: status.avgAttention ?? status.attentionScore ?? 0,
+        // VAS (Viewability Attention Score)
+        vasRaw: status.vasRaw ?? 0,
+        vasWeighted: status.vasWeighted ?? 0,
+        vasQualityMultiplier: status.vasQualityMultiplier ?? 1,
+        // Evidence classification
+        observationFamily: status.observationFamily ?? 'EMPTY_SCENE',
+        evidenceGrade: status.evidenceGrade ?? 'EMPTY',
+        decisionability: status.decisionability ?? 'NON_DECISIONABLE',
+        decisionBlockReasons: status.decisionBlockReasons ?? [],
+        measurementQuality: status.measurementQuality ?? 'unknown',
+        // Demographics (on-device)
+        demographics: status.onDeviceDemographics ?? status.demographics ?? null,
+        // Dwell time
+        avgDwellTimeMs: status.avgDwellTimeMs ?? 0,
+        // Ambient
+        ambientLux: status.ambientLux ?? null,
+        dominantAmbience: status.dominantAmbience ?? null,
+        // Audio
+        avgNoiseLevel: status.avgNoiseLevel ?? 0,
+        speech: status.speech ?? false,
+        // Foot traffic
+        footTraffic: status.footTraffic ?? 0,
+        // Engagement
+        emotionalEngagement: status.emotionalEngagement ?? 0,
+        adReceptivityScore: status.adReceptivityScore ?? 0,
+        // Sensing mode
+        sensingMode: status.sensingMode ?? 'unknown',
+        // Quality telemetry
+        edgeQuality: status.edgeQuality ?? null,
+    };
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(audience, null, 2),
+            },
+        ],
+    };
+}
+async function toolConfigureSensing(params) {
+    const config = params.config;
+    if (!config || typeof config !== 'object') {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: 'Invalid parameters: "config" must be a non-null object with configuration fields to merge.',
+                },
+            ],
+        };
+    }
+    const result = await postToAgent('/config', config);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    success: true,
+                    message: 'Configuration update sent to edge agent.',
+                    applied: result,
+                }, null, 2),
+            },
+        ],
+    };
+}
+async function toolRunBenchmark(params) {
+    let duration = 10;
+    if (typeof params.duration === 'number') {
+        duration = Math.max(3, Math.min(120, Math.round(params.duration)));
+    }
+    // Request benchmark from the agent's StatusServer
+    const result = await postToAgent('/benchmark', { duration });
+    // If the agent returned benchmark data directly, use it.
+    // Otherwise, fall back to collecting from /status snapshots.
+    if (result &&
+        typeof result === 'object' &&
+        ('fps' in result || 'cameraFps' in result)) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    // Fallback: poll /status at start and end to compute deltas
+    const startStatus = await fetchStatus('/status');
+    await new Promise((resolve) => setTimeout(resolve, duration * 1000));
+    const endStatus = await fetchStatus('/status');
+    const startQuality = (startStatus.edgeQuality ?? {});
+    const endQuality = (endStatus.edgeQuality ?? {});
+    const startTotalFrames = asNumber(startQuality.totalFrames, 0);
+    const endTotalFrames = asNumber(endQuality.totalFrames, 0);
+    const framesDelta = endTotalFrames - startTotalFrames;
+    const startDropped = asNumber(startQuality.droppedFrames, 0);
+    const endDropped = asNumber(endQuality.droppedFrames, 0);
+    const droppedDelta = endDropped - startDropped;
+    const benchmark = {
+        durationSeconds: duration,
+        fps: framesDelta > 0 ? round(framesDelta / duration, 2) : asNumber(endQuality.cameraFps, 0),
+        avgInferenceLatencyMs: asNumber(endQuality.inferenceLatencyMs, 0),
+        memoryUsageMb: asNumber(endQuality.memoryUsageMb, 0),
+        cpuUsagePercent: asNumber(endQuality.cpuUsagePercent, 0),
+        droppedFrames: droppedDelta,
+        totalFrames: framesDelta,
+        faceDetectionConfidence: asNumber(endQuality.faceDetectionConfidence, 0),
+        audioClassificationConfidence: asNumber(endQuality.audioClassificationConfidence, 0),
+        modelLoadTimeMs: asNumber(endQuality.modelLoadTimeMs, 0),
+        timestamp: Date.now(),
+    };
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(benchmark, null, 2),
+            },
+        ],
+    };
+}
+async function toolDiagnoseHardware() {
+    const checks = [];
+    // 1. Edge Agent connectivity
+    try {
+        const status = await fetchStatus('/status');
+        checks.push({
+            name: 'edge-agent',
+            status: 'pass',
+            message: `Edge Agent running on ${STATUS_HOST}:${STATUS_PORT}`,
+            details: {
+                fingerprint: status.fingerprint ?? null,
+                platform: status.platform ?? null,
+                uptime: status.uptime ?? null,
+                tier: status.tier ?? status.capabilityTier ?? null,
+            },
+        });
+    }
+    catch (err) {
+        checks.push({
+            name: 'edge-agent',
+            status: 'fail',
+            message: err instanceof Error ? err.message : 'Cannot reach Edge Agent',
+        });
+        // If we cannot reach the agent, run local-only diagnostics
+        return buildDiagnosticResult(checks, true);
+    }
+    // 2. System memory
+    const totalMemMb = Math.round(os.totalmem() / (1024 * 1024));
+    const freeMemMb = Math.round(os.freemem() / (1024 * 1024));
+    const memUsedPct = round(((totalMemMb - freeMemMb) / totalMemMb) * 100, 1);
+    checks.push({
+        name: 'memory',
+        status: memUsedPct > 90 ? 'fail' : memUsedPct > 75 ? 'warn' : 'pass',
+        message: `${freeMemMb} MB free of ${totalMemMb} MB (${memUsedPct}% used)`,
+        details: {
+            totalMb: totalMemMb,
+            freeMb: freeMemMb,
+            usedPercent: memUsedPct,
+        },
+    });
+    // 3. CPU
+    const cpus = os.cpus();
+    checks.push({
+        name: 'cpu',
+        status: cpus.length >= 2 ? 'pass' : 'warn',
+        message: `${cpus.length} cores, ${cpus[0]?.model ?? 'unknown'}`,
+        details: {
+            cores: cpus.length,
+            model: cpus[0]?.model ?? 'unknown',
+            architecture: os.arch(),
+        },
+    });
+    // 4. Disk space (check data directory and models directory)
+    const dataDir = path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.trillboards');
+    const diskCheck = checkDiskSpace(dataDir);
+    checks.push(diskCheck);
+    // 5. Camera (V4L2 on Linux, or ask agent)
+    const cameraCheck = await checkCamera();
+    checks.push(cameraCheck);
+    // 6. Audio device
+    const audioCheck = checkAudio();
+    checks.push(audioCheck);
+    // 7. Network connectivity
+    const networkCheck = await checkNetwork();
+    checks.push(networkCheck);
+    // 8. ONNX models
+    const modelCheck = checkModels();
+    checks.push(modelCheck);
+    // 9. System temperature (Linux: /sys/class/thermal)
+    const tempCheck = checkTemperature();
+    checks.push(tempCheck);
+    // 10. Subsystem health from agent
+    try {
+        const status = await fetchStatus('/status');
+        const subsystemHealth = status.subsystemHealth;
+        if (subsystemHealth && typeof subsystemHealth === 'object') {
+            const failedSubsystems = [];
+            for (const [name, info] of Object.entries(subsystemHealth)) {
+                const sub = info;
+                if (sub.stale === true || sub.status === 'ERROR' || sub.status === 'CRITICAL' || sub.status === 'OFFLINE') {
+                    failedSubsystems.push(name);
+                }
+            }
+            checks.push({
+                name: 'subsystem-health',
+                status: failedSubsystems.length > 0 ? 'warn' : 'pass',
+                message: failedSubsystems.length > 0
+                    ? `Degraded subsystems: ${failedSubsystems.join(', ')}`
+                    : 'All subsystems healthy',
+                details: subsystemHealth,
+            });
+        }
+    }
+    catch {
+        // Already checked agent connectivity above; skip
+    }
+    return buildDiagnosticResult(checks, false);
+}
+async function toolListModels() {
+    const models = [];
+    // Try to get model info from the agent first
+    try {
+        const status = await fetchStatus('/status');
+        if (status.models && Array.isArray(status.models)) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ source: 'agent', models: status.models }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    catch {
+        // Agent not available — scan filesystem
+    }
+    // Scan common model directories
+    const modelDirs = [
+        './models',
+        path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.trillboards', 'models'),
+        '/opt/trillboards/models',
+    ];
+    for (const dir of modelDirs) {
+        const resolved = path.resolve(dir);
+        if (!fs.existsSync(resolved))
+            continue;
+        try {
+            const files = fs.readdirSync(resolved);
+            for (const file of files) {
+                if (!file.endsWith('.onnx'))
+                    continue;
+                const filePath = path.join(resolved, file);
+                try {
+                    const stat = fs.statSync(filePath);
+                    models.push({
+                        name: file.replace('.onnx', ''),
+                        filename: file,
+                        path: filePath,
+                        sizeMb: round(stat.size / (1024 * 1024), 2),
+                        lastModified: stat.mtime.toISOString(),
+                    });
+                }
+                catch {
+                    models.push({
+                        name: file.replace('.onnx', ''),
+                        filename: file,
+                        path: filePath,
+                        sizeMb: 0,
+                        lastModified: null,
+                        error: 'Cannot stat file',
+                    });
+                }
+            }
+        }
+        catch {
+            // Cannot read directory — skip
+        }
+    }
+    // Also check if the agent reports loaded models via status
+    let loadedModels = [];
+    try {
+        const status = await fetchStatus('/status');
+        if (status.loadedModels && Array.isArray(status.loadedModels)) {
+            loadedModels = status.loadedModels;
+        }
+    }
+    catch {
+        // Agent not reachable
+    }
+    // Annotate models with loaded status
+    for (const model of models) {
+        model.loaded = loadedModels.some((m) => m === model.name ||
+            m === model.filename ||
+            m.includes(model.name));
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    source: 'filesystem',
+                    modelCount: models.length,
+                    models,
+                }, null, 2),
+            },
+        ],
+    };
+}
+async function toolGetBufferStats() {
+    // Try to get buffer stats from the agent's StatusServer
+    try {
+        const status = await fetchStatus('/status');
+        const bufferStats = {};
+        // The agent exposes buffer stats in the status payload
+        if (status.signalBuffer && typeof status.signalBuffer === 'object') {
+            Object.assign(bufferStats, status.signalBuffer);
+        }
+        else {
+            // Extract buffer-related fields from flat status
+            bufferStats.bufferedCount = status.bufferedSignals ?? status.signalBufferCount ?? 0;
+            bufferStats.capacity = 8640; // SignalBuffer.MAX_CAPACITY
+            bufferStats.backend = status.signalBufferBackend ?? 'unknown';
+            bufferStats.oldestTimestampMs = status.signalBufferOldestMs ?? null;
+            bufferStats.newestTimestampMs = status.signalBufferNewestMs ?? null;
+            bufferStats.byEvidenceGrade = status.signalBufferByGrade ?? {};
+        }
+        // Add derived fields
+        const bufferedCount = asNumber(bufferStats.bufferedCount, 0);
+        const capacity = asNumber(bufferStats.capacity, 8640);
+        bufferStats.usagePercent = round((bufferedCount / capacity) * 100, 1);
+        bufferStats.remainingCapacity = capacity - bufferedCount;
+        // Add human-readable timestamps
+        const oldestMs = bufferStats.oldestTimestampMs;
+        const newestMs = bufferStats.newestTimestampMs;
+        if (typeof oldestMs === 'number' && oldestMs > 0) {
+            bufferStats.oldestSignalAge = humanDuration(Date.now() - oldestMs);
+            bufferStats.oldestTimestamp = new Date(oldestMs).toISOString();
+        }
+        if (typeof newestMs === 'number' && newestMs > 0) {
+            bufferStats.newestSignalAge = humanDuration(Date.now() - newestMs);
+            bufferStats.newestTimestamp = new Date(newestMs).toISOString();
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(bufferStats, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        // If agent is not reachable, try to read the buffer file directly
+        return readBufferFromDisk();
+    }
+}
+function buildDiagnosticResult(checks, agentOffline) {
+    const passCount = checks.filter((c) => c.status === 'pass').length;
+    const warnCount = checks.filter((c) => c.status === 'warn').length;
+    const failCount = checks.filter((c) => c.status === 'fail').length;
+    let overallStatus;
+    if (failCount > 0) {
+        overallStatus = 'critical';
+    }
+    else if (warnCount > 0) {
+        overallStatus = 'degraded';
+    }
+    else {
+        overallStatus = 'healthy';
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    overallStatus,
+                    agentReachable: !agentOffline,
+                    summary: `${passCount} pass, ${warnCount} warn, ${failCount} fail`,
+                    timestamp: new Date().toISOString(),
+                    checks,
+                }, null, 2),
+            },
+        ],
+    };
+}
+function checkDiskSpace(dirPath) {
+    try {
+        const resolved = path.resolve(dirPath);
+        if (!fs.existsSync(resolved)) {
+            return {
+                name: 'disk',
+                status: 'warn',
+                message: `Data directory does not exist: ${resolved}`,
+            };
+        }
+        // Use df to check disk space on the partition containing the directory.
+        // Falls back gracefully if df is not available (Windows).
+        try {
+            const dfOutput = child_process
+                .execSync(`df -k "${resolved}" 2>/dev/null`, {
+                encoding: 'utf-8',
+                timeout: 5000,
+            })
+                .trim();
+            const lines = dfOutput.split('\n');
+            if (lines.length >= 2) {
+                // df -k output: Filesystem 1K-blocks Used Available Use% Mounted-on
+                const parts = lines[1].split(/\s+/);
+                if (parts.length >= 5) {
+                    const totalKb = parseInt(parts[1], 10);
+                    const availableKb = parseInt(parts[3], 10);
+                    const usePct = parseInt(parts[4], 10);
+                    const totalGb = round(totalKb / (1024 * 1024), 1);
+                    const availGb = round(availableKb / (1024 * 1024), 1);
+                    return {
+                        name: 'disk',
+                        status: usePct > 95 ? 'fail' : usePct > 85 ? 'warn' : 'pass',
+                        message: `${availGb} GB free of ${totalGb} GB (${usePct}% used)`,
+                        details: {
+                            totalGb,
+                            availableGb: availGb,
+                            usedPercent: usePct,
+                            path: resolved,
+                        },
+                    };
+                }
+            }
+        }
+        catch {
+            // df not available (Windows) — try statvfs-like approach or just report directory exists
+        }
+        return {
+            name: 'disk',
+            status: 'pass',
+            message: `Data directory exists: ${resolved}`,
+            details: { path: resolved },
+        };
+    }
+    catch (err) {
+        return {
+            name: 'disk',
+            status: 'warn',
+            message: `Cannot check disk: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}
+async function checkCamera() {
+    // Linux: check for /dev/video* devices
+    if (process.platform === 'linux') {
+        try {
+            const videoDevices = [];
+            if (fs.existsSync('/dev')) {
+                const devFiles = fs.readdirSync('/dev');
+                for (const f of devFiles) {
+                    if (f.startsWith('video')) {
+                        videoDevices.push(`/dev/${f}`);
+                    }
+                }
+            }
+            if (videoDevices.length > 0) {
+                return {
+                    name: 'camera',
+                    status: 'pass',
+                    message: `Found ${videoDevices.length} V4L2 device(s): ${videoDevices.join(', ')}`,
+                    details: { devices: videoDevices },
+                };
+            }
+            return {
+                name: 'camera',
+                status: 'warn',
+                message: 'No V4L2 camera devices found in /dev/video*',
+            };
+        }
+        catch {
+            return {
+                name: 'camera',
+                status: 'warn',
+                message: 'Cannot enumerate camera devices',
+            };
+        }
+    }
+    // Windows/macOS: check via agent status
+    try {
+        const status = await fetchStatus('/status');
+        const subsystemHealth = status.subsystemHealth;
+        if (subsystemHealth) {
+            const cameraHealth = subsystemHealth.CAMERA;
+            if (cameraHealth) {
+                const cameraStatus = cameraHealth.status;
+                return {
+                    name: 'camera',
+                    status: cameraStatus === 'ACTIVE' ? 'pass' : cameraStatus === 'ERROR' ? 'fail' : 'warn',
+                    message: `Camera status: ${cameraStatus}`,
+                    details: cameraHealth,
+                };
+            }
+        }
+    }
+    catch {
+        // Agent not reachable
+    }
+    return {
+        name: 'camera',
+        status: 'warn',
+        message: 'Cannot determine camera status (agent not reachable or not Linux)',
+    };
+}
+function checkAudio() {
+    // Linux: check for PulseAudio or ALSA
+    if (process.platform === 'linux') {
+        try {
+            // Check if PulseAudio is running
+            try {
+                child_process.execSync('pactl info 2>/dev/null', {
+                    encoding: 'utf-8',
+                    timeout: 3000,
+                });
+                return {
+                    name: 'audio',
+                    status: 'pass',
+                    message: 'PulseAudio is running',
+                };
+            }
+            catch {
+                // PulseAudio not running, check ALSA
+            }
+            // Check ALSA devices
+            if (fs.existsSync('/proc/asound/cards')) {
+                const cards = fs.readFileSync('/proc/asound/cards', 'utf-8').trim();
+                if (cards.length > 0 && !cards.includes('--- no soundcards ---')) {
+                    return {
+                        name: 'audio',
+                        status: 'pass',
+                        message: 'ALSA audio devices detected',
+                        details: { cards: cards.split('\n').slice(0, 4) },
+                    };
+                }
+            }
+            return {
+                name: 'audio',
+                status: 'warn',
+                message: 'No audio devices detected',
+            };
+        }
+        catch {
+            return {
+                name: 'audio',
+                status: 'warn',
+                message: 'Cannot check audio subsystem',
+            };
+        }
+    }
+    // Non-Linux: basic check
+    return {
+        name: 'audio',
+        status: 'pass',
+        message: `Audio check skipped on ${process.platform} — relies on agent reporting`,
+    };
+}
+async function checkNetwork() {
+    return new Promise((resolve) => {
+        const req = https.get({
+            hostname: 'api.trillboards.com',
+            port: 443,
+            path: '/health/live',
+            timeout: 5000,
+        }, (res) => {
+            res.resume(); // drain
+            resolve({
+                name: 'network',
+                status: res.statusCode === 200 ? 'pass' : 'warn',
+                message: `Trillboards API reachable (HTTPS ${res.statusCode})`,
+                details: { statusCode: res.statusCode },
+            });
+        });
+        req.on('error', (err) => {
+            resolve({
+                name: 'network',
+                status: 'warn',
+                message: `Cannot reach Trillboards API: ${err.message}`,
+            });
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            resolve({
+                name: 'network',
+                status: 'warn',
+                message: 'Trillboards API connection timed out (5s)',
+            });
+        });
+    });
+}
+function checkModels() {
+    const modelDirs = [
+        './models',
+        path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.trillboards', 'models'),
+        '/opt/trillboards/models',
+    ];
+    const expectedModels = ['blazeface.onnx', 'yamnet.onnx'];
+    const found = [];
+    const missing = [];
+    let searchedDir = null;
+    for (const dir of modelDirs) {
+        const resolved = path.resolve(dir);
+        if (!fs.existsSync(resolved))
+            continue;
+        searchedDir = resolved;
+        for (const model of expectedModels) {
+            const modelPath = path.join(resolved, model);
+            if (fs.existsSync(modelPath)) {
+                found.push(model);
+            }
+        }
+        if (found.length > 0)
+            break;
+    }
+    for (const model of expectedModels) {
+        if (!found.includes(model)) {
+            missing.push(model);
+        }
+    }
+    if (found.length === expectedModels.length) {
+        return {
+            name: 'models',
+            status: 'pass',
+            message: `All ${found.length} required models found`,
+            details: { found, directory: searchedDir },
+        };
+    }
+    if (found.length > 0) {
+        return {
+            name: 'models',
+            status: 'warn',
+            message: `Found ${found.length}/${expectedModels.length} models, missing: ${missing.join(', ')}`,
+            details: { found, missing, directory: searchedDir },
+        };
+    }
+    return {
+        name: 'models',
+        status: 'warn',
+        message: `No ONNX models found. Run: trillboards-edge download-models`,
+        details: { searchedDirs: modelDirs.map((d) => path.resolve(d)) },
+    };
+}
+function checkTemperature() {
+    if (process.platform !== 'linux') {
+        return {
+            name: 'temperature',
+            status: 'pass',
+            message: `Temperature check skipped on ${process.platform}`,
+        };
+    }
+    try {
+        const thermalZones = [
+            '/sys/class/thermal/thermal_zone0/temp',
+            '/sys/class/thermal/thermal_zone1/temp',
+        ];
+        for (const zone of thermalZones) {
+            if (fs.existsSync(zone)) {
+                const raw = fs.readFileSync(zone, 'utf-8').trim();
+                const tempC = parseInt(raw, 10) / 1000;
+                return {
+                    name: 'temperature',
+                    status: tempC > 85 ? 'fail' : tempC > 70 ? 'warn' : 'pass',
+                    message: `CPU temperature: ${tempC.toFixed(1)}C`,
+                    details: { temperatureC: round(tempC, 1), source: zone },
+                };
+            }
+        }
+        return {
+            name: 'temperature',
+            status: 'pass',
+            message: 'No thermal zones found — temperature monitoring unavailable',
+        };
+    }
+    catch {
+        return {
+            name: 'temperature',
+            status: 'pass',
+            message: 'Cannot read thermal sensor',
+        };
+    }
+}
+function readBufferFromDisk() {
+    // Try to read the signal buffer file directly from the data directory.
+    // This is a last resort when the agent is not running.
+    const dataDir = path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.trillboards');
+    const sqlitePath = path.join(dataDir, 'signal_buffer.db');
+    const jsonPath = path.join(dataDir, 'signal_buffer.json');
+    if (fs.existsSync(jsonPath)) {
+        try {
+            const raw = fs.readFileSync(jsonPath, 'utf-8');
+            const data = JSON.parse(raw);
+            const signals = Array.isArray(data.signals) ? data.signals : [];
+            const timestamps = signals
+                .map((s) => s.timestamp)
+                .filter((t) => typeof t === 'number');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            source: 'disk-json',
+                            agentRunning: false,
+                            bufferedCount: signals.length,
+                            capacity: 8640,
+                            usagePercent: round((signals.length / 8640) * 100, 1),
+                            oldestTimestampMs: timestamps.length > 0 ? Math.min(...timestamps) : null,
+                            newestTimestampMs: timestamps.length > 0 ? Math.max(...timestamps) : null,
+                            filePath: jsonPath,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch {
+            // Corrupted JSON file
+        }
+    }
+    if (fs.existsSync(sqlitePath)) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        source: 'disk-sqlite',
+                        agentRunning: false,
+                        message: 'SQLite buffer exists but cannot be read without the agent running. ' +
+                            'Start the edge agent to get live buffer statistics.',
+                        filePath: sqlitePath,
+                        fileSizeMb: round(fs.statSync(sqlitePath).size / (1024 * 1024), 2),
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    source: 'none',
+                    agentRunning: false,
+                    bufferedCount: 0,
+                    message: 'No signal buffer found. The edge agent may not have been started yet.',
+                }, null, 2),
+            },
+        ],
+    };
+}
+// ─── Utility Functions ─────────────────────────────────────────────────────
+function asNumber(value, fallback) {
+    if (typeof value === 'number' && !Number.isNaN(value))
+        return value;
+    if (typeof value === 'string') {
+        const parsed = parseFloat(value);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return fallback;
+}
+function round(value, decimals) {
+    const factor = Math.pow(10, decimals);
+    return Math.round(value * factor) / factor;
+}
+function humanDuration(ms) {
+    if (ms < 0)
+        return '0s';
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${round(ms / 1000, 1)}s`;
+    if (ms < 3600000)
+        return `${round(ms / 60000, 1)}m`;
+    if (ms < 86400000)
+        return `${round(ms / 3600000, 1)}h`;
+    return `${round(ms / 86400000, 1)}d`;
+}
+// ─── MCP Method Handlers ───────────────────────────────────────────────────
+function handleInitialize(id) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: {
+                tools: {},
+            },
+            serverInfo: {
+                name: 'trillboards-edge-mcp',
+                version: SERVER_VERSION,
+            },
+        },
+    };
+}
+function handleToolsList(id) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+            tools: TOOL_DEFINITIONS,
+        },
+    };
+}
+async function handleToolsCall(id, params) {
+    if (!params || typeof params !== 'object') {
+        return makeErrorResponse(id, INVALID_PARAMS, 'Missing params for tools/call');
+    }
+    const callParams = params;
+    const toolName = callParams.name;
+    const toolArgs = callParams.arguments ?? {};
+    if (typeof toolName !== 'string') {
+        return makeErrorResponse(id, INVALID_PARAMS, 'Missing "name" in tools/call params');
+    }
+    const toolDef = TOOL_DEFINITIONS.find((t) => t.name === toolName);
+    if (!toolDef) {
+        return makeErrorResponse(id, INVALID_PARAMS, `Unknown tool: "${toolName}". Available tools: ${TOOL_DEFINITIONS.map((t) => t.name).join(', ')}`);
+    }
+    try {
+        let result;
+        switch (toolName) {
+            case 'get-device-status':
+                result = await toolGetDeviceStatus();
+                break;
+            case 'get-audience-live':
+                result = await toolGetAudienceLive();
+                break;
+            case 'configure-sensing':
+                result = await toolConfigureSensing(toolArgs);
+                break;
+            case 'run-benchmark':
+                result = await toolRunBenchmark(toolArgs);
+                break;
+            case 'diagnose-hardware':
+                result = await toolDiagnoseHardware();
+                break;
+            case 'list-models':
+                result = await toolListModels();
+                break;
+            case 'get-buffer-stats':
+                result = await toolGetBufferStats();
+                break;
+            default:
+                return makeErrorResponse(id, METHOD_NOT_FOUND, `Tool not implemented: ${toolName}`);
+        }
+        return {
+            jsonrpc: '2.0',
+            id,
+            result,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            jsonrpc: '2.0',
+            id,
+            result: {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error executing tool "${toolName}": ${message}`,
+                    },
+                ],
+                isError: true,
+            },
+        };
+    }
+}
+// ─── JSON-RPC Response Helpers ─────────────────────────────────────────────
+function makeErrorResponse(id, code, message, data) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        error: { code, message, ...(data !== undefined ? { data } : {}) },
+    };
+}
+// ─── Message Router ────────────────────────────────────────────────────────
+async function handleMessage(request) {
+    const { id, method, params } = request;
+    // Notifications (no id) do not require a response per JSON-RPC spec.
+    // MCP uses notifications for things like initialized, cancelled, etc.
+    if (id === undefined || id === null) {
+        // Handle known notifications silently
+        switch (method) {
+            case 'notifications/initialized':
+            case 'notifications/cancelled':
+            case 'initialized':
+                process.stderr.write(`[trillboards-edge-mcp] Notification: ${method}\n`);
+                return null; // No response for notifications
+            default:
+                process.stderr.write(`[trillboards-edge-mcp] Unknown notification: ${method}\n`);
+                return null;
+        }
+    }
+    switch (method) {
+        case 'initialize':
+            return handleInitialize(id);
+        case 'tools/list':
+            return handleToolsList(id);
+        case 'tools/call':
+            return await handleToolsCall(id, params);
+        case 'ping':
+            return { jsonrpc: '2.0', id, result: {} };
+        default:
+            return makeErrorResponse(id, METHOD_NOT_FOUND, `Unknown method: ${method}`);
+    }
+}
+// ─── Main — stdio JSON-RPC transport ───────────────────────────────────────
+async function main() {
+    process.stderr.write(`[trillboards-edge-mcp] MCP server v${SERVER_VERSION} starting (StatusServer: ${STATUS_HOST}:${STATUS_PORT})\n`);
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+    let buffer = '';
+    rl.on('line', async (line) => {
+        buffer += line;
+        // Guard against unbounded buffer growth
+        if (buffer.length > MAX_BUFFER_SIZE) {
+            process.stderr.write('[trillboards-edge-mcp] Buffer exceeded 10 MB -- resetting\n');
+            buffer = '';
+            return;
+        }
+        // Try to parse the accumulated buffer as JSON.
+        // MCP clients send one JSON-RPC message per line.
+        let request;
+        try {
+            request = JSON.parse(buffer);
+            buffer = '';
+        }
+        catch {
+            // Incomplete JSON — keep buffering across lines
+            return;
+        }
+        // Validate JSON-RPC 2.0 structure
+        if (request.jsonrpc !== '2.0') {
+            const errorResp = makeErrorResponse(request.id ?? null, INVALID_REQUEST, 'Expected jsonrpc: "2.0"');
+            process.stdout.write(JSON.stringify(errorResp) + '\n');
+            return;
+        }
+        if (typeof request.method !== 'string') {
+            const errorResp = makeErrorResponse(request.id ?? null, INVALID_REQUEST, 'Missing "method" field');
+            process.stdout.write(JSON.stringify(errorResp) + '\n');
+            return;
+        }
+        try {
+            const response = await handleMessage(request);
+            // Notifications return null — do not send a response
+            if (response !== null) {
+                process.stdout.write(JSON.stringify(response) + '\n');
+            }
+        }
+        catch (err) {
+            // Catch-all: never crash the server
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[trillboards-edge-mcp] Unhandled error: ${message}\n`);
+            const errorResp = makeErrorResponse(request.id ?? null, INTERNAL_ERROR, `Internal server error: ${message}`);
+            process.stdout.write(JSON.stringify(errorResp) + '\n');
+        }
+    });
+    rl.on('close', () => {
+        process.stderr.write('[trillboards-edge-mcp] stdin closed, exiting\n');
+        process.exit(0);
+    });
+    // Handle process signals gracefully
+    process.on('SIGINT', () => {
+        process.stderr.write('[trillboards-edge-mcp] SIGINT received, exiting\n');
+        process.exit(0);
+    });
+    process.on('SIGTERM', () => {
+        process.stderr.write('[trillboards-edge-mcp] SIGTERM received, exiting\n');
+        process.exit(0);
+    });
+    // Prevent unhandled promise rejections from crashing the process
+    process.on('unhandledRejection', (reason) => {
+        const message = reason instanceof Error ? reason.message : String(reason);
+        process.stderr.write(`[trillboards-edge-mcp] Unhandled rejection: ${message}\n`);
+    });
+}
+// Auto-start when run directly
+if (require.main === module) {
+    main().catch((err) => {
+        process.stderr.write(`[trillboards-edge-mcp] Fatal error: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=mcp-server.js.map