@actuate-media/cli 0.7.0 → 0.10.0

package/src/commands/doctor.ts

@@ -6,8 +6,19 @@ import {
   buildDeploymentManifest,
   createDiagnosticReport,
   detectPackageManager,
+  VERCEL_MATRIX_OPTIONAL,
+  VERCEL_MATRIX_REQUIRED,
   type DiagnosticReport,
 } from '../deployment/diagnostics.js'
+import {
+  createVercelClient,
+  readVercelLink,
+  resolveVercelToken,
+  VercelApiError,
+  VERCEL_TARGETS,
+} from '../vercel/client.js'
+import { buildEnvMatrix, type EnvMatrix } from '../vercel/env-matrix.js'
+import { logger } from '../utils/logger.js'
 
 async function fileExists(path: string): Promise<boolean> {
   try {
@@ -108,23 +119,120 @@ export function registerDoctorCommand(program: Command): void {
     })
 }
 
+function printEnvMatrix(matrix: EnvMatrix): void {
+  const cell = (present: boolean): string => (present ? chalk.green(' Y ') : chalk.red(' . '))
+  const keyWidth = Math.max(24, ...matrix.rows.map((r) => `${r.key} (optional)`.length + 1))
+
+  console.log()
+  console.log(chalk.bold('Environment variable matrix (Vercel)'))
+  console.log(chalk.dim('─────────────────────────────────'))
+  console.log(`${'Variable'.padEnd(keyWidth)} Prod Prev Dev`)
+  for (const row of matrix.rows) {
+    const labelPlain = row.required ? row.key : `${row.key} (optional)`
+    const label = row.required ? row.key : chalk.dim(labelPlain)
+    console.log(
+      `${label}${' '.repeat(Math.max(1, keyWidth - labelPlain.length))}` +
+        `${cell(row.presence.production)} ${cell(row.presence.preview)} ${cell(row.presence.development)}`,
+    )
+  }
+  console.log(chalk.dim('─────────────────────────────────'))
+  console.log(chalk.dim('Y = set for that environment, . = missing'))
+}
+
+async function runVercelMatrix(opts: {
+  token?: string
+  project?: string
+  org?: string
+  json?: boolean
+}): Promise<{ ok: boolean; matrix?: EnvMatrix }> {
+  const token = resolveVercelToken(opts.token)
+  if (!token) {
+    logger.error('No Vercel token found. Pass --token or set VERCEL_TOKEN to use --vercel.')
+    return { ok: false }
+  }
+
+  const link = opts.project
+    ? { projectId: opts.project, orgId: opts.org }
+    : await readVercelLink(process.cwd())
+  if (!link?.projectId) {
+    logger.error('No linked Vercel project. Run `vercel link` or pass --project <id>.')
+    return { ok: false }
+  }
+
+  const client = createVercelClient({ token, teamId: link.orgId ?? opts.org })
+  try {
+    const envVars = await client.listProjectEnv(link.projectId)
+    const matrix = buildEnvMatrix(envVars, VERCEL_MATRIX_REQUIRED, VERCEL_MATRIX_OPTIONAL)
+    if (!opts.json) {
+      printEnvMatrix(matrix)
+      if (matrix.missingCritical.length > 0) {
+        for (const m of matrix.missingCritical) {
+          logger.error(`${m.key} missing on: ${m.targets.join(', ')}`)
+        }
+        logger.info(
+          `Add the missing variables in the Vercel dashboard (include Development for local \`vercel env pull\`). Targets checked: ${VERCEL_TARGETS.join(', ')}.`,
+        )
+      }
+    }
+    return { ok: matrix.missingCritical.length === 0, matrix }
+  } catch (error) {
+    const message =
+      error instanceof VercelApiError
+        ? error.message
+        : error instanceof Error
+          ? error.message
+          : String(error)
+    logger.error(`Could not read project environment from Vercel: ${message}`)
+    return { ok: false }
+  }
+}
+
 export function registerDeployCheckCommand(program: Command): void {
   program
     .command('deploy:check')
     .description('Check production deployment readiness for Actuate CMS')
     .option('--schema <path>', 'Path to schema.prisma', 'prisma/schema.prisma')
     .option('--config <path>', 'Path to actuate.config.ts', 'actuate.config.ts')
+    .option('--vercel', 'Read the linked Vercel project and print a per-environment matrix')
+    .option('--token <token>', 'Vercel access token (with --vercel; defaults to $VERCEL_TOKEN)')
+    .option('--project <id>', 'Vercel project id (with --vercel; defaults to .vercel/project.json)')
+    .option('--org <id>', 'Vercel team/org id (with --vercel)')
     .option('--json', 'Print machine-readable JSON')
-    .action(async (opts: { schema: string; config: string; json?: boolean }) => {
-      const report = await buildReport(opts.schema, opts.config, 'deploy')
-      if (opts.json) {
-        console.log(JSON.stringify({ ...report, manifest: buildDeploymentManifest() }, null, 2))
-      } else {
-        printReport('Actuate Deploy Check', report)
-        console.log(chalk.dim('Run `actuate verify --full` after deployment succeeds.'))
-      }
-      if (report.status === 'fail') process.exitCode = 1
-    })
+    .action(
+      async (opts: {
+        schema: string
+        config: string
+        vercel?: boolean
+        token?: string
+        project?: string
+        org?: string
+        json?: boolean
+      }) => {
+        const report = await buildReport(opts.schema, opts.config, 'deploy')
+        const vercelResult = opts.vercel ? await runVercelMatrix(opts) : null
+
+        if (opts.json) {
+          console.log(
+            JSON.stringify(
+              {
+                ...report,
+                manifest: buildDeploymentManifest(),
+                ...(vercelResult ? { vercelMatrix: vercelResult.matrix ?? null } : {}),
+              },
+              null,
+              2,
+            ),
+          )
+        } else {
+          printReport('Actuate Deploy Check', report)
+          console.log(chalk.dim('Run `actuate verify --full` after deployment succeeds.'))
+        }
+
+        if (report.status === 'fail' || (vercelResult && !vercelResult.ok)) {
+          process.exitCode = 1
+        }
+      },
+    )
 }
 
 export function registerVerifyCommand(program: Command): void {

package/src/commands/seed.ts

@@ -7,6 +7,7 @@ import { pathToFileURL } from 'node:url'
 import ora from 'ora'
 import { logger } from '../utils/logger.js'
 import { connectProjectDatabase } from '../utils/database.js'
+import { validateFormSeeds } from '../utils/form-seed.js'
 
 async function confirm(question: string): Promise<boolean> {
   const rl = createInterface({ input: process.stdin, output: process.stdout })
@@ -119,37 +120,101 @@ const DEMO_POSTS = [
   },
 ]
 
-const DEMO_FORMS = [
+// Canonical form seed shape: the form definition lives in document `data`
+// with its own lifecycle `status: 'active'` (gates the public endpoints) and
+// `fields` keyed by { id, key, label, type, required, sortOrder }. See
+// `validateFormSeeds` — these are validated by the same rules as user seeds.
+export const DEMO_FORMS = [
   {
+    name: 'Contact Form',
     title: 'Contact Form',
     slug: 'contact-form',
+    status: 'active',
     fields: [
-      { name: 'name', type: 'text', required: true },
-      { name: 'email', type: 'email', required: true },
-      { name: 'message', type: 'textarea', required: true },
+      {
+        id: 'contact-name',
+        key: 'name',
+        label: 'Name',
+        type: 'text',
+        required: true,
+        sortOrder: 0,
+      },
+      {
+        id: 'contact-email',
+        key: 'email',
+        label: 'Email',
+        type: 'email',
+        required: true,
+        sortOrder: 1,
+      },
+      {
+        id: 'contact-message',
+        key: 'message',
+        label: 'Message',
+        type: 'textarea',
+        required: true,
+        sortOrder: 2,
+      },
     ],
-    submitLabel: 'Send Message',
     successMessage: "Thanks for reaching out! We'll get back to you soon.",
   },
   {
+    name: 'Newsletter Signup',
     title: 'Newsletter Signup',
     slug: 'newsletter',
+    status: 'active',
     fields: [
-      { name: 'email', type: 'email', required: true },
-      { name: 'firstName', type: 'text', required: false },
+      {
+        id: 'newsletter-email',
+        key: 'email',
+        label: 'Email',
+        type: 'email',
+        required: true,
+        sortOrder: 0,
+      },
+      {
+        id: 'newsletter-first-name',
+        key: 'firstName',
+        label: 'First name',
+        type: 'text',
+        required: false,
+        sortOrder: 1,
+      },
     ],
-    submitLabel: 'Subscribe',
     successMessage: "You're subscribed! Check your inbox for confirmation.",
   },
   {
+    name: 'Feedback Form',
     title: 'Feedback Form',
     slug: 'feedback',
+    status: 'active',
     fields: [
-      { name: 'name', type: 'text', required: false },
-      { name: 'rating', type: 'select', options: ['1', '2', '3', '4', '5'], required: true },
-      { name: 'comments', type: 'textarea', required: false },
+      {
+        id: 'feedback-name',
+        key: 'name',
+        label: 'Name',
+        type: 'text',
+        required: false,
+        sortOrder: 0,
+      },
+      {
+        id: 'feedback-rating',
+        key: 'rating',
+        label: 'Rating',
+        type: 'select',
+        required: true,
+        sortOrder: 1,
+        options: ['1', '2', '3', '4', '5'].map((v) => ({ label: v, value: v })),
+      },
+      {
+        id: 'feedback-comments',
+        key: 'comments',
+        label: 'Comments',
+        type: 'textarea',
+        required: false,
+        sortOrder: 2,
+      },
     ],
-    submitLabel: 'Submit Feedback',
     successMessage: 'Thank you for your feedback!',
   },
 ]
@@ -188,6 +253,7 @@ interface SeedOptions {
   demo?: boolean
   file?: string
   reset?: boolean
+  upsert?: boolean
 }
 
 export interface NormalizedSeedDocument {
@@ -324,7 +390,7 @@ async function runSeed(options: SeedOptions): Promise<void> {
     }
 
     if (file) {
-      await seedFromFile(db, file)
+      await seedFromFile(db, file, { upsert: options.upsert })
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err)
@@ -380,19 +446,63 @@ export async function createSeedDocument(
   db: any,
   userId: string,
   doc: NormalizedSeedDocument,
-): Promise<void> {
+  options: { upsert?: boolean } = {},
+): Promise<'created' | 'updated'> {
   const { extractPlainText, hashContent, sanitizeHtml } = await import('@actuate-media/cms-core')
   const data = sanitizeSeedData(doc.data, sanitizeHtml) as Record<string, unknown>
   const serialized = JSON.stringify(data)
   const plainText = extractPlainText(serialized)
   const contentHash = await hashContent(serialized)
+  const slug = typeof data.slug === 'string' ? data.slug : null
+  const title = typeof data.title === 'string' ? data.title : null
+
+  // Upsert key: collection + slug. Slugless documents can't be re-identified,
+  // so they always insert (same as a plain seed run).
+  const existing =
+    options.upsert && slug
+      ? await db.document.findFirst({
+          where: { collection: doc.collection, slug, deletedAt: null },
+          select: { id: true, status: true, publishedAt: true },
+        })
+      : null
+
+  if (existing) {
+    await db.$transaction(async (tx: any) => {
+      await tx.document.update({
+        where: { id: existing.id },
+        data: {
+          title,
+          data,
+          status: doc.status,
+          // Stamp publishedAt only on the transition into PUBLISHED.
+          publishedAt:
+            doc.status === 'PUBLISHED'
+              ? (existing.publishedAt ?? new Date())
+              : existing.publishedAt,
+          updatedById: userId,
+          plainText,
+          contentHash,
+        },
+      })
+
+      await tx.version.create({
+        data: {
+          documentId: existing.id,
+          data,
+          changedById: userId,
+          changeType: 'UPDATE',
+        },
+      })
+    })
+    return 'updated'
+  }
 
   await db.$transaction(async (tx: any) => {
     const created = await tx.document.create({
       data: {
         collection: doc.collection,
-        title: typeof data.title === 'string' ? data.title : null,
-        slug: typeof data.slug === 'string' ? data.slug : null,
+        title,
+        slug,
         data,
         status: doc.status,
         publishedAt: doc.status === 'PUBLISHED' ? new Date() : null,
@@ -412,6 +522,7 @@ export async function createSeedDocument(
       },
     })
   })
+  return 'created'
 }
 
 async function seedDemoData(db: any): Promise<void> {
@@ -486,7 +597,11 @@ async function seedDemoData(db: any): Promise<void> {
   logger.info(`  Users:        ${usersCreated} (+ existing admin)`)
 }
 
-async function seedFromFile(db: any, filePath: string): Promise<void> {
+async function seedFromFile(
+  db: any,
+  filePath: string,
+  options: { upsert?: boolean } = {},
+): Promise<void> {
   if (!existsSync(filePath)) {
     logger.error(`File not found: ${filePath}`)
     process.exit(1)
@@ -511,13 +626,32 @@ async function seedFromFile(db: any, filePath: string): Promise<void> {
   const userId = adminUser.id
 
   const normalized = normalizeSeedPayload(seedData)
+
+  // Forms have a stricter shape than generic documents (data.status gates the
+  // public endpoints; fields need key/label/type). Fail loudly BEFORE writing
+  // anything — a malformed form seed used to insert fine and then 404 on
+  // /api/cms/public/forms/:slug with no hint why.
+  const formErrors = validateFormSeeds(normalized.documents)
+  if (formErrors.length > 0) {
+    spinner.fail('Form seed validation failed — nothing was written:')
+    for (const error of formErrors) {
+      logger.error(`  ${error}`)
+    }
+    logger.info(
+      '  Expected shape: { "forms": [{ "status": "PUBLISHED", "data": { "name", "slug", "status": "active", "fields": [{ "key", "label", "type", … }] } }] }',
+    )
+    process.exit(1)
+  }
+
   const { updateGlobal } = await import('@actuate-media/cms-core')
   const ctx = { userId, role: 'ADMIN', db }
 
-  let documentCount = 0
+  let createdCount = 0
+  let updatedCount = 0
   for (const doc of normalized.documents) {
-    await createSeedDocument(db, userId, doc)
-    documentCount++
+    const result = await createSeedDocument(db, userId, doc, options)
+    if (result === 'updated') updatedCount++
+    else createdCount++
   }
 
   let globalCount = 0
@@ -526,7 +660,11 @@ async function seedFromFile(db: any, filePath: string): Promise<void> {
     globalCount++
   }
 
-  spinner.succeed(`Seeded ${documentCount} documents and ${globalCount} globals from ${filePath}.`)
+  spinner.succeed(
+    options.upsert
+      ? `Seeded from ${filePath}: ${createdCount} created, ${updatedCount} updated, ${globalCount} globals.`
+      : `Seeded ${createdCount} documents and ${globalCount} globals from ${filePath}.`,
+  )
 }
 
 export function registerSeedCommand(program: Command): void {
@@ -536,6 +674,10 @@ export function registerSeedCommand(program: Command): void {
     .option('--demo', 'Seed demo content (pages, posts, forms, users)')
     .option('--file <path>', 'Seed from a JSON, JavaScript, or TypeScript file')
     .option('--reset', 'Clear existing data before seeding')
+    .option(
+      '--upsert',
+      'Update existing documents matched by collection + slug instead of inserting duplicates',
+    )
     .action(runSeed)
 
   program
@@ -543,5 +685,9 @@ export function registerSeedCommand(program: Command): void {
     .description('Populate the database from actuate.seed.json or a custom seed file')
     .option('--file <path>', 'Seed from a JSON, JavaScript, or TypeScript file')
     .option('--reset', 'Clear existing data before seeding')
+    .option(
+      '--upsert',
+      'Update existing documents matched by collection + slug instead of inserting duplicates',
+    )
     .action(runSeed)
 }

package/src/commands/vercel-blob-link.ts

@@ -0,0 +1,115 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import {
+  createVercelClient,
+  readVercelLink,
+  resolveVercelToken,
+  VercelApiError,
+  VERCEL_TARGETS,
+  type VercelTarget,
+} from '../vercel/client.js'
+import { evaluateBlobLink } from '../vercel/env-matrix.js'
+import { logger } from '../utils/logger.js'
+
+interface BlobLinkOptions {
+  token?: string
+  project?: string
+  org?: string
+  json?: boolean
+}
+
+function mark(present: boolean): string {
+  return present ? chalk.green('PASS') : chalk.red('FAIL')
+}
+
+export function registerVercelBlobLinkCommand(program: Command): void {
+  program
+    .command('vercel:blob-link')
+    .description('Validate the Vercel Blob store connection for the linked project')
+    .option('--token <token>', 'Vercel access token (defaults to $VERCEL_TOKEN)')
+    .option('--project <id>', 'Vercel project id (defaults to .vercel/project.json)')
+    .option('--org <id>', 'Vercel team/org id (defaults to .vercel/project.json)')
+    .option('--json', 'Print machine-readable JSON')
+    .action(async (opts: BlobLinkOptions) => {
+      const token = resolveVercelToken(opts.token)
+      if (!token) {
+        logger.error(
+          'No Vercel token found. Pass --token or set VERCEL_TOKEN (create one at https://vercel.com/account/tokens).',
+        )
+        process.exitCode = 1
+        return
+      }
+
+      const link = opts.project
+        ? { projectId: opts.project, orgId: opts.org }
+        : await readVercelLink(process.cwd())
+      if (!link?.projectId) {
+        logger.error(
+          'No linked Vercel project found. Run `vercel link` first, or pass --project <id> (and --org <id> for team projects).',
+        )
+        process.exitCode = 1
+        return
+      }
+
+      const client = createVercelClient({ token, teamId: link.orgId ?? opts.org })
+
+      let envVars
+      try {
+        envVars = await client.listProjectEnv(link.projectId)
+      } catch (error) {
+        const message =
+          error instanceof VercelApiError
+            ? error.message
+            : error instanceof Error
+              ? error.message
+              : String(error)
+        logger.error(`Could not read project environment variables from Vercel: ${message}`)
+        process.exitCode = 1
+        return
+      }
+
+      const report = evaluateBlobLink(envVars)
+
+      if (opts.json) {
+        console.log(JSON.stringify({ projectId: link.projectId, ...report }, null, 2))
+      } else {
+        console.log()
+        console.log(chalk.bold('Vercel Blob connection'))
+        console.log(chalk.dim('─────────────────────────────────'))
+        if (!report.linked) {
+          console.log('No Vercel Blob store is connected to this project.')
+        } else {
+          console.log('BLOB_READ_WRITE_TOKEN by environment:')
+          for (const target of VERCEL_TARGETS) {
+            console.log(`  ${mark(report.tokenByTarget[target])} ${target}`)
+          }
+        }
+        console.log(chalk.dim('─────────────────────────────────'))
+      }
+
+      if (report.status === 'partial') {
+        if (!opts.json) {
+          logger.error(
+            'A Blob store is connected but BLOB_READ_WRITE_TOKEN is missing for Production/Preview. Uploads will fail.',
+          )
+          logger.info(
+            'Reconnect the Blob store and provision the token to all environments (include Development for local `vercel env pull`), then re-run this command.',
+          )
+        }
+        process.exitCode = 1
+        return
+      }
+
+      const devOnlyMissing =
+        report.linked && report.missingTargets.includes('development' as VercelTarget)
+      if (devOnlyMissing && !opts.json) {
+        logger.warn(
+          'BLOB_READ_WRITE_TOKEN is not set for Development — `vercel env pull` will not provide a local token. Include Development when connecting the store.',
+        )
+      } else if (report.status === 'ok' && !opts.json) {
+        logger.success(
+          'Blob store is connected and BLOB_READ_WRITE_TOKEN is provisioned for Production and Preview.',
+        )
+      }
+    })
+}

package/src/deployment/diagnostics.ts

@@ -38,6 +38,24 @@ export const REQUIRED_ENV_VARS = [
   'NEXT_PUBLIC_SITE_URL',
 ] as const
 
+/** Vars the per-environment Vercel matrix treats as deploy-blocking. */
+export const VERCEL_MATRIX_REQUIRED = [
+  'DATABASE_URL',
+  'DIRECT_DATABASE_URL',
+  'CMS_SECRET',
+  'CMS_ENCRYPTION_KEY',
+  'NEXT_PUBLIC_SITE_URL',
+  'CRON_SECRET',
+] as const
+
+/** Vars the matrix surfaces as advisory (feature-gated, not deploy-blocking). */
+export const VERCEL_MATRIX_OPTIONAL = [
+  'BLOB_READ_WRITE_TOKEN',
+  'UPSTASH_REDIS_REST_URL',
+  'UPSTASH_REDIS_REST_TOKEN',
+  'RESEND_API_KEY',
+] as const
+
 export interface DiagnosticInput {
   schemaModels: Set<string>
   schemaContent?: string
@@ -56,6 +74,32 @@ export function missingEnvVars(env: Record<string, string | undefined>): string[
   return REQUIRED_ENV_VARS.filter((name) => !env[name])
 }
 
+export type BlobLinkState = 'ok' | 'partial' | 'token-format' | 'none'
+
+/**
+ * Classify the local Vercel Blob wiring. A "partial" link is the failure mode
+ * Opal hit: a Blob store is connected (so `BLOB_STORE_ID` / the webhook key are
+ * present, or the config selects vercel-blob storage) but `BLOB_READ_WRITE_TOKEN`
+ * was never provisioned — uploads then fail at runtime even though the store is
+ * "connected" in the dashboard. We treat that as a hard failure, not a warning.
+ */
+export function detectBlobLinkState(
+  env: Record<string, string | undefined>,
+  configContent?: string,
+): BlobLinkState {
+  const token = env.BLOB_READ_WRITE_TOKEN
+  if (token) {
+    return token.startsWith('vercel_blob_') ? 'ok' : 'token-format'
+  }
+
+  const hasPartialSignals =
+    Boolean(env.BLOB_STORE_ID) ||
+    Boolean(env.BLOB_WEBHOOK_PUBLIC_KEY) ||
+    (configContent ? /vercel-blob|platform-vercel|vercelBlob/i.test(configContent) : false)
+
+  return hasPartialSignals ? 'partial' : 'none'
+}
+
 export function detectPackageManager(lockfiles: Set<string>): string {
   if (lockfiles.has('pnpm-lock.yaml')) return 'pnpm'
   if (lockfiles.has('yarn.lock')) return 'yarn'
@@ -123,6 +167,31 @@ export function createDiagnosticReport(input: DiagnosticInput): DiagnosticReport
     docs: 'https://actuatecms.dev/docs/environment-variables',
   })
 
+  const blobState = detectBlobLinkState(input.env, input.configContent)
+  checks.push({
+    id: 'blob-storage',
+    label: 'Vercel Blob storage',
+    status: blobState === 'partial' ? 'fail' : blobState === 'token-format' ? 'warn' : 'pass',
+    message:
+      blobState === 'partial'
+        ? 'A Vercel Blob store is linked (BLOB_STORE_ID / webhook key or vercel-blob storage configured) but BLOB_READ_WRITE_TOKEN is missing. Media uploads will fail.'
+        : blobState === 'token-format'
+          ? 'BLOB_READ_WRITE_TOKEN does not start with `vercel_blob_` — verify it is a real Vercel Blob read-write token.'
+          : blobState === 'ok'
+            ? 'BLOB_READ_WRITE_TOKEN is configured.'
+            : 'No Vercel Blob storage configured (skipped).',
+    fix:
+      blobState === 'partial'
+        ? 'Finish the Blob connection so BLOB_READ_WRITE_TOKEN is provisioned to every environment (including Development for local `vercel env pull`), then `vercel env pull`. Validate with `actuate vercel:blob-link`.'
+        : blobState === 'token-format'
+          ? 'Re-copy the read-write token from the Vercel Blob store (Storage tab) and re-pull your environment.'
+          : undefined,
+    docs:
+      blobState === 'partial' || blobState === 'token-format'
+        ? 'https://actuatecms.dev/docs/deployment'
+        : undefined,
+  })
+
   checks.push({
     id: 'package-manager',
     label: 'Package manager',
@@ -163,6 +232,7 @@ export function buildDeploymentManifest() {
       'DIRECT_DATABASE_URL',
       'CMS_ADMIN_EMAIL',
       'CMS_ADMIN_PASSWORD',
+      'CRON_SECRET',
       'BLOB_READ_WRITE_TOKEN',
       'UPSTASH_REDIS_REST_URL',
       'UPSTASH_REDIS_REST_TOKEN',

package/src/index.ts

@@ -17,6 +17,7 @@ import {
   registerDoctorCommand,
   registerVerifyCommand,
 } from './commands/doctor.js'
+import { registerVercelBlobLinkCommand } from './commands/vercel-blob-link.js'
 
 const program = new Command()
 
@@ -40,5 +41,6 @@ registerInitCommand(program)
 registerDoctorCommand(program)
 registerDeployCheckCommand(program)
 registerVerifyCommand(program)
+registerVercelBlobLinkCommand(program)
 
 program.parse()