paygate-mcp 7.2.0 → 7.4.0

package/dist/server.js

@@ -231,6 +231,16 @@ class PayGateServer {
     scheduleTimer = null;
     /** Auto-incrementing schedule ID counter */
     nextScheduleId = 1;
+    /** Credit reservations (holds) */
+    creditReservations = new Map();
+    /** Auto-incrementing reservation ID counter */
+    nextReservationId = 1;
+    /** Request log — ring buffer of tool call entries */
+    requestLog = [];
+    /** Next request log entry ID */
+    nextRequestLogId = 1;
+    /** Max request log entries (ring buffer) */
+    maxRequestLogEntries = 5000;
     /** Number of in-flight /mcp requests */
     inflight = 0;
     /** Config file path for hot reload (null if not using config file) */
@@ -574,6 +584,26 @@ class PayGateServer {
                 res.writeHead(405, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ error: 'Method not allowed. Use GET.' }));
                 return;
+            case '/keys/reserve':
+                if (req.method === 'GET')
+                    return this.handleListReservations(req, res);
+                if (req.method === 'POST')
+                    return this.handleCreateReservation(req, res);
+                res.writeHead(405, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Method not allowed' }));
+                return;
+            case '/keys/reserve/commit':
+                if (req.method === 'POST')
+                    return this.handleCommitReservation(req, res);
+                res.writeHead(405, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Method not allowed. Use POST.' }));
+                return;
+            case '/keys/reserve/release':
+                if (req.method === 'POST')
+                    return this.handleReleaseReservation(req, res);
+                res.writeHead(405, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Method not allowed. Use POST.' }));
+                return;
             case '/keys/rotate':
                 return this.handleRotateKey(req, res);
             case '/keys/acl':
@@ -642,6 +672,12 @@ class PayGateServer {
                 return this.handleAuditExport(req, res);
             case '/audit/stats':
                 return this.handleAuditStats(req, res);
+            case '/requests':
+                if (req.method === 'GET')
+                    return this.handleRequestLog(req, res);
+                res.writeHead(405, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Method not allowed. Use GET.' }));
+                return;
             // ─── Registry / Discovery endpoints ──────────────────────────────
             case '/.well-known/mcp-payment':
                 return this.handlePaymentMetadata(req, res);
@@ -891,6 +927,7 @@ class PayGateServer {
             const pluginCtx = { apiKey, toolName, toolArgs, request };
             pluginRequest = await this.plugins.executeBeforeToolCall(pluginCtx);
         }
+        const toolCallStartTime = Date.now();
         let response = await this.handler.handleRequest(pluginRequest, apiKey, clientIp, scopedTokenTools);
         // Plugin: afterToolCall — let plugins modify the response
         if (this.plugins.count > 0 && request.method === 'tools/call') {
@@ -958,6 +995,49 @@ class PayGateServer {
                 }
             }
         }
+        // Record request log entry for tools/call
+        if (request.method === 'tools/call') {
+            const toolName = request.params?.name || 'unknown';
+            const durationMs = Date.now() - toolCallStartTime;
+            const isError = !!response.error;
+            let denyReason;
+            if (isError) {
+                const msg = response.error.message || '';
+                if (msg.includes('rate_limited'))
+                    denyReason = 'rate_limited';
+                else if (msg.includes('insufficient_credits'))
+                    denyReason = 'insufficient_credits';
+                else if (msg.includes('invalid_api_key'))
+                    denyReason = 'invalid_api_key';
+                else if (msg.includes('key_suspended'))
+                    denyReason = 'key_suspended';
+                else if (msg.includes('api_key_expired'))
+                    denyReason = 'api_key_expired';
+                else if (msg.includes('tool_not_allowed'))
+                    denyReason = 'tool_not_allowed';
+                else if (msg.includes('quota_exceeded'))
+                    denyReason = 'quota_exceeded';
+                else
+                    denyReason = msg || 'denied';
+            }
+            const creditsCharged = isError ? 0 : this.gate.getToolPrice(toolName, request.params?.arguments);
+            const logEntry = {
+                id: this.nextRequestLogId++,
+                timestamp: new Date().toISOString(),
+                tool: toolName,
+                key: (0, audit_1.maskKeyForAudit)(apiKey || 'anonymous'),
+                status: (isError ? 'denied' : 'allowed'),
+                credits: creditsCharged,
+                durationMs,
+                ...(denyReason ? { denyReason } : {}),
+                requestId,
+            };
+            this.requestLog.push(logEntry);
+            // Enforce ring buffer size
+            if (this.requestLog.length > this.maxRequestLogEntries) {
+                this.requestLog = this.requestLog.slice(-this.maxRequestLogEntries);
+            }
+        }
         // Build rate limit + credits headers for tools/call responses
         const rateLimitHeaders = this.buildRateLimitHeaders(apiKey, request);
         // Check if client accepts SSE
@@ -1214,6 +1294,8 @@ class PayGateServer {
                 keyNotes: 'GET /keys/notes?key=... — List notes + POST to add + DELETE to remove (requires X-Admin-Key)',
                 keySchedule: 'GET /keys/schedule?key=... — List schedules + POST to create + DELETE to cancel (requires X-Admin-Key)',
                 keyActivity: 'GET /keys/activity?key=... — Unified activity timeline for a key (requires X-Admin-Key)',
+                creditReservations: 'POST /keys/reserve to hold credits, POST /keys/reserve/commit to deduct, POST /keys/reserve/release to release, GET /keys/reserve to list (requires X-Admin-Key)',
+                requestLog: 'GET /requests — Queryable log of tool call requests with timing, credits, status (requires X-Admin-Key)',
                 ...(this.oauth ? {
                     oauthMetadata: 'GET /.well-known/oauth-authorization-server — OAuth 2.1 server metadata',
                     oauthRegister: 'POST /oauth/register — Register OAuth client',
@@ -4382,6 +4464,244 @@ class PayGateServer {
             events: page,
         }));
     }
+    // ─── /keys/reserve — Credit reservations (hold, commit, release) ─────────
+    handleListReservations(req, res) {
+        if (!this.checkAdmin(req, res))
+            return;
+        const urlParts = req.url?.split('?') || [];
+        const params = new URLSearchParams(urlParts[1] || '');
+        const keyParam = params.get('key');
+        // Clean up expired reservations first
+        this.cleanupExpiredReservations();
+        let reservations = [...this.creditReservations.values()];
+        if (keyParam) {
+            const record = this.gate.store.resolveKeyRaw(keyParam);
+            if (!record) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Key not found' }));
+                return;
+            }
+            reservations = reservations.filter(r => r.key === record.key);
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            reservations: reservations.map(r => ({
+                ...r,
+                key: (0, audit_1.maskKeyForAudit)(r.key),
+            })),
+            count: reservations.length,
+            totalHeld: reservations.reduce((sum, r) => sum + r.credits, 0),
+        }));
+    }
+    handleCreateReservation(req, res) {
+        if (!this.checkAdmin(req, res))
+            return;
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => {
+            let params;
+            try {
+                params = JSON.parse(body);
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON body' }));
+                return;
+            }
+            if (!params.key || typeof params.key !== 'string') {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing required field: key' }));
+                return;
+            }
+            if (!params.credits || typeof params.credits !== 'number' || params.credits <= 0) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing or invalid credits (must be positive number)' }));
+                return;
+            }
+            const record = this.gate.store.resolveKeyRaw(params.key);
+            if (!record) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Key not found' }));
+                return;
+            }
+            if (!record.active) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Key is revoked' }));
+                return;
+            }
+            if (record.suspended) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Key is suspended' }));
+                return;
+            }
+            // Cleanup expired before checking availability
+            this.cleanupExpiredReservations();
+            // Calculate available credits (total - held)
+            const heldCredits = this.getHeldCredits(record.key);
+            const available = record.credits - heldCredits;
+            if (params.credits > available) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    error: 'Insufficient available credits',
+                    available,
+                    held: heldCredits,
+                    total: record.credits,
+                    requested: params.credits,
+                }));
+                return;
+            }
+            // Max 50 active reservations per key
+            const keyReservations = [...this.creditReservations.values()].filter(r => r.key === record.key);
+            if (keyReservations.length >= 50) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Maximum 50 active reservations per key' }));
+                return;
+            }
+            const ttl = Math.min(3600, Math.max(10, params.ttlSeconds || 300)); // 10s – 1h, default 5m
+            const reservation = {
+                id: `rsv_${this.nextReservationId++}`,
+                key: record.key,
+                credits: params.credits,
+                createdAt: new Date().toISOString(),
+                expiresAt: new Date(Date.now() + ttl * 1000).toISOString(),
+                memo: params.memo?.slice(0, 200),
+            };
+            this.creditReservations.set(reservation.id, reservation);
+            this.audit.log('credits.reserved', 'admin', `Reserved ${params.credits} credits`, {
+                reservationId: reservation.id,
+                key: (0, audit_1.maskKeyForAudit)(record.key),
+                credits: params.credits,
+                ttlSeconds: ttl,
+            });
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                ...reservation,
+                key: (0, audit_1.maskKeyForAudit)(reservation.key),
+                available: available - params.credits,
+            }));
+        });
+    }
+    handleCommitReservation(req, res) {
+        if (!this.checkAdmin(req, res))
+            return;
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => {
+            let params;
+            try {
+                params = JSON.parse(body);
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON body' }));
+                return;
+            }
+            if (!params.reservationId || typeof params.reservationId !== 'string') {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing required field: reservationId' }));
+                return;
+            }
+            const reservation = this.creditReservations.get(params.reservationId);
+            if (!reservation) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Reservation not found (may have expired)' }));
+                return;
+            }
+            // Check if expired
+            if (new Date(reservation.expiresAt).getTime() <= Date.now()) {
+                this.creditReservations.delete(params.reservationId);
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Reservation has expired' }));
+                return;
+            }
+            const record = this.gate.store.resolveKeyRaw(reservation.key);
+            if (!record) {
+                this.creditReservations.delete(params.reservationId);
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Key not found' }));
+                return;
+            }
+            // Deduct credits
+            record.credits = Math.max(0, record.credits - reservation.credits);
+            this.gate.store.save();
+            // Remove reservation
+            this.creditReservations.delete(params.reservationId);
+            this.audit.log('credits.committed', 'admin', `Committed reservation: ${reservation.credits} credits deducted`, {
+                reservationId: reservation.id,
+                key: (0, audit_1.maskKeyForAudit)(record.key),
+                credits: reservation.credits,
+                remainingCredits: record.credits,
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                committed: {
+                    ...reservation,
+                    key: (0, audit_1.maskKeyForAudit)(reservation.key),
+                },
+                remainingCredits: record.credits,
+            }));
+        });
+    }
+    handleReleaseReservation(req, res) {
+        if (!this.checkAdmin(req, res))
+            return;
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => {
+            let params;
+            try {
+                params = JSON.parse(body);
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON body' }));
+                return;
+            }
+            if (!params.reservationId || typeof params.reservationId !== 'string') {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing required field: reservationId' }));
+                return;
+            }
+            const reservation = this.creditReservations.get(params.reservationId);
+            if (!reservation) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Reservation not found (may have expired)' }));
+                return;
+            }
+            // Remove reservation (release the hold)
+            this.creditReservations.delete(params.reservationId);
+            this.audit.log('credits.released', 'admin', `Released reservation: ${reservation.credits} credits freed`, {
+                reservationId: reservation.id,
+                key: (0, audit_1.maskKeyForAudit)(reservation.key),
+                credits: reservation.credits,
+            });
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                released: {
+                    ...reservation,
+                    key: (0, audit_1.maskKeyForAudit)(reservation.key),
+                },
+            }));
+        });
+    }
+    /** Get total held credits for a key across all active reservations. */
+    getHeldCredits(key) {
+        let held = 0;
+        for (const r of this.creditReservations.values()) {
+            if (r.key === key)
+                held += r.credits;
+        }
+        return held;
+    }
+    /** Remove expired reservations. */
+    cleanupExpiredReservations() {
+        const now = Date.now();
+        for (const [id, r] of this.creditReservations) {
+            if (new Date(r.expiresAt).getTime() <= now) {
+                this.creditReservations.delete(id);
+            }
+        }
+    }
     // ─── /config/reload — Hot reload configuration from file ─────────────────
     async handleConfigReload(req, res) {
         if (req.method !== 'POST') {
@@ -5961,6 +6281,65 @@ class PayGateServer {
             await this.redisSync.destroy();
         }
     }
+    // ─── /requests — Request Log (queryable tool call log) ──────────────────────
+    handleRequestLog(req, res) {
+        if (!this.checkAdmin(req, res))
+            return;
+        const urlParts = req.url?.split('?') || [];
+        const params = new URLSearchParams(urlParts[1] || '');
+        // Filters
+        const keyFilter = params.get('key');
+        const toolFilter = params.get('tool');
+        const statusFilter = params.get('status'); // 'allowed' | 'denied'
+        const sinceFilter = params.get('since');
+        const limit = Math.min(1000, Math.max(1, parseInt(params.get('limit') || '100', 10) || 100));
+        const offset = Math.max(0, parseInt(params.get('offset') || '0', 10) || 0);
+        let filtered = this.requestLog;
+        // Filter by key (partial match on masked key)
+        if (keyFilter) {
+            const kf = keyFilter.toLowerCase();
+            filtered = filtered.filter(e => e.key.toLowerCase().includes(kf));
+        }
+        // Filter by tool name (exact match)
+        if (toolFilter) {
+            filtered = filtered.filter(e => e.tool === toolFilter);
+        }
+        // Filter by status
+        if (statusFilter === 'allowed' || statusFilter === 'denied') {
+            filtered = filtered.filter(e => e.status === statusFilter);
+        }
+        // Filter by since timestamp
+        if (sinceFilter) {
+            const sinceTime = new Date(sinceFilter).getTime();
+            if (!isNaN(sinceTime)) {
+                filtered = filtered.filter(e => new Date(e.timestamp).getTime() >= sinceTime);
+            }
+        }
+        const total = filtered.length;
+        // Return newest first
+        const reversed = [...filtered].reverse();
+        const page = reversed.slice(offset, offset + limit);
+        // Compute summary stats
+        const totalAllowed = filtered.filter(e => e.status === 'allowed').length;
+        const totalDenied = filtered.filter(e => e.status === 'denied').length;
+        const totalCredits = filtered.reduce((sum, e) => sum + e.credits, 0);
+        const avgDurationMs = filtered.length > 0
+            ? Math.round(filtered.reduce((sum, e) => sum + e.durationMs, 0) / filtered.length)
+            : 0;
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            total,
+            offset,
+            limit,
+            summary: {
+                totalAllowed,
+                totalDenied,
+                totalCredits,
+                avgDurationMs,
+            },
+            requests: page,
+        }));
+    }
 }
 exports.PayGateServer = PayGateServer;
 //# sourceMappingURL=server.js.map