heyquilt 0.3.121 → 0.3.138

package/src/quilts/store-rpc.js

@@ -1,79 +0,0 @@
-// The quilt store over Postgres functions (supabase/migrations/20261024100000_quilts.sql): each
-// method is one call of one function with one jsonb argument, so each is one transaction, and
-// the commit and merge transactions hold the quilt row lock in the database. `rpc(fn, p)` makes
-// the call: supabase-js in production (store-supabase.js), psql in the local tests.
-import { StoreError } from './store-memory.js'
-
-/** A refusal raised by quilt_refuse ('quilt:<code>:<json>') as the store's own error. */
-export function toStoreError (message) {
-  const m = String(message || '').match(/quilt:([a-z_]+):(\{.*\})/s)
-  if (!m) return null
-  let extra = {}
-  try { extra = JSON.parse(m[2]) } catch {}
-  const { message: msg, ...rest } = extra
-  return new StoreError(m[1], msg || m[1], rest)
-}
-
-export function createRpcQuiltStore (rpc) {
-  const call = async (fn, p) => {
-    try { return await rpc(fn, p) } catch (err) { throw toStoreError(err?.message) || err }
-  }
-  const writes = {
-    createQuilt: 'quilt_create_quilt', setMember: 'quilt_set_member', sealPack: 'quilt_seal_pack', stageFiles: 'quilt_stage_files',
-    openSquare: 'quilt_open_square', commit: 'quilt_commit', beginMerge: 'quilt_begin_merge', endMerge: 'quilt_end_merge', merge: 'quilt_merge',
-    importCommit: 'quilt_import_commit', setSnapshot: 'quilt_set_snapshot', setSquare: 'quilt_set_square', setGitSha: 'quilt_set_git_sha', remember: 'quilt_remember',
-    addEvents: 'quilt_add_events', setWebhook: 'quilt_set_webhook', takeLease: 'quilt_take_lease', openAndCommit: 'quilt_open_and_commit', giveLease: 'quilt_give_lease', addStubs: 'quilt_add_stubs', fillLinePaths: 'quilt_fill_line_paths', setConflicted: 'quilt_set_conflicted', setArchive: 'quilt_set_archive', setLineWindow: 'quilt_set_line_window', createLine: 'quilt_create_line', setLineFrozen: 'quilt_set_line_frozen', createTag: 'quilt_create_tag', setLive: 'quilt_set_live', createClaim: 'quilt_create_claim', deleteClaim: 'quilt_delete_claim', setResolution: 'quilt_set_resolution', deleteResolution: 'quilt_delete_resolution', addReview: 'quilt_add_review', setLineRule: 'quilt_set_line_rule', setSquareCheck: 'quilt_set_square_check', addSigningKey: 'quilt_add_signing_key', removeSigningKey: 'quilt_remove_signing_key', addSignature: 'quilt_add_signature', createToken: 'quilt_create_token', revokeToken: 'quilt_revoke_token'
-  }
-  const store = {}
-  for (const [name, fn] of Object.entries(writes)) store[name] = (args) => call(fn, args)
-  return Object.assign(store, {
-    getQuilt: (id) => call('quilt_get_quilt', { id }),
-    quiltBySlug: (owner, slug) => call('quilt_quilt_by_slug', { owner, slug }),
-    quiltsFor: (member) => call('quilt_quilts_for', { member }),
-    memberLevel: (q, member) => call('quilt_member_level', { quilt_id: q, member }),
-    members: (q) => call('quilt_members_of', { quilt_id: q }),
-    getLine: (q, name) => call('quilt_get_line', { quilt_id: q, name }),
-    lines: (q) => call('quilt_lines_of', { quilt_id: q }),
-    getTag: (q, name) => call('quilt_get_tag', { quilt_id: q, name }),
-    getLive: (q, sq) => call('quilt_get_live', { quilt_id: q, square_id: sq }),
-    tags: (q) => call('quilt_tags_of', { quilt_id: q }),
-    claims: (q) => call('quilt_claims_of', { quilt_id: q }),
-    tokens: (q) => call('quilt_tokens_of', { quilt_id: q }),
-    tokenByHash: (hash) => call('quilt_token_by_hash', { hash }),
-    signingKey: (id) => call('quilt_signing_key', { id }),
-    signingKeys: (member) => call('quilt_signing_keys_of', { member }),
-    signaturesOf: (q, commits) => call('quilt_signatures_of', { quilt_id: q, commits }),
-    reviews: (q, sq) => call('quilt_reviews_of', { quilt_id: q, square_id: sq }),
-    squareChecks: (q, sq) => call('quilt_square_checks_of', { quilt_id: q, square_id: sq }),
-    lineRules: (q) => call('quilt_line_rules_of', { quilt_id: q }),
-    resolution: (q, key) => call('quilt_resolution', { quilt_id: q, key }),
-    resolutions: (q) => call('quilt_resolutions_of', { quilt_id: q }),
-    getSquare: (id) => call('quilt_get_square', { id }),
-    squares: (q, { state, holder, task } = {}) => call('quilt_squares_of', { quilt_id: q, state, holder, task }),
-    getCommit: (q, id) => call('quilt_get_commit', { quilt_id: q, id }),
-    commitAtSeq: (q, seq) => call('quilt_commit_at_seq', { quilt_id: q, seq }),
-    squaresByTail: (q, tail) => call('quilt_squares_by_tail', { quilt_id: q, tail }),
-    resolvePrefix: (q, prefix) => call('quilt_resolve_prefix', { quilt_id: q, prefix }),
-    squareCommits: (q, squareId) => call('quilt_square_commits', { quilt_id: q, square_id: squareId }),
-    getBlob: (q, id) => call('quilt_get_blob', { quilt_id: q, id }),
-    hasBlobs: (q, ids) => call('quilt_has_blobs', { quilt_id: q, ids }),
-    hasObjects: (q, ids) => call('quilt_has_objects', { quilt_id: q, ids }),
-    getObject: (q, id) => call('quilt_get_object', { quilt_id: q, id }),
-    patch: (q, line, n) => call('quilt_patch', { quilt_id: q, line, patch_no: n }),
-    patches: (q, line, { after = 0, before, limit = 50, desc = true } = {}) => call('quilt_patches', { quilt_id: q, line, after, before: Number.isFinite(before) ? before : undefined, limit, desc }),
-    linePatchesView: (q, line, { before, limit = 100 } = {}) => call('quilt_line_patches_view', { quilt_id: q, line, before: Number.isFinite(before) ? before : undefined, limit }),
-    eventCursor: async (q) => Number(await call('quilt_event_cursor', { quilt_id: q })) || 0,
-    eventsFor: (q, member, { after = 0, kinds, limit = 100 } = {}) => call('quilt_events_for', { quilt_id: q, member, after, kinds, limit }),
-    webhook: (q, member) => call('quilt_webhook', { quilt_id: q, member }),
-    logRows: (q, { after = 0, limit = 100, kinds } = {}) => call('quilt_log_rows', { quilt_id: q, after, limit, kinds }),
-    squarePathCommits: (q, squareId, path, { upTo, limit = 1000 } = {}) => call('quilt_square_path_commits', { quilt_id: q, square_id: squareId, path, up_to: Number.isFinite(upTo) ? upTo : undefined, limit }),
-    linePaths: (q, line, path, { upTo, limit = 1000 } = {}) => call('quilt_line_paths_of', { quilt_id: q, line, path, up_to: Number.isFinite(upTo) ? upTo : undefined, limit }),
-    recall: (key, maxAgeMs, now) => call('quilt_recall', { key, max_age_ms: maxAgeMs, now }),
-    stubMembers: (q) => call('quilt_stub_members', { quilt_id: q }),
-    gitSha: (q, sha) => call('quilt_git_sha', { quilt_id: q, sha }),
-    gitShas: async (q, shas) => (await call('quilt_git_shas', { quilt_id: q, shas })) || {},
-    gitShaPrefix: (q, prefix) => call('quilt_git_sha_prefix', { quilt_id: q, prefix }),
-    gitShaOf: (q, id) => call('quilt_git_sha_of', { quilt_id: q, commit_id: id }),
-    close () {}
-  })
-}

