briyah 1.0.0

package/dist/room/artifact-store.service.d.ts

@@ -0,0 +1,15 @@
+import { Artifact } from './artifact';
+export declare class ArtifactStoreService {
+    private readonly logger;
+    private readonly ARTIFACT_EXTENSION;
+    private readonly MAX_FILENAME_LENGTH;
+    private readonly UNSAFE_CHARS_REGEX;
+    saveArtifact(roomId: string, storageDir: string, artifact: Artifact): string;
+    loadArtifacts(roomId: string, storageDir: string): Artifact[];
+    deleteArtifact(roomId: string, storageDir: string, artifactName: string): boolean;
+    deleteAllArtifacts(roomId: string, storageDir: string): void;
+    sanitizeFilename(name: string, roomDir: string): string;
+    parseArtifactFile(content: string): Artifact | null;
+    formatArtifactFile(artifact: Artifact): string;
+    getArtifactFilePath(roomId: string, storageDir: string, sanitizedName: string): string;
+}

package/dist/room/artifact-store.service.js

@@ -0,0 +1,226 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var ArtifactStoreService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactStoreService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let ArtifactStoreService = ArtifactStoreService_1 = class ArtifactStoreService {
+    logger = new common_1.Logger(ArtifactStoreService_1.name);
+    ARTIFACT_EXTENSION = '.artifact';
+    MAX_FILENAME_LENGTH = 200;
+    UNSAFE_CHARS_REGEX = /[<>:"/\\|?*]/g;
+    saveArtifact(roomId, storageDir, artifact) {
+        const roomDir = path.join(storageDir, roomId);
+        if (!fs.existsSync(roomDir)) {
+            fs.mkdirSync(roomDir, { recursive: true });
+        }
+        this.deleteArtifact(roomId, storageDir, artifact.name);
+        const sanitizedName = this.sanitizeFilename(artifact.name, roomDir);
+        const filePath = this.getArtifactFilePath(roomId, storageDir, sanitizedName);
+        const content = this.formatArtifactFile(artifact);
+        try {
+            fs.writeFileSync(filePath, content, 'utf-8');
+            this.logger.log(`Saved artifact "${artifact.name}" to ${filePath}`);
+            return filePath;
+        }
+        catch (error) {
+            this.logger.error(`Failed to save artifact "${artifact.name}": ${error.message}`);
+            throw error;
+        }
+    }
+    loadArtifacts(roomId, storageDir) {
+        const roomDir = path.join(storageDir, roomId);
+        if (!fs.existsSync(roomDir)) {
+            return [];
+        }
+        const artifacts = [];
+        try {
+            const files = fs.readdirSync(roomDir);
+            const artifactFiles = files.filter((file) => file.endsWith(this.ARTIFACT_EXTENSION));
+            for (const file of artifactFiles) {
+                const filePath = path.join(roomDir, file);
+                try {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const artifact = this.parseArtifactFile(content);
+                    if (artifact) {
+                        artifacts.push(artifact);
+                    }
+                    else {
+                        this.logger.warn(`Skipping invalid artifact file: ${file}`);
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Error reading artifact file ${file}: ${error.message}`);
+                }
+            }
+            this.logger.log(`Loaded ${artifacts.length} artifacts for room ${roomId}`);
+        }
+        catch (error) {
+            this.logger.error(`Error loading artifacts for room ${roomId}: ${error.message}`);
+        }
+        return artifacts;
+    }
+    deleteArtifact(roomId, storageDir, artifactName) {
+        const roomDir = path.join(storageDir, roomId);
+        if (!fs.existsSync(roomDir)) {
+            return false;
+        }
+        try {
+            const files = fs.readdirSync(roomDir);
+            const artifactFiles = files.filter((file) => file.endsWith(this.ARTIFACT_EXTENSION));
+            for (const file of artifactFiles) {
+                const filePath = path.join(roomDir, file);
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const artifact = this.parseArtifactFile(content);
+                if (artifact && artifact.name === artifactName) {
+                    fs.unlinkSync(filePath);
+                    this.logger.log(`Deleted artifact "${artifactName}" from ${filePath}`);
+                    return true;
+                }
+            }
+            return false;
+        }
+        catch (error) {
+            this.logger.error(`Error deleting artifact "${artifactName}": ${error.message}`);
+            return false;
+        }
+    }
+    deleteAllArtifacts(roomId, storageDir) {
+        const roomDir = path.join(storageDir, roomId);
+        if (!fs.existsSync(roomDir)) {
+            return;
+        }
+        try {
+            const files = fs.readdirSync(roomDir);
+            const artifactFiles = files.filter((file) => file.endsWith(this.ARTIFACT_EXTENSION));
+            for (const file of artifactFiles) {
+                const filePath = path.join(roomDir, file);
+                fs.unlinkSync(filePath);
+            }
+            this.logger.log(`Deleted ${artifactFiles.length} artifact files from room ${roomId}`);
+        }
+        catch (error) {
+            this.logger.error(`Error deleting artifacts for room ${roomId}: ${error.message}`);
+        }
+    }
+    sanitizeFilename(name, roomDir) {
+        if (!name || name.trim().length === 0) {
+            throw new Error('Artifact name cannot be empty');
+        }
+        let sanitized = name.trim().replace(/^\.+|\.+$/g, '');
+        sanitized = sanitized.replace(this.UNSAFE_CHARS_REGEX, '_');
+        if (sanitized.length > this.MAX_FILENAME_LENGTH) {
+            sanitized = sanitized.substring(0, this.MAX_FILENAME_LENGTH);
+        }
+        let finalName = sanitized;
+        let counter = 2;
+        while (fs.existsSync(path.join(roomDir, finalName + this.ARTIFACT_EXTENSION))) {
+            finalName = `${sanitized}_${counter}`;
+            counter++;
+            if (counter > 1000) {
+                throw new Error(`Unable to generate unique filename for artifact "${name}"`);
+            }
+        }
+        return finalName;
+    }
+    parseArtifactFile(content) {
+        const lines = content.split('\n');
+        if (lines.length < 4) {
+            this.logger.error('Invalid artifact file: too few lines');
+            return null;
+        }
+        const nameLine = lines[0];
+        const creatorLine = lines[1];
+        const viewersLine = lines[2];
+        if (!nameLine.startsWith('# name: ')) {
+            this.logger.error('Invalid artifact file: missing or malformed name header');
+            return null;
+        }
+        const name = nameLine.substring('# name: '.length).trim();
+        if (!creatorLine.startsWith('# creator: ')) {
+            this.logger.error('Invalid artifact file: missing or malformed creator header');
+            return null;
+        }
+        const creator = creatorLine.substring('# creator: '.length).trim();
+        let viewers;
+        if (viewersLine.startsWith('# viewers: ')) {
+            const viewersStr = viewersLine.substring('# viewers: '.length).trim();
+            if (viewersStr.length > 0) {
+                viewers = viewersStr
+                    .split(',')
+                    .map((v) => v.trim())
+                    .filter((v) => v.length > 0);
+            }
+            else {
+                viewers = [creator];
+            }
+        }
+        else {
+            viewers = [creator];
+        }
+        const body = lines.slice(3).join('\n');
+        return {
+            name,
+            creator,
+            body,
+            viewers,
+        };
+    }
+    formatArtifactFile(artifact) {
+        const viewersStr = artifact.viewers && artifact.viewers.length > 0
+            ? artifact.viewers.join(', ')
+            : artifact.creator;
+        return `# name: ${artifact.name}
+# creator: ${artifact.creator}
+# viewers: ${viewersStr}
+
+${artifact.body}`;
+    }
+    getArtifactFilePath(roomId, storageDir, sanitizedName) {
+        return path.join(storageDir, roomId, sanitizedName + this.ARTIFACT_EXTENSION);
+    }
+};
+exports.ArtifactStoreService = ArtifactStoreService;
+exports.ArtifactStoreService = ArtifactStoreService = ArtifactStoreService_1 = __decorate([
+    (0, common_1.Injectable)()
+], ArtifactStoreService);

package/dist/room/artifact.d.ts

@@ -0,0 +1,6 @@
+export interface Artifact {
+    name: string;
+    creator: string;
+    body: string;
+    viewers?: string[];
+}

package/dist/room/artifact.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/room/message.d.ts

@@ -0,0 +1,19 @@
+import { Message, MessageAction } from '@shared/types/app.types';
+export declare class RoomMessage implements Message {
+    sender: string;
+    action: MessageAction;
+    content: string;
+    targets: string[];
+    timestamp: Date;
+    name?: string;
+    situation?: string;
+    index?: number;
+    constructor(sender: string, action: MessageAction, content: string, targets?: string[], name?: string, situation?: string);
+    getSender(): string;
+    getAction(): MessageAction;
+    getContent(): string;
+    getTargets(): string[];
+    getTimestamp(): Date;
+    isTarget(agentName: string): boolean;
+    canHear(agentNickname: string): boolean;
+}

package/dist/room/message.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomMessage = void 0;
+const app_types_1 = require("@shared/types/app.types");
+class RoomMessage {
+    sender;
+    action;
+    content;
+    targets;
+    timestamp;
+    name;
+    situation;
+    index;
+    constructor(sender, action = app_types_1.MessageAction.SPEAK, content, targets = [], name, situation) {
+        this.sender = sender;
+        this.action = action;
+        this.content = content;
+        this.targets = targets;
+        this.name = name;
+        this.timestamp = new Date();
+        this.situation = situation;
+    }
+    getSender() {
+        return this.sender;
+    }
+    getAction() {
+        return this.action;
+    }
+    getContent() {
+        return this.content;
+    }
+    getTargets() {
+        return [...this.targets];
+    }
+    getTimestamp() {
+        return this.timestamp;
+    }
+    isTarget(agentName) {
+        if (this.action === app_types_1.MessageAction.SHOUT)
+            return true;
+        if (this.action === app_types_1.MessageAction.THINK) {
+            return this.sender === agentName;
+        }
+        if (this.action === app_types_1.MessageAction.WHISPER ||
+            this.action === app_types_1.MessageAction.RELAY ||
+            this.action === app_types_1.MessageAction.RELAY_SILENT) {
+            return this.targets.includes(agentName);
+        }
+        if (this.targets.length > 0) {
+            return this.targets.includes(agentName);
+        }
+        return false;
+    }
+    canHear(agentNickname) {
+        if (this.sender === agentNickname) {
+            return false;
+        }
+        if (this.action === app_types_1.MessageAction.RELAY || this.action === app_types_1.MessageAction.RELAY_SILENT)
+            return this.targets.includes(agentNickname);
+        if (this.action === app_types_1.MessageAction.PUBLISH)
+            return this.targets.includes(agentNickname) || this.targets.length === 0;
+        if (this.action === app_types_1.MessageAction.EXECUTE)
+            return this.targets.includes(agentNickname) || this.targets.length === 0;
+        if (this.action === app_types_1.MessageAction.WHISPER) {
+            return this.targets.includes(agentNickname);
+        }
+        return true;
+    }
+}
+exports.RoomMessage = RoomMessage;

package/dist/room/published-rooms.service.d.ts

@@ -0,0 +1,12 @@
+export declare class PublishedRoomsService {
+    private mapping;
+    private filePath;
+    constructor();
+    private load;
+    private save;
+    getUserId(roomId: string): string | undefined;
+    addPublishedRoom(roomId: string, userId: string): void;
+    removePublishedRoom(roomId: string): void;
+    isPublished(roomId: string): boolean;
+    getPublishedRoomsForUser(userId: string): string[];
+}

package/dist/room/published-rooms.service.js

@@ -0,0 +1,108 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishedRoomsService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let PublishedRoomsService = class PublishedRoomsService {
+    mapping;
+    filePath;
+    constructor() {
+        this.filePath = path.join(process.cwd(), 'data', 'common', 'published-rooms.json');
+        this.mapping = new Map();
+        this.load();
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const data = JSON.parse(fs.readFileSync(this.filePath, 'utf8'));
+                this.mapping = new Map(Object.entries(data.mapping));
+            }
+        }
+        catch (error) {
+            console.error('Failed to load published rooms mapping:', error);
+        }
+    }
+    save() {
+        try {
+            const dir = path.dirname(this.filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            const data = {
+                mapping: Object.fromEntries(this.mapping),
+                version: 1,
+            };
+            fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to save published rooms mapping:', error);
+        }
+    }
+    getUserId(roomId) {
+        return this.mapping.get(roomId);
+    }
+    addPublishedRoom(roomId, userId) {
+        this.mapping.set(roomId, userId);
+        this.save();
+    }
+    removePublishedRoom(roomId) {
+        this.mapping.delete(roomId);
+        this.save();
+    }
+    isPublished(roomId) {
+        return this.mapping.has(roomId);
+    }
+    getPublishedRoomsForUser(userId) {
+        return (Array.from(this.mapping.entries())
+            .filter(([_roomId, uid]) => uid === userId)
+            .map(([roomId, _uid]) => roomId));
+    }
+};
+exports.PublishedRoomsService = PublishedRoomsService;
+exports.PublishedRoomsService = PublishedRoomsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], PublishedRoomsService);

package/dist/room/room-config.d.ts

@@ -0,0 +1,12 @@
+export interface RoomConfig {
+    id: string;
+    name: string;
+    goal: string;
+    baseRoomDir?: string;
+    agentIds: string[];
+    roomLeader: string;
+    messages: string[];
+    createdAt: string;
+    isPublished?: boolean;
+    templateRoomId?: string;
+}

package/dist/room/room-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/room/room-factory.d.ts

@@ -0,0 +1,7 @@
+import { Room } from './room';
+import { RoomStoreService } from './room-store.service';
+export declare class RoomFactory {
+    private readonly roomStoreService;
+    constructor(roomStoreService: RoomStoreService);
+    createRoom(name: string, goal: string, baseRoomDir?: string, storageDir?: string): Room;
+}

package/dist/room/room-factory.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomFactory = void 0;
+const room_1 = require("./room");
+class RoomFactory {
+    roomStoreService;
+    constructor(roomStoreService) {
+        this.roomStoreService = roomStoreService;
+    }
+    createRoom(name, goal, baseRoomDir = '', storageDir = '') {
+        const finalStorageDir = storageDir || this.roomStoreService.getDefaultStorageDir();
+        const room = new room_1.Room(null, name, goal, baseRoomDir, finalStorageDir, this.roomStoreService);
+        return room;
+    }
+}
+exports.RoomFactory = RoomFactory;

package/dist/room/room-message.module.d.ts

@@ -0,0 +1,2 @@
+export declare class RoomMessageModule {
+}

package/dist/room/room-message.module.js

@@ -0,0 +1,21 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomMessageModule = void 0;
+const common_1 = require("@nestjs/common");
+const room_message_service_1 = require("./room-message.service");
+let RoomMessageModule = class RoomMessageModule {
+};
+exports.RoomMessageModule = RoomMessageModule;
+exports.RoomMessageModule = RoomMessageModule = __decorate([
+    (0, common_1.Module)({
+        imports: [],
+        providers: [room_message_service_1.RoomMessageService],
+        exports: [room_message_service_1.RoomMessageService],
+    })
+], RoomMessageModule);

package/dist/room/room-message.service.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from 'events';
+export declare class RoomMessageService {
+    private messageEmitters;
+    getOrCreateEmitter(roomId: string): EventEmitter;
+    emitUpdate(roomId: string, roomState: any): void;
+    emitError(roomId: string, error: Error): void;
+    cleanup(roomId: string): void;
+}

package/dist/room/room-message.service.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomMessageService = void 0;
+const common_1 = require("@nestjs/common");
+const events_1 = require("events");
+let RoomMessageService = class RoomMessageService {
+    messageEmitters = new Map();
+    getOrCreateEmitter(roomId) {
+        if (!this.messageEmitters.has(roomId)) {
+            this.messageEmitters.set(roomId, new events_1.EventEmitter());
+        }
+        return this.messageEmitters.get(roomId);
+    }
+    emitUpdate(roomId, roomState) {
+        const emitter = this.getOrCreateEmitter(roomId);
+        emitter.emit('update', roomState);
+    }
+    emitError(roomId, error) {
+        const emitter = this.getOrCreateEmitter(roomId);
+        emitter.emit('update', {
+            timestamp: Date.now(),
+            type: 'error',
+            errorType: error.name,
+            message: error.message,
+        });
+    }
+    cleanup(roomId) {
+        const emitter = this.messageEmitters.get(roomId);
+        if (emitter) {
+            emitter.removeAllListeners();
+            this.messageEmitters.delete(roomId);
+        }
+    }
+};
+exports.RoomMessageService = RoomMessageService;
+exports.RoomMessageService = RoomMessageService = __decorate([
+    (0, common_1.Injectable)()
+], RoomMessageService);

package/dist/room/room-store.module.d.ts

@@ -0,0 +1,2 @@
+export declare class RoomStoreModule {
+}

package/dist/room/room-store.module.js

@@ -0,0 +1,25 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomStoreModule = void 0;
+const common_1 = require("@nestjs/common");
+const room_store_service_1 = require("./room-store.service");
+const artifact_store_service_1 = require("./artifact-store.service");
+const configuration_module_1 = require("../config/configuration.module");
+const agent_store_module_1 = require("../ai/agent-store.module");
+const attached_file_module_1 = require("../ai/attached-file.module");
+let RoomStoreModule = class RoomStoreModule {
+};
+exports.RoomStoreModule = RoomStoreModule;
+exports.RoomStoreModule = RoomStoreModule = __decorate([
+    (0, common_1.Module)({
+        imports: [configuration_module_1.ConfigurationModule, agent_store_module_1.AgentStoreModule, attached_file_module_1.AttachedFileModule],
+        providers: [room_store_service_1.RoomStoreService, artifact_store_service_1.ArtifactStoreService],
+        exports: [room_store_service_1.RoomStoreService],
+    })
+], RoomStoreModule);

package/dist/room/room-store.service.d.ts

@@ -0,0 +1,38 @@
+import { Room } from './room';
+import { ConfigurationService } from '../config/configuration.service';
+import { AgentStoreService } from '../ai/agent-store.service';
+import { AttachedFileService } from '../ai/attached-file.service';
+import { RoomInfo } from '@shared/types/app.types';
+import { RoomMessage } from './message';
+import { ArtifactStoreService } from './artifact-store.service';
+import { Artifact } from './artifact';
+export declare class RoomStoreService {
+    private readonly configService;
+    private readonly agentStore;
+    private readonly attachedFileService;
+    private readonly artifactStoreService;
+    private rooms;
+    private readonly defaultStorageDir;
+    private loaded;
+    private loadPromise;
+    constructor(configService: ConfigurationService, agentStore: AgentStoreService, attachedFileService: AttachedFileService, artifactStoreService: ArtifactStoreService);
+    getDefaultStorageDir(): string;
+    storeRoom(room: Room, storageDir?: string): string;
+    getRoom(id: string): Promise<Room | null>;
+    removeRoom(id: string, storageDir?: string, deleteAgents?: boolean): boolean;
+    getAllRoomIds(): Promise<string[]>;
+    getRoomCount(): number;
+    cloneRoomAsPublished(templateId: string, publishedName: string, userId: string): Promise<string>;
+    getPublishedInstances(templateId: string): Promise<Room[]>;
+    private ensureLoaded;
+    getAllRooms(): Promise<RoomInfo[]>;
+    readRoomMessagesFromFileAsync(messagesPath: string): Promise<RoomMessage[]>;
+    loadRoomsFromDirectory(storageDir: string): Promise<void>;
+    private saveRoomToFile;
+    appendMessageToFile(roomId: string, message: RoomMessage, storageDir: string): void;
+    clearRoomMessages(roomId: string, storageDir?: string): void;
+    saveArtifactFile(roomId: string, storageDir: string, artifact: Artifact): void;
+    deleteArtifactFile(roomId: string, storageDir: string, artifactName: string): boolean;
+    deleteAllArtifactFiles(roomId: string, storageDir: string): void;
+    private deleteRoomFile;
+}