mcp-creatio 0.3.6

package/src/services/session-context.ts

@@ -0,0 +1,232 @@
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+
+import log from '../log';
+
+export interface SessionInfo {
+	id: string;
+	userKey?: string | undefined;
+	transport?: StreamableHTTPServerTransport | undefined;
+	isLogged: boolean;
+	createdAt: Date;
+	remoteIp?: string | undefined;
+}
+
+export interface UserTokens {
+	accessToken: string;
+	accessTokenExpiryMs: number;
+	refreshToken?: string | undefined;
+}
+
+export interface OAuthState {
+	userKey: string;
+	createdAt: number;
+	expiresAt: number;
+}
+
+export class SessionContext {
+	private static _instance: SessionContext | undefined;
+	private readonly _sessions = new Map<string, SessionInfo>();
+	private readonly _userTokens = new Map<string, UserTokens>();
+	private readonly _oauthStates = new Map<string, OAuthState>();
+	private readonly _deletingSessions = new Set<string>();
+
+	public static get instance(): SessionContext {
+		if (!SessionContext._instance) {
+			SessionContext._instance = new SessionContext();
+		}
+		return SessionContext._instance;
+	}
+
+	private _generateState(): string {
+		return (
+			Math.random().toString(36).substring(2, 15) +
+			Math.random().toString(36).substring(2, 15)
+		);
+	}
+
+	public createSession(sessionId: string, userKey?: string, remoteIp?: string): SessionInfo {
+		const session: SessionInfo = {
+			id: sessionId,
+			isLogged: false,
+			createdAt: new Date(),
+		};
+		if (userKey !== undefined) {
+			session.userKey = userKey;
+		}
+		if (remoteIp !== undefined) {
+			session.remoteIp = remoteIp;
+		}
+		this._sessions.set(sessionId, session);
+		return session;
+	}
+
+	public getSession(sessionId: string): SessionInfo | undefined {
+		return this._sessions.get(sessionId);
+	}
+
+	public hasSession(sessionId: string): boolean {
+		return this._sessions.has(sessionId);
+	}
+
+	public markSessionAsLogged(sessionId: string): boolean {
+		const session = this._sessions.get(sessionId);
+		if (session) {
+			session.isLogged = true;
+			return true;
+		}
+		return false;
+	}
+
+	public setSessionTransport(sessionId: string, transport: StreamableHTTPServerTransport): void {
+		const session = this._sessions.get(sessionId);
+		if (session) {
+			session.transport = transport;
+		}
+	}
+
+	public mapSessionToUser(sessionId: string, userKey: string): void {
+		const session = this._sessions.get(sessionId);
+		if (session) {
+			session.userKey = userKey;
+			log.info('session_mapping.set', { sessionId, userKey });
+		}
+	}
+
+	public deleteSession(sessionId: string): void {
+		if (this._deletingSessions.has(sessionId)) {
+			return;
+		}
+		this._deletingSessions.add(sessionId);
+		const session = this._sessions.get(sessionId);
+		this._sessions.delete(sessionId);
+		if (session?.transport) {
+			try {
+				session.transport.close();
+			} catch (err) {
+				log.warn('transport.close.failed', { sessionId, error: String(err) });
+			}
+		}
+		this._deletingSessions.delete(sessionId);
+	}
+
+	public getAllSessions(): SessionInfo[] {
+		return Array.from(this._sessions.values());
+	}
+
+	public getSessionsForUser(userKey: string): SessionInfo[] {
+		return Array.from(this._sessions.values()).filter((s) => s.userKey === userKey);
+	}
+
+	public async getTokensForSession(sessionId: string): Promise<UserTokens | null> {
+		const session = this._sessions.get(sessionId);
+		if (!session?.userKey) {
+			return null;
+		}
+		return this.getTokensForUser(session.userKey);
+	}
+
+	public async getTokensForUser(userKey: string): Promise<UserTokens | null> {
+		return this._userTokens.get(userKey) || null;
+	}
+
+	public async setTokensForUser(userKey: string, tokens: UserTokens): Promise<void> {
+		this._userTokens.set(userKey, tokens);
+	}
+
+	public async deleteTokensForUser(userKey: string): Promise<void> {
+		this._userTokens.delete(userKey);
+	}
+
+	public createOAuthState(userKey: string): string {
+		const state = this._generateState();
+		const stateInfo: OAuthState = {
+			userKey,
+			createdAt: Date.now(),
+			expiresAt: Date.now() + 10 * 60 * 1000,
+		};
+		this._oauthStates.set(state, stateInfo);
+		return state;
+	}
+
+	public validateOAuthState(state: string): {
+		userKey: string;
+	} | null {
+		const stateInfo = this._oauthStates.get(state);
+		if (!stateInfo) {
+			return null;
+		}
+		if (Date.now() > stateInfo.expiresAt) {
+			this._oauthStates.delete(state);
+			return null;
+		}
+		this._oauthStates.delete(state);
+		return { userKey: stateInfo.userKey };
+	}
+
+	public validateAndConsumeOAuthState(state: string): string | undefined {
+		const result = this.validateOAuthState(state);
+		return result?.userKey;
+	}
+
+	public setSessionUserKey(sessionId: string, userKey: string): void {
+		const session = this._sessions.get(sessionId);
+		if (session) {
+			session.userKey = userKey;
+			log.info('session_mapping.set', { sessionId, userKey });
+		}
+	}
+
+	public cleanupExpiredOAuthStates(): void {
+		const now = Date.now();
+		for (const [state, stateInfo] of this._oauthStates.entries()) {
+			if (now > stateInfo.expiresAt) {
+				this._oauthStates.delete(state);
+			}
+		}
+	}
+
+	public async getEffectiveTokens(
+		sessionId?: string,
+		userKey?: string,
+	): Promise<UserTokens | null> {
+		if (userKey) {
+			return this.getTokensForUser(userKey);
+		}
+		if (sessionId) {
+			return this.getTokensForSession(sessionId);
+		}
+		return null;
+	}
+
+	public async createSessionWithUser(
+		sessionId: string,
+		userKey: string,
+		remoteIp?: string,
+	): Promise<SessionInfo> {
+		const session = this.createSession(sessionId, userKey, remoteIp);
+		return session;
+	}
+
+	public mapAllSessionsToUser(userKey: string): void {
+		const sessionIds: string[] = [];
+		for (const [sessionId, session] of this._sessions.entries()) {
+			if (session.transport) {
+				session.userKey = userKey;
+				sessionIds.push(sessionId);
+			}
+		}
+		log.info('mapping_all_sessions', {
+			userKey,
+			sessionCount: sessionIds.length,
+			sessionIds,
+		});
+	}
+
+	public getStats(): { sessionsCount: number; tokensCount: number; oauthStatesCount: number } {
+		return {
+			sessionsCount: this._sessions.size,
+			tokensCount: this._userTokens.size,
+			oauthStatesCount: this._oauthStates.size,
+		};
+	}
+}

