@atlisp/mcp 1.2.0 → 1.3.1

package/src/session-manager.js

@@ -1,89 +0,0 @@
-export class Session {
-  constructor(clientId) {
-    this.clientId = clientId;
-    this.subscriptions = new Set();
-    this.createdAt = Date.now();
-    this.connected = false;
-  }
-}
-
-export class SessionManager {
-  #sessions = new Map();
-
-  createSession(clientId) {
-    let session = this.#sessions.get(clientId);
-    if (!session) {
-      session = new Session(clientId);
-      this.#sessions.set(clientId, session);
-    }
-    return session;
-  }
-
-  getSession(clientId) {
-    return this.#sessions.get(clientId) || null;
-  }
-
-  hasSession(clientId) {
-    return this.#sessions.has(clientId);
-  }
-
-  removeSession(clientId) {
-    return this.#sessions.delete(clientId);
-  }
-
-  subscribe(clientId, uri) {
-    const session = this.#sessions.get(clientId);
-    if (session) {
-      session.subscriptions.add(uri);
-      return true;
-    }
-    return false;
-  }
-
-  unsubscribe(clientId, uri) {
-    const session = this.#sessions.get(clientId);
-    if (session) {
-      return session.subscriptions.delete(uri);
-    }
-    return false;
-  }
-
-  getSubscriptions(clientId) {
-    const session = this.#sessions.get(clientId);
-    return session ? Array.from(session.subscriptions) : [];
-  }
-
-  isSubscribed(clientId, uri) {
-    const session = this.#sessions.get(clientId);
-    return session ? session.subscriptions.has(uri) : false;
-  }
-
-  getAllSubscribedUris() {
-    const all = new Set();
-    for (const session of this.#sessions.values()) {
-      for (const uri of session.subscriptions) {
-        all.add(uri);
-      }
-    }
-    return all;
-  }
-
-  list() {
-    return Array.from(this.#sessions.entries()).map(([id, s]) => ({
-      clientId: id,
-      subscriptions: Array.from(s.subscriptions),
-      createdAt: s.createdAt,
-      connected: s.connected
-    }));
-  }
-
-  count() {
-    return this.#sessions.size;
-  }
-
-  clear() {
-    this.#sessions.clear();
-  }
-}
-
-export default SessionManager;

package/src/session-transport.js

@@ -1,89 +0,0 @@
-import { randomUUID } from 'crypto';
-
-const SESSION_TIMEOUT = 30 * 60 * 1000;
-
-export class SessionTransport {
-  constructor(sessionId) {
-    this.sessionId = sessionId || randomUUID();
-    this.onclose = null;
-    this.onerror = null;
-    this.onmessage = null;
-    this._pendingRequest = null;
-    this._started = false;
-    this._closed = false;
-    this._cleanupTimer = null;
-  }
-
-  async start() {
-    if (this._started) {
-      throw new Error('Transport already started');
-    }
-    this._started = true;
-  }
-
-  async send(message) {
-    if (this._closed) return;
-    if (this._pendingRequest) {
-      const { resolve, reject, timeout } = this._pendingRequest;
-      clearTimeout(timeout);
-      this._pendingRequest = null;
-      resolve(message);
-    }
-  }
-
-  async close() {
-    if (this._closed) return;
-    this._closed = true;
-    if (this._pendingRequest) {
-      const { reject, timeout } = this._pendingRequest;
-      clearTimeout(timeout);
-      this._pendingRequest = null;
-      reject(new Error('Transport closed'));
-    }
-    this._clearCleanupTimer();
-    this.onclose?.();
-  }
-
-  async handleRequest(message, timeoutMs = 60000) {
-    if (this._closed) {
-      throw new Error('Transport closed');
-    }
-
-    if (!message || !message.method) {
-      throw new Error('Invalid message');
-    }
-
-    if (!message.id) {
-      this.onmessage?.(message);
-      return null;
-    }
-
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        if (this._pendingRequest?.resolve === resolve) {
-          this._pendingRequest = null;
-          reject(new Error('Request timeout'));
-        }
-      }, timeoutMs);
-
-      this._pendingRequest = { resolve, reject, timeout };
-      this.onmessage?.(message);
-    });
-  }
-
-  resetCleanupTimer() {
-    this._clearCleanupTimer();
-    this._cleanupTimer = setTimeout(() => {
-      this.close();
-    }, SESSION_TIMEOUT);
-  }
-
-  _clearCleanupTimer() {
-    if (this._cleanupTimer) {
-      clearTimeout(this._cleanupTimer);
-      this._cleanupTimer = null;
-    }
-  }
-}
-
-export default SessionTransport;

package/src/sse-session-manager.js

