stackpatch 1.1.1 → 1.1.4

package/src/fileOps/copy.ts

@@ -0,0 +1,224 @@
+import fs from "fs";
+import path from "path";
+import fse from "fs-extra";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import {
+  detectAppDirectory,
+  detectComponentsDirectory,
+  generateComponentImportPath,
+} from "../utils/paths.js";
+import { findTypeScriptFiles } from "../utils/files.js";
+
+/**
+ * File copying operations
+ */
+
+/**
+ * Copy files from source to destination with smart directory detection
+ */
+export async function copyFiles(
+  src: string,
+  dest: string
+): Promise<{ success: boolean; addedFiles: string[] }> {
+  const addedFiles: string[] = [];
+
+  if (!fs.existsSync(src)) {
+    console.log(chalk.red(`❌ Boilerplate folder not found: ${src}`));
+    return { success: false, addedFiles: [] };
+  }
+
+  await fse.ensureDir(dest);
+
+  // Detect app directory location in target
+  const appDir = detectAppDirectory(dest);
+  const appDirPath = path.join(dest, appDir);
+  const componentsDir = detectComponentsDirectory(dest);
+  const componentsDirPath = path.join(dest, componentsDir);
+
+  // Detect lib directory (src/lib or lib)
+  const hasSrcDir = fs.existsSync(path.join(dest, "src"));
+  const libDir = hasSrcDir ? "src/lib" : "lib";
+  const libDirPath = path.join(dest, libDir);
+
+  const conflicts: string[] = [];
+
+  // Check for conflicts before copying
+  const entries = fse.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === "app") {
+      // For app directory, check conflicts in the detected app directory
+      if (fs.existsSync(appDirPath)) {
+        const appEntries = fse.readdirSync(path.join(src, "app"), { withFileTypes: true });
+        for (const appEntry of appEntries) {
+          const destAppPath = path.join(appDirPath, appEntry.name);
+          if (fs.existsSync(destAppPath)) {
+            conflicts.push(destAppPath);
+          }
+        }
+      }
+    } else if (entry.name === "components") {
+      // For components directory, check conflicts in the detected components directory
+      if (fs.existsSync(componentsDirPath)) {
+        const componentEntries = fse.readdirSync(path.join(src, "components"), {
+          withFileTypes: true,
+        });
+        for (const componentEntry of componentEntries) {
+          const destComponentPath = path.join(componentsDirPath, componentEntry.name);
+          if (fs.existsSync(destComponentPath)) {
+            conflicts.push(destComponentPath);
+          }
+        }
+      }
+    } else if (entry.name === "lib") {
+      // For lib directory, check conflicts in the detected lib directory
+      if (fs.existsSync(libDirPath)) {
+        const libEntries = fse.readdirSync(path.join(src, "lib"), {
+          withFileTypes: true,
+        });
+        for (const libEntry of libEntries) {
+          const destLibPath = path.join(libDirPath, libEntry.name);
+          if (fs.existsSync(destLibPath)) {
+            conflicts.push(destLibPath);
+          }
+        }
+      }
+    } else {
+      // For other files/directories (middleware, etc.), check in root
+      const destPath = path.join(dest, entry.name);
+      if (fs.existsSync(destPath)) {
+        conflicts.push(destPath);
+      }
+    }
+  }
+
+  if (conflicts.length) {
+    console.log(chalk.yellow("\n⚠️ The following files already exist:"));
+    conflicts.forEach((f) => console.log(`  ${f}`));
+
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "overwrite",
+        message: "Do you want to overwrite them?",
+        choices: [
+          { name: "Yes, overwrite", value: "yes" },
+          { name: "No, skip", value: "no" },
+        ],
+        default: "no",
+      },
+    ]);
+
+    if (overwrite !== "yes") {
+      console.log(chalk.red("\nAborted! No files were copied."));
+      return { success: false, addedFiles: [] };
+    }
+  }
+
+  // Track files from SOURCE (boilerplate) before copying
+  // This ensures we only track files that are actually from StackPatch
+  function trackSourceFiles(srcDir: string, baseDir: string, targetBase: string): void {
+    if (!fs.existsSync(srcDir)) return;
+
+    const files = fs.readdirSync(srcDir, { withFileTypes: true });
+    for (const file of files) {
+      const srcFilePath = path.join(srcDir, file.name);
+      if (file.isDirectory()) {
+        trackSourceFiles(srcFilePath, baseDir, targetBase);
+      } else {
+        const relativePath = path.relative(baseDir, srcFilePath);
+        const targetPath = targetBase
+          ? path.join(targetBase, relativePath).replace(/\\/g, "/")
+          : relativePath.replace(/\\/g, "/");
+        addedFiles.push(targetPath);
+      }
+    }
+  }
+
+  // Copy files with smart app directory handling
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+
+    if (entry.name === "app") {
+      // Track files from SOURCE boilerplate before copying
+      trackSourceFiles(srcPath, srcPath, appDir);
+
+      // Copy app directory contents to the detected app directory location
+      await fse.ensureDir(appDirPath);
+      await fse.copy(srcPath, appDirPath, { overwrite: true });
+    } else if (entry.name === "components") {
+      // Track files from SOURCE boilerplate before copying
+      trackSourceFiles(srcPath, srcPath, componentsDir);
+
+      // Copy components directory to the detected components directory location
+      await fse.ensureDir(componentsDirPath);
+      await fse.copy(srcPath, componentsDirPath, { overwrite: true });
+    } else if (entry.name === "lib") {
+      // Track files from SOURCE boilerplate before copying
+      trackSourceFiles(srcPath, srcPath, libDir);
+
+      // Copy lib directory to the detected lib directory location
+      await fse.ensureDir(libDirPath);
+      await fse.copy(srcPath, libDirPath, { overwrite: true });
+    } else {
+      // For root-level files/directories, track from source
+      const srcStat = fs.statSync(srcPath);
+      if (srcStat.isDirectory()) {
+        trackSourceFiles(srcPath, srcPath, "");
+      } else {
+        addedFiles.push(entry.name);
+      }
+
+      // Copy other files/directories (middleware, etc.) to root
+      const destPath = path.join(dest, entry.name);
+      await fse.copy(srcPath, destPath, { overwrite: true });
+    }
+  }
+
+  // Update imports in copied files to use correct paths
+  updateImportsInFiles(dest);
+
+  return { success: true, addedFiles };
+}
+
+/**
+ * Update imports in copied files to use correct paths
+ */
+function updateImportsInFiles(target: string): void {
+  const appDir = detectAppDirectory(target);
+  const appDirPath = path.join(target, appDir);
+
+  if (!fs.existsSync(appDirPath)) {
+    return;
+  }
+
+  const files = findTypeScriptFiles(appDirPath);
+
+  for (const filePath of files) {
+    try {
+      let content = fs.readFileSync(filePath, "utf-8");
+      let updated = false;
+
+      // Match imports like: from "@/components/component-name"
+      const importRegex = /from\s+["']@\/components\/([^"']+)["']/g;
+      const matches = Array.from(content.matchAll(importRegex));
+
+      for (const match of matches) {
+        const componentName = (match as RegExpMatchArray)[1];
+        const oldImport = (match as RegExpMatchArray)[0];
+        const newImportPath = generateComponentImportPath(target, componentName, filePath);
+        const newImport = oldImport.replace(/@\/components\/[^"']+/, newImportPath);
+
+        content = content.replace(oldImport, newImport);
+        updated = true;
+      }
+
+      if (updated) {
+        fs.writeFileSync(filePath, content, "utf-8");
+      }
+    } catch (error) {
+      // Silently skip files that can't be processed
+      continue;
+    }
+  }
+}

package/src/fileOps/layout.ts

@@ -0,0 +1,304 @@
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { detectAppDirectory } from "../utils/paths.js";
+import { generateComponentImportPath } from "../utils/paths.js";
+import { backupFile } from "../manifest.js";
+
+/**
+ * Layout file modification operations
+ */
+
+export interface LayoutUpdateResult {
+  success: boolean;
+  modified: boolean;
+  filePath: string;
+  originalContent?: string;
+}
+
+/**
+ * Update layout.tsx to include Toaster
+ */
+export function updateLayoutForToaster(
+  target: string
+): LayoutUpdateResult {
+  const appDir = detectAppDirectory(target);
+  const layoutPath = path.join(target, appDir, "layout.tsx");
+
+  if (!fs.existsSync(layoutPath)) {
+    return { success: false, modified: false, filePath: layoutPath };
+  }
+
+  try {
+    const originalContent = fs.readFileSync(layoutPath, "utf-8");
+    let layoutContent = originalContent;
+
+    // Check if already has Toaster
+    if (layoutContent.includes("Toaster")) {
+      console.log(chalk.green("✅ Layout already has Toaster!"));
+      return { success: true, modified: false, filePath: layoutPath };
+    }
+
+    // Generate the correct import path
+    const importPath = generateComponentImportPath(target, "toaster", layoutPath);
+
+    // Check if import already exists (check for various patterns)
+    const hasImport =
+      layoutContent.includes("toaster") &&
+      (layoutContent.includes("from") || layoutContent.includes("import"));
+
+    if (!hasImport) {
+      // Find the last import statement
+      const lines = layoutContent.split("\n");
+      let lastImportIndex = -1;
+
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith("import ") && trimmed.endsWith(";")) {
+          lastImportIndex = i;
+        } else if (trimmed && !trimmed.startsWith("//") && lastImportIndex >= 0) {
+          break;
+        }
+      }
+
+      if (lastImportIndex >= 0) {
+        lines.splice(lastImportIndex + 1, 0, `import { Toaster } from "${importPath}";`);
+        layoutContent = lines.join("\n");
+      }
+    }
+
+    // Add Toaster component
+    if (layoutContent.includes("{children}")) {
+      // Add Toaster after children
+      layoutContent = layoutContent.replace(/(\{children\})/, '$1\n          <Toaster />');
+    } else {
+      // Try to find body tag and add Toaster before closing body
+      const bodyRegex = /(<body[^>]*>)([\s\S]*?)(<\/body>)/;
+      if (bodyRegex.test(layoutContent)) {
+        layoutContent = layoutContent.replace(bodyRegex, '$1$2\n        <Toaster />\n      $3');
+      }
+    }
+
+    // Backup before modifying
+    backupFile(layoutPath, target);
+
+    fs.writeFileSync(layoutPath, layoutContent, "utf-8");
+    console.log(chalk.green("✅ Updated layout.tsx with Toaster!"));
+
+    const relativePath = path.relative(target, layoutPath).replace(/\\/g, "/");
+    return { success: true, modified: true, filePath: relativePath, originalContent };
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(chalk.yellow(`⚠️  Failed to update layout with Toaster: ${errorMessage}`));
+    return { success: false, modified: false, filePath: layoutPath };
+  }
+}
+
+/**
+ * Update layout.tsx to include AuthWrapper
+ * This wrapper provides client-side route protection
+ */
+export function updateLayoutForAuthWrapper(target: string): LayoutUpdateResult {
+  const appDir = detectAppDirectory(target);
+  const layoutPath = path.join(target, appDir, "layout.tsx");
+
+  if (!fs.existsSync(layoutPath)) {
+    console.log(chalk.yellow("⚠️  layout.tsx not found. Skipping layout update."));
+    return { success: false, modified: false, filePath: layoutPath };
+  }
+
+  try {
+    const originalContent = fs.readFileSync(layoutPath, "utf-8");
+    let layoutContent = originalContent;
+
+    // Check if already has AuthWrapper
+    if (layoutContent.includes("AuthWrapper")) {
+      console.log(chalk.green("✅ Layout already has AuthWrapper!"));
+      return { success: true, modified: false, filePath: layoutPath };
+    }
+
+    // Generate the correct import path
+    const importPath = generateComponentImportPath(target, "auth-wrapper", layoutPath);
+
+    // Check if import already exists
+    const hasImport =
+      layoutContent.includes("auth-wrapper") &&
+      (layoutContent.includes("from") || layoutContent.includes("import"));
+
+    if (!hasImport) {
+      // Find the last import statement
+      const lines = layoutContent.split("\n");
+      let lastImportIndex = -1;
+
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith("import ") && trimmed.endsWith(";")) {
+          lastImportIndex = i;
+        } else if (trimmed && !trimmed.startsWith("//") && lastImportIndex >= 0) {
+          break;
+        }
+      }
+
+      if (lastImportIndex >= 0) {
+        lines.splice(
+          lastImportIndex + 1,
+          0,
+          `import { AuthWrapper } from "${importPath}";`
+        );
+        layoutContent = lines.join("\n");
+      } else {
+        // No imports found, add after the first line
+        const firstNewline = layoutContent.indexOf("\n");
+        if (firstNewline > 0) {
+          layoutContent =
+            layoutContent.slice(0, firstNewline + 1) +
+            `import { AuthWrapper } from "${importPath}";\n` +
+            layoutContent.slice(firstNewline + 1);
+        } else {
+          layoutContent = `import { AuthWrapper } from "${importPath}";\n` + layoutContent;
+        }
+      }
+    }
+
+    // Wrap children with AuthWrapper
+    // Look for {children} pattern
+    const childrenPattern = /(\s*)(\{children\})(\s*)/;
+    if (childrenPattern.test(layoutContent)) {
+      layoutContent = layoutContent.replace(
+        childrenPattern,
+        '$1<AuthWrapper>{children}</AuthWrapper>$3'
+      );
+    } else {
+      // Try to find body tag and wrap its content
+      const bodyRegex = /(<body[^>]*>)([\s\S]*?)(<\/body>)/;
+      const bodyMatch = layoutContent.match(bodyRegex);
+      if (bodyMatch) {
+        const bodyContent = bodyMatch[2].trim();
+        if (bodyContent && !bodyContent.includes("AuthWrapper")) {
+          layoutContent = layoutContent.replace(
+            bodyRegex,
+            `$1\n        <AuthWrapper>${bodyContent}</AuthWrapper>\n      $3`
+          );
+        }
+      }
+    }
+
+    // Backup before modifying
+    backupFile(layoutPath, target);
+
+    fs.writeFileSync(layoutPath, layoutContent, "utf-8");
+    console.log(chalk.green("✅ Updated layout.tsx with AuthWrapper!"));
+
+    const relativePath = path.relative(target, layoutPath).replace(/\\/g, "/");
+    return { success: true, modified: true, filePath: relativePath, originalContent };
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(chalk.red(`❌ Failed to update layout.tsx: ${errorMessage}`));
+    return { success: false, modified: false, filePath: layoutPath };
+  }
+}
+
+/**
+ * Update layout.tsx to include AuthSessionProvider
+ * Note: Better Auth doesn't require a session provider, but we add it for compatibility
+ * @deprecated Not used - middleware handles all route protection
+ */
+export function updateLayoutForAuth(target: string): LayoutUpdateResult {
+  const appDir = detectAppDirectory(target);
+  const layoutPath = path.join(target, appDir, "layout.tsx");
+
+  if (!fs.existsSync(layoutPath)) {
+    console.log(chalk.yellow("⚠️  layout.tsx not found. Skipping layout update."));
+    return { success: false, modified: false, filePath: layoutPath };
+  }
+
+  try {
+    const originalContent = fs.readFileSync(layoutPath, "utf-8");
+    let layoutContent = originalContent;
+
+    // Check if already has AuthSessionProvider
+    if (layoutContent.includes("AuthSessionProvider")) {
+      console.log(chalk.green("✅ Layout already has AuthSessionProvider!"));
+      return { success: true, modified: false, filePath: layoutPath };
+    }
+
+    // Generate the correct import path
+    const importPath = generateComponentImportPath(target, "session-provider", layoutPath);
+
+    // Check if import already exists (check for various patterns)
+    const hasImport =
+      layoutContent.includes("session-provider") &&
+      (layoutContent.includes("from") || layoutContent.includes("import"));
+
+    if (!hasImport) {
+      // Find the last import statement (before the first non-import line)
+      const lines = layoutContent.split("\n");
+      let lastImportIndex = -1;
+
+      for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith("import ") && trimmed.endsWith(";")) {
+          lastImportIndex = i;
+        } else if (trimmed && !trimmed.startsWith("//") && lastImportIndex >= 0) {
+          break;
+        }
+      }
+
+      if (lastImportIndex >= 0) {
+        lines.splice(
+          lastImportIndex + 1,
+          0,
+          `import { AuthSessionProvider } from "${importPath}";`
+        );
+        layoutContent = lines.join("\n");
+      } else {
+        // No imports found, add after the first line
+        const firstNewline = layoutContent.indexOf("\n");
+        if (firstNewline > 0) {
+          layoutContent =
+            layoutContent.slice(0, firstNewline + 1) +
+            `import { AuthSessionProvider } from "${importPath}";\n` +
+            layoutContent.slice(firstNewline + 1);
+        } else {
+          layoutContent = `import { AuthSessionProvider } from "${importPath}";\n` + layoutContent;
+        }
+      }
+    }
+
+    // Wrap children with AuthSessionProvider
+    // Look for {children} pattern in body tag
+    const childrenPattern = /(\s*)(\{children\})(\s*)/;
+    if (childrenPattern.test(layoutContent)) {
+      layoutContent = layoutContent.replace(
+        childrenPattern,
+        '$1<AuthSessionProvider>{children}</AuthSessionProvider>$3'
+      );
+    } else {
+      // Try to find body tag and wrap its content
+      const bodyRegex = /(<body[^>]*>)([\s\S]*?)(<\/body>)/;
+      const bodyMatch = layoutContent.match(bodyRegex);
+      if (bodyMatch) {
+        const bodyContent = bodyMatch[2].trim();
+        if (bodyContent && !bodyContent.includes("AuthSessionProvider")) {
+          layoutContent = layoutContent.replace(
+            bodyRegex,
+            `$1\n        <AuthSessionProvider>${bodyContent}</AuthSessionProvider>\n      $3`
+          );
+        }
+      }
+    }
+
+    // Backup before modifying
+    backupFile(layoutPath, target);
+
+    fs.writeFileSync(layoutPath, layoutContent, "utf-8");
+    console.log(chalk.green("✅ Updated layout.tsx with AuthSessionProvider!"));
+
+    const relativePath = path.relative(target, layoutPath).replace(/\\/g, "/");
+    return { success: true, modified: true, filePath: relativePath, originalContent };
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.log(chalk.red(`❌ Failed to update layout.tsx: ${errorMessage}`));
+    return { success: false, modified: false, filePath: layoutPath };
+  }
+}