package/src/quilts/store-supabase.js

@@ -1,13 +0,0 @@
-// The quilt store in the accounts Supabase project: the migration's functions over supabase-js
-// with the service role (store-rpc.js has the mapping; only the API holds this key).
-import { createClient } from '@supabase/supabase-js'
-import { createRpcQuiltStore } from './store-rpc.js'
-
-export function createSupabaseQuiltStore ({ url, serviceKey }) {
-  const db = createClient(url, serviceKey, { auth: { persistSession: false, autoRefreshToken: false } })
-  return createRpcQuiltStore(async (fn, p) => {
-    const { data, error } = await db.rpc(fn, { p })
-    if (error) throw new Error(error.message)
-    return data
-  })
-}

package/src/quilts/tags.js

@@ -1,64 +0,0 @@
-// Tags and releases (plans/quilt-source-control/06): a tag is a name on one commit (a patch or any
-// revision) that never moves and is never deleted; a release is a tag with notes. tag:<name> is a
-// revision everywhere. Anyone who can write tags; the tag records who and when.
-import { QuiltError } from './service.js'
-
-const NAME = /^[A-Za-z0-9._-][A-Za-z0-9._/-]{0,99}$/
-
-/** A tag name: letters, digits, dots, dashes, underscores and slashes, no `..`, no trailing slash. */
-export function tagName (raw) {
-  const s = String(raw || '').trim()
-  if (!NAME.test(s) || s.includes('..') || s.includes('//') || s.endsWith('/')) throw new QuiltError(400, 'bad_request', 'a tag name is letters, digits, dots, dashes, underscores and slashes (up to 100)')
-  return s
-}
-
-export function tagOps (svc) {
-  const { store, now, quiltFor, resolve, fromStore, getCommit } = svc.internals
-
-  async function view (q, row) {
-    const c = row.commit ? await store.getCommit(q, row.commit) : null
-    return { name: row.name, commit: row.commit, short: row.commit ? row.commit.slice(0, 12) : null, patch: c?.patch || null, release: !!row.release, notes: row.notes ?? null, by: row.actor, at: row.at }
-  }
-
-  async function make (me, ref, { name, rev, notes } = {}, release) {
-    const q = await quiltFor(me, ref, 'write')
-    const n = tagName(name)
-    if (notes != null && String(notes).length > 20000) throw new QuiltError(400, 'bad_request', 'release notes are up to 20000 characters')
-    const commit = await resolve(q.id, rev || 'main')
-    if (!commit) throw new QuiltError(400, 'bad_request', `${rev || 'main'} has no commits to tag`)
-    await getCommit(q.id, commit)
-    try {
-      const row = await store.createTag({ quilt_id: q.id, name: n, commit, release, notes: release ? String(notes ?? '') : null, actor: me.member_id, at: now() })
-      return view(q.id, row)
-    } catch (err) { throw fromStore(err) }
-  }
-
-  /** GET /tags: every tag, by name. */
-  async function tags (me, ref) {
-    const q = await quiltFor(me, ref, 'read')
-    const rows = (await store.tags(q.id)).sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
-    return { tags: await Promise.all(rows.map((r) => view(q.id, r))) }
-  }
-
-  /** GET /releases: the tags that are releases, newest first. */
-  async function releases (me, ref) {
-    const q = await quiltFor(me, ref, 'read')
-    const rows = (await store.tags(q.id)).filter((r) => r.release).sort((a, b) => (b.seq || 0) - (a.seq || 0))
-    return { releases: await Promise.all(rows.map((r) => view(q.id, r))) }
-  }
-
-  async function getTag (me, ref, name) {
-    const q = await quiltFor(me, ref, 'read')
-    const row = await store.getTag(q.id, String(name))
-    if (!row) throw new QuiltError(404, 'not_found', `no tag ${name}`)
-    return view(q.id, row)
-  }
-
-  return {
-    tags,
-    releases,
-    getTag,
-    createTag: (me, ref, body) => make(me, ref, body, false),
-    createRelease: (me, ref, body) => make(me, ref, body, true)
-  }
-}

