heyquilt 0.3.122 → 0.3.140

package/src/quilts/dogfood.js

@@ -1,82 +0,0 @@
-// The dogfood round trip (week 4, item 2): a git repository's full history into a new quilt on
-// whatever API the client points at, every imported commit's tree checked against git, then
-// `main` exported back to git and checked: one exported commit per first-parent commit, each
-// with git's tree and its `Quilt-Git-Sha` trailer naming that commit, and a second export from
-// scratch giving the same tip (the export is deterministic).
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { execFileSync } from 'node:child_process'
-import { importGit } from './import-git.js'
-import { exportGit } from './export-git.js'
-
-const git = (dir, args) => execFileSync('git', ['-C', dir, ...args], { maxBuffer: 1 << 30, env: { ...process.env, GIT_NO_REPLACE_OBJECTS: '1' } }).toString()
-
-/** `git rev-list` with one format line per commit: [[sha, field], ...]. */
-function revs (dir, args, format) {
-  const out = git(dir, ['rev-list', `--format=${format}`, ...args]).split('\n')
-  const rows = []
-  for (let i = 0; i < out.length; i++) {
-    if (!out[i].startsWith('commit ')) continue
-    rows.push([out[i].slice(7), out[i + 1] || ''])
-  }
-  return rows
-}
-
-/**
- * Runs the round trip. `repo` is any git repository on this machine, `rev` the commit whose
- * history is imported (HEAD by default), `slug` the new quilt. Returns a report; throws on the
- * first mismatch.
- */
-export async function dogfood (client, { repo, rev = 'HEAD', slug, work, keep = false, batch = 200, log = () => {} }) {
-  const sha = git(repo, ['rev-parse', '--verify', `${rev}^{commit}`]).trim()
-  const dir = work || fs.mkdtempSync(path.join(os.tmpdir(), 'quilt-dogfood-'))
-  const src = path.join(dir, 'src')
-  const times = {}
-  try {
-    // A bare-ish copy whose HEAD is `rev`, so the import walks exactly that history.
-    git(os.tmpdir(), ['clone', '-q', '--shared', '--no-checkout', repo, src])
-    git(src, ['update-ref', '--no-deref', 'HEAD', sha])
-
-    let t = Date.now()
-    log(`Importing ${sha.slice(0, 12)} of ${repo} into ${slug}…`)
-    const imp = await importGit(client, { repo: src, slug, batch, validate: 'all', log, onlyHead: true, fresh: true })
-    times.import_ms = Date.now() - t
-    log(`Imported ${imp.commits} commits (${imp.patches} patches); every commit's tree equals git's (${imp.validated}).`)
-
-    t = Date.now()
-    const out = path.join(dir, 'export.git')
-    const exp = await exportGit(client, { q: imp.quilt, dir: out, log })
-    times.export_ms = Date.now() - t
-
-    const want = revs(src, ['--first-parent', '--reverse', sha], '%T')
-    const got = revs(out, ['--reverse', 'refs/heads/main'], '%T')
-    if (got.length !== want.length) throw new Error(`export: main has ${got.length} commits, git's first-parent history ${want.length}`)
-    const trailers = revs(out, ['--reverse', 'refs/heads/main'], '%(trailers:key=Quilt-Git-Sha,valueonly,separator=)')
-    for (let i = 0; i < want.length; i++) {
-      if (got[i][1] !== want[i][1]) throw new Error(`export: commit ${i + 1} (git ${want[i][0].slice(0, 12)}) has tree ${got[i][1].slice(0, 12)}, git's is ${want[i][1].slice(0, 12)}`)
-      if (trailers[i][1].trim() !== want[i][0]) throw new Error(`export: commit ${i + 1} names git ${trailers[i][1].trim() || 'nothing'} in Quilt-Git-Sha, expected ${want[i][0]}`)
-    }
-    log(`Exported ${exp.exported} patches; every tree and Quilt-Git-Sha matches git's first-parent history.`)
-
-    const again = await exportGit(client, { q: imp.quilt, dir: path.join(dir, 'again.git'), page: 97 })
-    if (again.sha !== exp.sha) throw new Error(`export is not deterministic: ${exp.sha} then ${again.sha}`)
-    log(`Exported again from scratch: same tip ${exp.sha.slice(0, 12)}.`)
-
-    return {
-      quilt: imp.quilt,
-      slug: imp.slug,
-      rev: sha,
-      commits: imp.commits,
-      patches: imp.patches,
-      validated: imp.validated,
-      exported: exp.exported,
-      export_sha: exp.sha,
-      left_out: imp.report,
-      ...times,
-      ...(keep ? { work: dir } : {})
-    }
-  } finally {
-    if (!keep && !work) fs.rmSync(dir, { recursive: true, force: true })
-  }
-}

package/src/quilts/errors.js

@@ -1,8 +0,0 @@
-// What both the server and the seam client need without loading the server (service.js).
-export class QuiltError extends Error {
-  /** `code` is the wire name (04/07/12): head_moved, tip_moved, conflict, not_found, ... */
-  constructor (status, code, message, extra = {}) { super(message); this.status = status; this.code = code; this.extra = extra }
-}
-
-/** A square's short handle: sq: + the last 8 hex of its uuid (02). */
-export const squareShort = (id) => `sq:${String(id).replace(/-/g, '').slice(-8)}`

