feat: bsmart with annotations

cli.js

@@ -22,7 +22,8 @@ async function selectProvider() {
         "sanoma",
         "hubscuola",
         "dibooklaterza",
-        "zanichelli"
+        "zanichelli",
+        "bsmart"
         // there'll be more providers in the future, but I currently don't have books to test em so if you want to contribute feel free to open a PR with your provider implementation
       ]
     }
@@ -33,6 +34,11 @@ async function selectProvider() {
 
 async function main() {
   const provider = await selectProvider();
+  const providerOptions = { ...argv };
+  delete providerOptions._;
+  delete providerOptions.$0;
+  delete providerOptions.provider;
+  delete providerOptions.p;
 
   try {
     const module = await import(`./providers/${provider}.js`);
@@ -42,7 +48,7 @@ async function main() {
       process.exit(1);
     }
 
-    await module.run({});
+    await module.run(providerOptions);
   } catch (err) {
     console.error("Errore caricando il provider:", err.message);
     process.exit(1);

package-lock.json

@@ -14,11 +14,15 @@
         "better-sqlite3": "^12.4.1",
         "fs-extra": "^11.2.0",
         "inquirer": "^8.2.7",
+        "md5": "^2.3.0",
+        "msgpack-lite": "^0.1.26",
         "node-fetch": "^3.3.2",
         "node-forge": "^1.3.3",
+        "p-limit": "^6.2.0",
         "pdf-lib": "^1.17.1",
         "pdf-merger-js": "^5.1.1",
         "prompt-sync": "^4.2.0",
+        "sanitize-filename": "^1.6.3",
         "svg-to-pdfkit": "^0.1.8",
         "sync-request": "^6.1.0",
         "xml2js": "^0.6.2",
@@ -314,6 +318,15 @@
       "integrity": "sha512-PsezH1rqdV9VvyNhxxOW32/d75r01NY7TQCmOqomRo15ZSOKbpTFVsfjghxo6JloQUCGnH4k1LGu0R4yCLlWQQ==",
       "license": "MIT"
     },
+    "node_modules/charenc": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz",
+      "integrity": "sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/chownr": {
       "version": "1.1.4",
       "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz",
@@ -487,6 +500,15 @@
       "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
       "license": "MIT"
     },
+    "node_modules/crypt": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz",
+      "integrity": "sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/crypto-js": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-4.2.0.tgz",
@@ -654,6 +676,12 @@
         "node": ">=0.8.0"
       }
     },
+    "node_modules/event-lite": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/event-lite/-/event-lite-0.1.3.tgz",
+      "integrity": "sha512-8qz9nOz5VeD2z96elrEKD2U433+L3DWdUdDkOINLGOJvx1GsMBbMn0aCeu28y8/e85A6mCigBiFlYMnTBEGlSw==",
+      "license": "MIT"
+    },
     "node_modules/expand-template": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
@@ -1043,16 +1071,6 @@
         }
       }
     },
-    "node_modules/inquirer/node_modules/@types/node": {
-      "version": "25.3.3",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.3.3.tgz",
-      "integrity": "sha512-DpzbrH7wIcBaJibpKo9nnSQL0MTRdnWttGyE5haGwK86xgMOkFLp7vEyfQPGLOJh5wNYiJ3V9PmUMDhV9u8kkQ==",
-      "optional": true,
-      "peer": true,
-      "dependencies": {
-        "undici-types": "~7.18.0"
-      }
-    },
     "node_modules/inquirer/node_modules/ansi-regex": {
       "version": "5.0.1",
       "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
@@ -1088,6 +1106,18 @@
         "node": ">=8"
       }
     },
+    "node_modules/int64-buffer": {
+      "version": "0.1.10",
+      "resolved": "https://registry.npmjs.org/int64-buffer/-/int64-buffer-0.1.10.tgz",
+      "integrity": "sha512-v7cSY1J8ydZ0GyjUHqF+1bshJ6cnEVLo9EnjB8p+4HDRPZc9N5jjmvUV7NvEsqQOKyH0pmIBFWXVQbiS0+OBbA==",
+      "license": "MIT"
+    },
+    "node_modules/is-buffer": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz",
+      "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==",
+      "license": "MIT"
+    },
     "node_modules/is-fullwidth-code-point": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
