betterstart-cli 0.0.30 → 0.0.32

package/dist/cli.js

@@ -21900,6 +21900,155 @@ function openBrowser(url) {
 // adapters/next/init/prompts/plugins.ts
 import { styleText } from "util";
 import * as p11 from "@clack/prompts";
+
+// adapters/next/init/scaffolders/env.ts
+import crypto2 from "crypto";
+
+// adapters/next/init/scaffolders/dev-server.ts
+import fs26 from "fs";
+import path32 from "path";
+var DEFAULT_DEV_PORT = 4242;
+var DEV_PORT_FLAG_PATTERN = /(?:^|\s)(?:--port(?:=|\s+)|-p(?:=|\s+)?)(\d+)(?=\s|$)/;
+var DEV_PORT_ENV_PATTERN = /(?:^|\s)PORT=(\d+)(?=\s|$)/;
+function detectDevPort(cwd) {
+  const pkg = readPackageJson2(cwd);
+  if (!pkg) return DEFAULT_DEV_PORT;
+  return detectDevPortFromScript(pkg.scripts?.dev) ?? DEFAULT_DEV_PORT;
+}
+function detectDevPortFromScript(devScript) {
+  if (typeof devScript !== "string") return void 0;
+  const trimmed = devScript.trim();
+  if (trimmed.length === 0) return void 0;
+  const flagMatch = trimmed.match(DEV_PORT_FLAG_PATTERN);
+  const envMatch = trimmed.match(DEV_PORT_ENV_PATTERN);
+  const rawPort = flagMatch?.[1] ?? envMatch?.[1];
+  if (!rawPort) return void 0;
+  const port = Number.parseInt(rawPort, 10);
+  return isValidPort(port) ? port : void 0;
+}
+function ensureDefaultDevScriptPort(cwd) {
+  const pkgPath = path32.join(cwd, "package.json");
+  if (!fs26.existsSync(pkgPath)) {
+    return { status: "missing-package", port: DEFAULT_DEV_PORT };
+  }
+  const raw = fs26.readFileSync(pkgPath, "utf-8");
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return { status: "missing-package", port: DEFAULT_DEV_PORT };
+  }
+  const devScript = pkg.scripts?.dev;
+  if (typeof devScript !== "string" || devScript.trim().length === 0) {
+    return { status: "missing-script", port: DEFAULT_DEV_PORT };
+  }
+  const explicitPort = detectDevPortFromScript(devScript);
+  if (explicitPort) {
+    return { status: "preserved", port: explicitPort };
+  }
+  if (!isPlainNextDevScript(devScript)) {
+    return { status: "skipped", port: DEFAULT_DEV_PORT };
+  }
+  const normalizedScript = `${normalizeWhitespace(devScript)} --port ${DEFAULT_DEV_PORT}`;
+  pkg.scripts = {
+    ...pkg.scripts,
+    dev: normalizedScript
+  };
+  const newline = raw.includes("\r\n") ? "\r\n" : "\n";
+  const indent = detectIndent(raw);
+  fs26.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, indent)}${newline}`, "utf-8");
+  return { status: "updated", port: DEFAULT_DEV_PORT };
+}
+function readPackageJson2(cwd) {
+  const pkgPath = path32.join(cwd, "package.json");
+  if (!fs26.existsSync(pkgPath)) return void 0;
+  try {
+    return JSON.parse(fs26.readFileSync(pkgPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function isPlainNextDevScript(devScript) {
+  const normalized = normalizeWhitespace(devScript);
+  return normalized === "next dev" || normalized === "next dev --turbopack" || normalized === "next dev --turbo";
+}
+function normalizeWhitespace(value) {
+  return value.trim().replace(/\s+/g, " ");
+}
+function detectIndent(raw) {
+  const indentMatch = raw.match(/^[ \t]+(?=")/m);
+  return indentMatch?.[0] ?? 2;
+}
+function isValidPort(port) {
+  return Number.isInteger(port) && port > 0 && port <= 65535;
+}
+
+// adapters/next/init/scaffolders/env.ts
+var LEGACY_DEFAULT_AUTH_URL = "http://localhost:3000";
+function getCoreEnvSections(databaseUrl, devPort, namespace) {
+  const authSecret = crypto2.randomBytes(32).toString("base64");
+  return [
+    {
+      header: "Database (PostgreSQL)",
+      vars: [{ key: "DATABASE_URL", value: databaseUrl ?? "postgresql://..." }]
+    },
+    {
+      header: "Authentication",
+      vars: [
+        { key: "BETTERSTART_AUTH_SECRET", value: authSecret },
+        { key: "BETTERSTART_AUTH_URL", value: `http://localhost:${devPort}` },
+        { key: "BETTERSTART_AUTH_BASE_PATH", value: `/api/${namespace}/auth` }
+      ]
+    }
+  ];
+}
+function shouldOverwriteAuthUrl(cwd, devPort) {
+  const existingAuthUrl = readEnvVar(cwd, "BETTERSTART_AUTH_URL");
+  if (!existingAuthUrl) return false;
+  return existingAuthUrl === LEGACY_DEFAULT_AUTH_URL && existingAuthUrl !== `http://localhost:${devPort}`;
+}
+function persistDatabaseUrl(cwd, databaseUrl) {
+  appendEnvVars(
+    cwd,
+    [
+      {
+        header: "Database (PostgreSQL)",
+        vars: [{ key: "DATABASE_URL", value: databaseUrl }]
+      }
+    ],
+    /* @__PURE__ */ new Set(["DATABASE_URL"])
+  );
+}
+function persistBlobReadWriteToken(cwd, token) {
+  appendEnvVars(
+    cwd,
+    [
+      {
+        header: "Storage (Vercel Blob)",
+        vars: [{ key: "BLOB_READ_WRITE_TOKEN", value: token }]
+      }
+    ],
+    /* @__PURE__ */ new Set(["BLOB_READ_WRITE_TOKEN"])
+  );
+}
+function scaffoldEnv(cwd, options) {
+  const devPort = detectDevPort(cwd);
+  const sections = getCoreEnvSections(options.databaseUrl, devPort, options.namespace ?? "admin");
+  const authBasePath = `/api/${options.namespace ?? "admin"}/auth`;
+  const overwrite = /* @__PURE__ */ new Set();
+  if (options.databaseUrl) {
+    overwrite.add("DATABASE_URL");
+  }
+  if (shouldOverwriteAuthUrl(cwd, devPort)) {
+    overwrite.add("BETTERSTART_AUTH_URL");
+  }
+  if (readEnvVar(cwd, "BETTERSTART_AUTH_BASE_PATH") !== authBasePath) {
+    overwrite.add("BETTERSTART_AUTH_BASE_PATH");
+  }
+  return appendEnvVars(cwd, sections, overwrite);
+}
+
+// adapters/next/init/prompts/plugins.ts
 async function promptPlugins(cwd, options = {}) {
   const sections = [];
   const overwriteKeys = /* @__PURE__ */ new Set();
@@ -21938,6 +22087,8 @@ async function promptPlugins(cwd, options = {}) {
     const existingToken = readEnvVar(cwd, "BLOB_READ_WRITE_TOKEN")?.trim();
     const flow = !existingToken && options.provisionVercelBlob ? await options.provisionVercelBlob() : void 0;
     if (flow?.ok && flow.token) {
+      persistBlobReadWriteToken(cwd, flow.token);
+      p11.log.success("Saved BLOB_READ_WRITE_TOKEN to .env.local");
       sections.push({
         header: "Storage (Vercel Blob)",
         vars: [{ key: "BLOB_READ_WRITE_TOKEN", value: flow.token }]
@@ -22045,53 +22196,53 @@ async function promptProject(defaultName) {
 }
 
 // adapters/next/init/scaffolders/api-routes.ts
-import path33 from "path";
+import path34 from "path";
 
 // core-engine/utils/fs.ts
-import fs26 from "fs";
-import path32 from "path";
+import fs27 from "fs";
+import path33 from "path";
 import fse from "fs-extra";
 function ensureDir(dirPath) {
   fse.ensureDirSync(dirPath);
 }
 function safeWriteFile(filePath, content, force = false) {
-  if (!force && fs26.existsSync(filePath)) {
+  if (!force && fs27.existsSync(filePath)) {
     return false;
   }
-  ensureDir(path32.dirname(filePath));
-  fs26.writeFileSync(filePath, content, "utf-8");
+  ensureDir(path33.dirname(filePath));
+  fs27.writeFileSync(filePath, content, "utf-8");
   return true;
 }
 
 // adapters/next/init/scaffolders/api-routes.ts
 function scaffoldApiRoutes({ cwd, config }) {
   const created = [];
-  const apiDir = path33.resolve(cwd, config.paths.api);
+  const apiDir = path34.resolve(cwd, config.paths.api);
   const namespace = config.frameworkConfig.next.namespace;
   function write(relPath, content) {
-    const fullPath = path33.join(apiDir, relPath);
-    ensureDir(path33.dirname(fullPath));
+    const fullPath = path34.join(apiDir, relPath);
+    ensureDir(path34.dirname(fullPath));
     const versionedContent = applyNextCacheApiForVersion(content, config.nextMajorVersion);
     if (safeWriteFile(fullPath, applyAdminNamespaceToContent(versionedContent, namespace))) {
-      created.push(path33.join(config.paths.api, relPath));
+      created.push(path34.join(config.paths.api, relPath));
     }
   }
-  write(path33.join("auth", "[...all]", "route.ts"), readTemplate("api/auth-route.ts"));
-  write(path33.join("upload", "route.ts"), readTemplate("api/upload-route.ts"));
+  write(path34.join("auth", "[...all]", "route.ts"), readTemplate("api/auth-route.ts"));
+  write(path34.join("upload", "route.ts"), readTemplate("api/upload-route.ts"));
   return created;
 }
 
 // adapters/next/init/scaffolders/auth.ts
-import path34 from "path";
+import path35 from "path";
 function scaffoldAuth({ cwd, config }) {
   const created = [];
-  const authDir = path34.resolve(cwd, config.paths.admin, "lib", "actions", "auth");
+  const authDir = path35.resolve(cwd, config.paths.admin, "lib", "actions", "auth");
   const namespace = config.frameworkConfig.next.namespace;
   function write(filename, content) {
     const outputFile = applyAdminNamespaceToPath(filename, namespace);
-    const fullPath = path34.join(authDir, outputFile);
+    const fullPath = path35.join(authDir, outputFile);
     if (safeWriteFile(fullPath, applyAdminNamespaceToContent(content, namespace))) {
-      created.push(path34.join(config.paths.admin, "lib", "actions", "auth", outputFile));
+      created.push(path35.join(config.paths.admin, "lib", "actions", "auth", outputFile));
     }
   }
   write("server.ts", readTemplate("lib/actions/auth/auth.ts"));
@@ -22101,7 +22252,7 @@ function scaffoldAuth({ cwd, config }) {
 }
 
 // adapters/next/init/scaffolders/base.ts
-import path35 from "path";
+import path36 from "path";
 function scaffoldBase({
   cwd,
   config,
@@ -22111,58 +22262,58 @@ function scaffoldBase({
   const adminDirs = [
     config.paths.admin,
     config.paths.schemas,
-    path35.join(config.paths.admin, "lib"),
-    path35.join(config.paths.admin, "lib", "db"),
-    path35.join(config.paths.admin, "lib", "db", "core"),
-    path35.join(config.paths.admin, "lib", "db", "migrations"),
-    path35.join(config.paths.admin, "lib", "actions"),
-    path35.join(config.paths.admin, "lib", "actions", "auth"),
-    path35.join(config.paths.admin, "lib", "actions", "email"),
-    path35.join(config.paths.admin, "lib", "actions", "forms"),
-    path35.join(config.paths.admin, "lib", "actions", "media"),
-    path35.join(config.paths.admin, "lib", "actions", "profile"),
-    path35.join(config.paths.admin, "lib", "actions", "storage"),
-    path35.join(config.paths.admin, "lib", "actions", "upload"),
-    path35.join(config.paths.admin, "lib", "actions", "users"),
-    path35.join(config.paths.admin, "hooks"),
-    path35.join(config.paths.admin, "components", "ui"),
-    path35.join(config.paths.admin, "components", "custom"),
-    path35.join(config.paths.admin, "components", "layouts"),
-    path35.join(config.paths.admin, "components", "shared"),
-    path35.join(config.paths.admin, "components", "shared", "data-table"),
-    path35.join(config.paths.admin, "components", "shared", "media"),
-    path35.join(config.paths.admin, "data"),
-    path35.join(config.paths.admin, "data", "navigation"),
-    path35.join(config.paths.admin, "types"),
-    path35.join(config.paths.admin, "utils"),
-    path35.join(config.paths.admin, "utils", "core")
+    path36.join(config.paths.admin, "lib"),
+    path36.join(config.paths.admin, "lib", "db"),
+    path36.join(config.paths.admin, "lib", "db", "core"),
+    path36.join(config.paths.admin, "lib", "db", "migrations"),
+    path36.join(config.paths.admin, "lib", "actions"),
+    path36.join(config.paths.admin, "lib", "actions", "auth"),
+    path36.join(config.paths.admin, "lib", "actions", "email"),
+    path36.join(config.paths.admin, "lib", "actions", "forms"),
+    path36.join(config.paths.admin, "lib", "actions", "media"),
+    path36.join(config.paths.admin, "lib", "actions", "profile"),
+    path36.join(config.paths.admin, "lib", "actions", "storage"),
+    path36.join(config.paths.admin, "lib", "actions", "upload"),
+    path36.join(config.paths.admin, "lib", "actions", "users"),
+    path36.join(config.paths.admin, "hooks"),
+    path36.join(config.paths.admin, "components", "ui"),
+    path36.join(config.paths.admin, "components", "custom"),
+    path36.join(config.paths.admin, "components", "layouts"),
+    path36.join(config.paths.admin, "components", "shared"),
+    path36.join(config.paths.admin, "components", "shared", "data-table"),
+    path36.join(config.paths.admin, "components", "shared", "media"),
+    path36.join(config.paths.admin, "data"),
+    path36.join(config.paths.admin, "data", "navigation"),
+    path36.join(config.paths.admin, "types"),
+    path36.join(config.paths.admin, "utils"),
+    path36.join(config.paths.admin, "utils", "core")
   ];
   if (includeEmailTemplatesDir) {
-    adminDirs.push(path35.join(config.paths.admin, "components", "email-templates"));
+    adminDirs.push(path36.join(config.paths.admin, "components", "email-templates"));
   }
   for (const dir of adminDirs) {
-    ensureDir(path35.resolve(cwd, dir));
+    ensureDir(path36.resolve(cwd, dir));
   }
-  const adminDir = path35.dirname(config.paths.pages);
+  const adminDir = path36.dirname(config.paths.pages);
   const appDirs = [
     config.paths.pages,
     config.paths.login,
     config.paths.api,
-    path35.join(adminDir, "(account)", "profile")
+    path36.join(adminDir, "(account)", "profile")
   ];
   for (const dir of appDirs) {
-    ensureDir(path35.resolve(cwd, dir));
+    ensureDir(path36.resolve(cwd, dir));
   }
   const configContent = serializeConfig(config);
-  if (safeWriteFile(path35.resolve(cwd, "admin.config.ts"), configContent)) {
+  if (safeWriteFile(path36.resolve(cwd, "admin.config.ts"), configContent)) {
     created.push("admin.config.ts");
   }
   return created;
 }
 
 // adapters/next/init/scaffolders/biome.ts
-import fs27 from "fs";
-import path36 from "path";
+import fs28 from "fs";
+import path37 from "path";
 function scaffoldBiome(cwd, linter) {
   if (linter.type !== "none") {
     return {
@@ -22170,8 +22321,8 @@ function scaffoldBiome(cwd, linter) {
       skippedReason: `${linter.type} already configured (${linter.configFile})`
     };
   }
-  const configPath = path36.join(cwd, "biome.json");
-  if (fs27.existsSync(configPath)) {
+  const configPath = path37.join(cwd, "biome.json");
+  if (fs28.existsSync(configPath)) {
     return { installed: false, skippedReason: "biome.json already exists" };
   }
   const config = {
@@ -22234,13 +22385,13 @@ function scaffoldBiome(cwd, linter) {
       ]
     }
   };
-  fs27.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+  fs28.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `, "utf-8");
   return { installed: true, skippedReason: null };
 }
 
 // adapters/next/init/scaffolders/components.ts
-import path37 from "path";
+import path38 from "path";
 
 // adapters/next/init/templates/app/admin.ts
 function adminDataTemplate(projectName, namespaceValue = DEFAULT_ADMIN_NAMESPACE) {
@@ -22252,17 +22403,17 @@ function adminDataTemplate(projectName, namespaceValue = DEFAULT_ADMIN_NAMESPACE
 }
 
 // adapters/next/init/scaffolders/components.ts
-import fs28 from "fs-extra";
+import fs29 from "fs-extra";
 function scaffoldComponents({ cwd, config }) {
-  const admin = path37.resolve(cwd, config.paths.admin);
+  const admin = path38.resolve(cwd, config.paths.admin);
   const created = [];
   const namespace = config.frameworkConfig.next.namespace;
   function write(relPath, content) {
     const namespacedRelPath = applyAdminNamespaceToPath(relPath, namespace);
-    const fullPath = path37.join(admin, namespacedRelPath);
+    const fullPath = path38.join(admin, namespacedRelPath);
     const versionedContent = applyNextCacheApiForVersion(content, config.nextMajorVersion);
     if (safeWriteFile(fullPath, applyAdminNamespaceToContent(versionedContent, namespace))) {
-      created.push(path37.join(config.paths.admin, namespacedRelPath));
+      created.push(path38.join(config.paths.admin, namespacedRelPath));
     }
   }
   write("admin-globals.css", readTemplate("admin-globals.css"));
@@ -22695,49 +22846,49 @@ function copyCustomTemplates(cwd, config) {
 }
 function copyStaticComponentTemplates(cwd, config, sourceDirectory, targetDirectory) {
   const created = [];
-  const destDir = path37.resolve(cwd, config.paths.admin, "components", targetDirectory);
+  const destDir = path38.resolve(cwd, config.paths.admin, "components", targetDirectory);
   const srcDir = resolveCliAssetPath("shared-assets", "react-admin", sourceDirectory);
-  if (!fs28.existsSync(srcDir)) {
+  if (!fs29.existsSync(srcDir)) {
     return created;
   }
-  fs28.ensureDirSync(destDir);
+  fs29.ensureDirSync(destDir);
   if (sourceDirectory === "custom") {
     copyStaticComponentTemplatesRecursive(
       srcDir,
       destDir,
       "",
-      path37.join(config.paths.admin, "components", targetDirectory),
+      path38.join(config.paths.admin, "components", targetDirectory),
       config.frameworkConfig.next.namespace,
       created
     );
     return created;
   }
-  const files = fs28.readdirSync(srcDir, { withFileTypes: true }).filter(
+  const files = fs29.readdirSync(srcDir, { withFileTypes: true }).filter(
     (entry) => entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))
   ).map((entry) => entry.name);
   for (const file of files) {
     const namespacedFile = applyAdminNamespaceToPath(file, config.frameworkConfig.next.namespace);
-    const destPath = path37.join(destDir, namespacedFile);
-    if (!fs28.existsSync(destPath)) {
-      const content = fs28.readFileSync(path37.join(srcDir, file), "utf-8");
-      fs28.writeFileSync(
+    const destPath = path38.join(destDir, namespacedFile);
+    if (!fs29.existsSync(destPath)) {
+      const content = fs29.readFileSync(path38.join(srcDir, file), "utf-8");
+      fs29.writeFileSync(
         destPath,
         applyAdminNamespaceToContent(content, config.frameworkConfig.next.namespace),
         "utf-8"
       );
-      created.push(path37.join(config.paths.admin, "components", targetDirectory, namespacedFile));
+      created.push(path38.join(config.paths.admin, "components", targetDirectory, namespacedFile));
     }
   }
   return created;
 }
 function copyStaticComponentTemplatesRecursive(srcDir, destDir, relBase, createdPrefix, namespace, created) {
-  const entries = fs28.readdirSync(srcDir, { withFileTypes: true });
+  const entries = fs29.readdirSync(srcDir, { withFileTypes: true });
   for (const entry of entries) {
-    const rel = path37.join(relBase, entry.name);
-    const srcPath = path37.join(srcDir, entry.name);
-    const destPath = path37.join(destDir, entry.name);
+    const rel = path38.join(relBase, entry.name);
+    const srcPath = path38.join(srcDir, entry.name);
+    const destPath = path38.join(destDir, entry.name);
     if (entry.isDirectory()) {
-      const namespacedDestPath2 = path37.join(
+      const namespacedDestPath2 = path38.join(
         destDir,
         applyAdminNamespaceToPath(entry.name, namespace)
       );
@@ -22755,37 +22906,37 @@ function copyStaticComponentTemplatesRecursive(srcDir, destDir, relBase, created
       continue;
     }
     const namespacedRel = applyAdminNamespaceToPath(rel, namespace);
-    const namespacedDestPath = path37.join(
-      path37.dirname(destPath),
+    const namespacedDestPath = path38.join(
+      path38.dirname(destPath),
       applyAdminNamespaceToPath(entry.name, namespace)
     );
-    if (!fs28.existsSync(namespacedDestPath)) {
-      fs28.ensureDirSync(path37.dirname(namespacedDestPath));
-      const content = fs28.readFileSync(srcPath, "utf-8");
-      fs28.writeFileSync(
+    if (!fs29.existsSync(namespacedDestPath)) {
+      fs29.ensureDirSync(path38.dirname(namespacedDestPath));
+      const content = fs29.readFileSync(srcPath, "utf-8");
+      fs29.writeFileSync(
         namespacedDestPath,
         applyAdminNamespaceToContent(content, namespace),
         "utf-8"
       );
-      created.push(path37.join(createdPrefix, namespacedRel));
+      created.push(path38.join(createdPrefix, namespacedRel));
     }
   }
 }
 function copySchemaMetaschema(cwd, config) {
   const created = [];
   const srcPath = resolveCliAssetPath("shared-assets", "react-admin", "schema.json");
-  const destPath = path37.resolve(cwd, config.paths.schemas, "schema.json");
-  if (fs28.existsSync(srcPath) && !fs28.existsSync(destPath)) {
-    fs28.ensureDirSync(path37.dirname(destPath));
-    fs28.copyFileSync(srcPath, destPath);
-    created.push(path37.join(config.paths.schemas, "schema.json"));
+  const destPath = path38.resolve(cwd, config.paths.schemas, "schema.json");
+  if (fs29.existsSync(srcPath) && !fs29.existsSync(destPath)) {
+    fs29.ensureDirSync(path38.dirname(destPath));
+    fs29.copyFileSync(srcPath, destPath);
+    created.push(path38.join(config.paths.schemas, "schema.json"));
   }
   return created;
 }
 
 // adapters/next/init/scaffolders/core-schemas.ts
-import fs29 from "fs";
-import path38 from "path";
+import fs30 from "fs";
+import path39 from "path";
 
 // adapters/next/init/templates/core/default-settings.ts
 function defaultSettingsSchema() {
@@ -22865,9 +23016,9 @@ function scaffoldCoreSchemas({
   };
   const schemaContent = defaultSettingsSchema();
   const schemaName = "settings";
-  const schemaPath = path38.join(cwd, config.paths.schemas, `${schemaName}.json`);
-  fs29.mkdirSync(path38.dirname(schemaPath), { recursive: true });
-  fs29.writeFileSync(schemaPath, schemaContent, "utf-8");
+  const schemaPath = path39.join(cwd, config.paths.schemas, `${schemaName}.json`);
+  fs30.mkdirSync(path39.dirname(schemaPath), { recursive: true });
+  fs30.writeFileSync(schemaPath, schemaContent, "utf-8");
   result.schemas.push(`${schemaName}.json`);
   ensureSnapshotGitFiles(cwd);
   try {
@@ -22912,21 +23063,21 @@ function scaffoldCoreSchemas({
 }
 
 // adapters/next/init/scaffolders/database.ts
-import path39 from "path";
+import path40 from "path";
 function scaffoldDatabase({ cwd, config }) {
   const created = [];
-  const dbDir = path39.resolve(cwd, config.paths.admin, "lib", "db");
+  const dbDir = path40.resolve(cwd, config.paths.admin, "lib", "db");
   const namespace = config.frameworkConfig.next.namespace;
   function write(filename, content) {
-    const fullPath = path39.join(dbDir, filename);
+    const fullPath = path40.join(dbDir, filename);
     if (safeWriteFile(fullPath, applyAdminNamespaceToContent(content, namespace))) {
-      created.push(path39.join(config.paths.admin, "lib", "db", filename));
+      created.push(path40.join(config.paths.admin, "lib", "db", filename));
     }
   }
   write("client.ts", readTemplate("lib/db/client.ts"));
   write("core/schema.ts", readTemplate("lib/db/core/schema.ts"));
   write("schema.ts", readTemplate("lib/db/schema.ts"));
-  const drizzleConfigPath = path39.resolve(cwd, "drizzle.config.ts");
+  const drizzleConfigPath = path40.resolve(cwd, "drizzle.config.ts");
   if (safeWriteFile(
     drizzleConfigPath,
     applyAdminNamespaceToContent(readTemplate("drizzle.config.ts"), namespace)
@@ -22936,139 +23087,6 @@ function scaffoldDatabase({ cwd, config }) {
   return created;
 }
 
-// adapters/next/init/scaffolders/dev-server.ts
-import fs30 from "fs";
-import path40 from "path";
-var DEFAULT_DEV_PORT = 4242;
-var DEV_PORT_FLAG_PATTERN = /(?:^|\s)(?:--port(?:=|\s+)|-p(?:=|\s+)?)(\d+)(?=\s|$)/;
-var DEV_PORT_ENV_PATTERN = /(?:^|\s)PORT=(\d+)(?=\s|$)/;
-function detectDevPort(cwd) {
-  const pkg = readPackageJson2(cwd);
-  if (!pkg) return DEFAULT_DEV_PORT;
-  return detectDevPortFromScript(pkg.scripts?.dev) ?? DEFAULT_DEV_PORT;
-}
-function detectDevPortFromScript(devScript) {
-  if (typeof devScript !== "string") return void 0;
-  const trimmed = devScript.trim();
-  if (trimmed.length === 0) return void 0;
-  const flagMatch = trimmed.match(DEV_PORT_FLAG_PATTERN);
-  const envMatch = trimmed.match(DEV_PORT_ENV_PATTERN);
-  const rawPort = flagMatch?.[1] ?? envMatch?.[1];
-  if (!rawPort) return void 0;
-  const port = Number.parseInt(rawPort, 10);
-  return isValidPort(port) ? port : void 0;
-}
-function ensureDefaultDevScriptPort(cwd) {
-  const pkgPath = path40.join(cwd, "package.json");
-  if (!fs30.existsSync(pkgPath)) {
-    return { status: "missing-package", port: DEFAULT_DEV_PORT };
-  }
-  const raw = fs30.readFileSync(pkgPath, "utf-8");
-  let pkg;
-  try {
-    pkg = JSON.parse(raw);
-  } catch {
-    return { status: "missing-package", port: DEFAULT_DEV_PORT };
-  }
-  const devScript = pkg.scripts?.dev;
-  if (typeof devScript !== "string" || devScript.trim().length === 0) {
-    return { status: "missing-script", port: DEFAULT_DEV_PORT };
-  }
-  const explicitPort = detectDevPortFromScript(devScript);
-  if (explicitPort) {
-    return { status: "preserved", port: explicitPort };
-  }
-  if (!isPlainNextDevScript(devScript)) {
-    return { status: "skipped", port: DEFAULT_DEV_PORT };
-  }
-  const normalizedScript = `${normalizeWhitespace(devScript)} --port ${DEFAULT_DEV_PORT}`;
-  pkg.scripts = {
-    ...pkg.scripts,
-    dev: normalizedScript
-  };
-  const newline = raw.includes("\r\n") ? "\r\n" : "\n";
-  const indent = detectIndent(raw);
-  fs30.writeFileSync(pkgPath, `${JSON.stringify(pkg, null, indent)}${newline}`, "utf-8");
-  return { status: "updated", port: DEFAULT_DEV_PORT };
-}
-function readPackageJson2(cwd) {
-  const pkgPath = path40.join(cwd, "package.json");
-  if (!fs30.existsSync(pkgPath)) return void 0;
-  try {
-    return JSON.parse(fs30.readFileSync(pkgPath, "utf-8"));
-  } catch {
-    return void 0;
-  }
-}
-function isPlainNextDevScript(devScript) {
-  const normalized = normalizeWhitespace(devScript);
-  return normalized === "next dev" || normalized === "next dev --turbopack" || normalized === "next dev --turbo";
-}
-function normalizeWhitespace(value) {
-  return value.trim().replace(/\s+/g, " ");
-}
-function detectIndent(raw) {
-  const indentMatch = raw.match(/^[ \t]+(?=")/m);
-  return indentMatch?.[0] ?? 2;
-}
-function isValidPort(port) {
-  return Number.isInteger(port) && port > 0 && port <= 65535;
-}
-
-// adapters/next/init/scaffolders/env.ts
-import crypto2 from "crypto";
-var LEGACY_DEFAULT_AUTH_URL = "http://localhost:3000";
-function getCoreEnvSections(databaseUrl, devPort, namespace) {
-  const authSecret = crypto2.randomBytes(32).toString("base64");
-  return [
-    {
-      header: "Database (PostgreSQL)",
-      vars: [{ key: "DATABASE_URL", value: databaseUrl ?? "postgresql://..." }]
-    },
-    {
-      header: "Authentication",
-      vars: [
-        { key: "BETTERSTART_AUTH_SECRET", value: authSecret },
-        { key: "BETTERSTART_AUTH_URL", value: `http://localhost:${devPort}` },
-        { key: "BETTERSTART_AUTH_BASE_PATH", value: `/api/${namespace}/auth` }
-      ]
-    }
-  ];
-}
-function shouldOverwriteAuthUrl(cwd, devPort) {
-  const existingAuthUrl = readEnvVar(cwd, "BETTERSTART_AUTH_URL");
-  if (!existingAuthUrl) return false;
-  return existingAuthUrl === LEGACY_DEFAULT_AUTH_URL && existingAuthUrl !== `http://localhost:${devPort}`;
-}
-function persistDatabaseUrl(cwd, databaseUrl) {
-  appendEnvVars(
-    cwd,
-    [
-      {
-        header: "Database (PostgreSQL)",
-        vars: [{ key: "DATABASE_URL", value: databaseUrl }]
-      }
-    ],
-    /* @__PURE__ */ new Set(["DATABASE_URL"])
-  );
-}
-function scaffoldEnv(cwd, options) {
-  const devPort = detectDevPort(cwd);
-  const sections = getCoreEnvSections(options.databaseUrl, devPort, options.namespace ?? "admin");
-  const authBasePath = `/api/${options.namespace ?? "admin"}/auth`;
-  const overwrite = /* @__PURE__ */ new Set();
-  if (options.databaseUrl) {
-    overwrite.add("DATABASE_URL");
-  }
-  if (shouldOverwriteAuthUrl(cwd, devPort)) {
-    overwrite.add("BETTERSTART_AUTH_URL");
-  }
-  if (readEnvVar(cwd, "BETTERSTART_AUTH_BASE_PATH") !== authBasePath) {
-    overwrite.add("BETTERSTART_AUTH_BASE_PATH");
-  }
-  return appendEnvVars(cwd, sections, overwrite);
-}
-
 // adapters/next/init/scaffolders/layout.ts
 import path41 from "path";
 function scaffoldLayout({ cwd, config }) {
@@ -24692,15 +24710,7 @@ async function provisionNeonInteractive(runner, cwd, options) {
   if (!add.success) {
     return { failure: add.timedOut ? "timeout" : "provision-failed" };
   }
-  const pullSpinner = spinner2();
-  pullSpinner.start("Retrieving DATABASE_URL from Vercel");
-  const databaseUrl = await pullVercelEnvValue(runner, cwd, readDbUrlFromDotenv, options.env);
-  if (!databaseUrl) {
-    pullSpinner.stop(`${pc5.yellow("\u25B2")} No DATABASE_URL came back from Vercel`);
-    return {};
-  }
-  pullSpinner.clear();
-  return { databaseUrl };
+  return {};
 }
 async function provisionNeon(runner, cwd, options) {
   const provisionSpinner = spinner2();
@@ -24723,20 +24733,6 @@ ${add.stderr}`.trim();
   provisionSpinner.clear();
   return readNeonProvisionInfo(add.stdout);
 }
-async function connectNeonResourceToProject(runner, cwd, resourceName, env) {
-  const connect = await runVercel(
-    runner,
-    ["integration", "resource", "connect", resourceName, "--yes", "--format", "json"],
-    { cwd, mode: "capture", timeoutMs: PROVISION_TIMEOUT_MS2, env }
-  );
-  if (connect.success) return { ok: true };
-  const detail = `${connect.stdout}
-${connect.stderr}`.trim();
-  if (/already connected/i.test(detail)) {
-    return { ok: true, alreadyConnected: true, detail: detail || void 0 };
-  }
-  return { ok: false, detail: detail || void 0 };
-}
 function readDbUrlFromDotenv(filePath) {
   const vars = parseDotenvFile(filePath);
   const isPg = (v) => !!v && (v.startsWith("postgres://") || v.startsWith("postgresql://"));
@@ -24747,14 +24743,13 @@ function readDbUrlFromDotenv(filePath) {
 function readNeonProvisionInfo(stdout) {
   const meta = parseVercelJson(stdout);
   if (!meta) return {};
-  return {
-    resourceName: meta.resource?.name,
-    dashboardUrl: meta.dashboardUrl,
-    resourceUrl: meta.ssoUrl?.resource
-  };
+  const info = {};
+  if (meta.dashboardUrl) info.dashboardUrl = meta.dashboardUrl;
+  if (meta.ssoUrl?.resource) info.resourceUrl = meta.ssoUrl.resource;
+  return info;
 }
 function neonAddArgs(options) {
-  const addArgs = ["integration", "add", "neon", "--no-connect", "--format", "json"];
+  const addArgs = ["integration", "add", "neon", "--format", "json"];
   if (options.plan) addArgs.push("--plan", options.plan);
   return addArgs;
 }
@@ -24785,20 +24780,10 @@ async function runVercelNeonFlow(options) {
       if (neon.detail) p16.log.message(pc6.dim(neon.detail));
       return { ok: false };
     }
-    let databaseUrl = neon.databaseUrl;
-    if (neon.resourceName) {
-      const pulledDatabaseUrl = await connectNeonAndPullDatabaseUrl(
-        runner,
-        options.cwd,
-        neon.resourceName,
-        env
-      );
-      databaseUrl = pulledDatabaseUrl ?? databaseUrl;
-    }
+    const databaseUrl = await pullNeonDatabaseUrl(runner, options.cwd, env);
     return {
       ok: true,
       databaseUrl,
-      neonResourceName: neon.resourceName,
       dashboardUrl: neon.dashboardUrl,
       resourceUrl: neon.resourceUrl
     };
@@ -24860,24 +24845,6 @@ async function runVercelDeployFlow(options) {
       return { ok: false };
     }
     await ensureLinkedProject(runner, options.cwd, options.projectName, env);
-    if (options.neonResourceName) {
-      const neonSpinner = spinner2();
-      neonSpinner.start("Connecting Neon database to Vercel project");
-      const connect = await connectNeonResourceToProject(
-        runner,
-        options.cwd,
-        options.neonResourceName,
-        env
-      );
-      if (connect.ok) {
-        neonSpinner.stop(
-          connect.alreadyConnected ? "Neon database already connected to Vercel project" : "Connected Neon database to Vercel project"
-        );
-      } else {
-        neonSpinner.stop(`${pc6.yellow("\u25B2")} Could not connect Neon database to Vercel project`);
-        if (connect.detail) p16.log.message(pc6.dim(connect.detail));
-      }
-    }
     const envSpinner = spinner2();
     envSpinner.start("Syncing environment variables to Vercel");
     const sync = await syncVercelProductionEnv(runner, options.cwd, env);
@@ -24940,16 +24907,9 @@ async function ensureLinkedProject(runner, cwd, projectName, env) {
     project2.linked ? `Linked Vercel project ${pc6.cyan(project2.name)}` : `Using Vercel project ${pc6.cyan(project2.name)}`
   );
 }
-async function connectNeonAndPullDatabaseUrl(runner, cwd, resourceName, env) {
+async function pullNeonDatabaseUrl(runner, cwd, env) {
   const neonSpinner = spinner2();
-  neonSpinner.start("Connecting Neon database to Vercel project");
-  const connect = await connectNeonResourceToProject(runner, cwd, resourceName, env);
-  if (!connect.ok) {
-    neonSpinner.stop(`${pc6.yellow("\u25B2")} Could not connect Neon database to Vercel project`);
-    if (connect.detail) p16.log.message(pc6.dim(connect.detail));
-    return void 0;
-  }
-  neonSpinner.message("Retrieving DATABASE_URL from Vercel");
+  neonSpinner.start("Retrieving DATABASE_URL from Vercel");
   const databaseUrl = await pullVercelEnvValue(runner, cwd, readDbUrlFromDotenv, env);
   if (!databaseUrl) {
     neonSpinner.stop(`${pc6.yellow("\u25B2")} No DATABASE_URL came back from Vercel`);
@@ -25581,7 +25541,6 @@ async function runInitCommand(name, options) {
     isFreshProject = true;
   }
   let databaseUrl;
-  let neonResourceName;
   const existingDbUrl = readExistingDbUrl(cwd);
   if (options.yes) {
     if (options.databaseUrl) {
@@ -25603,12 +25562,10 @@ async function runInitCommand(name, options) {
         env: process.env
       });
       if (flow.ok && flow.databaseUrl) {
-        neonResourceName = flow.neonResourceName;
         databaseUrl = flow.databaseUrl;
         persistDatabaseUrl(cwd, databaseUrl);
         p17.log.success(`Saved DATABASE_URL to ${pc7.cyan(".env.local")}`);
       } else if (flow.ok) {
-        neonResourceName = flow.neonResourceName;
         p17.log.warn("Created a Neon database, but DATABASE_URL could not be retrieved from Vercel.");
         const resourceUrl = flow.resourceUrl ?? flow.dashboardUrl;
         if (resourceUrl) {
@@ -25639,12 +25596,10 @@ async function runInitCommand(name, options) {
         env: process.env
       });
       if (flow.ok && flow.databaseUrl) {
-        neonResourceName = flow.neonResourceName;
         databaseUrl = flow.databaseUrl;
         persistDatabaseUrl(cwd, databaseUrl);
         p17.log.success(`Saved DATABASE_URL to ${pc7.cyan(".env.local")}`);
       } else if (flow.ok) {
-        neonResourceName = flow.neonResourceName;
         openBrowserVercelNeonResource(flow.resourceUrl ?? flow.dashboardUrl);
         databaseUrl = await promptConnectionString();
         persistDatabaseUrl(cwd, databaseUrl);
@@ -25690,6 +25645,8 @@ async function runInitCommand(name, options) {
         env: process.env
       });
       if (flow.ok && flow.token) {
+        persistBlobReadWriteToken(cwd, flow.token);
+        p17.log.success(`Saved BLOB_READ_WRITE_TOKEN to ${pc7.cyan(".env.local")}`);
         collectedIntegrationConfig.sections.push({
           header: "Storage (Vercel Blob)",
           vars: [{ key: "BLOB_READ_WRITE_TOKEN", value: flow.token }]
@@ -25891,8 +25848,9 @@ async function runInitCommand(name, options) {
       config: resolvedPluginInstallResult.config,
       pm,
       integrationIds: pluginSelection.integrations,
-      // Secrets were already collected up front and written to .env.local,
-      // so the install runs without prompting (rule: no mid-scaffold input).
+      // Secrets were already collected up front and persisted/written to
+      // .env.local, so the install runs without prompting (rule: no
+      // mid-scaffold input).
       interactive: false,
       includeBiome: project2.linter.type === "none"
     });
@@ -26172,13 +26130,12 @@ Run manually: ${pc7.cyan(betterstartExecCommand(pm, "seed"))}`,
         initialValue: linkedVercelProject
       });
       if (!p17.isCancel(deployNow) && deployNow) {
-        await runVercelDeployFlow({ cwd, projectName, neonResourceName, env: process.env });
+        await runVercelDeployFlow({ cwd, projectName, env: process.env });
       }
     } else if (linkedVercelProject && process.env.VERCEL_TOKEN) {
       const deployFlow = await runVercelDeployFlow({
         cwd,
         projectName,
-        neonResourceName,
         env: process.env
       });
       if (!deployFlow.ok) {