@liberstudio/cloudflare-list 2.4.6 → 2.4.8

package/README.md

@@ -76,7 +76,7 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
       excludedPaths: ["/api/health", "/api/webhook"],
       silentPaths:   ["/auth/me", "/auth/refresh"],
       verbose: false,
-      whatsappNotify: { phone: "393331234567" },
+      telegramNotify: { chatId: "123456789" },
     }),
   ],
 })
@@ -103,9 +103,10 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
         excludedPaths: ["/api/health", "/api/webhook", /^\/api\/public\/.*/],
         silentPaths:   ["/auth/me", "/auth/refresh"],
         verbose: false,
-        whatsappNotify: {
-          phone: config.getOrThrow<string>("WA_NOTIFY_PHONE"),
+        telegramNotify: {
+          chatId: config.getOrThrow<string>("TELEGRAM_NOTIFY_CHAT_ID"),
         },
+        notifyProvider: config.get<"whatsapp" | "telegram">("NOTIFY_PROVIDER"), // assente → scelta automatica
       }),
     }),
   ],
@@ -129,6 +130,35 @@ export class AppModule {}
 | `silentPaths` | `(string \| RegExp)[]` | no | Path bloccati su Cloudflare ma senza log su file |
 | `verbose` | `boolean` | no | Se `true`, il log include body, query, params e stack |
 | `whatsappNotify` | `{ phone: string }` | no | Invia una notifica WhatsApp quando un IP viene bannato |
+| `telegramNotify` | `{ chatId: string }` | no | Invia una notifica Telegram quando un IP viene bannato |
+| `notifyProvider` | `"whatsapp" \| "telegram"` | no | Canale di notifica da usare (default: vedi sotto) |
+
+### `notifyProvider` — scelta del canale di notifica
+
+Ad ogni ban viene inviata **una sola** notifica, sul canale scelto:
+
+- se `notifyProvider` è impostato, si usa quel canale;
+- altrimenti si usa **WhatsApp** solo se è configurato del tutto (`whatsappNotify` + le 4 variabili `WA_*`), in ogni altro caso **Telegram**.
+
+Se il canale scelto non è configurato (es. `telegramNotify` assente) la notifica viene saltata.
+
+### `telegramNotify` — notifiche ban su Telegram
+
+Invia il messaggio di ban tramite un bot Telegram. Il token del bot è letto da `process.env.TELEGRAM_BOT_TOKEN`.
+
+```typescript
+telegramNotify: {
+  chatId: "123456789", // id della chat, del gruppo (es. "-100...") o "@nomecanale"
+}
+```
+
+Per ricavare il `chatId`: scrivi un messaggio al bot (o aggiungilo al gruppo), poi apri `https://api.telegram.org/bot<TOKEN>/getUpdates` e leggi `message.chat.id`.
+
+```env
+TELEGRAM_BOT_TOKEN=123456:ABC-your-bot-token
+TELEGRAM_NOTIFY_CHAT_ID=123456789
+NOTIFY_PROVIDER=telegram   # opzionale: whatsapp | telegram
+```
 
 ### `whatsappNotify` — notifiche ban su WhatsApp
 

package/dist/attacks.service.d.ts