package/src/services/token-refresh-scheduler.ts

@@ -0,0 +1,68 @@
+import log from '../log';
+import { SessionContext } from '../services';
+export type TokenRefreshCallback = (userKey: string) => Promise<void>;
+
+export class TokenRefreshScheduler {
+	private readonly _refreshIntervals = new Map<string, NodeJS.Timeout>();
+	private readonly _sessionContext = SessionContext.instance;
+	private _refreshCallback?: TokenRefreshCallback;
+
+	private async _refreshUserTokens(userKey: string): Promise<void> {
+		if (!this._refreshCallback) {
+			throw new Error('no_refresh_callback');
+		}
+		const tokens = await this._sessionContext.getTokensForUser(userKey);
+		if (!tokens?.refreshToken) {
+			throw new Error('no_refresh_token');
+		}
+		const sessions = this._sessionContext.getSessionsForUser(userKey);
+		if (sessions.length === 0) {
+			throw new Error('no_active_sessions');
+		}
+		await this._refreshCallback(userKey);
+		log.info('background_token_refresh_success', { userKey, sessionsCount: sessions.length });
+	}
+
+	public setRefreshCallback(callback: TokenRefreshCallback): void {
+		this._refreshCallback = callback;
+	}
+
+	public scheduleRefresh(userKey: string): void {
+		this.cancelRefresh(userKey);
+		const refreshInterval = setInterval(
+			async () => {
+				try {
+					await this._refreshUserTokens(userKey);
+				} catch (err) {
+					log.warn('background_token_refresh_failed', { userKey, error: String(err) });
+					this.cancelRefresh(userKey);
+				}
+			},
+			15 * 60 * 1000,
+		);
+		this._refreshIntervals.set(userKey, refreshInterval);
+		log.info('token_refresh_scheduled', { userKey });
+	}
+
+	public cancelRefresh(userKey: string): void {
+		const interval = this._refreshIntervals.get(userKey);
+		if (interval) {
+			clearInterval(interval);
+			this._refreshIntervals.delete(userKey);
+			log.info('token_refresh_cancelled', { userKey });
+		}
+	}
+
+	public cancelAllRefresh(): void {
+		for (const userKey of this._refreshIntervals.keys()) {
+			this.cancelRefresh(userKey);
+		}
+	}
+
+	public getStats(): { activeRefreshCount: number; userKeys: string[] } {
+		return {
+			activeRefreshCount: this._refreshIntervals.size,
+			userKeys: Array.from(this._refreshIntervals.keys()),
+		};
+	}
+}

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './network';