@@ -1193,6 +1223,17 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/md5": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/md5/-/md5-2.3.0.tgz",
+      "integrity": "sha512-T1GITYmFaKuO91vxyoQMFETst+O71VUPEU3ze5GNzDm0OWdP8v1ziTaAEPUr/3kLsY3Sftgz242A1SetQiDL7g==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "charenc": "0.0.2",
+        "crypt": "0.0.2",
+        "is-buffer": "~1.1.6"
+      }
+    },
     "node_modules/mime-db": {
       "version": "1.52.0",
       "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
@@ -1250,6 +1291,21 @@
       "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==",
       "license": "MIT"
     },
+    "node_modules/msgpack-lite": {
+      "version": "0.1.26",
+      "resolved": "https://registry.npmjs.org/msgpack-lite/-/msgpack-lite-0.1.26.tgz",
+      "integrity": "sha512-SZ2IxeqZ1oRFGo0xFGbvBJWMp3yLIY9rlIJyxy8CGrwZn1f0ZK4r6jV/AM1r0FZMDUkWkglOk/eeKIL9g77Nxw==",
+      "license": "MIT",
+      "dependencies": {
+        "event-lite": "^0.1.1",
+        "ieee754": "^1.1.8",
+        "int64-buffer": "^0.1.9",
+        "isarray": "^1.0.0"
+      },
+      "bin": {
+        "msgpack": "bin/msgpack"
+      }
+    },
     "node_modules/mute-stream": {
       "version": "0.0.8",
       "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz",
@@ -1401,6 +1457,21 @@
         "node": ">=8"
       }
     },
+    "node_modules/p-limit": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-6.2.0.tgz",
+      "integrity": "sha512-kuUqqHNUqoIWp/c467RI4X6mmyuojY5jGutNU0wVTmEOOfcuwLqyMVoAi9MKi2Ak+5i9+nhmrK4ufZE8069kHA==",
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/pako": {
       "version": "1.0.11",
       "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
@@ -1647,6 +1718,15 @@
       "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
       "license": "MIT"
     },
+    "node_modules/sanitize-filename": {
+      "version": "1.6.3",
+      "resolved": "https://registry.npmjs.org/sanitize-filename/-/sanitize-filename-1.6.3.tgz",
+      "integrity": "sha512-y/52Mcy7aw3gRm7IrcGDFx/bCk4AhRh2eI9luHOQM86nZsqwiRkkq2GekHXBBD+SmPidc8i2PqtYZl+pWJ8Oeg==",
+      "license": "WTFPL OR ISC",
+      "dependencies": {
+        "truncate-utf8-bytes": "^1.0.0"
+      }
+    },
     "node_modules/sax": {
       "version": "1.4.4",
       "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.4.tgz",
@@ -1968,6 +2048,15 @@
       "integrity": "sha512-pkY1fj1cKHb2seWDy0B16HeWyczlJA9/WW3u3c4z/NiWDsO3DOU5D7nhTLE9CF0yXv/QZFY7sEJmj24dK+Rrqw==",
       "license": "MIT"
     },
+    "node_modules/truncate-utf8-bytes": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz",
+      "integrity": "sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ==",
+      "license": "WTFPL",
+      "dependencies": {
+        "utf8-byte-length": "^1.0.1"
+      }
+    },
     "node_modules/tslib": {
       "version": "1.14.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
@@ -2009,8 +2098,7 @@
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
       "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
       "license": "MIT",
-      "optional": true,
-      "peer": true
+      "optional": true
     },
     "node_modules/unicode-properties": {
       "version": "1.4.1",
@@ -2047,6 +2135,12 @@
         "node": ">= 10.0.0"
       }
     },
+    "node_modules/utf8-byte-length": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.5.tgz",
+      "integrity": "sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA==",
+      "license": "(WTFPL OR MIT)"
+    },
     "node_modules/util-deprecate": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
@@ -2185,6 +2279,18 @@
       "engines": {
         "node": ">=12"
       }
+    },
+    "node_modules/yocto-queue": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.2.2.tgz",
+      "integrity": "sha512-4LCcse/U2MHZ63HAJVE+v71o7yOdIe4cZ70Wpf8D/IyjDKYQLV5GD46B+hSTjJsvV5PztjvHoU580EftxjDZFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
     }
   }
 }

package.json

@@ -25,11 +25,15 @@
     "better-sqlite3": "^12.4.1",
     "fs-extra": "^11.2.0",
     "inquirer": "^8.2.7",
