memory-journal-mcp 4.4.2 → 4.5.0

package/src/server/Scheduler.ts

@@ -0,0 +1,278 @@
+/**
+ * Memory Journal MCP Server - Scheduler
+ *
+ * Lightweight in-process scheduler for periodic maintenance jobs.
+ * Only meaningful for HTTP/SSE transport (long-lived server processes).
+ * Uses setInterval for simplicity — no external dependencies.
+ */
+
+import type { SqliteAdapter } from '../database/SqliteAdapter.js'
+import type { VectorSearchManager } from '../vector/VectorSearchManager.js'
+import { logger } from '../utils/logger.js'
+
+// ============================================================================
+// Types
+// ============================================================================
+
+/** Scheduler configuration options */
+export interface SchedulerOptions {
+    /** Automated backup interval in minutes (0 = disabled) */
+    backupIntervalMinutes: number
+    /** Max backups to retain during automated cleanup */
+    keepBackups: number
+    /** Database optimize interval in minutes (0 = disabled) */
+    vacuumIntervalMinutes: number
+    /** Vector index rebuild interval in minutes (0 = disabled) */
+    rebuildIndexIntervalMinutes: number
+}
+
+/** Status of a single scheduled job */
+export interface JobStatus {
+    name: string
+    enabled: boolean
+    intervalMinutes: number
+    lastRun: string | null
+    lastResult: 'success' | 'error' | null
+    lastError: string | null
+    nextRun: string | null
+    runCount: number
+}
+
+/** Overall scheduler status */
+export interface SchedulerStatus {
+    active: boolean
+    jobs: JobStatus[]
+}
+
+/** Internal timer tracking for a job */
+interface JobTimer {
+    name: string
+    intervalMinutes: number
+    timer: ReturnType<typeof setInterval>
+    lastRun: Date | null
+    lastResult: 'success' | 'error' | null
+    lastError: string | null
+    runCount: number
+}
+
+// ============================================================================
+// Scheduler
+// ============================================================================
+
+/**
+ * Scheduler — runs periodic maintenance jobs for long-lived server processes.
+ *
+ * Jobs:
+ * - **backup**: Exports database to timestamped file, then prunes old backups.
+ * - **vacuum**: Runs `PRAGMA optimize` and flushes database to disk.
+ * - **rebuild-index**: Rebuilds vector search index from all entries.
+ */
+export class Scheduler {
+    private readonly options: SchedulerOptions
+    private readonly db: SqliteAdapter
+    private readonly vectorManager: VectorSearchManager | null
+    private readonly timers: JobTimer[] = []
+    private started = false
+
+    constructor(options: SchedulerOptions, db: SqliteAdapter, vectorManager?: VectorSearchManager) {
+        this.options = options
+        this.db = db
+        this.vectorManager = vectorManager ?? null
+    }
+
+    /**
+     * Start all enabled scheduled jobs.
+     * Each job runs on its own interval and failures are isolated.
+     */
+    start(): void {
+        if (this.started) {
+            logger.warning('Scheduler already started, ignoring duplicate start()', {
+                module: 'Scheduler',
+            })
+            return
+        }
+        this.started = true
+
+        const { backupIntervalMinutes, vacuumIntervalMinutes, rebuildIndexIntervalMinutes } =
+            this.options
+
+        if (backupIntervalMinutes > 0) {
+            this.scheduleJob('backup', backupIntervalMinutes, () => this.runBackup())
+        }
+
+        if (vacuumIntervalMinutes > 0) {
+            this.scheduleJob('vacuum', vacuumIntervalMinutes, () => this.runVacuumOptimize())
+        }
+
+        if (rebuildIndexIntervalMinutes > 0) {
+            if (this.vectorManager) {
+                this.scheduleJob('rebuild-index', rebuildIndexIntervalMinutes, () =>
+                    this.runRebuildIndex()
+                )
+            } else {
+                logger.warning(
+                    'rebuild-index-interval specified but vector manager not available, skipping',
+                    { module: 'Scheduler' }
+                )
+            }
+        }
+
+        if (this.timers.length > 0) {
+            const summary = this.timers.map((t) => `${t.name} (${String(t.intervalMinutes)}min)`)
+            logger.info(`Scheduler started: ${summary.join(', ')}`, { module: 'Scheduler' })
+        } else {
+            logger.info('Scheduler started with no jobs enabled', { module: 'Scheduler' })
+        }
+    }
+
+    /**
+     * Stop all scheduled jobs and clear timers.
+     * Safe to call multiple times.
+     */
+    stop(): void {
+        for (const job of this.timers) {
+            clearInterval(job.timer)
+        }
+        if (this.timers.length > 0) {
+            logger.info(`Scheduler stopped, cleared ${String(this.timers.length)} job(s)`, {
+                module: 'Scheduler',
+            })
+        }
+        this.timers.length = 0
+        this.started = false
+    }
+
+    /**
+     * Get the current status of all scheduled jobs.
+     */
+    getStatus(): SchedulerStatus {
+        return {
+            active: this.started,
+            jobs: this.timers.map((t) => ({
+                name: t.name,
+                enabled: true,
+                intervalMinutes: t.intervalMinutes,
+                lastRun: t.lastRun?.toISOString() ?? null,
+                lastResult: t.lastResult,
+                lastError: t.lastError,
+                nextRun: t.lastRun
+                    ? new Date(t.lastRun.getTime() + t.intervalMinutes * 60_000).toISOString()
+                    : new Date(Date.now() + t.intervalMinutes * 60_000).toISOString(),
+                runCount: t.runCount,
+            })),
+        }
+    }
+
+    // ========================================================================
+    // Private — Job scheduling
+    // ========================================================================
+
+    /**
+     * Schedule a recurring job.
+     */
+    private scheduleJob(name: string, intervalMinutes: number, fn: () => Promise<void>): void {
+        const intervalMs = intervalMinutes * 60_000
+
+        const jobTimer: JobTimer = {
+            name,
+            intervalMinutes,
+            timer: setInterval(() => {
+                void this.executeJob(jobTimer, fn)
+            }, intervalMs),
+            lastRun: null,
+            lastResult: null,
+            lastError: null,
+            runCount: 0,
+        }
+
+        this.timers.push(jobTimer)
+    }
+
+    /**
+     * Execute a job with error isolation and status tracking.
+     */
+    private async executeJob(job: JobTimer, fn: () => Promise<void>): Promise<void> {
+        const startTime = Date.now()
+        try {
+            await fn()
+            job.lastRun = new Date(startTime)
+            job.lastResult = 'success'
+            job.lastError = null
+            job.runCount++
+        } catch (error) {
+            job.lastRun = new Date(startTime)
+            job.lastResult = 'error'
+            job.lastError = error instanceof Error ? error.message : String(error)
+            job.runCount++
+            logger.error(`Scheduled job '${job.name}' failed`, {
+                module: 'Scheduler',
+                operation: job.name,
+                error: job.lastError,
+            })
+        }
+    }
+
+    // ========================================================================
+    // Private — Job implementations
+    // ========================================================================
+
+    /**
+     * Backup job: export database to file, then cleanup old backups.
+     */
+    private async runBackup(): Promise<void> {
+        const result = this.db.exportToFile()
+        logger.info('Scheduled backup created', {
+            module: 'Scheduler',
+            operation: 'backup',
+            context: { filename: result.filename, sizeBytes: result.sizeBytes },
+        })
+
+        const cleanup = this.db.deleteOldBackups(this.options.keepBackups)
+        if (cleanup.deleted.length > 0) {
+            logger.info(
+                `Backup cleanup: deleted ${String(cleanup.deleted.length)}, kept ${String(cleanup.kept)}`,
+                {
+                    module: 'Scheduler',
+                    operation: 'backup-cleanup',
+                }
+            )
+        }
+
+        await Promise.resolve()
+    }
+
+    /**
+     * Vacuum/optimize job: run PRAGMA optimize and flush to disk.
+     *
+     * Note: sql.js uses an in-memory database. PRAGMA optimize updates
+     * internal statistics, and flushSave() ensures the disk file is current.
+     * A full VACUUM on sql.js only compacts the in-memory representation.
+     */
+    private async runVacuumOptimize(): Promise<void> {
+        const rawDb = this.db.getRawDb()
+        rawDb.run('PRAGMA optimize')
+        this.db.flushSave()
+        logger.info('Scheduled database optimize completed', {
+            module: 'Scheduler',
+            operation: 'vacuum',
+        })
+
+        await Promise.resolve()
+    }
+
+    /**
+     * Rebuild index job: full vector index rebuild from database entries.
+     */
+    private async runRebuildIndex(): Promise<void> {
+        if (!this.vectorManager) {
+            return
+        }
+
+        const count = await this.vectorManager.rebuildIndex(this.db)
+        logger.info(`Scheduled vector index rebuild: ${String(count)} entries indexed`, {
+            module: 'Scheduler',
+            operation: 'rebuild-index',
+            context: { entriesIndexed: count },
+        })
+    }
+}

