@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/providers/better-t-stack/helpers/database-providers/turso-setup.js

@@ -0,0 +1,250 @@
+import os from "node:os";
+import path from "node:path";
+import { re } from "@reliverse/relico";
+import { relinka } from "@reliverse/relinka";
+import { cancel, confirm, isCancel, select, spinner, text } from "@reliverse/rempts";
+import { $ } from "execa";
+import {
+  addEnvVariablesToFile
+} from "../project-generation/env-setup.js";
+import { commandExists } from "../../utils/command-exists.js";
+async function isTursoInstalled() {
+  return commandExists("turso");
+}
+async function isTursoLoggedIn() {
+  try {
+    const output = await $`turso auth whoami`;
+    return !output.stdout.includes("You are not logged in");
+  } catch {
+    return false;
+  }
+}
+async function loginToTurso() {
+  const s = spinner({
+    text: "Logging in to Turso..."
+  });
+  try {
+    s.start("Logging in to Turso...");
+    await $`turso auth login`;
+    s.stop("Logged into Turso");
+    return true;
+  } catch (_error) {
+    s.stop(re.red("Failed to log in to Turso"));
+  }
+}
+async function installTursoCLI(isMac) {
+  const s = spinner({
+    text: "Installing Turso CLI..."
+  });
+  try {
+    s.start("Installing Turso CLI...");
+    if (isMac) {
+      await $`brew install tursodatabase/tap/turso`;
+    } else {
+      const { stdout: installScript } = await $`curl -sSfL https://get.tur.so/install.sh`;
+      await $`bash -c '${installScript}'`;
+    }
+    s.stop("Turso CLI installed");
+    return true;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("User force closed")) {
+      s.stop("Turso CLI installation cancelled");
+      relinka("warn", re.yellow("Turso CLI installation cancelled by user"));
+      throw new Error("Installation cancelled");
+    }
+    s.stop(re.red("Failed to install Turso CLI"));
+  }
+}
+async function getTursoGroups() {
+  const s = spinner({
+    text: "Fetching Turso groups..."
+  });
+  try {
+    s.start("Fetching Turso groups...");
+    const { stdout } = await $`turso group list`;
+    const lines = stdout.trim().split("\n");
+    if (lines.length <= 1) {
+      s.stop("No Turso groups found");
+      return [];
+    }
+    const groups = lines.slice(1).map((line) => {
+      const [name, locations, version, status] = line.trim().split(/\s{2,}/);
+      if (!name || !locations || !version || !status) return null;
+      return { name, locations, version, status };
+    }).filter((group) => group !== null);
+    s.stop(`Found ${groups.length} Turso groups`);
+    return groups;
+  } catch (error) {
+    s.stop(re.red("Error fetching Turso groups"));
+    console.error("Error fetching Turso groups:", error);
+    return [];
+  }
+}
+async function selectTursoGroup() {
+  const groups = await getTursoGroups();
+  if (groups.length === 0) {
+    return null;
+  }
+  if (groups.length === 1) {
+    relinka("info", `Using the only available group: ${re.blue(groups[0]?.name ?? "")}`);
+    return groups[0]?.name ?? null;
+  }
+  const groupOptions = groups.map((group) => ({
+    value: group.name,
+    label: `${group.name} (${group.locations})`
+  }));
+  const selectedGroup = await select({
+    message: "Select a Turso database group:",
+    options: groupOptions
+  });
+  if (isCancel(selectedGroup)) {
+    cancel(re.red("Operation cancelled"));
+    process.exit(0);
+  }
+  return selectedGroup;
+}
+async function createTursoDatabase(dbName, groupName) {
+  const s = spinner({
+    text: "Creating Turso database..."
+  });
+  try {
+    s.start(`Creating Turso database "${dbName}"${groupName ? ` in group "${groupName}"` : ""}...`);
+    if (groupName) {
+      await $`turso db create ${dbName} --group ${groupName}`;
+    } else {
+      await $`turso db create ${dbName}`;
+    }
+    s.stop(`Turso database "${dbName}" created`);
+  } catch (error) {
+    s.stop(re.red(`Failed to create database "${dbName}"`));
+    if (error instanceof Error && error.message.includes("already exists")) {
+      throw new Error("DATABASE_EXISTS");
+    }
+  }
+  s.start("Retrieving database connection details...");
+  try {
+    const { stdout: dbUrl } = await $`turso db show ${dbName} --url`;
+    const { stdout: authToken } = await $`turso db tokens create ${dbName}`;
+    s.stop("Database connection details retrieved");
+    return {
+      dbUrl: dbUrl.trim(),
+      authToken: authToken.trim()
+    };
+  } catch (_error) {
+    s.stop(re.red("Failed to retrieve database connection details"));
+  }
+}
+async function writeEnvFile(projectDir, config) {
+  const envPath = path.join(projectDir, "apps/server", ".env");
+  const variables = [
+    {
+      key: "DATABASE_URL",
+      value: config?.dbUrl ?? "",
+      condition: true
+    },
+    {
+      key: "DATABASE_AUTH_TOKEN",
+      value: config?.authToken ?? "",
+      condition: true
+    }
+  ];
+  await addEnvVariablesToFile(envPath, variables);
+}
+function displayManualSetupInstructions() {
+  relinka(
+    "info",
+    `Manual Turso Setup Instructions:
+1. Visit https://turso.tech and create an account
+2. Create a new database from the dashboard
+3. Get your database URL and authentication token
+4. Add these credentials to the .env file in apps/server/.env
+DATABASE_URL=your_database_url
+DATABASE_AUTH_TOKEN=your_auth_token`
+  );
+}
+export async function setupTurso(config) {
+  const { projectDir } = config;
+  const setupSpinner = spinner({
+    text: "Checking Turso CLI availability..."
+  });
+  setupSpinner.start("Checking Turso CLI availability...");
+  try {
+    const platform = os.platform();
+    const isMac = platform === "darwin";
+    const isWindows = platform === "win32";
+    if (isWindows) {
+      setupSpinner.stop(re.yellow("Turso setup not supported on Windows"));
+      relinka("warn", re.yellow("Automatic Turso setup is not supported on Windows."));
+      await writeEnvFile(projectDir);
+      displayManualSetupInstructions();
+      return;
+    }
+    setupSpinner.stop("Turso CLI availability checked");
+    const isCliInstalled = await isTursoInstalled();
+    if (!isCliInstalled) {
+      const shouldInstall = await confirm({
+        /* 
+                Argument of type '{ message: string; initialValue: true; }' is not assignable to parameter of type 'ConfirmPromptOptions'.
+          Property 'title' is missing in type '{ message: string; initialValue: true; }' but required in type 'ConfirmPromptOptions'.ts(2345)
+        types.d.ts(118, 5): 'title' is declared here.
+        */
+        title: "Turso CLI Installation",
+        message: "Would you like to install Turso CLI?",
+        initialValue: true
+      });
+      if (isCancel(shouldInstall)) {
+        cancel(re.red("Operation cancelled"));
+        process.exit(0);
+      }
+      if (!shouldInstall) {
+        await writeEnvFile(projectDir);
+        displayManualSetupInstructions();
+        return;
+      }
+      await installTursoCLI(isMac);
+    }
+    const isLoggedIn = await isTursoLoggedIn();
+    if (!isLoggedIn) {
+      await loginToTurso();
+    }
+    const selectedGroup = await selectTursoGroup();
+    let success = false;
+    let dbName = "";
+    let suggestedName = path.basename(projectDir);
+    while (!success) {
+      const dbNameResponse = await text({
+        message: "Enter a name for your database:",
+        defaultValue: suggestedName,
+        initialValue: suggestedName,
+        placeholder: suggestedName
+      });
+      if (isCancel(dbNameResponse)) {
+        cancel(re.red("Operation cancelled"));
+        process.exit(0);
+      }
+      dbName = dbNameResponse;
+      try {
+        const config2 = await createTursoDatabase(dbName, selectedGroup);
+        await writeEnvFile(projectDir, config2);
+        success = true;
+      } catch (error) {
+        if (error instanceof Error && error.message === "DATABASE_EXISTS") {
+          relinka("warn", re.yellow(`Database "${re.red(dbName)}" already exists`));
+          suggestedName = `${dbName}-${Math.floor(Math.random() * 1e3)}`;
+        } else {
+          throw error;
+        }
+      }
+    }
+    relinka("success", "Turso database setup completed successfully!");
+  } catch (error) {
+    setupSpinner.stop(re.red("Turso CLI availability check failed"));
+    relinka(
+      "error",
+      re.red(`Error during Turso setup: ${error instanceof Error ? error.message : String(error)}`)
+    );
+    await writeEnvFile(projectDir);
+    displayManualSetupInstructions();
+    relinka("success", "Setup completed with manual configuration required.");
+  }
+}

