heyquilt 0.0.1 → 0.3.90

package/src/merge3.js

@@ -0,0 +1,158 @@
+// Three-way merge of text, line by line, the way git does it: changes to
+// different lines combine on their own; the same lines changed on both sides
+// are a conflict. Quilt never uses it to combine two different changes on its
+// own (a person settles those): it writes the markers for Edit by hand, and
+// lays out a settled clash with the commits around it (relay-upstream.js).
+import { diff3Merge } from 'node-diff3'
+
+export const MARK = { start: '<<<<<<< mine', mid: '=======', end: '>>>>>>> session' }
+
+const lines = (s) => s.split('\n')
+
+/**
+ * Merges ours and theirs against base. `conflicts` is empty when the merge
+ * is clean; `text` then holds the merged file. With conflicts, `text` holds
+ * the merge with ours taken for each conflicted region (callers decide what
+ * to do with it; see withMarkers).
+ */
+export function merge3 (base, ours, theirs) {
+  const regions = diff3Merge(lines(ours), lines(base), lines(theirs), { excludeFalseConflicts: true })
+  const out = []
+  const conflicts = []
+  for (const r of regions) {
+    if (r.ok) { out.push(...r.ok); continue }
+    const c = r.conflict
+    conflicts.push({ base: c.o, ours: c.a, theirs: c.b })
+    out.push(...c.a)
+  }
+  return { text: out.join('\n'), conflicts }
+}
+
+/** The merge written out with git-style markers around each conflict, labelled with people's names. */
+export function withMarkers (base, ours, theirs, names) {
+  const regions = diff3Merge(lines(ours), lines(base), lines(theirs), { excludeFalseConflicts: true })
+  const out = []
+  for (const r of regions) {
+    if (r.ok) { out.push(...r.ok); continue }
+    out.push(`${MARK.start} (${names.mine})`, ...r.conflict.a, MARK.mid, ...r.conflict.b, `${MARK.end} (${names.theirs})`)
+  }
+  return out.join('\n')
+}
+
+/** True when the text still holds markers that withMarkers put there. */
+export function hasMarkers (text) {
+  return typeof text === 'string' && text.split('\n').some((l) => l.startsWith(`${MARK.start} (`) || l.startsWith(`${MARK.end} (`))
+}
+
+/**
+ * merge3, plus the clashes where neither side lost anything, resolved the way a person would:
+ * - both sides only added lines in the same place (base had nothing there): ours, then theirs,
+ *   with lines both start (or end) with written once, so two new sections under the same
+ *   heading become one heading with both sections' lines;
+ * - both sides changed the same one-line `import { … } from '…'` of the same module: one import
+ *   with every name either side has (a name either side removed stays removed).
+ * Anything else stays a conflict. Used where commits from elsewhere come in (upstream.js).
+ */
+export function mergeAdditive (base, ours, theirs) {
+  const regions = diff3Merge(lines(ours), lines(base), lines(theirs), { excludeFalseConflicts: true })
+  const out = []
+  const conflicts = []
+  for (const r of regions) {
+    if (r.ok) { out.push(...r.ok); continue }
+    const c = r.conflict
+    const both = c.o.length === 0 ? addedBoth(c.a, c.b) : sameImport(c.o, c.a, c.b)
+    if (both) { out.push(...both); continue }
+    conflicts.push({ base: c.o, ours: c.a, theirs: c.b })
+    out.push(...c.a)
+  }
+  return { text: out.join('\n'), conflicts }
+}
+
+/** Two blocks inserted at one place, as one: shared leading and trailing lines once, the middles in order. */
+function addedBoth (a, b) {
+  let pre = 0
+  while (pre < a.length && pre < b.length && a[pre] === b[pre]) pre++
+  let post = 0
+  while (post < a.length - pre && post < b.length - pre && a[a.length - 1 - post] === b[b.length - 1 - post]) post++
+  return [...a.slice(0, pre), ...a.slice(pre, a.length - post), ...b.slice(pre, b.length - post), ...a.slice(a.length - post)]
+}
+
+const IMPORT = /^(\s*import\s*\{)([^}]*)(\}\s*from\s*(['"][^'"]+['"]).*)$/
+
+/** Both sides changed the same one-line import of the same module: the union of its names, or null. */
+function sameImport (o, a, b) {
+  if (o.length !== 1 || a.length !== 1 || b.length !== 1) return null
+  const [mo, ma, mb] = [IMPORT.exec(o[0]), IMPORT.exec(a[0]), IMPORT.exec(b[0])]
+  if (!mo || !ma || !mb || mo[4] !== ma[4] || ma[4] !== mb[4]) return null
+  const names = (m) => m[2].split(',').map((s) => s.trim()).filter(Boolean)
+  const [no, na, nb] = [names(mo), names(ma), names(mb)]
+  const gone = new Set(no.filter((n) => !na.includes(n) || !nb.includes(n)))
+  const all = [...na, ...nb.filter((n) => !na.includes(n))].filter((n) => !gone.has(n))
+  return [`${ma[1]} ${all.join(', ')} ${ma[3]}`]
+}
+
+const normWs = (l) => l.replace(/\s+/g, ' ').trim()
+const sameIgnoringWs = (a, b) => a.length === b.length && a.every((l, i) => normWs(l) === normWs(b[i]))
+const TOKEN = /\s+|\w+|[^\w\s]/g
+
+/** Two blocks of lines merged word by word against their base, or null when the same words changed on both sides. */
+function mergeWords (o, a, b) {
+  const tok = (ls) => ls.join('\n').match(TOKEN) || []
+  const regions = diff3Merge(tok(a), tok(o), tok(b), { excludeFalseConflicts: true })
+  if (regions.some((r) => !r.ok)) return null
+  return regions.map((r) => r.ok.join('')).join('').split('\n')
+}
+
+/**
+ * The clash ladder's mechanical and structural steps (plan §7.3, steps 1 and 2): mergeAdditive, then
+ * each region still clashing is tried again ignoring whitespace (a side that only reindented loses
+ * to the side that changed something), then word by word within the clashing lines (two edits to
+ * different words of one line both land); a file marked merge=union takes both sides, ours first.
+ * Returns { text, conflicts, how } with `how` the step that settled it: 'lines', 'whitespace',
+ * 'words' or 'union'; `conflicts` lists what no step could settle (text then holds ours there).
+ */
+export function mergeSmart (base, ours, theirs, { union = false } = {}) {
+  const regions = diff3Merge(lines(ours), lines(base), lines(theirs), { excludeFalseConflicts: true })
+  const out = []
+  const conflicts = []
+  let how = 'lines'
+  const rank = { lines: 0, whitespace: 1, words: 2, union: 3 }
+  const step = (h) => { if (rank[h] > rank[how]) how = h }
+  for (const r of regions) {
+    if (r.ok) { out.push(...r.ok); continue }
+    const c = r.conflict
+    if (union) { out.push(...c.a, ...c.b); step('union'); continue }
+    const both = c.o.length === 0 ? addedBoth(c.a, c.b) : sameImport(c.o, c.a, c.b)
+    if (both) { out.push(...both); continue }
+    if (sameIgnoringWs(c.a, c.b)) { out.push(...c.a); step('whitespace'); continue } // the same change, spaced differently
+    if (sameIgnoringWs(c.a, c.o)) { out.push(...c.b); step('whitespace'); continue } // ours only reindented
+    if (sameIgnoringWs(c.b, c.o)) { out.push(...c.a); step('whitespace'); continue } // theirs only reindented
+    const words = mergeWords(c.o, c.a, c.b)
+    if (words) { out.push(...words); step('words'); continue }
+    conflicts.push({ base: c.o, ours: c.a, theirs: c.b })
+    out.push(...c.a)
+  }
+  return { text: out.join('\n'), conflicts, how }
+}
+
+/** The paths a .gitattributes text marks merge=union, as a matcher: (rel) => boolean. */
+export function unionMatcher (texts) {
+  const patterns = []
+  for (const [dir, text] of texts) {
+    for (const line of String(text || '').split('\n')) {
+      const t = line.trim()
+      if (!t || t.startsWith('#')) continue
+      const [pat, ...attrs] = t.split(/\s+/)
+      if (!attrs.includes('merge=union')) continue
+      patterns.push({ dir, pat })
+    }
+  }
+  if (!patterns.length) return () => false
+  return (rel) => patterns.some(({ dir, pat }) => {
+    if (dir && !rel.startsWith(`${dir}/`)) return false
+    const local = dir ? rel.slice(dir.length + 1) : rel
+    const name = local.includes('/') ? local.slice(local.lastIndexOf('/') + 1) : local
+    const re = new RegExp('^' + pat.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]') + '$')
+    return pat.includes('/') ? re.test(local.replace(/^\//, '')) : re.test(name)
+  })
+}

package/src/merges.js

@@ -0,0 +1,148 @@
+// Merge records: a file whose offline and in-session edits could not be
+// combined on their own. Kept as plain objects in the shared doc so everyone
+// in the session (and every AI) sees the same list and anyone can settle it.
+import crypto from 'node:crypto'
+import { isSafeRelPath } from './pathrules.js'
+
+export const MAX_RECORD_TEXT = 200_000
+export const MAX_MERGES = 50
+export const DONE_TTL_MS = 24 * 60 * 60 * 1000
+export const KINDS = ['conflict', 'ai', 'claimed']
+export const STATES = ['open', 'editing', 'done']
+export const HOWS = ['mine', 'theirs', 'hand', 'agent', 'review']
+// How the opener's side came about: pulled commits, an edit during a git command, or (null) offline.
+export const VIAS = ['pull', 'hold']
+
+/** What the opener did to the file, for agents and status text ("changed it offline"…). */
+export function mergeAction (m, deleted = !!m.oursDeleted) {
+  if (m.via === 'pull') return deleted ? 'pulled commits that delete it' : 'pulled commits that change it'
+  if (m.via === 'hold') return deleted ? 'deleted it during a git command' : 'changed it during a git command'
+  return deleted ? 'deleted it offline' : 'changed it offline'
+}
+
+const HEX_ID = /^[0-9a-f]{16}$/i
+// eslint-disable-next-line no-control-regex
+const CONTROL = /[\u0000-\u001f\u007f]/
+// eslint-disable-next-line no-control-regex
+const CONTROL_RUN = /[\u0000-\u001f\u007f]+/g
+const str = (v, max) => typeof v === 'string' && v.length <= max
+const optStr = (v, max) => v == null || str(v, max)
+// Names, paths and reasons go verbatim into logs and into the prompt a coding
+// tool gets for Send to…: one line each, no control characters.
+const line = (v, max) => str(v, max) && !CONTROL.test(v)
+const optLine = (v, max) => v == null || line(v, max)
+
+/**
+ * A peer-written name (from an activity entry or a claim), made safe to put
+ * in a merge record: control characters and newlines become a space,
+ * whitespace is collapsed, and it's trimmed and capped at 80 characters.
+ * Falls back to 'someone' when that leaves nothing, so a stray control
+ * character in a name never suppresses the merge record itself.
+ */
+export function cleanName (name) {
+  const flat = String(name == null ? '' : name).replace(CONTROL_RUN, ' ').replace(/\s+/g, ' ').trim().slice(0, 80)
+  return flat || 'someone'
+}
+
+/** A record we'll show. Anything a modified client pushed that isn't this shape is ignored. */
+export function publicMerge (v) {
+  if (!v || typeof v !== 'object') return null
+  if (typeof v.id !== 'string' || !HEX_ID.test(v.id)) return null
+  // A path any member could be made to write: inside the project, never .git or .quilt.
+  if (!line(v.path, 1024) || !isSafeRelPath(v.path)) return null
+  if (!line(v.by, 80) || !optStr(v.byId, 128)) return null
+  if (!Array.isArray(v.others) || v.others.length > 20 || !v.others.every((n) => line(n, 80))) return null
+  if (typeof v.ts !== 'number' || !Number.isFinite(v.ts)) return null
+  if (!KINDS.includes(v.kind) || !STATES.includes(v.state)) return null
+  if (!optStr(v.ours, MAX_RECORD_TEXT) || !optStr(v.base, MAX_RECORD_TEXT) || !optStr(v.theirsHash, 64)) return null
+  if (!optLine(v.claimedBy, 80) || !optLine(v.resolvedBy, 80) || !optLine(v.reason, 500)) return null
+  if (v.how != null && !HOWS.includes(v.how)) return null
+  if (v.doneTs != null && typeof v.doneTs !== 'number') return null
+  // Deleted offline: ours is gone, not merely too big to share (records from before this field have none).
+  if (v.oursDeleted != null && typeof v.oursDeleted !== 'boolean') return null
+  if (v.oursDeleted && v.ours != null) return null
+  if (v.via != null && !VIAS.includes(v.via)) return null
+  return {
+    id: v.id, path: v.path, by: v.by, byId: v.byId ?? null, others: v.others, ts: v.ts,
+    kind: v.kind, state: v.state, ours: v.ours ?? null, base: v.base ?? null, theirsHash: v.theirsHash ?? null,
+    binary: !!v.binary, local: !!v.local, oursDeleted: !!v.oursDeleted, claimedBy: v.claimedBy ?? null, resolvedBy: v.resolvedBy ?? null,
+    how: v.how ?? null, doneTs: v.doneTs ?? null, reason: v.reason ?? null, via: v.via ?? null
+  }
+}
+
+const rank = (s) => (s === 'done' ? 1 : 0)
+const order = (a, b) => rank(a.state) - rank(b.state) || a.ts - b.ts || (a.id < b.id ? -1 : 1)
+
+function split (map) {
+  const valid = []
+  const junk = []
+  map.forEach((v, key) => {
+    const m = publicMerge(v)
+    if (m && m.id === key) valid.push(m)
+    else junk.push(key)
+  })
+  valid.sort(order)
+  return { valid, junk }
+}
+
+export function readMerges (map) {
+  return split(map).valid
+}
+
+/** Opens a record. Text beyond the cap stays on the opener's disk only (`local`); `oursDeleted`: the opener deleted the file. */
+export function openMerge (doc, map, { path, by, byId = null, others = [], kind, ours = null, oursDeleted = false, base = null, theirsHash = null, binary = false, claimedBy = null, reason = null, via = null }, origin) {
+  if (!KINDS.includes(kind)) throw new Error('bad merge kind')
+  const fits = (t) => t == null || t.length <= MAX_RECORD_TEXT
+  const local = !fits(ours) || !fits(base)
+  const rec = {
+    id: crypto.randomBytes(8).toString('hex'),
+    path, by, byId, others: others.filter((n) => n && n !== by).slice(0, 20), ts: Date.now(),
+    kind, state: 'open',
+    ours: fits(ours) ? ours : null, base: fits(base) ? base : null, theirsHash, binary: !!binary, local, oursDeleted: !!oursDeleted,
+    claimedBy, resolvedBy: null, how: null, doneTs: null, reason, via
+  }
+  const out = publicMerge(rec)
+  if (!out) throw new Error('bad merge record') // never write what readers would drop as junk
+  doc.transact(() => {
+    for (const key of split(map).junk) map.delete(key)
+    map.set(rec.id, rec)
+  }, origin)
+  return out
+}
+
+/** Changes state, how, resolvedBy or reason. Setting state to done stamps doneTs. */
+export function updateMerge (doc, map, id, patch, origin) {
+  const cur = publicMerge(map.get(id))
+  if (!cur) throw new Error('no such merge')
+  const next = { ...cur }
+  if (patch.state !== undefined) {
+    if (!STATES.includes(patch.state)) throw new Error('bad merge state')
+    next.state = patch.state
+    if (patch.state === 'done') next.doneTs = Date.now()
+  }
+  if (patch.how !== undefined) {
+    if (patch.how != null && !HOWS.includes(patch.how)) throw new Error('bad merge how')
+    next.how = patch.how
+  }
+  if (patch.resolvedBy !== undefined) next.resolvedBy = patch.resolvedBy
+  if (patch.reason !== undefined) next.reason = patch.reason
+  const out = publicMerge(next)
+  if (!out) throw new Error('bad merge record')
+  doc.transact(() => map.set(id, next), origin)
+  return out
+}
+
+/** Drops done records older than a day, and the oldest done ones beyond MAX_MERGES. Open ones are kept. */
+export function pruneMerges (doc, map, origin, now = Date.now()) {
+  const { valid, junk } = split(map)
+  const drop = new Set(junk)
+  const done = valid.filter((m) => m.state === 'done').sort((a, b) => (a.doneTs || 0) - (b.doneTs || 0))
+  for (const m of done) if (m.doneTs && now - m.doneTs > DONE_TTL_MS) drop.add(m.id)
+  let count = valid.length - drop.size
+  for (const m of done) {
+    if (count <= MAX_MERGES) break
+    if (!drop.has(m.id)) { drop.add(m.id); count-- }
+  }
+  if (!drop.size) return
+  doc.transact(() => { for (const id of drop) map.delete(id) }, origin)
+}

package/src/pass-source.js

@@ -0,0 +1,176 @@
+// Session passes from the accounts API. A pass proves who you are to the relay
+// for 10 minutes. Clients keep one until 2 minutes before it runs out, and while
+// connected they fetch a fresh one every 5 minutes (see connection.js). A session
+// asks for passes for its own room: those carry what you may do there.
+import { readPass } from './passes.js'
+import { apiUrl, accountFile, readAccount, resumeAccount, NOT_SIGNED_IN, SIGNED_OUT } from './account.js'
+import { agentAccess, agentResume, readAgent } from './agent-join.js'
+
+export const PASS_EARLY_MS = 2 * 60 * 1000
+export const PASS_REFRESH_MS = 5 * 60 * 1000
+// A pass request with no answer gives up after this, so the retry runs: right after a computer
+// wakes, the network may be gone for a while and the system's own timeout can take minutes.
+// Passes are cheap to ask for again, unlike an agent's key refresh.
+export const PASS_TIMEOUT_MS = 10 * 1000
+const AGENT_SIGNED_OUT = "This agent's keys stopped working. Invite it again."
+
+/** The API turned the token away: this computer (or agent) is signed out for good. */
+export class SignedOutError extends Error {
+  constructor (message) {
+    super(message)
+    this.signedOut = true
+  }
+}
+
+export class PassSource {
+  /** `fetchPass(room)` resolves to { pass, expiresAt }; `room` is '' for a pass that isn't for one room. */
+  constructor ({ fetchPass, now = Date.now, earlyMs = PASS_EARLY_MS, room = '' }) {
+    this.fetchPass = fetchPass
+    this.now = now
+    this.earlyMs = earlyMs
+    this.room = room
+    this.rooms = new Map() // room -> PassSource, for forRoom
+    this.current = null // { pass, expiresAt, payload }
+    this.pending = null
+  }
+
+  /** The same account's passes for one room (kept, one per room). They carry its access there. */
+  forRoom (room) {
+    if (!room || room === this.room) return this
+    if (!this.rooms.has(room)) this.rooms.set(room, new PassSource({ fetchPass: this.fetchPass, now: this.now, earlyMs: this.earlyMs, room }))
+    return this.rooms.get(room)
+  }
+
+  /** A pass with at least `earlyMs` left, fetching one when needed. */
+  get () {
+    if (this.current && this.now() < this.current.expiresAt - this.earlyMs) return Promise.resolve(this.current.pass)
+    return this.fresh()
+  }
+
+  /** Always asks for a new pass. Calls made while one is on its way share it. */
+  fresh () {
+    if (!this.pending) {
+      this.pending = Promise.resolve()
+        .then(() => this.fetchPass(this.room))
+        .then(({ pass, expiresAt }) => {
+          this.current = { pass, expiresAt, payload: readPass(pass) }
+          return pass
+        })
+        .finally(() => { this.pending = null })
+    }
+    return this.pending
+  }
+
+  /**
+   * A pass issued after this call. One already on its way may have been issued before
+   * something changed (the relay asking for a fresh pass after the owner changed our
+   * access): wait for it, then ask again.
+   */
+  newer () {
+    return this.pending ? this.pending.catch(() => {}).then(() => this.fresh()) : this.fresh()
+  }
+
+  /** Forgets the cached pass (the relay turned it away), so the next get() fetches one. */
+  forget () {
+    this.current = null
+  }
+
+  /** Who the passes are for ({ sub, kind, name, key, … }), once one has been fetched. */
+  get payload () {
+    return this.current ? this.current.payload : null
+  }
+}
+
+async function requestPass (fetchImpl, api, bearer, signedOutMessage, room = '', timeoutMs = PASS_TIMEOUT_MS) {
+  let res
+  try {
+    const body = room ? { headers: { authorization: `Bearer ${bearer}`, 'content-type': 'application/json' }, body: JSON.stringify({ room }) } : { headers: { authorization: `Bearer ${bearer}` } }
+    res = await fetchImpl(`${String(api).replace(/\/+$/, '')}/v1/passes`, { method: 'POST', ...body, signal: AbortSignal.timeout(timeoutMs) })
+  } catch (err) {
+    throw new Error(`Couldn't reach Quilt (${err.name === 'TimeoutError' ? 'ETIMEDOUT' : err.cause?.code || err.message}).`)
+  }
+  const body = await res.json().catch(() => null)
+  if (res.status === 401) throw new SignedOutError(signedOutMessage)
+  if (!res.ok || !body || typeof body.pass !== 'string') throw Object.assign(new Error(body?.error || `Quilt answered ${res.status}.`), { status: res.status })
+  return body
+}
+
+/**
+ * Passes for this computer's account, from its qd_ token. A token turned away isn't the
+ * end: another app on this computer may have signed in again since (its token is in
+ * account.json), or the computer signs back in with its key. Only a computer that's no
+ * longer linked gets SignedOutError.
+ */
+export function personPasses ({ token, api = apiUrl(), fetch: fetchImpl = globalThis.fetch, now, file = accountFile(), resume = resumeAccount, timeoutMs } = {}) {
+  let current = token
+  // Whose sign-in this is: a sign-in for someone else since (a different account) doesn't carry on these passes.
+  const first = readAccount(file)
+  const who = first && first.token === token ? first.account.id : null
+  const same = (a) => a && (!who || a.account.id === who)
+  return new PassSource({
+    now,
+    fetchPass: async (room) => {
+      try {
+        return await requestPass(fetchImpl, api, current, SIGNED_OUT, room, timeoutMs)
+      } catch (err) {
+        if (!err.signedOut) throw err
+        const saved = readAccount(file)
+        if (saved && saved.token !== current) {
+          if (!same(saved)) throw err
+          current = saved.token
+        } else {
+          const back = await resume({ api, fetch: fetchImpl, file })
+          if (!same(back)) throw err
+          current = back.token
+        }
+        return requestPass(fetchImpl, api, current, SIGNED_OUT, room, timeoutMs)
+      }
+    }
+  })
+}
+
+/** Passes for a saved agent, from its access key (refreshed with its refresh key when it runs out). */
+export function agentPasses ({ name, dir, fetch: fetchImpl = globalThis.fetch, now } = {}) {
+  return new PassSource({
+    now,
+    fetchPass: async (room) => {
+      let saved
+      try {
+        saved = await agentAccess({ name, dir, fetch: fetchImpl, now })
+      } catch (err) {
+        if (err.status === 401) throw new SignedOutError(err.message)
+        throw err
+      }
+      try {
+        return await requestPass(fetchImpl, saved.api, saved.accessKey, AGENT_SIGNED_OUT, room)
+      } catch (err) {
+        if (!err.signedOut) throw err
+        // Keys revoked before the access key ran out: the agent signs back in with its resume key.
+        let back
+        try {
+          back = await agentResume({ name, dir, accessKey: saved.accessKey, fetch: fetchImpl })
+        } catch (e) {
+          if (e.status === 401) throw new SignedOutError(e.message)
+          throw e
+        }
+        if (!back) throw err
+        return requestPass(fetchImpl, back.api, back.accessKey, AGENT_SIGNED_OUT, room)
+      }
+    }
+  })
+}
+
+/**
+ * What a session started here signs in with: a saved agent's passes and key, or
+ * this computer's account. `name` is the name saved on this computer, so a
+ * session can start before (or without, when offline) its first pass.
+ */
+export function sessionPasses ({ agent = null, dir } = {}) {
+  if (agent) {
+    const saved = readAgent({ name: agent, dir })
+    return { passes: agentPasses({ name: agent, dir }), identity: saved.identity, kind: 'agent', name: saved.name || agent }
+  }
+  const account = readAccount()
+  if (!account) throw new Error(NOT_SIGNED_IN)
+  return { passes: personPasses({ token: account.token }), identity: null, kind: 'human', name: account.account.name || null }
+}

package/src/passes.js

@@ -0,0 +1,64 @@
+// Session passes: short-lived tickets the accounts API signs and the relay checks.
+// A pass says who you are (an account or an agent), your name, and the identity
+// key you'll prove when you connect (empty for a hosted agent, which only ever
+// talks to the relay over HTTPS and never proves a key). Its format is
+// base64url(JSON payload) + "." + base64url(Ed25519 signature of the first part).
+import crypto from 'node:crypto'
+import { generateIdentity, parsePublicKey } from './identity.js'
+
+export const PASS_VERSION = 1
+export const PASS_TTL_MS = 10 * 60 * 1000
+const MAX_NAME = 64
+const KINDS = ['person', 'agent']
+const ROOM = /^[A-Za-z0-9_-]{1,64}$/
+
+/** A new signing pair, encoded like identity keys: SPKI and PKCS8 DER, in base64url. */
+export function newPassKeys () {
+  return generateIdentity()
+}
+
+const privateKeyOf = (k) => typeof k === 'string' ? crypto.createPrivateKey({ key: Buffer.from(k, 'base64url'), format: 'der', type: 'pkcs8' }) : k
+const publicKeyOf = (k) => typeof k === 'string' ? parsePublicKey(k) : k
+
+/** The public half of a PASS_SIGNING_KEY, as QUILT_PASS_PUBLIC_KEY takes it. */
+export function passPublicKey (signingKey) {
+  return crypto.createPublicKey(privateKeyOf(signingKey)).export({ type: 'spki', format: 'der' }).toString('base64url')
+}
+
+export function signPass (payload, signingKey) {
+  const body = Buffer.from(JSON.stringify(payload)).toString('base64url')
+  const sig = crypto.sign(null, Buffer.from(body), privateKeyOf(signingKey)).toString('base64url')
+  return `${body}.${sig}`
+}
+
+/** A pass's payload without checking it (clients read their name from it). Null if malformed. */
+export function readPass (pass) {
+  const [body, sig, extra] = String(pass ?? '').split('.')
+  if (!body || !sig || extra !== undefined) return null
+  try {
+    const p = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'))
+    return p && typeof p === 'object' && !Array.isArray(p) ? p : null
+  } catch { return null }
+}
+
+/**
+ * The payload when the signature verifies, it's version 1, it hasn't expired and
+ * its fields make sense; otherwise null.
+ */
+export function verifyPass (pass, key, { now = Date.now() } = {}) {
+  const k = publicKeyOf(key)
+  const p = readPass(pass)
+  if (!k || !p) return null
+  const [body, sig] = String(pass).split('.')
+  let signed = false
+  try { signed = crypto.verify(null, Buffer.from(body), k, Buffer.from(sig, 'base64url')) } catch {}
+  if (!signed || p.v !== PASS_VERSION) return null
+  if (typeof p.exp !== 'number' || p.exp <= now) return null
+  if (typeof p.sub !== 'string' || !p.sub || !KINDS.includes(p.kind)) return null
+  if (typeof p.name !== 'string' || !p.name.trim() || p.name.length > MAX_NAME) return null
+  // A room pass is good in that room only (see access in session-access.js).
+  if (p.room !== undefined && (typeof p.room !== 'string' || !ROOM.test(p.room))) return null
+  // No key: an HTTP-only pass (a hosted agent, see relay-mcp.js); it can't open a WebSocket.
+  if (typeof p.key !== 'string' || (p.key && !parsePublicKey(p.key))) return null
+  return p
+}

package/src/pathrules.js

@@ -0,0 +1,127 @@
+// Which paths are synced, and which are safe to accept from a peer. No Node
+// APIs here: the web app uses the same rules as the CLI.
+import ignore from 'ignore'
+
+export const MAX_TEXT_BYTES = 2 * 1024 * 1024
+export const MAX_BINARY_BYTES = 8 * 1024 * 1024
+// Binary files this big or bigger are stored encrypted outside the session document.
+export const LARGE_FILE_BYTES = 256 * 1024
+// The most a stored file may be (the relay may allow less).
+export const MAX_STORED_BINARY_BYTES = 100 * 1024 * 1024
+
+// Never synced, regardless of .gitignore. .env files are excluded so secrets
+// stay on each person's machine; Claude Code worktrees are whole private
+// copies of the project.
+export const ALWAYS_IGNORED = [
+  '.git', '.quilt', '.cowove', 'node_modules', '.DS_Store', 'Thumbs.db', '.claude/worktrees',
+  // Each person's own Claude Code settings (permissions, Quilt's hooks) stay on their machine.
+  '.claude/settings.local.json',
+  // Build output and caches: large, machine-specific, and rebuilt by each person.
+  '.next', '.turbo', '.nuxt', '.svelte-kit', '.parcel-cache', '.vercel',
+  '.env', '.env.*', '!.env.example',
+  // A .quiltignore is each person's own list of what stays on their machine, so it stays there too.
+  '.quiltignore', '.cowoveignore',
+  '*.swp', '*.swo', '*~', '.#*'
+]
+
+/** Files whose patterns say what isn't synced, in the folder they sit in. */
+export const IGNORE_FILES = ['.gitignore', '.quiltignore', '.cowoveignore']
+
+/**
+ * Rewrites an ignore file found in subfolder `dir` so its patterns apply from
+ * the project root, the way git scopes a nested .gitignore to its folder.
+ */
+export function scopeIgnore (text, dir) {
+  if (!dir) return text
+  return text.split(/\r?\n/).map((line) => {
+    if (!line.trim() || line.startsWith('#')) return line
+    const neg = line.startsWith('!')
+    const body = neg ? line.slice(1) : line
+    // A slash anywhere but the end anchors the pattern to this folder.
+    const anchored = body.replace(/\/+\s*$/, '').includes('/')
+    const scoped = anchored ? `${dir}/${body.replace(/^\//, '')}` : `${dir}/**/${body}`
+    return (neg ? '!' : '') + scoped
+  }).join('\n')
+}
+
+/**
+ * An ignore matcher from the built-ins plus the text of .gitignore / .quiltignore
+ * files. The built-ins are kept apart from the project patterns, so a shared
+ * .gitignore saying "!.env" can't make anyone's secrets sync.
+ */
+export function makeIgnore (texts = []) {
+  const builtin = ignore().add(ALWAYS_IGNORED)
+  const project = ignore()
+  for (const t of texts) if (t) project.add(t)
+  return {
+    add (text) { project.add(text); return this },
+    ignores (p) { return builtin.ignores(p) || project.ignores(p) }
+  }
+}
+
+export function isIgnored (ig, rel) {
+  if (!rel || rel === '.') return false
+  // Check every ancestor directory so "dist/" also excludes "dist/a/b.js".
+  const parts = rel.split('/')
+  for (let i = 1; i <= parts.length; i++) {
+    const sub = parts.slice(0, i).join('/')
+    if (ig.ignores(sub)) return true
+    if (i < parts.length && ig.ignores(sub + '/')) return true
+  }
+  return false
+}
+
+// Names Windows reserves for devices, with any extension: a member there could never write them.
+const WINDOWS_DEVICE = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i
+const utf8Length = (s) => new TextEncoder().encode(s).length
+
+/**
+ * Validates a path received from a peer. Rejects anything that could escape
+ * the project folder or touch git internals, and names that some member's
+ * disk could not hold (a change nobody can write is a change nobody should
+ * share).
+ */
+export function isSafeRelPath (rel) {
+  if (typeof rel !== 'string' || !rel || rel.length > 1024) return false
+  if (rel.includes('\\') || rel.includes('\0')) return false
+  if (rel.startsWith('/') || /^[A-Za-z]:/.test(rel)) return false
+  const parts = rel.split('/')
+  for (const part of parts) {
+    if (part === '' || part === '.' || part === '..') return false
+    if (WINDOWS_DEVICE.test(part) || part.endsWith('.') || part.endsWith(' ')) return false
+    if (part.length > 255 || utf8Length(part) > 255) return false
+  }
+  const first = parts[0].toLowerCase()
+  if (first === '.git' || first === '.quilt' || first === '.cowove') return false
+  return true
+}
+
+/** Whether two claim patterns can cover the same file (paths: files that exist now). */
+export function patternsOverlap (a, b, paths = []) {
+  if (a === b) return true
+  const ma = globMatcher(a)
+  const mb = globMatcher(b)
+  return ma(b) || mb(a) || paths.some((p) => ma(p) && mb(p))
+}
+
+/** Converts a simple glob (*, **, ?) or a plain path/folder into a matcher. */
+export function globMatcher (pattern) {
+  let p = pattern.trim().replace(/^\.\//, '')
+  if (!/[*?]/.test(p)) {
+    const base = p.replace(/\/+$/, '')
+    return (rel) => rel === base || rel.startsWith(base + '/')
+  }
+  let re = ''
+  for (let i = 0; i < p.length; i++) {
+    const c = p[i]
+    if (c === '*' && p[i + 1] === '*') {
+      re += '.*'
+      i++
+      if (p[i + 1] === '/') i++
+    } else if (c === '*') re += '[^/]*'
+    else if (c === '?') re += '[^/]'
+    else re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+  }
+  const rx = new RegExp(`^${re}$`)
+  return (rel) => rx.test(rel)
+}