package/src/utils/logger.ts

@@ -97,11 +97,14 @@ class Logger {
     }
 
     setLevel(level: LogLevel): void {
-        this.minLevel = LOG_LEVELS[level]
+        if (level in LOG_LEVELS) {
+            this.minLevel = LOG_LEVELS[level]
+        }
     }
 }
 
-// Get log level from environment
-const envLevel = (process.env['LOG_LEVEL'] ?? 'info') as LogLevel
+// Get log level from environment (validated against known levels)
+const rawLevel = process.env['LOG_LEVEL'] ?? 'info'
+const envLevel: LogLevel = rawLevel in LOG_LEVELS ? (rawLevel as LogLevel) : 'info'
 
 export const logger = new Logger(envLevel)

package/src/utils/security-utils.ts

@@ -32,16 +32,6 @@ export class InvalidDateFormatError extends SecurityError {
     }
 }
 
-/**
- * Thrown when SQL injection patterns are detected in input
- */
-export class SqlInjectionError extends SecurityError {
-    constructor(pattern: string) {
-        super(`Potential SQL injection detected: '${pattern}'`, 'SQL_INJECTION')
-        this.name = 'SqlInjectionError'
-    }
-}
-
 /**
  * Thrown when path traversal is detected in input
  */
@@ -111,48 +101,6 @@ export function sanitizeSearchQuery(query: string): string {
     return query.replace(/\\/g, '\\\\').replace(/%/g, '\\%').replace(/_/g, '\\_')
 }
 
