miolo 3.0.0-beta.21 → 3.0.0-beta.210

package/bin/dev/dev_start.mjs

@@ -1,11 +1,12 @@
-import path from 'node:path'
-import {miolo_dev} from '../../src/server-dev.mjs'
+import path from "node:path"
+import { miolo_dev } from "../../src/server-dev.mjs"
 
 async function _miolo_dev_start_server() {
-  const config = await import(path.join(process.cwd(), process.env.MIOLO_DEV_CONFIG_ENTRY))
+  process.env.NODE_ENV = "development"
+  const config = await import(path.join(process.cwd(), process.env.MIOLO_BUILD_CONFIG_ENTRY))
   const app = await miolo_dev(config.default)
   await app.start()
-  return app  
+  return app
 }
 
-_miolo_dev_start_server()
+_miolo_dev_start_server()

package/bin/index.mjs

@@ -1,86 +1,128 @@
 #!/usr/bin/env node
-import path from 'node:path'
-import yargs from 'yargs-parser'
-import { init_env_config } from '../src/config/env.mjs'
-
+import path from "node:path"
+import yargs from "yargs-parser"
+import { init_env_config } from "../src/config/env.mjs"
 
 async function main() {
   const args = yargs(process.argv.slice(2))
   const command = args._[0]
 
-  // Init env
-  init_env_config()
-
-  // Init vars
-  const appName = args['app-name'] || process.env.MIOLO_NAME
-  const serverExt = 'node.bundle.mjs'
-
   try {
+    // Special handling for 'create' command - doesn't need env config
+    if (command === "create") {
+      const createAppName = args._[1]
+      const createOptions = {
+        port: args.port,
+        auth: args.auth,
+        dest: args.d || args.dest // Support both --d and --dest
+      }
+
+      const createAppHandler = (await import("./create/index.mjs")).default
+      await createAppHandler(createAppName, createOptions)
+      return
+    }
+
+    // Init env for other commands
+    process.env.NODE_ENV = "production"
+    init_env_config()
+
+    // Init vars
+    const appName = args["app-name"] || process.env.MIOLO_NAME || "miolo"
+    const cliEntry =
+      args["cli-entry"] || process.env.MIOLO_BUILD_CLIENT_ENTRY || "./src/cli/entry-cli.jsx"
+    const cliDest = args["cli-dest"] || process.env.MIOLO_BUILD_CLIENT_DEST || "./build/cli"
+    const cliSuffix =
+      args["cli-suffix"] || process.env.MIOLO_BUILD_CLIENT_SUFFIX || "iife.bundle.min"
+    const htmlFile =
+      args["html-file"] || process.env.MIOLO_BUILD_HTML_FILE || "./src/cli/index.html"
+    const srvEntry =
+      args["server-entry"] || process.env.MIOLO_BUILD_SERVER_ENTRY || "./src/server/server.mjs"
+    const configEntry =
+      args["config-entry"] || process.env.MIOLO_BUILD_CONFIG_ENTRY || "./src/server/config.mjs"
+    const srvDest = args["server-dest"] || process.env.MIOLO_BUILD_SERVER_DEST || "./build/server"
+    const srvExt = args["server-ext"] || process.env.MIOLO_BUILD_SERVER_EXT || "node.bundle.mjs"
+    const ssrEntry = args["ssr-entry"] || process.env.MIOLO_BUILD_SERVER_SSR_ENTRY
+    const ssrDest = args["ssr-dest"] || process.env.MIOLO_BUILD_SERVER_DEST || "./build/server"
+    const binDest = args["bin-dest"] || "./build/bin"
+    const binEntry = args["bin-entry"]
+    const binName =
+      args["bin-name"] || (binEntry ? path.basename(binEntry, path.extname(binEntry)) : "")
+    const binExt = args["bin-ext"] || "node.bundle.mjs"
 
     switch (command) {
-      case 'dev':
-        process.env.NODE_ENV = 'development'
-        const devHandler = (await import ('./dev/dev.mjs')).default
+      case "dev": {
+        process.env.NODE_ENV = "development"
+        const devHandler = (await import("./dev/dev.mjs")).default
         await devHandler(appName)
         break
+      }
 
-      case 'build-client':
-        const entry = args.entry || process.env.MIOLO_BUILD_CLIENT_ENTRY
-        const htmlFile = args['html-file'] || process.env.MIOLO_BUILD_HTML_FILE
-        const cliDest = args.dest || process.env.MIOLO_BUILD_CLIENT_DEST 
-
-        const buildClientHandler = (await import ('./prod-build/build-client.mjs')).default
-        await buildClientHandler(appName, entry, htmlFile, cliDest)
+      case "deb": {
+        process.env.NODE_ENV = "development"
+        const debHandler = (await import("./dev/dev.mjs")).default
+        await debHandler(appName, true)
         break
-
-      case 'build-server':
-        // Based on command line params or .env
-        const srvEntry= args['entry'] || process.env.MIOLO_BUILD_SERVER_ENTRY
-        const ssrEntry= args['ssr-entry'] || process.env.MIOLO_BUILD_SERVER_SSR_ENTRY
-        const ssrDest= args['ssr-dest'] || process.env.MIOLO_BUILD_SERVER_DEST
-        const srvDest= args.dest || process.env.MIOLO_BUILD_SERVER_DEST
-      
-        const buildServerHandler = (await import ('./prod-build/build-server.mjs')).default
-        await buildServerHandler(appName, ssrEntry, ssrDest, srvEntry, srvDest)
+      }
+
+      case "build": {
+        const buildHandler = (await import("./build/build.mjs")).default
+        await buildHandler(
+          appName,
+          cliEntry,
+          cliDest,
+          cliSuffix,
+          htmlFile,
+          srvEntry,
+          configEntry,
+          srvDest,
+          srvExt,
+          ssrEntry,
+          ssrDest
+        )
         break
+      }
 
-      case 'start':
-        
-        const destFile =  args.dest || path.join(process.cwd(), `${process.env.MIOLO_BUILD_SERVER_DEST}/${appName}.${serverExt}`)
+      case "build-bin": {
+        const buildHandler = (await import("./build/build_bin.mjs")).default
+        await buildHandler(appName, binEntry, binDest, binName, binExt)
+        break
+      }
 
-        const startHandler = (await import ('./prod-run/start.mjs')).default
-        await startHandler(appName, destFile)
+      case "start": {
+        const startHandler = (await import("./run/start.mjs")).default
+        await startHandler(appName, srvDest, srvExt)
         break
+      }
 
-      case 'stop':
-        const stopHandler = (await import ('./prod-run/stop.mjs')).default
+      case "stop": {
+        const stopHandler = (await import("./run/stop.mjs")).default
         await stopHandler(appName)
         break
+      }
 
-      case 'restart':
-        const restartDestFile =  args.dest || path.join(process.cwd(), `${process.env.MIOLO_BUILD_SERVER_DEST}/${appName}.${serverExt}`)
-
-        const restartHandler = (await import ('./prod-run/restart.mjs')).default
-        await restartHandler(appName, restartDestFile)
+      case "restart": {
+        const restartHandler = (await import("./run/restart.mjs")).default
+        await restartHandler(appName, srvDest, srvExt)
         break
+      }
 
-      case 'create-bin':
-        const dest = args.dest || process.env.MIOLO_BUILD_SERVER_DEST
-        const cbinDestFile = `./${appName}.${serverExt}`
-        
-        const createHandler = (await import ('./prod-bin/create-bin.mjs')).default
-        await createHandler(appName, dest, cbinDestFile)
+      case "create-bin": {
+        const createHandler = (await import("./prod-bin/create-bin.mjs")).default
+        await createHandler(appName, srvDest, srvExt)
         break
+      }
 
       default:
         console.error(`[miolo] Unknown command: ${command}`)
-        console.log('[miolo] Available commands: dev, build-client, build-server, start, stop, restart')
+        console.log(
+          "[miolo] Available commands: create, dev, deb, build, start, stop, restart, create-bin"
+        )
         process.exit(1)
     }
   } catch (error) {
-    console.error('[miolo] Error during command execution:', error)
+    console.error("[miolo] Error during command execution:", error)
     process.exit(1)
   }
 }
 
