devpush 0.0.0-stage → 1.0.0-beta.3

package/src/server/logs/budget.ts

@@ -0,0 +1,72 @@
+import { sql } from 'drizzle-orm'
+import { db } from '#devpush/server/db'
+import { rateLimits } from '#devpush/server/db/schema'
+import type { RuntimeLogLimits } from '#devpush/plugins/contract'
+
+/** Atomic, persistent reservations. Failed writes retain their reservation (fail closed). */
+export async function reserveLogBudget({
+  teamId,
+  kind,
+  amount,
+  limit,
+  windowMs,
+  now = Date.now(),
+}: {
+  teamId: string
+  kind: string
+  amount: number
+  limit: number
+  windowMs: number
+  now?: number
+}) {
+  if (!Number.isSafeInteger(limit) || limit < 1)
+    throw new Error('Invalid runtime log budget.')
+  if (!Number.isSafeInteger(amount) || amount < 1 || amount > limit)
+    return false
+  const resetAt = new Date((Math.floor(now / windowMs) + 1) * windowMs)
+  const timestamp = new Date(now)
+  const count = sql<number>`case when ${rateLimits.resetAt} <= ${timestamp} then ${amount} else ${rateLimits.count} + ${amount} end`
+  const result = await db
+    .insert(rateLimits)
+    .values({ key: `runtime-log:${kind}:${teamId}`, count: amount, resetAt })
+    .onConflictDoUpdate({
+      target: rateLimits.key,
+      set: {
+        count,
+        resetAt: sql`case when ${rateLimits.resetAt} <= ${timestamp} then ${resetAt} else ${rateLimits.resetAt} end`,
+      },
+      setWhere: sql`${count} <= ${limit}`,
+    })
+    .returning({ key: rateLimits.key })
+  return result.length === 1
+}
+
+export async function admitRuntimeLogs(
+  teamId: string,
+  limits: RuntimeLogLimits,
+  rows: readonly { content: string; searchContent: string }[],
+) {
+  for (const value of Object.values(limits)) {
+    if (!Number.isSafeInteger(value) || value < 1)
+      throw new Error('Invalid runtime log limits.')
+  }
+  const encoder = new TextEncoder()
+  // Include both stored text columns and an allowance for row identifiers/metadata.
+  const bytes = rows.reduce(
+    (sum, row) =>
+      sum +
+      encoder.encode(row.content).length +
+      encoder.encode(row.searchContent).length +
+      256,
+    0,
+  )
+  for (const [kind, amount, limit, windowMs] of [
+    ['minute', bytes, limits.bytesPerMinute, 60_000],
+    ['day', bytes, limits.bytesPerDay, 86_400_000],
+    ['rows', rows.length, limits.rowsPerDay, 86_400_000],
+  ] as const) {
+    if (!(await reserveLogBudget({ teamId, kind, amount, limit, windowMs })))
+      return false
+  }
+  return true
+}

package/src/server/logs/cleanup.ts

@@ -0,0 +1,64 @@
+import { eq, gt, inArray, sql } from 'drizzle-orm'
+
+import { db, logsDb } from '#devpush/server/db'
+import {
+  deploymentLogs,
+  logCleanupPositions,
+} from '#devpush/server/db/log-schema'
+import { deployments } from '#devpush/server/db/schema'
+
+const positionId = 'deployment-output'
+
+// Cross-file foreign keys cannot cascade. Walk indexed deployment identities
+// incrementally and delete only output whose main deployment no longer exists.
+export async function pruneOrphanDeploymentLogs() {
+  const [position] = await logsDb
+    .select()
+    .from(logCleanupPositions)
+    .where(eq(logCleanupPositions.id, positionId))
+  const cursor = position?.cursor ?? null
+  const candidates = await logsDb
+    .selectDistinct({ id: deploymentLogs.deploymentId })
+    .from(deploymentLogs)
+    .where(cursor ? gt(deploymentLogs.deploymentId, cursor) : undefined)
+    .orderBy(deploymentLogs.deploymentId)
+    .limit(80)
+  const ids = candidates.map((row) => row.id)
+  const live = ids.length
+    ? await db
+        .select({ id: deployments.id })
+        .from(deployments)
+        .where(inArray(deployments.id, ids))
+    : []
+  const existing = new Set(live.map((row) => row.id))
+  const missing = ids.filter((id) => !existing.has(id))
+  // Stay on this range while orphan output remains, even when one deployment
+  // has much more than a batch of output. Each run deletes at most 1,000 rows.
+  const nextCursor = missing.length ? cursor : (candidates.at(-1)?.id ?? null)
+  const savePosition = logsDb
+    .insert(logCleanupPositions)
+    .values({ id: positionId, cursor: nextCursor })
+    .onConflictDoUpdate({
+      target: logCleanupPositions.id,
+      set: { cursor: nextCursor },
+    })
+  if (!missing.length) {
+    await savePosition
+    return { checked: ids.length, deleted: 0 }
+  }
+  const [deleted] = await logsDb.batch([
+    logsDb
+      .delete(deploymentLogs)
+      .where(
+        sql`rowid in (
+      select rowid from ${deploymentLogs}
+      where ${inArray(deploymentLogs.deploymentId, missing)}
+      order by ${deploymentLogs.deploymentId}, ${deploymentLogs.stream}, ${deploymentLogs.seq}
+      limit 1000
+    )`,
+      )
+      .returning({ seq: deploymentLogs.seq }),
+    savePosition,
+  ])
+  return { checked: ids.length, deleted: deleted.length }
+}

