@enfyra/create 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Enfyra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @enfyra/create
+
+Create a complete Enfyra workspace with one command:
+
+```sh
+npx @enfyra/create my-enfyra
+```
+
+The generated project contains:
+
+- `app/` - Enfyra Nuxt admin app
+- `server/` - Enfyra server
+- Root workspace scripts for running both together
+- `app/.env` connected to `http://localhost:1105`
+- `server/.env` with `PORT=1105`
+
+The CLI prompts for:
+
+- Package manager: npm, yarn, or pnpm
+- Database type and URI
+- Redis URI
+- Default admin account
+
+It validates the database and Redis connections before scaffolding. If validation fails, you can re-enter the connection details, continue anyway, or exit setup.
+
+## Usage
+
+```sh
+cd my-enfyra
+<package-manager> run dev
+```
+
+Run one side only:
+
+```sh
+<package-manager> run dev:server
+<package-manager> run dev:app
+```
+
+The server port is fixed to `1105`. During setup, the CLI checks the port first and asks before killing any process that is already using it.
+
+The Nuxt app is configured with `PORT=3000`; Nuxt may pick another port at dev time if `3000` is already busy.
+
+## Requirements
+
+- Node.js 24.x
+- npm, yarn, or pnpm
+- A running MySQL, PostgreSQL, or MongoDB instance
+- A running Redis instance

package/components/connection-validator.js

@@ -0,0 +1,124 @@
+const mysql = require('mysql2/promise');
+const { Client } = require('pg');
+const { MongoClient } = require('mongodb');
+const Redis = require('ioredis');
+const chalk = require('chalk');
+
+function parseDatabaseUri(uri) {
+  const url = new URL(uri);
+  const protocol = url.protocol.replace(':', '');
+  const host = url.hostname;
+  const port = url.port ? parseInt(url.port, 10) : (protocol === 'mysql' ? 3306 : 5432);
+  const user = url.username || '';
+  const password = url.password || '';
+  const database = url.pathname ? url.pathname.replace(/^\//, '') : '';
+
+  return { host, port, user, password, database };
+}
+
+async function validateDatabaseConnection(config) {
+  const { dbType, dbUri, mongoUri, setupReplica, dbReplicaUri } = config;
+
+  console.log(chalk.gray(`\nTesting ${dbType} connection...`));
+
+  try {
+    if (dbType === 'mysql') {
+      await pingMysql(dbUri);
+      if (setupReplica && dbReplicaUri) await pingMysql(dbReplicaUri);
+    } else if (dbType === 'postgres') {
+      await pingPostgres(dbUri);
+      if (setupReplica && dbReplicaUri) await pingPostgres(dbReplicaUri);
+    } else {
+      await pingMongo(mongoUri);
+    }
+
+    console.log(chalk.green('Database connection successful'));
+    return true;
+  } catch (error) {
+    console.log(chalk.red(`Database connection failed: ${error.message}`));
+    return false;
+  }
+}
+
+async function validateRedisConnection(redisUri) {
+  console.log(chalk.gray('\nTesting Redis connection...'));
+
+  const redis = new Redis(redisUri, {
+    connectTimeout: 5000,
+    lazyConnect: true,
+    maxRetriesPerRequest: 1,
+  });
+  redis.on('error', () => {});
+
+  try {
+    await redis.connect();
+    await redis.ping();
+    console.log(chalk.green('Redis connection successful'));
+    return true;
+  } catch (error) {
+    console.log(chalk.red(`Redis connection failed: ${error.message}`));
+    return false;
+  } finally {
+    redis.disconnect();
+  }
+}
+
+async function validateAllConnections(config) {
+  console.log(chalk.cyan('\nValidating connections...'));
+
+  const dbValid = await validateDatabaseConnection(config);
+  const redisValid = await validateRedisConnection(config.redisUri);
+
+  if (dbValid && redisValid) {
+    console.log(chalk.green('\nAll connections validated successfully.\n'));
+    return true;
+  }
+
+  console.log(chalk.red('\nConnection validation failed.\n'));
+  return false;
+}
+
+async function pingMysql(uri) {
+  const parsed = parseDatabaseUri(uri);
+  const connection = await mysql.createConnection({
+    host: parsed.host,
+    port: parsed.port,
+    user: parsed.user,
+    password: parsed.password,
+    connectTimeout: 5000,
+  });
+  await connection.ping();
+  await connection.end();
+}
+
+async function pingPostgres(uri) {
+  const parsed = parseDatabaseUri(uri);
+  const client = new Client({
+    host: parsed.host,
+    port: parsed.port,
+    user: parsed.user,
+    password: parsed.password,
+    database: parsed.database || 'postgres',
+    connectionTimeoutMillis: 5000,
+  });
+  await client.connect();
+  await client.query('SELECT 1');
+  await client.end();
+}
+
+async function pingMongo(uri) {
+  const client = new MongoClient(uri, {
+    serverSelectionTimeoutMS: 5000,
+    connectTimeoutMS: 5000,
+  });
+  await client.connect();
+  const dbName = uri.match(/\/([^/?]+)(\?|$)/)?.[1] || 'enfyra';
+  await client.db(dbName).admin().ping();
+  await client.close();
+}
+
+module.exports = {
+  validateDatabaseConnection,
+  validateRedisConnection,
+  validateAllConnections,
+};

package/components/env-builder.js

@@ -0,0 +1,58 @@
+const crypto = require('crypto');
+const fs = require('fs-extra');
+const path = require('path');
+
+async function generateEnvFiles(projectPath, config) {
+  await fs.writeFile(path.join(projectPath, 'app', '.env'), buildAppEnv(config));
+  await fs.writeFile(path.join(projectPath, 'server', '.env'), buildServerEnv(config));
+}
+
+function buildAppEnv(config) {
+  return [
+    `API_URL=${config.apiUrl}`,
+    `PORT=${config.appPort}`,
+  ].join('\n') + '\n';
+}
+
+function buildServerEnv(config) {
+  const dbLines = [];
+
+  if (config.dbType === 'mongodb') {
+    dbLines.push(`DB_URI=${config.mongoUri}`);
+  } else {
+    dbLines.push(`DB_URI=${config.dbUri}`);
+    if (config.setupReplica && config.dbReplicaUri) {
+      dbLines.push(`DB_REPLICA_URIS=${config.dbReplicaUri}`);
+    }
+  }
+
+  return [
+    ...dbLines,
+    `REDIS_URI=${config.redisUri}`,
+    'DEFAULT_TTL=5',
+    'REDIS_RUNTIME_CACHE=false',
+    'REDIS_USER_CACHE_LIMIT_MB=30',
+    'REDIS_USER_CACHE_MAX_VALUE_BYTES=0',
+    `NODE_NAME=${toNodeName(config.projectName)}`,
+    `PORT=${config.serverPort}`,
+    `SECRET_KEY=${crypto.randomBytes(32).toString('hex')}`,
+    'SALT_ROUNDS=10',
+    'ACCESS_TOKEN_EXP=15m',
+    'REFRESH_TOKEN_NO_REMEMBER_EXP=1d',
+    'REFRESH_TOKEN_REMEMBER_EXP=7d',
+    `ADMIN_EMAIL=${config.adminEmail}`,
+    `ADMIN_PASSWORD=${config.adminPassword}`,
+    'NODE_ENV=development',
+    'BOOTSTRAP_VERBOSE=0',
+  ].join('\n') + '\n';
+}
+
+function toNodeName(projectName) {
+  return projectName.toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '') || 'enfyra';
+}
+
+module.exports = {
+  generateEnvFiles,
+  buildAppEnv,
+  buildServerEnv,
+};

