@jagilber-org/index-server 1.22.1 → 1.26.4

package/dist/dashboard/export/DataExporter.js

@@ -14,6 +14,7 @@ exports.DataExporter = void 0;
 const jsonExporter_js_1 = require("./exporters/jsonExporter.js");
 const csvExporter_js_1 = require("./exporters/csvExporter.js");
 const xmlExporter_js_1 = require("./exporters/xmlExporter.js");
+const logger_js_1 = require("../../services/logger.js");
 class DataExporter {
     exportConfigs = new Map();
     exportJobs = new Map();
@@ -613,7 +614,7 @@ class DataExporter {
                 callback(job);
             }
             catch (error) {
-                console.error('Error in export job callback:', error);
+                (0, logger_js_1.logError)('Error in export job callback:', error);
             }
         });
     }

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

@@ -101,6 +101,7 @@ export declare class AdminPanel {
         instructionCount: number;
         schemaVersion?: string;
         sizeBytes: number;
+        warnings?: string[];
     }[];
     restoreBackup(backupId: string): {
         success: boolean;
@@ -118,6 +119,7 @@ export declare class AdminPanel {
         success: boolean;
         message: string;
         pruned?: number;
+        errors?: string[];
     };
     /** Export a backup — returns the zip file path for streaming, or falls back to JSON bundle for legacy dirs */
     exportBackup(backupId: string): {
@@ -128,6 +130,7 @@ export declare class AdminPanel {
             manifest: Record<string, unknown>;
             files: Record<string, unknown>;
         };
+        warnings?: string[];
     };
     /** Import a backup from a JSON bundle uploaded by the client — creates a zip */
     importBackup(bundle: {

package/dist/dashboard/server/AdminPanel.js

@@ -24,6 +24,7 @@ const indexContext_1 = require("../../services/indexContext");
 const AdminPanelConfig_1 = require("./AdminPanelConfig");
 const AdminPanelState_1 = require("./AdminPanelState");
 const backupZip_1 = require("../../services/backupZip");
+const auditLog_1 = require("../../services/auditLog");
 const adm_zip_1 = __importDefault(require("adm-zip"));
 class AdminPanel {
     panelConfig;
@@ -154,9 +155,11 @@ class AdminPanel {
             return { success: true, message: 'System backup completed successfully', backupId, files: fileCount };
         }
         catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            (0, auditLog_1.logAudit)('admin/backup/perform_failed', undefined, { error: errMsg }, 'mutation');
             return {
                 success: false,
-                message: `Backup failed: ${error instanceof Error ? error.message : String(error)}`
+                message: `Backup failed: ${errMsg}`
             };
         }
     }
@@ -192,6 +195,7 @@ class AdminPanel {
                     let createdAt = new Date(stat.mtime).toISOString();
                     let instructionCount = 0;
                     let schemaVersion;
+                    const entryWarnings = [];
                     if (fs_1.default.existsSync(manifestPath)) {
                         try {
                             const mf = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
@@ -199,7 +203,13 @@ class AdminPanel {
                             instructionCount = mf.instructionCount || 0;
                             schemaVersion = mf.schemaVersion;
                         }
-                        catch { /* ignore */ }
+                        catch (err) {
+                            const errMsg = err instanceof Error ? err.message : String(err);
+                            const msg = `Failed to parse manifest for backup '${entry}': ${errMsg}`;
+                            process.stderr.write(`[admin] ${msg}\n`);
+                            entryWarnings.push(msg);
+                            (0, auditLog_1.logAudit)('admin/backup/list_warning', [entry], { error: errMsg, phase: 'manifest_parse' }, 'read');
+                        }
                     }
                     else {
                         instructionCount = fs_1.default.readdirSync(full).filter(f => f.toLowerCase().endsWith('.json')).length;
@@ -212,10 +222,18 @@ class AdminPanel {
                             return sum;
                         }
                     }, 0);
-                    results.push({ id: entry, createdAt, instructionCount, schemaVersion, sizeBytes });
+                    const result = { id: entry, createdAt, instructionCount, schemaVersion, sizeBytes };
+                    if (entryWarnings.length > 0)
+                        result.warnings = entryWarnings;
+                    results.push(result);
                 }
             }
-            catch { /* ignore individual entry errors */ }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                const msg = `Failed to read backup entry '${entry}': ${errMsg}`;
+                process.stderr.write(`[admin] ${msg}\n`);
+                (0, auditLog_1.logAudit)('admin/backup/list_warning', [entry], { error: errMsg, phase: 'read_entry' }, 'read');
+            }
         }
         results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
         return results;