package/src/server/logs/deployments.ts

@@ -0,0 +1,98 @@
+import { config } from '#devpush/server/config'
+import { and, eq, sql } from 'drizzle-orm'
+
+import { logsDb } from '#devpush/server/db'
+import { deploymentLogs } from '#devpush/server/db/log-schema'
+
+type Identity = {
+  projectId: string
+  environmentId: string
+  deploymentId: string
+  serverId: string
+  branch: string
+}
+
+// Identity must come from the authorized main deployment lookup, never the
+// agent payload.
+export async function appendDeploymentLogs(
+  identity: Identity,
+  startSeq: number,
+  lines: string[],
+) {
+  if (
+    !Number.isSafeInteger(startSeq) ||
+    startSeq < 1 ||
+    !Number.isSafeInteger(startSeq + lines.length - 1)
+  )
+    throw new Error('A positive deployment log sequence is required.')
+  const maxLines = config.DEVPUSH_DEPLOYMENT_LOG_MAX_LINES
+  const lineBytes = config.DEVPUSH_DEPLOYMENT_LOG_LINE_BYTES
+  const bounded = lines
+    .slice(0, Math.max(0, maxLines - startSeq + 1))
+    .map((content) => {
+      const bytes = new TextEncoder().encode(content)
+      if (bytes.length <= lineBytes) return content
+      const suffix = '… [line truncated]'
+      const max = lineBytes - new TextEncoder().encode(suffix).length
+      let end = max
+      while (end > 0 && (bytes[end]! & 0xc0) === 0x80) end--
+      return new TextDecoder().decode(bytes.subarray(0, end)) + suffix
+    })
+  const rows = bounded.map((content, index) => ({
+    seq: startSeq + index,
+    content,
+  }))
+  if (lines.length && startSeq + lines.length - 1 > maxLines)
+    rows.push({
+      seq: maxLines + 1,
+      content:
+        '[devpush] Deployment log limit reached. Further output was omitted; deployment execution is unaffected.',
+    })
+  const createdAt = new Date()
+  for (let offset = 0; offset < rows.length; offset += 32) {
+    const statements = []
+    for (
+      let start = offset;
+      start < Math.min(offset + 32, rows.length);
+      start += 8
+    ) {
+      statements.push(
+        logsDb
+          .insert(deploymentLogs)
+          .values(
+            rows.slice(start, start + 8).map(({ content, seq }) => ({
+              ...identity,
+              stream: 'deploy',
+              seq,
+              content,
+              searchContent: content.toLowerCase(),
+              createdAt,
+            })),
+          )
+          .onConflictDoNothing({
+            target: [
+              deploymentLogs.deploymentId,
+              deploymentLogs.stream,
+              deploymentLogs.seq,
+            ],
+          })
+          .returning({ seq: deploymentLogs.seq }),
+      )
+    }
+    const [first, ...rest] = statements
+    if (first) await logsDb.batch([first, ...rest])
+  }
+}
+
+export async function nextDeploymentLogSeq(deploymentId: string) {
+  const [row] = await logsDb
+    .select({ value: sql<number>`coalesce(max(${deploymentLogs.seq}), 0) + 1` })
+    .from(deploymentLogs)
+    .where(
+      and(
+        eq(deploymentLogs.deploymentId, deploymentId),
+        eq(deploymentLogs.stream, 'deploy'),
+      ),
+    )
+  return Number(row?.value ?? 1)
+}

package/src/server/logs/operations.ts

