opencode-telegram-group-topics-bot 0.11.2

package/dist/keyboard/manager.js

@@ -0,0 +1,115 @@
+import { createMainKeyboard } from "../bot/utils/keyboard.js";
+import { getStoredAgent } from "../agent/manager.js";
+import { getStoredModel } from "../model/manager.js";
+import { formatVariantForButton } from "../variant/manager.js";
+import { logger } from "../utils/logger.js";
+import { t } from "../i18n/index.js";
+import { SCOPE_CONTEXT, getScopeFromKey, getThreadIdFromScopeKey } from "../bot/scope.js";
+class KeyboardManager {
+    stateByScope = new Map();
+    api = null;
+    chatId = null;
+    lastUpdateTimeByScope = new Map();
+    UPDATE_DEBOUNCE_MS = 2000;
+    getOrCreateState(scopeKey) {
+        const existing = this.stateByScope.get(scopeKey);
+        if (existing) {
+            return existing;
+        }
+        const currentModel = getStoredModel(scopeKey);
+        const state = {
+            currentAgent: getStoredAgent(scopeKey),
+            currentModel,
+            contextInfo: null,
+            variantName: formatVariantForButton(currentModel.variant || "default"),
+        };
+        this.stateByScope.set(scopeKey, state);
+        return state;
+    }
+    initialize(api, chatId, scopeKey = "global") {
+        this.api = api;
+        this.chatId = chatId;
+        const hadState = this.stateByScope.has(scopeKey);
+        const state = this.getOrCreateState(scopeKey);
+        if (!hadState) {
+            logger.debug(`[KeyboardManager] Initialized scope=${scopeKey} agent="${state.currentAgent}", model="${state.currentModel.providerID}/${state.currentModel.modelID}", variant="${state.currentModel.variant || "default"}", chatId=${chatId}`);
+        }
+    }
+    updateAgent(agent, scopeKey = "global") {
+        const state = this.getOrCreateState(scopeKey);
+        state.currentAgent = agent;
+    }
+    updateModel(model, scopeKey = "global") {
+        const state = this.getOrCreateState(scopeKey);
+        state.currentModel = model;
+        state.variantName = formatVariantForButton(model.variant || "default");
+    }
+    updateVariant(variantId, scopeKey = "global") {
+        const state = this.getOrCreateState(scopeKey);
+        state.variantName = formatVariantForButton(variantId);
+    }
+    updateContext(tokensUsed, tokensLimit, scopeKey = "global") {
+        const state = this.getOrCreateState(scopeKey);
+        state.contextInfo = { tokensUsed, tokensLimit };
+    }
+    clearContext(scopeKey = "global") {
+        const state = this.getOrCreateState(scopeKey);
+        state.contextInfo = null;
+    }
+    getContextInfo(scopeKey = "global") {
+        return this.getOrCreateState(scopeKey).contextInfo ?? null;
+    }
+    buildKeyboard(scopeKey) {
+        const state = this.getOrCreateState(scopeKey);
+        const scope = getScopeFromKey(scopeKey);
+        const effectiveContextInfo = scope?.context === SCOPE_CONTEXT.GROUP_GENERAL ? undefined : (state.contextInfo ?? undefined);
+        const keyboardOptions = scope?.context === SCOPE_CONTEXT.GROUP_GENERAL
+            ? {
+                contextFirst: true,
+                contextLabel: t("keyboard.general_defaults"),
+            }
+            : undefined;
+        return createMainKeyboard(state.currentAgent, state.currentModel, effectiveContextInfo, state.variantName, keyboardOptions);
+    }
+    async sendKeyboardUpdate(chatId, scopeKey = "global") {
+        if (!this.api) {
+            logger.warn("[KeyboardManager] API not initialized");
+            return;
+        }
+        const targetChatId = chatId ?? this.chatId;
+        if (!targetChatId) {
+            logger.warn("[KeyboardManager] No chatId available");
+            return;
+        }
+        const now = Date.now();
+        const lastUpdateTime = this.lastUpdateTimeByScope.get(scopeKey) ?? 0;
+        if (now - lastUpdateTime < this.UPDATE_DEBOUNCE_MS) {
+            return;
+        }
+        this.lastUpdateTimeByScope.set(scopeKey, now);
+        try {
+            const keyboard = this.buildKeyboard(scopeKey);
+            const threadId = getThreadIdFromScopeKey(scopeKey);
+            await this.api.sendMessage(targetChatId, t("keyboard.updated"), {
+                reply_markup: keyboard,
+                ...(typeof threadId === "number" ? { message_thread_id: threadId } : {}),
+            });
+        }
+        catch (err) {
+            logger.error("[KeyboardManager] Failed to send keyboard update:", err);
+        }
+    }
+    getKeyboard(scopeKey = "global") {
+        if (!this.stateByScope.has(scopeKey)) {
+            return undefined;
+        }
+        return this.buildKeyboard(scopeKey);
+    }
+    getState(scopeKey = "global") {
+        return this.stateByScope.get(scopeKey);
+    }
+    isInitialized(scopeKey = "global") {
+        return this.stateByScope.has(scopeKey);
+    }
+}
+export const keyboardManager = new KeyboardManager();

