heyquilt 0.3.122 → 0.3.138

package/src/quilts/routes.js

@@ -1,186 +0,0 @@
-// Seam's HTTP door (plans/quilt-source-control/04): routes any server can mount. The host says
-// who is calling: identify(req) → { member_id, kind, name, tool?, on_behalf_of? }, or throws its
-// own refusal (Quilt's accounts API builds it from its sign-in, src/api/server.js). Every caller
-// reaches the same operations as the seam CLI and seam_* tools.
-import { QuiltError } from './service.js'
-import { classify, tokenKey } from './limits.js'
-import { scopeAllows } from './oauth.js'
-
-const Q = '/v1/quilts/([^/]+)'
-const MAX_JSON = 96 * 1024 * 1024
-const MAX_PACK = 65 * 1024 * 1024
-
-const query = (req) => new URL(req.url, 'http://x').searchParams
-const list = (v) => (v ? String(v).split(',').map((s) => s.trim()).filter(Boolean) : [])
-
-export function quiltRoutes ({ quilts, identify }) {
-  if (!quilts) return []
-  if (typeof identify !== 'function') throw new Error('quiltRoutes needs identify(req): who is calling')
-
-  /** The caller as a quilt member: a quilt token (tokens.js, `Authorization: Bearer sqt_…`, a key for one quilt), else whoever the host says. */
-  async function me (req) {
-    const h = String(req.headers?.authorization || '')
-    if (h.startsWith('Bearer sqt_')) {
-      const t = await quilts.tokenCaller(h.slice(7).trim())
-      if (!t) throw new QuiltError(401, 'bad_token', 'this quilt token is unknown or revoked')
-      return t
-    }
-    return identify(req)
-  }
-
-  // An app's OAuth token (oauth.js) reaches /v1/me, the quilts list and the quilts its scopes name.
-  const READ_POSTS = /\/(have|blobs)$/
-  async function withinScope (m, req) {
-    if (!m.scopes) return
-    const p = new URL(req.url, 'http://x').pathname
-    if (req.method === 'GET' && (p === '/v1/me' || p === '/v1/quilts')) return
-    const q = new RegExp(`^${Q}(?:/|$)`).exec(p)
-    const need = req.method === 'GET' || READ_POSTS.test(p) ? 'read' : 'write'
-    if (q) {
-      let ref
-      try { ref = decodeURIComponent(q[1]) } catch { ref = q[1] }
-      const quilt = await quilts.internals.quiltFor(m, ref, 'read')
-      if (scopeAllows(m.scopes, quilt.id, need)) return
-    }
-    throw new QuiltError(403, 'insufficient_scope', `this app's access does not include ${need} here; ask for a wider scope`)
-  }
-  const inScope = (m, list) => m.scopes && !m.scopes.some((s) => s.startsWith('quilts:')) ? list.filter((q) => scopeAllows(m.scopes, q.id, 'read')) : list
-
-  // Every answer is the server's record; a refusal carries its wire code (12's WriteResult).
-  // Per-token rate limits (04, limits.js), when the quilts were made with them.
-  const limiter = quilts.rateLimiter || null
-  const run = (fn) => async (req, body, params) => {
-    try {
-      const m = await me(req)
-      await withinScope(m, req)
-      if (limiter) limiter.take(tokenKey(req, m), classify(req.method, req.url, body), m.kind === 'person')
-      return await fn(m, body, params, req)
-    } catch (err) {
-      if (err instanceof QuiltError) return [err.status, { ok: false, error: err.message, code: err.code, ...err.extra }]
-      if (err && /^(bad path|a path|.*: (put|bad|give)|commit message|changes must|too many files)/.test(String(err.message))) return [400, { ok: false, error: err.message, code: 'bad_request' }]
-      throw err
-    }
-  }
-  const big = { maxBody: MAX_JSON }
-  // Seam's device flow, before a computer has a sign-in: no caller, a refusal as an answer.
-  const open = (fn) => async (req, body) => {
-    try { return await fn(body) } catch (err) {
-      if (err instanceof QuiltError) return [err.status, { ok: false, error: err.message, code: err.code, ...err.extra }]
-      throw err
-    }
-  }
-
-  return [
-    ['POST', /^\/v1\/imports$/, run(async (m, b) => [202, await quilts.startImport(m, b)])],
-    ['GET', /^\/v1\/imports\/([^/]+)$/, run((m, b, [id]) => quilts.importStatus(m, decodeURIComponent(id)))],
-    ['POST', /^\/v1\/imports\/([^/]+)\/cutover$/, run((m, b, [id]) => quilts.cutover(m, decodeURIComponent(id), b || {}))],
-    // A poke carries the import's secret (Bearer sip_…) or a member's key.
-    ['POST', /^\/v1\/imports\/([^/]+)\/poke$/, async (req, body, [id]) => {
-      const h = String(req.headers?.authorization || '')
-      if (!h.startsWith('Bearer sip_')) return run(async (m) => [202, await quilts.pokeImport(m, decodeURIComponent(id))])(req, body, [id])
-      try { return [202, await quilts.pokeImport(null, decodeURIComponent(id), { secret: h.slice(7).trim() })] } catch (err) { if (err instanceof QuiltError) return [err.status, { ok: false, error: err.message, code: err.code }]; throw err }
-    }],
-    ['GET', /^\/v1\/me$/, run((m) => quilts.whoami(m))],
-    ['POST', /^\/v1\/me\/signout$/, run((m) => quilts.signout(m))],
-    ['POST', /^\/v1\/device\/start$/, open((b) => quilts.deviceStart(b))],
-    ['POST', /^\/v1\/device\/poll$/, open((b) => quilts.devicePoll(b))],
-    ['POST', /^\/v1\/device\/resume$/, open((b) => quilts.deviceResume(b))],
-    ['POST', /^\/v1\/device\/approve$/, run((m, b) => quilts.deviceApprove(m, b))],
-    ['GET', /^\/v1\/device\/([A-Za-z0-9-]+)$/, run((m, b, [code]) => quilts.deviceLinkInfo(m, code))],
-    ['GET', /^\/v1\/agents$/, run((m) => quilts.agents(m))],
-    ['POST', /^\/v1\/agents$/, run(async (m, b) => [201, await quilts.createAgent(m, b)])],
-    ['POST', /^\/v1\/agents\/([^/]+)\/key$/, run((m, b, [id]) => quilts.refreshAgentKey(m, decodeURIComponent(id)))],
-    ['DELETE', /^\/v1\/agents\/([^/]+)$/, run((m, b, [id]) => quilts.revokeAgent(m, decodeURIComponent(id)))],
-    ['GET', /^\/v1\/oauth\/clients$/, run((m) => quilts.oauthClients(m))],
-    ['POST', /^\/v1\/oauth\/clients$/, run(async (m, b) => [201, await quilts.createOAuthClient(m, b)])],
-    ['DELETE', /^\/v1\/oauth\/clients\/([^/]+)$/, run((m, b, [id]) => quilts.revokeOAuthClient(m, decodeURIComponent(id)))],
-    ['GET', /^\/v1\/oauth\/authorize$/, run((m, b, p, req) => quilts.oauthAuthorizeInfo(m, Object.fromEntries(query(req))))],
-    ['POST', /^\/v1\/oauth\/authorize$/, run((m, b) => quilts.oauthAuthorize(m, b))],
-    ['POST', /^\/oauth\/token$/, open((b) => quilts.oauthToken(b))],
-    ['POST', /^\/oauth\/revoke$/, open((b) => quilts.oauthRevoke(b))],
-    ['GET', /^\/v1\/quilts$/, run(async (m) => ({ quilts: inScope(m, await quilts.quilts(m)) }))],
-    ['POST', /^\/v1\/quilts$/, run(async (m, b) => [201, await quilts.createQuilt(m, b)])],
-    ['GET', new RegExp(`^${Q}$`), run((m, b, [q]) => quilts.quiltInfo(m, q))],
-    ['POST', new RegExp(`^${Q}/members$`), run((m, b, [q]) => quilts.addMember(m, q, b))],
-    ['GET', new RegExp(`^${Q}/tokens$`), run((m, b, [q]) => quilts.tokens(m, q))],
-    ['POST', new RegExp(`^${Q}/tokens$`), run(async (m, b, [q]) => [201, await quilts.createToken(m, q, b)])],
-    ['DELETE', new RegExp(`^${Q}/tokens/([^/]+)$`), run((m, b, [q, id]) => quilts.revokeToken(m, q, decodeURIComponent(id)))],
-
-    ['GET', new RegExp(`^${Q}/squares$`), run(async (m, b, [q], req) => { const s = query(req); return { squares: await quilts.squares(m, q, { state: s.get('state') || undefined, mine: s.get('mine') === '1', task: s.get('task') || undefined }) } })],
-    ['POST', new RegExp(`^${Q}/squares$`), run(async (m, b, [q]) => [201, await quilts.openSquare(m, q, b)])],
-    ['GET', new RegExp(`^${Q}/squares/([^/]+)$`), run((m, b, [q, s]) => quilts.square(m, q, s))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/commit$`), run(async (m, b, [q, s]) => [201, await quilts.commit(m, q, s, b)]), big],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/amend$`), run(async (m, b, [q, s]) => [201, await quilts.amend(m, q, s, b)]), big],
-    ['GET', new RegExp(`^${Q}/resolutions$`), run((m, b, [q], req) => quilts.resolutions(m, q, { path: query(req).get('path') || undefined }))],
-    ['DELETE', new RegExp(`^${Q}/resolutions/([^/]+)$`), run((m, b, [q, k]) => quilts.forgetResolution(m, q, decodeURIComponent(k)))],
-    ['GET', new RegExp(`^${Q}/claims$`), run((m, b, [q], req) => quilts.claims(m, q, { square: query(req).get('square') || undefined }))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/claims$`), run(async (m, b, [q, s]) => [201, await quilts.claim(m, q, s, b)])],
-    ['DELETE', new RegExp(`^${Q}/squares/([^/]+)/claims/(.+)$`), run((m, b, [q, s, c]) => quilts.unclaim(m, q, s, decodeURIComponent(c)))],
-    ['GET', new RegExp(`^${Q}/squares/([^/]+)/reviews$`), run((m, b, [q, s]) => quilts.reviews(m, q, s))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/reviews$`), run(async (m, b, [q, s]) => [201, await quilts.review(m, q, s, b)])],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/checks$`), run((m, b, [q, s]) => quilts.reportSquareCheck(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/checks/([^/]+)/rerun$`), run(async (m, b, [q, s, c]) => [201, await quilts.rerunCheck(m, q, { ...b, check: decodeURIComponent(c), square: s })])],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/checks/([^/]+)/rerun$`), run(async (m, b, [q, line, c]) => [201, await quilts.rerunCheck(m, q, { ...b, check: decodeURIComponent(c), line: decodeURIComponent(line) })])],
-    ['GET', new RegExp(`^${Q}/lines/([^/]+)/policy$`), run((m, b, [q, line]) => quilts.linePolicy(m, q, decodeURIComponent(line)))],
-    ['PUT', new RegExp(`^${Q}/lines/([^/]+)/policy$`), run((m, b, [q, line]) => quilts.setLinePolicy(m, q, decodeURIComponent(line), b))],
-    ['GET', new RegExp(`^${Q}/squares/([^/]+)/live$`), run((m, b, [q, s]) => quilts.live(m, q, s))],
-    ['PUT', new RegExp(`^${Q}/squares/([^/]+)/live$`), run((m, b, [q, s]) => quilts.setLive(m, q, s, b)), big],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/handoff$`), run((m, b, [q, s]) => quilts.handoff(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/abandon$`), run((m, b, [q, s]) => quilts.abandon(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/merged$`), run((m, b, [q, s]) => quilts.squareMerged(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/reopen$`), run((m, b, [q, s]) => quilts.reopen(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/merge$`), run(async (m, b, [q, s]) => { const r = await quilts.mergeSquare(m, q, s, b); return r.noop ? r : [201, r] })],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/fold$`), run((m, b, [q, s]) => quilts.fold(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/split$`), run(async (m, b, [q, s]) => [201, await quilts.split(m, q, s, b)])],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/rebase$`), run((m, b, [q, s]) => quilts.rebase(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/cherry-pick$`), run((m, b, [q, s]) => quilts.cherryPick(m, q, s, b))],
-    ['POST', new RegExp(`^${Q}/squares/([^/]+)/resolve$`), run((m, b, [q, s]) => quilts.resolve(m, q, s, b))],
-    ['GET', new RegExp(`^${Q}/lines$`), run((m, b, [q]) => quilts.lines(m, q))],
-    ['POST', new RegExp(`^${Q}/lines$`), run(async (m, b, [q]) => [201, await quilts.newLine(m, q, b)])],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/freeze$`), run((m, b, [q, line]) => quilts.freezeLine(m, q, line))],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/unfreeze$`), run((m, b, [q, line]) => quilts.unfreezeLine(m, q, line))],
-    ['PUT', new RegExp(`^${Q}/export$`), run((m, b, [q]) => quilts.setExport(m, q, b))],
-    ['GET', new RegExp(`^${Q}/export$`), run((m, b, [q]) => quilts.exportStatus(m, q))],
-    ['GET', new RegExp(`^${Q}/tags$`), run((m, b, [q]) => quilts.tags(m, q))],
-    ['POST', new RegExp(`^${Q}/tags$`), run(async (m, b, [q]) => [201, await quilts.createTag(m, q, b)])],
-    ['GET', new RegExp(`^${Q}/tags/(.+)$`), run((m, b, [q, name]) => quilts.getTag(m, q, decodeURIComponent(name)))],
-    ['GET', new RegExp(`^${Q}/releases$`), run((m, b, [q]) => quilts.releases(m, q))],
-    ['POST', new RegExp(`^${Q}/releases$`), run(async (m, b, [q]) => [201, await quilts.createRelease(m, q, b)])],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/merge$`), run(async (m, b, [q, line]) => { const r = await quilts.mergeIntoLine(m, q, line, b); return r.ok || r.dry_run ? [r.dry_run ? 200 : 201, r] : [422, { ...r, error: r.refused.detail, code: r.refused.code }] })],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/checks$`), run((m, b, [q, line]) => quilts.reportCheck(m, q, line, b))],
-    ['GET', new RegExp(`^${Q}/lines/([^/]+)/window$`), run((m, b, [q, line]) => quilts.lineWindow(m, q, line))],
-    ['GET', new RegExp(`^${Q}/lines/([^/]+)/patches$`), run((m, b, [q, line], req) => { const s = query(req); return quilts.linePatches(m, q, line, { before: s.get('before') || undefined, limit: s.get('limit') || 100 }) })],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/window$`), run((m, b, [q, line]) => quilts.setLineLimits(m, q, line, b))],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/checks$`), run((m, b, [q, line]) => quilts.reportCheck(m, q, line, b))],
-    ['GET', new RegExp(`^${Q}/lines/([^/]+)/window$`), run((m, b, [q, line]) => quilts.lineWindow(m, q, line))],
-    ['POST', new RegExp(`^${Q}/lines/([^/]+)/window$`), run((m, b, [q, line]) => quilts.setLineLimits(m, q, line, b))],
-    ['POST', new RegExp(`^${Q}/patches/(\\d+)/revert$`), run(async (m, b, [q, n]) => [201, await quilts.revert(m, q, { ...b, rev: `${b.line || 'main'}:${n}` })])],
-    ['POST', new RegExp(`^${Q}/revert$`), run(async (m, b, [q]) => [201, await quilts.revert(m, q, b)])],
-
-    ['GET', new RegExp(`^${Q}/checks$`), run((m, b, [q], req) => { const s = query(req); return quilts.checkRuns(m, q, { state: s.get('state') || undefined, name: s.get('name') || undefined, tier: s.get('tier') || undefined, line: s.get('line') || undefined, square: s.get('square') || undefined, limit: s.get('limit') || 100 }) })],
-    ['GET', new RegExp(`^${Q}/events$`), run((m, b, [q], req) => { const s = query(req); return quilts.events(m, q, { after: s.get('after') || 0, kinds: list(s.get('kinds')), limit: s.get('limit') || 100 }) })],
-    ['POST', new RegExp(`^${Q}/webhook$`), run((m, b, [q]) => quilts.subscribe(m, q, b))],
-    ['GET', new RegExp(`^${Q}/show/([^/]+)$`), run((m, b, [q, rev], req) => { const s = query(req); return quilts.show(m, q, rev, { format: s.get('format') || 'unified', paths: list(s.get('paths')) }) })],
-    ['GET', new RegExp(`^${Q}/export/git$`), run((m, b, [q], req) => { const s = query(req); return quilts.exportPatches(m, q, { line: s.get('line') || 'main', after: s.has('after') ? Number(s.get('after')) : -1, limit: Number(s.get('limit')) || 200 }) })],
-    ['GET', new RegExp(`^${Q}/log$`), run((m, b, [q], req) => { const s = query(req); return quilts.log(m, q, { rev: s.get('rev') || 'main', paths: list(s.get('paths')), limit: Number(s.get('limit')) || 20, follow: s.get('follow') === '1' || s.get('follow') === 'true', search: s.get('search') ?? undefined, show_signature: s.get('show_signature') === '1' || s.get('show_signature') === 'true' }) })],
-    ['POST', new RegExp(`^${Q}/commits/([^/]+)/signatures$`), run(async (m, b, [q, rev]) => [201, await quilts.sign(m, q, decodeURIComponent(rev), b)])],
-    ['GET', /^\/v1\/search$/, run((m, b, p, req) => { const s = query(req); const yes = (k) => s.get(k) === '1' || s.get(k) === 'true'; return quilts.search(m, { pattern: s.get('pattern'), rev: s.get('rev') || 'main', quilts: list(s.get('quilts')), paths: list(s.get('paths')), ignore_case: yes('ignore_case'), fixed: yes('fixed'), limit: Number(s.get('limit')) || 200 }) })],
-    ['GET', /^\/v1\/signing-keys$/, run((m, b, p, req) => quilts.signingKeys(m, null, { member: query(req).get('member') || undefined }))],
-    ['POST', /^\/v1\/signing-keys$/, run(async (m, b) => [201, await quilts.addKey(m, null, b)])],
-    ['DELETE', /^\/v1\/signing-keys\/([^/]+)$/, run((m, b, [key]) => quilts.removeKey(m, null, decodeURIComponent(key)))],
-    ['GET', new RegExp(`^${Q}/describe$`), run((m, b, [q], req) => quilts.describe(m, q, query(req).get('rev') || 'main'))],
-    ['GET', new RegExp(`^${Q}/merge-base$`), run((m, b, [q], req) => { const s = query(req); return quilts.mergeBaseOf(m, q, s.get('a'), s.get('b')) })],
-    ['GET', new RegExp(`^${Q}/grep$`), run((m, b, [q], req) => { const s = query(req); const yes = (k) => s.get(k) === '1' || s.get(k) === 'true'; return quilts.grep(m, q, { pattern: s.get('pattern'), rev: s.get('rev') || 'main', paths: list(s.get('paths')), ignore_case: yes('ignore_case'), fixed: yes('fixed'), limit: Number(s.get('limit')) || 200 }) })],
-    ['POST', new RegExp(`^${Q}/bisect$`), run((m, b, [q]) => quilts.bisect(m, q, b || {}))],
-    ['GET', new RegExp(`^${Q}/diff$`), run((m, b, [q], req) => { const s = query(req); return quilts.diff(m, q, { from: s.get('from') || undefined, to: s.get('to') || undefined, paths: list(s.get('paths')), format: s.get('format') || 'unified' }) })],
-    ['GET', new RegExp(`^${Q}/tree/([^/]+)$`), run((m, b, [q, rev], req) => quilts.tree(m, q, rev, { paths: list(query(req).get('paths')) }))],
-    ['GET', new RegExp(`^${Q}/blob/([^/]+)/(.+)$`), run((m, b, [q, rev, path], req) => quilts.cat(m, q, rev, path, { format: query(req).get('format') || 'diff' }))],
-    ['GET', new RegExp(`^${Q}/blame/([^/]+)/(.+)$`), run((m, b, [q, rev, path]) => quilts.blame(m, q, rev, path))],
-
-    ['POST', new RegExp(`^${Q}/have$`), run((m, b, [q]) => quilts.have(m, q, b.ids)), { maxBody: 2 * 1024 * 1024 }],
-    ['POST', new RegExp(`^${Q}/blobs$`), run((m, b, [q]) => quilts.blobs(m, q, b.ids)), { maxBody: 2 * 1024 * 1024 }],
-    ['POST', new RegExp(`^${Q}/packs$`), run(async (m, b, [q]) => [201, await quilts.uploadPack(m, q, b)]), { raw: true, maxBody: MAX_PACK }],
-    ['POST', new RegExp(`^${Q}/import/commits$`), run((m, b, [q]) => quilts.importBatch(m, q, b)), big],
-    ['POST', new RegExp(`^${Q}/import/known$`), run((m, b, [q]) => quilts.importKnown(m, q, b)), big]
-  ]
-}