package/bin/app/providers/better-t-stack/helpers/project-generation/create-project.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectConfig } from "../../types.js";
+export declare function createProject(options: ProjectConfig): Promise<any>;

package/bin/app/providers/better-t-stack/helpers/project-generation/create-project.js

@@ -0,0 +1,82 @@
+import { re } from "@reliverse/relico";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { cancel } from "@reliverse/rempts";
+import { setupAddons } from "../setup/addons-setup.js";
+import { setupApi } from "../setup/api-setup.js";
+import { setupAuth } from "../setup/auth-setup.js";
+import { setupBackendDependencies } from "../setup/backend-setup.js";
+import { setupDatabase } from "../setup/db-setup.js";
+import { setupExamples } from "../setup/examples-setup.js";
+import { setupRuntime } from "../setup/runtime-setup.js";
+import { createReadme } from "./create-readme.js";
+import { setupEnvironmentVariables } from "./env-setup.js";
+import { installDependencies } from "./install-dependencies.js";
+import { displayPostInstallInstructions } from "./post-installation.js";
+import { initializeGit, updatePackageConfigurations } from "./project-config.js";
+import {
+  copyBaseTemplate,
+  handleExtras,
+  setupAddonsTemplate,
+  setupAuthTemplate,
+  setupBackendFramework,
+  setupDbOrmTemplates,
+  setupExamplesTemplate,
+  setupFrontendTemplates
+} from "./template-manager.js";
+export async function createProject(options) {
+  const projectDir = options.projectDir;
+  const isConvex = options.backend === "convex";
+  try {
+    await fs.ensureDir(projectDir);
+    await copyBaseTemplate(projectDir, options);
+    await setupFrontendTemplates(projectDir, options);
+    await setupBackendFramework(projectDir, options);
+    if (!isConvex) {
+      await setupDbOrmTemplates(projectDir, options);
+      await setupAuthTemplate(projectDir, options);
+    }
+    if (options.examples.length > 0 && options.examples[0] !== "none") {
+      await setupExamplesTemplate(projectDir, options);
+    }
+    await setupAddonsTemplate(projectDir, options);
+    await setupApi(options);
+    if (!isConvex) {
+      await setupBackendDependencies(options);
+      await setupDatabase(options);
+      await setupRuntime(options);
+      if (options.examples.length > 0 && options.examples[0] !== "none") {
+        await setupExamples(options);
+      }
+    }
+    if (options.addons.length > 0 && options.addons[0] !== "none") {
+      await setupAddons(options);
+    }
+    if (!isConvex && options.auth) {
+      await setupAuth(options);
+    }
+    await handleExtras(projectDir, options);
+    await setupEnvironmentVariables(options);
+    await updatePackageConfigurations(projectDir, options);
+    await createReadme(projectDir, options);
+    await initializeGit(projectDir, options.git);
+    relinka("success", "Project template successfully scaffolded!");
+    if (options.install) {
+      await installDependencies({
+        projectDir,
+        packageManager: options.packageManager
+      });
+    }
+    displayPostInstallInstructions({
+      ...options,
+      depsInstalled: options.install
+    });
+    return projectDir;
+  } catch (error) {
+    if (error instanceof Error) {
+      cancel(re.red(`Error during project creation: ${error.message}`));
+    } else {
+      cancel(re.red(`An unexpected error occurred: ${String(error)}`));
+    }
+  }
+}