package/src/quilts/events.js

@@ -1,171 +0,0 @@
-// Events (plans/quilt-source-control/12): never written in the commit or merge transaction. The
-// events job reads the quilt's log after its cursor, derives each event and its recipients, and
-// writes them with the cursor moved in one transaction (store.addEvents); then it POSTs each one
-// to the recipients' webhooks, signed and retried by seam's own webhook.js. Members read theirs
-// over HTTP (GET /v1/quilts/:q/events?after=), the CLI (`seam events`) and the MCP tool seam_events, so an agent in any tool is woken the same way.
-import { QuiltError, squareShort } from './service.js'
-import { makeSubscription, deliverWebhook, RETRY_DELAYS_MS } from './webhook.js'
-
-export const QUILT_EVENT_KINDS = ['patch.merged', 'patch.reverted', 'conflict.added', 'square.handoff', 'check.requested', 'check.cancelled']
-const MAX_DIFF_PATHS = 200
-
-export function eventOps (svc, sq, { allowLocalWebhooks = false, fetch, delays = RETRY_DELAYS_MS, log = () => {} } = {}) {
-  const { store, now, quiltFor, getCommit, getTerm, conflictsAt, snapshot, reader } = svc.internals
-  const running = new Map() // quilt → the job in flight, so one process runs one job per quilt at a time
-  const sending = new Map() // quilt + member → delivery chain, so a member's POSTs keep their order
-
-  const by = (c) => ({ member_id: c.author.member_id, kind: c.author.kind, name: c.author.name, ...(c.author.tool ? { tool: c.author.tool } : {}) })
-
-  async function changedPaths (qid, s) {
-    if (!s.head) return []
-    return (await reader(qid).diff(await snapshot(qid, s.base), await snapshot(qid, s.head))).map((e) => e.path)
-  }
-
-  /** The events one log row causes. */
-  async function derive (qid, row) {
-    const out = []
-    // check.requested (13, checks.js): to the runners a line's policy names.
-    if (svc.internals.checkRequests) out.push(...await svc.internals.checkRequests(qid, row))
-    if (row.kind === 'merge' && row.payload?.reverts) {
-      // patch.reverted: the reverted patch's holder (and whom they acted for) learns it is gone (07 step 4).
-      const c = await getCommit(qid, row.commit)
-      const gone = await store.patch(qid, row.line, Number(row.payload.reverts))
-      const orig = gone && gone.square ? await store.getSquare(gone.square) : null
-      const oc = gone ? await getCommit(qid, gone.commit).catch(() => null) : null
-      const to = [orig && !orig.import ? orig.holder : null, oc && oc.on_behalf_of].filter(Boolean)
-      if (to.length) {
-        out.push({
-          kind: 'patch.reverted', at: row.at, cause_seq: row.seq, square: orig.id, line: row.line, patch_no: Number(row.payload.reverts), by: by(c), paths: c.changes.map((ch) => ch.path).slice(0, MAX_DIFF_PATHS),
-          payload: { patch_no: Number(row.payload.reverts), revert_patch_no: row.patch_no, commit: c.id, message: c.message },
-          recipients: [...new Set(to)]
-        })
-      }
-    }
-    if (row.kind === 'merge') {
-      // patch.merged: to the holder and writers of every other open square on the line that changed a path the patch changed.
-      const c = await getCommit(qid, row.commit)
-      const touched = new Set(c.changes.map((ch) => ch.path))
-      for (const s of await store.squares(qid, { state: 'open' })) {
-        if (s.id === row.square || s.line !== row.line) continue
-        const overlap = (await changedPaths(qid, s)).filter((p) => touched.has(p))
-        if (!overlap.length) continue
-        const st = await sq.statusOf(qid, s)
-        const wc = (st.would_conflict || []).map((w) => w.path)
-        out.push({
-          kind: 'patch.merged', at: row.at, cause_seq: row.seq, square: s.id, line: row.line, patch_no: row.patch_no, by: by(c), paths: overlap,
-          ...(c.task_id ? { task: { id: c.task_id } } : {}),
-          payload: { patch_no: row.patch_no, commit: c.id, message: c.message, author: c.author.member_id, ...(c.task_id ? { task: c.task_id } : {}), stat: c.changes.slice(0, MAX_DIFF_PATHS).map((ch) => ({ path: ch.path, op: ch.op })), would_conflict: wc.length > 0, would_conflict_paths: wc },
-          recipients: [s.holder, ...(s.writers || [])]
-        })
-      }
-    } else if (row.kind === 'commit') {
-      // conflict.added: a term at a path that did not hold that term before this commit.
-      const c = await getCommit(qid, row.commit)
-      const terms = c.changes.filter((ch) => ch.op === 'conflict')
-      if (!terms.length) return out
-      const prev = c.predecessor || c.parents[0]
-      const before = new Map(prev ? (await conflictsAt(qid, prev)).map((e) => [e.path, e.term]) : [])
-      const s = await store.getSquare(row.square)
-      const cause = row.payload?.rebased_onto ? { commit: row.payload.rebased_onto, ...((await getCommit(qid, row.payload.rebased_onto).catch(() => null))?.patch || {}) } : row.payload?.merged_from ? { commit: row.payload.merged_from } : row.payload?.folded_from ? { square: row.payload.folded_from } : null
-      for (const ch of terms) {
-        if (before.get(ch.path) === ch.term) continue
-        const t = await getTerm(qid, ch.term)
-        out.push({
-          kind: 'conflict.added', at: row.at, cause_seq: row.seq, square: row.square, line: s && s.line, by: by(c), paths: [ch.path],
-          payload: { path: ch.path, kind: t.kind, term: ch.term, commit: c.id, sides: t.adds.map((a) => ({ by: a.by || null, commit: a.from_commit || null, ...(a.from_square ? { square: squareShort(a.from_square) } : {}) })), ...(cause ? { caused_by: cause } : {}), resolver: s ? s.holder : null },
-          recipients: s ? [s.holder] : []
-        })
-      }
-    } else if (row.kind === 'square' && row.payload?.op === 'handoff') {
-      out.push({
-        kind: 'square.handoff', at: row.at, cause_seq: row.seq, square: row.square, by: { member_id: row.actor },
-        payload: { from: row.payload.from, to: row.payload.to, ...(row.payload.context ? { note: row.payload.context } : {}) },
-        recipients: [row.payload.from, row.payload.to]
-      })
-    }
-    return out
-  }
-
-  /** Runs the events job for a quilt until it has read the whole log; returns the new events. */
-  function pump (qid) {
-    const prev = running.get(qid) || Promise.resolve()
-    const job = prev.catch(() => {}).then(async () => {
-      const made = []
-      for (;;) {
-        const cursor = await store.eventCursor(qid)
-        const rows = await store.logRows(qid, { after: cursor, limit: 200 })
-        if (!rows.length) return made
-        let events = []
-        for (const r of rows) events.push(...await derive(qid, r))
-        // A new check request cancels what it supersedes (checks.js settleRuns).
-        let cancels = []
-        if (svc.internals.settleRuns) ({ events, cancels } = await svc.internals.settleRuns(qid, events))
-        // A check.requested event's run record is stored first (idempotent on run_key), so a
-        // runner polling GET /checks finds every run it is woken for.
-        const runs = events.filter((e) => e.run).map((e) => e.run)
-        if (runs.length) await store.addCheckRuns({ quilt_id: qid, runs })
-        for (const e of events) delete e.run
-        try {
-          made.push(...await store.addEvents({ quilt_id: qid, events, expect_cursor: cursor, cursor: rows.at(-1).seq }))
-          if (cancels.length) await svc.internals.applyCancels(qid, cancels)
-        } catch (err) { if (err.code !== 'cursor_moved') throw err }
-      }
-    })
-    running.set(qid, job)
-    job.finally(() => { if (running.get(qid) === job) running.delete(qid) }).catch(() => {})
-    // Deliveries run beside the job (a dead webhook's retries never hold up reading events).
-    return job.then((made) => { const d = deliver(qid, made); inflight.add(d); d.finally(() => inflight.delete(d)); return made })
-  }
-  const inflight = new Set()
-  /** Waits for every webhook POST in flight (tests, and a clean shutdown). */
-  const eventsSettled = async () => { while (inflight.size) await Promise.all([...inflight]) }
-
-  /** The event as a member sees it (12's shape; recipients are not shown). */
-  const view = (e) => {
-    const { recipients, quilt_id: q, ...rest } = e
-    void recipients
-    return { ...rest, quilt: q, ...(e.square ? { square_short: squareShort(e.square) } : {}) }
-  }
-
-  /** POSTs new events to every recipient that subscribed (one chain per member, in order). */
-  async function deliver (qid, events) {
-    const waits = []
-    for (const e of events) {
-      for (const m of new Set(e.recipients || [])) {
-        const sub = await store.webhook(qid, m)
-        if (!sub || !sub.events.includes(e.kind)) continue
-        const key = `${qid}\u0000${m}`
-        const payload = { event: e.kind, id: `${qid}:${e.event_seq}`, to: m, ts: e.at || now(), ...view(e) }
-        const next = (sending.get(key) || Promise.resolve()).then(() => deliverWebhook(sub, payload, { delays, log, ...(fetch ? { fetch } : {}) })).catch(() => {})
-        sending.set(key, next)
-        waits.push(next)
-      }
-    }
-    await Promise.all(waits)
-  }
-
-  /** GET /events: the caller's events after `after` (the job runs first, so none is missing). */
-  async function events (me, ref, { after = 0, kinds, limit = 100 } = {}) {
-    const q = await quiltFor(me, ref)
-    await pump(q.id)
-    const list = await store.eventsFor(q.id, me.member_id, { after: Number(after) || 0, kinds: kinds && kinds.length ? kinds : undefined, limit: Math.min(Number(limit) || 100, 1000) })
-    return { events: list.map(view), after: list.length ? list.at(-1).event_seq : Number(after) || 0 }
-  }
-
-  /** POST /webhook: { url, secret?, events?, bearer? } subscribes the caller; { url: null } removes it. */
-  async function subscribe (me, ref, body = {}) {
-    const q = await quiltFor(me, ref)
-    if (body.url === null || body.off) { await store.setWebhook({ quilt_id: q.id, member_id: me.member_id, sub: null }); return { ok: true, removed: true } }
-    const kinds = body.events == null ? QUILT_EVENT_KINDS.slice() : body.events
-    if (!Array.isArray(kinds) || !kinds.length || kinds.some((k) => !QUILT_EVENT_KINDS.includes(k))) throw new QuiltError(400, 'bad_request', `events: give some of ${QUILT_EVENT_KINDS.join(', ')}`)
-    let sub
-    try { sub = makeSubscription({ url: body.url, secret: body.secret, bearer: body.bearer }, { allowLocal: allowLocalWebhooks }) } catch (err) { throw new QuiltError(400, 'bad_request', err.message) }
-    const row = { url: sub.url, secret: sub.secret, events: [...new Set(kinds)], since: sub.since, ...(sub.bearer ? { bearer: sub.bearer } : {}) }
-    // Events already in the table are not news to a new subscription: the job runs first.
-    await pump(q.id)
-    await store.setWebhook({ quilt_id: q.id, member_id: me.member_id, sub: row })
-    return { ok: true, url: row.url, events: row.events, ...(sub.made ? { secret: row.secret } : {}) }
-  }
-
-  return { events, subscribe, pumpEvents: pump, eventsSettled }
-}