package/src/quilts/runner.js

@@ -1,95 +0,0 @@
-// seam runner (plans/quilt-source-control/13 "Checks"): a ready-made check runner anyone starts on
-// their own machine. It polls the runs Seam asked its member to run (GET /checks?state=queued),
-// checks each run's commit out into a fresh block folder, runs the command there, and reports the
-// verdict (exit 0 green, anything else red) on the run's run_key with a link to the log. A run
-// Seam cancels (check.cancelled: a newer head superseded it) is stopped and not reported.
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import { spawn } from 'node:child_process'
-import { checkout } from './block.js'
-
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
-const safe = (key) => key.replace(/[^\w.-]+/g, '_').slice(0, 180)
-
-/** The log link a verdict carries: --log-url with {run_key} and {file}, else the log file's own address. */
-export function logLink (template, runKey, file) {
-  if (!template) return 'file://' + file
-  return template.replaceAll('{run_key}', encodeURIComponent(runKey)).replaceAll('{file}', encodeURIComponent(path.basename(file)))
-}
-
-/** The environment a run's command gets: what to run and, when Seam knows, which tests the change reaches. */
-export function runEnv (run, base = process.env) {
-  const a = run.affected || { confidence: 'all' }
-  return {
-    ...base,
-    SEAM_CHECK: run.name, SEAM_TIER: run.tier, SEAM_COMMIT: run.commit, SEAM_RUN_KEY: run.run_key,
-    SEAM_LINE: run.line || '', SEAM_SQUARE: run.square || '',
-    SEAM_AFFECTED_CONFIDENCE: a.confidence, SEAM_AFFECTED_TESTS: a.confidence === 'all' ? '' : (a.tests || []).join('\n')
-  }
-}
-
-/**
- * Runs checks for one quilt. { client, quilt, checks: ['ci'], run: 'npm test', dir (where block
- * folders and logs go), api, once (handle what is queued now, then return), intervalMs, logUrl,
- * say(line) }. Returns the runs it finished: [{ run_key, status | 'cancelled', url }].
- */
-export async function runChecks ({ client, quilt, checks, run: command, dir = path.join(os.tmpdir(), 'seam-runner'), api, once = false, intervalMs = 5000, logUrl, say = () => {}, keep = false }) {
-  if (!checks?.length) throw new Error('seam runner needs --check <name>[,<name>]')
-  if (!command) throw new Error('seam runner needs --run "<command>"')
-  const logs = path.join(dir, 'logs')
-  fs.mkdirSync(logs, { recursive: true })
-  const done = []
-  const seen = new Set()
-  for (;;) {
-    const queued = []
-    for (const name of checks) queued.push(...(await client.checkRuns(quilt, { state: 'queued', name })).runs)
-    const todo = queued.filter((r) => !seen.has(r.run_key)).sort((a, b) => a.at - b.at)
-    for (const r of todo) {
-      seen.add(r.run_key)
-      done.push(await runOne(r))
-    }
-    if (once) return done
-    await sleep(intervalMs)
-  }
-
-  async function runOne (r) {
-    const work = fs.mkdtempSync(path.join(dir, 'run-'))
-    const file = path.join(logs, safe(r.run_key) + '.log')
-    const url = logLink(logUrl, r.run_key, file)
-    say(`${r.name} (${r.tier}) on ${r.commit.slice(0, 12)}${r.square ? ` in ${r.square}` : ` at ${r.line}`}: running`)
-    const out = fs.openSync(file, 'w')
-    let status
-    try {
-      fs.writeSync(out, `seam runner: ${r.name} ${r.tier} ${r.commit} run_key ${r.run_key}\n$ ${command}\n`)
-      await checkout(client, { quilt, rev: r.commit, dir: work, api })
-      const child = spawn(command, { cwd: work, shell: true, env: runEnv(r), stdio: ['ignore', out, out], detached: process.platform !== 'win32' })
-      const exited = new Promise((resolve) => child.on('close', (code) => resolve(code)))
-      let cancelled = false
-      for (;;) {
-        const code = await Promise.race([exited, sleep(Math.min(intervalMs, 2000)).then(() => undefined)])
-        if (code !== undefined) { status = code === 0 ? 'green' : 'red'; break }
-        const gone = (await client.checkRuns(quilt, { state: 'cancelled', name: r.name, limit: 50 })).runs.some((x) => x.run_key === r.run_key)
-        if (gone && !cancelled) {
-          cancelled = true
-          try { process.kill(process.platform !== 'win32' ? -child.pid : child.pid, 'SIGTERM') } catch { child.kill('SIGTERM') }
-        }
-        if (cancelled) { await exited; status = 'cancelled'; break }
-      }
-    } catch (err) {
-      fs.writeSync(out, `\nseam runner: ${err.message}\n`)
-      status = 'red'
-    } finally {
-      fs.writeSync(out, `\nseam runner: ${status}\n`)
-      fs.closeSync(out)
-      if (!keep) fs.rmSync(work, { recursive: true, force: true })
-    }
-    if (status !== 'cancelled') {
-      const body = { check: r.name, status, run_key: r.run_key, url }
-      if (r.tier === 'pre_merge' && r.square) await client.reportSquareCheck(quilt, r.square, { ...body, head: r.commit })
-      else await client.reportCheck(quilt, r.line, body)
-    }
-    say(`${r.name} on ${r.commit.slice(0, 12)}: ${status} (log ${url})`)
-    return { run_key: r.run_key, status, url }
-  }
-}

