briyah 1.0.0

package/dist/server/src/ai/attached-file.service.js

@@ -0,0 +1,253 @@
+"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.AttachedFileService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const configuration_service_1 = require("../config/configuration.service");
+let AttachedFileService = class AttachedFileService {
+    configService;
+    attachedFilesDir;
+    constructor(configService) {
+        this.configService = configService;
+        this.attachedFilesDir = this.configService.getUploadDir();
+        if (!fs.existsSync(this.attachedFilesDir)) {
+            fs.mkdirSync(this.attachedFilesDir, { recursive: true });
+        }
+    }
+    getMetadataPath(ownerId) {
+        return path.join(this.getOwnerDirectory(ownerId), 'metadata.json');
+    }
+    storeFile(ownerId, fileName, fileData, additionalMetadata = {}) {
+        const existingMetadata = this.getFileMetadataByName(ownerId, fileName);
+        if (existingMetadata) {
+            console.log(`File "${fileName}" already exists for owner ${ownerId}, returning existing fileId: ${existingMetadata.fileId}`);
+            if (Object.keys(additionalMetadata).length > 0) {
+                this.updateFileMetadata(ownerId, existingMetadata.fileId, additionalMetadata);
+            }
+            return existingMetadata.fileId;
+        }
+        const ownerDir = this.getOwnerDirectory(ownerId);
+        if (!fs.existsSync(ownerDir)) {
+            fs.mkdirSync(ownerDir, { recursive: true });
+        }
+        const fileId = (0, crypto_1.randomUUID)();
+        const filePath = path.join(ownerDir, fileId);
+        fs.writeFileSync(filePath, Buffer.from(fileData));
+        const metadataPath = this.getMetadataPath(ownerId);
+        let metadataMap = {};
+        if (fs.existsSync(metadataPath)) {
+            try {
+                metadataMap = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+            }
+            catch (error) {
+                console.error('Error loading file metadata:', error);
+            }
+        }
+        const metadata = {
+            fileName,
+            fileId,
+            uploadDate: new Date().toISOString(),
+            size: fileData.length,
+            ...additionalMetadata,
+        };
+        metadataMap[fileId] = metadata;
+        fs.writeFileSync(metadataPath, JSON.stringify(metadataMap, null, 2));
+        return fileId;
+    }
+    getFile(ownerId, fileId) {
+        const filePath = path.join(this.getOwnerDirectory(ownerId), fileId);
+        if (!fs.existsSync(filePath)) {
+            return null;
+        }
+        const stats = fs.statSync(filePath);
+        if (!stats.isFile()) {
+            return null;
+        }
+        return new Uint8Array(fs.readFileSync(filePath));
+    }
+    getFileByName(ownerId, fileName) {
+        const fileId = this.getFileIdByName(ownerId, fileName);
+        if (!fileId) {
+            return null;
+        }
+        return this.getFile(ownerId, fileId);
+    }
+    updateFileMetadata(ownerId, fileId, metadataUpdates) {
+        const metadataPath = this.getMetadataPath(ownerId);
+        if (!fs.existsSync(metadataPath)) {
+            return false;
+        }
+        try {
+            const metadataMap = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+            if (!metadataMap[fileId]) {
+                return false;
+            }
+            metadataMap[fileId] = {
+                ...metadataMap[fileId],
+                ...metadataUpdates,
+            };
+            fs.writeFileSync(metadataPath, JSON.stringify(metadataMap, null, 2));
+            return true;
+        }
+        catch (error) {
+            console.error('Error updating file metadata:', error);
+            return false;
+        }
+    }
+    getFileMetadata(ownerId, fileId) {
+        const metadataPath = this.getMetadataPath(ownerId);
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+        try {
+            const metadataMap = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+            return metadataMap[fileId] || null;
+        }
+        catch (error) {
+            console.error('Error getting file metadata:', error);
+            return null;
+        }
+    }
+    getFileMetadataByName(ownerId, fileName) {
+        const metadataPath = this.getMetadataPath(ownerId);
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+        try {
+            const metadataMap = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+            for (const fileId in metadataMap) {
+                if (metadataMap[fileId].fileName === fileName) {
+                    return metadataMap[fileId];
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error getting file metadata by name:', error);
+        }
+        return null;
+    }
+    getFileIdByName(ownerId, fileName) {
+        const metadata = this.getFileMetadataByName(ownerId, fileName);
+        return metadata ? metadata.fileId : null;
+    }
+    listFileMetadata(ownerId) {
+        const metadataPath = this.getMetadataPath(ownerId);
+        if (!fs.existsSync(metadataPath)) {
+            return [];
+        }
+        try {
+            const metadataMap = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+            return Object.values(metadataMap);
+        }
+        catch (error) {
+            console.error('Error listing file metadata:', error);
+            return [];
+        }
+    }
+    listFiles(ownerId) {
+        return this.listFileMetadata(ownerId).map((metadata) => metadata.fileName);
+    }
+    deleteFile(ownerId, fileId) {
+        const ownerDir = this.getOwnerDirectory(ownerId);
+        const filePath = path.join(ownerDir, fileId);
+        const metadataPath = path.join(ownerDir, 'metadata.json');
+        if (!fs.existsSync(filePath)) {
+            return false;
+        }
+        fs.unlinkSync(filePath);
+        if (fs.existsSync(metadataPath)) {
+            try {
+                const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+                if (metadata[fileId]) {
+                    delete metadata[fileId];
+                    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+                }
+            }
+            catch (error) {
+                console.error('Error updating file metadata:', error);
+            }
+        }
+        return true;
+    }
+    deleteFileByName(ownerId, fileName) {
+        const fileId = this.getFileIdByName(ownerId, fileName);
+        if (!fileId) {
+            return false;
+        }
+        return this.deleteFile(ownerId, fileId);
+    }
+    deleteAllFiles(ownerId) {
+        const ownerDir = this.getOwnerDirectory(ownerId);
+        if (!fs.existsSync(ownerDir)) {
+            return false;
+        }
+        this.deleteDirectory(ownerDir);
+        return true;
+    }
+    getOwnerDirectory(ownerId) {
+        return path.join(this.attachedFilesDir, ownerId);
+    }
+    deleteDirectory(dirPath) {
+        if (fs.existsSync(dirPath)) {
+            fs.readdirSync(dirPath).forEach((file) => {
+                const curPath = path.join(dirPath, file);
+                if (fs.lstatSync(curPath).isDirectory()) {
+                    this.deleteDirectory(curPath);
+                }
+                else {
+                    fs.unlinkSync(curPath);
+                }
+            });
+            fs.rmdirSync(dirPath);
+        }
+    }
+};
+exports.AttachedFileService = AttachedFileService;
+exports.AttachedFileService = AttachedFileService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [configuration_service_1.ConfigurationService])
+], AttachedFileService);

