@mulingai-npm/redis 3.35.2 → 3.35.3

package/dist/managers/demo-room-pool-manager.d.ts

@@ -0,0 +1,65 @@
+import { RedisClient } from '../redis-client';
+/**
+ * Demo Room Pool Manager
+ *
+ * Manages a pool of pre-created demo rooms for unauthenticated visitors.
+ * Tracks room availability, active sessions, and rate limiting.
+ *
+ * Redis key structure:
+ * - demo:pool:all              (Set)     All demo room IDs
+ * - demo:pool:available        (Set)     Currently available room IDs
+ * - demo:pool:room:{id}:session (Hash)   Active session info per room
+ * - demo:ratelimit:email:{hash} (Counter) Demos per email per 24h
+ */
+export declare class DemoRoomPoolManager {
+    private redisClient;
+    constructor(redisClient: RedisClient);
+    /**
+     * Initialize the pool with demo room IDs.
+     * Called once at service startup. Idempotent — safe to call on restart.
+     */
+    initPool(roomIds: number[]): Promise<void>;
+    /**
+     * Assign an available room to a demo user.
+     * Returns null if no rooms available.
+     * Atomic: SPOP removes from available set in one operation.
+     */
+    assignRoom(emailHash: string, demoSessionId: string, durationMs: number): Promise<{
+        roomId: number;
+        expiresAt: number;
+    } | null>;
+    /**
+     * Release a room back to the available pool.
+     * Called when: user ends demo, session expires, or speaker disconnects.
+     */
+    releaseRoom(roomId: number): Promise<void>;
+    /**
+     * Get pool status (for landing page "all rooms busy" message).
+     */
+    getPoolStatus(): Promise<{
+        totalRooms: number;
+        availableRooms: number;
+        soonestAvailableMs: number | null;
+    }>;
+    /**
+     * Check if a room's session has expired (called by pipeline periodic check).
+     */
+    isSessionExpired(roomId: number): Promise<boolean>;
+    /**
+     * Get session info for a room.
+     */
+    getSession(roomId: number): Promise<{
+        emailHash: string;
+        demoSessionId: string;
+        startedAt: number;
+        expiresAt: number;
+    } | null>;
+    /**
+     * Check email rate limit. Returns true if under limit, false if exceeded.
+     */
+    checkEmailRateLimit(emailHash: string, max?: number): Promise<boolean>;
+    /**
+     * Increment email rate limit counter with 24h TTL.
+     */
+    incrementEmailRateLimit(emailHash: string): Promise<void>;
+}

package/dist/managers/demo-room-pool-manager.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DemoRoomPoolManager = void 0;
+/**
+ * Demo Room Pool Manager
+ *
+ * Manages a pool of pre-created demo rooms for unauthenticated visitors.
+ * Tracks room availability, active sessions, and rate limiting.
+ *
+ * Redis key structure:
+ * - demo:pool:all              (Set)     All demo room IDs
+ * - demo:pool:available        (Set)     Currently available room IDs
+ * - demo:pool:room:{id}:session (Hash)   Active session info per room
+ * - demo:ratelimit:email:{hash} (Counter) Demos per email per 24h
+ */
+class DemoRoomPoolManager {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+    /**
+     * Initialize the pool with demo room IDs.
+     * Called once at service startup. Idempotent — safe to call on restart.
+     */
+    async initPool(roomIds) {
+        if (roomIds.length === 0)
+            return;
+        const roomIdStrings = roomIds.map(String);
+        // Add all room IDs to the "all" set
+        await this.redisClient.sadd('demo:pool:all', ...roomIdStrings);
+        // For each room, if no active session exists, add to available set
+        for (const roomIdStr of roomIdStrings) {
+            const sessionData = await this.redisClient.hgetall(`demo:pool:room:${roomIdStr}:session`);
+            const hasActiveSession = sessionData && sessionData.expiresAt && Date.now() < parseInt(sessionData.expiresAt);
+            if (!hasActiveSession) {
+                // Clean up any stale session
+                if (sessionData && sessionData.expiresAt) {
+                    await this.redisClient.del(`demo:pool:room:${roomIdStr}:session`);
+                }
+                await this.redisClient.sadd('demo:pool:available', roomIdStr);
+            }
+        }
+    }
+    /**
+     * Assign an available room to a demo user.
+     * Returns null if no rooms available.
+     * Atomic: SPOP removes from available set in one operation.
+     */
+    async assignRoom(emailHash, demoSessionId, durationMs) {
+        // Atomic pop from available set
+        const roomIdStr = await this.redisClient.spop('demo:pool:available');
+        if (!roomIdStr)
+            return null; // All rooms busy
+        const roomId = parseInt(roomIdStr);
+        const now = Date.now();
+        const expiresAt = now + durationMs;
+        // Store session info
+        await this.redisClient.hset(`demo:pool:room:${roomId}:session`, {
+            emailHash,
+            demoSessionId,
+            startedAt: now.toString(),
+            expiresAt: expiresAt.toString(),
+            durationMs: durationMs.toString()
+        });
+        // TTL slightly longer than session to auto-cleanup stale sessions
+        await this.redisClient.expire(`demo:pool:room:${roomId}:session`, Math.ceil(durationMs / 1000) + 300);
+        return { roomId, expiresAt };
+    }
+    /**
+     * Release a room back to the available pool.
+     * Called when: user ends demo, session expires, or speaker disconnects.
+     */
+    async releaseRoom(roomId) {
+        await this.redisClient.del(`demo:pool:room:${roomId}:session`);
+        await this.redisClient.sadd('demo:pool:available', roomId.toString());
+    }
+    /**
+     * Get pool status (for landing page "all rooms busy" message).
+     */
+    async getPoolStatus() {
+        const total = await this.redisClient.scard('demo:pool:all');
+        const available = await this.redisClient.scard('demo:pool:available');
+        let soonestAvailableMs = null;
+        if (available === 0 && total > 0) {
+            // Find the session that expires soonest
+            const allRoomIds = await this.redisClient.smembers('demo:pool:all');
+            let soonestExpiry = Infinity;
+            for (const rid of allRoomIds) {
+                const expiresAtStr = await this.redisClient.hget(`demo:pool:room:${rid}:session`, 'expiresAt');
+                if (expiresAtStr) {
+                    const expiry = parseInt(expiresAtStr);
+                    if (expiry < soonestExpiry)
+                        soonestExpiry = expiry;
+                }
+            }
+            if (soonestExpiry < Infinity) {
+                soonestAvailableMs = Math.max(0, soonestExpiry - Date.now());
+            }
+        }
+        return { totalRooms: total, availableRooms: available, soonestAvailableMs };
+    }
+    /**
+     * Check if a room's session has expired (called by pipeline periodic check).
+     */
+    async isSessionExpired(roomId) {
+        const expiresAtStr = await this.redisClient.hget(`demo:pool:room:${roomId}:session`, 'expiresAt');
+        if (!expiresAtStr)
+            return true; // No session = expired
+        return Date.now() >= parseInt(expiresAtStr);
+    }
+    /**
+     * Get session info for a room.
+     */
+    async getSession(roomId) {
+        const data = await this.redisClient.hgetall(`demo:pool:room:${roomId}:session`);
+        if (!(data === null || data === void 0 ? void 0 : data.demoSessionId))
+            return null;
+        return {
+            emailHash: data.emailHash,
+            demoSessionId: data.demoSessionId,
+            startedAt: parseInt(data.startedAt),
+            expiresAt: parseInt(data.expiresAt)
+        };
+    }
+    /**
+     * Check email rate limit. Returns true if under limit, false if exceeded.
+     */
+    async checkEmailRateLimit(emailHash, max = 3) {
+        const count = await this.redisClient.get(`demo:ratelimit:email:${emailHash}`);
+        return !count || parseInt(count) < max;
+    }
+    /**
+     * Increment email rate limit counter with 24h TTL.
+     */
+    async incrementEmailRateLimit(emailHash) {
+        const key = `demo:ratelimit:email:${emailHash}`;
+        await this.redisClient.incr(key);
+        await this.redisClient.expire(key, 86400); // 24h
+    }
+}
+exports.DemoRoomPoolManager = DemoRoomPoolManager;

