symmetry-cli 1.0.7 → 1.0.11

package/dist/peer-repository.js

@@ -1,114 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PeerRepository = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const database_1 = require("./database");
-const logger_1 = require("./logger");
-class PeerRepository {
-    constructor() {
-        this.db = database_1.database;
-    }
-    upsert(message) {
-        return new Promise((resolve, reject) => {
-            this.db.run(`
-        INSERT OR REPLACE INTO peers (
-          key, discovery_key, gpu_memory, model_name, public, server_key, last_seen, online
-        ) VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, TRUE)
-      `, [
-                message.key,
-                message.discoveryKey,
-                message.config.gpuMemory,
-                message.config.modelName,
-                message.config.public,
-                message.config.serverKey,
-            ], function (err) {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(this.lastID);
-                }
-            });
-        });
-    }
-    getByDiscoveryKey(discoveryKey) {
-        return new Promise((resolve, reject) => {
-            this.db.get("SELECT * FROM peers WHERE discovery_key = ?", [discoveryKey], (err, row) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(row);
-                }
-            });
-        });
-    }
-    getPeer(randomPeerRequest) {
-        return new Promise((resolve, reject) => {
-            const { modelName } = randomPeerRequest;
-            this.db.get(`SELECT * FROM peers WHERE model_name = ? ORDER BY RANDOM() LIMIT 1`, [modelName], (err, row) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(row);
-                }
-            });
-        });
-    }
-    updateLastSeen(peerKey) {
-        return new Promise((resolve, reject) => {
-            this.db.run("UPDATE peers SET last_seen = ?, online = FALSE WHERE key = ?", [new Date().toISOString(), peerKey], function (err) {
-                if (err) {
-                    console.error(chalk_1.default.red("❌ Error updating peer last seen in database:"), err);
-                    reject(err);
-                }
-                else {
-                    if (this.changes > 0) {
-                        logger_1.logger.info(chalk_1.default.yellow("🕒 Peer disconnected"));
-                    }
-                    else {
-                        logger_1.logger.info(chalk_1.default.yellow("⚠️ Peer not found in database"));
-                    }
-                    resolve(this.changes);
-                }
-            });
-        });
-    }
-    async getActivePeerCount() {
-        return new Promise((resolve, reject) => {
-            this.db.get("SELECT COUNT(*) as count FROM peers WHERE online = TRUE", (err, row) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(row.count);
-                }
-            });
-        });
-    }
-    async getActiveModelCount() {
-        return new Promise((resolve, reject) => {
-            this.db.get("SELECT COUNT(DISTINCT model_name) as count FROM peers WHERE online = TRUE", (err, row) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(row.count);
-                }
-            });
-        });
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    updateStats(peerKey, data) {
-        // TODO: Update stats in database
-        logger_1.logger.info(peerKey, data);
-    }
-}
-exports.PeerRepository = PeerRepository;
-module.exports = {
-    PeerRepository,
-};

package/dist/provider.js

