texlite 0.2.0

package/dist/server/spellCheck.js

@@ -0,0 +1,195 @@
+import nspell from "nspell";
+import dictionary from "dictionary-en";
+const checker = nspell(dictionary);
+const wordPattern = /[A-Za-z][A-Za-z0-9]*(?:['’][A-Za-z0-9]+)*/g;
+const keyTokenPattern = /([A-Za-z][A-Za-z0-9_.:/-]*(?:\s+[A-Za-z][A-Za-z0-9_.:/-]*){0,7})\s*$/;
+const tableEnvironments = new Set(["tabular", "tabularx", "tabulary", "longtable", "array", "matrix", "pmatrix", "bmatrix", "Bmatrix", "vmatrix", "Vmatrix"]);
+const optionCommands = new Set(["documentclass", "usepackage", "RequirePackage", "includegraphics", "tikzset", "pgfplotsset", "hypersetup", "lstset", "definecolor", "colorlet", "setlength", "setcounter", "draw", "path", "fill", "filldraw", "shade", "node", "addplot"]);
+const identifierCommands = new Set(["label", "hypertarget", "ref", "pageref", "autoref", "nameref", "hyperref", "index", "gls", "Gls", "glspl", "Glspl", "cite", "citep", "citet", "citeauthor", "citeyear", "citenum", "parencite", "textcite", "autocite", "footcite"]);
+function addRange(ranges, from, to) {
+    if (to > from)
+        ranges.push({ from, to });
+}
+function balancedArgument(source, start, open, close) {
+    if (source[start] !== open)
+        return null;
+    let depth = 0;
+    for (let index = start; index < source.length; index += 1) {
+        const escaped = source[index - 1] === "\\" && source[index - 2] !== "\\";
+        if (!escaped && source[index] === open)
+            depth += 1;
+        if (!escaped && source[index] === close) {
+            depth -= 1;
+            if (depth === 0)
+                return { from: start, to: index + 1, end: index + 1 };
+        }
+    }
+    return null;
+}
+function skipWhitespace(source, start) {
+    let index = start;
+    while (index < source.length && /[ \t\r\n]/.test(source[index]))
+        index += 1;
+    return index;
+}
+function isCommentStart(source, position) {
+    if (source[position] !== "%")
+        return false;
+    let slashes = 0;
+    for (let index = position - 1; index >= 0 && source[index] === "\\"; index -= 1)
+        slashes += 1;
+    return slashes % 2 === 0;
+}
+function optionLike(value) {
+    return /[=,!/]/.test(value) || /\b(?:colorbar|legend|width|height|draw|fill|style|domain|samples|anchor|at|axis)\b/.test(value);
+}
+function identifierCommand(name) {
+    return identifierCommands.has(name) || /^cite[A-Za-z]*/.test(name);
+}
+function addKeyValueRanges(source, ranges) {
+    for (let equals = source.indexOf("="); equals >= 0; equals = source.indexOf("=", equals + 1)) {
+        const delimiters = ["\n", "[", "{", "]", "}", ",", ";"];
+        const segmentStart = Math.max(...delimiters.map((delimiter) => source.lastIndexOf(delimiter, equals - 1) + 1));
+        const segment = source.slice(segmentStart, equals);
+        const key = segment.match(keyTokenPattern);
+        if (key?.index !== undefined)
+            addRange(ranges, segmentStart + key.index, equals);
+        let valueStart = equals + 1;
+        while (valueStart < source.length && /\s/.test(source[valueStart]))
+            valueStart += 1;
+        let valueEnd = valueStart;
+        if (source[valueStart] === "{") {
+            const argument = balancedArgument(source, valueStart, "{", "}");
+            valueEnd = argument?.end ?? valueStart;
+        }
+        else {
+            while (valueEnd < source.length && !/[,\]\}\n]/.test(source[valueEnd]))
+                valueEnd += 1;
+        }
+        addRange(ranges, valueStart, valueEnd);
+    }
+}
+function ignoredRanges(source) {
+    const ranges = [];
+    const commandPattern = /[A-Za-z@]/;
+    for (let index = 0; index < source.length; index += 1) {
+        if (isCommentStart(source, index)) {
+            const end = source.indexOf("\n", index);
+            addRange(ranges, index, end < 0 ? source.length : end);
+            index = end < 0 ? source.length : end;
+            continue;
+        }
+        if (source[index] !== "\\")
+            continue;
+        const commandStart = index;
+        let commandEnd = index + 1;
+        if (commandPattern.test(source[commandEnd] ?? "")) {
+            while (commandEnd < source.length && /[A-Za-z@0-9:_]/.test(source[commandEnd]))
+                commandEnd += 1;
+        }
+        else if (commandEnd < source.length) {
+            commandEnd += 1;
+        }
+        const name = source.slice(index + 1, commandEnd);
+        addRange(ranges, commandStart, commandEnd);
+        let cursor = skipWhitespace(source, commandEnd);
+        if (name === "begin" || name === "end") {
+            const environment = balancedArgument(source, cursor, "{", "}");
+            if (environment) {
+                addRange(ranges, environment.from, environment.to);
+                const environmentName = source.slice(environment.from + 1, environment.to - 1).trim();
+                cursor = skipWhitespace(source, environment.end);
+                if (name === "begin") {
+                    const options = balancedArgument(source, cursor, "[", "]");
+                    if (options) {
+                        addRange(ranges, options.from, options.to);
+                        cursor = skipWhitespace(source, options.end);
+                    }
+                    if (tableEnvironments.has(environmentName)) {
+                        const columnSpec = balancedArgument(source, cursor, "{", "}");
+                        if (columnSpec)
+                            addRange(ranges, columnSpec.from, columnSpec.to);
+                    }
+                }
+            }
+            index = commandEnd - 1;
+            continue;
+        }
+        if (identifierCommand(name)) {
+            if (source[cursor] === "*")
+                cursor = skipWhitespace(source, cursor + 1);
+            while (true) {
+                const argument = balancedArgument(source, cursor, "[", "]") ?? balancedArgument(source, cursor, "{", "}");
+                if (!argument)
+                    break;
+                addRange(ranges, argument.from, argument.to);
+                cursor = skipWhitespace(source, argument.end);
+            }
+        }
+        else {
+            const options = balancedArgument(source, cursor, "[", "]");
+            if (options && (optionCommands.has(name) || optionLike(source.slice(options.from + 1, options.to - 1)))) {
+                addRange(ranges, options.from, options.to);
+                cursor = skipWhitespace(source, options.end);
+            }
+            if (optionCommands.has(name)) {
+                const argumentsToSkip = name === "definecolor" || name === "colorlet" ? 3 : 1;
+                for (let count = 0; count < argumentsToSkip; count += 1) {
+                    const argument = balancedArgument(source, cursor, "{", "}");
+                    if (!argument)
+                        break;
+                    addRange(ranges, argument.from, argument.to);
+                    cursor = skipWhitespace(source, argument.end);
+                }
+            }
+        }
+        index = commandEnd - 1;
+    }
+    // Keep key/value handling as a general fallback for package settings that
+    // are not attached directly to a command.
+    addKeyValueRanges(source, ranges);
+    for (const match of source.matchAll(/(?:https?|ftp):\/\/[^\s]+/gi)) {
+        if (match.index !== undefined)
+            addRange(ranges, match.index, match.index + match[0].length);
+    }
+    ranges.sort((left, right) => left.from - right.from || left.to - right.to);
+    const merged = [];
+    for (const range of ranges) {
+        const previous = merged.at(-1);
+        if (previous && range.from <= previous.to)
+            previous.to = Math.max(previous.to, range.to);
+        else
+            merged.push({ ...range });
+    }
+    return merged;
+}
+function isInside(ranges, position, cursor) {
+    while (cursor.index < ranges.length && ranges[cursor.index].to <= position)
+        cursor.index += 1;
+    const range = ranges[cursor.index];
+    return Boolean(range && range.from <= position && position < range.to);
+}
+export function checkSpelling(source, customWords = []) {
+    const ignored = ignoredRanges(source);
+    const ignoredCursor = { index: 0 };
+    const custom = new Set(customWords.map((word) => word.toLocaleLowerCase("en-US")));
+    const issues = [];
+    for (const match of source.matchAll(wordPattern)) {
+        if (match.index === undefined)
+            continue;
+        const word = match[0];
+        const from = match.index;
+        const to = from + word.length;
+        if (isInside(ignored, from, ignoredCursor))
+            continue;
+        // Identifiers, acronyms, numbers, and title-case words are not natural-language
+        // prose for this editor. Hyphenated words are intentionally tokenized into
+        // separate words by `wordPattern`.
+        if (word.length < 2 || /\d/.test(word) || /^[A-Z]/.test(word))
+            continue;
+        if (custom.has(word.toLocaleLowerCase("en-US")) || checker.correct(word))
+            continue;
+        issues.push({ from, to, word });
+    }
+    return issues;
+}