@@ -1,133 +0,0 @@
-import { SseSession, SSE_EVENTS } from './sse-session.js';
-
-export class SseSessionManager {
-    #sessions = new Map();
-    #eventHandlers = new Map();
-
-    constructor() {
-        this.#sessions = new Map();
-        this.#eventHandlers = new Map();
-    }
-
-    add(clientId, session) {
-        if (!(session instanceof SseSession)) {
-            throw new Error('session must be an SseSession instance');
-        }
-        this.#sessions.set(clientId, session);
-        session.startHeartbeat();
-    }
-
-    remove(clientId) {
-        const session = this.#sessions.get(clientId);
-        if (session) {
-            session.close();
-            this.#sessions.delete(clientId);
-            return true;
-        }
-        return false;
-    }
-
-    get(clientId) {
-        return this.#sessions.get(clientId) || null;
-    }
-
-    has(clientId) {
-        return this.#sessions.has(clientId);
-    }
-
-    list() {
-        return Array.from(this.#sessions.keys()).map(id => ({
-            clientId: id,
-            isActive: this.#sessions.get(id)?.isActive ?? false
-        }));
-    }
-
-    listActive() {
-        return this.list().filter(s => s.isActive);
-    }
-
-    count() {
-        return this.#sessions.size;
-    }
-
-    sendToClient(clientId, event, data, id = null) {
-        const session = this.#sessions.get(clientId);
-        if (!session || !session.isActive) {
-            return false;
-        }
-        return session.sendEvent(event, data, id);
-    }
-
-    sendMessageToClient(clientId, data) {
-        return this.sendToClient(clientId, SSE_EVENTS.MESSAGE, data);
-    }
-
-    sendErrorToClient(clientId, code, message, id = null) {
-        return this.sendToClient(clientId, SSE_EVENTS.ERROR, { code, message }, id);
-    }
-
-    sendProgressToClient(clientId, current, total, message = '') {
-        return this.sendToClient(clientId, SSE_EVENTS.PROGRESS, { current, total, message });
-    }
-
-    broadcast(event, data) {
-        let successCount = 0;
-        for (const [clientId, session] of this.#sessions) {
-            if (session.isActive && session.sendEvent(event, data)) {
-                successCount++;
-            }
-        }
-        return successCount;
-    }
-
-    broadcastMessage(data) {
-        return this.broadcast(SSE_EVENTS.MESSAGE, data);
-    }
-
-    broadcastError(code, message) {
-        return this.broadcast(SSE_EVENTS.ERROR, { code, message });
-    }
-
-    on(event, handler) {
-        if (!this.#eventHandlers.has(event)) {
-            this.#eventHandlers.set(event, new Set());
-        }
-        this.#eventHandlers.get(event).add(handler);
-    }
-
-    off(event, handler) {
-        const handlers = this.#eventHandlers.get(event);
-        if (handlers) {
-            handlers.delete(handler);
-        }
-    }
-
-    emit(event, data) {
-        const handlers = this.#eventHandlers.get(event);
-        if (handlers) {
-            for (const handler of handlers) {
-                try {
-                    handler(data);
-                } catch (e) {
-                    // Ignore handler errors
-                }
-            }
-        }
-    }
-
-    cleanupInactive() {
-        for (const [clientId, session] of this.#sessions) {
-            if (!session.isActive) {
-                session.close();
-                this.#sessions.delete(clientId);
-            }
-        }
-    }
-
-    closeAll() {
-        for (const [clientId, session] of this.#sessions) {
-            session.close();
-        }
-        this.#sessions.clear();
-    }
-}

package/src/sse-session.js

