@swissjs/swite 0.3.5 → 0.4.2

package/src/dev-engine/middleware/static-files.ts

@@ -26,7 +26,8 @@ export async function setupStaticFiles(
   app: Express,
   config: StaticFilesConfig,
 ): Promise<void> {
-  console.log(chalk.magenta(`[static-files] ⚡ setupStaticFiles called with root: ${config.root}`));
+  const _debug = process.env["SWITE_DEBUG"] === "1";
+  if (_debug) console.log(chalk.magenta(`[static-files] ⚡ setupStaticFiles called with root: ${config.root}`));
   
   // Static file serving - ONLY serve public directory
   // Do NOT serve dist/ folder - it contains old build artifacts with bare imports
@@ -145,11 +146,13 @@ export async function setupStaticFiles(
 
         next();
       });
-      console.log(
-        chalk.gray(
-          `  📦 Serving workspace node_modules from ${workspaceNodeModules}`,
-        ),
-      );
+      if (_debug) {
+        console.log(
+          chalk.gray(
+            `  📦 Serving workspace node_modules from ${workspaceNodeModules}`,
+          ),
+        );
+      }
     } catch {
       // Workspace node_modules doesn't exist, skip
     }
@@ -161,70 +164,94 @@ export async function setupStaticFiles(
   const workspaceRoot =
     workspaceRootForNodeModules || (await findWorkspaceRoot(config.root));
   
-  console.log(
-    chalk.blue(`[static-files] Workspace root: ${workspaceRoot}`),
-  );
-  console.log(
-    chalk.blue(`[static-files] App root: ${config.root}`),
-  );
+  if (_debug) {
+    console.log(
+      chalk.blue(`[static-files] Workspace root: ${workspaceRoot}`),
+    );
+  }
+  if (_debug) {
+    console.log(
+      chalk.blue(`[static-files] App root: ${config.root}`),
+    );
+  }
   
   // Try to serve lib/ directory - check both workspace root and app root parent
   let libPath: string | null = null;
   
-  console.log(
-    chalk.blue(`[static-files] Determining lib/ path... workspaceRoot: ${workspaceRoot}, config.root: ${config.root}`),
-  );
+  if (_debug) {
+    console.log(
+      chalk.blue(`[static-files] Determining lib/ path... workspaceRoot: ${workspaceRoot}, config.root: ${config.root}`),
+    );
+  }
   
   // First, try workspace root
   if (workspaceRoot && workspaceRoot !== config.root) {
     libPath = path.join(workspaceRoot, "lib");
-    console.log(
-      chalk.blue(`[static-files] Trying workspace root lib/: ${libPath}`),
-    );
+    if (_debug) {
+      console.log(
+        chalk.blue(`[static-files] Trying workspace root lib/: ${libPath}`),
+      );
+    }
   } else {
-    console.log(
-      chalk.yellow(`[static-files] Workspace root equals app root, trying parent directories...`),
-    );
+    if (_debug) {
+      console.log(
+        chalk.yellow(`[static-files] Workspace root equals app root, trying parent directories...`),
+      );
+    }
     // If workspace root equals app root, try going up from app root
     const parentDir = path.dirname(config.root);
     const parentLibPath = path.join(parentDir, "lib");
-    console.log(
-      chalk.blue(`[static-files] Trying parent lib/: ${parentLibPath}`),
-    );
+    if (_debug) {
+      console.log(
+        chalk.blue(`[static-files] Trying parent lib/: ${parentLibPath}`),
+      );
+    }
     try {
       await fs.access(parentLibPath);
       libPath = parentLibPath;
-      console.log(
-        chalk.blue(`[static-files] Using parent directory lib/: ${libPath}`),
-      );
+      if (_debug) {
+        console.log(
+          chalk.blue(`[static-files] Using parent directory lib/: ${libPath}`),
+        );
+      }
     } catch (error) {
-      console.log(
-        chalk.yellow(`[static-files] Parent lib/ not found: ${error instanceof Error ? error.message : String(error)}`),
-      );
+      if (_debug) {
+        console.log(
+          chalk.yellow(`[static-files] Parent lib/ not found: ${error instanceof Error ? error.message : String(error)}`),
+        );
+      }
       // Parent lib/ doesn't exist, try grandparent
       const grandparentDir = path.dirname(parentDir);
       const grandparentLibPath = path.join(grandparentDir, "lib");
-      console.log(
-        chalk.blue(`[static-files] Trying grandparent lib/: ${grandparentLibPath}`),
-      );
+      if (_debug) {
+        console.log(
+          chalk.blue(`[static-files] Trying grandparent lib/: ${grandparentLibPath}`),
+        );
+      }
       try {
         await fs.access(grandparentLibPath);
         libPath = grandparentLibPath;
-        console.log(
-          chalk.blue(`[static-files] Using grandparent directory lib/: ${libPath}`),
-        );
+        if (_debug) {
+          console.log(
+            chalk.blue(`[static-files] Using grandparent directory lib/: ${libPath}`),
+          );
+        }
       } catch (error2) {
-        console.log(
-          chalk.yellow(`[static-files] Grandparent lib/ not found: ${error2 instanceof Error ? error2.message : String(error2)}`),
-        );
+        if (_debug) {
+          console.log(
+            chalk.yellow(`[static-files] Grandparent lib/ not found: ${error2 instanceof Error ? error2.message : String(error2)}`),
+          );
+        }
       }
     }
   }
   
   // Serve lib/ directory if found
-  console.log(
-    chalk.blue(`[static-files] Checking for lib/ directory... libPath: ${libPath}`),
-  );
+  if (_debug) {
+    console.log(
+      chalk.blue(`[static-files] Checking for lib/ directory... libPath: ${libPath}`),
+    );
+  }
   
   // ALWAYS try to register /lib/ static serving
   // Calculate the lib path - prefer workspace root, fallback to parent of app root
@@ -239,49 +266,67 @@ export async function setupStaticFiles(
     finalLibPath = path.join(parentDir, "lib");
   }
   
-  console.log(
-    chalk.blue(`[static-files] Final lib path to check: ${finalLibPath}`),
-  );
-  console.log(
-    chalk.blue(`[static-files] workspaceRoot: ${workspaceRoot}, config.root: ${config.root}`),
-  );
+  if (_debug) {
+    console.log(
+      chalk.blue(`[static-files] Final lib path to check: ${finalLibPath}`),
+    );
+  }
+  if (_debug) {
+    console.log(
+      chalk.blue(`[static-files] workspaceRoot: ${workspaceRoot}, config.root: ${config.root}`),
+    );
+  }
   
   // Try to access the directory
   let libPathExists = false;
   try {
     await fs.access(finalLibPath);
     libPathExists = true;
-    console.log(
-      chalk.green(`[static-files] ✅ Found lib/ directory at: ${finalLibPath}`),
-    );
+    if (_debug) {
+      console.log(
+        chalk.green(`[static-files] ✅ Found lib/ directory at: ${finalLibPath}`),
+      );
+    }
     
     // Verify the CSS file exists
     const testCssPath = path.join(finalLibPath, "skltn", "src", "css", "index.css");
     try {
       await fs.access(testCssPath);
-      console.log(
-        chalk.green(`[static-files] ✅ Test CSS file exists: ${testCssPath}`),
-      );
+      if (_debug) {
+        console.log(
+          chalk.green(`[static-files] ✅ Test CSS file exists: ${testCssPath}`),
+        );
+      }
     } catch (error) {
+      if (_debug) {
+        console.error(
+          chalk.yellow(`[static-files] ⚠️  Test CSS file NOT found: ${testCssPath}`),
+        );
+      }
+    }
+  } catch (error) {
+    if (_debug) {
       console.error(
-        chalk.yellow(`[static-files] ⚠️  Test CSS file NOT found: ${testCssPath}`),
+        chalk.red(`[static-files] ❌ lib/ directory not found at: ${finalLibPath}`),
+      );
+    }
+    if (_debug) {
+      console.error(
+        chalk.red(`[static-files] Error: ${error instanceof Error ? error.message : String(error)}`),
+      );
+    }
+    if (_debug) {
+      console.error(
+        chalk.red(`[static-files] ⚠️  /lib middleware will NOT be registered - CSS files will 404!`),
       );
     }
-  } catch (error) {
-    console.error(
-      chalk.red(`[static-files] ❌ lib/ directory not found at: ${finalLibPath}`),
-    );
-    console.error(
-      chalk.red(`[static-files] Error: ${error instanceof Error ? error.message : String(error)}`),
-    );
-    console.error(
-      chalk.red(`[static-files] ⚠️  /lib middleware will NOT be registered - CSS files will 404!`),
-    );
   }
   
   // Register static file middleware ONLY if directory exists
   if (libPathExists) {
-    console.log(chalk.green(`[static-files] ✅ Registering /lib middleware with finalLibPath: ${finalLibPath}`));
+    if (_debug) {
+      console.log(chalk.green(`[static-files] ✅ Registering /lib middleware with finalLibPath: ${finalLibPath}`));
+    }
     
     // CRITICAL: First middleware to block source files BEFORE any express.static can serve them
     // This MUST run before express.static to prevent wrong MIME types
@@ -298,17 +343,21 @@ export async function setupStaticFiles(
         (path.endsWith(".js") && !path.includes("node_modules")) || path.endsWith(".mjs");
       
       if (isSourceFile) {
-        console.log(
-          chalk.red(
-            `[static-files] ⚠️  FIRST BLOCK: Skipping source file: url=${url}, path=${path} - should be handled by module middleware`
-          )
-        );
+        if (_debug) {
+          console.log(
+            chalk.red(
+              `[static-files] ⚠️  FIRST BLOCK: Skipping source file: url=${url}, path=${path} - should be handled by module middleware`
+            )
+          );
+        }
         return next(); // Let module transformation middleware handle it
       }
       
-      console.log(
-        chalk.cyan(`[static-files] Request for /lib${path} (static file)`),
-      );
+      if (_debug) {
+        console.log(
+          chalk.cyan(`[static-files] Request for /lib${path} (static file)`),
+        );
+      }
       next();
     });
     
@@ -324,7 +373,9 @@ export async function setupStaticFiles(
           res.setHeader("Pragma", "no-cache");
           res.setHeader("Expires", "0");
         } catch (error) {
-          console.error(chalk.red(`[static-files] Error setting headers for ${filePath}:`), error);
+          if (_debug) {
+            console.error(chalk.red(`[static-files] Error setting headers for ${filePath}:`), error);
+          }
         }
       },
     });
