基本配置#

1. 创建对应文件夹，拉取项目

   1
   mkdir -p /docker_data/nfd_bot && cd docker_data/nfd_bot && git clone https://github.com/LloydAsp/nfd.git src
   

2. 添加pachage.json文件

   1
   cat << EOF > package.json
   2
   {
   3
     "name": "nfd-bot",
   4
     "version": "1.0.0",
   5
     "description": "Telegram message forwarding bot with anti-fraud features",
   6
     "main": "src/index.js",
   7
     "scripts": {
   8
       "start": "node src/index.js",
   9
       "dev": "nodemon src/index.js"
   10
     },
   11
     "dependencies": {
   12
       "axios": "^1.4.0",
   13
       "body-parser": "^1.20.2",
   14
       "express": "^4.18.2",
   15
       "sqlite3": "^5.1.6",
   16
       "sqlite": "^4.2.1"
   17
     },
   18
     "devDependencies": {
   19
       "nodemon": "^2.0.22"
   20
     }
   21
   }
   22
   EOF
   

3. 创建Dockerfile

   1
   cat << EOF > Dockerfile
   2
   FROM node:16-alpine
   3
   
   4
   WORKDIR /app
   5
   
   6
   COPY package.json ./
   7
   RUN npm install
   8
   
   9
   COPY . .
   10
   
   11
   EXPOSE 3000
   12
   
   13
   CMD ["npm", "start"]
   14
   EOF
   

4. 创建docker-compose.yaml和.env文件

   1
   cat << EOF > Dockerfile
   2
   services:
   3
     nfd-bot:
   4
       build: .
   5
       container_name: nfd-bot
   6
       restart: always
   7
       ports:
   8
         - "${PORT:-3000}:3000"
   9
       environment:
   10
         - BOT_TOKEN=${BOT_TOKEN}
   11
         - BOT_SECRET=${BOT_SECRET}
   12
         - ADMIN_UID=${ADMIN_UID}
   13
         - PORT=3000
   14
         - BASE_URL=${BASE_URL}
   15
       volumes:
   16
         - ./src/data:/app/src/data
   17
       network_mode: bridge
   18
   EOF
   

   1
   BOT_TOKEN='替换为你自己的Bot Token （Bot Father获取）'
   2
   BOT_SECRET='UUID生成或替换为你自己的强密码'
   3
   ADMIN_UID=访问https://t.me/myidbot获取你自己账户的id
   4
   BASE_URL=https://example.com/tg # 注意最后不要加'/'
   5
   PORT=65035 # 替换你自己的端口
   

   UUID生成

