miolo 3.0.0-beta.147 → 3.0.0-beta.149

package/bin/create/auth.mjs

@@ -0,0 +1,24 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Updates server/miolo/index.mjs with correct auth import
+ */
+export function updateServerIndex(destPath, authMethod) {
+  const serverIndexPath = path.join(destPath, 'src/server/miolo/index.mjs')
+  
+  if (!fs.existsSync(serverIndexPath)) {
+    console.warn('[miolo] Warning: server/miolo/index.mjs not found, skipping auth import update')
+    return
+  }
+
+  let content = fs.readFileSync(serverIndexPath, 'utf8')
+  
+  // Replace the auth import line
+  content = content.replace(
+    /import auth from ['"]\.\/auth\/.*?['"]/,
+    `import auth from './auth/${authMethod}.mjs'`
+  )
+  
+  fs.writeFileSync(serverIndexPath, content, 'utf8')
+}

package/bin/create/copy.mjs

@@ -0,0 +1,156 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { transformPackageJson } from './pkgjson.mjs'
+
+// Text file extensions to transform
+const TEXT_EXTENSIONS = [
+  '.js', '.jsx', '.mjs', '.ts', '.tsx',
+  '.json', '.env', '.md', '.html',
+  '.css', '.scss', '.sass',
+  '.yml', '.yaml', '.toml',
+  '.txt', '.gitignore', '.editorconfig'
+]
+
+// Files and directories to exclude from copying
+const EXCLUDE_PATTERNS = [
+  'node_modules',
+  'dist',
+  'build',
+  '.git'
+]
+
+/**
+ * Checks if a file is a text file based on extension
+ */
+export function isTextFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase()
+  return TEXT_EXTENSIONS.includes(ext) || path.basename(filePath).startsWith('.')
+}
+
+/**
+ * Checks if a path should be excluded
+ */
+export function shouldExclude(itemPath) {
+  const basename = path.basename(itemPath)
+  return EXCLUDE_PATTERNS.some(pattern => basename === pattern)
+}
+
+/**
+ * Replaces all occurrences of miolo-sample with the new app name
+ */
+export function transformContent(content, appName) {
+  return content.replace(/miolo-sample/g, appName)
+}
+
+/**
+ * Copies a directory recursively with transformations
+ */
+export function copyDirectory(src, dest, appName, options = {}) {
+  const { authMethod } = options
+
+  // Create destination if it doesn't exist
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true })
+  }
+
+  const items = fs.readdirSync(src)
+
+  for (const item of items) {
+    const srcPath = path.join(src, item)
+    const destPath = path.join(dest, item)
+    const stat = fs.statSync(srcPath)
+
+    // Skip excluded items
+    if (shouldExclude(srcPath)) {
+      continue
+    }
+
+    if (stat.isDirectory()) {
+      // Special handling for auth directory
+      if (srcPath.endsWith('src/server/miolo/auth')) {
+        // Create auth directory
+        fs.mkdirSync(destPath, { recursive: true })
+        
+        // Copy only the selected auth file
+        const authFile = `${authMethod}.mjs`
+        const srcAuthFile = path.join(srcPath, authFile)
+        const destAuthFile = path.join(destPath, authFile)
+        
+        if (fs.existsSync(srcAuthFile)) {
+          let content = fs.readFileSync(srcAuthFile, 'utf8')
+          content = transformContent(content, appName)
+          fs.writeFileSync(destAuthFile, content, 'utf8')
+        } else {
+          console.warn(`[miolo] Warning: Auth file ${authFile} not found, skipping`)
+        }
+        continue
+      }
+
+      // Recursively copy directories
+      copyDirectory(srcPath, destPath, appName, options)
+    } else {
+      // Copy and transform files
+      if (isTextFile(srcPath)) {
+        let content = fs.readFileSync(srcPath, 'utf8')
+        
+        // Special handling for package.json to also replace versions
+        if (srcPath.endsWith('package.json')) {
+          content = transformPackageJson(content, appName)
+        } else {
+          content = transformContent(content, appName)
+        }
+        
+        fs.writeFileSync(destPath, content, 'utf8')
+      } else {
+        // Binary files - just copy
+        fs.copyFileSync(srcPath, destPath)
+      }
+    }
+  }
+}
+
+/**
+ * Copies only root-level files and specified directories
+ */
+export function copyTemplate(sourcePath, destPath, appName, options = {}) {
+  // Create destination directory
+  if (!fs.existsSync(destPath)) {
+    fs.mkdirSync(destPath, { recursive: true })
+  }
+
+  // Copy root-level files
+  const items = fs.readdirSync(sourcePath)
+  
+  for (const item of items) {
+    const srcPath = path.join(sourcePath, item)
+    const destItemPath = path.join(destPath, item)
+    const stat = fs.statSync(srcPath)
+
+    if (shouldExclude(srcPath)) {
+      continue
+    }
+
+    if (stat.isFile()) {
+      // Copy root-level files
+      if (isTextFile(srcPath)) {
+        let content = fs.readFileSync(srcPath, 'utf8')
+        
+        // Special handling for package.json to also replace versions
+        if (srcPath.endsWith('package.json')) {
+          content = transformPackageJson(content, appName)
+        } else {
+          content = transformContent(content, appName)
+        }
+        
+        fs.writeFileSync(destItemPath, content, 'utf8')
+      } else {
+        fs.copyFileSync(srcPath, destItemPath)
+      }
+    } else if (stat.isDirectory()) {
+      // Only copy src/ and docker/ directories
+      if (item === 'src' || item === 'docker') {
+        copyDirectory(srcPath, destItemPath, appName, options)
+      }
+    }
+  }
+}