package/dist/server/synctex.js

@@ -0,0 +1,56 @@
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const runFile = promisify(execFile);
+async function runSynctex(args, cwd) {
+    try {
+        const { stdout } = await runFile("synctex", args, {
+            cwd, timeout: 10_000, maxBuffer: 1024 * 1024, encoding: "utf8"
+        });
+        return stdout;
+    }
+    catch (error) {
+        const stderr = typeof error === "object" && error !== null && "stderr" in error
+            ? String(error.stderr) : "";
+        throw new Error(stderr.trim() || "SyncTeX 无法定位该位置，请重新编译项目");
+    }
+}
+export async function sourceToPdf(sourceDirectory, pdfPath, sourcePath, line, column) {
+    const output = await runSynctex([
+        "view", "-i", `${line}:${column}:${sourcePath}`, "-o", pdfPath
+    ], sourceDirectory);
+    const page = numericField(output, "Page");
+    const x = numericField(output, "x");
+    const y = numericField(output, "y");
+    if (!page || x === null || y === null)
+        throw new Error("SyncTeX 没有找到对应的 PDF 位置");
+    return {
+        page,
+        x,
+        y,
+        width: numericField(output, "W") ?? 0,
+        height: numericField(output, "H") ?? 0
+    };
+}
+export async function pdfToSource(sourceDirectory, pdfPath, page, x, y) {
+    const output = await runSynctex([
+        "edit", "-o", `${page}:${x}:${y}:${pdfPath}`
+    ], sourceDirectory);
+    const input = textField(output, "Input");
+    const line = numericField(output, "Line");
+    const column = numericField(output, "Column");
+    if (!input || !line)
+        throw new Error("SyncTeX 没有找到对应的源码位置");
+    const absoluteInput = path.isAbsolute(input) ? input : path.resolve(sourceDirectory, input);
+    return { input: absoluteInput, line, column: column && column > 0 ? column : 1 };
+}
+function numericField(output, name) {
+    const match = output.match(new RegExp(`^${name}:([-+]?\\d+(?:\\.\\d+)?)$`, "m"));
+    if (!match)
+        return null;
+    const value = Number(match[1]);
+    return Number.isFinite(value) ? value : null;
+}
+function textField(output, name) {
+    return output.match(new RegExp(`^${name}:(.+)$`, "m"))?.[1]?.trim() || null;
+}