package/components/package-managers.js

@@ -0,0 +1,51 @@
+const { execSync } = require('child_process');
+
+function detectPackageManagers() {
+  const managers = [];
+
+  for (const name of ['npm', 'yarn', 'pnpm']) {
+    try {
+      const version = execSync(`${name} --version`, {
+        encoding: 'utf8',
+        stdio: 'pipe',
+        shell: true,
+      }).trim();
+      managers.push({ name, value: name, version });
+    } catch {}
+  }
+
+  return managers;
+}
+
+function getWorkspaceRunCommand(packageManager, workspace, script) {
+  if (packageManager === 'yarn') return `yarn --cwd ${workspace} ${script}`;
+  if (packageManager === 'pnpm') return `pnpm --dir ${workspace} run ${script}`;
+  return `npm run ${script} -w ${workspace}`;
+}
+
+function getPackageRunCommand(packageManager, script) {
+  if (packageManager === 'yarn') return `yarn ${script}`;
+  if (packageManager === 'pnpm') return `pnpm run ${script}`;
+  return `npm run ${script}`;
+}
+
+function getPackageExecCommand(packageManager, binary, args = []) {
+  const suffix = [binary, ...args].join(' ');
+  if (packageManager === 'yarn') return `yarn exec ${suffix}`;
+  if (packageManager === 'pnpm') return `pnpm exec ${suffix}`;
+  return `npx ${suffix}`;
+}
+
+function getInstallCommand(packageManager) {
+  if (packageManager === 'yarn') return { command: 'yarn', args: ['install'] };
+  if (packageManager === 'pnpm') return { command: 'pnpm', args: ['install'] };
+  return { command: 'npm', args: ['install', '--legacy-peer-deps'] };
+}
+
+module.exports = {
+  detectPackageManagers,
+  getWorkspaceRunCommand,
+  getPackageRunCommand,
+  getPackageExecCommand,
+  getInstallCommand,
+};