package/bin/create/docker.mjs

@@ -0,0 +1,25 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Updates docker-compose.yaml and Dockerfile with custom port
+ */
+export function updateDockerFiles(destPath, port) {
+  // Update docker-compose.yaml
+  const dockerComposePath = path.join(destPath, 'docker/docker-compose.yaml')
+  if (fs.existsSync(dockerComposePath)) {
+    let content = fs.readFileSync(dockerComposePath, 'utf8')
+    // Replace port mapping (e.g., "8001:8001" -> "9000:9000")
+    content = content.replace(/- "\d+:\d+"/g, `- "${port}:${port}"`)
+    fs.writeFileSync(dockerComposePath, content, 'utf8')
+  }
+
+  // Update Dockerfile
+  const dockerfilePath = path.join(destPath, 'docker/Dockerfile')
+  if (fs.existsSync(dockerfilePath)) {
+    let content = fs.readFileSync(dockerfilePath, 'utf8')
+    // Replace EXPOSE port
+    content = content.replace(/EXPOSE \d+/, `EXPOSE ${port}`)
+    fs.writeFileSync(dockerfilePath, content, 'utf8')
+  }
+}

package/bin/create/index.mjs

@@ -0,0 +1,112 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { execSync } from 'node:child_process'
+
+// Import modular functions
+import { validateAppName, validateAuthMethod } from './validation.mjs'
+import { updateEnvFile } from './pkgjson.mjs'
+import { updateDockerFiles } from './docker.mjs'
+import { updateServerIndex } from './auth.mjs'
+import { copyTemplate } from './copy.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * Main create function
+ */
+export default async function create(appName, options = {}) {
+  try {
+    console.log('[miolo] Creating new miolo app:', appName)
+
+    // Validate app name
+    validateAppName(appName)
+
+    // Parse options
+    const { 
+      port, 
+      auth: authMethod = 'credentials',
+      dest = `./${appName}`
+    } = options
+
+    // Validate auth method
+    validateAuthMethod(authMethod)
+
+    // Get source path (template or miolo-sample for development)
+    // In development (monorepo), use miolo-sample directly
+    // In production (npm package), use bundled template folder
+    let sourcePath = path.resolve(__dirname, '../../../miolo-sample')
+    if (!fs.existsSync(sourcePath)) {
+      // Fallback to template folder (npm package)
+      sourcePath = path.resolve(__dirname, '../../template')
+    }
+    const destPath = path.resolve(process.cwd(), dest)
+
+    // Check if source exists
+    if (!fs.existsSync(sourcePath)) {
+      throw new Error(`Source template not found: ${sourcePath}`)
+    }
+
+    // Check if destination already exists and has content
+    if (fs.existsSync(destPath)) {
+      // Allow if destination is current directory (.) or an empty directory
+      const isCwd = path.resolve(destPath) === process.cwd()
+      if (!isCwd) {
+        const items = fs.readdirSync(destPath)
+        // Filter out hidden files/dirs that are safe to ignore
+        const significantItems = items.filter(item => 
+          !item.startsWith('.') && item !== 'node_modules'
+        )
+        if (significantItems.length > 0) {
+          throw new Error(`Destination already exists and is not empty: ${destPath}`)
+        }
+      }
+    }
+
+    console.log('[miolo] Copying template from:', sourcePath)
+    console.log('[miolo] Creating app at:', destPath)
+    console.log('[miolo] Auth method:', authMethod)
+    if (port) {
+      console.log('[miolo] Port:', port)
+    }
+
+    // Copy template files
+    copyTemplate(sourcePath, destPath, appName, { authMethod })
+
+    console.log('[miolo] Template copied successfully')
+
+    // Update .env with custom parameters
+    updateEnvFile(destPath, appName, { port })
+
+    // Update docker files with custom port
+    if (port) {
+      updateDockerFiles(destPath, port)
+    }
+
+    // Update server/miolo/index.mjs with correct auth import
+    updateServerIndex(destPath, authMethod)
+
+    // Install dependencies
+    console.log('[miolo] Installing dependencies...')
+    try {
+      execSync('npm install', { 
+        cwd: destPath,
+        stdio: 'inherit'
+      })
+      console.log('[miolo] Dependencies installed successfully')
+    } catch (_error) {
+      console.warn('[miolo] Warning: Failed to install dependencies automatically')
+      console.warn('[miolo] Please run "npm install" manually in the project directory')
+    }
+
+    console.log('[miolo] ✅ App created successfully!')
+    console.log('[miolo] To get started:')
+    console.log(`  cd ${dest}`)
+    console.log('  npm run dev')
+
+  } catch (error) {
+    console.error('[miolo] Error creating app:', error.message)
+    throw error
+  }
+}