package/dist/keyboard/types.js

@@ -0,0 +1 @@
+export {};

package/dist/model/capabilities.js

@@ -0,0 +1,62 @@
+import { opencodeClient } from "../opencode/client.js";
+import { logger } from "../utils/logger.js";
+const capabilitiesCache = {};
+/**
+ * Get model capabilities from OpenCode API
+ * Results are cached in memory per model
+ */
+export async function getModelCapabilities(providerID, modelID) {
+    const cacheKey = `${providerID}/${modelID}`;
+    if (capabilitiesCache[cacheKey] !== undefined) {
+        logger.debug(`[ModelCapabilities] Cache hit for ${cacheKey}`);
+        return capabilitiesCache[cacheKey];
+    }
+    try {
+        logger.debug(`[ModelCapabilities] Fetching capabilities for ${cacheKey}`);
+        const response = await opencodeClient.config.providers();
+        if (response.error || !response.data) {
+            logger.error("[ModelCapabilities] API returned error:", response.error);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        const providers = response.data.providers;
+        const provider = providers.find((p) => p.id === providerID);
+        if (!provider) {
+            logger.warn(`[ModelCapabilities] Provider ${providerID} not found`);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        const model = provider.models[modelID];
+        if (!model) {
+            logger.warn(`[ModelCapabilities] Model ${cacheKey} not found in provider`);
+            capabilitiesCache[cacheKey] = null;
+            return null;
+        }
+        logger.debug(`[ModelCapabilities] Found capabilities for ${cacheKey}`);
+        capabilitiesCache[cacheKey] = model.capabilities;
+        return model.capabilities;
+    }
+    catch (error) {
+        logger.error("[ModelCapabilities] Failed to fetch providers:", error);
+        capabilitiesCache[cacheKey] = null;
+        return null;
+    }
+}
+/**
+ * Check if model supports a specific input type
+ */
+export function supportsInput(capabilities, inputType) {
+    if (!capabilities) {
+        return false;
+    }
+    return capabilities.input[inputType] === true;
+}
+/**
+ * Check if model supports attachments in general
+ */
+export function supportsAttachment(capabilities) {
+    if (!capabilities) {
+        return false;
+    }
+    return capabilities.attachment === true;
+}

package/dist/model/manager.js

@@ -0,0 +1,257 @@
+import path from "node:path";
+import { config } from "../config.js";
+import { opencodeClient } from "../opencode/client.js";
+import { getCurrentModel, getScopedModels, setCurrentModel } from "../settings/manager.js";
+import { logger } from "../utils/logger.js";
+const MODEL_CATALOG_CACHE_TTL_MS = 10 * 60 * 1000;
+let cachedValidModelKeys = null;
+let modelCatalogCacheExpiresAt = 0;
+let modelCatalogFetchInFlight = null;
+function getModelKey(providerID, modelID) {
+    return `${providerID}/${modelID}`;
+}
+function getEnvDefaultModel() {
+    const providerID = config.opencode.model.provider;
+    const modelID = config.opencode.model.modelId;
+    if (!providerID || !modelID) {
+        return null;
+    }
+    return { providerID, modelID };
+}
+function dedupeModels(models) {
+    const unique = new Map();
+    for (const model of models) {
+        const key = `${model.providerID}/${model.modelID}`;
+        if (!unique.has(key)) {
+            unique.set(key, model);
+        }
+    }
+    return Array.from(unique.values());
+}
+function filterModelsByCatalog(models, validModelKeys) {
+    if (!validModelKeys) {
+        return models;
+    }
+    return models.filter((model) => validModelKeys.has(getModelKey(model.providerID, model.modelID)));
+}
+async function getValidModelKeys() {
+    if (cachedValidModelKeys && Date.now() < modelCatalogCacheExpiresAt) {
+        logger.debug(`[ModelManager] Model catalog cache hit: models=${cachedValidModelKeys.size}, ttlMs=${modelCatalogCacheExpiresAt - Date.now()}`);
+        return cachedValidModelKeys;
+    }
+    if (modelCatalogFetchInFlight) {
+        logger.debug("[ModelManager] Awaiting in-flight model catalog refresh");
+        return modelCatalogFetchInFlight;
+    }
+    modelCatalogFetchInFlight = (async () => {
+        try {
+            logger.debug("[ModelManager] Refreshing model catalog from OpenCode API");
+            const response = await opencodeClient.config.providers();
+            if (response.error || !response.data) {
+                logger.warn("[ModelManager] Failed to refresh model catalog:", response.error);
+                if (cachedValidModelKeys) {
+                    logger.warn("[ModelManager] Using stale model catalog cache after refresh failure");
+                    return cachedValidModelKeys;
+                }
+                return null;
+            }
+            const validModelKeys = new Set();
+            for (const provider of response.data.providers) {
+                for (const modelID of Object.keys(provider.models)) {
+                    validModelKeys.add(getModelKey(provider.id, modelID));
+                }
+            }
+            cachedValidModelKeys = validModelKeys;
+            modelCatalogCacheExpiresAt = Date.now() + MODEL_CATALOG_CACHE_TTL_MS;
+            logger.debug(`[ModelManager] Model catalog refreshed: providers=${response.data.providers.length}, models=${validModelKeys.size}`);
+            return cachedValidModelKeys;
+        }
+        catch (err) {
+            logger.warn("[ModelManager] Error refreshing model catalog:", err);
+            if (cachedValidModelKeys) {
+                logger.warn("[ModelManager] Using stale model catalog cache after refresh exception");
+                return cachedValidModelKeys;
+            }
+            return null;
+        }
+        finally {
+            modelCatalogFetchInFlight = null;
+        }
+    })();
+    return modelCatalogFetchInFlight;
+}
+function normalizeFavoriteModels(state) {
+    if (!Array.isArray(state.favorite)) {
+        return [];
+    }
+    return state.favorite
+        .filter((model) => typeof model?.providerID === "string" &&
+        model.providerID.length > 0 &&
+        typeof model.modelID === "string" &&
+        model.modelID.length > 0)
+        .map((model) => ({
+        providerID: model.providerID,
+        modelID: model.modelID,
+    }));
+}
+function normalizeRecentModels(state) {
+    if (!Array.isArray(state.recent)) {
+        return [];
+    }
+    return state.recent
+        .filter((model) => typeof model?.providerID === "string" &&
+        model.providerID.length > 0 &&
+        typeof model.modelID === "string" &&
+        model.modelID.length > 0)
+        .map((model) => ({
+        providerID: model.providerID,
+        modelID: model.modelID,
+    }));
+}
+function getOpenCodeModelStatePath() {
+    const xdgStateHome = process.env.XDG_STATE_HOME;
+    if (xdgStateHome && xdgStateHome.trim().length > 0) {
+        return path.join(xdgStateHome, "opencode", "model.json");
+    }
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    return path.join(homeDir, ".local", "state", "opencode", "model.json");
+}
+/**
+ * Get favorite and recent models from OpenCode local state file.
+ * Config model is always treated as favorite.
+ */
+export async function getModelSelectionLists() {
+    const envDefaultModel = getEnvDefaultModel();
+    try {
+        const fs = await import("fs/promises");
+        const stateFilePath = getOpenCodeModelStatePath();
+        const content = await fs.readFile(stateFilePath, "utf-8");
+        const state = JSON.parse(content);
+        const rawFavorites = normalizeFavoriteModels(state);
+        const rawRecent = normalizeRecentModels(state);
+        const shouldValidateWithCatalog = rawFavorites.length > 0 || rawRecent.length > 0;
+        const validModelKeys = shouldValidateWithCatalog ? await getValidModelKeys() : null;
+        const validatedFavorites = filterModelsByCatalog(rawFavorites, validModelKeys);
+        const validatedRecent = filterModelsByCatalog(rawRecent, validModelKeys);
+        const favorites = envDefaultModel
+            ? dedupeModels([...validatedFavorites, envDefaultModel])
+            : validatedFavorites;
+        if (rawFavorites.length === 0 && envDefaultModel) {
+            logger.info(`[ModelManager] No favorites in ${stateFilePath}, using config model as favorite`);
+        }
+        if (favorites.length === 0) {
+            logger.warn(`[ModelManager] No favorites in ${stateFilePath}`);
+        }
+        const filteredOutFavorites = rawFavorites.length - validatedFavorites.length;
+        const filteredOutRecent = rawRecent.length - validatedRecent.length;
+        if (filteredOutFavorites > 0 || filteredOutRecent > 0) {
+            logger.info(`[ModelManager] Filtered unavailable models from OpenCode state: favoritesRemoved=${filteredOutFavorites}, recentRemoved=${filteredOutRecent}`);
+        }
+        const favoriteKeys = new Set(favorites.map((model) => getModelKey(model.providerID, model.modelID)));
+        const recent = dedupeModels(validatedRecent).filter((model) => !favoriteKeys.has(getModelKey(model.providerID, model.modelID)));
+        logger.debug(`[ModelManager] Loaded model selection lists from ${stateFilePath}: favorites=${favorites.length}, recent=${recent.length}`);
+        return { favorites, recent };
+    }
+    catch (err) {
+        if (envDefaultModel) {
+            logger.warn("[ModelManager] Failed to load OpenCode model state, using config model as favorite:", err);
+            return {
+                favorites: [envDefaultModel],
+                recent: [],
+            };
+        }
+        logger.error("[ModelManager] Failed to load OpenCode model state:", err);
+        return {
+            favorites: [],
+            recent: [],
+        };
+    }
+}
+export async function reconcileStoredModelSelection() {
+    const scopedEntries = Object.entries(getScopedModels()).filter(([, model]) => Boolean(model?.providerID && model.modelID));
+    if (scopedEntries.length === 0) {
+        return;
+    }
+    const validModelKeys = await getValidModelKeys();
+    if (!validModelKeys) {
+        logger.warn("[ModelManager] Skipping stored model validation: model catalog unavailable");
+        return;
+    }
+    const envDefaultModel = getEnvDefaultModel();
+    if (!envDefaultModel) {
+        logger.warn("[ModelManager] Cannot reconcile unavailable stored models: env default model is missing");
+        return;
+    }
+    const fallbackModel = {
+        providerID: envDefaultModel.providerID,
+        modelID: envDefaultModel.modelID,
+        variant: "default",
+    };
+    for (const [scopeKey, model] of scopedEntries) {
+        const currentModelKey = getModelKey(model.providerID, model.modelID);
+        if (validModelKeys.has(currentModelKey)) {
+            continue;
+        }
+        logger.warn(`[ModelManager] Stored model ${currentModelKey} is unavailable in scope ${scopeKey}, falling back to ${fallbackModel.providerID}/${fallbackModel.modelID}`);
+        setCurrentModel({ ...fallbackModel }, scopeKey);
+    }
+}
+export function __resetModelCatalogCacheForTests() {
+    cachedValidModelKeys = null;
+    modelCatalogCacheExpiresAt = 0;
+    modelCatalogFetchInFlight = null;
+}
+/**
+ * Get list of favorite models from OpenCode local state file
+ * Falls back to env default model if file is unavailable or empty
+ */
+export async function getFavoriteModels() {
+    const { favorites } = await getModelSelectionLists();
+    return favorites;
+}
+/**
+ * Get current model from settings or fallback to config
+ * @returns Current model info
+ */
+export function fetchCurrentModel(scopeKey = "global") {
+    return getStoredModel(scopeKey);
+}
+/**
+ * Select model and persist to settings
+ * @param modelInfo Model to select
+ */
+export function selectModel(modelInfo, scopeKey = "global") {
+    logger.info(`[ModelManager] Selected model: ${modelInfo.providerID}/${modelInfo.modelID}`);
+    setCurrentModel(modelInfo, scopeKey);
+}
+/**
+ * Get stored model from settings (synchronous)
+ * ALWAYS returns a model - fallback to config if not found
+ * @returns Current model info
+ */
+export function getStoredModel(scopeKey = "global") {
+    const storedModel = getCurrentModel(scopeKey);
+    if (storedModel) {
+        // Ensure variant is set (default to "default")
+        if (!storedModel.variant) {
+            storedModel.variant = "default";
+        }
+        return storedModel;
+    }
+    // Fallback to model from config (environment variables)
+    if (config.opencode.model.provider && config.opencode.model.modelId) {
+        logger.debug("[ModelManager] Using model from config");
+        return {
+            providerID: config.opencode.model.provider,
+            modelID: config.opencode.model.modelId,
+            variant: "default",
+        };
+    }
+    // This should not happen if config is properly set
+    logger.warn("[ModelManager] No model found in settings or config, returning empty model");
+    return {
+        providerID: "",
+        modelID: "",
+        variant: "default",
+    };
+}

package/dist/model/types.js

@@ -0,0 +1,24 @@
+/**
+ * Model types and formatting utilities
+ */
+/**
+ * Format model for button display (compact format)
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns Formatted string "providerID/modelID"
+ */
+export function formatModelForButton(providerID, modelID) {
+    // If model name is too long, we only truncate the model part
+    const displayModelId = modelID.length > 20 ? `${modelID.substring(0, 17)}...` : modelID;
+    const displayProviderId = providerID.length > 15 ? `${providerID.substring(0, 12)}...` : providerID;
+    return `🤖 ${displayProviderId}\n${displayModelId}`;
+}
+/**
+ * Format model for display in messages (full format)
+ * @param providerID Provider ID
+ * @param modelID Model ID
+ * @returns Formatted string "providerID / modelID"
+ */
+export function formatModelForDisplay(providerID, modelID) {
+    return `${providerID} / ${modelID}`;
+}

package/dist/opencode/client.js

@@ -0,0 +1,13 @@
+import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+import { config } from "../config.js";
+const getAuth = () => {
+    if (!config.opencode.password) {
+        return undefined;
+    }
+    const credentials = `${config.opencode.username}:${config.opencode.password}`;
+    return `Basic ${Buffer.from(credentials).toString("base64")}`;
+};
+export const opencodeClient = createOpencodeClient({
+    baseUrl: config.opencode.apiUrl,
+    headers: config.opencode.password ? { Authorization: getAuth() } : undefined,
+});

package/dist/opencode/events.js

@@ -0,0 +1,159 @@
+import { opencodeClient } from "./client.js";
+import { logger } from "../utils/logger.js";
+const RECONNECT_BASE_DELAY_MS = 1000;
+const RECONNECT_MAX_DELAY_MS = 15000;
+const FATAL_NO_STREAM_ERROR = "No stream returned from event subscription";
+const workersByDirectory = new Map();
+function getReconnectDelayMs(attempt) {
+    const exponentialDelay = RECONNECT_BASE_DELAY_MS * Math.pow(2, Math.max(0, attempt - 1));
+    return Math.min(exponentialDelay, RECONNECT_MAX_DELAY_MS);
+}
+function waitWithAbort(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve(false);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timeoutId);
+            signal.removeEventListener("abort", onAbort);
+            resolve(false);
+        };
+        const timeoutId = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve(true);
+        }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function getOrCreateWorker(directory) {
+    const existingWorker = workersByDirectory.get(directory);
+    if (existingWorker) {
+        return existingWorker;
+    }
+    const nextWorker = {
+        directory,
+        callbacks: new Set(),
+        abortController: new AbortController(),
+        loopPromise: null,
+    };
+    workersByDirectory.set(directory, nextWorker);
+    return nextWorker;
+}
+function dispatchEvent(worker, event) {
+    const callbacks = Array.from(worker.callbacks);
+    for (const callback of callbacks) {
+        setImmediate(() => {
+            try {
+                const result = callback(event);
+                if (result && typeof result.then === "function") {
+                    void result.then(undefined, (error) => {
+                        logger.error("[Events] Async callback rejected", { directory: worker.directory, eventType: event.type }, error);
+                    });
+                }
+            }
+            catch (error) {
+                logger.error("[Events] Event callback failed", { directory: worker.directory, eventType: event.type }, error);
+            }
+        });
+    }
+}
+async function runWorkerLoop(worker) {
+    let reconnectAttempt = 0;
+    const { directory, abortController } = worker;
+    while (!abortController.signal.aborted && worker.callbacks.size > 0) {
+        try {
+            const result = await opencodeClient.event.subscribe({ directory }, { signal: abortController.signal });
+            if (!result.stream) {
+                throw new Error(FATAL_NO_STREAM_ERROR);
+            }
+            reconnectAttempt = 0;
+            for await (const event of result.stream) {
+                if (abortController.signal.aborted || worker.callbacks.size === 0) {
+                    break;
+                }
+                await new Promise((resolve) => setImmediate(resolve));
+                dispatchEvent(worker, event);
+            }
+            if (abortController.signal.aborted || worker.callbacks.size === 0) {
+                break;
+            }
+            reconnectAttempt++;
+            const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
+            logger.warn(`[Events] Stream ended, reconnecting`, {
+                directory,
+                reconnectAttempt,
+                reconnectDelay,
+            });
+            const shouldContinue = await waitWithAbort(reconnectDelay, abortController.signal);
+            if (!shouldContinue) {
+                break;
+            }
+        }
+        catch (error) {
+            if (abortController.signal.aborted || worker.callbacks.size === 0) {
+                break;
+            }
+            if (error instanceof Error && error.message === FATAL_NO_STREAM_ERROR) {
+                logger.error("[Events] Fatal event stream error", { directory }, error);
+                break;
+            }
+            reconnectAttempt++;
+            const reconnectDelay = getReconnectDelayMs(reconnectAttempt);
+            logger.error(`[Events] Stream failed, reconnecting`, { directory, reconnectAttempt, reconnectDelay }, error);
+            const shouldContinue = await waitWithAbort(reconnectDelay, abortController.signal);
+            if (!shouldContinue) {
+                break;
+            }
+        }
+    }
+}
+function ensureWorkerStarted(worker) {
+    if (worker.loopPromise) {
+        return;
+    }
+    worker.loopPromise = runWorkerLoop(worker)
+        .catch((error) => {
+        logger.error("[Events] Worker loop failed unexpectedly", { directory: worker.directory }, error);
+    })
+        .finally(() => {
+        worker.loopPromise = null;
+        if (worker.callbacks.size === 0 || worker.abortController.signal.aborted) {
+            workersByDirectory.delete(worker.directory);
+        }
+    });
+}
+export async function subscribeToEvents(directory, callback) {
+    const worker = getOrCreateWorker(directory);
+    worker.callbacks.add(callback);
+    ensureWorkerStarted(worker);
+}
+export function unsubscribeFromEvents(directory, callback) {
+    const worker = workersByDirectory.get(directory);
+    if (!worker) {
+        return;
+    }
+    worker.callbacks.delete(callback);
+    if (worker.callbacks.size > 0) {
+        return;
+    }
+    worker.abortController.abort();
+    workersByDirectory.delete(directory);
+}
+export function stopEventListening(directory) {
+    if (directory) {
+        const worker = workersByDirectory.get(directory);
+        if (!worker) {
+            return;
+        }
+        worker.abortController.abort();
+        workersByDirectory.delete(directory);
+        logger.info("[Events] Stopped event listener", { directory });
+        return;
+    }
+    for (const [workerDirectory, worker] of workersByDirectory.entries()) {
+        worker.abortController.abort();
+        workersByDirectory.delete(workerDirectory);
+    }
+    logger.info("[Events] Stopped all event listeners");
+}