@@ -1,307 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymmetryProvider = void 0;
-const node_stream_1 = require("node:stream");
-const promises_1 = require("stream/promises");
-const chalk_1 = __importDefault(require("chalk"));
-const hyperswarm_1 = __importDefault(require("hyperswarm"));
-const hypercore_crypto_1 = __importDefault(require("hypercore-crypto"));
-const node_fs_1 = __importDefault(require("node:fs"));
-const config_1 = require("./config");
-const utils_1 = require("./utils");
-const logger_1 = require("./logger");
-const constants_1 = require("./constants");
-class SymmetryProvider {
-    constructor(configPath) {
-        this._challenge = null;
-        this._conversationIndex = 0;
-        this._discoveryKey = null;
-        this._isPublic = false;
-        this._providerConnections = 0;
-        this._providerSwarm = null;
-        this._serverSwarm = null;
-        this._serverPeer = null;
-        logger_1.logger.info(`🔗 Initializing client using config file: ${configPath}`);
-        this._config = new config_1.ConfigManager(configPath);
-        this._isPublic = this._config.get("public");
-    }
-    async init() {
-        this._providerSwarm = new hyperswarm_1.default({
-            maxConnections: this._config.get("maxConnections"),
-        });
-        const keyPair = hypercore_crypto_1.default.keyPair(Buffer.alloc(32).fill(this._config.get("name")));
-        this._discoveryKey = hypercore_crypto_1.default.discoveryKey(keyPair.publicKey);
-        const discovery = this._providerSwarm.join(this._discoveryKey, {
-            server: true,
-            client: true,
-        });
-        await discovery.flushed();
-        this._providerSwarm.on("error", (err) => {
-            logger_1.logger.error(chalk_1.default.red("🚨 Swarm Error:"), err);
-        });
-        this._providerSwarm.on("connection", (peer) => {
-            logger_1.logger.info(`⚡️ New connection from peer: ${peer.rawStream.remoteHost}`);
-            this.listeners(peer);
-        });
-        logger_1.logger.info(`📁 Symmetry client initialized.`);
-        logger_1.logger.info(`🔑 Discovery key: ${this._discoveryKey.toString("hex")}`);
-        if (this._isPublic) {
-            logger_1.logger.info(chalk_1.default.white(`🔑 Server key: ${this._config.get("serverKey")}`));
-            logger_1.logger.info(chalk_1.default.white("🔗 Joining server, please wait."));
-            this.joinServer();
-        }
-        process.on("SIGINT", async () => {
-            var _a;
-            await ((_a = this._providerSwarm) === null || _a === void 0 ? void 0 : _a.destroy());
-            process.exit(0);
-        });
-        process.on("uncaughtException", (err) => {
-            if (err.message === "connection reset by peer") {
-                this._providerConnections = Math.max(0, this._providerConnections - 1);
-            }
-        });
-    }
-    async destroySwarms() {
-        var _a, _b;
-        await ((_a = this._providerSwarm) === null || _a === void 0 ? void 0 : _a.destroy());
-        await ((_b = this._serverSwarm) === null || _b === void 0 ? void 0 : _b.destroy());
-    }
-    async testProviderCall() {
-        const testCall = async () => {
-            logger_1.logger.info(chalk_1.default.white(`👋 Saying hello to your provider...`));
-            const testMessages = [
-                { role: "user", content: "Hello, this is a test message." },
-            ];
-            const req = this.buildStreamRequest(testMessages);
-            if (!req) {
-                logger_1.logger.error(chalk_1.default.red("❌ Failed to build test request"));
-                throw new Error("Failed to build test request");
-            }
-            const { requestOptions, requestBody } = req;
-            const { protocol, hostname, port, path, method, headers } = requestOptions;
-            const url = `${protocol}://${hostname}:${port}${path}`;
-            logger_1.logger.info(chalk_1.default.white(`🚀 Sending test request to ${url}`));
-            try {
-                const response = await fetch(url, {
-                    method,
-                    headers,
-                    body: JSON.stringify(requestBody),
-                });
-                if (!response.ok) {
-                    logger_1.logger.error(chalk_1.default.red(`❌ Server responded with status code: ${response.status}`));
-                    this.destroySwarms();
-                    throw new Error(`Server responded with status code: ${response.status}`);
-                }
-                if (!response.body) {
-                    logger_1.logger.error(chalk_1.default.red("❌ Failed to get a ReadableStream from the response"));
-                    this.destroySwarms();
-                    throw new Error("Failed to get a ReadableStream from the response");
-                }
-                logger_1.logger.info(chalk_1.default.white(`📡 Got response, checking stream...`));
-                const reader = response.body.getReader();
-                const { done } = await reader.read();
-                if (done) {
-                    logger_1.logger.error(chalk_1.default.red("❌ Stream ended without data"));
-                    this.destroySwarms();
-                    throw new Error("Stream ended without data");
-                }
-                logger_1.logger.info(chalk_1.default.green(`✅ Test inference call successful!`));
-            }
-            catch (error) {
-                this.destroySwarms();
-                logger_1.logger.error(chalk_1.default.red(`❌ Error during test inference call: ${error}`));
-                throw error;
-            }
-            logger_1.logger.info(chalk_1.default.white(`🔗 Test call successful!`));
-        };
-        setTimeout(() => testCall(), constants_1.PROVIDER_HELLO_TIMEOUT);
-    }
-    async joinServer() {
-        this._serverSwarm = new hyperswarm_1.default();
-        const serverKey = Buffer.from(this._config.get("serverKey"));
-        this._serverSwarm.join(hypercore_crypto_1.default.discoveryKey(serverKey), {
-            client: true,
-            server: false,
-        });
-        this._serverSwarm.flush();
-        this._serverSwarm.on("connection", (peer) => {
-            var _a;
-            this._serverPeer = peer;
-            logger_1.logger.info(chalk_1.default.green("🔗 Connected to server."));
-            this.testProviderCall();
-            this._challenge = hypercore_crypto_1.default.randomBytes(32);
-            this._serverPeer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.challenge, {
-                challenge: this._challenge,
-            }));
-            this._serverPeer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.join, {
-                ...this._config.getAll(),
-                discoveryKey: (_a = this._discoveryKey) === null || _a === void 0 ? void 0 : _a.toString("hex"),
-            }));
-            this._serverPeer.on("data", async (buffer) => {
-                var _a;
-                if (!buffer)
-                    return;
-                const data = (0, utils_1.safeParseJson)(buffer.toString());
-                if (data && data.key) {
-                    switch (data.key) {
-                        case constants_1.serverMessageKeys.challenge:
-                            this.handleServerVerification(data.data);
-                            break;
-                        case constants_1.serverMessageKeys.ping:
-                            (_a = this._serverPeer) === null || _a === void 0 ? void 0 : _a.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.pong));
-                            break;
-                    }
-                }
-            });
-        });
-    }
-    getServerPublicKey(serverKeyHex) {
-        const publicKey = Buffer.from(serverKeyHex, "hex");
-        if (publicKey.length !== 32) {
-            throw new Error(`Expected a 32-byte public key, but got ${publicKey.length} bytes`);
-        }
-        return publicKey;
-    }
-    handleServerVerification(data) {
-        if (!this._challenge) {
-            console.log("No challenge set. Cannot verify.");
-            return;
-        }
-        const serverKeyHex = this._config.get("serverKey");
-        try {
-            const publicKey = this.getServerPublicKey(serverKeyHex);
-            const signatureBuffer = Buffer.from(data.signature.data, "base64");
-            const verified = hypercore_crypto_1.default.verify(this._challenge, signatureBuffer, publicKey);
-            if (verified) {
-                logger_1.logger.info(chalk_1.default.greenBright(`✅ Verification successful.`));
-            }
-            else {
-                logger_1.logger.error(`❌ Verification failed!`);
-            }
-        }
-        catch (error) {
-            console.error("Error during verification:", error);
-        }
-    }
-    listeners(peer) {
-        peer.on("data", async (buffer) => {
-            if (!buffer)
-                return;
-            const data = (0, utils_1.safeParseJson)(buffer.toString());
-            if (data && data.key) {
-                switch (data.key) {
-                    case constants_1.serverMessageKeys.newConversation:
-                        this._conversationIndex = this._conversationIndex + 1;
-                        break;
-                    case constants_1.serverMessageKeys.inference:
-                        logger_1.logger.info(`📦 Inference message received from ${peer.rawStream.remoteHost}`);
-                        await this.handleInferenceRequest(data, peer);
-                        break;
-                }
-            }
-        });
-    }
-    getMessagesWithSystem(messages) {
-        const systemMessage = this._config.get("systemMessage");
-        if (messages.length === 2 && systemMessage) {
-            messages.unshift({
-                role: "system",
-                content: systemMessage,
-            });
-        }
-        return messages;
-    }
-    async handleInferenceRequest(data, peer) {
-        const emitterKey = data.data.key;
-        const messages = this.getMessagesWithSystem(data === null || data === void 0 ? void 0 : data.data.messages);
-        const req = this.buildStreamRequest(messages);
-        if (!req)
-            return;
-        const { requestOptions, requestBody } = req;
-        const { protocol, hostname, port, path, method, headers } = requestOptions;
-        const url = `${protocol}://${hostname}:${port}${path}`;
-        try {
-            const response = await fetch(url, {
-                method,
-                headers,
-                body: JSON.stringify(requestBody),
-            });
-            if (!response.ok) {
-                throw new Error(`Server responded with status code: ${response.status}`);
-            }
-            if (!response.body) {
-                throw new Error("Failed to get a ReadableStream from the response");
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const responseStream = node_stream_1.Readable.fromWeb(response.body);
-            const peerStream = new node_stream_1.PassThrough();
-            responseStream.pipe(peerStream);
-            let completion = "";
-            const provider = this._config.get("apiProvider");
-            peer.write(JSON.stringify({
-                symmetryEmitterKey: emitterKey,
-            }));
-            const peerPipeline = (0, promises_1.pipeline)(peerStream, async function (source) {
-                for await (const chunk of source) {
-                    if (peer.writable) {
-                        completion += (0, utils_1.getChatDataFromProvider)(provider, (0, utils_1.safeParseStreamResponse)(chunk.toString()));
-                        const write = peer.write(chunk);
-                        if (!write) {
-                            await new Promise((resolve) => peer.once("drain", resolve));
-                        }
-                    }
-                    else {
-                        break;
-                    }
-                }
-            });
-            await Promise.resolve(peerPipeline);
-            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.inferenceEnded, data === null || data === void 0 ? void 0 : data.data.key));
-            if (this._config.get("dataCollectionEnabled") &&
-                data.data.key === constants_1.serverMessageKeys.inference) {
-                this.saveCompletion(completion, peer, data.data.messages);
-            }
-        }
-        catch (error) {
-            let errorMessage = "An error occurred during inference";
-            if (error instanceof Error)
-                errorMessage = error.message;
-            logger_1.logger.error(`🚨 ${errorMessage}`);
-        }
-    }
-    async saveCompletion(completion, peer, messages) {
-        node_fs_1.default.writeFile(`${this._config.get("path")}/${peer.publicKey.toString("hex")}-${this._conversationIndex}.json`, JSON.stringify([
-            ...messages,
-            {
-                role: "assistant",
-                content: completion,
-            },
-        ]), () => {
-            logger_1.logger.info(`📝 Completion saved to file`);
-        });
-    }
-    buildStreamRequest(messages) {
-        const requestOptions = {
-            hostname: this._config.get("apiHostname"),
-            port: Number(this._config.get("apiPort")),
-            path: this._config.get("apiPath"),
-            protocol: this._config.get("apiProtocol"),
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${this._config.get("apiKey")}`,
-            },
-        };
-        const requestBody = {
-            model: this._config.get("modelName"),
-            messages: messages || undefined,
-            stream: true,
-        };
-        return { requestOptions, requestBody };
-    }
-}
-exports.SymmetryProvider = SymmetryProvider;
-exports.default = SymmetryProvider;

package/dist/server.js

@@ -1,143 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SymmetryServer = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const corestore_1 = __importDefault(require("corestore"));
-const hyperdrive_1 = __importDefault(require("hyperdrive"));
-const hyperswarm_1 = __importDefault(require("hyperswarm"));
-const path_1 = __importDefault(require("path"));
-const config_manager_1 = require("./config-manager");
-const utils_1 = require("./utils");
-const logger_1 = require("./logger");
-const peer_repository_1 = require("./peer-repository");
-const constants_1 = require("./constants");
-const session_manager_1 = require("./session-manager");
-const session_repository_1 = require("./session-repository");
-const websocket_server_1 = require("./websocket-server");
-class SymmetryServer {
-    constructor(configPath) {
-        logger_1.logger.info(`🔗 Initializing server using config file: ${configPath}`);
-        this._config = (0, config_manager_1.createConfigManager)(configPath, false);
-        if (!this._config.isServerConfig()) {
-            throw new Error("Invalid configuration for server");
-        }
-        this._peerRepository = new peer_repository_1.PeerRepository();
-        this._sessionRepository = new session_repository_1.SessionRepository();
-        this._sessionManager = new session_manager_1.SessionManager(this._sessionRepository, 5);
-    }
-    async init() {
-        var _a, _b;
-        const corePath = path_1.default.join(this._config.get("path"), "symmetry-core");
-        const store = new corestore_1.default(corePath);
-        const core = new hyperdrive_1.default(store);
-        const swarm = new hyperswarm_1.default();
-        await core.ready();
-        const discovery = swarm.join(core.discoveryKey, { server: true });
-        await discovery.flushed();
-        swarm.on("connection", (peer) => {
-            logger_1.logger.info(`🔗 New Connection: ${peer.rawStream.remoteHost}`);
-            store.replicate(peer);
-            this.listeners(peer);
-        });
-        this._wsServer = new websocket_server_1.WsServer(this._config.get("webSocketPort"), this._peerRepository, swarm);
-        logger_1.logger.info(`🔑 Discovery key: ${(_a = core.discoveryKey) === null || _a === void 0 ? void 0 : _a.toString("hex")}`);
-        logger_1.logger.info(`🔑 Drive key: ${(_b = core.key) === null || _b === void 0 ? void 0 : _b.toString("hex")}`);
-        logger_1.logger.info(chalk_1.default.green(`\u2713 Websocket server started: ws://localhost:${this._config.get("webSocketPort")}`));
-        logger_1.logger.info(chalk_1.default.green(`\u2713 Symmetry server started, waiting for connections...`));
-    }
-    listeners(peer) {
-        peer.on("error", (err) => err);
-        peer.on("close", () => {
-            const peerKey = peer.publicKey.toString("hex");
-            this._peerRepository.updateLastSeen(peerKey);
-            logger_1.logger.info(`🔗 Connection Closed: Peer ${peerKey.slice(0, 6)}...${peerKey.slice(-6)}`);
-        });
-        peer.on("data", (message) => {
-            const data = (0, utils_1.safeParseJson)(message.toString());
-            if (!data)
-                return;
-            if (data.key) {
-                switch (data === null || data === void 0 ? void 0 : data.key) {
-                    case constants_1.serverMessageKeys.join:
-                        this.join(peer, data.data);
-                        break;
-                    case constants_1.serverMessageKeys.requestProvider:
-                        this.handlePeerSession(peer, data.data);
-                        break;
-                    case constants_1.serverMessageKeys.verifySession:
-                        this.handlePeerSessionValidation(peer, data.data);
-                        break;
-                }
-            }
-        });
-    }
-    async join(peer, message) {
-        const peerKey = peer.publicKey.toString("hex");
-        try {
-            await this._peerRepository.upsert({
-                ...message,
-                key: peerKey,
-            });
-            logger_1.logger.info(`👋 Peer provider joined ${peer.rawStream.remoteHost}`);
-            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.joinAck, {
-                status: "success",
-                key: peerKey,
-            }));
-        }
-        catch (error) {
-            let errorMessage = "";
-            if (error instanceof Error)
-                errorMessage = error.message;
-            logger_1.logger.error(`🚨 ${errorMessage}`);
-        }
-    }
-    async handlePeerSession(peer, randomPeerRequest) {
-        try {
-            const providerPeer = await this._peerRepository.getPeer(randomPeerRequest);
-            const sessionToken = await this._sessionManager.createSession(providerPeer.discovery_key);
-            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.providerDetails, {
-                providerId: providerPeer.key,
-                sessionToken,
-            }));
-        }
-        catch (error) {
-            let errorMessage = "";
-            if (error instanceof Error)
-                errorMessage = error.message;
-            logger_1.logger.error(`🚨 ${errorMessage}`);
-        }
-    }
-    async handlePeerSessionValidation(peer, message) {
-        if (!message.sessionToken)
-            return;
-        try {
-            const providerDiscoveryKey = await this._sessionManager.verifySession(message.sessionToken);
-            if (!providerDiscoveryKey)
-                return;
-            const providerPeer = await this._peerRepository.getByDiscoveryKey(providerDiscoveryKey);
-            if (!providerPeer)
-                return;
-            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.sessionValid, {
-                discoveryKey: providerPeer.discovery_key,
-            }));
-            await this._sessionManager.extendSession(message.sessionToken);
-        }
-        catch (error) {
-            logger_1.logger.error(`Session verification error: ${error instanceof Error ? error.message : "Unknown error"}`);
-            peer.write((0, utils_1.createMessage)(constants_1.serverMessageKeys.sessionValid, {
-                valid: false,
-                error: "Error verifying session",
-            }));
-        }
-    }
-    async cleanupSessions() {
-        await this._sessionManager.cleanupExpiredSessions();
-    }
-}
-exports.SymmetryServer = SymmetryServer;
-module.exports = {
-    SymmetryServer,
-};

