kempo-server 1.6.0 → 1.6.1

package/tests/cacheConfig.node-test.js

@@ -0,0 +1,107 @@
+import defaultConfig from '../src/defaultConfig.js';
+import path from 'path';
+import { writeFile, mkdir, rm } from 'fs/promises';
+
+/*
+  Test Utilities
+*/
+const createTempConfig = async (config) => {
+  const tempDir = path.join(process.cwd(), 'tests', 'temp-config-test');
+  await mkdir(tempDir, { recursive: true });
+  
+  const configPath = path.join(tempDir, 'test.config.json');
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+  
+  return { tempDir, configPath };
+};
+
+const cleanupTempConfig = async (tempDir) => {
+  try {
+    await rm(tempDir, { recursive: true });
+  } catch(e) {
+    // Directory might not exist
+  }
+};
+
+/*
+  Lifecycle Callbacks
+*/
+export const afterAll = async (log) => {
+  log('Cleaning up cache configuration test environment...');
+  const tempDir = path.join(process.cwd(), 'tests', 'temp-config-test');
+  await cleanupTempConfig(tempDir);
+};
+
+/*
+  Cache Configuration Tests
+*/
+export default {
+  'default cache configuration includes all required fields': async ({pass, fail, log}) => {
+    try {
+      const cache = defaultConfig.cache;
+      
+      if(!cache) throw new Error('cache config missing from defaults');
+      if(typeof cache.enabled !== 'boolean') throw new Error('enabled should be boolean');
+      if(typeof cache.maxSize !== 'number') throw new Error('maxSize should be number');
+      if(typeof cache.maxMemoryMB !== 'number') throw new Error('maxMemoryMB should be number');
+      if(typeof cache.ttlMs !== 'number') throw new Error('ttlMs should be number');
+      if(typeof cache.maxHeapUsagePercent !== 'number') throw new Error('maxHeapUsagePercent should be number');
+      if(typeof cache.memoryCheckInterval !== 'number') throw new Error('memoryCheckInterval should be number');
+      if(typeof cache.watchFiles !== 'boolean') throw new Error('watchFiles should be boolean');
+      if(typeof cache.enableMemoryMonitoring !== 'boolean') throw new Error('enableMemoryMonitoring should be boolean');
+      
+      log('✓ Default cache configuration structure valid');
+      pass('Default cache configuration verified');
+    } catch(e){ fail(e.message); }
+  },
+
+  'cache can be completely disabled': async ({pass, fail, log}) => {
+    try {
+      const { tempDir, configPath } = await createTempConfig({
+        cache: { enabled: false }
+      });
+      
+      // Import router to test config loading
+      const router = await import('../src/router.js');
+      const flags = { root: 'docs', config: configPath };
+      
+      const handler = await router.default(flags, () => {}); // Empty log function
+      
+      if(handler.moduleCache !== null) throw new Error('cache should be null when disabled');
+      
+      await cleanupTempConfig(tempDir);
+      log('✓ Cache properly disabled via configuration');
+      pass('Cache disable configuration verified');
+    } catch(e){ fail(e.message); }
+  },
+
+  'custom cache limits are applied correctly': async ({pass, fail, log}) => {
+    try {
+      const { tempDir, configPath } = await createTempConfig({
+        cache: {
+          enabled: true,
+          maxSize: 25,
+          maxMemoryMB: 10,
+          ttlMs: 120000
+        }
+      });
+      
+      const router = await import('../src/router.js');
+      const flags = { root: 'docs', config: configPath };
+      
+      const handler = await router.default(flags, () => {});
+      
+      if(!handler.moduleCache) throw new Error('cache should be enabled');
+      
+      const stats = handler.getStats();
+      if(stats.cache.maxSize !== 25) throw new Error('maxSize not applied');
+      if(stats.cache.maxMemoryMB !== 10) throw new Error('maxMemoryMB not applied');
+      if(stats.config.ttlMs !== 120000) throw new Error('ttlMs not applied');
+      
+      handler.moduleCache.destroy();
+      await cleanupTempConfig(tempDir);
+      log('✓ Custom cache limits applied correctly');
+      pass('Custom cache configuration verified');
+    } catch(e){ fail(e.message); }
+  }
+};

package/tests/moduleCache.node-test.js

