Add local MarianMT translation service

.gitignore

@@ -118,6 +118,10 @@ dist
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+# Local Python environments
+translation-service/.venv/
+translation-service/__pycache__/
 # Logs
 logs
 *.log

README.md

@@ -31,6 +31,27 @@ A step by step series of examples that tell you how to get a development env run
     npm start
     ```
 
+### Local MarianMT translation
+
+The translation service is independent from the Node backend and provides `GET /health` and `POST /translate`.
+
+1. Start it locally:
+   ```
+   cd translation-service
+   python3 -m venv .venv
+   .venv/bin/pip install -r requirements.txt
+   .venv/bin/python server.py
+   ```
+2. Configure the Node backend:
+   ```
+   TRANSLATION_PROVIDER=marian
+   MARIAN_TRANSLATION_URL=http://127.0.0.1:8000
+   ```
+
+With Docker Compose, the service runs as the internal `translation` service. Set `TRANSLATION_PROVIDER=marian` before running `docker compose up`. MarianMT models download only when first needed and are stored in the `translation-models` Docker volume.
+
+Supported languages are English (`en`), Spanish (`es`), French (`fr`), Danish (`da`), and Arabic (`ar`). Non-English pairs translate through English. Keep the service on the internal Docker network; it has no public port mapping.
+
 ### API Documentation
 
 Once the server is running, you can access the interactive API documentation powered by Swagger UI at:
@@ -130,6 +151,14 @@ The API is divided into several sections based on functionality. Most routes und
 -   `GET /chapters/:chapterId`: Get the content of a chapter.
 -   `GET /chapters/:chapterId/verses`: Get the verses of a chapter.
 -   `GET /search`: Search the Bible.
+-   `GET /mine`: Get Bible highlights and notes for the active profile.
+-   `GET /verses/:verseKey/counters`: Get highlight and note counters for a verse key like `GEN.1.1`.
+-   `GET /verses/:verseKey/activity`: Get profiles that highlighted/noted a verse and recent notes, limited to 10 by default.
+-   `POST /verses/:verseKey/highlight`: Highlight a verse for the active profile.
+-   `DELETE /verses/:verseKey/highlight`: Remove a verse highlight for the active profile.
+-   `POST /verses/:verseKey/notes`: Add a note for a verse.
+-   `PUT /verses/:verseKey/notes/:noteId`: Update one of the active profile's notes.
+-   `DELETE /verses/:verseKey/notes/:noteId`: Delete one of the active profile's notes.
 
 ### Subsplash (`/subsplash`)
 
@@ -139,4 +168,4 @@ The API is divided into several sections based on functionality. Most routes und
 ### TODO
 
 -   [ ] Define nodes schema
--   [ ] Implement basic login/registration
+-   [ ] Implement basic login/registration

dbTools/bible.js

@@ -0,0 +1,287 @@
+const DBName = "EMI_SOCIAL";
+
+const toProfileIds = (DB, profileIds = []) => {
+    return profileIds
+        .filter((profileId) => DB.ObjectID.isValid(profileId))
+        .map((profileId) => DB.ObjectID(profileId));
+};
+
+const publicProfile = (profile) => {
+    if (!profile) return null;
+    return {
+        _id: profile._id,
+        profile: profile.profile,
+        username: profile.username,
+        isGroup: profile.isGroup,
+        isCourse: profile.isCourse,
+    };
+};
+
+const bibleDB = (DB) => {
+    DB.bibleVerseCols = DB.db.db(DBName).collection("bible_verses");
+    DB.bibleVerseCols.createIndex({ highlightedBy: 1 }).catch(console.error);
+    DB.bibleVerseCols.createIndex({ notedBy: 1 }).catch(console.error);
+
+    const getVerseDoc = async (verseKey) => {
+        return DB.bibleVerseCols.findOne({ _id: verseKey }).catch((err) => {
+            console.log(err);
+            return false;
+        });
+    };
+
+    DB.getBibleProfileData = async (profileid) => {
+        if (!DB.ObjectID.isValid(profileid)) return false;
+        const profile = await DB.profileCols.findOne(
+            { _id: DB.ObjectID(profileid) },
+            { projection: { bibleHighlights: 1, bibleNotes: 1 } }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        return {
+            highlights: profile?.bibleHighlights || [],
+            notes: profile?.bibleNotes || [],
+        };
+    };
+
+    DB.getBibleVerseCounters = async (verseKey) => {
+        const verse = await getVerseDoc(verseKey);
+        const highlightedBy = Array.isArray(verse?.highlightedBy) ? verse.highlightedBy : [];
+        const notedBy = Array.isArray(verse?.notedBy) ? verse.notedBy : [];
+        return {
+            verseKey,
+            highlightCount: highlightedBy.length,
+            noteProfileCount: notedBy.length,
+            notesCount: verse?.notesCount || 0,
+        };
+    };
+
+    DB.getBibleVerseActivity = async (verseKey, limit = 10) => {
+        const verse = await getVerseDoc(verseKey);
+        const highlightedBy = Array.isArray(verse?.highlightedBy) ? verse.highlightedBy : [];
+        const notedBy = Array.isArray(verse?.notedBy) ? verse.notedBy : [];
+        const highlightProfiles = toProfileIds(DB, highlightedBy);
+        const noteProfiles = toProfileIds(DB, notedBy);
+
+        const [highlights, noteUsers, notes] = await Promise.all([
+            highlightProfiles.length
+                ? DB.profileCols.find({ _id: { $in: highlightProfiles } }).project({
+                    profile: 1,
+                    username: 1,
+                    isGroup: 1,
+                    isCourse: 1,
+                }).toArray()
+                : [],
+            noteProfiles.length
+                ? DB.profileCols.find({ _id: { $in: noteProfiles } }).project({
+                    profile: 1,
+                    username: 1,
+                    isGroup: 1,
+                    isCourse: 1,
+                }).toArray()
+                : [],
+            DB.profileCols.aggregate([
+                { $match: { "bibleNotes.verseKey": verseKey } },
+                { $unwind: "$bibleNotes" },
+                { $match: { "bibleNotes.verseKey": verseKey } },
+                { $sort: { "bibleNotes.updatedAt": -1, "bibleNotes.createdAt": -1 } },
+                { $limit: limit },
+                {
+                    $project: {
+                        _id: 0,
+                        note: "$bibleNotes",
+                        profile: {
+                            _id: "$_id",
+                            profile: "$profile",
+                            username: "$username",
+                            isGroup: "$isGroup",
+                            isCourse: "$isCourse",
+                        }
+                    }
+                }
+            ]).toArray(),
+        ]);
+
+        return {
+            counters: await DB.getBibleVerseCounters(verseKey),
+            highlightedBy: highlights.map(publicProfile),
+            notedBy: noteUsers.map(publicProfile),
+            notes,
+        };
+    };
+
+    DB.addBibleHighlight = async (profileid, verseKey) => {
+        if (!DB.ObjectID.isValid(profileid)) return false;
+        const now = new Date();
+        const _id = DB.ObjectID(profileid);
+        const profileUpdate = await DB.profileCols.updateOne(
+            { _id, "bibleHighlights.verseKey": { $ne: verseKey } },
+            {
+                $push: {
+                    bibleHighlights: {
+                        verseKey,
+                        createdAt: now,
+                    }
+                },
+                $set: { lastUpdate: now }
+            }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        await DB.bibleVerseCols.updateOne(
+            { _id: verseKey },
+            {
+                $setOnInsert: { createdAt: now },
+                $set: { updatedAt: now },
+                $addToSet: { highlightedBy: profileid + "" }
+            },
+            { upsert: true }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        if (DB.clearProfileCache) DB.clearProfileCache(profileid);
+        return profileUpdate;
+    };
+
+    DB.removeBibleHighlight = async (profileid, verseKey) => {
+        if (!DB.ObjectID.isValid(profileid)) return false;
+        const now = new Date();
+        const _id = DB.ObjectID(profileid);
+        const profileUpdate = await DB.profileCols.updateOne(
+            { _id },
+            {
+                $pull: { bibleHighlights: { verseKey } },
+                $set: { lastUpdate: now }
+            }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        await DB.bibleVerseCols.updateOne(
+            { _id: verseKey },
+            {
+                $pull: { highlightedBy: profileid + "" },
+                $set: { updatedAt: now }
+            }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        if (DB.clearProfileCache) DB.clearProfileCache(profileid);
+        return profileUpdate;
+    };
+
+    DB.addBibleNote = async (profileid, verseKey, text) => {
+        if (!DB.ObjectID.isValid(profileid)) return false;
+        const now = new Date();
+        const note = {
+            _id: DB.ObjectID().toString(),
+            verseKey,
+            text,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const _id = DB.ObjectID(profileid);
+        const profileUpdate = await DB.profileCols.updateOne(
+            { _id },
+            {
+                $push: { bibleNotes: note },
+                $set: { lastUpdate: now }
+            }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        await DB.bibleVerseCols.updateOne(
+            { _id: verseKey },
+            {
+                $setOnInsert: { createdAt: now },
+                $set: { updatedAt: now },
+                $addToSet: { notedBy: profileid + "" },
+                $inc: { notesCount: 1 }
+            },
+            { upsert: true }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        if (DB.clearProfileCache) DB.clearProfileCache(profileid);
+        return profileUpdate ? note : false;
+    };
+
+    DB.updateBibleNote = async (profileid, verseKey, noteId, text) => {
+        if (!DB.ObjectID.isValid(profileid)) return false;
+        const now = new Date();
+        const _id = DB.ObjectID(profileid);
+        const result = await DB.profileCols.findOneAndUpdate(
+            { _id, bibleNotes: { $elemMatch: { _id: noteId, verseKey } } },
+            {
+                $set: {
+                    "bibleNotes.$.text": text,
+                    "bibleNotes.$.updatedAt": now,
+                    lastUpdate: now,
+                }
+            },
+            {
+                returnOriginal: false,
+                projection: { bibleNotes: 1 }
+            }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        if (DB.clearProfileCache) DB.clearProfileCache(profileid);
+        return result?.value?.bibleNotes?.find((note) => note._id === noteId) || null;
+    };
+
+    DB.removeBibleNote = async (profileid, verseKey, noteId) => {
+        if (!DB.ObjectID.isValid(profileid)) return false;
+        const now = new Date();
+        const _id = DB.ObjectID(profileid);
+        const result = await DB.profileCols.updateOne(
+            { _id, bibleNotes: { $elemMatch: { _id: noteId, verseKey } } },
+            {
+                $pull: { bibleNotes: { _id: noteId, verseKey } },
+                $set: { lastUpdate: now }
+            }
+        ).catch((err) => {
+            console.log(err);
+            return false;
+        });
+
+        if (result?.modifiedCount) {
+            const stillHasNotes = await DB.profileCols.findOne(
+                { _id, "bibleNotes.verseKey": verseKey },
+                { projection: { _id: 1 } }
+            );
+
+            const verseUpdate = {
+                $inc: { notesCount: -1 },
+                $set: { updatedAt: now }
+            };
+            if (!stillHasNotes) {
+                verseUpdate.$pull = { notedBy: profileid + "" };
+            }
+
+            await DB.bibleVerseCols.updateOne({ _id: verseKey }, verseUpdate).catch((err) => {
+                console.log(err);
+                return false;
+            });
+        }
+
+        if (DB.clearProfileCache) DB.clearProfileCache(profileid);
+        return result;
+    };
+}
+
+module.exports = bibleDB;

dbTools/profile.js

@@ -5,6 +5,10 @@ let userProfileCache = {};
 userDB = (DB) => {
     DB.profileCols = DB.db.db(DBName).collection("profiles");
 
+    DB.clearProfileCache = (profileid) => {
+        if (userProfileCache[profileid]) delete userProfileCache[profileid];
+    };
+
     DB.newProfile = (profileObj) => {
         return DB.profileCols.insertOne(profileObj.toObj()).catch((err) => {
             console.log(err);

def/profile.js

@@ -17,6 +17,8 @@ class User {
         this.lastUpdate = info.lastUpdate || new Date();
         this.newsFeedCache = info.newsFeedCache || [];
         this.notifications = info.notifications || [];
+        this.bibleHighlights = info.bibleHighlights || [];
+        this.bibleNotes = info.bibleNotes || [];
 
         //groupRelated
         this.isGroup = info.isGroup || false;
@@ -33,4 +35,4 @@ class User {
 
 }
 
-module.exports = User;
+module.exports = User;

docker-compose.yml

@@ -18,15 +18,32 @@ services:
       - WEB_PUSH_EMAIL=${WEB_PUSH_EMAIL}
       - EMAILPASS=${EMAILPASS}
       - PORT=3001
+      - TRANSLATION_PROVIDER=${TRANSLATION_PROVIDER:-openai}
+      - MARIAN_TRANSLATION_URL=http://translation:8000
     volumes:
       - .:/app
       - '/app/node_modules'
     #depends_on:
     #  - mongo
     command: node index.js
+    depends_on:
+      - translation
+    networks:
+      - emi-network
   #  networks:
   #    - emi-network
 
+  translation:
+    build:
+      context: ./translation-service
+    restart: unless-stopped
+    environment:
+      - MARIAN_HOST=0.0.0.0
+    volumes:
+      - translation-models:/models
+    networks:
+      - emi-network
+
   #mongo:
   #  image: mongo:latest
   #  ports:
@@ -38,6 +55,8 @@ services:
   #    - ./dump:/dump
     #entrypoint: mongodump ${MONGO_URL} && mongorestore --db EMI_SOCIAL dump/EMI_SOCIAL/ && mongod
 
-#volumes:
+volumes:
+  translation-models:
+    driver: local
   #mongodbdata:
-  #  driver: local  # This ensures the volume is created
+  #  driver: local  # This ensures the volume is created

mongoDB.js

@@ -10,6 +10,7 @@ const profileDB = require("./dbTools/profile.js");
 const paymentDB = require("./dbTools/payments.js");
 const songsDB = require("./dbTools/songs.js");
 const chatDB = require("./dbTools/chat.js");
+const bibleDB = require("./dbTools/bible.js");
 
 console.log("Connecting to MongoDB...");
 const nodeMajorVersion = parseInt((process.versions.node || "0").split(".")[0], 10);
@@ -179,6 +180,7 @@ const getDB = new Promise((resolve, reject) => {
         paymentDB(DB);
         songsDB(DB);
         chatDB(DB);
+        bibleDB(DB);
     
         resolve(DB);
     });

routes/bible.js

@@ -2,6 +2,7 @@ const axios = require('axios');
 var express = require('express')
 var router = express.Router()
 const DB = require("./../mongoDB.js");
+const { getProfileId } = require("./../utils/sessionUtils.js");
 
 const fetchAPI = async (path) => {
     baseUrl = "https://api.scripture.api.bible/v1/"
@@ -11,6 +12,20 @@ const fetchAPI = async (path) => {
 
 const defaultBibleId = "592420522e16049f-01";
 
+const normalizeVerseKey = (verseKey) => {
+    if (!verseKey || typeof verseKey !== "string") return "";
+    return verseKey.trim().toUpperCase();
+};
+
+const isValidVerseKey = (verseKey) => {
+    return /^[A-Z0-9]+(\.[A-Z0-9]+)+$/.test(verseKey);
+};
+
+const getNoteText = (req) => {
+    const text = req.body?.text || req.body?.note || "";
+    return typeof text === "string" ? text.trim() : "";
+};
+
 //getMedia('y42zyf3').then(console.log)
 DB.getDB.then((DB) => {
     /**
@@ -37,6 +52,302 @@ DB.getDB.then((DB) => {
         return res.json(bibles);
     });
 
+    /**
+ * @swagger
+ * /bible/mine:
+ *   get:
+ *     summary: Get Bible highlights and notes for the active profile
+ *     tags: [Bible]
+ *     security:
+ *       - cookieAuth: []
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+    router.get("/mine", async (req, res) => {
+        const profileid = getProfileId(req);
+        const bibleData = await DB.getBibleProfileData(profileid);
+        if (!bibleData) return res.status(400).json({ status: "Invalid profile" });
+        return res.json({
+            status: "ok",
+            ...bibleData
+        });
+    });
+
+    /**
+ * @swagger
+ * /bible/verses/{verseKey}/counters:
+ *   get:
+ *     summary: Get highlight and note counters for a Bible verse
+ *     tags: [Bible]
+ *     security:
+ *       - cookieAuth: []
+ *     parameters:
+ *       - in: path
+ *         name: verseKey
+ *         required: true
+ *         schema:
+ *           type: string
+ *           example: GEN.1.1
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+    router.get("/verses/:verseKey/counters", async (req, res) => {
+        const verseKey = normalizeVerseKey(req.params.verseKey);
+        if (!isValidVerseKey(verseKey)) {
+            return res.status(400).json({ status: "Invalid verse key" });
+        }
+
+        const counters = await DB.getBibleVerseCounters(verseKey);
+        return res.json({
+            status: "ok",
+            ...counters
+        });
+    });
+
+    /**
+ * @swagger
+ * /bible/verses/{verseKey}/activity:
+ *   get:
+ *     summary: Get profiles and recent notes for a Bible verse
+ *     tags: [Bible]
+ *     security:
+ *       - cookieAuth: []
+ *     parameters:
+ *       - in: path
+ *         name: verseKey
+ *         required: true
+ *         schema:
+ *           type: string
+ *           example: GEN.1.1
+ *       - in: query
+ *         name: limit
+ *         schema:
+ *           type: integer
+ *           default: 10
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+    router.get("/verses/:verseKey/activity", async (req, res) => {
+        const verseKey = normalizeVerseKey(req.params.verseKey);
+        if (!isValidVerseKey(verseKey)) {
+            return res.status(400).json({ status: "Invalid verse key" });
+        }
+
+        const limit = Math.min(Math.max(parseInt(req.query.limit, 10) || 10, 1), 10);
+        const activity = await DB.getBibleVerseActivity(verseKey, limit);
+        return res.json({
+            status: "ok",
+            verseKey,
+            ...activity
+        });
+    });
+
+    /**
+ * @swagger
+ * /bible/verses/{verseKey}/highlight:
+ *   post:
+ *     summary: Highlight a Bible verse for the active profile
+ *     tags: [Bible]
+ *     security:
+ *       - cookieAuth: []
+ *     parameters:
+ *       - in: path
+ *         name: verseKey
+ *         required: true
+ *         schema:
+ *           type: string
+ *           example: GEN.1.1
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+    router.post("/verses/:verseKey/highlight", async (req, res) => {
+        const profileid = getProfileId(req);
+        const verseKey = normalizeVerseKey(req.params.verseKey);
+        if (!isValidVerseKey(verseKey)) {
+            return res.status(400).json({ status: "Invalid verse key" });
+        }
+
+        const result = await DB.addBibleHighlight(profileid, verseKey);
+        if (!result) return res.status(400).json({ status: "Could not add highlight" });
+
+        const counters = await DB.getBibleVerseCounters(verseKey);
+        return res.json({
+            status: "ok",
+            highlighted: true,
+            ...counters
+        });
+    });
+
+    /**
+ * @swagger
+ * /bible/verses/{verseKey}/highlight:
+ *   delete:
+ *     summary: Remove a Bible verse highlight for the active profile
+ *     tags: [Bible]
+ *     security:
+ *       - cookieAuth: []
+ *     parameters:
+ *       - in: path
+ *         name: verseKey
+ *         required: true
+ *         schema:
+ *           type: string
+ *           example: GEN.1.1
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+    router.delete("/verses/:verseKey/highlight", async (req, res) => {
+        const profileid = getProfileId(req);
+        const verseKey = normalizeVerseKey(req.params.verseKey);
+        if (!isValidVerseKey(verseKey)) {
+            return res.status(400).json({ status: "Invalid verse key" });
+        }
+
+        const result = await DB.removeBibleHighlight(profileid, verseKey);
+        if (!result) return res.status(400).json({ status: "Could not remove highlight" });
+
+        const counters = await DB.getBibleVerseCounters(verseKey);
+        return res.json({
+            status: "ok",
+            highlighted: false,
+            ...counters
+        });
+    });
+
+    /**
+ * @swagger
+ * /bible/verses/{verseKey}/notes:
+ *   post:
+ *     summary: Add a Bible verse note for the active profile
+ *     tags: [Bible]
+ *     security:
+ *       - cookieAuth: []
+ *     parameters:
+ *       - in: path
+ *         name: verseKey
+ *         required: true
+ *         schema:
+ *           type: string
+ *           example: GEN.1.1
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+    router.post("/verses/:verseKey/notes", async (req, res) => {
+        const profileid = getProfileId(req);
+        const verseKey = normalizeVerseKey(req.params.verseKey);
+        const text = getNoteText(req);
+        if (!isValidVerseKey(verseKey)) {
+            return res.status(400).json({ status: "Invalid verse key" });
+        }
+        if (!text) return res.status(400).json({ status: "Note text is required" });
+
+        const note = await DB.addBibleNote(profileid, verseKey, text);
+        if (!note) return res.status(400).json({ status: "Could not add note" });
+
+        const counters = await DB.getBibleVerseCounters(verseKey);
+        return res.json({
+            status: "ok",
+            verseKey,
+            note,
+            counters
+        });
+    });
+
+    /**
+ * @swagger
+ * /bible/verses/{verseKey}/notes/{noteId}:
+ *   put:
+ *     summary: Update a Bible verse note for the active profile
+ *     tags: [Bible]
+ *     security:
+ *       - cookieAuth: []
+ *     parameters:
+ *       - in: path
+ *         name: verseKey
+ *         required: true
+ *         schema:
+ *           type: string
+ *           example: GEN.1.1
+ *       - in: path
+ *         name: noteId
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+    router.put("/verses/:verseKey/notes/:noteId", async (req, res) => {
+        const profileid = getProfileId(req);
+        const verseKey = normalizeVerseKey(req.params.verseKey);
+        const noteId = req.params.noteId;
+        const text = getNoteText(req);
+        if (!isValidVerseKey(verseKey)) {
+            return res.status(400).json({ status: "Invalid verse key" });
+        }
+        if (!text) return res.status(400).json({ status: "Note text is required" });
+
+        const note = await DB.updateBibleNote(profileid, verseKey, noteId, text);
+        if (!note) return res.status(404).json({ status: "Note not found" });
+
+        return res.json({
+            status: "ok",
+            verseKey,
+            note
+        });
+    });
+
+    /**
+ * @swagger
+ * /bible/verses/{verseKey}/notes/{noteId}:
+ *   delete:
+ *     summary: Delete a Bible verse note for the active profile
+ *     tags: [Bible]
+ *     security:
+ *       - cookieAuth: []
+ *     parameters:
+ *       - in: path
+ *         name: verseKey
+ *         required: true
+ *         schema:
+ *           type: string
+ *           example: GEN.1.1
+ *       - in: path
+ *         name: noteId
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+    router.delete("/verses/:verseKey/notes/:noteId", async (req, res) => {
+        const profileid = getProfileId(req);
+        const verseKey = normalizeVerseKey(req.params.verseKey);
+        const noteId = req.params.noteId;
+        if (!isValidVerseKey(verseKey)) {
+            return res.status(400).json({ status: "Invalid verse key" });
+        }
+
+        const result = await DB.removeBibleNote(profileid, verseKey, noteId);
+        if (!result) return res.status(400).json({ status: "Could not delete note" });
+        if (!result.modifiedCount) return res.status(404).json({ status: "Note not found" });
+
+        const counters = await DB.getBibleVerseCounters(verseKey);
+        return res.json({
+            status: "ok",
+            verseKey,
+            deleted: true,
+            counters
+        });
+    });
+
 /**
  * @swagger
  * /bible/books:
@@ -219,4 +530,4 @@ DB.getDB.then((DB) => {
 
 });
 
-module.exports = router
+module.exports = router

routes/liveCaptions.js

@@ -112,7 +112,7 @@ const maybeResetForInactivity = () => {
     resetLiveCaptionState();
 };
 
-router.get("/stream", sessionChecker, async (req, res) => {
+router.get("/stream", async (req, res) => {
     try {
         maybeResetForInactivity();
         const sinceSequence = Number.parseInt(req.query?.sinceSequence, 10);
@@ -210,4 +210,38 @@ router.post("/reset", async (_, res) => {
     }
 });
 
+router.get("/public/stream", async (req, res) => {
+    try {
+        maybeResetForInactivity();
+        const sinceSequence = Number.parseInt(req.query?.sinceSequence, 10);
+        const requestedLimit = Number.parseInt(req.query?.limit, 10);
+        const initialLimit = Number.isFinite(requestedLimit)
+            ? Math.max(1, Math.min(requestedLimit, MAX_INITIAL_LIMIT))
+            : DEFAULT_INITIAL_LIMIT;
+
+        let captions = [];
+        if (Number.isFinite(sinceSequence) && sinceSequence >= 0) {
+            captions = liveCaptionState.captions.filter((item) => item.sequence > sinceSequence);
+        } else {
+            captions = liveCaptionState.captions.slice(-initialLimit);
+        }
+
+        return res.json({
+            status: "ok",
+            latestSequence: liveCaptionState.latestSequence,
+            startedAt: new Date(liveCaptionState.startedAt).toISOString(),
+            availableLanguages: getAvailableLanguages(),
+            captions,
+        });
+    } catch (error) {
+        console.error("Error getting public live captions stream", error);
+        return res.status(500).json({
+            status: "Internal server error",
+            latestSequence: liveCaptionState.latestSequence,
+            captions: [],
+            availableLanguages: [],
+        });
+    }
+});
+
 module.exports = router;

translation-service/.dockerignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+*.pyc

translation-service/Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+COPY server.py ./
+
+ENV MARIAN_HOST=0.0.0.0
+ENV TRANSFORMERS_CACHE=/models
+VOLUME ["/models"]
+EXPOSE 8000
+
+CMD ["python", "server.py"]

translation-service/requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.2,<3
+transformers>=4.40,<5
+sentencepiece>=0.2,<1
+langdetect>=1.0.9,<2

translation-service/server.py

@@ -0,0 +1,118 @@
+import json
+import os
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from langdetect import DetectorFactory, LangDetectException, detect
+from transformers import MarianMTModel, MarianTokenizer
+
+DetectorFactory.seed = 0
+
+HOST = os.getenv("MARIAN_HOST", "127.0.0.1")
+PORT = int(os.getenv("MARIAN_PORT", "8000"))
+MAX_INPUT_LENGTH = int(os.getenv("MARIAN_MAX_INPUT_LENGTH", "1000"))
+DEFAULT_SOURCE_LANGUAGE = os.getenv("MARIAN_DEFAULT_SOURCE_LANGUAGE", "en")
+SUPPORTED_LANGUAGES = {"en", "es", "fr", "da", "ar"}
+MODEL_CACHE = {}
+
+
+def normalize_language(value):
+    language = str(value or "").strip().lower().split(",")[0].split("-")[0]
+    return language
+
+
+def detect_source_language(text):
+    try:
+        detected = normalize_language(detect(text))
+        if detected in SUPPORTED_LANGUAGES:
+            return detected
+    except LangDetectException:
+        pass
+    return DEFAULT_SOURCE_LANGUAGE
+
+
+def get_model(source, target):
+    model_name = f"Helsinki-NLP/opus-mt-{source}-{target}"
+    if model_name not in MODEL_CACHE:
+        MODEL_CACHE[model_name] = (
+            MarianTokenizer.from_pretrained(model_name),
+            MarianMTModel.from_pretrained(model_name),
+        )
+    return model_name, MODEL_CACHE[model_name]
+
+
+def translate_once(text, source, target):
+    model_name, (tokenizer, model) = get_model(source, target)
+    encoded = tokenizer([text], return_tensors="pt", truncation=True)
+    generated = model.generate(**encoded)
+    return tokenizer.batch_decode(generated, skip_special_tokens=True)[0], model_name
+
+
+def translate(text, source, target):
+    if source == "auto":
+        source = detect_source_language(text)
+    if source not in SUPPORTED_LANGUAGES or target not in SUPPORTED_LANGUAGES:
+        raise ValueError("Only en, es, fr, da, and ar are supported")
+    if source == target:
+        return text, source, "none"
+    if source == "en" or target == "en":
+        translated, model_name = translate_once(text, source, target)
+        return translated, source, model_name
+
+    english, first_model = translate_once(text, source, "en")
+    translated, second_model = translate_once(english, "en", target)
+    return translated, source, f"{first_model},{second_model}"
+
+
+class TranslationHandler(BaseHTTPRequestHandler):
+    def send_json(self, status, body):
+        payload = json.dumps(body).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(payload)))
+        self.end_headers()
+        self.wfile.write(payload)
+
+    def do_GET(self):
+        if self.path != "/health":
+            self.send_json(404, {"status": "not found"})
+            return
+        self.send_json(200, {"status": "ok", "provider": "marianmt", "loadedModels": list(MODEL_CACHE)})
+
+    def do_POST(self):
+        if self.path != "/translate":
+            self.send_json(404, {"status": "not found"})
+            return
+        try:
+            content_length = int(self.headers.get("Content-Length", "0"))
+            body = json.loads(self.rfile.read(content_length).decode("utf-8"))
+            text = str(body.get("text") or "").strip()
+            source = normalize_language(body.get("sourceLang")) or "auto"
+            target = normalize_language(body.get("targetLang"))
+            if not text or not target:
+                self.send_json(400, {"status": "text and targetLang are required"})
+                return
+            if len(text) > MAX_INPUT_LENGTH:
+                self.send_json(400, {"status": f"text exceeds {MAX_INPUT_LENGTH} characters"})
+                return
+            translated, detected_source, model_name = translate(text, source, target)
+            self.send_json(200, {
+                "status": "ok",
+                "translatedText": translated,
+                "sourceLang": detected_source,
+                "targetLang": target,
+                "provider": "marianmt",
+                "model": model_name,
+            })
+        except (ValueError, json.JSONDecodeError) as error:
+            self.send_json(400, {"status": str(error)})
+        except Exception as error:
+            print(f"Translation failed: {error}", flush=True)
+            self.send_json(502, {"status": "Translation failed"})
+
+    def log_message(self, format_string, *args):
+        print(f"[marianmt] {self.address_string()} {format_string % args}", flush=True)
+
+
+if __name__ == "__main__":
+    print(f"MarianMT translation service listening on {HOST}:{PORT}", flush=True)
+    ThreadingHTTPServer((HOST, PORT), TranslationHandler).serve_forever()

utils/chatTranslation.js

@@ -1,6 +1,8 @@
 const axios = require("axios");
 
 const DEFAULT_MODEL = process.env.OPENAI_TRANSLATION_MODEL || process.env.OPENAI_MODEL || "gpt-4o-mini";
+const TRANSLATION_PROVIDER = (process.env.TRANSLATION_PROVIDER || "openai").trim().toLowerCase();
+const MARIAN_TRANSLATION_URL = (process.env.MARIAN_TRANSLATION_URL || "http://127.0.0.1:8000").replace(/\/$/, "");
 
 const normalizeLanguageCode = (rawLanguage) => {
     if (!rawLanguage || typeof rawLanguage !== "string") return "en";
@@ -40,6 +42,31 @@ const translateText = async ({ text, sourceLang, targetLang }) => {
         };
     }
 
+    if (TRANSLATION_PROVIDER === "marian") {
+        try {
+            const response = await axios.post(
+                `${MARIAN_TRANSLATION_URL}/translate`,
+                { text, sourceLang: sourceLang || "auto", targetLang: normalizedTarget },
+                { timeout: 30000, headers: { "Content-Type": "application/json" } }
+            );
+            const translatedText = response?.data?.translatedText?.trim();
+            if (!translatedText) return null;
+            return {
+                translatedText,
+                provider: response.data.provider || "marianmt",
+                model: response.data.model || "unknown",
+            };
+        } catch (error) {
+            console.error("Error translating with MarianMT", error?.response?.data || error?.message || error);
+            return null;
+        }
+    }
+
+    if (TRANSLATION_PROVIDER !== "openai") {
+        console.error(`Unsupported translation provider: ${TRANSLATION_PROVIDER}`);
+        return null;
+    }
+
     const apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) return null;