devpush 0.0.0-stage → 1.0.0-beta.4

package/src/server/servers/status.ts

@@ -0,0 +1,32 @@
+export type ServerStatus =
+  | 'pending'
+  | 'connected'
+  | 'disconnected'
+  | 'disabled'
+  | 'deleted'
+
+export const serverDisconnectedAfterMs = 2 * 60 * 1000
+
+export function getEffectiveServerStatus({
+  status,
+  lastSeenAt,
+  now = new Date(),
+}: {
+  status: ServerStatus
+  lastSeenAt: Date | null
+  now?: Date
+}): ServerStatus {
+  if (status !== 'connected') {
+    return status
+  }
+
+  if (!lastSeenAt) {
+    return 'disconnected'
+  }
+
+  if (now.getTime() - lastSeenAt.getTime() > serverDisconnectedAfterMs) {
+    return 'disconnected'
+  }
+
+  return 'connected'
+}

package/src/server/servers/switch.ts

@@ -0,0 +1,96 @@
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto'
+import { and, eq, inArray, or, sql } from 'drizzle-orm'
+import { config } from '#devpush/server/config'
+import { db } from '#devpush/server/db'
+import {
+  agentJobs,
+  deployments,
+  environments,
+  projects,
+  servers,
+} from '#devpush/server/db/schema'
+import { AgentRequestError } from '#devpush/server/agents/protocol'
+
+function sign(value: string) {
+  return createHmac('sha256', config.BETTER_AUTH_SECRET)
+    .update(value)
+    .digest('hex')
+}
+
+export async function switchServerControlPlane(input: {
+  serverId: string
+  token: string
+  action: 'prepare' | 'rollback'
+  ticket?: string
+}) {
+  const hash = createHash('sha256').update(input.token).digest('hex')
+  const auth = and(
+    eq(servers.id, input.serverId),
+    or(
+      eq(servers.agentCredentialHash, hash),
+      eq(servers.pendingAgentCredentialHash, hash),
+    ),
+  )
+  const now = new Date()
+  if (input.action === 'rollback') {
+    const [value, signature] = (input.ticket ?? '').split('.')
+    if (
+      !value ||
+      !signature ||
+      !/^[a-f0-9]{64}$/.test(signature) ||
+      !timingSafeEqual(
+        Buffer.from(signature, 'hex'),
+        Buffer.from(sign(value), 'hex'),
+      )
+    ) {
+      throw new AgentRequestError(401, 'Invalid rollback ticket.')
+    }
+    const ticket = JSON.parse(Buffer.from(value, 'base64url').toString()) as {
+      id: string
+      at: number
+    }
+    if (ticket.id !== input.serverId || !Number.isSafeInteger(ticket.at))
+      throw new AgentRequestError(401, 'Invalid rollback ticket.')
+    const rows = await db
+      .update(servers)
+      .set({ status: 'connected', updatedAt: now })
+      .where(
+        and(
+          auth,
+          eq(servers.status, 'disabled'),
+          eq(servers.updatedAt, new Date(ticket.at)),
+        ),
+      )
+      .returning({ id: servers.id })
+    if (!rows.length)
+      throw new AgentRequestError(
+        409,
+        'Source state changed; rollback requires operator review.',
+      )
+    return { serverId: input.serverId }
+  }
+  // One conditional write both validates emptiness and disables subsequent claims.
+  const rows = await db
+    .update(servers)
+    .set({ status: 'disabled', updatedAt: now })
+    .where(
+      and(
+        auth,
+        eq(servers.status, 'connected'),
+        sql`not exists (select 1 from ${projects} where ${projects.defaultServerId} = ${input.serverId})`,
+        sql`not exists (select 1 from ${environments} where ${environments.serverId} = ${input.serverId})`,
+        sql`not exists (select 1 from ${agentJobs} where ${agentJobs.serverId} = ${input.serverId} and ${inArray(agentJobs.status, ['queued', 'running'])})`,
+        sql`not exists (select 1 from ${deployments} where ${deployments.serverId} = ${input.serverId})`,
+      ),
+    )
+    .returning({ id: servers.id })
+  if (!rows.length)
+    throw new AgentRequestError(
+      409,
+      'Source must be connected and have no projects, deployments, or outstanding jobs.',
+    )
+  const value = Buffer.from(
+    JSON.stringify({ id: input.serverId, at: now.getTime() }),
+  ).toString('base64url')
+  return { serverId: input.serverId, ticket: `${value}.${sign(value)}` }
+}