-main()
+main()

package/bin/prod-bin/create-bin.mjs

@@ -1,31 +1,46 @@
-import {readFileSync, writeFileSync} from 'node:fs'
-import path from 'path'
-import { fileURLToPath } from 'url'
-import { copyFileSync } from '../util.mjs'
+import { readFileSync, writeFileSync } from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { copyFileSync } from "../util.mjs"
 
 const __my_filename = fileURLToPath(import.meta.url)
 const __my_dirname = path.dirname(__my_filename)
 
-export default async function(appName, dest, destFile) {
-  console.log(`[${appName}][prod][create-bin] Creating bin files...`)
-
-  const readSource = (f) => readFileSync(path.resolve(__my_dirname, '../prod-run', f), {encoding:'utf8'})
-  const writeDest = (f, content) => writeFileSync(path.join(process.cwd(), dest, f), content, {encoding:'utf8',flag:'w'})
-
-  const pidContent = readSource('./pid.mjs')
-  writeDest('pid.mjs', pidContent)
-
-  let startContent = readSource('./start.mjs')
-  startContent = startContent.replace('(appName, destFile) {', `(appName= '${appName}', destFile= '${destFile}') {`)
-  writeDest('start.mjs', startContent)
-  
-  let stopContent = readSource('./stop.mjs')
-  stopContent = stopContent.replace('(appName) {', `(appName= '${appName}') {`)
-  writeDest('stop.mjs', stopContent)
-
-  let restartContent = readSource('./restart.mjs')
-  restartContent = restartContent.replace('(appName, destFile) {', `(appName= '${appName}', destFile= '${destFile}') {`)
-  writeDest('restart.mjs', restartContent)
-  
-  copyFileSync(path.join(__my_dirname, './run.mjs'), path.join(process.cwd(), dest, 'run.mjs'))
-}
+export default async function (appName, srvDest, srvExt) {
+  // const cbinDestFile = `./${appName}.${srvExt}`
+
+  const pkgPath = process.cwd()
+  console.log(`[${appName}][build][create-bin] Creating bin files...`)
+
+  const readSource = (f) =>
+    readFileSync(path.resolve(__my_dirname, "../run", f), { encoding: "utf8" })
+  const writeDest = (f, content) =>
+    writeFileSync(path.join(pkgPath, srvDest, f), content, { encoding: "utf8", flag: "w" })
+
+  const pidContent = readSource("pid.mjs")
+  writeDest("pid.mjs", pidContent)
+
+  let startContent = readSource("start.mjs")
+  startContent = startContent.replace(
+    "(appName, srvDest, srvExt) {",
+    `(appName= '${appName}', srvDest= '${srvDest}', srvExt= '${srvExt}') {`
+  )
+  writeDest("start.mjs", startContent)
+
+  let stopContent = readSource("stop.mjs")
+  stopContent = stopContent.replace("(appName) {", `(appName= '${appName}') {`)
+  writeDest("stop.mjs", stopContent)
+
+  let restartContent = readSource("restart.mjs")
+  restartContent = restartContent.replace(
+    "(appName, srvDest, srvExt) {",
+    `(appName= '${appName}', srvDest= '${srvDest}', srvExt= '${srvExt}') {`
+  )
+  writeDest("restart.mjs", restartContent)
+
+  copyFileSync(path.join(__my_dirname, "run.mjs"), path.join(pkgPath, srvDest, "run.mjs"))
+  copyFileSync(
+    path.join(__my_dirname, "../../src/config/.env"),
+    path.join(pkgPath, srvDest, ".env")
+  )
+}

