memory-journal-mcp 6.1.2 → 6.2.1

package/src/transports/http/server/stateful.ts

@@ -1,222 +0,0 @@
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
-import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { randomUUID } from 'node:crypto'
-import type { Request, Response, Express } from 'express'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import { logger } from '../../../utils/logger.js'
-import {
-    SESSION_TIMEOUT_MS,
-    SESSION_SWEEP_INTERVAL_MS,
-    JSONRPC_SERVER_ERROR,
-    JSONRPC_INTERNAL_ERROR,
-} from '../types.js'
-import type { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js'
-
-export interface StatefulContext {
-    transports: Map<string, StreamableHTTPServerTransport>
-    // eslint-disable-next-line @typescript-eslint/no-deprecated -- backward compat
-    sseTransports: Map<string, SSEServerTransport>
-    sessionLastActivity: Map<string, number>
-    touchSession: (sid: string) => void
-    /** Tracks whether server.connect() has been called (close-before-reconnect pattern) */
-    serverConnected: boolean
-}
-
-export function setupStateful(
-    ctx: StatefulContext,
-    app: Express,
-    server: McpServer
-): ReturnType<typeof setInterval> {
-    const sessionSweepTimer = setInterval(() => {
-        const now = Date.now()
-        for (const [sid, lastActivity] of ctx.sessionLastActivity) {
-            const idleMs = now - lastActivity
-            if (idleMs <= SESSION_TIMEOUT_MS) continue
-
-            // Expire idle Streamable HTTP sessions
-            if (ctx.transports.has(sid)) {
-                logger.info('Expiring idle HTTP session', {
-                    module: 'HTTP',
-                    sessionId: sid,
-                    idleMinutes: Math.round(idleMs / 60_000),
-                })
-                const t = ctx.transports.get(sid)
-                if (t) {
-                    void t.close()
-                }
-                ctx.transports.delete(sid)
-                ctx.sessionLastActivity.delete(sid)
-            }
-
-            // Expire idle Legacy SSE sessions
-            if (ctx.sseTransports.has(sid)) {
-                logger.info('Expiring idle SSE session', {
-                    module: 'HTTP',
-                    sessionId: sid,
-                    idleMinutes: Math.round(idleMs / 60_000),
-                })
-                const t = ctx.sseTransports.get(sid)
-                if (t) {
-                    void t.close()
-                }
-                ctx.sseTransports.delete(sid)
-                ctx.sessionLastActivity.delete(sid)
-            }
-        }
-    }, SESSION_SWEEP_INTERVAL_MS)
-    sessionSweepTimer.unref()
-
-    // POST /mcp — Handle JSON-RPC requests
-    app.post('/mcp', (req: Request, res: Response): void => {
-        const sessionId = req.headers['mcp-session-id'] as string | undefined
-
-        void (async () => {
-            try {
-                let httpTransport: StreamableHTTPServerTransport | undefined
-
-                if (sessionId !== undefined && ctx.transports.has(sessionId)) {
-                    // Cross-protocol guard: reject SSE session IDs on /mcp
-                    if (ctx.sseTransports.has(sessionId)) {
-                        res.status(400).json({
-                            jsonrpc: '2.0',
-                            error: {
-                                code: JSONRPC_SERVER_ERROR,
-                                message:
-                                    'Bad Request: Session uses Legacy SSE transport, not Streamable HTTP',
-                            },
-                            id: null,
-                        })
-                        return
-                    }
-
-                    // Reuse existing transport and refresh session activity
-                    ctx.touchSession(sessionId)
-                    httpTransport = ctx.transports.get(sessionId)
-                } else if (sessionId === undefined && isInitializeRequest(req.body)) {
-                    // New initialization request — create transport
-                    const newTransport = new StreamableHTTPServerTransport({
-                        sessionIdGenerator: () => randomUUID(),
-                        onsessioninitialized: (sid: string) => {
-                            logger.info('HTTP session initialized', {
-                                module: 'HTTP',
-                                sessionId: sid,
-                            })
-                            ctx.transports.set(sid, newTransport)
-                            ctx.touchSession(sid)
-                        },
-                    })
-
-                    // Clean up on transport close
-                    newTransport.onclose = () => {
-                        const sid = newTransport.sessionId
-                        if (sid !== undefined && ctx.transports.has(sid)) {
-                            logger.info('HTTP transport closed', {
-                                module: 'HTTP',
-                                sessionId: sid,
-                            })
-                            ctx.transports.delete(sid)
-                            ctx.sessionLastActivity.delete(sid)
-                        }
-                    }
-
-                    // Connect transport to server
-                    // SDK requires close() before reconnecting to a new transport.
-                    // This cleanly supports sequential sessions; concurrent sessions
-                    // are an SDK limitation (only one transport at a time).
-                    if (ctx.serverConnected) {
-                        await server.close()
-                    }
-                    await server.connect(newTransport)
-                    ctx.serverConnected = true
-                    await newTransport.handleRequest(
-                        req as IncomingMessage,
-                        res as ServerResponse,
-                        req.body
-                    )
-                    return
-                } else {
-                    // Invalid request — no session ID or not initialization
-                    res.status(400).json({
-                        jsonrpc: '2.0',
-                        error: {
-                            code: JSONRPC_SERVER_ERROR,
-                            message: 'Bad Request: No valid session ID provided',
-                        },
-                        id: null,
-                    })
-                    return
-                }
-
-                // Handle request with existing transport
-                if (httpTransport !== undefined) {
-                    await httpTransport.handleRequest(
-                        req as IncomingMessage,
-                        res as ServerResponse,
-                        req.body
-                    )
-                }
-            } catch (error) {
-                logger.error('Error handling MCP request', {
-                    module: 'HTTP',
-                    error: error instanceof Error ? error.message : String(error),
-                })
-                if (!res.headersSent) {
-                    res.status(500).json({
-                        jsonrpc: '2.0',
-                        error: { code: JSONRPC_INTERNAL_ERROR, message: 'Internal server error' },
-                        id: null,
-                    })
-                }
-            }
-        })()
-    })
-
-    // GET /mcp — SSE stream for server-to-client notifications
-    app.get('/mcp', (req: Request, res: Response): void => {
-        const sessionId = req.headers['mcp-session-id'] as string | undefined
-
-        if (sessionId === undefined || !ctx.transports.has(sessionId)) {
-            res.status(400).send('Invalid or missing session ID')
-            return
-        }
-
-        // Refresh session activity on SSE reconnect
-        ctx.touchSession(sessionId)
-
-        const lastEventId = req.headers['last-event-id']
-        if (lastEventId !== undefined) {
-            logger.debug('Client reconnecting with Last-Event-ID', {
-                module: 'HTTP',
-                sessionId,
-                lastEventId,
-            })
-        }
-
-        const httpTransport = ctx.transports.get(sessionId)
-        if (httpTransport !== undefined) {
-            void httpTransport.handleRequest(req as IncomingMessage, res as ServerResponse)
-        }
-    })
-
-    // DELETE /mcp — Session termination
-    app.delete('/mcp', (req: Request, res: Response): void => {
-        const sessionId = req.headers['mcp-session-id'] as string | undefined
-
-        if (sessionId === undefined || !ctx.transports.has(sessionId)) {
-            res.status(400).send('Invalid or missing session ID')
-            return
-        }
-
-        logger.info('Session termination requested', {
-            module: 'HTTP',
-            sessionId,
-        })
-
-        const httpTransport = ctx.transports.get(sessionId)
-        if (httpTransport !== undefined) {
-            void httpTransport.handleRequest(req as IncomingMessage, res as ServerResponse)
-        }
-    })
-    return sessionSweepTimer
-}

package/src/transports/http/server/stateless.ts

@@ -1,42 +0,0 @@
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { Request, Response, Express } from 'express'
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import { logger } from '../../../utils/logger.js'
-import { JSONRPC_SERVER_ERROR } from '../types.js'
-
-export async function setupStateless(app: Express, server: McpServer): Promise<void> {
-    const statelessTransport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: undefined,
-        enableJsonResponse: true,
-    })
-
-    await server.connect(statelessTransport)
-    logger.info('Stateless transport connected', { module: 'HTTP' })
-
-    // POST /mcp — all requests go to the same transport
-    app.post('/mcp', (req: Request, res: Response): void => {
-        void statelessTransport.handleRequest(
-            req as IncomingMessage,
-            res as ServerResponse,
-            req.body
-        )
-    })
-
-    // GET /mcp — SSE not available in stateless mode
-    app.get('/mcp', (_req: Request, res: Response): void => {
-        res.status(405).json({
-            jsonrpc: '2.0',
-            error: {
-                code: JSONRPC_SERVER_ERROR,
-                message: 'SSE streaming not available in stateless mode',
-            },
-            id: null,
-        })
-    })
-
-    // DELETE /mcp — no-op in stateless mode
-    app.delete('/mcp', (_req: Request, res: Response): void => {
-        res.status(204).end()
-    })
-}