@@ -0,0 +1,145 @@
+import { and, eq, sql, asc, inArray, gte } from 'drizzle-orm'
+import { z } from 'zod'
+import { auth } from '#devpush/server/auth/better-auth'
+import { db, logsDb } from '#devpush/server/db'
+import { operationLogs } from '#devpush/server/db/log-schema'
+import {
+  agentJobs,
+  projects,
+  teamMembers,
+  teams,
+  user,
+} from '#devpush/server/db/schema'
+import { requireAgentServer } from '#devpush/server/servers/service'
+import { AgentRequestError } from '#devpush/server/agents/protocol'
+
+const retentionMs = 14 * 24 * 60 * 60 * 1000
+const maxBytes = 10 * 1024 * 1024
+export const operationLogUploadSchema = z.object({
+  serverId: z.string().min(1),
+  token: z.string().min(1),
+  jobId: z.string().min(1),
+  offset: z.number().int().min(0).max(maxBytes),
+  content: z
+    .string()
+    .min(1)
+    .max(16 * 1024),
+})
+export async function uploadOperationLogs(
+  payload: z.infer<typeof operationLogUploadSchema>,
+) {
+  await requireAgentServer(payload)
+  const [job] = await db
+    .select({ id: agentJobs.id })
+    .from(agentJobs)
+    .where(
+      and(
+        eq(agentJobs.id, payload.jobId),
+        eq(agentJobs.serverId, payload.serverId),
+        inArray(agentJobs.type, ['backup', 'restore']),
+      ),
+    )
+    .limit(1)
+  if (!job)
+    throw new AgentRequestError(404, 'Operation not found for this server.')
+  const bytes = new TextEncoder().encode(payload.content).length
+  if (bytes > 16 * 1024 || payload.offset + bytes > maxBytes)
+    throw new AgentRequestError(409, 'Operation log size limit exceeded.')
+  const [existing] = await logsDb
+    .select()
+    .from(operationLogs)
+    .where(
+      and(
+        eq(operationLogs.jobId, job.id),
+        eq(operationLogs.offset, payload.offset),
+      ),
+    )
+    .limit(1)
+  if (existing && existing.content !== payload.content)
+    throw new AgentRequestError(
+      409,
+      'Operation log replay differs from stored output.',
+    )
+  if (!existing) {
+    const [last] = await logsDb
+      .select({
+        end: sql<number>`coalesce(max(${operationLogs.offset} + length(cast(${operationLogs.content} as blob))), 0)`,
+      })
+      .from(operationLogs)
+      .where(eq(operationLogs.jobId, job.id))
+    if (payload.offset !== Number(last?.end ?? 0))
+      throw new AgentRequestError(409, 'Operation log offset is out of order.')
+  }
+  await logsDb
+    .insert(operationLogs)
+    .values({ jobId: job.id, offset: payload.offset, content: payload.content })
+    .onConflictDoNothing({
+      target: [operationLogs.jobId, operationLogs.offset],
+    })
+  return { ok: true }
+}
+export async function readOperationLogs(request: Request) {
+  const current = await auth.api.getSession({ headers: request.headers })
+  if (!current) return new Response('Unauthorized', { status: 401 })
+  const url = new URL(request.url)
+  const type = url.searchParams.get('type')
+  const id = url.searchParams.get('id') ?? ''
+  const rawOffset = url.searchParams.get('offset') ?? '0'
+  const offset = Number(rawOffset)
+  if (
+    !/^\d+$/.test(rawOffset) ||
+    !Number.isSafeInteger(offset) ||
+    offset > maxBytes
+  )
+    return new Response('Invalid log offset', { status: 400 })
+  if (type !== 'backup' && type !== 'restore')
+    return new Response('Invalid operation', { status: 400 })
+  const [job] = await db
+    .select({ id: agentJobs.id })
+    .from(agentJobs)
+    .innerJoin(projects, eq(projects.id, agentJobs.projectId))
+    .innerJoin(teamMembers, eq(teamMembers.teamId, projects.teamId))
+    .innerJoin(teams, eq(teams.id, projects.teamId))
+    .innerJoin(user, eq(user.id, teamMembers.userId))
+    .where(
+      and(
+        eq(teamMembers.userId, current.user.id),
+        eq(teams.status, 'active'),
+        eq(projects.status, 'active'),
+        eq(user.status, 'active'),
+        eq(agentJobs.type, type),
+        type === 'restore'
+          ? eq(agentJobs.id, id)
+          : sql`json_extract(${agentJobs.payload}, '$.backupRunId') = ${id}`,
+      ),
+    )
+    .limit(1)
+  if (!job) return new Response('Operation not found', { status: 404 })
+  const rows = await logsDb
+    .select({ offset: operationLogs.offset, content: operationLogs.content })
+    .from(operationLogs)
+    .where(
+      and(
+        eq(operationLogs.jobId, job.id),
+        gte(operationLogs.offset, offset),
+        sql`${operationLogs.createdAt} >= ${Date.now() - retentionMs}`,
+      ),
+    )
+    .orderBy(asc(operationLogs.offset))
+
+  const content = rows.map((row) => row.content).join('')
+  // Uploads are contiguous; returned cursors are UTF-8 byte offsets at chunk
+  // boundaries. Reject arbitrary offsets that would silently skip a chunk.
+  if (offset > 0 && rows.length && rows[0]!.offset !== offset)
+    return new Response(
+      'Log offset is no longer available. Reopen the viewer.',
+      { status: 409 },
+    )
+  return Response.json({
+    content,
+    nextOffset: rows.length
+      ? rows.at(-1)!.offset +
+        new TextEncoder().encode(rows.at(-1)!.content).length
+      : offset,
+  })
+}

