@betterstart/cli 0.1.30 → 0.1.32

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
 } from "./chunk-6JCWMKSY.js";
 
 // src/cli.ts
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/commands/generate.ts
 import path22 from "path";
@@ -901,8 +901,8 @@ function toPascalCase3(str) {
   return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
 }
 function toCamelCase(str) {
-  const p6 = toPascalCase3(str);
-  return p6.charAt(0).toLowerCase() + p6.slice(1);
+  const p7 = toPascalCase3(str);
+  return p7.charAt(0).toLowerCase() + p7.slice(1);
 }
 function toKebabCase(str) {
   return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
@@ -993,7 +993,7 @@ function generateFormAdminPages(schema, cwd, pagesDir, options) {
   const adminDir = path4.join(cwd, pagesDir, "forms", kebab);
   if (!fs4.existsSync(adminDir)) fs4.mkdirSync(adminDir, { recursive: true });
   const files = [];
-  const rel = (p6) => path4.relative(cwd, p6);
+  const rel = (p7) => path4.relative(cwd, p7);
   const pagePath = path4.join(adminDir, "page.tsx");
   if (!fs4.existsSync(pagePath) || options.force) {
     fs4.writeFileSync(pagePath, generatePage(pascal, kebab), "utf-8");
@@ -1934,8 +1934,8 @@ function toPascalCase4(str) {
   return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
 }
 function toCamelCase2(str) {
-  const p6 = toPascalCase4(str);
-  return p6.charAt(0).toLowerCase() + p6.slice(1);
+  const p7 = toPascalCase4(str);
+  return p7.charAt(0).toLowerCase() + p7.slice(1);
 }
 function toKebabCase3(str) {
   return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
@@ -2650,8 +2650,8 @@ function toPascalCase5(str) {
   return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
 }
 function toCamelCase3(str) {
-  const p6 = toPascalCase5(str);
-  return p6.charAt(0).toLowerCase() + p6.slice(1);
+  const p7 = toPascalCase5(str);
+  return p7.charAt(0).toLowerCase() + p7.slice(1);
 }
 function singularize2(str) {
   if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
@@ -2711,11 +2711,11 @@ function generateActions(schema, cwd, actionsDir, options = {}) {
   const listFieldsWithRels = findListFieldsWithRelationships(dbFields);
   const hasListRels = listFieldsWithRels.length > 0;
   const allListRelQueries = [];
-  for (const { field: listField, path: path42 } of listFieldsWithRels) {
+  for (const { field: listField, path: path43 } of listFieldsWithRels) {
     const rels = (listField.fields || []).filter((f) => f.type === "relationship" && f.relationship);
     for (const relField of rels) {
       allListRelQueries.push({
-        fieldPath: path42.join("_"),
+        fieldPath: path43.join("_"),
         relField,
         relTable: toCamelCase3(relField.relationship),
         listFieldName: listField.name
@@ -2723,6 +2723,10 @@ function generateActions(schema, cwd, actionsDir, options = {}) {
     }
   }
   const populateListRelsFn = hasListRels ? generatePopulateListRelsFunction(allListRelQueries, Singular) : "";
+  const htmlOutputFields = regularDbFields.filter(
+    (f) => (f.type === "richtext" || f.type === "markdown") && f.output === "html"
+  );
+  const hasHtmlOutput = htmlOutputFields.length > 0;
   const hasSlug = regularDbFields.some((f) => f.name === "slug");
   const hasDraft = schema.actions?.draft === true;
   const hasPublished = regularDbFields.some((f) => f.name === "published");
@@ -2769,8 +2773,10 @@ function generateActions(schema, cwd, actionsDir, options = {}) {
     (f) => `  ${quotePropertyName2(f.name)}: ${getFieldType(f, "output")}${f.required ? "" : " | null"}`
   ).join("\n");
   const m2mFieldTypes = m2mFields.map((f) => `  ${quotePropertyName2(f.name)}: number[]`).join("\n");
+  const htmlFieldTypes = htmlOutputFields.map((f) => `  ${f.name}Html: string`).join("\n");
   const dataInterface = `export interface ${Singular}Data {
-${dataFields}${m2mFieldTypes ? `
+${dataFields}${htmlFieldTypes ? `
+${htmlFieldTypes}` : ""}${m2mFieldTypes ? `
 ${m2mFieldTypes}` : ""}
 }`;
   const responseInterface = `export interface ${Plural}Response {
@@ -2837,6 +2843,10 @@ ${searchFields.map((f) => `          ilike(${tableVar}.${f}, searchTerm)`).join(
     }`;
   const fieldMeta = createFields.map((f) => `{ name: '${f.name}', type: '${f.type}', required: ${f.required ?? false} }`).join(",\n    ");
   const createMappings = createFields.map((f) => `      ${f.name}: ${generateFieldMapping(f)}`).join(",\n");
+  const htmlCreateBlock = hasHtmlOutput ? `
+    const { renderMarkdownSync } = await import('@cms/lib/markdown/render')
+` + htmlOutputFields.map((f) => `    const ${f.name}Html = renderMarkdownSync(input.${f.name} || '')`).join("\n") + "\n" : "";
+  const htmlCreateMappings = htmlOutputFields.map((f) => `      ${f.name}Html`).join(",\n");
   const distinctFns = hasFilters ? (schema.filters || []).map(
     (filter) => `
 export async function getDistinct${Plural}${toPascalCase5(filter.field)}(): Promise<string[]> {
@@ -3004,9 +3014,10 @@ export async function create${Singular}(input: Create${Singular}Input): Promise<
       .orderBy(desc(${tableVar}.sortOrder))
       .limit(1)
     const nextSortOrder = (maxSortOrderResult[0]?.maxOrder ?? 0) + 1
-
+${htmlCreateBlock}
     const result = await db.insert(${tableVar}).values({
-${createMappings},${hasDraft ? `
+${createMappings},${hasHtmlOutput ? `
+${htmlCreateMappings},` : ""}${hasDraft ? `
       published: input.published ?? false,` : ""}
       sortOrder: nextSortOrder,
       createdAt: new Date().toISOString(),
@@ -3046,7 +3057,11 @@ ${autoSlugUpdate}
         processedData[key] = value
       }
     }
-
+${hasHtmlOutput ? `
+    const { renderMarkdownSync } = await import('@cms/lib/markdown/render')
+` + htmlOutputFields.map((f) => `    if (processedData.${f.name} !== undefined) {
+      processedData.${f.name}Html = renderMarkdownSync(String(processedData.${f.name} || ''))
+    }`).join("\n") + "\n" : ""}
     const result = await db.update(${tableVar})
       .set({ ...processedData, updatedAt: new Date().toISOString() })
       .where(eq(${tableVar}.id, id))
@@ -3150,6 +3165,10 @@ function generateSingleActions(schema, cwd, actionsDir, options = {}) {
   const dbFields = flattenFields(schema.fields).filter(
     (f) => !(f.type === "relationship" && f.multiple === true)
   );
+  const singleHtmlOutputFields = dbFields.filter(
+    (f) => (f.type === "richtext" || f.type === "markdown") && f.output === "html"
+  );
+  const singleHasHtmlOutput = singleHtmlOutputFields.length > 0;
   const allDbFields = [...dbFields];
   if (!dbFields.some((f) => f.name === "createdAt")) {
     allDbFields.push({ name: "createdAt", type: "timestamp", required: true });
@@ -3163,8 +3182,10 @@ function generateSingleActions(schema, cwd, actionsDir, options = {}) {
   const dataFields = allDbFields.map(
     (f) => `  ${quotePropertyName2(f.name)}: ${getFieldType(f, "output")}${f.required ? "" : " | null"}`
   ).join("\n");
+  const singleHtmlFieldTypes = singleHtmlOutputFields.map((f) => `  ${f.name}Html: string`).join("\n");
   const dataInterface = `export interface ${Singular}Data {
-${dataFields}
+${dataFields}${singleHtmlFieldTypes ? `
+${singleHtmlFieldTypes}` : ""}
 }`;
   const upsertInterfaceFields = upsertFields.map(
     (f) => `  ${quotePropertyName2(f.name)}${f.required ? "" : "?"}: ${getFieldType(f, "input")}`
@@ -3175,6 +3196,7 @@ ${upsertInterfaceFields}
   const upsertMappings = upsertFields.map((f) => `      ${f.name}: ${generateFieldMapping(f)}`).join(",\n");
   const fieldMeta = upsertFields.map((f) => `{ name: '${f.name}', type: '${f.type}', required: ${f.required ?? false} }`).join(",\n    ");
   const cacheTag = `${schema.name}:all`;
+  const singleHtmlUpsertMappings = singleHtmlOutputFields.map((f) => `      ${f.name}Html`).join(",\n");
   const content = `'use server'
 
 import db from '@cms/db'
@@ -3223,14 +3245,18 @@ export async function upsert${Singular}(input: Upsert${Singular}Input): Promise<
         processedData[key] = value
       }
     }
-
+${singleHasHtmlOutput ? `
+    const { renderMarkdownSync } = await import('@cms/lib/markdown/render')
+` + singleHtmlOutputFields.map((f) => `    if (processedData.${f.name} !== undefined) {
+      processedData.${f.name}Html = renderMarkdownSync(String(processedData.${f.name} || ''))
+    }`).join("\n") + "\n" + singleHtmlOutputFields.map((f) => `    const ${f.name}Html = renderMarkdownSync(input.${f.name} || '')`).join("\n") + "\n" : ""}
     const now = new Date().toISOString()
 
     const result = await db
       .insert(${tableVar})
       .values({
         id: 1,
-${upsertMappings},
+${upsertMappings},${singleHasHtmlOutput ? "\n" + singleHtmlOutputFields.map((f) => `      ${f.name}Html`).join(",\n") + "," : ""}
         createdAt: now,
         updatedAt: now
       })
@@ -3374,8 +3400,8 @@ function toPascalCase6(str) {
   return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
 }
 function toCamelCase4(str) {
-  const p6 = toPascalCase6(str);
-  return p6.charAt(0).toLowerCase() + p6.slice(1);
+  const p7 = toPascalCase6(str);
+  return p7.charAt(0).toLowerCase() + p7.slice(1);
 }
 function singularize3(str) {
   if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
@@ -4506,8 +4532,8 @@ function toPascalCase9(str) {
   return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
 }
 function toCamelCase5(str) {
-  const p6 = toPascalCase9(str);
-  return p6.charAt(0).toLowerCase() + p6.slice(1);
+  const p7 = toPascalCase9(str);
+  return p7.charAt(0).toLowerCase() + p7.slice(1);
 }
 function singularize6(str) {
   if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
@@ -4553,7 +4579,14 @@ function generateTableDefinition(schema, requiredImports, needsSql) {
   const fieldDefs = dbFields.map((field) => {
     const drizzleType = toDrizzleType(field, requiredImports);
     const modifiers = getFieldModifiers(field, needsSql);
-    return `    ${field.name}: ${drizzleType}${modifiers}`;
+    const line = `    ${field.name}: ${drizzleType}${modifiers}`;
+    if ((field.type === "richtext" || field.type === "markdown") && field.output === "html") {
+      const snakeName = field.name.replace(/([A-Z])/g, "_$1").toLowerCase();
+      requiredImports.add("text");
+      return `${line},
+    ${field.name}Html: text('${snakeName}_html')`;
+    }
+    return line;
   }).join(",\n");
   let publishedField = "";
   if (hasDraftMode && !hasPublishedField) {
@@ -4755,8 +4788,8 @@ function toPascalCase10(str) {
   return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
 }
 function toCamelCase6(str) {
-  const p6 = toPascalCase10(str);
-  return p6.charAt(0).toLowerCase() + p6.slice(1);
+  const p7 = toPascalCase10(str);
+  return p7.charAt(0).toLowerCase() + p7.slice(1);
 }
 function singularize7(str) {
   if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
@@ -5417,6 +5450,36 @@ ${indent}                        </FormControl>${nestedHint}
 ${indent}                        <FormMessage />
 ${indent}                      </FormItem>
 ${indent}                    )}
+${indent}                  />`;
+      }
+      if (nf.type === "video") {
+        return `${indent}                  <FormField
+${indent}                    control={form.control}
+${indent}                    name={\`${field.name}.\${index}.${nf.name}\`}
+${indent}                    render={({ field: formField }) => (
+${indent}                      <FormItem>
+${indent}                        <FormLabel>${nestedLabel}</FormLabel>
+${indent}                        <FormControl>
+${indent}                          <VideoUploadField value={formField.value} onChange={formField.onChange} onBlur={formField.onBlur} disabled={isPending} maxSizeInMB={100} label="" />
+${indent}                        </FormControl>${nestedHint}
+${indent}                        <FormMessage />
+${indent}                      </FormItem>
+${indent}                    )}
+${indent}                  />`;
+      }
+      if (nf.type === "media") {
+        return `${indent}                  <FormField
+${indent}                    control={form.control}
+${indent}                    name={\`${field.name}.\${index}.${nf.name}\`}
+${indent}                    render={({ field: formField }) => (
+${indent}                      <FormItem>
+${indent}                        <FormLabel>${nestedLabel}</FormLabel>
+${indent}                        <FormControl>
+${indent}                          <MediaUploadField value={formField.value} onChange={formField.onChange} onBlur={formField.onBlur} disabled={isPending} maxSizeInMB={100} label="" />
+${indent}                        </FormControl>${nestedHint}
+${indent}                        <FormMessage />
+${indent}                      </FormItem>
+${indent}                    )}
 ${indent}                  />`;
       }
       return `${indent}                  <FormField
@@ -6945,8 +7008,8 @@ function toPascalCase16(str) {
   return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
 }
 function toCamelCase7(str) {
-  const p6 = toPascalCase16(str);
-  return p6.charAt(0).toLowerCase() + p6.slice(1);
+  const p7 = toPascalCase16(str);
+  return p7.charAt(0).toLowerCase() + p7.slice(1);
 }
 function singularize12(str) {
   if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
@@ -7631,7 +7694,7 @@ function runPostGenerate(cwd, schemaName, options = {}) {
       console.log("\n  Running drizzle-kit push...");
       const drizzleBin = path21.join(cwd, "node_modules", ".bin", "drizzle-kit");
       try {
-        execFileSync2(drizzleBin, ["push", "--force"], { cwd, stdio: "pipe" });
+        execFileSync2(drizzleBin, ["push", "--force"], { cwd, stdio: "inherit" });
         result.dbPush = "success";
         console.log("  Database schema synced");
       } catch {
@@ -10550,7 +10613,6 @@ function markdownRenderTemplate() {
   return `import { transformerNotationDiff, transformerNotationHighlight } from '@shikijs/transformers'
 import { renderToString } from 'katex'
 import MarkdownIt from 'markdown-it'
-import dollarmath from 'markdown-it-dollarmath'
 import { createHighlighterCoreSync } from 'shiki/core'
 import { createJavaScriptRegexEngine } from 'shiki/engine/javascript'
 import css from 'shiki/langs/css.mjs'
@@ -10638,6 +10700,68 @@ function headingAnchorPlugin(md: MarkdownIt) {
   })
 }
 
+// --- Inline KaTeX math plugin (replaces markdown-it-dollarmath) ---
+
+function mathPlugin(md: MarkdownIt) {
+  // Inline: $...$
+  md.inline.ruler.after('escape', 'math_inline', (state, silent) => {
+    if (state.src.charCodeAt(state.pos) !== 0x24) return false
+    if (state.src.charCodeAt(state.pos + 1) === 0x24) return false
+    const start = state.pos + 1
+    let end = start
+    while (end < state.posMax && state.src.charCodeAt(end) !== 0x24) {
+      if (state.src.charCodeAt(end) === 0x5C) end++
+      end++
+    }
+    if (end >= state.posMax) return false
+    const content = state.src.slice(start, end).trim()
+    if (!content) return false
+    if (!silent) {
+      const token = state.push('math_inline', 'math', 0)
+      token.content = content
+      token.markup = '$'
+    }
+    state.pos = end + 1
+    return true
+  })
+
+  md.renderer.rules.math_inline = (tokens, idx) => {
+    return renderToString(tokens[idx].content, { displayMode: false, throwOnError: false, strict: 'ignore' })
+  }
+
+  // Block: $$...$$
+  md.block.ruler.after('blockquote', 'math_block', (state, startLine, endLine, silent) => {
+    const startPos = state.bMarks[startLine] + state.tShift[startLine]
+    if (state.src.charCodeAt(startPos) !== 0x24 || state.src.charCodeAt(startPos + 1) !== 0x24) return false
+    if (silent) return true
+    let nextLine = startLine
+    let found = false
+    while (nextLine < endLine) {
+      nextLine++
+      if (nextLine >= endLine) break
+      const pos = state.bMarks[nextLine] + state.tShift[nextLine]
+      const max = state.eMarks[nextLine]
+      const line = state.src.slice(pos, max).trim()
+      if (line === '$$') { found = true; break }
+    }
+    if (!found) return false
+    const contentLines: string[] = []
+    for (let i = startLine + 1; i < nextLine; i++) {
+      contentLines.push(state.src.slice(state.bMarks[i] + state.tShift[i], state.eMarks[i]))
+    }
+    const token = state.push('math_block', 'math', 0)
+    token.content = contentLines.join('\\n').trim()
+    token.markup = '$$'
+    token.map = [startLine, nextLine + 1]
+    state.line = nextLine + 1
+    return true
+  })
+
+  md.renderer.rules.math_block = (tokens, idx) => {
+    return '<div class="math-display">' + renderToString(tokens[idx].content, { displayMode: true, throwOnError: false, strict: 'ignore' }) + '</div>\\n'
+  }
+}
+
 // --- Markdown-it Instance ---
 
 const md = MarkdownIt({
@@ -10658,26 +10782,7 @@ const md = MarkdownIt({
   },
 })
   .use(headingAnchorPlugin)
-  .use(dollarmath, {
-    allow_space: false,
-    allow_digits: false,
-    double_inline: true,
-    allow_labels: true,
-    allow_blank_lines: true,
-    renderer(content: string, { displayMode }: { displayMode: boolean }) {
-      return renderToString(content, {
-        displayMode,
-        throwOnError: false,
-        strict: 'ignore',
-      })
-    },
-    labelNormalizer(label: string) {
-      return label.replace(/[\\s]+/g, '-')
-    },
-    labelRenderer(label: string) {
-      return \`<a href="#\${label}" class="mathlabel" title="Permalink to this equation">\xB6</a>\`
-    },
-  })
+  .use(mathPlugin)
 
 export function renderMarkdownSync(src: string): string {
   const trimmedContent = trimMathBlock(src)
@@ -11530,7 +11635,6 @@ var CORE_DEPS = [
   "@shikijs/transformers",
   "katex",
   "markdown-it",
-  "markdown-it-dollarmath",
   // Drag-and-drop
   "@dnd-kit/core",
   "@dnd-kit/sortable",
@@ -13419,13 +13523,13 @@ var seedCommand = new Command2("seed").description("Create the initial admin use
     clack.cancel("Cancelled.");
     process.exit(0);
   }
-  const password3 = await clack.password({
+  const password4 = await clack.password({
     message: "Admin password",
     validate: (v) => {
       if (!v || v.length < 8) return "Password must be at least 8 characters";
     }
   });
-  if (clack.isCancel(password3)) {
+  if (clack.isCancel(password4)) {
     clack.cancel("Cancelled.");
     process.exit(0);
   }
@@ -13455,7 +13559,7 @@ var seedCommand = new Command2("seed").description("Create the initial admin use
         env: {
           ...process.env,
           SEED_EMAIL: email,
-          SEED_PASSWORD: password3,
+          SEED_PASSWORD: password4,
           SEED_NAME: name || "Admin",
           ...overwrite ? { SEED_OVERWRITE: "true" } : {}
         }
@@ -13471,13 +13575,13 @@ var seedCommand = new Command2("seed").description("Create the initial admin use
       }
     );
   });
-  const spinner5 = clack.spinner();
-  spinner5.start("Creating admin user...");
+  const spinner6 = clack.spinner();
+  spinner6.start("Creating admin user...");
   try {
     const result = await runSeed2(false);
     if (result.code === 2) {
       const existingName = result.stdout.split("\n").find((l) => l.startsWith("EXISTING_USER:"))?.replace("EXISTING_USER:", "")?.trim() || "unknown";
-      spinner5.stop(`Account already exists for ${email}`);
+      spinner6.stop(`Account already exists for ${email}`);
       const overwrite = await clack.confirm({
         message: `An admin account (${existingName}) already exists with this email. Replace it?`
       });
@@ -13489,14 +13593,14 @@ var seedCommand = new Command2("seed").description("Create the initial admin use
         }
         process.exit(0);
       }
-      spinner5.start("Replacing admin user...");
+      spinner6.start("Replacing admin user...");
       await runSeed2(true);
-      spinner5.stop("Admin user replaced");
+      spinner6.stop("Admin user replaced");
     } else {
-      spinner5.stop("Admin user created");
+      spinner6.stop("Admin user created");
     }
   } catch (err) {
-    spinner5.stop("Failed to create admin user");
+    spinner6.stop("Failed to create admin user");
     const errMsg = err instanceof Error ? err.message : String(err);
     clack.log.error(errMsg);
     clack.log.info("You can run the seed script manually:");
@@ -14005,7 +14109,7 @@ function hasDbUrl(cwd) {
   }
   return false;
 }
-function runSeed(cwd, cmsDir, email, password3, overwrite = false) {
+function runSeed(cwd, cmsDir, email, password4, overwrite = false) {
   const scriptsDir = path37.join(cwd, cmsDir, "scripts");
   const seedPath = path37.join(scriptsDir, "seed.ts");
   if (!fs32.existsSync(scriptsDir)) {
@@ -14029,7 +14133,7 @@ function runSeed(cwd, cmsDir, email, password3, overwrite = false) {
       env: {
         ...process.env,
         SEED_EMAIL: email,
-        SEED_PASSWORD: password3,
+        SEED_PASSWORD: password4,
         SEED_NAME: "Admin",
         ...overwrite ? { SEED_OVERWRITE: "true" } : {}
       }
@@ -14116,8 +14220,8 @@ function toPascalCase17(str) {
   return str.split(/[-_\s]+/).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
 }
 function toCamelCase8(str) {
-  const p6 = toPascalCase17(str);
-  return p6.charAt(0).toLowerCase() + p6.slice(1);
+  const p7 = toPascalCase17(str);
+  return p7.charAt(0).toLowerCase() + p7.slice(1);
 }
 function singularize13(str) {
   if (str.endsWith("ies")) return `${str.slice(0, -3)}y`;
@@ -14329,15 +14433,298 @@ var removeCommand = new Command4("remove").alias("rm").description("Remove all g
   console.log("");
 });
 
-// src/commands/uninstall.ts
-import fs35 from "fs";
+// src/commands/setup-r2.ts
+import { execFileSync as execFileSync5, spawnSync } from "child_process";
+import fs34 from "fs";
+import os from "os";
 import path39 from "path";
 import * as p5 from "@clack/prompts";
 import { Command as Command5 } from "commander";
 import pc3 from "picocolors";
+var setupR2Command = new Command5("setup-r2").description("Create a Cloudflare R2 bucket and configure storage env vars").option("--cwd <path>", "Project root path").option("--bucket <name>", "Bucket name (skips prompt)").action(async (options) => {
+  const cwd = options.cwd ? path39.resolve(options.cwd) : process.cwd();
+  p5.intro(pc3.bgCyan(pc3.black(" BetterStart \u2014 R2 Storage Setup ")));
+  const s = p5.spinner();
+  s.start("Looking for wrangler CLI");
+  const wrangler = findWrangler(cwd);
+  if (!wrangler) {
+    s.stop(`${pc3.red("\u2717")} Wrangler CLI not found`);
+    p5.log.error(
+      `Install it first:
+  ${pc3.cyan("npm install -g wrangler")}
+  ${pc3.dim("or")} ${pc3.cyan("npx wrangler --version")}`
+    );
+    process.exit(1);
+  }
+  s.stop(`Wrangler: ${pc3.cyan(wrangler.bin === "npx" ? "npx wrangler" : "wrangler")}`);
+  s.start("Checking Cloudflare authentication");
+  const whoami = runWrangler(wrangler, ["whoami"], { cwd });
+  const whoamiOut = whoami.stdout?.toString() ?? "";
+  if (whoami.status !== 0 || whoamiOut.includes("Not authenticated")) {
+    s.stop(`${pc3.yellow("\u25B2")} Not logged in to Cloudflare`);
+    const login = await p5.confirm({
+      message: "Open browser to log in to Cloudflare?",
+      initialValue: true
+    });
+    if (p5.isCancel(login) || !login) {
+      p5.cancel("Setup cancelled. Run `wrangler login` manually first.");
+      process.exit(0);
+    }
+    s.start("Waiting for Cloudflare login");
+    const loginResult = runWrangler(wrangler, ["login"], { cwd, stdio: "inherit", timeout: 12e4 });
+    if (loginResult.status !== 0) {
+      s.stop(`${pc3.red("\u2717")} Login failed`);
+      p5.cancel("Could not authenticate with Cloudflare. Run `wrangler login` manually.");
+      process.exit(1);
+    }
+    s.stop(`${pc3.green("\u2713")} Logged in to Cloudflare`);
+  } else {
+    const emailMatch = whoamiOut.match(/associated with the email\s+(\S+)/i);
+    const tableMatch = whoamiOut.match(/│\s*([^│]+?)\s*│\s*[a-f0-9]{32}\s*│/);
+    const accountLabel = emailMatch?.[1] ?? tableMatch?.[1]?.trim() ?? "authenticated";
+    s.stop(`Logged in as ${pc3.cyan(accountLabel)}`);
+  }
+  s.start("Fetching account ID");
+  const accountId = extractAccountId(wrangler, cwd);
+  if (!accountId) {
+    s.stop(`${pc3.red("\u2717")} Could not determine account ID`);
+    p5.log.info(
+      `You can find it at: ${pc3.cyan("https://dash.cloudflare.com/?to=/:account/r2")}`
+    );
+    process.exit(1);
+  }
+  s.stop(`Account ID: ${pc3.dim(accountId)}`);
+  let bucketName = options.bucket;
+  if (!bucketName) {
+    const result = await p5.text({
+      message: "R2 bucket name",
+      placeholder: "betterstart-uploads",
+      defaultValue: "betterstart-uploads",
+      validate: (v) => {
+        if (!v || v.length < 3) return "Bucket name must be at least 3 characters";
+        if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(v))
+          return "Bucket name must be lowercase alphanumeric with hyphens, no leading/trailing hyphens";
+      }
+    });
+    if (p5.isCancel(result)) {
+      p5.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    bucketName = result;
+  }
+  s.start(`Creating R2 bucket: ${bucketName}`);
+  const createResult = runWrangler(wrangler, ["r2", "bucket", "create", bucketName], {
+    cwd,
+    timeout: 3e4
+  });
+  const createOut = (createResult.stdout?.toString() ?? "") + (createResult.stderr?.toString() ?? "");
+  if (createResult.status !== 0) {
+    if (createOut.includes("already exists") || createOut.includes("AlreadyExists")) {
+      s.stop(`Bucket ${pc3.cyan(bucketName)} already exists \u2014 using it`);
+    } else {
+      s.stop("Failed to create bucket");
+      p5.log.error(createOut.trim() || "Unknown error from wrangler");
+      process.exit(1);
+    }
+  } else {
+    s.stop(`Created bucket: ${pc3.cyan(bucketName)}`);
+  }
+  let publicUrl = "";
+  const oauthToken = readWranglerToken();
+  if (oauthToken) {
+    s.start("Enabling public r2.dev URL");
+    const domainResult = await enablePublicDomain(accountId, bucketName, oauthToken);
+    if (domainResult.success && domainResult.domain) {
+      publicUrl = `https://${domainResult.domain}`;
+      s.stop(`Public URL: ${pc3.cyan(publicUrl)}`);
+    } else {
+      s.stop("Could not enable public URL automatically");
+      p5.log.warning(domainResult.error ?? "Unknown error");
+      p5.log.info(
+        `You can enable it manually in the dashboard:
+  ${pc3.cyan(`https://dash.cloudflare.com/${accountId}/r2/default/buckets/${bucketName}/settings`)}`
+      );
+    }
+  } else {
+    p5.log.warning("Could not read wrangler OAuth token \u2014 skipping public URL setup");
+    p5.log.info(
+      `Enable it manually: ${pc3.cyan(`https://dash.cloudflare.com/${accountId}/r2/default/buckets/${bucketName}/settings`)}`
+    );
+  }
+  p5.note(
+    [
+      `Create an R2 API token with ${pc3.bold("Object Read & Write")} permission.`,
+      "",
+      `Dashboard: ${pc3.cyan(`https://dash.cloudflare.com/${accountId}/r2/api-tokens`)}`,
+      "",
+      pc3.dim("The dashboard will give you an Access Key ID and Secret Access Key.")
+    ].join("\n"),
+    "Create R2 API Token"
+  );
+  const openDashboard = await p5.confirm({
+    message: "Open the R2 API tokens page in your browser?",
+    initialValue: true
+  });
+  if (!p5.isCancel(openDashboard) && openDashboard) {
+    const url = `https://dash.cloudflare.com/${accountId}/r2/api-tokens`;
+    try {
+      execFileSync5("open", [url], { stdio: "pipe", timeout: 5e3 });
+    } catch {
+      p5.log.warning(`Could not open browser. Visit: ${pc3.cyan(url)}`);
+    }
+  }
+  const credentials = await p5.group(
+    {
+      accessKeyId: () => p5.text({
+        message: "R2 Access Key ID",
+        placeholder: "Paste from Cloudflare dashboard",
+        validate: (v) => {
+          if (!v || v.trim().length < 10) return "Please paste a valid Access Key ID";
+        }
+      }),
+      secretAccessKey: () => p5.password({
+        message: "R2 Secret Access Key",
+        validate: (v) => {
+          if (!v || v.trim().length < 10) return "Please paste a valid Secret Access Key";
+        }
+      })
+    },
+    {
+      onCancel: () => {
+        p5.cancel("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+  );
+  s.start("Writing environment variables");
+  const envResult = appendEnvVars(cwd, [
+    {
+      header: "Storage (Cloudflare R2)",
+      vars: [
+        { key: "BETTERSTART_R2_ACCOUNT_ID", value: accountId },
+        { key: "BETTERSTART_R2_ACCESS_KEY_ID", value: credentials.accessKeyId.trim() },
+        { key: "BETTERSTART_R2_SECRET_ACCESS_KEY", value: credentials.secretAccessKey.trim() },
+        { key: "BETTERSTART_R2_BUCKET_NAME", value: bucketName },
+        ...publicUrl ? [{ key: "BETTERSTART_R2_PUBLIC_URL", value: publicUrl }] : []
+      ]
+    }
+  ], /* @__PURE__ */ new Set([
+    "BETTERSTART_R2_ACCOUNT_ID",
+    "BETTERSTART_R2_ACCESS_KEY_ID",
+    "BETTERSTART_R2_SECRET_ACCESS_KEY",
+    "BETTERSTART_R2_BUCKET_NAME",
+    "BETTERSTART_R2_PUBLIC_URL"
+  ]));
+  const totalChanged = envResult.added.length + envResult.updated.length;
+  if (totalChanged > 0) {
+    s.stop(`Updated .env.local ${pc3.dim(`(${envResult.added.length} added, ${envResult.updated.length} updated)`)}`);
+  } else {
+    s.stop("All R2 env vars already set in .env.local");
+  }
+  const summaryLines = [
+    `Bucket:     ${pc3.cyan(bucketName)}`,
+    `Account:    ${pc3.dim(accountId)}`,
+    `Access Key: ${pc3.dim(credentials.accessKeyId.trim().slice(0, 8) + "...")}`
+  ];
+  if (publicUrl) {
+    summaryLines.push(`Public URL: ${pc3.cyan(publicUrl)}`);
+  }
+  summaryLines.push(`Env file:   ${pc3.dim(".env.local")}`);
+  p5.note(summaryLines.join("\n"), pc3.green("R2 storage configured"));
+  p5.outro("Done! Your CMS can now upload files to R2.");
+});
+function findWrangler(cwd) {
+  const localBin = path39.join(cwd, "node_modules", ".bin", "wrangler");
+  if (fs34.existsSync(localBin)) return { bin: localBin, prefix: [] };
+  const result = spawnSync("which", ["wrangler"], { stdio: "pipe", timeout: 5e3 });
+  if (result.status === 0) {
+    const found = result.stdout?.toString().trim();
+    if (found) return { bin: found, prefix: [] };
+  }
+  const npxResult = spawnSync("npx", ["wrangler", "--version"], {
+    stdio: "pipe",
+    timeout: 15e3
+  });
+  if (npxResult.status === 0) return { bin: "npx", prefix: ["wrangler"] };
+  return null;
+}
+function runWrangler(ref, args, opts) {
+  const fullArgs = [...ref.prefix, ...args];
+  return spawnSync(ref.bin, fullArgs, {
+    cwd: opts.cwd,
+    stdio: opts.stdio ?? "pipe",
+    timeout: opts.timeout ?? 15e3
+  });
+}
+function extractAccountId(ref, cwd) {
+  const result = runWrangler(ref, ["whoami"], { cwd });
+  const output = result.stdout?.toString() ?? "";
+  const idMatch = output.match(/Account ID[:\s]+([a-f0-9]{32})/i);
+  if (idMatch) return idMatch[1];
+  const hexMatch = output.match(/\b([a-f0-9]{32})\b/);
+  if (hexMatch) return hexMatch[1];
+  return null;
+}
+function readWranglerToken() {
+  const candidates = [
+    path39.join(os.homedir(), "Library", "Preferences", ".wrangler", "config", "default.toml"),
+    // macOS
+    path39.join(os.homedir(), ".config", ".wrangler", "config", "default.toml"),
+    // Linux
+    path39.join(os.homedir(), ".wrangler", "config", "default.toml")
+    // fallback
+  ];
+  if (process.env.WRANGLER_CONFIG_PATH) {
+    candidates.unshift(process.env.WRANGLER_CONFIG_PATH);
+  }
+  if (process.env.XDG_CONFIG_HOME) {
+    candidates.unshift(
+      path39.join(process.env.XDG_CONFIG_HOME, ".wrangler", "config", "default.toml")
+    );
+  }
+  for (const configPath of candidates) {
+    if (!fs34.existsSync(configPath)) continue;
+    try {
+      const content = fs34.readFileSync(configPath, "utf-8");
+      const match = content.match(/^oauth_token\s*=\s*"([^"]+)"/m);
+      if (match) return match[1];
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function enablePublicDomain(accountId, bucketName, token) {
+  try {
+    const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/r2/buckets/${bucketName}/domains/managed`;
+    const res = await fetch(url, {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ enabled: true })
+    });
+    const data = await res.json();
+    if (data.success && data.result?.domain) {
+      return { success: true, domain: data.result.domain };
+    }
+    const errMsg = data.errors?.[0]?.message ?? "API returned success=false";
+    return { success: false, error: errMsg };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : "fetch failed" };
+  }
+}
+
+// src/commands/uninstall.ts
+import fs36 from "fs";
+import path40 from "path";
+import * as p6 from "@clack/prompts";
+import { Command as Command6 } from "commander";
+import pc4 from "picocolors";
 
 // src/commands/uninstall-cleaners.ts
-import fs34 from "fs";
+import fs35 from "fs";
 function stripJsonComments2(input) {
   let result = "";
   let i = 0;
@@ -14371,8 +14758,8 @@ function stripJsonComments2(input) {
   return result;
 }
 function cleanTsconfig(tsconfigPath) {
-  if (!fs34.existsSync(tsconfigPath)) return [];
-  const raw = fs34.readFileSync(tsconfigPath, "utf-8");
+  if (!fs35.existsSync(tsconfigPath)) return [];
+  const raw = fs35.readFileSync(tsconfigPath, "utf-8");
   const stripped = stripJsonComments2(raw).replace(/,\s*([\]}])/g, "$1");
   let tsconfig;
   try {
@@ -14396,13 +14783,13 @@ function cleanTsconfig(tsconfigPath) {
     compilerOptions.paths = paths;
   }
   tsconfig.compilerOptions = compilerOptions;
-  fs34.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
+  fs35.writeFileSync(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `, "utf-8");
   return removed;
 }
 function cleanCss(cssPath) {
-  if (!fs34.existsSync(cssPath)) return [];
-  const content = fs34.readFileSync(cssPath, "utf-8");
+  if (!fs35.existsSync(cssPath)) return [];
+  const content = fs35.readFileSync(cssPath, "utf-8");
   const lines = content.split("\n");
   const sourcePattern = /^@source\s+"[^"]*cms[^"]*";\s*$/;
   const removed = [];
@@ -14416,12 +14803,12 @@ function cleanCss(cssPath) {
   }
   if (removed.length === 0) return [];
   const cleaned = kept.join("\n").replace(/\n{3,}/g, "\n\n");
-  fs34.writeFileSync(cssPath, cleaned, "utf-8");
+  fs35.writeFileSync(cssPath, cleaned, "utf-8");
   return removed;
 }
 function cleanEnvFile(envPath) {
-  if (!fs34.existsSync(envPath)) return [];
-  const content = fs34.readFileSync(envPath, "utf-8");
+  if (!fs35.existsSync(envPath)) return [];
+  const content = fs35.readFileSync(envPath, "utf-8");
   const lines = content.split("\n");
   const removed = [];
   const kept = [];
@@ -14454,9 +14841,9 @@ function cleanEnvFile(envPath) {
   if (removed.length === 0) return [];
   const result = kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
   if (result === "") {
-    fs34.unlinkSync(envPath);
+    fs35.unlinkSync(envPath);
   } else {
-    fs34.writeFileSync(envPath, `${result}
+    fs35.writeFileSync(envPath, `${result}
 `, "utf-8");
   }
   return removed;
@@ -14482,15 +14869,15 @@ function findMainCss2(cwd) {
     "globals.css"
   ];
   for (const candidate of candidates) {
-    const filePath = path39.join(cwd, candidate);
-    if (fs35.existsSync(filePath)) return filePath;
+    const filePath = path40.join(cwd, candidate);
+    if (fs36.existsSync(filePath)) return filePath;
   }
   return void 0;
 }
 function isCLICreatedBiome(biomePath) {
-  if (!fs35.existsSync(biomePath)) return false;
+  if (!fs36.existsSync(biomePath)) return false;
   try {
-    const content = JSON.parse(fs35.readFileSync(biomePath, "utf-8"));
+    const content = JSON.parse(fs36.readFileSync(biomePath, "utf-8"));
     return content.$schema?.includes("biomejs.dev") && content.formatter?.indentStyle === "space" && content.javascript?.formatter?.quoteStyle === "single" && Array.isArray(content.files?.ignore) && content.files.ignore.includes(".next");
   } catch {
     return false;
@@ -14498,13 +14885,13 @@ function isCLICreatedBiome(biomePath) {
 }
 function buildUninstallPlan(cwd) {
   const steps = [];
-  const hasSrc = fs35.existsSync(path39.join(cwd, "src"));
+  const hasSrc = fs36.existsSync(path40.join(cwd, "src"));
   const appBase = hasSrc ? "src/app" : "app";
   const dirs = [];
-  const cmsDir = path39.join(cwd, "cms");
-  const cmsRouteGroup = path39.join(cwd, appBase, "(cms)");
-  if (fs35.existsSync(cmsDir)) dirs.push("cms/");
-  if (fs35.existsSync(cmsRouteGroup)) dirs.push(`${appBase}/(cms)/`);
+  const cmsDir = path40.join(cwd, "cms");
+  const cmsRouteGroup = path40.join(cwd, appBase, "(cms)");
+  if (fs36.existsSync(cmsDir)) dirs.push("cms/");
+  if (fs36.existsSync(cmsRouteGroup)) dirs.push(`${appBase}/(cms)/`);
   if (dirs.length > 0) {
     steps.push({
       label: "CMS directories",
@@ -14512,25 +14899,25 @@ function buildUninstallPlan(cwd) {
       count: dirs.length,
       unit: dirs.length === 1 ? "directory" : "directories",
       execute() {
-        if (fs35.existsSync(cmsDir)) fs35.rmSync(cmsDir, { recursive: true, force: true });
-        if (fs35.existsSync(cmsRouteGroup)) fs35.rmSync(cmsRouteGroup, { recursive: true, force: true });
+        if (fs36.existsSync(cmsDir)) fs36.rmSync(cmsDir, { recursive: true, force: true });
+        if (fs36.existsSync(cmsRouteGroup)) fs36.rmSync(cmsRouteGroup, { recursive: true, force: true });
       }
     });
   }
   const configFiles = [];
   const configPaths = [];
   const candidates = [
-    ["cms.config.ts", path39.join(cwd, "cms.config.ts")],
-    ["drizzle.config.ts", path39.join(cwd, "drizzle.config.ts")],
-    ["CMS.md", path39.join(cwd, "CMS.md")]
+    ["cms.config.ts", path40.join(cwd, "cms.config.ts")],
+    ["drizzle.config.ts", path40.join(cwd, "drizzle.config.ts")],
+    ["CMS.md", path40.join(cwd, "CMS.md")]
   ];
   for (const [label, fullPath] of candidates) {
-    if (fs35.existsSync(fullPath)) {
+    if (fs36.existsSync(fullPath)) {
       configFiles.push(label);
       configPaths.push(fullPath);
     }
   }
-  const biomePath = path39.join(cwd, "biome.json");
+  const biomePath = path40.join(cwd, "biome.json");
   if (isCLICreatedBiome(biomePath)) {
     configFiles.push("biome.json (CLI-created)");
     configPaths.push(biomePath);
@@ -14542,15 +14929,15 @@ function buildUninstallPlan(cwd) {
       count: configFiles.length,
       unit: configFiles.length === 1 ? "file" : "files",
       execute() {
-        for (const p6 of configPaths) {
-          if (fs35.existsSync(p6)) fs35.unlinkSync(p6);
+        for (const p7 of configPaths) {
+          if (fs36.existsSync(p7)) fs36.unlinkSync(p7);
         }
       }
     });
   }
-  const tsconfigPath = path39.join(cwd, "tsconfig.json");
-  if (fs35.existsSync(tsconfigPath)) {
-    const content = fs35.readFileSync(tsconfigPath, "utf-8");
+  const tsconfigPath = path40.join(cwd, "tsconfig.json");
+  if (fs36.existsSync(tsconfigPath)) {
+    const content = fs36.readFileSync(tsconfigPath, "utf-8");
     const aliasMatches = content.match(/"@cms\//g);
     if (aliasMatches && aliasMatches.length > 0) {
       const aliasCount = aliasMatches.length;
@@ -14567,10 +14954,10 @@ function buildUninstallPlan(cwd) {
   }
   const cssFile = findMainCss2(cwd);
   if (cssFile) {
-    const cssContent = fs35.readFileSync(cssFile, "utf-8");
+    const cssContent = fs36.readFileSync(cssFile, "utf-8");
     const sourceLines = cssContent.split("\n").filter((l) => /^@source\s+"[^"]*cms[^"]*";\s*$/.test(l));
     if (sourceLines.length > 0) {
-      const relCss = path39.relative(cwd, cssFile);
+      const relCss = path40.relative(cwd, cssFile);
       steps.push({
         label: `CSS @source lines (${relCss})`,
         items: [`@source lines in ${relCss}`],
@@ -14582,9 +14969,9 @@ function buildUninstallPlan(cwd) {
       });
     }
   }
-  const envPath = path39.join(cwd, ".env.local");
-  if (fs35.existsSync(envPath)) {
-    const envContent = fs35.readFileSync(envPath, "utf-8");
+  const envPath = path40.join(cwd, ".env.local");
+  if (fs36.existsSync(envPath)) {
+    const envContent = fs36.readFileSync(envPath, "utf-8");
     const bsVars = envContent.split("\n").filter((l) => l.trim().match(/^BETTERSTART_\w+=/)).map((l) => l.split("=")[0]);
     if (bsVars.length > 0) {
       steps.push({
@@ -14600,32 +14987,32 @@ function buildUninstallPlan(cwd) {
   }
   return steps;
 }
-var uninstallCommand = new Command5("uninstall").description("Remove all CMS files and undo modifications made by betterstart init").option("-f, --force", "Skip all confirmation prompts", false).option("--cwd <path>", "Project root path").action(async (options) => {
-  const cwd = options.cwd ? path39.resolve(options.cwd) : process.cwd();
-  p5.intro(pc3.bgRed(pc3.white(" BetterStart Uninstall ")));
+var uninstallCommand = new Command6("uninstall").description("Remove all CMS files and undo modifications made by betterstart init").option("-f, --force", "Skip all confirmation prompts", false).option("--cwd <path>", "Project root path").action(async (options) => {
+  const cwd = options.cwd ? path40.resolve(options.cwd) : process.cwd();
+  p6.intro(pc4.bgRed(pc4.white(" BetterStart Uninstall ")));
   const steps = buildUninstallPlan(cwd);
   if (steps.length === 0) {
-    p5.log.success(`${pc3.green("\u2713")} Nothing to remove \u2014 project is already clean.`);
-    p5.outro("Done");
+    p6.log.success(`${pc4.green("\u2713")} Nothing to remove \u2014 project is already clean.`);
+    p6.outro("Done");
     return;
   }
   const planLines = steps.map((step) => {
     const names = step.items.join(" ");
-    const countLabel = pc3.dim(`${step.count} ${step.unit}`);
-    return `${pc3.red("\xD7")} ${names}  ${countLabel}`;
+    const countLabel = pc4.dim(`${step.count} ${step.unit}`);
+    return `${pc4.red("\xD7")} ${names}  ${countLabel}`;
   });
-  p5.note(planLines.join("\n"), "Uninstall plan");
+  p6.note(planLines.join("\n"), "Uninstall plan");
   if (!options.force) {
-    const confirmed = await p5.confirm({
+    const confirmed = await p6.confirm({
       message: "Proceed with uninstall?",
       initialValue: false
     });
-    if (p5.isCancel(confirmed) || !confirmed) {
-      p5.cancel("Uninstall cancelled.");
+    if (p6.isCancel(confirmed) || !confirmed) {
+      p6.cancel("Uninstall cancelled.");
       process.exit(0);
     }
   }
-  const s = p5.spinner();
+  const s = p6.spinner();
   s.start(steps[0].label);
   for (const step of steps) {
     s.message(step.label);
@@ -14633,16 +15020,16 @@ var uninstallCommand = new Command5("uninstall").description("Remove all CMS fil
   }
   const parts = steps.map((step) => `${step.count} ${step.unit}`);
   s.stop(`Removed ${parts.join(", ")}`);
-  p5.note(pc3.dim("Database tables were NOT dropped \u2014 drop them manually if needed."), "Next steps");
-  p5.outro("Uninstall complete");
+  p6.note(pc4.dim("Database tables were NOT dropped \u2014 drop them manually if needed."), "Next steps");
+  p6.outro("Uninstall complete");
 });
 
 // src/commands/update-deps.ts
-import path40 from "path";
+import path41 from "path";
 import * as clack2 from "@clack/prompts";
-import { Command as Command6 } from "commander";
-var updateDepsCommand = new Command6("update-deps").description("Install or update all CMS dependencies").option("--cwd <path>", "Project root path").action(async (options) => {
-  const cwd = options.cwd ? path40.resolve(options.cwd) : process.cwd();
+import { Command as Command7 } from "commander";
+var updateDepsCommand = new Command7("update-deps").description("Install or update all CMS dependencies").option("--cwd <path>", "Project root path").action(async (options) => {
+  const cwd = options.cwd ? path41.resolve(options.cwd) : process.cwd();
   clack2.intro("BetterStart Update Dependencies");
   const pm = detectPackageManager(cwd);
   clack2.log.info(`Package manager: ${pm}`);
@@ -14667,32 +15054,33 @@ var updateDepsCommand = new Command6("update-deps").description("Install or upda
 });
 
 // src/commands/update-styles.ts
-import fs36 from "fs";
-import path41 from "path";
+import fs37 from "fs";
+import path42 from "path";
 import * as clack3 from "@clack/prompts";
-import { Command as Command7 } from "commander";
-var updateStylesCommand = new Command7("update-styles").description("Replace cms-globals.css with the latest version from the CLI").option("--cwd <path>", "Project root path").action(async (options) => {
-  const cwd = options.cwd ? path41.resolve(options.cwd) : process.cwd();
+import { Command as Command8 } from "commander";
+var updateStylesCommand = new Command8("update-styles").description("Replace cms-globals.css with the latest version from the CLI").option("--cwd <path>", "Project root path").action(async (options) => {
+  const cwd = options.cwd ? path42.resolve(options.cwd) : process.cwd();
   clack3.intro("BetterStart Update Styles");
   const config = await resolveConfig(cwd);
   const cmsDir = config.paths?.cms ?? "./cms";
-  const targetPath = path41.join(cwd, cmsDir, "cms-globals.css");
-  if (!fs36.existsSync(targetPath)) {
-    clack3.cancel(`cms-globals.css not found at ${path41.relative(cwd, targetPath)}`);
+  const targetPath = path42.join(cwd, cmsDir, "cms-globals.css");
+  if (!fs37.existsSync(targetPath)) {
+    clack3.cancel(`cms-globals.css not found at ${path42.relative(cwd, targetPath)}`);
     process.exit(1);
   }
-  fs36.writeFileSync(targetPath, cmsGlobalsCssTemplate(), "utf-8");
-  clack3.log.success(`Updated ${path41.relative(cwd, targetPath)}`);
+  fs37.writeFileSync(targetPath, cmsGlobalsCssTemplate(), "utf-8");
+  clack3.log.success(`Updated ${path42.relative(cwd, targetPath)}`);
   clack3.outro("Styles updated");
 });
 
 // src/cli.ts
-var program = new Command8();
+var program = new Command9();
 program.name("betterstart").description("Scaffold a full-featured CMS into any Next.js 16 application").version("0.1.0");
 program.addCommand(initCommand);
 program.addCommand(generateCommand);
 program.addCommand(removeCommand);
 program.addCommand(seedCommand);
+program.addCommand(setupR2Command);
 program.addCommand(uninstallCommand);
 program.addCommand(updateDepsCommand);
 program.addCommand(updateStylesCommand);