@@ -228,8 +246,11 @@ class AdminPanel {
             const backupDir = path_1.default.join(backupRoot, safeId);
             const isZip = fs_1.default.existsSync(zipPath);
             const isDir = fs_1.default.existsSync(backupDir) && fs_1.default.statSync(backupDir).isDirectory();
-            if (!isZip && !isDir)
-                return { success: false, message: `Backup not found: ${safeId}` };
+            if (!isZip && !isDir) {
+                const msg = `Backup not found: ${safeId}`;
+                (0, auditLog_1.logAudit)('admin/backup/restore_failed', [safeId], { error: msg }, 'mutation');
+                return { success: false, message: msg };
+            }
             const instructionsDir = this.instructionsRoot;
             if (!fs_1.default.existsSync(instructionsDir))
                 fs_1.default.mkdirSync(instructionsDir, { recursive: true });
@@ -265,7 +286,9 @@ class AdminPanel {
             return { success: true, message: `Backup ${safeId} restored`, restored };
         }
         catch (error) {
-            return { success: false, message: `Restore failed: ${error instanceof Error ? error.message : String(error)}` };
+            const errMsg = error instanceof Error ? error.message : String(error);
+            (0, auditLog_1.logAudit)('admin/backup/restore_failed', backupId ? [String(backupId)] : undefined, { error: errMsg }, 'mutation');
+            return { success: false, message: `Restore failed: ${errMsg}` };
         }
     }
     /** Delete a backup zip or directory (safety checks on name) */
@@ -278,10 +301,15 @@ class AdminPanel {
             const dirPath = path_1.default.join(backupRoot, safeId);
             const hasZip = fs_1.default.existsSync(zipPath);
             const hasDir = fs_1.default.existsSync(dirPath) && fs_1.default.statSync(dirPath).isDirectory();
-            if (!hasZip && !hasDir)
-                return { success: false, message: `Backup not found: ${safeId}` };
+            if (!hasZip && !hasDir) {
+                const msg = `Backup not found: ${safeId}`;
+                (0, auditLog_1.logAudit)('admin/backup/delete_failed', [safeId], { error: msg }, 'mutation');
+                return { success: false, message: msg };
+            }
             if (!/^backup_|^instructions-|^pre_restore_|^auto-backup-/.test(safeId)) {
-                return { success: false, message: 'Refusing to delete unexpected backup name' };
+                const msg = 'Refusing to delete unexpected backup name';
+                (0, auditLog_1.logAudit)('admin/backup/delete_failed', [safeId], { error: msg }, 'mutation');
+                return { success: false, message: msg };
             }
             if (hasZip)
                 fs_1.default.unlinkSync(zipPath);
@@ -291,17 +319,23 @@ class AdminPanel {
             return { success: true, message: `Backup ${safeId} deleted`, removed: true };
         }
         catch (error) {
-            return { success: false, message: `Delete failed: ${error instanceof Error ? error.message : String(error)}` };
+            const errMsg = error instanceof Error ? error.message : String(error);
+            (0, auditLog_1.logAudit)('admin/backup/delete_failed', backupId ? [String(backupId)] : undefined, { error: errMsg }, 'mutation');
+            return { success: false, message: `Delete failed: ${errMsg}` };
         }
     }
     /** Prune backups keeping newest N (by createdAt / mtime). Returns count pruned. */
     pruneBackups(retain) {
         try {
-            if (retain < 0)
-                return { success: false, message: 'retain must be >= 0' };
+            if (retain < 0) {
+                const msg = 'retain must be >= 0';
+                (0, auditLog_1.logAudit)('admin/backup/prune_failed', undefined, { error: msg, retain }, 'mutation');
+                return { success: false, message: msg };
+            }
             const backupRoot = this.backupRoot;
             if (!fs_1.default.existsSync(backupRoot))
                 return { success: true, message: 'No backups to prune', pruned: 0 };
+            const pruneErrors = [];
             const entries = fs_1.default.readdirSync(backupRoot)
                 .map(name => {
                 const full = path_1.default.join(backupRoot, name);
@@ -341,10 +375,21 @@ class AdminPanel {
                             fs_1.default.rmSync(d.full, { recursive: true, force: true });
                         prunedAll++;
                     }
-                    catch { /* ignore */ }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        const msg = `Failed to delete backup '${d.id}': ${errMsg}`;
+                        process.stderr.write(`[admin] ${msg}\n`);
+                        pruneErrors.push(msg);
+                        (0, auditLog_1.logAudit)('admin/backup/prune_warning', [d.id], { error: errMsg, phase: 'delete_all' }, 'mutation');
+                    }
                 }
                 process.stderr.write(`[admin] Pruned all backups (${prunedAll})\n`);
-                return { success: true, message: `Pruned ${prunedAll} backups`, pruned: prunedAll };
+                const result = { success: true, message: `Pruned ${prunedAll} backups`, pruned: prunedAll };
+                if (pruneErrors.length > 0) {
+                    result.message += ` (${pruneErrors.length} error(s))`;
+                    result.errors = pruneErrors;
+                }
+                return result;
             }
             const toDelete = entries.slice(retain);
             let pruned = 0;
@@ -356,13 +401,26 @@ class AdminPanel {
                         fs_1.default.rmSync(d.full, { recursive: true, force: true });
                     pruned++;
                 }
-                catch { /* ignore */ }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    const msg = `Failed to delete backup '${d.id}': ${errMsg}`;
+                    process.stderr.write(`[admin] ${msg}\n`);
+                    pruneErrors.push(msg);
+                    (0, auditLog_1.logAudit)('admin/backup/prune_warning', [d.id], { error: errMsg, phase: 'delete_retain' }, 'mutation');
+                }
             }
             process.stderr.write(`[admin] Pruned ${pruned} backup(s); retained ${entries.length - pruned}\n`);