package/bin/create/pkgjson.mjs

@@ -0,0 +1,69 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+/**
+ * Get miolo version from package.json
+ */
+export function getMioloVersion() {
+  try {
+    const mioloPackageJsonPath = path.resolve(__dirname, '../../package.json')
+    const mioloPackageJson = JSON.parse(fs.readFileSync(mioloPackageJsonPath, 'utf8'))
+    return `^${mioloPackageJson.version}`
+  } catch (_error) {
+    console.warn('[miolo] Warning: Could not read miolo version, using latest')
+    return '^3.0.0'
+  }
+}
+
+/**
+ * Transforms package.json content by replacing app name and file:../ references
+ */
+export function transformPackageJson(content, appName) {
+  // First, replace app name
+  let transformed = content.replace(/miolo-sample/g, appName)
+  
+  // Then, replace file:../ references with npm versions
+  const version = getMioloVersion()
+  transformed = transformed.replace(/"file:\.\.\/(miolo-cli|miolo-react|miolo)"/g, `"${version}"`)
+  
+  return transformed
+}
+
+/**
+ * Updates the .env and .env.production files with custom parameters
+ */
+export function updateEnvFile(destPath, appName, options = {}) {
+  const { port } = options
+  
+  // Update .env
+  const envPath = path.join(destPath, '.env')
+  if (fs.existsSync(envPath)) {
+    let content = fs.readFileSync(envPath, 'utf8')
+    
+    // Update port if specified
+    if (port) {
+      content = content.replace(/MIOLO_PORT=\d+/, `MIOLO_PORT=${port}`)
+    }
+    
+    fs.writeFileSync(envPath, content, 'utf8')
+  } else {
+    console.warn('[miolo] Warning: .env file not found')
+  }
+
+  // Update .env.production
+  const envProdPath = path.join(destPath, '.env.production')
+  if (fs.existsSync(envProdPath)) {
+    let content = fs.readFileSync(envProdPath, 'utf8')
+    
+    // Update port if specified
+    if (port) {
+      content = content.replace(/MIOLO_PORT=\d+/, `MIOLO_PORT=${port}`)
+    }
+    
+    fs.writeFileSync(envProdPath, content, 'utf8')
+  }
+}