package/src/server/settings-version.ts

@@ -0,0 +1,43 @@
+import { sql } from 'drizzle-orm'
+import { PublicError } from '#devpush/lib/public-error'
+import type { SQL } from 'drizzle-orm'
+import type { AtomicStore } from '#devpush/server/db/atomic'
+
+export function projectSettingsGuard(
+  projectId: string,
+  userId: string,
+  settingsVersion: number,
+  manager = false,
+): SQL {
+  return sql`exists(select 1 from projects p join teams t on t.id = p.team_id join team_members m on m.team_id = t.id join user u on u.id = m.user_id where p.id = ${projectId} and p.status = 'active' and p.settings_version = ${settingsVersion} and t.status = 'active' and u.status = 'active' and m.user_id = ${userId} ${manager ? sql`and m.role in ('owner','admin')` : sql``})`
+}
+
+export function teamSettingsAccess(teamId: string, userId: string): SQL {
+  return sql`exists(select 1 from teams t join team_members m on m.team_id = t.id join user u on u.id = m.user_id where t.id = ${teamId} and t.status = 'active' and u.status = 'active' and m.user_id = ${userId} and m.role in ('owner','admin'))`
+}
+
+/** A failed guard violates NOT NULL, rolling back every statement in a D1 batch. */
+export function advanceProjectSettings(
+  store: AtomicStore,
+  projectId: string,
+  guard: SQL,
+) {
+  return store.run(
+    sql`update projects set settings_version = case when ${guard} then settings_version + 1 else null end where id = ${projectId}`,
+  )
+}
+
+export function rethrowSettingsConflict(error: unknown): never {
+  if (error && typeof error === 'object') {
+    if (
+      'message' in error &&
+      typeof error.message === 'string' &&
+      /NOT NULL constraint failed: (projects|teams|user|servers|backup_configs|backup_storage)\.settings_version/i.test(
+        error.message,
+      )
+    )
+      throw new PublicError('SETTINGS_CONFLICT')
+    if ('cause' in error && error.cause) rethrowSettingsConflict(error.cause)
+  }
+  throw error
+}

package/src/server/storage/capabilities.ts

@@ -0,0 +1,6 @@
+import { createServerFn } from '@tanstack/react-start'
+import { isObjectStorageConfigured } from './object-store'
+
+export const getStorageCapabilities = createServerFn({ method: 'GET' }).handler(
+  async () => ({ imageUploads: isObjectStorageConfigured() }),
+)

package/src/server/storage/local-object-store.cloudflare.ts

@@ -0,0 +1,7 @@
+import type { ObjectStore } from './object-store'
+
+export function createLocalObjectStore(): ObjectStore {
+  throw new Error(
+    'Object storage is not configured. Cloudflare requires an R2 binding or S3-compatible storage.',
+  )
+}

package/src/server/storage/local-object-store.ts

@@ -0,0 +1,50 @@
+import { access, mkdir, readFile, unlink, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { ObjectStore } from './object-store'
+
+export function createLocalObjectStore(): ObjectStore {
+  const root = path.join(process.cwd(), 'public', 'uploads')
+
+  return {
+    async delete(key) {
+      try {
+        await unlink(resolveLocalKey(root, key))
+      } catch (error) {
+        if (!isMissingFile(error)) throw error
+      }
+    },
+    async exists(key) {
+      try {
+        await access(resolveLocalKey(root, key))
+        return true
+      } catch (error) {
+        if (isMissingFile(error)) return false
+        throw error
+      }
+    },
+    async get(key) {
+      return { body: await readFile(resolveLocalKey(root, key)) }
+    },
+    async put(key, body) {
+      const filePath = resolveLocalKey(root, key)
+      await mkdir(path.dirname(filePath), { recursive: true })
+      await writeFile(filePath, body)
+    },
+  }
+}
+
+function resolveLocalKey(root: string, key: string) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_./-]*$/.test(key) || key.includes('..')) {
+    throw new Error('Invalid object key.')
+  }
+
+  return path.join(root, key)
+}
+
+function isMissingFile(error: unknown) {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    (error as NodeJS.ErrnoException).code === 'ENOENT'
+  )
+}