-            return { success: true, message: `Pruned ${pruned} backups (retained ${entries.length - pruned})`, pruned };
+            const result = { success: true, message: `Pruned ${pruned} backups (retained ${entries.length - pruned})`, pruned };
+            if (pruneErrors.length > 0) {
+                result.message += ` (${pruneErrors.length} error(s))`;
+                result.errors = pruneErrors;
+            }
+            return result;
         }
         catch (error) {
-            return { success: false, message: `Prune failed: ${error instanceof Error ? error.message : String(error)}` };
+            const errMsg = error instanceof Error ? error.message : String(error);
+            (0, auditLog_1.logAudit)('admin/backup/prune_failed', undefined, { error: errMsg, retain }, 'mutation');
+            return { success: false, message: `Prune failed: ${errMsg}` };
         }
     }
     /** Export a backup — returns the zip file path for streaming, or falls back to JSON bundle for legacy dirs */
@@ -375,15 +433,25 @@ class AdminPanel {
             }
             // Legacy directory fallback
             const backupDir = path_1.default.join(this.backupRoot, safeId);
-            if (!fs_1.default.existsSync(backupDir) || !fs_1.default.statSync(backupDir).isDirectory())
-                return { success: false, message: `Backup not found: ${safeId}` };
+            if (!fs_1.default.existsSync(backupDir) || !fs_1.default.statSync(backupDir).isDirectory()) {
+                const msg = `Backup not found: ${safeId}`;
+                (0, auditLog_1.logAudit)('admin/backup/export_failed', [safeId], { error: msg }, 'read');
+                return { success: false, message: msg };
+            }
             let manifest = {};
