texlite 0.2.0

package/dist/server/projectOutline.js

@@ -0,0 +1,101 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveSourcePath, safeRelativePath } from "./files.js";
+const levels = { part: 0, chapter: 0, section: 1, subsection: 2, subsubsection: 3, paragraph: 4 };
+const commandPattern = /\\(part|chapter|section|subsection|subsubsection|paragraph)\*?(?:\s*\[[^\]]*\])?\s*\{|\\(?:input|include|subfile)\s*\{/g;
+export function buildProjectOutline(config, projectId, mainFileInput) {
+    const mainFile = safeRelativePath(mainFileInput);
+    const result = [];
+    const visited = new Set();
+    const visit = (filePath) => {
+        if (visited.has(filePath) || visited.size >= 200)
+            return;
+        visited.add(filePath);
+        const absolute = resolveSourcePath(config, projectId, filePath);
+        if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile() || fs.statSync(absolute).size > 3 * 1024 * 1024)
+            return;
+        const content = stripCommentsPreserveLines(fs.readFileSync(absolute, "utf8"));
+        const lineStarts = sourceLineStarts(content);
+        commandPattern.lastIndex = 0;
+        for (const command of content.matchAll(commandPattern)) {
+            const start = (command.index ?? 0) + command[0].length;
+            const argument = balancedArgument(content, start);
+            if (!argument)
+                continue;
+            if (command[1]) {
+                result.push({ path: filePath, line: lineAtOffset(lineStarts, command.index ?? 0), level: levels[command[1]], title: cleanTitle(argument.value) });
+                continue;
+            }
+            const included = resolveIncludedFile(config, projectId, filePath, argument.value);
+            if (included)
+                visit(included);
+        }
+    };
+    visit(mainFile);
+    return result;
+}
+function resolveIncludedFile(config, projectId, currentFile, value) {
+    const raw = value.trim();
+    if (!raw || /[\\#]/.test(raw))
+        return null;
+    const withExtension = path.posix.extname(raw) ? raw : `${raw}.tex`;
+    const candidates = [withExtension, path.posix.join(path.posix.dirname(currentFile), withExtension)];
+    for (const candidate of [...new Set(candidates)]) {
+        try {
+            const safe = safeRelativePath(candidate);
+            if (fs.existsSync(resolveSourcePath(config, projectId, safe)))
+                return safe;
+        }
+        catch { /* Ignore includes outside the project. */ }
+    }
+    return null;
+}
+function balancedArgument(source, start) {
+    let depth = 1;
+    for (let index = start; index < source.length; index += 1) {
+        if (source[index] === "{" && !escapedAt(source, index))
+            depth += 1;
+        if (source[index] === "}" && !escapedAt(source, index))
+            depth -= 1;
+        if (depth === 0)
+            return { value: source.slice(start, index), end: index };
+    }
+    return null;
+}
+function stripCommentsPreserveLines(source) {
+    return source.split(/(?<=\n)/).map((line) => {
+        for (let index = 0; index < line.length; index += 1) {
+            if (line[index] === "%" && !escapedAt(line, index))
+                return `${line.slice(0, index)}${line.endsWith("\n") ? "\n" : ""}`;
+        }
+        return line;
+    }).join("");
+}
+function escapedAt(source, index) {
+    let slashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1)
+        slashes += 1;
+    return slashes % 2 === 1;
+}
+function sourceLineStarts(source) {
+    const starts = [0];
+    for (let index = 0; index < source.length; index += 1)
+        if (source[index] === "\n")
+            starts.push(index + 1);
+    return starts;
+}
+function lineAtOffset(starts, offset) {
+    let low = 0;
+    let high = starts.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (starts[middle] <= offset)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return Math.max(1, low);
+}
+function cleanTitle(value) {
+    return value.replace(/\\(?:texorpdfstring|MakeUppercase)\s*\{([^{}]*)\}(?:\{[^{}]*\})?/g, "$1").replace(/\\[a-zA-Z@]+\*?/g, "").replace(/[{}]/g, "").trim() || value.trim();
+}

package/dist/server/projectSearch.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listProjectFilesAsync, resolveSourcePath } from "./files.js";
+const textExtension = /(?:\.(?:tex|bib|sty|cls|txt|md)|latexmkrc)$/i;
+const maxFiles = 500;
+const maxFileBytes = 3 * 1024 * 1024;
+const maxTotalBytes = 24 * 1024 * 1024;
+const maxMatches = 500;
+export async function searchProject(config, projectId, options) {
+    const pattern = searchPattern(options);
+    const matches = [];
+    let total = 0;
+    let indexedBytes = 0;
+    const entries = (await listProjectFilesAsync(config, projectId)).filter((entry) => entry.type === "file" && textExtension.test(entry.path)).slice(0, maxFiles);
+    for (const entry of entries) {
+        if ((entry.size ?? 0) > maxFileBytes || indexedBytes + (entry.size ?? 0) > maxTotalBytes)
+            continue;
+        indexedBytes += entry.size ?? 0;
+        let content;
+        try {
+            content = await fs.promises.readFile(resolveSourcePath(config, projectId, entry.path), "utf8");
+        }
+        catch {
+            continue;
+        }
+        pattern.lastIndex = 0;
+        let line = 1;
+        let lineStart = 0;
+        let nextLineBreak = content.indexOf("\n");
+        for (const match of content.matchAll(pattern)) {
+            total += 1;
+            if (matches.length >= maxMatches)
+                continue;
+            const offset = match.index;
+            while (nextLineBreak >= 0 && nextLineBreak < offset) {
+                line += 1;
+                lineStart = nextLineBreak + 1;
+                nextLineBreak = content.indexOf("\n", lineStart);
+            }
+            const lineEndCandidate = content.indexOf("\n", offset);
+            const lineEnd = lineEndCandidate < 0 ? content.length : lineEndCandidate;
+            const preview = content.slice(lineStart, lineEnd).slice(0, 500);
+            const previewOffset = Math.min(offset - lineStart, 500);
+            matches.push({
+                path: entry.path,
+                line,
+                column: offset - lineStart + 1,
+                preview,
+                matchStart: previewOffset,
+                matchEnd: Math.min(preview.length, previewOffset + match[0].length)
+            });
+        }
+    }
+    return { matches, total, truncated: total > matches.length };
+}
+export async function replaceProject(config, projectId, options, replacement) {
+    const pattern = searchPattern(options);
+    const staged = [];
+    let indexedBytes = 0;
+    const entries = (await listProjectFilesAsync(config, projectId)).filter((entry) => entry.type === "file" && textExtension.test(entry.path)).slice(0, maxFiles);
+    for (const entry of entries) {
+        if ((entry.size ?? 0) > maxFileBytes || indexedBytes + (entry.size ?? 0) > maxTotalBytes)
+            continue;
+        indexedBytes += entry.size ?? 0;
+        const absolute = resolveSourcePath(config, projectId, entry.path);
+        let previous;
+        try {
+            previous = await fs.promises.readFile(absolute, "utf8");
+        }
+        catch {
+            continue;
+        }
+        pattern.lastIndex = 0;
+        let count = 0;
+        const content = previous.replace(pattern, () => { count += 1; return replacement; });
+        if (!count || content === previous)
+            continue;
+        const temporary = `${absolute}.search-${process.pid}-${Date.now()}-${staged.length}.tmp`;
+        await fs.promises.writeFile(temporary, content, { encoding: "utf8", mode: 0o600 });
+        staged.push({ path: entry.path, absolute, temporary, previous, content, count });
+    }
+    const installed = [];
+    try {
+        for (const entry of staged) {
+            await fs.promises.rename(entry.temporary, entry.absolute);
+            installed.push(entry);
+        }
+    }
+    catch (error) {
+        // A project-wide replacement is presented as one operation. Restore every
+        // file already installed if a later rename fails, and remove unused stages.
+        for (const entry of installed.reverse()) {
+            const rollback = `${entry.absolute}.search-rollback-${process.pid}-${Date.now()}.tmp`;
+            await fs.promises.writeFile(rollback, entry.previous, { encoding: "utf8", mode: 0o600 });
+            await fs.promises.rename(rollback, entry.absolute);
+        }
+        await Promise.allSettled(staged.map((entry) => fs.promises.rm(entry.temporary, { force: true })));
+        throw error;
+    }
+    return staged.map(({ path: filePath, previous, content, count }) => ({ path: filePath, previous, content, count }));
+}
+function searchPattern(options) {
+    const query = options.query.trim();
+    if (!query || query.length > 500)
+        throw Object.assign(new Error("搜索内容格式不正确"), { code: "SEARCH_QUERY_INVALID", statusCode: 400 });
+    const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const source = options.wholeWord ? `(?<![\\p{L}\\p{N}_])${escaped}(?![\\p{L}\\p{N}_])` : escaped;
+    return new RegExp(source, `${options.caseSensitive ? "" : "i"}gu`);
+}
+export function projectSearchTextFile(filePath) {
+    return textExtension.test(path.basename(filePath));
+}

package/dist/server/projects.js

@@ -0,0 +1,29 @@
+export function accessibleProject(db, projectId, user) {
+    if (user.role === "admin") {
+        const row = db.prepare(`
+      SELECT p.*, 'owner' AS permission, owner.username AS owner_username,
+        owner.display_name AS owner_display_name,
+        modifier.username AS last_modified_username, modifier.display_name AS last_modified_display_name
+      FROM projects p
+      JOIN users owner ON owner.id = p.owner_id
+      LEFT JOIN users modifier ON modifier.id = p.last_modified_by
+      WHERE p.id = ?
+    `).get(projectId);
+        return row ?? null;
+    }
+    const row = db.prepare(`
+    SELECT p.*,
+      CASE WHEN p.owner_id = ? THEN 'owner' ELSE pm.permission END AS permission,
+      owner.username AS owner_username, owner.display_name AS owner_display_name,
+      modifier.username AS last_modified_username, modifier.display_name AS last_modified_display_name
+    FROM projects p
+    JOIN users owner ON owner.id = p.owner_id
+    LEFT JOIN users modifier ON modifier.id = p.last_modified_by
+    LEFT JOIN project_members pm ON pm.project_id = p.id AND pm.user_id = ?
+    WHERE p.id = ? AND (p.owner_id = ? OR pm.user_id IS NOT NULL)
+  `).get(user.id, user.id, projectId, user.id);
+    return row ?? null;
+}
+export function canEdit(project) {
+    return project.permission === "owner" || project.permission === "edit";
+}

package/dist/server/routes/compile.js

@@ -0,0 +1,343 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { performance } from "node:perf_hooks";
+import { requireUser } from "../auth.js";
+import { accessibleProject, canEdit } from "../projects.js";
+import { resolveSourcePath, safeRelativePath } from "../files.js";
+import { captureCompileSnapshot, compileProject, discardCompileSnapshot, publishCompileArtifacts, publishedCompileArtifacts } from "../compiler.js";
+import { parseCompileDiagnostics } from "../compileDiagnostics.js";
+import { pdfToSource, sourceToPdf } from "../synctex.js";
+import { availablePdf, compileMainFile, compilePdfUrl, isTextCompileArtifact, listCompileArtifacts, syncArtifacts } from "../compileArtifacts.js";
+import { apiError, contentDisposition } from "../http.js";
+const now = () => new Date().toISOString();
+const timingDuration = (milliseconds) => Math.round(milliseconds * 10) / 10;
+export function registerCompileRoutes(app, context) {
+    const { config, db, collaboration, compileCoordinator, metrics, pruneCompileRuns } = context;
+    app.get("/api/projects/:id/compile/latest", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { id } = request.params;
+        const project = accessibleProject(db, id, user);
+        if (!project)
+            return apiError(reply, 404, "PROJECT_NOT_FOUND", "项目不存在");
+        const query = request.query;
+        const mainFile = compileMainFile(config, id, project.main_file, query.mainFile);
+        if (!mainFile)
+            return apiError(reply, 400, "MAIN_DOCUMENT_INVALID", "所选文件不是有效的 LaTeX 主文档");
+        const latest = db.prepare(`SELECT run.id, run.status, run.log, run.created_at, run.finished_at,
+      run.requested_by, user.username AS requested_by_username, user.display_name AS requested_by_name
+      FROM compile_runs run LEFT JOIN users user ON user.id = run.requested_by
+      WHERE run.project_id = ? AND run.main_file = ?
+      ORDER BY CASE run.status WHEN 'running' THEN 0 WHEN 'queued' THEN 1 ELSE 2 END, run.created_at DESC LIMIT 1`).get(id, mainFile);
+        const latestSuccess = db.prepare(`SELECT id, finished_at FROM compile_runs
+      WHERE project_id = ? AND main_file = ? AND status = 'succeeded' ORDER BY created_at DESC LIMIT 1`).get(id, mainFile);
+        const pdf = availablePdf(config, id, mainFile, project.main_file);
+        const published = publishedCompileArtifacts(config, id, mainFile, mainFile === project.main_file);
+        const publishedRun = published ? db.prepare(`SELECT id, finished_at FROM compile_runs
+      WHERE id = ? AND project_id = ? AND status = 'succeeded'`).get(published.runId, id) : undefined;
+        const pdfVersion = published?.runId ?? latestSuccess?.id ?? pdf?.version;
+        return {
+            mainFile,
+            latestRun: latest ? {
+                id: latest.id, status: latest.status, log: latest.log,
+                diagnostics: parseCompileDiagnostics(latest.log, latest.status === "succeeded" || latest.status === "failed" ? latest.status : null),
+                createdAt: latest.created_at, finishedAt: latest.finished_at,
+                requestedBy: latest.requested_by ? {
+                    id: latest.requested_by,
+                    username: latest.requested_by_username ?? "deleted-user",
+                    name: latest.requested_by_name ?? "Deleted User"
+                } : null
+            } : null,
+            hasPdf: Boolean(pdf),
+            pdfUrl: pdf ? compilePdfUrl(id, mainFile, pdfVersion ?? pdf.version) : null,
+            pdfCompiledAt: publishedRun?.finished_at ?? latestSuccess?.finished_at ?? null
+        };
+    });
+    app.get("/api/projects/:id/compile/artifacts", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { id } = request.params;
+        const project = accessibleProject(db, id, user);
+        if (!project)
+            return apiError(reply, 404, "PROJECT_NOT_FOUND", "项目不存在");
+        const query = request.query;
+        const mainFile = compileMainFile(config, id, project.main_file, query.mainFile);
+        if (!mainFile)
+            return apiError(reply, 400, "MAIN_DOCUMENT_INVALID", "所选文件不是有效的 LaTeX 主文档");
+        const published = publishedCompileArtifacts(config, id, mainFile, mainFile === project.main_file);
+        if (!query.path)
+            return { mainFile, runId: published?.runId ?? null, artifacts: published ? listCompileArtifacts(published.output) : [] };
+        if (!published)
+            return apiError(reply, 404, "COMPILE_ARTIFACTS_NOT_FOUND", "尚无可用的编译产物");
+        const relative = safeRelativePath(query.path);
+        const absolute = path.join(published.output, relative);
+        const outputDirectory = path.resolve(published.output);
+        const resolved = path.resolve(absolute);
+        if (!resolved.startsWith(`${outputDirectory}${path.sep}`)
+            || !fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+            return apiError(reply, 404, "COMPILE_ARTIFACT_NOT_FOUND", "编译产物不存在");
+        }
+        const stat = fs.statSync(resolved);
+        if (query.download === "1") {
+            reply.header("Content-Type", "application/octet-stream");
+            reply.header("Content-Disposition", contentDisposition(path.basename(relative), "attachment"));
+            reply.header("Content-Length", stat.size);
+            return reply.send(fs.createReadStream(resolved));
+        }
+        if (stat.size > 2 * 1024 * 1024 || !isTextCompileArtifact(relative)) {
+            return apiError(reply, 415, "ARTIFACT_PREVIEW_UNSUPPORTED", "该产物不能作为文本预览，请下载后查看");
+        }
+        return { path: relative, content: fs.readFileSync(resolved, "utf8") };
+    });
+    app.get("/api/projects/:id/sync/pdf", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { id } = request.params;
+        const project = accessibleProject(db, id, user);
+        if (!project)
+            return apiError(reply, 404, "PROJECT_NOT_FOUND", "项目不存在");
+        const query = request.query;
+        const mainFile = compileMainFile(config, id, project.main_file, query.mainFile);
+        if (!mainFile)
+            return apiError(reply, 400, "MAIN_DOCUMENT_INVALID", "所选文件不是有效的 LaTeX 主文档");
+        const sourcePath = safeRelativePath(query.path ?? "");
+        const line = Number(query.line);
+        const column = Number(query.column ?? 1);
+        if (!Number.isInteger(line) || line < 1 || !Number.isInteger(column) || column < 1) {
+            return apiError(reply, 400, "SYNC_SOURCE_INVALID", "源码位置无效");
+        }
+        if (!fs.existsSync(resolveSourcePath(config, id, sourcePath))) {
+            return apiError(reply, 404, "SOURCE_FILE_NOT_FOUND", "源码文件不存在");
+        }
+        const artifacts = syncArtifacts(config, id, mainFile, project.main_file);
+        if (!artifacts)
+            return apiError(reply, 409, "SYNCTEX_NOT_AVAILABLE", "项目尚无可用的 SyncTeX 数据，请重新编译");
+        return await sourceToPdf(artifacts.source, artifacts.pdf, sourcePath, line, column);
+    });
+    app.get("/api/projects/:id/sync/source", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { id } = request.params;
+        const project = accessibleProject(db, id, user);
+        if (!project)
+            return apiError(reply, 404, "PROJECT_NOT_FOUND", "项目不存在");
+        const query = request.query;
+        const mainFile = compileMainFile(config, id, project.main_file, query.mainFile);
+        if (!mainFile)
+            return apiError(reply, 400, "MAIN_DOCUMENT_INVALID", "所选文件不是有效的 LaTeX 主文档");
+        const page = Number(query.page);
+        const x = Number(query.x);
+        const y = Number(query.y);
+        if (!Number.isInteger(page) || page < 1 || !Number.isFinite(x) || x < 0 || !Number.isFinite(y) || y < 0) {
+            return apiError(reply, 400, "SYNC_PDF_INVALID", "PDF 位置无效");
+        }
+        const artifacts = syncArtifacts(config, id, mainFile, project.main_file);
+        if (!artifacts)
+            return apiError(reply, 409, "SYNCTEX_NOT_AVAILABLE", "项目尚无可用的 SyncTeX 数据，请重新编译");
+        const location = await pdfToSource(artifacts.source, artifacts.pdf, page, x, y);
+        const sourceDirectory = path.resolve(artifacts.source);
+        const relative = path.relative(sourceDirectory, path.resolve(location.input));
+        if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+            return apiError(reply, 400, "SYNCTEX_EXTERNAL_PATH", "SyncTeX 返回了项目外部的源码路径");
+        }
+        return { path: safeRelativePath(relative.replaceAll(path.sep, "/")), line: location.line, column: location.column };
+    });
+    app.post("/api/projects/:id/compile", async (request, reply) => {
+        const requestStartedAt = performance.now();
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { id } = request.params;
+        const project = accessibleProject(db, id, user);
+        if (!project || !canEdit(project))
+            return apiError(reply, 403, "COMPILE_FORBIDDEN", "没有编译权限");
+        const body = (request.body ?? {});
+        const mainFile = compileMainFile(config, id, project.main_file, body.mainFile);
+        if (!mainFile)
+            return apiError(reply, 400, "MAIN_DOCUMENT_INVALID", "所选文件不是有效的 LaTeX 主文档");
+        collaboration.flushProject(id);
+        const runId = randomUUID();
+        const snapshotStartedAt = performance.now();
+        const snapshot = await captureCompileSnapshot(config, id, runId, {
+            mainFile,
+            engine: project.engine,
+            latexmkrc: project.latexmkrc,
+            extraArgs: config.extraArgs
+        });
+        const snapshotMs = performance.now() - snapshotStartedAt;
+        metrics.record("compile.snapshot", snapshotMs);
+        const published = publishedCompileArtifacts(config, id, mainFile, mainFile === project.main_file);
+        const publishedRun = published ? db.prepare(`SELECT id, status, log, finished_at
+      FROM compile_runs WHERE id = ? AND project_id = ?`).get(published.runId, id) : undefined;
+        const latestRun = db.prepare(`SELECT id, status FROM compile_runs
+      WHERE project_id = ? AND main_file = ? ORDER BY created_at DESC LIMIT 1`).get(id, mainFile);
+        const activeRun = db.prepare(`SELECT 1 AS active FROM compile_runs
+      WHERE project_id = ? AND main_file = ? AND status IN ('queued', 'running') LIMIT 1`).get(id, mainFile);
+        if (!activeRun && published && publishedRun?.status === "succeeded"
+            && latestRun?.id === publishedRun.id && snapshot.revision === published.revision) {
+            discardCompileSnapshot(snapshot);
+            const requestMs = performance.now() - requestStartedAt;
+            metrics.record("compile.request", requestMs);
+            reply.header("Server-Timing", `snapshot;dur=${timingDuration(snapshotMs)}, total;dur=${timingDuration(requestMs)}`);
+            return {
+                runId: published.runId,
+                ok: true,
+                skipped: true,
+                log: publishedRun.log ?? "",
+                diagnostics: parseCompileDiagnostics(publishedRun.log ?? "", "succeeded"),
+                mainFile,
+                pdfUrl: compilePdfUrl(id, mainFile, published.runId),
+                pdfCompiledAt: publishedRun.finished_at,
+                timings: { snapshotMs, requestMs }
+            };
+        }
+        db.prepare("INSERT INTO compile_runs (id, project_id, requested_by, main_file, status, created_at) VALUES (?, ?, ?, ?, 'queued', ?)")
+            .run(runId, id, user.id, mainFile, now());
+        const requestedBy = { id: user.id, username: user.username, name: user.display_name };
+        let phase = "queued";
+        const broadcast = () => collaboration.signalCompileState(id, { mainFile, runId, status: phase, requestedBy, updatedAt: now() });
+        const result = await compileCoordinator.request({
+            projectId: id,
+            target: mainFile,
+            runId,
+            revision: snapshot.revision,
+            onQueued: broadcast,
+            onSelected: broadcast,
+            onDiscarded: () => {
+                db.prepare("DELETE FROM compile_runs WHERE id = ? AND status = 'queued'").run(runId);
+                discardCompileSnapshot(snapshot);
+            },
+            execute: async () => {
+                phase = "running";
+                db.prepare("UPDATE compile_runs SET status = 'running' WHERE id = ?").run(runId);
+                broadcast();
+                let compiled;
+                try {
+                    compiled = await compileProject(config, snapshot, mainFile, project.engine, project.latexmkrc);
+                    if (compiled.ok && compiled.pdfPath) {
+                        if (!db.prepare("SELECT 1 FROM projects WHERE id = ?").get(id))
+                            throw new Error("项目已被删除");
+                        const publishStartedAt = performance.now();
+                        publishCompileArtifacts(config, id, snapshot, compiled);
+                        if (compiled.timings) {
+                            compiled.timings.publishMs = performance.now() - publishStartedAt;
+                            compiled.timings.totalMs += compiled.timings.publishMs;
+                        }
+                    }
+                    else {
+                        discardCompileSnapshot(snapshot);
+                    }
+                }
+                catch (error) {
+                    discardCompileSnapshot(snapshot);
+                    compiled = {
+                        ok: false,
+                        log: error instanceof Error ? error.message : String(error),
+                        diagnostics: parseCompileDiagnostics(error instanceof Error ? error.message : String(error), "failed"),
+                        pdfPath: null,
+                        synctexPath: null
+                    };
+                }
+                phase = compiled.ok ? "succeeded" : "failed";
+                db.prepare("UPDATE compile_runs SET status = ?, log = ?, finished_at = ? WHERE id = ?")
+                    .run(phase, compiled.log, now(), runId);
+                broadcast();
+                return { ...compiled, runId, revision: snapshot.revision };
+            }
+        });
+        const completed = db.prepare("SELECT finished_at FROM compile_runs WHERE id = ?").get(result.runId);
+        const requestMs = performance.now() - requestStartedAt;
+        metrics.record("compile.request", requestMs);
+        if (result.timings) {
+            metrics.record("compile.cacheSync", result.timings.cacheSyncMs);
+            metrics.record("compile.latexmk", result.timings.latexmkMs);
+            metrics.record("compile.artifactCopy", result.timings.artifactCopyMs);
+        }
+        pruneCompileRuns(id);
+        const timings = result.timings ? { snapshotMs, ...result.timings, requestMs } : { snapshotMs, requestMs };
+        reply.header("Server-Timing", [
+            `snapshot;dur=${timingDuration(snapshotMs)}`,
+            result.timings ? `cache;dur=${timingDuration(result.timings.cacheSyncMs)}` : "",
+            result.timings ? `latexmk;dur=${timingDuration(result.timings.latexmkMs)}` : "",
+            result.timings ? `artifacts;dur=${timingDuration(result.timings.artifactCopyMs)}` : "",
+            result.timings?.publishMs !== undefined ? `publish;dur=${timingDuration(result.timings.publishMs)}` : "",
+            `total;dur=${timingDuration(requestMs)}`
+        ].filter(Boolean).join(", "));
+        return {
+            mainFile, runId: result.runId, ok: result.ok, skipped: false, log: result.log, diagnostics: result.diagnostics,
+            pdfUrl: result.ok ? compilePdfUrl(id, mainFile, result.runId) : null,
+            pdfCompiledAt: result.ok ? completed?.finished_at ?? null : null,
+            timings
+        };
+    });
+    app.get("/api/projects/:id/pdf", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        const { id } = request.params;
+        const project = accessibleProject(db, id, user);
+        if (!project)
+            return apiError(reply, 404, "PROJECT_NOT_FOUND", "项目不存在");
+        const query = request.query;
+        const mainFile = compileMainFile(config, id, project.main_file, query.mainFile);
+        if (!mainFile)
+            return apiError(reply, 400, "MAIN_DOCUMENT_INVALID", "所选文件不是有效的 LaTeX 主文档");
+        const downloading = query.download === "1";
+        const artifact = availablePdf(config, id, mainFile, project.main_file);
+        if (!artifact)
+            return apiError(reply, 404, "PDF_NOT_FOUND", "尚未生成 PDF");
+        const pdf = artifact.path;
+        const stat = fs.statSync(pdf);
+        const etag = `"${stat.size.toString(16)}-${Math.trunc(stat.mtimeMs).toString(16)}"`;
+        reply.header("Content-Type", "application/pdf");
+        const targetSuffix = mainFile === project.main_file ? "" : `-${path.basename(mainFile, ".tex")}`;
+        const filename = downloading ? `${project.name}${targetSuffix}-${pdfDownloadTimestamp()}.pdf` : `${project.name}${targetSuffix}.pdf`;
+        reply.header("Content-Disposition", contentDisposition(filename, downloading ? "attachment" : "inline"));
+        reply.header("Cache-Control", "private, no-cache");
+        reply.header("Accept-Ranges", "bytes");
+        reply.header("ETag", etag);
+        reply.header("Last-Modified", stat.mtime.toUTCString());
+        if (request.headers["if-none-match"]?.split(",").some((candidate) => candidate.trim() === etag)) {
+            return reply.code(304).send();
+        }
+        const range = parseByteRange(request.headers.range, stat.size);
+        if (range === "invalid") {
+            reply.header("Content-Range", `bytes */${stat.size}`);
+            return reply.code(416).send();
+        }
+        if (range) {
+            reply.header("Content-Range", `bytes ${range.start}-${range.end}/${stat.size}`);
+            reply.header("Content-Length", range.end - range.start + 1);
+            return reply.code(206).send(fs.createReadStream(pdf, range));
+        }
+        reply.header("Content-Length", stat.size);
+        return reply.send(fs.createReadStream(pdf));
+    });
+}
+function pdfDownloadTimestamp(date = new Date()) {
+    return date.toISOString().slice(0, 19).replace("T", "-").replaceAll(":", "");
+}
+function parseByteRange(value, size) {
+    if (!value)
+        return null;
+    const match = /^bytes=(\d*)-(\d*)$/.exec(value.trim());
+    if (!match || (!match[1] && !match[2]) || size < 1)
+        return "invalid";
+    if (!match[1]) {
+        const suffixLength = Number(match[2]);
+        if (!Number.isSafeInteger(suffixLength) || suffixLength <= 0)
+            return "invalid";
+        return { start: Math.max(0, size - suffixLength), end: size - 1 };
+    }
+    const start = Number(match[1]);
+    const requestedEnd = match[2] ? Number(match[2]) : size - 1;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(requestedEnd) || start >= size || requestedEnd < start) {
+        return "invalid";
+    }
+    return { start, end: Math.min(requestedEnd, size - 1) };
+}