package/src/quilts/export-git.js

@@ -1,130 +0,0 @@
-// The local driver of the one-way git export (plans/quilt-source-control/14, Export): reads a
-// line's patches from the server (GET /quilts/:q/export/git) and writes each as one commit on a
-// branch of a plain git repository with `git fast-import`, so CI and deploys that expect git
-// keep working. The commit fields come from the server whole, so the same patch always gives
-// the same commit id, on any machine, in any number of runs. A run picks up after the last
-// patch it exported (state in the repository's `quilt-export.json`), and refuses a branch that
-// moved under it: the export is one way, never a merge.
-import { spawn, execFileSync } from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-
-const MODES = { file: '100644', exec: '100755', symlink: '120000', gitlink: '160000' }
-const GIT_ENV = { ...process.env, GIT_NO_REPLACE_OBJECTS: '1', GIT_CONFIG_NOSYSTEM: '1' }
-
-const git = (dir, args) => execFileSync('git', ['-C', dir, ...args], { env: GIT_ENV, maxBuffer: 256 * 1024 * 1024 }).toString().trim()
-const tryGit = (dir, args) => { try { return git(dir, args) } catch { return null } }
-
-/** A path as fast-import reads it: C-quoted when it would otherwise be misread. */
-const fiPath = (p) => (/^"|[\n"\\]/.test(p) ? '"' + p.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"' : p)
-const ident = (who) => `${who.name} <${who.email}> ${who.at} +0000`
-
-/** The repository at `dir`, made bare when it does not exist yet: its git dir. */
-function openRepo (dir) {
-  if (!fs.existsSync(dir)) { fs.mkdirSync(dir, { recursive: true }); git(dir, ['init', '-q', '--bare']) }
-  const gd = tryGit(dir, ['rev-parse', '--absolute-git-dir'])
-  if (!gd) throw new Error(`${dir} is not a git repository`)
-  return gd
-}
-
-/** fast-import as a writable stream with backpressure; done() → its exit. */
-function fastImport (dir, marks) {
-  const p = spawn('git', ['-C', dir, 'fast-import', '--quiet', '--date-format=raw', `--export-marks=${marks}`], { env: GIT_ENV, stdio: ['pipe', 'ignore', 'pipe'] })
-  let err = ''
-  p.stderr.on('data', (d) => { err += d })
-  const exit = new Promise((resolve, reject) => p.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`git fast-import failed: ${err.trim()}`)))))
-  exit.catch(() => {})
-  return {
-    write (chunk) { return p.stdin.write(chunk) ? null : new Promise((resolve) => p.stdin.once('drain', resolve)) },
-    async done () { p.stdin.end(); await exit }
-  }
-}
-
-/** Every blob in `ids`, as Buffers, in as many requests as the server's size cap needs. */
-async function fetchBlobs (client, q, ids) {
-  const out = new Map()
-  let todo = [...new Set(ids)]
-  while (todo.length) {
-    const r = await client.blobs(q, todo.slice(0, 2000))
-    const got = Object.entries(r.blobs || {})
-    if (!got.length) throw new Error(`the server returned none of ${todo.length} blobs`)
-    for (const [id, b64] of got) out.set(id, Buffer.from(b64, 'base64'))
-    todo = todo.filter((id) => !out.has(id))
-  }
-  return out
-}
-
-/**
- * Exports `line` of quilt `q` to `branch` of the repository at `dir` (created bare when
- * missing). Returns { exported, patch_no, sha, branch }.
- */
-export async function exportGit (client, { q, dir, line = 'main', branch, page = 200, log = () => {} }) {
-  branch = branch || line
-  const gitDir = openRepo(dir)
-  const stateFile = path.join(gitDir, 'quilt-export.json')
-  const shaFile = path.join(gitDir, 'quilt-export-shas')
-  const all = fs.existsSync(stateFile) ? JSON.parse(fs.readFileSync(stateFile, 'utf8')) : {}
-  const key = `${line}→${branch}`
-  const state = all[key] || null
-  const tip = tryGit(dir, ['rev-parse', '--verify', '-q', `refs/heads/${branch}`])
-  if (state && state.quilt !== undefined && state.quilt !== null) {
-    const info = await client.quilt(q)
-    if (info.id !== state.quilt) throw new Error(`${dir} holds the export of another quilt (${state.quilt})`)
-  }
-  if (state ? tip !== state.sha : tip) throw new Error(`branch ${branch} in ${dir} moved since the last export (${tip || 'gone'}, expected ${state ? state.sha : 'no branch'}): the export never merges or forces; point it at a new branch or repository`)
-
-  let after = state ? state.patch_no : -1
-  let sha = state ? state.sha : null
-  let exported = 0
-  let version = state ? state.version : null
-  let quiltId = state ? state.quilt : null
-  for (;;) {
-    const r = await client.exportPatches(q, { line, after, limit: page })
-    if (version !== null && version !== r.version) throw new Error(`export format ${r.version} differs from the ${version} this branch was exported with: export to a new branch`)
-    version = r.version; quiltId = r.quilt
-    if (!r.patches.length) break
-    const blobs = await fetchBlobs(client, q, r.patches.flatMap((p) => p.changes.filter((c) => c.op === 'put').map((c) => c.blob)))
-    const marksFile = path.join(gitDir, 'quilt-export.marks')
-    const fi = fastImport(dir, marksFile)
-    const send = async (s) => { const w = fi.write(s); if (w) await w }
-    let mark = 0
-    const blobMark = new Map()
-    for (const [id, bytes] of blobs) {
-      // A gitlink's content is the submodule commit it pins; git writes no blob for it.
-      if (r.patches.some((p) => p.changes.some((c) => c.blob === id && c.mode === 'gitlink'))) blobMark.set(id, bytes.toString('utf8').trim())
-      if (blobMark.has(id)) continue
-      blobMark.set(id, ++mark)
-      await send(`blob\nmark :${mark}\ndata ${bytes.length}\n`); await send(bytes); await send('\n')
-    }
-    const commitMark = new Map()
-    let first = true
-    for (const p of r.patches) {
-      commitMark.set(p.patch_no, ++mark)
-      const msg = Buffer.from(p.message, 'utf8')
-      let s = `commit refs/heads/${branch}\nmark :${mark}\nauthor ${ident(p.author)}\ncommitter ${ident(p.committer)}\ndata ${msg.length}\n`
-      await send(s); await send(msg); s = '\n'
-      if (first && sha) s += `from ${sha}\n`
-      first = false
-      for (const c of p.changes) {
-        if (c.op === 'delete') s += `D ${fiPath(c.path)}\n`
-        else if (c.mode === 'gitlink') s += `M 160000 ${blobMark.get(c.blob)} ${fiPath(c.path)}\n`
-        else s += `M ${MODES[c.mode || 'file'] || MODES.file} :${blobMark.get(c.blob)} ${fiPath(c.path)}\n`
-      }
-      await send(s + '\n')
-    }
-    await fi.done()
-    const marks = new Map(fs.readFileSync(marksFile, 'utf8').split('\n').filter(Boolean).map((l) => { const [m, h] = l.split(' '); return [Number(m.slice(1)), h] }))
-    fs.rmSync(marksFile, { force: true })
-    const lines = r.patches.map((p) => `${line} ${p.patch_no} ${marks.get(commitMark.get(p.patch_no))}`)
-    fs.appendFileSync(shaFile, lines.join('\n') + '\n')
-    const last = r.patches[r.patches.length - 1]
-    after = last.patch_no
-    sha = marks.get(commitMark.get(last.patch_no))
-    exported += r.patches.length
-    all[key] = { quilt: quiltId, line, branch, patch_no: after, sha, version }
-    fs.writeFileSync(stateFile, JSON.stringify(all, null, 2) + '\n')
-    log(`  ${line}/${after} → ${sha.slice(0, 12)} (${exported} exported)`)
-  }
-  if (sha && !tryGit(dir, ['symbolic-ref', '-q', 'HEAD'])?.endsWith(`/${branch}`) && !tryGit(dir, ['rev-parse', '--verify', '-q', 'HEAD'])) git(dir, ['symbolic-ref', 'HEAD', `refs/heads/${branch}`])
-  return { exported, patch_no: after, sha, branch }
-}

