briyah 1.0.0

package/dist/auth/twilio.service.js

@@ -0,0 +1,139 @@
+"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;
+};
+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.TwilioService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+let TwilioService = class TwilioService {
+    configService;
+    TWILIO_ACCOUNT_SID;
+    TWILIO_AUTH_TOKEN;
+    TWILIO_API_URL;
+    TWILIO_PHONE;
+    TWILIO_VERIFY_SID;
+    constructor(configService) {
+        this.configService = configService;
+        this.TWILIO_ACCOUNT_SID = this.configService.get('TWILIO_ACCOUNT_SID');
+        this.TWILIO_AUTH_TOKEN = this.configService.get('TWILIO_AUTH_TOKEN');
+        this.TWILIO_API_URL = this.configService.get('TWILIO_API_URL');
+        this.TWILIO_PHONE = this.configService.get('TWILIO_PHONE');
+        this.TWILIO_VERIFY_SID = this.configService.get('TWILIO_VERIFY_SID');
+        if (process.env.NODE_ENV === 'production' && process.env.TEST_MODE === 'true') {
+            throw new Error('TEST_MODE cannot be enabled in production environment');
+        }
+    }
+    async sendVerification(to, channel = 'sms') {
+        if (this.isTestMode() && this.isTestPhoneNumber(to)) {
+            console.log(`[TEST MODE] Skipping OTP send for test number: ${to}`);
+            return { status: 'pending', to: `+1${to}` };
+        }
+        const dialPrefix = '+1';
+        const toPhone = dialPrefix + to;
+        const url = `https://verify.twilio.com/v2/Services/${this.TWILIO_VERIFY_SID}/Verifications`;
+        const params = new URLSearchParams();
+        params.append('To', toPhone);
+        params.append('Channel', channel);
+        const auth = Buffer.from(`${this.TWILIO_ACCOUNT_SID}:${this.TWILIO_AUTH_TOKEN}`).toString('base64');
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Authorization: `Basic ${auth}`,
+                },
+                body: params,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to send verification: ${error.message}`);
+        }
+    }
+    async checkVerification(to, code) {
+        if (this.isTestMode() && this.isTestPhoneNumber(to)) {
+            if (code.length === 6 && /^\d{6}$/.test(code)) {
+                console.log(`[TEST MODE] Accepting test code for: ${to}`);
+                return { status: 'approved', valid: true };
+            }
+            console.log(`[TEST MODE] Rejecting invalid test code format for: ${to}`);
+            return { status: 'pending', valid: false };
+        }
+        const dialPrefix = '+1';
+        const toPhone = dialPrefix + to;
+        const url = `https://verify.twilio.com/v2/Services/${this.TWILIO_VERIFY_SID}/VerificationCheck`;
+        const params = new URLSearchParams();
+        params.append('To', toPhone);
+        params.append('Code', code);
+        const auth = Buffer.from(`${this.TWILIO_ACCOUNT_SID}:${this.TWILIO_AUTH_TOKEN}`).toString('base64');
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Authorization: `Basic ${auth}`,
+                },
+                body: params,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to check verification: ${error.message}`);
+        }
+    }
+    async sendSms(to, body) {
+        const dialPrefix = '+1';
+        const toPhone = dialPrefix + to;
+        const url = `${this.TWILIO_API_URL}/${this.TWILIO_ACCOUNT_SID}/Messages.json`;
+        const params = new URLSearchParams();
+        params.append('To', toPhone);
+        params.append('From', this.TWILIO_PHONE);
+        params.append('Body', body);
+        const auth = Buffer.from(`${this.TWILIO_ACCOUNT_SID}:${this.TWILIO_AUTH_TOKEN}`).toString('base64');
+        try {
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Authorization: `Basic ${auth}`,
+                },
+                body: params,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            throw new Error(`Failed to send SMS: ${error.message}`);
+        }
+    }
+    isTestMode() {
+        return process.env.TEST_MODE === 'true' || process.env.NODE_ENV === 'test';
+    }
+    isTestPhoneNumber(phoneNumber) {
+        const normalized = phoneNumber.replace(/^\+1/, '');
+        return normalized.startsWith('555');
+    }
+};
+exports.TwilioService = TwilioService;
+exports.TwilioService = TwilioService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [config_1.ConfigService])
+], TwilioService);

package/dist/auth/users.service.d.ts

@@ -0,0 +1,24 @@
+import { OnModuleInit } from '@nestjs/common';
+interface User {
+    userId: string;
+    phoneNumber: string;
+    phoneVerified: boolean;
+    createdAt: string;
+}
+interface UsersData {
+    [userId: string]: Omit<User, 'userId'>;
+}
+export declare class UsersService implements OnModuleInit {
+    private readonly usersFilePath;
+    private readonly dataDir;
+    constructor();
+    onModuleInit(): void;
+    loadUsers(): UsersData;
+    saveUsers(users: UsersData): void;
+    generateUserId(): string;
+    createUser(phoneNumber: string): string | null;
+    findUser(userId: string): User | null;
+    deleteUser(userId: string): void;
+    findUserByPhone(phoneNumber: string): User | null;
+}
+export {};

package/dist/auth/users.service.js

@@ -0,0 +1,149 @@
+"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.UsersService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const uuid_1 = require("uuid");
+let UsersService = class UsersService {
+    usersFilePath;
+    dataDir;
+    constructor() {
+        this.dataDir = path.resolve(process.cwd(), 'data');
+        const commonDir = path.resolve(this.dataDir, 'common');
+        const usersDir = path.resolve(commonDir, 'users');
+        this.usersFilePath = path.resolve(usersDir, 'users.json');
+    }
+    onModuleInit() {
+        const usersDir = path.dirname(this.usersFilePath);
+        if (!fs.existsSync(usersDir)) {
+            fs.mkdirSync(usersDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.usersFilePath)) {
+            fs.writeFileSync(this.usersFilePath, JSON.stringify({}), 'utf-8');
+        }
+        console.log('UsersService initialized with phone/OTP authentication');
+    }
+    loadUsers() {
+        try {
+            const data = fs.readFileSync(this.usersFilePath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (_error) {
+            return {};
+        }
+    }
+    saveUsers(users) {
+        fs.writeFileSync(this.usersFilePath, JSON.stringify(users, null, 2), 'utf-8');
+    }
+    generateUserId() {
+        return (0, uuid_1.v4)();
+    }
+    createUser(phoneNumber) {
+        const users = this.loadUsers();
+        if (this.findUserByPhone(phoneNumber)) {
+            return null;
+        }
+        const userId = this.generateUserId();
+        users[userId] = {
+            phoneNumber,
+            phoneVerified: true,
+            createdAt: new Date().toISOString(),
+        };
+        const userDir = path.resolve(this.dataDir, 'user', userId);
+        if (!fs.existsSync(userDir)) {
+            fs.mkdirSync(userDir, { recursive: true });
+        }
+        this.saveUsers(users);
+        return userId;
+    }
+    findUser(userId) {
+        const users = this.loadUsers();
+        const userData = users[userId];
+        if (!userData) {
+            return null;
+        }
+        return {
+            userId,
+            ...userData,
+        };
+    }
+    deleteUser(userId) {
+        const users = this.loadUsers();
+        if (!users[userId]) {
+            return;
+        }
+        delete users[userId];
+        this.saveUsers(users);
+        try {
+            const userDir = path.resolve(this.dataDir, 'user', userId);
+            if (fs.existsSync(userDir)) {
+                fs.rmSync(userDir, { recursive: true, force: true });
+                console.log(`Deleted user directory: ${userDir}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error deleting user directory for ${userId}:`, error);
+        }
+        console.log(`User ${userId} deleted successfully`);
+    }
+    findUserByPhone(phoneNumber) {
+        const users = this.loadUsers();
+        for (const [userId, userData] of Object.entries(users)) {
+            if (userData.phoneNumber === phoneNumber) {
+                return {
+                    userId,
+                    ...userData,
+                };
+            }
+        }
+        return null;
+    }
+};
+exports.UsersService = UsersService;
+exports.UsersService = UsersService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], UsersService);

package/dist/common/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class NotFoundError extends Error {
+    constructor(message: string);
+}
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
+export declare class OperationFailedError extends Error {
+    constructor(message: string);
+}
+export declare class InsufficientBalanceError extends Error {
+    constructor(message: string);
+}

package/dist/common/errors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsufficientBalanceError = exports.OperationFailedError = exports.ValidationError = exports.NotFoundError = void 0;
+class NotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NotFoundError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, NotFoundError);
+        }
+    }
+}
+exports.NotFoundError = NotFoundError;
+class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ValidationError);
+        }
+    }
+}
+exports.ValidationError = ValidationError;
+class OperationFailedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'OperationFailedError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, OperationFailedError);
+        }
+    }
+}
+exports.OperationFailedError = OperationFailedError;
+class InsufficientBalanceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InsufficientBalanceError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, InsufficientBalanceError);
+        }
+    }
+}
+exports.InsufficientBalanceError = InsufficientBalanceError;

package/dist/config/configuration.module.d.ts

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

package/dist/config/configuration.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.ConfigurationModule = void 0;
+const common_1 = require("@nestjs/common");
+const configuration_service_1 = require("./configuration.service");
+let ConfigurationModule = class ConfigurationModule {
+};
+exports.ConfigurationModule = ConfigurationModule;
+exports.ConfigurationModule = ConfigurationModule = __decorate([
+    (0, common_1.Module)({
+        providers: [configuration_service_1.ConfigurationService],
+        exports: [configuration_service_1.ConfigurationService],
+    })
+], ConfigurationModule);

package/dist/config/configuration.service.d.ts

@@ -0,0 +1,26 @@
+export declare class ConfigurationService {
+    private dataDir;
+    private credsDir;
+    private promptsDir;
+    private commonPromptsDir;
+    private userPromptsDir;
+    private uploadDir;
+    private userConfigDir;
+    private commonConfigDir;
+    private userDataDir;
+    private userId;
+    constructor(userId: string, baseDataPath?: string);
+    getDataDir(): string;
+    getCredsDir(): string;
+    getPromptsDir(): string;
+    getUploadDir(): string;
+    getUserConfigDir(): string;
+    getCommonConfigDir(): string;
+    store(configName: string, data: string): void;
+    load(configName: string): string | null;
+    exists(configName: string): boolean;
+    getCommonPromptsDir(): string;
+    getUserPromptsDir(): string;
+    getUserDataDir(): string;
+    getUserId(): string;
+}

package/dist/config/configuration.service.js

@@ -0,0 +1,131 @@
+"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 });
+exports.ConfigurationService = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ConfigurationService {
+    dataDir;
+    credsDir;
+    promptsDir;
+    commonPromptsDir;
+    userPromptsDir;
+    uploadDir;
+    userConfigDir;
+    commonConfigDir;
+    userDataDir;
+    userId;
+    constructor(userId, baseDataPath) {
+        this.userId = userId;
+        const dataPath = baseDataPath || process.env.SERVER_DATA_PATH || path.resolve(process.cwd(), 'data');
+        this.dataDir = path.resolve(dataPath);
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+        const commonDir = path.resolve(this.dataDir, 'common');
+        this.credsDir = path.resolve(commonDir, 'creds');
+        if (!fs.existsSync(this.credsDir)) {
+            fs.mkdirSync(this.credsDir, { recursive: true });
+        }
+        this.commonConfigDir = path.resolve(commonDir, 'config');
+        if (!fs.existsSync(this.commonConfigDir)) {
+            fs.mkdirSync(this.commonConfigDir, { recursive: true });
+        }
+        this.commonPromptsDir = path.resolve(commonDir, 'prompts');
+        if (!fs.existsSync(this.commonPromptsDir)) {
+            fs.mkdirSync(this.commonPromptsDir, { recursive: true });
+        }
+        this.userDataDir = path.resolve(this.dataDir, 'user', this.userId);
+        this.userPromptsDir = path.resolve(this.userDataDir, 'prompts');
+        if (!fs.existsSync(this.userPromptsDir)) {
+            fs.mkdirSync(this.userPromptsDir, { recursive: true });
+        }
+        this.uploadDir = path.resolve(this.userDataDir, 'upload');
+        if (!fs.existsSync(this.uploadDir)) {
+            fs.mkdirSync(this.uploadDir, { recursive: true });
+        }
+        this.userConfigDir = path.resolve(this.userDataDir, 'userconfig');
+        if (!fs.existsSync(this.userConfigDir)) {
+            fs.mkdirSync(this.userConfigDir, { recursive: true });
+        }
+        this.promptsDir = this.userPromptsDir;
+    }
+    getDataDir() {
+        return this.dataDir;
+    }
+    getCredsDir() {
+        return this.credsDir;
+    }
+    getPromptsDir() {
+        return this.promptsDir;
+    }
+    getUploadDir() {
+        return this.uploadDir;
+    }
+    getUserConfigDir() {
+        return this.userConfigDir;
+    }
+    getCommonConfigDir() {
+        return this.commonConfigDir;
+    }
+    store(configName, data) {
+        const configPath = path.join(this.getUserConfigDir(), configName);
+        fs.writeFileSync(configPath, data);
+    }
+    load(configName) {
+        const configPath = path.join(this.getUserConfigDir(), configName);
+        if (!fs.existsSync(configPath)) {
+            return null;
+        }
+        return fs.readFileSync(configPath, 'utf8');
+    }
+    exists(configName) {
+        const configPath = path.join(this.getUserConfigDir(), configName);
+        return fs.existsSync(configPath);
+    }
+    getCommonPromptsDir() {
+        return this.commonPromptsDir;
+    }
+    getUserPromptsDir() {
+        return this.userPromptsDir;
+    }
+    getUserDataDir() {
+        return this.userDataDir;
+    }
+    getUserId() {
+        return this.userId;
+    }
+}
+exports.ConfigurationService = ConfigurationService;