@hotmeshio/long-tail 0.1.5 → 0.1.7

package/build/api/mcp.js

@@ -0,0 +1,212 @@
+"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.listMcpServers = listMcpServers;
+exports.createMcpServer = createMcpServer;
+exports.testConnection = testConnection;
+exports.getMcpServer = getMcpServer;
+exports.updateMcpServer = updateMcpServer;
+exports.deleteMcpServer = deleteMcpServer;
+exports.connectMcpServer = connectMcpServer;
+exports.disconnectMcpServer = disconnectMcpServer;
+exports.getCredentialStatus = getCredentialStatus;
+exports.listMcpServerTools = listMcpServerTools;
+exports.callMcpTool = callMcpTool;
+const mcpDbService = __importStar(require("../services/mcp/db"));
+const mcp_1 = require("../services/mcp");
+async function listMcpServers(input) {
+    try {
+        const result = await mcpDbService.listMcpServers(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function createMcpServer(input) {
+    try {
+        if (!input.name || !input.transport_type || !input.transport_config) {
+            return { status: 400, error: 'name, transport_type, and transport_config are required' };
+        }
+        const server = await mcpDbService.createMcpServer(input);
+        return { status: 201, data: server };
+    }
+    catch (err) {
+        if (err.message?.includes('duplicate key') || err.code === '23505') {
+            return { status: 409, error: 'MCP server with that name already exists' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+async function testConnection(input) {
+    try {
+        if (!input.transport_type || !input.transport_config) {
+            return { status: 400, error: 'transport_type and transport_config are required' };
+        }
+        const { testConnection: testConn } = await Promise.resolve().then(() => __importStar(require('../services/mcp/client/connection')));
+        const result = await testConn(input.transport_type, input.transport_config);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 200, data: { success: false, error: err.message, tools: [] } };
+    }
+}
+async function getMcpServer(input) {
+    try {
+        const server = await mcpDbService.getMcpServer(input.id);
+        if (!server) {
+            return { status: 404, error: 'MCP server not found' };
+        }
+        return { status: 200, data: server };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function updateMcpServer(input) {
+    try {
+        const { id, ...fields } = input;
+        const server = await mcpDbService.updateMcpServer(id, fields);
+        if (!server) {
+            return { status: 404, error: 'MCP server not found' };
+        }
+        return { status: 200, data: server };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function deleteMcpServer(input) {
+    try {
+        const deleted = await mcpDbService.deleteMcpServer(input.id);
+        if (!deleted) {
+            return { status: 404, error: 'MCP server not found' };
+        }
+        return { status: 200, data: { deleted: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function connectMcpServer(input) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        await adapter.connectClient(input.id);
+        return { status: 200, data: { connected: true, serverId: input.id } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function disconnectMcpServer(input) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        await adapter.disconnectClient(input.id);
+        return { status: 200, data: { disconnected: true, serverId: input.id } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getCredentialStatus(input, auth) {
+    try {
+        const server = await mcpDbService.getMcpServer(input.id);
+        if (!server) {
+            return { status: 404, error: 'MCP server not found' };
+        }
+        const required = server.credential_providers ?? [];
+        const registered = [];
+        const missing = [];
+        if (auth?.userId && required.length > 0) {
+            const { resolveCredential } = await Promise.resolve().then(() => __importStar(require('../services/iam/credentials')));
+            for (const provider of required) {
+                const cred = await resolveCredential({ id: auth.userId, type: 'user', roles: [] }, provider);
+                if (cred)
+                    registered.push(provider);
+                else
+                    missing.push(provider);
+            }
+        }
+        else {
+            missing.push(...required);
+        }
+        return { status: 200, data: { required, registered, missing } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function listMcpServerTools(input) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        const tools = await adapter.listTools(input.id);
+        return { status: 200, data: { tools } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function callMcpTool(input, auth) {
+    try {
+        const adapter = mcp_1.mcpRegistry.current;
+        if (!adapter) {
+            return { status: 400, error: 'MCP adapter not registered' };
+        }
+        const authContext = (input.execute_as || auth?.userId)
+            ? { userId: input.execute_as || auth?.userId }
+            : undefined;
+        const result = await adapter.callTool(input.id, input.toolName, input.arguments || {}, authContext);
+        return { status: 200, data: { result } };
+    }
+    catch (err) {
+        if (err.name === 'MissingCredentialError') {
+            return {
+                status: 422,
+                error: 'missing_credential',
+                ...{ provider: err.provider, message: err.message },
+            };
+        }
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/namespaces.d.ts

@@ -0,0 +1,7 @@
+import type { LTApiResult } from '../types/sdk';
+export declare function listNamespaces(): Promise<LTApiResult>;
+export declare function registerNamespace(input: {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}): Promise<LTApiResult>;

package/build/{routes/escalations/helpers.js → api/namespaces.js}

@@ -33,16 +33,28 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVisibleRoles = getVisibleRoles;
-const userService = __importStar(require("../../services/user"));
-/**
- * Return the role names visible to a user, or undefined if superadmin (no filter).
- * Returns an empty array when the user holds no roles at all.
- */
-async function getVisibleRoles(userId) {
-    const isSuperAdminUser = await userService.isSuperAdmin(userId);
-    if (isSuperAdminUser)
-        return undefined;
-    const userRoles = await userService.getUserRoles(userId);
-    return userRoles.map((r) => r.role);
+exports.listNamespaces = listNamespaces;
+exports.registerNamespace = registerNamespace;
+const namespaceService = __importStar(require("../services/namespace"));
+async function listNamespaces() {
+    try {
+        const namespaces = await namespaceService.listNamespaces();
+        return { status: 200, data: { namespaces } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function registerNamespace(input) {
+    try {
+        const { name, description, metadata } = input;
+        if (!name || typeof name !== 'string') {
+            return { status: 400, error: 'name is required' };
+        }
+        const namespace = await namespaceService.registerNamespace(name, description, metadata);
+        return { status: 200, data: namespace };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
 }

package/build/api/roles.d.ts

@@ -0,0 +1,25 @@
+import type { LTApiResult } from '../types/sdk';
+export declare function listRoles(): Promise<LTApiResult>;
+export declare function listRolesWithDetails(): Promise<LTApiResult>;
+export declare function createRole(input: {
+    role: string;
+}): Promise<LTApiResult>;
+export declare function getEscalationChains(): Promise<LTApiResult>;
+export declare function addEscalationChain(input: {
+    source_role: string;
+    target_role: string;
+}): Promise<LTApiResult>;
+export declare function removeEscalationChain(input: {
+    source_role: string;
+    target_role: string;
+}): Promise<LTApiResult>;
+export declare function getEscalationTargets(input: {
+    role: string;
+}): Promise<LTApiResult>;
+export declare function replaceEscalationTargets(input: {
+    role: string;
+    targets: string[];
+}): Promise<LTApiResult>;
+export declare function deleteRole(input: {
+    role: string;
+}): Promise<LTApiResult>;

package/build/api/roles.js

@@ -0,0 +1,159 @@
+"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.listRoles = listRoles;
+exports.listRolesWithDetails = listRolesWithDetails;
+exports.createRole = createRole;
+exports.getEscalationChains = getEscalationChains;
+exports.addEscalationChain = addEscalationChain;
+exports.removeEscalationChain = removeEscalationChain;
+exports.getEscalationTargets = getEscalationTargets;
+exports.replaceEscalationTargets = replaceEscalationTargets;
+exports.deleteRole = deleteRole;
+const roleService = __importStar(require("../services/role"));
+async function listRoles() {
+    try {
+        const roles = await roleService.listDistinctRoles();
+        return { status: 200, data: { roles } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function listRolesWithDetails() {
+    try {
+        const roles = await roleService.listRolesWithDetails();
+        return { status: 200, data: { roles } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function createRole(input) {
+    try {
+        if (!input.role || typeof input.role !== 'string' || !input.role.trim()) {
+            return { status: 400, error: 'role is required' };
+        }
+        const trimmed = input.role.trim().toLowerCase();
+        if (!/^[a-z][a-z0-9_-]*$/.test(trimmed)) {
+            return {
+                status: 400,
+                error: 'Role must start with a letter and contain only lowercase letters, numbers, hyphens, and underscores',
+            };
+        }
+        await roleService.createRole(trimmed);
+        return { status: 201, data: { role: trimmed } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getEscalationChains() {
+    try {
+        const chains = await roleService.getAllEscalationChains();
+        return { status: 200, data: { chains } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function addEscalationChain(input) {
+    try {
+        if (!input.source_role || !input.target_role) {
+            return { status: 400, error: 'source_role and target_role are required' };
+        }
+        await roleService.addEscalationChain(input.source_role, input.target_role);
+        return {
+            status: 201,
+            data: { source_role: input.source_role, target_role: input.target_role },
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function removeEscalationChain(input) {
+    try {
+        if (!input.source_role || !input.target_role) {
+            return { status: 400, error: 'source_role and target_role are required' };
+        }
+        const removed = await roleService.removeEscalationChain(input.source_role, input.target_role);
+        if (!removed) {
+            return { status: 404, error: 'Chain entry not found' };
+        }
+        return { status: 200, data: { removed: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getEscalationTargets(input) {
+    try {
+        const targets = await roleService.getEscalationTargets(input.role);
+        return { status: 200, data: { targets } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function replaceEscalationTargets(input) {
+    try {
+        if (!Array.isArray(input.targets)) {
+            return { status: 400, error: 'targets must be an array of strings' };
+        }
+        await roleService.replaceEscalationTargets(input.role, input.targets);
+        return { status: 200, data: { role: input.role, targets: input.targets } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+// Admin-required
+async function deleteRole(input) {
+    try {
+        const result = await roleService.deleteRole(input.role);
+        if (!result.deleted) {
+            return { status: 409, error: result.error || 'Cannot delete role' };
+        }
+        return { status: 200, data: { deleted: true } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/settings.d.ts

@@ -0,0 +1,2 @@
+import type { LTApiResult } from '../types/sdk';
+export declare function getSettings(): Promise<LTApiResult>;

package/build/api/settings.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSettings = getSettings;
+const telemetry_1 = require("../lib/telemetry");
+const events_1 = require("../lib/events");
+const nats_1 = require("../lib/events/nats");
+const socketio_1 = require("../lib/events/socketio");
+const defaults_1 = require("../modules/defaults");
+async function getSettings() {
+    try {
+        const hasSocketIO = !!events_1.eventRegistry.getAdapter(socketio_1.SocketIOEventAdapter);
+        const hasNats = !!events_1.eventRegistry.getAdapter(nats_1.NatsEventAdapter);
+        const transport = hasSocketIO ? 'socketio' : hasNats ? 'nats' : 'none';
+        return {
+            status: 200,
+            data: {
+                telemetry: {
+                    traceUrl: telemetry_1.telemetryRegistry.traceUrl ?? null,
+                },
+                escalation: {
+                    claimDurations: defaults_1.CLAIM_DURATION_OPTIONS,
+                },
+                events: {
+                    transport,
+                    natsWsUrl: hasNats
+                        ? (process.env.VITE_NATS_WS_URL || process.env.NATS_WS_URL || null)
+                        : null,
+                },
+            },
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/tasks.d.ts

@@ -0,0 +1,27 @@
+import type { LTApiResult } from '../types/sdk';
+export declare function listTasks(input: {
+    status?: string;
+    lt_type?: string;
+    workflow_type?: string;
+    workflow_id?: string;
+    parent_workflow_id?: string;
+    origin_id?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<LTApiResult>;
+export declare function getProcessStats(input: {
+    period?: string;
+}): Promise<LTApiResult>;
+export declare function listProcesses(input: {
+    limit?: number;
+    offset?: number;
+    workflow_type?: string;
+    status?: string;
+    search?: string;
+}): Promise<LTApiResult>;
+export declare function getProcess(input: {
+    originId: string;
+}): Promise<LTApiResult>;
+export declare function getTask(input: {
+    id: string;
+}): Promise<LTApiResult>;

package/build/api/tasks.js

@@ -0,0 +1,96 @@
+"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.listTasks = listTasks;
+exports.getProcessStats = getProcessStats;
+exports.listProcesses = listProcesses;
+exports.getProcess = getProcess;
+exports.getTask = getTask;
+const taskService = __importStar(require("../services/task"));
+const escalationService = __importStar(require("../services/escalation"));
+async function listTasks(input) {
+    try {
+        const result = await taskService.listTasks(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getProcessStats(input) {
+    try {
+        const stats = await taskService.getProcessStats(input.period);
+        return { status: 200, data: stats };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function listProcesses(input) {
+    try {
+        const result = await taskService.listProcesses(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getProcess(input) {
+    try {
+        const [tasks, escalations] = await Promise.all([
+            taskService.getProcessTasks(input.originId),
+            escalationService.getEscalationsByOriginId(input.originId),
+        ]);
+        return {
+            status: 200,
+            data: { origin_id: input.originId, tasks, escalations },
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function getTask(input) {
+    try {
+        const task = await taskService.getTask(input.id);
+        if (!task) {
+            return { status: 404, error: 'Task not found' };
+        }
+        return { status: 200, data: task };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/users.d.ts

@@ -0,0 +1,44 @@
+import type { LTApiResult } from '../types/sdk';
+import type { LTRoleType } from '../types';
+export declare function listUsers(input: {
+    role?: string;
+    roleType?: LTRoleType;
+    status?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<LTApiResult>;
+export declare function getUser(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function createUser(input: {
+    external_id?: string;
+    email?: string;
+    display_name?: string;
+    roles?: {
+        role: string;
+        type: string;
+    }[];
+    metadata?: Record<string, any>;
+}): Promise<LTApiResult>;
+export declare function updateUser(input: {
+    id: string;
+    email?: string;
+    display_name?: string;
+    status?: string;
+    metadata?: Record<string, any>;
+}): Promise<LTApiResult>;
+export declare function deleteUser(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function getUserRoles(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function addUserRole(input: {
+    id: string;
+    role: string;
+    type: string;
+}): Promise<LTApiResult>;
+export declare function removeUserRole(input: {
+    id: string;
+    role: string;
+}): Promise<LTApiResult>;