@2byte/tgbot-framework 1.0.2 → 1.0.4

package/bin/2byte-cli.ts

@@ -63,6 +63,19 @@ generate
     }
   });
 
+generate
+  .command('service <name>')
+  .description('Generate a new API service')
+  .action(async (name) => {
+    try {
+      const command = new GenerateCommand();
+      await command.generateService(name);
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
 generate
   .command('migration <name>')
   .description('Generate a new migration')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2byte/tgbot-framework",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A TypeScript framework for creating Telegram bots with sections-based architecture (Bun optimized)",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -29,7 +29,11 @@
   "author": "2byte",
   "license": "MIT",
   "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
     "dotenv": "^16.6.1",
+    "fs-extra": "^11.3.2",
+    "input": "^1.0.1",
     "inquirer": "^12.9.6",
     "mustache": "^4.2.0",
     "socks": "^2.8.6",
@@ -37,6 +41,7 @@
     "telegram": "^2.26.22"
   },
   "devDependencies": {
+    "@types/bun": "^1.3.1",
     "@types/node": "^20.19.8",
     "bun-types": "^1.2.18",
     "typescript": "^5.8.3"

package/src/cli/GenerateCommand.ts

@@ -27,6 +27,31 @@ export class GenerateCommand {
     console.log(chalk.green(`✅ Created section ${sectionName} at ${sectionPath}`));
   }
 
+  async generateService(name: string): Promise<void> {
+    console.log(chalk.blue(`⚙️  Generating service: ${name}`));
+
+    const currentDir = process.cwd();
+    const servicesDir = path.join(currentDir, 'workflow', 'services');
+    const serviceName = this.formatServiceName(name);
+    const servicePath = path.join(servicesDir, `${serviceName}.ts`);
+
+    // Ensure services directory exists
+    await fs.ensureDir(servicesDir);
+
+    // Check if service already exists
+    if (await fs.pathExists(servicePath)) {
+      console.log(chalk.red(`❌ Service ${serviceName} already exists at ${servicePath}`));
+      return;
+    }
+
+    // Generate service content
+    const template = this.getServiceTemplate(serviceName);
+    await fs.writeFile(servicePath, template);
+
+    console.log(chalk.green(`✅ Created service ${serviceName} at ${servicePath}`));
+    console.log(chalk.yellow(`💡 Service will be automatically loaded from workflow/services directory`));
+  }
+
   async generateMigration(name: string): Promise<void> {
     console.log(chalk.blue(`🗃️  Generating migration: ${name}`));
 
@@ -54,30 +79,34 @@ export class GenerateCommand {
   }
 
   private formatSectionName(name: string): string {
-    return name.charAt(0).toUpperCase() + name.slice(1).toLowerCase();
+    return name.charAt(0).toUpperCase() + name.slice(1);
+  }
+
+  private formatServiceName(name: string): string {
+    // Convert to PascalCase and add "Service" suffix if not present
+    const pascalName = name.charAt(0).toUpperCase() + name.slice(1);
+    return pascalName.endsWith('Service') ? pascalName : `${pascalName}Service`;
   }
 
   private getSectionTemplate(name: string): string {
-    return `import { Section } from "2bytetgbot";
-import { SectionOptions } from "2bytetgbot";
-import { InlineKeyboard } from "2bytetgbot";
+    return `import { Section } from "@2byte/tgbot-framework";
+import { SectionOptions } from "@2byte/tgbot-framework";
+import { InlineKeyboard } from "@2byte/tgbot-framework";
 
 export default class ${name}Section extends Section {
   static command = "${name.toLowerCase()}";
   static description = "${name} section";
   static actionRoutes = {
-    "${name.toLowerCase()}.index": "index",
+    "${name}.index": "index",
   };
   
-  public sectionId = "${name.toLowerCase()}";
+  public sectionId = "${name}";
   private mainInlineKeyboard: InlineKeyboard;
 
   constructor(options: SectionOptions) {
     super(options);
 
-    this.mainInlineKeyboard = this.makeInlineKeyboard([
-      [this.makeInlineButton("🏠 На главную", "home.index")],
-    ]);
+    this.mainInlineKeyboard = this.makeInlineKeyboard().addFootFixedButtons(this.btnHome);
   }
 
   public async up(): Promise<void> {}
@@ -98,6 +127,61 @@ export default class ${name}Section extends Section {
 `;
   }
 
+  private getServiceTemplate(name: string): string {
+    return `import { App } from "@2byte/tgbot-framework";
+import { ApiService } from "@2byte/tgbot-framework";
+
+export default class ${name} extends ApiService {
+
+    constructor(
+        protected app: App,
+        public name: string = "${name}"
+    ) {
+        super(app, name);
+    }
+
+    /**
+     * Setup method called when service is registered
+     * Use this for initialization tasks like setting up connections,
+     * loading configurations, etc.
+     */
+    public async setup(): Promise<void> {
+        // TODO: Add setup logic here
+        this.app.debugLog(\`[\${this.name}] Service setup completed\`);
+        return Promise.resolve();
+    }
+
+    /**
+     * Cleanup method called when service is being destroyed
+     * Use this for cleanup tasks like closing connections,
+     * releasing resources, etc.
+     */
+    public async unsetup(): Promise<void> {
+        // TODO: Add cleanup logic here
+        this.app.debugLog(\`[\${this.name}] Service cleanup completed\`);
+        return Promise.resolve();
+    }
+
+    /**
+     * Main run method for the service
+     * This is where your service's main logic should be implemented
+     */
+    public async run(): Promise<void> {
+        // TODO: Add your service logic here
+        this.app.debugLog(\`[\${this.name}] Service running\`);
+        return Promise.resolve();
+    }
+
+    /**
+     * Example method - you can add your own methods here
+     */
+    // public async exampleMethod(): Promise<void> {
+    //     // Your custom logic
+    // }
+}
+`;
+  }
+
   private getMigrationTemplate(name: string): string {
     return `-- UP
 CREATE TABLE IF NOT EXISTS ${name} (

package/src/cli/TgAccountManager.ts

@@ -0,0 +1,50 @@
+import {
+  TelegramManagerCredentialsDB,
+  TelegramAccountRemote,
+} from "../libs/TelegramAccountControl";
+import { Model } from "../models/Model";
+import Input from "input";
+
+export const manualAdderTgAccount = async () => {
+  const credentialsManager = new TelegramManagerCredentialsDB(Model.getConnection());
+
+  const tgAccountControl = TelegramAccountRemote.init({
+    appId: process.env.TG_APP_ID!,
+    appHash: process.env.TG_APP_HASH!,
+    credetialsManager: credentialsManager,
+  });
+
+  const phone = await Input.text("Введите номер телефона (с кодом страны, например, 79614416445):");
+  
+  await credentialsManager.addCredential({
+    phone,
+  });
+
+  const credentials = await credentialsManager.getCredential(
+    phone
+  );
+
+  if (!credentials) {
+    console.log("Учётная запись с таким номером телефона не найдена.");
+    return;
+  }
+  
+  await tgAccountControl.login(
+    credentials,
+    async () => {
+      console.log("Требуется код подтверждения");
+      return await Input.text("Введите код подтверждения:");
+    },
+    async () => {
+      console.log("Требуется пароль");
+      return await Input.password("Введите пароль:");
+    },
+    async (err: any) => {
+      console.log("Ошибка логина:", err);
+      tgAccountControl.disconnect();
+      throw new Error(err);
+    }
+  );
+
+  tgAccountControl.disconnect();
+};

package/src/core/ApiService.ts

@@ -0,0 +1,21 @@
+import { App } from "./App";
+
+export abstract class ApiService {
+
+    constructor(
+        protected app: App,
+        public name: string
+    ) {}
+
+    async setup(): Promise<void> {
+        // Implement your API logic here
+    }
+
+    async unsetup(): Promise<void> {
+        // Implement your API logic here
+    }
+
+    async run(): Promise<void> {
+        // Implement your API logic here
+    }
+}

package/src/core/ApiServiceManager.ts

@@ -0,0 +1,63 @@
+import { App } from "./App";
+import { ApiService } from "./ApiService";
+import { readdirSync } from "fs";
+
+export class ApiServiceManager {
+  private services: Map<string, ApiService> = new Map();
+
+  constructor(private app: App) {}
+
+  static init(app: App): ApiServiceManager {
+    return new ApiServiceManager(app);
+  }
+
+  async loadServicesFromDirectory(pathDirectory: string): Promise<void> {
+    for (const entry of readdirSync(pathDirectory, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".ts")) {
+        const serviceModule = await import(`${pathDirectory}/${entry.name}`);
+        const ServiceClass = serviceModule.default;
+        const serviceInstance = new ServiceClass(this.app);
+        this.registerService(entry.name.replace(".ts", ""), serviceInstance);
+      }
+    }
+  }
+
+  public registerService(name: string, service: ApiService): void {
+    this.services.set(name, service);
+  }
+
+  public getService(name: string): ApiService | undefined {
+    return this.services.get(name);
+  }
+
+  public async setupService(name: string): Promise<void> {
+    const service = this.getService(name);
+    if (service) {
+      await service.setup();
+    }
+  }
+
+  public async unsetupService(name: string): Promise<void> {
+    const service = this.getService(name);
+    if (service) {
+      await service.unsetup();
+    }
+  }
+
+  public async runService(name: string): Promise<void> {
+    const service = this.getService(name);
+    if (service) {
+      await service.run();
+    }
+  }
+
+  public getAll(): Map<string, ApiService> {
+    return this.services;
+  }
+
+  public async unsetupAllServices(): Promise<void> {
+    for (const [name, service] of this.services) {
+      await service.unsetup();
+    }
+  }
+}

package/src/core/App.ts

@@ -1,6 +1,10 @@
 import { Telegraf, Markup } from "telegraf";
 import path from "node:path";
-import { Telegraf2byteContext, Telegraf2byteContextExtraMethods } from "../illumination/Telegraf2byteContext";
+import { access } from "fs/promises";
+import {
+  Telegraf2byteContext,
+  Telegraf2byteContextExtraMethods,
+} from "../illumination/Telegraf2byteContext";
 import { Section } from "../illumination/Section";
 import { RunSectionRoute } from "../illumination/RunSectionRoute";
 import { UserModel } from "../user/UserModel";
@@ -15,6 +19,7 @@ import {
   UserRegistrationData,
 } from "../types";
 import { nameToCapitalize } from "./utils";
+import { ApiServiceManager } from "./ApiServiceManager";
 
 export class App {
   private config: AppConfig = {
@@ -36,13 +41,15 @@ export class App {
     terminateSigInt: true,
     terminateSigTerm: true,
     keepSectionInstances: false,
+    botCwd: process.cwd(),
   };
 
-  private bot!: Telegraf<Telegraf2byteContext>;
+  public bot!: Telegraf<Telegraf2byteContext>;
   private sectionClasses: Map<string, typeof Section> = new Map();
   private runnedSections: WeakMap<UserModel, RunnedSection | Map<string, RunnedSection>> =
     new WeakMap();
   private middlewares: CallableFunction[] = [];
+  private apiServiceManager!: ApiServiceManager;
 
   // Система управления фоновыми задачами
   private runningTasks: Map<
@@ -58,10 +65,10 @@ export class App {
       controller?: {
         signal: AbortSignal;
         sendMessage: (message: string) => Promise<void>;
-        onMessage: (handler: (message: string, source: 'task' | 'external') => void) => void;
+        onMessage: (handler: (message: string, source: "task" | "external") => void) => void;
         receiveMessage: (message: string) => Promise<void>;
       };
-      messageQueue?: Array<{ message: string; source: 'task' | 'external' }>;
+      messageQueue?: Array<{ message: string; source: "task" | "external" }>;
     }
   > = new Map();
 
@@ -169,6 +176,11 @@ export class App {
       return this;
     }
 
+    botCwd(cwdPath: string): this {
+      this.app.config.botCwd = cwdPath;
+      return this;
+    }
+
     build(): App {
       return this.app;
     }
@@ -197,6 +209,7 @@ export class App {
     this.registerHears();
     this.registerCommands();
     this.registerMessageHandlers();
+    await this.registerServices();
 
     return this;
   }
@@ -241,22 +254,52 @@ export class App {
       if (!this.config.userStorage) {
         throw new Error("User storage is not set");
       }
+      
+      let startPayload: string | null = null;
+      let accessKey: string | null = null;
+
+      if (ctx?.message?.text?.startsWith("/start")) {
+        startPayload = ctx?.message?.text?.split(" ")[1] || null;
+        accessKey = startPayload && startPayload.includes("key=") ? startPayload.split("key=")[1] || null : null;
+      }
 
+      // Check access by username and register user if not exists
       if (!this.config.userStorage.exists(tgUsername)) {
-        if (!this.config.accessPublic) {
+        const isAuthByUsername = !this.config.accessPublic && !accessKey;
+
+        // check access by username for private bots
+        if (isAuthByUsername) {
           const requestUsername = this.getTgUsername(ctx);
           this.debugLog("Private access mode. Checking username:", requestUsername);
-          const checkAccess = this.config.envConfig.ACCESS_USERNAMES && this.config.envConfig.ACCESS_USERNAMES.split(",").map(name => name.trim());
-          if (checkAccess && checkAccess.every(name => name !== requestUsername)) {
+          const checkAccess =
+            this.config.envConfig.ACCESS_USERNAMES &&
+            this.config.envConfig.ACCESS_USERNAMES.split(",").map((name) => name.trim());
+          if (
+            checkAccess &&
+            checkAccess.every((name) => name.toLowerCase() !== requestUsername.toLowerCase())
+          ) {
             return ctx.reply("Access denied. Your username is not in the access list.");
           }
+          this.debugLog("Username access granted.");
+        }
+        
+        // check access keys for private bots
+        if (!isAuthByUsername && accessKey) {
+          this.debugLog("Private access mode. Checking access key in start payload.");
+          const accessKeys =
+            this.config.envConfig.BOT_ACCESS_KEYS &&
+            this.config.envConfig.BOT_ACCESS_KEYS.split(",").map((key) => key.trim());
+          if (accessKeys && accessKeys.every((key) => key.toLowerCase() !== accessKey?.toLowerCase())) {
+            return ctx.reply("Access denied. Your access key is not valid.");
+          }
+          this.debugLog("Access key granted.");
         }
 
         if (!ctx.from) {
           return ctx.reply("User information is not available");
         }
 
-        const userRefIdFromStart = ctx.startPayload ? parseInt(ctx.startPayload) : 0;
+        const userRefIdFromStart = startPayload ? parseInt(startPayload) : 0;
 
         await this.registerUser({
           user_refid: userRefIdFromStart,
@@ -264,9 +307,9 @@ export class App {
           tg_username: tgUsername,
           tg_first_name: ctx.from.first_name || tgUsername,
           tg_last_name: ctx.from.last_name || "",
-          role: 'user',
+          role: "user",
           language: ctx.from.language_code || "en",
-        })
+        });
       }
 
       ctx.user = this.config.userStorage.find(tgUsername);
@@ -312,7 +355,7 @@ export class App {
         const sectionId = actionPathParts[0];
 
         let sectionClass = this.sectionClasses.get(sectionId);
-        
+
         if (!sectionClass) {
           throw new Error(`Section class not found for sectionId ${sectionId}`);
         }
@@ -320,7 +363,9 @@ export class App {
         const method = sectionClass.actionRoutes[actionPath];
 
         if (!method) {
-          throw new Error(`Method ${actionPath} not found in section ${sectionId}`);
+          throw new Error(
+            `Action ${actionPath} method ${method} not found in section ${sectionId}`
+          );
         }
 
         const sectionRoute = new RunSectionRoute()
@@ -339,10 +384,9 @@ export class App {
     // Register hears
     Object.entries(this.config.hears).forEach(([key, sectionMethod]) => {
       this.bot.hears(key, async (ctx: Telegraf2byteContext) => {
-        
         const [sectionId, method] = sectionMethod.split(".");
         const sectionRoute = new RunSectionRoute().section(sectionId).method(method).hearsKey(key);
-        
+
         this.debugLog(`Hears matched: ${key}, running section ${sectionId}, method ${method}`);
 
         this.runSection(ctx, sectionRoute).catch((err) => {
@@ -381,6 +425,48 @@ export class App {
     });
   }
 
+  private async registerServices() {
+    this.apiServiceManager = ApiServiceManager.init(this);
+
+    const registerServices = async (pathDirectory: string) => {
+      try {
+        await this.apiServiceManager.loadServicesFromDirectory(pathDirectory);
+      } catch (error) {
+        this.debugLog("Error loading services:", error);
+        throw error;
+      }
+
+      this.debugLog(
+        "Registered API services:%s in dir: %s",
+        Array.from(this.apiServiceManager.getAll().keys()),
+        pathDirectory
+      );
+
+      for (const [name, service] of this.apiServiceManager.getAll()) {
+        await service.setup();
+        this.debugLog(`Service ${name} setup completed`);
+        await service.run();
+        this.debugLog(`Service ${name} run completed`);
+      }
+    };
+
+    // Register services from bot directory
+    await registerServices(this.config.botCwd + "/workflow/services");
+    // Register services from framework directory
+    await registerServices(path.resolve(__dirname, "../workflow/services"));
+  }
+
+  private async unregisterServices() {
+    this.apiServiceManager = ApiServiceManager.init(this);
+
+    try {
+      this.apiServiceManager.unsetupAllServices();
+    } catch (error) {
+      this.debugLog("Error unsetting up services:", error);
+      throw error;
+    }
+  }
+
   private async handleUserInput(
     ctx: Telegraf2byteContext,
     inputValue: any,
@@ -417,6 +503,7 @@ export class App {
           delete ctx.userSession.awaitingInputPromise;
           // Разрешаем Promise
           resolve(inputValue);
+          ctx.deleteLastMessage();
         } else {
           // Увеличиваем счетчик попыток
           awaitingPromise.retryCount = retryCount + 1;
@@ -628,13 +715,20 @@ export class App {
     let pathSectionModule =
       sectionParams.pathModule ??
       path.join(process.cwd(), "./sections/" + nameToCapitalize(sectionId) + "Section");
- 
-    this.debugLog('Path to section module: ', pathSectionModule);
-    
+
+    this.debugLog("Path to section module: ", pathSectionModule);
+
+    // Check if file exists
+    try {
+      await access(pathSectionModule + ".ts");
+    } catch {
+      throw new Error(`Section ${sectionId} not found at path ${pathSectionModule}.ts`);
+    }
+
     if (freshVersion) {
       pathSectionModule += "?update=" + Date.now();
     }
-    
+
     const sectionClass = (await import(pathSectionModule)).default;
 
     this.debugLog("Loaded section", sectionId);
@@ -650,8 +744,10 @@ export class App {
       try {
         this.sectionClasses.set(sectionId, await this.loadSection(sectionId));
       } catch (err) {
-        this.debugLog('Error stack:', err instanceof Error ? err.stack : 'No stack available');
-        throw new Error(`Failed to load section ${sectionId}: ${err instanceof Error ? err.message : err}`);
+        this.debugLog("Error stack:", err instanceof Error ? err.stack : "No stack available");
+        throw new Error(
+          `Failed to load section ${sectionId}: ${err instanceof Error ? err.message : err}`
+        );
       }
     }
   }
@@ -752,7 +848,9 @@ export class App {
       if (sectionInstalled) {
         this.debugLog(`[Setup] Section ${sectionId} install for user ${ctx.user.username}`);
         await sectionInstance.setup();
-        this.debugLog(`[Setup finish] Section ${sectionId} installed for user ${ctx.user.username}`);
+        this.debugLog(
+          `[Setup finish] Section ${sectionId} installed for user ${ctx.user.username}`
+        );
       }
     }
 
@@ -812,6 +910,7 @@ export class App {
 
       if (this.config.userStorage) {
         this.config.userStorage.add(data.tg_username, user);
+        this.debugLog('User added to storage:', data.tg_username);
       }
 
       return user;
@@ -833,7 +932,7 @@ export class App {
     task: (controller: {
       signal: AbortSignal;
       sendMessage: (message: string) => Promise<void>;
-      onMessage: (handler: (message: string, source: 'task' | 'external') => void) => void;
+      onMessage: (handler: (message: string, source: "task" | "external") => void) => void;
     }) => Promise<any>,
     options: {
       taskId?: string;
@@ -859,8 +958,8 @@ export class App {
     const abortController = new AbortController();
 
     // Message handling setup
-    const messageHandlers: ((message: string, source: 'task' | 'external') => void)[] = [];
-    const messageQueue: Array<{ message: string; source: 'task' | 'external' }> = [];
+    const messageHandlers: ((message: string, source: "task" | "external") => void)[] = [];
+    const messageQueue: Array<{ message: string; source: "task" | "external" }> = [];
 
     // Create task controller interface
     const taskController = {
@@ -870,23 +969,25 @@ export class App {
         if (!silent) {
           await ctx.reply(`[Задача ${taskId}]: ${message}`).catch(console.error);
         }
-        messageQueue.push({ message, source: 'task' });
-        messageHandlers.forEach(handler => handler(message, 'task'));
+        messageQueue.push({ message, source: "task" });
+        messageHandlers.forEach((handler) => handler(message, "task"));
       },
       // Handle incoming messages to task
-      onMessage: (handler: (message: string, source: 'task' | 'external') => void) => {
+      onMessage: (handler: (message: string, source: "task" | "external") => void) => {
         messageHandlers.push(handler);
         // Process any queued messages
         messageQueue.forEach(({ message, source }) => handler(message, source));
       },
       // Receive message from external source
       receiveMessage: async (message: string) => {
-        messageQueue.push({ message, source: 'external' });
-        messageHandlers.forEach(handler => handler(message, 'external'));
+        messageQueue.push({ message, source: "external" });
+        messageHandlers.forEach((handler) => handler(message, "external"));
         if (!silent) {
-          await ctx.reply(`[Внешнее сообщение для задачи ${taskId}]: ${message}`).catch(console.error);
+          await ctx
+            .reply(`[Внешнее сообщение для задачи ${taskId}]: ${message}`)
+            .catch(console.error);
         }
-      }
+      },
     };
 
     // Send start notification if enabled
@@ -907,7 +1008,7 @@ export class App {
       startTime: Date.now(),
       ctx,
       controller: taskController,
-      messageQueue
+      messageQueue,
     });
 
     // Handle task completion and errors

package/src/illumination/InlineKeyboard.ts

@@ -22,7 +22,7 @@ export class InlineKeyboard {
     return this;
   }
 
-  append(row: any[] | any[][]): InlineKeyboard {
+  append(row: any[] | any[][] | any): InlineKeyboard {
     if (!Array.isArray(row)) {
       this.keyboard.push([row]);
     } else if (Array.isArray(row[0])) {
@@ -51,6 +51,7 @@ export class InlineKeyboard {
       keyboard.push(...this.footFixedButtons);
     }
     
+    this.keyboard = [];
     return keyboard;
   }