@@ -0,0 +1,274 @@
+import ModuleCache from '../src/moduleCache.js';
+import path from 'path';
+import { writeFile, unlink, stat, mkdir, rm } from 'fs/promises';
+
+/*
+  Test Utilities
+*/
+const activeCaches = [];
+
+const createTestCache = (config = {}) => {
+  const cache = new ModuleCache({
+    enableMemoryMonitoring: false, // Always disable to prevent hanging
+    watchFiles: false,             // Default to false for most tests
+    ...config
+  });
+  activeCaches.push(cache);
+  return cache;
+};
+const createTempDir = async () => {
+  const tempDir = path.join(process.cwd(), 'tests', 'temp-cache-test');
+  try {
+    await mkdir(tempDir, { recursive: true });
+  } catch(e) {
+    // Directory might already exist
+  }
+  return tempDir;
+};
+
+const cleanupTempDir = async (tempDir) => {
+  try {
+    await rm(tempDir, { recursive: true });
+  } catch(e) {
+    // Directory might not exist
+  }
+};
+
+/*
+  Lifecycle Callbacks
+*/
+export const beforeAll = async (log) => {
+  log('Setting up module cache test environment...');
+};
+
+export const afterAll = async (log) => {
+  log('Starting cleanup of module cache test environment...');
+  
+  log(`Found ${activeCaches.length} active caches to destroy`);
+  // Destroy all active caches to clean up timers and watchers
+  for(let i = 0; i < activeCaches.length; i++) {
+    log(`Destroying cache ${i + 1}/${activeCaches.length}`);
+    activeCaches[i].destroy();
+  }
+  activeCaches.length = 0;
+  log('All caches destroyed');
+  
+  // Give file watchers extra time to fully close
+  log('Waiting for file watchers to close...');
+  await new Promise(resolve => setTimeout(resolve, 500));
+  log('File watcher wait complete');
+  
+  const tempDir = path.join(process.cwd(), 'tests', 'temp-cache-test');
+  log('Cleaning up temp directory...');
+  await cleanupTempDir(tempDir);
+  log('Module cache test cleanup complete');
+};
+
+/*
+  Module Cache Tests
+*/
+export default {
+  'basic LRU functionality works correctly': async ({pass, fail, log}) => {
+    try {
+      const cache = createTestCache({
+        maxSize: 2,
+        maxMemoryMB: 10,
+        ttlMs: 60000,
+        watchFiles: false
+      });
+
+      const mockStats1 = { mtime: new Date('2023-01-01') };
+      const mockStats2 = { mtime: new Date('2023-01-02') };
+      const mockStats3 = { mtime: new Date('2023-01-03') };
+
+      cache.set('/test1.js', { default: () => 'test1' }, mockStats1, 1);
+      if(cache.cache.size !== 1) throw new Error('size should be 1');
+
+      cache.set('/test2.js', { default: () => 'test2' }, mockStats2, 1);
+      if(cache.cache.size !== 2) throw new Error('size should be 2');
+
+      cache.set('/test3.js', { default: () => 'test3' }, mockStats3, 1);
+      if(cache.cache.size !== 2) throw new Error('size should still be 2');
+      if(cache.get('/test1.js', mockStats1) !== null) throw new Error('oldest should be evicted');
+
+      cache.destroy();
+      log('✓ LRU eviction working correctly');
+      pass('LRU functionality verified');
+    } catch(e){ 
+      cache?.destroy(); 
+      fail(e.message); 
+    }
+  },
+
+  'TTL expiration invalidates entries': async ({pass, fail, log}) => {
+    try {
+      const cache = createTestCache({
+        maxSize: 10,
+        ttlMs: 50,
+        watchFiles: false
+      });
+
+      const mockStats = { mtime: new Date('2023-01-01') };
+      cache.set('/test.js', { default: () => 'test' }, mockStats, 1);
+      
+      if(cache.get('/test.js', mockStats) === null) throw new Error('should be available immediately');
+      
+      await new Promise(resolve => setTimeout(resolve, 100));
+      
+      if(cache.get('/test.js', mockStats) !== null) throw new Error('should be expired');
+      
+      cache.destroy();
+      log('✓ TTL expiration working');
+      pass('TTL expiration verified');
+    } catch(e){ 
+      cache?.destroy(); 
+      fail(e.message); 
+    }
+  },
+
+  'file modification invalidates cache entry': async ({pass, fail, log}) => {
+    try {
+      const cache = createTestCache({
+        maxSize: 10,
+        ttlMs: 60000,
+        watchFiles: false
+      });
+
+      const oldStats = { mtime: new Date('2023-01-01') };
+      const newStats = { mtime: new Date('2023-01-02') };
+      
+      cache.set('/test.js', { default: () => 'test' }, oldStats, 1);
+      
+      if(cache.get('/test.js', oldStats) === null) throw new Error('should be available with old stats');
+      if(cache.get('/test.js', newStats) !== null) throw new Error('should be invalidated with newer stats');
+      
+      cache.destroy();
+      log('✓ File modification detection working');
+      pass('File modification invalidation verified');
+    } catch(e){ 
+      cache?.destroy(); 
+      fail(e.message); 
+    }
+  },
+
+  'memory limit enforcement evicts oldest entries': async ({pass, fail, log}) => {
+    try {
+      const cache = createTestCache({
+        maxSize: 100,
+        maxMemoryMB: 0.002,
+        ttlMs: 60000,
+        watchFiles: false
+      });
+
+      const mockStats = { mtime: new Date('2023-01-01') };
+      
+      cache.set('/test1.js', { default: () => 'test1' }, mockStats, 1);
+      cache.set('/test2.js', { default: () => 'test2' }, mockStats, 1);
+      cache.set('/test3.js', { default: () => 'test3' }, mockStats, 1);
+      
+      if(cache.get('/test1.js', mockStats) !== null) throw new Error('first entry should be evicted due to memory limit');
+      if(cache.get('/test2.js', mockStats) === null) throw new Error('second entry should still be cached');
+      if(cache.get('/test3.js', mockStats) === null) throw new Error('third entry should still be cached');
+      
+      cache.destroy();
+      log('✓ Memory limit enforcement working');
+      pass('Memory limit enforcement verified');
+    } catch(e){ 
+      cache?.destroy(); 
+      fail(e.message); 
+    }
+  },
+
+  'statistics tracking works correctly': async ({pass, fail, log}) => {
+    try {
+      const cache = createTestCache({
+        maxSize: 10,
+        watchFiles: false
+      });
+
+      const mockStats = { mtime: new Date('2023-01-01') };
+      
+      if(cache.get('/test.js', mockStats) !== null) throw new Error('should be cache miss');
+      if(cache.stats.misses !== 1) throw new Error('miss count should be 1');
+      
+      cache.set('/test.js', { default: () => 'test' }, mockStats, 1);
+      if(cache.get('/test.js', mockStats) === null) throw new Error('should be cache hit');
+      if(cache.stats.hits !== 1) throw new Error('hit count should be 1');
+      
+      if(cache.getHitRate() !== 50) throw new Error('hit rate should be 50%');
+      
+      const stats = cache.getStats();
+      if(!stats.cache || !stats.stats || !stats.memory) throw new Error('stats structure invalid');
+      
+      cache.destroy();
+      log('✓ Statistics tracking accurate');
+      pass('Statistics tracking verified');
+    } catch(e){ 
+      cache?.destroy(); 
+      fail(e.message); 
+    }
+  },
+
+  'file watching invalidates cache on changes': async ({pass, fail, log}) => {
+    let cache;
+    let testFilePath;
+    try {
+      log('Starting file watching test...');
+      const tempDir = await createTempDir();
+      log('Created temp directory');
+      
+      cache = createTestCache({
+        maxSize: 10,
+        ttlMs: 60000,
+        watchFiles: true
+      });
+      log('Created cache with file watching enabled');
+
+      testFilePath = path.join(tempDir, 'watch-test.js');
+      
+      await writeFile(testFilePath, 'export default () => "v1";');
+      log('Wrote initial test file');
+      const initialStats = await stat(testFilePath);
+      
+      const module = { default: () => 'v1' };
+      cache.set(testFilePath, module, initialStats, 1);
+      log('Set initial cache entry');
+      
+      if(cache.get(testFilePath, initialStats) === null) throw new Error('should be in cache initially');
+      log('Verified initial cache entry exists');
+      
+      await new Promise(resolve => setTimeout(resolve, 50));
+      await writeFile(testFilePath, 'export default () => "v2";');
+      log('Modified test file');
+      
+      await new Promise(resolve => setTimeout(resolve, 200));
+      log('Waited for file watcher to detect changes');
+      
+      if(cache.get(testFilePath, initialStats) !== null) throw new Error('should be invalidated after file change');
+      if(cache.stats.fileChanges === 0) throw new Error('file change should be tracked');
+      log('Verified cache invalidation worked');
+      
+      // Clean up immediately
+      await unlink(testFilePath);
+      log('Deleted test file');
+      cache.destroy();
+      log('Destroyed cache');
+      cache = null; // Ensure it's not destroyed again in catch
+      
+      // Give extra time for file watcher cleanup
+      await new Promise(resolve => setTimeout(resolve, 100));
+      log('File watching test cleanup complete');
+      
+      log('✓ File watching invalidation working');
+      pass('File watching verified');
+    } catch(e){ 
+      log(`Error in file watching test: ${e.message}`);
+      if (testFilePath) {
+        try { await unlink(testFilePath); log('Cleaned up test file after error'); } catch {}
+      }
+      cache?.destroy(); 
+      log('Destroyed cache after error');
+      fail(e.message); 
+    }
+  }
+};

