@l10nmonster/server 3.0.0-alpha.9 → 3.1.1

package/CHANGELOG.md

@@ -1,3 +1,48 @@
+## @l10nmonster/server [3.1.1](https://public-github/l10nmonster/l10nmonster/compare/@l10nmonster/server@3.1.0...@l10nmonster/server@3.1.1) (2025-12-23)
+
+
+### Bug Fixes
+
+* Improve type definitions and checks ([826b412](https://public-github/l10nmonster/l10nmonster/commit/826b412f0f7e761d404165a243b0c2b26c416ac1))
+
+# @l10nmonster/server [3.1.0](https://public-github/l10nmonster/l10nmonster/compare/@l10nmonster/server@3.0.0...@l10nmonster/server@3.1.0) (2025-12-20)
+
+
+### Bug Fixes
+
+* Active filter not working ([f1c5e85](https://public-github/l10nmonster/l10nmonster/commit/f1c5e85dedcd197b4ec94d48b90c43c67ceb824a))
+* Calibrate log severities ([2b3350a](https://public-github/l10nmonster/l10nmonster/commit/2b3350a3123abb91e7f91a9c1864daeb6275c3ad))
+* **core:** Performance improvements ([09dbd9d](https://public-github/l10nmonster/l10nmonster/commit/09dbd9db8bd494c2a5698af39547462fd0a853bc))
+* **core:** Tm cleanup doesn't bump job date ([cfe5860](https://public-github/l10nmonster/l10nmonster/commit/cfe5860930ff6d98945930e136d262a94914df2b))
+* **server:** Add project filtering to status pages ([89177fe](https://public-github/l10nmonster/l10nmonster/commit/89177feceae34c5fecb942c8e31406356f573479))
+* **server:** Fix cart cleanup ([9bbcab9](https://public-github/l10nmonster/l10nmonster/commit/9bbcab93e1fd20aeb09f59c828665159f091f37c))
+* **server:** Fix drop downs and alerts ([af9450c](https://public-github/l10nmonster/l10nmonster/commit/af9450c7faa6debf23edc2e215b92c7000fc574b))
+* **server:** Fix unit test ([bace95e](https://public-github/l10nmonster/l10nmonster/commit/bace95e20a621425febb03e1c729f4507c453168))
+* **server:** home page improvements ([afe9264](https://public-github/l10nmonster/l10nmonster/commit/afe9264fa54cb4440559b6eb3dfcaa8b66f9238d))
+* **server:** Improve error handling ([e635adf](https://public-github/l10nmonster/l10nmonster/commit/e635adf499410da8b85cad91e61202abad642549))
+* **server:** Improve TM Detail performance ([836bebf](https://public-github/l10nmonster/l10nmonster/commit/836bebf45aceafd0ee0887aa4689bf41affbbcab))
+* **server:** Improve UI ([9b18a83](https://public-github/l10nmonster/l10nmonster/commit/9b18a83d7f1d831eff4b91a5b4e323175b233855))
+* **server:** Migrate from Material UI to Chakra UI 3.0 ([f02f0b3](https://public-github/l10nmonster/l10nmonster/commit/f02f0b39487a993fe0ba8cea7ccdd25981ced149))
+* **server:** More Status page optimizations ([1b37177](https://public-github/l10nmonster/l10nmonster/commit/1b3717708780767296e0e81e3b3cb43404dbf874))
+* **server:** Move only leveraged filter server side plus optimizations ([c3a7525](https://public-github/l10nmonster/l10nmonster/commit/c3a7525f819a866f60e9ef52e2b0e38f8263e069))
+* **server:** UI tweaks ([0ad528e](https://public-github/l10nmonster/l10nmonster/commit/0ad528eaaa01dd5deffd2b6443a752dda310ccc8))
+* Version bumps ([d3030bd](https://public-github/l10nmonster/l10nmonster/commit/d3030bdd0af6ddbc79b3076af7427111ca9b04d0))
+
+
+### Features
+
+* **core:** Major refactor ([6992ee4](https://public-github/l10nmonster/l10nmonster/commit/6992ee4d74ad2e25afef6220f92f2e72dfd02457))
+* Improve LQA Boss ([fcb0818](https://public-github/l10nmonster/l10nmonster/commit/fcb0818181f1a7bd46764596c9d2b8d8f362375c))
+* Refactor TM TOC page for performance ([0088b3c](https://public-github/l10nmonster/l10nmonster/commit/0088b3c2b69cdd00bc27697f50c892429f113f80))
+* **server:** Add group to TMDetail page ([9d7ff6d](https://public-github/l10nmonster/l10nmonster/commit/9d7ff6d9ebf15747e7e345edd0e38f92ec7afe36))
+* **server:** Add job page ([5014b8e](https://public-github/l10nmonster/l10nmonster/commit/5014b8e40accfe007281e5a744c8b714f4c34676))
+* **server:** Add translation status to Sources page ([b73d4ec](https://public-github/l10nmonster/l10nmonster/commit/b73d4ec043ef37fc78ae2b548e7623aeb07c1ec1))
+* **server:** Break down untranslated content by group ([7544c98](https://public-github/l10nmonster/l10nmonster/commit/7544c98e1c1beadf2f0b939eb29f527a7f11101d))
+* **server:** Major improvements ([c8f9c2e](https://public-github/l10nmonster/l10nmonster/commit/c8f9c2e2fdf236a58df31ef1b9f22b626ccd35d8))
+* **server:** New features and improvements ([1d18c14](https://public-github/l10nmonster/l10nmonster/commit/1d18c14037ba4838fda6090f120529b09ff9bfa9))
+* **server:** Support for route extensions ([6e42ca0](https://public-github/l10nmonster/l10nmonster/commit/6e42ca0fa18af279fa152dfe447155b7951f8ff3))
+* **server:** Support multi-select drop downs in TMDetail ([872c529](https://public-github/l10nmonster/l10nmonster/commit/872c529c621a9f5561b842658248d0aa41a13996))
+
 # Changelog
 
 All notable changes to this project will be documented in this file.

package/index.js

@@ -2,60 +2,167 @@ import express from 'express';
 import cors from 'cors';
 import path from 'path';
 import open from 'open';
-import { readFileSync } from 'fs';
-import { getBaseDir } from '@l10nmonster/core';
+import os from 'os';
+import { setupInfoRoute } from './routes/info.js';
 import { setupStatusRoute } from './routes/status.js';
-import { setupActiveContentStatsRoute } from './routes/sources.js';
+import { setupChannelRoutes } from './routes/sources.js';
 import { setupTmRoutes } from './routes/tm.js';
+import { setupProviderRoute } from './routes/providers.js';
+import { setupDispatcherRoutes } from './routes/dispatcher.js';
+import { consoleLog, l10nMonsterVersion, l10nMonsterDescription } from '@l10nmonster/core';
 
-const serverPackage = JSON.parse(readFileSync(path.join(import.meta.dirname, 'package.json'), 'utf-8'));
-
-export default class serve {
-    static help = {
+/**
+ * CLI action for starting the L10n Monster server.
+ * @type {import('@l10nmonster/core').L10nAction & { extensions: Record<string, Function>, registerExtension: (name: string, routeMaker: Function) => void }}
+ */
+const ServeAction = {
+    extensions: {},
+    name: 'serve',
+    help: {
         description: 'starts the L10n Monster server.',
         options: [
-            [ '--port <number>', 'listen to specified port' ],
+            [ '--host <address>', 'hostname/IP to bind to and open in browser (default: all interfaces)' ],
+            [ '--port <number>', 'listen to specified port (default: 9691)' ],
             [ '--ui', 'also serve a web frontend' ],
+            [ '--open', 'open browser with web frontend' ],
         ]
-    };
+    },
+
+    registerExtension(name, routeMaker) {
+        this.extensions[name] = routeMaker;
+    },
 
-    static async action(mm, options) {
+    async action(mm, options) {
         const port = options.port ?? 9691;
+        const host = options.host; // undefined means listen on all interfaces
         const app = express();
 
         // === Middleware ===
         app.use(cors());
         app.use(express.json());
+        app.use(express.json({ limit: '10mb' }));
 
         // === API Routes ===
         const apiRouter = express.Router();
 
-        apiRouter.get('/info', async (req, res) => {
-            res.json({
-                version: serverPackage.version,
-                description: serverPackage.description,
-                baseDir: path.resolve(getBaseDir()),
-            });
-        });
-    
         // Setup routes from separate files
+        setupInfoRoute(apiRouter, mm, l10nMonsterVersion, l10nMonsterDescription);
         setupStatusRoute(apiRouter, mm);
-        setupActiveContentStatsRoute(apiRouter, mm);
+        setupChannelRoutes(apiRouter, mm);
         setupTmRoutes(apiRouter, mm);
+        setupProviderRoute(apiRouter, mm);
+        setupDispatcherRoutes(apiRouter, mm);
 
         // Mount the API router under the /api prefix
         app.use('/api', apiRouter);
 
-        if (options.ui) {
+        for (const [name, routeMaker] of Object.entries(ServeAction.extensions)) {
+            const extensionRouter = express.Router();
+            const routes = routeMaker(mm);
+            for (const [method, path, handler] of routes) {
+                extensionRouter[method](path, handler);
+            }
+            app.use(`/api/ext/${name}`, extensionRouter);
+            consoleLog`Mounted extension ${name} at /api/ext/${name}`;
+        }
+
+        // API 404 handler - must come before the UI catch-all
+        app.use('/api/*splat', (req, res) => {
+            res.status(404).json({
+                error: 'API endpoint not found',
+                path: req.path,
+                method: req.method
+            });
+        });
+
+        if (options.ui || options.open) {
             const uiDistPath = path.join(import.meta.dirname, 'ui', 'dist');
             app.use(express.static(uiDistPath)); // rest of dist files
             app.get('/*splat', (req, res) => res.sendFile(path.join(uiDistPath, 'index.html'))); // fallback for Client-Side Routing
         }
 
         // === Start Server ===
-        app.listen(port, async () => {
-            console.log(`🚀 L10n Monster Server listening on port ${port}`);
-            options.ui && await open(`http://localhost:${port}`);
+        const listenArgs = [port];
+        if (host) {
+            listenArgs.push(host);
+        }
+
+        const server = app.listen(...listenArgs, async () => {
+            const address = server.address();
+
+            consoleLog`L10n Monster Server v${l10nMonsterVersion} started 🚀\n`;
+
+            // Handle Unix domain sockets (string) vs TCP sockets (AddressInfo)
+            if (typeof address === 'string') {
+                consoleLog`  Listening on Unix socket:`;
+                consoleLog`  - ${address}`;
+
+                if (options.open && options.ui) {
+                    consoleLog`\n  ⚠️  Cannot open browser for Unix domain socket. Please access the server manually.`;
+                }
+            } else {
+                const boundPort = address.port;
+                const boundAddress = address.address;
+
+                consoleLog`  Available at:`;
+
+                // Determine what URLs to show and what to open
+                let openHost = host || 'localhost'; // Default to localhost for opening
+
+                // If listening on all interfaces (0.0.0.0 or ::)
+                if (!host || boundAddress === '0.0.0.0' || boundAddress === '::') {
+                    // Show localhost first
+                    consoleLog`  - http://localhost:${boundPort}`;
+                    consoleLog`  - http://127.0.0.1:${boundPort}`;
+
+                    // Get all network interfaces
+                    const interfaces = os.networkInterfaces();
+                    for (const [name, addresses] of Object.entries(interfaces)) {
+                        for (const addr of addresses) {
+                            // Skip internal interfaces and IPv6 link-local addresses
+                            if (!addr.internal && addr.family === 'IPv4') {
+                                consoleLog`  - http://${addr.address}:${boundPort} (${name})`;
+                            }
+                        }
+                    }
+                } else {
+                    // Specific address was bound
+                    openHost = boundAddress; // Use the bound address for opening
+                    consoleLog`  - http://${boundAddress}:${boundPort}`;
+
+                    // Also show localhost if we bound to 127.0.0.1
+                    if (boundAddress === '127.0.0.1') {
+                        consoleLog`  - http://localhost:${boundPort}`;
+                    }
+                }
+
+                if (options.open) {
+                    const openUrl = `http://${openHost}:${boundPort}`;
+                    consoleLog``;
+                    consoleLog`  Opening browser at: ${openUrl}`;
+                    await open(openUrl);
+                }
+            }
+            consoleLog``;
+        });
+
+        // Handle server binding errors
+        server.on('error', (error) => {
+            if (error.code === 'EADDRINUSE') {
+                const addressStr = host ? `${host}:${port}` : `port ${port}`;
+                throw new Error(`Failed to bind server: Address ${addressStr} is already in use`);
+            } else if (error.code === 'EACCES') {
+                const addressStr = host ? `${host}:${port}` : `port ${port}`;
+                throw new Error(`Failed to bind server: Permission denied for ${addressStr}`);
+            } else if (error.code === 'EADDRNOTAVAIL') {
+                throw new Error(`Failed to bind server: Address ${host} is not available on this system`);
+            } else {
+                throw new Error(`Failed to bind server: ${error.message}`);
+            }
         });
+
+        return server;
     }
-}
+};
+
+export default ServeAction;

package/interfaces.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Central type definitions for @l10nmonster/server
+ * This is the single source of truth for server-related interfaces.
+ */
+
+/**
+ * Express-compatible route handler function.
+ */
+export type RouteHandler = (req: unknown, res: unknown) => Promise<void> | void;
+
+/**
+ * Route definition tuple: [method, path, handler].
+ * Method is HTTP method (get, post, put, delete, etc.).
+ */
+export type RouteDefinition = [string, string, RouteHandler];
+
+/**
+ * Server extension route factory function.
+ * Creates routes for a server extension given a MonsterManager instance.
+ */
+export type ServerExtensionRouteMaker = (mm: unknown) => RouteDefinition[];

package/package.json

@@ -1,16 +1,17 @@
 {
     "name": "@l10nmonster/server",
-    "version": "3.0.0-alpha.9",
+    "version": "3.1.1",
     "description": "L10n Monster Manager",
     "type": "module",
     "main": "index.js",
     "dependencies": {
         "@chakra-ui/react": "^3.2.0",
         "@emotion/react": "^11.14.0",
+        "@tanstack/react-query": "^5.85.5",
         "cors": "^2.8.5",
         "dotenv": "^17",
         "express": "^5.1.0",
-        "lucide-react": "^0.525.0",
+        "lucide-react": "^0.553.0",
         "next-themes": "^0.4.6",
         "open": "^10.1.1",
         "react": "^19.1.0",
@@ -31,7 +32,8 @@
         "lint": "eslint .",
         "lint:fix": "eslint . --fix",
         "format": "prettier --write \"ui/src/**/*.{js,jsx,ts,tsx,json,css,md}\"",
-        "type-check": "tsc --noEmit"
+        "type-check": "tsc --noEmit",
+        "typecheck": "tsc --noEmit"
     },
     "eslintConfig": {
         "extends": [
@@ -60,21 +62,21 @@
         "@types/react-dom": "^19.0.2",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
         "@typescript-eslint/parser": "^8.0.0",
-        "@vitejs/plugin-react": "^4.4.1",
-        "@vitest/coverage-v8": "^3.1.2",
-        "@vitest/ui": "^3.1.2",
+        "@vitejs/plugin-react": "^5",
+        "@vitest/coverage-v8": "^4",
+        "@vitest/ui": "^4",
         "eslint": "^9",
         "eslint-config-prettier": "^10",
         "eslint-plugin-prettier": "^5.0.0",
         "eslint-plugin-react": "^7.35.0",
-        "eslint-plugin-react-hooks": "^5",
-        "jsdom": "^26.1.0",
+        "eslint-plugin-react-hooks": "^7",
+        "jsdom": "^27",
         "prettier": "^3.5.0",
         "supertest": "^7.0.0",
         "typescript": "^5.7.3",
         "vite": "^7",
         "vite-tsconfig-paths": "^5.1.4",
-        "vitest": "^3.1.2"
+        "vitest": "^4"
     },
     "engines": {
         "node": ">=22.11.0"

package/routes/dispatcher.js

@@ -0,0 +1,116 @@
+import { logInfo, logVerbose, logWarn } from '@l10nmonster/core';
+
+async function createJob(mm, sourceLang, targetLang, guids, provider) {
+    logVerbose`Creating job with ${guids.length} TUs for provider ${provider}`;
+
+    // Expand TUs from guids to full TU data
+    const tm = mm.tmm.getTM(sourceLang, targetLang);
+    const expandedTus = await tm.queryByGuids(guids);
+
+    // Call the MonsterManager dispatcher with single provider
+    const jobs = await mm.dispatcher.createJobs(
+        { sourceLang, targetLang, tus: expandedTus },
+        { providerList: [provider], skipQualityCheck: true, skipGroupCheck: true }
+    );
+
+    // Find the job for this provider (if accepted)
+    const job = jobs.find(j => j.translationProvider === provider);
+
+    if (!job) {
+        logVerbose`Provider ${provider} did not accept any TUs`;
+        return null;
+    }
+
+    return job;
+}
+
+export function setupDispatcherRoutes(router, mm) {
+    router.post('/dispatcher/estimateJob', async (req, res) => {
+        logInfo`/dispatcher/estimateJob`;
+
+        try {
+            const { sourceLang, targetLang, guids, provider } = req.body;
+
+            // Validate required parameters
+            if (!sourceLang || !targetLang || !guids || !provider) {
+                return res.status(400).json({
+                    error: 'Missing required parameters: sourceLang, targetLang, guids, provider'
+                });
+            }
+
+            // Validate that guids is an array
+            if (!Array.isArray(guids)) {
+                return res.status(400).json({
+                    error: 'guids must be an array'
+                });
+            }
+
+            // Create job with provider
+            const job = await createJob(mm, sourceLang, targetLang, guids, provider);
+
+            if (!job) {
+                return res.json(null);
+            }
+
+            // Return job with guids array instead of full tus to minimize payload
+            const { tus: jobTus, ...jobWithoutTus } = job;
+            const estimatedJob = {
+                ...jobWithoutTus,
+                guids: jobTus.map(tu => tu.guid)
+            };
+
+            logVerbose`Estimated job with ${estimatedJob.guids.length} TUs`;
+            res.json(estimatedJob);
+        } catch (error) {
+            logWarn`Error estimating job: ${error.message}`;
+            res.status(500).json({
+                error: 'Failed to estimate job',
+                message: error.message
+            });
+        }
+    });
+
+    router.post('/dispatcher/startJob', async (req, res) => {
+        logInfo`/dispatcher/startJob`;
+
+        try {
+            const { sourceLang, targetLang, guids, provider, jobName, instructions } = req.body;
+
+            // Validate required parameters
+            if (!sourceLang || !targetLang || !guids || !provider) {
+                return res.status(400).json({
+                    error: 'Missing required parameters: sourceLang, targetLang, guids, provider'
+                });
+            }
+
+            // Validate that guids is an array
+            if (!Array.isArray(guids)) {
+                return res.status(400).json({
+                    error: 'guids must be an array'
+                });
+            }
+
+            // Create job with provider
+            const job = await createJob(mm, sourceLang, targetLang, guids, provider);
+
+            if (!job) {
+                return res.status(400).json({
+                    error: `Provider ${provider} did not accept any TUs`
+                });
+            }
+
+            // Start the job
+            const result = await mm.dispatcher.startJobs([job], { jobName, instructions });
+
+            logVerbose`Started job with name: ${jobName || 'none'} and instructions: ${instructions || 'none'}`;
+            res.json(result);
+
+        } catch (error) {
+            logWarn`Error starting job: ${error.message}`;
+            res.status(500).json({
+                error: 'Failed to start job',
+                message: error.message
+            });
+        }
+    });
+}

package/routes/info.js

@@ -0,0 +1,25 @@
+import { logInfo, getBaseDir, logWarn } from '@l10nmonster/core';
+import path from 'path';
+
+export function setupInfoRoute(router, mm, version, description) {
+    router.get('/info', async (req, res) => {
+        logInfo`/info`;
+        try {
+            res.json({
+                version,
+                description,
+                baseDir: path.resolve(getBaseDir()),
+                providers: mm.dispatcher.providers.map(p => ({id: p.id, type: p.constructor.name})),
+                channels: mm.rm.channelIds.map(id => mm.rm.getChannel(id).getInfo()),
+                tmStores: mm.tmm.tmStoreIds.map(id => mm.tmm.getTmStoreInfo(id)),
+                snapStores: mm.rm.snapStoreIds.map(id => mm.rm.getSnapStoreInfo(id)),
+            });
+        } catch (error) {
+            logWarn`Error in /info: ${error.message}`;
+            res.status(500).json({
+                error: 'Failed to get system info',
+                message: error.message
+            });
+        }
+    });
+}

package/routes/providers.js

@@ -0,0 +1,17 @@
+import { logInfo, logVerbose } from '@l10nmonster/core';
+
+export function setupProviderRoute(apiRouter, mm) {
+  apiRouter.get('/providers/:providerId', async (req, res) => {
+    const { providerId } = req.params;
+    logInfo`/providers/${providerId}`;
+    try {
+      const provider = mm.dispatcher.getProvider(providerId);
+      const { id, ...info } = await provider.info();
+      logVerbose`Returned provider info for ${id}`;
+      res.json({ properties: provider, info });
+    } catch (error) {
+      console.error('Error fetching provider data:', error);
+      res.status(500).json({ error: 'Failed to fetch provider data' });
+    }
+  });
+}

package/routes/sources.js

@@ -1,10 +1,52 @@
-export function setupActiveContentStatsRoute(router, mm) {
-    router.get('/activeContentStats', async (req, res) => {
-        const sources = {};
-        for (const channelId of Object.keys(mm.rm.channels)) {
-            const channelStats = await mm.rm.getActiveContentStats(channelId);
-            sources[channelId] = channelStats;
+import { logInfo, logVerbose, logWarn } from '@l10nmonster/core';
+
+export function setupChannelRoutes(router, mm) {
+    router.get('/channel/:channelId', async (req, res) => {
+        const { channelId } = req.params;
+        logInfo`/channel/${channelId}`;
+        try {
+            const { ts, store } = await mm.rm.getChannelMeta(channelId);
+            const projects = await mm.rm.getActiveContentStats(channelId);
+            logVerbose`Returned active content stats for ${projects.length} projects`;
+            res.json({ ts, store, projects });
+        } catch (error) {
+            logWarn`Error in /channel/${channelId}: ${error.message}`;
+            res.status(500).json({
+                error: 'Failed to get channel data',
+                message: error.message
+            });
+        }
+    });
+    router.get('/channel/:channelId/:prj', async (req, res) => {
+        const { channelId, prj } = req.params;
+        const { offset, limit } = req.query;
+        logInfo`/channel/${channelId}/${prj} (offset=${offset}, limit=${limit})`;
+        try {
+            const projectTOC = await mm.rm.getProjectTOC(channelId, prj, offset, limit);
+            logVerbose`Returned project TOC for ${prj} with ${projectTOC.length} resources`;
+            res.json(projectTOC);
+        } catch (error) {
+            logWarn`Error in /channel/${channelId}/${prj}: ${error.message}`;
+            res.status(500).json({
+                error: 'Failed to get project TOC',
+                message: error.message
+            });
+        }
+    });
+    router.get('/resource/:channelId', async (req, res) => {
+        const { channelId } = req.params;
+        const { rid } = req.query;
+        logInfo`/resource/${channelId}/${rid}`;
+        try {
+            const resource = await mm.rm.getResourceHandle(channelId, rid, { keepRaw: true });
+            logVerbose`Returned resource ${rid} with ${resource.segments.length} segments`;
+            res.json(resource);
+        } catch (error) {
+            logWarn`Error in /resource/${channelId}/${rid}: ${error.message}`;
+            res.status(500).json({
+                error: 'Failed to get resource',
+                message: error.message
+            });
         }
-        res.json(sources);
     });
 } 

package/routes/status.js

@@ -1,34 +1,34 @@
+import { logInfo, logVerbose, logWarn } from '@l10nmonster/core';
+
 export function setupStatusRoute(router, mm) {
-    router.get('/status', async (req, res) => {
+    router.get('/status/:channelId', async (req, res) => {
+        const { channelId } = req.params;
+        logInfo`/status/${channelId}`;
         try {
-            const status = await mm.getTranslationStatus();
-            
-            // Transform the structure from:
-            // source_lang -> target_lang -> channel -> project -> data
-            // to:
-            // channel -> project -> source_lang -> target_lang -> data
-            const flippedStatus = {};
-            
-            for (const [sourceLang, targetLangs] of Object.entries(status)) {
-                for (const [targetLang, channels] of Object.entries(targetLangs)) {
-                    for (const [channelId, projects] of Object.entries(channels)) {
-                        for (const [projectName, data] of Object.entries(projects)) {
-                            // Initialize nested structure if it doesn't exist
-                            flippedStatus[channelId] ??= {};
-                            flippedStatus[channelId][projectName] ??= {};
-                            flippedStatus[channelId][projectName][sourceLang] ??= {};
-                            
-                            // Set the data at the new location
-                            flippedStatus[channelId][projectName][sourceLang][targetLang] = data;
-                        }
-                    }
-                }
-            }
-            
-            res.json(flippedStatus);
+            const status = await mm.getTranslationStatus(channelId);
+            // channel -> source_lang -> target_lang -> project -> data
+            logVerbose`Returned translation status`;
+            res.json(status[channelId]);
         } catch (error) {
             console.error('Error fetching status: ', error);
             res.status(500).json({ message: 'Problems fetching status data' });
         }
     });
-} 
+
+    router.get('/status/:channelId/:sourceLang/:targetLang', async (req, res) => {
+        const { channelId, sourceLang, targetLang } = req.params;
+        const { prj } = req.query;
+        logInfo`/status/${channelId}/${sourceLang}/${targetLang}${prj ? `?prj=${prj}` : ''}`;
+        try {
+            const tm = mm.tmm.getTM(sourceLang, targetLang);
+            const options = { limit: 500 };
+            if (prj) options.prj = [prj];
+            const tus = await tm.getUntranslatedContent(channelId, options);
+            logVerbose`Returned ${tus.length} untranslated TUs for ${sourceLang}->${targetLang} in channel ${channelId}${prj ? ` (project: ${prj})` : ''}`;
+            res.json(tus);
+        } catch (error) {
+            logWarn`Error: ${error.message}`;
+            res.status(500).json({ error: error.message });
+        }
+    });
+}