@@ -344,11 +395,13 @@ export async function setupStaticFiles(
         (path.endsWith(".js") && !path.includes("node_modules")) || path.endsWith(".mjs");
       
       if (isSourceFile) {
-        console.log(
-          chalk.red(
-            `[static-files /lib express.static] ⚠️  BLOCKING source file: url=${url}, path=${path} - should be handled by module transformation middleware`
-          )
-        );
+        if (_debug) {
+          console.log(
+            chalk.red(
+              `[static-files /lib express.static] ⚠️  BLOCKING source file: url=${url}, path=${path} - should be handled by module transformation middleware`
+            )
+          );
+        }
         // CRITICAL: Don't call libStatic - return next() to skip it
         return next(); // Let module transformation middleware handle it
       }
@@ -359,9 +412,11 @@ export async function setupStaticFiles(
     // Source files should be handled by module transformation middleware (registered before this)
     // Only static files (CSS, images) should be served, and they're handled by the custom handler above
     // If a file isn't found, let it 404 rather than serving with wrong MIME type
-    console.log(
-      chalk.gray(`  📦 Serving workspace lib/ from ${finalLibPath}`),
-    );
+    if (_debug) {
+      console.log(
+        chalk.gray(`  📦 Serving workspace lib/ from ${finalLibPath}`),
+      );
+    }
   }
   
   // Continue with other workspace directories if workspaceRoot is different from app root
@@ -372,9 +427,11 @@ export async function setupStaticFiles(
     try {
       await fs.access(librariesPath);
       app.use("/libraries", express.static(librariesPath));
-      console.log(
-        chalk.gray(`  📦 Serving workspace libraries/ from ${librariesPath}`),
-      );
+      if (_debug) {
+        console.log(
+          chalk.gray(`  📦 Serving workspace libraries/ from ${librariesPath}`),
+        );
+      }
     } catch {
       // libraries/ doesn't exist, skip
     }
@@ -404,9 +461,11 @@ export async function setupStaticFiles(
         }
         express.static(modulesPath)(req, res, next);
       });