package/tests/router.node-test.js

@@ -40,7 +40,7 @@ export default {
   process.chdir(dir);
   const flags = {root: '.', logging: 0, scan: true};
   const handler = await router(flags, log);
-        const server = http.createServer(handler);
+  const server = http.createServer(handler);
         const port = randomPort();
   await new Promise(r => server.listen(port, r));
   await new Promise(r => setTimeout(r, 50));
@@ -67,7 +67,9 @@ export default {
   const flags = {root: '.', logging: 0, scan: false};
   const logFn = () => {};
   // write config before init
-  await write(dir, '.config.json', JSON.stringify({customRoutes: {'/a': fileA, 'b/*': path.join(dir, 'b/*')}}));
+  await write(dir, '.config.json', JSON.stringify({
+    customRoutes: {'/a': fileA, 'b/*': path.join(dir, 'b/*')}
+  }));
   const handler = await router(flags, logFn);
   const server = http.createServer(handler);
         const port = randomPort();

package/utils/cache-demo.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+/*
+  Cache Demo Script
+  Demonstrates the module cache functionality with real-time monitoring
+*/
+
+import path from 'path';
+import { writeFile, unlink, mkdir, rm } from 'fs/promises';
+import ModuleCache from '../src/moduleCache.js';
+
+const createDemoFiles = async (demoDir) => {
+  await mkdir(demoDir, { recursive: true });
+  
+  // Create some demo route files
+  await writeFile(path.join(demoDir, 'users.js'), 
+    'export default async (req, res) => res.json({ users: ["alice", "bob"] });'
+  );
+  
+  await writeFile(path.join(demoDir, 'posts.js'), 
+    'export default async (req, res) => res.json({ posts: ["post1", "post2"] });'
+  );
+  
+  await writeFile(path.join(demoDir, 'auth.js'), 
+    'export default async (req, res) => res.json({ authenticated: true });'
+  );
+  
+  return [
+    path.join(demoDir, 'users.js'),
+    path.join(demoDir, 'posts.js'), 
+    path.join(demoDir, 'auth.js')
+  ];
+};
+
+const simulateFileAccess = async (cache, filePaths) => {
+  const { stat } = await import('fs/promises');
+  
+  for(const filePath of filePaths) {
+    const stats = await stat(filePath);
+    
+    // Try to get from cache first
+    let module = cache.get(filePath, stats);
+    
+    if(!module) {
+      // Simulate loading module
+      const fileUrl = `file://${filePath}?t=${Date.now()}`;
+      module = await import(fileUrl);
+      cache.set(filePath, module, stats, stats.size / 1024);
+    }
+    
+    console.log(`📁 ${path.basename(filePath)}: ${module ? '✅ cached' : '❌ loaded fresh'}`);
+  }
+};
+
+const displayCacheStats = (cache) => {
+  console.log('\n📊 Cache Statistics:');
+  console.log('─'.repeat(40));
+  
+  const stats = cache.getStats();
+  console.log(`Entries: ${stats.cache.size}/${stats.cache.maxSize}`);
+  console.log(`Memory: ${stats.cache.memoryUsageMB}/${stats.cache.maxMemoryMB}MB`);
+  console.log(`Hit Rate: ${cache.getHitRate()}%`);
+  console.log(`Hits: ${stats.stats.hits}, Misses: ${stats.stats.misses}`);
+  console.log(`File Changes: ${stats.stats.fileChanges}`);
+  console.log(`Heap Usage: ${stats.memory.heapUsedMB}MB (${stats.memory.heapUsagePercent}%)`);
+  
+  if(stats.cache.size > 0) {
+    console.log('\n📋 Cached Files:');
+    const cachedFiles = cache.getCachedFiles();
+    cachedFiles.forEach(file => {
+      const ageSeconds = Math.round(file.age / 1000);
+      console.log(`  • ${file.relativePath} (${file.sizeKB.toFixed(1)}KB, ${ageSeconds}s old)`);
+    });
+  }
+  console.log();
+};
+
+const main = async () => {
+  console.log('🚀 Kempo Server Module Cache Demo\n');
+  
+  // Create demo directory and files
+  const demoDir = path.join(process.cwd(), 'demo-cache-test');
+  console.log('📝 Creating demo files...');
+  const filePaths = await createDemoFiles(demoDir);
+  
+  // Initialize cache with small limits for demo
+  const cache = new ModuleCache({
+    maxSize: 2,
+    maxMemoryMB: 1,
+    ttlMs: 5000, // 5 seconds
+    watchFiles: true,
+    enableMemoryMonitoring: true
+  });
+  
+  console.log('✅ Cache initialized\n');
+  
+  try {
+    // Round 1: Initial loads (cache misses)
+    console.log('🔄 Round 1: Initial file access (expect cache misses)');
+    await simulateFileAccess(cache, filePaths);
+    displayCacheStats(cache);
+    
+    // Round 2: Immediate re-access (cache hits)
+    console.log('🔄 Round 2: Immediate re-access (expect cache hits)');
+    await simulateFileAccess(cache, [filePaths[0], filePaths[1]]);
+    displayCacheStats(cache);
+    
+    // Round 3: Add third file (should evict oldest due to maxSize=2)
+    console.log('🔄 Round 3: Access third file (expect LRU eviction)');
+    await simulateFileAccess(cache, [filePaths[2]]);
+    displayCacheStats(cache);
+    
+    // Round 4: Wait for TTL expiration
+    console.log('⏱️  Waiting 6 seconds for TTL expiration...');
+    await new Promise(resolve => setTimeout(resolve, 6000));
+    
+    console.log('🔄 Round 4: Access after TTL expiration (expect cache misses)');
+    await simulateFileAccess(cache, [filePaths[1]]);
+    displayCacheStats(cache);
+    
+    // Round 5: Demonstrate file watching
+    console.log('📝 Round 5: Modifying file to test file watching...');
+    await writeFile(filePaths[1], 
+      'export default async (req, res) => res.json({ posts: ["updated post"] });'
+    );
+    
+    // Wait for file watcher to detect change
+    await new Promise(resolve => setTimeout(resolve, 200));
+    
+    console.log('🔄 Accessing modified file (expect cache invalidation)');
+    await simulateFileAccess(cache, [filePaths[1]]);
+    displayCacheStats(cache);
+    
+  } finally {
+    // Cleanup
+    console.log('🧹 Cleaning up...');
+    cache.destroy();
+    await rm(demoDir, { recursive: true });
+    console.log('✅ Demo completed successfully!');
+  }
+};
+
+if(import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(console.error);
+}

package/utils/cache-monitor.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+/*
+  Cache Monitor Utility
+  Displays real-time cache statistics and memory usage
+*/
+
+import { spawn } from 'child_process';
+import { pathToFileURL } from 'url';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const formatBytes = (bytes) => {
+  const mb = bytes / 1024 / 1024;
+  return `${mb.toFixed(2)}MB`;
+};
+
+const formatPercent = (value) => `${value.toFixed(1)}%`;
+
+const clearScreen = () => process.stdout.write('\x1b[2J\x1b[0f');
+
+const displayStats = (stats) => {
+  clearScreen();
+  console.log('='.repeat(60));
+  console.log('📦 KEMPO SERVER - MODULE CACHE MONITOR');
+  console.log('='.repeat(60));
+  console.log();
+  
+  if (!stats) {
+    console.log('❌ Cache not available or disabled');
+    return;
+  }
+  
+  const { cache, stats: cacheStats, memory, config } = stats;
+  
+  // Cache Status
+  console.log('📊 CACHE STATUS');
+  console.log('-'.repeat(30));
+  console.log(`Entries:     ${cache.size}/${cache.maxSize} (${((cache.size/cache.maxSize)*100).toFixed(1)}%)`);
+  console.log(`Memory:      ${cache.memoryUsageMB}/${cache.maxMemoryMB}MB (${((cache.memoryUsageMB/cache.maxMemoryMB)*100).toFixed(1)}%)`);
+  console.log(`Watchers:    ${cache.watchersActive} active`);
+  console.log();
+  
+  // Performance Stats
+  console.log('⚡ PERFORMANCE');
+  console.log('-'.repeat(30));
+  const total = cacheStats.hits + cacheStats.misses;
+  const hitRate = total === 0 ? 0 : (cacheStats.hits / total * 100);
+  console.log(`Hit Rate:    ${hitRate.toFixed(1)}% (${cacheStats.hits} hits, ${cacheStats.misses} misses)`);
+  console.log(`Evictions:   ${cacheStats.evictions}`);
+  console.log(`File Changes: ${cacheStats.fileChanges}`);
+  console.log();
+  
+  // Memory Info
+  console.log('🧠 NODE.JS MEMORY');
+  console.log('-'.repeat(30));
+  console.log(`Heap Used:   ${memory.heapUsedMB}MB (${memory.heapUsagePercent}%)`);
+  console.log(`Heap Total:  ${memory.heapTotalMB}MB`);
+  console.log(`RSS:         ${memory.rssMB}MB`);
+  console.log();
+  
+  // Configuration
+  console.log('⚙️  CONFIGURATION');
+  console.log('-'.repeat(30));
+  console.log(`TTL:         ${Math.round(config.ttlMs / 1000)}s`);
+  console.log(`Max Heap:    ${config.maxHeapUsagePercent}%`);
+  console.log(`File Watch:  ${config.watchFiles ? '✅' : '❌'}`);
+  console.log();
+  
+  console.log(`Last updated: ${new Date().toLocaleTimeString()}`);
+  console.log('Press Ctrl+C to exit');
+};
+
+// Simulate getting stats from a running server
+// In a real implementation, you'd expose an endpoint or use IPC
+const getStatsFromServer = async () => {
+  // This is a placeholder - in practice you'd either:
+  // 1. Add an admin endpoint to your server that returns cache stats
+  // 2. Use process communication to get stats from the running server
+  // 3. Log stats to a file that this script reads
+  
+  // For demonstration, return mock stats
+  return {
+    cache: {
+      size: Math.floor(Math.random() * 100),
+      maxSize: 100,
+      memoryUsageMB: Math.random() * 50,
+      maxMemoryMB: 50,
+      watchersActive: Math.floor(Math.random() * 50)
+    },
+    stats: {
+      hits: Math.floor(Math.random() * 1000),
+      misses: Math.floor(Math.random() * 200),
+      evictions: Math.floor(Math.random() * 50),
+      fileChanges: Math.floor(Math.random() * 10)
+    },
+    memory: {
+      heapUsedMB: 45 + Math.random() * 20,
+      heapTotalMB: 70 + Math.random() * 30,
+      heapUsagePercent: 60 + Math.random() * 20,
+      rssMB: 80 + Math.random() * 40
+    },
+    config: {
+      ttlMs: 300000,
+      maxHeapUsagePercent: 70,
+      watchFiles: true
+    }
+  };
+};
+
+const main = async () => {
+  console.log('Starting cache monitor...');
+  
+  setInterval(async () => {
+    try {
+      const stats = await getStatsFromServer();
+      displayStats(stats);
+    } catch (error) {
+      console.error('Error getting stats:', error.message);
+    }
+  }, 2000); // Update every 2 seconds
+};
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+  console.log('\n\n👋 Cache monitor stopped');
+  process.exit(0);
+});
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main();
+}