@hotmeshio/long-tail 0.1.5 → 0.1.7

package/build/api/exports.js

@@ -0,0 +1,146 @@
+"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.listJobs = listJobs;
+exports.exportWorkflowState = exportWorkflowState;
+exports.exportWorkflowExecution = exportWorkflowExecution;
+exports.getWorkflowStatus = getWorkflowStatus;
+exports.getWorkflowState = getWorkflowState;
+const exportService = __importStar(require("../services/export"));
+const resolve_1 = require("../services/task/resolve");
+async function listJobs(input) {
+    try {
+        const result = await exportService.listJobs(input);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function exportWorkflowState(input) {
+    try {
+        let resolved;
+        try {
+            resolved = await (0, resolve_1.resolveWorkflowHandle)(input.workflowId);
+        }
+        catch {
+            return { status: 404, error: 'Workflow not found' };
+        }
+        const exported = await exportService.exportWorkflow(input.workflowId, resolved.taskQueue, resolved.workflowName, { allow: input.allow, block: input.block, values: input.values });
+        return { status: 200, data: exported };
+    }
+    catch (err) {
+        const msg = err.message ?? '';
+        if (msg.includes('not found') || msg.includes('undefined')) {
+            return {
+                status: 404,
+                error: 'Workflow data is no longer available (job may have expired)',
+            };
+        }
+        return { status: 500, error: msg };
+    }
+}
+async function exportWorkflowExecution(input) {
+    try {
+        let resolved;
+        try {
+            resolved = await (0, resolve_1.resolveWorkflowHandle)(input.workflowId);
+        }
+        catch {
+            return { status: 404, error: 'Workflow not found' };
+        }
+        const execution = await exportService.exportWorkflowExecution(input.workflowId, resolved.taskQueue, resolved.workflowName, {
+            exclude_system: input.excludeSystem ?? false,
+            omit_results: input.omitResults ?? false,
+            mode: input.mode || undefined,
+            max_depth: input.maxDepth,
+            enrich_inputs: true,
+        });
+        return { status: 200, data: execution };
+    }
+    catch (err) {
+        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
+        return {
+            status,
+            error: status === 404
+                ? 'Workflow data is no longer available (job may have expired)'
+                : err.message,
+        };
+    }
+}
+async function getWorkflowStatus(input) {
+    try {
+        let resolved;
+        try {
+            resolved = await (0, resolve_1.resolveWorkflowHandle)(input.workflowId);
+        }
+        catch {
+            return { status: 404, error: 'Workflow not found' };
+        }
+        const result = await exportService.getWorkflowStatus(input.workflowId, resolved.taskQueue, resolved.workflowName);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
+        return {
+            status,
+            error: status === 404
+                ? 'Workflow data is no longer available (job may have expired)'
+                : err.message,
+        };
+    }
+}
+async function getWorkflowState(input) {
+    try {
+        let resolved;
+        try {
+            resolved = await (0, resolve_1.resolveWorkflowHandle)(input.workflowId);
+        }
+        catch {
+            return { status: 404, error: 'Workflow not found' };
+        }
+        const result = await exportService.getWorkflowState(input.workflowId, resolved.taskQueue, resolved.workflowName);
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        const status = err.status === 404 || err.message?.includes('Not Found') ? 404 : 500;
+        return {
+            status,
+            error: status === 404
+                ? 'Workflow data is no longer available (job may have expired)'
+                : err.message,
+        };
+    }
+}

package/build/api/index.d.ts

@@ -0,0 +1,18 @@
+export * as tasks from './tasks';
+export * as escalations from './escalations';
+export * as workflows from './workflows';
+export * as yamlWorkflows from './yaml-workflows';
+export * as users from './users';
+export * as roles from './roles';
+export * as auth from './auth';
+export * as mcp from './mcp';
+export * as mcpRuns from './mcp-runs';
+export * as insight from './insight';
+export * as settings from './settings';
+export * as exports from './exports';
+export * as controlplane from './controlplane';
+export * as botAccounts from './bot-accounts';
+export * as workflowSets from './workflow-sets';
+export * as dba from './dba';
+export * as namespaces from './namespaces';
+export * as maintenance from './maintenance';

package/build/api/index.js

@@ -0,0 +1,54 @@
+"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.maintenance = exports.namespaces = exports.dba = exports.workflowSets = exports.botAccounts = exports.controlplane = exports.exports = exports.settings = exports.insight = exports.mcpRuns = exports.mcp = exports.auth = exports.roles = exports.users = exports.yamlWorkflows = exports.workflows = exports.escalations = exports.tasks = void 0;
+exports.tasks = __importStar(require("./tasks"));
+exports.escalations = __importStar(require("./escalations"));
+exports.workflows = __importStar(require("./workflows"));
+exports.yamlWorkflows = __importStar(require("./yaml-workflows"));
+exports.users = __importStar(require("./users"));
+exports.roles = __importStar(require("./roles"));
+exports.auth = __importStar(require("./auth"));
+exports.mcp = __importStar(require("./mcp"));
+exports.mcpRuns = __importStar(require("./mcp-runs"));
+exports.insight = __importStar(require("./insight"));
+exports.settings = __importStar(require("./settings"));
+exports.exports = __importStar(require("./exports"));
+exports.controlplane = __importStar(require("./controlplane"));
+exports.botAccounts = __importStar(require("./bot-accounts"));
+exports.workflowSets = __importStar(require("./workflow-sets"));
+exports.dba = __importStar(require("./dba"));
+exports.namespaces = __importStar(require("./namespaces"));
+exports.maintenance = __importStar(require("./maintenance"));

package/build/api/insight.d.ts

@@ -0,0 +1,29 @@
+import type { LTApiResult, LTApiAuth } from '../types/sdk';
+export declare function mcpQuery(input: {
+    prompt: string;
+    tags?: string[];
+    wait?: boolean;
+    direct?: boolean;
+    context?: any;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+export declare function buildWorkflow(input: {
+    prompt: string;
+    tags?: string[];
+    wait?: boolean;
+    feedback?: string;
+    prior_yaml?: string;
+    answers?: any;
+    prior_questions?: any;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+export declare function refineWorkflow(input: {
+    prompt: string;
+    prior_yaml: string;
+    feedback: string;
+    tags?: string[];
+    wait?: boolean;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+export declare function describeWorkflow(input: {
+    prompt: string;
+    result_title?: string;
+    result_summary?: string;
+}): Promise<LTApiResult>;

package/build/api/insight.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpQuery = mcpQuery;
+exports.buildWorkflow = buildWorkflow;
+exports.refineWorkflow = refineWorkflow;
+exports.describeWorkflow = describeWorkflow;
+const insight_1 = require("../services/insight");
+async function mcpQuery(input, auth) {
+    try {
+        if (!input.prompt || typeof input.prompt !== 'string') {
+            return { status: 400, error: 'prompt is required' };
+        }
+        if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+            return { status: 503, error: 'MCP queries require an LLM API key (OPENAI_API_KEY or ANTHROPIC_API_KEY)' };
+        }
+        const result = await (0, insight_1.startMcpQuery)({
+            prompt: input.prompt,
+            tags: input.tags,
+            wait: input.wait,
+            direct: input.direct,
+            context: input.context,
+            userId: auth?.userId,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        if (err.message?.includes('timeout') || err.message?.includes('TIMEOUT')) {
+            return { status: 504, error: 'MCP query timed out. Try a simpler prompt.' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+async function buildWorkflow(input, auth) {
+    try {
+        if (!input.prompt || typeof input.prompt !== 'string') {
+            return { status: 400, error: 'prompt is required' };
+        }
+        if (!process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+            return { status: 503, error: 'Workflow builder requires an LLM API key (OPENAI_API_KEY or ANTHROPIC_API_KEY)' };
+        }
+        const result = await (0, insight_1.startWorkflowBuilder)({
+            prompt: input.prompt,
+            tags: input.tags,
+            wait: input.wait,
+            feedback: input.feedback,
+            prior_yaml: input.prior_yaml,
+            answers: input.answers,
+            prior_questions: input.prior_questions,
+            userId: auth?.userId,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        if (err.message?.includes('timeout') || err.message?.includes('TIMEOUT')) {
+            return { status: 504, error: 'Workflow builder timed out. Try a simpler description.' };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+async function refineWorkflow(input, auth) {
+    try {
+        if (!input.prompt || !input.prior_yaml || !input.feedback) {
+            return { status: 400, error: 'prompt, prior_yaml, and feedback are required' };
+        }
+        const result = await (0, insight_1.startWorkflowBuilder)({
+            prompt: input.prompt,
+            tags: input.tags,
+            wait: input.wait,
+            feedback: input.feedback,
+            prior_yaml: input.prior_yaml,
+            userId: auth?.userId,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+async function describeWorkflow(input) {
+    try {
+        if (!input.prompt) {
+            return { status: 400, error: 'prompt is required' };
+        }
+        const result = await (0, insight_1.describeWorkflow)(input);
+        return { status: 200, data: result };
+    }
+    catch {
+        return { status: 200, data: { description: input.prompt || '', tags: [] } };
+    }
+}

package/build/api/maintenance.d.ts

@@ -0,0 +1,7 @@
+import type { LTMaintenanceConfig } from '../types/maintenance';
+import type { LTApiResult } from '../types/sdk';
+export declare function getMaintenanceConfig(): LTApiResult;
+export declare function updateMaintenanceConfig(input: {
+    schedule: string;
+    rules: LTMaintenanceConfig['rules'];
+}): Promise<LTApiResult>;

package/build/api/maintenance.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaintenanceConfig = getMaintenanceConfig;
+exports.updateMaintenanceConfig = updateMaintenanceConfig;
+const maintenance_1 = require("../services/maintenance");
+function getMaintenanceConfig() {
+    return {
+        status: 200,
+        data: { config: maintenance_1.maintenanceRegistry.config, active: maintenance_1.maintenanceRegistry.hasConfig },
+    };
+}
+async function updateMaintenanceConfig(input) {
+    try {
+        if (!input.schedule || !Array.isArray(input.rules)) {
+            return { status: 400, error: 'schedule (string) and rules (array) are required' };
+        }
+        await maintenance_1.maintenanceRegistry.disconnect();
+        maintenance_1.maintenanceRegistry.register({ schedule: input.schedule, rules: input.rules });
+        await maintenance_1.maintenanceRegistry.connect();
+        return {
+            status: 200,
+            data: { config: maintenance_1.maintenanceRegistry.config, restarted: true },
+        };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/mcp-runs.d.ts

@@ -0,0 +1,16 @@
+import type { LTApiResult } from '../types/sdk';
+export declare function listEntities(input: {
+    app_id: string;
+}): Promise<LTApiResult>;
+export declare function listJobs(input: {
+    app_id: string;
+    limit?: number;
+    offset?: number;
+    entity?: string;
+    search?: string;
+    status?: string;
+}): Promise<LTApiResult>;
+export declare function getJobExecution(input: {
+    jobId: string;
+    app_id: string;
+}): Promise<LTApiResult>;

package/build/api/mcp-runs.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listEntities = listEntities;
+exports.listJobs = listJobs;
+exports.getJobExecution = getJobExecution;
+const hotmesh_utils_1 = require("../services/hotmesh-utils");
+const mcp_runs_1 = require("../services/mcp-runs");
+async function listEntities(input) {
+    try {
+        if (!input.app_id) {
+            return { status: 400, error: 'app_id query parameter is required' };
+        }
+        const entities = await (0, mcp_runs_1.listEntities)(input.app_id);
+        return { status: 200, data: { entities } };
+    }
+    catch (err) {
+        if (err.message?.includes('does not exist')) {
+            return { status: 200, data: { entities: [] } };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+async function listJobs(input) {
+    try {
+        if (!input.app_id) {
+            return { status: 400, error: 'app_id query parameter is required' };
+        }
+        const result = await (0, mcp_runs_1.listJobs)({
+            rawAppId: input.app_id,
+            limit: input.limit,
+            offset: input.offset,
+            entity: input.entity,
+            search: input.search,
+            status: input.status,
+        });
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        if (err.message?.includes('does not exist')) {
+            return { status: 200, data: { jobs: [], total: 0 } };
+        }
+        return { status: 500, error: err.message };
+    }
+}
+async function getJobExecution(input) {
+    try {
+        if (!input.app_id) {
+            return { status: 400, error: 'app_id query parameter is required' };
+        }
+        const appId = (0, hotmesh_utils_1.sanitizeAppId)(input.app_id);
+        const schema = (0, hotmesh_utils_1.quoteSchema)(appId);
+        const execution = await (0, mcp_runs_1.buildExecution)(input.jobId, appId, schema);
+        return { status: 200, data: execution };
+    }
+    catch (err) {
+        const msg = err.message ?? '';
+        if (err.status === 404 || msg.includes('not found') || msg.includes('does not exist')) {
+            return { status: 404, error: msg };
+        }
+        return { status: 500, error: msg };
+    }
+}

package/build/api/mcp.d.ts

@@ -0,0 +1,52 @@
+import type { LTApiResult, LTApiAuth } from '../types/sdk';
+export declare function listMcpServers(input: {
+    status?: string;
+    auto_connect?: boolean;
+    search?: string;
+    tags?: string[];
+    limit?: number;
+    offset?: number;
+}): Promise<LTApiResult>;
+export declare function createMcpServer(input: {
+    name: string;
+    description?: string;
+    transport_type: string;
+    transport_config: Record<string, any>;
+    auto_connect?: boolean;
+    metadata?: Record<string, any>;
+    tags?: string[];
+    compile_hints?: any;
+    credential_providers?: string[];
+}): Promise<LTApiResult>;
+export declare function testConnection(input: {
+    transport_type: string;
+    transport_config: Record<string, any>;
+}): Promise<LTApiResult>;
+export declare function getMcpServer(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function updateMcpServer(input: {
+    id: string;
+    [key: string]: any;
+}): Promise<LTApiResult>;
+export declare function deleteMcpServer(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function connectMcpServer(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function disconnectMcpServer(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function getCredentialStatus(input: {
+    id: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;
+export declare function listMcpServerTools(input: {
+    id: string;
+}): Promise<LTApiResult>;
+export declare function callMcpTool(input: {
+    id: string;
+    toolName: string;
+    arguments?: Record<string, any>;
+    execute_as?: string;
+}, auth?: LTApiAuth): Promise<LTApiResult>;