package/bin/app/providers/better-t-stack/helpers/project-generation/create-readme.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectConfig } from "../../types.js";
+export declare function createReadme(projectDir: string, options: ProjectConfig): Promise<void>;

package/bin/app/providers/better-t-stack/helpers/project-generation/create-readme.js

@@ -0,0 +1,245 @@
+import path from "node:path";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+export async function createReadme(projectDir, options) {
+  const readmePath = path.join(projectDir, "README.md");
+  const content = generateReadmeContent(options);
+  try {
+    await fs.writeFile(readmePath, content);
+  } catch (error) {
+    relinka("error", "Failed to create README.md file:", error);
+  }
+}
+function generateReadmeContent(options) {
+  const {
+    projectName,
+    packageManager,
+    database,
+    auth,
+    addons = [],
+    orm = "drizzle",
+    runtime = "bun",
+    frontend = ["tanstack-router"],
+    backend = "hono",
+    api = "trpc"
+  } = options;
+  const isConvex = backend === "convex";
+  const hasReactRouter = frontend.includes("react-router");
+  const hasTanstackRouter = frontend.includes("tanstack-router");
+  const hasNative = frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
+  const hasNext = frontend.includes("next");
+  const hasTanstackStart = frontend.includes("tanstack-start");
+  const hasSvelte = frontend.includes("svelte");
+  const hasSolid = frontend.includes("solid");
+  const hasNuxt = frontend.includes("nuxt");
+  const packageManagerRunCmd = packageManager === "npm" ? "npm run" : packageManager;
+  let webPort = "3001";
+  if (hasReactRouter || hasSvelte) {
+    webPort = "5173";
+  }
+  return `# ${projectName}
+This project was created with [Better-T-Stack](https://github.com/AmanVarshney01/create-better-t-stack), a modern TypeScript stack that combines ${hasTanstackRouter ? "React, TanStack Router" : hasReactRouter ? "React, React Router" : hasNext ? "Next.js" : hasTanstackStart ? "React, TanStack Start" : hasSvelte ? "SvelteKit" : hasNuxt ? "Nuxt" : hasSolid ? "SolidJS" : ""}, ${backend?.[0]?.toUpperCase() ?? ""}${backend?.slice(1) ?? ""}${isConvex ? "" : `, ${api.toUpperCase()}`}, and more.
+## Features
+${generateFeaturesList(database, auth, addons, orm, runtime, frontend, backend, api)}
+## Getting Started
+First, install the dependencies:
+\`\`\`bash
+${packageManager} install
+\`\`\`
+${isConvex ? `
+## Convex Setup
+This project uses Convex as a backend. You'll need to set up Convex before running the app:
+\`\`\`bash
+${packageManagerRunCmd} dev:setup
+\`\`\`
+Follow the prompts to create a new Convex project and connect it to your application.` : generateDatabaseSetup(database, auth, packageManagerRunCmd, orm)}
+Then, run the development server:
+\`\`\`bash
+${packageManagerRunCmd} dev
+\`\`\`
+${hasTanstackRouter || hasReactRouter || hasNext || hasTanstackStart || hasSvelte || hasNuxt || hasSolid ? `Open [http://localhost:${webPort}](http://localhost:${webPort}) in your browser to see the web application.` : ""}
+${hasNative ? "Use the Expo Go app to run the mobile application.\n" : ""}
+${isConvex ? "Your app will connect to the Convex cloud backend automatically." : "The API is running at [http://localhost:3000](http://localhost:3000)."}
+${addons.includes("pwa") && hasReactRouter ? "\n## PWA Support with React Router v7\n\nThere is a known compatibility issue between VitePWA and React Router v7.\nSee: https://github.com/vite-pwa/vite-plugin-pwa/issues/809\n" : ""}
+## Project Structure
+\`\`\`
+${projectName}/
+\u251C\u2500\u2500 apps/
+${hasTanstackRouter || hasReactRouter || hasNext || hasTanstackStart || hasSvelte || hasNuxt || hasSolid ? `\u2502   \u251C\u2500\u2500 web/         # Frontend application (${hasTanstackRouter ? "React + TanStack Router" : hasReactRouter ? "React + React Router" : hasNext ? "Next.js" : hasTanstackStart ? "React + TanStack Start" : hasSvelte ? "SvelteKit" : hasNuxt ? "Nuxt" : hasSolid ? "SolidJS" : ""})
+` : ""}${hasNative ? "\u2502   \u251C\u2500\u2500 native/      # Mobile application (React Native, Expo)\n" : ""}${addons.includes("starlight") ? "\u2502   \u251C\u2500\u2500 docs/        # Documentation site (Astro Starlight)\n" : ""}${isConvex ? "\u251C\u2500\u2500 packages/\n\u2502   \u2514\u2500\u2500 backend/     # Convex backend functions and schema\n" : `\u2502   \u2514\u2500\u2500 server/      # Backend API (${backend?.[0]?.toUpperCase() ?? ""}, ${api.toUpperCase()})`}
+\`\`\`
+## Available Scripts
+${generateScriptsList(packageManagerRunCmd, database, orm, auth, hasNative, addons, backend)}
+`;
+}
+function generateFeaturesList(database, auth, addons, orm, runtime, frontend, backend, api) {
+  const isConvex = backend === "convex";
+  const hasTanstackRouter = frontend.includes("tanstack-router");
+  const hasReactRouter = frontend.includes("react-router");
+  const hasNative = frontend.includes("native-nativewind") || frontend.includes("native-unistyles");
+  const hasNext = frontend.includes("next");
+  const hasTanstackStart = frontend.includes("tanstack-start");
+  const hasSvelte = frontend.includes("svelte");
+  const hasNuxt = frontend.includes("nuxt");
+  const hasSolid = frontend.includes("solid");
+  const addonsList = ["- **TypeScript** - For type safety and improved developer experience"];
+  if (hasTanstackRouter) {
+    addonsList.push("- **TanStack Router** - File-based routing with full type safety");
+  } else if (hasReactRouter) {
+    addonsList.push("- **React Router** - Declarative routing for React");
+  } else if (hasNext) {
+    addonsList.push("- **Next.js** - Full-stack React framework");
+  } else if (hasTanstackStart) {
+    addonsList.push("- **TanStack Start** - SSR framework with TanStack Router");
+  } else if (hasSvelte) {
+    addonsList.push("- **SvelteKit** - Web framework for building Svelte apps");
+  } else if (hasNuxt) {
+    addonsList.push("- **Nuxt** - The Intuitive Vue Framework");
+  } else if (hasSolid) {
+    addonsList.push("- **SolidJS** - Simple and performant reactivity");
+  }
+  if (hasNative) {
+    addonsList.push("- **React Native** - Build mobile apps using React");
+    addonsList.push("- **Expo** - Tools for React Native development");
+  }
+  addonsList.push(
+    "- **TailwindCSS** - Utility-first CSS for rapid UI development",
+    "- **shadcn/ui** - Reusable UI components"
+  );
+  if (isConvex) {
+    addonsList.push("- **Convex** - Reactive backend-as-a-service platform");
+  } else {
+    if (backend === "hono") {
+      addonsList.push("- **Hono** - Lightweight, performant server framework");
+    } else if (backend === "express") {
+      addonsList.push("- **Express** - Fast, unopinionated web framework");
+    } else if (backend === "fastify") {
+      addonsList.push("- **Fastify** - Fast, low-overhead web framework");
+    } else if (backend === "elysia") {
+      addonsList.push("- **Elysia** - Type-safe, high-performance framework");
+    } else if (backend === "next") {
+      addonsList.push("- **Next.js** - Full-stack React framework");
+    }
+    if (api === "trpc") {
+      addonsList.push("- **tRPC** - End-to-end type-safe APIs");
+    } else if (api === "orpc") {
+      addonsList.push("- **oRPC** - End-to-end type-safe APIs with OpenAPI integration");
+    }
+    addonsList.push(`- **${runtime === "bun" ? "Bun" : "Node.js"}** - Runtime environment`);
+  }
+  if (database !== "none" && !isConvex) {
+    addonsList.push(
+      `- **${orm === "drizzle" ? "Drizzle" : orm === "prisma" ? "Prisma" : "Mongoose"}** - TypeScript-first ORM`,
+      `- **${database === "sqlite" ? "SQLite/Turso" : database === "postgres" ? "PostgreSQL" : database === "mysql" ? "MySQL" : "MongoDB"}** - Database engine`
+    );
+  }
+  if (auth && !isConvex) {
+    addonsList.push("- **Authentication** - Email & password authentication with Better Auth");
+  }
+  for (const addon of addons) {
+    if (addon === "pwa") {
+      addonsList.push("- **PWA** - Progressive Web App support");
+    } else if (addon === "tauri") {
+      addonsList.push("- **Tauri** - Build native desktop applications");
+    } else if (addon === "biome") {
+      addonsList.push("- **Biome** - Linting and formatting");
+    } else if (addon === "husky") {
+      addonsList.push("- **Husky** - Git hooks for code quality");
+    } else if (addon === "starlight") {
+      addonsList.push("- **Starlight** - Documentation site with Astro");
+    } else if (addon === "turborepo") {
+      addonsList.push("- **Turborepo** - Optimized monorepo build system");
+    }
+  }
+  return addonsList.join("\n");
+}
+function generateDatabaseSetup(database, auth, packageManagerRunCmd, orm) {
+  if (database === "none") {
+    return "";
+  }
+  let setup = "## Database Setup\n\n";
+  if (database === "sqlite") {
+    setup += `This project uses SQLite${orm === "drizzle" ? " with Drizzle ORM" : " with Prisma"}.
+1. Start the local SQLite database:
+\`\`\`bash
+cd apps/server && ${packageManagerRunCmd} db:local
+\`\`\`
+2. Update your \`.env\` file in the \`apps/server\` directory with the appropriate connection details if needed.
+`;
+  } else if (database === "postgres") {
+    setup += `This project uses PostgreSQL${orm === "drizzle" ? " with Drizzle ORM" : " with Prisma"}.
+1. Make sure you have a PostgreSQL database set up.
+2. Update your \`apps/server/.env\` file with your PostgreSQL connection details.
+`;
+  } else if (database === "mysql") {
+    setup += `This project uses MySQL${orm === "drizzle" ? " with Drizzle ORM" : " with Prisma"}.
+1. Make sure you have a MySQL database set up.
+2. Update your \`apps/server/.env\` file with your MySQL connection details.
+`;
+  } else if (database === "mongodb") {
+    setup += `This project uses MongoDB ${orm === "mongoose" ? "with Mongoose" : "with Prisma ORM"}.
+1. Make sure you have MongoDB set up.
+2. Update your \`apps/server/.env\` file with your MongoDB connection URI.
+`;
+  }
+  setup += `
+${auth ? "3" : "3"}. ${orm === "prisma" ? `Generate the Prisma client and push the schema:
+\`\`\`bash
+${packageManagerRunCmd} db:push
+\`\`\`` : orm === "drizzle" ? `Apply the schema to your database:
+\`\`\`bash
+${packageManagerRunCmd} db:push
+\`\`\`` : `Apply the schema to your database:
+\`\`\`bash
+${packageManagerRunCmd} db:push
+\`\`\``}
+`;
+  return setup;
+}
+function generateScriptsList(packageManagerRunCmd, database, orm, _auth, hasNative, addons, backend) {
+  const isConvex = backend === "convex";
+  let scripts = `- \`${packageManagerRunCmd} dev\`: Start all applications in development mode
+- \`${packageManagerRunCmd} build\`: Build all applications
+- \`${packageManagerRunCmd} dev:web\`: Start only the web application`;
+  if (isConvex) {
+    scripts += `
+- \`${packageManagerRunCmd} dev:setup\`: Setup and configure your Convex project`;
+  } else {
+    scripts += `
+- \`${packageManagerRunCmd} dev:server\`: Start only the server`;
+  }
+  scripts += `
+- \`${packageManagerRunCmd} check-types\`: Check TypeScript types across all apps`;
+  if (hasNative) {
+    scripts += `
+- \`${packageManagerRunCmd} dev:native\`: Start the React Native/Expo development server`;
+  }
+  if (database !== "none" && !isConvex) {
+    scripts += `
+- \`${packageManagerRunCmd} db:push\`: Push schema changes to database
+- \`${packageManagerRunCmd} db:studio\`: Open database studio UI`;
+    if (database === "sqlite" && orm === "drizzle") {
+      scripts += `
+- \`cd apps/server && ${packageManagerRunCmd} db:local\`: Start the local SQLite database`;
+    }
+  }
+  if (addons.includes("biome")) {
+    scripts += `
+- \`${packageManagerRunCmd} check\`: Run Biome formatting and linting`;
+  }
+  if (addons.includes("pwa")) {
+    scripts += `
+- \`cd apps/web && ${packageManagerRunCmd} generate-pwa-assets\`: Generate PWA assets`;
+  }
+  if (addons.includes("tauri")) {
+    scripts += `
+- \`cd apps/web && ${packageManagerRunCmd} desktop:dev\`: Start Tauri desktop app in development
+- \`cd apps/web && ${packageManagerRunCmd} desktop:build\`: Build Tauri desktop app`;
+  }
+  if (addons.includes("starlight")) {
+    scripts += `
+- \`cd apps/docs && ${packageManagerRunCmd} dev\`: Start documentation site
+- \`cd apps/docs && ${packageManagerRunCmd} build\`: Build documentation site`;
+  }
+  return scripts;
+}

package/bin/app/providers/better-t-stack/helpers/project-generation/env-setup.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectConfig } from "../../types.js";
+export interface EnvVariable {
+    key: string;
+    value: string | null | undefined;
+    condition: boolean;
+}
+export declare function addEnvVariablesToFile(filePath: string, variables: EnvVariable[]): Promise<void>;
+export declare function setupEnvironmentVariables(config: ProjectConfig): Promise<void>;