package/dist/session-manager.js

@@ -1,68 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionManager = void 0;
-const logger_1 = require("./logger");
-const crypto_1 = __importDefault(require("crypto"));
-class SessionManager {
-    constructor(sessionRepository, sessionDurationMinutes = 60) {
-        this.sessionRepository = sessionRepository;
-        this.sessionDuration = sessionDurationMinutes * 60 * 1000;
-    }
-    async createSession(providerId) {
-        const sessionId = crypto_1.default.randomUUID();
-        const now = new Date();
-        const session = {
-            id: sessionId,
-            providerId,
-            createdAt: now,
-            expiresAt: new Date(now.getTime() + this.sessionDuration),
-        };
-        await this.sessionRepository.create(session);
-        logger_1.logger.info(`🖇️ Session created for provider: ${providerId}`);
-        return sessionId;
-    }
-    async verifySession(sessionId) {
-        const session = await this.sessionRepository.get(sessionId);
-        if (!session) {
-            logger_1.logger.warning(`❌ Session not found: ${sessionId}`);
-            return null;
-        }
-        if (new Date() > session.expiresAt) {
-            logger_1.logger.warning(`🕛 Session expired: ${sessionId}`);
-            await this.sessionRepository.delete(sessionId);
-            return null;
-        }
-        return session.providerId;
-    }
-    async extendSession(sessionId) {
-        const session = await this.sessionRepository.get(sessionId);
-        if (!session) {
-            logger_1.logger.warning(`🚨 Cannot extend non-existent session: ${sessionId}`);
-            return false;
-        }
-        session.expiresAt = new Date(Date.now() + this.sessionDuration);
-        await this.sessionRepository.update(session);
-        logger_1.logger.info(`🎟️ Session extended: ${sessionId}`);
-        return true;
-    }
-    async deleteSession(sessionId) {
-        const result = await this.sessionRepository.delete(sessionId);
-        if (result) {
-            // cross bin emoji  
-            logger_1.logger.info(`🗑 Session deleted: ${sessionId}`);
-        }
-        else {
-            logger_1.logger.warning(`🚨 Failed to delete session: ${sessionId}`);
-        }
-        return result;
-    }
-    async cleanupExpiredSessions() {
-        const deletedCount = await this.sessionRepository.deleteExpired();
-        logger_1.logger.info(`🕛 Cleaned up ${deletedCount} expired sessions`);
-        return deletedCount;
-    }
-}
-exports.SessionManager = SessionManager;