package/src/transports/http/types.ts

@@ -1,132 +0,0 @@
-/**
- * memory-journal-mcp — HTTP Transport Types
- *
- * Shared interfaces and constants for the HTTP transport module.
- */
-
-// =============================================================================
-// Server Timeout Constants
-// =============================================================================
-
-/** HTTP request timeout (ms) — prevents slowloris-style DoS */
-export const HTTP_REQUEST_TIMEOUT_MS = 120_000
-
-/** Keep-alive timeout (ms) — slightly above common LB idle timeout */
-export const HTTP_KEEP_ALIVE_TIMEOUT_MS = 65_000
-
-/** Headers timeout (ms) — must be > keepAliveTimeout per Node.js docs */
-export const HTTP_HEADERS_TIMEOUT_MS = 66_000
-
-// =============================================================================
-// Rate Limiting Constants
-// =============================================================================
-
-export const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000
-export const DEFAULT_RATE_LIMIT_MAX_REQUESTS = 100
-export const DEFAULT_MAX_BODY_BYTES = 1_048_576 // 1 MB
-export const DEFAULT_HSTS_MAX_AGE = 31_536_000 // 1 year
-
-/** CORS preflight cache duration (seconds) — browsers cache OPTIONS responses for 24h */
-export const CORS_PREFLIGHT_MAX_AGE_SECONDS = 86_400
-
-// =============================================================================
-// JSON-RPC Error Codes
-// =============================================================================
-
-/** JSON-RPC server error (protocol-level, not application errors) */
-export const JSONRPC_SERVER_ERROR = -32000
-
-/** JSON-RPC internal error */
-export const JSONRPC_INTERNAL_ERROR = -32603
-
-/** Session timeout for stateful HTTP mode (30 minutes) */
-export const SESSION_TIMEOUT_MS = 30 * 60 * 1000
-
-/** Session timeout sweep interval (5 minutes) */
-export const SESSION_SWEEP_INTERVAL_MS = 5 * 60 * 1000
-
-// =============================================================================
-// Rate Limiting
-// =============================================================================
-
-export interface RateLimitEntry {
-    count: number
-    resetTime: number
-}
-
-// =============================================================================
-// Configuration
-// =============================================================================
-
-/**
- * HTTP transport configuration
- */
-export interface HttpTransportConfig {
-    /** Port to listen on */
-    port: number
-
-    /** Host to bind to (default: localhost) */
-    host: string
-
-    /** Enable stateless HTTP mode (default: false) */
-    stateless: boolean
-
-    /** Bearer token for authentication (optional) */
-    authToken?: string
-
-    /**
-     * Allowed CORS origins. Defaults to ["*"] (all origins).
-     * Supports wildcard subdomains (e.g., "*.example.com" matches "app.example.com").
-     */
-    corsOrigins?: string[]
-
-    /** Allow credentials in CORS requests (default: false) */
-    corsAllowCredentials?: boolean
-
-    /**
-     * Trust proxy headers for client IP extraction (default: false).
-     * When enabled, uses the leftmost IP from X-Forwarded-For for rate limiting.
-     * Only enable when running behind a trusted reverse proxy.
-     */
-    trustProxy?: boolean
-
-    /**
-     * Enable HTTP Strict Transport Security header (default: false).
-     * Should only be enabled when running behind HTTPS.
-     */
-    enableHSTS?: boolean
-
-    /** HSTS max-age in seconds (default: 31536000 = 1 year) */
-    hstsMaxAge?: number
-
-    /** Enable rate limiting (default: true) */
-    enableRateLimit?: boolean
-
-    /** Rate limit window in milliseconds (default: 60000 = 1 minute) */
-    rateLimitWindowMs?: number
-
-    /** Maximum requests per window per IP (default: 100) */
-    rateLimitMaxRequests?: number
-
-    /** Maximum request body size in bytes (default: 1MB) */
-    maxBodySize?: number
-
-    // =================
-    // OAuth 2.1 Config
-    // =================
-
-    /** Enable OAuth 2.1 authentication (default: false) */
-    oauthEnabled?: boolean
-
-    /** OAuth issuer URL (authorization server) */
-    oauthIssuer?: string
-
-    /** Expected OAuth audience (client ID) */
-    oauthAudience?: string
-
-    /** JWKS URI for key discovery (auto-discovered if not set) */
-    oauthJwksUri?: string
-
-    /** Clock tolerance in seconds for token validation (default: 60) */
-    oauthClockTolerance?: number
-}

