papilot 0.6.0 → 0.8.0

package/src/server/git-overview.ts

@@ -0,0 +1,69 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import { promisify } from 'node:util';
+import type { GitGraphCommit, GitOverview, GitWorktree, Task } from '../shared.ts';
+import { gitStatus } from './manuscript.ts';
+
+const exec = promisify(execFile);
+async function git(root: string, args: string[]) {
+  return (await exec('git', args, { cwd: root, timeout: 15_000, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } })).stdout;
+}
+const realPath = (value: string) => { try { return fs.realpathSync(value); } catch { return value; } };
+
+// -z preserves spaces, newlines and backslashes in paths and lock reasons.
+export function parseWorktrees(output: string, root: string): GitWorktree[] {
+  const current = realPath(root);
+  return output.split('\0\0').filter(Boolean).map(record => {
+    const fields = new Map(record.split('\0').map(field => {
+      const space = field.indexOf(' ');
+      return space < 0 ? [field, ''] : [field.slice(0, space), field.slice(space + 1)];
+    }));
+    const path = fields.get('worktree') || '';
+    const head = fields.get('HEAD');
+    return {
+      path, branch: fields.get('branch')?.replace(/^refs\/heads\//, '') || null,
+      head: head && !/^0+$/.test(head) ? head : null,
+      current: realPath(path) === current, bare: fields.has('bare'), status: null,
+      ...(fields.has('locked') ? { locked: fields.get('locked')! } : {}),
+      ...(fields.has('prunable') ? { prunable: fields.get('prunable')! } : {}),
+    };
+  });
+}
+
+export async function gitOverview(root: string, tasks: Pick<Task, 'id' | 'worktree'>[] = []): Promise<GitOverview> {
+  const worktrees = parseWorktrees(await git(root, ['worktree', 'list', '--porcelain', '-z']), root);
+  // Tasks can share a HEAD and use opaque branch names. Match their actual
+  // checkout paths, including /var vs /private/var and other symlink aliases.
+  const taskPaths = new Map(tasks.map(task => [realPath(task.worktree), task.id]));
+  for (const tree of worktrees) {
+    const taskId = taskPaths.get(realPath(tree.path));
+    if (taskId) tree.taskId = taskId;
+  }
+  // Bound the number of simultaneous status processes for repositories with many tasks.
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(4, worktrees.length) }, async () => {
+    while (next < worktrees.length) {
+      const tree = worktrees[next++];
+      if (tree.bare) continue;
+      try { tree.status = await gitStatus(tree.path); }
+      catch { tree.error = 'Could not read this worktree.'; }
+    }
+  }));
+  worktrees.sort((a, b) => Number(b.current) - Number(a.current));
+  const refs = new Map<string, string[]>();
+  const refOutput = await git(root, ['for-each-ref', '--format=%(objectname)%00%(refname:short)%00%(*objectname)', 'refs/heads', 'refs/remotes', 'refs/tags']);
+  for (const line of refOutput.trim().split('\n').filter(Boolean)) {
+    const [object, name, peeled] = line.split('\0'), hash = peeled || object;
+    refs.set(hash, [...(refs.get(hash) || []), name]);
+  }
+  // Include detached worktree tips, which --branches alone would miss.
+  const heads = [...new Set(worktrees.flatMap(tree => tree.head ? [tree.head] : []))];
+  if (!heads.length && !refs.size) return { worktrees, commits: [], truncated: false };
+  const limit = 80;
+  const log = await git(root, ['log', '--topo-order', `-${limit + 1}`, '--format=%H%x00%P%x00%s%x00%an%x00%ct', '--branches', '--remotes', '--tags', ...heads, '--']);
+  const commits: GitGraphCommit[] = log.trim().split('\n').filter(Boolean).map(line => {
+    const [hash, parents, subject, author, date] = line.split('\0');
+    return { hash, parents: parents ? parents.split(' ') : [], subject, author, date: Number(date) * 1000, refs: refs.get(hash) || [] };
+  });
+  return { worktrees, commits: commits.slice(0, limit), truncated: commits.length > limit };
+}

package/src/server/imports.ts