@@ -8,6 +8,9 @@ export declare class AttacksService {
     private readonly ASN_LOOKUP_URL;
     constructor(httpService: HttpService, options: CloudflareAttacksOptions);
     blockIp(rawIp: string): Promise<CloudflareResponse | null>;
+    private sendNotification;
+    private isWhatsappConfigured;
+    private sendTelegramNotification;
     private sendWhatsappNotification;
     private lookupAsnRange;
     updateIpList(cidr: string): Promise<CloudflareResponse>;

package/dist/attacks.service.js

@@ -47,7 +47,7 @@ let AttacksService = class AttacksService {
         if (asnRange && !(await (0, utils_1.googleBotOverlapsCidr)(asnRange))) {
             this.logger.error(`ASN range trovato per ${rawIp}: ${asnRange} — blocco intera subnet`);
             const result = await this.updateIpList(asnRange);
-            this.sendWhatsappNotification(rawIp, asnRange);
+            this.sendNotification(rawIp, asnRange);
             return result;
         }
         if (asnRange) {
@@ -57,10 +57,37 @@ let AttacksService = class AttacksService {
         if (!cidr)
             throw new Error(`IP non valido: ${rawIp}`);
         const result = await this.updateIpList(cidr);
-        this.sendWhatsappNotification(rawIp, cidr);
+        this.sendNotification(rawIp, cidr);
         return result;
     }
-    sendWhatsappNotification(rawIp, cidr) {
+    sendNotification(rawIp, cidr) {
+        const message = `🚨 IP bannato su Cloudflare\nProvenienza: ${this.options.comment}\nIP: ${rawIp}\nSubnet bloccata: ${cidr}`;
+        const provider = this.options.notifyProvider ?? (this.isWhatsappConfigured() ? "whatsapp" : "telegram");
+        if (provider === "whatsapp")
+            this.sendWhatsappNotification(message);
+        else
+            this.sendTelegramNotification(message);
+    }
+    isWhatsappConfigured() {
+        const env = process.env;
+        return !!(this.options.whatsappNotify && env["WA_URL"] && env["WA_USER"] && env["WA_PASSWORD"] && env["CLOUDFLARE_WA_DEVICE_ID"]);
+    }
+    sendTelegramNotification(message) {
+        const tg = this.options.telegramNotify;
+        if (!tg)
+            return;
+        const token = process.env["TELEGRAM_BOT_TOKEN"];
+        if (!token) {
+            this.logger.warn("Notifica Telegram saltata: TELEGRAM_BOT_TOKEN mancante");
+            return;
+        }
+        (0, rxjs_1.firstValueFrom)(this.httpService.post(`https://api.telegram.org/bot${token}/sendMessage`, { chat_id: tg.chatId, text: message })).catch((err) => {
+            const msg = err instanceof Error ? err.message : "Errore sconosciuto";
+            const description = axios_2.default.isAxiosError(err) ? err.response?.data?.description : undefined;
+            this.logger.warn(`Notifica Telegram fallita: ${msg}${description ? ` (${description})` : ""}`);
+        });
+    }
+    sendWhatsappNotification(message) {
         const wa = this.options.whatsappNotify;
         if (!wa)
             return;
@@ -73,7 +100,6 @@ let AttacksService = class AttacksService {
             return;
         }
         const auth = Buffer.from(`${user}:${password}`).toString("base64");
-        const message = `🚨 IP bannato su Cloudflare\nProvenienza: ${this.options.comment}\nIP: ${rawIp}\nSubnet bloccata: ${cidr}`;
         (0, rxjs_1.firstValueFrom)(this.httpService.post(`${url}/send/message`, { phone: wa.phone, message }, { headers: { Authorization: `Basic ${auth}`, "X-Device-Id": deviceId } })).catch((err) => {
             const msg = err instanceof Error ? err.message : "Errore sconosciuto";
             this.logger.warn(`Notifica WhatsApp fallita: ${msg}`);

package/dist/interfaces/cloudflare-attacks.interface.d.ts

@@ -1,6 +1,10 @@
 export interface WhatsappNotifyOptions {
     phone: string;
 }
+export interface TelegramNotifyOptions {
+    chatId: string;
+}
+export type NotifyProvider = "whatsapp" | "telegram";
 export interface CloudflareAttacksOptions {
     apiToken: string;
     accountId: string;
@@ -12,6 +16,8 @@ export interface CloudflareAttacksOptions {
     silentPaths?: (string | RegExp)[];
     verbose?: boolean;
     whatsappNotify?: WhatsappNotifyOptions;
+    telegramNotify?: TelegramNotifyOptions;
+    notifyProvider?: NotifyProvider;
 }
 export interface CloudflareAttacksAsyncOptions {
     imports?: any[];

package/dist/middleware/attack-logger.middleware.js

@@ -53,11 +53,19 @@ let AttackLoggerMiddleware = AttackLoggerMiddleware_1 = class AttackLoggerMiddle
         if (!ip || this.isThrottled(ip))
             return;
         const silent = this.isSilent(req.url);
+        // Provenienza reale della richiesta: serve a capire se è passata dalla zona Cloudflare
+        // (cf-ray assente → accesso diretto all'origin; host inatteso → altro hostname/zona)
+        const origin = {
+            remoteAddress: req.socket.remoteAddress ?? "unknown",
+            host: this.sanitize(req.headers.host ?? "-"),
+            cfRay: this.sanitize(String(req.headers["cf-ray"] ?? "-")),
+        };
         if (!silent) {
             const entry = {
                 timestamp: new Date().toISOString(),
                 type: "ATTACK",
                 ip,
+                ...origin,
                 method: req.method,
                 url: this.sanitize(req.url),
                 ...(this.options.verbose && {
@@ -77,6 +85,7 @@ let AttackLoggerMiddleware = AttackLoggerMiddleware_1 = class AttackLoggerMiddle
             this.logger.warn(`IP non valido: ${ip}`);
             return;
         }
+        this.logger.warn(`Provenienza ${ip}: socket=${origin.remoteAddress} host=${origin.host} cf-ray=${origin.cfRay}`);
         this.attSrv.blockIp(ip).catch((err) => {
             const msg = err instanceof Error ? err.message : "Errore sconosciuto";
             this.logger.error(`Aggiornamento Cloudflare fallito: ${msg}`);

package/dist/utils/options.validator.js

@@ -11,4 +11,8 @@ function validateOptions(opzioni) {
             throw new Error(`CloudflareAttacksOptions.${campo} deve essere una stringa non vuota`);
         }
     }
+    const provider = opzioni.notifyProvider;
+    if (provider !== undefined && provider !== "whatsapp" && provider !== "telegram") {
+        throw new Error(`CloudflareAttacksOptions.notifyProvider deve essere "whatsapp" o "telegram"`);
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liberstudio/cloudflare-list",
-  "version": "2.4.6",
+  "version": "2.4.8",
   "description": "Modulo NestJS per gestione IP List Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,19 +25,19 @@
     "pre-commit": "[ -f \"$HOME/.bashrc\" ] && \\. \"$HOME/.bashrc\"; export NVM_DIR=\"$HOME/.nvm\"; [ -s \"$NVM_DIR/nvm.sh\" ] && \\. \"$NVM_DIR/nvm.sh\"; npm run version:bump && git add package.json package-lock.json"
   },
   "peerDependencies": {
-    "@nestjs/axios": ">=3.0.0",
-    "@nestjs/common": ">=10.4.3",
-    "@nestjs/core": ">=10.4.3",
+    "@nestjs/axios": "^3.0.0 || ^4.0.0 || ^12.0.0",
+    "@nestjs/common": "^10.4.3 || ^11.0.0 || ^12.0.0",
+    "@nestjs/core": "^10.4.3 || ^11.0.0 || ^12.0.0",
     "axios": ">=1.18.0",
     "rxjs": ">=7.0.0"
   },
   "devDependencies": {
-    "@nestjs/axios": "^4.0.1",
-    "@nestjs/common": "^11.1.27",
-    "@nestjs/core": "^11.1.27",
+    "@nestjs/axios": "^12.0.1",
+    "@nestjs/common": "^12.4.0",
+    "@nestjs/core": "^12.4.0",
     "@types/express": "^5.0.6",
     "@types/node": "^20.19.43",
-    "axios": "^1.18.0",
+    "axios": "^1.21.0",
     "rxjs": "^7.8.2",
     "simple-git-hooks": "^2.13.1",
     "typescript": "^5.0.0"