@preventive/triage 1.0.0-alpha.25 → 1.0.0-alpha.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preventive/triage",
-  "version": "1.0.0-alpha.25",
+  "version": "1.0.0-alpha.27",
   "description": "Client & relay server for triaging of automated reports",
   "license": "MIT",
   "author": {
@@ -89,7 +89,6 @@
     "server-managed/activity.ts",
     "server-managed/avatar-store.ts",
     "server-managed/blob-store.ts",
-    "server-managed/blob-vercel.ts",
     "server-managed/brotli.ts",
     "server-managed/bundle-cache.ts",
     "server-managed/bundle-catalog.ts",
@@ -120,6 +119,9 @@
     "server-managed/import-triage.ts",
     "server-managed/managed-issues.ts",
     "server-managed/management.ts",
+    "server-managed/object-storage.ts",
+    "server-managed/object-storage-disk.ts",
+    "server-managed/object-storage-vercel.ts",
     "server-managed/index.ts",
     "server-managed/package-entry-points.ts",
     "server-managed/public-workspace.ts",
@@ -133,10 +135,17 @@
     "server-managed/repository-policy.ts",
     "server-managed/session.ts",
     "server-managed/slugs.ts",
+    "server-managed/solidity-entry-points.ts",
     "server-managed/sql-postgres.ts",
     "server-managed/sql.ts",
     "server-managed/static.ts",
     "server-managed/storage.ts",
+    "server-managed/storage-command.ts",
+    "server-managed/storage-db.ts",
+    "server-managed/storage-encryption.ts",
+    "server-managed/storage-maintenance.ts",
+    "server-managed/storage-payload.ts",
+    "server-managed/storage-stores.ts",
     "server-managed/team-catalog.ts",
     "server-managed/team-feed.ts",
     "server-managed/team-reports.ts",
@@ -150,6 +159,7 @@
     "server-common/origin.ts",
     "server-common/standalone.ts",
     "server-common/storage-log.ts",
+    "server-common/storage-crypto.ts",
     "server-common/vercel-blob.ts",
     "server-common/scan-config.ts",
     "report/index.js",

package/server-common/storage-crypto.ts

@@ -0,0 +1,182 @@
+// Storage envelope v1: header, then 64 KiB plaintext chunks with full AEAD tags.
+// The nonce layout follows age's STREAM construction (counter || final flag).
+// Every write derives a new key, including rewrites of the same logical object.
+import { Buffer } from 'node:buffer'
+import { createCipheriv, createDecipheriv, createHash, hkdfSync, randomBytes } from 'node:crypto'
+import { Readable } from 'node:stream'
+
+export const STORAGE_MAGIC = Buffer.from('DeepView.storage')
+const VERSION = 1
+export const STORAGE_CHUNK_BYTES = 65_536
+export const STORAGE_HEADER_BYTES = 57
+const TAG_BYTES = 16
+const UNKNOWN_SIZE = 0xffff_ffff_ffff_ffffn
+
+export interface StorageKey { bytes: Buffer; id: string }
+
+export function parseStorageKey(value: string | null | undefined): StorageKey | null {
+  if (value == null || value === '') return null
+  const bytes = Buffer.from(value, 'base64')
+  if (bytes.length !== 32 || bytes.toString('base64') !== value) {
+    throw new Error('MANAGED_STORAGE_ENCRYPTION_KEY must be canonical base64 encoding of 32 random bytes')
+  }
+  const id = createHash('sha256').update('deepview.storage.key.v1\0').update(bytes).digest('hex').slice(0, 32)
+  return { bytes, id }
+}
+
+// Re-chunk without accumulating a file, regardless of the input's read sizes.
+async function* chunks(source: AsyncIterable<Uint8Array>, size: number): AsyncGenerator<Buffer> {
+  let length = 0, pending: Buffer[] = []
+  for await (const value of source) {
+    const input = Buffer.from(value.buffer, value.byteOffset, value.byteLength)
+    for (let offset = 0; offset < input.length;) {
+      const n = Math.min(size - length, input.length - offset)
+      pending.push(input.subarray(offset, offset + n)); length += n; offset += n
+      if (length === size) { yield Buffer.concat(pending, length); pending = []; length = 0 }
+    }
+  }
+  if (length) yield Buffer.concat(pending, length)
+}
+
+async function* frames(source: AsyncIterable<Uint8Array>, size: number) {
+  const iterator = chunks(source, size)[Symbol.asyncIterator]()
+  try {
+    let current = await iterator.next()
+    if (current.done) { yield { bytes: Buffer.alloc(0), last: true }; return }
+    while (!current.done) {
+      const next = await iterator.next()
+      yield { bytes: current.value, last: next.done === true }
+      current = next
+    }
+  } finally { await iterator.return(undefined) }
+}
+
+function nonce(index: number, last: boolean): Buffer {
+  if (!Number.isSafeInteger(index) || index < 0 || index > 0xffff_ffff) throw new Error('Storage object has too many chunks')
+  const value = Buffer.alloc(12)
+  value.writeUInt32BE(index, 7)
+  value[11] = last ? 1 : 0
+  return value
+}
+
+function objectKey(key: Uint8Array, header: Buffer, identity: string): Buffer {
+  return Buffer.from(hkdfSync('sha256', key, header.subarray(17, 49),
+    Buffer.from(JSON.stringify(['deepview.storage.v1', identity])), 32))
+}
+
+function makeHeader(size: number | null): Buffer {
+  if (size !== null && (!Number.isSafeInteger(size) || size < 0)) throw new Error('Invalid storage size')
+  const header = Buffer.alloc(STORAGE_HEADER_BYTES)
+  STORAGE_MAGIC.copy(header); header[16] = VERSION
+  randomBytes(32).copy(header, 17)
+  header.writeBigUInt64BE(size === null ? UNKNOWN_SIZE : BigInt(size), 49)
+  return header
+}
+
+export function encryptStorageStream(source: Readable, key: Uint8Array, identity: string, size: number | null): Readable {
+  async function* encrypt() {
+    const header = makeHeader(size)
+    const derived = objectKey(key, header, identity)
+    let index = 0, length = 0
+    try {
+      yield header
+      for await (const { bytes, last } of frames(source, STORAGE_CHUNK_BYTES)) {
+        length += bytes.length
+        if (last && size !== null && length !== size) throw new Error('Storage size changed while encrypting')
+        const cipher = createCipheriv('chacha20-poly1305', derived, nonce(index++, last), { authTagLength: TAG_BYTES })
+        cipher.setAAD(header)
+        yield Buffer.concat([cipher.update(bytes), cipher.final(), cipher.getAuthTag()])
+      }
+    } finally { derived.fill(0); source.destroy() }
+  }
+  const stream = Readable.from(encrypt(), { objectMode: false })
+  stream.once('close', () => source.destroy())
+  return stream
+}
+
+// Read just the envelope and authenticate the first frame before returning.
+// In particular, never trust a corrupted size or release update() output
+// before final() authenticates the complete chunk.
+export async function decryptStorageStream(source: Readable, key: Uint8Array, identity: string) {
+  const iterator = source[Symbol.asyncIterator]()
+  let done = false
+  let peek: Buffer = Buffer.alloc(0), remainder: Buffer = Buffer.alloc(0)
+  async function read(size: number): Promise<Buffer> {
+    const parts: Buffer[] = peek.length > 0 ? [peek] : []
+    let length = peek.length
+    peek = Buffer.alloc(0)
+    while (length < size) {
+      if (remainder.length === 0 && !done) {
+        const next = await iterator.next(); done = next.done === true
+        remainder = done ? Buffer.alloc(0) : next.value
+      }
+      if (remainder.length === 0 && done) break
+      const n = Math.min(size - length, remainder.length)
+      parts.push(remainder.subarray(0, n)); remainder = remainder.subarray(n); length += n
+    }
+    return Buffer.concat(parts, length)
+  }
+  let derived: Buffer | undefined
+  try {
+    const header = await read(STORAGE_HEADER_BYTES)
+    if (header.length !== STORAGE_HEADER_BYTES || !header.subarray(0, 16).equals(STORAGE_MAGIC) || header[16] !== VERSION) {
+      throw new Error('Invalid encrypted storage envelope')
+    }
+    const rawSize = header.readBigUInt64BE(49)
+    if (rawSize !== UNKNOWN_SIZE && rawSize > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error('Invalid encrypted storage size')
+    const size = rawSize === UNKNOWN_SIZE ? null : Number(rawSize)
+    derived = objectKey(key, header, identity)
+    const derivedKey = derived
+    let index = 0, length = 0
+    const nextFrame = async () => {
+      const bytes = await read(STORAGE_CHUNK_BYTES + TAG_BYTES)
+      // Peek beyond the frame: EOF authenticates the final flag, including
+      // exact chunk boundaries. Keep the byte for the next read.
+      peek = await read(1)
+      const last = peek.length === 0
+      if (bytes.length < TAG_BYTES || (index > 0 && bytes.length === TAG_BYTES)) throw new Error('Truncated encrypted storage object')
+      const decipher = createDecipheriv('chacha20-poly1305', derivedKey, nonce(index++, last), { authTagLength: TAG_BYTES })
+      decipher.setAAD(header); decipher.setAuthTag(bytes.subarray(-TAG_BYTES))
+      const plain = Buffer.concat([decipher.update(bytes.subarray(0, -TAG_BYTES)), decipher.final()])
+      length += plain.length
+      if (size !== null && (length > size || (last && length !== size))) throw new Error('Encrypted storage size mismatch')
+      return { plain, last }
+    }
+    const first = await nextFrame()
+    const decrypt = async function* () {
+      try {
+        yield first.plain
+        let last = first.last
+        while (!last) { const frame = await nextFrame(); last = frame.last; yield frame.plain }
+      } finally { derivedKey.fill(0); await iterator.return?.(); source.destroy() }
+    }
+    const stream = Readable.from(decrypt(), { objectMode: false })
+    stream.once('close', () => { derivedKey.fill(0); source.destroy() })
+    return { size, stream }
+  } catch (err) { derived?.fill(0); source.destroy(); throw err }
+}
+
+// Small SQL values (data keys, OAuth tokens and the installation sentinel).
+// Fresh salt derives a one-use wrapping key, so the nonce can be all zeroes.
+// The version and master-key ID are authenticated along with the row/field.
+export function wrapStorageValue(key: StorageKey, identity: string, value: Uint8Array): string {
+  const header = Buffer.concat([Buffer.from([1]), Buffer.from(key.id, 'hex'), randomBytes(32)])
+  const derived = Buffer.from(hkdfSync('sha256', key.bytes, header.subarray(17), 'deepview.wrap.v1', 32))
+  try {
+    const cipher = createCipheriv('chacha20-poly1305', derived, Buffer.alloc(12), { authTagLength: TAG_BYTES })
+    cipher.setAAD(Buffer.concat([header, Buffer.from(identity)]))
+    return Buffer.concat([header, cipher.update(value), cipher.final(), cipher.getAuthTag()]).toString('base64')
+  } finally { derived.fill(0) }
+}
+
+export function unwrapStorageValue(key: StorageKey, identity: string, value: string): Buffer {
+  const bytes = Buffer.from(value, 'base64'), header = bytes.subarray(0, 49)
+  if (bytes.length < 65 || bytes.toString('base64') !== value || header[0] !== 1
+    || header.subarray(1, 17).toString('hex') !== key.id) throw new Error('Invalid wrapped storage value or encryption key')
+  const derived = Buffer.from(hkdfSync('sha256', key.bytes, header.subarray(17), 'deepview.wrap.v1', 32))
+  try {
+    const decipher = createDecipheriv('chacha20-poly1305', derived, Buffer.alloc(12), { authTagLength: TAG_BYTES })
+    decipher.setAAD(Buffer.concat([header, Buffer.from(identity)])); decipher.setAuthTag(bytes.subarray(-TAG_BYTES))
+    return Buffer.concat([decipher.update(bytes.subarray(49, -TAG_BYTES)), decipher.final()])
+  } finally { derived.fill(0) }
+}

package/server-common/storage-log.ts

@@ -19,11 +19,15 @@ export function e2eStorageLines(config: DatabaseConfig & { objstoreDir: string }
   ]
 }
 
-export function managedStorageLines(config: DatabaseConfig): string[] {
+export function managedStorageLines(config: DatabaseConfig & { storageEncryptionKey?: string | null }): string[] {
   const dir = dirname(config.dbPath)
   const location = (path: string) => config.neonUrl ? `Vercel Blob (private), .managed/${path}/` : resolve(dir, path)
   return [
     `  Managed database: ${databaseLocation(config)}`,
+    ...(config.storageEncryptionKey ? [
+      '  Managed storage encryption: ChaCha20-Poly1305',
+      `  Managed encrypted caches: ${location('cache-encrypted-v1')}`,
+    ] : []),
     `  Managed reports: ${location('reports')}`,
     `  Managed bundles: ${location('bundles')}`,
     `  Managed avatars: ${location('avatars')}`,

package/server-common/vercel-blob.ts

@@ -18,6 +18,7 @@ import type { Buffer } from 'node:buffer'
 type VercelBlobBody = Readable | Buffer | string | Blob | ArrayBuffer | ReadableStream<Uint8Array>
 export type VercelBlobSdk = {
   BlobNotFoundError: new () => Error
+  BlobPreconditionFailedError?: new () => Error
   put: (
     pathname: string,
     body: VercelBlobBody,
@@ -27,6 +28,7 @@ export type VercelBlobSdk = {
       allowOverwrite?: boolean
       contentType?: string
       token?: string
+      ifMatch?: string
       multipart?: boolean
       abortSignal?: AbortSignal
       cacheControlMaxAge?: number
@@ -35,7 +37,7 @@ export type VercelBlobSdk = {
   head: (
     pathname: string,
     options?: { token?: string; abortSignal?: AbortSignal },
-  ) => Promise<{ size: number; pathname: string; url: string }>
+  ) => Promise<{ size: number; pathname: string; url: string; etag?: string; uploadedAt?: Date | string | number }>
   get: (
     pathname: string,
     options: {
@@ -47,7 +49,7 @@ export type VercelBlobSdk = {
   ) => Promise<{
     statusCode: 200 | 304
     stream: ReadableStream<Uint8Array> | null
-    blob: { size: number | null }
+    blob: { size: number | null; etag?: string; uploadedAt?: Date | string | number }
   } | null>
   copy: (
     fromPathname: string,
@@ -63,7 +65,7 @@ export type VercelBlobSdk = {
   ) => Promise<{ url: string; pathname: string }>
   del: (
     urlOrPathname: string | string[],
-    options?: { token?: string; abortSignal?: AbortSignal },
+    options?: { token?: string; abortSignal?: AbortSignal; ifMatch?: string },
   ) => Promise<void>
   list: (options: {
     prefix?: string
@@ -71,6 +73,7 @@ export type VercelBlobSdk = {
     limit?: number
     mode?: 'expanded' | 'folded'
     token?: string
+    abortSignal?: AbortSignal
   }) => Promise<{
     // `uploadedAt` (a Date per the SDK v2 surface) is the blob's
     // creation time — used by the reaper's GC grace window. Optional

package/server-e2e/config.ts

@@ -54,6 +54,10 @@ Environment:
   DEEPVIEW_SCAN_SERVER       optional HTTP(S) scan-service URL; advertised
                              in /api/config and allowed by the UI CSP.
                              Unset by default (no external scan service).
+  GITHUB_NEW_ISSUE_LABELS    optional comma-separated labels for the client's
+                             prefilled GitHub issue form, in addition to
+                             deepview and security (for security findings).
+                             Advertised in /api/config and sync connections.
   DB_PATH                    sqlite file (default: server-e2e/data/data.db);
                              ignored when an e2e database URL is set
   DATABASE_URL               shared Neon Postgres URL for enabled modes.

package/server-managed/avatar-store.ts

@@ -1,12 +1,4 @@
-// Avatar cache for the managed server. The user's GitHub avatar is fetched once
-// at login (see github-oauth.ts) and served same-origin from GET
-// /api/auth/avatar — the app's CSP is `img-src 'self'`, so the GitHub-hosted
-// original can't be loaded by the page directly.
-//
-// The disk backend uses a dir beside SQLite; blob-vercel.ts implements the
-// same AvatarStore interface for remote storage. Keyed by the user's opaque `id`.
-import { mkdir, readFile, writeFile } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
+// Shared avatar cache interface, implemented by storage-stores.ts.
 import type { Buffer } from 'node:buffer'
 
 export interface CachedAvatar {
@@ -18,34 +10,3 @@ export interface AvatarStore {
   put(id: string, contentType: string, bytes: Buffer): Promise<void>
   get(id: string): Promise<CachedAvatar | null>
 }
-
-// The user id is a v4 uuid (crypto.randomUUID) — lowercase hex + dashes, no
-// path separators. Validated anyway so a crafted id can't escape the store dir.
-const ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u
-
-export function createDiskAvatarStore(dir: string): AvatarStore {
-  function pathFor(id: string): string {
-    if (!ID_RE.test(id)) throw new Error('invalid avatar id')
-    return join(dir, id)
-  }
-  return {
-    async put(id, contentType, bytes) {
-      const p = pathFor(id)
-      await mkdir(dirname(p), { recursive: true })
-      // Bytes first, then the content-type sidecar — a crash between the two
-      // leaves a typeless blob that `get` treats as missing (re-fetched next
-      // login) rather than serving with a wrong/absent type.
-      await writeFile(p, bytes)
-      await writeFile(`${p}.type`, contentType, 'utf8')
-    },
-    async get(id) {
-      try {
-        const p = pathFor(id)
-        const [bytes, contentType] = await Promise.all([readFile(p), readFile(`${p}.type`, 'utf8')])
-        return { bytes, contentType: contentType.trim() || 'application/octet-stream' }
-      } catch {
-        return null
-      }
-    },
-  }
-}

package/server-managed/blob-store.ts

@@ -1,14 +1,4 @@
-// Disk byte-store for the managed server's stored blobs (uploaded reports and
-// bundles). Unlike the e2e relay (which only ever holds opaque client-encrypted
-// blobs), a managed server is TRUSTED and stores the bytes in the clear so it
-// can operate on them — the metadata + attribution live in the DB, the bytes
-// live here, keyed by the blob's opaque `id`.
-//
-// The disk backend uses a dir beside SQLite (data/reports/<uuid> or
-// data/bundles/<uuid>); blob-vercel.ts implements the same interface remotely. Bytes only — the
-// content-type / filename / integrity ride the DB row, so there's no sidecar.
-import { mkdir, open, readFile, rm, writeFile } from 'node:fs/promises'
-import { dirname, join } from 'node:path'
+// Logical upload-store interfaces shared by disk and Vercel storage.
 import type { Buffer } from 'node:buffer'
 import type { Readable } from 'node:stream'
 
@@ -19,48 +9,9 @@ export interface OpenedBlob {
 }
 
 export interface BlobStore {
-  put(id: string, bytes: Buffer): Promise<void>
+  // Encrypted upload stores return the wrapped data key for the SQL insert.
+  put(id: string, bytes: Buffer): Promise<string | null>
   get(id: string): Promise<Buffer | null>
   open(id: string): Promise<OpenedBlob | null>
   delete(id: string): Promise<void>
 }
-
-// The blob id is a v4 uuid (crypto.randomUUID) — lowercase hex + dashes, no
-// path separators. Validated anyway so a crafted id can't escape the store dir.
-const ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u
-
-export function createDiskBlobStore(dir: string, suffix = ''): BlobStore {
-  function pathFor(id: string): string {
-    if (!ID_RE.test(id)) throw new Error('invalid blob id')
-    return join(dir, id + suffix)
-  }
-  return {
-    async put(id, bytes) {
-      const p = pathFor(id)
-      await mkdir(dirname(p), { recursive: true })
-      await writeFile(p, bytes)
-    },
-    async get(id) {
-      try {
-        return await readFile(pathFor(id))
-      } catch {
-        return null
-      }
-    },
-    async open(id) {
-      let file
-      try { file = await open(pathFor(id), 'r') }
-      catch (err) { if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null; throw err }
-      try {
-        const info = await file.stat()
-        // Remain paused until piped. HEAD can close without reading the body.
-        return { size: info.size, stream: file.createReadStream() }
-      } catch (err) { await file.close(); throw err }
-    },
-    async delete(id) {
-      // `force` so a missing file (already gone) is a no-op, not a throw — the
-      // metadata row is the source of truth for whether a blob "exists".
-      await rm(pathFor(id), { force: true })
-    },
-  }
-}

package/server-managed/bundle-cache.ts

@@ -1,9 +1,6 @@
 // Metadata is cached as Brotli. Contents use the stored Brotli bytes directly:
 // unchanged Stasis uploads or sourcemaps compressed once at upload.
 import { Buffer } from 'node:buffer'
-import { mkdir, open, rename, rm, stat, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { randomUUID } from 'node:crypto'
 import { brotliDecompress } from 'node:zlib'
 import { promisify } from 'node:util'
 import { BUNDLE_METADATA_VERSION, type BundleDetails, createBundleMetadata, createBundleSummary, parseBundleContents } from '../common/bundle-metadata.js'
@@ -158,28 +155,3 @@ export function createBundleCache(storage: BundleCacheStorage, db: ManagedDb, st
   }
 }
 export type BundleCache = ReturnType<typeof createBundleCache>
-
-export function createDiskBundleCache(dir: string, db: ManagedDb, store: BundleStore): BundleCache {
-  function directory(id: string) {
-    if (!/^[a-f\d-]{36}$/iu.test(id)) throw new Error('Invalid bundle id')
-    return join(dir, id)
-  }
-  return createBundleCache({
-    async exists(id, file) {
-      try { await stat(join(directory(id), file)); return true }
-      catch (err) { if ((err as NodeJS.ErrnoException).code === 'ENOENT') return false; throw err }
-    },
-    async put(id, file, bytes) {
-      await mkdir(directory(id), { recursive: true })
-      const target = join(directory(id), file), temp = `${target}.${randomUUID()}.tmp`
-      try { await writeFile(temp, bytes); await rename(temp, target) }
-      finally { await rm(temp, { force: true }) }
-    },
-    async open(id, name) {
-      const file = await open(join(directory(id), name), 'r')
-      try { return { size: (await file.stat()).size, stream: file.createReadStream() } }
-      catch (err) { await file.close(); throw err }
-    },
-    async delete(id) { await rm(directory(id), { recursive: true, force: true }) },
-  }, db, store)
-}

package/server-managed/bundle-store.ts

@@ -1,11 +1,11 @@
 // 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 type { BlobStore, OpenedBlob } from './blob-store.ts'
 import { encodeBrotli } from './brotli.ts'
 
 export interface BundleStore {
-  put(id: string, bytes: Buffer, kind: string | null): Promise<void>
+  put(id: string, bytes: Buffer, kind: string | null): Promise<string | null>
   get(id: string, kind: string | null): Promise<Buffer | null>
   open(id: string, kind: string | null): Promise<OpenedBlob | null>
   delete(id: string): Promise<void>
@@ -15,14 +15,10 @@ export function createBundleStore(archives: BlobStore, sourcemaps: BlobStore): B
   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)
+      return 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/cache-storage.ts

@@ -1,7 +1,4 @@
 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.
@@ -16,25 +13,3 @@ 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

@@ -9,5 +9,13 @@
 // 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()
+const command = process.argv[2]
+if (command === '--storage-encryption-status') {
+  const { storageCommand } = await import('./storage-command.ts')
+  await storageCommand(process.argv[3])
+} else if (command) {
+  throw new Error(`Unknown command: ${command}`)
+} else {
+  const { start } = await import('./index.ts')
+  await start()
+}

package/server-managed/config.ts

@@ -3,6 +3,8 @@
 // GitHub App can provide both flows, with repository grants at installation.
 import { env } from 'node:process'
 import { databaseUrls } from '../server-common/database-config.ts'
+import { MAX_UPLOAD_BYTES } from './uploads.ts'
+import { parseStorageKey } from '../server-common/storage-crypto.ts'
 
 const LOOPBACK_HOSTS = new Set(['127.0.0.1', '::1', 'localhost'])
 
@@ -12,6 +14,10 @@ export interface ManagedConfig {
   dbPath: string
   neonUrl?: string | null
   blobToken?: string | null
+  storageEncryptionKey?: string | null
+  storageEncryptionMigrate?: boolean
+  storageEncryptionMigrateMaxMs?: number
+  vercelPreview?: boolean
   serverless?: boolean
   debug: boolean
   allowShare: boolean
@@ -87,6 +93,10 @@ export function loadManagedConfig({ combined = false } = {}): ManagedConfig {
   const serverless = env['VERCEL'] === '1'
   const neonUrl = databaseUrls({ combined }).managed
   const blobToken = env['BLOB_READ_WRITE_TOKEN'] || null
+  const storageEncryptionKey = env['MANAGED_STORAGE_ENCRYPTION_KEY'] || null
+  parseStorageKey(storageEncryptionKey)
+  const storageEncryptionMigrate = env['MANAGED_STORAGE_ENCRYPTION_MIGRATE'] === '1'
+  if (storageEncryptionMigrate && !storageEncryptionKey) fail('MANAGED_STORAGE_ENCRYPTION_MIGRATE requires MANAGED_STORAGE_ENCRYPTION_KEY.')
   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'
@@ -104,7 +114,9 @@ export function loadManagedConfig({ combined = false } = {}): ManagedConfig {
     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,
+    neonUrl, blobToken, serverless, storageEncryptionKey, storageEncryptionMigrate,
+    storageEncryptionMigrateMaxMs: intEnv('MANAGED_STORAGE_ENCRYPTION_MIGRATE_MAX_MS', 150_000, 1, serverless ? 240_000 : 3_600_000),
+    vercelPreview: env['VERCEL_ENV'] === 'preview',
     port: intEnv('PORT', 8765, 0, 65535),
     host,
     // DB_PATH belongs to e2e in a combined process. Keep the two stores apart.
@@ -124,7 +136,7 @@ export function loadManagedConfig({ combined = false } = {}): ManagedConfig {
     githubAppSlug: env['GITHUB_APP_SLUG'] ?? null,
     githubNewIssueLabels: env['GITHUB_NEW_ISSUE_LABELS'] ?? '',
     maxReportBytes: intEnv('MAX_REPORT_BYTES', 10_485_760, 1, 104_857_600),
-    maxBundleBytes: intEnv('MAX_BUNDLE_BYTES', 209_715_200, 1, 1_073_741_824),
+    maxBundleBytes: intEnv('MAX_BUNDLE_BYTES', 209_715_200, 1, MAX_UPLOAD_BYTES),
     triageHistoryLimit: intEnv('TRIAGE_HISTORY_LIMIT', 0, 0, 1_000_000_000),
   }
 }