package/src/types/entities.ts

@@ -1,145 +0,0 @@
-/**
- * Memory Journal MCP Server - Database Entity Types
- */
-
-/**
- * Entry types for journal entries
- */
-export type EntryType =
-    | 'personal_reflection'
-    | 'project_decision'
-    | 'technical_achievement'
-    | 'bug_fix'
-    | 'feature_implementation'
-    | 'code_review'
-    | 'meeting_notes'
-    | 'learning'
-    | 'research'
-    | 'planning'
-    | 'retrospective'
-    | 'standup'
-    | 'technical_note'
-    | 'development_note'
-    | 'enhancement'
-    | 'milestone'
-    | 'system_integration_test'
-    | 'test_entry'
-    | 'other'
-
-/**
- * Significance types for important entries
- */
-export type SignificanceType =
-    | 'milestone'
-    | 'breakthrough'
-    | 'technical_breakthrough'
-    | 'decision'
-    | 'lesson_learned'
-    | 'blocker_resolved'
-    | 'release'
-    | null
-
-/**
- * Relationship types between entries
- *
- * Standard types:
- * - evolves_from: Entry builds upon previous work
- * - references: Entry mentions or links to another
- * - implements: Entry implements a spec/design
- * - clarifies: Entry explains or clarifies another
- * - response_to: Entry responds to a question/issue
- *
- * Causal types (for decision tracing):
- * - blocked_by: Entry was blocked by another (e.g., blocker → resolution)
- * - resolved: Entry resolved/fixed an issue from another
- * - caused: Entry caused or led to another outcome
- */
-export type RelationshipType =
-    | 'evolves_from'
-    | 'references'
-    | 'implements'
-    | 'clarifies'
-    | 'response_to'
-    | 'blocked_by'
-    | 'resolved'
-    | 'caused'
-
-/**
- * Journal entry entity
- */
-export interface JournalEntry {
-    id: number
-    entryType: EntryType
-    content: string
-    timestamp: string
-    isPersonal: boolean
-    significanceType: SignificanceType
-    autoContext: string | null
-    deletedAt: string | null
-    tags: string[]
-    // GitHub integration fields
-    projectNumber?: number | null
-    projectOwner?: string | null
-    issueNumber?: number | null
-    issueUrl?: string | null
-    prNumber?: number | null
-    prUrl?: string | null
-    prStatus?: string | null
-    workflowRunId?: number | null
-    workflowName?: string | null
-    workflowStatus?: string | null
-}
-
-/**
- * Tag entity
- */
-export interface Tag {
-    id: number
-    name: string
-    usageCount: number
-}
-
-/**
- * Relationship entity
- */
-export interface Relationship {
-    id: number
-    fromEntryId: number
-    toEntryId: number
-    relationshipType: RelationshipType
-    description: string | null
-    createdAt: string
-}
-
-/**
- * Embedding entity for vector search
- */
-export interface Embedding {
-    entryId: number
-    embedding: Float32Array
-    modelName: string
-}
-
-/**
- * Importance scoring breakdown showing weighted component contributions
- */
-export interface ImportanceBreakdown {
-    /** Significance type contribution (weight: 0.30) */
-    significance: number
-    /** Relationship count contribution (weight: 0.35) */
-    relationships: number
-    /** Causal relationship contribution (weight: 0.20) */
-    causal: number
-    /** Recency decay contribution (weight: 0.15) */
-    recency: number
-}
-
-/**
- * Importance calculation result with total score and component breakdown
- */
-export interface ImportanceResult {
-    /** Total importance score (0.0-1.0) */
-    score: number
-    /** Weighted component contributions */
-    breakdown: ImportanceBreakdown
-}

