@cosider.construction/eapp-maker 1.0.0

package/src/index.js

@@ -0,0 +1,741 @@
+#!/usr/bin/env node
+import minimist from 'minimist';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs-extra';
+import { fileURLToPath } from 'url';
+import { input, select, confirm, password } from '@inquirer/prompts';
+
+const __myDir   = path.dirname(fileURLToPath(import.meta.url));
+const stubsBase = path.join(__myDir, 'stubs');
+
+const HELP = `
+${chalk.bold.cyan('eapp-maker')} — Scaffold a new Electron + Vue ERP project
+
+${chalk.bold('Usage:')}
+  npx eapp-maker <app-name> [options]
+  npm create @cosider.construction/eapp-maker <app-name>
+
+${chalk.bold('Options:')}
+  --tailwind              Include Tailwind CSS
+  --db <type>             sqlite | mssql | mysql | postgres
+  --db-host <host>        DB server host
+  --db-port <port>        DB server port
+  --db-user <user>        DB username
+  --db-pass <pass>        DB password
+  --db-name <name>        Database name
+  --db-mode <mode>        single | multi
+  --modules <list>        Comma-separated modules e.g. rh,stk,trv
+  --help, -h              Show this help
+`;
+
+// ─── File writer ──────────────────────────────────────────────────────────────
+
+async function write(filePath, content) {
+  await fs.ensureDir(path.dirname(filePath));
+  await fs.writeFile(filePath, content, 'utf8');
+  console.log(chalk.green('  created'), chalk.dim(path.relative(process.cwd(), filePath)));
+}
+
+async function writeJson(filePath, data) {
+  await write(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+
+// ─── Templates ────────────────────────────────────────────────────────────────
+
+const engineLoader = () => `import { ipcMain } from 'electron';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { checkPermission } from './auth.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BACKEND_ROOT = path.resolve(__dirname, '..');
+
+export async function loadHandlers() {
+  const dirs = [
+    path.join(BACKEND_ROOT, 'shared'),
+    path.join(BACKEND_ROOT, 'modules'),
+  ];
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    for (const ipcPath of walkIpc(dir)) registerIpc(ipcPath);
+  }
+}
+
+function walkIpc(root, out = []) {
+  for (const e of fs.readdirSync(root, { withFileTypes: true })) {
+    const full = path.join(root, e.name);
+    if (e.isDirectory()) walkIpc(full, out);
+    else if (e.name === 'ipc.json') out.push(full);
+  }
+  return out;
+}
+
+async function registerIpc(ipcJsonPath) {
+  let config;
+  try { config = JSON.parse(fs.readFileSync(ipcJsonPath, 'utf8')); }
+  catch (e) { console.warn('[engine] bad ipc.json:', ipcJsonPath); return; }
+
+  const { route, schema, methods = {} } = config;
+  const entityDir = path.dirname(ipcJsonPath);
+  let ctrl;
+  try { ctrl = await import(path.join(entityDir, 'controller.js')); }
+  catch (e) { console.warn('[engine] no controller at', entityDir); return; }
+
+  for (const [methodName, def] of Object.entries(methods)) {
+    const handler    = typeof def === 'string' ? def : def.handler;
+    const permission = typeof def === 'object' ? def.permission : null;
+    const channel    = \`\${route}:\${methodName}\`;
+
+    if (typeof ctrl[handler] !== 'function') {
+      console.warn(\`[engine] \${handler} not found in \${entityDir}\`);
+      continue;
+    }
+
+    ipcMain.handle(channel, async (_, payload) => {
+      if (permission) {
+        const ok = await checkPermission(payload?.__userId, permission);
+        if (!ok) return { error: 'FORBIDDEN', message: \`Missing: \${permission}\` };
+      }
+      try {
+        const { id, data } = payload || {};
+        if (methodName === 'getById') return await ctrl[handler](id);
+        if (methodName === 'update')  return await ctrl[handler](id, data);
+        if (methodName === 'delete')  return await ctrl[handler](id);
+        if (methodName === 'add')     return await ctrl[handler](data);
+        return await ctrl[handler](payload);
+      } catch (err) {
+        return { error: 'INTERNAL_ERROR', message: err.message };
+      }
+    });
+    console.log(\`[engine] \${channel}\`);
+  }
+}
+`;
+
+const engineAuth = () => `import * as permModel from '../shared/PERMISSION/model.js';
+
+export async function checkPermission(userId, permissionString) {
+  if (!userId) return false;
+  try {
+    const p = await permModel.findByUserAndPermission(userId, permissionString);
+    return !!p;
+  } catch { return false; }
+}
+`;
+
+const engineDbSqlite = () => `import Database from 'better-sqlite3';
+import path from 'path';
+import { app } from 'electron';
+
+const _db = new Database(path.join(app.getPath('userData'), 'app.db'));
+_db.pragma('journal_mode = WAL');
+
+function scope(schema) {
+  // SQLite has no schemas — schema param kept for API compatibility
+  return {
+    query:    (sql, p = {}) => _db.prepare(sql).all(p),
+    queryOne: (sql, p = {}) => _db.prepare(sql).get(p) ?? null,
+    execute:  (sql, p = {}) => _db.prepare(sql).run(p),
+  };
+}
+
+export const dbo = scope('dbo');
+// Add module scopes as modules are generated: export const rh = scope('rh');
+`;
+
+const engineDbExternal = ({ dbType, connections, mode }) => {
+  const driver = { mssql: `import sql from 'mssql';`, mysql: `import mysql from 'mysql2/promise';`, postgres: `import pg from 'pg';` }[dbType];
+  return `${driver}
+import config from '../../db.config.json' assert { type: 'json' };
+
+let activeDb = config.connections[0]?.database || '';
+export const setActiveDatabase = (name) => { activeDb = name; };
+export const getActiveDatabase = () => activeDb;
+
+function qualify(schema, table) {
+  return \`[\${activeDb}].[\${schema}].[\${table}]\`;
+}
+
+function scope(schema) {
+  async function conn() {
+    const c = config.connections.find(x => x.database === activeDb) || config.connections[0];
+    ${dbType === 'mssql'
+      ? `return sql.connect({ server: c.host, port: c.port, user: c.user, password: c.password, database: c.database, options: { trustServerCertificate: true } });`
+      : dbType === 'mysql'
+      ? `return mysql.createConnection({ host: c.host, port: c.port, user: c.user, password: c.password, database: c.database });`
+      : `const client = new pg.Client({ host: c.host, port: c.port, user: c.user, password: c.password, database: c.database }); await client.connect(); return client;`}
+  }
+  function q(sql) {
+    return sql
+      .replace(/FROM (\\w+)/gi,   (_, t) => \`FROM \${qualify(schema, t)}\`)
+      .replace(/JOIN (\\w+)/gi,   (_, t) => \`JOIN \${qualify(schema, t)}\`)
+      .replace(/INTO (\\w+)/gi,   (_, t) => \`INTO \${qualify(schema, t)}\`)
+      .replace(/UPDATE (\\w+)/gi, (_, t) => \`UPDATE \${qualify(schema, t)}\`);
+  }
+  return {
+    async query(sql, params = {})         { const c = await conn(); ${dbType === 'mssql' ? `const r = await c.request().query(q(sql)); return r.recordset;` : `const [rows] = await c.execute(q(sql), Object.values(params)); return rows;`} },
+    async queryOne(sql, params = {})      { return (await this.query(sql, params))[0] ?? null; },
+    async execute(sql, params = {})       { const c = await conn(); ${dbType === 'mssql' ? `return c.request().query(q(sql));` : `const [r] = await c.execute(q(sql), Object.values(params)); return r;`} },
+  };
+}
+
+export const dbo = scope('dbo');
+// Add module scopes: export const rh = scope('rh');
+`;
+};
+
+const preloadIpc = () => `const { contextBridge, ipcRenderer } = require('electron');
+contextBridge.exposeInMainWorld('api', (channel, data) => ipcRenderer.invoke(channel, data));
+`;
+
+const baseApi = () => `export class Api {
+  constructor(route) { this.route = route; }
+  call(method, data) { return window.api(\`\${this.route}:\${method}\`, data); }
+  getAll()           { return this.call('getAll'); }
+  getById(id)        { return this.call('getById', { id }); }
+  add(data)          { return this.call('add', { data }); }
+  update(id, data)   { return this.call('update', { id, data }); }
+  delete(id)         { return this.call('delete', { id }); }
+}
+`;
+
+const authStore = () => `import { defineStore } from 'pinia';
+import { ref, computed } from 'vue';
+
+export const useAuthStore = defineStore('auth', () => {
+  const user        = ref(null);
+  const permissions = ref([]);
+  const isAuthenticated = computed(() => !!user.value);
+
+  const setSession   = (u, p = []) => { user.value = u; permissions.value = p; };
+  const clearSession = () => { user.value = null; permissions.value = []; };
+  const hasPermission = (p) => permissions.value.includes(p);
+  const canAccess = (route) => {
+    const req = route?.meta?.permission;
+    return req ? hasPermission(req) : isAuthenticated.value;
+  };
+
+  return { user, permissions, isAuthenticated, setSession, clearSession, hasPermission, canAccess };
+});
+`;
+
+const router = () => `import { createRouter, createWebHashHistory } from 'vue-router';
+import { useAuthStore } from '@/stores/auth.js';
+
+// routes
+const routes = [
+  { path: '/',              redirect: '/dashboard' },
+  { path: '/login',         component: () => import('@/views/LoginView.vue') },
+  { path: '/access-denied', component: () => import('@/views/AccessDeniedView.vue') },
+];
+
+const router = createRouter({ history: createWebHashHistory(), routes });
+
+router.beforeEach((to, _, next) => {
+  const auth = useAuthStore();
+  if (to.path === '/login') return next();
+  if (!auth.isAuthenticated) return next({ path: '/login', query: { redirect: to.fullPath } });
+  if (!auth.canAccess(to))   return next('/access-denied');
+  next();
+});
+
+export default router;
+`;
+
+const menuLoader = () => `import { useAuthStore } from '@/stores/auth.js';
+const menus = import.meta.glob('./*.menu.json', { eager: true });
+
+export function useMenuLoader() {
+  const auth  = useAuthStore();
+  const hMenu = [];
+  const vMenu = [];
+  for (const mod of Object.values(menus)) {
+    const m = mod.default ?? mod;
+    (m.hMenu || []).filter(i => canShow(auth, i)).forEach(i => hMenu.push(i));
+    (m.vMenu || []).filter(i => canShow(auth, i)).forEach(i => vMenu.push(i));
+  }
+  return { hMenu, vMenu };
+}
+
+function canShow(auth, item) {
+  return !item.permission || auth.hasPermission(item.permission);
+}
+`;
+
+const defaultLayout = () => `<script setup>
+import { inject } from 'vue';
+import AppMenuH from '@/components/AppMenuH.vue';
+import AppMenuV from '@/components/AppMenuV.vue';
+import mainMenu from '@/menus/main.menu.json';
+const subHMenu    = inject('hMenuConfig', null);
+const hMenuConfig = mainMenu.hMenu || { style: 'classic', items: [] };
+const vMenuConfig = mainMenu.vMenu || { items: [] };
+</script>
+<template>
+  <div class="default-layout">
+    <AppMenuH :config="hMenuConfig" />
+    <AppMenuH v-if="subHMenu" :config="subHMenu" sub />
+    <div class="default-layout__body">
+      <AppMenuV :config="vMenuConfig" />
+      <main class="default-layout__main"><slot /></main>
+    </div>
+  </div>
+</template>
+<style scoped>
+.default-layout       { display:flex;flex-direction:column;height:100vh;overflow:hidden; }
+.default-layout__body { display:flex;flex:1;overflow:hidden; }
+.default-layout__main { flex:1;overflow:auto;padding:1.5rem;background:#1e1e2e; }
+</style>
+`;
+
+const loginView = (multiDb) => `<script setup>
+import { ref } from 'vue';
+import { useRouter } from 'vue-router';
+import { useAuthStore } from '@/stores/auth.js';
+${multiDb ? "import dbConfig from '../../../db.config.json';" : ''}
+const router = useRouter();
+const auth   = useAuthStore();
+const username = ref(''); const password = ref(''); const error = ref('');
+${multiDb ? "const selectedDb = ref(dbConfig.connections[0]?.name || '');\nconst connections = dbConfig.connections;" : ''}
+async function login() {
+  error.value = '';
+  const result = await window.api('shared.USER:login', { username: username.value, password: password.value${multiDb ? ", database: selectedDb.value" : ''} });
+  if (result?.error) { error.value = result.message; return; }
+  auth.setSession(result.user, result.permissions);
+  router.push('/');
+}
+</script>
+<template>
+  <div class="login-page">
+    <div class="login-card">
+      <h1>Sign In</h1>
+      <div v-if="error" class="error">{{ error }}</div>
+      <input v-model="username" placeholder="Username" />
+      <input v-model="password" placeholder="Password" type="password" />
+      ${multiDb ? '<select v-model="selectedDb"><option v-for="c in connections" :key="c.name" :value="c.name">{{ c.name }}</option></select>' : ''}
+      <button @click="login">Sign In</button>
+    </div>
+  </div>
+</template>
+<style scoped>
+.login-page{display:flex;align-items:center;justify-content:center;height:100vh;background:#1e1e2e}
+.login-card{background:#313244;padding:2rem;border-radius:12px;display:flex;flex-direction:column;gap:1rem;min-width:320px}
+h1{color:#cdd6f4;margin:0}input,select{padding:.5rem;border:1px solid #45475a;border-radius:6px;background:#1e1e2e;color:#cdd6f4}
+button{padding:.6rem;background:#89b4fa;color:#1e1e2e;font-weight:bold;border:none;border-radius:6px;cursor:pointer}
+.error{color:#f38ba8;font-size:.875rem}
+</style>
+`;
+
+const accessDenied = () => `<template>
+  <div style="display:flex;flex-direction:column;align-items:center;justify-content:center;height:100vh;gap:1rem;color:#cdd6f4">
+    <h1>Access Denied</h1><p>You don't have permission to view this page.</p>
+    <router-link to="/">Go Home</router-link>
+  </div>
+</template>`;
+
+const sharedModel = (entity) => `import { dbo as db } from '../../../engine/db.js';
+const TABLE = '${entity.toUpperCase()}';
+export async function getAll()            { return db.query(\`SELECT * FROM \${TABLE}\`); }
+export async function getById(id)         { return db.queryOne(\`SELECT * FROM \${TABLE} WHERE id = @id\`, { id }); }
+export async function add(data)           { return db.execute(\`INSERT INTO \${TABLE} DEFAULT VALUES\`, data); }
+export async function update(id, data)    { return db.execute(\`UPDATE \${TABLE} SET id=@id WHERE id=@id\`, { ...data, id }); }
+export async function remove(id)          { return db.execute(\`DELETE FROM \${TABLE} WHERE id=@id\`, { id }); }
+${entity === 'USER' ? `
+export async function findByUsername(username) { return db.queryOne(\`SELECT * FROM \${TABLE} WHERE username=@username\`, { username }); }
+export async function findByUserAndPermission(userId, permissionString) {
+  return db.queryOne(\`SELECT p.* FROM PERMISSION p JOIN ROLE r ON r.id=p.role_id JOIN USER u ON u.role_id=r.id WHERE u.id=@userId AND p.permission_string=@permissionString\`, { userId, permissionString });
+}` : ''}
+${entity === 'PERMISSION' ? `
+export async function findByUserAndPermission(userId, permissionString) {
+  return db.queryOne(\`SELECT p.* FROM PERMISSION p JOIN ROLE r ON r.id=p.role_id JOIN USER u ON u.role_id=r.id WHERE u.id=@userId AND p.permission_string=@permissionString\`, { userId, permissionString });
+}` : ''}
+`;
+
+const sharedController = (entity) => `import * as model from './model.js';
+export const getAll  = model.getAll;
+export const getById = model.getById;
+export const add     = model.add;
+export const update  = model.update;
+export const remove  = model.remove;
+${entity === 'USER' ? `
+export async function login({ username, password, database }) {
+  const user = await model.findByUsername(username);
+  if (!user) return { error: 'UNAUTHORIZED', message: 'Invalid credentials' };
+  // TODO: bcrypt.compare(password, user.password_hash)
+  const allPerms = await import('../PERMISSION/model.js').then(m => m.getAll());
+  const permissions = allPerms.filter(p => p.role_id === user.role_id).map(p => p.permission_string);
+  return { user: { id: user.id, username: user.username }, permissions };
+}` : ''}
+`;
+
+const sharedIpc = (entity) => JSON.stringify({
+  route: `shared.${entity.toUpperCase()}`,
+  schema: 'dbo',
+  methods: {
+    getAll:  { handler: 'getAll',  permission: `shared.${entity.toLowerCase()}.view`   },
+    getById: { handler: 'getById', permission: `shared.${entity.toLowerCase()}.view`   },
+    add:     { handler: 'add',     permission: `shared.${entity.toLowerCase()}.add`    },
+    update:  { handler: 'update',  permission: `shared.${entity.toLowerCase()}.update` },
+    delete:  { handler: 'remove',  permission: `shared.${entity.toLowerCase()}.delete` },
+    ...(entity === 'USER' ? { login: { handler: 'login' } } : {}),
+  },
+}, null, 2);
+
+const mainJs = () => `import { app, BrowserWindow } from 'electron';
+import { loadIpc } from './loaders/loader.ipc.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Runtime config — reads app.config.json next to exe, falls back to db.config.json
+function loadConfig() {
+  const exeDir    = path.dirname(process.execPath);
+  const runtimeCfg = path.join(exeDir, 'app.config.json');
+  const devCfg     = path.resolve(__dirname, '../../db.config.json');
+  try {
+    if (fs.existsSync(runtimeCfg)) {
+      console.log('[config] loaded runtime config:', runtimeCfg);
+      return JSON.parse(fs.readFileSync(runtimeCfg, 'utf8'));
+    }
+  } catch {}
+  console.log('[config] loaded dev config:', devCfg);
+  return JSON.parse(fs.readFileSync(devCfg, 'utf8'));
+}
+
+global.__appConfig = loadConfig();
+
+app.whenReady().then(async () => {
+  await loadIpc();
+  const win = new BrowserWindow({
+    width: 1280, height: 800,
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.ipc.js'),
+      contextIsolation: true,
+      nodeIntegration: false,
+    },
+  });
+  process.env.NODE_ENV === 'development'
+    ? win.loadURL(process.env.VITE_DEV_SERVER_URL)
+    : win.loadFile(path.join(__dirname, '../../dist/renderer/index.html'));
+});
+
+app.on('window-all-closed', () => { if (process.platform !== 'darwin') app.quit(); });
+`;
+
+const viteConfig = (tailwind) => `import { defineConfig } from 'electron-vite';
+import vue from '@vitejs/plugin-vue';
+import { resolve } from 'path';
+${tailwind ? "import tailwindcss from 'tailwindcss';\nimport autoprefixer from 'autoprefixer';" : ''}
+export default defineConfig({
+  main:     { build: { lib: { entry: 'src/backend/main.js' } } },
+  preload:  { build: { lib: { entry: 'src/backend/preload.ipc.js' } } },
+  renderer: {
+    root: 'src/frontend',
+    resolve: { alias: { '@': resolve('src/frontend') } },
+    plugins: [vue()],
+    ${tailwind ? "css: { postcss: { plugins: [tailwindcss(), autoprefixer()] } }," : ''}
+  },
+});
+`;
+
+const pkgJson = (name, dbType, tailwind, eappVersion) => {
+  const deps = { electron: '^30.0.0', vue: '^3.4.0', 'vue-router': '^4.3.0', pinia: '^2.1.0' };
+  if (dbType === 'sqlite')   deps['better-sqlite3'] = '^9.6.0';
+  if (dbType === 'mssql')    deps['mssql']          = '^10.0.0';
+  if (dbType === 'mysql')    deps['mysql2']          = '^3.9.0';
+  if (dbType === 'postgres') deps['pg']              = '^8.11.0';
+  const devDeps = {
+    '@vitejs/plugin-vue': '^5.0.0',
+    'electron-vite':      '^2.2.0',
+    vite:                 '^5.2.0',
+    '@cosider.construction/eapp': eappVersion || '*',  // ← fix: add eapp CLI
+  };
+  if (tailwind) { devDeps.tailwindcss = '^3.4.0'; devDeps.autoprefixer = '^10.4.0'; devDeps.postcss = '^8.4.0'; }
+  return JSON.stringify({
+    name, version: '0.1.0', private: true, type: 'module',
+    main: 'src/backend/main.js',
+    scripts: { dev: 'electron-vite dev', build: 'electron-vite build', eapp: 'eapp' },
+    dependencies: deps, devDependencies: devDeps,
+  }, null, 2);
+};
+
+const appHome = () => `<script setup>
+import { ref } from 'vue';
+const gridConfig = ref([
+  { id: 'w1', col: 1, row: 1, colSpan: 2, rowSpan: 1, type: 'placeholder', title: 'Welcome' },
+  { id: 'w2', col: 3, row: 1, colSpan: 1, rowSpan: 1, type: 'placeholder', title: 'Stats'   },
+  { id: 'w3', col: 1, row: 2, colSpan: 3, rowSpan: 1, type: 'placeholder', title: 'Activity' },
+]);
+const COLS = 3;
+function gridStyle(w) { return { gridColumn: \`\${w.col} / span \${w.colSpan}\`, gridRow: \`\${w.row} / span \${w.rowSpan}\` }; }
+</script>
+<template>
+  <div class="app-home">
+    <div class="home-header"><h1>Dashboard</h1><p class="sub">Welcome back</p></div>
+    <div class="widget-grid" :style="{ '--grid-cols': COLS }">
+      <div v-for="w in gridConfig" :key="w.id" class="widget" :style="gridStyle(w)">
+        <div class="widget__header"><span>{{ w.title }}</span></div>
+        <div class="widget__body"><div class="widget__ph"><span>{{ w.type }}</span><small>Configure in gridConfig</small></div></div>
+      </div>
+    </div>
+  </div>
+</template>
+<style scoped>
+.app-home { padding:1.5rem;color:#cdd6f4; }
+.home-header { margin-bottom:1.5rem; } h1 { font-size:1.5rem;font-weight:700;margin:0; }
+.sub { color:#6c7086;margin:.25rem 0 0;font-size:.875rem; }
+.widget-grid { display:grid;grid-template-columns:repeat(var(--grid-cols,3),1fr);gap:1rem; }
+.widget { background:#313244;border:1px solid #45475a;border-radius:10px;display:flex;flex-direction:column;min-height:180px; }
+.widget__header { padding:.75rem 1rem;border-bottom:1px solid #45475a;font-weight:600;font-size:.875rem; }
+.widget__body { flex:1;padding:1rem; }
+.widget__ph { height:100%;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:.35rem;color:#585b70;font-size:.8rem; }
+</style>
+`;
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const argv = minimist(process.argv.slice(2), {
+    boolean: ['tailwind', 'help', 'h'],
+    string: ['db', 'db-host', 'db-port', 'db-user', 'db-pass', 'db-name', 'db-mode', 'modules'],
+  });
+
+  if (argv.help || argv.h) { console.log(HELP); process.exit(0); }
+
+  let appName = argv._[0];
+  if (!appName) { console.error(chalk.red('Error: provide an app name.')); console.log(HELP); process.exit(1); }
+
+  const targetDir = path.resolve(process.cwd(), appName);
+  if (await fs.pathExists(targetDir)) {
+    console.error(chalk.red(`Directory "${appName}" already exists.`)); process.exit(1);
+  }
+
+  let { tailwind } = argv;
+  let dbType = argv.db;
+  let dbMode = argv['db-mode'] || 'single';
+  let connections = [];
+
+  // Interactive prompts if flags not provided
+  if (!dbType) {
+    if (!argv.tailwind) tailwind = await confirm({ message: 'Include Tailwind CSS?', default: false });
+    const embedded = await confirm({ message: 'Use embedded database (SQLite)?', default: true });
+    dbType = embedded ? 'sqlite' : null;
+
+    if (!embedded) {
+      dbType = await select({ message: 'Database type:', choices: [
+        { name: 'SQL Server (mssql)', value: 'mssql' },
+        { name: 'MySQL',              value: 'mysql'  },
+        { name: 'PostgreSQL',         value: 'postgres' },
+      ]});
+      dbMode = await select({ message: 'Database mode:', choices: [
+        { name: 'Single database', value: 'single' },
+        { name: 'Multiple databases', value: 'multi' },
+      ]});
+      const count = dbMode === 'multi'
+        ? parseInt(await input({ message: 'How many connections?', default: '2' }), 10)
+        : 1;
+      for (let i = 0; i < count; i++) {
+        console.log(chalk.bold(`\nConnection ${i + 1}:`));
+        const name     = count > 1 ? await input({ message: 'Name:' }) : appName;
+        const host     = await input({ message: 'Host:', default: '127.0.0.1' });
+        const port     = parseInt(await input({ message: 'Port:', default: dbType === 'mssql' ? '1433' : dbType === 'mysql' ? '3306' : '5432' }), 10);
+        const user     = await input({ message: 'Username:' });
+        const pass     = await password({ message: 'Password:' });
+        const database = await input({ message: 'Database name:' });
+        connections.push({ name, host, port, user, password: pass, database });
+      }
+    }
+  } else if (dbType !== 'sqlite') {
+    connections = [{ name: appName, host: argv['db-host'] || '127.0.0.1', port: parseInt(argv['db-port'] || '1433', 10), user: argv['db-user'] || '', password: argv['db-pass'] || '', database: argv['db-name'] || appName }];
+  }
+
+  if (dbType === 'sqlite') connections = [{ name: appName, database: 'local' }];
+
+  const modules   = argv.modules ? argv.modules.split(',').map(m => m.trim().toLowerCase()) : [];
+  const multiDb   = dbMode === 'multi';
+  const p = (...parts) => path.join(targetDir, ...parts);
+
+  console.log('');
+  console.log(chalk.bold.white('Creating:'), chalk.cyan(appName));
+  console.log(chalk.dim(`  db: ${dbType}  mode: ${dbMode}  tailwind: ${tailwind}  modules: ${modules.join(',') || 'none'}`));
+  console.log('');
+
+  // ── Write everything ───────────────────────────────────────────────────────
+  await write(p('package.json'),            pkgJson(appName, dbType, tailwind, '1.0.0'));
+  await write(p('electron-vite.config.js'), viteConfig(tailwind));
+  await write(p('.gitignore'),              `node_modules/\ndist/\nout/\n.env\n`);
+  await write(p('db.config.json'),          JSON.stringify({ mode: dbMode, connections }, null, 2));
+  await write(p('app.config.json'),         JSON.stringify({ mode: dbMode, connections }, null, 2));
+  if (tailwind) await write(p('tailwind.config.js'), `export default { content: ['./src/frontend/**/*.{vue,js}'], theme: { extend: {} }, plugins: [] };\n`);
+
+  // Engine
+  await write(p('src/backend/engine/auth.js'),     engineAuth());
+  await write(p('src/backend/engine/db.js'),        dbType === 'sqlite' ? engineDbSqlite() : engineDbExternal({ dbType, connections, mode: dbMode }));
+  await write(p('src/backend/engine/router.js'),    `// Reserved for middleware extensions\n`);
+  await write(p('src/backend/engine/registry.js'),  `const r = new Map();\nexport const register = (k,v) => r.set(k,v);\nexport const getAll  = () => [...r.entries()];\nexport const has     = (k) => r.has(k);\n`);
+  await write(p('src/backend/preload.ipc.js'),      preloadIpc());
+  await write(p('src/backend/main.js'),             mainJs());
+
+  // Backend loader
+  await fs.ensureDir(p('src/backend/loaders'));
+  await fs.copyFile(
+    path.join(stubsBase, 'loaders', 'loader.ipc.js'),
+    p('src/backend/loaders/loader.ipc.js')
+  );
+  console.log(chalk.green('  created'), chalk.dim('src/backend/loaders/loader.ipc.js'));
+
+  // Shared entities
+  for (const entity of ['USER', 'ROLE', 'PERMISSION']) {
+    const d = p('src/backend/shared', entity);
+    await write(path.join(d, 'model.js'),      sharedModel(entity));
+    await write(path.join(d, 'controller.js'), sharedController(entity));
+    await write(path.join(d, 'ipc.json'),      sharedIpc(entity));
+  }
+
+  // Frontend
+  await write(p('src/frontend/main.js'), `import { createApp } from 'vue';\nimport { createPinia } from 'pinia';\nimport App from './App.vue';\nimport router from './loaders/loader.routes.js';\nconst app = createApp(App);\napp.use(createPinia()).use(router).mount('#app');\n`);
+  await write(p('src/frontend/App.vue'), `<script setup>\nimport { RouterView } from 'vue-router';\n</script>\n<template><RouterView /></template>\n<style>*{box-sizing:border-box;margin:0;padding:0}body{font-family:system-ui,sans-serif;background:#1e1e2e;color:#cdd6f4}</style>\n`);
+  await write(p('src/frontend/index.html'), `<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><title>${appName}</title></head><body><div id="app"></div><script type="module" src="./main.js"></script></body></html>\n`);
+  await write(p('src/frontend/api/api.js'),           baseApi());
+  await write(p('src/frontend/stores/auth.js'),       authStore());
+  await write(p('src/frontend/router/index.js'),      router());
+  await write(p('src/frontend/layouts/DefaultLayout.vue'), defaultLayout());
+  await write(p('src/frontend/menus/main.menu.json'), JSON.stringify({
+    module: 'main', label: 'Main',
+    hMenu: { style: 'classic', items: [{ label: 'Home', route: '/', icon: '' }] },
+    vMenu: { items: [] },
+  }, null, 2));
+  await write(p('src/frontend/views/LoginView.vue'),  loginView(multiDb));
+  await write(p('src/frontend/views/AccessDeniedView.vue'), accessDenied());
+  await write(p('src/frontend/views/AppHome.vue'),    appHome());
+  await fs.ensureDir(p('src/frontend/api/modules'));
+
+  // Copy frontend loaders
+  await fs.ensureDir(p('src/frontend/loaders'));
+  for (const file of ['loader.menu.js', 'loader.routes.js']) {
+    const src = path.join(stubsBase, 'loaders', file);
+    if (await fs.pathExists(src)) {
+      await fs.copyFile(src, p(`src/frontend/loaders/${file}`));
+      console.log(chalk.green('  created'), chalk.dim(`src/frontend/loaders/${file}`));
+    }
+  }
+
+  // Copy DefaultLayout from stubs
+  await fs.copyFile(
+    path.join(stubsBase, 'layouts', 'DefaultLayout.vue'),
+    p('src/frontend/layouts/DefaultLayout.vue')
+  );
+  console.log(chalk.green('  created'), chalk.dim('src/frontend/layouts/DefaultLayout.vue'));
+
+  // Dumb UI components
+  const compDest = p('src/frontend/components');
+  await fs.ensureDir(compDest);
+  for (const file of ['AppMenuH.vue', 'AppMenuV.vue', 'AppModal.vue', 'AppConfirm.vue', 'AppToast.vue']) {
+    const src = path.join(stubsBase, 'components', file);
+    if (await fs.pathExists(src)) {
+      await fs.copyFile(src, path.join(compDest, file));
+      console.log(chalk.green('  created'), chalk.dim(`src/frontend/components/${file}`));
+    }
+  }
+
+  await fs.ensureDir(p('public'));
+
+  // Modules
+  for (const mod of modules) {
+    const Pascal = mod.charAt(0).toUpperCase() + mod.slice(1);
+    await fs.ensureDir(p('src/backend/modules', mod.toUpperCase()));
+    await fs.ensureDir(p('src/frontend/views/modules', mod));
+
+    // Menu JSON with AppMenuH/AppMenuV structure
+    await write(p('src/frontend/menus', `${mod}.menu.json`), JSON.stringify({
+      module: mod,
+      label:  Pascal,
+      hMenu:  { style: 'classic', items: [{ label: `${Pascal} Home`, route: `/${mod}`, icon: '' }] },
+      vMenu:  { items: [{ label: Pascal, icon: '', children: [] }] },
+    }, null, 2));
+
+    // Module layout
+    await write(p('src/frontend/layouts', `${Pascal}Layout.vue`), `<script setup>
+import { inject } from 'vue';
+import AppMenuH from '@/components/AppMenuH.vue';
+import AppMenuV from '@/components/AppMenuV.vue';
+import moduleMenu from '@/menus/${mod}.menu.json';
+const subHMenu    = inject('hMenuConfig', null);
+const hMenuConfig = moduleMenu.hMenu || { style: 'classic', items: [] };
+const vMenuConfig = moduleMenu.vMenu || { items: [] };
+</script>
+<template>
+  <div class="${mod}-layout">
+    <AppMenuH :config="hMenuConfig" />
+    <AppMenuH v-if="subHMenu" :config="subHMenu" sub />
+    <div class="${mod}-layout__body">
+      <AppMenuV :config="vMenuConfig" />
+      <main class="${mod}-layout__main"><slot /></main>
+    </div>
+  </div>
+</template>
+<style scoped>
+.${mod}-layout       { display:flex;flex-direction:column;height:100vh;overflow:hidden; }
+.${mod}-layout__body { display:flex;flex:1;overflow:hidden; }
+.${mod}-layout__main { flex:1;overflow:auto;padding:1.5rem;background:#1e1e2e; }
+</style>
+`);
+
+    // Module home page
+    await write(p('src/frontend/views/modules', mod, `${Pascal}Home.vue`), `<script setup>
+import { ref } from 'vue';
+const gridConfig = ref([
+  { id: 'w1', col: 1, row: 1, colSpan: 2, rowSpan: 1, type: 'placeholder', title: '${Pascal} Overview' },
+  { id: 'w2', col: 3, row: 1, colSpan: 1, rowSpan: 1, type: 'placeholder', title: 'Quick Stats'        },
+  { id: 'w3', col: 1, row: 2, colSpan: 3, rowSpan: 1, type: 'placeholder', title: 'Recent Activity'    },
+]);
+const COLS = 3;
+function gridStyle(w) { return { gridColumn: \`\${w.col} / span \${w.colSpan}\`, gridRow: \`\${w.row} / span \${w.rowSpan}\` }; }
+</script>
+<template>
+  <div class="${mod}-home">
+    <div class="home-header"><h1>${Pascal}</h1><p class="sub">Module overview</p></div>
+    <div class="widget-grid" :style="{ '--grid-cols': COLS }">
+      <div v-for="w in gridConfig" :key="w.id" class="widget" :style="gridStyle(w)">
+        <div class="widget__header"><span>{{ w.title }}</span></div>
+        <div class="widget__body"><div class="widget__ph"><span>{{ w.type }}</span><small>Configure in gridConfig</small></div></div>
+      </div>
+    </div>
+  </div>
+</template>
+<style scoped>
+.${mod}-home { padding:1.5rem;color:#cdd6f4; }
+.home-header { margin-bottom:1.5rem; } h1 { font-size:1.4rem;font-weight:700;margin:0; }
+.sub { color:#6c7086;margin:.25rem 0 0;font-size:.875rem; }
+.widget-grid { display:grid;grid-template-columns:repeat(var(--grid-cols,3),1fr);gap:1rem; }
+.widget { background:#313244;border:1px solid #45475a;border-radius:10px;display:flex;flex-direction:column;min-height:160px; }
+.widget__header { padding:.75rem 1rem;border-bottom:1px solid #45475a;font-weight:600;font-size:.875rem; }
+.widget__body { flex:1;padding:1rem; }
+.widget__ph { height:100%;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:.35rem;color:#585b70;font-size:.8rem; }
+</style>
+`);
+    console.log(chalk.green('  module'), mod.toUpperCase());
+  }
+
+  console.log('');
+  console.log(chalk.bold.green('✔ Done!'));
+  console.log('');
+  console.log(chalk.cyan(`  cd ${appName}`));
+  console.log(chalk.cyan('  npm install'));
+  console.log(chalk.cyan('  npm run dev'));
+  console.log('');
+  console.log(chalk.dim('  Then use the eapp CLI inside your project:'));
+  console.log(chalk.cyan('  eapp entity rh/employee'));
+  console.log(chalk.cyan('  eapp view rh/employee'));
+  console.log('');
+}
+
+main().catch((err) => {
+  if (err.name === 'ExitPromptError') { console.log(chalk.yellow('\nCancelled.')); process.exit(0); }
+  console.error(chalk.red('Error:'), err.message);
+  process.exit(1);
+});