@kya-os/mcp-i/dist/esm/polling.js

COMING SOON:Production-ready MCP Identity with automatic registration, key rotation, and optimized performance

/**
 * Simple polling utility for async registration
 * Uses fixed intervals for universal compatibility
 */
/**
 * Sleep utility
 */
function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}
/**
 * Simple polling function for registration status
 *
 * @param statusUrl - URL to poll for status
 * @param transport - Transport instance for HTTP requests
 * @param options - Polling options
 * @returns Registration result or throws on timeout/failure
 */
export async function pollRegistrationStatus(statusUrl, transport, options = {}) {
    const { pollInterval = 2000, // Fixed 2-second intervals
    maxPollingTime = 60000, // 60 seconds max
    logger, onProgress } = options;
    const startTime = Date.now();
    let attempts = 0;
    logger?.debug(`Starting registration polling: ${statusUrl}`);
    while (Date.now() - startTime < maxPollingTime) {
        attempts++;
        try {
            // Simple GET request for status
            const response = await transport.get(statusUrl);
            const status = response.data;
            logger?.debug(`Poll attempt ${attempts}: ${status.status}`);
            // Update progress if callback provided
            const elapsed = Math.floor((Date.now() - startTime) / 1000);
            const progressMessage = `Registration ${status.status}... (${elapsed}s elapsed)`;
            if (onProgress) {
                onProgress(progressMessage, status.progress);
            }
            // Check completion states
            if (status.status === 'completed' && status.result) {
                logger?.info('Registration completed successfully');
                return status.result;
            }
            if (status.status === 'failed') {
                const errorMessage = status.error?.message || 'Registration failed';
                logger?.error(`Registration failed: ${errorMessage}`);
                throw new Error(errorMessage);
            }
            // Wait before next poll (simple fixed interval)
            await sleep(pollInterval);
        }
        catch (error) {
            // If it's a completion/failure error, re-throw it
            if (error.message && !error.message.includes('ECONNREFUSED')) {
                throw error;
            }
            // Network errors - just wait and retry
            logger?.debug(`Network error during polling (attempt ${attempts}): ${error.message}`);
            await sleep(pollInterval);
        }
    }
    // Timeout reached
    const timeoutMessage = `Registration timeout after ${maxPollingTime / 1000} seconds`;
    logger?.error(timeoutMessage);
    throw new Error(timeoutMessage);
}
/**
 * Check if a registration response is async (v2.0 API)
 */
export function isAsyncRegistrationResponse(response) {
    return response &&
        typeof response.jobId === 'string' &&
        typeof response.status === 'string' &&
        !response.did; // Async responses don't have DID yet
}
//# sourceMappingURL=polling.js.map