@deadragdoll/tellymcp 0.0.1

package/dist/lib/trace.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTraceErrorData = exports.buildTraceSuccessData = exports.buildTraceStartData = exports.buildTraceMetaSummary = exports.sanitizeTraceValue = exports.normalizeTraceLevel = void 0;
+const TRACE_MAX_DEPTH = 4;
+const TRACE_MAX_ARRAY = 25;
+const TRACE_MAX_KEYS = 40;
+const TRACE_MAX_STRING = 1000;
+const truncateString = (value) => value.length > TRACE_MAX_STRING ? `${value.slice(0, TRACE_MAX_STRING)}...` : value;
+const normalizeTraceLevel = (value) => {
+    const level = String(value || "info").toLowerCase();
+    if (["fatal", "error", "warn", "info", "debug", "trace"].includes(level)) {
+        return level;
+    }
+    return "info";
+};
+exports.normalizeTraceLevel = normalizeTraceLevel;
+const sanitizeError = (error, depth, seen) => {
+    if (!(error instanceof Error)) {
+        return (0, exports.sanitizeTraceValue)(error, depth, seen);
+    }
+    return {
+        name: error.name,
+        message: truncateString(error.message || ""),
+        stack: truncateString(error.stack || ""),
+    };
+};
+const sanitizeTraceValue = (value, depth = 0, seen = new WeakSet()) => {
+    if (value == null || typeof value === "boolean" || typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        return truncateString(value);
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (typeof value === "symbol") {
+        return value.toString();
+    }
+    if (typeof value === "function") {
+        return `[Function ${value.name || "anonymous"}]`;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (value instanceof Error) {
+        return sanitizeError(value, depth, seen);
+    }
+    if (Buffer.isBuffer(value)) {
+        return `[Buffer ${value.length}]`;
+    }
+    if (value instanceof Set) {
+        return {
+            type: "Set",
+            size: value.size,
+            values: Array.from(value.values())
+                .slice(0, TRACE_MAX_ARRAY)
+                .map(item => (0, exports.sanitizeTraceValue)(item, depth + 1, seen)),
+        };
+    }
+    if (value instanceof Map) {
+        return {
+            type: "Map",
+            size: value.size,
+            entries: Array.from(value.entries())
+                .slice(0, TRACE_MAX_ARRAY)
+                .map(([key, item]) => [
+                (0, exports.sanitizeTraceValue)(key, depth + 1, seen),
+                (0, exports.sanitizeTraceValue)(item, depth + 1, seen),
+            ]),
+        };
+    }
+    if (Array.isArray(value)) {
+        if (depth >= TRACE_MAX_DEPTH) {
+            return `[Array(${value.length})]`;
+        }
+        return value
+            .slice(0, TRACE_MAX_ARRAY)
+            .map(item => (0, exports.sanitizeTraceValue)(item, depth + 1, seen));
+    }
+    if (typeof value === "object") {
+        const objectValue = value;
+        if (seen.has(objectValue)) {
+            return "[Circular]";
+        }
+        seen.add(objectValue);
+        if (depth >= TRACE_MAX_DEPTH) {
+            return `[${objectValue?.constructor?.name || "Object"}]`;
+        }
+        const keys = Object.keys(objectValue).slice(0, TRACE_MAX_KEYS);
+        const result = {};
+        for (const key of keys) {
+            result[key] = (0, exports.sanitizeTraceValue)(objectValue[key], depth + 1, seen);
+        }
+        if (Object.keys(objectValue).length > TRACE_MAX_KEYS) {
+            result.__truncatedKeys = Object.keys(objectValue).length - TRACE_MAX_KEYS;
+        }
+        return result;
+    }
+    return String(value);
+};
+exports.sanitizeTraceValue = sanitizeTraceValue;
+const pickFields = (source, fields) => {
+    if (fields === false) {
+        return undefined;
+    }
+    if (fields === true || fields == null) {
+        return (0, exports.sanitizeTraceValue)(source);
+    }
+    if (!source || typeof source !== "object") {
+        return (0, exports.sanitizeTraceValue)(source);
+    }
+    const result = {};
+    for (const key of fields) {
+        result[key] = (0, exports.sanitizeTraceValue)(source[key]);
+    }
+    return result;
+};
+const buildTraceMetaSummary = (ctx) => (0, exports.sanitizeTraceValue)({
+    requestID: ctx.requestID || null,
+    userSub: ctx.meta?.user?.sub || null,
+});
+exports.buildTraceMetaSummary = buildTraceMetaSummary;
+const buildTraceStartData = (ctx, actionName, tracer, startedSession = false) => (0, exports.sanitizeTraceValue)({
+    action: actionName,
+    startedSession,
+    params: pickFields(ctx.params, tracer?.captureParams),
+    meta: (0, exports.buildTraceMetaSummary)(ctx),
+});
+exports.buildTraceStartData = buildTraceStartData;
+const buildTraceSuccessData = (ctx, actionName, result, durationMs, tracer) => (0, exports.sanitizeTraceValue)({
+    action: actionName,
+    durationMs,
+    result: tracer?.captureResult === undefined
+        ? undefined
+        : pickFields(result, tracer.captureResult),
+});
+exports.buildTraceSuccessData = buildTraceSuccessData;
+const buildTraceErrorData = (ctx, actionName, error, durationMs, tracer) => (0, exports.sanitizeTraceValue)({
+    action: actionName,
+    durationMs,
+    error: tracer?.captureError === undefined
+        ? sanitizeError(error, 0, new WeakSet())
+        : pickFields(error, tracer.captureError),
+    meta: (0, exports.buildTraceMetaSummary)(ctx),
+});
+exports.buildTraceErrorData = buildTraceErrorData;

package/dist/lib/traceContext.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteTraceContext = exports.touchTraceContext = exports.loadTraceContext = exports.saveTraceContext = void 0;
+const redis = __importStar(require("redis"));
+const trace_1 = require("./trace");
+const TRACE_CONTEXT_TTL_SEC = Math.max(1, Number(process.env.TRACE_CONTEXT_TTL_SEC || 2));
+const TRACE_CONTEXT_KEY = "trace:active";
+let traceRedisClient = null;
+let traceRedisConnectPromise = null;
+const createTraceRedisClient = () => redis.createClient({
+    socket: {
+        host: process.env.REDIS_HOST || "localhost",
+        port: +(process.env.REDIS_PORT || 6379),
+    },
+    database: +(process.env.REDIS_DB || 0),
+    name: `${process.env.APP_NAME || process.env.APPNAME || "app"}:trace`,
+});
+const getTraceRedisClient = async () => {
+    if (traceRedisClient?.isOpen) {
+        return traceRedisClient;
+    }
+    if (!traceRedisClient) {
+        traceRedisClient = createTraceRedisClient();
+    }
+    if (!traceRedisConnectPromise) {
+        traceRedisConnectPromise = traceRedisClient.connect().then(() => traceRedisClient);
+    }
+    try {
+        return await traceRedisConnectPromise;
+    }
+    finally {
+        traceRedisConnectPromise = null;
+    }
+};
+const saveTraceContext = async (trace) => {
+    if (!trace?.sessionId) {
+        return false;
+    }
+    const client = await getTraceRedisClient();
+    await client.setEx(TRACE_CONTEXT_KEY, TRACE_CONTEXT_TTL_SEC, JSON.stringify((0, trace_1.sanitizeTraceValue)(trace)));
+    return true;
+};
+exports.saveTraceContext = saveTraceContext;
+const loadTraceContext = async () => {
+    const client = await getTraceRedisClient();
+    const raw = await client.get(TRACE_CONTEXT_KEY);
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(Buffer.isBuffer(raw) ? raw.toString("utf-8") : String(raw));
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        return {
+            sessionId: String(parsed.sessionId || ""),
+            name: parsed.name || null,
+            tag: parsed.tag || null,
+            rootAction: parsed.rootAction || null,
+            startedBy: parsed.startedBy || null,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+exports.loadTraceContext = loadTraceContext;
+const touchTraceContext = async () => {
+    const client = await getTraceRedisClient();
+    const exists = await client.exists(TRACE_CONTEXT_KEY);
+    if (!exists) {
+        return false;
+    }
+    await client.expire(TRACE_CONTEXT_KEY, TRACE_CONTEXT_TTL_SEC);
+    return true;
+};
+exports.touchTraceContext = touchTraceContext;
+const deleteTraceContext = async () => {
+    const client = await getTraceRedisClient();
+    await client.del(TRACE_CONTEXT_KEY);
+    return true;
+};
+exports.deleteTraceContext = deleteTraceContext;

package/dist/moleculer.config.js

@@ -0,0 +1,274 @@
+"use strict";
+/* eslint-disable no-console */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line no-duplicate-imports
+const moleculer_1 = require("moleculer");
+const dotenv_1 = __importDefault(require("dotenv"));
+require("module-alias/register");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const logfeed_1 = require("./lib/mixins/logfeed");
+const session_errors_1 = require("./lib/mixins/session.errors");
+const tracer_1 = require("./lib/middlewares/tracer");
+dotenv_1.default.config({ path: process.env.ENV_FILE ?? ".env" });
+/**
+ * Moleculer ServiceBroker configuration file 1
+ *
+ * More info about options:
+ *     https://moleculer.services/docs/0.14/configuration.html
+ *
+ *
+ * Overwriting options in production:
+ * ================================
+ *    You can overwrite any option with environment variables.
+ *    For example to overwrite the "logLevel" value, use `LOGLEVEL=warn` env var.
+ *    To overwrite a nested parameter, e.g. retryPolicy.retries, use `RETRYPOLICY_RETRIES=10` env var.
+ *
+ *    To overwrite broker’s deeply nested default options, which are not presented in "moleculer.config.js",
+ *    use the `MOL_` prefix and double underscore `__` for nested properties in .env file.
+ *    For example, to set the cacher prefix to `MYCACHE`, you should declare an env var as `MOL_CACHER__OPTIONS__PREFIX=mycache`.
+ *  It will set this:
+ *  {
+ *    cacher: {
+ *      options: {
+ *        prefix: "mycache"
+ *      }
+ *    }
+ *  }
+ */
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+const logger = [
+    {
+        type: "Console",
+        options: {
+            colors: true,
+            moduleColors: true,
+            formatter: process.env.LOGFORMATTER ?? "short",
+            objectPrinter: null,
+            autoPadding: false,
+        },
+    },
+];
+const metricsEnabled = process.env.MOLECULER_METRICS === "true";
+const metricsPort = +(process.env.METRICS_PORT || 3030);
+const metricsPath = process.env.METRICS_PATH || "/metrics";
+const logFileEnabled = process.env.LOG_FILE_ENABLED === "true";
+const logFeedEnabled = process.env.ENABLE_LOGFEED != null
+    ? !["0", "false", "no", "off"].includes(process.env.ENABLE_LOGFEED.toLowerCase())
+    : process.env.LOGFEED_ENABLED !== "false";
+const logFileFolder = process.env.LOG_FILE_FOLDER || "./logs";
+const logFileName = process.env.LOG_FILE_NAME || "moleculer-{date}.log";
+const logFileRetentionDays = +(process.env.LOG_FILE_RETENTION_DAYS || 14);
+const cleanupLogFiles = async () => {
+    if (!logFileEnabled || !Number.isFinite(logFileRetentionDays) || logFileRetentionDays <= 0) {
+        return;
+    }
+    const logFolder = node_path_1.default.resolve(logFileFolder);
+    const now = Date.now();
+    const maxAgeMs = logFileRetentionDays * 24 * 60 * 60 * 1000;
+    const filenamePattern = new RegExp(`^${logFileName
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+        .replace(/\\\{date\\\}/g, "\\d{4}-\\d{2}-\\d{2}")
+        .replace(/\\\{nodeID\\\}/g, "[^/]+")
+        .replace(/\\\{namespace\\\}/g, "[^/]+")}$`);
+    try {
+        const entries = await promises_1.default.readdir(logFolder, { withFileTypes: true });
+        await Promise.all(entries
+            .filter(entry => entry.isFile() && filenamePattern.test(entry.name))
+            .map(async (entry) => {
+            const filePath = node_path_1.default.join(logFolder, entry.name);
+            const stats = await promises_1.default.stat(filePath);
+            if (now - stats.mtimeMs > maxAgeMs) {
+                await promises_1.default.unlink(filePath);
+            }
+        }));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            console.warn("LOG_FILE cleanup failed:", error);
+        }
+    }
+};
+if (logFileEnabled) {
+    void cleanupLogFiles();
+    logger.push({
+        type: "File",
+        options: {
+            level: process.env.LOG_FILE_LEVEL || process.env.LOG_LEVEL || "info",
+            folder: logFileFolder,
+            filename: logFileName,
+            formatter: process.env.LOG_FILE_FORMATTER || "json",
+            eol: "\n",
+            interval: +(process.env.LOG_FILE_INTERVAL_MS || 1000),
+        },
+    });
+}
+if (logFeedEnabled) {
+    logger.push(new logfeed_1.LogFeedLogger({
+        level: process.env.LOGFEED_LEVEL || process.env.LOG_LEVEL || "info",
+    }));
+}
+const brokerConfig = {
+    // Namespace of nodes to segment your nodes on the same network.
+    namespace: process.env.NAMESPACE,
+    // Unique node identifier. Must be unique in a namespace.
+    nodeID: process.env.NODE_ID,
+    // Custom metadata store. Store here what you want. Accessing: `this.broker.metadata`
+    metadata: {},
+    // Enable/disable logging or use custom logger. More info: https://moleculer.services/docs/0.14/logging.html
+    // Available logger types: "Console", "File", "Pino", "Winston", "Bunyan", "debug", "Log4js", "Datadog"
+    logger,
+    // Default log level for built-in console logger. It can be overwritten in logger options above.
+    // Available values: trace, debug, info, warn, error, fatal
+    logLevel: process.env.LOG_LEVEL || "info",
+    // Define transporter.
+    // More info: https://moleculer.services/docs/0.14/networking.html
+    // Note: During the development, you don't need to define it because all services will be loaded locally.
+    // In production you can set it via `TRANSPORTER=nats://localhost:4222` environment variable.
+    transporter: process.env.TRANSPORT ?? "TCP", // "NATS"
+    // Define a cacher.
+    // More info: https://moleculer.services/docs/0.14/caching.html
+    // cacher:false,
+    cacher: false,
+    // Define a serializer.
+    // Available values: "JSON", "Avro", "ProtoBuf", "MsgPack", "Notepack", "Thrift".
+    // More info: https://moleculer.services/docs/0.14/networking.html#Serialization
+    serializer: "JSON",
+    // Number of milliseconds to wait before reject a request with a RequestTimeout error. Disabled: 0
+    requestTimeout: 0, // 0 , 10 * 60 * 1000,
+    // Retry policy settings. More info: https://moleculer.services/docs/0.14/fault-tolerance.html#Retry
+    retryPolicy: {
+        // Enable feature
+        enabled: false,
+        // Count of retries
+        retries: 5,
+        // First delay in milliseconds.
+        delay: 100,
+        // Maximum delay in milliseconds.
+        maxDelay: 1000,
+        // Backoff factor for delay. 2 means exponential backoff.
+        factor: 2,
+        // A function to check failed requests.
+        check: (err) => err && err instanceof moleculer_1.Errors.MoleculerRetryableError && !!err.retryable,
+    },
+    // Limit of calling level. If it reaches the limit, broker will throw an MaxCallLevelError error. (Infinite loop protection)
+    maxCallLevel: 100,
+    // Number of seconds to send heartbeat packet to other nodes.
+    heartbeatInterval: 10,
+    // Number of seconds to wait before setting node to unavailable status.
+    heartbeatTimeout: 30,
+    // Cloning the params of context if enabled. High performance impact, use it with caution!
+    contextParamsCloning: false,
+    // Tracking requests and waiting for running requests before shuting down. More info: https://moleculer.services/docs/0.14/context.html#Context-tracking
+    tracking: {
+        // Enable feature
+        enabled: false,
+        // Number of milliseconds to wait before shuting down the process.
+        shutdownTimeout: 5000,
+    },
+    // Disable built-in request & emit balancer. (Transporter must support it, as well.). More info: https://moleculer.services/docs/0.14/networking.html#Disabled-balancer
+    disableBalancer: false,
+    // Settings of Service Registry. More info: https://moleculer.services/docs/0.14/registry.html
+    registry: {
+        // Define balancing strategy. More info: https://moleculer.services/docs/0.14/balancing.html
+        // Available values: "RoundRobin", "Random", "CpuUsage", "Latency", "Shard"
+        strategy: "RoundRobin",
+        // Enable local action call preferring. Always call the local action instance if available.
+        preferLocal: true,
+    },
+    // Settings of Circuit Breaker. More info: https://moleculer.services/docs/0.14/fault-tolerance.html#Circuit-Breaker
+    circuitBreaker: {
+        // Enable feature
+        enabled: false,
+        // Threshold value. 0.5 means that 50% should be failed for tripping.
+        threshold: 0.5,
+        // Minimum request count. Below it, CB does not trip.
+        minRequestCount: 20,
+        // Number of seconds for time window.
+        windowTime: 60,
+        // Number of milliseconds to switch from open to half-open state
+        halfOpenTime: 10 * 1000,
+        // A function to check failed requests.
+        check: (err) => err && err instanceof moleculer_1.Errors.MoleculerError && err.code >= 500,
+    },
+    // Settings of bulkhead feature. More info: https://moleculer.services/docs/0.14/fault-tolerance.html#Bulkhead
+    bulkhead: {
+        // Enable feature.
+        enabled: false,
+        // Maximum concurrent executions.
+        concurrency: 10,
+        // Maximum size of queue
+        maxQueueSize: 100,
+    },
+    // Enable action & event parameter validation. More info: https://moleculer.services/docs/0.14/validating.html
+    validator: true,
+    errorHandler: (err, { ctx, service }) => {
+        // ctx.service.logger.error("errorHandler", err);
+        if (err instanceof session_errors_1.BackendError) {
+            // ctx.meta.$statusCode = err.extensions.code;
+            return err;
+        }
+        else if (err instanceof Error) {
+            // ctx.meta.$statusCode = 502;
+            const rawName = ctx?.action?.rawName ||
+                ctx?.action?.name ||
+                service?.name ||
+                "UNKNOWN";
+            return new session_errors_1.BackendError(err.message, 502, `XC_${String(rawName).toUpperCase()}`);
+        }
+        return err;
+    },
+    // Enable/disable built-in metrics function. More info: https://moleculer.services/docs/0.14/metrics.html
+    metrics: {
+        enabled: metricsEnabled,
+        // Available built-in reporters: "Console", "CSV", "Event", "Prometheus", "Datadog", "StatsD"
+        reporter: {
+            type: "Prometheus",
+            options: {
+                // HTTP port
+                port: metricsPort,
+                // HTTP URL path
+                path: metricsPath,
+                // Default labels which are appended to all metrics labels
+                defaultLabels: (registry) => ({
+                    namespace: registry.broker.namespace,
+                    nodeID: registry.broker.nodeID,
+                }),
+            },
+        },
+    },
+    // Enable built-in tracing function. More info: https://moleculer.services/docs/0.14/tracing.html
+    tracing: {
+        enabled: process.env.MOLECULER_TRACE,
+        // Available built-in exporters: "Console", "Datadog", "Event", "EventLegacy", "Jaeger", "Zipkin"
+        exporter: {
+            type: "Console", // Console exporter is only for development!
+            options: {
+                // Custom logger
+                logger: null,
+                // Using colors
+                colors: true,
+                // Width of row
+                width: 100,
+                // Gauge width in the row
+                gaugeWidth: 40,
+            },
+        },
+    },
+    // Register custom middlewares
+    middlewares: [(0, tracer_1.createTracerMiddleware)()],
+    // Register custom REPL commands.
+    replCommands: null,
+    // Called after broker created.
+    // created(broker: ServiceBroker): void {},
+    // Called after broker started.
+    started() {
+        console.log("ALLOWED ORIGINS", (process.env.ORIGINS ?? "").split(","));
+    },
+    // Called after broker stopped.
+    // async stopped(broker: ServiceBroker): Promise<void> {},
+};
+exports.default = brokerConfig;

package/dist/services/features/telegram-mcp/approval.service.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_APPROVAL_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const orchestrator_1 = require("./src/processes/human-approval/model/orchestrator");
+exports.TELEGRAM_MCP_APPROVAL_SERVICE_NAME = "telegramMcp.approval";
+const TelegramMcpApprovalService = {
+    name: exports.TELEGRAM_MCP_APPROVAL_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    created() {
+        this.approvalOrchestrator = null;
+    },
+    methods: {
+        getApprovalOrchestrator() {
+            if (!this.approvalOrchestrator) {
+                throw new Error("telegram_mcp approval service is not initialized yet");
+            }
+            return this.approvalOrchestrator;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp approval service");
+        this.approvalOrchestrator = new orchestrator_1.HumanApprovalOrchestrator(runtime.config, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver);
+        this.logger.info("telegram_mcp approval service is ready");
+    },
+};
+exports.default = TelegramMcpApprovalService;

package/dist/services/features/telegram-mcp/browser.service.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_BROWSER_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const browserService_1 = require("./src/features/browser/model/browserService");
+exports.TELEGRAM_MCP_BROWSER_SERVICE_NAME = "telegramMcp.browser";
+const TelegramMcpBrowserService = {
+    name: exports.TELEGRAM_MCP_BROWSER_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    created() {
+        this.browserService = null;
+    },
+    methods: {
+        getBrowserService() {
+            if (!this.browserService) {
+                throw new Error("telegram_mcp browser service is not initialized yet");
+            }
+            return this.browserService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp browser service");
+        this.browserService = new browserService_1.BrowserService(runtime.config, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.objectStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver);
+        this.logger.info("telegram_mcp browser service is ready");
+    },
+    async stopped() {
+        if (!this.browserService) {
+            return;
+        }
+        const browserService = this.browserService;
+        this.browserService = null;
+        this.logger.info("Stopping telegram_mcp browser service");
+        await browserService.shutdown();
+    },
+};
+exports.default = TelegramMcpBrowserService;

package/dist/services/features/telegram-mcp/collaboration.service.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const collaborationService_1 = require("./src/features/collaboration/model/collaborationService");
+const sendPartnerFileService_1 = require("./src/features/collaboration/model/sendPartnerFileService");
+const gatewayCollaborationBackend_1 = require("./src/features/distributed-client/model/gatewayCollaborationBackend");
+const localCollaborationBackend_1 = require("./src/features/collaboration/model/localCollaborationBackend");
+exports.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME = "telegramMcp.collaboration";
+const TelegramMcpCollaborationService = {
+    name: exports.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    created() {
+        this.collaborationService = null;
+        this.sendPartnerFileService = null;
+    },
+    methods: {
+        getCollaborationService() {
+            if (!this.collaborationService) {
+                throw new Error("telegram_mcp collaboration service is not initialized yet");
+            }
+            return this.collaborationService;
+        },
+        getSendPartnerFileService() {
+            if (!this.sendPartnerFileService) {
+                throw new Error("telegram_mcp send partner file service is not initialized yet");
+            }
+            return this.sendPartnerFileService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = runtimeService.getRuntime();
+        this.logger.info("Starting telegram_mcp collaboration service");
+        const localBackend = new localCollaborationBackend_1.LocalCollaborationBackend(runtime.config, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.objectStore, runtime.telegramTransport, runtime.logger);
+        runtime.gatewayHttpService.setPartnerNoteRelayHandler(async (input) => {
+            const resolved = runtime.projectIdentityResolver.resolveSessionDefaults(input);
+            return localBackend.sendPartnerNote(input, resolved);
+        });
+        const backend = runtime.config.distributed.gatewayPublicUrl
+            ? new gatewayCollaborationBackend_1.GatewayCollaborationBackend(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken)
+            : localBackend;
+        this.collaborationService = new collaborationService_1.CollaborationService(backend, runtime.logger, runtime.projectIdentityResolver);
+        this.sendPartnerFileService = new sendPartnerFileService_1.SendPartnerFileService(runtime.config, runtime.sessionStore, runtime.logger, runtime.projectIdentityResolver, this.collaborationService);
+        runtime.telegramTransport.setCollaborationService(this.collaborationService);
+        this.logger.info("telegram_mcp collaboration service is ready");
+    },
+};
+exports.default = TelegramMcpCollaborationService;