@liberstudio/cloudflare-list 2.4.7 → 3.0.0

package/README.md

@@ -47,6 +47,8 @@ Il modulo ignora automaticamente:
    - Action: `Block`
 6. Salvare la regola
 
+Con più account Cloudflare ripetere i passi per ogni account: ognuno ha la sua lista, il suo token e la sua regola WAF.
+
 ---
 
 ## Installazione
@@ -67,9 +69,10 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
 @Module({
   imports: [
     CloudflareAttacksModule.forRoot({
-      accountId: "abc123",
-      listId:    "def456",
-      apiToken:  "your-cloudflare-api-token",
+      accounts: [
+        { accountId: "abc123", listId: "def456", apiToken: "token-account-1" },
+        { accountId: "ghi789", listId: "jkl012", apiToken: "token-account-2" },
+      ],
       comment:   "Blocked by liberstudio/cloudflare-list",
       logPath:   "/var/log/nestjs-attacks.log",
       allowedIps:    ["1.2.3.4", "10.0.0.0/8"],
@@ -94,9 +97,18 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
       imports: [ConfigModule],
       inject:  [ConfigService],
       useFactory: (config: ConfigService) => ({
-        apiToken:  config.getOrThrow<string>("CLOUDFLARE_API_TOKEN"),
-        accountId: config.getOrThrow<string>("CLOUDFLARE_ACCOUNT_ID"),
-        listId:    config.getOrThrow<string>("CLOUDFLARE_LIST_ID"),
+        accounts: [
+          {
+            apiToken:  config.getOrThrow<string>("CLOUDFLARE_API_TOKEN"),
+            accountId: config.getOrThrow<string>("CLOUDFLARE_ACCOUNT_ID"),
+            listId:    config.getOrThrow<string>("CLOUDFLARE_LIST_ID"),
+          },
+          {
+            apiToken:  config.getOrThrow<string>("CLOUDFLARE_2_API_TOKEN"),
+            accountId: config.getOrThrow<string>("CLOUDFLARE_2_ACCOUNT_ID"),
+            listId:    config.getOrThrow<string>("CLOUDFLARE_2_LIST_ID"),
+          },
+        ],
         comment:   config.get<string>("CLOUDFLARE_LIST_COMMENT") || "Blocked",
         logPath:   config.get<string>("CLOUDFLARE_LIST_LOG_PATH") || "/var/log/nestjs-attacks.log",
         allowedIps:    ["1.2.3.4", "10.0.0.0/8"],
@@ -106,6 +118,7 @@ import { CloudflareAttacksModule } from "@liberstudio/cloudflare-list";
         telegramNotify: {
           chatId: config.getOrThrow<string>("TELEGRAM_NOTIFY_CHAT_ID"),
         },
+        notifyProvider: config.get<"whatsapp" | "telegram">("NOTIFY_PROVIDER"), // assente → scelta automatica
       }),
     }),
   ],
@@ -119,9 +132,7 @@ export class AppModule {}
 
 | Opzione | Tipo | Obbligatorio | Descrizione |
 |---|---|---|---|
-| `apiToken` | `string` | si | Token API Cloudflare |
-| `accountId` | `string` | si | ID account Cloudflare |
-| `listId` | `string` | si | ID della IP List Cloudflare |
+| `accounts` | `CloudflareAccount[]` | si | Account Cloudflare su cui bannare (almeno uno), vedi sotto |
 | `comment` | `string` | si | Commento aggiunto ad ogni IP bloccato |
 | `logPath` | `string` | si | Percorso del file di log degli attacchi |
 | `allowedIps` | `string[]` | no | IP o CIDR mai bloccati (whitelist, supporta IPv4 e IPv6) |
@@ -132,6 +143,38 @@ export class AppModule {}
 | `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) |
 
+### `accounts` — ban su più account Cloudflare
+
+Ogni elemento di `accounts` è un `CloudflareAccount`:
+
+| Campo | Tipo | Obbligatorio | Descrizione |
+|---|---|---|---|
+| `apiToken` | `string` | si | Token API Cloudflare con accesso all'account |
+| `accountId` | `string` | si | ID account Cloudflare |
+| `listId` | `string` | si | ID della IP List dell'account |
+
+Ad ogni ban l'IP (o la subnet) viene aggiunto **in parallelo** alle liste di tutti gli account:
+
+- se un account fallisce, l'errore viene loggato con il suo `accountId` e gli altri proseguono;
+- se falliscono **tutti**, `updateIpList()` lancia `HttpException` con il primo errore;
+- `updateIpList()` e `blockIp()` ritornano un `CloudflareResponse[]` con le risposte degli account riusciti.
+
+Se lo stesso token ha accesso a più account, basta ripeterlo in ogni elemento.
+
+### Migrazione dalla 2.x
+
+La 3.0.0 è un breaking change: `apiToken`, `accountId` e `listId` non stanno più alla radice delle opzioni, ma dentro `accounts`.
+
+```typescript
+// 2.x
+{ apiToken: "...", accountId: "...", listId: "...", comment: "...", logPath: "..." }
+
+// 3.x
+{ accounts: [{ apiToken: "...", accountId: "...", listId: "..." }], comment: "...", logPath: "..." }
+```
+
+Inoltre `updateIpList()` ritorna `CloudflareResponse[]` invece di `CloudflareResponse`, e `blockIp()` ritorna `CloudflareResponse[] | null`.
+
 ### `notifyProvider` — scelta del canale di notifica
 
 Ad ogni ban viene inviata **una sola** notifica, sul canale scelto:
@@ -156,6 +199,7 @@ Per ricavare il `chatId`: scrivi un messaggio al bot (o aggiungilo al gruppo), p
 ```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
@@ -174,8 +218,11 @@ Il messaggio inviato sarà:
 Provenienza: Blocked by liberstudio/cloudflare-list
 IP: 1.2.3.4
 Subnet bloccata: 1.2.0.0/16
+Account: 2/2
 ```
 
+`Account` indica su quanti account configurati il ban è andato a buon fine. La notifica è sempre **una** per ban.
+
 Variabili d'ambiente richieste (lette automaticamente da `process.env`):
 ```env
 WA_URL=https://messaggistica.liberdesign.eu

package/dist/attacks.service.d.ts

@@ -7,11 +7,13 @@ export declare class AttacksService {
     private readonly API_URL;
     private readonly ASN_LOOKUP_URL;
     constructor(httpService: HttpService, options: CloudflareAttacksOptions);
-    blockIp(rawIp: string): Promise<CloudflareResponse | null>;
+    blockIp(rawIp: string): Promise<CloudflareResponse[] | null>;
     private sendNotification;
     private isWhatsappConfigured;
     private sendTelegramNotification;
     private sendWhatsappNotification;
     private lookupAsnRange;
-    updateIpList(cidr: string): Promise<CloudflareResponse>;
+    /** Aggiunge il CIDR alle liste di tutti gli account; ritorna le risposte degli account riusciti. */
+    updateIpList(cidr: string): Promise<CloudflareResponse[]>;
+    private addToAccountList;
 }

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.sendNotification(rawIp, asnRange);
+            this.sendNotification(rawIp, asnRange, result.length);
             return result;
         }
         if (asnRange) {
@@ -57,11 +57,11 @@ let AttacksService = class AttacksService {
         if (!cidr)
             throw new Error(`IP non valido: ${rawIp}`);
         const result = await this.updateIpList(cidr);
-        this.sendNotification(rawIp, cidr);
+        this.sendNotification(rawIp, cidr, result.length);
         return result;
     }
-    sendNotification(rawIp, cidr) {
-        const message = `🚨 IP bannato su Cloudflare\nProvenienza: ${this.options.comment}\nIP: ${rawIp}\nSubnet bloccata: ${cidr}`;
+    sendNotification(rawIp, cidr, okAccounts) {
+        const message = `🚨 IP bannato su Cloudflare\nProvenienza: ${this.options.comment}\nIP: ${rawIp}\nSubnet bloccata: ${cidr}\nAccount: ${okAccounts}/${this.options.accounts.length}`;
         const provider = this.options.notifyProvider ?? (this.isWhatsappConfigured() ? "whatsapp" : "telegram");
         if (provider === "whatsapp")
             this.sendWhatsappNotification(message);
@@ -83,7 +83,8 @@ let AttacksService = class AttacksService {
         }
         (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";
-            this.logger.warn(`Notifica Telegram fallita: ${msg}`);
+            const description = axios_2.default.isAxiosError(err) ? err.response?.data?.description : undefined;
+            this.logger.warn(`Notifica Telegram fallita: ${msg}${description ? ` (${description})` : ""}`);
         });
     }
     sendWhatsappNotification(message) {
@@ -113,11 +114,30 @@ let AttacksService = class AttacksService {
             return null;
         }
     }
+    /** Aggiunge il CIDR alle liste di tutti gli account; ritorna le risposte degli account riusciti. */
     async updateIpList(cidr) {
-        const { accountId, listId, apiToken, comment } = this.options;
+        const { accounts } = this.options;
+        this.logger.error(`Aggiungo ${cidr} alle liste Cloudflare (${accounts.length} account)`);
+        const results = await Promise.allSettled(accounts.map((account) => this.addToAccountList(account, cidr)));
+        const ok = [];
+        let firstError;
+        results.forEach((r, i) => {
+            if (r.status === "fulfilled") {
+                ok.push(r.value);
+                return;
+            }
+            firstError ??= r.reason;
+            const msg = r.reason instanceof Error ? r.reason.message : "Errore sconosciuto";
+            this.logger.error(`Aggiunta di ${cidr} fallita sull'account ${accounts[i].accountId}: ${msg}`);
+        });
+        if (ok.length === 0)
+            throw firstError;
+        return ok;
+    }
+    async addToAccountList(account, cidr) {
+        const { accountId, listId, apiToken } = account;
         const url = `${this.API_URL}/${accountId}/rules/lists/${listId}/items`;
-        this.logger.error(`Aggiungo ${cidr} alla lista Cloudflare`);
-        const body = [{ ip: cidr, comment }];
+        const body = [{ ip: cidr, comment: this.options.comment }];
         try {
             const response = await (0, rxjs_1.firstValueFrom)(this.httpService.post(url, body, {
                 headers: {

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

@@ -5,10 +5,13 @@ export interface TelegramNotifyOptions {
     chatId: string;
 }
 export type NotifyProvider = "whatsapp" | "telegram";
-export interface CloudflareAttacksOptions {
+export interface CloudflareAccount {
     apiToken: string;
     accountId: string;
     listId: string;
+}
+export interface CloudflareAttacksOptions {
+    accounts: CloudflareAccount[];
     comment: string;
     logPath: string;
     allowedIps?: string[];

package/dist/scripts/version-bump.js

@@ -20,4 +20,10 @@ if (minor >= 10) {
 pkg.version = `${major}.${minor}.${patch}`;
 // Scrittura package.json
 (0, node_fs_1.writeFileSync)(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+// Allineamento package-lock.json (versione radice e del pacchetto "")
+const lockPath = (0, node_path_1.resolve)(__dirname, '../../package-lock.json');
+const lock = JSON.parse((0, node_fs_1.readFileSync)(lockPath, 'utf8'));
+lock.version = pkg.version;
+lock.packages[''].version = pkg.version;
+(0, node_fs_1.writeFileSync)(lockPath, JSON.stringify(lock, null, 2) + '\n');
 console.log(`Version updated to ${pkg.version}`);

package/dist/utils/options.validator.js

@@ -1,16 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOptions = validateOptions;
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
 function validateOptions(opzioni) {
     if (!opzioni)
         throw new Error("CloudflareAttacksOptions è obbligatorio");
-    const campiObbligatori = ["apiToken", "accountId", "listId", "comment", "logPath"];
+    const campiObbligatori = ["comment", "logPath"];
     for (const campo of campiObbligatori) {
-        const valore = opzioni[campo];
-        if (typeof valore !== "string" || valore.trim().length === 0) {
+        if (!isNonEmptyString(opzioni[campo])) {
             throw new Error(`CloudflareAttacksOptions.${campo} deve essere una stringa non vuota`);
         }
     }
+    if (!Array.isArray(opzioni.accounts) || opzioni.accounts.length === 0) {
+        throw new Error("CloudflareAttacksOptions.accounts deve essere un array non vuoto");
+    }
+    const campiAccount = ["apiToken", "accountId", "listId"];
+    opzioni.accounts.forEach((account, i) => {
+        for (const campo of campiAccount) {
+            if (!isNonEmptyString(account?.[campo])) {
+                throw new Error(`CloudflareAttacksOptions.accounts[${i}].${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.7",
+  "version": "3.0.0",
   "description": "Modulo NestJS per gestione IP List Cloudflare",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",