package/components/port-guard.js

@@ -0,0 +1,89 @@
+const { execFileSync } = require('child_process');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const net = require('net');
+
+async function ensureServerPortAvailable(port) {
+  if (await isPortAvailable(port)) return;
+
+  const pids = getPortPids(port);
+  const pidText = pids.length ? ` PID(s): ${pids.join(', ')}` : '';
+  console.log(chalk.yellow(`Port ${port} is already in use.${pidText}`));
+
+  const { killPort } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'killPort',
+      message: `Kill the process using port ${port} and continue?`,
+      default: false,
+    },
+  ]);
+
+  if (!killPort) {
+    console.log(chalk.yellow(`Setup cancelled. Free port ${port} and run the command again.`));
+    process.exit(0);
+  }
+
+  if (!pids.length) {
+    console.log(chalk.red(`Could not identify the process using port ${port}.`));
+    process.exit(1);
+  }
+
+  for (const pid of pids) {
+    try {
+      process.kill(Number(pid), 'SIGTERM');
+    } catch {}
+  }
+
+  await wait(1200);
+
+  if (!(await isPortAvailable(port))) {
+    for (const pid of pids) {
+      try {
+        process.kill(Number(pid), 'SIGKILL');
+      } catch {}
+    }
+    await wait(800);
+  }
+
+  if (!(await isPortAvailable(port))) {
+    console.log(chalk.red(`Port ${port} is still busy. Please free it and try again.`));
+    process.exit(1);
+  }
+
+  console.log(chalk.green(`Port ${port} is available.`));
+}
+
+function isPortAvailable(port) {
+  const server = net.createServer();
+
+  return new Promise((resolve) => {
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, '0.0.0.0');
+  });
+}
+
+function getPortPids(port) {
+  try {
+    const output = execFileSync('lsof', ['-ti', `tcp:${port}`], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return output.split('\n').map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  ensureServerPortAvailable,
+  isPortAvailable,
+  getPortPids,
+};

package/components/project-setup.js

@@ -0,0 +1,387 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const { downloadTemplate } = require('giget');
+const { generateEnvFiles } = require('./env-builder');
+const {
+  getInstallCommand,
+  getPackageExecCommand,
+  getWorkspaceRunCommand,
+} = require('./package-managers');
+
+async function createProject(config, projectPath) {
+  const spinner = ora();
+
+  try {
+    spinner.start(chalk.blue('Creating workspace...'));
+    await fs.ensureDir(projectPath);
+    spinner.succeed(chalk.green('Workspace created'));
+
+    spinner.start(chalk.blue('Downloading Enfyra app...'));
+    await downloadTemplate('github:enfyra/app', {
+      dir: path.join(projectPath, 'app'),
+      force: true,
+      provider: 'github',
+    });
+    spinner.succeed(chalk.green('App downloaded'));
+
+    spinner.start(chalk.blue('Downloading Enfyra server...'));
+    await downloadTemplate('github:enfyra/server', {
+      dir: path.join(projectPath, 'server'),
+      force: true,
+      provider: 'github',
+    });
+    spinner.succeed(chalk.green('Server downloaded'));
+
+    spinner.start(chalk.blue(`Preparing ${config.packageManager} workspaces...`));
+    await removeTemplateFiles(projectPath);
+    await cleanPackageManagerRestrictions(projectPath);
+    await updateWorkspacePackageJson(projectPath, config);
+    await writePackageManagerConfig(projectPath, config);
+    await updateAppPackageJson(path.join(projectPath, 'app'), config);
+    await updateServerPackageJson(path.join(projectPath, 'server'), config);
+    spinner.succeed(chalk.green(`${config.packageManager} workspaces prepared`));
+
+    spinner.start(chalk.blue('Generating environment files...'));
+    await generateEnvFiles(projectPath, config);
+    spinner.succeed(chalk.green('Environment files created'));
+
+    spinner.start(chalk.blue(`Installing dependencies with ${config.packageManager}...`));
+    await installDependencies(projectPath, config.packageManager);
+    spinner.succeed(chalk.green('Dependencies installed'));
+  } catch (error) {
+    spinner.fail(chalk.red('Setup failed'));
+
+    if (fs.existsSync(projectPath)) {
+      await fs.remove(projectPath);
+    }
+
+    throw error;
+  }
+}
+
+async function updateWorkspacePackageJson(projectPath, config) {
+  const packageName = toPackageName(config.projectName);
+  const packageManager = config.packageManager;
+  const resolutions = await collectTemplateResolutions(projectPath);
+  const packageJson = {
+    name: packageName,
+    version: '0.1.0',
+    private: true,
+    workspaces: [
+      'app',
+      'server',
+    ],
+    scripts: {
+      dev: `concurrently -k -n server,app -c cyan,green "${getWorkspaceRunCommand(packageManager, 'server', 'dev')}" "${getPackageExecCommand(packageManager, 'wait-on', [`http://localhost:${config.serverPort}`])} && ${getWorkspaceRunCommand(packageManager, 'app', 'dev')}"`,
+      'dev:app': getWorkspaceRunCommand(packageManager, 'app', 'dev'),
+      'dev:server': getWorkspaceRunCommand(packageManager, 'server', 'dev'),
+      build: `${getWorkspaceRunCommand(packageManager, 'server', 'build')} && ${getWorkspaceRunCommand(packageManager, 'app', 'build')}`,
+      'build:app': getWorkspaceRunCommand(packageManager, 'app', 'build'),
+      'build:server': getWorkspaceRunCommand(packageManager, 'server', 'build'),
+      start: getWorkspaceRunCommand(packageManager, 'server', 'start'),
+    },
+    devDependencies: {
+      concurrently: '^9.2.1',
+      'wait-on': '^8.0.3',
+    },
+  };
+
+  if (config.packageManagerVersion) {
+    packageJson.packageManager = `${packageManager}@${config.packageManagerVersion}`;
+  }
+
+  if (packageManager === 'yarn' && Object.keys(resolutions).length > 0) {
+    packageJson.resolutions = resolutions;
+  }
+
+  await fs.writeJson(path.join(projectPath, 'package.json'), packageJson, { spaces: 2 });
+  await fs.writeFile(path.join(projectPath, '.gitignore'), buildGitignore());
+  await ensureWorkspaceGitignores(projectPath);
+  if (packageManager === 'pnpm') {
+    await fs.writeFile(path.join(projectPath, 'pnpm-workspace.yaml'), buildPnpmWorkspaceYaml(resolutions, config.packageManagerVersion));
+  }
+}
+
+async function writePackageManagerConfig(projectPath, config) {
+  if (config.packageManager !== 'yarn') return;
+
+  await fs.writeFile(
+    path.join(projectPath, '.yarnrc.yml'),
+    [
+      'approvedGitRepositories:',
+      '  - "**"',
+      '',
+      'enableScripts: true',
+      '',
+      'nodeLinker: node-modules',
+      '',
+      'npmMinimalAgeGate: 0',
+      '',
+    ].join('\n'),
+  );
+}
+
+async function updateAppPackageJson(appPath, config) {
+  const packageJsonPath = path.join(appPath, 'package.json');
+  const packageJson = await fs.readJson(packageJsonPath);
+
+  packageJson.name = `${toPackageName(config.projectName)}-app`;
+  packageJson.version = '0.1.0';
+  delete packageJson.packageManager;
+  delete packageJson.repository;
+  delete packageJson.bugs;
+  delete packageJson.homepage;
+  if (config.packageManager === 'pnpm') delete packageJson.resolutions;
+
+  if (packageJson.engines) {
+    delete packageJson.engines.npm;
+    delete packageJson.engines.yarn;
+    delete packageJson.engines.pnpm;
+    if (Object.keys(packageJson.engines).length === 0) delete packageJson.engines;
+  }
+
+  ensureAppDirectDependencies(packageJson);
+
+  await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+
+async function updateServerPackageJson(serverPath, config) {
+  const packageJsonPath = path.join(serverPath, 'package.json');
+  const packageJson = await fs.readJson(packageJsonPath);
+
+  packageJson.name = `${toPackageName(config.projectName)}-server`;
+  packageJson.version = '0.1.0';
+  delete packageJson.packageManager;
+  delete packageJson.repository;
+  delete packageJson.bugs;
+  delete packageJson.homepage;
+  if (config.packageManager === 'pnpm') delete packageJson.resolutions;
+
+  if (packageJson.engines) {
+    delete packageJson.engines.npm;
+    delete packageJson.engines.yarn;
+    delete packageJson.engines.pnpm;
+    if (Object.keys(packageJson.engines).length === 0) delete packageJson.engines;
+  }
+
+  rewritePackageManagerScripts(packageJson, config.packageManager);
+
+  await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+}
+
+async function removeTemplateFiles(projectPath) {
+  const paths = [
+    '.github',
+    path.join('app', '.github'),
+    path.join('server', '.github'),
+  ];
+
+  for (const relativePath of paths) {
+    const fullPath = path.join(projectPath, relativePath);
+    if (fs.existsSync(fullPath)) await fs.remove(fullPath);
+  }
+}
+
+async function cleanPackageManagerRestrictions(projectPath) {
+  const files = [
+    '.npmrc',
+    '.yarnrc',
+    '.yarnrc.yml',
+    'pnpm-workspace.yaml',
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    '.pnp.cjs',
+    '.pnp.loader.mjs',
+  ];
+  const directories = [
+    '.yarn',
+  ];
+
+  for (const workspace of ['', 'app', 'server']) {
+    for (const file of files) {
+      const filePath = path.join(projectPath, workspace, file);
+      if (fs.existsSync(filePath)) await fs.remove(filePath);
+    }
+    for (const directory of directories) {
+      const directoryPath = path.join(projectPath, workspace, directory);
+      if (fs.existsSync(directoryPath)) await fs.remove(directoryPath);
+    }
+  }
+}
+
+function rewritePackageManagerScripts(packageJson, packageManager = 'npm') {
+  if (!packageJson.scripts) return;
+
+  const runCommand = packageManager === 'yarn' ? 'yarn' : `${packageManager} run`;
+  for (const [name, script] of Object.entries(packageJson.scripts)) {
+    if (typeof script !== 'string') continue;
+    packageJson.scripts[name] = script.replace(/\byarn\s+([A-Za-z0-9:_-]+)/g, `${runCommand} $1`);
+  }
+}
+
+function ensureAppDirectDependencies(packageJson) {
+  packageJson.dependencies ||= {};
+  const tiptapVersion = packageJson.dependencies['@tiptap/core'] || packageJson.dependencies['@tiptap/starter-kit'] || '3.15.3';
+
+  for (const dependency of [
+    '@tiptap/extension-link',
+    '@tiptap/extension-placeholder',
+    '@tiptap/extension-underline',
+    '@tiptap/extensions',
+  ]) {
+    packageJson.dependencies[dependency] ||= tiptapVersion;
+  }
+}
+
+function installDependencies(projectPath, packageManager) {
+  return new Promise((resolve, reject) => {
+    const { command, args } = getInstallCommand(packageManager);
+    const install = spawn(command, args, {
+      cwd: projectPath,
+      stdio: 'pipe',
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    install.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    install.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    install.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error(stderr || stdout || `npm install failed with code ${code}`));
+    });
+
+    install.on('error', (error) => {
+      reject(new Error(`${command} spawn error: ${error.message}`));
+    });
+  });
+}
+
+function buildGitignore() {
+  return [
+    'node_modules',
+    '.env',
+    '.env.*',
+    '!.env.example',
+    '.nuxt',
+    '.output',
+    'dist',
+    'logs',
+    '*.log',
+    '.DS_Store',
+  ].join('\n') + '\n';
+}
+
+async function ensureWorkspaceGitignores(projectPath) {
+  for (const workspace of ['app', 'server']) {
+    const gitignorePath = path.join(projectPath, workspace, '.gitignore');
+    const existing = fs.existsSync(gitignorePath) ? await fs.readFile(gitignorePath, 'utf8') : '';
+    const next = mergeGitignoreEntries(existing, ['.env', '.env.*', '!.env.example']);
+    await fs.writeFile(gitignorePath, next);
+  }
+}
+
+function mergeGitignoreEntries(content, entries) {
+  const lines = content.split(/\r?\n/);
+  const existing = new Set(lines.map((line) => line.trim()));
+
+  for (const entry of entries) {
+    if (!existing.has(entry)) lines.push(entry);
+  }
+
+  return `${lines.join('\n').replace(/\n+$/, '')}\n`;
+}
+
+async function collectTemplateResolutions(projectPath) {
+  const resolutions = {};
+
+  for (const workspace of ['app', 'server']) {
+    const packageJsonPath = path.join(projectPath, workspace, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) continue;
+
+    const packageJson = await fs.readJson(packageJsonPath);
+    Object.assign(resolutions, packageJson.resolutions || {});
+  }
+
+  return resolutions;
+}
+
+function buildPnpmWorkspaceYaml(resolutions, pnpmVersion) {
+  const allowedBuildDependencies = [
+    '@parcel/watcher',
+    'esbuild',
+    'isolated-vm',
+    'msgpackr-extract',
+    'sharp',
+    'vue-demi',
+  ];
+  const lines = [
+    'packages:',
+    '  - app',
+    '  - server',
+    '',
+  ];
+
+  if (getMajorVersion(pnpmVersion) >= 11) {
+    lines.push('allowBuilds:');
+    for (const dependency of allowedBuildDependencies) {
+      lines.push(`  ${yamlQuote(dependency)}: true`);
+    }
+  } else {
+    lines.push('onlyBuiltDependencies:');
+    for (const dependency of allowedBuildDependencies) {
+      lines.push(`  - ${yamlQuote(dependency)}`);
+    }
+  }
+
+  const overrideEntries = Object.entries(resolutions);
+  if (overrideEntries.length > 0) {
+    lines.push('', 'overrides:');
+    for (const [name, version] of overrideEntries) {
+      lines.push(`  ${yamlQuote(name)}: ${yamlQuote(version)}`);
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function yamlQuote(value) {
+  return JSON.stringify(String(value));
+}
+
+function getMajorVersion(version) {
+  const major = Number(String(version || '').split('.')[0]);
+  return Number.isFinite(major) && major > 0 ? major : 11;
+}
+
+function toPackageName(projectName) {
+  return projectName
+    .toLowerCase()
+    .replace(/_/g, '-')
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'enfyra';
+}
+
+module.exports = {
+  createProject,
+  cleanPackageManagerRestrictions,
+  rewritePackageManagerScripts,
+  toPackageName,
+  buildPnpmWorkspaceYaml,
+  ensureAppDirectDependencies,
+  mergeGitignoreEntries,
+};

package/components/prompts.js

@@ -0,0 +1,136 @@
+const validators = require('./validators');
+
+function getPrompts(projectNameArg, options = {}) {
+  const prompts = [];
+
+  if (!projectNameArg && !options.connectionOnly) {
+    prompts.push({
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: 'my-enfyra',
+      validate: validators.validateProjectName,
+    });
+  }
+
+  if (!options.connectionOnly) {
+    prompts.push({
+      type: 'list',
+      name: 'packageManager',
+      message: 'Package manager:',
+      choices: options.packageManagers.map((pm) => ({
+        name: `${getPackageManagerIcon(pm.name)} ${pm.name} (v${pm.version})`,
+        value: pm.value,
+        short: pm.name,
+      })),
+      default: options.packageManagers.find((pm) => pm.value === 'npm')?.value || options.packageManagers[0]?.value,
+    });
+  }
+
+  prompts.push(
+    {
+      type: 'list',
+      name: 'dbType',
+      message: 'Database type:',
+      choices: [
+        { name: 'MySQL', value: 'mysql' },
+        { name: 'PostgreSQL', value: 'postgres' },
+        { name: 'MongoDB', value: 'mongodb' },
+      ],
+      default: 'mysql',
+    },
+    {
+      type: 'input',
+      name: 'dbUri',
+      message: (answers) => {
+        if (answers.dbType === 'postgres') return 'Database URI (postgresql://postgres:password@host:port/database):';
+        return 'Database URI (mysql://user:password@host:port/database):';
+      },
+      default: (answers) => {
+        if (answers.dbType === 'postgres') return 'postgresql://postgres:postgres@localhost:5432/enfyra';
+        return 'mysql://root:1234@localhost:3306/enfyra';
+      },
+      when: (answers) => answers.dbType !== 'mongodb',
+      validate: validators.dbUri,
+    },
+    {
+      type: 'input',
+      name: 'mongoUri',
+      message: 'MongoDB URI:',
+      default: 'mongodb://enfyra_admin:enfyra_password_123@localhost:27017/enfyra?authSource=admin',
+      when: (answers) => answers.dbType === 'mongodb',
+      validate: validators.mongoUri,
+    },
+    {
+      type: 'confirm',
+      name: 'setupReplica',
+      message: 'Setup read replica?',
+      default: false,
+      when: (answers) => answers.dbType !== 'mongodb',
+    },
+    {
+      type: 'input',
+      name: 'dbReplicaUri',
+      message: (answers) => {
+        if (answers.dbType === 'postgres') return 'Replica URI (postgresql://postgres:password@host:port/database):';
+        return 'Replica URI (mysql://user:password@host:port/database):';
+      },
+      default: (answers) => {
+        if (answers.dbType === 'postgres') return 'postgresql://postgres:postgres@localhost:5433/enfyra';
+        return 'mysql://root:1234@localhost:3307/enfyra';
+      },
+      when: (answers) => answers.setupReplica === true && answers.dbType !== 'mongodb',
+      validate: validators.dbUri,
+    },
+    {
+      type: 'input',
+      name: 'redisUri',
+      message: 'Redis URI:',
+      default: 'redis://localhost:6379',
+      validate: validators.redisUri,
+    },
+  );
+
+  if (!options.connectionOnly) {
+    prompts.push(
+      {
+        type: 'input',
+        name: 'adminEmail',
+        message: 'Admin email:',
+        validate: validators.email,
+      },
+      {
+        type: 'password',
+        name: 'adminPassword',
+        message: 'Admin password:',
+        mask: '*',
+        validate: validators.adminPassword,
+      },
+    );
+  }
+
+  return prompts;
+}
+
+function getConfirmationPrompt() {
+  return {
+    type: 'confirm',
+    name: 'confirm',
+    message: 'Create Enfyra workspace with app/ and server/?',
+    default: true,
+  };
+}
+
+function getPackageManagerIcon(name) {
+  const icons = {
+    npm: '📦',
+    yarn: '🧶',
+    pnpm: '⚡',
+  };
+  return icons[name] || '📦';
+}
+
+module.exports = {
+  getPrompts,
+  getConfirmationPrompt,
+};

package/components/validators.js

@@ -0,0 +1,76 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+function validateProjectName(input) {
+  if (!input || !input.trim()) return 'Project name is required';
+  if (!/^[a-zA-Z0-9-_]+$/.test(input)) return 'Only letters, numbers, - and _ allowed';
+  if (fs.existsSync(path.join(process.cwd(), input))) return `Directory ${input} already exists`;
+  return true;
+}
+
+function checkNodeVersion() {
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split('.')[0], 10);
+  if (major !== 24) {
+    console.log(chalk.red(`Node.js version ${nodeVersion} is not supported.`));
+    console.log(chalk.yellow('Enfyra Server requires Node.js 24.x.'));
+    process.exit(1);
+  }
+}
+
+function dbUri(input) {
+  if (!input.trim()) return 'Database URI is required';
+  if (!input.startsWith('mysql://') && !input.startsWith('postgresql://') && !input.startsWith('postgres://')) {
+    return 'Must start with mysql://, postgresql://, or postgres://';
+  }
+  try {
+    const url = new URL(input);
+    if (!url.hostname) return 'Invalid URI: hostname is required';
+    if (!url.pathname || url.pathname === '/') return 'Invalid URI: database name is required';
+    return true;
+  } catch {
+    return 'Invalid URI format';
+  }
+}
+
+function mongoUri(input) {
+  if (!input.trim()) return 'MongoDB URI is required';
+  if (!input.startsWith('mongodb://') && !input.startsWith('mongodb+srv://')) {
+    return 'Must start with mongodb:// or mongodb+srv://';
+  }
+  try {
+    const url = new URL(input);
+    if (!url.hostname) return 'Invalid URI: hostname is required';
+    return true;
+  } catch {
+    return 'Invalid URI format';
+  }
+}
+
+function redisUri(input) {
+  if (!input.trim()) return 'Redis is required for Enfyra';
+  if (!input.startsWith('redis://')) return 'Must start with redis://';
+  return true;
+}
+
+function email(input) {
+  if (!input.trim()) return 'Email is required';
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input)) return 'Invalid email format';
+  return true;
+}
+
+function adminPassword(input) {
+  if (!input || input.length < 4) return 'Password must be at least 4 characters';
+  return true;
+}
+
+module.exports = {
+  validateProjectName,
+  checkNodeVersion,
+  dbUri,
+  mongoUri,
+  redisUri,
+  email,
+  adminPassword,
+};

package/index.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const inquirer = require('inquirer');
+const packageJson = require('./package.json');
+const { validateProjectName, checkNodeVersion } = require('./components/validators');
+const { getPrompts, getConfirmationPrompt } = require('./components/prompts');
+const { ensureServerPortAvailable } = require('./components/port-guard');
+const { validateAllConnections } = require('./components/connection-validator');
+const { createProject } = require('./components/project-setup');
+const { detectPackageManagers, getWorkspaceRunCommand, getPackageRunCommand } = require('./components/package-managers');
+
+const SERVER_PORT = 1105;
+
+const banner = `
+${chalk.cyan.bold('╔═══════════════════════════════════════╗')}
+${chalk.cyan.bold('║')}  ${chalk.white.bold('Create Enfyra')}                      ${chalk.cyan.bold('║')}
+${chalk.cyan.bold('║')}  ${chalk.gray('App + Server in one workspace')}      ${chalk.cyan.bold('║')}
+${chalk.cyan.bold('╚═══════════════════════════════════════╝')}
+`;
+
+async function main() {
+  const program = new Command();
+
+  program
+    .name('create')
+    .description('Create a complete Enfyra app and server workspace')
+    .version(packageJson.version)
+    .argument('[project-name]', 'Name of the project to create')
+    .option('--skip-connection-check', 'Skip database and Redis connection checks')
+    .parse();
+
+  console.log(banner);
+  checkNodeVersion();
+  const packageManagers = detectPackageManagers();
+  if (packageManagers.length === 0) {
+    console.log(chalk.red('No compatible package manager found.'));
+    console.log(chalk.yellow('Please install npm, yarn, or pnpm.'));
+    process.exit(1);
+  }
+  console.log(chalk.gray('Detected package managers:'));
+  for (const manager of packageManagers) {
+    console.log(chalk.gray(`  • ${manager.name} v${manager.version}`));
+  }
+  console.log('');
+
+  let projectName = program.args[0];
+  if (projectName) {
+    const validation = validateProjectName(projectName);
+    if (validation !== true) {
+      console.log(chalk.red(`Invalid project name: ${validation}`));
+      projectName = null;
+    }
+  }
+
+  const answers = await inquirer.prompt(getPrompts(projectName, { packageManagers }));
+  const selectedPackageManager = packageManagers.find((pm) => pm.value === answers.packageManager);
+  const config = {
+    ...answers,
+    projectName: projectName || answers.projectName,
+    packageManager: answers.packageManager,
+    packageManagerVersion: selectedPackageManager?.version,
+    appPort: 3000,
+    serverPort: SERVER_PORT,
+    apiUrl: `http://localhost:${SERVER_PORT}`,
+  };
+
+  const projectPath = path.resolve(config.projectName);
+  if (fs.existsSync(projectPath)) {
+    console.log(chalk.red(`Directory ${chalk.bold(config.projectName)} already exists.`));
+    process.exit(1);
+  }
+
+  await ensureServerPortAvailable(SERVER_PORT);
+
+  if (!program.opts().skipConnectionCheck) {
+    let connectionsValid = false;
+    while (!connectionsValid) {
+      connectionsValid = await validateAllConnections(config);
+
+      if (!connectionsValid) {
+        const { retry } = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'retry',
+            message: 'What would you like to do?',
+            choices: [
+              { name: 'Re-enter connection details', value: 'retry' },
+              { name: 'Continue anyway and create the project', value: 'continue' },
+              { name: 'Exit setup', value: 'exit' },
+            ],
+          },
+        ]);
+
+        if (retry === 'continue') {
+          console.log(chalk.yellow('\nContinuing without verified database/Redis connections.'));
+          break;
+        }
+
+        if (retry === 'exit') {
+          console.log(chalk.yellow('\nSetup cancelled. Fix your connections and try again later.'));
+          process.exit(0);
+        }
+
+        const connectionConfig = await inquirer.prompt(
+          getPrompts(config.projectName, { connectionOnly: true }),
+        );
+        Object.assign(config, connectionConfig);
+      }
+    }
+  }
+
+  const { confirm } = await inquirer.prompt([getConfirmationPrompt()]);
+  if (!confirm) {
+    console.log(chalk.yellow('\nInstallation cancelled.'));
+    process.exit(0);
+  }
+
+  try {
+    await createProject(config, projectPath);
+
+    console.log(chalk.green.bold('\nProject created successfully.'));
+    console.log(chalk.cyan('\nNext steps:'));
+    console.log(chalk.gray(`  cd ${config.projectName}`));
+    console.log(chalk.gray(`  ${getPackageRunCommand(config.packageManager, 'dev')}`));
+    console.log(chalk.gray('\nIndividual workspaces:'));
+    console.log(chalk.gray(`  ${getWorkspaceRunCommand(config.packageManager, 'server', 'dev')}`));
+    console.log(chalk.gray(`  ${getWorkspaceRunCommand(config.packageManager, 'app', 'dev')}`));
+    console.log(chalk.yellow('\nKeep server/.env SECRET_KEY stable and backed up.'));
+  } catch (error) {
+    console.error(chalk.red.bold('\nSetup failed:'));
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+process.on('unhandledRejection', (error) => {
+  console.error(chalk.red(`\nUnexpected error: ${error.message}`));
+  process.exit(1);
+});
+
+main();

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@enfyra/create",
+  "version": "0.1.0",
+  "description": "Create a complete Enfyra app with frontend and server workspaces",
+  "main": "index.js",
+  "bin": {
+    "create-enfyra": "index.js"
+  },
+  "preferGlobal": true,
+  "engines": {
+    "node": ">=24.0.0 <25"
+  },
+  "scripts": {
+    "test": "node --check index.js && node --check components/*.js"
+  },
+  "keywords": [
+    "enfyra",
+    "create",
+    "nuxt",
+    "server",
+    "baas",
+    "cli",
+    "scaffold"
+  ],
+  "author": "Enfyra Team",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.1.1",
+    "giget": "^2.0.0",
+    "inquirer": "^8.2.5",
+    "ioredis": "^5.3.2",
+    "mongodb": "^6.3.0",
+    "mysql2": "^3.6.0",
+    "ora": "^5.4.1",
+    "pg": "^8.11.0",
+    "wait-on": "^8.0.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/enfyra/create.git"
+  },
+  "bugs": {
+    "url": "https://github.com/enfyra/create/issues"
+  },
+  "homepage": "https://github.com/enfyra/create#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "index.js",
+    "components",
+    "README.md",
+    "LICENSE"
+  ]
+}