package/src/server/logs/retention.ts

@@ -0,0 +1,39 @@
+import { inArray, lt, sql } from 'drizzle-orm'
+
+import { logsDb } from '#devpush/server/db'
+import { runtimeLogs, operationLogs } from '#devpush/server/db/log-schema'
+
+export const runtimeLogRetentionMs = 24 * 60 * 60 * 1000
+export const runtimeLogPruneBatchSize = 1_000
+
+// Global cleanup includes runtimes that no longer report logs or whose main
+// records have been deleted. No cross-database foreign keys are available.
+export async function pruneExpiredRuntimeLogs(now = new Date()) {
+  const cutoff = new Date(now.getTime() - runtimeLogRetentionMs)
+  let deleted = 0
+  for (let batch = 0; batch < 10; batch++) {
+    const rows = await logsDb
+      .delete(runtimeLogs)
+      .where(
+        inArray(
+          runtimeLogs.id,
+          logsDb
+            .select({ id: runtimeLogs.id })
+            .from(runtimeLogs)
+            .where(lt(runtimeLogs.observedAt, cutoff))
+            .orderBy(runtimeLogs.observedAt, runtimeLogs.id)
+            .limit(runtimeLogPruneBatchSize),
+        ),
+      )
+      .returning({ id: runtimeLogs.id })
+    deleted += rows.length
+    if (rows.length < runtimeLogPruneBatchSize) break
+  }
+  // Operation diagnostics share this existing scheduled log-maintenance pass.
+  await logsDb
+    .delete(operationLogs)
+    .where(
+      sql`rowid in (select rowid from ${operationLogs} where ${operationLogs.createdAt} < ${now.getTime() - 14 * 24 * 60 * 60 * 1000} order by ${operationLogs.createdAt} limit 1000)`,
+    )
+  return { deleted }
+}

package/src/server/maintenance.ts

@@ -0,0 +1,61 @@
+import { pruneOperationalNotifications } from '#devpush/server/notifications/outbox'
+import { getPluginServices } from '#devpush/server/plugins/services.server'
+import { pruneDeletedResources } from '#devpush/server/deleted-resources'
+import { pruneApiHistory } from '#devpush/server/api/retention'
+import {
+  failStaleRunningDeployments,
+  failStaleQueuedDeployments,
+  failStaleAgentJobs,
+} from '#devpush/server/agents/jobs'
+import { queueBackupRetentionCleanupJobs } from '#devpush/server/backups/service'
+import { cleanupExpiredRateLimits } from '#devpush/server/http/rate-limit'
+import { cleanupExpiredTeamInvites } from '#devpush/server/teams/service'
+import { runQueuedUserCleanupJobs } from '#devpush/server/users/service'
+import { pruneServerMonitoring } from '#devpush/server/servers/monitoring'
+import { pruneExpiredRuntimeLogs } from '#devpush/server/logs/retention'
+import { pruneOrphanDeploymentLogs } from '#devpush/server/logs/cleanup'
+
+export async function runMaintenance() {
+  const [
+    expiredInvites,
+    staleDeployments,
+    staleQueuedDeployments,
+    staleAgentJobs,
+    userCleanupJobs,
+    backupCleanupJobs,
+    ,
+    monitoring,
+    runtimeLogs,
+    deploymentLogs,
+    apiHistory,
+  ] = await Promise.all([
+    cleanupExpiredTeamInvites(),
+    failStaleRunningDeployments(),
+    failStaleQueuedDeployments(),
+    failStaleAgentJobs(),
+    runQueuedUserCleanupJobs(),
+    queueBackupRetentionCleanupJobs(),
+    cleanupExpiredRateLimits(),
+    pruneServerMonitoring(),
+    pruneExpiredRuntimeLogs(),
+    pruneOrphanDeploymentLogs(),
+    pruneApiHistory(),
+    pruneOperationalNotifications(),
+  ])
+
+  await getPluginServices().serverLifecycle?.maintain()
+  const deletedResources = await pruneDeletedResources()
+
+  return {
+    deletedResources,
+    expiredInvites: expiredInvites.expiredCount,
+    staleDeployments: staleDeployments.length + staleQueuedDeployments.length,
+    staleAgentJobs: staleAgentJobs.length,
+    userCleanupJobs,
+    backupCleanupJobs: backupCleanupJobs.length,
+    monitoring,
+    runtimeLogs,
+    deploymentLogs,
+    apiHistory,
+  }
+}