@net3/queuer/dist/lib/actions/list-queue-items.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.listQueueItems = void 0;
const pieces_framework_1 = require("@activepieces/pieces-framework");
const queue_manager_1 = require("../common/queue-manager");
const mcp_manager_1 = require("../common/mcp-manager");
exports.listQueueItems = (0, pieces_framework_1.createAction)({
    name: 'list_queue_items',
    displayName: 'List Queue Items',
    description: 'Show all queued items for a specific queue',
    props: {
        queueId: pieces_framework_1.Property.Dropdown({
            displayName: 'Select Queue',
            description: 'Select the queue to list items from',
            required: true,
            refreshers: [],
            options: async ({ auth }) => {
                const authConfig = auth;
                if (!authConfig.mcpServerUrl) {
                    return {
                        options: [],
                        placeholder: 'MCP Server URL required in auth configuration'
                    };
                }
                try {
                    const config = { mcpServerUrl: authConfig.mcpServerUrl };
                    const tools = await mcp_manager_1.MCPManager.listMCPTools(config);
                    if (tools.length === 0) {
                        return {
                            options: [],
                            placeholder: 'No MCP tools found'
                        };
                    }
                    // Generate queue options based on available tools
                    const queueOptions = tools.map((tool) => ({
                        label: `Queue: ${tool.name} - ${tool.description || 'No description'}`,
                        value: `mcp_${tool.name}_queue`,
                    }));
                    return {
                        options: queueOptions,
                        placeholder: 'Select a queue to list items from'
                    };
                }
                catch (error) {
                    console.error('Failed to fetch MCP tools:', error);
                    return {
                        options: [],
                        placeholder: 'Failed to connect to MCP server'
                    };
                }
            },
        }),
        includeDetails: pieces_framework_1.Property.Checkbox({
            displayName: 'Include Full Details',
            description: 'Include complete action configuration and parameters for each item',
            required: false,
            defaultValue: false,
        }),
    },
    async run(context) {
        try {
            const { queueId, includeDetails } = context.propsValue;
            if (!queueId) {
                throw new Error('Queue ID is required');
            }
            // Verify queue exists
            let queue;
            try {
                queue = await queue_manager_1.QueueManager.getQueueConfiguration(context, queueId);
                if (!queue) {
                    throw new Error(`Queue "${queueId}" not found. Make sure the queue was created using Create/Update Queue action.`);
                }
            }
            catch (error) {
                throw new Error(`Failed to get queue configuration: ${error.message}`);
            }
            // Get queue status
            let status;
            try {
                status = await queue_manager_1.QueueManager.getQueueStatus(context, queueId);
                if (!status) {
                    throw new Error(`Failed to get queue status for "${queueId}"`);
                }
            }
            catch (error) {
                throw new Error(`Failed to get queue status: ${error.message}`);
            }
            // Get all items in the queue
            let items;
            try {
                items = await queue_manager_1.QueueManager.listQueueItems(context, queueId);
                if (!Array.isArray(items)) {
                    throw new Error('Invalid queue items data received');
                }
            }
            catch (error) {
                throw new Error(`Failed to get queue items: ${error.message}`);
            }
            // Format items for output
            let formattedItems;
            try {
                formattedItems = items.map(item => {
                    if (!item || !item.id) {
                        throw new Error('Invalid item data found in queue');
                    }
                    const baseInfo = {
                        id: item.id,
                        status: item.status,
                        releaseTime: new Date(item.releaseTime).toISOString(),
                        createdAt: new Date(item.createdAt).toISOString(),
                        targetAction: item.targetAction,
                        lastError: item.lastError || null,
                    };
                    if (includeDetails) {
                        return {
                            ...baseInfo,
                            actionConfig: item.actionConfig,
                        };
                    }
                    return baseInfo;
                });
            }
            catch (error) {
                throw new Error(`Failed to format queue items: ${error.message}`);
            }
            // Group items by status for summary
            let statusSummary;
            try {
                statusSummary = items.reduce((acc, item) => {
                    acc[item.status] = (acc[item.status] || 0) + 1;
                    return acc;
                }, {});
            }
            catch (error) {
                throw new Error(`Failed to create status summary: ${error.message}`);
            }
            return {
                success: true,
                queueId: queueId,
                queueName: queue.mcpToolName,
                totalItems: items.length,
                statusSummary,
                items: formattedItems,
                queueStatus: status,
                retrievedAt: new Date().toISOString(),
                message: `Successfully retrieved ${items.length} items from queue "${queue.mcpToolName}"`,
            };
        }
        catch (error) {
            throw new Error(`List Queue Items Action Failed: ${error.message}`);
        }
    },
});