@deadragdoll/tellymcp 0.0.1

package/dist/lib/logfeed/store.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logFeedStore = exports.stringifyLogArgs = void 0;
+const node_events_1 = require("node:events");
+const node_util_1 = require("node:util");
+const DEFAULT_BUFFER_SIZE = +(process.env.LOGFEED_BUFFER_SIZE || 500);
+const ANSI_PATTERN = /\u001b\[.*?m/g;
+class LogFeedStore extends node_events_1.EventEmitter {
+    buffer = [];
+    maxSize;
+    seq = 0;
+    constructor(maxSize = DEFAULT_BUFFER_SIZE) {
+        super();
+        this.maxSize = Number.isFinite(maxSize) && maxSize > 0 ? maxSize : DEFAULT_BUFFER_SIZE;
+    }
+    push(entry) {
+        const nextSeq = ++this.seq;
+        const item = {
+            id: `${entry.ts}-${nextSeq}`,
+            seq: nextSeq,
+            ...entry,
+        };
+        this.buffer.push(item);
+        if (this.buffer.length > this.maxSize) {
+            this.buffer.splice(0, this.buffer.length - this.maxSize);
+        }
+        this.emit("entry", item);
+        return item;
+    }
+    list(limit = 200) {
+        const normalizedLimit = Number.isFinite(limit) && limit > 0 ? Math.min(limit, this.maxSize) : 200;
+        return this.buffer.slice(-normalizedLimit);
+    }
+}
+const stringifyLogArgs = (args) => args
+    .map(arg => {
+    if (arg == null) {
+        return "<null>";
+    }
+    if (typeof arg === "string") {
+        return arg.replace(ANSI_PATTERN, "");
+    }
+    return `\r\n${(0, node_util_1.inspect)(arg, {
+        showHidden: false,
+        depth: 4,
+        compact: false,
+        breakLength: Number.POSITIVE_INFINITY,
+    })}`;
+})
+    .join(" ");
+exports.stringifyLogArgs = stringifyLogArgs;
+exports.logFeedStore = new LogFeedStore();

package/dist/lib/middlewares/tracer.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTracerMiddleware = void 0;
+const traceContext_1 = require("../traceContext");
+const trace_1 = require("../trace");
+const shouldSkipTrace = (actionName, ctx) => Boolean(ctx?.meta?.$traceInternal ||
+    !actionName ||
+    actionName === "context" ||
+    actionName === "graphql.publish" ||
+    (actionName === "rest" && ctx?.params?.req?.url === "/api/graphql"));
+const createTracerMiddleware = () => {
+    let broker = null;
+    const resolveTracer = (action) => {
+        const rawName = String(action?.rawName || action?.name || "");
+        if (action?.tracer)
+            return { tracer: action.tracer, source: "action.tracer" };
+        if (action?.schema?.tracer)
+            return { tracer: action.schema.tracer, source: "action.schema.tracer" };
+        if (action?.service?.schema?.actions?.[rawName]?.tracer) {
+            return {
+                tracer: action.service.schema.actions[rawName].tracer,
+                source: "service.schema.actions[rawName].tracer",
+            };
+        }
+        return {};
+    };
+    const callTrace = async (ctx, actionName, params, silent = false) => {
+        if (!broker) {
+            return null;
+        }
+        try {
+            return await broker.call(actionName, params, {
+                requestID: ctx.requestID,
+                meta: {
+                    user: ctx.meta?.user,
+                    $traceInternal: true,
+                },
+            });
+        }
+        catch (error) {
+            if (!silent) {
+                broker.logger.warn("Tracer call failed", {
+                    actionName,
+                    sourceAction: ctx.action?.name || null,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            return null;
+        }
+    };
+    return {
+        created(localBroker) {
+            broker = localBroker;
+        },
+        localAction(next, action) {
+            const actionName = String(action?.rawName || action?.name || "");
+            const serviceName = String(action?.service?.name || "");
+            return async function traceAction(ctx) {
+                if (serviceName === "trace" || shouldSkipTrace(actionName, ctx)) {
+                    return next(ctx);
+                }
+                const resolvedTracer = resolveTracer(ctx?.action || action);
+                const tracer = resolvedTracer.tracer;
+                let traceMeta = null;
+                const startSessionName = tracer?.startSession;
+                const tracerTag = tracer?.tag;
+                const shouldStartRootSession = Boolean(startSessionName);
+                if (!shouldStartRootSession) {
+                    traceMeta = await (0, traceContext_1.loadTraceContext)();
+                }
+                let startedSession = false;
+                if (shouldStartRootSession) {
+                    await (0, traceContext_1.deleteTraceContext)().catch(() => null);
+                    const session = (await callTrace(ctx, "trace.startSession", {
+                        name: startSessionName,
+                        tag: tracerTag || null,
+                        source: actionName,
+                        meta: (0, trace_1.sanitizeTraceValue)({
+                            action: actionName,
+                            params: ctx.params,
+                        }),
+                    }, false));
+                    if (session?.session_id) {
+                        traceMeta = {
+                            sessionId: String(session.session_id),
+                            name: startSessionName ?? null,
+                            tag: tracerTag || null,
+                            rootAction: actionName,
+                            startedBy: actionName,
+                        };
+                        await (0, traceContext_1.saveTraceContext)(traceMeta);
+                        startedSession = true;
+                    }
+                }
+                const sessionId = String(traceMeta?.sessionId || "").trim();
+                const hasSession = Boolean(sessionId);
+                const startedAt = Date.now();
+                if (hasSession) {
+                    await (0, traceContext_1.touchTraceContext)().catch(() => null);
+                    await callTrace(ctx, "trace.log", {
+                        session_id: sessionId,
+                        level: (0, trace_1.normalizeTraceLevel)(tracer?.level || "debug"),
+                        action: actionName,
+                        state: "started",
+                        marker: tracer?.marker || null,
+                        step: tracer?.step || "action",
+                        message: actionName,
+                        data: (0, trace_1.buildTraceStartData)(ctx, actionName, tracer, startedSession),
+                    }, false);
+                }
+                try {
+                    const result = await next(ctx);
+                    const durationMs = Date.now() - startedAt;
+                    if (hasSession) {
+                        await callTrace(ctx, "trace.log", {
+                            session_id: sessionId,
+                            level: (0, trace_1.normalizeTraceLevel)(tracer?.level || "debug"),
+                            action: actionName,
+                            state: "succeeded",
+                            marker: tracer?.marker || null,
+                            step: tracer?.step || "action",
+                            message: actionName,
+                            data: (0, trace_1.buildTraceSuccessData)(ctx, actionName, result, durationMs, tracer),
+                        }, false);
+                        if (tracer?.stopSession) {
+                            await callTrace(ctx, "trace.endSession", {
+                                session_id: sessionId,
+                                status: "succeeded",
+                                summary: `${actionName} completed`,
+                                meta: (0, trace_1.sanitizeTraceValue)({
+                                    action: actionName,
+                                    durationMs,
+                                }),
+                            }, false);
+                            await (0, traceContext_1.deleteTraceContext)();
+                        }
+                    }
+                    return result;
+                }
+                catch (error) {
+                    const durationMs = Date.now() - startedAt;
+                    if (hasSession) {
+                        await callTrace(ctx, "trace.log", {
+                            session_id: sessionId,
+                            level: "error",
+                            action: actionName,
+                            state: "failed",
+                            marker: tracer?.marker || null,
+                            step: tracer?.step || "action",
+                            message: actionName,
+                            data: (0, trace_1.buildTraceErrorData)(ctx, actionName, error, durationMs, tracer),
+                        }, false);
+                        if (tracer?.stopSession || startedSession) {
+                            await callTrace(ctx, "trace.endSession", {
+                                session_id: sessionId,
+                                status: "failed",
+                                summary: error instanceof Error ? error.message : `Action failed: ${actionName}`,
+                                meta: (0, trace_1.sanitizeTraceValue)({
+                                    action: actionName,
+                                    durationMs,
+                                }),
+                            }, false);
+                            await (0, traceContext_1.deleteTraceContext)();
+                        }
+                    }
+                    throw error;
+                }
+            };
+        },
+    };
+};
+exports.createTracerMiddleware = createTracerMiddleware;

package/dist/lib/mixins/db.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBMixin = void 0;
+/* eslint-disable @typescript-eslint/no-namespace */
+const knex_1 = __importDefault(require("knex"));
+const paginate = (q, pagination) => {
+    if (!pagination)
+        return q.then(items => ({ items }));
+    return q
+        .clone()
+        .clearSelect()
+        .clearOrder()
+        .count("*")
+        .first()
+        .then(({ count: total }) => {
+        if (pagination?.limit)
+            q.limit(pagination.limit);
+        if (pagination?.offset)
+            q.offset(pagination.offset);
+        return q.then(items => ({
+            pagination: {
+                total: +total,
+                ...pagination,
+            },
+            items,
+        }));
+    });
+};
+const filter = (q, flt) => {
+    const create = (f, p) => {
+        if (f.operator.toLocaleUpperCase() === "IN") {
+            q.whereIn(f.column, f.values);
+        }
+        else if (p) {
+            console.log("P", p);
+            p.andWhere(f.column, f.operator, f.value);
+        }
+        else
+            q.orWhere(f.column, f.operator, f.value);
+        if (f.and) {
+            f.and.forEach((af) => create(af, q));
+        }
+        return q;
+    };
+    if (!flt)
+        return q;
+    flt.forEach(f => create(f));
+    return q;
+};
+const orderBy = (q, sort) => {
+    const orders = sort
+        .map(({ column, order, nulls }) => {
+        return `"${column}" ${order} ${nulls || ""}`;
+    })
+        .join(",");
+    q.orderByRaw(orders);
+};
+knex_1.default.QueryBuilder.extend("dataView", function (dataView) {
+    if (dataView?.filter)
+        filter(this, dataView.filter);
+    if (dataView?.sort)
+        orderBy(this, dataView.sort);
+    return paginate(this, dataView?.pagination);
+});
+const DBConfig = {
+    host: process.env.DB_HOST || "localhost",
+    port: Number(process.env.DB_PORT || 5432),
+    user: process.env.DB_USER || "",
+    password: process.env.DB_PASSWORD || "",
+    database: process.env.DB_NAME || "",
+};
+const DB_ENABLED = Boolean(process.env.DB_HOST?.trim());
+const createNoopPromise = (value) => Promise.resolve(value);
+const createNoopQueryBuilder = (state = {}) => {
+    const target = function noopQueryBuilder() {
+        return createNoopQueryBuilder(state);
+    };
+    const proxy = new Proxy(target, {
+        apply() {
+            return createNoopQueryBuilder(state);
+        },
+        get(_obj, prop) {
+            if (prop === "then") {
+                return createNoopPromise([]).then.bind(createNoopPromise([]));
+            }
+            if (prop === "catch") {
+                return createNoopPromise([]).catch.bind(createNoopPromise([]));
+            }
+            if (prop === "finally") {
+                return createNoopPromise([]).finally.bind(createNoopPromise([]));
+            }
+            if (prop === "first") {
+                return () => createNoopPromise(state.countMode ? { count: 0 } : null);
+            }
+            if (prop === "pluck") {
+                return () => createNoopPromise([]);
+            }
+            if (prop === "insert" ||
+                prop === "update" ||
+                prop === "delete" ||
+                prop === "del" ||
+                prop === "increment" ||
+                prop === "decrement") {
+                return () => createNoopQueryBuilder(state);
+            }
+            if (prop === "count") {
+                return () => createNoopQueryBuilder({ ...state, countMode: true });
+            }
+            if (prop === "clone" ||
+                prop === "clearSelect" ||
+                prop === "clearOrder" ||
+                prop === "select" ||
+                prop === "from" ||
+                prop === "table" ||
+                prop === "withSchema" ||
+                prop === "where" ||
+                prop === "andWhere" ||
+                prop === "orWhere" ||
+                prop === "whereIn" ||
+                prop === "whereNotIn" ||
+                prop === "whereNull" ||
+                prop === "whereNotNull" ||
+                prop === "leftJoin" ||
+                prop === "rightJoin" ||
+                prop === "join" ||
+                prop === "groupBy" ||
+                prop === "having" ||
+                prop === "orderBy" ||
+                prop === "orderByRaw" ||
+                prop === "limit" ||
+                prop === "offset" ||
+                prop === "transacting" ||
+                prop === "onConflict" ||
+                prop === "merge" ||
+                prop === "returning" ||
+                prop === "modify" ||
+                prop === "column" ||
+                prop === "union" ||
+                prop === "unionAll" ||
+                prop === "forUpdate" ||
+                prop === "forShare") {
+                return () => createNoopQueryBuilder(state);
+            }
+            return createNoopQueryBuilder(state);
+        },
+    });
+    return proxy;
+};
+const createNoopSchema = () => {
+    const schemaTarget = {};
+    return new Proxy(schemaTarget, {
+        get(_obj, prop) {
+            if (prop === "hasTable") {
+                return () => Promise.resolve(false);
+            }
+            if (prop === "withSchema" ||
+                prop === "createTable" ||
+                prop === "alterTable" ||
+                prop === "dropTable" ||
+                prop === "dropTableIfExists" ||
+                prop === "createSchema" ||
+                prop === "createSchemaIfNotExists") {
+                return () => createNoopSchema();
+            }
+            if (prop === "then") {
+                return Promise.resolve(undefined).then.bind(Promise.resolve(undefined));
+            }
+            if (prop === "catch") {
+                return Promise.resolve(undefined).catch.bind(Promise.resolve(undefined));
+            }
+            if (prop === "finally") {
+                return Promise.resolve(undefined).finally.bind(Promise.resolve(undefined));
+            }
+            return () => createNoopSchema();
+        },
+    });
+};
+const createNoopKnex = () => {
+    const queryBuilder = createNoopQueryBuilder();
+    const schema = createNoopSchema();
+    const rawResult = {
+        rows: [],
+        rowCount: 0,
+        command: "NOOP",
+    };
+    const target = function noopKnex() {
+        return createNoopQueryBuilder();
+    };
+    const proxy = new Proxy(target, {
+        apply() {
+            return createNoopQueryBuilder();
+        },
+        get(_obj, prop) {
+            if (prop === "schema") {
+                return schema;
+            }
+            if (prop === "fn") {
+                return {
+                    now: () => new Date(),
+                };
+            }
+            if (prop === "raw") {
+                return async () => rawResult;
+            }
+            if (prop === "destroy") {
+                return async () => undefined;
+            }
+            if (prop === "transaction") {
+                return async (handler) => {
+                    if (typeof handler === "function") {
+                        return handler(proxy);
+                    }
+                    return proxy;
+                };
+            }
+            if (prop === "withSchema" || prop === "table") {
+                return () => createNoopQueryBuilder();
+            }
+            if (prop === "queryBuilder") {
+                return () => createNoopQueryBuilder();
+            }
+            return queryBuilder[prop] ?? createNoopQueryBuilder();
+        },
+    });
+    return proxy;
+};
+const DBMixin = {
+    name: "DBMixin",
+    created() {
+        if (!DB_ENABLED) {
+            this.logger?.warn?.("DBMixin: DB_HOST is not set, using no-op database stub");
+            this.db = createNoopKnex();
+            return;
+        }
+        this.db = (0, knex_1.default)({
+            debug: Boolean(process.env.PG_DEBUG),
+            client: "pg",
+            connection: {
+                ...DBConfig,
+            },
+            pool: {
+                min: 1,
+                max: 64,
+                // acquireTimeoutMillis: 1000 * 60 * 60,
+                propagateCreateError: false,
+                afterCreate: (con, callback) => {
+                    con.on("error", (err) => {
+                        console.error("[KNEX-ERROR]", err);
+                    });
+                    con.on("notice", function (msg) {
+                        console.warn(`[DB] ${msg.name}/${msg.severity}:`, msg.message);
+                        // console.warn(`[PG]`, msg.message);
+                    });
+                    con.query('SET time zone  "Europe/Moscow"', (err) => {
+                        if (err)
+                            console.error("QUERY", err);
+                        callback(err, con);
+                    });
+                },
+            },
+        });
+    },
+};
+exports.DBMixin = DBMixin;

package/dist/lib/mixins/logfeed.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogFeedLogger = void 0;
+/* eslint-disable no-control-regex */
+const moleculer_1 = require("moleculer");
+const store_1 = require("../logfeed/store");
+const LEVELS = ["fatal", "error", "warn", "info", "debug", "trace"];
+class LogFeedLogger extends moleculer_1.Loggers.Base {
+    getLogHandler(bindings) {
+        const level = bindings ? this.getLogLevel?.(bindings.mod) : null;
+        if (!level)
+            return null;
+        const levelIdx = LEVELS.indexOf(level);
+        return (type, args) => {
+            const typeIdx = LEVELS.indexOf(type);
+            if (typeIdx > levelIdx || !args?.length)
+                return;
+            const message = (0, store_1.stringifyLogArgs)(args);
+            if (message.includes("graphql.publish")) {
+                return;
+            }
+            store_1.logFeedStore.push({
+                ts: Date.now(),
+                level: type,
+                module: bindings?.mod?.toUpperCase?.() || null,
+                nodeID: bindings?.nodeID || null,
+                namespace: bindings?.ns || null,
+                svc: bindings?.svc || null,
+                message,
+            });
+        };
+    }
+}
+exports.LogFeedLogger = LogFeedLogger;

package/dist/lib/mixins/session.errors.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaygroundDisabledError = exports.SessionIdleTimeoutExceededError = exports.TokenInvalidError = exports.TokenNotFoundError = exports.SessionTokenSignatureInvalidError = exports.SessionTokenInvalidFormatError = exports.SessionTokenMismatchError = exports.SessionTokenNotFoundError = exports.SessionTokenRevokedError = exports.SessionTokenNotActiveError = exports.SessionTokenExpiredError = exports.SessionTokenInvalidError = exports.SessionValidationError = exports.SessionRefreshError = exports.SessionMaxLifetimeExceededError = exports.SessionStealedError = exports.SessionInvalidError = exports.SessionExpiredError = exports.SessionNotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BackendError = void 0;
+const graphql_1 = require("graphql");
+class BackendError extends graphql_1.GraphQLError {
+    constructor(message, code, type, data) {
+        super(message, {
+            extensions: {
+                code: code,
+                type: type || code,
+                data,
+            },
+        });
+    }
+}
+exports.BackendError = BackendError;
+class UnauthorizedError extends BackendError {
+    constructor(message = "Unauthorized", data) {
+        super(message, 401, "UNAUTHORIZED", data);
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+class ForbiddenError extends BackendError {
+    constructor(message = "Forbidden", data) {
+        super(message, 403, "FORBIDDEN", data);
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class SessionNotFoundError extends BackendError {
+    constructor(message = "Session not found", data) {
+        super(message, 401, "SESSION_NOT_FOUND", data);
+    }
+}
+exports.SessionNotFoundError = SessionNotFoundError;
+class SessionExpiredError extends BackendError {
+    constructor(message = "Session expired", data) {
+        super(message, 401, "SESSION_EXPIRED", data);
+    }
+}
+exports.SessionExpiredError = SessionExpiredError;
+class SessionInvalidError extends BackendError {
+    constructor(message = "Session invalid", data) {
+        super(message, 401, "SESSION_INVALID", data);
+    }
+}
+exports.SessionInvalidError = SessionInvalidError;
+class SessionStealedError extends BackendError {
+    constructor(message = "Session stealed", data) {
+        super(message, 401, "SESSION_STEALED", data);
+    }
+}
+exports.SessionStealedError = SessionStealedError;
+class SessionMaxLifetimeExceededError extends BackendError {
+    constructor(message = "Session max lifetime exceeded", data) {
+        super(message, 401, "SESSION_MAX_LIFETIME_EXCEEDED", data);
+    }
+}
+exports.SessionMaxLifetimeExceededError = SessionMaxLifetimeExceededError;
+class SessionRefreshError extends BackendError {
+    constructor(message = "Session refresh failed", data) {
+        super(message, 401, "SESSION_REFRESH_FAILED", data);
+    }
+}
+exports.SessionRefreshError = SessionRefreshError;
+class SessionValidationError extends BackendError {
+    constructor(message = "Session validation failed", data) {
+        super(message, 401, "SESSION_VALIDATION_FAILED", data);
+    }
+}
+exports.SessionValidationError = SessionValidationError;
+class SessionTokenInvalidError extends BackendError {
+    constructor(message = "Session token invalid", data) {
+        super(message, 401, "SESSION_TOKEN_INVALID", data);
+    }
+}
+exports.SessionTokenInvalidError = SessionTokenInvalidError;
+class SessionTokenExpiredError extends BackendError {
+    constructor(message = "Session token expired", data) {
+        super(message, 401, "SESSION_TOKEN_EXPIRED", data);
+    }
+}
+exports.SessionTokenExpiredError = SessionTokenExpiredError;
+class SessionTokenNotActiveError extends BackendError {
+    constructor(message = "Session token not active", data) {
+        super(message, 401, "SESSION_TOKEN_NOT_ACTIVE", data);
+    }
+}
+exports.SessionTokenNotActiveError = SessionTokenNotActiveError;
+class SessionTokenRevokedError extends BackendError {
+    constructor(message = "Session token revoked", data) {
+        super(message, 401, "SESSION_TOKEN_REVOKED", data);
+    }
+}
+exports.SessionTokenRevokedError = SessionTokenRevokedError;
+class SessionTokenNotFoundError extends BackendError {
+    constructor(message = "Session token not found", data) {
+        super(message, 401, "SESSION_TOKEN_NOT_FOUND", data);
+    }
+}
+exports.SessionTokenNotFoundError = SessionTokenNotFoundError;
+class SessionTokenMismatchError extends BackendError {
+    constructor(message = "Session token mismatch", data) {
+        super(message, 401, "SESSION_TOKEN_MISMATCH", data);
+    }
+}
+exports.SessionTokenMismatchError = SessionTokenMismatchError;
+class SessionTokenInvalidFormatError extends BackendError {
+    constructor(message = "Session token invalid format", data) {
+        super(message, 401, "SESSION_TOKEN_INVALID_FORMAT", data);
+    }
+}
+exports.SessionTokenInvalidFormatError = SessionTokenInvalidFormatError;
+class SessionTokenSignatureInvalidError extends BackendError {
+    constructor(message = "Session token signature invalid", data) {
+        super(message, 401, "SESSION_TOKEN_SIGNATURE_INVALID", data);
+    }
+}
+exports.SessionTokenSignatureInvalidError = SessionTokenSignatureInvalidError;
+class TokenNotFoundError extends BackendError {
+    constructor(message = "Token not found", data) {
+        super(message, 401, "TOKEN_NOT_FOUND", data);
+    }
+}
+exports.TokenNotFoundError = TokenNotFoundError;
+class TokenInvalidError extends BackendError {
+    constructor(message = "Token invalid", data) {
+        super(message, 401, "TOKEN_INVALID", data);
+    }
+}
+exports.TokenInvalidError = TokenInvalidError;
+class SessionIdleTimeoutExceededError extends BackendError {
+    constructor(message = "Session idle timeout exceeded", data) {
+        super(message, 401, "SESSION_IDLE_TIMEOUT_EXCEEDED", data);
+    }
+}
+exports.SessionIdleTimeoutExceededError = SessionIdleTimeoutExceededError;
+class PlaygroundDisabledError extends BackendError {
+    constructor(message = "Playground disabled", data) {
+        super(message, 403, "PLAYGROUND_DISABLED", data);
+    }
+}
+exports.PlaygroundDisabledError = PlaygroundDisabledError;

package/dist/lib/moleculer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });