@preventive/triage 1.0.0-alpha.2 → 1.0.0-alpha.21

package/server-managed/bundle-catalog.ts

@@ -0,0 +1,29 @@
+import type { BundleCache, BundleSummary } from './bundle-cache.ts'
+import type { AdminBundle, UserTeamBundle } from './db.ts'
+
+const SUMMARY_READ_CONCURRENCY = 8
+
+// Read only existing summaries: cold/malformed bundles must never trigger
+// parsing or wait for metadata builds before the catalog response is sent.
+export async function bundleSummaries(bundles: readonly (AdminBundle | UserTeamBundle)[], cache?: BundleCache) {
+  const summaries = new Map<string, { summary: BundleSummary | null; summaryRetryAt: number | null }>()
+  if (cache) {
+    const unique = [...new Map(bundles.map(bundle => [bundle.integrity, bundle])).values()]
+    let next = 0
+    // Cold reads may each access remote storage. Bound those requests as well
+    // as the subsequent backfill, without dropping entries from large catalogs.
+    await Promise.all(Array.from({ length: Math.min(SUMMARY_READ_CONCURRENCY, unique.length) }, async () => {
+      while (next < unique.length) {
+        const bundle = unique[next++]!
+        summaries.set(bundle.integrity, await cache.summaryStatus(bundle).catch(() => ({ summary: null, summaryRetryAt: null })))
+      }
+    }))
+  }
+  return summaries
+}
+
+// Called after sending the response. Each cache permits one small batch at a
+// time, deduplicated by content hash, and skips persisted retry-backoff markers.
+export async function backfillBundleSummaries(bundles: readonly (AdminBundle | UserTeamBundle)[], cache?: BundleCache) {
+  await cache?.backfillSummaries([...new Map(bundles.map(bundle => [bundle.integrity, bundle])).values()])
+}

package/server-managed/bundle-store.ts

@@ -0,0 +1,28 @@
+// Sourcemaps are stored once as Brotli. The DB retains the uploaded filename,
+// byte size and integrity so compression does not change report links/dedup.
+import type { Buffer } from 'node:buffer'
+import { type BlobStore, type OpenedBlob, createDiskBlobStore } from './blob-store.ts'
+import { encodeBrotli } from './brotli.ts'
+
+export interface BundleStore {
+  put(id: string, bytes: Buffer, kind: string | null): Promise<void>
+  get(id: string, kind: string | null): Promise<Buffer | null>
+  open(id: string, kind: string | null): Promise<OpenedBlob | null>
+  delete(id: string): Promise<void>
+}
+
+export function createBundleStore(archives: BlobStore, sourcemaps: BlobStore): BundleStore {
+  const storage = (kind: string | null) => kind === 'sourcemap' ? sourcemaps : archives
+  return {
+    async put(id, bytes, kind) {
+      await storage(kind).put(id, kind === 'sourcemap' ? await encodeBrotli(bytes) : bytes)
+    },
+    get: (id, kind) => storage(kind).get(id),
+    open: (id, kind) => storage(kind).open(id),
+    async delete(id) { await Promise.all([archives.delete(id), sourcemaps.delete(id)]) },
+  }
+}
+
+export function createDiskBundleStore(dir: string): BundleStore {
+  return createBundleStore(createDiskBlobStore(dir), createDiskBlobStore(dir, '.map.br'))
+}

package/server-managed/bundle-summary-cache.ts

@@ -0,0 +1,97 @@
+import { Buffer } from 'node:buffer'
+import { setImmediate } from 'node:timers/promises'
+import { BUNDLE_METADATA_VERSION } from '../common/bundle-metadata.js'
+import { decodeUtf8 } from '../common/utf8.js'
+import type { BundleCacheRecord, BundleCacheStorage, BundleSummary } from './bundle-cache.ts'
+
+export const SUMMARY_FILENAME = `v${BUNDLE_METADATA_VERSION}-summary.json`
+const RETRY_MS = 5 * 60_000
+const BACKFILL_LIMIT = 4
+type CachedSummary = BundleSummary | { retryAt: number }
+
+async function readSummary(storage: BundleCacheStorage, id: string): Promise<CachedSummary> {
+  const cached = await storage.open(id, SUMMARY_FILENAME)
+  try {
+    const chunks: Buffer[] = []
+    let size = 0
+    for await (const chunk of cached.stream) {
+      size += chunk.length
+      if (size > 1024) throw new Error('Invalid bundle summary')
+      chunks.push(Buffer.from(chunk))
+    }
+    const summary = JSON.parse(decodeUtf8(Buffer.concat(chunks))) as CachedSummary
+    if (summary && 'retryAt' in summary && Number.isSafeInteger(summary.retryAt) && summary.retryAt > 0) return summary
+    const counts = summary as BundleSummary
+    if (!counts || ![counts.files, counts.codeFiles, counts.lines].every(value => Number.isSafeInteger(value) && value >= 0)
+        || counts.codeFiles > counts.files) throw new Error('Invalid bundle summary')
+    return counts
+  } finally { cached.stream.destroy() }
+}
+
+export function createBundleSummaryCache(storage: BundleCacheStorage, build: (record: BundleCacheRecord) => Promise<BundleSummary>, exists: (id: string) => Promise<unknown>) {
+  const entries = new Map<string, { id: string; value: CachedSummary }>()
+  const active = new Map<string, Promise<void>>()
+  let pending: Promise<void> | null = null
+  function remember(record: BundleCacheRecord, value: CachedSummary) {
+    if (entries.size >= 256) entries.delete(entries.keys().next().value!)
+    entries.set(record.integrity, { id: record.id, value })
+  }
+  async function read(record: BundleCacheRecord) {
+    const known = entries.get(record.integrity)
+    if (known) return known.value
+    if (!await storage.exists(record.id, SUMMARY_FILENAME)) return null
+    const value = await readSummary(storage, record.id)
+    remember(record, value)
+    return value
+  }
+  async function publish(record: BundleCacheRecord, value: CachedSummary) {
+    if (!await exists(record.id)) return
+    await storage.put(record.id, SUMMARY_FILENAME, Buffer.from(JSON.stringify(value)))
+    if (!await exists(record.id)) { await storage.delete(record.id); return }
+    remember(record, value)
+  }
+  async function buildOne(record: BundleCacheRecord) {
+    try { await publish(record, await build(record)) }
+    catch { await publish(record, { retryAt: Date.now() + RETRY_MS }).catch(() => {}) }
+  }
+  async function summaryStatus(record: BundleCacheRecord) {
+    const value = ['stasis', 'sourcemap'].includes(record.kind ?? '') ? await read(record) : null
+    return { summary: value && !('retryAt' in value) ? value : null,
+      summaryRetryAt: value && 'retryAt' in value ? value.retryAt : null }
+  }
+  async function backfill(records: readonly BundleCacheRecord[]) {
+    // Start after the catalog has been sent. Keep this work awaited by the
+    // request owner (including serverless), with no detached tasks or backlog.
+    await setImmediate()
+    let attempts = 0
+    for (const record of records) {
+      if (!['stasis', 'sourcemap'].includes(record.kind ?? '')) continue
+      const cached = await read(record).catch(() => null)
+      if (cached && (!('retryAt' in cached) || cached.retryAt > Date.now())) continue
+      if (!await exists(record.id)) continue
+      if (attempts++ >= BACKFILL_LIMIT) break
+      const job = buildOne(record)
+      active.set(record.id, job)
+      try { await job } finally { active.delete(record.id) }
+    }
+  }
+  return {
+    remember,
+    summaryStatus,
+    async summary(record: BundleCacheRecord): Promise<BundleSummary | null> {
+      return (await summaryStatus(record)).summary
+    },
+    backfill(records: readonly BundleCacheRecord[]) {
+      if (pending) return Promise.resolve() // Another catalog already owns the bounded batch.
+      const job = backfill(records).finally(() => { if (pending === job) pending = null })
+      pending = job
+      return job
+    },
+    async forget(id: string) {
+      // Only this bundle can republish its cache during deletion. A stalled
+      // backfill elsewhere must not delay removing these bytes or responding.
+      await active.get(id)
+      for (const [hash, entry] of entries) if (entry.id === id) entries.delete(hash)
+    },
+  }
+}

package/server-managed/bundle.ts

