Ben Stull
ca8ba69acb
Replaces the v0.3.0 / v0.7.0 allowed_emails admission gate with an admin-grant flow (roadmap item #6, SPEC §6.1 / §6.2 / §14.1 / §17). Any valid email can sign in via OTC; a fresh user lands in permission_state='pending' with a captured first/last/why profile, and an admin grant flips them to 'granted' before write endpoints accept them. Grandfathered users pass through the migration with the column default 'granted' so existing contributors are unaffected. The allowed_emails table stays in the schema as a fast-path bypass pending v0.9.0's admin user-management page (item #7). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
682 lines
22 KiB
JavaScript
682 lines
22 KiB
JavaScript
// api.js — every backend call lives here.
|
|
//
|
|
// All write requests pass {credentials: 'include'} implicitly because
|
|
// the dev proxy and the production deploy serve the API from the same
|
|
// origin as the frontend. If you split origins later, change here.
|
|
|
|
async function jsonOrThrow(res) {
|
|
if (!res.ok) {
|
|
let detail = ''
|
|
try {
|
|
const body = await res.json()
|
|
detail = body.detail || JSON.stringify(body)
|
|
} catch {
|
|
detail = await res.text()
|
|
}
|
|
const error = new Error(detail || `HTTP ${res.status}`)
|
|
error.status = res.status
|
|
throw error
|
|
}
|
|
return res.json()
|
|
}
|
|
|
|
export async function getMe() {
|
|
const res = await fetch('/api/auth/me')
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
// ── v0.7.0: email + one-time-code sign-in (§6.2) ─────────────────────────
|
|
//
|
|
// The legacy /auth/login → /auth/callback OAuth flow remains during the
|
|
// migration — the new UI just no longer points at it primarily. These
|
|
// two helpers drive the Login.jsx surface.
|
|
|
|
export async function requestOtc(email) {
|
|
const res = await fetch('/auth/otc/request', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ email }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function verifyOtc(email, code) {
|
|
const res = await fetch('/auth/otc/verify', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ email, code }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
// ── v0.8.0: open beta-access request flow (§6.1 / §14.1) ─────────────────
|
|
//
|
|
// On the first OTC sign-in, the user lands in `permission_state='pending'`
|
|
// and `/api/auth/me` reports `needs_profile=true`. The Login.jsx surface
|
|
// then prompts for first/last/why and POSTs them here. After this lands,
|
|
// the user sees the /beta-pending page until an admin grants access.
|
|
|
|
export async function submitBetaRequest({ first_name, last_name, beta_request_reason }) {
|
|
const res = await fetch('/api/auth/me/beta-request', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ first_name, last_name, beta_request_reason }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function listRFCs() {
|
|
return jsonOrThrow(await fetch('/api/rfcs'))
|
|
}
|
|
|
|
export async function getRFC(slug) {
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}`))
|
|
}
|
|
|
|
export async function listProposals() {
|
|
return jsonOrThrow(await fetch('/api/proposals'))
|
|
}
|
|
|
|
export async function getProposal(prNumber) {
|
|
return jsonOrThrow(await fetch(`/api/proposals/${prNumber}`))
|
|
}
|
|
|
|
export async function proposeRFC({ title, slug, pitch, tags }) {
|
|
const res = await fetch('/api/rfcs/propose', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ title, slug, pitch, tags: tags || [] }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function mergeProposal(prNumber) {
|
|
const res = await fetch(`/api/proposals/${prNumber}/merge`, { method: 'POST' })
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function declineProposal(prNumber, comment) {
|
|
const res = await fetch(`/api/proposals/${prNumber}/decline`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ comment }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function withdrawProposal(prNumber) {
|
|
const res = await fetch(`/api/proposals/${prNumber}/withdraw`, { method: 'POST' })
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
// ── Slice 2: active-RFC view (§8) ─────────────────────────────────────────
|
|
|
|
export async function listModels(slug) {
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}/models`))
|
|
}
|
|
|
|
export async function getRFCMain(slug) {
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}/main`))
|
|
}
|
|
|
|
export async function getBranch(slug, branch) {
|
|
return jsonOrThrow(await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}`
|
|
))
|
|
}
|
|
|
|
export async function promoteToBranch(slug, body = {}) {
|
|
const res = await fetch(`/api/rfcs/${slug}/branches/main/promote-to-branch`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(body),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function acceptChange(slug, branch, changeId, { proposed, wasEdited, forceApplyStale }) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/changes/${changeId}/accept`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
proposed,
|
|
was_edited_before_accept: !!wasEdited,
|
|
force_apply_stale: !!forceApplyStale,
|
|
}),
|
|
},
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function declineChange(slug, branch, changeId) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/changes/${changeId}/decline`,
|
|
{ method: 'POST' },
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function reaskChange(slug, branch, changeId) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/changes/${changeId}/reask`,
|
|
{ method: 'POST' },
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function manualFlush(slug, branch, { newContent, paragraphCount }) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/manual-flush`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ new_content: newContent, paragraph_count: paragraphCount }),
|
|
},
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function setBranchVisibility(slug, branch, { readPublic, contributeMode }) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/visibility`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
read_public: readPublic,
|
|
contribute_mode: contributeMode,
|
|
}),
|
|
},
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function createThread(slug, branch, body) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/threads`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(body),
|
|
},
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function listThreads(slug, branch) {
|
|
return jsonOrThrow(await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/threads`,
|
|
))
|
|
}
|
|
|
|
export async function getThreadMessages(slug, branch, threadId) {
|
|
return jsonOrThrow(await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/threads/${threadId}/messages`,
|
|
))
|
|
}
|
|
|
|
export async function postThreadMessage(slug, branch, threadId, { text, quote }) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/threads/${threadId}/messages`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ text, quote }),
|
|
},
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function resolveThread(slug, branch, threadId) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/threads/${threadId}/resolve`,
|
|
{ method: 'POST' },
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
// ── v0.5.0: PR-less per-RFC discussion (§5 / §10) ────────────────────────
|
|
//
|
|
// The substrate is `threads.branch_name IS NULL` — the same threads
|
|
// table the branch chat uses, with a null branch the schema already
|
|
// supported. Contribution still requires a PR (api_prs / openPR), so
|
|
// these endpoints are read+write for discussion only.
|
|
|
|
export async function listDiscussionThreads(slug) {
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}/discussion/threads`))
|
|
}
|
|
|
|
export async function createDiscussionThread(slug, { label = null, message = null } = {}) {
|
|
const res = await fetch(`/api/rfcs/${slug}/discussion/threads`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ label, message }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function getDiscussionThreadMessages(slug, threadId) {
|
|
return jsonOrThrow(await fetch(
|
|
`/api/rfcs/${slug}/discussion/threads/${threadId}/messages`,
|
|
))
|
|
}
|
|
|
|
export async function postDiscussionMessage(slug, threadId, { text, quote = null }) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/discussion/threads/${threadId}/messages`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ text, quote }),
|
|
},
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function resolveDiscussionThread(slug, threadId) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/discussion/threads/${threadId}/resolve`,
|
|
{ method: 'POST' },
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
// ── Slice 4: super-draft body editing (§9.5) ─────────────────────────────
|
|
|
|
export async function startEditBranch(slug, body = {}) {
|
|
const res = await fetch(`/api/rfcs/${slug}/start-edit-branch`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(body),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function editMetadata(slug, { title, tags, prDescription }) {
|
|
const res = await fetch(`/api/rfcs/${slug}/metadata`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
title: title ?? null,
|
|
tags: tags ?? null,
|
|
pr_description: prDescription ?? null,
|
|
}),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
// ── Slice 5: §13 graduation + §13.1 claim ────────────────────────────────
|
|
|
|
export async function claimOwnership(slug) {
|
|
const res = await fetch(`/api/rfcs/${slug}/claim`, { method: 'POST' })
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function listBlockingPRs(slug) {
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}/blocking-prs`))
|
|
}
|
|
|
|
export async function graduateCheck(slug, { id, repo }) {
|
|
const params = new URLSearchParams()
|
|
if (id != null) params.set('id', id)
|
|
if (repo != null) params.set('repo', repo)
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}/graduate/check?${params}`))
|
|
}
|
|
|
|
export async function startGraduation(slug, { rfcId, repoName, owners }) {
|
|
const res = await fetch(`/api/rfcs/${slug}/graduate`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ rfc_id: rfcId, repo_name: repoName, owners }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
// Open an EventSource on the §13.3 progress stream. Returns the
|
|
// EventSource so the caller can close() on dialog dismiss. Calls
|
|
// onUpdate with the parsed state payload for every event.
|
|
export function openGraduationProgress(slug, { onUpdate, onDone, onError }) {
|
|
const es = new EventSource(`/api/rfcs/${slug}/graduate/progress`)
|
|
const handle = (e) => {
|
|
try {
|
|
const payload = JSON.parse(e.data)
|
|
onUpdate?.(payload, e.type)
|
|
if (e.type === 'done' && payload?.finished) onDone?.(payload)
|
|
} catch (err) {
|
|
onError?.(err)
|
|
}
|
|
}
|
|
for (const name of ['snapshot', 'step', 'rollback_step', 'completed', 'rolled_back', 'done']) {
|
|
es.addEventListener(name, handle)
|
|
}
|
|
es.onerror = (e) => { onError?.(e); es.close() }
|
|
return es
|
|
}
|
|
|
|
// ── Slice 3: the §10 PR flow ─────────────────────────────────────────────
|
|
|
|
export async function draftPRText(slug, branch) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/pr-draft`,
|
|
{ method: 'POST' },
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function openPR(slug, branch, { title, description }) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/open-pr`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ title, description }),
|
|
},
|
|
)
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function getPR(slug, prNumber) {
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}/prs/${prNumber}`))
|
|
}
|
|
|
|
export async function advancePRSeen(slug, prNumber, { lastSeenCommitSha, lastSeenMessageId }) {
|
|
const res = await fetch(`/api/rfcs/${slug}/prs/${prNumber}/seen`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
last_seen_commit_sha: lastSeenCommitSha,
|
|
last_seen_message_id: lastSeenMessageId,
|
|
}),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function postPRReview(slug, prNumber, { text, anchorPayload, quote }) {
|
|
const res = await fetch(`/api/rfcs/${slug}/prs/${prNumber}/review`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ text, anchor_payload: anchorPayload || {}, quote: quote || null }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function mergePR(slug, prNumber) {
|
|
const res = await fetch(`/api/rfcs/${slug}/prs/${prNumber}/merge`, { method: 'POST' })
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function withdrawPR(slug, prNumber) {
|
|
const res = await fetch(`/api/rfcs/${slug}/prs/${prNumber}/withdraw`, { method: 'POST' })
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function editPRDescription(slug, prNumber, { title, description }) {
|
|
const res = await fetch(`/api/rfcs/${slug}/prs/${prNumber}/description`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ title, description }),
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
export async function startResolutionBranch(slug, prNumber) {
|
|
const res = await fetch(`/api/rfcs/${slug}/prs/${prNumber}/resolution-branch`, {
|
|
method: 'POST',
|
|
})
|
|
return jsonOrThrow(res)
|
|
}
|
|
|
|
// Stream a chat turn into a per-branch thread. Calls onChunk for each
|
|
// text fragment, onChanges when the trailing `changes` event arrives,
|
|
// and onDone at the terminal DONE marker. Returns the response headers
|
|
// (so the caller can pull X-Assistant-Message-Id without re-streaming).
|
|
export async function streamChatTurn(slug, branch, threadId, { text, quote, model }, { onChunk, onChanges, onDone }) {
|
|
const res = await fetch(
|
|
`/api/rfcs/${slug}/branches/${encodeURIComponent(branch)}/threads/${threadId}/chat`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ text, quote, model }),
|
|
},
|
|
)
|
|
if (!res.ok) {
|
|
const detail = await res.text()
|
|
throw new Error(`Chat failed: ${detail || res.status}`)
|
|
}
|
|
const assistantId = res.headers.get('X-Assistant-Message-Id')
|
|
const userMsgId = res.headers.get('X-User-Message-Id')
|
|
const reader = res.body.getReader()
|
|
const decoder = new TextDecoder()
|
|
let buffer = ''
|
|
let currentEvent = null
|
|
while (true) {
|
|
const { done, value } = await reader.read()
|
|
if (done) break
|
|
buffer += decoder.decode(value, { stream: true })
|
|
const parts = buffer.split('\n\n')
|
|
buffer = parts.pop()
|
|
for (const part of parts) {
|
|
const lines = part.split('\n')
|
|
let dataLine = null
|
|
let event = null
|
|
for (const line of lines) {
|
|
if (line.startsWith('event: ')) event = line.slice(7).trim()
|
|
if (line.startsWith('data: ')) dataLine = line.slice(6).trim()
|
|
}
|
|
if (dataLine === null) continue
|
|
if (event === 'changes') {
|
|
try { onChanges?.(JSON.parse(dataLine)) } catch {}
|
|
continue
|
|
}
|
|
if (dataLine === 'DONE') { onDone?.(); break }
|
|
try {
|
|
const text = new TextDecoder().decode(
|
|
Uint8Array.from(atob(dataLine), c => c.charCodeAt(0))
|
|
)
|
|
onChunk?.(text)
|
|
} catch {
|
|
// partial chunk
|
|
}
|
|
}
|
|
}
|
|
onDone?.()
|
|
return { assistantId, userMsgId }
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// §15 / Slice 6: notifications surface
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export async function listNotifications({ unread, rfcSlug, category, actorUserId, bundled } = {}) {
|
|
const params = new URLSearchParams()
|
|
if (unread) params.set('unread', '1')
|
|
if (rfcSlug) params.set('rfc_slug', rfcSlug)
|
|
if (category) params.set('category', category)
|
|
if (actorUserId) params.set('actor_user_id', actorUserId)
|
|
if (bundled) params.set('bundled', '1')
|
|
const qs = params.toString()
|
|
return jsonOrThrow(await fetch(`/api/notifications${qs ? `?${qs}` : ''}`))
|
|
}
|
|
|
|
export async function markNotificationRead(id) {
|
|
return jsonOrThrow(await fetch(`/api/notifications/${id}/read`, { method: 'POST' }))
|
|
}
|
|
|
|
export async function markNotificationsReadByFilter(filter) {
|
|
return jsonOrThrow(await fetch('/api/notifications/read', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(filter || {}),
|
|
}))
|
|
}
|
|
|
|
export async function listWatches() {
|
|
return jsonOrThrow(await fetch('/api/watches'))
|
|
}
|
|
|
|
export async function setWatch(slug, state) {
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}/watch`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ state }),
|
|
}))
|
|
}
|
|
|
|
export async function getNotificationPreferences() {
|
|
return jsonOrThrow(await fetch('/api/users/me/notification-preferences'))
|
|
}
|
|
|
|
export async function setNotificationPreferences(prefs) {
|
|
return jsonOrThrow(await fetch('/api/users/me/notification-preferences', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify(prefs),
|
|
}))
|
|
}
|
|
|
|
export async function getQuietHours() {
|
|
return jsonOrThrow(await fetch('/api/users/me/quiet-hours'))
|
|
}
|
|
|
|
export async function setQuietHours({ start, end, timezone } = {}) {
|
|
return jsonOrThrow(await fetch('/api/users/me/quiet-hours', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ start: start || null, end: end || null, timezone: timezone || null }),
|
|
}))
|
|
}
|
|
|
|
// v0.13.0 / roadmap item #11: cookie consent (SPEC §14.5).
|
|
export async function getCookieConsent() {
|
|
return jsonOrThrow(await fetch('/api/users/me/cookie-consent'))
|
|
}
|
|
|
|
export async function setCookieConsent({ analytics, other } = {}) {
|
|
return jsonOrThrow(await fetch('/api/users/me/cookie-consent', {
|
|
method: 'PUT',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({
|
|
essential: true,
|
|
analytics: !!analytics,
|
|
other: !!other,
|
|
}),
|
|
}))
|
|
}
|
|
|
|
export async function muteUser(userId) {
|
|
return jsonOrThrow(await fetch(`/api/users/${userId}/notification-mute`, { method: 'POST' }))
|
|
}
|
|
|
|
export async function unmuteUser(userId) {
|
|
return jsonOrThrow(await fetch(`/api/users/${userId}/notification-mute`, { method: 'DELETE' }))
|
|
}
|
|
|
|
export async function advanceChatSeen(slug, branch, lastSeenMessageId) {
|
|
return jsonOrThrow(await fetch(`/api/rfcs/${slug}/branches/${branch}/chat-seen`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ last_seen_message_id: lastSeenMessageId || null }),
|
|
}))
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// §14.2 / Slice 7: PHILOSOPHY.md surface
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export async function getPhilosophy() {
|
|
return jsonOrThrow(await fetch('/api/philosophy'))
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Slice 7: admin neighborhood (§17 admin/* + user search for the §15.8 mute
|
|
// typeahead).
|
|
// ---------------------------------------------------------------------------
|
|
|
|
export async function listAdminUsers() {
|
|
return jsonOrThrow(await fetch('/api/admin/users'))
|
|
}
|
|
|
|
export async function setUserRole(userId, role) {
|
|
return jsonOrThrow(await fetch(`/api/admin/users/${userId}/role`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ role }),
|
|
}))
|
|
}
|
|
|
|
export async function setUserMute(userId, muted) {
|
|
return jsonOrThrow(await fetch(`/api/admin/users/${userId}/mute`, {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ muted }),
|
|
}))
|
|
}
|
|
|
|
export async function listAuditLog({ actionKind, actorUserId, rfcSlug, beforeId, limit } = {}) {
|
|
const params = new URLSearchParams()
|
|
if (actionKind) params.set('action_kind', actionKind)
|
|
if (actorUserId != null) params.set('actor_user_id', actorUserId)
|
|
if (rfcSlug) params.set('rfc_slug', rfcSlug)
|
|
if (beforeId != null) params.set('before_id', beforeId)
|
|
if (limit != null) params.set('limit', limit)
|
|
const qs = params.toString()
|
|
return jsonOrThrow(await fetch(`/api/admin/audit${qs ? `?${qs}` : ''}`))
|
|
}
|
|
|
|
export async function listPermissionEvents({ beforeId, limit } = {}) {
|
|
const params = new URLSearchParams()
|
|
if (beforeId != null) params.set('before_id', beforeId)
|
|
if (limit != null) params.set('limit', limit)
|
|
const qs = params.toString()
|
|
return jsonOrThrow(await fetch(`/api/admin/permission-events${qs ? `?${qs}` : ''}`))
|
|
}
|
|
|
|
export async function listGraduationQueue() {
|
|
return jsonOrThrow(await fetch('/api/admin/graduation-queue'))
|
|
}
|
|
|
|
export async function listAllowlist() {
|
|
return jsonOrThrow(await fetch('/api/admin/allowlist'))
|
|
}
|
|
|
|
export async function addAllowlistEmail(email, note) {
|
|
return jsonOrThrow(await fetch('/api/admin/allowlist', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ email, note: note || null }),
|
|
}))
|
|
}
|
|
|
|
export async function removeAllowlistEmail(email) {
|
|
return jsonOrThrow(await fetch(`/api/admin/allowlist/${encodeURIComponent(email)}`, {
|
|
method: 'DELETE',
|
|
}))
|
|
}
|
|
|
|
export async function searchUsers(q) {
|
|
const params = new URLSearchParams()
|
|
if (q) params.set('q', q)
|
|
return jsonOrThrow(await fetch(`/api/users/search?${params}`))
|
|
}
|
|
|
|
// SSE subscription helper. Returns a close() function. The handler
|
|
// surface mirrors §15.3: a snapshot event on open, then per-notification
|
|
// `notification` events, plus `read` events when another tab marks a row.
|
|
export function subscribeToNotifications({ onSnapshot, onNotification, onRead, onError } = {}) {
|
|
const source = new EventSource('/api/notifications/stream')
|
|
source.addEventListener('snapshot', e => {
|
|
try { onSnapshot?.(JSON.parse(e.data)) } catch {}
|
|
})
|
|
source.addEventListener('notification', e => {
|
|
try { onNotification?.(JSON.parse(e.data)) } catch {}
|
|
})
|
|
source.addEventListener('read', e => {
|
|
try { onRead?.(JSON.parse(e.data)) } catch {}
|
|
})
|
|
source.onerror = err => { onError?.(err) }
|
|
return () => source.close()
|
|
}
|
|
|