package/src/types/network.ts

@@ -0,0 +1,7 @@
+export type CookieKV = {
+	name: string;
+	value: string;
+};
+
+export const JSON_ACCEPT = 'application/json';
+export const XML_ACCEPT = 'application/xml';

package/src/utils/context.ts

@@ -0,0 +1,49 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+import { SessionContext } from '../services';
+
+export type RequestContext = {
+	userKey?: string | undefined;
+	sessionId?: string | undefined;
+};
+
+const als = new AsyncLocalStorage<RequestContext>();
+
+const sessionContext = SessionContext.instance;
+
+export function runWithContext<T>(ctx: Partial<RequestContext>, fn: () => Promise<T>): Promise<T> {
+	const store: RequestContext = {};
+	if (typeof ctx.userKey === 'string') {
+		store.userKey = ctx.userKey;
+	}
+	if (typeof ctx.sessionId === 'string') {
+		store.sessionId = ctx.sessionId;
+	}
+	return als.run(store, fn);
+}
+
+export function getRequestContext(): RequestContext | undefined {
+	return als.getStore();
+}
+
+export function getUserKey(): string | undefined {
+	return als.getStore()?.userKey;
+}
+
+export function getSessionId(): string | undefined {
+	return als.getStore()?.sessionId;
+}
+
+export function getEffectiveUserKey(): string | undefined {
+	const ctx = als.getStore();
+	if (ctx?.userKey) {
+		return ctx.userKey;
+	}
+	if (ctx?.sessionId) {
+		const session = sessionContext.getSession(ctx.sessionId);
+		if (session?.userKey) {
+			return session.userKey;
+		}
+	}
+	return ctx?.sessionId;
+}

package/src/utils/env.ts

