heyquilt 0.3.121 → 0.3.122

package/src/quilts/import-follow.js

@@ -0,0 +1,236 @@
+// The remote driver of a git import, and the follow (plans/quilt-source-control/14, "Who runs
+// it and where" and "Importing a live repository"; 16 step 1). POST /v1/imports makes a new
+// quilt and imports a git remote into it from a mirror in scratch, with the same code as the
+// local driver (import-git.js). With follow: true the import then keeps following the remote's
+// main and release/* every `interval` seconds (default 600, at least 60), or at once on a poke
+// (POST /v1/imports/:id/poke, with the import's secret, so a git hook or a cron job can send it
+// without a member's key). While it follows, those lines are frozen with reason import_follow:
+// merges into them are refused with the import's id, because git is the authority. A rewritten
+// ref stops the follow (state failed, error 'ref rewritten'). One import per quilt, never
+// reopened (D19): the import's id is its quilt's id.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { execFile } from 'node:child_process'
+import { QuiltError } from './service.js'
+import { buildPack } from './pack.js'
+import { importGit } from './import-git.js'
+
+export const POKE_PREFIX = 'sip_'
+const hash = (s) => crypto.createHash('sha256').update(String(s)).digest('hex')
+const followed = (name) => name === 'main' || name.startsWith('release/')
+const LEASE = ' import' // a line lease no line can hold: one pass at a time across servers
+
+/** Who may read a remote: a URL a server may fetch (never a path on the server unless allowLocal). */
+export function remoteUrl (raw, { allowLocal = false } = {}) {
+  const s = String(raw || '').trim()
+  if (/^(https?|ssh|git):\/\/[^\s]+$/i.test(s) || /^[\w.-]+@[\w.-]+:[^\s]+$/.test(s)) return s
+  if (allowLocal && (path.isAbsolute(s) || /^file:\/\//.test(s))) return s
+  throw new QuiltError(400, 'bad_request', 'url: a git remote (https://, ssh:// or user@host:path)')
+}
+
+export function run (args, { env = {}, cwd } = {}) {
+  return new Promise((resolve, reject) => {
+    execFile('git', args, { cwd, env: { ...process.env, GIT_NO_REPLACE_OBJECTS: '1', GIT_TERMINAL_PROMPT: '0', ...env }, maxBuffer: 64 << 20 }, (err, stdout, stderr) => {
+      if (err) return reject(new Error(String(stderr || err.message).trim().split('\n').pop()))
+      resolve(stdout)
+    })
+  })
+}
+
+/** The import's credential as git config: `user:token`, or a bare token as x-access-token's. */
+export function authArgs (secret) {
+  if (!secret) return []
+  const pair = secret.includes(':') ? secret : `x-access-token:${secret}`
+  return ['-c', `http.extraHeader=Authorization: Basic ${Buffer.from(pair).toString('base64')}`]
+}
+
+/** importGit's client, in this process: the same operations the HTTP routes call. */
+export function localClient (api, me) {
+  return {
+    quilt: (q) => api.quiltInfo(me, q),
+    createQuilt: (b) => api.createQuilt(me, b),
+    importKnown: (q, shas) => api.importKnown(me, q, { shas }),
+    lines: async (q) => (await api.lines(me, q)).lines,
+    tags: async (q) => (await api.tags(me, q)).tags,
+    createTag: (q, b) => api.createTag(me, q, b),
+    tree: (q, rev, paths) => api.tree(me, q, rev, { paths: paths || [''] }),
+    exportPatches: (q, o) => api.exportPatches(me, q, o),
+    blobs: (q, ids) => api.blobs(me, q, ids),
+    importCommits: (q, items, lines = []) => api.importBatch(me, q, JSON.parse(JSON.stringify({ items, lines }))),
+    async upload (q, objs) {
+      const missing = new Set()
+      for (let i = 0; i < objs.length; i += 10000) for (const id of (await api.have(me, q, objs.slice(i, i + 10000).map((o) => o.id))).missing) missing.add(id)
+      let batch = []; let size = 0
+      const flush = async () => { if (batch.length) await api.uploadPack(me, q, buildPack(batch).bytes); batch = []; size = 0 }
+      for (const o of objs.filter((x) => missing.has(x.id))) {
+        if (size + o.bytes.length > 48 * 1024 * 1024) await flush()
+        batch.push(o); size += o.bytes.length
+      }
+      await flush()
+    }
+  }
+}
+
+export function importFollowOps (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 = `follower:${process.pid}:${crypto.randomBytes(4).toString('hex')}`, tickMs = 30_000 } = {}) {
+  const { store, now, quiltFor, fromStore } = svc.internals
+  const running = new Map() // quilt id → the pass in flight
+  const lastPass = new Map() // quilt id → when its last pass started, on this server
+  let timer = null
+
+  const view = (rec) => { const { poke_hash: _, ...rest } = rec; return { ...rest, quilt_id: rec.id } }
+  const save = async (qid, rec, opts = {}) => { try { return await store.setImport({ quilt_id: qid, import: rec, actor: rec.by.member_id, at: now(), ...opts }) } catch (err) { throw fromStore(err) } }
+
+  async function record (qid) {
+    const q = await store.getQuilt(qid)
+    return q?.settings?.import || null
+  }
+
+  /** One follow pass: fetch the remote into the mirror, import what is new, freeze what is followed. */
+  async function pass (qid) {
+    const rec = await record(qid)
+    if (!rec || !['reading', 'following'].includes(rec.state)) return
+    const lease = await store.takeLease({ kind: 'line', quilt_id: qid, line: LEASE, holder, ttl_ms: 30 * 60_000, at: now() })
+    if (!lease.held) return
+    lastPass.set(qid, now())
+    const was = rec.state
+    try {
+      const mirror = path.join(scratch, qid)
+      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' }
+      if (!fs.existsSync(path.join(mirror, 'HEAD'))) {
+        fs.mkdirSync(scratch, { recursive: true })
+        fs.rmSync(mirror, { recursive: true, force: true })
+        await run([...auth, 'clone', '--quiet', '--mirror', rec.source.url, mirror], { env })
+      } else {
+        await run([...auth, '-C', mirror, 'fetch', '--quiet', '--prune', 'origin'], { env })
+      }
+      const r = await importGit(localClient(api, rec.by), { repo: mirror, slug: qid, follow: true })
+      const lines = []
+      for (const l of await store.lines(qid)) {
+        if (!followed(l.name)) continue
+        lines.push({ line: l.name, patches: l.patch_count, tip_sha: l.tip ? await store.gitShaOf(qid, l.tip) : null })
+      }
+      const next = { ...rec, lines, passes: (rec.passes || 0) + 1, last_pass_at: now(), commits: (rec.commits || 0) + r.commits }
+      delete next.error
+      if (r.rewritten.length) Object.assign(next, { state: 'failed', error: 'ref rewritten', rewritten: r.rewritten, finished_at: now() })
+      else if (!rec.follow) Object.assign(next, { state: 'done', finished_at: now() })
+      else next.state = 'following'
+      // While git leads, every followed line stays frozen (a stopped follow too: nobody merges
+      // over git's history until the owner decides).
+      await save(qid, next, { freeze: rec.follow ? true : null, lines: lines.map((l) => l.line), expect_state: was })
+    } catch (err) {
+      // A first pass that fails ends the import; a later one keeps following and says why.
+      const cur = await record(qid)
+      if (cur && cur.state === was) await save(qid, was === 'reading' ? { ...cur, state: 'failed', error: err.message, finished_at: now() } : { ...cur, error: err.message }, { expect_state: was }).catch(() => {})
+    } finally {
+      await store.giveLease({ kind: 'line', quilt_id: qid, line: LEASE, holder }).catch(() => {})
+    }
+  }
+
+  /** Runs a pass now, or joins the one in flight. */
+  function kick (qid) {
+    if (!running.has(qid)) running.set(qid, pass(qid).catch(() => {}).finally(() => running.delete(qid)))
+    return running.get(qid)
+  }
+
+  /** POST /v1/imports { url, slug, follow?, interval?, credential? } → the import, and its poke secret (shown once). */
+  async function startImport (me, { url, slug, follow = false, interval = 600, credential = null } = {}) {
+    const source = remoteUrl(url, { allowLocal })
+    const s = String(slug || '').toLowerCase()
+    let existing = null
+    try { existing = await quiltFor(me, s) } catch (err) { if (err.status !== 404) throw err }
+    if (existing) throw new QuiltError(409, existing.settings?.import ? 'import_closed' : 'slug_taken', existing.settings?.import ? `${s} already has its import (one import per quilt, never reopened)` : `you already have a quilt called ${s}`)
+    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 q = await api.createQuilt(me, { slug: s, name: s, import: true })
+    const poke = POKE_PREFIX + crypto.randomBytes(24).toString('base64url')
+    const rec = { id: q.id, source: { url: source }, ...(credential ? { credential: String(credential) } : {}), follow: !!follow, interval_s: Math.max(60, Math.floor(Number(interval) || 600)), state: 'reading', lines: [], passes: 0, commits: 0, poke_hash: hash(poke), by: { member_id: me.member_id, kind: me.kind || 'person', name: me.name || null }, started_at: now() }
+    // main is frozen before anything is imported, so nothing merges ahead of git.
+    await save(q.id, rec, { freeze: rec.follow ? true : null, lines: ['main'], expect_state: null })
+    kick(q.id)
+    return { ...view(rec), poke_secret: poke }
+  }
+
+  async function importStatus (me, id) {
+    const q = await quiltFor(me, id, 'read')
+    const rec = q.settings?.import
+    if (!rec) throw new QuiltError(404, 'not_found', 'this quilt has no import')
+    return view(rec)
+  }
+
+  /** POST /v1/imports/:id/poke: a member who can write, or anyone with the import's secret. */
+  async function pokeImport (me, id, { secret: given } = {}) {
+    let rec
+    if (given) {
+      const q = /^[0-9a-f-]{36}$/i.test(String(id)) ? await store.getQuilt(String(id)) : null
+      rec = q?.settings?.import
+      if (!rec || !rec.poke_hash || !crypto.timingSafeEqual(Buffer.from(rec.poke_hash), Buffer.from(hash(given)))) throw new QuiltError(401, 'bad_token', 'this poke secret is not the import\'s')
+    } else {
+      const q = await quiltFor(me, id, 'write')
+      rec = q.settings?.import
+      if (!rec) throw new QuiltError(404, 'not_found', 'this quilt has no import')
+    }
+    if (rec.state !== 'following') throw new QuiltError(409, 'not_following', `the import is ${rec.state}, not following`)
+    kick(rec.id)
+    return { ok: true, id: rec.id, queued: true }
+  }
+
+  /**
+   * POST /v1/imports/:id/cutover (admin; 14 step 3, 16 step 3): a last follow pass, the remote's
+   * tips checked against the imported tips, then in one go: the follow ended for good (state
+   * done, closed), the followed lines unfrozen, and the export of main to the source turned on.
+   * Refuses (remote_moved, or conflict when a line moved in Seam) and leaves the follow as it was.
+   */
+  async function cutover (me, id, { credential } = {}) {
+    const q = await quiltFor(me, id, 'admin')
+    if (!q.settings?.import) throw new QuiltError(404, 'not_found', 'this quilt has no import')
+    if (q.settings.import.state !== 'following') throw new QuiltError(409, 'not_following', `the import is ${q.settings.import.state}, not following`)
+    await (running.get(q.id) || Promise.resolve())
+    await kick(q.id)
+    const rec = await record(q.id)
+    if (rec.state !== 'following') throw new QuiltError(409, 'not_following', `the last follow pass ended the import: ${rec.error || rec.state}`)
+    const auth = authArgs(rec.credential ? await secret(rec.credential, { quilt_id: q.id }) : null)
+    const env = { GIT_ALLOW_PROTOCOL: allowLocal ? 'https:http:ssh:git:file' : 'https:http:ssh:git' }
+    const remote = new Map()
+    for (const row of (await run([...auth, 'ls-remote', rec.source.url, 'HEAD', 'refs/heads/release/*'], { env })).split('\n').filter(Boolean)) {
+      const [sha, ref] = row.split('\t')
+      remote.set(ref === 'HEAD' ? 'main' : ref.replace(/^refs\/heads\//, ''), sha)
+    }
+    const have = new Map(rec.lines.map((l) => [l.line, l.tip_sha]))
+    for (const [line, sha] of remote) if (have.get(line) !== sha) throw new QuiltError(409, 'remote_moved', `the remote's ${line} is ${sha.slice(0, 12)}, the import has ${have.has(line) ? String(have.get(line)).slice(0, 12) : 'no such line'}: stop pushes to the remote (branch protection), then cut over again`, { line, sha })
+    const tips = {}
+    for (const l of await store.lines(q.id)) if (followed(l.name)) tips[l.name] = l.tip
+    const done = { ...rec, state: 'done', closed: true, finished_at: now() }
+    delete done.error
+    await save(q.id, done, { freeze: false, lines: Object.keys(tips), expect_state: 'following', expect_tips: tips })
+    let exp
+    try {
+      exp = await api.setExport(me, q.id, { target: rec.source.url, credential: credential || rec.credential || null, lines: ['main'], releases: false })
+    } catch (err) {
+      // The export must be on before anything merges in Seam: put the follow back as it was.
+      await save(q.id, rec, { freeze: true, lines: Object.keys(tips), expect_state: 'done' }).catch(() => {})
+      throw err
+    }
+    return { ok: true, import: view(done), export: exp }
+  }
+
+  const follower = {
+    /** Every tick, a pass for each following import whose interval is up (on this server). */
+    start () {
+      if (timer) return
+      const tick = async () => {
+        let list = []
+        try { list = await store.importsFollowing() } catch { return }
+        for (const { quilt_id: qid, import: rec } of list) if (now() - (lastPass.get(qid) || 0) >= rec.interval_s * 1000) kick(qid)
+        api.exportTick?.().catch(() => {})
+      }
+      timer = setInterval(tick, tickMs)
+      timer.unref?.()
+      tick()
+    },
+    stop () { if (timer) clearInterval(timer); timer = null }
+  }
+
+  return { startImport, importStatus, pokeImport, cutover, importIdle: (id) => running.get(id) || Promise.resolve(), follower, importPass: kick }
+}

package/src/quilts/import-git.js

@@ -115,9 +115,10 @@ function gitTags (repo) {
  * where only the commits it does not have yet are added. Returns { quilt, slug, commits,
  * patches, lines, tags, report, validated? }.
  */
-export async function importGit (client, { repo, slug, batch = 100, log = () => {}, validate = false, limit = 0, onlyHead = false, fresh = false }) {
+export async function importGit (client, { repo, slug, batch = 100, log = () => {}, validate = false, limit = 0, onlyHead = false, fresh = false, follow = false }) {
   const head = git(repo, ['rev-parse', 'HEAD']).toString().trim()
-  const refs = onlyHead ? [{ name: 'main', sha: head, git: 'HEAD' }] : branches(repo, head)
+  // follow: only main and release/* (14: the lines an import follows).
+  const refs = onlyHead ? [{ name: 'main', sha: head, git: 'HEAD' }] : branches(repo, head).filter((r) => !follow || r.name === 'main' || r.name.startsWith('release/'))
   const all = git(repo, ['rev-list', ...new Set(refs.map((r) => r.sha))]).toString().split('\n').filter(Boolean)
   const cat = catFile(repo)
   const report = []
@@ -150,6 +151,7 @@ export async function importGit (client, { repo, slug, batch = 100, log = () =>
     let pending = []
     let commits = 0; let patches = 0
     const lines = []
+    const rewritten = [] // git branches whose line no longer follows them (a rewritten ref)
 
     const flush = async () => {
       if (!items.length && !newLines.length) return
@@ -211,6 +213,7 @@ export async function importGit (client, { repo, slug, batch = 100, log = () =>
         lineTips.set(ref.name, base)
       } else if ((lineTips.get(ref.name) || null) !== base) {
         // The line moved on in the quilt (merges since the import), or git rewrote the branch.
+        rewritten.push(ref.name)
         if (chain.length) report.push({ kind: 'branch', ref: ref.git, note: `line ${ref.name} no longer follows git's branch; its ${chain.length} new commits were left out` })
         return
       }
@@ -282,7 +285,7 @@ export async function importGit (client, { repo, slug, batch = 100, log = () =>
         validated++
       }
     }
-    return { quilt: quilt.id, slug: quilt.slug, again, commits, patches, lines, tags: tagged, report, ...(validate ? { validated } : {}), tip: lineTips.get('main') }
+    return { quilt: quilt.id, slug: quilt.slug, again, commits, patches, lines, tags: tagged, report, rewritten, ...(validate ? { validated } : {}), tip: lineTips.get('main') }
   } finally {
     cat.close()
   }

package/src/quilts/import.js

@@ -19,14 +19,44 @@ export function importLineName (raw) {
 }
 
 export function importOps (svc) {
-  const { store, now, quiltFor, getCommit, treeGrower, seal, snapshot, fromStore } = svc.internals
+  const { store, now, quiltFor, getCommit, treeGrower, seal, snapshot, fromStore, squareByRef, squareView } = svc.internals
 
   /** The quilt, if an import made it: only those take imported commits. */
   async function importQuilt (me, ref) {
     const q = await quiltFor(me, ref, 'admin')
     const quilt = await store.getQuilt(q.id)
+    if (quilt.settings?.import?.closed) throw new QuiltError(409, 'import_closed', 'this quilt\'s import is over (cut-over): git content comes in only as a square now')
     if (!quilt.settings?.importing) throw new QuiltError(409, 'bad_request', 'this quilt was not made by an import (seam import git makes a new quilt, or adds to one it made)')
-    return q
+    return { ...q, settings: quilt.settings }
+  }
+
+  /** Whether git still leads this quilt's line: an import follows it and has not cut over (14). */
+  const following = (settings, line) => {
+    const imp = settings?.import
+    return !!(imp && imp.follow && !imp.closed && imp.state !== 'done' && (line === 'main' || line.startsWith('release/')))
+  }
+
+  /**
+   * Squares during a follow (14, step 2): the open square on `line` whose base has the same tree
+   * as the imported commit's parent and whose head has the same tree as the commit. The oldest
+   * such square wins; one commit closes one square.
+   */
+  async function matchSquare (qid, line, parentRoot, root, taken) {
+    const open = (await store.squares(qid, { state: 'open' })).filter((s) => s.line === line && !s.import && s.head && !taken.has(s.id))
+    open.sort((x, y) => (x.opened_at || 0) - (y.opened_at || 0))
+    for (const s of open) {
+      if ((await snapshot(qid, s.base)) !== parentRoot) continue
+      if ((await snapshot(qid, s.head)) === root) return s
+    }
+    return null
+  }
+
+  /** Closes a square whose work reached git: merged, with how it was found and the imported commit. */
+  async function closeMerged (qid, sq, { line, patch_no: patchNo, commit, git_sha: gitSha, how }, actor) {
+    const merged = { line, patch_no: patchNo, commit, how, ...(gitSha ? { git_sha: gitSha } : {}) }
+    try {
+      return await store.setSquare({ square_id: sq.id, op: 'merged', expect: { state: 'open', head: sq.head || null }, actor, at: now(), patch: { state: 'merged', merged } })
+    } catch (err) { throw fromStore(err) }
   }
 
   /**
@@ -70,6 +100,7 @@ export function importOps (svc) {
       }
       const h = heads.get(ln)
       if ((p.c.parents[0] || null) !== (h.tip || null)) throw new QuiltError(422, 'bad_request', `patch ${p.id.slice(0, 12)} does not follow ${ln}'s tip`)
+      p.parentRoot = h.root
       const t = await grow(h.root, p.c.changes)
       h.root = t.root
       nodes.push(...t.objects)
@@ -89,6 +120,8 @@ export function importOps (svc) {
     }
     if (stubs.size) await store.addStubs({ quilt_id: q.id, stubs: [...stubs.values()], at: now() })
     let patches = 0; let commits = 0
+    const matched = []
+    const taken = new Set()
     for (const p of prepared) {
       if (p.done) continue
       const at = now()
@@ -102,9 +135,18 @@ export function importOps (svc) {
       if (p.it.kind === 'patch') {
         const ln = p.it.line || 'main'
         const cur = await store.getLine(q.id, ln)
-        await store.merge({ commit: record, line: ln, expected_tip: cur.tip, expect_head: null, snapshot_root: p.root, actor: me.member_id, at, payload, import: true })
+        const m = await store.merge({ commit: record, line: ln, expected_tip: cur.tip, expect_head: null, snapshot_root: p.root, actor: me.member_id, at, payload, import: true })
         await store.fillLinePaths({ quilt_id: q.id })
         patches++
+        // While git leads, a square whose work came in through git is closed as matched.
+        if (following(q.settings, ln)) {
+          const sq = await matchSquare(q.id, ln, p.parentRoot, p.root, taken)
+          if (sq) {
+            taken.add(sq.id)
+            await closeMerged(q.id, sq, { line: ln, patch_no: m.patch_no, commit: p.id, git_sha: p.it.git_sha, how: 'matched' }, me.member_id)
+            matched.push({ square: sq.id, commit: p.id, ...(p.it.git_sha ? { git_sha: p.it.git_sha } : {}) })
+          }
+        }
       } else {
         await store.importCommit({ commit: record, actor: me.member_id, at, payload })
       }
@@ -112,7 +154,27 @@ export function importOps (svc) {
       if (p.it.git_sha) await store.setGitSha({ quilt_id: q.id, sha: p.it.git_sha, commit_id: p.id })
     }
     const after = await store.getLine(q.id, 'main')
-    return { ok: true, commits, patches, tip: after.tip, patch_count: after.patch_count }
+    return { ok: true, commits, patches, tip: after.tip, patch_count: after.patch_count, ...(matched.length ? { matched } : {}) }
+  }
+
+  /**
+   * POST /squares/:id/merged { git_sha } (admin): closes an open square whose work a person put
+   * into git by hand and the follower could not match (14, step 2). merged.how = 'manual' and
+   * merged.commit is the imported commit of that sha, which keeps its own import square.
+   */
+  async function squareMerged (me, ref, sqRef, { git_sha: raw } = {}) {
+    const q = await quiltFor(me, ref, 'admin')
+    const quilt = await store.getQuilt(q.id)
+    if (!quilt.settings?.import) throw new QuiltError(409, 'bad_request', 'this quilt has no git import: a square merges with seam merge')
+    const sha = String(raw || '').toLowerCase()
+    if (!/^[0-9a-f]{40,64}$/.test(sha)) throw new QuiltError(400, 'bad_request', 'give git_sha: the git commit that holds the square\'s work')
+    const sq = await squareByRef(q.id, sqRef)
+    if (sq.state !== 'open') throw new QuiltError(409, 'square_state', `the square is ${sq.state}`)
+    const id = await store.gitSha(q.id, sha)
+    if (!id) throw new QuiltError(404, 'not_found', `git commit ${sha.slice(0, 12)} is not imported yet: poke the import (seam import poke) and try again`)
+    const c = await getCommit(q.id, id)
+    if (!c.patch) throw new QuiltError(422, 'bad_request', `git commit ${sha.slice(0, 12)} is not on a line's first-parent history`)
+    return squareView(await closeMerged(q.id, sq, { line: c.patch.line, patch_no: c.patch.patch_no, commit: id, git_sha: sha, how: 'manual' }, me.member_id))
   }
 
   /** POST /import/known { shas }: which git commits this quilt already has → { known: { sha: commit id } }. */
@@ -130,5 +192,5 @@ export function importOps (svc) {
     return { ok: true, tip: line.tip, patch_count: line.patch_count, tip_commit: line.tip ? (await getCommit(q.id, line.tip)).id : null }
   }
 
-  return { importBatch, importDone, importKnown }
+  return { importBatch, importDone, importKnown, squareMerged }
 }

package/src/quilts/index.js

@@ -14,33 +14,46 @@ import { lineOps } from './lines.js'
 import { tagOps } from './tags.js'
 import { claimOps } from './claims.js'
 import { reviewOps } from './reviews.js'
+import { checkOps } from './checks.js'
 import { resolutionOps } from './resolutions.js'
 import { liveOps } from './live.js'
 import { historyOps } from './history.js'
 import { signingOps } from './signing.js'
 import { tokenOps } from './tokens.js'
+import { accountOps } from './accounts.js'
+import { keyOps } from './keys.js'
+import { oauthOps } from './oauth.js'
 import { createLimiter } from './limits.js'
+import { importFollowOps } from './import-follow.js'
+import { exportRemoteOps } from './export-remote.js'
 
 // Writes after which the events job runs (in the background; GET /events runs it too).
-const WRITES = ['commit', 'amend', 'mergeIntoLine', 'rebase', 'cherryPick', 'revert', 'resolve', 'handoff', 'abandon', 'reopen', 'mergeSquare', 'fold', 'split', 'newLine', 'freezeLine', 'unfreezeLine', 'createTag', 'createRelease', 'reportCheck', 'review', 'setLinePolicy', 'reportSquareCheck']
+const WRITES = ['commit', 'amend', 'mergeIntoLine', 'rebase', 'cherryPick', 'revert', 'resolve', 'handoff', 'abandon', 'squareMerged', 'reopen', 'mergeSquare', 'fold', 'split', 'newLine', 'freezeLine', 'unfreezeLine', 'createTag', 'createRelease', 'reportCheck', 'review', 'setLinePolicy', 'reportSquareCheck', 'rerunCheck']
 
-export function createQuilts ({ store, objects, now = Date.now, events: eventOpts = {}, archive: archiveOpts = {}, mergeWindow: windowOpts = {}, rateLimits = {} }) {
+export function createQuilts ({ store, objects, now = Date.now, events: eventOpts = {}, archive: archiveOpts = {}, mergeWindow: windowOpts = {}, rateLimits = {}, importFollow = {}, siteUrl }) {
   const svc = createQuiltService({ store, objects, now })
   // The merge window (07): `mergeWindow: false` turns the check off, `{ max }` sets the default.
   const win = windowOps(svc, windowOpts || {})
   if (windowOpts !== false) svc.internals.mergeWindow = win.checkWindow
+  const checks = checkOps(svc)
+  svc.internals.checkRequests = checks.requestedBy
+  svc.internals.askForChecks = checks.askForMissing
+  svc.internals.noteVerdict = checks.noteVerdict
+  svc.internals.settleRuns = checks.settleRuns
+  svc.internals.applyCancels = checks.applyCancels
   const { guardReview, ...reviewApi } = reviewOps(svc)
   svc.internals.guardReview = guardReview
   const merges = mergeOps(svc)
   const { mergeInternals, ...mergeApi } = merges
   const squares = squareOps(svc, mergeInternals)
   const ev = eventOps(svc, squares, eventOpts)
+  svc.internals.pumpEvents = ev.pumpEvents
   // The log archiver (03): after each write, in the background, writes the segments that are due.
   const archiver = archiveOpts === false ? null : createArchiver({ store, objects, now, ...archiveOpts })
   const { checkWindow, ...windowApi } = win
   // Per-token rate limits (04), applied by the HTTP routes: `rateLimits: false` turns them off.
   const rateLimiter = rateLimits === false ? null : createLimiter({ now, ...rateLimits })
-  const api = { archiver, rateLimiter, ...windowApi, ...svc, ...mergeApi, ...blameOps(svc), ...importOps(svc), ...exportOps(svc), ...lineOps(svc), ...tagOps(svc), ...claimOps(svc), ...reviewApi, ...resolutionOps(svc), ...tokenOps(svc), ...liveOps(svc), ...historyOps(svc, { mergeBase: squares.mergeBase }), ...squares, ...ev }
+  const api = { archiver, rateLimiter, ...windowApi, ...svc, ...mergeApi, ...blameOps(svc), ...importOps(svc), ...exportOps(svc), ...lineOps(svc), ...tagOps(svc), ...claimOps(svc), ...reviewApi, checkRuns: checks.checkRuns, rerunCheck: checks.rerunCheck, ...resolutionOps(svc), ...tokenOps(svc), ...accountOps(svc), ...keyOps(svc, siteUrl ? { siteUrl } : {}), ...oauthOps(svc), ...liveOps(svc), ...historyOps(svc, { mergeBase: squares.mergeBase }), ...squares, ...ev }
   // Signed commits (signing.js): log { show_signature } checks each commit's signature.
   const { withSignatures, ...signApi } = signingOps(svc)
   Object.assign(api, signApi)
@@ -57,14 +70,23 @@ export function createQuilts ({ store, objects, now = Date.now, events: eventOpt
     const n = body.patch == null ? null : Number(body.patch)
     if (n != null && (!Number.isInteger(n) || n < 1)) throw new QuiltError(400, 'bad_request', 'patch: the number of the patch on the line the check failed at')
     const w = await report(me, ref, line, body)
-    if (n == null || body.status !== 'red') return w
+    if (n == null || body.status !== 'red' || w.advisory) return w
     return { ...w, revert: await auto.revertCulprit(me, ref, line, String(body.check).trim(), n) }
   }
+  // Imports from a git remote, and the follow (import-follow.js): follower.start() runs the passes.
+  Object.assign(api, importFollowOps(svc, api, importFollow || {}))
+  // Export to a git remote after each merge on its lines (export-remote.js), same scratch and secrets.
+  Object.assign(api, exportRemoteOps(svc, api, importFollow || {}))
   for (const name of WRITES) {
     const fn = api[name]
+    const after = (me, ref) => svc.internals.quiltFor(me, ref).then((q) => { archiver?.maybe(q.id); if (q.settings?.export?.enabled) api.exportPass(q.id); mergeApi.sweepMerges(q.id).catch(() => {}); return ev.pumpEvents(q.id) }).catch(() => {})
     api[name] = async (me, ref, ...rest) => {
-      const r = await fn(me, ref, ...rest)
-      svc.internals.quiltFor(me, ref).then((q) => { archiver?.maybe(q.id); mergeApi.sweepMerges(q.id).catch(() => {}); return ev.pumpEvents(q.id) }).catch(() => {})
+      let r
+      try { r = await fn(me, ref, ...rest) } catch (err) {
+        if (err?.status === 428) after(me, ref) // a refused merge may have asked runners for checks (checks.js)
+        throw err
+      }
+      after(me, ref)
       return r
     }
   }