package/dist/server/src/ai/model_prices.d.ts

@@ -0,0 +1,2 @@
+declare let modelPrices: any;
+export default modelPrices;

package/dist/server/src/ai/model_prices.js

@@ -0,0 +1,54 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const dataDir = path.resolve(process.cwd(), 'data');
+const configDir = path.resolve(dataDir, 'common', 'config');
+const pricesFilePath = path.join(configDir, 'model_prices.json');
+let modelPrices = {};
+try {
+    if (fs.existsSync(pricesFilePath)) {
+        const fileContent = fs.readFileSync(pricesFilePath, 'utf8');
+        modelPrices = JSON.parse(fileContent);
+    }
+    else {
+        console.warn('Model prices file not found at', pricesFilePath);
+    }
+}
+catch (error) {
+    console.error('Error loading model prices:', error);
+}
+exports.default = modelPrices;

package/dist/server/src/ai/published-agents.service.d.ts

@@ -0,0 +1,13 @@
+import { OnModuleInit } from '@nestjs/common';
+export declare class PublishedAgentsService implements OnModuleInit {
+    private mapping;
+    private readonly mappingFile;
+    constructor();
+    onModuleInit(): void;
+    getUserId(agentId: string): string | undefined;
+    addPublishedAgent(agentId: string, userId: string): void;
+    removePublishedAgent(agentId: string): void;
+    isAgentPublished(agentId: string): boolean;
+    private load;
+    private save;
+}

package/dist/server/src/ai/published-agents.service.js