-// ============================================================================
-// SQL Injection Detection
-// ============================================================================
-
-/**
- * Patterns that indicate SQL injection attempts.
- * Used for validation in edge cases where parameterized queries aren't possible.
- */
-const SQL_INJECTION_PATTERNS = [
-    /;\s*(DROP|DELETE|INSERT|UPDATE|CREATE|ALTER|TRUNCATE)/i,
-    /--\s*/,
-    /\/\*[\s\S]*?\*\//,
-    /UNION\s+(ALL\s+)?SELECT/i,
-    /'\s*OR\s+['"]?1['"]?\s*=\s*['"]?1/i,
-    /ATTACH\s+DATABASE/i,
-    /DETACH\s+DATABASE/i,
-    /load_extension\s*\(/i,
-] as const
-
-/**
- * Checks if a string contains potential SQL injection patterns.
- * This is a secondary defense layer; parameterized queries are the primary defense.
- *
- * @param input - The string to check
- * @returns true if injection patterns are detected, false otherwise
- */
-export function containsSqlInjection(input: string): boolean {
-    return SQL_INJECTION_PATTERNS.some((pattern) => pattern.test(input))
-}
-
-/**
- * Validates that input does not contain SQL injection patterns.
- *
- * @param input - The string to validate
- * @throws SqlInjectionError if injection patterns are detected
- */
-export function assertNoSqlInjection(input: string): void {
-    if (containsSqlInjection(input)) {
-        throw new SqlInjectionError(input.substring(0, 50))
-    }
-}
-
 // ============================================================================
 // Path Validation
 // ============================================================================

package/tests/constants/server-instructions.test.ts

@@ -99,6 +99,32 @@ describe('generateInstructions', () => {
             )
             expect(result).not.toContain('## GitHub Integration')
         })
+
+        it('should include Session End section', () => {
+            const result = generateInstructions(
+                TEST_TOOLS,
+                TEST_RESOURCES,
+                TEST_PROMPTS,
+                undefined,
+                'essential'
+            )
+            expect(result).toContain('Session End')
+            expect(result).toContain('session-summary')
+            expect(result).toContain('retrospective')
+            expect(result).toContain('opt-out')
+        })
+
+        it('should include Rule & Skill Suggestions section', () => {
+            const result = generateInstructions(
+                TEST_TOOLS,
+                TEST_RESOURCES,
+                TEST_PROMPTS,
+                undefined,
+                'essential'
+            )
+            expect(result).toContain('Rule & Skill Suggestions')
+            expect(result).toContain('always ask the user first')
+        })
     })
 
     describe('standard level', () => {

package/tests/database/sqlite-adapter.test.ts

@@ -471,6 +471,65 @@ describe('SqliteAdapter', () => {
                 fs.unlinkSync(backup.path)
             }
         })
+
+        it('should delete old backups keeping only keepCount', () => {
+            const fs = require('node:fs')
+
+            // Clean up any pre-existing backups from other tests
+            const preExisting = db.listBackups()
+            for (const backup of preExisting) {
+                if (fs.existsSync(backup.path)) fs.unlinkSync(backup.path)
+            }
+
+            // Create 3 backups
+            const b1 = db.exportToFile('cleanup-1')
+            const b2 = db.exportToFile('cleanup-2')
+            const b3 = db.exportToFile('cleanup-3')
+
+            // Keep only 1 newest
+            db.deleteOldBackups(1)
+
+            const remaining = db.listBackups()
+            // Should have exactly 1 backup remaining (newest)
+            expect(remaining.length).toBe(1)
+
+            // Cleanup any remaining
+            for (const path of [b1.path, b2.path, b3.path]) {
+                if (fs.existsSync(path)) fs.unlinkSync(path)
+            }
+        })
+
+        it('should restore from a backup file', async () => {
+            const fs = require('node:fs')
+            // Create an entry and backup
+            db.createEntry({ content: 'Before restore test' })
+            const countBefore = db.getActiveEntryCount()
+            const backup = db.exportToFile('restore-test')
+
+            // Create more entries after backup
+            db.createEntry({ content: 'After backup 1' })
+            db.createEntry({ content: 'After backup 2' })
+            const countAfterAdding = db.getActiveEntryCount()
+            expect(countAfterAdding).toBeGreaterThan(countBefore)
+
+            // Restore should revert to backup state
+            const result = await db.restoreFromFile(backup.filename)
+            expect(result.previousEntryCount).toBe(countAfterAdding)
+            expect(result.newEntryCount).toBe(countBefore)
+
+            // Cleanup
+            const backups = db.listBackups()
+            for (const b of backups) {
+                const path = require('node:path').join('backups', b.filename)
+                if (fs.existsSync(path)) fs.unlinkSync(path)
+            }
+        })
+
+        it('should get raw database handle', () => {
+            const rawDb = db.getRawDb()
+            expect(rawDb).toBeDefined()
+            expect(typeof rawDb.exec).toBe('function')
+        })
     })
 
     // ========================================================================
