localewarden 0.1.1 → 0.3.0

package/dist/ui/server.js

@@ -0,0 +1,194 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import http from 'node:http';
+import { LockError } from '../lock.js';
+import { listReview, updateReview } from '../review.js';
+import { checkProject } from '../project.js';
+import { loadPlugins, PluginHost } from '../plugins.js';
+import { run } from '../translate.js';
+import { editString, status, strings } from './data.js';
+import { PAGE } from './page.js';
+const MAX_BODY = 1_000_000;
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let size = 0;
+        const chunks = [];
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY) {
+                reject(new Error('Request too large.'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            try {
+                resolve(chunks.length ? JSON.parse(Buffer.concat(chunks).toString('utf8')) : {});
+            }
+            catch {
+                reject(new Error('Body must be JSON.'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+const sameToken = (a, b) => {
+    const x = Buffer.from(a);
+    const y = Buffer.from(b);
+    return x.length === y.length && timingSafeEqual(x, y);
+};
+/**
+ * Local web interface: overview, strings with inline editing, check findings, review list,
+ * and runs with live log. Listens on 127.0.0.1 only; every request needs the random token
+ * from the printed URL (page) or the X-Localewarden-Token header (API), and the Host header
+ * must be the local address, which blocks other websites and DNS rebinding.
+ */
+export async function startUi(config, options = {}) {
+    const token = options.token ?? randomBytes(18).toString('base64url');
+    const plugins = new PluginHost(options.plugins ?? (await loadPlugins(config)));
+    let job = null;
+    let lastCheck = null;
+    let port = 0;
+    const send = (res, code, body, type = 'application/json') => {
+        res.writeHead(code, {
+            'Content-Type': `${type}; charset=utf-8`,
+            'Cache-Control': 'no-store',
+            'X-Content-Type-Options': 'nosniff',
+            'Referrer-Policy': 'no-referrer',
+            'Content-Security-Policy': "default-src 'self'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'; frame-ancestors 'none'",
+        });
+        res.end(type === 'application/json' ? JSON.stringify(body) : String(body));
+    };
+    const startJob = (kind, work) => {
+        job = { kind, running: true, lines: [], dropped: 0, started: new Date().toISOString() };
+        const current = job;
+        const log = (line) => {
+            current.lines.push(line);
+            if (current.lines.length > 5000) {
+                const excess = current.lines.length - 5000;
+                current.lines.splice(0, excess);
+                current.dropped += excess;
+            }
+        };
+        work(log)
+            .then(result => Object.assign(current, result))
+            .catch((error) => {
+            current.error = error.message;
+        })
+            .finally(() => {
+            current.running = false;
+        });
+    };
+    const server = http.createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+            const host = req.headers.host ?? '';
+            if (host !== `127.0.0.1:${port}` && host !== `localhost:${port}`)
+                return send(res, 403, { error: 'Wrong host.' });
+            if (url.pathname === '/' && req.method === 'GET') {
+                if (!sameToken(url.searchParams.get('t') ?? '', token))
+                    return send(res, 403, 'Open the URL printed by "localewarden ui" (it contains the access token).', 'text/plain');
+                return send(res, 200, PAGE, 'text/html');
+            }
+            if (!url.pathname.startsWith('/api/'))
+                return send(res, 404, { error: 'Not found.' });
+            if (!sameToken(String(req.headers['x-localewarden-token'] ?? ''), token))
+                return send(res, 403, { error: 'Missing or wrong token.' });
+            const route = `${req.method} ${url.pathname}`;
+            const q = url.searchParams;
+            switch (route) {
+                case 'GET /api/status':
+                    return send(res, 200, { ...status(config, plugins), job: job && { kind: job.kind, running: job.running } });
+                case 'GET /api/strings':
+                    return send(res, 200, strings(config, plugins, {
+                        group: q.get('group') || undefined,
+                        lang: q.get('lang') ?? '',
+                        q: q.get('q') || undefined,
+                        only: (q.get('only') || undefined),
+                        limit: Number(q.get('limit') ?? 200),
+                    }));
+                case 'POST /api/strings': {
+                    if (job?.running && job.kind === 'run')
+                        return send(res, 409, { error: 'A run is in progress; edit after it finished.' });
+                    const body = (await readBody(req));
+                    return send(res, 200, editString(config, plugins, body));
+                }
+                case 'GET /api/review':
+                    return send(res, 200, listReview(config, q.get('all') === '1'));
+                case 'POST /api/review': {
+                    const body = (await readBody(req));
+                    if (body.action !== 'approve' && body.action !== 'release')
+                        return send(res, 400, { error: 'action must be approve or release.' });
+                    if (!Array.isArray(body.selectors) || !body.selectors.every(s => typeof s === 'string'))
+                        return send(res, 400, { error: 'selectors must be a list.' });
+                    return send(res, 200, { changed: updateReview(config, body.action, body.selectors) });
+                }
+                case 'GET /api/findings': {
+                    const filter = (f) => (!q.get('lang') || f.lang === q.get('lang')) && (!q.get('check') || f.check === q.get('check')) && (!q.get('group') || f.group === q.get('group'));
+                    const all = lastCheck ?? [];
+                    const rows = all.filter(filter);
+                    return send(res, 200, { checked: lastCheck !== null, total: rows.length, rows: rows.slice(0, Number(q.get('limit') ?? 300)) });
+                }
+                case 'POST /api/check': {
+                    if (job?.running)
+                        return send(res, 409, { error: 'Something is already running.' });
+                    startJob('check', async (log) => {
+                        log('Checking all translations…');
+                        const findings = checkProject(config, { plugins: plugins.plugins });
+                        lastCheck = findings;
+                        log(`${findings.length} finding(s).`);
+                        return { findings: [] };
+                    });
+                    return send(res, 202, { started: true });
+                }
+                case 'POST /api/run': {
+                    if (job?.running)
+                        return send(res, 409, { error: 'Something is already running.' });
+                    const body = (await readBody(req));
+                    const mode = body.mode ?? 'dry-run';
+                    if (!['dry-run', 'translate', 'fix-flagged'].includes(mode))
+                        return send(res, 400, { error: 'mode must be dry-run, translate or fix-flagged.' });
+                    startJob('run', async (log) => {
+                        const summary = await run(config, {
+                            dryRun: mode === 'dry-run',
+                            fixFlagged: mode === 'fix-flagged',
+                            groups: body.groups?.length ? body.groups : undefined,
+                            languages: body.languages?.length ? body.languages : undefined,
+                            plugins: plugins.plugins,
+                            model: options.model,
+                            logger: { info: log, warn: m => log(`warning: ${m}`), error: m => log(`error: ${m}`) },
+                        });
+                        return { summary };
+                    });
+                    return send(res, 202, { started: true });
+                }
+                case 'GET /api/job':
+                    if (!job)
+                        return send(res, 200, null);
+                    {
+                        // `from` counts all lines ever logged; the oldest may have been dropped.
+                        const from = Math.max(0, Number(q.get('from') ?? 0) - job.dropped);
+                        return send(res, 200, { ...job, findings: undefined, lines: job.lines.slice(from), lineCount: job.dropped + job.lines.length });
+                    }
+                default:
+                    return send(res, 404, { error: 'Not found.' });
+            }
+        }
+        catch (error) {
+            // A run (here or in another process) holds the lock: try again when it is done.
+            if (error instanceof LockError)
+                return send(res, 409, { error: error.message });
+            return send(res, 400, { error: error.message });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(options.port ?? 4848, '127.0.0.1', () => resolve());
+    });
+    port = server.address().port;
+    return {
+        url: `http://127.0.0.1:${port}/?t=${token}`,
+        token,
+        close: () => new Promise(resolve => server.close(() => resolve())),
+    };
+}

package/dist/util.d.ts

@@ -1,4 +1,4 @@
-/** Short content hash used in the state files. */
+/** Short content hash. NFC-normalized, so an editor that stores "é" decomposed is no edit. */
 export declare const hash: (value: string) => string;
 export declare const today: () => string;
 export declare const sleep: (ms: number) => Promise<void>;
@@ -10,5 +10,9 @@ export declare const isTraditionalChinese: (lang: string) => boolean;
 /** English name of a language code ("de" -> "German", "pt-BR" -> "Brazilian Portuguese"). */
 export declare function languageName(lang: string): string;
 export declare function sortObject<T>(obj: Record<string, T>): Record<string, T>;
-/** Runs `worker` over `items` with at most `concurrency` in flight. */
+/**
+ * Runs `worker` over `items` with at most `concurrency` in flight. After the first error no
+ * new item starts, and the error is thrown only once every running worker has finished, so
+ * nothing keeps writing after the caller has cleaned up (released its lock).
+ */
 export declare function inParallel<T>(items: T[], concurrency: number, worker: (item: T) => Promise<void>): Promise<void>;

package/dist/util.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
-/** Short content hash used in the state files. */
-export const hash = (value) => createHash('sha256').update(value.trim()).digest('hex').slice(0, 12);
+/** Short content hash. NFC-normalized, so an editor that stores "é" decomposed is no edit. */
+export const hash = (value) => createHash('sha256').update(value.normalize('NFC').trim()).digest('hex').slice(0, 12);
 export const today = () => new Date().toISOString().slice(0, 10);
 export const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 export const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -21,14 +21,26 @@ export function languageName(lang) {
 export function sortObject(obj) {
     return Object.fromEntries(Object.entries(obj).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
 }
-/** Runs `worker` over `items` with at most `concurrency` in flight. */
+/**
+ * Runs `worker` over `items` with at most `concurrency` in flight. After the first error no
+ * new item starts, and the error is thrown only once every running worker has finished, so
+ * nothing keeps writing after the caller has cleaned up (released its lock).
+ */
 export async function inParallel(items, concurrency, worker) {
     let next = 0;
+    let failure = null;
     const run = async () => {
-        while (next < items.length) {
+        while (!failure && next < items.length) {
             const item = items[next++];
-            await worker(item);
+            try {
+                await worker(item);
+            }
+            catch (error) {
+                failure ??= { error };
+            }
         }
     };
     await Promise.all(Array.from({ length: Math.max(1, Math.min(concurrency, items.length)) }, run));
+    if (failure)
+        throw failure.error;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "localewarden",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Incremental AI translation for JSON locale files: translates only what changed, never overwrites hand edits, and checks every result before writing it.",
   "type": "module",
   "bin": {
@@ -39,6 +39,17 @@
     "json",
     "locales",
     "i18next",
+    "react-intl",
+    "vue-i18n",
+    "next-intl",
+    "fastlane",
+    "flutter",
+    "arb",
+    "app-store",
+    "ai-translation",
+    "gpt",
+    "chatgpt",
+    "translation-quality",
     "cli"
   ],
   "repository": {