@@ -1,314 +0,0 @@
-import { randomUUID } from 'crypto';
-
-const DEFAULT_HEARTBEAT_INTERVAL = 30000;
-const DEFAULT_RETRY_INTERVAL = 30000;
-const MAX_SENT_MESSAGES = 1000;
-
-export const SSE_EVENTS = {
-    MESSAGE: 'message',
-    ENDPOINT: 'endpoint',
-    PING: 'ping',
-    ERROR: 'error',
-    PROGRESS: 'progress',
-    CAPABILITIES: 'capabilities',
-};
-
-export class SseSession {
-    #res;
-    #clientId;
-    #active = true;
-    #heartbeatTimer = null;
-    #lastEventId = 0;
-    #heartbeatInterval;
-    #retryInterval;
-    #sessionData = {};
-    #sentMessages = [];
-    #backpressureBuffer = [];
-    #drainHandler = null;
-
-    constructor(res, options = {}) {
-        this.#res = res;
-        this.#clientId = options.clientId || randomUUID();
-        this.#heartbeatInterval = options.heartbeatInterval || DEFAULT_HEARTBEAT_INTERVAL;
-        this.#retryInterval = options.retryInterval || DEFAULT_RETRY_INTERVAL;
-        this.#sessionData = options.sessionData || {};
-
-        if (options.resumeFromId && options.resumeFromId > 0) {
-            this.#lastEventId = options.resumeFromId;
-        }
-
-        this._setupSseHeaders();
-        this._sendRetry();
-        this._setupDrain();
-    }
-
-    get clientId() {
-        return this.#clientId;
-    }
-
-    get isActive() {
-        return this.#active;
-    }
-
-    get lastEventId() {
-        return this.#lastEventId;
-    }
-
-    get sessionData() {
-        return this.#sessionData;
-    }
-
-    get sentMessages() {
-        return [...this.#sentMessages];
-    }
-
-    getMessagesSince(eventId) {
-        return this.#sentMessages.filter(m => m.id > eventId);
-    }
-
-    setSessionData(key, value) {
-        this.#sessionData[key] = value;
-    }
-
-    getSessionData(key) {
-        return this.#sessionData[key];
-    }
-
-    get retryInterval() {
-        return this.#retryInterval;
-    }
-
-    setRetryInterval(ms) {
-        this.#retryInterval = ms;
-    }
-
-    _sendRetry() {
-        this._write(`retry: ${this.#retryInterval}\n\n`);
-    }
-
-    _setupSseHeaders() {
-        this.#res.setHeader('Content-Type', 'text/event-stream');
-        this.#res.setHeader('Cache-Control', 'no-cache');
-        this.#res.setHeader('Connection', 'keep-alive');
-        this.#res.setHeader('Transfer-Encoding', 'chunked');
-        this.#res.setHeader('X-Accel-Buffering', 'no');
-        if (typeof this.#res.flush !== 'function') {
-            this.#res.flush = () => {};
-        }
-    }
-
-    _formatEvent(event, data, id = null) {
-        const lines = [];
-        if (id !== null) {
-            lines.push(`id: ${id}`);
-        }
-        lines.push(`event: ${event}`);
-
-        if (data !== null && data !== undefined) {
-            const jsonStr = JSON.stringify(data);
-            lines.push(`data: ${jsonStr}`);
-        } else {
-            lines.push('data:');
-        }
-
-        return lines.join('\n') + '\n\n';
-    }
-
-    _setupDrain() {
-        if (typeof this.#res.on !== 'function') return;
-        this.#drainHandler = () => {
-            if (!this.#active) return;
-            if (this.#backpressureBuffer.length > 0) {
-                this._drainBuffer();
-            }
-        };
-        this.#res.on('drain', this.#drainHandler);
-    }
-
-    _drainBuffer() {
-        const batch = this.#backpressureBuffer.splice(0, 50);
-        for (const item of batch) {
-            const ok = this.#res.write(item);
-            if (!ok) {
-                this.#backpressureBuffer.unshift(...batch.slice(batch.indexOf(item)));
-                return;
-            }
-        }
-        this._flush();
-        if (this.#backpressureBuffer.length > 0) {
-            this._drainBuffer();
-        }
-    }
-
-    _write(content) {
-        if (!this.#active) return false;
-        try {
-            if (this.#backpressureBuffer.length > 0) {
-                this.#backpressureBuffer.push(content);
-                return true;
-            }
-            const result = this.#res.write(content);
-            if (typeof this.#res.flush === 'function') {
-                this.#res.flush();
-            }
-            if (result === false) {
-                this.#backpressureBuffer.push(content);
-                return true;
-            }
-            return true;
-        } catch (e) {
-            this.#active = false;
-            this.close();
-            return false;
-        }
-    }
-
-    _flush() {
-        try {
-            if (typeof this.#res.flush === 'function') {
-                this.#res.flush();
-            }
-        } catch (e) {
-            // Ignore flush errors
-        }
-    }
-
-    flushBackpressure() {
-        if (this.#backpressureBuffer.length > 0) {
-            this._drainBuffer();
-        }
-    }
-
-    sendEvent(event, data, id = null) {
-        this.#lastEventId++;
-        const eventId = id !== null ? id : this.#lastEventId;
-        const formatted = this._formatEvent(event, data, eventId);
-        this.#sentMessages.push({ event, data, id: eventId, timestamp: Date.now() });
-        if (this.#sentMessages.length > MAX_SENT_MESSAGES) {
-            this.#sentMessages.splice(0, this.#sentMessages.length - MAX_SENT_MESSAGES);
-        }
-        this._write(formatted);
-        this._flush();
-        return true;
-    }
-
-    sendMessage(data) {
-        return this.sendEvent(SSE_EVENTS.MESSAGE, data);
-    }
-
-    sendEndpoint(path) {
-        return this.sendEvent(SSE_EVENTS.ENDPOINT, path);
-    }
-
-    sendError(code, message, id = null) {
-        return this.sendEvent(SSE_EVENTS.ERROR, { code, message }, id);
-    }
-
-    sendPing() {
-        return this.sendEvent(SSE_EVENTS.PING, { timestamp: Date.now() });
-    }
-
-    sendProgress(current, total, message = '') {
-        return this.sendEvent(SSE_EVENTS.PROGRESS, { current, total, message });
-    }
-
-    sendCapabilities(capabilities) {
-        return this.sendEvent(SSE_EVENTS.CAPABILITIES, capabilities);
-    }
-
-    sendResponse(jsonrpcResponse, id = null) {
-        const eventId = id !== null ? id : this.#lastEventId;
-        return this.sendEvent(SSE_EVENTS.MESSAGE, jsonrpcResponse, eventId);
-    }
-
-    startHeartbeat(interval = null) {
-        this.stopHeartbeat();
-        const ms = interval || this.#heartbeatInterval;
-        
-        this.#heartbeatTimer = setInterval(() => {
-            if (!this.#active) {
-                this.stopHeartbeat();
-                return;
-            }
-            if (!this.sendPing()) {
-                this.stopHeartbeat();
-                this.close();
-            }
-        }, ms);
-    }
-
-    stopHeartbeat() {
-        if (this.#heartbeatTimer) {
-            clearInterval(this.#heartbeatTimer);
-            this.#heartbeatTimer = null;
-        }
-    }
-
-    close() {
-        this.#active = false;
-        this.stopHeartbeat();
-        if (this.#drainHandler) {
-            this.#res.removeListener('drain', this.#drainHandler);
-            this.#drainHandler = null;
-        }
-        this.#backpressureBuffer = [];
-        try {
-            this.#res.end();
-        } catch (e) {
-            // Ignore errors during close
-        }
-    }
-}
-
-export function setupSseHeaders(res) {
-    res.setHeader('Content-Type', 'text/event-stream');
-    res.setHeader('Cache-Control', 'no-cache');
-    res.setHeader('Connection', 'keep-alive');
-    res.setHeader('Transfer-Encoding', 'chunked');
-    res.setHeader('X-Accel-Buffering', 'no');
-    res.setHeader('Vary', 'Accept');
-    if (typeof res.flush !== 'function') {
-        res.flush = () => {};
-    }
-}
-
-let sseGlobalId = 0;
-
-export function sendSSE(res, data, event = SSE_EVENTS.MESSAGE, id = null) {
-    const eventId = id !== null ? id : ++sseGlobalId;
-    const lines = [
-        `id: ${eventId}`,
-        `event: ${event}`,
-        `data: ${JSON.stringify(data)}`,
-        ''
-    ];
-    res.write(lines.join('\n') + '\n');
-    if (typeof res.flush === 'function') res.flush();
-}
-
-export function createSseResponseHandler(res, acceptSse = false) {
-    if (acceptSse) {
-        setupSseHeaders(res);
-    }
-
-    return {
-        send: (data, done = false) => {
-            if (acceptSse) {
-                sendSSE(res, data);
-            } else {
-                const json = JSON.stringify(data);
-                res.setHeader('Content-Type', 'application/json');
-                res.end(json);
-            }
-        }
-    };
-}
-
-export function parseLastEventId(req) {
-    const lastEventId = req.get('Last-Event-ID') || req.get('last-event-id');
-    if (lastEventId) {
-        const parsed = parseInt(lastEventId, 10);
-        return isNaN(parsed) ? null : parsed;
-    }
-    return null;
-}

package/src/subscription-manager.js

@@ -1,52 +0,0 @@
-import { SessionManager } from './session-manager.js';
-
-const sessionManager = new SessionManager();
-let _notifyFn = null;
-
-export function setNotify(fn) {
-    _notifyFn = fn;
-}
-
-export function subscribe(uri, sessionId) {
-    if (sessionId) {
-        return sessionManager.subscribe(sessionId, uri);
-    }
-    return true;
-}
-
-export function unsubscribe(uri, sessionId) {
-    if (sessionId) {
-        return sessionManager.unsubscribe(sessionId, uri);
-    }
-    return true;
-}
-
-export function list(sessionId) {
-    if (sessionId) {
-        return sessionManager.getSubscriptions(sessionId);
-    }
-    return Array.from(sessionManager.getAllSubscribedUris());
-}
-
-export function isSubscribed(uri, sessionId) {
-    if (sessionId) {
-        return sessionManager.isSubscribed(sessionId, uri);
-    }
-    return sessionManager.getAllSubscribedUris().has(uri);
-}
-
-export function notify(uri, data) {
-    if (_notifyFn) {
-        _notifyFn(uri, data);
-    }
-}
-
-export function clear() {
-    sessionManager.clear();
-}
-
-export function size() {
-    return sessionManager.count();
-}
-
-export { sessionManager };