+            const exportWarnings = [];
             const manifestPath = path_1.default.join(backupDir, 'manifest.json');
             if (fs_1.default.existsSync(manifestPath)) {
                 try {
                     manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
                 }
-                catch { /* ignore */ }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    const msg = `Failed to parse manifest.json for backup '${safeId}': ${errMsg}`;
+                    process.stderr.write(`[admin] ${msg}\n`);
+                    exportWarnings.push(msg);
+                    (0, auditLog_1.logAudit)('admin/backup/export_warning', [safeId], { error: errMsg, phase: 'manifest_parse' }, 'read');
+                }
             }
             const files = {};
             for (const f of fs_1.default.readdirSync(backupDir)) {
@@ -391,20 +459,35 @@ class AdminPanel {
                     try {
                         files[f] = JSON.parse(fs_1.default.readFileSync(path_1.default.join(backupDir, f), 'utf-8'));
                     }
-                    catch { /* skip corrupt */ }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        const msg = `Skipped corrupt file '${f}' in backup '${safeId}': ${errMsg}`;
+                        process.stderr.write(`[admin] ${msg}\n`);
+                        exportWarnings.push(msg);
+                        (0, auditLog_1.logAudit)('admin/backup/export_warning', [safeId], { error: errMsg, phase: 'file_parse', file: f }, 'read');
+                    }
                 }
             }
