texlite 0.6.0 → 0.6.6

package/dist/server/git.js

@@ -3,14 +3,14 @@ import path from "node:path";
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
 import { assertGitAvailable } from "./environment.js";
-import { sourceRoot } from "./files.js";
+import { assertNoSourceSymlinks, sourceRoot, symbolicLinkError } from "./files.js";
+import { detachedProcessGroup, killProcessGroup } from "./processTree.js";
 const MAX_COMMAND_OUTPUT = 8 * 1024 * 1024;
 const MAX_DIFF_OUTPUT = 1024 * 1024;
 export class ProjectGitService {
     config;
     db;
     githubFetch;
-    locks = new Map();
     gitAvailability = null;
     constructor(config, db, githubFetch = fetch) {
         this.config = config;
@@ -19,8 +19,20 @@ export class ProjectGitService {
     }
     async status(project) {
         await this.ensureGitAvailable();
+        assertNoSourceSymlinks(this.config, project.id);
         const settings = this.settings(project.id);
-        const initialized = fs.existsSync(path.join(sourceRoot(this.config, project.id), ".git"));
+        const gitDirectory = path.join(sourceRoot(this.config, project.id), ".git");
+        let gitStat = null;
+        try {
+            gitStat = fs.lstatSync(gitDirectory);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (gitStat && !gitStat.isDirectory())
+            throw symbolicLinkError(".git");
+        const initialized = Boolean(gitStat);
         if (!initialized)
             return {
                 initialized: false,
@@ -65,102 +77,94 @@ export class ProjectGitService {
         if (token.length < 20 || token.length > 500)
             throw httpError(400, "GitHub token 格式不正确");
         await this.ensureGitAvailable();
-        return this.exclusive(project.id, async () => {
-            const account = await this.githubRequest(token, "/user", { method: "GET" });
-            if (typeof account.login !== "string" || !account.login)
-                throw httpError(502, "GitHub 没有返回有效的用户信息");
-            await this.ensureRepository(project);
-            const timestamp = new Date().toISOString();
-            this.db.prepare(`INSERT INTO project_git_settings
-        (project_id, token_ciphertext, github_login, default_branch, created_at, updated_at)
-        VALUES (?, ?, ?, 'main', ?, ?)
-        ON CONFLICT(project_id) DO UPDATE SET token_ciphertext = excluded.token_ciphertext,
-          github_login = excluded.github_login, updated_at = excluded.updated_at`)
-                .run(project.id, encryptToken(this.config, token), account.login, timestamp, timestamp);
-            return this.status(project);
-        });
+        const account = await this.githubRequest(token, "/user", { method: "GET" });
+        if (typeof account.login !== "string" || !account.login)
+            throw httpError(502, "GitHub 没有返回有效的用户信息");
+        await this.ensureRepository(project);
+        const timestamp = new Date().toISOString();
+        this.db.prepare(`INSERT INTO project_git_settings
+      (project_id, token_ciphertext, github_login, default_branch, created_at, updated_at)
+      VALUES (?, ?, ?, 'main', ?, ?)
+      ON CONFLICT(project_id) DO UPDATE SET token_ciphertext = excluded.token_ciphertext,
+        github_login = excluded.github_login, updated_at = excluded.updated_at`)
+            .run(project.id, encryptToken(this.config, token), account.login, timestamp, timestamp);
+        return this.status(project);
     }
     async removeToken(project) {
-        return this.exclusive(project.id, async () => {
-            this.db.prepare("UPDATE project_git_settings SET token_ciphertext = NULL, github_login = NULL, updated_at = ? WHERE project_id = ?")
-                .run(new Date().toISOString(), project.id);
-            return this.status(project);
-        });
+        this.db.prepare("UPDATE project_git_settings SET token_ciphertext = NULL, github_login = NULL, updated_at = ? WHERE project_id = ?")
+            .run(new Date().toISOString(), project.id);
+        return this.status(project);
     }
     async createGitHubRepository(project, name, isPrivate) {
         if (!/^[A-Za-z0-9._-]{1,100}$/.test(name))
             throw httpError(400, "GitHub 仓库名称只能包含字母、数字、点、横线或下划线");
         await this.ensureGitAvailable();
-        return this.exclusive(project.id, async () => {
-            const settings = this.requireTokenSettings(project.id);
-            if (settings.remote_url)
-                throw httpError(409, "该项目已经配置远程仓库");
-            const token = decryptToken(this.config, settings.token_ciphertext);
-            const repository = await this.githubRequest(token, "/user/repos", {
-                method: "POST",
-                body: JSON.stringify({ name, private: isPrivate, auto_init: false, description: `Backup of ${project.name}` })
-            });
-            if (typeof repository.clone_url !== "string" || typeof repository.html_url !== "string") {
-                throw httpError(502, "GitHub 没有返回有效的仓库地址");
-            }
-            await this.ensureRepository(project);
-            const root = sourceRoot(this.config, project.id);
-            const currentRemote = await this.git(root, ["remote", "get-url", "origin"], [2]);
-            if (currentRemote.code === 0)
-                await this.git(root, ["remote", "set-url", "origin", repository.clone_url]);
-            else
-                await this.git(root, ["remote", "add", "origin", repository.clone_url]);
-            const defaultBranch = typeof repository.default_branch === "string" && repository.default_branch
-                ? repository.default_branch : "main";
-            this.db.prepare(`UPDATE project_git_settings SET remote_url = ?, repository_name = ?,
-        repository_html_url = ?, default_branch = ?, updated_at = ? WHERE project_id = ?`)
-                .run(repository.clone_url, typeof repository.name === "string" ? repository.name : name, repository.html_url, defaultBranch, new Date().toISOString(), project.id);
-            return this.status(project);
+        const settings = this.requireTokenSettings(project.id);
+        if (settings.remote_url)
+            throw httpError(409, "该项目已经配置远程仓库");
+        const token = decryptToken(this.config, settings.token_ciphertext);
+        const repository = await this.githubRequest(token, "/user/repos", {
+            method: "POST",
+            body: JSON.stringify({ name, private: isPrivate, auto_init: false, description: `Backup of ${project.name}` })
         });
+        if (typeof repository.clone_url !== "string" || typeof repository.html_url !== "string") {
+            throw httpError(502, "GitHub 没有返回有效的仓库地址");
+        }
+        await this.ensureRepository(project);
+        const root = sourceRoot(this.config, project.id);
+        const currentRemote = await this.git(root, ["remote", "get-url", "origin"], [2]);
+        if (currentRemote.code === 0)
+            await this.git(root, ["remote", "set-url", "origin", repository.clone_url]);
+        else
+            await this.git(root, ["remote", "add", "origin", repository.clone_url]);
+        const defaultBranch = typeof repository.default_branch === "string" && repository.default_branch
+            ? repository.default_branch : "main";
+        this.db.prepare(`UPDATE project_git_settings SET remote_url = ?, repository_name = ?,
+      repository_html_url = ?, default_branch = ?, updated_at = ? WHERE project_id = ?`)
+            .run(repository.clone_url, typeof repository.name === "string" ? repository.name : name, repository.html_url, defaultBranch, new Date().toISOString(), project.id);
+        return this.status(project);
     }
     async commit(project, owner, messageInput) {
         const message = messageInput.trim();
         if (!message || message.length > 300)
             throw httpError(400, "提交说明不能为空且不能超过 300 个字符");
-        return this.exclusive(project.id, async () => {
-            const root = this.requireRepository(project.id);
-            const branch = await this.git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"], [1]);
-            if (branch.code !== 0)
-                throw httpError(409, "当前处于 detached HEAD，请先返回默认分支再提交");
-            await this.git(root, ["add", "--all"]);
-            const staged = await this.git(root, ["diff", "--cached", "--quiet"], [1]);
-            if (staged.code === 0)
-                throw httpError(409, "当前没有可以提交的修改");
-            await this.git(root, [
-                "-c", `user.name=${owner.username}`,
-                "-c", `user.email=${owner.username}@texlite.com`,
-                "-c", "commit.gpgSign=false",
-                "-c", "core.hooksPath=/dev/null",
-                "commit", "-m", message
-            ]);
-            const result = await this.git(root, ["log", "-1", "--format=%H%x1f%h%x1f%an%x1f%ae%x1f%aI%x1f%s"]);
-            return parseCommit(result.stdout.trim());
-        });
+        const root = this.requireRepository(project.id);
+        assertNoSourceSymlinks(this.config, project.id);
+        const branch = await this.git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"], [1]);
+        if (branch.code !== 0)
+            throw httpError(409, "当前处于 detached HEAD，请先返回默认分支再提交");
+        await this.git(root, ["add", "--all"]);
+        const staged = await this.git(root, ["diff", "--cached", "--quiet"], [1]);
+        if (staged.code === 0)
+            throw httpError(409, "当前没有可以提交的修改");
+        await this.git(root, [
+            "-c", `user.name=${owner.username}`,
+            "-c", `user.email=${owner.username}@texlite.com`,
+            "-c", "commit.gpgSign=false",
+            "-c", "core.hooksPath=/dev/null",
+            "commit", "-m", message
+        ]);
+        const result = await this.git(root, ["log", "-1", "--format=%H%x1f%h%x1f%an%x1f%ae%x1f%aI%x1f%s"]);
+        return parseCommit(result.stdout.trim());
     }
     async push(project) {
-        return this.exclusive(project.id, async () => {
-            const settings = this.requireTokenSettings(project.id);
-            if (!settings.remote_url)
-                throw httpError(409, "请先创建 GitHub 仓库");
-            const root = this.requireRepository(project.id);
-            const head = await this.git(root, ["rev-parse", "--verify", "HEAD"], [128]);
-            if (head.code !== 0)
-                throw httpError(409, "请先提交项目修改");
-            const branchResult = await this.git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"], [1]);
-            if (branchResult.code !== 0)
-                throw httpError(409, "当前处于 detached HEAD，请先返回默认分支再推送");
-            const branch = branchResult.stdout.trim();
-            if (!/^[A-Za-z0-9._/-]+$/.test(branch))
-                throw httpError(400, "本地分支名称无效");
-            const token = decryptToken(this.config, settings.token_ciphertext);
-            await this.git(root, ["push", "--set-upstream", "origin", `HEAD:refs/heads/${branch}`], [], this.authEnvironment(token));
-            return this.status(project);
-        });
+        const settings = this.requireTokenSettings(project.id);
+        if (!settings.remote_url)
+            throw httpError(409, "请先创建 GitHub 仓库");
+        const root = this.requireRepository(project.id);
+        assertNoSourceSymlinks(this.config, project.id);
+        const head = await this.git(root, ["rev-parse", "--verify", "HEAD"], [128]);
+        if (head.code !== 0)
+            throw httpError(409, "请先提交项目修改");
+        const branchResult = await this.git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"], [1]);
+        if (branchResult.code !== 0)
+            throw httpError(409, "当前处于 detached HEAD，请先返回默认分支再推送");
+        const branch = branchResult.stdout.trim();
+        if (!/^[A-Za-z0-9._/-]+$/.test(branch))
+            throw httpError(400, "本地分支名称无效");
+        const token = decryptToken(this.config, settings.token_ciphertext);
+        await this.git(root, ["push", "--set-upstream", "origin", `HEAD:refs/heads/${branch}`], [], this.authEnvironment(token));
+        return this.status(project);
     }
     async history(project) {
         const root = this.requireRepository(project.id);
@@ -200,40 +204,65 @@ export class ProjectGitService {
         };
     }
     async checkout(project, revisionInput, force) {
-        return this.exclusive(project.id, async () => {
-            const root = this.requireRepository(project.id);
-            const settings = this.settings(project.id);
-            const revision = revisionInput === null ? settings?.default_branch ?? "main" : validateRevision(revisionInput);
-            const target = revisionInput === null ? revision : await this.verifyCommit(root, revision);
-            if (force) {
-                await this.git(root, ["reset", "--hard", "HEAD"]);
-                await this.git(root, ["clean", "-fdx"]);
-            }
-            await this.git(root, ["-c", "core.hooksPath=/dev/null", "checkout", ...(revisionInput === null ? [] : ["--detach"]), ...(force ? ["--force"] : []), target]);
-            return target;
-        });
+        const root = this.requireRepository(project.id);
+        const settings = this.settings(project.id);
+        const revision = revisionInput === null ? settings?.default_branch ?? "main" : validateRevision(revisionInput);
+        const target = revisionInput === null ? revision : await this.verifyCommit(root, revision);
+        await this.assertRevisionHasNoSymlinks(root, target);
+        if (force) {
+            await this.git(root, ["reset", "--hard", "HEAD"]);
+            await this.git(root, ["clean", "-fdx"]);
+        }
+        await this.git(root, ["-c", "core.hooksPath=/dev/null", "checkout", ...(revisionInput === null ? [] : ["--detach"]), ...(force ? ["--force"] : []), target]);
+        assertNoSourceSymlinks(this.config, project.id);
+        return target;
     }
     async discardChanges(project) {
-        return this.exclusive(project.id, async () => {
-            const root = this.requireRepository(project.id);
-            const head = await this.git(root, ["rev-parse", "--verify", "HEAD"], [128]);
-            if (head.code !== 0)
-                throw httpError(409, "该项目尚无可恢复的提交");
-            await this.git(root, ["restore", "--source=HEAD", "--staged", "--worktree", "--", "."]);
-        });
+        const root = this.requireRepository(project.id);
+        const head = await this.git(root, ["rev-parse", "--verify", "HEAD"], [128]);
+        if (head.code !== 0)
+            throw httpError(409, "该项目尚无可恢复的提交");
+        await this.assertRevisionHasNoSymlinks(root, head.stdout.trim());
+        await this.git(root, ["restore", "--source=HEAD", "--staged", "--worktree", "--", "."]);
+        assertNoSourceSymlinks(this.config, project.id);
     }
     async ensureRepository(project) {
         const root = sourceRoot(this.config, project.id);
+        assertNoSourceSymlinks(this.config, project.id);
         fs.mkdirSync(root, { recursive: true, mode: 0o700 });
-        if (fs.existsSync(path.join(root, ".git")))
+        const gitDirectory = path.join(root, ".git");
+        let gitStat = null;
+        try {
+            gitStat = fs.lstatSync(gitDirectory);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (gitStat) {
+            if (gitStat.isSymbolicLink() || !gitStat.isDirectory())
+                throw symbolicLinkError(".git");
             return;
+        }
         await this.git(root, ["init"]);
         await this.git(root, ["symbolic-ref", "HEAD", "refs/heads/main"]);
     }
     requireRepository(projectId) {
         const root = sourceRoot(this.config, projectId);
-        if (!fs.existsSync(path.join(root, ".git")))
+        assertNoSourceSymlinks(this.config, projectId);
+        const gitDirectory = path.join(root, ".git");
+        let gitStat = null;
+        try {
+            gitStat = fs.lstatSync(gitDirectory);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (!gitStat)
             throw httpError(409, "该项目尚未初始化 Git");
+        if (gitStat.isSymbolicLink() || !gitStat.isDirectory())
+            throw symbolicLinkError(".git");
         return root;
     }
     settings(projectId) {
@@ -251,6 +280,12 @@ export class ProjectGitService {
             throw httpError(404, "Git 版本不存在");
         return result.stdout.trim();
     }
+    async assertRevisionHasNoSymlinks(root, revision) {
+        const tree = await this.git(root, ["ls-tree", "-r", "-z", "--full-tree", revision]);
+        if (tree.stdout.split("\0").some((entry) => entry.startsWith("120000 "))) {
+            throw symbolicLinkError(`Git revision ${revision}`);
+        }
+    }
     async githubRequest(token, route, init) {
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), this.config.gitOperationTimeoutMs);
@@ -309,16 +344,25 @@ export class ProjectGitService {
     async git(cwd, args, allowedCodes = [], env = process.env) {
         await this.ensureGitAvailable();
         return new Promise((resolve, reject) => {
-            const child = spawn(this.config.git, args, { cwd, env, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+            const child = spawn(this.config.git, args, {
+                cwd, env, shell: false, detached: detachedProcessGroup(), stdio: ["ignore", "pipe", "pipe"]
+            });
             const stdout = [];
             const stderr = [];
             let size = 0;
             let timedOut = false;
-            const timer = setTimeout(() => { timedOut = true; child.kill("SIGKILL"); }, this.config.gitOperationTimeoutMs);
+            let terminated = false;
+            const terminate = () => {
+                if (terminated)
+                    return;
+                terminated = true;
+                killProcessGroup(child);
+            };
+            const timer = setTimeout(() => { timedOut = true; terminate(); }, this.config.gitOperationTimeoutMs);
             const collect = (target) => (chunk) => {
                 size += chunk.length;
                 if (size > MAX_COMMAND_OUTPUT)
-                    child.kill("SIGKILL");
+                    terminate();
                 else
                     target.push(chunk);
             };
@@ -340,22 +384,6 @@ export class ProjectGitService {
             });
         });
     }
-    async exclusive(projectId, operation) {
-        const previous = this.locks.get(projectId) ?? Promise.resolve();
-        let release = () => undefined;
-        const gate = new Promise((resolve) => { release = resolve; });
-        const tail = previous.catch(() => undefined).then(() => gate);
-        this.locks.set(projectId, tail);
-        await previous.catch(() => undefined);
-        try {
-            return await operation();
-        }
-        finally {
-            release();
-            if (this.locks.get(projectId) === tail)
-                this.locks.delete(projectId);
-        }
-    }
 }
 function parseCommit(line) {
     const [sha = "", shortSha = "", authorName = "", authorEmail = "", authoredAt = "", ...message] = line.split("\x1f");

package/dist/server/history.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
-import { listProjectFiles, outputRoot, projectRoot, resolveSourcePath, safeRelativePath, sourceRoot } from "./files.js";
+import { assertNoSourceSymlinks, listProjectFiles, outputRoot, projectRoot, resolveSourcePath, safeRelativePath, sourceRoot } from "./files.js";
 const AUTOSAVE_COALESCE_MS = 2 * 60_000;
 export class ProjectHistoryService {
     config;
@@ -240,23 +240,90 @@ export class ProjectHistoryService {
         return path.join(outputRoot(this.config, projectId), ".texlite", "history", "objects", digest.slice(0, 2), digest);
     }
     pruneVersions(projectId) {
-        const obsolete = this.db.prepare(`SELECT id, manifest_json FROM project_history_versions
-      WHERE project_id = ? AND label IS NULL AND reason <> 'initial'
-      ORDER BY created_at DESC, rowid DESC LIMIT -1 OFFSET ?`)
-            .all(projectId, this.config.historyMaxVersions);
-        this.deleteVersions(projectId, obsolete);
-        // The latest version is always retained as the baseline for subsequent
-        // incremental snapshots. Initial and labeled versions are also protected,
-        // so explicitly preserved work can make the project exceed the soft cap.
-        while (this.stats(projectId).objectBytes > this.config.historyMaxStorageBytes) {
-            const candidate = this.db.prepare(`SELECT id, manifest_json FROM project_history_versions
-        WHERE project_id = ? AND label IS NULL AND reason <> 'initial'
-          AND id <> (SELECT id FROM project_history_versions WHERE project_id = ?
-            ORDER BY created_at DESC, rowid DESC LIMIT 1)
-        ORDER BY created_at ASC, rowid ASC LIMIT 1`).get(projectId, projectId);
-            if (!candidate)
-                break;
-            this.deleteVersions(projectId, [candidate]);
+        const rows = this.db.prepare(`SELECT id, reason, label, manifest_json, created_at
+      FROM project_history_versions WHERE project_id = ?
+      ORDER BY created_at DESC, rowid DESC`).all(projectId);
+        if (!rows.length)
+            return;
+        // Parse manifests and build reference counts & object size tracking in a single pass
+        const manifests = new Map();
+        const refCounts = new Map();
+        const sizeMap = new Map();
+        for (const row of rows) {
+            const manifest = parseManifest(row.manifest_json);
+            manifests.set(row.id, manifest);
+            for (const file of Object.values(manifest.files)) {
+                refCounts.set(file.digest, (refCounts.get(file.digest) ?? 0) + 1);
+                if (!sizeMap.has(file.digest))
+                    sizeMap.set(file.digest, file.size);
+            }
+        }
+        const baseline = this.baseline(projectId);
+        if (baseline) {
+            for (const file of Object.values(baseline.files)) {
+                refCounts.set(file.digest, (refCounts.get(file.digest) ?? 0) + 1);
+                if (!sizeMap.has(file.digest))
+                    sizeMap.set(file.digest, file.size);
+            }
+        }
+        let currentObjectBytes = 0;
+        for (const [digest, count] of refCounts.entries()) {
+            if (count > 0)
+                currentObjectBytes += sizeMap.get(digest) ?? 0;
+        }
+        const latestId = rows[0]?.id;
+        // Ordinary versions eligible for version count capping (ordered newest to oldest)
+        const ordinaryDesc = rows.filter((row) => row.label === null && row.reason !== "initial");
+        const toDeleteIds = new Set();
+        const removeVersionRefs = (versionId) => {
+            if (toDeleteIds.has(versionId))
+                return;
+            toDeleteIds.add(versionId);
+            const manifest = manifests.get(versionId);
+            if (!manifest)
+                return;
+            for (const file of Object.values(manifest.files)) {
+                const count = refCounts.get(file.digest);
+                if (count !== undefined) {
+                    if (count === 1) {
+                        refCounts.set(file.digest, 0);
+                        currentObjectBytes -= sizeMap.get(file.digest) ?? 0;
+                    }
+                    else if (count > 1) {
+                        refCounts.set(file.digest, count - 1);
+                    }
+                }
+            }
+        };
+        // 1. Cap by historyMaxVersions (prune excess ordinary versions from newest to oldest offset)
+        if (ordinaryDesc.length > this.config.historyMaxVersions) {
+            const obsolete = ordinaryDesc.slice(this.config.historyMaxVersions);
+            for (const row of obsolete)
+                removeVersionRefs(row.id);
+        }
+        // 2. Cap by historyMaxStorageBytes (prune remaining eligible versions from oldest to newest)
+        if (currentObjectBytes > this.config.historyMaxStorageBytes) {
+            const remainingEligibleAsc = ordinaryDesc
+                .filter((row) => row.id !== latestId && !toDeleteIds.has(row.id))
+                .reverse();
+            for (const row of remainingEligibleAsc) {
+                if (currentObjectBytes <= this.config.historyMaxStorageBytes)
+                    break;
+                removeVersionRefs(row.id);
+            }
+        }
+        if (!toDeleteIds.size)
+            return;
+        // 3. Batch delete rows in a single transaction
+        const remove = this.db.prepare("DELETE FROM project_history_versions WHERE id = ? AND project_id = ?");
+        this.db.transaction(() => {
+            for (const id of toDeleteIds)
+                remove.run(id, projectId);
+        })();
+        // 4. Remove unreferenced CAS objects on disk
+        for (const [digest, count] of refCounts.entries()) {
+            if (count === 0)
+                fs.rmSync(this.objectPath(projectId, digest), { force: true });
         }
     }
     deleteVersions(projectId, rows) {
@@ -292,6 +359,7 @@ export class ProjectHistoryService {
             fs.rmSync(this.objectPath(projectId, digest), { force: true });
     }
     restoreProjectTree(projectId, manifest) {
+        assertNoSourceSymlinks(this.config, projectId);
         const root = projectRoot(this.config, projectId);
         const live = sourceRoot(this.config, projectId);
         const temporary = path.join(root, `.history-restore-${randomUUID()}`);

package/dist/server/http.js

@@ -1,3 +1,29 @@
+export class ValidationError extends Error {
+    statusCode = 400;
+    code = "REQUEST_INVALID";
+    constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+    }
+}
+/**
+ * A collaborative draft could not be made durable on disk.  Mutations that
+ * replace or remove source files must stop at this boundary instead of
+ * continuing with a stale filesystem snapshot.
+ */
+export class SourceFlushError extends Error {
+    statusCode = 409;
+    code = "SOURCE_FLUSH_FAILED";
+    failedPaths;
+    constructor(failedPaths = []) {
+        const paths = [...new Set(failedPaths)].slice(0, 100);
+        super(paths.length
+            ? `部分源码未能保存至磁盘，无法继续项目操作：${paths.join(", ")}`
+            : "部分源码未能保存至磁盘，无法继续项目操作");
+        this.name = "SourceFlushError";
+        this.failedPaths = paths;
+    }
+}
 export function apiError(reply, status, code, message, details = {}) {
     return reply.code(status).send({ code, error: message, ...details });
 }

package/dist/server/index.js

@@ -4,44 +4,57 @@ import { loadConfig } from "./config.js";
 import { activeAdminCount, openDatabase } from "./db.js";
 import { buildApp } from "./app.js";
 import { assertEnvironment } from "./environment.js";
+import { acquireDataDirectoryLock } from "./instanceLock.js";
 export async function startServer(configPath) {
     const config = loadConfig(configPath);
-    const environment = await assertEnvironment(config);
-    const db = openDatabase(config);
-    if (activeAdminCount(db) === 0) {
-        db.close();
-        throw new Error("No active administrator found. Run `texlite init` first (or `npm run init` from a source checkout); the server will not start.");
-    }
-    let app;
+    const lock = acquireDataDirectoryLock(config);
+    let db = null;
+    let app = null;
     try {
+        const environment = await assertEnvironment(config);
+        db = openDatabase(config);
+        if (activeAdminCount(db) === 0) {
+            throw new Error("No active administrator found. Run `texlite init` first (or `npm run init` from a source checkout); the server will not start.");
+        }
         app = await buildApp(config, db);
-    }
-    catch (error) {
-        db.close();
-        throw error;
-    }
-    try {
         await app.listen({ host: config.host, port: config.port });
+        app.log.info(`Environment ready: ${environment.map((item) => `${item.name} ${item.version}`).join(", ")}`);
+        app.log.info(`${config.siteName} running at http://${config.host}:${config.port}`);
+        if (typeof process.send === "function")
+            process.send("ready");
+        return {
+            address: `http://${config.host}:${config.port}`,
+            close: async () => {
+                try {
+                    if (app)
+                        await app.close();
+                }
+                finally {
+                    try {
+                        db?.close();
+                    }
+                    finally {
+                        lock.release();
+                    }
+                }
+            }
+        };
     }
     catch (error) {
-        db.close();
-        throw error;
-    }
-    app.log.info(`Environment ready: ${environment.map((item) => `${item.name} ${item.version}`).join(", ")}`);
-    app.log.info(`${config.siteName} running at http://${config.host}:${config.port}`);
-    if (typeof process.send === "function")
-        process.send("ready");
-    return {
-        address: `http://${config.host}:${config.port}`,
-        close: async () => {
-            try {
+        try {
+            if (app)
                 await app.close();
+        }
+        finally {
+            try {
+                db?.close();
             }
             finally {
-                db.close();
+                lock.release();
             }
         }
-    };
+        throw error;
+    }
 }
 export async function serve(configPath) {
     const running = await startServer(configPath);