package/src/quilts/server.js

@@ -1,144 +0,0 @@
-// Seam's own server: the routes in routes.js on an HTTP port, apart from any other product.
-// Who is calling comes from an identity service over HTTP (SEAM_IDENTITY_URL): Seam sends it the
-// caller's Authorization header and gets back the caller as a quilt member. Quilt's accounts API is
-// one such service (GET /v1/seam/me); any other host can be one by answering the same way.
-//
-//   seam serve            or   node src/quilts/server.js
-//   SEAM_AUTH_URL         Seam's own accounts: its Supabase project's address; Seam checks the
-//                         project's access tokens itself (SEAM_AUTH_JWT_SECRET for a shared secret)
-//   SEAM_IDENTITY_URL     an identity service, for every other token: GET with the caller's
-//                         Authorization → 200 { member_id, kind, name, tool?, on_behalf_of? }, or 401
-//                         (one of the two is required)
-//   SEAM_PORT / PORT      port (default 8080); SEAM_HOST (default 0.0.0.0)
-//   SEAM_STORE=supabase   rows and packs in Seam's own Supabase project: SEAM_SUPABASE_URL,
-//                         SEAM_SUPABASE_KEY (service role), SEAM_BUCKET (default quilt-packs);
-//                         otherwise a local store in SEAM_DATA (default ./seam-data)
-import http from 'node:http'
-import crypto from 'node:crypto'
-import { fileURLToPath } from 'node:url'
-import { quiltRoutes } from './routes.js'
-import { QuiltError } from './errors.js'
-import { quiltsFromEnv } from './setup.js'
-import { supabaseVerifier, seamIdentity } from './accounts.js'
-
-const MAX_BODY = 1024 * 1024
-const KINDS = new Set(['person', 'agent'])
-
-/**
- * identify(req) from an identity service over HTTP. A caller it accepts is kept for `ttlMs`
- * (keyed by a hash of the Authorization header, never the header itself); a refusal is not kept.
- */
-export function remoteIdentity ({ url, fetch = globalThis.fetch, ttlMs = 30_000, now = Date.now, max = 10_000, timeoutMs = 5000 }) {
-  if (!url) throw new Error('remoteIdentity needs the identity service url (SEAM_IDENTITY_URL)')
-  const cache = new Map() // hash → { member, until }
-  return async function identify (req) {
-    const auth = String(req.headers?.authorization || '')
-    if (!auth) throw new QuiltError(401, 'not_signed_in', 'sign in: send "Authorization: Bearer <token>"')
-    const key = crypto.createHash('sha256').update(auth).digest('hex')
-    const hit = cache.get(key)
-    if (hit && hit.until > now()) return hit.member
-    let res
-    try {
-      res = await fetch(url, { headers: { authorization: auth, accept: 'application/json' }, signal: AbortSignal.timeout(timeoutMs) })
-    } catch {
-      throw new QuiltError(503, 'identity_unavailable', 'Seam could not reach its sign-in service; try again')
-    }
-    const data = await res.json().catch(() => null)
-    if (res.status === 401 || res.status === 403) throw new QuiltError(401, 'not_signed_in', (data && data.error) || 'this sign-in is unknown or expired')
-    const m = res.ok && data && typeof data === 'object' ? data : null
-    if (!m || typeof m.member_id !== 'string' || !m.member_id || !KINDS.has(m.kind)) throw new QuiltError(503, 'identity_unavailable', 'Seam\'s sign-in service gave an answer it cannot use; try again')
-    const member = { member_id: m.member_id, kind: m.kind, name: String(m.name || m.kind) }
-    if (m.tool) member.tool = String(m.tool)
-    if (m.on_behalf_of) member.on_behalf_of = String(m.on_behalf_of)
-    if (cache.size >= max) cache.delete(cache.keys().next().value)
-    cache.set(key, { member, until: now() + ttlMs })
-    return member
-  }
-}
-
-function readBody (req, max, raw) {
-  return new Promise((resolve, reject) => {
-    let size = 0; const chunks = []
-    req.on('data', (c) => { size += c.length; if (size > max) { req.destroy(); reject(new QuiltError(413, 'too_large', 'too large')) } else chunks.push(c) })
-    req.on('end', () => {
-      const buf = Buffer.concat(chunks)
-      if (raw) return resolve(buf)
-      if (!buf.length) return resolve({})
-      if (/^application\/x-www-form-urlencoded/i.test(String(req.headers['content-type'] || ''))) return resolve(Object.fromEntries(new URLSearchParams(buf.toString('utf8'))))
-      let body
-      try { body = JSON.parse(buf.toString('utf8')) } catch { return reject(new QuiltError(400, 'bad_request', 'bad json')) }
-      resolve(body && typeof body === 'object' && !Array.isArray(body) ? body : {})
-    })
-    req.on('error', reject)
-  })
-}
-
-const decode = (s) => { try { return decodeURIComponent(s) } catch { throw new QuiltError(400, 'bad_request', 'bad path') } }
-
-/** Seam on a port: { server, url, close }. */
-export async function startSeamServer ({ quilts, identify, port = 0, host = '127.0.0.1', log = () => {} }) {
-  if (!quilts) throw new Error('startSeamServer needs quilts (createQuilts)')
-  const routes = quiltRoutes({ quilts, identify })
-  const server = http.createServer(async (req, res) => {
-    const send = (status, data) => {
-      res.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' })
-      res.end(JSON.stringify(data))
-    }
-    try {
-      const url = new URL(req.url, 'http://x')
-      if (req.method === 'GET' && (url.pathname === '/healthz' || url.pathname === '/')) return send(200, { ok: true, service: 'seam' })
-      const route = routes.find(([m, re]) => m === req.method && re.test(url.pathname))
-      if (!route) return send(404, { ok: false, error: 'not found', code: 'not_found' })
-      const opts = route[3] || {}
-      const body = opts.raw ? await readBody(req, opts.maxBody || MAX_BODY, true) : ['POST', 'PUT', 'PATCH'].includes(req.method) ? await readBody(req, opts.maxBody || MAX_BODY, false) : {}
-      const out = await route[2](req, body, url.pathname.match(route[1]).slice(1).map(decode))
-      if (Array.isArray(out)) send(out[0], out[1])
-      else send(200, out)
-    } catch (err) {
-      if (err instanceof QuiltError) return send(err.status, { ok: false, error: err.message, code: err.code, ...err.extra })
-      if (err && Number.isInteger(err.status) && err.status >= 400 && err.status < 500) return send(err.status, { ok: false, error: err.message })
-      log(`seam error: ${err?.stack || err?.message || err}`)
-      send(500, { ok: false, error: 'internal error', code: 'internal' })
-    }
-  })
-  await new Promise((resolve) => server.listen(port, host, resolve))
-  const at = server.address()
-  return { server, url: `http://${at.address.includes(':') ? `[${at.address}]` : at.address}:${at.port}`, close: () => new Promise((resolve) => server.close(resolve)) }
-}
-
-/** The SEAM_* settings as the store settings setup.js reads (its QUILT_SOURCE_* names still work). */
-export function storeEnv (env) {
-  const pick = (seam, old) => env[seam] ?? env[old]
-  const out = { QUILT_SOURCE: '1' }
-  const map = { QUILT_SOURCE_STORE: pick('SEAM_STORE', 'QUILT_SOURCE_STORE'), QUILT_SOURCE_SUPABASE_URL: pick('SEAM_SUPABASE_URL', 'QUILT_SOURCE_SUPABASE_URL'), QUILT_SOURCE_SUPABASE_KEY: pick('SEAM_SUPABASE_KEY', 'QUILT_SOURCE_SUPABASE_KEY'), QUILT_SOURCE_BUCKET: pick('SEAM_BUCKET', 'QUILT_SOURCE_BUCKET'), QUILT_SOURCE_DATA: env.SEAM_DATA ?? env.QUILT_SOURCE_DATA ?? './seam-data', SUPABASE_URL: env.SUPABASE_URL, SEAM_SITE_URL: env.SEAM_SITE_URL }
-  for (const [k, v] of Object.entries(map)) if (v !== undefined) out[k] = v
-  return out
-}
-
-/**
- * Who is calling, from the settings: Seam's own sign-in (SEAM_AUTH_URL, Seam's Supabase project,
- * with SEAM_AUTH_JWT_SECRET when it still signs with a shared secret) checked here, and/or an
- * identity service over HTTP (SEAM_IDENTITY_URL) for every other token.
- */
-export function identityFromEnv (env, quilts, { fetch = globalThis.fetch } = {}) {
-  const authUrl = env.SEAM_AUTH_URL || ''
-  const verify = authUrl ? supabaseVerifier({ authUrl, jwtSecret: env.SEAM_AUTH_JWT_SECRET || null, fetch }) : null
-  const fallback = env.SEAM_IDENTITY_URL ? remoteIdentity({ url: env.SEAM_IDENTITY_URL, fetch, ...(env.SEAM_IDENTITY_TTL_MS ? { ttlMs: Number(env.SEAM_IDENTITY_TTL_MS) } : {}) }) : null
-  if (!verify && !fallback) throw new Error('seam serve needs a sign-in: SEAM_AUTH_URL (Seam\'s own accounts, its Supabase project) and/or SEAM_IDENTITY_URL (an identity service, e.g. https://api.heyquilt.com/v1/seam/me)')
-  return seamIdentity({ quilts, verify, fallback })
-}
-
-/** `seam serve`: the settings from the environment, a port, and a log line. */
-export async function serveFromEnv (env = process.env, { log = console.log } = {}) {
-  if (!env.SEAM_AUTH_URL && !env.SEAM_IDENTITY_URL) identityFromEnv(env, null)
-  const quilts = await quiltsFromEnv(storeEnv(env), { log })
-  const identify = identityFromEnv(env, quilts)
-  const s = await startSeamServer({ quilts, identify, port: Number(env.SEAM_PORT || env.PORT || 8080), host: env.SEAM_HOST || '0.0.0.0', log })
-  const from = [env.SEAM_AUTH_URL && `Seam accounts (${new URL(env.SEAM_AUTH_URL).host})`, env.SEAM_IDENTITY_URL && new URL(env.SEAM_IDENTITY_URL).host].filter(Boolean).join(' and ')
-  log(`seam: listening on ${s.url}, sign-in from ${from}`)
-  return s
-}
-
-if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
-  serveFromEnv().catch((err) => { console.error(err.message || err); process.exit(1) })
-}