@deadragdoll/tellymcp 0.0.9 → 0.0.11

package/dist/services/features/telegram-mcp/src/features/tools-sync/model/refreshToolsMarkdownService.js

@@ -4,6 +4,9 @@ exports.RefreshToolsMarkdownService = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const schema_1 = require("../../../entities/request/model/schema");
+const projectIdentity_1 = require("../../../shared/lib/project-identity/projectIdentity");
+const versionHandshake_1 = require("../../../shared/lib/version/versionHandshake");
 function normalizeGatewayBaseUrl(value) {
     const url = new URL(value);
     url.pathname = url.pathname.replace(/\/+$/u, "");
@@ -15,27 +18,84 @@ function normalizeGatewayBaseUrl(value) {
 function computeContentHash(content) {
     return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
 }
+function normalizeClientLocalSessionId(mode, value) {
+    const trimmed = value?.trim();
+    if (!trimmed || mode !== "client") {
+        return trimmed || undefined;
+    }
+    const separatorIndex = trimmed.indexOf(":");
+    if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
+        return trimmed;
+    }
+    return trimmed.slice(separatorIndex + 1).trim() || trimmed;
+}
+function normalizeRemoteRefreshOutput(value) {
+    const candidate = value && typeof value === "object" && "structuredContent" in value
+        ? value.structuredContent
+        : value && typeof value === "object" && "result" in value
+            ? value.result
+            : value;
+    const parsed = schema_1.refreshToolsMarkdownOutputSchema.safeParse(candidate);
+    return parsed.success ? parsed.data : null;
+}
 class RefreshToolsMarkdownService {
     config;
     sessionStore;
     logger;
     projectIdentityResolver;
-    constructor(config, sessionStore, logger, projectIdentityResolver) {
+    remoteConsoleInvoker;
+    constructor(config, sessionStore, logger, projectIdentityResolver, remoteConsoleInvoker) {
         this.config = config;
         this.sessionStore = sessionStore;
         this.logger = logger;
         this.projectIdentityResolver = projectIdentityResolver;
+        this.remoteConsoleInvoker = remoteConsoleInvoker;
     }
     async refresh(input = {}) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = normalizeClientLocalSessionId(this.config.distributed.mode, input.session_id);
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults({
+            ...input,
+            ...(normalizedSessionId ? { session_id: normalizedSessionId } : {}),
+        });
+        const explicitCwd = input.cwd?.trim() ? (0, node_path_1.resolve)(input.cwd.trim()) : null;
+        const requestedSessionId = normalizedSessionId ?? "";
+        const knownHash = input.known_hash?.trim() || null;
+        const remoteLookupRequested = Boolean(this.remoteConsoleInvoker) &&
+            this.config.distributed.mode !== "client";
+        const remote = remoteLookupRequested && requestedSessionId
+            ? await this.remoteConsoleInvoker?.invokeForRelaySession(requestedSessionId, "telegramMcp.toolsSync.refreshToolsMarkdownRemote", input)
+            : null;
+        if (remote) {
+            const normalizedRemote = normalizeRemoteRefreshOutput(remote);
+            if (normalizedRemote) {
+                return normalizedRemote;
+            }
+            this.logger.error("refresh_tools_markdown received invalid remote console output", {
+                sessionId: requestedSessionId,
+                remote,
+            });
+            throw new Error(`Invalid remote refresh_tools_markdown output: ${JSON.stringify(remote)}`);
+        }
+        if (remoteLookupRequested) {
+            this.logger.error("refresh_tools_markdown could not resolve remote console target", {
+                sessionId: resolved.sessionId,
+                requestedSessionId,
+                explicitCwd,
+            });
+            throw new Error(requestedSessionId
+                ? "Could not resolve remote console target for refresh_tools_markdown. Use the canonical gateway session_id in the format client_uuid:local_session_id."
+                : "refresh_tools_markdown requires explicit session_id in gateway mode. Use the canonical gateway session_id in the format client_uuid:local_session_id.");
+        }
         const session = await this.sessionStore.getSession(resolved.sessionId);
-        const workspaceDir = input.cwd?.trim()
-            ? (0, node_path_1.resolve)(input.cwd.trim())
-            : session?.cwd?.trim()
-                ? (0, node_path_1.resolve)(session.cwd.trim())
-                : undefined;
-        const saveLocally = input.save_locally !== false;
-        const gatewayToolsPath = (0, node_path_1.join)(process.cwd(), "TOOLS.md");
+        const sessionCwd = session?.cwd?.trim() ? (0, node_path_1.resolve)(session.cwd.trim()) : null;
+        const workspaceDir = requestedSessionId
+            ? sessionCwd ?? explicitCwd ?? resolved.cwd
+            : explicitCwd ?? sessionCwd ?? resolved.cwd;
+        const packageRoot = (0, versionHandshake_1.getTellyMcpPackageRoot)(__dirname);
+        if (!packageRoot) {
+            throw new Error("Could not resolve installed package root for TOOLS.md.");
+        }
+        const gatewayToolsPath = (0, node_path_1.join)(packageRoot, "TOOLS.md");
         let source = "local";
         let content;
         if (this.config.distributed.gatewayPublicUrl) {
@@ -59,64 +119,53 @@ class RefreshToolsMarkdownService {
         else {
             content = (0, node_fs_1.readFileSync)(gatewayToolsPath, "utf8");
         }
-        if (!workspaceDir) {
-            throw new Error("Could not resolve target workspace for TOOLS.md. Pair the session with cwd first or pass cwd/session_id explicitly.");
-        }
-        const toolsPath = (0, node_path_1.join)(workspaceDir, "TOOLS.md");
-        if (saveLocally) {
-            (0, node_fs_1.writeFileSync)(toolsPath, content, "utf8");
-            const appliedHash = computeContentHash(content);
-            await this.sessionStore.setSession({
-                sessionId: resolved.sessionId,
-                ...(session?.label ? { label: session.label } : {}),
-                ...(session?.cwd ? { cwd: session.cwd } : { cwd: workspaceDir }),
-                ...(session?.linkedSessionId
-                    ? { linkedSessionId: session.linkedSessionId }
-                    : {}),
-                ...(session?.activeProjectUuid
-                    ? { activeProjectUuid: session.activeProjectUuid }
-                    : {}),
-                ...(session?.activeProjectName
-                    ? { activeProjectName: session.activeProjectName }
-                    : {}),
-                ...(session?.task ? { task: session.task } : {}),
-                ...(session?.summary ? { summary: session.summary } : {}),
-                ...(session?.files ? { files: session.files } : {}),
-                ...(session?.decisions ? { decisions: session.decisions } : {}),
-                ...(session?.risks ? { risks: session.risks } : {}),
-                ...(session?.tmuxSessionName
-                    ? { tmuxSessionName: session.tmuxSessionName }
-                    : {}),
-                ...(session?.tmuxWindowName
-                    ? { tmuxWindowName: session.tmuxWindowName }
-                    : {}),
-                ...(typeof session?.tmuxWindowIndex === "number"
-                    ? { tmuxWindowIndex: session.tmuxWindowIndex }
-                    : {}),
-                ...(session?.tmuxPaneId ? { tmuxPaneId: session.tmuxPaneId } : {}),
-                ...(typeof session?.tmuxPaneIndex === "number"
-                    ? { tmuxPaneIndex: session.tmuxPaneIndex }
-                    : {}),
-                ...(session?.tmuxTarget ? { tmuxTarget: session.tmuxTarget } : {}),
-                ...(session?.lastTmuxNudgeAt
-                    ? { lastTmuxNudgeAt: session.lastTmuxNudgeAt }
-                    : {}),
-                lastSeenToolsHash: appliedHash,
-                lastNotifiedToolsHash: appliedHash,
-                updatedAt: new Date().toISOString(),
+        const currentHash = computeContentHash(content);
+        const changed = knownHash !== currentHash;
+        await this.sessionStore.setSession({
+            sessionId: resolved.sessionId,
+            ...(session?.label ? { label: session.label } : {}),
+            ...(session?.cwd ? { cwd: session.cwd } : workspaceDir ? { cwd: workspaceDir } : {}),
+            ...(session?.activeProjectUuid
+                ? { activeProjectUuid: session.activeProjectUuid }
+                : {}),
+            ...(session?.activeProjectName
+                ? { activeProjectName: session.activeProjectName }
+                : {}),
+            ...(session?.task ? { task: session.task } : {}),
+            ...(session?.summary ? { summary: session.summary } : {}),
+            ...(session?.files ? { files: session.files } : {}),
+            ...(session?.decisions ? { decisions: session.decisions } : {}),
+            ...(session?.risks ? { risks: session.risks } : {}),
+            ...(session?.terminalTarget ? { terminalTarget: session.terminalTarget } : {}),
+            ...(session?.lastTerminalNudgeAt
+                ? { lastTerminalNudgeAt: session.lastTerminalNudgeAt }
+                : {}),
+            lastSeenToolsHash: currentHash,
+            lastNotifiedToolsHash: currentHash,
+            updatedAt: new Date().toISOString(),
+        });
+        if (workspaceDir) {
+            (0, projectIdentity_1.writeSessionMarkerState)({
+                cwd: workspaceDir,
+                localSessionId: resolved.sessionId,
+                lastSeenToolsHash: currentHash,
+                lastNotifiedToolsHash: currentHash,
+                logger: this.logger,
             });
         }
         this.logger.info("TOOLS.md refreshed", {
             source,
-            saved: saveLocally,
-            path: toolsPath,
             bytes: Buffer.byteLength(content, "utf8"),
+            currentHash,
+            changed,
         });
         return {
             source,
-            saved: saveLocally,
+            session_id: resolved.sessionId,
+            current_hash: currentHash,
+            changed,
+            ...(changed ? { content } : {}),
             bytes: Buffer.byteLength(content, "utf8"),
-            ...(saveLocally ? { path: toolsPath } : {}),
         };
     }
 }

package/dist/services/features/telegram-mcp/src/features/tools-sync/model/refreshToolsMarkdownTool.js

@@ -18,7 +18,7 @@ class RefreshToolsMarkdownTool {
     register(server) {
         server.registerTool("refresh_tools_markdown", {
             title: "Refresh TOOLS.md",
-            description: "Use this when the user asks to refresh or update agent instructions, tools documentation, or gateway-side working rules. Download the canonical TOOLS.md from the configured gateway, overwrite the local workspace TOOLS.md, then re-read that local TOOLS.md before continuing. If no gateway is configured, refresh from the local file.",
+            description: "Use this when the user asks to refresh or update agent instructions, tools documentation, or gateway-side working rules. In gateway mode, always pass explicit session_id equal to the canonical gateway console id client_uuid:local_session_id. If the current console id is already known from prior context, reuse it directly and do not call list_gateway_sessions again. Only call list_gateway_sessions when the console id is unknown, then take session_id from the matching record exactly as returned. Do not use workspace-derived ids or cwd for routing. Prefer hash-based refresh: pass known_hash from the last applied TOOLS state. The tool returns current_hash and changed; content is included only when changed=true. There is no local file-save mode: read and apply returned content directly.",
             inputSchema: schema_1.refreshToolsMarkdownInputSchema,
             outputSchema: schema_1.refreshToolsMarkdownOutputSchema,
         }, async (args) => {

package/dist/services/features/telegram-mcp/src/features/xchange/model/getXchangeRecordTool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetXchangeRecordTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [{ type: "text", text: JSON.stringify(output, null, 2) }];
+}
+class GetXchangeRecordTool {
+    xchangeService;
+    constructor(xchangeService) {
+        this.xchangeService = xchangeService;
+    }
+    register(server) {
+        server.registerTool("get_xchange_record", {
+            title: "Get Xchange Record",
+            description: "Read one structured .mcp-xchange record by record_id. Use this to get the full body_text, action_desc, tools, attachments, routing metadata, and reply requirements for a collaboration item, local handoff, or human Telegram message.",
+            inputSchema: schema_1.getXchangeRecordInputSchema,
+            outputSchema: schema_1.getXchangeRecordOutputSchema,
+        }, async (args) => {
+            const output = await this.xchangeService.getRecord(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.GetXchangeRecordTool = GetXchangeRecordTool;

package/dist/services/features/telegram-mcp/src/features/xchange/model/listXchangeRecordsTool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListXchangeRecordsTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [{ type: "text", text: JSON.stringify(output, null, 2) }];
+}
+class ListXchangeRecordsTool {
+    xchangeService;
+    constructor(xchangeService) {
+        this.xchangeService = xchangeService;
+    }
+    register(server) {
+        server.registerTool("list_xchange_records", {
+            title: "List Xchange Records",
+            description: "List structured .mcp-xchange records for the current console from the local sqlite store. Use this first for partner notes, local handoffs, unread collaboration items, human Telegram messages, and follow-up work instead of parsing markdown index files or relying on inbox-style flows.",
+            inputSchema: schema_1.listXchangeRecordsInputSchema,
+            outputSchema: schema_1.listXchangeRecordsOutputSchema,
+        }, async (args) => {
+            const output = await this.xchangeService.listRecords(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.ListXchangeRecordsTool = ListXchangeRecordsTool;

package/dist/services/features/telegram-mcp/src/features/xchange/model/markXchangeRecordReadTool.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkXchangeRecordReadTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [{ type: "text", text: JSON.stringify(output, null, 2) }];
+}
+class MarkXchangeRecordReadTool {
+    xchangeService;
+    constructor(xchangeService) {
+        this.xchangeService = xchangeService;
+    }
+    register(server) {
+        server.registerTool("mark_xchange_record_read", {
+            title: "Mark Xchange Record Read",
+            description: "Mark a structured .mcp-xchange record as read after you have consumed its body_text, attachments, and next-step instructions.",
+            inputSchema: schema_1.markXchangeRecordReadInputSchema,
+            outputSchema: schema_1.markXchangeRecordReadOutputSchema,
+        }, async (args) => {
+            const output = await this.xchangeService.markRead(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.MarkXchangeRecordReadTool = MarkXchangeRecordReadTool;

package/dist/services/features/telegram-mcp/src/features/xchange/model/xchangeService.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XchangeService = void 0;
+const sqliteRecordStore_1 = require("../../../shared/integrations/xchange/sqliteRecordStore");
+class XchangeService {
+    config;
+    sessionStore;
+    maintenanceStore;
+    xchangeFileMetaStore;
+    logger;
+    projectIdentityResolver;
+    remoteConsoleInvoker;
+    constructor(config, sessionStore, maintenanceStore, xchangeFileMetaStore, logger, projectIdentityResolver, remoteConsoleInvoker) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.maintenanceStore = maintenanceStore;
+        this.xchangeFileMetaStore = xchangeFileMetaStore;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+        this.remoteConsoleInvoker = remoteConsoleInvoker;
+    }
+    async listRecords(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = this.config.distributed.mode !== "client"
+            ? await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, "telegramMcp.xchange.listRecordsRemote", {
+                ...input,
+                session_id: sessionId,
+            })
+            : null;
+        if (remote) {
+            return remote;
+        }
+        const workspaceDir = await this.resolveWorkspaceDir(sessionId);
+        const records = await (0, sqliteRecordStore_1.listXchangeRecords)(this.config.terminal, workspaceDir, this.config.exchange.dir, sessionId, {
+            ...(input.status ? { status: input.status } : {}),
+            ...(input.category ? { category: input.category } : {}),
+            ...(input.direction ? { direction: input.direction } : {}),
+            ...(typeof input.limit === "number" ? { limit: input.limit } : {}),
+        });
+        this.logger.info("Xchange records listed", {
+            sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            total: records.length,
+            status: input.status,
+            category: input.category,
+            direction: input.direction,
+            limit: input.limit,
+        });
+        return {
+            session_id: sessionId,
+            total: records.length,
+            records,
+        };
+    }
+    async getRecord(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = this.config.distributed.mode !== "client"
+            ? await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, "telegramMcp.xchange.getRecordRemote", {
+                ...input,
+                session_id: sessionId,
+            })
+            : null;
+        if (remote) {
+            return remote;
+        }
+        const workspaceDir = await this.resolveWorkspaceDir(sessionId);
+        const record = await (0, sqliteRecordStore_1.getXchangeRecord)(this.config.terminal, workspaceDir, this.config.exchange.dir, sessionId, input.record_id);
+        this.logger.info("Xchange record fetched", {
+            sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            recordId: input.record_id,
+            exists: Boolean(record),
+        });
+        return {
+            session_id: sessionId,
+            record,
+        };
+    }
+    async markRead(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = this.config.distributed.mode !== "client"
+            ? await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, "telegramMcp.xchange.markReadRemote", {
+                ...input,
+                session_id: sessionId,
+            })
+            : null;
+        if (remote) {
+            return remote;
+        }
+        const workspaceDir = await this.resolveWorkspaceDir(sessionId);
+        const updated = await (0, sqliteRecordStore_1.markXchangeRecordRead)(this.config.terminal, workspaceDir, this.config.exchange.dir, sessionId, input.record_id);
+        this.logger.info("Xchange record marked as read", {
+            sessionId,
+            sessionIdDerived: resolved.sessionIdDerived,
+            recordId: input.record_id,
+            updated,
+        });
+        return {
+            session_id: sessionId,
+            record_id: input.record_id,
+            updated,
+        };
+    }
+    async listFileMetas(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const metas = await this.xchangeFileMetaStore.listXchangeFileMetas(sessionId);
+        const filtered = input.source
+            ? metas.filter((meta) => meta.source === input.source)
+            : metas;
+        filtered.sort((left, right) => right.filePath.localeCompare(left.filePath));
+        return {
+            session_id: sessionId,
+            metas: filtered,
+        };
+    }
+    async getFileMeta(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        return {
+            session_id: sessionId,
+            file_path: input.file_path,
+            meta: await this.xchangeFileMetaStore.getXchangeFileMeta(sessionId, input.file_path),
+        };
+    }
+    async deleteFileMeta(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        return {
+            session_id: sessionId,
+            file_path: input.file_path,
+            deleted: await this.xchangeFileMetaStore.deleteXchangeFileMeta(sessionId, input.file_path),
+        };
+    }
+    async normalizeSessionIdForAccess(sessionId) {
+        const trimmed = sessionId.trim();
+        if (!trimmed) {
+            return trimmed;
+        }
+        const direct = await this.sessionStore.getSession(trimmed);
+        if (direct) {
+            return trimmed;
+        }
+        const separatorIndex = trimmed.indexOf(":");
+        if (separatorIndex <= 0) {
+            return trimmed;
+        }
+        const localClientUuid = await this.maintenanceStore.getGatewayClientUuid();
+        const clientUuid = trimmed.slice(0, separatorIndex).trim();
+        const localSessionId = trimmed.slice(separatorIndex + 1).trim();
+        if (!localClientUuid || clientUuid !== localClientUuid || !localSessionId) {
+            return trimmed;
+        }
+        const localSession = await this.sessionStore.getSession(localSessionId);
+        return localSession ? localSessionId : trimmed;
+    }
+    async resolveWorkspaceDir(sessionId) {
+        const session = await this.sessionStore.getSession(sessionId);
+        const workspaceDir = session?.cwd?.trim();
+        if (!workspaceDir) {
+            throw new Error(`Workspace cwd is not registered for console '${sessionId}'.`);
+        }
+        return workspaceDir;
+    }
+}
+exports.XchangeService = XchangeService;

package/dist/services/features/telegram-mcp/src/processes/human-approval/model/orchestrator.js

@@ -55,8 +55,9 @@ class HumanApprovalOrchestrator {
             session_id: input.session_id,
         });
         const binding = await this.bindingStore.getBinding(resolved.sessionId);
-        if (!binding) {
-            throw new Error("Session is not linked to Telegram. Call create_session_pair_code first.");
+        const canUseGatewayProxy = Boolean(this.config.distributed.gatewayPublicUrl);
+        if (!binding && !canUseGatewayProxy) {
+            throw new Error("Session is not available through the gateway console registry yet. Open /menu in the gateway bot and select the console first.");
         }
         const session = await this.sessionStore.getSession(resolved.sessionId);
         const merged = mergeSavedContext(input, session);
@@ -88,8 +89,8 @@ class HumanApprovalOrchestrator {
             ...(input.fallback_if_timeout
                 ? { fallbackIfTimeout: (0, redactSecrets_1.redactSecrets)(input.fallback_if_timeout) }
                 : {}),
-            telegramChatId: binding.telegramChatId,
-            telegramUserId: binding.telegramUserId,
+            telegramChatId: binding?.telegramChatId ?? 0,
+            telegramUserId: binding?.telegramUserId ?? 0,
             queuedAt: new Date().toISOString(),
             status: this.config.mode === "queue" ? "queued" : "active",
         };

package/dist/services/features/telegram-mcp/src/shared/i18n/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLocale = normalizeLocale;
+exports.translate = translate;
+const i18next_1 = require("i18next");
+const en_1 = require("./resources/en");
+const ru_1 = require("./resources/ru");
+const instance = (0, i18next_1.createInstance)();
+void instance.init({
+    lng: "en",
+    fallbackLng: "en",
+    ns: ["common", "menu"],
+    defaultNS: "common",
+    initAsync: false,
+    interpolation: {
+        escapeValue: false,
+    },
+    returnNull: false,
+    returnEmptyString: false,
+    resources: {
+        en: {
+            common: en_1.enCommon,
+            menu: en_1.enMenu,
+        },
+        ru: {
+            common: ru_1.ruCommon,
+            menu: ru_1.ruMenu,
+        },
+    },
+});
+function normalizeLocale(input) {
+    const normalized = input?.trim().toLowerCase() ?? "";
+    if (normalized === "ru" || normalized.startsWith("ru-")) {
+        return "ru";
+    }
+    if (normalized === "en" || normalized.startsWith("en-")) {
+        return "en";
+    }
+    return "en";
+}
+function translate(locale, key, options) {
+    return instance.t(key, {
+        lng: normalizeLocale(locale),
+        ...(options ?? {}),
+    });
+}