stackpatch 1.2.6 → 1.2.8

package/dist/stackpatch.js

@@ -841,55 +841,70 @@ function getParentDirectories(filePath, rootPath) {
     }
     return dirs;
 }
+/**
+ * Check if a directory is a Next.js app
+ */
+function isNextJsApp(dir) {
+    return (fs.existsSync(path.join(dir, "app")) ||
+        fs.existsSync(path.join(dir, "src", "app")) ||
+        fs.existsSync(path.join(dir, "pages")) ||
+        fs.existsSync(path.join(dir, "src", "pages"))) && fs.existsSync(path.join(dir, "package.json"));
+}
 /**
  * Auto-detect target directory for Next.js app
  */
 function detectTargetDirectory(startDir = process.cwd()) {
     let target = startDir;
-    // Check if we're in a Next.js app (has app/, src/app/, pages/, or src/pages/ directory)
-    const hasAppDir = fs.existsSync(path.join(target, "app")) || fs.existsSync(path.join(target, "src", "app"));
-    const hasPagesDir = fs.existsSync(path.join(target, "pages")) || fs.existsSync(path.join(target, "src", "pages"));
-    if (!hasAppDir && !hasPagesDir) {
-        // Try parent directory
-        const parent = path.resolve(target, "..");
-        if (fs.existsSync(path.join(parent, "app")) ||
-            fs.existsSync(path.join(parent, "src", "app")) ||
-            fs.existsSync(path.join(parent, "pages")) ||
-            fs.existsSync(path.join(parent, "src", "pages"))) {
-            target = parent;
-        }
-        else {
-            // Try common monorepo locations: apps/, packages/, or root
-            const possiblePaths = [
-                path.join(target, "apps"),
-                path.join(parent, "apps"),
-                path.join(target, "packages"),
-                path.join(parent, "packages"),
-            ];
-            let foundApp = false;
-            for (const possiblePath of possiblePaths) {
-                if (fs.existsSync(possiblePath)) {
-                    // Look for Next.js apps in this directory
-                    const entries = fs.readdirSync(possiblePath, { withFileTypes: true });
-                    for (const entry of entries) {
-                        if (entry.isDirectory()) {
-                            const appPath = path.join(possiblePath, entry.name);
-                            if (fs.existsSync(path.join(appPath, "app")) ||
-                                fs.existsSync(path.join(appPath, "src", "app")) ||
-                                fs.existsSync(path.join(appPath, "pages")) ||
-                                fs.existsSync(path.join(appPath, "src", "pages"))) {
-                                target = appPath;
-                                foundApp = true;
-                                break;
-                            }
+    // Check if we're in a Next.js app
+    if (isNextJsApp(target)) {
+        return target;
+    }
+    // Try parent directory
+    const parent = path.resolve(target, "..");
+    if (isNextJsApp(parent)) {
+        return parent;
+    }
+    // Try common monorepo locations: apps/, packages/, or root
+    const possiblePaths = [
+        path.join(target, "apps"),
+        path.join(parent, "apps"),
+        path.join(target, "packages"),
+        path.join(parent, "packages"),
+    ];
+    for (const possiblePath of possiblePaths) {
+        if (fs.existsSync(possiblePath)) {
+            // Look for Next.js apps in this directory
+            try {
+                const entries = fs.readdirSync(possiblePath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        const appPath = path.join(possiblePath, entry.name);
+                        if (isNextJsApp(appPath)) {
+                            return appPath;
                         }
                     }
-                    if (foundApp)
-                        break;
                 }
             }
+            catch {
+                // Ignore errors reading directory
+            }
         }
     }
+    // Try searching subdirectories (one level deep) in current directory
+    try {
+        const entries = fs.readdirSync(target, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const subPath = path.join(target, entry.name);
+                if (isNextJsApp(subPath)) {
+                    return subPath;
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors reading directory
+    }
     return target;
 }
 
@@ -1436,15 +1451,73 @@ async function addPatch(patchName, targetDir) {
     const hasPagesDir = fs.existsSync(path.join(target, "pages")) || fs.existsSync(path.join(target, "src", "pages"));
     if (!hasAppDir && !hasPagesDir) {
         console.log(chalk$1.yellow("⚠️  Could not auto-detect Next.js app directory."));
+        // Try to find Next.js apps in subdirectories
+        let foundApps = [];
+        try {
+            const entries = fs.readdirSync(target, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const subPath = path.join(target, entry.name);
+                    const hasSubAppDir = fs.existsSync(path.join(subPath, "app")) || fs.existsSync(path.join(subPath, "src", "app"));
+                    const hasSubPagesDir = fs.existsSync(path.join(subPath, "pages")) || fs.existsSync(path.join(subPath, "src", "pages"));
+                    const hasPackageJson = fs.existsSync(path.join(subPath, "package.json"));
+                    if ((hasSubAppDir || hasSubPagesDir) && hasPackageJson) {
+                        foundApps.push(entry.name);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        let defaultPath = target;
+        if (foundApps.length === 1) {
+            defaultPath = path.join(target, foundApps[0]);
+            console.log(chalk$1.green(`💡 Found Next.js app in subdirectory: ${foundApps[0]}`));
+        }
+        else if (foundApps.length > 1) {
+            console.log(chalk$1.cyan(`💡 Found multiple Next.js apps: ${foundApps.join(", ")}`));
+        }
         const { userTarget } = await inquirer$1.prompt([
             {
                 type: "input",
                 name: "userTarget",
                 message: "Enter the path to your Next.js app folder:",
-                default: target,
+                default: defaultPath,
             },
         ]);
-        target = path.resolve(userTarget);
+        // Resolve the path - handle both absolute and relative paths
+        if (path.isAbsolute(userTarget)) {
+            target = userTarget;
+        }
+        else {
+            // If relative, resolve from current working directory
+            target = path.resolve(process.cwd(), userTarget);
+        }
+        // Verify the target exists
+        if (!fs.existsSync(target)) {
+            console.log(chalk$1.red(`❌ Error: Directory does not exist: ${target}`));
+            console.log(chalk$1.yellow(`💡 Tip: Make sure you're in the correct directory or provide the full absolute path.`));
+            console.log(chalk$1.yellow(`   Current directory: ${process.cwd()}`));
+            if (foundApps.length > 0) {
+                console.log(chalk$1.yellow(`   Found Next.js apps in subdirectories: ${foundApps.join(", ")}`));
+            }
+            process.exit(1);
+        }
+        // Verify it's actually a Next.js app
+        const finalHasAppDir = fs.existsSync(path.join(target, "app")) || fs.existsSync(path.join(target, "src", "app"));
+        const finalHasPagesDir = fs.existsSync(path.join(target, "pages")) || fs.existsSync(path.join(target, "src", "pages"));
+        const finalHasPackageJson = fs.existsSync(path.join(target, "package.json"));
+        if (!finalHasAppDir && !finalHasPagesDir) {
+            console.log(chalk$1.red(`❌ Error: ${target} does not appear to be a Next.js app directory.`));
+            console.log(chalk$1.yellow(`   Expected to find: app/, src/app/, pages/, or src/pages/ directory`));
+            process.exit(1);
+        }
+        if (!finalHasPackageJson) {
+            console.log(chalk$1.red(`❌ Error: package.json not found in ${target}.`));
+            console.log(chalk$1.yellow(`   Make sure you're pointing to the root of your Next.js project.`));
+            process.exit(1);
+        }
     }
     // For auth patches, use new setup flow
     if (patchName === "auth" || patchName === "auth-ui") {
@@ -2059,6 +2132,15 @@ function scanProject(target) {
             };
             if (deps.next || deps["next"]) {
                 scan.framework = "nextjs";
+                // Extract Next.js version
+                const nextVersion = deps.next || deps["next"];
+                if (typeof nextVersion === "string") {
+                    // Extract version number (handle ranges like "^16.0.0" or "16.0.0")
+                    const versionMatch = nextVersion.match(/(\d+)\.(\d+)\.(\d+)/);
+                    if (versionMatch) {
+                        scan.nextVersion = versionMatch[0];
+                    }
+                }
             }
             // Detect package manager from lock files
             if (fs.existsSync(path.join(target, "pnpm-lock.yaml"))) {
@@ -2610,7 +2692,22 @@ function generateMiddleware(target, config, scan) {
     if (config.protectedRoutes.length === 0) {
         return null;
     }
-    const middlewarePath = path.join(target, "middleware.ts");
+    // Next.js 16+ uses proxy.ts instead of middleware.ts
+    const isNext16Plus = scan.nextVersion &&
+        (parseInt(scan.nextVersion.split(".")[0]) >= 16);
+    const middlewareFileName = isNext16Plus ? "proxy.ts" : "middleware.ts";
+    const middlewarePath = path.join(target, middlewareFileName);
+    // Also check for the old filename if migrating
+    const oldMiddlewarePath = path.join(target, isNext16Plus ? "middleware.ts" : "proxy.ts");
+    if (fs.existsSync(oldMiddlewarePath) && oldMiddlewarePath !== middlewarePath) {
+        // Remove old middleware file if it exists
+        try {
+            fs.unlinkSync(oldMiddlewarePath);
+        }
+        catch {
+            // Ignore errors
+        }
+    }
     // Check if middleware already exists
     if (fs.existsSync(middlewarePath)) {
         // Try to update existing middleware
@@ -2638,7 +2735,46 @@ function generateMiddleware(target, config, scan) {
     // Add auth pages to matcher so we can redirect authenticated users away
     const authPages = ["/auth/login", "/auth/signup"];
     const allMatcherPatterns = [...matcherPatterns, ...authPages];
-    const middlewareContent = `import { NextRequest, NextResponse } from "next/server";
+    // Next.js 16+ uses proxy.ts with default export
+    const middlewareContent = isNext16Plus
+        ? `import { NextRequest, NextResponse } from "next/server";
+import { getSessionCookie } from "better-auth/cookies";
+
+export default async function handler(request: NextRequest) {
+  const pathname = request.nextUrl.pathname;
+
+  // Check if session cookie exists
+  const sessionCookie = getSessionCookie(request);
+
+  // Handle auth pages (login/signup)
+  if (pathname === "/auth/login" || pathname === "/auth/signup") {
+    // If already authenticated, redirect away from auth pages
+    if (sessionCookie) {
+      const redirectParam = request.nextUrl.searchParams.get("redirect");
+      const redirectTo = redirectParam || "/stackpatch";
+      return NextResponse.redirect(new URL(redirectTo, request.url));
+    }
+    // Not authenticated - allow access to auth pages
+    return NextResponse.next();
+  }
+
+  // Handle protected routes (only protected routes reach here thanks to matcher)
+  if (!sessionCookie) {
+    // Not authenticated - redirect to login with return URL
+    const loginUrl = new URL("/auth/login", request.url);
+    loginUrl.searchParams.set("redirect", pathname);
+    return NextResponse.redirect(loginUrl);
+  }
+
+  // Authenticated and accessing protected route - allow access
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: ${JSON.stringify(allMatcherPatterns)}, // Protected routes + auth pages
+};
+`
+        : `import { NextRequest, NextResponse } from "next/server";
 import { getSessionCookie } from "better-auth/cookies";
 
 export async function middleware(request: NextRequest) {
@@ -3208,7 +3344,10 @@ function showSuccessMessage(target, config, scan) {
     console.log(chalk$1.white(`   - ${libDir}/auth-client.ts`));
     console.log(chalk$1.white(`   - app/api/auth/[...all]/route.ts`));
     if (config.protectedRoutes.length > 0) {
-        console.log(chalk$1.white(`   - middleware.ts`));
+        const middlewareFileName = scan.nextVersion && parseInt(scan.nextVersion.split(".")[0]) >= 16
+            ? "proxy.ts"
+            : "middleware.ts";
+        console.log(chalk$1.white(`   - ${middlewareFileName}`));
     }
     if (config.protectedRoutes.length > 0) {
         console.log(chalk$1.white(`   - ${libDir}/protected-routes.ts`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackpatch",
-  "version": "1.2.6",
+  "version": "1.2.8",
   "description": "Composable frontend features for modern React & Next.js apps - Add authentication, UI components, and more with zero configuration",
   "main": "dist/stackpatch.js",
   "bin": {
@@ -20,6 +20,7 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:cli": "node scripts/test-cli-execution.js",
+    "test:nextjs-version": "node scripts/test-nextjs-version.js",
     "prepublishOnly": "npm run build && node scripts/prepare-publish.js && npm run test:cli",
     "dev": "bun run bin/stackpatch.ts",
     "create": "bun run bin/stackpatch.ts"