@mulingai-npm/redis 3.35.0 → 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-chunk-manager.d.ts

@@ -30,6 +30,7 @@ export type MulingstreamChunkData = {
     shortCodeTargetLanguages: string[];
     finalTranscription: string;
     createdAt: number;
+    creditUsageSessionId?: number | null;
     streamingChunk: StreamingChunkData;
     translation: {
         [language: string]: {
@@ -75,6 +76,7 @@ export declare class MulingstreamChunkManager {
         sttProvider: SttProvider;
         targetLanguages: string[];
         shortCodeTargetLanguages: string[];
+        creditUsageSessionId?: number | null;
         streamingData: {
             startMs: number;
             endMs: number;

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

@@ -34,6 +34,7 @@ class MulingstreamChunkManager {
             shortCodeTargetLanguages: this.deserialize(h.shortCodeTargetLanguages),
             finalTranscription: h.finalTranscription,
             createdAt: parseInt(h.createdAt, 10),
+            creditUsageSessionId: h.creditUsageSessionId ? parseInt(h.creditUsageSessionId, 10) : null,
             streamingChunk: this.deserialize(h.streamingChunk),
             translation: this.deserialize(h.translation),
             tts: this.deserialize(h.tts),
@@ -75,7 +76,7 @@ class MulingstreamChunkManager {
      */
     async addStreamingChunk(params) {
         var _a, _b;
-        const { roomId, userId, chunkNumber, language, transcription, sttProvider, targetLanguages, shortCodeTargetLanguages, streamingData } = params;
+        const { roomId, userId, chunkNumber, language, transcription, sttProvider, targetLanguages, shortCodeTargetLanguages, creditUsageSessionId, streamingData } = params;
         // Clear room if this is first chunk (new session)
         if (chunkNumber === 1) {
             const old = await this.redisClient.zrange(this.roomZsetKey(roomId), 0, -1);
@@ -127,6 +128,7 @@ class MulingstreamChunkManager {
             shortCodeTargetLanguages,
             finalTranscription: transcription,
             createdAt,
+            creditUsageSessionId: creditUsageSessionId !== null && creditUsageSessionId !== void 0 ? creditUsageSessionId : null,
             streamingChunk,
             translation,
             tts,
@@ -143,6 +145,7 @@ class MulingstreamChunkManager {
             shortCodeTargetLanguages: this.serialize(shortCodeTargetLanguages),
             finalTranscription: transcription,
             createdAt: String(createdAt),
+            creditUsageSessionId: creditUsageSessionId != null ? String(creditUsageSessionId) : '',
             streamingChunk: this.serialize(streamingChunk),
             translation: this.serialize(translation),
             tts: this.serialize(tts),

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;
@@ -36,6 +38,8 @@ export declare class MulingstreamSpeakerManager {
     isRoomEmpty(roomId: string): Promise<boolean>;
     updateSourceLanguage(socketId: string, newLang: string): Promise<boolean>;
     updateTargetLanguages(socketId: string, languages: string[]): Promise<boolean>;
+    updateSourceLanguageByRoomId(roomId: string, newLang: string): Promise<number>;
+    updateTargetLanguagesByRoomId(roomId: string, languages: string[]): Promise<number>;
     increaseRecordingDuration(socketId: string, delta: number): Promise<number>;
     private cleanIndexes;
 }

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) {
@@ -201,6 +209,24 @@ class MulingstreamSpeakerManager {
         await this.redisClient.hset(this.buildKey(speaker.speakerId), { targetLanguages: JSON.stringify(languages) });
         return true;
     }
+    async updateSourceLanguageByRoomId(roomId, newLang) {
+        const speakers = await this.getSpeakersByRoomId(roomId);
+        let updated = 0;
+        for (const speaker of speakers) {
+            await this.redisClient.hset(this.buildKey(speaker.speakerId), { sourceLanguage: newLang });
+            updated++;
+        }
+        return updated;
+    }
+    async updateTargetLanguagesByRoomId(roomId, languages) {
+        const speakers = await this.getSpeakersByRoomId(roomId);
+        let updated = 0;
+        for (const speaker of speakers) {
+            await this.redisClient.hset(this.buildKey(speaker.speakerId), { targetLanguages: JSON.stringify(languages) });
+            updated++;
+        }
+        return updated;
+    }
     async increaseRecordingDuration(socketId, delta) {
         const speaker = await this.getSpeakerBySocketId(socketId);
         if (speaker === null)

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.0",
+    "version": "3.35.3",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "repository": {