package/bin/create/prepare-template.mjs

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import fs from 'fs'
+import path from 'path'
+import {fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+console.log('[prepare-template] Starting template preparation...')
+
+// Paths
+const mioloSamplePath = path.resolve(__dirname, '../../../miolo-sample')
+const templatePath = path.resolve(__dirname, '../../template')
+const mioloPackageJsonPath = path.resolve(__dirname, '../../package.json')
+
+// Read miolo version
+const mioloPackageJson = JSON.parse(fs.readFileSync(mioloPackageJsonPath, 'utf8'))
+const version = `^${mioloPackageJson.version}`
+
+console.log(`[prepare-template] Using version: ${version}`)
+
+// Step 1: Remove existing template directory
+if (fs.existsSync(templatePath)) {
+  console.log('[prepare-template] Removing existing template directory...')
+  fs.rmSync(templatePath, { recursive: true, force: true })
+}
+
+// Step 2: Create template directory
+console.log('[prepare-template] Creating template directory...')
+fs.mkdirSync(templatePath, { recursive: true })
+
+// Step 3: Copy files from miolo-sample to template
+console.log('[prepare-template] Copying files from miolo-sample...')
+
+// Files to copy
+const filesToCopy = [
+  '.env',
+  '.env.production',
+  '.editorconfig',
+  '.gitignore',
+  'components.json',
+  'jsconfig.json',
+  'package.json',
+  'eslint.config.js',
+  'postcss.config.js',
+  'vite.config.mjs'
+]
+
+// Copy individual files
+for (const file of filesToCopy) {
+  const srcFile = path.join(mioloSamplePath, file)
+  const destFile = path.join(templatePath, file)
+  
+  if (fs.existsSync(srcFile)) {
+    fs.copyFileSync(srcFile, destFile)
+    console.log(`[prepare-template]   ✓ Copied ${file}`)
+  } else {
+    console.warn(`[prepare-template]   ⚠ File not found: ${file}`)
+  }
+}
+
+// Copy directories
+const dirsToCopy = ['src', 'docker']
+
+for (const dir of dirsToCopy) {
+  const srcDir = path.join(mioloSamplePath, dir)
+  const destDir = path.join(templatePath, dir)
+  
+  if (fs.existsSync(srcDir)) {
+    copyDirRecursive(srcDir, destDir)
+    console.log(`[prepare-template]   ✓ Copied ${dir}/`)
+  } else {
+    console.warn(`[prepare-template]   ⚠ Directory not found: ${dir}`)
+  }
+}
+
+// Step 4: Update package.json versions
+console.log('[prepare-template] Updating package.json versions...')
+const templatePackageJsonPath = path.join(templatePath, 'package.json')
+const templatePackageJson = JSON.parse(fs.readFileSync(templatePackageJsonPath, 'utf8'))
+
+const replacements = {
+  'file:../miolo': version,
+  'file:../miolo-cli': version,
+  'file:../miolo-react': version
+}
+
+let modified = false
+
+// Update dependencies
+if (templatePackageJson.dependencies) {
+  for (const [pkg, currentVersion] of Object.entries(templatePackageJson.dependencies)) {
+    if (replacements[currentVersion]) {
+      console.log(`[prepare-template]   ${pkg}: ${currentVersion} → ${replacements[currentVersion]}`)
+      templatePackageJson.dependencies[pkg] = replacements[currentVersion]
+      modified = true
+    }
+  }
+}
+
+// Update devDependencies
+if (templatePackageJson.devDependencies) {
+  for (const [pkg, currentVersion] of Object.entries(templatePackageJson.devDependencies)) {
+    if (replacements[currentVersion]) {
+      console.log(`[prepare-template]   ${pkg}: ${currentVersion} → ${replacements[currentVersion]}`)
+      templatePackageJson.devDependencies[pkg] = replacements[currentVersion]
+      modified = true
+    }
+  }
+}
+
+if (modified) {
+  fs.writeFileSync(
+    templatePackageJsonPath,
+    JSON.stringify(templatePackageJson, null, 2) + '\n',
+    'utf8'
+  )
+  console.log('[prepare-template] ✅ Template package.json updated')
+} else {
+  console.log('[prepare-template] No file:../ references found to replace')
+}
+
+console.log('[prepare-template] ✅ Template synchronized from miolo-sample')
+
+// Helper function to copy directories recursively
+function copyDirRecursive(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true })
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath)
+    } else {
+      fs.copyFileSync(srcPath, destPath)
+    }
+  }
+}