package/src/types/error-types.ts

@@ -1,92 +0,0 @@
-/**
- * memory-journal-mcp — Error Type Definitions
- *
- * Standardized error types for the harmonized error handling system
- * across all MCP servers (db-mcp, postgres-mcp, mysql-mcp, memory-journal-mcp).
- */
-
-// =============================================================================
-// Error Category
-// =============================================================================
-
-/**
- * Categorization of error types for structured error responses.
- * Enables agents to make programmatic decisions based on error category.
- */
-export enum ErrorCategory {
-    /** Input validation failures (bad params, schema violations) */
-    VALIDATION = 'validation',
-
-    /** Database/service connection failures */
-    CONNECTION = 'connection',
-
-    /** Query/operation execution failures */
-    QUERY = 'query',
-
-    /** Permission denied (insufficient privileges) */
-    PERMISSION = 'permission',
-
-    /** Server/service configuration errors */
-    CONFIGURATION = 'configuration',
-
-    /** Resource not found or unavailable */
-    RESOURCE = 'resource',
-
-    /** Authentication failures (invalid/expired credentials) */
-    AUTHENTICATION = 'authentication',
-
-    /** Authorization failures (valid credentials, insufficient access) */
-    AUTHORIZATION = 'authorization',
-
-    /** Internal/unexpected server errors */
-    INTERNAL = 'internal',
-}
-
-// =============================================================================
-// Error Response
-// =============================================================================
-
-/**
- * Structured error response returned by tools.
- * Provides agents with actionable context for error handling.
- */
-export interface ErrorResponse {
-    /** Always false for error responses */
-    success: false
-
-    /** Human-readable error message */
-    error: string
-
-    /** Module-prefixed error code (e.g., 'AUTH_TOKEN_EXPIRED') */
-    code: string
-
-    /** Error category for programmatic handling */
-    category: ErrorCategory
-
-    /** Actionable suggestion for resolving the error */
-    suggestion?: string
-
-    /** Whether the operation can be retried */
-    recoverable: boolean
-
-    /** Additional structured context */
-    details?: Record<string, unknown>
-}
-
-// =============================================================================
-// Error Context
-// =============================================================================
-
-/**
- * Context information for error reporting and diagnostics.
- */
-export interface ErrorContext {
-    /** The operation that failed */
-    operation?: string
-
-    /** Entity identifier involved */
-    entityId?: string | number
-
-    /** Additional context key-value pairs */
-    [key: string]: unknown
-}