@@ -0,0 +1,39 @@
+// Bundle helpers for the managed server: the content-addressed identity used to
+// dedupe stored bundles and to auto-link reports to them.
+//
+// A report's top-level `bundleHashes` lists the `sha512-<base64>` integrities
+// the analyzer ran against (see ui/view/ingest.js); a stored bundle's identity
+// is that same integrity computed from its bytes. Matching the two is how a
+// report auto-links to its bundle.
+import { createHash } from 'node:crypto'
+import type { Buffer } from 'node:buffer'
+
+// `sha512-<base64>` identity for a bundle's bytes. MUST stay byte-identical to
+// the client's common/integrity.js (SHA-512 → standard base64 WITH padding) so
+// a report's `bundleHashes` entries match a stored bundle's computed integrity.
+// (The client uses `Uint8Array.toBase64()`, whose default is standard base64 +
+// padding — the same bytes node:crypto's base64 digest emits.)
+export function bundleIntegrity(bytes: Buffer): string {
+  return `sha512-${createHash('sha512').update(bytes).digest('base64')}`
+}
+
+// Classify an uploaded bundle by filename — mirrors ui/view/ingest.js
+// `bundleKind`: sourcemap (.map) or stasis (stasis.code.br / .stasis.code.br).
+// null for anything else (stored anyway; the kind is informational).
+export function bundleKind(filename: string): 'sourcemap' | 'stasis' | null {
+  const lower = filename.toLowerCase()
+  if (lower.endsWith('.map')) return 'sourcemap'
+  if (lower === 'stasis.code.br' || lower.endsWith('.stasis.code.br')) return 'stasis'
+  return null
+}
+
+// Extract the bundle integrities a report declares (its top-level
+// `bundleHashes`). Non-JSON reports (markdown / CSV) or a missing field → [].
+export function reportBundleHashes(bytes: Buffer): string[] {
+  let data: unknown
+  try { data = JSON.parse(bytes.toString('utf8')) } catch { return [] }
+  if (data == null || typeof data !== 'object') return []
+  const hashes = (data as { bundleHashes?: unknown }).bundleHashes
+  if (!Array.isArray(hashes)) return []
+  return hashes.filter((x): x is string => typeof x === 'string' && x !== '')
+}

package/server-managed/cache-storage.ts