package/bin/create/validation.mjs

@@ -0,0 +1,27 @@
+/**
+ * Validation helper functions for create command
+ */
+
+/**
+ * Validates app name (alphanumeric + hyphens/underscores)
+ */
+export function validateAppName(name) {
+  if (!name) {
+    throw new Error('App name is required')
+  }
+  if (!/^[a-z0-9-_]+$/i.test(name)) {
+    throw new Error('App name must contain only alphanumeric characters, hyphens, and underscores')
+  }
+  return true
+}
+
+/**
+ * Validates auth method
+ */
+export function validateAuthMethod(authMethod) {
+  const validAuthMethods = ['credentials', 'basic', 'guest']
+  if (!validAuthMethods.includes(authMethod)) {
+    throw new Error(`Invalid auth method: ${authMethod}. Valid options: ${validAuthMethods.join(', ')}`)
+  }
+  return true
+}

package/bin/index.mjs

@@ -18,7 +18,7 @@ async function main() {
         dest: args.d || args.dest  // Support both --d and --dest
       }
       
-      const createAppHandler = (await import ('./create/create.mjs')).default
+      const createAppHandler = (await import ('./create/index.mjs')).default
       await createAppHandler(createAppName, createOptions)
       return
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo",
-  "version": "3.0.0-beta.147",
+  "version": "3.0.0-beta.149",
   "description": "all-in-one koa-based server",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [
@@ -38,9 +38,8 @@
     "reset": "rm -fr package-lock.json npm-lock.yaml dist/* && npm i",
     "clean": "rm -fr ./dist/*",
     "bundle": "npx xeira bundle --target=node --source_index=./src/index.mjs --bundle_folder=./dist --bundle_name=miolo --bundle_extension=node.mjs",
-    "dist": "npm run clean && npm run bundle",
-    "prepare-template": "rm -rf template && mkdir -p template && cp -r ../miolo-sample/.env ../miolo-sample/.env.production ../miolo-sample/.editorconfig ../miolo-sample/.gitignore ../miolo-sample/*.json ../miolo-sample/src ../miolo-sample/docker template/ && echo 'Template synchronized from miolo-sample'",
-    "prepublishOnly": "npm run prepare-template"
+    "prepare-template": "node bin/create/prepare-template.mjs",
+    "dist": "npm run clean && npm run bundle && npm run prepare-template"
   },
   "dependencies": {
     "@babel/plugin-proposal-decorators": "^7.29.0",

package/template/eslint.config.js

@@ -0,0 +1,25 @@
+import {eslintConfig} from 'xeira'
+
+
+export default [
+  // Extiende la configuración base de xeira
+  ...eslintConfig,
+  
+  // Opcional: añade reglas o configuraciones específicas para este proyecto
+  {
+    files: ['src/**/*.mjs', 'src/**/*.jsx'],
+    rules: {
+      'react/display-name': 0,
+      'no-unused-vars': [
+        "warn", // or "error"
+        {
+          "argsIgnorePattern": "^_",
+          "varsIgnorePattern": "^_",
+          "caughtErrorsIgnorePattern": "^_"
+        }
+      ],      
+      // React 19 seems to not need this, but it is required by our build approach
+      'react/react-in-jsx-scope': 'error',
+    },
+  },
+];

package/template/package.json

@@ -43,9 +43,10 @@
     "clsx": "^2.1.1",
     "farrapa": "^3.0.0-beta.3",
     "intre": "^3.0.0-beta.3",
+    "joi": "^18.0.2",
     "lucide-react": "^0.563.0",
-    "miolo-cli": "file:../miolo-cli",
-    "miolo-react": "file:../miolo-react",
+    "miolo-cli": "^3.0.0-beta.149",
+    "miolo-react": "^3.0.0-beta.149",
     "next-themes": "^0.4.6",
     "radix-ui": "^1.4.3",
     "react": "^19.2.4",
@@ -59,7 +60,7 @@
     "tw-animate-css": "^1.4.0"
   },
   "devDependencies": {
-    "miolo": "file:../miolo",
+    "miolo": "^3.0.0-beta.149",
     "sass-embedded": "^1.97.3",
     "xeira": "^2.0.0-beta.10"
   },