-            return { success: true, message: 'Export ready', bundle: { manifest, files } };
+            const result = { success: true, message: 'Export ready', bundle: { manifest, files } };
+            if (exportWarnings.length > 0) {
+                result.warnings = exportWarnings;
+                result.message = `Export ready (${exportWarnings.length} warning(s))`;
+            }
+            return result;
         }
         catch (error) {
-            return { success: false, message: `Export failed: ${error instanceof Error ? error.message : String(error)}` };
+            const errMsg = error instanceof Error ? error.message : String(error);
+            (0, auditLog_1.logAudit)('admin/backup/export_failed', backupId ? [String(backupId)] : undefined, { error: errMsg }, 'read');
+            return { success: false, message: `Export failed: ${errMsg}` };
         }
     }
     /** Import a backup from a JSON bundle uploaded by the client — creates a zip */
     importBackup(bundle) {
         try {
             if (!bundle || typeof bundle !== 'object' || !bundle.files || typeof bundle.files !== 'object') {
-                return { success: false, message: 'Invalid bundle: must contain a "files" object' };
+                const msg = 'Invalid bundle: must contain a "files" object';
+                (0, auditLog_1.logAudit)('admin/backup/import_failed', undefined, { error: msg }, 'mutation');
+                return { success: false, message: msg };
             }
             const now = new Date();
             const baseTs = now.toISOString().replace(/[-:]/g, '').replace(/\..+/, '');
@@ -437,21 +520,27 @@ class AdminPanel {
             return { success: true, message: `Imported ${written} files as ${backupId}`, backupId, files: written };
         }
         catch (error) {
-            return { success: false, message: `Import failed: ${error instanceof Error ? error.message : String(error)}` };
+            const errMsg = error instanceof Error ? error.message : String(error);
+            (0, auditLog_1.logAudit)('admin/backup/import_failed', undefined, { error: errMsg, mode: 'json' }, 'mutation');
+            return { success: false, message: `Import failed: ${errMsg}` };
         }
     }
     /** Import a zip backup uploaded by the client without rewriting its contents. */
     importZipBackup(zipBuffer, sourceName) {
         try {
             if (!Buffer.isBuffer(zipBuffer) || zipBuffer.length === 0) {
-                return { success: false, message: 'Invalid zip backup: upload was empty' };
+                const msg = 'Invalid zip backup: upload was empty';
+                (0, auditLog_1.logAudit)('admin/backup/import_failed', undefined, { error: msg, mode: 'zip' }, 'mutation');
+                return { success: false, message: msg };
             }
             const zip = new adm_zip_1.default(zipBuffer);
             const instructionFiles = zip.getEntries()
                 .map(entry => path_1.default.basename(entry.entryName))
                 .filter(name => name.toLowerCase().endsWith('.json') && name === path_1.default.basename(name) && name !== 'manifest.json');
             if (!instructionFiles.length) {
-                return { success: false, message: 'Invalid zip backup: contains no instruction files' };
+                const msg = 'Invalid zip backup: contains no instruction files';
+                (0, auditLog_1.logAudit)('admin/backup/import_failed', undefined, { error: msg, mode: 'zip' }, 'mutation');
+                return { success: false, message: msg };
             }
             const now = new Date();
             const baseTs = now.toISOString().replace(/[-:]/g, '').replace(/\..+/, '');
@@ -460,13 +549,15 @@ class AdminPanel {
             const zipPath = path_1.default.join(this.backupRoot, `${backupId}.zip`);
             if (!fs_1.default.existsSync(this.backupRoot))
                 fs_1.default.mkdirSync(this.backupRoot, { recursive: true });
-            fs_1.default.writeFileSync(zipPath, zipBuffer);
+            fs_1.default.writeFileSync(zipPath, zipBuffer); // lgtm[js/http-to-file-access] — zipPath is generated under controlled backupRoot; admin endpoint behind dashboardAdminAuth
             const safeSourceName = sourceName ? path_1.default.basename(sourceName) : undefined;
             process.stderr.write(`[admin] Imported zip backup from file: ${backupId}.zip (${instructionFiles.length} files${safeSourceName ? `, source=${safeSourceName}` : ''})\n`);
             return { success: true, message: `Imported ${instructionFiles.length} files as ${backupId}`, backupId, files: instructionFiles.length };
         }
         catch (error) {
-            return { success: false, message: `Import failed: ${error instanceof Error ? error.message : String(error)}` };
+            const errMsg = error instanceof Error ? error.message : String(error);
+            (0, auditLog_1.logAudit)('admin/backup/import_failed', undefined, { error: errMsg, mode: 'zip' }, 'mutation');
+            return { success: false, message: `Import failed: ${errMsg}` };
         }
     }
     /**
@@ -582,8 +673,8 @@ class AdminPanel {
                 skipped = Math.max(0, scanned - accepted);
             }
         }
-        catch {
-            /* ignore */
+        catch (err) {
+            process.stderr.write(`[admin] getAdminStats: failed to read index state: ${err instanceof Error ? err.message : String(err)}\n`);
         }
         // Count instructions from the store (raw count uses store, with disk fallback for transparency)
         const indexDir = this.instructionsRoot;
@@ -598,7 +689,9 @@ class AdminPanel {
                     rawFileCount = fs_1.default.readdirSync(indexDir).filter(f => f.toLowerCase().endsWith('.json')).length;
                 }
             }
-            catch { /* ignore */ }
+            catch (err) {
+                process.stderr.write(`[admin] getAdminStats: failed to count instruction files on disk: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
         }
         // Recompute schema version snapshot only when any of these counts change
         const cacheNeedsUpdate = !this.indexStatsCache || this.indexStatsCache.acceptedInstructions !== accepted || this.indexStatsCache.rawFileCount !== rawFileCount || this.indexStatsCache.skippedInstructions !== skipped;
@@ -623,11 +716,15 @@ class AdminPanel {
                                 if (typeof json.schemaVersion === 'string')
                                     schemaVersions.add(json.schemaVersion);
                             }
-                            catch { /* ignore parse */ }
+                            catch (err) {
+                                process.stderr.write(`[admin] getAdminStats: failed to parse schema version from '${f}': ${err instanceof Error ? err.message : String(err)}\n`);
+                            }
                         }
                     }
                 }
-                catch { /* ignore */ }
+                catch (err) {
+                    process.stderr.write(`[admin] getAdminStats: failed to read instruction files for schema version: ${err instanceof Error ? err.message : String(err)}\n`);
+                }
             }
             const schemaVersion = schemaVersions.size === 0 ? 'unknown' : (schemaVersions.size === 1 ? Array.from(schemaVersions)[0] : `mixed(${Array.from(schemaVersions).join(',')})`);
             this.indexStatsCache = {

package/dist/dashboard/server/ApiRoutes.js

@@ -39,22 +39,21 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createApiRoutes = createApiRoutes;
 const express_1 = __importStar(require("express"));
-const express_rate_limit_1 = __importDefault(require("express-rate-limit"));
+const express_rate_limit_1 = __importStar(require("express-rate-limit"));
 const MetricsCollector_js_1 = require("./MetricsCollector.js");
 const auditLog_1 = require("../../services/auditLog");
 const runtimeConfig_js_1 = require("../../config/runtimeConfig.js");
 const index_js_1 = require("./routes/index.js");
 const ensureLoadedMiddleware_js_1 = require("./middleware/ensureLoadedMiddleware.js");
+const logger_js_1 = require("../../services/logger.js");
 function createApiRoutes(options = {}) {
     const router = (0, express_1.Router)();
     const metricsCollector = (0, MetricsCollector_js_1.getMetricsCollector)();
-    const rateLimitOpts = options.rateLimit ?? { windowMs: 60_000, max: 100 };
+    const httpCfg = (0, runtimeConfig_js_1.getRuntimeConfig)().dashboard.http;
+    const rateLimitOpts = options.rateLimit ?? { windowMs: httpCfg.rateLimitWindowMs, max: httpCfg.rateLimitMax };
     // CORS middleware (if enabled)
     // Security: only allow loopback origins (localhost, 127.0.0.1, [::1]) to prevent
     // cross-origin attacks. No wildcard (*) origins; credentials are not exposed.
@@ -63,7 +62,7 @@ function createApiRoutes(options = {}) {
             const origin = req.headers.origin;
             // nosemgrep: javascript.express.security.cors-misconfiguration.cors-misconfiguration -- origin is validated against loopback-only regex; not user-controlled
             if (origin && /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/.test(origin)) {
-                res.header('Access-Control-Allow-Origin', origin);
+                res.header('Access-Control-Allow-Origin', origin); // lgtm[js/cors-misconfiguration] — origin validated against loopback-only regex above
             }
             res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
             res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
@@ -72,8 +71,9 @@ function createApiRoutes(options = {}) {
     }
     // JSON middleware
     router.use(express_1.default.json());
-    const rateLimitEnabled = (0, runtimeConfig_js_1.getRuntimeConfig)().dashboard.http.rateLimitEnabled;
+    const rateLimitEnabled = httpCfg.rateLimitEnabled;
     if (rateLimitEnabled && rateLimitOpts.max > 0 && rateLimitOpts.windowMs > 0) {
+        // Global rate limit for all routes (reads + mutations)
         router.use((0, express_rate_limit_1.default)({
             windowMs: rateLimitOpts.windowMs,
             max: rateLimitOpts.max,
@@ -81,13 +81,43 @@ function createApiRoutes(options = {}) {
             legacyHeaders: true,
             validate: { ip: false },
             skip: (req) => req.method === 'OPTIONS',
-            keyGenerator: (req) => req.ip || req.socket.remoteAddress || 'unknown',
+            keyGenerator: (req) => {
+                const clientIp = req.ip || req.socket.remoteAddress;
+                return clientIp ? (0, express_rate_limit_1.ipKeyGenerator)(clientIp) : 'unknown';
+            },
             handler: (_req, res) => {
                 const retryAfter = Number(res.getHeader('Retry-After') || Math.ceil(rateLimitOpts.windowMs / 1000));
                 res.status(429).json({
                     error: 'Too Many Requests',
                     message: `Rate limit exceeded. Try again in ${retryAfter} second(s).`,
                     retryAfterSeconds: retryAfter,
+                    tier: 'global',
+                    timestamp: Date.now(),
+                });
+            },
+        }));
+        // Stricter rate limit for mutation endpoints (POST/PUT/PATCH/DELETE).
+        // Defaults to runtimeConfig httpCfg.rateLimitMutationMax (env-configurable),
+        // bounded by the global per-window cap so mutation-tier never exceeds global.
+        const mutationMax = Math.max(1, Math.min(httpCfg.rateLimitMutationMax, rateLimitOpts.max));
+        router.use((0, express_rate_limit_1.default)({
+            windowMs: rateLimitOpts.windowMs,
+            max: mutationMax,
+            standardHeaders: true,
+            legacyHeaders: false,
+            validate: { ip: false },
+            skip: (req) => req.method === 'OPTIONS' || req.method === 'GET' || req.method === 'HEAD',
+            keyGenerator: (req) => {
+                const clientIp = req.ip || req.socket.remoteAddress;
+                return `mutation:${clientIp ? (0, express_rate_limit_1.ipKeyGenerator)(clientIp) : 'unknown'}`;
+            },
+            handler: (_req, res) => {
+                const retryAfter = Number(res.getHeader('Retry-After') || Math.ceil(rateLimitOpts.windowMs / 1000));
+                res.status(429).json({
+                    error: 'Too Many Requests',
+                    message: `Mutation rate limit exceeded. Try again in ${retryAfter} second(s).`,
+                    retryAfterSeconds: retryAfter,
+                    tier: 'mutation',
                     timestamp: Date.now(),
                 });
             },
@@ -169,9 +199,10 @@ function createApiRoutes(options = {}) {
     router.use((0, index_js_1.createScriptsRoutes)());
     router.use((0, index_js_1.createMessagingRoutes)());
     router.use((0, index_js_1.createSqliteRoutes)());
+    router.use((0, index_js_1.createAdminFeedbackRoutes)());
     // Error handling middleware
     router.use((error, _req, res, _next) => {
-        console.error('[API] Unhandled error:', error);
+        (0, logger_js_1.logError)('[API] Unhandled error:', error);
         const exposeDetails = (0, runtimeConfig_js_1.getRuntimeConfig)().dashboard.http.verboseLogging;
         res.status(500).json({
             error: 'Internal server error',

package/dist/dashboard/server/DashboardServer.js

@@ -118,7 +118,7 @@ class DashboardServer {
                 const origin = req.headers.origin;
                 // nosemgrep: javascript.express.security.cors-misconfiguration.cors-misconfiguration -- origin is validated against loopback-only regex; not user-controlled
                 if (origin && /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/.test(origin)) {
-                    res.header('Access-Control-Allow-Origin', origin);
+                    res.header('Access-Control-Allow-Origin', origin); // lgtm[js/cors-misconfiguration] — origin validated against loopback-only regex above
                 }
                 res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
                 res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');

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

@@ -7,6 +7,7 @@ export declare class FileMetricsStorage {
     private storageDir;
     private maxFiles;
     private retentionMinutes;
+    private cleanupHealth;
     constructor(options?: {
         storageDir?: string;
         maxFiles?: number;
@@ -32,15 +33,33 @@ export declare class FileMetricsStorage {
         totalSizeKB: number;
         oldestTimestamp?: number;
         newestTimestamp?: number;
+        cleanup: {
+            degraded: boolean;
+            deletionFailures: number;
+            lastDeletionError?: string;
+            lastDeletionFailureAt?: number;
+            lastDeletionRecoveredAt?: number;
+        };
     }>;
     /**
      * Clear all stored metrics
      */
     clearAll(): Promise<void>;
+    getCleanupHealth(): {
+        degraded: boolean;
+        deletionFailures: number;
+        lastDeletionError?: string;
+        lastDeletionFailureAt?: number;
+        lastDeletionRecoveredAt?: number;
+    };
     private ensureStorageDir;
     private getSnapshotFiles;
     private extractTimestampFromFilename;
     private cleanupOldFiles;
+    private formatCleanupError;
+    private recordDeletionFailure;
+    private recordDeletionRecovery;
+    private deleteSnapshotFile;
 }
 export declare function getFileMetricsStorage(options?: {
     storageDir?: string;

package/dist/dashboard/server/FileMetricsStorage.js

@@ -16,6 +16,13 @@ class FileMetricsStorage {
     storageDir;
     maxFiles;
     retentionMinutes;
+    cleanupHealth = {
+        degraded: false,
+        deletionFailures: 0,
+        lastDeletionError: undefined,
+        lastDeletionFailureAt: undefined,
+        lastDeletionRecoveredAt: undefined,
+    };
     constructor(options = {}) {
         this.storageDir = options.storageDir || path_1.default.join(process.cwd(), 'metrics');
         this.maxFiles = options.maxFiles || 720; // 12 hours at 1-minute intervals
@@ -96,7 +103,7 @@ class FileMetricsStorage {
         try {
             const files = await this.getSnapshotFiles();
             if (files.length === 0) {
-                return { fileCount: 0, totalSizeKB: 0 };
+                return { fileCount: 0, totalSizeKB: 0, cleanup: this.getCleanupHealth() };
             }
             let totalSize = 0;
             for (const file of files) {
@@ -114,11 +121,12 @@ class FileMetricsStorage {
                 totalSizeKB: Math.round(totalSize / 1024),
                 oldestTimestamp: timestamps.length > 0 ? Math.min(...timestamps) : undefined,
                 newestTimestamp: timestamps.length > 0 ? Math.max(...timestamps) : undefined,
+                cleanup: this.getCleanupHealth(),
             };
         }
         catch (error) {
             (0, logger_js_1.logError)('[FileMetricsStorage] Failed to get storage stats', error);
-            return { fileCount: 0, totalSizeKB: 0 };
+            return { fileCount: 0, totalSizeKB: 0, cleanup: this.getCleanupHealth() };
         }
     }
     /**
@@ -127,12 +135,19 @@ class FileMetricsStorage {
     async clearAll() {
         try {
             const files = await this.getSnapshotFiles();
-            await Promise.all(files.map(file => fs_1.default.promises.unlink(path_1.default.join(this.storageDir, file)).catch(() => { })));
+            const results = await Promise.all(files.map(file => this.deleteSnapshotFile(file)));
+            const failedCount = results.filter(result => !result).length;
+            if (failedCount > 0) {
+                (0, logger_js_1.logWarn)('[FileMetricsStorage] Failed to delete one or more metrics files during clear', { failedCount });
+            }
         }
         catch (error) {
             (0, logger_js_1.logError)('[FileMetricsStorage] Failed to clear metrics storage', error);
         }
     }
+    getCleanupHealth() {
+        return { ...this.cleanupHealth };
+    }
     async ensureStorageDir() {
         try {
             await fs_1.default.promises.mkdir(this.storageDir, { recursive: true });
@@ -174,14 +189,46 @@ class FileMetricsStorage {
                 filesToDelete = [...new Set([...expiredFiles, ...oldestFiles])];
             }
             if (filesToDelete.length > 0) {
-                await Promise.all(filesToDelete.map(file => fs_1.default.promises.unlink(path_1.default.join(this.storageDir, file)).catch(() => { })));
-                (0, logger_js_1.logInfo)('[FileMetricsStorage] Cleaned up old metrics files', { count: filesToDelete.length });
+                const results = await Promise.all(filesToDelete.map(file => this.deleteSnapshotFile(file)));
+                const deletedCount = results.filter(Boolean).length;
+                const failedCount = filesToDelete.length - deletedCount;
+                (0, logger_js_1.logInfo)('[FileMetricsStorage] Cleaned up old metrics files', { count: deletedCount, failedCount });
             }
         }
         catch (error) {
             (0, logger_js_1.logError)('[FileMetricsStorage] Failed to cleanup old metrics files', error);
         }
     }
+    formatCleanupError(error) {
+        return error instanceof Error ? (error.stack ?? error.message) : String(error);
+    }
+    recordDeletionFailure(file, error) {
+        this.cleanupHealth.degraded = true;
+        this.cleanupHealth.deletionFailures += 1;
+        this.cleanupHealth.lastDeletionError = this.formatCleanupError(error);
+        this.cleanupHealth.lastDeletionFailureAt = Date.now();
+        this.cleanupHealth.lastDeletionRecoveredAt = undefined;
+        (0, logger_js_1.logWarn)(`[FileMetricsStorage] Failed to delete metrics file ${file}`, error);
+    }
+    recordDeletionRecovery(file) {
+        if (!this.cleanupHealth.degraded)
+            return;
+        this.cleanupHealth.degraded = false;
+        this.cleanupHealth.lastDeletionError = undefined;
+        this.cleanupHealth.lastDeletionRecoveredAt = Date.now();
+        (0, logger_js_1.logInfo)('[FileMetricsStorage] Metrics file cleanup recovered', { file, deletionFailures: this.cleanupHealth.deletionFailures });
+    }
+    async deleteSnapshotFile(file) {
+        try {
+            await fs_1.default.promises.unlink(path_1.default.join(this.storageDir, file));
+            this.recordDeletionRecovery(file);
+            return true;
+        }
+        catch (error) {
+            this.recordDeletionFailure(file, error);
+            return false;
+        }
+    }
 }
 exports.FileMetricsStorage = FileMetricsStorage;
 /**