@l10nmonster/server 3.0.0-alpha.9 → 3.1.0

package/index.js

@@ -2,60 +2,164 @@ import express from 'express';
 import cors from 'cors';
 import path from 'path';
 import open from 'open';
+import os from 'os';
 import { readFileSync } from 'fs';
-import { getBaseDir } from '@l10nmonster/core';
+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 { logVerbose, consoleLog } from '@l10nmonster/core';
 
 const serverPackage = JSON.parse(readFileSync(path.join(import.meta.dirname, 'package.json'), 'utf-8'));
 
-export default class serve {
+export default class ServeAction {
+    static extensions = {};
+    static name = 'serve';
     static 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' ],
         ]
     };
 
+    static registerExtension(name, routeMaker) {
+        ServeAction.extensions[name] = routeMaker;
+    }
+
     static 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, serverPackage);
         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${serverPackage.version} 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;
     }
 }

package/package.json

@@ -1,16 +1,17 @@
 {
     "name": "@l10nmonster/server",
-    "version": "3.0.0-alpha.9",
+    "version": "3.1.0",
     "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",
@@ -60,21 +61,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, serverPackage) {
+    router.get('/info', async (req, res) => {
+        logInfo`/info`;
+        try {
+            res.json({
+                version: serverPackage.version,
+                description: serverPackage.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 });
+        }
+    });
+}