-      console.log(
-        chalk.gray(`  📦 Serving workspace modules/ from ${modulesPath}`),
-      );
+      if (_debug) {
+        console.log(
+          chalk.gray(`  📦 Serving workspace modules/ from ${modulesPath}`),
+        );
+      }
     } catch {
       // modules/ doesn't exist, skip
     }
@@ -425,7 +484,10 @@ export async function setupSPAFallback(
   app: Express,
   config: StaticFilesConfig,
 ): Promise<void> {
-  console.log(chalk.magenta(`[SWITE] setupSPAFallback loaded - VERSION 3.0.0 (NO HARDCODED CSS)`));
+  const _debug = process.env["SWITE_DEBUG"] === "1";
+  if (_debug) {
+    console.log(chalk.magenta(`[SWITE] setupSPAFallback loaded - VERSION 0.3.5 (NO HARDCODED CSS)`));
+  }
   // Use app.all() to catch ALL HTTP methods, but only for non-source files
   app.all("*", async (req, res, next) => {
     const url = req.url.split("?")[0];
@@ -433,16 +495,11 @@ export async function setupSPAFallback(
     const accept = String(req.headers?.accept || "");
     
     // DEBUG: Verify handler is being called
-    process.stderr.write(`[SPA FALLBACK] Handler called for: ${req.method} ${fullUrl}\n`);
-    console.error(`[SWITE CSS DEBUG] ========== SPA FALLBACK HANDLER START ==========`);
-    console.error(`[SWITE CSS DEBUG] URL: ${url}, Full URL: ${fullUrl}`);
     
     // --- CRITICAL SAFETY CHECK ---
     // NEVER serve HTML for /src/* requests - these are source files that must be handled by middleware
     // Even if middleware fails, we should return 404, not HTML
     if (req.path?.startsWith("/src/") || url.startsWith("/src/")) {
-      console.error(chalk.red(`[SPA FALLBACK] ⚠️  BLOCKED: Attempt to serve HTML for source path: ${req.method} ${fullUrl}`));
-      console.error(chalk.red(`[SPA FALLBACK] This should have been handled by /src middleware! Returning 404.`));
       res.status(404).setHeader("Content-Type", "text/plain");
       res.send(`File not found: ${url}`);
       return;
@@ -452,8 +509,6 @@ export async function setupSPAFallback(
     // NEVER serve HTML for /swiss-packages/* requests - these are SWISS framework packages
     // They should be handled by TS/JS handlers to rewrite imports
     if (req.path?.startsWith("/swiss-packages/") || url.startsWith("/swiss-packages/")) {
-      console.error(chalk.red(`[SPA FALLBACK] ⚠️  BLOCKED: Attempt to serve HTML for SWISS package: ${req.method} ${fullUrl}`));
-      console.error(chalk.red(`[SPA FALLBACK] This should have been handled by module transformation middleware! Returning 404.`));
       res.status(404).setHeader("Content-Type", "text/plain");
       res.send(`File not found: ${url}`);
       return;
@@ -463,21 +518,15 @@ export async function setupSPAFallback(
     // NEVER serve HTML for /lib/* requests - these are workspace library files
     // They should be handled by static file middleware
     if (req.path?.startsWith("/lib/") || url.startsWith("/lib/")) {
-      console.error(chalk.red(`[SPA FALLBACK] ⚠️  BLOCKED: Attempt to serve HTML for /lib/ path: ${req.method} ${fullUrl}`));
-      console.error(chalk.red(`[SPA FALLBACK] This should have been handled by static file middleware! Returning 404.`));
       res.status(404).setHeader("Content-Type", "text/plain");
       res.send(`File not found: ${url}`);
       return;
     }
     
     // Log every request that hits the fallback (for diagnostics)
-    console.log(chalk.gray(`[SPA FALLBACK] Serving HTML for: ${req.method} ${fullUrl}`));
-    process.stderr.write(`[SPA FALLBACK] About to read HTML file...\n`);
     
     // Log if SPA fallback is being hit for .ui files (this should NOT happen after /src check)
     if (url.endsWith(".ui")) {
-      console.error(chalk.red(`[SPA FALLBACK] ⚠️  WARNING: SPA fallback intercepted .ui file: ${fullUrl}`));
-      console.error(chalk.red(`[SPA FALLBACK] This should have been handled by module transformation middleware!`));
     }
     
     // DO NOT serve HTML for source files - they should be handled by handlers
@@ -494,7 +543,6 @@ export async function setupSPAFallback(
     ) {
       // These should have been handled by middleware handlers
       // If we reach here, the file wasn't found, return 404 with proper content type
-      console.error(chalk.red(`[SPA FALLBACK] Returning 404 for ${url} - should have been handled earlier`));
       res.status(404).setHeader("Content-Type", "text/plain");
       res.send(`File not found: ${url}`);
       return;
@@ -548,12 +596,18 @@ export async function setupSPAFallback(
     // This dynamically discovers CSS files from the app's entry point
     // CRITICAL: This MUST run before import map injection
     // IMPORTANT: Only inject CSS files that actually exist in the app's directory
-    console.log(chalk.magenta(`[SWITE CSS] ========== CSS EXTRACTION START (VERSION 3.0.0) ==========`));
-    console.log(chalk.magenta(`[SWITE CSS] App root: ${config.root}`));
+    if (_debug) {
+      console.log(chalk.magenta(`[SWITE CSS] ========== CSS EXTRACTION START (VERSION 0.3.5) ==========`));
+    }
+    if (_debug) {
+      console.log(chalk.magenta(`[SWITE CSS] App root: ${config.root}`));
+    }
     try {
       const entryFile = config.entry ?? "src/index.ui";
       const entryPointPath = path.join(config.root, entryFile);
-      console.log(chalk.blue(`[SWITE CSS] Checking entry point: ${entryPointPath}`));
+      if (_debug) {
+        console.log(chalk.blue(`[SWITE CSS] Checking entry point: ${entryPointPath}`));
+      }
       const entryPointContent = await fs.readFile(entryPointPath, "utf-8");
       
       // Extract CSS imports using regex
@@ -620,10 +674,14 @@ export async function setupSPAFallback(
         }
       }
       
-      console.log(chalk.blue(`[SWITE CSS] Found ${cssImports.size} CSS import(s) in code`));
+      if (_debug) {
+        console.log(chalk.blue(`[SWITE CSS] Found ${cssImports.size} CSS import(s) in code`));
+      }
       if (cssImports.size > 0) {
         const cssArray = Array.from(cssImports);
-        console.log(chalk.blue(`[SWITE CSS] CSS imports found: ${cssArray.join(", ")}`));
+        if (_debug) {
+          console.log(chalk.blue(`[SWITE CSS] CSS imports found: ${cssArray.join(", ")}`));
+        }
         
         // Verify CSS files exist before injecting them
         const existingCssFiles: string[] = [];
@@ -634,22 +692,32 @@ export async function setupSPAFallback(
             ? path.join(config.root, url.substring(1)) // Remove leading /
             : path.join(config.root, "src", cssPath);
           
-          console.log(chalk.blue(`[SWITE CSS] Checking if CSS file exists: ${filePath} (url: ${url})`));
+          if (_debug) {
+            console.log(chalk.blue(`[SWITE CSS] Checking if CSS file exists: ${filePath} (url: ${url})`));
+          }
           try {
             await fs.access(filePath);
-            console.log(chalk.green(`[SWITE CSS] ✅ CSS file exists: ${filePath}`));
+            if (_debug) {
+              console.log(chalk.green(`[SWITE CSS] ✅ CSS file exists: ${filePath}`));
+            }
             existingCssFiles.push(url);
           } catch {
             // CSS file doesn't exist, skip it
             // This allows different apps/websites to have different CSS files
-            console.log(chalk.yellow(`[SWITE CSS] ⚠️  CSS file NOT found: ${filePath}, skipping`));
+            if (_debug) {
+              console.log(chalk.yellow(`[SWITE CSS] ⚠️  CSS file NOT found: ${filePath}, skipping`));
+            }
           }
         }
         
         // Only inject CSS files that actually exist
-        console.log(chalk.blue(`[SWITE CSS] ${existingCssFiles.length} CSS file(s) exist out of ${cssArray.length} found`));
+        if (_debug) {
+          console.log(chalk.blue(`[SWITE CSS] ${existingCssFiles.length} CSS file(s) exist out of ${cssArray.length} found`));
+        }
         if (existingCssFiles.length === 0) {
-          console.log(chalk.yellow(`[SWITE CSS] ⚠️  No CSS files exist, skipping injection`));
+          if (_debug) {
+            console.log(chalk.yellow(`[SWITE CSS] ⚠️  No CSS files exist, skipping injection`));
+          }
         } else if (existingCssFiles.length > 0) {
           const cssLinks = existingCssFiles
             .map(url => `    <link rel="stylesheet" href="${url}">`)
@@ -665,19 +733,27 @@ export async function setupSPAFallback(
             const beforeReplace = html;
             html = html.replace(/\s*<\/head>/i, `${cssLinks}\n  </head>`);
             if (html === beforeReplace) {
-              console.warn(chalk.yellow("[SWITE] Failed to inject CSS links - </head> not found"));
+              if (_debug) {
+                console.warn(chalk.yellow("[SWITE] Failed to inject CSS links - </head> not found"));
+              }
             } else {
-              console.log(chalk.green(`[SWITE] ✅ Injected ${existingCssFiles.length} CSS link(s): ${existingCssFiles.join(", ")}`));
+              if (_debug) {
+                console.log(chalk.green(`[SWITE] ✅ Injected ${existingCssFiles.length} CSS link(s): ${existingCssFiles.join(", ")}`));
+              }
             }
           } else {
-            console.log(chalk.blue(`[SWITE CSS] CSS links already in HTML, skipping injection`));
+            if (_debug) {
+              console.log(chalk.blue(`[SWITE CSS] CSS links already in HTML, skipping injection`));
+            }
           }
         }
       }
     } catch (error) {
       // If entry point doesn't exist or can't be read, continue without CSS injection
       // Silently continue - CSS injection is optional
-      console.log(chalk.yellow(`[SWITE CSS] Could not extract CSS imports: ${error instanceof Error ? error.message : String(error)}`));
+      if (_debug) {
+        console.log(chalk.yellow(`[SWITE CSS] Could not extract CSS imports: ${error instanceof Error ? error.message : String(error)}`));
+      }
     }
 
     // Add/merge import map to help browser resolve bare module specifiers.
@@ -701,13 +777,19 @@ export async function setupSPAFallback(
       const beforeReplace = html;
       html = html.replace(/\s*<\/head>/i, `${importMap}\n  </head>`);
       if (html === beforeReplace) {
-        console.warn("[SWITE] Failed to add import map - </head> not found or already replaced");
+        if (_debug) {
+          console.warn("[SWITE] Failed to add import map - </head> not found or already replaced");
+        }
       } else {
-        console.log(`[SWITE] Added import map with ${Object.keys(switeImports).length} entries`);
+        if (_debug) {
+          console.log(`[SWITE] Added import map with ${Object.keys(switeImports).length} entries`);
+        }
       }
     } else {
       // Importmap already in HTML — merge swite entries without overwriting existing ones
-      console.log("[SWITE] Import map already exists in HTML — merging swite entries");
+      if (_debug) {
+        console.log("[SWITE] Import map already exists in HTML — merging swite entries");
+      }
       if (Object.keys(switeImports).length > 0) {
         html = html.replace(
           /(<script\s+type=["']importmap["'][^>]*>)\s*([\s\S]*?)(\s*<\/script>)/i,

package/src/dev-engine/pythonDevManager.ts

@@ -5,7 +5,7 @@ import { initPythonProxy } from "../adapters/proxy/proxyToPython.js";
 import type { PythonServiceConfig } from "../config/config.js";
 
 const POLL_INTERVAL_MS = 500;
-const HEALTH_TIMEOUT_MS = 15_000;
+const HEALTH_TIMEOUT_MS = 30_000;
 const BACKOFF_THRESHOLD = 5;
 
 let _child: ChildProcess | null = null;

package/src/dev-engine/router/file-router.ts

@@ -11,7 +11,6 @@ import type { RouteDefinition } from "@swissjs/core";
 import { RouteScanner } from "@swissjs/plugin-file-router/core";
 import { createFileWatcher } from "@swissjs/plugin-file-router/dev";
 import { HMREngine } from "../hmr/hmr.js";
-import { findWorkspaceRoot } from "../../kernel/workspace.js";
 
 export interface FileRouterConfig {
   root: string;
@@ -38,7 +37,6 @@ export async function setupFileRouter(
   };
 
   try {
-    const workspaceRoot = await findWorkspaceRoot(config.root);
     const appRoot = config.root;
 
     // Initialize route scanner
@@ -49,59 +47,18 @@ export async function setupFileRouter(
       lazyLoading: true,
     });
 
-          // Scan routes from multiple locations:
-          // 1. App's pages directory (apps/alpine/src/pages)
-          // 2. SKLTN's pages directory (framework/skltn/src/pages) - for reusable auth pages
     const routesToScan: string[] = [];
 
-    // App pages
+    // App pages directory
     const appPagesDir = path.join(appRoot, "src", "pages");
     try {
       await fs.access(appPagesDir);
       routesToScan.push(appPagesDir);
-      console.log(chalk.gray(`  📄 Scanning app routes from ${appPagesDir}`));
+      console.log(chalk.gray(`  Scanning app routes from ${appPagesDir}`));
     } catch {
       // pages directory doesn't exist, skip
     }
 
-    // SKLTN pages (if workspace root exists)
-    if (workspaceRoot && workspaceRoot !== appRoot) {
-      // Try framework/skltn first (new location), then fallback to lib/skltn (legacy)
-      const skltnPagesDir = path.join(
-        workspaceRoot,
-        "framework",
-        "skltn",
-        "src",
-        "pages",
-      );
-      const legacySkltnPagesDir = path.join(
-        workspaceRoot,
-        "lib",
-        "skltn",
-        "src",
-        "pages",
-      );
-      
-      try {
-        await fs.access(skltnPagesDir);
-        routesToScan.push(skltnPagesDir);
-        console.log(
-          chalk.gray(`  📄 Scanning SKLTN routes from ${skltnPagesDir}`),
-        );
-      } catch {
-        // Try legacy location
-        try {
-          await fs.access(legacySkltnPagesDir);
-          routesToScan.push(legacySkltnPagesDir);
-          console.log(
-            chalk.gray(`  📄 Scanning SKLTN routes from ${legacySkltnPagesDir} (legacy)`),
-          );
-        } catch {
-          // pages directory doesn't exist, skip
-        }
-      }
-    }
-
     // Scan all route directories
     for (const pagesDir of routesToScan) {
       try {