+    "md5": "^2.3.0",
+    "msgpack-lite": "^0.1.26",
     "node-fetch": "^3.3.2",
     "node-forge": "^1.3.3",
     "pdf-lib": "^1.17.1",
     "pdf-merger-js": "^5.1.1",
+    "p-limit": "^6.2.0",
     "prompt-sync": "^4.2.0",
+    "sanitize-filename": "^1.6.3",
     "svg-to-pdfkit": "^0.1.8",
     "sync-request": "^6.1.0",
     "xml2js": "^0.6.2",

providers/bsmart.js

@@ -0,0 +1,583 @@
+import PromptSync from 'prompt-sync';
+import fetch from 'node-fetch';
+import { PDFDocument, rgb } from 'pdf-lib';
+import fs from 'fs';
+import sanitize from 'sanitize-filename';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import md5 from 'md5';
+import { spawn } from 'child_process';
+import path from 'path';
+import pLimit from 'p-limit';
+
+import { fetchEncryptionKey, decryptFile } from './src/crypto.js';
+import { getUserInfo, getBooks, getBookInfo, getBookResources, getResourceLinks } from './src/api.js';
+
+const prompt = PromptSync({ sigint: true });
+
+function parseAnnotationValue(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+
+    return value
+        .map(element => {
+            if (typeof element !== 'string') {
+                return null;
+            }
+
+            try {
+                return JSON.parse(element);
+            } catch {
+                return null;
+            }
+        })
+        .filter(Boolean);
+}
+
+function extractAnnotationsFromLinks(links) {
+    const annotations = [];
+
+    for (const link of links) {
+        const resource = link?.resource;
+        const parsed = parseAnnotationValue(resource?.content?.value);
+
+        if (parsed.length === 0) {
+            continue;
+        }
+
+        annotations.push({
+            linkId: link?.id ?? null,
+            resourceId: resource?.id ?? link?.resource_id ?? null,
+            resourceTypeId: resource?.resource_type_id ?? link?.resource_type_id ?? null,
+            targetId: link?.target_id ?? null,
+            targetTypeId: link?.target_type_id ?? null,
+            items: parsed
+        });
+    }
+
+    return annotations;
+}
+
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+
+function parseHexColor(color) {
+    if (typeof color !== 'string') {
+        return rgb(0, 0, 0);
+    }
+
+    const normalized = color.trim().replace('#', '');
+
+    if (!/^[0-9a-fA-F]{6}$/.test(normalized)) {
+        return rgb(0, 0, 0);
+    }
+
+    const red = parseInt(normalized.slice(0, 2), 16) / 255;
+    const green = parseInt(normalized.slice(2, 4), 16) / 255;
+    const blue = parseInt(normalized.slice(4, 6), 16) / 255;
+    return rgb(red, green, blue);
+}
+
+function toPdfRect(pageHeight, rect) {
+    if (!Array.isArray(rect) || rect.length < 4) {
+        return null;
+    }
+
+    const x = Number(rect[0]);
+    const y = Number(rect[1]);
+    const width = Number(rect[2]);
+    const height = Number(rect[3]);
+
+    if (![x, y, width, height].every(Number.isFinite)) {
+        return null;
+    }
+
+    return {
+        x,
+        y: pageHeight - y - height,
+        width,
+        height
+    };
+}
+
+function drawInkAnnotationOnPage(pdfPage, annotationItem) {
+    const pointsByStroke = annotationItem?.lines?.points;
+
+    if (!Array.isArray(pointsByStroke)) {
+        return;
+    }
+
+    const pageHeight = pdfPage.getHeight();
+    const strokeColor = parseHexColor(annotationItem?.strokeColor);
+    const thickness = Math.max(1, Number(annotationItem?.lineWidth) || 1);
+    const opacity = clamp(Number(annotationItem?.opacity) || 1, 0, 1);
+
+    for (const stroke of pointsByStroke) {
+        if (!Array.isArray(stroke) || stroke.length === 0) {
+            continue;
+        }
+
+        if (stroke.length === 1) {
+            const point = stroke[0];
+            if (Array.isArray(point) && point.length >= 2) {
+                const x = Number(point[0]);
+                const y = Number(point[1]);
+                if (Number.isFinite(x) && Number.isFinite(y)) {
+                    pdfPage.drawCircle({
+                        x,
+                        y: pageHeight - y,
+                        size: Math.max(0.5, thickness / 2),
+                        color: strokeColor,
+                        opacity
+                    });
+                }
+            }
+            continue;
+        }
+
+        for (let i = 0; i < stroke.length - 1; i++) {
+            const from = stroke[i];
+            const to = stroke[i + 1];
+
+            if (!Array.isArray(from) || !Array.isArray(to) || from.length < 2 || to.length < 2) {
+                continue;
+            }
+
+            const x1 = Number(from[0]);
+            const y1 = Number(from[1]);
+            const x2 = Number(to[0]);
+            const y2 = Number(to[1]);
+
+            if (![x1, y1, x2, y2].every(Number.isFinite)) {
+                continue;
+            }
+
+            pdfPage.drawLine({
+                start: { x: x1, y: pageHeight - y1 },
+                end: { x: x2, y: pageHeight - y2 },
+                thickness,
+                color: strokeColor,
+                opacity
+            });
+        }
+    }
+}
+
+function drawHighlightAnnotationOnPage(pdfPage, annotationItem) {
+    const pageHeight = pdfPage.getHeight();
+    const color = parseHexColor(annotationItem?.color || '#FAFC00');
+    const opacity = clamp(Number(annotationItem?.opacity) || 0.6, 0, 1);
+    const rects = Array.isArray(annotationItem?.rects) && annotationItem.rects.length > 0
+        ? annotationItem.rects
+        : [annotationItem?.bbox];
+
+    for (const rect of rects) {
+        const normalized = toPdfRect(pageHeight, rect);
+        if (!normalized) {
+            continue;
+        }
+
+        pdfPage.drawRectangle({
+            x: normalized.x,
+            y: normalized.y,
+            width: normalized.width,
+            height: normalized.height,
+            color,
+            opacity
+        });
+    }
+}
+
+function drawLinkAnnotationOnPage(pdfPage, annotationItem) {
+    const pageHeight = pdfPage.getHeight();
+    const rect = toPdfRect(pageHeight, annotationItem?.bbox);
+
+    if (!rect) {
+        return;
+    }
+
+    const borderWidth = Math.max(0, Number(annotationItem?.borderWidth) || 0);
+    if (borderWidth === 0) {
+        return;
+    }
+
+    const borderColor = parseHexColor(annotationItem?.color || '#1A73E8');
+    const opacity = clamp(Number(annotationItem?.opacity) || 1, 0, 1);
+
+    pdfPage.drawRectangle({
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height,
+        borderColor,
+        borderWidth,
+        borderOpacity: opacity
+    });
+}
+
+function drawFallbackRectAnnotationOnPage(pdfPage, annotationItem) {
+    const pageHeight = pdfPage.getHeight();
+    const rects = Array.isArray(annotationItem?.rects) && annotationItem.rects.length > 0
+        ? annotationItem.rects
+        : [annotationItem?.bbox];
+
+    const borderColor = parseHexColor(annotationItem?.strokeColor || annotationItem?.color || '#000000');
+    const fillColor = annotationItem?.fillColor ? parseHexColor(annotationItem.fillColor) : null;
+    const opacity = clamp(Number(annotationItem?.opacity) || 1, 0, 1);
+    const borderWidth = Math.max(0.5, Number(annotationItem?.lineWidth) || Number(annotationItem?.borderWidth) || 1);
+
+    for (const rect of rects) {
+        const normalized = toPdfRect(pageHeight, rect);
+        if (!normalized) {
+            continue;
+        }
+
+        pdfPage.drawRectangle({
+            x: normalized.x,
+            y: normalized.y,
+            width: normalized.width,
+            height: normalized.height,
+            ...(fillColor ? { color: fillColor, opacity } : {}),
+            borderColor,
+            borderWidth,
+            borderOpacity: opacity
+        });
+    }
+}
+
+function drawAnnotationsOnPage(pdfPage, annotations) {
+    const stats = {};
+
+    for (const annotation of annotations) {
+        for (const item of annotation.items || []) {
+            const type = item?.type || 'unknown';
+
+            if (type === 'pspdfkit/ink') {
+                drawInkAnnotationOnPage(pdfPage, item);
+                stats[type] = (stats[type] || 0) + 1;
+                continue;
+            }
+
+            if (type === 'pspdfkit/markup/highlight') {
+                drawHighlightAnnotationOnPage(pdfPage, item);
+                stats[type] = (stats[type] || 0) + 1;
+                continue;
+            }
+
+            if (type === 'pspdfkit/link') {
+                drawLinkAnnotationOnPage(pdfPage, item);
+                stats[type] = (stats[type] || 0) + 1;
+                continue;
+            }
+
+            if (item?.bbox || (Array.isArray(item?.rects) && item.rects.length > 0)) {
+                drawFallbackRectAnnotationOnPage(pdfPage, item);
+                stats[type] = (stats[type] || 0) + 1;
+            }
+        }
+    }
+
+    return stats;
+}
+
+export async function run(options = {}) {
+    const argv = yargs(hideBin(process.argv))
+        .option('site', {
+            describe: 'The site to download from, currently either bsmart or digibook24',
+            type: 'string',
+            default: null
+        })
+        .option('siteUrl', {
+            describe: 'This overwrites the base url for the site, useful in case a new platform is added',
+            type: 'string',
+            default: null
+        })
+        .option('cookie', {
+            describe: 'Input "_bsw_session_v1_production" cookie',
+            type: 'string',
+            default: null
+        })
+        .option('bookId', {
+            describe: 'Book id',
+            type: 'string',
+            default: null
+        })
+        .option('downloadOnly', {
+            describe: 'Downloads the pages as individual pdfs and will provide a command that can be used to merge them with pdftk',
+            type: 'boolean',
+            default: false
+        })
+        .option('pdftk', {
+            describe: 'Downloads the pages as individual pdfs and merges them with pdftk',
+            type: 'boolean',
+            default: false
+        })
+        .option('pdftkPath', {
+            describe: 'Path to pdftk executable',
+            type: 'string',
+            default: 'pdftk'
+        })
+        .option('checkMd5', {
+            describe: 'Checks the md5 hash of the downloaded pages',
+            type: 'boolean',
+            default: false
+        })
+        .option('output', {
+            describe: 'Output filename',
+            type: 'string',
+            default: null
+        })
+        .option('resources', {
+            describe: 'Download resources of the book instead of the book itself',
+            type: 'boolean',
+            default: false
+        })
+        .option('concurrency', {
+            describe: 'Number of parallel downloads',
+            type: 'number',
+            default: 4
+        })
+        .option('annotations', {
+            describe: 'Draw page annotations on merged PDF',
+            type: 'boolean',
+            default: false
+        })
+        .help()
+        .argv;
+
+    const runtime = { ...argv, ...options };
+
+    if (runtime.downloadOnly && runtime.pdftk) {
+        console.log("Can't use --download-only and --pdftk at the same time");
+        return;
+    }
+
+    if (runtime.annotations && (runtime.downloadOnly || runtime.pdftk)) {
+        console.log('Annotations drawing requires merged PDF mode (without --downloadOnly/--pdftk)');
+    }
+
+    if ((runtime.downloadOnly || runtime.pdftk) && !fs.existsSync('temp')) {
+        fs.mkdirSync('temp');
+    }
+
+    if ((runtime.downloadOnly || runtime.pdftk) && fs.readdirSync('temp').length > 0) {
+        console.log('Files already in temp folder, please manually delete them if you want to download a new book');
+        return;
+    }
+
+    let baseSite = runtime.siteUrl;
+
+    if (!baseSite) {
+        let platform = runtime.site;
+        while (!platform) {
+            platform = prompt('Input site (bsmart or digibook24):');
+            if (platform !== 'bsmart' && platform !== 'digibook24') {
+                platform = null;
+                console.log('Invalid site');
+            }
+        }
+
+        baseSite = platform === 'bsmart' ? 'www.bsmart.it' : 'web.digibook24.com';
+    }
+
+    let cookie = runtime.cookie;
+    while (!cookie) {
+        cookie = prompt('Input "_bsw_session_v1_production" cookie:');
+    }
+
+    let user;
+    try {
+        const cookieHeaders = { cookie: `_bsw_session_v1_production=${cookie}` };
+        user = await getUserInfo(baseSite, cookieHeaders);
+    } catch (error) {
+        console.log('Error fetching user info:', error);
+        return;
+    }
+
+    const headers = { auth_token: user.auth_token };
+
+    let books;
+    try {
+        books = await getBooks(baseSite, headers);
+    } catch (error) {
+        console.log('Error fetching books:', error);
+        return;
+    }
+
+    if (books.length === 0) {
+        console.log('No books in your library!');
+    } else {
+        console.log('Book list:');
+        console.table(books.map(book => ({ id: book.id, title: book.title })));
+    }
+
+    let bookId = runtime.bookId;
+    while (!bookId) {
+        bookId = prompt(`Please input book id${books.length === 0 ? ' manually' : ''}:`);
+    }
+
+    console.log('Fetching book info');
+
+    let book;
+    try {
+        book = await getBookInfo(baseSite, bookId, headers);
+    } catch (error) {
+        console.log('Error fetching book info:', error.message);
+        return;
+    }
+
+    let info;
+    try {
+        info = await getBookResources(baseSite, book, headers);
+    } catch (error) {
+        console.log('Error fetching book resources:', error);
+        return;
+    }
+
+    const outputPdf = await PDFDocument.create();
+    const filenames = [];
+    const outputname = runtime.output || sanitize(`${book.id} - ${book.title}`);
+
+    let assets = info
+        .flatMap(resource =>
+            (resource.assets || []).map(asset => ({
+                ...asset,
+                pageResourceId: resource.id
+            }))
+        );
+
+    console.log('Fetching encryption key');
+
+    let encryptionKey;
+    try {
+        encryptionKey = await fetchEncryptionKey();
+    } catch (error) {
+        console.log('Error fetching encryption key:', error);
+        return;
+    }
+
+    if (runtime.resources) {
+        assets = assets.filter(element => element.use === 'launch_file');
+        if (!fs.existsSync(outputname)) {
+            fs.mkdirSync(outputname);
+        }
+        console.log('Downloading resources');
+    } else {
+        assets = assets.filter(element => element.use === 'page_pdf');
+        console.log('Downloading pages');
+    }
+
+    const limit = pLimit(runtime.concurrency);
+    let pagesWithAnnotations = 0;
+    let totalAnnotationItems = 0;
+    const renderedByType = {};
+
+    const downloadTasks = assets.map((asset, index) =>
+        limit(async () => {
+            try {
+                let data = await fetch(asset.url).then(response => response.buffer());
+                if (asset.encrypted !== false) {
+                    data = await decryptFile(data, encryptionKey);
+                }
+                if (runtime.checkMd5 && md5(data) !== asset.url) {
+                    console.log(`\nMismatching md5 hash for asset ${index}: ${asset.url}`);
+                }
+                return data;
+            } catch (error) {
+                console.log(`\nError downloading asset ${index}: ${error.message}`);
+                throw error;
+            }
+        })
+    );
+
+    for (let index = 0; index < assets.length; index++) {
+        const asset = assets[index];
+        let data;
+
+        try {
+            data = await downloadTasks[index];
+        } catch {
+            return;
+        }
+
+        process.stdout.write(`\rProgress ${((index + 1) / assets.length * 100).toFixed(2)}% (${index + 1}/${assets.length})`);
+
+        if (runtime.resources) {
+            const filename = path.basename(asset.filename);
+            await fs.promises.writeFile(`${outputname}/${filename}`, data);
+            continue;
+        }
+
+        if (runtime.downloadOnly || runtime.pdftk) {
+            const filename = path.basename(asset.filename, '.pdf');
+            const filePath = `temp/${filename}.pdf`;
+            await fs.promises.writeFile(filePath, data);
+            filenames.push(filePath);
+            continue;
+        }
+
+        const page = await PDFDocument.load(data);
+        const [firstDonorPage] = await outputPdf.copyPages(page, [0]);
+
+        if (runtime.annotations && asset?.pageResourceId) {
+            try {
+            const links = await getResourceLinks(baseSite, asset.pageResourceId, headers);
+                const annotations = extractAnnotationsFromLinks(links);
+
+                if (annotations.length > 0) {
+                    const pageStats = drawAnnotationsOnPage(firstDonorPage, annotations);
+                    pagesWithAnnotations++;
+                    totalAnnotationItems += annotations.reduce((sum, group) => sum + (group.items?.length || 0), 0);
+                    for (const [type, count] of Object.entries(pageStats)) {
+                        renderedByType[type] = (renderedByType[type] || 0) + count;
+                    }
+                }
+            } catch (error) {
+                console.log(`\nError fetching annotations for page ${index + 1}: ${error.message}`);
+            }
+        }
+
+        outputPdf.addPage(firstDonorPage);
+    }
+
+    console.log();
+
+    if (!runtime.resources && !runtime.downloadOnly && !runtime.pdftk) {
+        await fs.promises.writeFile(`${outputname}.pdf`, await outputPdf.save());
+
+        if (runtime.annotations) {
+            console.log(`Applied ${totalAnnotationItems} annotation item(s) on ${pagesWithAnnotations} page(s)`);
+            console.log(`Rendered by type: ${JSON.stringify(renderedByType)}`);
+        }
+
+        console.log('Done');
+        return;
+    }
+
+    if (!runtime.resources) {
+        const pdftkCommand = `${runtime.pdftkPath} ${filenames.join(' ')} cat output "${outputname}.pdf"`;
+        console.log('Run this command to merge the pages with pdftk:');
+        console.log(pdftkCommand);
+
+        if (runtime.pdftk) {
+            console.log('Merging pages with pdftk');
+            await new Promise(resolve => {
+                const pdftk = spawn(runtime.pdftkPath, [...filenames, 'cat', 'output', `${outputname}.pdf`]);
+                pdftk.stdout.on('data', data => {
+                    console.log(`stdout: ${data}`);
+                });
+                pdftk.stderr.on('data', data => {
+                    console.log(`stderr: ${data}`);
+                });
+                pdftk.on('close', code => {
+                    console.log(`child process exited with code ${code}`);
+                    resolve();
+                });
+            });
+        }
+    }
+
+    console.log('Done');
+}