package/src/quilts/export-remote.js

@@ -1,156 +0,0 @@
-// Export to a git remote (plans/quilt-source-control/14, "Export"): `settings.export` names a
-// remote (any: GitHub, GitLab, a bare repository), a credential the owner gives by name, the
-// lines to export (names, or `release/*`) and whether releases go out as tags. After each merge
-// on those lines the server writes the new patches as 14's commits (export.js and export-git.js:
-// deterministic, so the same patch gives the same sha on any machine) in a bare repository in
-// scratch and pushes them, fast-forward only: a remote that moved is refused, never forced, and
-// the status says which line and sha. Failures to reach the remote retry with backoff. A
-// quilt that an import made continues git's own history when the target is the import's source:
-// the first exported patch's parent is the last imported sha (14, cut-over). While its import
-// follows git, the export may go only to a scratch remote that is not the source.
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import crypto from 'node:crypto'
-import { QuiltError } from './service.js'
-import { exportGit } from './export-git.js'
-import { remoteUrl, run, authArgs, localClient } from './import-follow.js'
-
-const LEASE = ' export'
-const matches = (patterns, line) => patterns.some((p) => p === line || (p.endsWith('/*') && line.startsWith(p.slice(0, -1))))
-const BACKOFF = [30_000, 60_000, 5 * 60_000, 15 * 60_000, 60 * 60_000]
-
-export function exportRemoteOps (svc, api, { scratch = path.join(os.tmpdir(), 'seam-imports'), allowLocal = false, secret = (name) => process.env[`SEAM_SECRET_${String(name).toUpperCase().replace(/[^A-Z0-9]/g, '_')}`] || null, holder = `exporter:${process.pid}:${crypto.randomBytes(4).toString('hex')}` } = {}) {
-  const { store, now, quiltFor, fromStore } = svc.internals
-  const running = new Map()
-  const again = new Set() // a write came in while a pass ran: run once more after it
-  const retryAt = new Map() // quilt id → when to try again (this server)
-
-  const save = async (qid, rec, actor, logged = false) => { try { return await store.setExport({ quilt_id: qid, export: rec, logged, actor, at: now() }) } catch (err) { throw fromStore(err) } }
-
-  /** PUT /v1/quilts/:q/export { target, credential?, lines?, releases?, scratch?, enabled? } (admin). */
-  async function setExport (me, ref, { target, credential = null, lines = ['main'], releases = false, scratch: isScratch = false, enabled = true } = {}) {
-    const q = await quiltFor(me, ref, 'admin')
-    const url = remoteUrl(target, { allowLocal })
-    const list = (Array.isArray(lines) ? lines : [lines]).map(String)
-    if (!list.length || list.some((l) => !/^[A-Za-z0-9._-][A-Za-z0-9._/-]{0,99}(\/\*)?$/.test(l))) throw new QuiltError(400, 'bad_request', 'lines: line names, or a prefix such as release/*')
-    if (credential != null && !/^[A-Za-z0-9_.-]{1,100}$/.test(String(credential))) throw new QuiltError(400, 'bad_request', 'credential: the name of a secret, not the secret')
-    const imp = q.settings?.import
-    if (imp && imp.follow && ['reading', 'following'].includes(imp.state)) {
-      // 14: never push to the source while git is the authority, and only to a remote nothing pins.
-      if (url === imp.source?.url) throw new QuiltError(409, 'export_is_source', `${url} is the source this quilt's import follows; export to a scratch remote until cut-over`)
-      if (!isScratch) throw new QuiltError(409, 'scratch_required', 'while the import follows git, the export goes only to a scratch remote: say scratch: true (--scratch) to state that nothing pins a sha from it')
-    }
-    const prev = q.settings?.export || null
-    const rec = { target: url, ...(credential ? { credential: String(credential) } : {}), lines: list, releases: !!releases, scratch: !!isScratch, enabled: !!enabled, by: { member_id: me.member_id, kind: me.kind || 'person', name: me.name || null }, status: prev && prev.target === url ? prev.status : { state: 'idle', lines: {} } }
-    await save(q.id, rec, me.member_id, true)
-    if (rec.enabled) kick(q.id)
-    return view(rec)
-  }
-
-  const view = (rec) => rec
-  async function exportStatus (me, ref) {
-    const q = await quiltFor(me, ref, 'read')
-    if (!q.settings?.export) throw new QuiltError(404, 'not_found', 'this quilt exports nowhere')
-    return view(q.settings.export)
-  }
-
-  /** One pass: every exported line's new patches, pushed; then the release tags. */
-  async function pass (qid) {
-    const q = await store.getQuilt(qid)
-    const rec = q?.settings?.export
-    if (!rec || !rec.enabled) return
-    const lease = await store.takeLease({ kind: 'line', quilt_id: qid, line: LEASE, holder, ttl_ms: 30 * 60_000, at: now() })
-    if (!lease.held) { retryAt.set(qid, now() + 30_000); return }
-    const status = { ...(rec.status || {}), lines: { ...(rec.status?.lines || {}) } }
-    try {
-      const dir = path.join(scratch, `export-${qid}.git`)
-      if (!fs.existsSync(path.join(dir, 'HEAD'))) { fs.mkdirSync(dir, { recursive: true }); await run(['init', '-q', '--bare', dir]) }
-      const auth = authArgs(rec.credential ? await secret(rec.credential, { quilt_id: qid }) : null)
-      const env = { GIT_ALLOW_PROTOCOL: allowLocal ? 'https:http:ssh:git:file' : 'https:http:ssh:git' }
-      const client = localClient(api, rec.by)
-      const imp = q.settings?.import
-      const stateFile = path.join(dir, 'quilt-export.json')
-      for (const ln of await store.lines(qid)) {
-        if (!matches(rec.lines, ln.name) || !ln.tip) continue
-        // What the remote has now; the export only ever adds to it.
-        const remoteRef = `refs/seam-remote/${ln.name}`
-        await run([...auth, '-C', dir, 'fetch', '--quiet', '--no-tags', rec.target, `+refs/heads/${ln.name}:${remoteRef}`], { env }).catch(() => run(['-C', dir, 'update-ref', '-d', remoteRef]).catch(() => {}))
-        const remoteSha = (await run(['-C', dir, 'rev-parse', '--verify', '-q', remoteRef]).catch(() => '')).trim() || null
-        const all = fs.existsSync(stateFile) ? JSON.parse(fs.readFileSync(stateFile, 'utf8')) : {}
-        const key = `${ln.name}→${ln.name}`
-        // An imported quilt exporting to its source continues git's history from the import's tip.
-        const base = imp && imp.source?.url === rec.target ? (imp.lines || []).find((l) => l.line === ln.name) : null
-        if (!all[key] && base?.tip_sha && remoteSha === base.tip_sha) {
-          await run(['-C', dir, 'update-ref', `refs/heads/${ln.name}`, base.tip_sha])
-          all[key] = { quilt: qid, line: ln.name, branch: ln.name, patch_no: base.patches, sha: base.tip_sha, version: null }
-          fs.writeFileSync(stateFile, JSON.stringify(all, null, 2) + '\n')
-        }
-        const r = await exportGit(client, { q: qid, dir, line: ln.name })
-        if (remoteSha && remoteSha !== r.sha) {
-          // Is the remote behind us (fine: fast-forward) or somewhere else (refused)?
-          const behind = await run(['-C', dir, 'merge-base', '--is-ancestor', remoteSha, `refs/heads/${ln.name}`]).then(() => true, () => false)
-          if (!behind) throw Object.assign(new Error(`the remote's ${ln.name} moved to ${remoteSha.slice(0, 12)}, which the export did not write: it never forces (bring the commit in with a square, or reset the remote's branch)`), { refused: true, line: ln.name, sha: remoteSha })
-        }
-        if (r.sha && r.sha !== remoteSha) await run([...auth, '-C', dir, 'push', '--quiet', rec.target, `refs/heads/${ln.name}:refs/heads/${ln.name}`], { env })
-        status.lines[ln.name] = { patch_no: r.patch_no, sha: r.sha }
-      }
-      if (rec.releases) await pushTags(qid, dir, rec, auth, env)
-      Object.assign(status, { state: 'ok', at: now(), attempts: 0 })
-      delete status.error; delete status.next_at
-      retryAt.delete(qid)
-    } catch (err) {
-      const attempts = (status.attempts || 0) + 1
-      if (err.refused) Object.assign(status, { state: 'refused', error: err.message, line: err.line, remote_sha: err.sha, at: now() })
-      else {
-        const wait = BACKOFF[Math.min(attempts - 1, BACKOFF.length - 1)]
-        Object.assign(status, { state: 'retrying', error: String(err.message || err), attempts, next_at: now() + wait, at: now() })
-        retryAt.set(qid, now() + wait)
-      }
-    } finally {
-      const cur = (await store.getQuilt(qid))?.settings?.export
-      if (cur && cur.target === rec.target) await save(qid, { ...cur, status }, rec.by.member_id, cur.status?.state !== status.state).catch(() => {})
-      await store.giveLease({ kind: 'line', quilt_id: qid, line: LEASE, holder }).catch(() => {})
-    }
-  }
-
-  /** Tags on exported commits: a release as an annotated tag with its notes, a tag as a plain one. Never moved. */
-  async function pushTags (qid, dir, rec, auth, env) {
-    const shaFile = path.join(dir, 'quilt-export-shas')
-    const shas = new Map()
-    if (fs.existsSync(shaFile)) for (const l of fs.readFileSync(shaFile, 'utf8').split('\n')) { const [line, n, sha] = l.split(' '); if (sha) shas.set(`${line}/${n}`, sha) }
-    const tags = await store.tags(qid)
-    for (const t of tags) {
-      const c = t.commit ? await store.getCommit(qid, t.commit) : null
-      const sha = c?.patch ? shas.get(`${c.patch.line}/${c.patch.patch_no}`) : null
-      if (!sha) continue
-      const have = (await run(['-C', dir, 'rev-parse', '--verify', '-q', `refs/tags/${t.name}`]).catch(() => '')).trim()
-      if (!have) {
-        if (t.release) {
-          // Deterministic: the tagger and date are the release's, not the clock's.
-          const at = Math.floor(Number(t.at || 0) / 1000)
-          await run(['-C', dir, '-c', 'user.name=Quilt', '-c', 'user.email=export@heyquilt.com', 'tag', '-a', t.name, sha, '-m', t.notes || t.name], { env: { GIT_COMMITTER_DATE: `${at} +0000` } })
-        } else await run(['-C', dir, 'tag', t.name, sha])
-      }
-    }
-    if (tags.length) await run([...auth, '-C', dir, 'push', '--quiet', rec.target, 'refs/tags/*:refs/tags/*'], { env })
-  }
-
-  function kick (qid) {
-    if (running.has(qid)) { again.add(qid); return running.get(qid) }
-    const p = pass(qid).catch(() => {}).finally(() => { running.delete(qid); if (again.delete(qid)) kick(qid) })
-    running.set(qid, p)
-    return p
-  }
-
-  /** After a write: export when the quilt exports. */
-  async function afterWrite (qid) {
-    const q = await store.getQuilt(qid)
-    if (q?.settings?.export?.enabled) kick(qid)
-  }
-
-  async function exportIdle (qid) { while (running.has(qid)) await running.get(qid) }
-  async function exportTick () { for (const [qid, at] of retryAt) if (now() >= at) kick(qid) }
-
-  return { setExport, exportStatus, exportIdle, exportTick, exportAfterWrite: afterWrite, exportPass: kick }
-}