package/src/server/storage/object-store.ts

@@ -0,0 +1,160 @@
+import { createLocalObjectStore } from '#devpush/server/storage/local-object-store'
+
+import { config } from '#devpush/server/config'
+import {
+  isCloudflareRuntime,
+  getR2ObjectStore,
+} from '#devpush/server/runtime/platform-env'
+import type { S3Client } from '@aws-sdk/client-s3'
+
+type StoredObject = {
+  body: Buffer
+  contentType?: string
+}
+
+export interface ObjectStore {
+  delete: (key: string) => Promise<void>
+  exists: (key: string) => Promise<boolean>
+  get: (key: string) => Promise<StoredObject>
+  put: (key: string, body: Uint8Array, contentType?: string) => Promise<void>
+}
+
+let store: ObjectStore | undefined
+
+export function getObjectStore() {
+  const r2 = getR2ObjectStore()
+
+  if (r2) {
+    return createR2ObjectStore(r2)
+  }
+
+  // Node may pool a client; Worker invocations must not share its transport I/O.
+  if (isCloudflareRuntime()) {
+    if (!isRemoteObjectStorageConfigured())
+      throw new Error('Object storage is not configured.')
+    return createS3ObjectStore()
+  }
+  store ??= isRemoteObjectStorageConfigured()
+    ? createS3ObjectStore()
+    : createLocalObjectStore()
+
+  return store
+}
+
+export function isObjectStorageConfigured() {
+  return (
+    !isCloudflareRuntime() ||
+    Boolean(getR2ObjectStore()) ||
+    isRemoteObjectStorageConfigured()
+  )
+}
+
+function createR2ObjectStore(bucket: R2Bucket): ObjectStore {
+  return {
+    async delete(key) {
+      await bucket.delete(key)
+    },
+    async exists(key) {
+      return Boolean(await bucket.head(key))
+    },
+    async get(key) {
+      const object = await bucket.get(key)
+      if (!object) throw new Error(`Object ${key} was not found.`)
+
+      return {
+        body: Buffer.from(await object.arrayBuffer()),
+        contentType: object.httpMetadata?.contentType,
+      }
+    },
+    async put(key, body, contentType) {
+      await bucket.put(key, body, {
+        httpMetadata: contentType ? { contentType } : undefined,
+      })
+    },
+  }
+}
+
+function isRemoteObjectStorageConfigured() {
+  return Boolean(
+    config.DEVPUSH_STORAGE_ENDPOINT &&
+    config.DEVPUSH_STORAGE_BUCKET &&
+    config.DEVPUSH_STORAGE_ACCESS_KEY_ID &&
+    config.DEVPUSH_STORAGE_SECRET_ACCESS_KEY,
+  )
+}
+
+function createS3ObjectStore(): ObjectStore {
+  const bucket = config.DEVPUSH_STORAGE_BUCKET!
+  let clientPromise: Promise<S3Client> | undefined
+  const getClient = () =>
+    (clientPromise ??= import('@aws-sdk/client-s3').then(
+      ({ S3Client }) =>
+        new S3Client({
+          endpoint: config.DEVPUSH_STORAGE_ENDPOINT,
+          region: config.DEVPUSH_STORAGE_REGION ?? 'auto',
+          credentials: {
+            accessKeyId: config.DEVPUSH_STORAGE_ACCESS_KEY_ID!,
+            secretAccessKey: config.DEVPUSH_STORAGE_SECRET_ACCESS_KEY!,
+          },
+        }),
+    ))
+
+  return {
+    async delete(key) {
+      const [{ DeleteObjectCommand }, client] = await Promise.all([
+        import('@aws-sdk/client-s3'),
+        getClient(),
+      ])
+      await client.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }))
+    },
+    async exists(key) {
+      try {
+        const [{ HeadObjectCommand }, client] = await Promise.all([
+          import('@aws-sdk/client-s3'),
+          getClient(),
+        ])
+        await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }))
+        return true
+      } catch (error) {
+        if (
+          error instanceof Error &&
+          'name' in error &&
+          (error.name === 'NotFound' || error.name === 'NoSuchKey')
+        ) {
+          return false
+        }
+        throw error
+      }
+    },
+    async get(key) {
+      const [{ GetObjectCommand }, client] = await Promise.all([
+        import('@aws-sdk/client-s3'),
+        getClient(),
+      ])
+      const result = await client.send(
+        new GetObjectCommand({ Bucket: bucket, Key: key }),
+      )
+
+      if (!result.Body) throw new Error(`Object ${key} has no content.`)
+
+      return {
+        body: Buffer.from(await result.Body.transformToByteArray()),
+        contentType: result.ContentType,
+      }
+    },
+    async put(key, body, contentType) {
+      const [{ PutObjectCommand }, client] = await Promise.all([
+        import('@aws-sdk/client-s3'),
+        getClient(),
+      ])
+      await client.send(
+        new PutObjectCommand({
+          Body: body,
+          Bucket: bucket,
+          ContentType: contentType,
+          Key: key,
+        }),
+      )
+    },
+  }
+}