package/bin/prod-bin/run.mjs

@@ -2,33 +2,37 @@
 async function miolo_run() {
   const args = process.argv.slice(2)
   const command = args[0]
+  process.env.NODE_ENV = "production"
 
   try {
     switch (command) {
-      case 'start':
-        const startHandler = (await import ('./start.mjs')).default
+      case "start": {
+        const startHandler = (await import("./start.mjs")).default
         await startHandler()
         break
+      }
 
-      case 'stop':
-        const stopHandler = (await import ('./stop.mjs')).default
+      case "stop": {
+        const stopHandler = (await import("./stop.mjs")).default
         await stopHandler()
         break
+      }
 
-      case 'restart':
-        const restartHandler = (await import ('./restart.mjs')).default
+      case "restart": {
+        const restartHandler = (await import("./restart.mjs")).default
         await restartHandler()
         break
+      }
 
       default:
         console.error(`[miolo] Unknown command: ${command}`)
-        console.log('[miolo] Available commands: start, stop, restart')
+        console.log("[miolo] Available commands: start, stop, restart")
         process.exit(1)
     }
   } catch (error) {
-    console.error('[miolo] Error during command execution:', error)
+    console.error("[miolo] Error during command execution:", error)
     process.exit(1)
   }
 }
 
-miolo_run()
+miolo_run()

