tgbox 0.0.0-stage → 1.0.0

package/fileService.js

@@ -0,0 +1,155 @@
+const fs = require('fs');
+
+class FileService {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async upload(filePath, targetChat = 'me') {
+    try {
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found at path: ${filePath}`);
+      }
+
+      const result = await this.client.sendFile(targetChat, {
+        file: filePath,
+        workers: 2,
+      });
+
+      return {
+        success: true,
+        messageId: result.id,
+        fileName: filePath.split(/[\\/]/).pop(),
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async download(messageId, outputPath, targetChat = 'me') {
+    try {
+      const messages = await this.client.getMessages(targetChat, {
+        ids: [messageId],
+      });
+
+      if (!messages || messages.length === 0) {
+        throw new Error('Message not found.');
+      }
+
+      await this.client.downloadMedia(messages[0], {
+        outputFile: outputPath,
+      });
+
+      return { success: true, path: outputPath };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async deleteFile(messageId, targetChat = 'me') {
+    const messageIds = Array.isArray(messageId) ? messageId : [messageId];
+    if (
+      messageIds.length === 0 ||
+      messageIds.some((id) => !Number.isInteger(Number(id)) || Number(id) <= 0)
+    ) {
+      return { success: false, error: 'A valid file message ID is required.' };
+    }
+
+    try {
+      await this.client.deleteMessages(
+        targetChat,
+        messageIds.map(Number),
+        { revoke: true },
+      );
+
+      return { success: true, messageIds: messageIds.map(Number) };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async listFiles(targetChat = 'me') {
+    try {
+      const files = [];
+
+      for await (const message of this.client.iterMessages(targetChat, {
+        limit: 0,
+      })) {
+        if (!message.document) {
+          continue;
+        }
+
+        const fileNameAttribute = message.document.attributes.find(
+          (attribute) => attribute.className === 'DocumentAttributeFilename',
+        );
+
+        files.push({
+          messageId: message.id,
+          fileName: fileNameAttribute ? fileNameAttribute.fileName : null,
+          size: Number(message.document.size),
+          mimeType: message.document.mimeType,
+          date: message.date,
+          caption: message.message || null,
+          telegram: {
+            message: message.toJSON(),
+            document: message.document.toJSON(),
+          },
+        });
+      }
+
+      return { success: true, files };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async searchFiles(query, targetChat = 'me') {
+    if (typeof query !== 'string' || query.trim() === '') {
+      return { success: false, error: 'Search query must not be empty.' };
+    }
+
+    const result = await this.listFiles(targetChat);
+    if (!result.success) {
+      return result;
+    }
+
+    const normalizedQuery = query.trim().toLowerCase();
+    const files = result.files.filter((file) => {
+      const fileName = file.fileName || '';
+      const caption = file.caption || '';
+      const messageId = String(file.messageId);
+      return (
+        messageId === normalizedQuery ||
+        `${fileName} ${caption}`.toLowerCase().includes(normalizedQuery)
+      );
+    });
+
+    return { success: true, files };
+  }
+
+  async findFile(identifier, targetChat = 'me') {
+    if (typeof identifier !== 'string' && typeof identifier !== 'number') {
+      return { success: false, error: 'File ID or name is required.' };
+    }
+
+    const query = String(identifier).trim();
+    if (!query) {
+      return { success: false, error: 'File ID or name must not be empty.' };
+    }
+
+    const result = await this.listFiles(targetChat);
+    if (!result.success) {
+      return result;
+    }
+
+    const files = result.files.filter(
+      (item) =>
+        String(item.messageId) === query ||
+        (item.fileName && item.fileName.toLowerCase() === query.toLowerCase()),
+    );
+
+    return { success: true, files };
+  }
+}
+
+module.exports = FileService;

package/index.js

@@ -0,0 +1,69 @@
+const { TelegramClient } = require('telegram');
+const { StringSession } = require('telegram/sessions');
+const input = require('input');
+const fs = require('fs');
+const FileService = require('./fileService');
+
+class TgBox {
+  constructor(apiId, apiHash, sessionFilePath = 'session.txt') {
+    if (!apiId || !apiHash) {
+      throw new Error('TgBox requires apiId and apiHash.');
+    }
+    this.apiId = Number(apiId);
+    this.apiHash = apiHash;
+    this.sessionFilePath = sessionFilePath;
+    this.fileService = null;
+
+    let savedSession = '';
+    if (fs.existsSync(this.sessionFilePath)) {
+      savedSession = fs.readFileSync(this.sessionFilePath, 'utf8').trim();
+    }
+
+    this.stringSession = new StringSession(savedSession);
+  }
+
+  async init() {
+    this.client = new TelegramClient(this.stringSession, this.apiId, this.apiHash, {
+      connectionRetries: 5,
+    });
+    this.fileService = new FileService(this.client);
+
+    await this.client.start({
+      phoneNumber: async () => await input.text('[INFO] Type your phonenumber in: '),
+      password: async () => await input.text('[INFO] 2FA Code: '),
+      phoneCode: async () => await input.text('[INFO] Telegram code: '),
+      onError: (err) => console.log("[ERROR] " + err),
+    });
+
+    console.log('[INFO] Successfully logged in!');
+
+
+    const currentSession = this.client.session.save();
+    fs.writeFileSync(this.sessionFilePath, currentSession);
+  }
+  async upload(filePath, targetChat = 'me') {
+    return this.fileService.upload(filePath, targetChat);
+  }
+  
+  async download(messageId, outputPath, targetChat = 'me') {
+    return this.fileService.download(messageId, outputPath, targetChat);
+  }
+
+  async deleteFile(messageId, targetChat = 'me') {
+    return this.fileService.deleteFile(messageId, targetChat);
+  }
+
+  async listFiles(targetChat = 'me') {
+    return this.fileService.listFiles(targetChat);
+  }
+
+  async searchFiles(query, targetChat = 'me') {
+    return this.fileService.searchFiles(query, targetChat);
+  }
+
+  async findFile(identifier, targetChat = 'me') {
+    return this.fileService.findFile(identifier, targetChat);
+  }
+}
+
+module.exports = TgBox;

package/package.json

@@ -1,6 +1,28 @@
 {
   "name": "tgbox",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "A lightweight free cloud storage solution using Telegram as backend.",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "fileService.js"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "telegram",
+    "storage",
+    "cloud",
+    "backup",
+    "files"
+  ],
+  "author": "Dein Name",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.7.9",
+    "form-data": "^4.0.1",
+    "input": "^1.0.1",
+    "telegram": "^2.26.22"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.