briyah 1.0.0

package/dist/server/src/room/room-store.service.js

@@ -0,0 +1,353 @@
+"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.RoomStoreService = void 0;
+const common_1 = require("@nestjs/common");
+const room_1 = require("./room");
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const configuration_service_1 = require("../config/configuration.service");
+const agent_store_service_1 = require("../ai/agent-store.service");
+const attached_file_service_1 = require("../ai/attached-file.service");
+const artifact_store_service_1 = require("./artifact-store.service");
+let RoomStoreService = class RoomStoreService {
+    configService;
+    agentStore;
+    attachedFileService;
+    artifactStoreService;
+    rooms = new Map();
+    defaultStorageDir;
+    loaded = false;
+    loadPromise = null;
+    constructor(configService, agentStore, attachedFileService, artifactStoreService) {
+        this.configService = configService;
+        this.agentStore = agentStore;
+        this.attachedFileService = attachedFileService;
+        this.artifactStoreService = artifactStoreService;
+        this.defaultStorageDir = path.join(this.configService.getUserDataDir(), 'rooms');
+    }
+    getDefaultStorageDir() {
+        return this.defaultStorageDir;
+    }
+    storeRoom(room, storageDir) {
+        const finalStorageDir = storageDir || this.defaultStorageDir;
+        room.setStorageDir(finalStorageDir);
+        room.setRoomStoreService(this);
+        this.rooms.set(room.getId(), room);
+        this.saveRoomToFile(room, finalStorageDir);
+        return room.getId();
+    }
+    async getRoom(id) {
+        await this.ensureLoaded();
+        return this.rooms.get(id) || null;
+    }
+    removeRoom(id, storageDir, deleteAgents = false) {
+        const room = this.rooms.get(id);
+        const result = this.rooms.delete(id);
+        if (result) {
+            this.deleteRoomFile(id, storageDir || this.defaultStorageDir, deleteAgents, room);
+        }
+        return result;
+    }
+    async getAllRoomIds() {
+        await this.ensureLoaded();
+        return Array.from(this.rooms.keys());
+    }
+    getRoomCount() {
+        return this.rooms.size;
+    }
+    async cloneRoomAsPublished(templateId, publishedName, userId) {
+        await this.ensureLoaded();
+        const template = await this.getRoom(templateId);
+        if (!template) {
+            throw new Error(`Template room not found: ${templateId}`);
+        }
+        const instanceId = (0, crypto_1.randomUUID)();
+        const templateAgents = template.getAgents();
+        const clonedAgentIds = [];
+        for (const templateAgent of templateAgents) {
+            const clonedAgentId = await this.agentStore.cloneAgentAsPublished(templateAgent.id, templateAgent.agentName, userId);
+            clonedAgentIds.push(clonedAgentId);
+            const clonedAgent = await this.agentStore.getAgent(clonedAgentId);
+            if (clonedAgent) {
+                clonedAgent.ownerRoomId = instanceId;
+                this.agentStore.storeAgent(clonedAgent);
+            }
+        }
+        const instance = new room_1.Room(instanceId, publishedName, template.getGoal(), template.getBaseRoomDir(), this.defaultStorageDir, this);
+        for (const agentId of clonedAgentIds) {
+            const agent = await this.agentStore.getAgent(agentId);
+            if (agent) {
+                instance.arrive(agent);
+            }
+        }
+        instance.setPublished(true);
+        instance.setTemplateRoomId(templateId);
+        instance.setRoomLeader(template.getRoomLeader());
+        this.storeRoom(instance);
+        return instanceId;
+    }
+    async getPublishedInstances(templateId) {
+        await this.ensureLoaded();
+        const instances = [];
+        for (const room of this.rooms.values()) {
+            if (room.getTemplateRoomId() === templateId) {
+                instances.push(room);
+            }
+        }
+        return instances;
+    }
+    async ensureLoaded() {
+        if (this.loaded)
+            return;
+        if (!this.loadPromise) {
+            this.loadPromise = this.loadRoomsFromDirectory(this.defaultStorageDir)
+                .then(() => {
+                this.loaded = true;
+            })
+                .catch((error) => {
+                this.loadPromise = null;
+                throw error;
+            });
+        }
+        await this.loadPromise;
+    }
+    async getAllRooms() {
+        await this.ensureLoaded();
+        return Array.from(this.rooms.entries()).map(([id, room]) => ({
+            id,
+            name: room.getName(),
+            goal: room.getGoal(),
+            agentCount: room.getAgentCount(),
+        }));
+    }
+    async readRoomMessagesFromFileAsync(messagesPath) {
+        try {
+            try {
+                let messagesContent = await fs.promises.readFile(messagesPath, 'utf-8');
+                if (!messagesContent)
+                    return [];
+                if (messagesContent.startsWith(','))
+                    messagesContent = messagesContent.slice(1);
+                return JSON.parse('[' + messagesContent + ']');
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    return [];
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            console.error(`Error reading room messages from file ${messagesPath}:`, error);
+            return [];
+        }
+    }
+    async loadRoomsFromDirectory(storageDir) {
+        try {
+            try {
+                await fs.promises.access(storageDir);
+            }
+            catch {
+                console.log(`Room storage directory not found: ${storageDir}`);
+                await fs.promises.mkdir(storageDir, { recursive: true });
+                return;
+            }
+            const entries = await fs.promises.readdir(storageDir, {
+                withFileTypes: true,
+            });
+            const roomDirs = entries
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => entry.name);
+            console.log(`Loading ${roomDirs.length} rooms from ${storageDir}`);
+            for (const roomDirName of roomDirs) {
+                try {
+                    const roomDir = path.join(storageDir, roomDirName);
+                    const metadataPath = path.join(roomDir, 'metadata.json');
+                    const messagesPath = path.join(roomDir, 'messages');
+                    try {
+                        await fs.promises.access(metadataPath);
+                    }
+                    catch {
+                        console.warn(`Skipping ${roomDirName}: metadata.json not found`);
+                        continue;
+                    }
+                    const fileContent = await fs.promises.readFile(metadataPath, 'utf-8');
+                    const config = JSON.parse(fileContent);
+                    let messages = await this.readRoomMessagesFromFileAsync(messagesPath);
+                    const room = new room_1.Room(config.id, config.name, config.goal, '', storageDir, this);
+                    room.setLoading(true);
+                    room.setCreatedAt(new Date(config.createdAt));
+                    room.setRoomMessages(messages);
+                    const artifacts = this.artifactStoreService.loadArtifacts(config.id, storageDir);
+                    room.setArtifacts(artifacts);
+                    if (config.isPublished !== undefined) {
+                        room.setPublished(config.isPublished);
+                    }
+                    if (config.templateRoomId) {
+                        room.setTemplateRoomId(config.templateRoomId);
+                    }
+                    for (const agentId of config.agentIds) {
+                        const agent = await this.agentStore.getAgent(agentId);
+                        if (agent) {
+                            room.arrive(agent);
+                        }
+                        else {
+                            console.warn(`Agent ${agentId} not found when loading room ${config.name} from ${storageDir}`);
+                        }
+                    }
+                    room.setRoomLeader(config.roomLeader);
+                    this.rooms.set(config.id, room);
+                    room.setLoading(false);
+                    room.ready();
+                    console.log(`Loaded room: ${config.name} (${config.id}) with ${messages.length} messages from ${storageDir}`);
+                }
+                catch (error) {
+                    console.error(`Error loading room from directory ${roomDirName}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error loading rooms from directory ${storageDir}:`, error);
+        }
+    }
+    saveRoomToFile(room, storageDir) {
+        try {
+            if (!fs.existsSync(storageDir)) {
+                fs.mkdirSync(storageDir, { recursive: true });
+            }
+            const roomDir = path.join(storageDir, room.getId());
+            if (!fs.existsSync(roomDir)) {
+                fs.mkdirSync(roomDir, { recursive: true });
+            }
+            const config = {
+                id: room.getId(),
+                name: room.getName(),
+                goal: room.getGoal(),
+                agentIds: room.getAgents().map((agent) => agent.id),
+                roomLeader: room.getRoomLeader(),
+                messages: [],
+                createdAt: room.getCreatedAt().toISOString(),
+                isPublished: room.getIsPublished(),
+                templateRoomId: room.getTemplateRoomId(),
+            };
+            const metadataPath = path.join(roomDir, 'metadata.json');
+            fs.writeFileSync(metadataPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error(`Error saving room ${room.getId()} to file:`, error);
+        }
+    }
+    appendMessageToFile(roomId, message, storageDir) {
+        try {
+            const roomDir = path.join(storageDir, roomId);
+            const messagesPath = path.join(roomDir, 'messages');
+            fs.appendFileSync(messagesPath, ',\n' + JSON.stringify(message), 'utf-8');
+        }
+        catch (error) {
+            console.error(`Error appending message to room ${roomId}:`, error);
+        }
+    }
+    clearRoomMessages(roomId, storageDir) {
+        try {
+            const finalStorageDir = storageDir || this.defaultStorageDir;
+            const room = this.rooms.get(roomId);
+            if (room) {
+                room.setRoomMessages([]);
+            }
+            const roomDir = path.join(finalStorageDir, roomId);
+            const messagesPath = path.join(roomDir, 'messages');
+            if (fs.existsSync(messagesPath)) {
+                fs.unlinkSync(messagesPath);
+                console.log(`Cleared messages for room ${roomId}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error clearing messages for room ${roomId}:`, error);
+        }
+    }
+    saveArtifactFile(roomId, storageDir, artifact) {
+        this.artifactStoreService.saveArtifact(roomId, storageDir, artifact);
+    }
+    deleteArtifactFile(roomId, storageDir, artifactName) {
+        return this.artifactStoreService.deleteArtifact(roomId, storageDir, artifactName);
+    }
+    deleteAllArtifactFiles(roomId, storageDir) {
+        this.artifactStoreService.deleteAllArtifacts(roomId, storageDir);
+    }
+    deleteRoomFile(roomId, storageDir, deleteAgents = false, room) {
+        try {
+            if (deleteAgents && room) {
+                const agents = room.getAgents();
+                for (const agent of agents) {
+                    try {
+                        this.agentStore.removeAgent(agent.id);
+                        console.log(`Deleted agent ${agent.agentName} (${agent.id}) as part of room deletion`);
+                    }
+                    catch (err) {
+                        console.error(`Failed to delete agent ${agent.id}:`, err);
+                    }
+                }
+            }
+            const roomDir = path.join(storageDir, roomId);
+            if (fs.existsSync(roomDir)) {
+                this.deleteAllArtifactFiles(roomId, storageDir);
+                fs.rmSync(roomDir, { recursive: true, force: true });
+                console.log(`Deleted room directory: ${roomDir}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error deleting room directory ${roomId}:`, error);
+        }
+    }
+};
+exports.RoomStoreService = RoomStoreService;
+exports.RoomStoreService = RoomStoreService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [configuration_service_1.ConfigurationService,
+        agent_store_service_1.AgentStoreService,
+        attached_file_service_1.AttachedFileService,
+        artifact_store_service_1.ArtifactStoreService])
+], RoomStoreService);

package/dist/server/src/room/room.d.ts

@@ -0,0 +1,107 @@
+import { Agent } from '../ai/agent';
+import { RoomMessage } from './message';
+import { Artifact } from './artifact';
+export declare class Room {
+    private id;
+    private name;
+    private goal;
+    private baseRoomDir;
+    private agents;
+    private roomLeader;
+    private roomMessages;
+    private pendingMessages;
+    private nextMessageIndex;
+    private createdAt;
+    private artifacts;
+    private isAdjourned;
+    private processingInProgress;
+    private isPaused;
+    private currentSpeaker;
+    private isPublished;
+    private isLoading;
+    private onStateChange?;
+    private onError?;
+    private currentSituation;
+    private onSituationUpdate?;
+    private templateRoomId;
+    private storageDir;
+    private roomStoreService;
+    constructor(id: string | null, name: string, goal: string, baseRoomDir?: string, storageDir?: string, roomStoreService?: any);
+    deleteRoom(): void;
+    setLoading(isLoading: boolean): void;
+    getName(): string;
+    setName(name: string): void;
+    getGoal(): string;
+    setGoal(goal: string): void;
+    getBaseRoomDir(): string;
+    setBaseRoomDir(dir: string): void;
+    getIsPublished(): boolean;
+    setPublished(published: boolean): void;
+    getPaused(): boolean;
+    getTemplateRoomId(): string | undefined;
+    setTemplateRoomId(templateId: string): void;
+    clearRoomMessages(): void;
+    arrive(agent: Agent): boolean;
+    getAgents(): Agent[];
+    setAgents(newAgents: Agent[]): void;
+    describeAgentsInRoom(): string;
+    setRoomLeader(agentNickname: string): void;
+    getRoomLeader(): string;
+    getAgentCount(): number;
+    ready(): void;
+    getCurrentSpeaker(): string | null;
+    setCurrentSpeaker(agentNickname: string | null): void;
+    isAgentsTurn(agentNickname: string): boolean;
+    getRoomMessageStats(): {
+        numMessages: number;
+        numChars: number;
+    };
+    getLatestRoomMessages(fromIndex?: number, includeThoughts?: boolean): RoomMessage[];
+    setRoomMessages(messages: RoomMessage[]): void;
+    addRoomMessage(message: RoomMessage): void;
+    addRoomMessages(messages: RoomMessage[]): void;
+    getCreatedAt(): Date;
+    setCreatedAt(date: Date): void;
+    getArtifacts(): Artifact[];
+    isRoomAdjourned(): boolean;
+    setArtifacts(artifacts: Artifact[]): void;
+    private parseAgentResponse;
+    private getAgentAiResponse;
+    perceive(agent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): void;
+    moderate(moderatorAgent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): Promise<void>;
+    private handleInsufficientBalance;
+    findArtifact(name: string): Artifact | undefined;
+    publishArtifact(name: string, creator: string, body: string, viewers?: string[]): Artifact | null;
+    deleteArtifact(name: string): boolean;
+    getVisibleArtifacts(agentNickname: string): Artifact[];
+    getId(): string;
+    setId(id: string): void;
+    getStorageDir(): string;
+    setStorageDir(dir: string): void;
+    getRoomStoreService(): any;
+    setRoomStoreService(service: any): void;
+    saveMessages(messages: RoomMessage[]): void;
+    saveMetadata(): string;
+    setOnStateChange(callback: () => void): void;
+    notifyStateChange(): void;
+    setOnError(callback: (error: Error) => void): void;
+    private notifyError;
+    getHumanAgentName(): string;
+    getModeratorAgent(): Agent | undefined;
+    getSituation(): string;
+    setSituation(situation: string): void;
+    setOnSituationUpdate(callback: (situation: string) => void): void;
+    private handleSituationUpdate;
+    handlePublishMessages(messages: RoomMessage[]): void;
+    handleExecuteMessages(messages: RoomMessage[]): void;
+    private executeCommand;
+    handleAdjournMessages(messages: RoomMessage[]): void;
+    addPendingMessage(message: RoomMessage, clearQueue?: boolean): void;
+    isProcessingInProgress(): boolean;
+    pause(): void;
+    resume(): void;
+    checkAgentNicknameMatch(existingNickname: string, targetNickname: string): boolean;
+    private handleModeratorResponse;
+    private processPendingMessages;
+    private filterConcurrentMessages;
+}