@actuate-media/cli 0.6.0 → 0.8.0

package/src/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander'
 import { registerMigrateCommand } from './commands/migrate.js'
+import { registerMigrateSectionsCommand } from './commands/migrate-sections.js'
 import { registerGenerateCommand } from './commands/generate.js'
 import { registerSeedCommand } from './commands/seed.js'
 import { registerImportCommand } from './commands/import.js'
@@ -16,6 +17,7 @@ import {
   registerDoctorCommand,
   registerVerifyCommand,
 } from './commands/doctor.js'
+import { registerVercelBlobLinkCommand } from './commands/vercel-blob-link.js'
 
 const program = new Command()
 
@@ -25,6 +27,7 @@ program
   .version('0.1.0')
 
 registerMigrateCommand(program)
+registerMigrateSectionsCommand(program)
 registerGenerateCommand(program)
 registerSeedCommand(program)
 registerImportCommand(program)
@@ -38,5 +41,6 @@ registerInitCommand(program)
 registerDoctorCommand(program)
 registerDeployCheckCommand(program)
 registerVerifyCommand(program)
+registerVercelBlobLinkCommand(program)
 
 program.parse()

package/src/utils/database.ts

@@ -0,0 +1,77 @@
+import { existsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+/**
+ * Shared helper for CLI commands that need a live connection to the consumer
+ * project's database (seed, populate, data migrations…).
+ *
+ * Resolution order mirrors how a scaffolded Actuate project exposes Prisma:
+ *   1. If `cms-core` already has an initialized client (e.g. set up by the host
+ *      app in-process), reuse it.
+ *   2. Otherwise build a client from the project's generated Prisma client
+ *      (`generated/prisma/client.ts`, Prisma 7 + pg driver adapter).
+ *   3. Fall back to a plain `@prisma/client` resolved from the project.
+ *
+ * The returned `disconnect()` only tears down clients this helper created — a
+ * pre-initialized in-process client is left untouched.
+ */
+export async function connectProjectDatabase(): Promise<{
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Prisma client shape varies by project; callers treat it structurally.
+  db: any
+  disconnect: () => Promise<void>
+}> {
+  const { getDB, initDB, isDBInitialized } = await import('@actuate-media/cms-core')
+
+  if (isDBInitialized()) {
+    return { db: getDB<any>(), disconnect: async () => {} }
+  }
+
+  const db = await createProjectPrismaClient()
+  initDB(db)
+  return {
+    db,
+    disconnect: async () => {
+      if (typeof db.$disconnect === 'function') {
+        await db.$disconnect()
+      }
+    },
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- see above.
+async function createProjectPrismaClient(): Promise<any> {
+  if (!process.env.DATABASE_URL) {
+    throw new Error('DATABASE_URL is required to connect to the project database.')
+  }
+
+  const requireFromProject = createRequire(path.join(process.cwd(), 'package.json'))
+  const generatedClient = path.resolve('generated', 'prisma', 'client.ts')
+
+  if (existsSync(generatedClient)) {
+    const [{ tsImport }, adapterModule, pgModule] = await Promise.all([
+      import('tsx/esm/api'),
+      import(pathToFileURL(requireFromProject.resolve('@prisma/adapter-pg')).href),
+      import(pathToFileURL(requireFromProject.resolve('pg')).href),
+    ])
+    const { PrismaClient } = (await tsImport(
+      pathToFileURL(generatedClient).href,
+      import.meta.url,
+    )) as {
+      PrismaClient: new (options?: unknown) => any
+    }
+    const { PrismaPg } = adapterModule as { PrismaPg: new (pool: unknown) => unknown }
+    const pg = (pgModule as { default?: typeof pgModule }).default ?? pgModule
+    const pool = new (pg as any).Pool({ connectionString: process.env.DATABASE_URL })
+    const adapter = new PrismaPg(pool)
+    return new PrismaClient({ adapter } as any)
+  }
+
+  const clientModule = (await import(
+    pathToFileURL(requireFromProject.resolve('@prisma/client')).href
+  )) as {
+    PrismaClient: new () => any
+  }
+  return new clientModule.PrismaClient()
+}

package/src/vercel/client.ts

@@ -0,0 +1,112 @@
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+/**
+ * Minimal Vercel REST client for the CLI. Scope is deliberately small: read a
+ * project's environment variables so we can validate Blob wiring and print a
+ * per-environment readiness matrix. No write operations.
+ *
+ * Auth: a Vercel access token via `--token`, `VERCEL_TOKEN`, or
+ * `VERCEL_API_TOKEN`. Project/team identity from `.vercel/project.json` (written
+ * by `vercel link`) or explicit overrides. The client is fetch-injectable so the
+ * evaluation logic can be unit-tested without network access.
+ */
+
+const DEFAULT_BASE_URL = 'https://api.vercel.com'
+
+export const VERCEL_TARGETS = ['production', 'preview', 'development'] as const
+export type VercelTarget = (typeof VERCEL_TARGETS)[number]
+
+export interface VercelLink {
+  projectId: string
+  orgId?: string
+}
+
+export interface VercelEnvVar {
+  key: string
+  /** Targets this var applies to, e.g. ['production', 'preview']. */
+  target: VercelTarget[]
+  type?: string
+}
+
+export class VercelApiError extends Error {
+  readonly status: number
+
+  constructor(message: string, status: number) {
+    super(message)
+    this.name = 'VercelApiError'
+    this.status = status
+  }
+}
+
+/** Read `.vercel/project.json` (written by `vercel link`). Returns null if absent. */
+export async function readVercelLink(cwd: string): Promise<VercelLink | null> {
+  try {
+    const raw = await readFile(join(cwd, '.vercel', 'project.json'), 'utf-8')
+    const parsed = JSON.parse(raw) as { projectId?: string; orgId?: string }
+    if (!parsed.projectId) return null
+    return { projectId: parsed.projectId, orgId: parsed.orgId }
+  } catch {
+    return null
+  }
+}
+
+/** Resolve a Vercel token from an explicit flag or the standard env vars. */
+export function resolveVercelToken(explicit?: string): string | undefined {
+  return explicit ?? process.env.VERCEL_TOKEN ?? process.env.VERCEL_API_TOKEN ?? undefined
+}
+
+export interface VercelClientOptions {
+  token: string
+  /** Team / org id, appended as `teamId` when the project belongs to a team. */
+  teamId?: string
+  fetchImpl?: typeof fetch
+  baseUrl?: string
+}
+
+export interface VercelClient {
+  listProjectEnv(projectId: string): Promise<VercelEnvVar[]>
+}
+
+export function createVercelClient(options: VercelClientOptions): VercelClient {
+  const fetchImpl = options.fetchImpl ?? fetch
+  const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL
+
+  async function request<T>(path: string): Promise<T> {
+    const url = new URL(path, baseUrl)
+    if (options.teamId) url.searchParams.set('teamId', options.teamId)
+
+    const response = await fetchImpl(url.toString(), {
+      headers: { Authorization: `Bearer ${options.token}` },
+    })
+
+    if (!response.ok) {
+      let detail = ''
+      try {
+        const body = (await response.json()) as { error?: { message?: string } }
+        detail = body?.error?.message ? `: ${body.error.message}` : ''
+      } catch {
+        // non-JSON error body — status alone is enough context
+      }
+      throw new VercelApiError(
+        `Vercel API request failed (HTTP ${response.status})${detail}`,
+        response.status,
+      )
+    }
+
+    return (await response.json()) as T
+  }
+
+  return {
+    async listProjectEnv(projectId: string): Promise<VercelEnvVar[]> {
+      const data = await request<{ envs?: VercelEnvVar[] }>(
+        `/v9/projects/${encodeURIComponent(projectId)}/env`,
+      )
+      return (data.envs ?? []).map((env) => ({
+        key: env.key,
+        target: Array.isArray(env.target) ? env.target : [],
+        type: env.type,
+      }))
+    },
+  }
+}

package/src/vercel/env-matrix.ts

@@ -0,0 +1,101 @@
+import { VERCEL_TARGETS, type VercelEnvVar, type VercelTarget } from './client.js'
+
+/**
+ * Pure evaluation helpers over a project's Vercel env vars. Kept free of I/O so
+ * the matrix / blob logic is unit-testable without hitting the Vercel API.
+ */
+
+export type TargetPresence = Record<VercelTarget, boolean>
+
+function emptyPresence(): TargetPresence {
+  return { production: false, preview: false, development: false }
+}
+
+/** Which targets a given env var key is defined for. */
+export function presenceForKey(envVars: VercelEnvVar[], key: string): TargetPresence {
+  const presence = emptyPresence()
+  for (const env of envVars) {
+    if (env.key !== key) continue
+    for (const target of env.target) {
+      if ((VERCEL_TARGETS as readonly string[]).includes(target)) {
+        presence[target as VercelTarget] = true
+      }
+    }
+  }
+  return presence
+}
+
+export interface EnvMatrixRow {
+  key: string
+  required: boolean
+  presence: TargetPresence
+}
+
+export interface EnvMatrix {
+  rows: EnvMatrixRow[]
+  /** Required vars missing on production or preview (deploy-blocking). */
+  missingCritical: { key: string; targets: VercelTarget[] }[]
+}
+
+/** Production and preview are the deploy-blocking targets; development is local-only. */
+const DEPLOY_TARGETS: VercelTarget[] = ['production', 'preview']
+
+export function buildEnvMatrix(
+  envVars: VercelEnvVar[],
+  requiredKeys: readonly string[],
+  optionalKeys: readonly string[] = [],
+): EnvMatrix {
+  const rows: EnvMatrixRow[] = []
+  const seen = new Set<string>()
+  const missingCritical: { key: string; targets: VercelTarget[] }[] = []
+
+  for (const key of requiredKeys) {
+    seen.add(key)
+    const presence = presenceForKey(envVars, key)
+    rows.push({ key, required: true, presence })
+    const missing = DEPLOY_TARGETS.filter((t) => !presence[t])
+    if (missing.length > 0) missingCritical.push({ key, targets: missing })
+  }
+
+  for (const key of optionalKeys) {
+    if (seen.has(key)) continue
+    seen.add(key)
+    rows.push({ key, required: false, presence: presenceForKey(envVars, key) })
+  }
+
+  return { rows, missingCritical }
+}
+
+export type BlobLinkStatus = 'ok' | 'partial' | 'none'
+
+export interface BlobLinkReport {
+  /** True when any BLOB_* var indicates a store is connected to the project. */
+  linked: boolean
+  tokenByTarget: TargetPresence
+  /** Targets (any) where BLOB_READ_WRITE_TOKEN is absent while linked. */
+  missingTargets: VercelTarget[]
+  /** 'partial' when production/preview lack the token (deploy-blocking). */
+  status: BlobLinkStatus
+}
+
+const BLOB_LINK_SIGNALS = ['BLOB_STORE_ID', 'BLOB_WEBHOOK_PUBLIC_KEY', 'BLOB_READ_WRITE_TOKEN']
+
+export function evaluateBlobLink(envVars: VercelEnvVar[]): BlobLinkReport {
+  const linked = envVars.some(
+    (env) => BLOB_LINK_SIGNALS.includes(env.key) || env.key.startsWith('BLOB_'),
+  )
+  const tokenByTarget = presenceForKey(envVars, 'BLOB_READ_WRITE_TOKEN')
+
+  if (!linked) {
+    return { linked: false, tokenByTarget, missingTargets: [], status: 'none' }
+  }
+
+  const missingTargets = VERCEL_TARGETS.filter((t) => !tokenByTarget[t])
+  const criticalMissing = DEPLOY_TARGETS.some((t) => !tokenByTarget[t])
+  return {
+    linked: true,
+    tokenByTarget,
+    missingTargets,
+    status: criticalMissing ? 'partial' : 'ok',
+  }
+}