@bluefly/openstandardagents 0.5.1 → 0.5.3

package/dist/messaging/protocols/memory.js

@@ -1,290 +0,0 @@
-/**
- * OSSA Messaging Extension - In-Memory Transport
- * In-memory message broker for development and testing
- */
-import { randomUUID } from 'crypto';
-import { EventEmitter } from 'events';
-import { AbstractMessageBroker } from '../broker.js';
-import { ChannelManager } from '../channels.js';
-/**
- * In-memory message broker
- * Non-persistent, single-process only
- */
-export class MemoryMessageBroker extends AbstractMessageBroker {
-    eventBus;
-    messages;
-    activeSubscriptions;
-    config;
-    pruneTimer;
-    constructor(config = {}) {
-        super(new ChannelManager());
-        this.eventBus = new EventEmitter();
-        this.eventBus.setMaxListeners(1000); // Support many subscriptions
-        this.messages = new Map();
-        this.activeSubscriptions = new Map();
-        this.config = {
-            maxMessages: config.maxMessages || 10000,
-            pruneInterval: config.pruneInterval || 60000,
-        };
-        // Start periodic pruning of old messages
-        this.startPruning();
-    }
-    /**
-     * Publish a message to a channel
-     */
-    async publish(channel, message) {
-        this.validateMessage(message);
-        // Store message
-        const stored = {
-            message,
-            timestamp: Date.now(),
-            acknowledged: false,
-        };
-        if (!this.messages.has(channel)) {
-            this.messages.set(channel, []);
-        }
-        const channelMessages = this.messages.get(channel);
-        channelMessages.push(stored);
-        // Enforce max messages limit
-        if (channelMessages.length > this.config.maxMessages) {
-            channelMessages.shift(); // Remove oldest message
-        }
-        // Emit to matching subscribers
-        await this.deliverMessage(channel, message);
-    }
-    /**
-     * Subscribe to messages on a channel
-     */
-    async subscribe(subscription, handler) {
-        const handle = {
-            id: randomUUID(),
-            channel: subscription.channel,
-            subscription,
-            handler,
-            pattern: this.channelPatternToRegex(subscription.channel),
-            unsubscribe: async () => {
-                await this.unsubscribe(handle);
-            },
-        };
-        this.activeSubscriptions.set(handle.id, handle);
-        // Add to channel subscriptions map
-        if (!this.subscriptions.has(subscription.channel)) {
-            this.subscriptions.set(subscription.channel, new Set());
-        }
-        this.subscriptions.get(subscription.channel).add(handle);
-        return handle;
-    }
-    /**
-     * Unsubscribe from a channel
-     */
-    async unsubscribe(handle) {
-        // Remove from active subscriptions
-        this.activeSubscriptions.delete(handle.id);
-        // Remove from channel subscriptions (base class handles this)
-        await super.unsubscribe(handle);
-    }
-    /**
-     * Acknowledge message receipt
-     */
-    async acknowledge(messageId) {
-        // Find and mark message as acknowledged
-        for (const channelMessages of this.messages.values()) {
-            const message = channelMessages.find((m) => m.message.id === messageId);
-            if (message) {
-                message.acknowledged = true;
-                return;
-            }
-        }
-    }
-    /**
-     * Negative acknowledge (reject) a message
-     */
-    async nack(messageId, requeue = true) {
-        if (!requeue) {
-            // Remove message from storage
-            for (const [channel, channelMessages] of this.messages.entries()) {
-                const index = channelMessages.findIndex((m) => m.message.id === messageId);
-                if (index !== -1) {
-                    const [message] = channelMessages.splice(index, 1);
-                    // Send to DLQ if configured
-                    const dlqChannel = `${channel}.dlq`;
-                    await this.publish(dlqChannel, message.message);
-                    return;
-                }
-            }
-        }
-        // If requeue is true, message stays in storage for redelivery
-    }
-    /**
-     * Close the broker connection
-     */
-    async close() {
-        if (this.pruneTimer) {
-            clearInterval(this.pruneTimer);
-        }
-        this.eventBus.removeAllListeners();
-        this.messages.clear();
-        this.activeSubscriptions.clear();
-        this.subscriptions.clear();
-    }
-    /**
-     * Deliver message to matching subscribers
-     */
-    async deliverMessage(channel, message) {
-        const matchingSubscriptions = this.findMatchingSubscriptions(channel);
-        for (const sub of matchingSubscriptions) {
-            // Check filter
-            if (!this.matchesFilter(message, sub.subscription.filter)) {
-                continue;
-            }
-            // Execute handler with error handling
-            try {
-                await this.executeHandler(sub, message);
-            }
-            catch (error) {
-                console.error(`Error in message handler for channel ${channel}:`, error);
-                // Handle retry logic
-                if (sub.subscription.config?.retryOnError) {
-                    await this.handleRetry(sub, message, error);
-                }
-            }
-        }
-    }
-    /**
-     * Execute message handler
-     */
-    async executeHandler(sub, message) {
-        const timeout = sub.subscription.config?.timeout || 30000;
-        // Create timeout promise
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error('Handler timeout')), timeout);
-        });
-        // Execute handler with timeout
-        await Promise.race([sub.handler(message), timeoutPromise]);
-        // Auto-acknowledge if configured
-        if (sub.subscription.config?.autoAcknowledge) {
-            await this.acknowledge(message.id);
-        }
-    }
-    /**
-     * Handle message retry
-     */
-    async handleRetry(sub, message, error) {
-        const maxRetries = sub.subscription.config?.maxRetries || 3;
-        const retryCount = parseInt(String(message.metadata?.headers?.['x-retry-count'] || '0'), 10) || 0;
-        if (retryCount < maxRetries) {
-            // Calculate backoff delay
-            const backoff = sub.subscription.config?.retryBackoff;
-            const delay = this.calculateBackoffDelay(retryCount, backoff);
-            // Schedule retry
-            setTimeout(async () => {
-                const retryMessage = {
-                    ...message,
-                    metadata: {
-                        ...message.metadata,
-                        headers: {
-                            ...message.metadata?.headers,
-                            'x-retry-count': String(retryCount + 1),
-                        },
-                    },
-                };
-                await this.deliverMessage(message.channel, retryMessage);
-            }, delay);
-        }
-        else {
-            // Max retries exceeded, send to DLQ
-            const dlqChannel = `${message.channel}.dlq`;
-            await this.publish(dlqChannel, message);
-        }
-    }
-    /**
-     * Calculate backoff delay for retries
-     */
-    calculateBackoffDelay(retryCount, backoff) {
-        if (!backoff || backoff.strategy === 'none') {
-            return 0;
-        }
-        const initialDelay = backoff.initialDelay || 1000;
-        const maxDelay = backoff.maxDelay || 30000;
-        let delay;
-        if (backoff.strategy === 'linear') {
-            delay = initialDelay * (retryCount + 1);
-        }
-        else {
-            // exponential
-            const multiplier = backoff.multiplier || 2;
-            delay = initialDelay * Math.pow(multiplier, retryCount);
-        }
-        return Math.min(delay, maxDelay);
-    }
-    /**
-     * Find subscriptions matching a channel
-     */
-    findMatchingSubscriptions(channel) {
-        const matching = [];
-        for (const sub of this.activeSubscriptions.values()) {
-            if (sub.pattern.test(channel)) {
-                matching.push(sub);
-            }
-        }
-        // Sort by priority
-        return matching.sort((a, b) => {
-            const priorityOrder = { critical: 4, high: 3, normal: 2, low: 1 };
-            const aPriority = priorityOrder[a.subscription.priority || 'normal'];
-            const bPriority = priorityOrder[b.subscription.priority || 'normal'];
-            return bPriority - aPriority;
-        });
-    }
-    /**
-     * Convert channel pattern to regex
-     */
-    channelPatternToRegex(pattern) {
-        const regexPattern = pattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '[^.]+')
-            .replace(/#/g, '.*');
-        return new RegExp(`^${regexPattern}$`);
-    }
-    /**
-     * Start periodic pruning of old messages
-     */
-    startPruning() {
-        this.pruneTimer = setInterval(() => {
-            this.pruneOldMessages();
-        }, this.config.pruneInterval);
-    }
-    /**
-     * Prune old acknowledged messages
-     */
-    pruneOldMessages() {
-        const now = Date.now();
-        const maxAge = 3600000; // 1 hour
-        for (const [channel, messages] of this.messages.entries()) {
-            const filtered = messages.filter((m) => {
-                // Keep unacknowledged messages
-                if (!m.acknowledged)
-                    return true;
-                // Keep recent messages
-                return now - m.timestamp < maxAge;
-            });
-            if (filtered.length !== messages.length) {
-                this.messages.set(channel, filtered);
-            }
-        }
-    }
-    /**
-     * Get statistics (for testing/debugging)
-     */
-    getStats() {
-        let totalMessages = 0;
-        for (const messages of this.messages.values()) {
-            totalMessages += messages.length;
-        }
-        return {
-            channels: this.messages.size,
-            totalMessages,
-            activeSubscriptions: this.activeSubscriptions.size,
-        };
-    }
-}
-//# sourceMappingURL=memory.js.map

