texlite 0.8.4 → 0.9.1

package/dist/server/i18n.js

@@ -16,6 +16,7 @@ const enMessages = {
     COMMENT_FILE_NOT_FOUND: "The file for this comment does not exist.",
     COMMENT_NOT_FOUND: "The comment does not exist.",
     COMMENT_RANGE_INVALID: "The comment source range is invalid.",
+    COMMENT_SOURCE_CHANGED: "The source changed while this comment was being prepared. Reselect the passage and try again.",
     COMMENT_UPDATE_EMPTY: "There is no comment change to save.",
     COMPILE_ARTIFACT_NOT_FOUND: "The compiled artifact does not exist.",
     COMPILE_ARTIFACTS_NOT_FOUND: "No compiled artifacts are available yet.",
@@ -45,9 +46,12 @@ const enMessages = {
     GIT_UNAVAILABLE: "Git is not available on this server.",
     HARPER_UNAVAILABLE: "Harper spelling and grammar checking is temporarily unavailable.",
     HISTORY_FILE_NOT_FOUND: "The historical file does not exist.",
+    HISTORY_OBJECT_MISSING: "A stored file for this snapshot is missing. It can no longer be viewed or restored.",
     HISTORY_FILE_PREVIEW_UNSUPPORTED: "This historical file cannot be compared as text.",
     HISTORY_TARGET_CONFLICT: "The historical version cannot be restored to the requested path.",
     HISTORY_VERSION_NOT_FOUND: "The history version does not exist.",
+    HISTORY_VERSION_CHANGED: "The selected project snapshot changed while it was being reviewed. Refresh it before restoring.",
+    SELECTION_HISTORY_SOURCE_CHANGED: "The source changed while opening selection history. Wait for synchronization, then select the passage and open its history again.",
     INVALID_PATH: "The file path is invalid.",
     LAST_ADMIN: "At least one active administrator must remain.",
     LATEXMKRC_DISABLED: "Project latexmkrc files are disabled by the administrator.",
@@ -59,6 +63,7 @@ const enMessages = {
     MAIN_FILE_INVALID: "The main document must be an existing .tex file.",
     MAIN_FILE_NOT_FOUND: "The selected main document does not exist.",
     MEMBERS_MANAGE_FORBIDDEN: "Only the project owner can manage members.",
+    MENTION_NOT_FOUND: "The mention notification does not exist.",
     MOVE_INTO_SELF: "A folder cannot be moved into itself.",
     OWNER_MEMBER_FORBIDDEN: "The project owner cannot be added as a member.",
     PASSWORD_TOO_SHORT: "The password must contain at least {{minLength}} characters.",
@@ -87,6 +92,7 @@ const enMessages = {
     SOURCE_FLUSH_FAILED: "Some source files could not be saved. The project operation was cancelled.",
     SPELLCHECK_SOURCE_INVALID: "The source to check is invalid.",
     SPELLCHECK_SOURCE_TOO_LARGE: "The source to check is too large.",
+    SPELLCHECK_SUPERSEDED: "A newer writing check replaced this request.",
     SYNCTEX_EXTERNAL_PATH: "SyncTeX returned a source path outside the project.",
     SYNCTEX_NOT_AVAILABLE: "No SyncTeX data is available. Compile the project again.",
     SYMLINK_FORBIDDEN: "Symbolic links are not allowed in project sources.",
@@ -142,6 +148,7 @@ const zhMessages = {
     COMMENT_FILE_NOT_FOUND: "批注对应的文件不存在。",
     COMMENT_NOT_FOUND: "批注不存在。",
     COMMENT_RANGE_INVALID: "批注的源码区间无效。",
+    COMMENT_SOURCE_CHANGED: "准备批注时源码已发生变化。请重新选择文本后再试。",
     COMMENT_UPDATE_EMPTY: "没有可保存的批注修改。",
     COMPILE_ARTIFACT_NOT_FOUND: "编译产物不存在。",
     COMPILE_ARTIFACTS_NOT_FOUND: "尚无可用的编译产物。",
@@ -171,9 +178,12 @@ const zhMessages = {
     GIT_UNAVAILABLE: "服务器未安装 Git。",
     HARPER_UNAVAILABLE: "Harper 拼写与语法检查暂不可用。",
     HISTORY_FILE_NOT_FOUND: "历史文件不存在。",
+    HISTORY_OBJECT_MISSING: "该快照的已存储文件缺失，无法再查看或恢复。",
     HISTORY_FILE_PREVIEW_UNSUPPORTED: "该历史文件不能作为文本比较。",
     HISTORY_TARGET_CONFLICT: "无法将历史版本恢复到所请求的路径。",
     HISTORY_VERSION_NOT_FOUND: "历史版本不存在。",
+    HISTORY_VERSION_CHANGED: "查看期间该项目快照已发生变化。请刷新后再恢复。",
+    SELECTION_HISTORY_SOURCE_CHANGED: "打开选区历史时源码已发生变化。请等待同步完成，重新选择文本后再打开历史。",
     INVALID_PATH: "文件路径无效。",
     LAST_ADMIN: "系统必须保留至少一名可用管理员。",
     LATEXMKRC_DISABLED: "管理员已禁用项目级 latexmkrc。",
@@ -185,6 +195,7 @@ const zhMessages = {
     MAIN_FILE_INVALID: "主文档必须是存在的 .tex 文件。",
     MAIN_FILE_NOT_FOUND: "所选主文档不存在。",
     MEMBERS_MANAGE_FORBIDDEN: "只有项目所有者可以管理成员。",
+    MENTION_NOT_FOUND: "@ 提醒不存在。",
     MOVE_INTO_SELF: "不能把文件夹移动到自身内部。",
     OWNER_MEMBER_FORBIDDEN: "项目所有者不能作为成员添加。",
     PASSWORD_TOO_SHORT: "密码至少需要 {{minLength}} 个字符。",
@@ -213,6 +224,7 @@ const zhMessages = {
     SOURCE_FLUSH_FAILED: "部分源码未能保存至磁盘，项目操作已取消。",
     SPELLCHECK_SOURCE_INVALID: "待检查源码格式不正确。",
     SPELLCHECK_SOURCE_TOO_LARGE: "待检查源码过大。",
+    SPELLCHECK_SUPERSEDED: "更新的写作检查已替代此请求。",
     SYNCTEX_EXTERNAL_PATH: "SyncTeX 返回了项目外部的源码路径。",
     SYNCTEX_NOT_AVAILABLE: "尚无可用的 SyncTeX 数据，请重新编译。",
     SYMLINK_FORBIDDEN: "项目源码中不允许使用符号链接。",

package/dist/server/index.js

@@ -5,12 +5,16 @@ import { activeAdminCount, openDatabase } from "./db.js";
 import { buildApp } from "./app.js";
 import { assertEnvironment } from "./environment.js";
 import { acquireDataDirectoryLock } from "./instanceLock.js";
+import { LogRotation } from "./logRotation.js";
 export async function startServer(configPath) {
     const config = loadConfig(configPath);
     const lock = acquireDataDirectoryLock(config);
     let db = null;
     let app = null;
+    const logs = process.env.TEXLITE_MANAGED_LOGS === "1"
+        ? new LogRotation(config.dataDir, (error) => console.error("TexLite log rotation failed:", error)) : null;
     try {
+        await logs?.start();
         const environment = await assertEnvironment(config);
         db = openDatabase(config);
         if (activeAdminCount(db) === 0) {
@@ -34,6 +38,7 @@ export async function startServer(configPath) {
                         db?.close();
                     }
                     finally {
+                        await logs?.stop();
                         lock.release();
                     }
                 }
@@ -50,6 +55,7 @@ export async function startServer(configPath) {
                 db?.close();
             }
             finally {
+                await logs?.stop();
                 lock.release();
             }
         }

package/dist/server/latexSpellMask.js

@@ -1,16 +1,34 @@
 // This intentionally recognizes only the parts of LaTeX that are clearly not
 // prose. It is a single-pass lexer, not a parser: malformed delimiters remain
 // narrow, so they never hide the rest of a document or cause backtracking.
+const literalEnvironments = new Set([
+    "verbatim", "verbatim*", "bverbatim", "bverbatim*", "lverbatim", "lverbatim*", "saveverbatim", "saveverbatim*", "verbatimout",
+    "lstlisting", "minted", "minted*", "filecontents", "filecontents*", "luacode", "luacodestar", "comment"
+]);
 const nonProseEnvironments = new Set([
-    "math", "displaymath", "equation", "equation*", "align", "align*", "alignat", "alignat*", "gather", "gather*", "multline", "multline*", "flalign", "flalign*",
-    "tikzpicture", "axis", "scope", "pgfonlayer", "pgfpicture",
-    "tabular", "tabularx", "tabulary", "longtable", "array", "matrix", "pmatrix", "bmatrix", "vmatrix",
-    "verbatim", "lstlisting", "minted", "comment", "algorithmic"
+    // Display and helper math environments commonly used by amsmath/mathtools.
+    "math", "displaymath", "equation", "equation*", "align", "align*", "alignat", "alignat*", "aligned", "alignedat", "gather", "gather*", "gathered", "multline", "multline*", "multlined", "flalign", "flalign*", "split", "cases", "dcases", "rcases", "drcases",
+    "array", "matrix", "pmatrix", "bmatrix", "vmatrix", "smallmatrix", "psmallmatrix", "bsmallmatrix", "vsmallmatrix",
+    // Diagram, table, and literal/code environments. Keep prose containers such
+    // as figure, table, theorem, and caption outside this list.
+    "tikzpicture", "tikzcd", "axis", "scope", "pgfonlayer", "pgfpicture",
+    "tabular", "tabularx", "tabulary", "longtable",
+    "verbatim", "verbatim*", "bverbatim", "bverbatim*", "lverbatim", "lverbatim*", "saveverbatim", "saveverbatim*", "verbatimout",
+    "lstlisting", "minted", "minted*", "filecontents", "filecontents*", "luacode", "luacodestar", "comment", "algorithmic"
 ]);
 const opaqueArgumentCommands = new Set([
     "documentclass", "usepackage", "requirepackage", "includegraphics", "tikzset", "pgfplotsset", "hypersetup", "lstset",
     "label", "hypertarget", "ref", "pageref", "autoref", "nameref", "hyperref", "index", "gls", "glspl",
-    "bibliography", "addbibresource", "input", "include", "url", "path", "setlength", "setcounter", "color", "textcolor", "colorbox", "pagecolor"
+    "bibliography", "addbibresource", "input", "include", "url", "path", "setlength", "setcounter", "color", "textcolor", "colorbox", "pagecolor",
+    // These arguments are code, identifiers, or paths rather than prose.
+    "texttt", "detokenize", "lstinputlisting"
+]);
+/** Number of brace arguments after a macro/environment target. */
+const macroDefinitionArgumentCounts = new Map([
+    ["newcommand", 1], ["renewcommand", 1], ["providecommand", 1], ["declarerobustcommand", 1],
+    ["newenvironment", 2], ["renewenvironment", 2],
+    ["newdocumentcommand", 2], ["renewdocumentcommand", 2], ["providedocumentcommand", 2], ["declaredocumentcommand", 2],
+    ["declaremathoperator", 1], ["declarepaireddelimiter", 2]
 ]);
 function addRange(ranges, from, to) {
     if (to > from)
@@ -26,7 +44,7 @@ function isCommandNameCharacter(character) {
     return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || (code >= 48 && code <= 57)
         || character === "@" || character === ":" || character === "_";
 }
-function balancedArgument(source, start, open, close) {
+function balancedArgument(source, start, open, close, literal = false) {
     if (source[start] !== open)
         return null;
     let depth = 1;
@@ -35,6 +53,13 @@ function balancedArgument(source, start, open, close) {
             index += 1;
             continue;
         }
+        if (!literal && source[index] === "%") {
+            const lineEnd = source.indexOf("\n", index);
+            if (lineEnd < 0)
+                return null;
+            index = lineEnd;
+            continue;
+        }
         if (source[index] === open)
             depth += 1;
         else if (source[index] === close && --depth === 0)
@@ -48,6 +73,17 @@ function skipWhitespace(source, start) {
         index += 1;
     return index;
 }
+/** Skip whitespace and TeX comments between arguments while masking comments. */
+function skipTrivia(source, start, ranges) {
+    let index = skipWhitespace(source, start);
+    while (source[index] === "%") {
+        const lineEnd = source.indexOf("\n", index);
+        const end = lineEnd < 0 ? source.length : lineEnd;
+        addRange(ranges, index, end);
+        index = skipWhitespace(source, lineEnd < 0 ? source.length : lineEnd + 1);
+    }
+    return index;
+}
 function readCommand(source, start) {
     let end = start + 1;
     if (isCommandNameCharacter(source[end]))
@@ -64,23 +100,103 @@ function isCitationCommand(name) {
     const normalized = name.toLocaleLowerCase("en-US");
     return normalized === "cite" || normalized.startsWith("cite") || normalized.endsWith("cite");
 }
-function masksOpaqueArguments(name) {
+function opaqueArgumentCount(name) {
     const normalized = name.toLocaleLowerCase("en-US");
-    return opaqueArgumentCommands.has(normalized) || isCitationCommand(normalized) || normalized === "definecolor" || normalized === "colorlet" || normalized === "href";
+    if (normalized === "definecolor" || normalized === "colorlet")
+        return 3;
+    if (normalized === "mint" || normalized === "inputminted")
+        return 2;
+    return opaqueArgumentCommands.has(normalized) || isCitationCommand(normalized) || normalized === "href" ? 1 : 0;
 }
-function maskOpaqueArguments(source, start, name, ranges) {
+function maskBraceArguments(source, start, count, ranges) {
     let cursor = start;
-    const normalized = name.toLocaleLowerCase("en-US");
-    const count = normalized === "definecolor" || normalized === "colorlet" ? 3 : 1;
     for (let index = 0; index < count; index += 1) {
         const argument = balancedArgument(source, cursor, "{", "}");
         if (!argument)
             break;
         addRange(ranges, argument.from, argument.to);
-        cursor = skipWhitespace(source, argument.to);
+        cursor = skipTrivia(source, argument.to, ranges);
     }
     return cursor;
 }
+function maskMacroTarget(source, start, ranges) {
+    const bracedTarget = balancedArgument(source, start, "{", "}");
+    if (bracedTarget) {
+        addRange(ranges, bracedTarget.from, bracedTarget.to);
+        return skipTrivia(source, bracedTarget.to, ranges);
+    }
+    if (source[start] === "\\") {
+        const target = readCommand(source, start);
+        addRange(ranges, start, target.end);
+        return skipTrivia(source, target.end, ranges);
+    }
+    return start;
+}
+function maskMacroDefinition(source, start, definitionArgumentCount, ranges) {
+    let cursor = maskMacroTarget(source, start, ranges);
+    if (cursor === start)
+        return cursor;
+    // newcommand-style macros may have both an argument-count option and a
+    // default-argument option. Mask every immediately following option before
+    // their definition bodies, while keeping malformed input narrow.
+    for (;;) {
+        const option = balancedArgument(source, cursor, "[", "]");
+        if (!option)
+            break;
+        addRange(ranges, option.from, option.to);
+        cursor = skipTrivia(source, option.to, ranges);
+    }
+    return maskBraceArguments(source, cursor, definitionArgumentCount, ranges);
+}
+function maskDelimitedCode(source, start, ranges) {
+    const delimiter = source[start];
+    if (!delimiter || isWhitespace(delimiter))
+        return start;
+    // TeX's delimiter-based inline literal commands cannot span a line. If a
+    // user is still typing the closing delimiter, hide only the incomplete
+    // current line rather than accidentally suppressing all later prose until a
+    // matching character happens to occur.
+    for (let cursor = start + 1; cursor < source.length; cursor += 1) {
+        const character = source[cursor];
+        if (character === delimiter) {
+            addRange(ranges, start, cursor + 1);
+            return skipTrivia(source, cursor + 1, ranges);
+        }
+        if (character === "\r" || character === "\n") {
+            addRange(ranges, start, cursor);
+            return cursor;
+        }
+    }
+    addRange(ranges, start, source.length);
+    return source.length;
+}
+function maskDelimitedOrBracedCode(source, start, ranges) {
+    if (source[start] !== "{")
+        return maskDelimitedCode(source, start, ranges);
+    // The brace form is also inline literal code. Preserve nested braces and
+    // escaped characters, but never let an unfinished argument conceal a later
+    // source line from the writing checker.
+    let depth = 1;
+    for (let cursor = start + 1; cursor < source.length; cursor += 1) {
+        const character = source[cursor];
+        if (character === "\\" && source[cursor + 1] !== "\r" && source[cursor + 1] !== "\n") {
+            cursor += 1;
+            continue;
+        }
+        if (character === "\r" || character === "\n") {
+            addRange(ranges, start, cursor);
+            return cursor;
+        }
+        if (character === "{")
+            depth += 1;
+        else if (character === "}" && --depth === 0) {
+            addRange(ranges, start, cursor + 1);
+            return cursor + 1;
+        }
+    }
+    addRange(ranges, start, source.length);
+    return source.length;
+}
 function rawUrlEnd(source, start) {
     const first = source[start];
     if (first !== "h" && first !== "H" && first !== "f" && first !== "F")
@@ -115,6 +231,33 @@ export function ignoredLatexRanges(source) {
     // The same technique keeps unmatched $ / \[ delimiters cheap and local.
     let pendingMath = null;
     for (let index = 0; index < source.length;) {
+        // An open literal environment owns its full body. Do not parse
+        // dollars, comments, or nested commands within it: literal code often
+        // contains all of those. Only look for its matching \end marker.
+        const activeNonProse = nonProseStack.at(-1);
+        if (activeNonProse && literalEnvironments.has(activeNonProse.name)) {
+            if (source[index] === "\\") {
+                const command = readCommand(source, index);
+                if (command.name === "end") {
+                    const cursor = skipTrivia(source, command.end, ranges);
+                    const environment = balancedArgument(source, cursor, "{", "}");
+                    const environmentName = environment
+                        ? source.slice(environment.from + 1, environment.to - 1).trim().toLocaleLowerCase("en-US")
+                        : "";
+                    if (environment && environmentName === activeNonProse.name) {
+                        activeNonProse.range.to = skipTrivia(source, environment.to, ranges);
+                        nonProseStack.pop();
+                        index = activeNonProse.range.to;
+                        continue;
+                    }
+                }
+                index = Math.max(index + 1, command.end);
+            }
+            else {
+                index += 1;
+            }
+            continue;
+        }
         if (pendingMath?.close.startsWith("\\") && source.startsWith(pendingMath.close, index)) {
             pendingMath.range.to = index + pendingMath.close.length;
             index += pendingMath.close.length;
@@ -171,44 +314,41 @@ export function ignoredLatexRanges(source) {
             continue;
         }
         const command = readCommand(source, commandStart);
-        let cursor = skipWhitespace(source, command.end);
-        if (command.name === "verb") {
-            addRange(ranges, commandStart, command.end);
-            const delimiter = source[cursor];
-            if (delimiter && !isWhitespace(delimiter)) {
-                const end = source.indexOf(delimiter, cursor + 1);
-                if (end >= 0) {
-                    addRange(ranges, cursor, end + 1);
-                    cursor = end + 1;
-                }
+        const commandName = command.name.toLocaleLowerCase("en-US");
+        // Reserve the command span before scanning trivia, which may append spans.
+        const commandRange = { from: commandStart, to: command.end };
+        ranges.push(commandRange);
+        let cursor = commandName === "verb" || commandName === "lstinline"
+            ? command.end : skipTrivia(source, command.end, ranges);
+        if (commandName === "verb") {
+            const options = command.name === "Verb" ? balancedArgument(source, cursor, "[", "]") : null;
+            if (options) {
+                addRange(ranges, options.from, options.to);
+                cursor = skipWhitespace(source, options.to);
             }
+            cursor = maskDelimitedOrBracedCode(source, cursor, ranges);
             index = Math.max(command.end, cursor);
             continue;
         }
         if (command.name === "begin" || command.name === "end") {
             const environment = balancedArgument(source, cursor, "{", "}");
             if (!environment) {
-                addRange(ranges, commandStart, command.end);
                 index = command.end;
                 continue;
             }
             const environmentName = source.slice(environment.from + 1, environment.to - 1).trim().toLocaleLowerCase("en-US");
-            cursor = skipWhitespace(source, environment.to);
+            addRange(ranges, environment.from, environment.to);
+            cursor = skipTrivia(source, environment.to, ranges);
             let options = null;
             if (command.name === "begin") {
                 options = balancedArgument(source, cursor, "[", "]");
-                if (options)
-                    cursor = skipWhitespace(source, options.to);
-                if (nonProseEnvironments.has(environmentName)) {
-                    const range = { from: commandStart, to: cursor };
-                    ranges.push(range);
-                    nonProseStack.push({ name: environmentName, range });
+                if (options) {
+                    addRange(ranges, options.from, options.to);
+                    cursor = skipTrivia(source, options.to, ranges);
                 }
-                else {
-                    addRange(ranges, commandStart, command.end);
-                    addRange(ranges, environment.from, environment.to);
-                    if (options)
-                        addRange(ranges, options.from, options.to);
+                if (nonProseEnvironments.has(environmentName)) {
+                    commandRange.to = cursor;
+                    nonProseStack.push({ name: environmentName, range: commandRange });
                 }
             }
             else {
@@ -217,22 +357,36 @@ export function ignoredLatexRanges(source) {
                     nonProseStack.pop();
                     open.range.to = cursor;
                 }
-                else {
-                    addRange(ranges, commandStart, command.end);
-                    addRange(ranges, environment.from, environment.to);
-                }
             }
             index = Math.max(command.end, cursor);
             continue;
         }
-        addRange(ranges, commandStart, command.end);
         const options = balancedArgument(source, cursor, "[", "]");
         if (options) {
             addRange(ranges, options.from, options.to);
-            cursor = skipWhitespace(source, options.to);
+            cursor = commandName === "lstinline" ? skipWhitespace(source, options.to) : skipTrivia(source, options.to, ranges);
+        }
+        if (commandName === "lstinline") {
+            cursor = maskDelimitedOrBracedCode(source, cursor, ranges);
+        }
+        else if (commandName === "mintinline") {
+            const language = balancedArgument(source, cursor, "{", "}");
+            if (language) {
+                addRange(ranges, language.from, language.to);
+                cursor = maskDelimitedOrBracedCode(source, skipWhitespace(source, language.to), ranges);
+            }
+        }
+        else {
+            const macroDefinitionArgumentCount = macroDefinitionArgumentCounts.get(commandName);
+            if (macroDefinitionArgumentCount !== undefined) {
+                cursor = maskMacroDefinition(source, cursor, macroDefinitionArgumentCount, ranges);
+            }
+            else {
+                const opaqueCount = opaqueArgumentCount(commandName);
+                if (opaqueCount > 0)
+                    cursor = maskBraceArguments(source, cursor, opaqueCount, ranges);
+            }
         }
-        if (masksOpaqueArguments(command.name))
-            cursor = maskOpaqueArguments(source, cursor, command.name, ranges);
         index = Math.max(command.end, cursor);
     }
     return mergeOrderedRanges(ranges);

package/dist/server/logRotation.js

@@ -0,0 +1,82 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export const LOG_MAX_BYTES = 10 * 1024 * 1024;
+export const LOG_CHECK_INTERVAL_MS = 60_000;
+const LOG_BACKUPS = 3;
+export function managedLogPaths(dataDir) {
+    const directory = path.resolve(dataDir, "logs");
+    return { stdout: path.join(directory, "stdout.log"), stderr: path.join(directory, "stderr.log") };
+}
+/** PM2 owns the open descriptors: copy/truncate keeps them valid across rotation. */
+export class LogRotation {
+    dataDir;
+    onError;
+    maxBytes;
+    pending = null;
+    timer = null;
+    stopped = false;
+    constructor(dataDir, onError, maxBytes = LOG_MAX_BYTES) {
+        this.dataDir = dataDir;
+        this.onError = onError;
+        this.maxBytes = maxBytes;
+    }
+    async start() {
+        await this.check();
+        if (!this.stopped && !this.timer) {
+            this.timer = setInterval(() => { void this.check(); }, LOG_CHECK_INTERVAL_MS);
+            this.timer.unref();
+        }
+    }
+    check() {
+        if (this.stopped)
+            return Promise.resolve();
+        if (this.pending)
+            return this.pending;
+        this.pending = this.rotateLogs().finally(() => { this.pending = null; });
+        return this.pending;
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        await this.pending;
+    }
+    async rotateLogs() {
+        for (const file of Object.values(managedLogPaths(this.dataDir))) {
+            try {
+                await this.rotate(file);
+            }
+            catch (error) {
+                this.onError(error);
+            }
+        }
+    }
+    async rotate(file) {
+        const stat = await fs.lstat(file).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (!stat?.isFile() || stat.size < this.maxBytes)
+            return;
+        const temporary = `${file}.rotate.tmp`;
+        try {
+            // Do not truncate until a complete backup has been successfully published.
+            await fs.copyFile(file, temporary);
+            await fs.rm(`${file}.${LOG_BACKUPS}`, { force: true });
+            for (let index = LOG_BACKUPS - 1; index >= 1; index--) {
+                await fs.rename(`${file}.${index}`, `${file}.${index + 1}`).catch((error) => {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                });
+            }
+            await fs.rename(temporary, `${file}.1`);
+            // Writes between the copy and truncate can be lost; these are diagnostic logs.
+            await fs.truncate(file, 0);
+        }
+        finally {
+            await fs.rm(temporary, { force: true });
+        }
+    }
+}

package/dist/server/pm2.js

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import http from "node:http";
 import path from "node:path";
+import { managedLogPaths } from "./logRotation.js";
 import { defaultConfigPath, packageRootDirectory, packageServerEntry } from "./runtimePaths.js";
 let pm2Client = null;
 async function loadPm2() {
@@ -64,12 +65,15 @@ export async function managedProcess(configPath) {
     }
 }
 function startOptions(config) {
+    const logs = managedLogPaths(config.dataDir);
+    fs.mkdirSync(path.dirname(logs.stdout), { recursive: true, mode: 0o700 });
     const packageRoot = packageRootDirectory();
     const script = packageServerEntry();
     const environment = {
         ...Object.fromEntries(Object.entries(process.env).filter((entry) => typeof entry[1] === "string")),
         NODE_ENV: "production",
         TEXLITE_CONFIG: path.resolve(config.configPath),
+        TEXLITE_MANAGED_LOGS: "1",
         TEXLITE_CLIENT_DIR: path.resolve(config.clientDir)
     };
     return {
@@ -78,6 +82,9 @@ function startOptions(config) {
         cwd: packageRoot,
         exec_mode: "fork",
         instances: 1,
+        output: logs.stdout,
+        error: logs.stderr,
+        merge_logs: true,
         autorestart: true,
         watch: false,
         wait_ready: true,