@@ -0,0 +1,40 @@
+import type { Buffer } from 'node:buffer'
+import { randomUUID } from 'node:crypto'
+import { mkdir, open, rename, rm, stat, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import type { OpenedBlob } from './blob-store.ts'
+
+// Keys are internal relative paths; delete removes a whole directory of variants.
+export interface CacheStorage {
+  exists(key: string): Promise<boolean>
+  put(key: string, bytes: Buffer): Promise<void>
+  open(key: string): Promise<OpenedBlob>
+  delete(prefix: string): Promise<void>
+}
+
+export function validateCacheKey(key: string): string {
+  if (!key.split('/').every(part => /^[a-z0-9][a-z0-9.-]*$/iu.test(part))) throw new Error('Invalid cache key')
+  return key
+}
+
+export function createDiskCacheStorage(dir: string): CacheStorage {
+  const path = (key: string) => join(dir, validateCacheKey(key))
+  return {
+    async exists(key) {
+      try { await stat(path(key)); return true }
+      catch (err) { if ((err as NodeJS.ErrnoException).code === 'ENOENT') return false; throw err }
+    },
+    async put(key, bytes) {
+      const target = path(key), temp = `${target}.${randomUUID()}.tmp`
+      await mkdir(dirname(target), { recursive: true })
+      try { await writeFile(temp, bytes); await rename(temp, target) }
+      finally { await rm(temp, { force: true }) }
+    },
+    async open(key) {
+      const file = await open(path(key), 'r')
+      try { return { size: (await file.stat()).size, stream: file.createReadStream() } }
+      catch (err) { await file.close(); throw err }
+    },
+    async delete(prefix) { await rm(path(prefix), { recursive: true, force: true }) },
+  }
+}

package/server-managed/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// Executable entry for the managed-server bin. See server-e2e/cli.js for the
+// full rationale: Node refuses to strip TypeScript types from files under
+// node_modules, so once this package is installed as a dependency
+// server-managed/index.ts can't be executed directly. Register the in-thread
+// type-stripping hook FIRST, then load the server via a dynamic import (a
+// static import would be fetched before the hook is active) and start it.
+//
+// Imported here rather than run as the process entry, so index.ts's
+// `import.meta.main` auto-start gate stays off and we call `start()` ourselves.
+import '../strip-types-loader.js'
+const { start } = await import('./index.ts')
+await start()

package/server-managed/combined.ts

@@ -0,0 +1,46 @@
+// Compose the existing HTTP apps on e2e's listener, including its WS/SSE
+// transports and static UI. Managed handles its API, discovery and page HTML;
+// assets and other requests fall through to the unchanged e2e HTTP handler.
+import { resolve } from 'node:path'
+import type { Server } from 'node:http'
+import { withReap } from '../server-common/reap.ts'
+import { loadConfig } from '../server-e2e/config.ts'
+import { createE2eApp } from '../server-e2e/app.ts'
+import { loadManagedConfig } from './config.ts'
+import { LOGIN_PATH } from './github-oauth.ts'
+import { createManagedApp, logManagedStartup } from './index.ts'
+
+export async function init(mode: 'managed+e2e' | 'e2e+managed'): Promise<Server> {
+  const config = loadManagedConfig({ combined: true })
+  const e2eConfig = loadConfig()
+  if (!e2eConfig.neonUrl && !config.neonUrl && config.dbPath !== ':memory:' && resolve(config.dbPath) === resolve(e2eConfig.dbPath)) {
+    throw new Error('MANAGED_DB_PATH must differ from e2e DB_PATH in combined mode.')
+  }
+  const e2e = await createE2eApp(e2eConfig)
+  // Replace the assembled server's single
+  // request listener; adding a second would write two responses per request.
+  const handlers = e2e.httpServer.listeners('request')
+  const next = handlers[0]
+  if (handlers.length !== 1 || !next) throw new Error('Expected one e2e HTTP request handler')
+  const managed = await createManagedApp(config, {
+    next: e2e.handleRequest,
+    isShuttingDown: e2e.isShuttingDown,
+    serverInfo: {
+      mode, managed: { loginPath: LOGIN_PATH, cookieName: config.sessionCookieName },
+      ...(e2eConfig.deepviewScanServer ? { deepviewScanServer: e2eConfig.deepviewScanServer } : {}),
+    },
+  }).catch(async err => {
+    await e2e.httpServer[Symbol.asyncDispose]()
+    throw err
+  })
+  e2e.onShutdown(managed.close)
+  e2e.httpServer.removeListener('request', next)
+  e2e.httpServer.on('request', withReap(managed.handleRequest,
+    { e2e: e2e.reap, managed: managed.reap }, { isShuttingDown: e2e.isShuttingDown }))
+  e2e.httpServer.once('listening', () => {
+    const address = e2e.httpServer.address()
+    const port = typeof address === 'object' && address ? address.port : config.port
+    logManagedStartup(config, port, mode)
+  })
+  return e2e.httpServer
+}

package/server-managed/comments.ts

@@ -0,0 +1,151 @@
+import { randomUUID } from 'node:crypto'
+import type { DatabaseSync } from 'node:sqlite'
+import { type ManagedComment, canDeleteComment } from '../common/managed/comments.ts'
+import type { ManagedSql } from './sql.ts'
+
+export interface CommentInput {
+  findingId: string
+  body: string
+  // Runtime imports may omit authorship, including future admin UI imports.
+  // Ordinary comment posts always supply the authenticated user as author.
+  authorId: string | null
+  authorLogin: string | null
+  // The user performing an import need not be the author of its comments.
+  // Omitted for ordinary posts, where the author is also the acting user.
+  actor?: { id: string; login: string }
+  // Omitted dates default to the action time; null preserves unknown dates.
+  createdAt?: number | null
+  updatedAt?: number | null
+  reportId?: string | null
+}
+
+export interface CommentStore {
+  listComments(findingIds: readonly string[]): Promise<ManagedComment[]>
+  listCommentedFindingIds(findingIds: readonly string[]): Promise<string[]>
+  getComment(id: string): Promise<ManagedComment | null>
+  createComment(input: CommentInput, now: number): Promise<ManagedComment>
+  editComment(id: string, authorId: string, authorLogin: string, body: string, version: number, reportId: string, now: number): Promise<ManagedComment | 'conflict' | 'forbidden' | null>
+  deleteComment(id: string, actorId: string, actorLogin: string, version: number, reportId: string, now: number): Promise<'deleted' | 'conflict' | 'forbidden' | null>
+}
+
+const COMMENT_COLUMNS = `id TEXT PRIMARY KEY, finding_id TEXT NOT NULL, body TEXT NOT NULL,
+  author_id TEXT REFERENCES managed_user(id) ON DELETE SET NULL,
+  author_login TEXT, created_at INTEGER, updated_at INTEGER,
+  version INTEGER NOT NULL DEFAULT 1`
+
+export const COMMENT_SCHEMA = `
+    CREATE TABLE IF NOT EXISTS managed_finding_comment (${COMMENT_COLUMNS}) STRICT;
+    CREATE INDEX IF NOT EXISTS finding_comment_finding_idx ON managed_finding_comment(finding_id, created_at, id);
+    CREATE TABLE IF NOT EXISTS managed_finding_comment_event (
+      seq INTEGER PRIMARY KEY, comment_id TEXT NOT NULL, finding_id TEXT NOT NULL,
+      actor_id TEXT REFERENCES managed_user(id) ON DELETE SET NULL,
+      actor_login TEXT, action TEXT NOT NULL, at INTEGER NOT NULL,
+      report_id TEXT, report TEXT, repo TEXT
+    ) STRICT;
+    CREATE INDEX IF NOT EXISTS finding_comment_event_finding_idx ON managed_finding_comment_event(finding_id, seq);
+    CREATE INDEX IF NOT EXISTS finding_comment_event_actor_at_idx ON managed_finding_comment_event(actor_id, at);
+    CREATE INDEX IF NOT EXISTS finding_comment_event_at_idx ON managed_finding_comment_event(at, seq);
+`
+
+export function initCommentMethods(db: DatabaseSync): void {
+  db.exec(COMMENT_SCHEMA)
+  migrateCommentDates(db)
+  // updated_by belongs to the whole triage row, not necessarily its comment.
+  // Preserve legacy text without guessing an author. Clearing the old column
+  // in the same transaction makes the migration safe to restart. Use a fresh
+  // ID so a later legacy-server write cannot collide with an earlier import.
+  db.exec('BEGIN')
+  try {
+    db.exec(`INSERT INTO managed_finding_comment (id, finding_id, body, created_at, updated_at)
+      SELECT 'legacy:' || lower(hex(randomblob(16))), finding_id, comment, updated_at, updated_at
+      FROM managed_finding_triage WHERE comment IS NOT NULL AND comment != '';
+      UPDATE managed_finding_triage SET comment = NULL WHERE comment IS NOT NULL;`)
+    db.exec('COMMIT')
+  } catch (err) {
+    db.exec('ROLLBACK')
+    throw err
+  }
+}
+
+export function commentMethods(db: ManagedSql): CommentStore {
+  const fields = `c.id, c.finding_id AS findingId, c.body, c.author_id AS authorId,
+    COALESCE(u.login, c.author_login) AS authorLogin,
+    c.created_at AS createdAt, c.updated_at AS updatedAt, c.version`
+  const select = db.prepare(`SELECT ${fields} FROM managed_finding_comment c
+    LEFT JOIN managed_user u ON u.id = c.author_id WHERE c.id = ?`)
+  const list = db.prepare(`SELECT ${fields} FROM managed_finding_comment c
+    LEFT JOIN managed_user u ON u.id = c.author_id
+    WHERE c.finding_id IN (SELECT value FROM json_each(?)) ORDER BY c.created_at NULLS FIRST, c.id`)
+  const insert = db.prepare(`INSERT INTO managed_finding_comment
+    (id, finding_id, body, author_id, author_login, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)`)
+  const update = db.prepare(`UPDATE managed_finding_comment SET body = ?, updated_at = ?, version = version + 1
+    WHERE id = ? AND author_id = ? AND version = ?`)
+  const remove = db.prepare('DELETE FROM managed_finding_comment WHERE id = ? AND (author_id = ? OR (author_id IS NULL AND ? IS NULL)) AND version = ?')
+  const userRole = db.prepare('SELECT role FROM managed_user WHERE id = ?')
+  // Deleted comments still have audit events which explicit annotation purges
+  // must find, including when no current triage/comment record remains.
+  const annotated = db.prepare(`SELECT finding_id AS id FROM managed_finding_comment WHERE finding_id IN (SELECT value FROM json_each(?))
+    UNION SELECT finding_id AS id FROM managed_finding_comment_event WHERE finding_id IN (SELECT value FROM json_each(?))`)
+  const event = db.prepare(`INSERT INTO managed_finding_comment_event
+    (comment_id, finding_id, actor_id, actor_login, action, at, report_id, report, repo)
+    VALUES (?, ?, ?, ?, ?, ?, ?, (SELECT filename FROM managed_report WHERE id = ?),
+      (SELECT p.full_name FROM managed_report r JOIN managed_selected_repo p ON p.repo_id = r.repo_id WHERE r.id = ?))`)
+  const read = async (id: string) => (await select.get(id)) as ManagedComment | undefined
+  return {
+    async listComments(ids) { return ids.length > 0 ? (await list.all(JSON.stringify(ids))) as unknown as ManagedComment[] : [] },
+    async listCommentedFindingIds(ids) {
+      const json = JSON.stringify(ids)
+      return ((await annotated.all(json, json)) as { id: string }[]).map(row => row.id)
+    },
+    async getComment(id) { return (await read(id)) ?? null },
+    async createComment(input, now) {
+      const id = randomUUID()
+      const createdAt = input.createdAt === undefined ? now : input.createdAt
+      const updatedAt = input.updatedAt === undefined ? createdAt : input.updatedAt
+      await insert.run(id, input.findingId, input.body, input.authorId, input.authorLogin, createdAt, updatedAt)
+      await event.run(id, input.findingId, input.actor?.id ?? input.authorId, input.actor?.login ?? input.authorLogin, 'added a comment', now,
+        input.reportId ?? null, input.reportId ?? null, input.reportId ?? null)
+      return (await read(id))!
+    },
+    async editComment(id, authorId, authorLogin, body, version, reportId, now) {
+      // Identity/version checks and the event share the operation transaction.
+      const current = await read(id)
+      if (!current || current.authorId !== authorId || current.version !== version || current.body === body) {
+        if (!current) return null
+        if (current.authorId !== authorId) return 'forbidden'
+        if (current.version !== version) return 'conflict'
+        return current
+      }
+      await update.run(body, now, id, authorId, version)
+      await event.run(id, current.findingId, authorId, authorLogin, 'edited a comment', now, reportId, reportId, reportId)
+      return (await read(id))!
+    },
+    async deleteComment(id, actorId, actorLogin, version, reportId, now) {
+      const current = await read(id)
+      const role = (await userRole.get(actorId) as { role: string } | undefined)?.role ?? 'none'
+      const allowed = current != null && canDeleteComment(current, { id: actorId, role })
+      if (!current || !allowed || current.version !== version) {
+        if (!current) return null
+        return allowed ? 'conflict' : 'forbidden'
+      }
+      await remove.run(id, current.authorId, current.authorId, version)
+      await event.run(id, current.findingId, actorId, actorLogin, 'deleted a comment', now, reportId, reportId, reportId)
+      return 'deleted'
+    },
+  }
+}
+
+function migrateCommentDates(db: DatabaseSync): void {
+  const columns = db.prepare('PRAGMA table_info(managed_finding_comment)').all() as { name: string; notnull: number }[]
+  if (!columns.some(column => ['created_at', 'updated_at'].includes(column.name) && column.notnull)) return
+  db.exec('BEGIN')
+  try {
+    db.exec(`CREATE TABLE managed_finding_comment_nullable_dates (${COMMENT_COLUMNS}) STRICT;
+      INSERT INTO managed_finding_comment_nullable_dates (id, finding_id, body, author_id, author_login, created_at, updated_at, version)
+        SELECT id, finding_id, body, author_id, author_login, created_at, updated_at, version FROM managed_finding_comment;
+      DROP TABLE managed_finding_comment;
+      ALTER TABLE managed_finding_comment_nullable_dates RENAME TO managed_finding_comment;
+      CREATE INDEX finding_comment_finding_idx ON managed_finding_comment(finding_id, created_at, id);`)
+    db.exec('COMMIT')
+  } catch (err) { db.exec('ROLLBACK'); throw err }
+}

package/server-managed/config.ts

@@ -0,0 +1,144 @@
+// Managed-server boot config, parsed once at startup and
+// failing fast on a missing / invalid required value — the same discipline as
+// server-e2e/config.ts. Auth (GitHub identity + sessions) is required. An
+// optional, SEPARATE GitHub App (id + private key + slug) enables PRIVATE repo
+// listing via installation tokens — kept distinct from the login App so its
+// Contents permission never lands on the login consent. The sync protocol is
+// not parsed here yet.
+import { env } from 'node:process'
+import { databaseUrls } from '../server-common/database-config.ts'
+
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', '::1', 'localhost'])
+
+export interface ManagedConfig {
+  port: number
+  host: string
+  dbPath: string
+  neonUrl?: string | null
+  blobToken?: string | null
+  serverless?: boolean
+  debug: boolean
+  allowShare: boolean
+  trustProxyEnv: string | undefined
+  // GitHub App user-authorization (identity) credentials — the App's client id
+  // + secret, used by the login flow.
+  githubClientId: string
+  githubClientSecret: string
+  // Preapproved GitHub identity promoted on login when it is the only user
+  // and its role is No access, including a login after registration.
+  initialAdminGithubId: number | null
+  // Absolute callback registered with GitHub, e.g.
+  // 'https://triage.example.com/api/oauth/github/callback'.
+  oauthCallbackUrl: string
+  // Whether cookies carry `Secure` (callback is https). Also gates the
+  // `__Host-` prefix, so loopback http dev can run with a plain cookie name.
+  cookieSecure: boolean
+  sessionCookieName: string
+  sessionTtlMs: number
+  // Optional SEPARATE GitHub App for PRIVATE repository access — distinct from
+  // the login App above. It carries the Contents: Read permission (so its
+  // consent never touches login) and is read via installation tokens: the id +
+  // PEM private key mint them; the slug builds the "Connect a repository"
+  // install URL. id/key absent → private repos are off (public-only listing);
+  // slug absent → no install link.
+  githubAppId: string | null
+  githubAppPrivateKey: string | null
+  githubAppSlug: string | null
+  // Max accepted size (bytes) for an uploaded report on the "Manage reports"
+  // page. Reports are findings dumps (JSON / markdown / CSV), small to a few MB.
+  maxReportBytes: number
+  // Max accepted size (bytes) for an uploaded bundle (sourcemap / stasis
+  // archive). Bundles run larger than reports, so a higher cap (default 100 MiB,
+  // matching the e2e objstore per-upload cap).
+  maxBundleBytes: number
+  // How many triage-trail events to keep per finding (managed_finding_triage_event):
+  // 0, the default, keeps everything — the trail is the record. An operator
+  // who would rather bound the store sets a positive count; older events of a
+  // finding are then trimmed as new ones land.
+  triageHistoryLimit: number
+}
+
+function fail(msg: string): never {
+  throw new Error(msg)
+}
+
+function requireStr(name: string): string {
+  const v = env[name]
+  if (v == null || v === '') fail(`Missing required env ${name} (managed mode).`)
+  return v
+}
+
+function intEnv(name: string, def: number, min: number, max: number): number {
+  const raw = env[name]
+  const n = raw == null ? def : Number(raw)
+  if (!Number.isSafeInteger(n) || n < min || n > max) {
+    fail(`Invalid ${name}: ${raw} — must be an integer in [${min}, ${max}].`)
+  }
+  return n
+}
+
+function optionalGithubId(name: string): number | null {
+  const raw = env[name]
+  if (raw == null || raw === '') return null
+  const id = Number(raw)
+  if (!/^[1-9]\d*$/u.test(raw) || !Number.isSafeInteger(id)) {
+    fail(`Invalid ${name}: must be a single positive numeric GitHub user ID.`)
+  }
+  return id
+}
+
+function urlOrFail(name: string, raw: string): URL {
+  try { return new URL(raw) } catch { fail(`${name} is not a valid URL: ${raw}`) }
+}
+
+export function loadManagedConfig({ combined = false } = {}): ManagedConfig {
+  const serverless = env['VERCEL'] === '1'
+  const neonUrl = databaseUrls({ combined }).managed
+  const blobToken = env['BLOB_READ_WRITE_TOKEN'] || null
+  if (serverless && !neonUrl) fail('Vercel managed mode requires DATABASE_URL or MANAGED_DATABASE_URL.')
+  if (neonUrl && !blobToken) fail('Managed Neon mode requires BLOB_READ_WRITE_TOKEN.')
+  const host = env['HOST'] ?? '127.0.0.1'
+  const oauthCallbackUrl = requireStr('OAUTH_CALLBACK_URL')
+  const callback = urlOrFail('OAUTH_CALLBACK_URL', oauthCallbackUrl)
+  const cookieSecure = callback.protocol === 'https:'
+  // A `__Host-` cookie mandates `Secure`, so any non-loopback bind must be
+  // HTTPS — fail fast (mirrors server-e2e's boot check). Loopback dev over
+  // http is allowed with a non-prefixed cookie name.
+  if ((serverless || !LOOPBACK_HOSTS.has(host)) && !cookieSecure) {
+    fail(`Vercel or non-loopback HOST=${host} requires an https OAUTH_CALLBACK_URL — the session cookie needs Secure.`)
+  }
+  const sessionCookieName = env['SESSION_COOKIE_NAME'] ?? '__Host-dvsid'
+  if (sessionCookieName.startsWith('__Host-') && !cookieSecure) {
+    fail(`SESSION_COOKIE_NAME=${sessionCookieName} uses the __Host- prefix but the callback is not https. Use a non-prefixed name for loopback http dev.`)
+  }
+  return {
+    neonUrl, blobToken, serverless,
+    port: intEnv('PORT', 8765, 0, 65535),
+    host,
+    // DB_PATH belongs to e2e in a combined process. Keep the two stores apart.
+    dbPath: env['MANAGED_DB_PATH'] ?? (combined ? undefined : env['DB_PATH']) ?? 'server-managed/data/managed.db',
+    debug: env['DEBUG'] === '1' || env['DEBUG'] === 'true',
+    allowShare: env['DEEPVIEW_ALLOW_SHARE'] === '1',
+    trustProxyEnv: env['TRUST_PROXY'] ?? (serverless ? '1' : undefined),
+    githubClientId: requireStr('GITHUB_CLIENT_ID'),
+    githubClientSecret: requireStr('GITHUB_CLIENT_SECRET'),
+    initialAdminGithubId: optionalGithubId('MANAGED_INITIAL_ADMIN_GITHUB_ID'),
+    oauthCallbackUrl,
+    cookieSecure,
+    sessionCookieName,
+    sessionTtlMs: intEnv('SESSION_TTL_MS', 1_209_600_000, 60_000, 7_776_000_000),
+    githubAppId: env['GITHUB_APP_ID'] ?? null,
+    githubAppPrivateKey: normalizePem(env['GITHUB_APP_PRIVATE_KEY']),
+    githubAppSlug: env['GITHUB_APP_SLUG'] ?? null,
+    maxReportBytes: intEnv('MAX_REPORT_BYTES', 10_485_760, 1, 104_857_600),
+    maxBundleBytes: intEnv('MAX_BUNDLE_BYTES', 104_857_600, 1, 1_073_741_824),
+    triageHistoryLimit: intEnv('TRIAGE_HISTORY_LIMIT', 0, 0, 1_000_000_000),
+  }
+}
+
+// PEM private keys are awkward in env vars; accept a literal multi-line value or
+// one with escaped newlines (`\n`). Empty/absent → null (private repos off).
+function normalizePem(raw: string | undefined): string | null {
+  if (raw == null || raw === '') return null
+  return raw.includes('\\n') ? raw.replaceAll('\\n', '\n') : raw
+}

package/server-managed/content-access.ts

@@ -0,0 +1,15 @@
+import type { ManagedDb, StoredUser } from './db.ts'
+
+export type RepoScope = { repoId: number; path: string | null }
+type Content = { repoId: number | null; repoDirectory?: string }
+
+// Read grants for each request: neither the manager role nor a cached page
+// confers repository access. Bundles have repository scope; reports also have
+// a directory scope. Unassigned content is only available to administrators.
+export async function contentAccess(db: ManagedDb, user: StoredUser) {
+  const scopes = user.role === 'admin' ? null : await db.listRepoScopesForUser(user.id)
+  const bundle = (item: Content) => scopes == null || scopes.some(scope => scope.repoId === item.repoId)
+  const report = (item: Content) => scopes == null || scopes.some(scope => scope.repoId === item.repoId
+    && (!scope.path || item.repoDirectory === scope.path || item.repoDirectory?.startsWith(scope.path + '/')))
+  return { scopes, bundle, report }
+}

package/server-managed/crypto.ts

@@ -0,0 +1,25 @@
+// Token helpers for the managed auth server. The raw session token lives ONLY
+// in the cookie; the DB row id is its SHA-256 (see db.ts / session.ts), so a
+// DB read can't reconstruct a live cookie. No HMAC pepper is needed — the
+// tokens are 256-bit random, not guessable or reversible from their hash.
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto'
+
+// 256-bit URL-safe random token: the session cookie value and the OAuth CSRF
+// `state` nonce.
+export function randomToken(): string {
+  return randomBytes(32).toString('base64url')
+}
+
+// At-rest id for a session cookie token (stored as the managed_session PK).
+export function hashToken(token: string): string {
+  return createHash('sha256').update(token, 'utf8').digest('base64url')
+}
+
+// Constant-time equality for CSRF / OAuth-state checks. A length mismatch
+// short-circuits (the length of these fixed-width tokens isn't a secret).
+export function safeEqual(a: string, b: string): boolean {
+  const ab = Buffer.from(a, 'utf8')
+  const bb = Buffer.from(b, 'utf8')
+  if (ab.length !== bb.length) return false
+  return timingSafeEqual(ab, bb)
+}