@@ -552,4 +611,29 @@ describe('SqliteAdapter', () => {
             expect(results.length).toBeGreaterThan(0)
         })
     })
+
+    // ========================================================================
+    // Backup edge cases
+    // ========================================================================
+
+    describe('backup edge cases', () => {
+        it('should return empty array when backups directory does not exist', () => {
+            // Use a fresh adapter with no backups dir created
+            const tempDb = new SqliteAdapter('./test-no-backups.db')
+            tempDb.initialize()
+            const backups = tempDb.listBackups()
+            expect(backups).toEqual([])
+            tempDb.close()
+        })
+
+        it('should throw when deleteOldBackups keepCount is less than 1', () => {
+            expect(() => db.deleteOldBackups(0)).toThrow('keepCount must be at least 1')
+        })
+
+        it('should throw when restoring from non-existent backup file', async () => {
+            await expect(db.restoreFromFile('nonexistent-backup.db')).rejects.toThrow(
+                'Backup file not found'
+            )
+        })
+    })
 })

package/tests/filtering/tool-filter.test.ts

@@ -264,3 +264,49 @@ describe('getFilterSummary', () => {
         expect(summary.length).toBeGreaterThan(0)
     })
 })
+
+// ============================================================================
+// parseToolFilter edge cases
+// ============================================================================
+
+describe('parseToolFilter edge cases', () => {
+    it('should handle blacklist-first mode (-admin = all except admin)', () => {
+        const config = parseToolFilter('-admin')
+        // Should have all tools EXCEPT admin tools
+        expect(config.enabledTools.has('create_entry')).toBe(true)
+        expect(config.enabledTools.has('search_entries')).toBe(true)
+        expect(config.enabledTools.has('backup_journal')).toBe(true)
+        // Admin tools should be excluded
+        expect(config.enabledTools.has('delete_entry')).toBe(false)
+    })
+
+    it('should handle single tool name whitelist', () => {
+        const config = parseToolFilter('create_entry')
+        expect(config.enabledTools.has('create_entry')).toBe(true)
+        expect(config.enabledTools.size).toBe(1)
+    })
+
+    it('should handle meta-group in non-first position', () => {
+        const config = parseToolFilter('backup,starter')
+        // starter = core + search, plus backup group
+        expect(config.enabledTools.has('create_entry')).toBe(true)
+        expect(config.enabledTools.has('search_entries')).toBe(true)
+        expect(config.enabledTools.has('backup_journal')).toBe(true)
+    })
+
+    it('should handle combined meta-group with tool exclusion', () => {
+        const config = parseToolFilter('starter,-create_entry_minimal')
+        expect(config.enabledTools.has('create_entry')).toBe(true)
+        expect(config.enabledTools.has('create_entry_minimal')).toBe(false)
+    })
+
+    it('should handle multiple exclusions', () => {
+        const config = parseToolFilter('full,-admin,-backup,-github')
+        expect(config.enabledTools.has('create_entry')).toBe(true)
+        expect(config.enabledTools.has('search_entries')).toBe(true)
+        // Excluded groups
+        expect(config.enabledTools.has('delete_entry')).toBe(false)
+        expect(config.enabledTools.has('backup_journal')).toBe(false)
+        expect(config.enabledTools.has('get_github_issues')).toBe(false)
+    })
+})