package/src/quilts/textdiff.js

@@ -1,96 +0,0 @@
-// Line diffs for quilts: unified text for `diff` and `show`, and the line mapping `blame` walks.
-
-import { xdiff } from './xdiff.js'
-
-const MAX_TEXT = 8 * 1024 * 1024
-
-/** Whether bytes read as text: valid UTF-8, no NUL, at most 8 MiB (07's max_merge_text_bytes). */
-export function isText (buf) {
-  if (!buf) return true
-  if (buf.length > MAX_TEXT || buf.includes(0)) return false
-  try { new TextDecoder('utf-8', { fatal: true }).decode(buf); return true } catch { return false }
-}
-
-/** A text's lines, split on \n, without the empty string after a final newline. */
-export function splitLines (s) {
-  if (!s) return []
-  const ls = s.split('\n')
-  if (ls[ls.length - 1] === '') ls.pop()
-  return ls
-}
-
-/** Lines back to bytes, each ended by \n (what `hunks` diffs). */
-function linesBuf (ls) { return Buffer.from(ls.length ? ls.join('\n') + '\n' : '', 'utf8') }
-
-/**
- * The hunks between two line lists: [{ a: [start, len], b: [start, len] }], chosen the way git's
- * xdiff chooses them (its Myers variant, record cleanup, and sliding with the indent heuristic),
- * so `diff`, `show` and `blame` agree with git's.
- */
-export function hunks (a, b) {
-  return xdiff(linesBuf(a), linesBuf(b))
-}
-
-/** +added −removed counts between two texts. */
-export function lineStat (a, b) {
-  let add = 0; let del = 0
-  for (const h of hunks(splitLines(a), splitLines(b))) { del += h.a[1]; add += h.b[1] }
-  return { add, del }
-}
-
-/**
- * A unified diff of one file (git's format, 3 lines of context). `before`/`after` are strings,
- * or null when the file is added or deleted.
- */
-export function unified (path, before, after, { context = 3, fromPath = path } = {}) {
-  const a = splitLines(before ?? '')
-  const b = splitLines(after ?? '')
-  const head = [`--- ${before == null ? '/dev/null' : `a/${fromPath}`}`, `+++ ${after == null ? '/dev/null' : `b/${path}`}`]
-  const hs = hunks(a, b)
-  if (!hs.length) return ''
-  const out = [...head]
-  // Group hunks whose context overlaps.
-  let i = 0
-  while (i < hs.length) {
-    let j = i
-    while (j + 1 < hs.length && hs[j + 1].a[0] - (hs[j].a[0] + hs[j].a[1]) <= context * 2) j++
-    const aStart = Math.max(0, hs[i].a[0] - context)
-    const aEnd = Math.min(a.length, hs[j].a[0] + hs[j].a[1] + context)
-    const bStart = Math.max(0, hs[i].b[0] - context)
-    const bEnd = Math.min(b.length, hs[j].b[0] + hs[j].b[1] + context)
-    const body = []
-    let ap = aStart
-    for (let k = i; k <= j; k++) {
-      const h = hs[k]
-      while (ap < h.a[0]) body.push(' ' + a[ap++])
-      for (let x = 0; x < h.a[1]; x++) body.push('-' + a[h.a[0] + x])
-      for (let x = 0; x < h.b[1]; x++) body.push('+' + b[h.b[0] + x])
-      ap = h.a[0] + h.a[1]
-    }
-    while (ap < aEnd) body.push(' ' + a[ap++])
-    const range = (s, n) => `${n === 0 ? s : s + 1}${n === 1 ? '' : `,${n}`}`
-    out.push(`@@ -${range(aStart, aEnd - aStart)} +${range(bStart, bEnd - bStart)} @@`, ...body)
-    i = j + 1
-  }
-  return out.join('\n') + '\n'
-}
-
-/**
- * For each line of `b`, its line in `a` when the diff kept it, else -1 (it was added or
- * changed in b). What blame follows from a commit back to its parent. Given Buffers (the files'
- * bytes) it diffs exactly as `git blame` does, final newline and common-tail trim included.
- */
-export function lineMap (a, b) {
-  const bytes = Buffer.isBuffer(a)
-  const hs = bytes ? xdiff(a, b, { trimTail: true }) : hunks(a, b)
-  const n = bytes ? splitLines(b.toString('utf8')).length : b.length
-  const map = new Array(n).fill(-1)
-  let ai = 0; let bi = 0
-  for (const h of hs) {
-    while (bi < h.b[0]) map[bi++] = ai++
-    ai = h.a[0] + h.a[1]
-    bi = h.b[0] + h.b[1]
-  }
-  while (bi < n) map[bi++] = ai++
-  return map
-}

