miolo 3.0.0-beta.2 → 3.0.0-beta.200

package/bin/create/copy.mjs

@@ -0,0 +1,175 @@
+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",
+  ".sh"
+]
+
+// 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(".") ||
+    path.basename(filePath) === "Dockerfile"
+  )
+}
+
+/**
+ * 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 { authType } = 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 = `${authType}.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)
+    let destItemPath = path.join(destPath, item)
+    const stat = fs.statSync(srcPath)
+
+    if (shouldExclude(srcPath)) {
+      continue
+    }
+
+    if (stat.isFile()) {
+      // Special handling for gitignore -> .gitignore rename
+      // (npm doesn't include .gitignore in subdirectories, so we store it as gitignore)
+      if (item === "gitignore") {
+        destItemPath = path.join(destPath, ".gitignore")
+      }
+
+      // 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()) {
+      // Copy src/, db/, docker/, and .agent/ directories
+      if (item === "src" || item === "docker" || item === "db" || item === ".agent") {
+        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,137 @@
+import { execSync } from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { updateServerIndex } from "./auth.mjs"
+import { copyTemplate } from "./copy.mjs"
+import { updateDockerFiles } from "./docker.mjs"
+import { updateEnvFile } from "./pkgjson.mjs"
+// Import modular functions
+import { validateAppName, validateAuthType } from "./validation.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: authType = "passport", dest = `./${appName}` } = options
+
+    // Validate auth method
+    validateAuthType(authType)
+
+    // 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:", authType)
+    if (port) {
+      console.log("[miolo] Port:", port)
+    }
+
+    // Copy template files
+    copyTemplate(sourcePath, destPath, appName, { authType })
+
+    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, authType)
+
+    // 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')
+    }
+
+    // Initialize database
+    const dbInitScript = path.join(destPath, "db/init.sh")
+    if (fs.existsSync(dbInitScript)) {
+      console.log("")
+      console.log("[miolo] Database initialization")
+      console.log(
+        "[miolo] ⚠️  Note: This step may require sudo password if your user doesn't have CREATEDB permission"
+      )
+      console.log("[miolo] Database name will be:", appName)
+
+      // Make script executable
+      try {
+        fs.chmodSync(dbInitScript, 0o755)
+      } catch (_error) {
+        // Ignore chmod errors
+      }
+
+      try {
+        execSync(`${dbInitScript} ${appName}`, {
+          cwd: destPath,
+          stdio: "inherit"
+        })
+        console.log("[miolo] ✅ Database initialized successfully")
+      } catch (_error) {
+        console.warn("[miolo] ⚠️  Warning: Database initialization failed or was skipped")
+        console.warn("[miolo] You can initialize it manually later by running:")
+        console.warn(`[miolo]   cd ${dest} && ./db/init.sh ${appName}`)
+      }
+    }
+
+    console.log("")
+    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,158 @@
+#!/usr/bin/env node
+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)
+
+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 (note: .gitignore renamed to gitignore to avoid npm exclusion)
+const filesToCopy = [
+  { src: ".env", dest: ".env" },
+  { src: ".env.production", dest: ".env.production" },
+  { src: ".editorconfig", dest: ".editorconfig" },
+  { src: ".gitignore", dest: "gitignore" }, // Rename to avoid npm ignoring it
+  { src: "components.json", dest: "components.json" },
+  { src: "jsconfig.json", dest: "jsconfig.json" },
+  { src: "package.json", dest: "package.json" },
+  { src: "biome.json", dest: "biome.json" },
+  { src: "postcss.config.js", dest: "postcss.config.js" }
+  //{ src: 'vite.config.mjs', dest: 'vite.config.mjs' }
+]
+
+// Copy individual files
+for (const { src, dest } of filesToCopy) {
+  const srcFile = path.join(mioloSamplePath, src)
+  const destFile = path.join(templatePath, dest)
+
+  if (fs.existsSync(srcFile)) {
+    fs.copyFileSync(srcFile, destFile)
+    console.log(`[prepare-template]   ✓ Copied ${src}${src !== dest ? ` → ${dest}` : ""}`)
+  } else {
+    console.warn(`[prepare-template]   ⚠ File not found: ${src}`)
+  }
+}
+
+// Copy directories
+const dirsToCopy = ["src", "docker", "db"]
+
+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}`)
+  }
+}
+
+// Copy skills from workspace root
+const skillsSrc = path.resolve(__dirname, "../../../../skills")
+const skillsDest = path.join(templatePath, ".agent", "skills")
+if (fs.existsSync(skillsSrc)) {
+  fs.mkdirSync(path.join(templatePath, ".agent"), { recursive: true })
+  copyDirRecursive(skillsSrc, skillsDest)
+  console.log("[prepare-template]   ✓ Copied skills/")
+} else {
+  console.warn("[prepare-template]   ⚠ Skills directory not found at", skillsSrc)
+}
+
+// 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 validateAuthType(authType) {
+  const validAuthTypes = ["passport", "basic", "guest"]
+  if (!validAuthTypes.includes(authType)) {
+    throw new Error(`Invalid auth type: ${authType}. Valid options: ${validAuthTypes.join(", ")}`)
+  }
+  return true
+}

package/bin/{dev.mjs → dev/dev.mjs}

@@ -1,7 +1,6 @@
-
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { fork } from 'node:child_process'
+import { fork } from "node:child_process"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -14,18 +13,32 @@ function _isProcessRunning(pid) {
   try {
     process.kill(pid, 0) // Sending a signal 0 does nothing but checks if the process exists
     return true
-  } catch (error) {
+  } catch (_) {
     return false
   }
 }
 
-async function startDevServerProcess({ appName }) {
-  const serverPath = path.join(__dirname, './dev_start.mjs')
-  serverProcess = fork(serverPath)
+async function startDevServerProcess({ appName, debug }) {
+  const serverPath = path.join(__dirname, "./dev_start.mjs")
+
+  const execArgv = []
+  if (debug === true) {
+    const newDebugPort = process.debugPort + 1
+    console.log(
+      `[${appName}][dev] Debugging enabled. Attaching debugger to child process on port ${newDebugPort}`
+    )
+    execArgv.push(`--inspect=${newDebugPort}`)
+  }
+
+  serverProcess = fork(serverPath, [], {
+    execArgv: execArgv
+  })
 
-  console.log(`[${appName}][dev] Server process started with pid ${serverProcess.pid} from ${process.pid}`)
+  console.log(
+    `[${appName}][dev] Server process started with pid ${serverProcess.pid} from ${process.pid}`
+  )
 
-  serverProcess.on('exit', (code, args) => {
+  serverProcess.on("exit", (code, args) => {
     console.log(`[${appName}][dev] Server process exited with code ${code} -  ${args}`)
     serverProcess = null
     // Puedes implementar lógica de reintento aquí si es necesario
@@ -38,34 +51,36 @@ async function startDevServerProcess({ appName }) {
     //  } else if (code !== 0) {
     //    console.error(`[${serverName}][dev] Server failed to start after ${maxRetries} retries. Exiting.`)
     //    process.exit(1)
-    //  }    
+    //  }
   })
 
-  serverProcess.on('message', (message) => {
-    if (message === 'miolo_restart') {
+  serverProcess.on("message", (message) => {
+    if (message === "miolo_restart") {
       console.log(`[${appName}][dev] Received restart signal. Restarting server...`)
 
       const pidToKill = serverProcess ? serverProcess.pid : null
       if (pidToKill) {
         console.log(`[${appName}][dev] Killing process with PID: ${pidToKill}`)
         // Clean kill
-        process.kill(pidToKill, 'SIGTERM')
+        process.kill(pidToKill, "SIGTERM")
 
         // Harder if still alive
         setTimeout(() => {
           if (_isProcessRunning(pidToKill)) {
-            process.kill(pidToKill, 'SIGKILL')
+            process.kill(pidToKill, "SIGKILL")
           }
         }, 2000)
       }
 
-      startDevServerProcess({ appName }) // Inicia un nuevo proceso
+      startDevServerProcess({ appName, debug }) // Inicia un nuevo proceso
     }
   })
 }
 
+export default async function (appName = undefined, debug = false) {
+  // Based on command line params or .env
+  appName = appName || process.env.MIOLO_NAME
 
-export default async function(appName) {
   console.log(`[${appName}][dev] Running DEV server`)
-  await startDevServerProcess({ appName })
+  await startDevServerProcess({ appName, debug })
 }