@@ -0,0 +1,205 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import { pipeline } from 'node:stream/promises';
+import yauzl from 'yauzl';
+import { DATA, ENGINE } from './paths.ts';
+import type { PaperImport, Project } from '../shared.ts';
+import type { Manuscripts } from './manuscript.ts';
+
+const execute = promisify(execFile);
+const MAX_BYTES = 64 * 1024 * 1024, MAX_FILES = 5000;
+const CONFIG = '.latex-review.json';
+const skip = (name: string) => ['.git', '__macosx', '.ds_store', 'node_modules', '.papilot'].includes(name.toLowerCase()) || name.startsWith('._');
+const git = async (root: string, ...args: string[]) => (await execute('git', ['-C', root, ...args], { timeout: 30000, maxBuffer: 8 * 1024 * 1024 })).stdout.trim();
+function safeName(name: unknown): string {
+  if (typeof name !== 'string' || !name || name.length > 4000 || /[\\\x00-\x1f:]/.test(name) || name.startsWith('/') || name.split('/').some(part => !part || part === '.' || part === '..')) throw new Error('Invalid file path in upload.');
+  return name;
+}
+function bytes(value: unknown) {
+  if (typeof value !== 'string' || value.length > Math.ceil(MAX_BYTES / 3) * 4 || value.length % 4 || /[^A-Za-z0-9+/=]/.test(value) || /=/.test(value.slice(0, -2)) || /=[^=]$/.test(value)) throw new Error('Invalid upload data.');
+  return Buffer.from(value, 'base64');
+}
+function config(root: string): Record<string, unknown> {
+  const file = path.join(root, CONFIG);
+  if (!fs.existsSync(file)) return {};
+  if (fs.lstatSync(file).isSymbolicLink()) throw new Error('The paper configuration must not be a symbolic link.');
+  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!data || typeof data !== 'object' || Array.isArray(data)) throw new Error('The paper configuration must contain a JSON object.');
+  return data;
+}
+export function texFiles(root: string) {
+  const files: string[] = []; let count = 0;
+  function walk(folder: string, depth: number) {
+    if (depth > 20) return;
+    for (const item of fs.readdirSync(path.join(root, folder), { withFileTypes: true })) {
+      if (++count > MAX_FILES) throw new Error('This folder has too many files. Select the folder containing just the paper.');
+      if (skip(item.name) || ['build', 'out', 'output'].includes(item.name)) continue;
+      const file = path.posix.join(folder, item.name);
+      if (item.isDirectory()) walk(file, depth + 1);
+      else if (item.isFile() && /\.tex$/i.test(file)) files.push(file);
+    }
+  }
+  walk('', 0); return files.sort();
+}
+export async function inspectPaper(root: string) {
+  const files = texFiles(root), roots = files.filter(file => {
+    const text = fs.readFileSync(path.join(root, file), 'utf8').slice(0, 300000).replace(/(?<!\\)%[^\n]*/g, '');
+    return /\\documentclass\b/.test(text) && /\\begin\s*\{document\}/.test(text);
+  });
+  let main = roots.length === 1 ? roots[0] : '', engine = '', error: string | undefined;
+  try {
+    const settings = config(root);
+    if (typeof settings.main === 'string' && files.includes(settings.main)) main = settings.main;
+    const module = await import(pathToFileURL(path.join(ENGINE, 'src/core/config.ts')).href);
+    if (!main) { try { main = module.detectMain(root); } catch { /* The author chooses among all TeX files. */ } }
+    // Engine detection also works before Git initialization by reading the source hints.
+    if (main) {
+      const text = fs.readFileSync(path.join(root, main), 'utf8');
+      engine = typeof settings.engine === 'string' ? settings.engine : '';
+      const rc = [path.join(path.dirname(main), '.latexmkrc'), path.join(path.dirname(main), 'latexmkrc'), '.latexmkrc', 'latexmkrc'].find(file => fs.existsSync(path.join(root, file)));
+      const mode = rc ? fs.readFileSync(path.join(root, rc), 'utf8').match(/^\s*\$pdf_mode\s*=\s*(\d)/m)?.[1] : undefined;
+      if (!engine) engine = text.match(/^%\s*!\s*TEX\s+(?:TS-)?program\s*=\s*(pdflatex|xelatex|lualatex)/im)?.[1].toLowerCase() || ({ '1': 'pdflatex', '4': 'lualatex', '5': 'xelatex' } as Record<string, string>)[mode || ''] || (/\\(?:usepackage(?:\[[^\]]*\])?\{[^}]*\b(?:fontspec|xeCJK|unicode-math|polyglossia)\b|documentclass(?:\[[^\]]*\])?\{ctex)/.test(text) ? 'xelatex' : 'pdflatex');
+    }
+  } catch (failure) { error = (failure as Error).message; }
+  return { candidates: [...roots, ...files.filter(file => !roots.includes(file))], main, engine: engine || 'pdflatex', error };
+}
+async function repositoryRoot(root: string) {
+  let top: string | undefined;
+  try { top = await git(root, 'rev-parse', '--show-toplevel'); } catch { /* A plain folder needs Git. */ }
+  if (top && fs.realpathSync(top) !== root) throw new Error('This folder belongs to a parent Git repository. Select its root folder, or upload a copy.');
+  return top;
+}
+export async function prepareRepository(root: string) {
+  const top = await repositoryRoot(root);
+  if (!top) await git(root, 'init', '-q');
+  try { await git(root, 'rev-parse', '--verify', 'HEAD'); return; } catch { /* Empty repositories need their first snapshot. */ }
+  // Do not change the author's global identity or overwrite their ignore rules.
+  if (!fs.existsSync(path.join(root, '.gitignore'))) fs.writeFileSync(path.join(root, '.gitignore'), '*.aux\n*.log\n*.fls\n*.fdb_latexmk\n*.synctex.gz\n*.toc\n*.out\n.DS_Store\n');
+  await git(root, 'add', '--all');
+  await git(root, '-c', 'user.name=Papilot', '-c', 'user.email=papilot@localhost', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-qm', 'Import paper into Papilot');
+}
+export async function extractZip(buffer: Buffer, root: string) {
+  if (buffer.length > MAX_BYTES) throw new Error('Choose a ZIP smaller than 64 MB.');
+  const zip = await new Promise<yauzl.ZipFile>((resolve, reject) => yauzl.fromBuffer(buffer, { lazyEntries: true, strictFileNames: true, validateEntrySizes: true }, (error, value) => error ? reject(error) : resolve(value)));
+  await new Promise<void>((resolve, reject) => {
+    let count = 0, total = 0;
+    const fail = (error: unknown) => { zip.close(); reject(error); };
+    zip.on('error', fail); zip.on('end', resolve);
+    zip.on('entry', (entry: yauzl.Entry) => { void (async () => {
+      if (++count > MAX_FILES || (total += entry.uncompressedSize) > MAX_BYTES) throw new Error('The ZIP expands beyond 64 MB or 5,000 files.');
+      const name = safeName(entry.fileName.replace(/\/$/, ''));
+      const mode = (entry.externalFileAttributes >>> 16) & 0o170000;
+      if (mode && mode !== 0o100000 && mode !== 0o040000) throw new Error('ZIP links and special files are not supported.');
+      if (name.split('/').some(skip) || entry.fileName.endsWith('/')) { zip.readEntry(); return; }
+      const target = path.join(root, name); fs.mkdirSync(path.dirname(target), { recursive: true });
+      const stream = await new Promise<NodeJS.ReadableStream>((resolve, reject) => zip.openReadStream(entry, (error, stream) => error ? reject(error) : resolve(stream)));
+      await pipeline(stream, fs.createWriteStream(target, { flags: 'wx', mode: 0o600 })); zip.readEntry();
+    })().catch(fail); });
+    zip.readEntry();
+  });
+}
+
+export class PaperImports {
+  private sessions = new Map<string, PaperImport>();
+  private active = new Set<string>();
+  get busy() { return this.active.size > 0; }
+  constructor(private manuscripts: Manuscripts, private directory = DATA, private registered: (root: string) => boolean = () => false) {
+    const folder = path.join(directory, 'imports');
+    if (fs.existsSync(folder)) for (const file of fs.readdirSync(folder)) {
+      if (/^[a-f0-9-]{36}\.json$/.test(file)) try { this.get(file.slice(0, -5)); } catch { /* An unreadable receipt must not prevent other papers from opening. */ }
+    }
+  }
+  private save(value: PaperImport) {
+    fs.mkdirSync(path.join(this.directory, 'imports'), { recursive: true, mode: 0o700 });
+    const file = path.join(this.directory, 'imports', value.id + '.json');
+    fs.writeFileSync(file + '.tmp', JSON.stringify(value), { mode: 0o600 }); fs.renameSync(file + '.tmp', file);
+    this.sessions.set(value.id, value); return { ...value };
+  }
+  get(id: string) {
+    if (!/^[a-f0-9-]{36}$/.test(id)) throw new Error('Import not found.');
+    let value = this.sessions.get(id);
+    if (!value) {
+      value = JSON.parse(fs.readFileSync(path.join(this.directory, 'imports', id + '.json'), 'utf8')) as PaperImport;
+      if (['building', 'repairing'].includes(value.phase)) Object.assign(value, { phase: 'failed', error: 'Papilot restarted. Retry compilation to continue this import.' });
+      this.sessions.set(id, value);
+    }
+    return { ...value };
+  }
+  async create(input: { path?: unknown; name?: unknown; zip?: unknown; files?: unknown }) {
+    const id = randomUUID(); let root = '', copied = false;
+    if ([input.path, input.zip, input.files].filter(value => value !== undefined).length !== 1) throw new Error('Choose one folder or ZIP.');
+    if (input.name !== undefined && (typeof input.name !== 'string' || input.name.length > 120)) throw new Error('Paper name is too long.');
+    try {
+      if (input.path !== undefined) {
+        if (typeof input.path !== 'string' || !input.path.trim()) throw new Error('Enter a folder path.');
+        root = fs.realpathSync(input.path.startsWith('~/') ? path.join(os.homedir(), input.path.slice(2)) : input.path);
+        if (!fs.statSync(root).isDirectory()) throw new Error('Select a folder containing the paper.');
+      } else {
+        root = path.join(this.directory, 'papers', id); copied = true; fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+        if (input.zip !== undefined) await extractZip(bytes(input.zip), root);
+        else {
+          if (!Array.isArray(input.files) || !input.files.length || input.files.length > MAX_FILES) throw new Error('Choose between 1 and 5,000 files.');
+          let total = 0;
+          for (const file of input.files) {
+            const name = safeName(file.path);
+            if (name.split('/').some(skip)) continue;
+            const data = bytes(file.data); total += data.length;
+            if (total > MAX_BYTES) throw new Error('Choose a folder smaller than 64 MB.');
+            const target = path.join(root, name); fs.mkdirSync(path.dirname(target), { recursive: true }); fs.writeFileSync(target, data, { flag: 'wx', mode: 0o600 });
+          }
+        }
+        // Unwrap export folders (Overleaf and GitHub ZIPs commonly have one).
+        let children = fs.readdirSync(root).filter(name => !skip(name));
+        while (children.length === 1 && fs.statSync(path.join(root, children[0])).isDirectory()) { root = path.join(root, children[0]); children = fs.readdirSync(root).filter(name => !skip(name)); }
+      }
+      if (this.registered(root)) throw new Error('This paper is already added. Open it from the paper list.');
+      if (!copied && [...this.sessions.values()].some(item => item.path === root)) return this.get([...this.sessions.values()].find(item => item.path === root)!.id);
+      const detected = await inspectPaper(root);
+      const existing = !copied && [...this.sessions.values()].find(item => item.path === root);
+      if (existing) return this.get(existing.id);
+      return this.save({ id, path: root, copied, name: (input.name as string)?.trim() || path.basename(root), ...detected, phase: 'choose' });
+    } catch (error) { if (copied) fs.rmSync(path.join(this.directory, 'papers', id), { recursive: true, force: true }); throw error; }
+  }
+  async build(id: string, input: { main?: unknown; engine?: unknown; name?: unknown }, repair?: (root: string, error: string) => Promise<string>) {
+    const value = this.get(id);
+    if (this.active.has(id)) return value;
+    if (this.registered(value.path)) throw new Error('This paper is already added. Open it from the paper list.');
+    const main = input.main ?? value.main, engine = input.engine ?? value.engine;
+    if (typeof main !== 'string' || !texFiles(value.path).includes(main)) throw new Error('Choose an existing TeX main file.');
+    if (!['pdflatex', 'xelatex', 'lualatex'].includes(engine as string)) throw new Error('Choose a supported LaTeX engine.');
+    if (input.name !== undefined && (typeof input.name !== 'string' || !input.name.trim() || input.name.length > 120)) throw new Error('Enter a paper name under 120 characters.');
+    this.active.add(id);
+    const previousError = value.error || '';
+    Object.assign(value, { main, engine, ...(input.name ? { name: input.name } : {}), phase: repair ? 'repairing' : 'building', error: undefined });
+    this.save(value);
+    void (async () => {
+      try {
+        await repositoryRoot(value.path);
+        if (!repair) {
+          const settings = config(value.path);
+          fs.writeFileSync(path.join(value.path, CONFIG), JSON.stringify({ ...settings, main, engine, source_dir: '' }, null, 2) + '\n');
+        }
+        await prepareRepository(value.path); value.versioned = true;
+        if (repair) { value.summary = await repair(value.path, previousError); Object.assign(value, await inspectPaper(value.path)); }
+        value.phase = 'building'; this.save(value);
+        let result = await this.manuscripts.state('import-' + id, value.path, true);
+        while (result.build.status === 'building') { await new Promise(resolve => setTimeout(resolve, 400)); result = await this.manuscripts.state('import-' + id, value.path); }
+        value.phase = result.build.status === 'ready' ? 'ready' : 'failed'; value.error = result.build.error;
+      } catch (error) { value.phase = 'failed'; value.error = (error as Error).message; }
+      finally { this.active.delete(id); this.save(value); }
+    })();
+    return this.get(id);
+  }
+  async finish(id: string, register: (root: string, name: string) => Promise<Project>) {
+    const value = this.get(id);
+    if (this.active.has(id) || !value.versioned) throw new Error('Wait for repository preparation to finish.');
+    const project = await register(value.path, value.name);
+    // Keep the receipt so a lost HTTP response can safely retry finalization.
+    this.manuscripts.forgetProject('import-' + id); return project;
+  }
+}

package/src/server/latex-installation.ts

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFile } from 'node:child_process';
+import type { LatexInstallation } from '../shared.ts';
+
+type Probe = (file: string, args: string[], env: NodeJS.ProcessEnv) => Promise<string | null>;
+const command: Probe = (file, args, env) => new Promise(resolve => {
+  const child = execFile(file, args, { env, cwd: os.homedir(), timeout: 5000, killSignal: 'SIGKILL', maxBuffer: 128 * 1024 }, (error, stdout) => resolve(error ? null : stdout.trim()));
+  child.stdin?.end();
+});
+
+// Identify the installation actually found on the server's PATH. In particular,
+// a MacTeX receipt elsewhere on the machine must not relabel another TeX Live.
+export async function detectLatex(env: NodeJS.ProcessEnv = process.env, platform = process.platform, probe: Probe = command): Promise<LatexInstallation | null> {
+  const suffix = platform === 'win32' ? '.exe' : '';
+  const executable = (name: string) => (env.PATH || '').split(path.delimiter).filter(Boolean).map(directory => path.resolve(directory, name + suffix)).find(candidate => {
+      try { fs.accessSync(candidate, platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK); return fs.statSync(candidate).isFile(); } catch { return false; }
+    });
+  let found = false;
+  for (const engine of ['pdflatex', 'xelatex', 'lualatex']) {
+    const file = executable(engine);
+    if (!file) continue;
+    found = true;
+    const banner = await probe(file, ['--version'], env);
+    if (!banner) continue;
+    const texlive = banner.match(/\bTeX Live (\d{4})\b/i);
+    const miktex = banner.match(/\bMiKTeX[ \t]+([\d.]+)/i);
+    let distribution: LatexInstallation['distribution'] = texlive ? 'TeX Live' : /\bMiKTeX\b/i.test(banner) ? 'MiKTeX' : null;
+    const resolved = fs.realpathSync(file);
+    const root = await probe(path.join(path.dirname(file), 'kpsewhich' + suffix), ['-var-value=TEXMFROOT'], env);
+    const location = root && path.isAbsolute(root) && !/[\r\n]/.test(root) ? root : path.dirname(resolved);
+    if (platform === 'darwin' && texlive) {
+      const receipt = await probe('/usr/sbin/pkgutil', ['--file-info', resolved], env);
+      const ids = [...(receipt || '').matchAll(/^pkgid:\s*(\S+)/gm)].map(match => match[1]);
+      if (ids.some(id => /^org\.tug\.mactex\.basictex\d*$/i.test(id))) distribution = 'BasicTeX';
+      else if (ids.some(id => /^org\.tug\.mactex\.texlive\d*$/i.test(id))) distribution = 'MacTeX';
+    }
+    return { distribution, version: texlive?.[1] || miktex?.[1] || null, path: location };
+  }
+  if (found) throw new Error('Could not read the LaTeX installation.');
+  return null;
+}

