@net3/queuer/src/lib/actions/get-queue.ts

import {
  createAction,
  Property,
  ActionContext,
} from '@activepieces/pieces-framework';
import { QueueManager } from '../common/queue-manager';
import { MCPManager } from '../common/mcp-manager';

export const getQueue = createAction({
  name: 'get_queue',
  displayName: 'Get Queue',
  description: 'Show queue settings and status information for a specific queue',
  props: {
    queueId: Property.Dropdown({
      displayName: 'Select Queue',
      description: 'Select the queue to view settings and status for',
      required: true,
      refreshers: [],
      options: async ({ auth }) => {
        const authConfig = auth as { mcpServerUrl?: string };
        if (!authConfig.mcpServerUrl) {
          return { 
            options: [],
            placeholder: 'MCP Server URL required in auth configuration'
          };
        }
        
        try {
          const config = { mcpServerUrl: authConfig.mcpServerUrl };
          const tools = await 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: any) => ({
            label: `Queue: ${tool.name} - ${tool.description || 'No description'}`,
            value: `mcp_${tool.name}_queue`,
          }));
          
          return {
            options: queueOptions,
            placeholder: 'Select a queue to view'
          };
        } catch (error) {
          console.error('Failed to fetch MCP tools:', error);
          return {
            options: [],
            placeholder: 'Failed to connect to MCP server'
          };
        }
      },
    }),

    includeUsageDetails: Property.Checkbox({
      displayName: 'Include Usage Details',
      description: 'Include detailed usage statistics and active hours information',
      required: false,
      defaultValue: true,
    }),
  },

  async run(context: ActionContext) {
    try {
      const { queueId, includeUsageDetails } = context.propsValue;

      if (!queueId) {
        throw new Error('Queue ID is required');
      }

      // Verify queue exists
      let queue;
      try {
        queue = await QueueManager.getQueueConfiguration(context, queueId as string);
        if (!queue) {
          throw new Error(`Queue "${queueId}" not found. Make sure the queue was created using Create/Update Queue action.`);
        }
      } catch (error: any) {
        throw new Error(`Failed to get queue configuration: ${error.message}`);
      }

      // Get complete queue details
      let details;
      try {
        details = await QueueManager.getQueueDetails(context, queueId as string);
        if (!details) {
          throw new Error('Failed to retrieve queue details');
        }
      } catch (error: any) {
        throw new Error(`Failed to get queue details: ${error.message}`);
      }

      // Validate details structure
      if (!details.configuration || !details.state || !details.usage) {
        throw new Error('Incomplete queue details received - missing configuration, state, or usage data');
      }

      // Format the configuration for output
      let baseResponse;
      try {
        baseResponse = {
          success: true,
          queueId: queueId as string,
          configuration: {
            id: details.configuration.id,
            mcpToolName: details.configuration.mcpToolName,
            delayType: details.configuration.delayType,
            delayUnit: details.configuration.delayUnit,
            delayValue: details.configuration.delayValue,
            delayMin: details.configuration.delayMin,
            delayMax: details.configuration.delayMax,
            dailyLimit: details.configuration.dailyLimit,
            hourlyLimit: details.configuration.hourlyLimit,
            createdAt: details.configuration.createdAt ? new Date(details.configuration.createdAt).toISOString() : null,
            updatedAt: details.configuration.updatedAt ? new Date(details.configuration.updatedAt).toISOString() : null,
            lastUsed: details.configuration.lastUsed ? new Date(details.configuration.lastUsed).toISOString() : null,
            totalProcessed: details.configuration.totalProcessed || 0,
          },
          status: details.status,
          currentState: {
            pendingItems: details.state.itemCount,
            currentlyExecuting: details.state.currentExecutingItem,
            lastExecutedTime: details.state.lastExecutedTime ? new Date(details.state.lastExecutedTime).toISOString() : null,
            lastReleaseTime: details.state.lastReleaseTime ? new Date(details.state.lastReleaseTime).toISOString() : null,
            version: details.state.version,
          },
          retrievedAt: new Date().toISOString(),
          message: `Successfully retrieved queue information for "${details.configuration.mcpToolName}"`,
        };
      } catch (error: any) {
        throw new Error(`Failed to format queue response: ${error.message}`);
      }

      if (includeUsageDetails) {
        try {
          return {
            ...baseResponse,
            usageDetails: {
              currentUsage: details.usage,
              activeHours: details.configuration.activeHours || null,
              rateLimits: {
                daily: {
                  limit: details.configuration.dailyLimit || 0,
                  used: details.usage.dailyCount,
                  remaining: details.status?.dailyRemaining,
                },
                hourly: {
                  limit: details.configuration.hourlyLimit || 0,
                  used: details.usage.hourlyCount,
                  remaining: details.status?.hourlyRemaining,
                },
              },
              activeHoursStatus: {
                isWithinActiveHours: details.status?.isWithinActiveHours,
                nextActiveWindow: details.status?.nextActiveWindow,
              },
            },
          };
        } catch (error: any) {
          throw new Error(`Failed to format usage details: ${error.message}`);
        }
      }

      return baseResponse;

    } catch (error: any) {
      throw new Error(`Get Queue Action Failed: ${error.message}`);
    }
  },
});