package/src/server/teams/creation.ts

@@ -0,0 +1,51 @@
+import { sql } from 'drizzle-orm'
+import type { AtomicStore } from '#devpush/server/db/atomic'
+import { teamMembers, teams, user } from '#devpush/server/db/schema'
+
+type TeamInput = {
+  userId: string
+  teamId: string
+  name: string
+  baseSlug: string
+}
+
+function teamSlug(input: TeamInput) {
+  return sql`case when exists(select 1 from ${teams} where slug = ${input.baseSlug})
+    then ${`${input.baseSlug.slice(0, 32)}-${input.teamId.slice(0, 7)}`}
+    else ${input.baseSlug} end`
+}
+
+export async function insertOwnedTeam(store: AtomicStore, input: TeamInput) {
+  const now = Date.now()
+  const [created] = await store.batch([
+    store.all(sql`insert into ${teams} (id, name, slug, created_at, updated_at)
+      select ${input.teamId}, ${input.name}, ${teamSlug(input)}, ${now}, ${now}
+      from ${user} where id = ${input.userId} and status = 'active' returning id`),
+    store.run(sql`insert into ${teamMembers} (id, team_id, user_id, role, created_at)
+      select ${crypto.randomUUID()}, id, ${input.userId}, 'owner', ${now}
+      from ${teams} where id = ${input.teamId}`),
+  ])
+  return created.length === 1
+}
+
+export async function bootstrapOwnedTeam(store: AtomicStore, input: TeamInput) {
+  const now = Date.now()
+  const activeMemberships = sql`select membership.team_id from ${teamMembers} as membership
+    join ${teams} as member_team on member_team.id = membership.team_id
+    where membership.user_id = ${input.userId} and member_team.status = 'active'`
+  const [, , updated] = await store.batch([
+    store.run(sql`insert into ${teams} (id, name, slug, created_at, updated_at)
+      select ${input.teamId}, ${input.name}, ${teamSlug(input)}, ${now}, ${now}
+      from ${user} where id = ${input.userId} and status = 'active'
+      and not exists(${activeMemberships})`),
+    store.run(sql`insert into ${teamMembers} (id, team_id, user_id, role, created_at)
+      select ${crypto.randomUUID()}, id, ${input.userId}, 'owner', ${now}
+      from ${teams} where id = ${input.teamId}`),
+    store.all(sql`update ${user} set default_team_id = case
+      when default_team_id in (${activeMemberships}) then default_team_id
+      else (${activeMemberships} order by membership.created_at desc limit 1) end,
+      updated_at = ${now}
+      where id = ${input.userId} and status = 'active' returning id`),
+  ])
+  return updated.length === 1
+}

package/src/server/teams/delete-policy.ts