package/dist/server/runtimePaths.js

@@ -0,0 +1,42 @@
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export const CONFIG_FILE_NAME = "texlite.config.json";
+function nonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function xdgConfigHome(environment = process.env, home = os.homedir()) {
+    return path.resolve(nonEmpty(environment.XDG_CONFIG_HOME) ?? path.join(home, ".config"));
+}
+export function xdgDataHome(environment = process.env, home = os.homedir()) {
+    return path.resolve(nonEmpty(environment.XDG_DATA_HOME) ?? path.join(home, ".local", "share"));
+}
+export function texliteConfigDirectory(environment = process.env, home = os.homedir()) {
+    return path.join(xdgConfigHome(environment, home), "texlite");
+}
+export function defaultConfigPath(environment = process.env, home = os.homedir()) {
+    return path.join(texliteConfigDirectory(environment, home), CONFIG_FILE_NAME);
+}
+export function defaultDataDirectory(environment = process.env, home = os.homedir()) {
+    return path.join(xdgDataHome(environment, home), "texlite");
+}
+export function resolveConfigPath(explicitPath, environment = process.env) {
+    const configured = nonEmpty(explicitPath) ?? nonEmpty(environment.TEXLITE_CONFIG);
+    return path.resolve(configured ?? defaultConfigPath(environment));
+}
+/** The directory containing the installed package's compiled assets. */
+export function packageRootDirectory(moduleUrl = import.meta.url) {
+    return path.resolve(path.dirname(fileURLToPath(moduleUrl)), "..", "..");
+}
+/** The Vite output beside dist/server in a production npm package. */
+export function packageClientDirectory(moduleUrl = import.meta.url) {
+    // Resolve from the package root rather than from the source/compiled module
+    // directory. This keeps source execution (`tsx src/server/...`) pointed at
+    // the repository's `dist/client` after a build, while compiled npm installs
+    // resolve to `<package>/dist/client` as well.
+    return path.join(packageRootDirectory(moduleUrl), "dist", "client");
+}
+export function packageServerEntry(moduleUrl = import.meta.url) {
+    return path.resolve(path.dirname(fileURLToPath(moduleUrl)), "index.js");
+}

