@jagilber-org/index-server 1.22.1 → 1.26.1

package/dist/dashboard/server/HttpTransport.js

@@ -50,6 +50,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMcpTransportRoutes = createMcpTransportRoutes;
 const express_1 = __importStar(require("express"));
 const registry_1 = require("../../server/registry");
+const logger_1 = require("../../services/logger");
+const auditLog_1 = require("../../services/auditLog");
 /**
  * Create an Express router for the MCP HTTP transport.
  */
@@ -105,6 +107,10 @@ function createMcpTransportRoutes(options = {}) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : 'Internal error';
+            const stack = error instanceof Error ? error.stack : undefined;
+            const errorType = error instanceof Error ? error.constructor.name : typeof error;
+            (0, logger_1.log)('ERROR', `[HttpTransport] RPC handler error for method '${method}': ${message}`, { detail: stack });
+            (0, auditLog_1.logAudit)('rpc_error', method, { error: message, errorType, stack: stack?.slice(0, 500), requestId: id ?? null }, 'http');
             res.status(500).json({
                 jsonrpc: '2.0',
                 error: { code: -32603, message },

package/dist/dashboard/server/InstanceManager.js

@@ -212,8 +212,13 @@ function pingInstance(host, port, protocol = 'http', timeoutMs = 3000) {
                 tlsOpts.ca = fs_1.default.readFileSync(caPath);
             }
             else {
-                // Localhost health-check against self-signed certs when no CA configured
-                tlsOpts.rejectUnauthorized = false; // lgtm[js/disabling-certificate-validation] — localhost self-signed cert
+                // No trusted CA configured. Do NOT disable certificate verification
+                // in production code — instead, skip the HTTPS reachability probe
+                // entirely. The earlier isProcessAlive() PID check still ensures the
+                // owning process exists; treat the instance as alive and defer
+                // liveness validation to the next iteration once a CA is configured.
+                resolve(true);
+                return;
             }
         }
         const opts = {

package/dist/dashboard/server/KnowledgeStore.js

@@ -16,6 +16,7 @@ exports.createKnowledgeStore = createKnowledgeStore;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const runtimeConfig_1 = require("../../config/runtimeConfig");
+const logger_js_1 = require("../../services/logger.js");
 class KnowledgeStore {
     entries = new Map();
     filePath;
@@ -36,7 +37,9 @@ class KnowledgeStore {
                 }
             }
         }
-        catch { /* ignore corrupt/missing file */ }
+        catch (error) {
+            (0, logger_js_1.logWarn)('[KnowledgeStore] Failed to load persisted knowledge store', error);
+        }
     }
     saveToDisk() {
         try {
@@ -45,7 +48,9 @@ class KnowledgeStore {
                 fs_1.default.mkdirSync(dir, { recursive: true });
             fs_1.default.writeFileSync(this.filePath, JSON.stringify(Array.from(this.entries.values()), null, 2));
         }
-        catch { /* ignore write errors */ }
+        catch (error) {
+            (0, logger_js_1.logWarn)('[KnowledgeStore] Failed to persist knowledge store', error);
+        }
     }
     upsert(key, content, metadata = {}) {
         const now = new Date().toISOString();

package/dist/dashboard/server/MetricsCollector.d.ts

@@ -10,6 +10,7 @@ export type { ToolMetrics, ServerMetrics, ConnectionMetrics, MetricsSnapshot, Me
 import { type ToolMetrics, type MetricsSnapshot, type MetricsTimeSeriesEntry, type ToolCallEvent, type RealtimeMetrics, type RealtimeStreamingData, type SystemHealth, type EnhancedPerformanceMetrics, type AdvancedAnalytics, type Alert, type MetricsCollectorOptions, type ResourceSample } from './metricsAggregation.js';
 import type { ToolUsageChartData, PerformanceChartData, ToolUsageStats } from './metricsAggregation.js';
 export declare class MetricsCollector {
+    private persistenceHealth;
     private tools;
     private resourceSamples;
     private lastCpuUsageSample;
@@ -46,6 +47,19 @@ export declare class MetricsCollector {
     private appendFlushMs;
     private appendCompactMs;
     constructor(options?: MetricsCollectorOptions);
+    private formatPersistenceError;
+    private recordPersistenceFailure;
+    private recordPersistenceRecovery;
+    getPersistenceHealth(): {
+        degraded: boolean;
+        totalFailures: number;
+        appendFailures: number;
+        snapshotFailures: number;
+        truncateFailures: number;
+        lastError?: string;
+        lastFailureAt?: number;
+        lastRecoveredAt?: number;
+    };
     /**
      * Record a tool call event
      */
@@ -85,6 +99,7 @@ export declare class MetricsCollector {
         oldestTimestamp?: number;
         newestTimestamp?: number;
         memorySnapshots: number;
+        persistence: ReturnType<MetricsCollector['getPersistenceHealth']>;
     }>;
     /**
      * Get tool-specific metrics
@@ -176,6 +191,7 @@ export declare class MetricsCollector {
             toolCallEvents: BufferRingStats;
             performanceMetrics: BufferRingStats;
         };
+        persistence: ReturnType<MetricsCollector['getPersistenceHealth']>;
         historicalSnapshots?: MetricsTimeSeriesEntry[];
         toolCallEvents?: ToolCallEvent[];
         performanceMetrics?: Array<{

package/dist/dashboard/server/MetricsCollector.js

@@ -23,6 +23,16 @@ const logger_js_1 = require("../../services/logger.js");
 const metricsAggregation_js_1 = require("./metricsAggregation.js");
 const metricsSerializer_js_1 = require("./metricsSerializer.js");
 class MetricsCollector {
+    persistenceHealth = {
+        degraded: false,
+        totalFailures: 0,
+        appendFailures: 0,
+        snapshotFailures: 0,
+        truncateFailures: 0,
+        lastError: undefined,
+        lastFailureAt: undefined,
+        lastRecoveredAt: undefined,
+    };
     tools = new Map();
     // Resource usage samples (CPU/Memory) for leak/trend analysis
     resourceSamples;
@@ -139,7 +149,7 @@ class MetricsCollector {
                         try {
                             const stat = fs_1.default.statSync(this.appendLogPath);
                             if (stat.size < 25 * 1024 * 1024) { // safety cap 25MB
-                                const raw = fs_1.default.readFileSync(this.appendLogPath, 'utf8');
+                                const raw = fs_1.default.readFileSync(this.appendLogPath, 'utf8'); // lgtm[js/file-system-race] — appendLogPath is config-controlled metrics path; statSync above bounds size
                                 const lines = raw.split(/\r?\n/).filter(l => l.trim().length > 0);
                                 for (const line of lines) {
                                     try {
@@ -179,6 +189,49 @@ class MetricsCollector {
         // Start periodic collection
         this.startCollection();
     }
+    formatPersistenceError(error) {
+        if (error instanceof Error) {
+            return error.stack ?? error.message;
+        }
+        return String(error);
+    }
+    recordPersistenceFailure(operation, error) {
+        this.persistenceHealth.degraded = true;
+        this.persistenceHealth.totalFailures += 1;
+        this.persistenceHealth.lastError = this.formatPersistenceError(error);
+        this.persistenceHealth.lastFailureAt = Date.now();
+        if (operation === 'append') {
+            this.persistenceHealth.appendFailures += 1;
+        }
+        else if (operation === 'truncate') {
+            this.persistenceHealth.truncateFailures += 1;
+        }
+        else {
+            this.persistenceHealth.snapshotFailures += 1;
+        }
+        if (this.persistenceHealth.totalFailures === 1 || this.persistenceHealth.lastRecoveredAt !== undefined) {
+            (0, logger_js_1.logWarn)('[MetricsCollector] Metrics persistence degraded; in-memory buffers will retry writes', {
+                operation,
+                error: this.persistenceHealth.lastError,
+                totalFailures: this.persistenceHealth.totalFailures,
+            });
+            this.persistenceHealth.lastRecoveredAt = undefined;
+        }
+    }
+    recordPersistenceRecovery(operation) {
+        if (!this.persistenceHealth.degraded)
+            return;
+        this.persistenceHealth.degraded = false;
+        this.persistenceHealth.lastError = undefined;
+        this.persistenceHealth.lastRecoveredAt = Date.now();
+        (0, logger_js_1.logInfo)('[MetricsCollector] Metrics persistence recovered', {
+            operation,
+            totalFailures: this.persistenceHealth.totalFailures,
+        });
+    }
+    getPersistenceHealth() {
+        return { ...this.persistenceHealth };
+    }
     /**
      * Record a tool call event
      */
@@ -225,10 +278,18 @@ class MetricsCollector {
                 this._pendingToolPersist++;
                 const dueTime = now - this._lastToolPersist > this.appendFlushMs;
                 if (this._pendingToolPersist >= this.appendChunkSize || dueTime) {
+                    const pendingAtSchedule = this._pendingToolPersist;
                     setTimeout(() => {
-                        this.toolCallEvents.saveToDisk().catch(() => { });
-                        this._lastToolPersist = Date.now();
-                        this._pendingToolPersist = 0;
+                        this.toolCallEvents.saveToDisk()
+                            .then(() => {
+                            this._lastToolPersist = Date.now();
+                            this._pendingToolPersist = Math.max(0, this._pendingToolPersist - pendingAtSchedule);
+                            this.recordPersistenceRecovery('snapshot');
+                        })
+                            .catch((error) => {
+                            this._pendingToolPersist = Math.max(this._pendingToolPersist, pendingAtSchedule);
+                            this.recordPersistenceFailure('snapshot', error);
+                        });
                     }, 0).unref?.();
                 }
             }
@@ -267,23 +328,54 @@ class MetricsCollector {
                 return;
             const toWrite = this.pendingAppendEvents.splice(0, this.pendingAppendEvents.length);
             const lines = toWrite.map(e => JSON.stringify(e)).join('\n') + '\n';
-            fs_1.default.promises.appendFile(this.appendLogPath, lines).catch(() => { });
-            this.lastAppendFlush = now;
-            // Periodic compaction: write full snapshot & truncate log
-            if ((now - this.lastAppendCompact) >= this.appendCompactMs || force) {
-                this.toolCallEvents.saveToDisk().catch(() => { });
-                this.lastAppendCompact = now;
+            const shouldCompact = (now - this.lastAppendCompact) >= this.appendCompactMs || force;
+            void fs_1.default.promises.appendFile(this.appendLogPath, lines)
+                .then(async () => {
+                this.lastAppendFlush = now;
+                if (!shouldCompact) {
+                    this.recordPersistenceRecovery('append');
+                    return;
+                }
+                try {
+                    await this.toolCallEvents.saveToDisk();
+                    this.lastAppendCompact = now;
+                }
+                catch (error) {
+                    this.recordPersistenceFailure('snapshot', error);
+                    return;
+                }
                 if (this.appendLogPath) {
-                    fs_1.default.promises.writeFile(this.appendLogPath, '').catch(() => { }); // truncate
+                    try {
+                        await fs_1.default.promises.writeFile(this.appendLogPath, '');
+                    }
+                    catch (error) {
+                        this.recordPersistenceFailure('truncate', error);
+                        return;
+                    }
                 }
-            }
+                this.recordPersistenceRecovery('append');
+            })
+                .catch((error) => {
+                this.pendingAppendEvents.unshift(...toWrite);
+                this.lastAppendFlush = 0;
+                this.recordPersistenceFailure('append', error);
+            });
+            // Periodic compaction: write full snapshot & truncate log
         }
         else {
             // snapshot mode manual force
             if (force) {
-                this.toolCallEvents.saveToDisk().catch(() => { });
-                this._lastToolPersist = now;
-                this._pendingToolPersist = 0;
+                const pendingAtForce = Math.max(this._pendingToolPersist, 1);
+                void this.toolCallEvents.saveToDisk()
+                    .then(() => {
+                    this._lastToolPersist = now;
+                    this._pendingToolPersist = Math.max(0, this._pendingToolPersist - pendingAtForce);
+                    this.recordPersistenceRecovery('snapshot');
+                })
+                    .catch((error) => {
+                    this._pendingToolPersist = Math.max(this._pendingToolPersist, pendingAtForce);
+                    this.recordPersistenceFailure('snapshot', error);
+                });
             }
         }
     }
@@ -430,12 +522,14 @@ class MetricsCollector {
                 fileCount: 0,
                 totalSizeKB: 0,
                 memorySnapshots: this.snapshots.length,
+                persistence: this.getPersistenceHealth(),
             };
         }
         const fileStats = await this.fileStorage.getStorageStats();
         return {
             ...fileStats,
             memorySnapshots: this.snapshots.length,
+            persistence: this.getPersistenceHealth(),
         };
     }
     /**
@@ -605,6 +699,7 @@ class MetricsCollector {
     getSystemHealth() {
         const cpu = (0, metricsAggregation_js_1.estimateCPUUsage)(this.snapshots.slice(-5));
         const memory = (0, metricsAggregation_js_1.estimateMemoryUsage)(this.connections.size, this.snapshots.length);
+        const baseStatus = (0, metricsAggregation_js_1.getOverallHealthStatus)(cpu, memory, (0, metricsAggregation_js_1.getErrorRate)(this.tools));
         return {
             cpuUsage: cpu,
             memoryUsage: memory,
@@ -612,7 +707,7 @@ class MetricsCollector {
             networkLatency: (0, metricsAggregation_js_1.getAverageResponseTime)(this.tools),
             uptime: Date.now() - this.startTime,
             lastHealthCheck: new Date(),
-            status: (0, metricsAggregation_js_1.getOverallHealthStatus)(cpu, memory, (0, metricsAggregation_js_1.getErrorRate)(this.tools)),
+            status: this.persistenceHealth.degraded && baseStatus === 'healthy' ? 'warning' : baseStatus,
         };
     }
     getDetailedPerformanceMetrics() {
@@ -765,7 +860,8 @@ class MetricsCollector {
         const data = {
             timestamp: Date.now(),
             currentSnapshot: this.getCurrentSnapshot(),
-            bufferStats: this.getBufferRingStats()
+            bufferStats: this.getBufferRingStats(),
+            persistence: this.getPersistenceHealth(),
         };
         const result = data;
         if (options.includeHistorical !== false) {

package/dist/dashboard/server/legacyDashboardHtml.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable */
 /**
  * legacyDashboardHtml - generates the v1 legacy dashboard HTML page.
  * Extracted from DashboardServer.ts to keep the coordinator within line limits.
@@ -13,8 +12,14 @@ const legacyDashboardStyles_js_1 = require("./legacyDashboardStyles.js");
 // ---------------------------------------------------------------------------
 // stripGraphTab - removes graph-related markup when the graph feature is off
 // ---------------------------------------------------------------------------
+// NOTE: These regexes operate on dashboard HTML built in this module from
+// trusted constants — never on user input. The patterns are intentional
+// targeted strips (matching specific data-section, comment markers, and the
+// admin.graph.js script src) rather than a general HTML sanitizer.
+// CodeQL bad-tag-filter / incomplete-multi-character-sanitization queries
+// are suppressed for this file via .github/codeql/codeql-config.yml.
 function stripGraphTab(html) {
-    html = html.replace(/<button[^>]*data-section="graph"[^>]*>Graph<\/button>\s*/i, ""); // lgtm[js/incomplete-multi-character-sanitization] — stripping graph tab, not sanitization
+    html = html.replace(/<button[^>]*data-section="graph"[^>]*>Graph<\/button>\s*/i, "");
     html = html.replace(/<!--\s*Graph Section\s*-->[\s\S]*?(?=<!--\s*Configuration Section\s*-->)/i, "");
     html = html.replace(/<script[^>]*src="js\/admin\.graph\.js[^"]*"[^>]*><\/script>\s*/i, "");
     return html;

package/dist/dashboard/server/middleware/ensureLoadedMiddleware.d.ts

@@ -22,4 +22,4 @@ export interface IndexLocals {
  * Middleware that eagerly loads the instruction index once per request.
  * Attach to any router whose handlers need index state.
  */
-export declare function ensureLoadedMiddleware(_req: Request, res: Response, next: NextFunction): void;
+export declare function ensureLoadedMiddleware(_req: Request, res: Response, next: NextFunction): Promise<void>;

package/dist/dashboard/server/middleware/ensureLoadedMiddleware.js

@@ -18,7 +18,12 @@ const indexContext_js_1 = require("../../../services/indexContext.js");
  * Middleware that eagerly loads the instruction index once per request.
  * Attach to any router whose handlers need index state.
  */
-function ensureLoadedMiddleware(_req, res, next) {
-    res.locals.indexState = (0, indexContext_js_1.ensureLoaded)();
-    next();
+async function ensureLoadedMiddleware(_req, res, next) {
+    try {
+        res.locals.indexState = await (0, indexContext_js_1.ensureLoadedAsync)();
+        next();
+    }
+    catch (error) {
+        next(error);
+    }
 }

package/dist/dashboard/server/routes/admin.feedback.routes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Admin Feedback CRUD Routes — Human-operator management of persisted feedback entries.
+ *
+ * Routes:
+ *   GET    /admin/feedback       — list all entries
+ *   POST   /admin/feedback       — create a new entry
+ *   GET    /admin/feedback/:id   — get a single entry
+ *   PATCH  /admin/feedback/:id   — update entry fields (e.g., status)
+ *   DELETE /admin/feedback/:id   — remove an entry
+ *
+ * Storage: shared via src/services/feedbackStorage.ts (no I/O duplication with MCP layer).
+ * This surface is NOT the webhook/external-connector surface in api.feedback.routes.ts.
+ */
+import { Router } from 'express';
+export declare function createAdminFeedbackRoutes(): Router;

package/dist/dashboard/server/routes/admin.feedback.routes.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * Admin Feedback CRUD Routes — Human-operator management of persisted feedback entries.
+ *
+ * Routes:
+ *   GET    /admin/feedback       — list all entries
+ *   POST   /admin/feedback       — create a new entry
+ *   GET    /admin/feedback/:id   — get a single entry
+ *   PATCH  /admin/feedback/:id   — update entry fields (e.g., status)
+ *   DELETE /admin/feedback/:id   — remove an entry
+ *
+ * Storage: shared via src/services/feedbackStorage.ts (no I/O duplication with MCP layer).
+ * This surface is NOT the webhook/external-connector surface in api.feedback.routes.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdminFeedbackRoutes = createAdminFeedbackRoutes;
+const express_1 = require("express");
+const adminAuth_js_1 = require("./adminAuth.js");
+const feedbackStorage_js_1 = require("../../../services/feedbackStorage.js");
+const auditLog_js_1 = require("../../../services/auditLog.js");
+const VALID_TYPES = new Set([
+    'issue', 'status', 'security', 'feature-request',
+    'bug-report', 'performance', 'usability', 'other',
+]);
+const VALID_SEVERITIES = new Set(['low', 'medium', 'high', 'critical']);
+const VALID_STATUSES = new Set(['new', 'acknowledged', 'in-progress', 'resolved', 'closed']);
+const MAX_TITLE_LENGTH = 200;
+const MAX_DESCRIPTION_LENGTH = 10_000;
+const MAX_TAGS = 10;
+function sanitizeTags(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const tags = value
+        .filter((tag) => typeof tag === 'string')
+        .map(tag => tag.trim())
+        .filter(Boolean)
+        .slice(0, MAX_TAGS);
+    return tags.length > 0 ? tags : undefined;
+}
+function createAdminFeedbackRoutes() {
+    const router = (0, express_1.Router)();
+    /** GET /admin/feedback — list all persisted feedback entries */
+    router.get('/admin/feedback', adminAuth_js_1.dashboardAdminAuth, (_req, res) => {
+        try {
+            const storage = (0, feedbackStorage_js_1.loadFeedbackStorage)();
+            res.json({
+                entries: storage.entries,
+                total: storage.entries.length,
+                lastUpdated: storage.lastUpdated,
+            });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to load feedback entries', message: String(error) });
+        }
+    });
+    /** POST /admin/feedback — create a new feedback entry */
+    router.post('/admin/feedback', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const body = req.body;
+            const { type, severity, title, description } = body;
+            if (!title || typeof title !== 'string' || !title.trim()) {
+                res.status(400).json({ error: 'Missing required field: title' });
+                return;
+            }
+            if (!type || !VALID_TYPES.has(String(type))) {
+                res.status(400).json({
+                    error: `Missing or invalid field: type. Must be one of: ${[...VALID_TYPES].join(', ')}`,
+                });
+                return;
+            }
+            if (!severity || !VALID_SEVERITIES.has(String(severity))) {
+                res.status(400).json({
+                    error: `Missing or invalid field: severity. Must be one of: ${[...VALID_SEVERITIES].join(', ')}`,
+                });
+                return;
+            }
+            const timestamp = new Date().toISOString();
+            const id = (0, feedbackStorage_js_1.generateFeedbackId)(String(type), timestamp);
+            const entry = {
+                id,
+                timestamp,
+                type: type,
+                severity: severity,
+                title: title.trim().slice(0, MAX_TITLE_LENGTH),
+                description: description ? String(description).slice(0, MAX_DESCRIPTION_LENGTH) : '',
+                status: 'new',
+            };
+            const tags = sanitizeTags(body.tags);
+            if (tags)
+                entry.tags = tags;
+            if (body.metadata && typeof body.metadata === 'object') {
+                entry.metadata = body.metadata;
+            }
+            const storage = (0, feedbackStorage_js_1.loadFeedbackStorage)();
+            storage.entries.push(entry);
+            (0, feedbackStorage_js_1.saveFeedbackStorage)(storage);
+            (0, auditLog_js_1.logAudit)('admin/feedback/create', [id], { title: entry.title, type: entry.type });
+            res.status(201).json(entry);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to create feedback entry', message: String(error) });
+        }
+    });
+    /** GET /admin/feedback/:id — retrieve a single entry by id */
+    router.get('/admin/feedback/:id', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const { id } = req.params;
+            const storage = (0, feedbackStorage_js_1.loadFeedbackStorage)();
+            const entry = storage.entries.find(e => e.id === id);
+            if (!entry) {
+                res.status(404).json({ error: `Feedback entry not found: ${id}` });
+                return;
+            }
+            res.json(entry);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to get feedback entry', message: String(error) });
+        }
+    });
+    /** PATCH /admin/feedback/:id — update mutable fields on an entry */
+    router.patch('/admin/feedback/:id', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const { id } = req.params;
+            const body = req.body;
+            const storage = (0, feedbackStorage_js_1.loadFeedbackStorage)();
+            const idx = storage.entries.findIndex(e => e.id === id);
+            if (idx === -1) {
+                res.status(404).json({ error: `Feedback entry not found: ${id}` });
+                return;
+            }
+            const entry = { ...storage.entries[idx] };
+            if (body.status !== undefined) {
+                if (!VALID_STATUSES.has(String(body.status))) {
+                    res.status(400).json({
+                        error: `Invalid status. Must be one of: ${[...VALID_STATUSES].join(', ')}`,
+                    });
+                    return;
+                }
+                entry.status = body.status;
+            }
+            if (body.title !== undefined && typeof body.title === 'string') {
+                entry.title = body.title.trim().slice(0, MAX_TITLE_LENGTH);
+            }
+            if (body.description !== undefined && typeof body.description === 'string') {
+                entry.description = body.description.slice(0, MAX_DESCRIPTION_LENGTH);
+            }
+            if (body.severity !== undefined) {
+                if (!VALID_SEVERITIES.has(String(body.severity))) {
+                    res.status(400).json({
+                        error: `Invalid severity. Must be one of: ${[...VALID_SEVERITIES].join(', ')}`,
+                    });
+                    return;
+                }
+                entry.severity = body.severity;
+            }
+            if (body.tags !== undefined) {
+                entry.tags = sanitizeTags(body.tags);
+            }
+            storage.entries[idx] = entry;
+            (0, feedbackStorage_js_1.saveFeedbackStorage)(storage);
+            (0, auditLog_js_1.logAudit)('admin/feedback/update', [id], { fields: Object.keys(body) });
+            res.json(entry);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to update feedback entry', message: String(error) });
+        }
+    });
+    /** DELETE /admin/feedback/:id — remove an entry */
+    router.delete('/admin/feedback/:id', adminAuth_js_1.dashboardAdminAuth, (req, res) => {
+        try {
+            const { id } = req.params;
+            const storage = (0, feedbackStorage_js_1.loadFeedbackStorage)();
+            const idx = storage.entries.findIndex(e => e.id === id);
+            if (idx === -1) {
+                res.status(404).json({ error: `Feedback entry not found: ${id}` });
+                return;
+            }
+            storage.entries.splice(idx, 1);
+            (0, feedbackStorage_js_1.saveFeedbackStorage)(storage);
+            (0, auditLog_js_1.logAudit)('admin/feedback/delete', [id]);
+            res.status(200).json({ deleted: true, id });
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to delete feedback entry', message: String(error) });
+        }
+    });
+    return router;
+}