package/src/quilts/export.js

@@ -1,81 +0,0 @@
-// The server half of the one-way git export (plans/quilt-source-control/14, Export): the
-// patches of a line in order, each with everything the exported git commit is made from, so a
-// driver (export-git.js) can write the same git objects from them on any machine. The git
-// fields are worked out here, from the commit record and the merge row only, so the same patch
-// always gives the same commit id: nothing from the clock, the driver or a member's current
-// profile gets in (14, Determinism).
-import { QuiltError } from './service.js'
-
-const EXPORT_VERSION = 1
-const COMMITTER = { name: 'Quilt', email: 'export@heyquilt.com' }
-
-/** A member slug safe for an email local part. */
-const slugOf = (id) => String(id || 'unknown').replace(/^[a-z]+:/, '').toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 64) || 'unknown'
-
-/**
- * The git identity of a commit's author, frozen in the commit record. A stub member from a git
- * import keeps the email git had (it was public there); everyone else gets the noreply address
- * of 14 (`<slug>@people|agents.noreply.heyquilt.com`), since no member has opted in to a
- * public email yet.
- */
-export function exportAuthor (author = {}) {
-  const id = String(author.member_id || '')
-  const kind = author.kind === 'agent' ? 'agent' : 'person'
-  const stub = id.startsWith('stub:') ? id.slice(5) : ''
-  const email = stub.includes('@') ? stub : `${slugOf(id)}@${kind === 'agent' ? 'agents' : 'people'}.noreply.heyquilt.com`
-  const name = String(author.name || stub || slugOf(id)).replace(/[<>\n]/g, '').trim() || slugOf(id)
-  return { name, email, slug: slugOf(id), kind, ...(author.tool ? { tool: author.tool } : {}), ...(author.model ? { model: author.model } : {}) }
-}
-
-/** The commit message with 14's trailers, in their fixed order. */
-export function exportMessage ({ commit, line, patch_no: patchNo, git_sha: gitSha }) {
-  const a = exportAuthor(commit.author)
-  const trailers = [
-    `Quilt-Commit: ${commit.id}`,
-    `Quilt-Square: ${commit.square_id}`,
-    `Quilt-Patch: ${line}/${patchNo}`,
-    `Quilt-Author: ${a.slug} (${[a.kind, a.tool, a.model].filter(Boolean).join(', ')})`,
-    ...(commit.on_behalf_of ? [`Quilt-On-Behalf-Of: ${slugOf(commit.on_behalf_of)}`] : []),
-    ...(commit.task_id ? [`Quilt-Task: ${commit.task_id}`] : []),
-    ...Object.keys(commit.stack || {}).sort().map((k) => `Quilt-Stack-${k}: ${commit.stack[k]}`),
-    ...(gitSha ? [`Quilt-Git-Sha: ${gitSha}`] : [])
-  ]
-  const body = String(commit.message || '').replace(/\s+$/, '')
-  return `${body || '(no message)'}\n\n${trailers.join('\n')}\n`
-}
-
-export function exportOps (svc) {
-  const { quiltFor, getCommit, store } = svc.internals
-
-  /**
-   * GET /quilts/:q/export/git: the patches on `line` after `after`, oldest first, at most
-   * `limit`: { version, line, patch_count, patches: [{ patch_no, commit, parent, author,
-   * committer, message, changes }] }. `changes` are the patch commit's changes against its
-   * first parent (the previous patch), which is what the exported commit changes too.
-   */
-  async function exportPatches (me, ref, { line = 'main', after = -1, limit = 200 } = {}) {
-    const q = await quiltFor(me, ref)
-    const ln = await store.getLine(q.id, line)
-    if (!ln) throw new QuiltError(404, 'not_found', `no line ${line}`)
-    const max = Math.max(1, Math.min(Number(limit) || 200, 1000))
-    const rows = await store.patches(q.id, line, { after: Number(after), limit: max, desc: false })
-    const patches = []
-    for (const row of rows) {
-      const c = await getCommit(q.id, row.commit)
-      const gitSha = store.gitShaOf ? await store.gitShaOf(q.id, c.id) : null
-      const a = exportAuthor(c.author)
-      patches.push({
-        patch_no: row.patch_no,
-        commit: c.id,
-        parent: c.parents[0] || null,
-        author: { name: a.name, email: a.email, at: Math.floor((c.authored_at || 0) / 1000) },
-        committer: { ...COMMITTER, at: Math.floor((row.at || 0) / 1000) },
-        message: exportMessage({ commit: c, line, patch_no: row.patch_no, git_sha: gitSha }),
-        changes: c.changes.map((ch) => (ch.op === 'delete' ? { path: ch.path, op: 'delete' } : { path: ch.path, op: 'put', blob: ch.blob, mode: ch.mode }))
-      })
-    }
-    return { version: EXPORT_VERSION, quilt: q.id, line, patch_count: ln.patch_count, patches }
-  }
-
-  return { exportPatches }
-}