providers/src/api.js

@@ -0,0 +1,108 @@
+import fetch from 'node-fetch';
+
+/**
+ * Gets user information from the API
+ * @param {string} baseSite - The base site URL
+ * @param {Object} headers - Complete headers object including auth_token
+ * @returns {Promise<Object>} User information
+ */
+export async function getUserInfo(baseSite, headers) {
+    const response = await fetch(`https://${baseSite}/api/v5/user`, { headers });
+
+    if (response.status != 200) {
+        throw new Error('Bad cookie');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Gets the list of books from the API
+ * @param {string} baseSite - The base site URL
+ * @param {Object} headers - Complete headers object including auth_token
+ * @returns {Promise<Array>} Array of books
+ */
+export async function getBooks(baseSite, headers) {
+    const books = await fetch(`https://${baseSite}/api/v6/books?page_thumb_size=medium&per_page=25000`, { headers }).then(res => res.json());
+
+    const preactivations = await fetch(`https://${baseSite}/api/v5/books/preactivations`, { headers }).then(res => res.json());
+
+    preactivations.forEach(preactivation => {
+        if (preactivation.no_bsmart === false) {
+            books.push(...preactivation.books);
+        }
+    });
+
+    return books;
+}
+
+/**
+ * Gets detailed information about a specific book
+ * @param {string} baseSite - The base site URL
+ * @param {string} bookId - The book ID
+ * @param {Object} headers - Complete headers object including auth_token
+ * @returns {Promise<Object>} Book information
+ */
+export async function getBookInfo(baseSite, bookId, headers) {
+    const response = await fetch(`https://${baseSite}/api/v6/books/by_book_id/${bookId}`, { headers });
+
+    if (response.status != 200) {
+        throw new Error('Invalid book id');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Gets all resources for a book
+ * @param {string} baseSite - The base site URL
+ * @param {Object} book - The book object
+ * @param {Object} headers - Complete headers object including auth_token
+ * @returns {Promise<Array>} Array of resources
+ */
+export async function getBookResources(baseSite, book, headers) {
+    let info = [];
+    let page = 1;
+
+    while (true) {
+        const tempInfo = await fetch(`https://${baseSite}/api/v5/books/${book.id}/${book.current_edition.revision}/resources?per_page=500&page=${page}`, { headers }).then(res => res.json());
+        info = info.concat(tempInfo);
+        if (tempInfo.length < 500) break;
+        page++;
+    }
+
+    return info;
+}
+
+/**
+ * Gets links attached to a specific resource (used for annotations)
+ * @param {string} baseSite - The base site URL
+ * @param {number|string} resourceId - The page resource ID
+ * @param {Object} headers - Complete headers object including auth_token
+ * @returns {Promise<Array>} Array of links
+ */
+export async function getResourceLinks(baseSite, resourceId, headers) {
+    let links = [];
+    let page = 1;
+
+    while (true) {
+        const pageLinks = await fetch(
+            `https://${baseSite}/api/v5/resources/${resourceId}/links?per_page=50&page=${page}`,
+            { headers }
+        ).then(res => res.json());
+
+        if (!Array.isArray(pageLinks) || pageLinks.length === 0) {
+            break;
+        }
+
+        links = links.concat(pageLinks);
+
+        if (pageLinks.length < 50) {
+            break;
+        }
+
+        page++;
+    }
+
+    return links;
+}

providers/src/crypto.js

@@ -0,0 +1,55 @@
+import fetch from 'node-fetch';
+import msgpack from 'msgpack-lite';
+import aesjs from 'aes-js';
+
+/**
+ * Fetches the encryption key from the bSmart website
+ * @returns {Promise<Buffer>} The encryption key
+ */
+export async function fetchEncryptionKey() {
+    const page = await fetch('https://my.bsmart.it/');
+    const text = await page.text();
+    const script = text.match(/<script src="(\/scripts\/.*.min.js)">/)[1];
+    const scriptText = await fetch('https://my.bsmart.it' + script).then(res => res.text());
+    let keyScript = scriptText.slice(scriptText.indexOf('var i=String.fromCharCode'));
+    keyScript = keyScript.slice(0, keyScript.indexOf('()'));
+    const sourceCharacters = keyScript.match(/var i=String.fromCharCode\((((\d+),)+(\d+))\)/)[1].split(',').map(e => parseInt(e)).map(e => String.fromCharCode(e));
+    const map = keyScript.match(/i\[\d+\]/g).map(e => parseInt(e.slice(2, -1)));
+    const snippet = map.map(e => sourceCharacters[e]).join('');
+    const key = Buffer.from(snippet.match(/'((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?)'/)[1], 'base64');
+    return key;
+}
+
+/**
+ * Decrypts an encrypted file using the provided encryption key
+ * @param {Buffer} file - The encrypted file data
+ * @param {Buffer} key - The encryption key
+ * @returns {Promise<Uint8Array>} The decrypted file data
+ */
+export async function decryptFile(file, key) {
+    return new Promise((resolve, reject) => {
+        try {
+            const header = msgpack.decode(file.slice(0, 256));
+
+            const firstPart = file.slice(256, header.start);
+            const secondPart = new Uint8Array(file.slice(header.start));
+
+            const aesCbc = new aesjs.ModeOfOperation.cbc(key, firstPart.slice(0, 16));
+            let decryptedFirstPart = aesCbc.decrypt(firstPart.slice(16));
+
+            for (let i = 16; i > 0; i--) {
+                if (decryptedFirstPart.slice(decryptedFirstPart.length - i).every(e => e == i)) {
+                    decryptedFirstPart = decryptedFirstPart.slice(0, decryptedFirstPart.length - i);
+                    break;
+                }
+            }
+
+            const result = new Uint8Array(decryptedFirstPart.length + secondPart.length);
+            result.set(decryptedFirstPart);
+            result.set(secondPart, decryptedFirstPart.length);
+            resolve(result);
+        } catch (e) {
+            reject({ e, file });
+        }
+    });
+}

providers/src/pdf.js

@@ -0,0 +1,27 @@
+import { PDFDocument } from 'pdf-lib';
+
+/**
+ * Merges multiple PDF pages into a single PDF document
+ * @param {Array<Buffer>} pages - Array of PDF page data
+ * @returns {Promise<PDFDocument>} The merged PDF document
+ */
+export async function mergePdfPages(pages) {
+    const outputPdf = await PDFDocument.create();
+
+    for (const pageData of pages) {
+        const page = await PDFDocument.load(pageData);
+        const [firstDonorPage] = await outputPdf.copyPages(page, [0]);
+        outputPdf.addPage(firstDonorPage);
+    }
+
+    return outputPdf;
+}
+
+/**
+ * Saves a PDF document to a buffer
+ * @param {PDFDocument} pdfDoc - The PDF document to save
+ * @returns {Promise<Uint8Array>} The PDF data as a buffer
+ */
+export async function savePdf(pdfDoc) {
+    return await pdfDoc.save();
+}