5. 创建src/index.js，nano src/index.js

   1
   const express = require('express');
   2
   const bodyParser = require('body-parser');
   3
   const axios = require('axios');
   4
   const fs = require('fs');
   5
   const path = require('path');
   6
   const sqlite3 = require('sqlite3');
   7
   const { open } = require('sqlite');
   8
   
   9
   const app = express();
   10
   app.use(bodyParser.json());
   11
   
   12
   // 从环境变量获取配置
   13
   const TOKEN = process.env.BOT_TOKEN;
   14
   const SECRET = process.env.BOT_SECRET;
   15
   const ADMIN_UID = process.env.ADMIN_UID;
   16
   const PORT = process.env.PORT || 3000;
   17
   const WEBHOOK_PATH = process.env.WEBHOOK_PATH || '/endpoint';
   18
   const NOTIFY_INTERVAL = 3600 * 1000;
   19
   const enable_notification = true;
   20
   
   21
   // 数据文件路径
   22
   const FRAUD_DB_PATH = path.join(__dirname, 'data/fraud.db');
   23
   const NOTIFICATION_PATH = path.join(__dirname, 'data/notification.txt');
   24
   const START_MSG_PATH = path.join(__dirname, 'data/startMessage.md');
   25
   const DB_PATH = path.join(__dirname, 'data/nfd.sqlite');
   26
   
   27
   // SQLite 数据库连接
   28
   let db;
   29
   
   30
   // 初始化数据库
   31
   async function initDatabase() {
   32
     db = await open({
   33
       filename: DB_PATH,
   34
       driver: sqlite3.Database
   35
     });
   36
   
   37
     // 创建表
   38
     await db.exec(`
   39
       CREATE TABLE IF NOT EXISTS kv_store (
   40
         key TEXT PRIMARY KEY,
   41
         value TEXT,
   42
         timestamp INTEGER
   43
       )
   44
     `);
   45
   
   46
     console.log('Database initialized');
   47
   }
   48
   
   49
   // 封装 KV 操作的函数
   50
   async function kvGet(key) {
   51
     const row = await db.get('SELECT value FROM kv_store WHERE key = ?', [key]);
   52
     return row ? JSON.parse(row.value) : null;
   53
   }
   54
   
   55
   async function kvPut(key, value) {
   56
     const jsonValue = JSON.stringify(value);
   57
     await db.run(
   58
       'INSERT OR REPLACE INTO kv_store (key, value, timestamp) VALUES (?, ?, ?)',
   59
       [key, jsonValue, Date.now()]
   60
     );
   61
   }
   62
   
   63
   /**
   64
    * 返回 Telegram API URL
   65
    */
   66
   function apiUrl(methodName, params = null) {
   67
     let query = '';
   68
     if (params) {
   69
       const searchParams = new URLSearchParams();
   70
       Object.entries(params).forEach(([key, value]) => {
   71
         searchParams.append(key, value);
   72
       });
   73
       query = '?' + searchParams.toString();
   74
     }
   75
     return `https://api.telegram.org/bot${TOKEN}/${methodName}${query}`;
   76
   }
   77
   
   78
   /**
   79
    * 向 Telegram API 发送请求
   80
    */
   81
   async function requestTelegram(methodName, body, params = null) {
   82
     try {
   83
       const response = await axios.post(apiUrl(methodName, params), body);
   84
       return response.data;
   85
     } catch (error) {
   86
       console.error(`Error calling Telegram API ${methodName}:`, error.message);
   87
       return { ok: false, error: error.message };
   88
     }
   89
   }
   90
   
   91
   function makeReqBody(body) {
   92
     return body;
   93
   }
   94
   
   95
   function sendMessage(msg = {}) {
   96
     return requestTelegram('sendMessage', makeReqBody(msg));
   97
   }
   98
   
   99
   function copyMessage(msg = {}) {
   100
     return requestTelegram('copyMessage', makeReqBody(msg));
   101
   }
   102
   
   103
   function forwardMessage(msg) {
   104
     return requestTelegram('forwardMessage', makeReqBody(msg));
   105
   }
   106
   
   107
   /**
   108
    * 处理 webhook 请求
   109
    */
   110
   app.post(WEBHOOK_PATH, async (req, res) => {
   111
     // 验证 secret token
   112
     if (req.headers['x-telegram-bot-api-secret-token'] !== SECRET) {
   113
       return res.status(403).send('Unauthorized');
   114
     }
   115
   
   116
     const update = req.body;
   117
   
   118
     // 异步处理 update
   119
     onUpdate(update).catch(err => {
   120
       console.error('Error processing update:', err);
   121
     });
   122
   
   123
     return res.status(200).send('Ok');
   124
   });
   125
   
   126
   /**
   127
    * 处理传入的 Update
   128
    */
   129
   async function onUpdate(update) {
   130
     if ('message' in update) {
   131
       await onMessage(update.message);
   132
     }
   133
   }
   134
   
   135
   /**
   136
    * 处理传入的 Message
   137
    */
   138
   async function onMessage(message) {
   139
     if (message.text === '/start') {
   140
       let startMsg = await readFile(START_MSG_PATH);
   141
       return sendMessage({
   142
         chat_id: message.chat.id,
   143
         text: startMsg,
   144
       });
   145
     }
   146
   
   147
     if (message.chat.id.toString() === ADMIN_UID) {
   148
       if (!message?.reply_to_message?.chat) {
   149
         return sendMessage({
   150
           chat_id: ADMIN_UID,
   151
           text: '使用方法，回复转发的消息，并发送回复消息，或者`/block`、`/unblock`、`/checkblock`等指令'
   152
         });
   153
       }
   154
   
   155
       if (/^\/block$/.exec(message.text)) {
   156
         return handleBlock(message);
   157
       }
   158
   
   159
       if (/^\/unblock$/.exec(message.text)) {
   160
         return handleUnBlock(message);
   161
       }
   162
   
   163
       if (/^\/checkblock$/.exec(message.text)) {
   164
         return checkBlock(message);
   165
       }
   166
   
   167
       let guestChantId = await kvGet(`msg-map-${message?.reply_to_message.message_id}`);
   168
       return copyMessage({
   169
         chat_id: guestChantId,
   170
         from_chat_id: message.chat.id,
   171
         message_id: message.message_id,
   172
       });
   173
     }
   174
   
   175
     return handleGuestMessage(message);
   176
   }
   177
   
   178
   async function handleGuestMessage(message) {
   179
     let chatId = message.chat.id;
   180
     let isblocked = await kvGet(`isblocked-${chatId}`);
   181
   
   182
     if (isblocked) {
   183
       return sendMessage({
   184
         chat_id: chatId,
   185
         text: 'Your are blocked'
   186
       });
   187
     }
   188
   
   189
     let forwardReq = await forwardMessage({
   190
       chat_id: ADMIN_UID,
   191
       from_chat_id: message.chat.id,
   192
       message_id: message.message_id
   193
     });
   194
   
   195
     console.log(JSON.stringify(forwardReq));
   196
   
   197
     if (forwardReq.ok) {
   198
       await kvPut(`msg-map-${forwardReq.result.message_id}`, chatId);
   199
     }
   200
   
   201
     return handleNotify(message);
   202
   }
   203
   
   204
   async function handleNotify(message) {
   205
     // 先判断是否是诈骗人员，如果是，则直接提醒
   206
     // 如果不是，则根据时间间隔提醒：用户id，交易注意点等
   207
     let chatId = message.chat.id;
   208
   
   209
     if (await isFraud(chatId)) {
   210
       return sendMessage({
   211
         chat_id: ADMIN_UID,
   212
         text: `检测到骗子，UID${chatId}`
   213
       });
   214
     }
   215
   
   216
     if (enable_notification) {
   217
       let lastMsgTime = await kvGet(`lastmsg-${chatId}`);
   218
   
   219
       if (!lastMsgTime || Date.now() - lastMsgTime > NOTIFY_INTERVAL) {
   220
         await kvPut(`lastmsg-${chatId}`, Date.now());
   221
   
   222
         return sendMessage({
   223
           chat_id: ADMIN_UID,
   224
           text: await readFile(NOTIFICATION_PATH)
   225
         });
   226
       }
   227
     }
   228
   }
   229
   
   230
   async function handleBlock(message) {
   231
     let guestChantId = await kvGet(`msg-map-${message.reply_to_message.message_id}`);
   232
   
   233
     if (guestChantId === ADMIN_UID) {
   234
       return sendMessage({
   235
         chat_id: ADMIN_UID,
   236
         text: '不能屏蔽自己'
   237
       });
   238
     }
   239
   
   240
     await kvPut(`isblocked-${guestChantId}`, true);
   241
   
   242
     return sendMessage({
   243
       chat_id: ADMIN_UID,
   244
       text: `UID:${guestChantId}屏蔽成功`,
   245
     });
   246
   }
   247
   
   248
   async function handleUnBlock(message) {
   249
     let guestChantId = await kvGet(`msg-map-${message.reply_to_message.message_id}`);
   250
     await kvPut(`isblocked-${guestChantId}`, false);
   251
   
   252
     return sendMessage({
   253
       chat_id: ADMIN_UID,
   254
       text: `UID:${guestChantId}解除屏蔽成功`,
   255
     });
   256
   }
   257
   
   258
   async function checkBlock(message) {
   259
     let guestChantId = await kvGet(`msg-map-${message.reply_to_message.message_id}`);
   260
     let blocked = await kvGet(`isblocked-${guestChantId}`);
   261
   
   262
     return sendMessage({
   263
       chat_id: ADMIN_UID,
   264
       text: `UID:${guestChantId}` + (blocked ? '被屏蔽' : '没有被屏蔽')
   265
     });
   266
   }
   267
   
   268
   /**
   269
    * 发送纯文本消息
   270
    */
   271
   async function sendPlainText(chatId, text) {
   272
     return sendMessage({
   273
       chat_id: chatId,
   274
       text
   275
     });
   276
   }
   277
   
   278
   /**
   279
    * 设置 webhook
   280
    */
   281
   app.get('/registerWebhook', async (req, res) => {
   282
     const BASE_URL = process.env.BASE_URL || `http://localhost:${PORT}`;
   283
     const webhookUrl = `${BASE_URL}${WEBHOOK_PATH}`;
   284
   
   285
     try {
   286
       const r = await axios.get(apiUrl('setWebhook', {
   287
         url: webhookUrl,
   288
         secret_token: SECRET
   289
       }));
   290
   
   291
       if (r.data.ok) {
   292
         return res.send('Webhook registered successfully');
   293
       } else {
   294
         return res.status(400).send(JSON.stringify(r.data, null, 2));
   295
       }
   296
     } catch (error) {
   297
       return res.status(500).send(`Error: ${error.message}`);
   298
     }
   299
   });
   300
   
   301
   /**
   302
    * 删除 webhook
   303
    */
   304
   app.get('/unRegisterWebhook', async (req, res) => {
   305
     try {
   306
       const r = await axios.get(apiUrl('setWebhook', { url: '' }));
   307
   
   308
       if (r.data.ok) {
   309
         return res.send('Webhook unregistered successfully');
   310
       } else {
   311
         return res.status(400).send(JSON.stringify(r.data, null, 2));
   312
       }
   313
     } catch (error) {
   314
       return res.status(500).send(`Error: ${error.message}`);
   315
     }
   316
   });
   317
   
   318
   /**
   319
    * 检查是否是骗子
   320
    */
   321
   async function isFraud(id) {
   322
     id = id.toString();
   323
     const fraudDb = await readFile(FRAUD_DB_PATH);
   324
     let arr = fraudDb.split('\n').filter(v => v);
   325
     console.log(JSON.stringify(arr));
   326
     let flag = arr.filter(v => v === id).length !== 0;
   327
     console.log(flag);
   328
     return flag;
   329
   }
   330
   
   331
   /**
   332
    * 读取文件辅助函数
   333
    */
   334
   function readFile(filePath) {
   335
     return new Promise((resolve, reject) => {
   336
       fs.readFile(filePath, 'utf8', (err, data) => {
   337
         if (err) {
   338
           console.error(`Error reading file ${filePath}:`, err);
   339
           reject(err);
   340
         } else {
   341
           resolve(data);
   342
         }
   343
       });
   344
     });
   345
   }
   346
   
   347
   // 启动服务器
   348
   async function startServer() {
   349
     // 初始化数据库
   350
     await initDatabase();
   351
   
   352
     // 启动 Express 服务器
   353
     app.listen(PORT, () => {
   354
       console.log(`NFD Bot server running on port ${PORT}`);
   355
       console.log(`Webhook path: ${WEBHOOK_PATH}`);
   356
     });
   357
   }
   358
   
   359
   // 启动应用
   360
   startServer().catch(err => {
   361
     console.error('Failed to start server:', err);
   362
     process.exit(1);
   363
   });
   

6. 启动服务

   1
   docker compose up -d