@@ -0,0 +1,118 @@
+"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.PublishedAgentsService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let PublishedAgentsService = class PublishedAgentsService {
+    mapping = new Map();
+    mappingFile;
+    constructor() {
+        const dataPath = process.env.SERVER_DATA_PATH || path.resolve(process.cwd(), 'data');
+        const dataDir = path.resolve(dataPath, 'common');
+        if (!fs.existsSync(dataDir)) {
+            fs.mkdirSync(dataDir, { recursive: true });
+        }
+        this.mappingFile = path.join(dataDir, 'published-agents.json');
+    }
+    onModuleInit() {
+        this.load();
+    }
+    getUserId(agentId) {
+        return this.mapping.get(agentId);
+    }
+    addPublishedAgent(agentId, userId) {
+        this.mapping.set(agentId, userId);
+        this.save();
+    }
+    removePublishedAgent(agentId) {
+        this.mapping.delete(agentId);
+        this.save();
+    }
+    isAgentPublished(agentId) {
+        return this.mapping.has(agentId);
+    }
+    load() {
+        try {
+            if (!fs.existsSync(this.mappingFile)) {
+                console.log('[PublishedAgentsService] No published agents file found, starting fresh');
+                this.mapping = new Map();
+                this.save();
+                return;
+            }
+            const data = fs.readFileSync(this.mappingFile, 'utf-8');
+            const parsed = JSON.parse(data);
+            if (parsed.mapping && typeof parsed.mapping === 'object') {
+                this.mapping = new Map(Object.entries(parsed.mapping));
+            }
+            else {
+                throw new Error('Invalid file format');
+            }
+        }
+        catch (error) {
+            console.error('[PublishedAgentsService] Error loading published agents:', error);
+            console.log('[PublishedAgentsService] Starting with empty mapping');
+            this.mapping = new Map();
+            this.save();
+        }
+    }
+    save() {
+        try {
+            const data = {
+                mapping: Object.fromEntries(this.mapping),
+                version: 1,
+            };
+            fs.writeFileSync(this.mappingFile, JSON.stringify(data, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error('[PublishedAgentsService] Error saving published agents:', error);
+        }
+    }
+};
+exports.PublishedAgentsService = PublishedAgentsService;
+exports.PublishedAgentsService = PublishedAgentsService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], PublishedAgentsService);

package/dist/server/src/app/balance-message.service.d.ts

@@ -0,0 +1,8 @@
+import { EventEmitter } from 'events';
+export declare class BalanceMessageService {
+    private messageEmitters;
+    getOrCreateEmitter(userId: string): EventEmitter;
+    getEmitter(userId: string): EventEmitter | undefined;
+    emitUpdate(userId: string, balance: number): void;
+    cleanup(userId: string): void;
+}

package/dist/server/src/app/balance-message.service.js

@@ -0,0 +1,45 @@
+"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.BalanceMessageService = void 0;
+const common_1 = require("@nestjs/common");
+const events_1 = require("events");
+let BalanceMessageService = class BalanceMessageService {
+    messageEmitters = new Map();
+    getOrCreateEmitter(userId) {
+        let emitter = this.messageEmitters.get(userId);
+        if (!emitter) {
+            emitter = new events_1.EventEmitter();
+            this.messageEmitters.set(userId, emitter);
+        }
+        return emitter;
+    }
+    getEmitter(userId) {
+        return this.messageEmitters.get(userId);
+    }
+    emitUpdate(userId, balance) {
+        const emitter = this.messageEmitters.get(userId);
+        if (emitter) {
+            emitter.emit('update', {
+                timestamp: Date.now(),
+                balance,
+            });
+        }
+    }
+    cleanup(userId) {
+        const emitter = this.messageEmitters.get(userId);
+        if (emitter) {
+            emitter.removeAllListeners();
+            this.messageEmitters.delete(userId);
+        }
+    }
+};
+exports.BalanceMessageService = BalanceMessageService;
+exports.BalanceMessageService = BalanceMessageService = __decorate([
+    (0, common_1.Injectable)()
+], BalanceMessageService);

package/dist/server/src/app/balance.module.d.ts

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

package/dist/server/src/app/balance.module.js

@@ -0,0 +1,20 @@
+"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.BalanceModule = void 0;
+const common_1 = require("@nestjs/common");
+const balance_message_service_1 = require("./balance-message.service");
+let BalanceModule = class BalanceModule {
+};
+exports.BalanceModule = BalanceModule;
+exports.BalanceModule = BalanceModule = __decorate([
+    (0, common_1.Module)({
+        providers: [balance_message_service_1.BalanceMessageService],
+        exports: [balance_message_service_1.BalanceMessageService],
+    })
+], BalanceModule);

package/dist/server/src/app/balance.service.d.ts

@@ -0,0 +1,18 @@
+import { ConfigurationService } from '../config/configuration.service';
+import { BalanceMessageService } from './balance-message.service';
+export declare class BalanceService {
+    private userId;
+    private configService;
+    private balanceFilePath;
+    private markupFilePath;
+    private startingBalance;
+    private balanceMessageService?;
+    constructor(userId: string, configService: ConfigurationService, balanceMessageService?: BalanceMessageService);
+    getBalance(): number;
+    getMarkup(): number;
+    hasSufficientBalance(): boolean;
+    decrementBalance(amount: number, markup?: number): void;
+    addBalance(amount: number): void;
+    private saveBalance;
+    private saveMarkup;
+}