package/src/fileOps/protected.ts

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+import { BOILERPLATE_ROOT } from "../config.js";
+import { detectAppDirectory, detectComponentsDirectory } from "../utils/paths.js";
+
+/**
+ * Copy protected route files
+ */
+export async function copyProtectedRouteFiles(target: string): Promise<void> {
+  const protectedRouteSrc = path.join(BOILERPLATE_ROOT, "auth/components/protected-route.tsx");
+  const middlewareSrc = path.join(BOILERPLATE_ROOT, "auth/middleware.ts");
+
+  const componentsDir = detectComponentsDirectory(target);
+  const componentsDirPath = path.join(target, componentsDir);
+  const protectedRouteDest = path.join(componentsDirPath, "protected-route.tsx");
+  const middlewareDest = path.join(target, "middleware.ts");
+
+  // Ensure components directory exists
+  if (!fs.existsSync(componentsDirPath)) {
+    fs.mkdirSync(componentsDirPath, { recursive: true });
+  }
+
+  // Copy protected route component
+  if (fs.existsSync(protectedRouteSrc)) {
+    fs.copyFileSync(protectedRouteSrc, protectedRouteDest);
+  }
+
+  // Copy middleware (only if it doesn't exist)
+  if (fs.existsSync(middlewareSrc) && !fs.existsSync(middlewareDest)) {
+    fs.copyFileSync(middlewareSrc, middlewareDest);
+  }
+
+  // Auth navbar is not copied by default - it's available in boilerplate if needed
+  // Users can manually copy it if they want to use it
+
+  // Copy example pages (only if they don't exist)
+  const appDir = detectAppDirectory(target);
+  const dashboardPageSrc = path.join(BOILERPLATE_ROOT, "auth/app/dashboard/page.tsx");
+  const landingPageSrc = path.join(BOILERPLATE_ROOT, "auth/app/page.tsx");
+  const dashboardPageDest = path.join(target, appDir, "dashboard/page.tsx");
+  const landingPageDest = path.join(target, appDir, "page.tsx");
+
+  // Create dashboard directory if needed
+  const dashboardDir = path.join(target, appDir, "dashboard");
+  if (!fs.existsSync(dashboardDir)) {
+    fs.mkdirSync(dashboardDir, { recursive: true });
+  }
+
+  // Copy dashboard page (only if it doesn't exist)
+  if (fs.existsSync(dashboardPageSrc) && !fs.existsSync(dashboardPageDest)) {
+    fs.copyFileSync(dashboardPageSrc, dashboardPageDest);
+  }
+
+  // Copy landing page (only if it doesn't exist or is default)
+  if (fs.existsSync(landingPageSrc)) {
+    // Check if current page is just a default Next.js page
+    if (fs.existsSync(landingPageDest)) {
+      const currentContent = fs.readFileSync(landingPageDest, "utf-8");
+      // Only replace if it's the default Next.js page
+      if (currentContent.includes("Get started by editing") || currentContent.length < 500) {
+        fs.copyFileSync(landingPageSrc, landingPageDest);
+      }
+    } else {
+      fs.copyFileSync(landingPageSrc, landingPageDest);
+    }
+  }
+}