memory-journal-mcp 4.4.2 → 4.5.0

package/src/database/SqliteAdapter.ts

@@ -9,7 +9,11 @@ import initSqlJs, { type Database } from 'sql.js'
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { logger } from '../utils/logger.js'
-import { validateDateFormatPattern } from '../utils/security-utils.js'
+import {
+    validateDateFormatPattern,
+    sanitizeSearchQuery,
+    assertNoPathTraversal,
+} from '../utils/security-utils.js'
 import type {
     JournalEntry,
     Tag,
@@ -168,6 +172,11 @@ export class SqliteAdapter {
 
         // Initialize schema
         this.db.run(SCHEMA_SQL)
+
+        // Enable foreign key enforcement (SQLite disables by default)
+        // Required for ON DELETE CASCADE in entry_tags, relationships, embeddings
+        this.db.run('PRAGMA foreign_keys = ON')
+
         this.initialized = true
 
         logger.info('Database opened', { module: 'SqliteAdapter', dbPath: this.dbPath })
@@ -582,9 +591,9 @@ export class SqliteAdapter {
 
         let sql = `
             SELECT * FROM memory_journal
-            WHERE deleted_at IS NULL AND content LIKE ?
+            WHERE deleted_at IS NULL AND content LIKE ? ESCAPE '\\'
         `
-        const params: unknown[] = [`%${query}%`]
+        const params: unknown[] = [`%${sanitizeSearchQuery(query)}%`]
 
         if (isPersonal !== undefined) {
             sql += ` AND is_personal = ?`
@@ -1037,6 +1046,11 @@ export class SqliteAdapter {
         const db = this.ensureDb()
         const backupsDir = this.getBackupsDir()
 
+        // Validate backup name against path traversal before sanitization
+        if (backupName) {
+            assertNoPathTraversal(backupName)
+        }
+
         // Ensure backups directory exists
         if (!fs.existsSync(backupsDir)) {
             fs.mkdirSync(backupsDir, { recursive: true })
@@ -1118,7 +1132,7 @@ export class SqliteAdapter {
     deleteOldBackups(keepCount: number): { deleted: string[]; kept: number } {
         const backups = this.listBackups() // Already sorted newest-first
 
-        if (keepCount < 1) {
+        if (keepCount < 1 || Number.isNaN(keepCount)) {
             throw new Error('keepCount must be at least 1')
         }
 
@@ -1155,9 +1169,7 @@ export class SqliteAdapter {
         newEntryCount: number
     }> {
         // Validate filename (prevent path traversal)
-        if (filename.includes('/') || filename.includes('\\') || filename.includes('..')) {
-            throw new Error('Invalid backup filename: path separators not allowed')
-        }
+        assertNoPathTraversal(filename)
 
         const backupsDir = this.getBackupsDir()
         const backupPath = path.join(backupsDir, filename)
@@ -1187,6 +1199,7 @@ export class SqliteAdapter {
         // Initialize new database from backup
         const SQL = await import('sql.js').then((m) => m.default())
         this.db = new SQL.Database(backupBuffer)
+        this.db.run('PRAGMA foreign_keys = ON')
         this.initialized = true
 
         // Get new entry count
@@ -1329,7 +1342,8 @@ export class SqliteAdapter {
     }
 
     /**
-     * Get raw database for advanced operations
+     * Get raw sql.js Database handle for advanced queries.
+     * @internal Callers MUST use parameterized queries — never concatenate user input into SQL.
      */
     getRawDb(): Database {
         return this.ensureDb()

package/src/handlers/resources/index.ts

@@ -10,6 +10,7 @@ import type { ToolFilterConfig } from '../../filtering/ToolFilter.js'
 import { getAllToolNames } from '../../filtering/ToolFilter.js'
 import type { Tag, McpIcon } from '../../types/index.js'
 import type { GitHubIntegration } from '../../github/GitHubIntegration.js'
+import type { Scheduler } from '../../server/Scheduler.js'
 import { generateInstructions, type InstructionLevel } from '../../constants/ServerInstructions.js'
 import { getPrompts } from '../prompts/index.js'
 import {
@@ -36,6 +37,7 @@ export interface ResourceContext {
     vectorManager?: VectorSearchManager
     filterConfig?: ToolFilterConfig | null
     github?: GitHubIntegration | null
+    scheduler?: Scheduler | null
 }
 
 /**
@@ -131,10 +133,11 @@ export async function readResource(
     db: SqliteAdapter,
     vectorManager?: VectorSearchManager,
     filterConfig?: ToolFilterConfig | null,
-    github?: GitHubIntegration | null
+    github?: GitHubIntegration | null,
+    scheduler?: Scheduler | null
 ): Promise<{ data: unknown; annotations?: { lastModified?: string } }> {
     const resources = getAllResourceDefinitions()
-    const context: ResourceContext = { db, vectorManager, filterConfig, github }
+    const context: ResourceContext = { db, vectorManager, filterConfig, github, scheduler }
 
     // Strip query parameters for matching, but pass full URI to handler
     const baseUri = getBaseUri(uri)
@@ -1172,6 +1175,9 @@ I have project memory access and will create entries for significant work.`,
                         ...dbHealth,
                         vectorIndex,
                         toolFilter,
+                        scheduler: context.scheduler
+                            ? context.scheduler.getStatus()
+                            : { active: false, jobs: [] },
                         timestamp: lastModified,
                     },
                     annotations: { lastModified },

package/src/handlers/tools/index.ts

@@ -37,12 +37,48 @@ export interface ToolContext {
 // Zod Schemas for Input Validation
 // ============================================================================
 
+/**
+ * Valid entry types (matches EntryType union in types/index.ts)
+ */
+const ENTRY_TYPES = [
+    'personal_reflection',
+    'project_decision',
+    'technical_achievement',
+    'bug_fix',
+    'feature_implementation',
+    'code_review',
+    'meeting_notes',
+    'learning',
+    'research',
+    'planning',
+    'retrospective',
+    'standup',
+    'other',
+] as const
+
+/**
+ * Valid significance types (matches SignificanceType union in types/index.ts)
+ */
+const SIGNIFICANCE_TYPES = [
+    'milestone',
+    'breakthrough',
+    'technical_breakthrough',
+    'decision',
+    'lesson_learned',
+    'blocker_resolved',
+    'release',
+] as const
+
+/** YYYY-MM-DD date format regex */
+const DATE_FORMAT_REGEX = /^\d{4}-\d{2}-\d{2}$/
+const DATE_FORMAT_MESSAGE = 'Date must be YYYY-MM-DD format'
+
 const CreateEntrySchema = z.object({
     content: z.string().min(1).max(50000),
-    entry_type: z.string().optional().default('personal_reflection'),
+    entry_type: z.enum(ENTRY_TYPES).optional().default('personal_reflection'),
     tags: z.array(z.string()).optional().default([]),
     is_personal: z.boolean().optional().default(true),
-    significance_type: z.string().optional(),
+    significance_type: z.enum(SIGNIFICANCE_TYPES).optional(),
     auto_context: z.boolean().optional().default(true),
     project_number: z.number().optional(),
     project_owner: z.string().optional(),
@@ -87,9 +123,9 @@ const SearchEntriesSchema = z.object({
 })
 
 const SearchByDateRangeSchema = z.object({
-    start_date: z.string(),
-    end_date: z.string(),
-    entry_type: z.string().optional(),
+    start_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE),
+    end_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE),
+    entry_type: z.enum(ENTRY_TYPES).optional(),
     tags: z.array(z.string()).optional(),
     is_personal: z.boolean().optional(),
     project_number: z.number().optional(),
@@ -112,8 +148,8 @@ const SemanticSearchSchema = z.object({
 
 const GetStatisticsSchema = z.object({
     group_by: z.enum(['day', 'week', 'month']).optional().default('week'),
-    start_date: z.string().optional(),
-    end_date: z.string().optional(),
+    start_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
+    end_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
     project_breakdown: z.boolean().optional().default(false),
 })
 
@@ -138,9 +174,9 @@ const LinkEntriesSchema = z.object({
 
 const ExportEntriesSchema = z.object({
     format: z.enum(['json', 'markdown']).optional().default('json'),
-    start_date: z.string().optional(),
-    end_date: z.string().optional(),
-    entry_types: z.array(z.string()).optional(),
+    start_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
+    end_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
+    entry_types: z.array(z.enum(ENTRY_TYPES)).optional(),
     tags: z.array(z.string()).optional(),
     limit: z.number().optional().default(100).describe('Maximum entries to export (default: 100)'),
 })
@@ -148,7 +184,7 @@ const ExportEntriesSchema = z.object({
 const UpdateEntrySchema = z.object({
     entry_id: z.number(),
     content: z.string().optional(),
-    entry_type: z.string().optional(),
+    entry_type: z.enum(ENTRY_TYPES).optional(),
     is_personal: z.boolean().optional(),
     tags: z.array(z.string()).optional(),
 })
@@ -1036,10 +1072,10 @@ function getAllToolDefinitions(context: ToolContext): ToolDefinition[] {
 
                 const entry = db.createEntry({
                     content: input.content,
-                    entryType: input.entry_type as EntryType,
+                    entryType: input.entry_type,
                     tags: input.tags,
-                    isPersonal: input.is_personal,
-                    significanceType: (input.significance_type as SignificanceType) ?? null,
+                    isPersonal: input.share_with_team ? false : input.is_personal,
+                    significanceType: input.significance_type ?? null,
                     projectNumber: input.project_number,
                     projectOwner: input.project_owner,
                     issueNumber: input.issue_number,
@@ -1184,7 +1220,7 @@ function getAllToolDefinitions(context: ToolContext): ToolDefinition[] {
             handler: (params: unknown) => {
                 const input = SearchByDateRangeSchema.parse(params)
                 const entries = db.searchByDateRange(input.start_date, input.end_date, {
-                    entryType: input.entry_type as EntryType | undefined,
+                    entryType: input.entry_type,
                     tags: input.tags,
                     isPersonal: input.is_personal,
                     projectNumber: input.project_number,
@@ -1277,8 +1313,16 @@ function getAllToolDefinitions(context: ToolContext): ToolDefinition[] {
             description: 'Analyze patterns across all GitHub Projects tracked in journal entries',
             group: 'analytics',
             inputSchema: z.object({
-                start_date: z.string().optional().describe('Start date (YYYY-MM-DD)'),
-                end_date: z.string().optional().describe('End date (YYYY-MM-DD)'),
+                start_date: z
+                    .string()
+                    .regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE)
+                    .optional()
+                    .describe('Start date (YYYY-MM-DD)'),
+                end_date: z
+                    .string()
+                    .regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE)
+                    .optional()
+                    .describe('End date (YYYY-MM-DD)'),
                 min_entries: z
                     .number()
                     .optional()
@@ -1290,8 +1334,14 @@ function getAllToolDefinitions(context: ToolContext): ToolDefinition[] {
             handler: (params: unknown) => {
                 const input = z
                     .object({
-                        start_date: z.string().optional(),
-                        end_date: z.string().optional(),
+                        start_date: z
+                            .string()
+                            .regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE)
+                            .optional(),
+                        end_date: z
+                            .string()
+                            .regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE)
+                            .optional(),
                         min_entries: z.number().optional().default(3),
                     })
                     .parse(params)
@@ -1744,7 +1794,7 @@ function getAllToolDefinitions(context: ToolContext): ToolDefinition[] {
                 const input = UpdateEntrySchema.parse(params)
                 const entry = db.updateEntry(input.entry_id, {
                     content: input.content,
-                    entryType: input.entry_type as EntryType | undefined,
+                    entryType: input.entry_type,
                     isPersonal: input.is_personal,
                     tags: input.tags,
                 })

package/src/server/McpServer.ts

@@ -13,6 +13,7 @@ import { randomUUID } from 'node:crypto'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import express from 'express'
 import type { Express, Request, Response } from 'express'
+import rateLimit from 'express-rate-limit'
 import { z } from 'zod'
 
 import { SqliteAdapter } from '../database/SqliteAdapter.js'
@@ -29,6 +30,7 @@ import { getTools, callTool } from '../handlers/tools/index.js'
 import { getResources, readResource } from '../handlers/resources/index.js'
 import { getPrompts, getPrompt } from '../handlers/prompts/index.js'
 import { generateInstructions } from '../constants/ServerInstructions.js'
+import { Scheduler, type SchedulerOptions } from './Scheduler.js'
 import pkg from '../../package.json' with { type: 'json' }
 
 /** Session timeout for stateful HTTP mode (30 minutes) */
@@ -47,6 +49,7 @@ export interface ServerOptions {
     autoRebuildIndex?: boolean
     statelessHttp?: boolean
     corsOrigin?: string
+    scheduler?: SchedulerOptions
 }
 
 /**
@@ -290,7 +293,8 @@ export async function createServer(options: ServerOptions): Promise<void> {
                         db,
                         vectorManager,
                         filterConfig,
-                        github
+                        github,
+                        scheduler
                     )
                     const dataStr =
                         typeof result.data === 'string'
@@ -324,7 +328,8 @@ export async function createServer(options: ServerOptions): Promise<void> {
                         db,
                         vectorManager,
                         filterConfig,
-                        github
+                        github,
+                        scheduler
                     )
                     const dataStr =
                         typeof result.data === 'string'
@@ -388,6 +393,25 @@ export async function createServer(options: ServerOptions): Promise<void> {
         )
     }
 
+    // Initialize scheduler (HTTP/SSE only)
+    let scheduler: Scheduler | null = null
+    if (options.scheduler) {
+        const hasAnyJob =
+            options.scheduler.backupIntervalMinutes > 0 ||
+            options.scheduler.vacuumIntervalMinutes > 0 ||
+            options.scheduler.rebuildIndexIntervalMinutes > 0
+
+        if (hasAnyJob && transport === 'stdio') {
+            logger.warning(
+                'Scheduler options ignored for stdio transport (session is ephemeral). ' +
+                    'Use HTTP/SSE transport for automated scheduling.',
+                { module: 'Scheduler' }
+            )
+        } else if (hasAnyJob) {
+            scheduler = new Scheduler(options.scheduler, db, vectorManager)
+        }
+    }
+
     // Start server based on transport
     if (transport === 'stdio') {
         const stdioTransport = new StdioServerTransport()
@@ -405,12 +429,24 @@ export async function createServer(options: ServerOptions): Promise<void> {
         const port = options.port ?? 3000
         const host = options.host ?? 'localhost'
         const corsOrigin = options.corsOrigin ?? process.env['MCP_CORS_ORIGIN'] ?? '*'
+
+        if (corsOrigin === '*') {
+            logger.warning(
+                'CORS origin is set to "*" (all origins). ' +
+                    'Set --cors-origin or MCP_CORS_ORIGIN for production deployments.',
+                { module: 'McpServer' }
+            )
+        }
+
         const app: Express = express()
 
         // Security headers middleware
         app.use((_req: Request, res: Response, next: () => void) => {
             res.setHeader('X-Content-Type-Options', 'nosniff')
             res.setHeader('X-Frame-Options', 'DENY')
+            res.setHeader('Content-Security-Policy', "default-src 'none'; frame-ancestors 'none'")
+            res.setHeader('Cache-Control', 'no-store')
+            res.setHeader('Referrer-Policy', 'no-referrer')
             next()
         })
 
@@ -437,6 +473,19 @@ export async function createServer(options: ServerOptions): Promise<void> {
         // JSON body parser with size limit to prevent memory exhaustion (DoS)
         app.use(express.json({ limit: '1mb' }))
 
+        // Rate limiting to prevent abuse (100 requests/minute per IP)
+        const limiter = rateLimit({
+            windowMs: 60 * 1000,
+            limit: 100,
+            standardHeaders: 'draft-8',
+            legacyHeaders: false,
+            message: { error: 'Too many requests, please try again later' },
+        })
+        app.use(limiter)
+        logger.info('Rate limiting enabled: 100 requests/minute per IP', {
+            module: 'McpServer',
+        })
+
         // Explicit OPTIONS handler for /mcp - MUST be before other /mcp routes
         // Using app.all to intercept before Express 5's auto-OPTIONS
         app.all('/mcp', (req: Request, res: Response, next: () => void) => {
@@ -498,6 +547,9 @@ export async function createServer(options: ServerOptions): Promise<void> {
                 })
             })
 
+            // Start scheduler after HTTP server is listening
+            scheduler?.start()
+
             httpServer.on('close', () => {
                 logger.info('HTTP server closed', { module: 'McpServer' })
             })
@@ -506,6 +558,7 @@ export async function createServer(options: ServerOptions): Promise<void> {
             process.on('SIGINT', () => {
                 logger.info('Shutting down HTTP server...', { module: 'McpServer' })
                 void (async () => {
+                    scheduler?.stop()
                     try {
                         await statelessTransport.close()
                     } catch (error) {
@@ -711,6 +764,9 @@ export async function createServer(options: ServerOptions): Promise<void> {
                 })
             })
 
+            // Start scheduler after HTTP server is listening
+            scheduler?.start()
+
             // Keep process alive - httpServer keeps the event loop active
             // but we also ensure it doesn't close prematurely
             httpServer.on('close', () => {
@@ -722,6 +778,8 @@ export async function createServer(options: ServerOptions): Promise<void> {
                 logger.info('Shutting down HTTP server...', { module: 'McpServer' })
 
                 void (async () => {
+                    scheduler?.stop()
+
                     // Close all active transports
                     for (const [sessionId, httpTransport] of transports) {
                         try {