papilot 0.3.0 → 0.4.0

package/src/server/manuscript.ts

@@ -210,13 +210,13 @@ export async function workingTree(root: string) {
 }
 
 async function engine() {
-  const [{ Builder }, { Repo }, { loadProject }, { mupdf, PdfDocument, containsCenter }] = await Promise.all([
+  const [{ Builder }, { Repo }, { loadProject }, { mupdf, PdfDocument, containsCenter, walkText }] = await Promise.all([
     import(pathToFileURL(path.join(ENGINE, 'src/core/build.ts')).href),
     import(pathToFileURL(path.join(ENGINE, 'src/core/git.ts')).href),
     import(pathToFileURL(path.join(ENGINE, 'src/core/config.ts')).href),
     import(pathToFileURL(path.join(ENGINE, 'src/render/pdf.ts')).href),
   ]);
-  return { Builder, Repo, loadProject, mupdf, PdfDocument, containsCenter };
+  return { Builder, Repo, loadProject, mupdf, PdfDocument, containsCenter, walkText };
 }
 
 // `synctex edit` maps a PDF position (big points from the top-left corner) to
@@ -293,7 +293,7 @@ export function sourceExcerpt(file: string, [start, end]: [number, number], limi
 // the page's top left. pdf.js lays a whole line out in a stand-in font and
 // drifts from the printed words mid-line; per-word runs cannot drift.
 export async function pdfWords(pdf: string, page: number) {
-  const { PdfDocument } = await engine();
+  const { PdfDocument, walkText } = await engine();
   const document = new PdfDocument(pdf);
   try {
     if (!Number.isInteger(page) || page < 0 || page >= document.length) throw Object.assign(new Error('That page is not part of the manuscript.'), { statusCode: 400 });
@@ -301,7 +301,7 @@ export async function pdfWords(pdf: string, page: number) {
     const words: { text: string; left: number; right: number; baseline: number; size: number; eol: boolean }[] = [];
     let word: (typeof words)[number] | null = null;
     const text = raw.toStructuredText('preserve-whitespace');
-    text.walk({
+    walkText(text, {
       beginLine: () => { word = null; },
       onChar: (c: string, origin: [number, number], _font: unknown, size: number, quad: number[]) => {
         if (/\s/u.test(c)) { word = null; return; }

package/src/server/paths.ts

@@ -8,4 +8,8 @@ export const VERSION: string = JSON.parse(fs.readFileSync(path.join(ROOT, 'packa
 export const PORT = Number(process.env.PAPILOT_PORT || 7274);
 export const PUBLIC_ORIGIN = process.env.PAPILOT_PUBLIC_ORIGIN || '';
 export const OWNER = process.env.PAPILOT_TAILSCALE_LOGIN || '';
+// The public URL where invited people sign in with passkeys, and the local
+// port its proxy (such as Tailscale Funnel) forwards to.
+export const ACCOUNT_ORIGIN = (process.env.PAPILOT_ACCOUNT_ORIGIN || '').replace(/\/+$/, '');
+export const ACCOUNT_PORT = Number(process.env.PAPILOT_ACCOUNT_PORT || 7275);
 export const CODEX = process.env.PAPILOT_CODEX_BIN || (fs.existsSync(path.join(ROOT, 'node_modules/.bin/codex')) ? path.join(ROOT, 'node_modules/.bin/codex') : 'codex');

package/src/server/security.ts

@@ -13,3 +13,23 @@ export function authorize(headers: IncomingHttpHeaders, remoteAddress: string |
   if (headers.origin && headers.origin !== publicOrigin) return 'The request origin does not match.';
   return null;
 }
+
+// The public sign-in URL needs its own port, an exact HTTPS origin (plain HTTP
+// only on localhost, for testing), and must not be the tailnet endpoint, whose
+// requests are trusted as the owner.
+export function accountProblem(accountOrigin: string, accountPort: number, port: number, publicOrigin: string): string | null {
+  if (!accountOrigin) return null;
+  let url: URL;
+  try { url = new URL(accountOrigin); } catch { return `PAPILOT_ACCOUNT_ORIGIN is not a URL: ${accountOrigin}`; }
+  if (url.origin !== accountOrigin) return `PAPILOT_ACCOUNT_ORIGIN must be an origin without a path, such as ${url.origin}.`;
+  if (url.protocol !== 'https:' && !(url.protocol === 'http:' && url.hostname === 'localhost')) return 'PAPILOT_ACCOUNT_ORIGIN must use https://.';
+  if (!Number.isInteger(accountPort) || accountPort < 1 || accountPort > 65535 || accountPort === port) return `PAPILOT_ACCOUNT_PORT must be a free port other than ${port}.`;
+  if (publicOrigin && new URL(publicOrigin).host === url.host) return 'PAPILOT_ACCOUNT_ORIGIN must differ from PAPILOT_PUBLIC_ORIGIN, the tailnet address; use another port, such as :10000.';
+  return null;
+}
+// HSTS on the public address covers every port of its host name, so it is
+// left off when the tailnet endpoint on that host uses plain HTTP.
+export function accountHsts(accountOrigin: string, publicOrigin: string) {
+  const account = new URL(accountOrigin);
+  return account.protocol === 'https:' && !(publicOrigin.startsWith('http:') && new URL(publicOrigin).hostname === account.hostname);
+}

package/src/server/store.ts

@@ -17,6 +17,11 @@ export class Store extends EventEmitter {
       CREATE TABLE IF NOT EXISTS items(id TEXT PRIMARY KEY, task_id TEXT NOT NULL, created INTEGER NOT NULL, data TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS deleted_tasks(id TEXT PRIMARY KEY, deleted INTEGER NOT NULL);
       CREATE TABLE IF NOT EXISTS annotations(id TEXT PRIMARY KEY, project_id TEXT NOT NULL, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS users(id TEXT PRIMARY KEY, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS credentials(id TEXT PRIMARY KEY, user_id TEXT NOT NULL, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS invites(token_hash TEXT PRIMARY KEY, user_id TEXT NOT NULL, expires INTEGER NOT NULL, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS sessions(token_hash TEXT PRIMARY KEY, id TEXT UNIQUE NOT NULL, user_id TEXT NOT NULL, expires INTEGER NOT NULL, data TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS members(project_id TEXT NOT NULL, user_id TEXT NOT NULL, PRIMARY KEY(project_id, user_id));
       CREATE INDEX IF NOT EXISTS task_items ON items(task_id,created);
       CREATE INDEX IF NOT EXISTS task_runs ON runs(task_id,status);`);
   }

package/src/server/workspace.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import fs from 'node:fs';
@@ -13,7 +13,7 @@ import { findSkill, type SkillFile } from './skills.ts';
 import { buildFixPrompt, reviewInstructions, skillPrompt, summarizeFeedback } from '../conversation.ts';
 import { commitMessageFrom } from '../commit.ts';
 import { commitChanges, conflictMarkers, gitCommit, gitRemote, gitStatus, mergeConflicts, mergeInProgress } from './manuscript.ts';
-import type { Task, Run, TimelineItem, PendingRequest, RuntimeStatus, Snapshot, PendingReview, AgentModel, Usage, AgentId, MessageMeta, FeedbackSummary, BuildFailure } from '../shared.ts';
+import type { Task, Run, TimelineItem, PendingRequest, RuntimeStatus, Snapshot, PendingReview, AgentModel, Usage, AgentId, MessageMeta, FeedbackSummary, BuildFailure, Author } from '../shared.ts';
 
 const execute = promisify(execFile);
 const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
@@ -43,6 +43,10 @@ const FIXABLE = /^(Some edits are outside the task scope|The revised document co
 const BUILD_FIX = 'build-fix-';
 
 const AGENTS: AgentId[] = ['codex', 'claude', 'antigravity'];
+// The small model an agent offers for short text such as a commit message,
+// by the names agents give them (GPT Luna and mini, Claude Haiku, Gemini Flash).
+const LIGHT = /\b(?:luna|mini|nano|haiku|flash|lite)\b/i;
+export const lightModel = (models: AgentModel[]) => models.find(model => LIGHT.test(model.id) || LIGHT.test(model.name));
 // A commit message's agent sees the changes in its prompt and needs no tools.
 const commitInstructions = 'You write Git commit messages for the repository of a LaTeX paper. Reply with the commit message only, without a preamble, quotes or a code fence: a subject line in the imperative mood under 72 characters and, only when the change needs more explanation, a blank line and a body of a few short plain sentences. Describe what changed in the paper, such as its wording, sections, equations, figures or references, rather than listing files. Follow the style and language of the recent commit subjects, or write in English when there are none. Everything you need is in the message: do not run commands, read files or edit anything.';
 // A merge's agent edits the conflicted files in the manuscript checkout and nothing else.
@@ -72,6 +76,9 @@ export class Workspace extends EventEmitter {
   private flushTimer: NodeJS.Timeout | null = null;
   private connecting: Promise<void> | null = null;
   private usageTimers = new Map<AgentId, NodeJS.Timeout>();
+  // Commit messages by agent, model and prompt, kept or still being written,
+  // so one written ahead for a finished review is there when the dialog opens.
+  private messages = new Map<string, Promise<{ message: string; agent: AgentId }>>();
   constructor(public store: Store, public codex: AgentRuntime = new Codex(), private concurrency = 2, private connectReview = reviewClient, others: Partial<Record<AgentId, AgentRuntime>> = {}) {
     super();
     this.agents = { codex, claude: others.claude || new ClaudeAgent(), antigravity: others.antigravity || new AntigravityAgent() };
@@ -137,10 +144,12 @@ export class Workspace extends EventEmitter {
     this.store.saveProject(project); return project;
   }
   // A task can start from a skill; its instructions are then the author's own words, possibly none.
-  async createTask(input: { projectId: string; title: string; instructions: string; skill?: string; agent?: AgentId; model?: string; effort?: string; id: string }) {
+  async createTask(input: { projectId: string; title: string; instructions: string; skill?: string; agent?: AgentId; model?: string; effort?: string; id: string; author?: Author }) {
     if (!/^[\w-]{16,64}$/.test(input.id)) throw new Error('Invalid task ID.');
     if (this.store.taskDeleted(input.id)) throw new Error('This task was deleted. Create a new task instead.');
-    const existing = this.store.tasks().find(t => t.id === input.id); if (existing) return existing;
+    // A retried request returns its task; an ID from another paper is refused.
+    const existing = this.store.tasks().find(t => t.id === input.id);
+    if (existing) { if (existing.projectId !== input.projectId) throw new Error('Invalid task ID.'); return existing; }
     if (this.preparing.has(input.id)) throw new Error('This task is being created. Refresh in a moment.');
     this.preparing.add(input.id);
     try {
@@ -153,14 +162,14 @@ export class Workspace extends EventEmitter {
         worktree: info.worktree, threadId: null, turnId: null, agent: input.agent || 'codex', model: input.model || null, effort: input.effort || null, status: 'idle',
         createdAt: Date.now(), updatedAt: Date.now(), feedbackCursor: 0, error: null, review: null };
       this.store.saveTask(task);
-      await this.enqueue(task.id, input.instructions, 'initial-' + task.id, false, { skill });
+      await this.enqueue(task.id, input.instructions, 'initial-' + task.id, false, { skill, author: input.author });
       return this.store.task(task.id);
     } finally { this.preparing.delete(input.id); }
   }
   // The author's message, a skill run with or without one, the review
   // feedback alone, or a build the agent broke. The chat keeps what happened;
   // the agent gets the prompt.
-  async enqueue(taskId: string, text: string, requestKey: string, includeFeedback = true, options: { skill?: SkillFile; feedback?: boolean; build?: BuildFailure } = {}) {
+  async enqueue(taskId: string, text: string, requestKey: string, includeFeedback = true, options: { skill?: SkillFile; feedback?: boolean; build?: BuildFailure; author?: Author } = {}) {
     const task = this.store.task(taskId);
     if (task.status === 'deleting') throw new Error('This task is being deleted.');
     const existing = this.store.runByKey(requestKey);
@@ -179,7 +188,7 @@ export class Workspace extends EventEmitter {
       if (task.error) prompt += '\n\nLatest task/review error:\n' + task.error + '\nThe latest accepted manuscript is at ' + this.store.project(task.projectId).path + '. You may read it to understand accepted changes, but must only edit your isolated task worktree. Prepare a revised proposal for another review; never write to or accept changes in the manuscript checkout.';
     }
     const run: Run = { id: randomUUID(), taskId, requestKey, prompt, feedbackCursor: cursor, status: 'queued', createdAt: Date.now(), finishedAt: null };
-    const meta: MessageMeta = { ...(options.skill ? { skill: { id: options.skill.id, name: options.skill.name } } : {}), ...(summary ? { feedback: summary } : {}), ...(options.feedback ? { sendsFeedback: true } : {}), ...(options.build ? { build: options.build } : {}) };
+    const meta: MessageMeta = { ...(options.skill ? { skill: { id: options.skill.id, name: options.skill.name } } : {}), ...(summary ? { feedback: summary } : {}), ...(options.feedback ? { sendsFeedback: true } : {}), ...(options.build ? { build: options.build } : {}), ...(options.author ? { author: options.author } : {}) };
     const saved = this.store.transaction(() => {
       // Feedback loading yields to other requests. Recheck identity, queue, and
       // task status together before committing; none of the earlier reads own a lock.
@@ -535,13 +544,13 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
   }
   // The agent that writes a commit message or resolves a merge: the one the
   // author chose, or else the first that is signed in, with the chosen model
-  // or the default one.
-  private helper(choice: { agent?: AgentId; model?: string }, task: string) {
+  // or the default one; light asks for the agent's small model when it has one.
+  private helper(choice: { agent?: AgentId; model?: string }, task: string, light = false) {
     const usable = (id: AgentId) => this.agents[id].ready && this.runtimes[id].authenticated;
     const id = choice.agent && usable(choice.agent) ? choice.agent : AGENTS.find(usable);
     if (!id) throw new Error(`Sign in to Codex, Claude or Antigravity to ${task}.`);
     const models = this.runtimes[id].models;
-    return { id, model: models.find(item => item.id === choice.model) || models.find(item => item.isDefault) };
+    return { id, model: (light ? lightModel(models) : undefined) || models.find(item => item.id === choice.model) || models.find(item => item.isDefault) };
   }
   // One turn on a thread the agent does not keep, outside any task: its
   // reply is returned and no chat shows it.
@@ -568,9 +577,11 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
     });
   }
   // Writes a commit message for the chosen manuscript files, like Cursor's
-  // generate button: one read-only turn with the lightest reasoning the model offers.
-  async commitMessage(projectId: string, paths: string[], choice: { agent?: AgentId; model?: string } = {}) {
-    const project = this.store.project(projectId), { id, model } = this.helper(choice, 'write a commit message');
+  // generate button: one read-only turn on the agent's small model, with the
+  // lightest reasoning it offers. The same changes get the message already
+  // written, or being written, for them unless the author asks for a fresh one.
+  async commitMessage(projectId: string, paths: string[], choice: { agent?: AgentId; fresh?: boolean } = {}) {
+    const project = this.store.project(projectId), { id, model } = this.helper(choice, 'write a commit message', true);
     const { files, patch, recent } = await commitChanges(project.path, paths);
     const tasks = this.store.tasks().filter(task => task.projectId === projectId && task.review?.files?.some(file => paths.includes(file))).map(task => task.title);
     const prompt = [
@@ -579,10 +590,29 @@ ${this.agentOf(task) === 'antigravity' ? 'Shell commands are not available to yo
       `Changed files:\n${files.map(file => `${file.status === '?' ? 'A' : file.status} ${file.from ? `${file.from} -> ` : ''}${file.path}`).join('\n')}`,
       `Diff:\n${patch}`,
     ].filter(Boolean).join('\n\n');
-    const reply = await this.oneOff(id, { cwd: project.path, sandbox: 'read-only', instructions: commitInstructions, prompt, model, effort: model?.efforts[0], timeout: 120000, what: 'write a commit message' });
-    const message = commitMessageFrom(reply);
-    if (!message) throw new Error(`${AGENT_NAMES[id]} did not return a commit message. Try again.`);
-    return { message, agent: id };
+    const key = createHash('sha256').update(`${id}\0${model?.id ?? ''}\0${prompt}`).digest('hex'), kept = this.messages.get(key);
+    if (kept && !choice.fresh) return kept;
+    const written = this.oneOff(id, { cwd: project.path, sandbox: 'read-only', instructions: commitInstructions, prompt, model, effort: model?.efforts[0], timeout: 120000, what: 'write a commit message' }).then(reply => {
+      const message = commitMessageFrom(reply);
+      if (!message) throw new Error(`${AGENT_NAMES[id]} did not return a commit message. Try again.`);
+      return { message, agent: id };
+    });
+    // Only the latest few messages are kept, and never a failed one.
+    this.messages.delete(key); this.messages.set(key, written);
+    for (const old of this.messages.keys()) { if (this.messages.size <= 20) break; this.messages.delete(old); }
+    written.catch(() => { if (this.messages.get(key) === written) this.messages.delete(key); });
+    return written;
+  }
+  // A finished review offers to commit what it accepted, so after the
+  // author's last decision its commit message is written ahead.
+  async prepareCommitMessage(taskId: string) {
+    try {
+      const task = this.store.task(taskId), files = task.review?.files || [];
+      if (task.status !== 'reviewing' || task.review?.counts?.pending || !files.length) return;
+      const project = this.store.project(task.projectId), git = await gitStatus(project.path);
+      const paths = git.merging ? [] : files.filter(file => git.files.some(item => item.path === file));
+      if (paths.length) await this.commitMessage(project.id, paths, { agent: this.agentOf(task) });
+    } catch { /* The commit dialog writes the message when it opens. */ }
   }
   // Resolves a merge's conflicts in the manuscript checkout itself: the agent
   // edits only the conflicted files, at the model's default reasoning, and

package/src/shared.ts

@@ -20,7 +20,9 @@ export interface TimelineItem { id: string; taskId: string; type: string; text:
 // A user message can run a skill or carry review feedback; the chat shows
 // those as what they are rather than as the prompt the agent receives.
 // Papilot itself sends the agent a build its own edits broke.
-export interface MessageMeta { skill?: { id: string; name: string }; feedback?: FeedbackSummary; sendsFeedback?: boolean; build?: BuildFailure }
+export interface MessageMeta { skill?: { id: string; name: string }; feedback?: FeedbackSummary; sendsFeedback?: boolean; build?: BuildFailure; author?: Author }
+// Who wrote a message or note; none means the owner.
+export interface Author { id: string; name: string }
 // A failed review build as the engine reports it; log is the compiler log's path.
 export interface BuildFailure { error: string; details: string[]; log?: string }
 export interface FeedbackSummary { round: number | null; accepted: number; rejected: number; undone: number; comments: { where: string; text: string }[]; buildError?: boolean }
@@ -32,11 +34,21 @@ export interface AgentModel { id: string; name: string; isDefault: boolean; effo
 export interface UsageWindow { usedPercent: number; minutes: number | null; resetsAt: number | null }
 export interface Usage { plan: string | null; windows: UsageWindow[]; credits: { unlimited: boolean; balance: number | null } | null; reached: boolean }
 export interface RuntimeStatus { connected: boolean; authenticated: boolean; account: string | null; error: string | null; models: AgentModel[]; usage?: Usage | null }
-export interface Snapshot { projects: Project[]; tasks: Task[]; requests: PendingRequest[]; runtime: RuntimeStatus; runtimes?: Partial<Record<AgentId, RuntimeStatus>>; version: string }
+export interface Snapshot { projects: Project[]; tasks: Task[]; requests: PendingRequest[]; runtime: RuntimeStatus; runtimes?: Partial<Record<AgentId, RuntimeStatus>>; version: string; viewer?: Viewer }
+// Who is looking: the owner on this host or Tailscale (local), or a person
+// signed in with a passkey at the public URL (account). Older servers send none.
+// owner names the owner, whose messages carry no author.
+export interface Viewer { id: string; name: string; role: 'owner' | 'member'; listener: 'local' | 'account'; owner: string }
+// A person the owner invited, as the People dialog shows them. joined means
+// they have registered at least one passkey; projects are the shared papers.
+export interface Person { id: string; name: string; role: 'owner' | 'member'; joined: boolean; projects: string[]; lastSeenAt: number | null; devices: Device[] }
+// A passkey or a signed-in browser session, either of which the owner can revoke.
+export interface Device { id: string; kind: 'passkey' | 'session'; label: string; createdAt: number; lastUsedAt: number | null }
+export interface People { origin: string | null; people: Person[] }
 export interface GitFile { path: string; status: string; staged: boolean; lines?: [number, number]; from?: string }
 // merging is a merge in progress, with the files whose conflict markers remain.
 export interface GitStatus { branch: string | null; upstream: string | null; ahead: number; behind: number; files: GitFile[]; head: { hash: string; subject: string; date: number } | null; remote?: boolean; merging?: { message: string; conflicts: string[] } | null }
 export interface GitDiff { path: string; diff: string; truncated: boolean }
 export interface ManuscriptBuild { status: 'building' | 'ready' | 'failed'; key?: string; pages?: [number, number][]; builtAt?: number; error?: string; current: boolean }
-export interface Annotation { id: string; projectId: string; key: string; page: number; rect: [number, number, number, number]; rects?: [number, number, number, number][]; comment: string; quote: string; source: { file: string; lines: [number, number]; excerpt?: string } | null; createdAt: number; taskId?: string }
+export interface Annotation { id: string; projectId: string; key: string; page: number; rect: [number, number, number, number]; rects?: [number, number, number, number][]; comment: string; quote: string; source: { file: string; lines: [number, number]; excerpt?: string } | null; createdAt: number; taskId?: string; author?: Author }
 export interface Manuscript { git: GitStatus; build: ManuscriptBuild; annotations: Annotation[] }

package/vendor/latex-review/src/render/pdf.ts

@@ -54,6 +54,40 @@ export interface Raster {
   stride: number;
   pixels: Uint8Array;
 }
+// mupdf.js's walk turns each character into a string with String.fromCharCode,
+// which keeps only the low 16 bits: math italic 𝐹 (U+1D439) arrives as the
+// Hangul syllable 퐹 (U+D439). The JSON export spells every line correctly, one
+// code point per character, so a character comes from there whenever the two
+// agree on its low 16 bits.
+export function walkText(
+  text: mupdf.StructuredText,
+  walker: Parameters<mupdf.StructuredText["walk"]>[0],
+) {
+  const lines = (
+    JSON.parse(text.asJSON()) as { blocks: { lines?: { text: string }[] }[] }
+  ).blocks.flatMap((b) => (b.lines ?? []).map((l) => Array.from(l.text)));
+  let next = 0,
+    line: string[] = [],
+    index = 0;
+  text.walk({
+    ...walker,
+    beginLine: (...args) => {
+      line = lines[next++] ?? [];
+      index = 0;
+      walker.beginLine?.(...args);
+    },
+    onChar: (c, ...args) => {
+      const full = line[index++];
+      walker.onChar?.(
+        full !== undefined &&
+          (full.codePointAt(0)! & 0xffff) === c.charCodeAt(0)
+          ? full
+          : c,
+        ...args,
+      );
+    },
+  });
+}
 export class PdfPage {
   private columns?: boolean;
   raw: mupdf.Page;
@@ -73,7 +107,7 @@ export class PdfPage {
       "preserve-whitespace,preserve-ligatures",
     );
     let block: TextBlock, line: Line;
-    text.walk({
+    walkText(text, {
       beginTextBlock: (rect) => {
         block = { rect, text: "", lines: [] };
         this.blocks.push(block);