package/bin/{prod-run → run}/pid.mjs

@@ -1,13 +1,13 @@
-import {writeFileSync, readFileSync} from 'node:fs'
+import { readFileSync, writeFileSync } from "node:fs"
 
 export function pidFileCreate(appName) {
   const pidFilePath = `/tmp/${appName}.pid`
-  writeFileSync(pidFilePath, `${process.pid}`, {encoding:'utf8',flag:'w'})
+  writeFileSync(pidFilePath, `${process.pid}`, { encoding: "utf8", flag: "w" })
   return process.pid
 }
 
 export function pidFileRead(appName) {
   const pidFilePath = `/tmp/${appName}.pid`
-  const pid = readFileSync(pidFilePath, {encoding:'utf8'})
+  const pid = readFileSync(pidFilePath, { encoding: "utf8" })
   return pid
-}
+}

package/bin/run/restart.mjs

@@ -0,0 +1,13 @@
+import path from "node:path"
+import start from "./start.mjs"
+import stop from "./stop.mjs"
+
+export default async function restart(appName, srvDest, srvExt) {
+  const pkgPath = process.cwd()
+  const destFile = path.join(pkgPath, `${srvDest}/${appName}.${srvExt}`)
+
+  console.log(`[${appName}][restart] Restarting server...`)
+
+  await stop(appName)
+  await start(appName, destFile)
+}

package/bin/run/start.mjs

@@ -0,0 +1,18 @@
+import path from "node:path"
+import { pidFileCreate } from "./pid.mjs"
+
+export default async function start(appName, srvDest, srvExt) {
+  // Start server
+  const pkgPath = process.cwd()
+  const destFile = path.join(pkgPath, `${srvDest}/${appName}.${srvExt}`)
+
+  console.log(`[${appName}][start] Starting server from ${destFile}...`)
+
+  const srv_module = await import(destFile)
+  const server = srv_module.default
+
+  const pid = pidFileCreate(appName)
+  console.log(`[${appName}][start] Starting server. PID is ${pid}...`)
+
+  await server()
+}

package/bin/run/stop.mjs

@@ -0,0 +1,20 @@
+import { pidFileRead } from "./pid.mjs"
+
+export default async function stop(appName) {
+  // stop server by killin gprocess
+  console.log(`[${appName}][stop] Stopping server...`)
+
+  try {
+    const pid = pidFileRead(appName)
+    console.log(`[${appName}][stop] Killing current process with PID ${pid}`)
+
+    process.kill(pid, "SIGKILL")
+
+    return 1
+  } catch (_) {
+    console.log(`[${appName}][stop] No current process to kill`)
+    console.error(_)
+
+    return 0
+  }
+}