@@ -0,0 +1,13 @@
+import type { TeamRole } from '#devpush/lib/team-role'
+
+export function canDeleteTeam({
+  defaultUserIds,
+}: {
+  defaultUserIds: Array<string>
+}) {
+  return defaultUserIds.length === 0
+}
+
+export function canDeleteProject(role: TeamRole) {
+  return role === 'owner' || role === 'admin'
+}

package/src/server/teams/deletion-state.ts

@@ -0,0 +1,80 @@
+import { releaseBackupCleanupRuns } from '#devpush/server/backups/queue-state'
+import { sql } from 'drizzle-orm'
+import type { SQL } from 'drizzle-orm'
+import type { AtomicStore } from '#devpush/server/db/atomic'
+import { runtimeCleanupInsert } from '#devpush/server/agents/cleanup'
+
+export function teamDeletionStatements(input: {
+  teamIds: SQL
+  guard: SQL
+  reason: string
+  message: string
+  now: Date
+  clearDefaults?: boolean
+}): [SQL, ...SQL[]] {
+  const now = input.now.getTime()
+  const projects = sql`select id from projects where team_id in (${input.teamIds})`
+  const servers = sql`select id from servers where team_id in (${input.teamIds})`
+  const environments = sql`select id from environments where project_id in (${projects})`
+  return [
+    releaseBackupCleanupRuns({
+      jobIds: sql`select id from agent_jobs where server_id in (${servers})`,
+      guard: input.guard,
+      message: input.message,
+      now: input.now,
+    }),
+    sql`update agent_jobs set status = 'canceled', error_message = ${input.message}, finished_at = ${now}, updated_at = ${now}
+      where server_id in (${servers}) and type in ('deploy', 'backup', 'restore', 'backup_cleanup')
+      and status in ('queued', 'running') and ${input.guard}`,
+    sql`update backup_runs set status = 'canceled', error_message = ${input.message}, finished_at = ${now}, updated_at = ${now}
+      where server_id in (${servers}) and status in ('queued', 'running') and ${input.guard}`,
+    runtimeCleanupInsert({
+      projectIds: projects,
+      guard: input.guard,
+      reason: input.reason,
+      now: input.now,
+    }),
+    sql`update environments set status = 'deleted', is_production = 0, updated_at = ${now}
+      where project_id in (${projects}) and ${input.guard}`,
+    sql`update deployments set status = 'canceled', phase = 'canceled', error_message = ${input.message}, finished_at = ${now}
+      where environment_id in (${environments}) and status in ('queued', 'running') and ${input.guard}`,
+    sql`update projects set status = 'deleted', updated_at = ${now} where team_id in (${input.teamIds}) and ${input.guard}`,
+    sql`update servers set status = 'deleted', updated_at = ${now} where team_id in (${input.teamIds}) and ${input.guard}`,
+    ...(input.clearDefaults
+      ? [
+          sql`update user set default_team_id = null, updated_at = ${now}
+      where default_team_id in (${input.teamIds}) and ${input.guard}`,
+        ]
+      : []),
+    sql`update teams set status = 'deleted', updated_at = ${now} where id in (${input.teamIds}) and ${input.guard} returning id`,
+  ]
+}
+
+export async function deleteTeamState(
+  store: AtomicStore,
+  input: {
+    teamId: string
+    userId: string
+    now: Date
+  },
+) {
+  const guard = sql`exists(select 1 from teams t join team_members m on m.team_id = t.id
+    join user u on u.id = m.user_id where t.id = ${input.teamId} and t.status = 'active'
+      and m.user_id = ${input.userId} and m.role = 'owner' and u.status = 'active')
+    and not exists(select 1 from user where default_team_id = ${input.teamId} and status = 'active')`
+  const [first, ...rest] = teamDeletionStatements({
+    teamIds: sql`select id from teams where id = ${input.teamId}`,
+    guard,
+    reason: 'Team deleted.',
+    message: 'Canceled because the team was deleted.',
+    now: input.now,
+  })
+  const results = await store.batch([
+    store.run(first),
+    ...rest.map((query, index) =>
+      index === rest.length - 1 ? store.all(query) : store.run(query),
+    ),
+  ])
+  const changed = results.at(-1)
+  return Array.isArray(changed) && changed.length === 1
+}