package/dist/messaging/protocols/redis.d.ts

@@ -1,83 +0,0 @@
-/**
- * OSSA v0.3.3 Messaging Extension - Redis Transport
- * Redis-based message broker for production use
- */
-import { Message, MessageHandler, Subscription, SubscriptionHandle } from '../types.js';
-import { AbstractMessageBroker } from '../broker.js';
-/**
- * Redis message broker
- * Uses Redis Pub/Sub for broadcast and Redis Streams for persistent queues
- *
- * Note: This is a reference implementation. In production, use actual Redis client.
- * Install: npm install redis@^4.0.0
- */
-export declare class RedisMessageBroker extends AbstractMessageBroker {
-    private config;
-    private client;
-    private subscriber;
-    private activeSubscriptions;
-    private connected;
-    constructor(config: Record<string, unknown>);
-    /**
-     * Initialize Redis connections
-     */
-    private connect;
-    /**
-     * Publish a message to a channel
-     */
-    publish(channel: string, message: Message): Promise<void>;
-    /**
-     * Subscribe to messages on a channel
-     */
-    subscribe(subscription: Subscription, handler: MessageHandler): Promise<SubscriptionHandle>;
-    /**
-     * Acknowledge message receipt
-     */
-    acknowledge(messageId: string): Promise<void>;
-    /**
-     * Negative acknowledge (reject) a message
-     */
-    nack(messageId: string, requeue?: boolean): Promise<void>;
-    /**
-     * Close the broker connection
-     */
-    close(): Promise<void>;
-    /**
-     * Publish to Redis Pub/Sub
-     */
-    private publishToPubSub;
-    /**
-     * Publish to Redis Stream
-     */
-    private publishToStream;
-    /**
-     * Subscribe to a pattern
-     */
-    private subscribePattern;
-    /**
-     * Convert channel pattern to Redis pattern
-     */
-    private channelToRedisPattern;
-    /**
-     * Get Redis key for channel
-     */
-    private getChannelKey;
-    /**
-     * Validate configuration
-     */
-    private validateConfig;
-    /**
-     * Create mock Redis client for reference implementation
-     * In production, remove this and use actual Redis client
-     */
-    private createMockRedisClient;
-    /**
-     * Get broker statistics (for monitoring)
-     */
-    getStats(): Promise<{
-        connected: boolean;
-        activeSubscriptions: number;
-        url: string;
-    }>;
-}
-//# sourceMappingURL=redis.d.ts.map