package/template/postcss.config.js

@@ -0,0 +1,9 @@
+import tailwindcss from '@tailwindcss/postcss'
+import autoprefixer from 'autoprefixer'
+
+export default {
+  plugins: [
+    tailwindcss,
+    autoprefixer,
+  ],
+}

package/bin/create/create.mjs

@@ -1,340 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { execSync } from 'node:child_process'
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-// Text file extensions to transform
-const TEXT_EXTENSIONS = [
-  '.js', '.jsx', '.mjs', '.ts', '.tsx',
-  '.json', '.env', '.md', '.html',
-  '.css', '.scss', '.sass',
-  '.yml', '.yaml', '.toml',
-  '.txt', '.gitignore', '.editorconfig'
-]
-
-// Files and directories to exclude from copying
-const EXCLUDE_PATTERNS = [
-  'node_modules',
-  'dist',
-  'build',
-  '.git'
-]
-
-/**
- * Validates app name (alphanumeric + hyphens/underscores)
- */
-function validateAppName(name) {
-  if (!name) {
-    throw new Error('App name is required')
-  }
-  if (!/^[a-z0-9-_]+$/i.test(name)) {
-    throw new Error('App name must contain only alphanumeric characters, hyphens, and underscores')
-  }
-  return true
-}
-
-/**
- * Checks if a file is a text file based on extension
- */
-function isTextFile(filePath) {
-  const ext = path.extname(filePath).toLowerCase()
-  return TEXT_EXTENSIONS.includes(ext) || path.basename(filePath).startsWith('.')
-}
-
-/**
- * Checks if a path should be excluded
- */
-function shouldExclude(itemPath) {
-  const basename = path.basename(itemPath)
-  return EXCLUDE_PATTERNS.some(pattern => basename === pattern)
-}
-
-/**
- * Replaces all occurrences of miolo-sample with the new app name
- */
-function transformContent(content, appName) {
-  return content.replace(/miolo-sample/g, appName)
-}
-
-/**
- * Copies a directory recursively with transformations
- */
-function copyDirectory(src, dest, appName, options = {}) {
-  const { authMethod = 'credentials' } = options
-
-  // Create destination directory
-  if (!fs.existsSync(dest)) {
-    fs.mkdirSync(dest, { recursive: true })
-  }
-
-  const items = fs.readdirSync(src)
-
-  for (const item of items) {
-    const srcPath = path.join(src, item)
-    const destPath = path.join(dest, item)
-    const stat = fs.statSync(srcPath)
-
-    // Skip excluded items
-    if (shouldExclude(srcPath)) {
-      continue
-    }
-
-    if (stat.isDirectory()) {
-      // Special handling for auth directory
-      if (srcPath.endsWith('src/server/miolo/auth')) {
-        // Create auth directory
-        fs.mkdirSync(destPath, { recursive: true })
-        
-        // Copy only the selected auth file
-        const authFile = `${authMethod}.mjs`
-        const srcAuthFile = path.join(srcPath, authFile)
-        const destAuthFile = path.join(destPath, authFile)
-        
-        if (fs.existsSync(srcAuthFile)) {
-          let content = fs.readFileSync(srcAuthFile, 'utf8')
-          content = transformContent(content, appName)
-          fs.writeFileSync(destAuthFile, content, 'utf8')
-        } else {
-          console.warn(`[miolo] Warning: Auth file ${authFile} not found, skipping`)
-        }
-        continue
-      }
-
-      // Recursively copy directories
-      copyDirectory(srcPath, destPath, appName, options)
-    } else {
-      // Copy and transform files
-      if (isTextFile(srcPath)) {
-        let content = fs.readFileSync(srcPath, 'utf8')
-        content = transformContent(content, appName)
-        fs.writeFileSync(destPath, content, 'utf8')
-      } else {
-        // Binary files - just copy
-        fs.copyFileSync(srcPath, destPath)
-      }
-    }
-  }
-}
-
-/**
- * Updates the .env file with custom parameters
- */
-function updateEnvFile(destPath, appName, options = {}) {
-  const { port } = options
-  
-  // Update .env
-  const envPath = path.join(destPath, '.env')
-  if (fs.existsSync(envPath)) {
-    let content = fs.readFileSync(envPath, 'utf8')
-    
-    // Update port if specified
-    if (port) {
-      content = content.replace(/MIOLO_PORT=\d+/, `MIOLO_PORT=${port}`)
-    }
-    
-    fs.writeFileSync(envPath, content, 'utf8')
-  } else {
-    console.warn('[miolo] Warning: .env file not found')
-  }
-
-  // Update .env.production
-  const envProdPath = path.join(destPath, '.env.production')
-  if (fs.existsSync(envProdPath)) {
-    let content = fs.readFileSync(envProdPath, 'utf8')
-    
-    // Update port if specified
-    if (port) {
-      content = content.replace(/MIOLO_PORT=\d+/, `MIOLO_PORT=${port}`)
-    }
-    
-    fs.writeFileSync(envProdPath, content, 'utf8')
-  }
-}
-
-/**
- * Updates server/miolo/index.mjs to import the correct auth method
- */
-function updateServerIndex(destPath, authMethod) {
-  const indexPath = path.join(destPath, 'src/server/miolo/index.mjs')
-
-  if (!fs.existsSync(indexPath)) {
-    console.warn('[miolo] Warning: src/server/miolo/index.mjs not found')
-    return
-  }
-
-  let content = fs.readFileSync(indexPath, 'utf8')
-
-  // Replace the auth import
-  content = content.replace(
-    /import auth from ['"]\.\/auth\/\w+\.mjs['"]/,
-    `import auth from './auth/${authMethod}.mjs'`
-  )
-
-  fs.writeFileSync(indexPath, content, 'utf8')
-}
-
-/**
- * Updates docker files with custom port
- */
-function updateDockerFiles(destPath, port) {
-  // Update docker-compose.yaml
-  const dockerComposePath = path.join(destPath, 'docker/docker-compose.yaml')
-  if (fs.existsSync(dockerComposePath)) {
-    let content = fs.readFileSync(dockerComposePath, 'utf8')
-    // Replace port mapping (e.g., "8001:8001" -> "9000:9000")
-    content = content.replace(/- "\d+:\d+"/, `- "${port}:${port}"`)
-    fs.writeFileSync(dockerComposePath, content, 'utf8')
-  }
-
-  // Update Dockerfile
-  const dockerfilePath = path.join(destPath, 'docker/Dockerfile')
-  if (fs.existsSync(dockerfilePath)) {
-    let content = fs.readFileSync(dockerfilePath, 'utf8')
-    // Replace EXPOSE port
-    content = content.replace(/EXPOSE \d+/, `EXPOSE ${port}`)
-    fs.writeFileSync(dockerfilePath, content, 'utf8')
-  }
-}
-
-/**
- * Copies only root-level files and specified directories
- */
-function copyTemplate(sourcePath, destPath, appName, options = {}) {
-  // Create destination directory
-  if (!fs.existsSync(destPath)) {
-    fs.mkdirSync(destPath, { recursive: true })
-  }
-
-  // Copy root-level files
-  const items = fs.readdirSync(sourcePath)
-  
-  for (const item of items) {
-    const srcPath = path.join(sourcePath, item)
-    const destItemPath = path.join(destPath, item)
-    const stat = fs.statSync(srcPath)
-
-    if (shouldExclude(srcPath)) {
-      continue
-    }
-
-    if (stat.isFile()) {
-      // Copy root-level files
-      if (isTextFile(srcPath)) {
-        let content = fs.readFileSync(srcPath, 'utf8')
-        content = transformContent(content, appName)
-        fs.writeFileSync(destItemPath, content, 'utf8')
-      } else {
-        fs.copyFileSync(srcPath, destItemPath)
-      }
-    } else if (stat.isDirectory()) {
-      // Only copy src/ and docker/ directories
-      if (item === 'src' || item === 'docker') {
-        copyDirectory(srcPath, destItemPath, appName, options)
-      }
-    }
-  }
-}
-
-/**
- * Main create function
- */
-export default async function create(appName, options = {}) {
-  try {
-    console.log('[miolo] Creating new miolo app:', appName)
-
-    // Validate app name
-    validateAppName(appName)
-
-    // Parse options
-    const { 
-      port, 
-      auth: authMethod = 'credentials',
-      dest = `./${appName}`
-    } = options
-
-    // Validate auth method
-    const validAuthMethods = ['credentials', 'basic', 'guest']
-    if (!validAuthMethods.includes(authMethod)) {
-      throw new Error(`Invalid auth method: ${authMethod}. Valid options: ${validAuthMethods.join(', ')}`)
-    }
-
-    // Get source path (template or miolo-sample for development)
-    // In development (monorepo), use miolo-sample directly
-    // In production (npm package), use bundled template folder
-    let sourcePath = path.resolve(__dirname, '../../../miolo-sample')
-    if (!fs.existsSync(sourcePath)) {
-      // Fallback to template folder (npm package)
-      sourcePath = path.resolve(__dirname, '../../template')
-    }
-    const destPath = path.resolve(process.cwd(), dest)
-
-    // Check if source exists
-    if (!fs.existsSync(sourcePath)) {
-      throw new Error(`Source template not found: ${sourcePath}`)
-    }
-
-    // Check if destination already exists and has content
-    if (fs.existsSync(destPath)) {
-      // Allow if destination is current directory (.) or an empty directory
-      const isCwd = path.resolve(destPath) === process.cwd()
-      if (!isCwd) {
-        const items = fs.readdirSync(destPath)
-        // Filter out hidden files/dirs that are safe to ignore
-        const significantItems = items.filter(item => 
-          !item.startsWith('.') && item !== 'node_modules'
-        )
-        if (significantItems.length > 0) {
-          throw new Error(`Destination already exists and is not empty: ${destPath}`)
-        }
-      }
-    }
-
-    console.log('[miolo] Copying template from:', sourcePath)
-    console.log('[miolo] Creating app at:', destPath)
-    console.log('[miolo] Auth method:', authMethod)
-    if (port) {
-      console.log('[miolo] Port:', port)
-    }
-
-    // Copy template
-    copyTemplate(sourcePath, destPath, appName, { authMethod })
-
-    // Update .env with custom parameters
-    updateEnvFile(destPath, appName, { port })
-
-    // Update docker files with custom port
-    if (port) {
-      updateDockerFiles(destPath, port)
-    }
-
-    // Update server/miolo/index.mjs with correct auth import
-    updateServerIndex(destPath, authMethod)
-
-    console.log('[miolo] Template copied successfully')
-    console.log('[miolo] Installing dependencies...')
-
-    // Install dependencies
-    try {
-      execSync('npm install', { 
-        cwd: destPath, 
-        stdio: 'inherit' 
-      })
-      console.log('[miolo] Dependencies installed successfully')
-    } catch (_error) {
-      console.warn('[miolo] Warning: Failed to install dependencies automatically')
-      console.warn('[miolo] Please run "npm install" manually in the project directory')
-    }
-
-    console.log('[miolo] ✅ App created successfully!')
-    console.log('[miolo] To get started:')
-    console.log(`  cd ${dest}`)
-    console.log(`  npm run dev`)
-
-  } catch (error) {
-    console.error('[miolo] Error creating app:', error.message)
-    process.exit(1)
-  }
-}