package/dist/managers/mulingstream-speaker-manager.d.ts

@@ -11,6 +11,8 @@ export type MulingstreamSpeakerData = {
     recordingsDuration: number;
     targetLanguages: string[];
     timestamp: string;
+    isDemoSession?: boolean;
+    demoExpiresAt?: number;
 };
 export declare class MulingstreamSpeakerManager {
     private redisClient;

package/dist/managers/mulingstream-speaker-manager.js

@@ -32,7 +32,9 @@ class MulingstreamSpeakerManager {
             prompts: hash.prompts,
             recordingsDuration: parseInt(hash.recordingsDuration, 10) || 0,
             targetLanguages: JSON.parse(hash.targetLanguages || '[]'),
-            timestamp: hash.timestamp
+            timestamp: hash.timestamp,
+            isDemoSession: hash.isDemoSession === 'true',
+            demoExpiresAt: parseInt(hash.demoExpiresAt, 10) || 0
         };
     }
     serialize(data) {
@@ -51,6 +53,12 @@ class MulingstreamSpeakerManager {
         if (data.roomUuid) {
             result.roomUuid = data.roomUuid;
         }
+        if (data.isDemoSession) {
+            result.isDemoSession = 'true';
+        }
+        if (data.demoExpiresAt) {
+            result.demoExpiresAt = data.demoExpiresAt.toString();
+        }
         return result;
     }
     buildId(roomId, userId, socketId) {

package/dist/redis-client.d.ts

@@ -32,6 +32,9 @@ export declare class RedisClient {
     }>>;
     zcard(key: string): Promise<number>;
     zscore(key: string, member: string): Promise<number | null>;
+    scard(key: string): Promise<number>;
+    spop(key: string): Promise<string | null>;
+    hget(key: string, field: string): Promise<string | null>;
     incr(key: string): Promise<number>;
     scan(cursor: number, pattern: string, count?: number): Promise<[string, string[]]>;
     keys(pattern: string): Promise<string[]>;

package/dist/redis-client.js

@@ -91,6 +91,15 @@ class RedisClient {
         const score = await this.client.zscore(key, member);
         return score !== null ? parseFloat(score) : null;
     }
+    async scard(key) {
+        return this.client.scard(key);
+    }
+    async spop(key) {
+        return this.client.spop(key);
+    }
+    async hget(key, field) {
+        return this.client.hget(key, field);
+    }
     async incr(key) {
         return this.client.incr(key);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mulingai-npm/redis",
-    "version": "3.35.2",
+    "version": "3.35.3",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "repository": {