package/dist/server/zip.js

@@ -0,0 +1,185 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import yauzl from "yauzl";
+import { safeRelativePath } from "./files.js";
+const MAX_ENTRIES = 1_000;
+const MAX_TOTAL_BYTES = 200 * 1024 * 1024;
+export async function extractProjectZip(buffer, destination, maxFileBytes) {
+    const maxTotalBytes = Math.max(MAX_TOTAL_BYTES, maxFileBytes);
+    const entries = await inspectZip(buffer, maxFileBytes, maxTotalBytes);
+    const prefix = commonRootPrefix(entries.filter((entry) => !entry.directory).map((entry) => entry.fileName));
+    fs.mkdirSync(destination, { recursive: true, mode: 0o700 });
+    const files = await extractZip(buffer, destination, prefix, maxFileBytes, maxTotalBytes);
+    const mainFile = discoverMainFile(destination, files);
+    if (!mainFile)
+        throw new Error("压缩包中没有找到 LaTeX 主文档（.tex）");
+    return { files, mainFile };
+}
+async function inspectZip(buffer, maxFileBytes, maxTotalBytes) {
+    const zip = await openZip(buffer);
+    return await new Promise((resolve, reject) => {
+        const entries = [];
+        const seenPaths = new Set();
+        let totalBytes = 0;
+        const fail = (error) => { zip.close(); reject(error); };
+        zip.on("error", reject);
+        zip.on("entry", (entry) => {
+            try {
+                validateEntry(entry);
+                if (entries.length >= MAX_ENTRIES)
+                    throw new Error(`ZIP 文件数量不能超过 ${MAX_ENTRIES}`);
+                totalBytes += entry.uncompressedSize;
+                if (entry.uncompressedSize > maxFileBytes)
+                    throw new Error(`ZIP 中存在超过 ${formatMB(maxFileBytes)} MB 的单个文件`);
+                if (totalBytes > maxTotalBytes)
+                    throw new Error(`ZIP 解压后总体积不能超过 ${formatMB(maxTotalBytes)} MB`);
+                const normalized = normalizedEntryName(entry.fileName);
+                // ZIP archives can contain duplicate entries.  Extraction of the
+                // second entry would otherwise silently replace the first one (and a
+                // `name`/`name/` pair would collide on disk as well).
+                const collisionKey = safeRelativePath(normalized.replace(/\/+$/, ""));
+                if (seenPaths.has(collisionKey))
+                    throw new Error(`ZIP 包含重复文件名：${collisionKey}`);
+                seenPaths.add(collisionKey);
+                entries.push({ fileName: normalized, uncompressedSize: entry.uncompressedSize, directory: /\/$/.test(entry.fileName) });
+                zip.readEntry();
+            }
+            catch (error) {
+                fail(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        zip.on("end", () => resolve(entries));
+        zip.readEntry();
+    });
+}
+async function extractZip(buffer, destination, prefix, maxFileBytes, maxTotalBytes) {
+    const zip = await openZip(buffer);
+    return await new Promise((resolve, reject) => {
+        const files = [];
+        let actualBytes = 0;
+        let settled = false;
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            zip.close();
+            reject(error instanceof Error ? error : new Error(String(error)));
+        };
+        zip.on("error", fail);
+        zip.on("entry", (entry) => {
+            void (async () => {
+                validateEntry(entry);
+                const normalized = normalizedEntryName(entry.fileName);
+                const stripped = prefix && normalized.startsWith(prefix) ? normalized.slice(prefix.length) : normalized;
+                if (!stripped || stripped.startsWith("__MACOSX/") || stripped.endsWith("/.DS_Store") || stripped === ".DS_Store") {
+                    zip.readEntry();
+                    return;
+                }
+                const relative = safeRelativePath(stripped);
+                const absolute = path.join(destination, relative);
+                if (/\/$/.test(entry.fileName)) {
+                    fs.mkdirSync(absolute, { recursive: true, mode: 0o700 });
+                    zip.readEntry();
+                    return;
+                }
+                fs.mkdirSync(path.dirname(absolute), { recursive: true, mode: 0o700 });
+                const input = await openEntryStream(zip, entry);
+                let entryBytes = 0;
+                const limiter = new Transform({
+                    transform(chunk, _encoding, callback) {
+                        actualBytes += chunk.length;
+                        entryBytes += chunk.length;
+                        if (entryBytes > maxFileBytes)
+                            callback(new Error(`ZIP 中单个文件实际解压体积超过 ${formatMB(maxFileBytes)} MB`));
+                        else if (actualBytes > maxTotalBytes)
+                            callback(new Error(`ZIP 实际解压体积超过 ${formatMB(maxTotalBytes)} MB`));
+                        else
+                            callback(null, chunk);
+                    }
+                });
+                await pipeline(input, limiter, fs.createWriteStream(absolute, { mode: 0o600 }));
+                files.push(relative);
+                zip.readEntry();
+            })().catch(fail);
+        });
+        zip.on("end", () => {
+            if (!settled) {
+                settled = true;
+                resolve(files);
+            }
+        });
+        zip.readEntry();
+    });
+}
+function openZip(buffer) {
+    return new Promise((resolve, reject) => {
+        yauzl.fromBuffer(buffer, { lazyEntries: true, autoClose: true, strictFileNames: true, validateEntrySizes: true }, (error, zip) => {
+            if (error || !zip)
+                reject(error ?? new Error("无法读取 ZIP 文件"));
+            else
+                resolve(zip);
+        });
+    });
+}
+function openEntryStream(zip, entry) {
+    return new Promise((resolve, reject) => {
+        zip.openReadStream(entry, (error, stream) => {
+            if (error || !stream)
+                reject(error ?? new Error("无法读取 ZIP 条目"));
+            else
+                resolve(stream);
+        });
+    });
+}
+function validateEntry(entry) {
+    const name = entry.fileName;
+    if (!name || name.includes("\0") || name.startsWith("/") || name.startsWith("\\"))
+        throw new Error("ZIP 包含无效路径");
+    safeRelativePath(name.replace(/\/$/, "") || "invalid");
+    const unixType = (entry.externalFileAttributes >>> 16) & 0o170000;
+    if (unixType === 0o120000)
+        throw new Error("ZIP 不允许包含符号链接");
+}
+function normalizedEntryName(name) {
+    return name.replaceAll("\\", "/");
+}
+function commonRootPrefix(files) {
+    if (files.length === 0)
+        return "";
+    const first = files[0].split("/");
+    if (first.length < 2 || !first[0])
+        return "";
+    return files.every((file) => file.startsWith(`${first[0]}/`)) ? `${first[0]}/` : "";
+}
+function discoverMainFile(root, files) {
+    const texFiles = files.filter((file) => file.toLowerCase().endsWith(".tex"));
+    if (texFiles.length === 1)
+        return texFiles[0];
+    return texFiles.find((file) => {
+        const source = fs.readFileSync(path.join(root, file), "utf8");
+        return hasDocumentClass(source);
+    }) ?? "";
+}
+export function hasDocumentClass(source) {
+    const withoutComments = source.split(/(?<=\n)/).map((line) => {
+        for (let index = 0; index < line.length; index += 1) {
+            if (line[index] !== "%")
+                continue;
+            let slashes = 0;
+            for (let cursor = index - 1; cursor >= 0 && line[cursor] === "\\"; cursor -= 1)
+                slashes += 1;
+            if (slashes % 2 === 0)
+                return `${line.slice(0, index)}${line.endsWith("\n") ? "\n" : ""}`;
+        }
+        return line;
+    }).join("");
+    const withoutVerbatim = withoutComments
+        .replace(/\\verb\*?([^\s]).*?\1/g, "")
+        .replace(/\\begin\{(?:verbatim\*?|Verbatim|lstlisting|minted)\}[\s\S]*?\\end\{(?:verbatim\*?|Verbatim|lstlisting|minted)\}/g, "");
+    return /\\documentclass\s*(?:\[[^\]]*\]\s*)?\{/.test(withoutVerbatim);
+}
+function formatMB(bytes) {
+    return Math.floor(bytes / 1024 / 1024);
+}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "texlite",
+  "version": "0.2.0",
+  "description": "A lightweight local-first collaborative LaTeX workspace",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SWUFE-DB-Group/TexLite.git"
+  },
+  "homepage": "https://github.com/SWUFE-DB-Group/TexLite",
+  "bugs": {
+    "url": "https://github.com/SWUFE-DB-Group/TexLite/issues"
+  },
+  "keywords": [
+    "latex",
+    "overleaf",
+    "collaboration",
+    "tex"
+  ],
+  "bin": {
+    "texlite": "dist/server/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE",
+    "preview.png",
+    "texlite.config.example.json"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/server/index.ts",
+    "dev:web": "vite",
+    "build": "npm run build:web && npm run build:server",
+    "build:web": "vite build",
+    "build:server": "tsc -p tsconfig.server.json",
+    "start": "node dist/server/index.js",
+    "pm2:start": "pm2 start ecosystem.config.cjs",
+    "pm2:restart": "pm2 restart texlite --update-env",
+    "pm2:stop": "pm2 stop texlite",
+    "pm2:delete": "pm2 delete texlite",
+    "pm2:logs": "pm2 logs texlite",
+    "pm2:save": "pm2 save",
+    "init": "tsx src/server/cli.ts init",
+    "prepack": "npm run build",
+    "test": "vitest run --config vitest.config.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.server.json --noEmit"
+  },
+  "dependencies": {
+    "@codemirror/autocomplete": "^6.18.6",
+    "@codemirror/commands": "^6.8.1",
+    "@codemirror/lang-markdown": "^6.3.3",
+    "@codemirror/language": "^6.11.3",
+    "@codemirror/legacy-modes": "^6.5.1",
+    "@codemirror/search": "^6.7.1",
+    "@codemirror/state": "^6.5.2",
+    "@codemirror/view": "^6.38.1",
+    "@fastify/cookie": "^11.0.2",
+    "@fastify/multipart": "^9.2.1",
+    "@fastify/static": "^10.1.2",
+    "@fastify/websocket": "^11.3.0",
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@replit/codemirror-vim": "^6.4.0",
+    "better-sqlite3": "^13.0.2",
+    "dictionary-en": "^4.0.0",
+    "diff-match-patch": "^1.0.5",
+    "fastify": "^5.4.0",
+    "i18next": "^25.3.2",
+    "i18next-browser-languagedetector": "^8.2.0",
+    "lib0": "^0.2.117",
+    "lucide-react": "^0.468.0",
+    "nspell": "^2.1.5",
+    "pdfjs-dist": "^6.2.108",
+    "pm2": "^6.0.14",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "react-i18next": "^15.6.1",
+    "react-resizable-panels": "^2.1.9",
+    "ws": "^8.21.1",
+    "y-codemirror.next": "^0.3.5",
+    "y-indexeddb": "^9.0.12",
+    "y-protocols": "^1.0.7",
+    "y-websocket": "^3.0.0",
+    "yauzl": "^3.2.0",
+    "yazl": "^3.3.1",
+    "yjs": "^13.6.31"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^9.6.0",
+    "@types/diff-match-patch": "^1.0.36",
+    "@types/node": "^24.1.0",
+    "@types/react": "^19.1.9",
+    "@types/react-dom": "^19.1.7",
+    "@types/ws": "^8.18.1",
+    "@types/yauzl": "^2.10.3",
+    "@types/yazl": "^3.3.0",
+    "@vitejs/plugin-react": "^4.7.0",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
+    "vite": "^7.0.6",
+    "vitest": "^3.2.4"
+  }
+}

package/texlite.config.example.json

@@ -0,0 +1,33 @@
+{
+  "siteName": "TexLite",
+  "adminEmail": "admin@example.com",
+  "sessionDays": 14,
+  "server": {
+    "host": "127.0.0.1",
+    "port": 3000
+  },
+  "storage": {
+    "dataDir": ".texlite"
+  },
+  "uploads": {
+    "maxFileSizeMB": 50
+  },
+  "history": {
+    "maxVersions": 200,
+    "maxStorageMB": 512
+  },
+  "git": {
+    "binary": "git",
+    "operationTimeoutSeconds": 120,
+    "githubApiBaseUrl": "https://api.github.com"
+  },
+  "latex": {
+    "latexmk": "latexmk",
+    "defaultEngine": "xelatex",
+    "allowedEngines": ["pdflatex", "xelatex", "lualatex"],
+    "extraArgs": [],
+    "allowProjectLatexmkrc": true,
+    "compileTimeoutSeconds": 600,
+    "maxCompileJobs": 10
+  }
+}