package/dist/server/security.js

@@ -0,0 +1,29 @@
+import { createHash, randomBytes, scrypt as scryptCallback, timingSafeEqual } from "node:crypto";
+import { promisify } from "node:util";
+const scrypt = promisify(scryptCallback);
+const KEY_LENGTH = 64;
+export const MIN_PASSWORD_LENGTH = 8;
+export async function hashPassword(password) {
+    if (password.length < MIN_PASSWORD_LENGTH) {
+        throw new Error(`密码至少需要 ${MIN_PASSWORD_LENGTH} 个字符`);
+    }
+    const salt = randomBytes(16);
+    const key = (await scrypt(password, salt, KEY_LENGTH));
+    return `scrypt$${salt.toString("base64url")}$${key.toString("base64url")}`;
+}
+export async function verifyPassword(password, encoded) {
+    const [algorithm, saltText, keyText] = encoded.split("$");
+    if (algorithm !== "scrypt" || !saltText || !keyText)
+        return false;
+    const salt = Buffer.from(saltText, "base64url");
+    const expected = Buffer.from(keyText, "base64url");
+    const actual = (await scrypt(password, salt, expected.length));
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+export function createSessionToken() {
+    const token = randomBytes(32).toString("base64url");
+    return { token, digest: digestToken(token) };
+}
+export function digestToken(token) {
+    return createHash("sha256").update(token).digest("hex");
+}