@preventive/triage 1.0.0-alpha.19 → 1.0.0-alpha.20

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 for the first registration in an empty DB.
+  // This never changes an existing user's role on later logins.
+  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)
+}