package/src/quilts/tokens.js

@@ -1,66 +0,0 @@
-// Quilt tokens: a key for one quilt, read or write, for a CI job or a script. An admin makes one
-// (seam token new ci --level write), the secret (sqt_…) is shown once, and only its sha256 is kept.
-// A token is a member of its one quilt as token:<id> (so every read and write checks it like any
-// other member) and calls as an agent named after the token. Revoking it ends its membership.
-import crypto from 'node:crypto'
-import { QuiltError } from './errors.js'
-import { uuidv7 } from './ids.js'
-
-export const TOKEN_PREFIX = 'sqt_'
-export const MAX_TOKENS = 50
-const SECRET = /^sqt_[A-Za-z0-9_-]{43}$/
-
-export const hashToken = (secret) => crypto.createHash('sha256').update(String(secret)).digest('hex')
-export const isQuiltToken = (s) => SECRET.test(String(s || ''))
-
-export function tokenOps (svc) {
-  const { store, now, quiltFor, fromStore } = svc.internals
-  const view = (r) => ({ id: r.id, name: r.name, level: r.level, created_by: r.created_by, created_at: r.created_at, ...(r.revoked_at ? { revoked_at: r.revoked_at } : {}) })
-
-  /** POST /tokens { name, level? }: makes a token (admin). The secret is in this answer only. */
-  async function createToken (me, ref, { name, level = 'read' } = {}) {
-    const q = await quiltFor(me, ref, 'admin')
-    const n = String(name || '').trim()
-    if (!n || n.length > 100) throw new QuiltError(400, 'bad_request', 'name: what the token is for, up to 100 characters (e.g. ci)')
-    if (!['read', 'write'].includes(level)) throw new QuiltError(400, 'bad_request', 'level is read or write')
-    const live = (await store.tokens(q.id)).filter((r) => !r.revoked_at)
-    if (live.length >= MAX_TOKENS) throw new QuiltError(409, 'too_many_tokens', `up to ${MAX_TOKENS} tokens per quilt; revoke one first`)
-    const secret = TOKEN_PREFIX + crypto.randomBytes(32).toString('base64url')
-    try {
-      const row = await store.createToken({ id: uuidv7(now()), quilt_id: q.id, name: n, level, hash: hashToken(secret), created_by: me.member_id, created_at: now() })
-      return { ...view(row), quilt: q.slug, member_id: `token:${row.id}`, token: secret }
-    } catch (err) { throw fromStore(err) }
-  }
-
-  /** GET /tokens: the quilt's tokens, revoked ones too (admin). Never their secrets. */
-  async function tokens (me, ref) {
-    const q = await quiltFor(me, ref, 'admin')
-    return { quilt: q.slug, tokens: (await store.tokens(q.id)).map(view) }
-  }
-
-  /** DELETE /tokens/:id: revokes a token (by id, or by name when one live token has it). */
-  async function revokeToken (me, ref, which) {
-    const q = await quiltFor(me, ref, 'admin')
-    const all = await store.tokens(q.id)
-    const w = String(which || '')
-    let row = all.find((r) => r.id === w)
-    if (!row) {
-      const named = all.filter((r) => r.name === w && !r.revoked_at)
-      if (named.length > 1) throw new QuiltError(400, 'bad_request', `${named.length} tokens are named ${w}; revoke one by its id`)
-      row = named[0]
-    }
-    if (!row) throw new QuiltError(404, 'not_found', `no token ${w}`)
-    if (row.revoked_at) return view(row)
-    try { return view(await store.revokeToken({ quilt_id: q.id, id: row.id, actor: me.member_id, at: now() })) } catch (err) { throw fromStore(err) }
-  }
-
-  /** The caller a token secret stands for, or null when it is unknown or revoked. */
-  async function tokenCaller (secret) {
-    if (!isQuiltToken(secret)) return null
-    const row = await store.tokenByHash(hashToken(secret))
-    if (!row || row.revoked_at) return null
-    return { member_id: `token:${row.id}`, kind: 'agent', name: row.name, tool: 'token', token: { id: row.id, quilt_id: row.quilt_id, level: row.level } }
-  }
-
-  return { createToken, tokens, revokeToken, tokenCaller }
-}