package/dist/messaging/protocols/redis.js

@@ -1,223 +0,0 @@
-/**
- * OSSA v0.3.3 Messaging Extension - Redis Transport
- * Redis-based message broker for production use
- */
-import { randomUUID } from 'crypto';
-import { AbstractMessageBroker } from '../broker.js';
-import { ChannelManager } from '../channels.js';
-/**
- * Redis message broker
- * Uses Redis Pub/Sub for broadcast and Redis Streams for persistent queues
- *
- * Note: This is a reference implementation. In production, use actual Redis client.
- * Install: npm install redis@^4.0.0
- */
-export class RedisMessageBroker extends AbstractMessageBroker {
-    config;
-    client; // Redis client (would be RedisClientType in production)
-    subscriber; // Separate client for subscriptions
-    activeSubscriptions;
-    connected;
-    constructor(config) {
-        super(new ChannelManager());
-        this.config = this.validateConfig(config);
-        this.activeSubscriptions = new Map();
-        this.connected = false;
-    }
-    /**
-     * Initialize Redis connections
-     */
-    async connect() {
-        if (this.connected)
-            return;
-        try {
-            // In production, use actual Redis client:
-            // const redis = await import('redis');
-            // this.client = redis.createClient({ url: this.config.url });
-            // this.subscriber = this.client.duplicate();
-            // await this.client.connect();
-            // await this.subscriber.connect();
-            // For reference implementation, we simulate the connection
-            this.client = this.createMockRedisClient();
-            this.subscriber = this.createMockRedisClient();
-            this.connected = true;
-        }
-        catch (error) {
-            throw new Error(`Failed to connect to Redis: ${error}`);
-        }
-    }
-    /**
-     * Publish a message to a channel
-     */
-    async publish(channel, message) {
-        await this.connect();
-        this.validateMessage(message);
-        const key = this.getChannelKey(channel);
-        const serialized = JSON.stringify(message);
-        try {
-            // For persistent messages, use Redis Streams
-            if (message.qos?.persistent) {
-                await this.publishToStream(key, message);
-            }
-            else {
-                // For non-persistent, use Pub/Sub
-                await this.publishToPubSub(key, serialized);
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to publish message: ${error}`);
-        }
-    }
-    /**
-     * Subscribe to messages on a channel
-     */
-    async subscribe(subscription, handler) {
-        await this.connect();
-        const handle = {
-            id: randomUUID(),
-            channel: subscription.channel,
-            unsubscribe: async () => {
-                await this.unsubscribe(handle);
-            },
-        };
-        this.activeSubscriptions.set(handle.id, handle);
-        // Subscribe using pattern matching for wildcards
-        const pattern = this.channelToRedisPattern(subscription.channel);
-        await this.subscribePattern(pattern, subscription, handler);
-        return handle;
-    }
-    /**
-     * Acknowledge message receipt
-     */
-    async acknowledge(messageId) {
-        await this.connect();
-        // In production: XACK stream group messageId
-        // For reference implementation, we simulate acknowledgment
-        console.log(`Acknowledged message: ${messageId}`);
-    }
-    /**
-     * Negative acknowledge (reject) a message
-     */
-    async nack(messageId, requeue = true) {
-        await this.connect();
-        if (!requeue) {
-            // Move to dead letter queue
-            // In production: use XADD to DLQ stream
-            console.log(`Moved message to DLQ: ${messageId}`);
-        }
-        // If requeue, message stays in pending list for redelivery
-    }
-    /**
-     * Close the broker connection
-     */
-    async close() {
-        if (!this.connected)
-            return;
-        try {
-            // In production: await this.client.quit(); await this.subscriber.quit();
-            this.connected = false;
-            this.activeSubscriptions.clear();
-        }
-        catch (error) {
-            console.error('Error closing Redis connection:', error);
-        }
-    }
-    /**
-     * Publish to Redis Pub/Sub
-     */
-    async publishToPubSub(channel, message) {
-        // In production: await this.client.publish(channel, message);
-        console.log(`Publishing to ${channel}:`, message);
-    }
-    /**
-     * Publish to Redis Stream
-     */
-    async publishToStream(streamKey, message) {
-        // In production:
-        // await this.client.xAdd(streamKey, '*', {
-        //   data: JSON.stringify(message),
-        //   id: message.id,
-        //   type: message.type,
-        //   timestamp: message.timestamp,
-        // });
-        console.log(`Publishing to stream ${streamKey}:`, message.id);
-    }
-    /**
-     * Subscribe to a pattern
-     */
-    async subscribePattern(pattern, subscription, handler) {
-        // In production: use PSUBSCRIBE for pub/sub or consumer groups for streams
-        // this.subscriber.pSubscribe(pattern, async (message, channel) => {
-        //   const msg = JSON.parse(message);
-        //   if (this.matchesFilter(msg, subscription.filter)) {
-        //     await handler(msg);
-        //   }
-        // });
-        console.log(`Subscribed to pattern: ${pattern}`);
-    }
-    /**
-     * Convert channel pattern to Redis pattern
-     */
-    channelToRedisPattern(channel) {
-        return channel.replace(/\*/g, '*').replace(/#/g, '*');
-    }
-    /**
-     * Get Redis key for channel
-     */
-    getChannelKey(channel) {
-        const prefix = this.config.keyPrefix || 'ossa:messages:';
-        return `${prefix}${channel}`;
-    }
-    /**
-     * Validate configuration
-     */
-    validateConfig(config) {
-        if (!config.url || typeof config.url !== 'string') {
-            throw new Error('Redis URL is required');
-        }
-        return {
-            url: config.url,
-            db: config.db || 0,
-            keyPrefix: config.keyPrefix || 'ossa:messages:',
-            connectionTimeout: config.connectionTimeout || 5000,
-            retryStrategy: config.retryStrategy || {
-                maxRetries: 3,
-                backoff: 'exponential',
-            },
-        };
-    }
-    /**
-     * Create mock Redis client for reference implementation
-     * In production, remove this and use actual Redis client
-     */
-    createMockRedisClient() {
-        return {
-            publish: async (channel, message) => {
-                console.log(`[Mock Redis] PUBLISH ${channel}: ${message.substring(0, 100)}...`);
-            },
-            xAdd: async (key, id, fields) => {
-                console.log(`[Mock Redis] XADD ${key} ${id}:`, fields);
-            },
-            pSubscribe: async (pattern, _callback) => {
-                console.log(`[Mock Redis] PSUBSCRIBE ${pattern}`);
-            },
-            xAck: async (key, group, id) => {
-                console.log(`[Mock Redis] XACK ${key} ${group} ${id}`);
-            },
-            quit: async () => {
-                console.log('[Mock Redis] QUIT');
-            },
-        };
-    }
-    /**
-     * Get broker statistics (for monitoring)
-     */
-    async getStats() {
-        return {
-            connected: this.connected,
-            activeSubscriptions: this.activeSubscriptions.size,
-            url: this.config.url,
-        };
-    }
-}
-//# sourceMappingURL=redis.js.map