texlite 0.10.0 → 0.12.0

package/dist/server/git.js

@@ -22,6 +22,7 @@ export class ProjectGitService {
         await this.ensureGitAvailable();
         assertNoSourceSymlinks(this.config, project.id);
         const settings = this.settings(project.id);
+        const account = this.userSettings(project.owner_id);
         const gitDirectory = path.join(sourceRoot(this.config, project.id), ".git");
         let gitStat = null;
         try {
@@ -37,8 +38,8 @@ export class ProjectGitService {
         if (!initialized)
             return {
                 initialized: false,
-                tokenConfigured: Boolean(settings?.token_ciphertext),
-                githubLogin: settings?.github_login ?? null,
+                tokenConfigured: Boolean(account?.token_ciphertext),
+                githubLogin: account?.github_login ?? null,
                 remoteUrl: settings?.remote_url ?? null,
                 repositoryName: settings?.repository_name ?? null,
                 repositoryHtmlUrl: settings?.repository_html_url ?? null,
@@ -56,11 +57,17 @@ export class ProjectGitService {
         const branch = branchResult.code === 0 ? branchResult.stdout.trim() : null;
         const remoteResult = await this.git(root, ["remote", "get-url", "origin"], [2]);
         const latestResult = await this.git(root, ["log", "-1", "--format=%H%x1f%h%x1f%an%x1f%ae%x1f%aI%x1f%s"], [128]);
-        const aheadResult = await this.git(root, ["rev-list", "--count", "@{upstream}..HEAD"], [128]);
+        const upstreamResult = branch
+            ? await this.git(root, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"], [128])
+            : null;
+        // A newly initialized backup repository has no upstream until its first
+        // push. In that case, every local commit is pending for the remote.
+        const aheadRevision = upstreamResult?.code === 0 ? "@{upstream}..HEAD" : "HEAD";
+        const aheadResult = branch ? await this.git(root, ["rev-list", "--count", aheadRevision], [128]) : null;
         return {
             initialized: true,
-            tokenConfigured: Boolean(settings?.token_ciphertext),
-            githubLogin: settings?.github_login ?? null,
+            tokenConfigured: Boolean(account?.token_ciphertext),
+            githubLogin: account?.github_login ?? null,
             remoteUrl: settings?.remote_url ?? (remoteResult.code === 0 ? remoteResult.stdout.trim() : null),
             repositoryName: settings?.repository_name ?? null,
             repositoryHtmlUrl: settings?.repository_html_url ?? null,
@@ -69,41 +76,43 @@ export class ProjectGitService {
             dirty: Boolean(porcelain),
             restorable: porcelain.split("\n").some((line) => Boolean(line) && !line.startsWith("??")),
             changedFiles: porcelain ? porcelain.split("\n").length : 0,
-            ahead: aheadResult.code === 0 ? Number.parseInt(aheadResult.stdout.trim(), 10) || 0 : 0,
+            ahead: aheadResult?.code === 0 ? Number.parseInt(aheadResult.stdout.trim(), 10) || 0 : 0,
             latestCommit: latestResult.code === 0 ? parseCommit(latestResult.stdout.trim()) : null
         };
     }
-    async configureToken(project, tokenInput) {
+    githubAccountStatus(userId) {
+        const settings = this.userSettings(userId);
+        return { tokenConfigured: Boolean(settings?.token_ciphertext), githubLogin: settings?.github_login ?? null };
+    }
+    async configureUserToken(userId, tokenInput) {
         const token = tokenInput.trim();
         if (token.length < 20 || token.length > 500)
             throw httpError(400, "GIT_TOKEN_INVALID");
-        await this.ensureGitAvailable();
         const account = await this.githubRequest(token, "/user", { method: "GET" });
         if (typeof account.login !== "string" || !account.login)
             throw httpError(502, "GIT_ACCOUNT_INVALID");
-        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,
+        this.db.prepare(`INSERT INTO user_github_settings
+      (user_id, token_ciphertext, github_login, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(user_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);
+            .run(userId, encryptToken(this.config, token), account.login, timestamp, timestamp);
+        return this.githubAccountStatus(userId);
     }
-    async removeToken(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);
+    removeUserToken(userId) {
+        this.db.prepare("DELETE FROM user_github_settings WHERE user_id = ?").run(userId);
+        return this.githubAccountStatus(userId);
     }
     async createGitHubRepository(project, name, isPrivate) {
         if (!/^[A-Za-z0-9._-]{1,100}$/.test(name))
             throw httpError(400, "GIT_REPOSITORY_NAME_INVALID");
         await this.ensureGitAvailable();
-        const settings = this.requireTokenSettings(project.id);
-        if (settings.remote_url)
+        const account = this.requireUserTokenSettings(project.owner_id);
+        const settings = this.settings(project.id);
+        if (settings?.remote_url)
             throw httpError(409, "GIT_REMOTE_ALREADY_CONFIGURED");
-        const token = decryptToken(this.config, settings.token_ciphertext);
+        const token = decryptToken(this.config, account.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}` })
@@ -112,6 +121,7 @@ export class ProjectGitService {
             throw httpError(502, "GIT_REPOSITORY_RESPONSE_INVALID");
         }
         await this.ensureRepository(project);
+        this.ensureProjectSettings(project.id);
         const root = sourceRoot(this.config, project.id);
         const currentRemote = await this.git(root, ["remote", "get-url", "origin"], [2]);
         if (currentRemote.code === 0)
@@ -149,8 +159,8 @@ export class ProjectGitService {
         return parseCommit(result.stdout.trim());
     }
     async push(project) {
-        const settings = this.requireTokenSettings(project.id);
-        if (!settings.remote_url)
+        const account = this.requireUserTokenSettings(project.owner_id);
+        if (!this.settings(project.id)?.remote_url)
             throw httpError(409, "GIT_REMOTE_NOT_CONFIGURED");
         const root = this.requireRepository(project.id);
         assertNoSourceSymlinks(this.config, project.id);
@@ -163,7 +173,7 @@ export class ProjectGitService {
         const branch = branchResult.stdout.trim();
         if (!/^[A-Za-z0-9._/-]+$/.test(branch))
             throw httpError(400, "GIT_BRANCH_INVALID");
-        const token = decryptToken(this.config, settings.token_ciphertext);
+        const token = decryptToken(this.config, account.token_ciphertext);
         await this.git(root, ["push", "--set-upstream", "origin", `HEAD:refs/heads/${branch}`], [], this.authEnvironment(token));
         return this.status(project);
     }
@@ -269,12 +279,20 @@ export class ProjectGitService {
     settings(projectId) {
         return this.db.prepare("SELECT * FROM project_git_settings WHERE project_id = ?").get(projectId);
     }
-    requireTokenSettings(projectId) {
-        const settings = this.settings(projectId);
+    userSettings(userId) {
+        return this.db.prepare("SELECT * FROM user_github_settings WHERE user_id = ?").get(userId);
+    }
+    requireUserTokenSettings(userId) {
+        const settings = this.userSettings(userId);
         if (!settings?.token_ciphertext)
             throw httpError(409, "GIT_TOKEN_NOT_CONFIGURED");
         return settings;
     }
+    ensureProjectSettings(projectId) {
+        const timestamp = new Date().toISOString();
+        this.db.prepare(`INSERT INTO project_git_settings (project_id, default_branch, created_at, updated_at)
+      VALUES (?, 'main', ?, ?) ON CONFLICT(project_id) DO NOTHING`).run(projectId, timestamp, timestamp);
+    }
     async verifyCommit(root, revision) {
         const result = await this.git(root, ["rev-parse", "--verify", `${revision}^{commit}`], [128]);
         if (result.code !== 0)
@@ -303,7 +321,10 @@ export class ProjectGitService {
                 }
             });
             if (!response.ok) {
-                throw httpError(response.status === 401 || response.status === 403 ? 400 : 502, response.status === 401 || response.status === 403 ? "GIT_TOKEN_REJECTED" : "GIT_OPERATION_FAILED");
+                const authError = classifyGitHubAuthFailure(response.status);
+                if (authError)
+                    throw httpError(400, authError);
+                throw httpError(502, "GIT_OPERATION_FAILED");
             }
             return await response.json();
         }
@@ -376,13 +397,27 @@ export class ProjectGitService {
                 if (size > MAX_COMMAND_OUTPUT)
                     return reject(httpError(413, "GIT_OUTPUT_TOO_LARGE"));
                 if (result.code !== 0 && !allowedCodes.includes(result.code)) {
-                    return reject(httpError(400, "GIT_COMMAND_FAILED"));
+                    const pushAuthError = args[0] === "push" ? classifyGitPushFailure(result.stderr) : null;
+                    return reject(httpError(400, pushAuthError ?? "GIT_COMMAND_FAILED"));
                 }
                 resolve(result);
             });
         });
     }
 }
+function classifyGitHubAuthFailure(status) {
+    // GitHub's 401/403 responses do not reliably distinguish invalid or expired
+    // credentials from insufficient repository access (including SSO/policy
+    // restrictions), so give users one actionable message for these cases.
+    return status === 401 || status === 403 ? "GIT_TOKEN_REJECTED" : null;
+}
+export function classifyGitPushFailure(stderr) {
+    if (/saml|single[- ]sign[- ]on|\bsso\b/i.test(stderr) ||
+        /invalid username or token|bad credentials|authentication failed|could not read username/i.test(stderr) ||
+        /write access.{0,80}(?:not granted|denied)|permission to .{1,200} denied|repository not found|returned error:\s*403/i.test(stderr))
+        return "GIT_TOKEN_REJECTED";
+    return null;
+}
 function parseCommit(line) {
     const [sha = "", shortSha = "", authorName = "", authorEmail = "", authoredAt = "", ...message] = line.split("\x1f");
     return { sha, shortSha, authorName, authorEmail, authoredAt, message: message.join("\x1f") };

package/dist/server/harper.js

@@ -115,6 +115,20 @@ export class HarperService {
     async preload() {
         await this.ensureAvailable();
     }
+    /** Availability probe only; does not run a writing check or join its queue. */
+    async isAvailable() {
+        if (this.disposed)
+            return false;
+        try {
+            await this.ensureAvailable();
+            return !this.disposed;
+        }
+        catch (error) {
+            if (error instanceof HarperUnavailableError)
+                return false;
+            throw error;
+        }
+    }
     /**
      * Schedule one host-side check. A lane represents one browser page's
      * current file, so an edit can replace only its own stale waiting request

package/dist/server/history.js

@@ -4,6 +4,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { assertNoSourceSymlinks, listProjectFiles, outputRoot, projectRoot, resolveSourcePath, safeRelativePath, sourceRoot } from "./files.js";
 import { httpError } from "./http.js";
 import { MAX_TEXT_PREVIEW_BYTES } from "./limits.js";
+import { isUtf8 } from "node:buffer";
+import { isHistoryTextFile } from "../shared/historyFiles.js";
 const AUTOSAVE_COALESCE_MS = 2 * 60_000;
 // Logical stored payload; SQLite pages, indexes and WAL are shared database overhead.
 function historyMetadataBytes(row) {
@@ -39,7 +41,9 @@ export class ProjectHistoryService {
             }
         }
         const changedPaths = previousManifest ? changedManifestPaths(previousManifest, manifest) : Object.keys(manifest.files).sort();
-        if (previousManifest && changedPaths.length === 0 && JSON.stringify(previousManifest.settings) === JSON.stringify(manifest.settings)) {
+        // Settings alone do not create a file-history entry. Keep the baseline
+        // current so the next real file change captures the effective settings.
+        if (changedPaths.length === 0) {
             this.saveBaseline(projectId, manifest);
             return null;
         }
@@ -72,7 +76,8 @@ export class ProjectHistoryService {
     list(projectId, limit = 100) {
         const rows = this.db.prepare(`SELECT history.*, user.username AS author_username, user.display_name AS author_name
       FROM project_history_versions history LEFT JOIN users user ON user.id = history.author_id
-      WHERE history.project_id = ? ORDER BY history.created_at DESC, history.rowid DESC LIMIT ?`)
+      WHERE history.project_id = ? AND json_array_length(history.changed_paths_json) > 0
+      ORDER BY history.created_at DESC, history.rowid DESC LIMIT ?`)
             .all(projectId, Math.min(200, Math.max(1, limit)));
         return rows.map((row) => versionJson(row));
     }
@@ -97,7 +102,7 @@ export class ProjectHistoryService {
         const rows = this.db.prepare(`SELECT history.*, history.rowid AS history_rowid,
       user.username AS author_username, user.display_name AS author_name
       FROM project_history_versions history LEFT JOIN users user ON user.id = history.author_id
-      WHERE history.project_id = ? ${cursorFilter}
+      WHERE history.project_id = ? AND json_array_length(history.changed_paths_json) > 0 ${cursorFilter}
       ORDER BY history.created_at DESC, history.rowid DESC LIMIT ?`)
             .all(...values);
         const pageRows = rows.slice(0, limitValue);
@@ -231,7 +236,8 @@ export class ProjectHistoryService {
     previousVersion(projectId, versionId) {
         const row = this.db.prepare(`SELECT older.id FROM project_history_versions older
       JOIN project_history_versions selected ON selected.id = ? AND selected.project_id = older.project_id
-      WHERE older.project_id = ? AND (older.created_at < selected.created_at
+      WHERE older.project_id = ? AND json_array_length(older.changed_paths_json) > 0
+        AND (older.created_at < selected.created_at
         OR (older.created_at = selected.created_at AND older.rowid < selected.rowid))
       ORDER BY older.created_at DESC, older.rowid DESC LIMIT 1`).get(versionId, projectId);
         return row ? this.version(row.id, projectId) : null;
@@ -243,6 +249,8 @@ export class ProjectHistoryService {
     }
     readTextFile(projectId, versionId, filePathInput) {
         const filePath = safeRelativePath(filePathInput);
+        if (!isHistoryTextFile(filePath))
+            return null;
         const entry = this.manifest(projectId, versionId)?.files[filePath];
         if (!entry || entry.size > MAX_TEXT_PREVIEW_BYTES)
             return null;
@@ -272,8 +280,8 @@ export class ProjectHistoryService {
             return { restoredPaths: [filePath], manifest };
         }
         this.restoreProjectTree(projectId, manifest);
-        this.db.prepare("UPDATE projects SET main_file = ?, engine = ?, latexmkrc = ? WHERE id = ?")
-            .run(manifest.settings.mainFile, manifest.settings.engine, manifest.settings.latexmkrc, projectId);
+        this.db.prepare("UPDATE projects SET main_file = ?, engine = ?, latexmkrc = ?, chktex_enabled = ? WHERE id = ?")
+            .run(manifest.settings.mainFile, manifest.settings.engine, manifest.settings.latexmkrc, manifest.settings.chktexEnabled ? 1 : 0, projectId);
         return { restoredPaths: Object.keys(manifest.files).sort(), manifest };
     }
     assertRestoreTargetIsFile(projectId, filePath) {
@@ -364,7 +372,8 @@ export class ProjectHistoryService {
      */
     readStoredObject(projectId, digest, filePath) {
         try {
-            return fs.readFileSync(this.objectPath(projectId, digest), "utf8");
+            const bytes = fs.readFileSync(this.objectPath(projectId, digest));
+            return !bytes.includes(0) && isUtf8(bytes) ? bytes.toString("utf8") : null;
         }
         catch (error) {
             this.rethrowHistoryObjectError(error, filePath);
@@ -570,7 +579,7 @@ export class ProjectHistoryService {
     }
 }
 function settings(project) {
-    return { mainFile: project.main_file, engine: project.engine, latexmkrc: project.latexmkrc };
+    return { mainFile: project.main_file, engine: project.engine, latexmkrc: project.latexmkrc, chktexEnabled: Boolean(project.chktex_enabled) };
 }
 function cloneManifest(manifest) {
     return { version: 1, files: { ...manifest.files }, settings: { ...manifest.settings } };
@@ -579,7 +588,7 @@ function parseManifest(value) {
     const parsed = JSON.parse(value);
     if (parsed.version !== 1 || !parsed.files || !parsed.settings)
         throw new Error("History manifest is invalid");
-    return parsed;
+    return { ...parsed, settings: { ...parsed.settings, chktexEnabled: parsed.settings.chktexEnabled === true } };
 }
 function parseStringArray(value) {
     try {

package/dist/server/i18n.js

@@ -11,6 +11,10 @@ const enMessages = {
     CITATION_NOT_FOUND: "The citation does not exist.",
     CITATION_TAG_NOT_FOUND: "The citation tag does not exist.",
     CITATION_TOO_LARGE: "The BibTeX entry is too large.",
+    CHK_TEX_SOURCE_INVALID: "The source to check is invalid.",
+    CHK_TEX_SOURCE_TOO_LARGE: "The source to check is too large.",
+    CHK_TEX_SUPERSEDED: "A newer ChkTeX check replaced this request.",
+    CHK_TEX_UNAVAILABLE: "ChkTeX is not installed or cannot run on this server. Install the TeX Live chktex package and try again.",
     COMMENT_DELETE_FORBIDDEN: "You can only delete your own comments.",
     COMMENT_EDIT_FORBIDDEN: "You can only edit your own comments.",
     COMMENT_FILE_NOT_FOUND: "The file for this comment does not exist.",
@@ -42,7 +46,7 @@ const enMessages = {
     GIT_REVISION_INVALID: "Choose a Git revision to check out.",
     GIT_TOKEN_INVALID: "Enter a GitHub token.",
     GIT_TOKEN_NOT_CONFIGURED: "Configure a GitHub token first.",
-    GIT_TOKEN_REJECTED: "GitHub rejected this token. Check its permissions and try again.",
+    GIT_TOKEN_REJECTED: "GitHub rejected this token. It may be invalid, expired, or lack the required permissions.",
     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.",
@@ -77,6 +81,7 @@ const enMessages = {
     PROJECT_ICON_INVALID: "Enter a valid installed Lucide icon short name.",
     PROJECT_NOT_FOUND: "The project does not exist or is no longer accessible.",
     PROJECT_OWNER_ONLY: "Only the project owner can perform this action.",
+    PROJECT_SETTINGS_CONFLICT: "These project settings changed in another session. Refresh the project page before saving again.",
     PROJECT_TRANSFER_FORBIDDEN: "Only the current project owner can transfer ownership.",
     PROJECT_TRANSFER_SELF: "You already own this project.",
     PROJECT_TRANSFER_TARGET_INVALID: "Choose a new project owner.",
@@ -106,7 +111,7 @@ const enMessages = {
     WORD_COUNT_FAILED: "TeXcount could not count this source.",
     WORD_COUNT_SOURCE_INVALID: "Select LaTeX source text to count.",
     WORD_COUNT_SOURCE_TOO_LARGE: "The selected source is too large to count.",
-    WORD_COUNT_UNAVAILABLE: "TeXcount is not available on this server. Install it from TeX Live and try again.",
+    WORD_COUNT_UNAVAILABLE: "The TeX Live texcount package is not installed on this server. Install it and try again.",
     ZIP_DUPLICATE_ENTRY: "The ZIP archive contains a duplicate filename: {{path}}.",
     ZIP_ENTRY_READ_FAILED: "A ZIP archive entry could not be read.",
     ZIP_ENTRY_TOO_LARGE: "The ZIP archive contains a file that exceeds the permitted size.",
@@ -143,6 +148,10 @@ const zhMessages = {
     CITATION_NOT_FOUND: "引用条目不存在。",
     CITATION_TAG_NOT_FOUND: "引用标签不存在。",
     CITATION_TOO_LARGE: "BibTeX 条目过大。",
+    CHK_TEX_SOURCE_INVALID: "待检查源码格式不正确。",
+    CHK_TEX_SOURCE_TOO_LARGE: "待检查源码过大。",
+    CHK_TEX_SUPERSEDED: "更新的 ChkTeX 检查已替代此请求。",
+    CHK_TEX_UNAVAILABLE: "服务器未安装 ChkTeX，或 ChkTeX 当前无法运行。请在服务器安装 TeX Live 的 chktex 包后重试。",
     COMMENT_DELETE_FORBIDDEN: "只能删除自己的批注。",
     COMMENT_EDIT_FORBIDDEN: "只能编辑自己的批注。",
     COMMENT_FILE_NOT_FOUND: "批注对应的文件不存在。",
@@ -174,7 +183,7 @@ const zhMessages = {
     GIT_REVISION_INVALID: "请选择要 checkout 的 Git 版本。",
     GIT_TOKEN_INVALID: "请输入 GitHub token。",
     GIT_TOKEN_NOT_CONFIGURED: "请先配置 GitHub token。",
-    GIT_TOKEN_REJECTED: "GitHub 拒绝了该 token，请检查权限后重试。",
+    GIT_TOKEN_REJECTED: "GitHub 拒绝了此 token：它可能无效、已过期或权限不足。",
     GIT_UNAVAILABLE: "服务器未安装 Git。",
     HARPER_UNAVAILABLE: "Harper 拼写与语法检查暂不可用。",
     HISTORY_FILE_NOT_FOUND: "历史文件不存在。",
@@ -209,6 +218,7 @@ const zhMessages = {
     PROJECT_ICON_INVALID: "请输入已安装的有效 Lucide 图标短名称。",
     PROJECT_NOT_FOUND: "项目不存在或你已无法访问。",
     PROJECT_OWNER_ONLY: "只有项目所有者可以执行此操作。",
+    PROJECT_SETTINGS_CONFLICT: "项目设置已在其他会话中更改。请刷新项目页面后再保存。",
     PROJECT_TRANSFER_FORBIDDEN: "只有当前项目所有者可以转让项目。",
     PROJECT_TRANSFER_SELF: "你已经是该项目的所有者。",
     PROJECT_TRANSFER_TARGET_INVALID: "请选择新的项目所有者。",
@@ -238,7 +248,7 @@ const zhMessages = {
     WORD_COUNT_FAILED: "TeXcount 无法统计这段源码。",
     WORD_COUNT_SOURCE_INVALID: "请选择 LaTeX 源码后再统计。",
     WORD_COUNT_SOURCE_TOO_LARGE: "所选源码过大，无法统计。",
-    WORD_COUNT_UNAVAILABLE: "服务器未安装 TeXcount，请安装 TeX Live 后重试。",
+    WORD_COUNT_UNAVAILABLE: "服务器未安装 TeX Live 的 texcount 包，请安装后重试。",
     ZIP_DUPLICATE_ENTRY: "ZIP 压缩包包含重复文件名：{{path}}。",
     ZIP_ENTRY_READ_FAILED: "无法读取 ZIP 压缩包中的文件。",
     ZIP_ENTRY_TOO_LARGE: "ZIP 压缩包中存在超过限制的文件。",

package/dist/server/projectImportUploads.js

@@ -0,0 +1,133 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+const CHUNK_SIZE = 4 * 1024 * 1024;
+const SESSION_TTL_MS = 30 * 60 * 1000;
+const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
+const MAX_ACTIVE_UPLOADS = 8;
+const MAX_ACTIVE_UPLOADS_PER_USER = 2;
+const MAX_IN_FLIGHT_CHUNKS_PER_UPLOAD = 4;
+export class ProjectImportUploadError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ProjectImportUploadError";
+    }
+}
+/** Bounded, per-user temporary storage for parallel ZIP upload chunks. */
+export class ProjectImportUploads {
+    rootDirectory;
+    sessions = new Map();
+    cleanupTimer;
+    constructor(config) {
+        this.rootDirectory = path.join(config.dataDir, "tmp", "project-imports");
+        this.cleanupTimer = setInterval(() => { void this.cleanupExpired().catch(() => undefined); }, CLEANUP_INTERVAL_MS);
+        this.cleanupTimer.unref();
+    }
+    async initialize() {
+        await fs.mkdir(this.rootDirectory, { recursive: true, mode: 0o700 });
+        // Any remaining entries are abandoned uploads from a previous server run.
+        const entries = await fs.readdir(this.rootDirectory, { withFileTypes: true });
+        await Promise.all(entries.map((entry) => fs.rm(path.join(this.rootDirectory, entry.name), { recursive: true, force: true })));
+    }
+    async start(userId, filename, size, maxBytes) {
+        await this.cleanupExpired();
+        if (!Number.isSafeInteger(size) || size <= 0 || size > maxBytes)
+            throw new ProjectImportUploadError("ZIP_UPLOAD_SIZE_INVALID");
+        const active = [...this.sessions.values()];
+        const reservedBytes = active.reduce((sum, session) => sum + session.size, 0);
+        if (active.length >= MAX_ACTIVE_UPLOADS || active.filter((session) => session.userId === userId).length >= MAX_ACTIVE_UPLOADS_PER_USER || reservedBytes + size > maxBytes * 2) {
+            throw new ProjectImportUploadError("ZIP_UPLOAD_LIMIT");
+        }
+        const id = randomUUID();
+        const directory = path.join(this.rootDirectory, id);
+        await fs.mkdir(directory, { recursive: false, mode: 0o700 });
+        const chunkCount = Math.ceil(size / CHUNK_SIZE);
+        const timestamp = Date.now();
+        this.sessions.set(id, {
+            id, userId, filename, size, chunkCount, directory, received: new Set(), inFlight: new Set(),
+            updatedAt: timestamp, completing: false
+        });
+        return { uploadId: id, chunkSize: CHUNK_SIZE, chunkCount };
+    }
+    async writeChunk(userId, uploadId, index, bytes) {
+        const session = this.getSession(userId, uploadId);
+        if (!Number.isSafeInteger(index) || index < 0 || index >= session.chunkCount || session.completing) {
+            throw new ProjectImportUploadError("ZIP_UPLOAD_CHUNK_INVALID");
+        }
+        if (session.inFlight.size >= MAX_IN_FLIGHT_CHUNKS_PER_UPLOAD)
+            throw new ProjectImportUploadError("ZIP_UPLOAD_LIMIT");
+        if (session.received.has(index) || session.inFlight.has(index))
+            throw new ProjectImportUploadError("ZIP_UPLOAD_CHUNK_DUPLICATE");
+        const expectedSize = Math.min(CHUNK_SIZE, session.size - index * CHUNK_SIZE);
+        if (bytes.length !== expectedSize)
+            throw new ProjectImportUploadError("ZIP_UPLOAD_CHUNK_INVALID");
+        session.inFlight.add(index);
+        try {
+            await fs.writeFile(path.join(session.directory, `${index}.part`), bytes, { flag: "wx", mode: 0o600 });
+            session.received.add(index);
+            session.updatedAt = Date.now();
+        }
+        finally {
+            session.inFlight.delete(index);
+        }
+    }
+    async assemble(userId, uploadId) {
+        const session = this.getSession(userId, uploadId);
+        if (session.completing || session.inFlight.size > 0 || session.received.size !== session.chunkCount) {
+            throw new ProjectImportUploadError("ZIP_UPLOAD_INCOMPLETE");
+        }
+        session.completing = true;
+        try {
+            const buffer = Buffer.allocUnsafe(session.size);
+            let offset = 0;
+            for (let index = 0; index < session.chunkCount; index += 1) {
+                const chunk = await fs.readFile(path.join(session.directory, `${index}.part`));
+                if (chunk.length !== Math.min(CHUNK_SIZE, session.size - offset))
+                    throw new ProjectImportUploadError("ZIP_UPLOAD_CHUNK_INVALID");
+                chunk.copy(buffer, offset);
+                offset += chunk.length;
+            }
+            if (offset !== session.size)
+                throw new ProjectImportUploadError("ZIP_UPLOAD_CHUNK_INVALID");
+            return { filename: session.filename, buffer };
+        }
+        catch (error) {
+            if (error instanceof ProjectImportUploadError)
+                throw error;
+            throw new ProjectImportUploadError("ZIP_UPLOAD_INCOMPLETE");
+        }
+        finally {
+            await this.removeSession(session);
+        }
+    }
+    async cancel(userId, uploadId) {
+        const session = this.sessions.get(uploadId);
+        if (!session || session.userId !== userId || session.completing || session.inFlight.size > 0)
+            return;
+        await this.removeSession(session);
+    }
+    async close() {
+        clearInterval(this.cleanupTimer);
+        await Promise.all([...this.sessions.values()].map((session) => this.removeSession(session)));
+    }
+    getSession(userId, uploadId) {
+        const session = this.sessions.get(uploadId);
+        if (!session || session.userId !== userId || Date.now() - session.updatedAt > SESSION_TTL_MS) {
+            if (session && Date.now() - session.updatedAt > SESSION_TTL_MS)
+                void this.removeSession(session).catch(() => undefined);
+            throw new ProjectImportUploadError("ZIP_UPLOAD_NOT_FOUND");
+        }
+        return session;
+    }
+    async cleanupExpired() {
+        const expired = [...this.sessions.values()].filter((session) => !session.completing && session.inFlight.size === 0 && Date.now() - session.updatedAt > SESSION_TTL_MS);
+        await Promise.all(expired.map((session) => this.removeSession(session)));
+    }
+    async removeSession(session) {
+        if (this.sessions.get(session.id) === session)
+            this.sessions.delete(session.id);
+        await fs.rm(session.directory, { recursive: true, force: true });
+    }
+}

package/dist/server/routes/projectFiles.js

@@ -477,6 +477,9 @@ export function registerProjectFileRoutes(app, context) {
                 throw error;
             }
             fs.rmSync(absolute, { recursive: true, force: true });
+            if (currentProject.latexmkrc === relative || currentProject.latexmkrc?.startsWith(`${relative}/`)) {
+                db.prepare("UPDATE projects SET latexmkrc = NULL WHERE id = ?").run(id);
+            }
             const deleteResult = db.prepare("DELETE FROM comments WHERE project_id = ? AND (file_path = ? OR file_path GLOB ?)").run(id, relative, `${escapeGlobPattern(relative)}/*`);
             touchProject(db, id, user.id);
             collaboration.removePath(id, relative);

package/dist/server/routes/projectGit.js

@@ -23,27 +23,26 @@ export function registerProjectGitRoutes(app, context) {
             return { status: await projectGit.status(requireGitOwner(id, user)) };
         }, { preflight: () => { requireGitOwner(id, user); } });
     });
-    app.put("/api/projects/:id/git/token", async (request, reply) => {
+    app.get("/api/account/github", async (request, reply) => {
+        const user = requireUser(request, reply, db);
+        if (!user)
+            return;
+        return { status: projectGit.githubAccountStatus(user.id) };
+    });
+    app.put("/api/account/github", async (request, reply) => {
         const user = requireUser(request, reply, db);
         if (!user)
             return;
-        const { id } = request.params;
         const body = request.body;
         if (typeof body.token !== "string")
             return apiError(reply, 400, "GIT_TOKEN_INVALID");
-        const token = body.token;
-        return await projectMutations.runSerialized(id, async () => {
-            return { status: await projectGit.configureToken(requireGitOwner(id, user), token) };
-        }, { preflight: () => { requireGitOwner(id, user); } });
+        return { status: await projectGit.configureUserToken(user.id, body.token) };
     });
-    app.delete("/api/projects/:id/git/token", async (request, reply) => {
+    app.delete("/api/account/github", async (request, reply) => {
         const user = requireUser(request, reply, db);
         if (!user)
             return;
-        const { id } = request.params;
-        return await projectMutations.runSerialized(id, async () => {
-            return { status: await projectGit.removeToken(requireGitOwner(id, user)) };
-        }, { preflight: () => { requireGitOwner(id, user); } });
+        return { status: projectGit.removeUserToken(user.id) };
     });
     app.post("/api/projects/:id/git/repository", async (request, reply) => {
         const user = requireUser(request, reply, db);

package/dist/server/routes/projectHistory.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { isUtf8 } from "node:buffer";
 import { requireUser } from "../auth.js";
 import { isCollaborativeTextFile, maxCollaborativeFileBytes } from "../collaboration.js";
 import { hashText } from "../editHistory.js";
@@ -6,6 +7,7 @@ import { HISTORY_RETENTION_DELAY_MS } from "../historyRetention.js";
 import { resolveSourcePath, safeRelativePath } from "../files.js";
 import { apiError, httpError } from "../http.js";
 import { MAX_TEXT_PREVIEW_BYTES } from "../limits.js";
+import { isHistoryTextFile } from "../../shared/historyFiles.js";
 import { accessibleProject, canEdit } from "../projects.js";
 import { commentsSummaryForProject, projectJson, projectTextSnapshot, reanchorProjectSnapshot, requireEditableProject, requireProjectOwnerPermission, tagsForProject, text, touchProject } from "./projectShared.js";
 /** Register retained project version listing, inspection, restoration, and cleanup routes. */
@@ -112,7 +114,10 @@ export function registerProjectHistoryRoutes(app, context) {
         return {
             version,
             settings: manifest.settings,
-            files: Object.entries(manifest.files).map(([filePath, file]) => ({ path: filePath, size: file.size })).sort((left, right) => left.path.localeCompare(right.path))
+            files: [
+                ...Object.entries(manifest.files).map(([filePath, file]) => ({ path: filePath, size: file.size })),
+                ...version.changedPaths.filter((filePath) => !manifest.files[filePath]).map((filePath) => ({ path: filePath, size: 0, deleted: true }))
+            ].sort((left, right) => left.path.localeCompare(right.path))
         };
     });
     app.get("/api/projects/:id/history/:versionId/file", async (request, reply) => {
@@ -125,19 +130,41 @@ export function registerProjectHistoryRoutes(app, context) {
         const query = request.query;
         const filePath = safeRelativePath(query.path ?? "");
         return await projectMutations.runConsistentRead(id, () => {
-            const historical = history.readTextFile(id, versionId, filePath);
+            const manifest = history.manifest(id, versionId);
+            const version = history.version(versionId, id);
+            if (!manifest || !version)
+                return apiError(reply, 404, "HISTORY_VERSION_NOT_FOUND");
+            if (!manifest.files[filePath] && !version.changedPaths.includes(filePath))
+                return apiError(reply, 404, "HISTORY_FILE_NOT_FOUND");
+            // Never decode attachment bytes as UTF-8, including direct API calls.
+            if (!isHistoryTextFile(filePath))
+                return apiError(reply, 415, "HISTORY_FILE_PREVIEW_UNSUPPORTED", { path: filePath });
+            const historical = manifest.files[filePath] ? history.readTextFile(id, versionId, filePath) : "";
             if (historical === null)
                 return apiError(reply, 415, "HISTORY_FILE_PREVIEW_UNSUPPORTED", { path: filePath });
             let comparison = "";
             const previousVersion = query.against === "__previous__" ? history.previousVersion(id, versionId) : null;
             const against = query.against === "__previous__" ? previousVersion?.id ?? "__none__" : query.against;
             if (query.against) {
-                comparison = history.readTextFile(id, against, filePath) ?? "";
+                const comparisonManifest = history.manifest(id, against);
+                if (against !== "__none__" && !comparisonManifest)
+                    return apiError(reply, 404, "HISTORY_VERSION_NOT_FOUND");
+                if (comparisonManifest?.files[filePath]) {
+                    const text = history.readTextFile(id, against, filePath);
+                    if (text === null)
+                        return apiError(reply, 415, "HISTORY_FILE_PREVIEW_UNSUPPORTED", { path: filePath });
+                    comparison = text;
+                }
             }
             else {
                 const current = resolveSourcePath(config, id, filePath);
-                if (fs.existsSync(current) && fs.statSync(current).isFile() && fs.statSync(current).size <= MAX_TEXT_PREVIEW_BYTES) {
-                    comparison = fs.readFileSync(current, "utf8");
+                if (fs.existsSync(current) && fs.statSync(current).isFile()) {
+                    if (fs.statSync(current).size > MAX_TEXT_PREVIEW_BYTES)
+                        return apiError(reply, 415, "HISTORY_FILE_PREVIEW_UNSUPPORTED", { path: filePath });
+                    const bytes = fs.readFileSync(current);
+                    if (bytes.includes(0) || !isUtf8(bytes))
+                        return apiError(reply, 415, "HISTORY_FILE_PREVIEW_UNSUPPORTED", { path: filePath });
+                    comparison = bytes.toString("utf8");
                 }
             }
             return { path: filePath, historical, comparison, against: against ?? "current", previousVersion };