package/src/server/main.ts

@@ -1,44 +1,10 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { randomBytes } from 'node:crypto';
-import { Store } from './store.ts';
-import { Workspace } from './workspace.ts';
-import { Accounts } from './accounts.ts';
-import { ROOT, DATA, PORT, PUBLIC_ORIGIN, OWNER, VERSION, ACCOUNT_ORIGIN, ACCOUNT_PORT } from './paths.ts';
-import { accountHsts, accountProblem } from './security.ts';
-import { Manuscripts } from './manuscript.ts';
-import { Changes } from './changes.ts';
-import { buildApp, gitQueue } from './app.ts';
+import { pathToFileURL } from 'node:url';
+import { ROOT, DATA } from './paths.ts';
+import { activeInstallation, waitForActivation } from '../../bin/installation.mjs';
 
-const problem = accountProblem(ACCOUNT_ORIGIN, ACCOUNT_PORT, PORT, PUBLIC_ORIGIN);
-if (problem) { console.error(problem); process.exit(1); }
-const store = new Store(path.join(DATA, 'papilot.sqlite'));
-const workspace = new Workspace(store);
-const accounts = new Accounts(store, ACCOUNT_ORIGIN || null);
-const shared = {
-  store, workspace, accounts, manuscripts: new Manuscripts(), changes: new Changes(), csrf: randomBytes(32).toString('base64url'), serialGit: gitQueue(),
-  dist: fs.existsSync(path.join(ROOT, 'dist/index.html')) ? path.join(ROOT, 'dist') : null, version: VERSION,
-};
-const apps = [await buildApp({ ...shared, listener: { kind: 'local', port: PORT, publicOrigin: PUBLIC_ORIGIN, owner: OWNER } })];
-if (ACCOUNT_ORIGIN) apps.push(await buildApp({ ...shared, listener: { kind: 'account', origin: ACCOUNT_ORIGIN, hsts: accountHsts(ACCOUNT_ORIGIN, PUBLIC_ORIGIN) } }));
-
-await apps[0].listen({ host: '127.0.0.1', port: PORT });
-if (apps[1]) await apps[1].listen({ host: '127.0.0.1', port: ACCOUNT_PORT });
-store.recover();
-console.log(`Papilot is running at http://127.0.0.1:${PORT}${PUBLIC_ORIGIN ? `\nRemote: ${PUBLIC_ORIGIN}` : ''}${ACCOUNT_ORIGIN ? `\nSign-in for invited people: ${ACCOUNT_ORIGIN} (forwarded to 127.0.0.1:${ACCOUNT_PORT})` : ''}`);
-void workspace.connect();
-// Recompute cached feedback counts, including decisions from before this restart.
-for (const task of store.tasks()) {
-  if (task.status === 'building') {
-    store.updateTask(task.id, { status: 'interrupted', error: 'The server restarted during the PDF build. Check the review and rebuild it if needed.' });
-    void workspace.refresh(task.id);
-  } else if (task.review?.round && task.status !== 'deleting') void workspace.refresh(task.id);
-}
-// Expired invites and sessions are removed as they lapse.
-setInterval(() => accounts.purge(), 3600000).unref();
-let shuttingDown = false;
-for (const signal of ['SIGINT', 'SIGTERM']) process.on(signal, () => {
-  if (shuttingDown) return; shuttingDown = true; workspace.close();
-  void Promise.all(apps.map(app => app.close())).finally(() => { store.close(); process.exit(0); });
-  setTimeout(() => process.exit(0), 2500).unref();
-});
+await waitForActivation(DATA);
+const root = activeInstallation(ROOT, DATA);
+// A source checkout's default data directory must not move with the release.
+process.env.PAPILOT_DATA = DATA;
+await import(pathToFileURL(path.join(root, 'src/server/start.ts')).href);