package/bin/util.mjs

@@ -1,32 +1,56 @@
-import {readdirSync, rmSync, writeFileSync, readFileSync} from 'node:fs'
-import path from 'node:path'
-
+import { readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { readFile } from "node:fs/promises"
+import path from "node:path"
 
 export function cleanFolder(folder) {
-  readdirSync(folder).forEach(file => {
-    rmSync(`${folder}/${file}`, { recursive: true, force: true });
+  readdirSync(folder).forEach((file) => {
+    rmSync(`${folder}/${file}`, { recursive: true, force: true })
   })
 }
 
-export function copyFileSync(srcPath, destPath, modifier= undefined) {
+export function copyFileSync(srcPath, destPath, modifier = undefined) {
   try {
-    let content = readFileSync(srcPath, 'utf8')
+    let content = readFileSync(srcPath, "utf8")
     if (modifier) {
       content = modifier(content)
     }
-    writeFileSync(destPath, content, {encoding:'utf8',flag:'w'})
+    writeFileSync(destPath, content, { encoding: "utf8", flag: "w" })
     console.log(`[miolo] Copied file from ${srcPath} to ${destPath}`)
   } catch (error) {
     console.error(`[miolo] Error copying file from ${srcPath} to ${destPath}:`, error)
   }
-} 
+}
 
 export function isFileExistingSync(filePath) {
   try {
-    const fullPath = path.join(process.cwd(), filePath)   
+    const fullPath = path.join(process.cwd(), filePath)
     return readdirSync(path.dirname(fullPath)).includes(path.basename(fullPath))
   } catch (error) {
     console.error(`[miolo] Error checking if file exists: ${filePath}`, error)
     return false
   }
-} 
+}
+
+export async function readJsonFile(jsonPath) {
+  try {
+    const data = await readFile(jsonPath)
+    const obj = JSON.parse(data)
+    return obj
+  } catch (err) {
+    console.error(`readJsonFile${jsonPath}`, err)
+    return {}
+  }
+}
+
+export function readJsonFileSync(jsonPath, silent = false) {
+  try {
+    const data = readFileSync(jsonPath, { encoding: "utf8", flag: "r" })
+    const obj = JSON.parse(data)
+    return obj
+  } catch (err) {
+    if (!silent) {
+      console.error(`readJsonFileSync${jsonPath}`, err)
+    }
+    return {}
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo",
-  "version": "3.0.0-beta.21",
+  "version": "3.0.0-beta.210",
   "description": "all-in-one koa-based server",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [
@@ -15,71 +15,91 @@
   },
   "homepage": "https://www.afialapis.com/os/miolo",
   "license": "MIT",
+  "type": "module",
   "bin": {
     "miolo": "./bin/index.mjs"
   },
-  "type": "module",
+  "main": "./src/index.mjs",
   "exports": {
-    "node": "./src/index.mjs", 
+    "node": "./src/index.mjs",
     "import": "./src/index.mjs",
-    "default": "./dist/miolo.node.mjs"
+    "default": "./src/index.mjs"
   },
   "files": [
     "bin",
-    "src"
+    "src",
+    "template",
+    "template/.env",
+    "template/.env.production",
+    "template/.editorconfig",
+    "template/.agent",
+    "package.json"
   ],
   "scripts": {
-    "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",
-    "test": "npx xeira test --files=./test/index.mjs"
+    "lint": "biome check ./src ./bin --reporter=github",
+    "lint:fix": "biome check --write ./src ./bin --reporter=github",
+    "reset": "rm -fr package-lock.json npm-lock.yaml && npm i",
+    "prepare-template": "node bin/create/prepare-template.mjs",
+    "dist": "npm run prepare-template",
+    "prepublishOnly": "npm run lint && npm run dist"
   },
   "dependencies": {
-    "@babel/plugin-proposal-decorators": "^7.28.0",
-    "@dotenvx/dotenvx": "^1.47.6",
-    "@koa/bodyparser": "^6.0.0",
+    "@babel/plugin-proposal-decorators": "^7.29.7",
+    "@babel/preset-env": "^7.29.7",
+    "@babel/preset-react": "^7.29.7",
+    "@dotenvx/dotenvx": "^1.75.0",
+    "@koa/bodyparser": "^6.1.0",
     "@koa/cors": "^5.0.0",
-    "@koa/router": "^13.1.1",
-    "@maxmind/geoip2-node": "^6.1.0",
-    "@vitejs/plugin-react": "^4.6.0",
-    "cacheiro": "^0.4.4",
-    "calustra": "^0.15.3",
-    "cron": "^4.3.2",
+    "@koa/router": "^15.6.0",
+    "@maxmind/geoip2-node": "^6.3.4",
+    "@rollup/plugin-alias": "^6.0.0",
+    "@rollup/plugin-babel": "^7.1.0",
+    "@rollup/plugin-commonjs": "^29.0.3",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@tailwindcss/postcss": "^4.3.1",
+    "@tailwindcss/vite": "^4.3.1",
+    "@vitejs/plugin-react": "^6.0.2",
+    "autoprefixer": "^10.5.0",
+    "cacheiro": "^0.5.0-beta.11",
+    "calustra": "^1.0.0-beta.14",
+    "cron": "^4.4.0",
     "deepmerge": "^4.3.1",
     "diskspace": "^2.0.0",
     "http-terminator": "^3.2.0",
-    "intre": "^2.6.1",
+    "intre": "^3.0.0-beta.4",
+    "is-plain-object": "^5.0.0",
+    "joi": "^18.2.3",
     "jwt-simple": "^0.5.6",
-    "koa": "^3.0.0",
-    "koa-compress": "^5.1.1",
-    "koa-connect": "^2.1.0",
+    "koa": "^3.2.1",
+    "koa-compress": "^5.2.2",
+    "koa-connect": "^2.1.1",
     "koa-favicon": "^2.1.0",
     "koa-mount": "^4.2.0",
     "koa-passport": "^6.0.0",
     "koa-proxies": "^0.12.4",
     "koa-ratelimit": "^6.0.0",
     "koa-session": "^7.0.2",
-    "koa-socket-2": "^2.0.0",
     "koa-static": "^5.0.0",
-    "nodemailer": "^7.0.5",
+    "nanoid": "^5.1.15",
+    "nodemailer": "^9.0.1",
+    "passport-google-oauth20": "^2.0.0",
     "passport-local": "^1.0.0",
-    "socket.io": "^4.8.1",
-    "socket.io-client": "^4.8.1",
+    "rollup": "^4.62.2",
+    "rollup-plugin-node-externals": "^9.0.1",
+    "rollup-plugin-postcss": "^4.0.2",
+    "socket.io": "^4.8.3",
+    "socket.io-client": "^4.8.3",
+    "statuses": "^2.0.2",
+    "tailwindcss": "^4.3.1",
     "tinguir": "^0.0.7",
-    "vite": "^7.0.4",
-    "winston": "^3.17.0",
+    "vite": "^8.0.16",
+    "winston": "^3.19.0",
     "winston-daily-rotate-file": "^5.0.0",
     "yargs-parser": "^22.0.0"
   },
-  "devDependencies": {
-    "esbuild": "^0.25.6",
-    "node-fetch": "^3.3.2",
-    "xeira": "^1.2.3"
-  },
-  "eslintConfig": {
-    "extends": [
-      "../../node_modules/xeira/configs/eslint.react.cjs"
-    ]
+  "engines": {
+    "node": ">=24"
   }
-}
+}