@@ -0,0 +1,12 @@
+export function env(name: string): string | undefined {
+	const v = process.env[name];
+	return (v && v.trim()) || undefined;
+}
+
+export function envBool(name: string, def: boolean): boolean {
+	const v = env(name);
+	if (v == null) {
+		return def;
+	}
+	return v.toLowerCase() === 'true' || v === '1';
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from './env';
+export * from './mcp';
+export * from './network';
+export * from './pkce';
+export * from './context';

package/src/utils/mcp.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export function withValidation<T extends z.ZodTypeAny>(
+	schema: T,
+	handler: (args: z.infer<T>) => Promise<any>,
+) {
+	return async (payload: unknown) => handler(schema.parse(payload));
+}

package/src/utils/network.ts

@@ -0,0 +1,65 @@
+import { CookieKV } from '../types';
+
+import type express from 'express';
+
+export function getClientIp(req: express.Request): string | undefined {
+	const forwarded = req.headers['x-forwarded-for'] as string | string[] | undefined;
+	if (forwarded) {
+		if (Array.isArray(forwarded)) {
+			return forwarded[0];
+		}
+		const parts = forwarded.split(',').map((s) => s.trim());
+		if (parts.length) {
+			return parts[0];
+		}
+	}
+	if (req.ip) {
+		return req.ip;
+	}
+	if (req.socket && req.socket.remoteAddress) {
+		return req.socket.remoteAddress;
+	}
+	return undefined;
+}
+
+export function parseSetCookie(setCookie: string[]): CookieKV[] {
+	const out: CookieKV[] = [];
+	for (const raw of setCookie || []) {
+		const first = raw.split(';')[0]?.trim();
+		if (!first) {
+			continue;
+		}
+		const idx = first.indexOf('=');
+		if (idx > 0) {
+			out.push({ name: first.slice(0, idx), value: first.slice(idx + 1) });
+		}
+	}
+	return out;
+}
+
+export function getUserKeyFromRequest(req: express.Request): string | undefined {
+	const fromHeader = req.headers['x-user-key'];
+	if (typeof fromHeader === 'string' && fromHeader) {
+		return fromHeader;
+	}
+	const fromQuery = (req.query as any)?.userKey;
+	if (typeof fromQuery === 'string' && fromQuery) {
+		return fromQuery;
+	}
+	const sessionId = getSessionIdFromRequest(req as any);
+	if (sessionId) {
+		return `user_${sessionId}`;
+	}
+	return undefined;
+}
+
+export function getSessionIdFromRequest(req: any) {
+	return (
+		req.headers['mcp-session-id'] ||
+		req.query?.session_id ||
+		req.headers['x-session-id'] ||
+		req.body?.params?.session_id ||
+		req.body?.session_id ||
+		null
+	);
+}

package/src/utils/pkce.ts

@@ -0,0 +1,39 @@
+function base64UrlEncode(bytes: Uint8Array): string {
+	let bin = '';
+	for (let i = 0; i < bytes.length; i++) {
+		bin += String.fromCharCode(bytes[i]!);
+	}
+	const b64 = Buffer.from(bin, 'binary').toString('base64');
+	return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+
+export function generateCodeVerifier(length: number = 32): string {
+	const arr = new Uint8Array(length);
+	if (typeof crypto !== 'undefined' && typeof (crypto as any).getRandomValues === 'function') {
+		(crypto as any).getRandomValues(arr);
+	} else {
+		const { randomBytes } = require('node:crypto');
+		const rb: Buffer = randomBytes(length);
+		for (let i = 0; i < length; i++) {
+			arr[i] = rb[i]!;
+		}
+	}
+	return base64UrlEncode(arr);
+}
+
+export async function challengeS256(verifier: string): Promise<string> {
+	const data = new TextEncoder().encode(verifier);
+	if (typeof crypto !== 'undefined' && (crypto as any).subtle?.digest) {
+		const hash = await (crypto as any).subtle.digest('SHA-256', data);
+		return base64UrlEncode(new Uint8Array(hash));
+	}
+	const { createHash } = require('node:crypto');
+	const hash = createHash('sha256').update(Buffer.from(data)).digest();
+	return base64UrlEncode(new Uint8Array(hash));
+}
+
+export async function generatePkcePair() {
+	const verifier = generateCodeVerifier();
+	const challenge = await challengeS256(verifier);
+	return { verifier, challenge } as const;
+}

package/src/version.ts

@@ -0,0 +1,15 @@
+import pkg from '../package.json';
+
+export const NAME: string =
+	(
+		pkg as {
+			name?: string;
+		}
+	).name || 'creatio-mcp';
+
+export const VERSION: string =
+	(
+		pkg as {
+			version?: string;
+		}
+	).version || '0.0.0';

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"module": "Node16",
+		"target": "es2022",
+		"lib": ["esnext"],
+		"types": ["node"],
+		"sourceMap": true,
+		"declaration": true,
+		"declarationMap": true,
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+		"strict": true,
+		"jsx": "react-jsx",
+		"verbatimModuleSyntax": false,
+		"esModuleInterop": true,
+		"resolveJsonModule": true,
+		"moduleResolution": "Node16",
+		"isolatedModules": true,
+		"noUncheckedSideEffectImports": true,
+		"moduleDetection": "force",
+		"skipLibCheck": true
+  }
+	,
+	"include": ["src/**/*.ts"],
+	"exclude": ["scripts/**"]
+}