@nutin/cli 1.3.1 → 2.1.0

package/templates/base/tools/utils/run-command.test.js.hbs

@@ -0,0 +1,19 @@
+import { runCommand } from './run-command.js';
+
+describe('runCommand', () => {
+  it('resolves when the child process exits with code 0', async () => {
+    const result = await runCommand('node', ['-e', 'process.exitCode=0']);
+    expect(result).toBe(undefined);
+  });
+
+  it('rejects with the exit code when the child process exits non-zero', async () => {
+    let error;
+    try {
+      await runCommand('node', ['-e', 'process.exitCode=7']);
+    } catch (err) {
+      error = err;
+    }
+    expect(error).toBeDefined();
+    expect(error.message).toContain('7');
+  });
+});

package/templates/base/tools/utils/run-script.js.hbs

@@ -4,17 +4,28 @@ import process from 'process';
 import { print } from './index.js';
 
 export function runScript(path, message) {
-  print.boldSection(message);
+  if (!message) print.boldSection(`Running ${path}...`);
+  else print.boldSection(`${message}`);
 
-  const args = [resolve(path)];
+  const args = [resolve(path), '--silent'];
 
-  const result = spawnSync('node', args, 
+  const result = spawnSync('node', args,
     { 
       stdio: 'inherit',
       env: { ...process.env }, 
     }
   );
 
+  if (result.error) {
+    print.boldError(`\nScript ${path} could not be started: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if (result.signal) {
+    print.boldError(`\nScript ${path} was terminated by signal ${result.signal}.`);
+    process.exit(1);
+  }
+
   if (result.status !== 0) {
     print.boldError(`\nScript ${path} failed.`);
     process.exit(result.status ?? 1);

package/templates/base/tools/utils/run-script.test.js.hbs

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { runScript } from './run-script.js';
+
+describe('runScript', () => {
+  let tmpDir;
+  let exitSpy;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-run-script-'));
+    exitSpy = spyOn(process, 'exit').andCallFake(() => {});
+  });
+
+  afterEach(() => {
+    exitSpy.restore();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('does not call process.exit when the script exits 0', () => {
+    const scriptPath = path.join(tmpDir, 'ok.js');
+    fs.writeFileSync(scriptPath, '// no-op, exits 0 by default\n');
+
+    // runScript prints its status message via console.info as part of its real behavior
+    silenceConsole('info', () => runScript(scriptPath, 'running ok script'));
+
+    expect(exitSpy.callCount).toBe(0);
+  });
+
+  it('calls process.exit with the script status when it exits non-zero', () => {
+    const scriptPath = path.join(tmpDir, 'fail.js');
+    fs.writeFileSync(scriptPath, 'process.exitCode = 3;\n');
+
+    // runScript prints its status message and a failure message via console.info/console.error
+    silenceConsole(['info', 'error'], () => runScript(scriptPath, 'running failing script'));
+
+    expect(exitSpy.callCount).toBe(1);
+    expect(exitSpy.lastCall).toEqual([3]);
+  });
+});

package/templates/features/{deployHelper → docker}/.dockerignore.hbs

@@ -8,13 +8,13 @@ dist-build
 *.md
 .env
 *.txt
-{{#if testinNutin}}
 *.test.js
-testin-nutin
-{{/if}}
 *.log
 
-npm-debug.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
 .nyc_output
 coverage
 .DS_Store

package/templates/features/docker/tools/docker/Dockerfile.template.hbs

@@ -0,0 +1,51 @@
+ARG NODE_VERSION=22.23.2
+ARG ALPINE_VERSION=3.20
+ARG PORT="__PORTS_PLACEHOLDER__"
+
+FROM node:${NODE_VERSION}-alpine AS builder
+WORKDIR /usr/src/app
+RUN corepack enable
+{{#if (eq packageManager "npm")}}
+COPY package.json package-lock.json* .
+{{/if}}
+{{#if (eq packageManager "pnpm")}}
+COPY package.json pnpm-lock.yaml .
+{{/if}}
+{{#if (eq packageManager "yarn")}}
+COPY package.json yarn.lock .
+{{/if}}
+{{#if (eq packageManager "bun")}}
+COPY package.json bun.lock* bun.lockb* .
+RUN npm install -g bun
+{{/if}}
+{{#if (eq packageManager "pnpm")}}
+RUN {{ciCommand}} || pnpm approve-builds --all
+{{else}}
+RUN {{ciCommand}}
+{{/if}}
+COPY tsconfig.json .
+COPY ./src ./src
+COPY ./public ./public
+COPY ./nutin.config.js .
+COPY ./config ./config
+COPY ./tools/builder ./tools/builder
+COPY ./tools/docker ./tools/docker
+COPY ./tools/utils ./tools/utils
+RUN {{packageManager}} run build:prod
+
+FROM alpine:${ALPINE_VERSION}
+ARG PORT
+ENV PORT=${PORT}
+
+RUN apk add --no-cache nginx nginx-mod-http-brotli
+
+RUN rm -f /etc/nginx/http.d/default.conf
+COPY --from=builder /usr/src/app/tools/docker/nginx.conf /etc/nginx/http.d/default.conf
+COPY --from=builder /usr/src/app/dist/src /usr/share/nginx/html
+
+EXPOSE ${PORT}
+
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://127.0.0.1:__PRIMARY_PORT_PLACEHOLDER__/health || exit 1
+
+CMD ["nginx", "-g", "daemon off;"]

package/templates/features/{deployHelper/tools/deployment/nginx.conf.hbs → docker/tools/docker/nginx.conf.template}

@@ -30,14 +30,16 @@ map $uri $csp_policy {
 # ---------------------------
 gzip on;
 gzip_static on;
-gzip_vary on;
 gzip_proxied any;
 
+brotli on;
+brotli_static on;
+
 server {
     # ---------------------------
     # LISTEN PORTS
     # ---------------------------
-    listen 9090;
+    __PORTS_PLACEHOLDER__
     server_name _;
 
     # ---------------------------

package/templates/features/docker/tools/docker/scripts/docker-build.js.hbs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import { readFileSync } from 'fs';
+import { spawn } from 'child_process';
+import { print, runScript } from '../../utils/index.js';
+
+const { name: projectName } = JSON.parse(readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'));
+
+runScript(path.join(process.cwd(), 'tools', 'docker', 'scripts', 'validate-docker.js'), 'Validating Docker configuration...');
+
+const args = ['build', '-t', projectName, '-f', 'tools/docker/Dockerfile', '.'];
+print.boldSection(`Running: docker ${args.join(' ')}`);
+
+const child = spawn('docker', args, { stdio: 'inherit' });
+child.on('error', (err) => {
+  print.boldError(`Failed to start docker: ${err.message}`);
+  process.exit(1);
+});
+child.on('exit', (code) => process.exit(code ?? 1));

package/templates/features/docker/tools/docker/scripts/docker-ports.js.hbs

@@ -0,0 +1,48 @@
+// Registered/user port range only — excludes privileged ports (<1024, may need
+// elevated host privileges to bind) and the OS ephemeral range (>=49152, reserved
+// for outgoing/dynamic connections, not meant for fixed service ports).
+const MIN_PORT = 1024;
+const MAX_PORT = 49151;
+
+export function validateDockerPorts(rawPorts) {
+  if (rawPorts === undefined) {
+    throw new Error('nutin.config.js: "dockerPorts" not found. It must be an array of integers (e.g. [9090, 6969])');
+  }
+
+  if (!Array.isArray(rawPorts)) {
+    throw new Error('nutin.config.js: "dockerPorts" must be an array of integers (e.g. [9090, 6969]).');
+  }
+
+  if (rawPorts.length === 0) {
+    throw new Error('nutin.config.js: "dockerPorts" must contain at least one port (e.g. [9090]).');
+  }
+
+  const seen = new Set();
+
+  for (let i = 0; i < rawPorts.length; i++) {
+    const port = rawPorts[i];
+
+    if (typeof port !== 'number' || !Number.isInteger(port)) {
+      throw new Error(`nutin.config.js: "dockerPorts[${i}]" must be an integer; ports must be numbers, e.g. 9090 not "9090".`);
+    }
+
+    if (port < MIN_PORT) {
+      throw new Error(`nutin.config.js: "dockerPorts[${i}]" (${port}) is a privileged port (<1024) — use a registered port between ${MIN_PORT} and ${MAX_PORT}.`);
+    }
+
+    if (port > MAX_PORT) {
+      throw new Error(`nutin.config.js: "dockerPorts[${i}]" (${port}) is in the OS ephemeral port range (49152-65535) — use a registered port between ${MIN_PORT} and ${MAX_PORT}.`);
+    }
+
+    if (port < MIN_PORT || port > MAX_PORT) {
+      throw new Error(`nutin.config.js: "dockerPorts[${i}]" (${port}) is outside of port range (${MIN_PORT} / ${MAX_PORT} .`);
+    }
+
+    if (seen.has(port)) {
+      throw new Error(`nutin.config.js: "dockerPorts" contains duplicate port ${port} — each port must be listed once.`);
+    }
+    seen.add(port);
+  }
+
+  return rawPorts;
+}

package/templates/features/docker/tools/docker/scripts/docker-ports.test.js.hbs

@@ -0,0 +1,52 @@
+import { validateDockerPorts } from './docker-ports.js';
+
+describe('validateDockerPorts', () => {
+  it('throws when dockerPorts is not set', () => {
+    expect(() => validateDockerPorts(undefined)).toThrow('"dockerPorts" not found');
+  });
+
+  it('throws when dockerPorts is not an array', () => {
+    expect(() => validateDockerPorts(9090)).toThrow('must be an array of integers');
+    expect(() => validateDockerPorts('9090')).toThrow('must be an array of integers');
+    expect(() => validateDockerPorts({ port: 9090 })).toThrow('must be an array of integers');
+  });
+
+  it('throws when dockerPorts is empty', () => {
+    expect(() => validateDockerPorts([])).toThrow('must contain at least one port');
+  });
+
+  it('throws when an entry is not an integer', () => {
+    expect(() => validateDockerPorts(['8080'])).toThrow('must be an integer');
+    expect(() => validateDockerPorts([8080.5])).toThrow('must be an integer');
+    expect(() => validateDockerPorts([NaN])).toThrow('must be an integer');
+    expect(() => validateDockerPorts([true])).toThrow('must be an integer');
+    expect(() => validateDockerPorts([null])).toThrow('must be an integer');
+  });
+
+  it('throws for privileged ports below 1024', () => {
+    expect(() => validateDockerPorts([80])).toThrow('privileged port');
+    expect(() => validateDockerPorts([1023])).toThrow('privileged port');
+  });
+
+  it('throws for ephemeral ports at or above 49152', () => {
+    expect(() => validateDockerPorts([49152])).toThrow('ephemeral port range');
+    expect(() => validateDockerPorts([60000])).toThrow('ephemeral port range');
+  });
+
+  it('throws for duplicate ports', () => {
+    expect(() => validateDockerPorts([8080, 8080])).toThrow('duplicate port');
+  });
+
+  it('identifies the invalid entry by index in the error message', () => {
+    expect(() => validateDockerPorts([8080, 80])).toThrow('dockerPorts[1]');
+  });
+
+  it('accepts the registered-port range boundaries', () => {
+    expect(validateDockerPorts([1024])).toEqual([1024]);
+    expect(validateDockerPorts([49151])).toEqual([49151]);
+  });
+
+  it('returns a valid multi-port array unchanged', () => {
+    expect(validateDockerPorts([8080, 8081, 3000])).toEqual([8080, 8081, 3000]);
+  });
+});

package/templates/features/docker/tools/docker/scripts/docker-run.js.hbs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { print, errorExit } from '../../utils/index.js';
+import nutinConfig from '../../../nutin.config.js';
+import { validateDockerPorts } from './docker-ports.js';
+
+const { name: projectName } = JSON.parse(readFileSync(path.join(process.cwd(), 'package.json'), 'utf-8'));
+
+let ports;
+try {
+  ports = validateDockerPorts(nutinConfig.dockerPorts);
+} catch (err) {
+  errorExit(err.message);
+}
+
+const portArgs = ports.flatMap((port) => ['-p', `${port}:${port}`]);
+const args = ['run', ...portArgs, `${projectName}:latest`];
+print.boldSection(`Running: docker ${args.join(' ')}`);
+
+const child = spawn('docker', args, { stdio: 'inherit' });
+child.on('error', (err) => {
+  print.boldError(`Failed to start docker: ${err.message}`);
+  process.exit(1);
+});
+child.on('exit', (code) => process.exit(code ?? 1));

package/templates/features/docker/tools/docker/scripts/render-docker-template.js.hbs

@@ -0,0 +1,23 @@
+import { readFile, writeFile } from 'fs/promises';
+import path from 'path';
+
+export async function renderFromTemplate(dockerDir, templateName, outputName, replacements) {
+  const templatePath = path.join(dockerDir, templateName);
+  const outputPath = path.join(dockerDir, outputName);
+
+  let content;
+  try {
+    content = await readFile(templatePath, 'utf-8');
+  } catch {
+    throw new Error(`tools/docker/${templateName} not found — re-run "nutin-add docker" or restore the file.`);
+  }
+
+  for (const [placeholder, value] of replacements) {
+    if (!content.includes(placeholder)) {
+      throw new Error(`tools/docker/${templateName} is missing the "${placeholder}" token — validate-docker has nothing to substitute. Restore the token or re-run "nutin-add docker".`);
+    }
+    content = content.replace(placeholder, value);
+  }
+
+  await writeFile(outputPath, content);
+}

package/templates/features/docker/tools/docker/scripts/render-docker-template.test.js.hbs

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { renderFromTemplate } from './render-docker-template.js';
+
+describe('renderFromTemplate', () => {
+  let tmpDir;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nutin-render-docker-template-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('substitutes a single placeholder and writes the output file', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'nginx.conf.template'), '__PORTS_PLACEHOLDER__;\n');
+
+    await renderFromTemplate(tmpDir, 'nginx.conf.template', 'nginx.conf', [
+      ['__PORTS_PLACEHOLDER__', 'listen 8080;'],
+    ]);
+
+    const output = fs.readFileSync(path.join(tmpDir, 'nginx.conf'), 'utf-8');
+    expect(output).toBe('listen 8080;;\n');
+  });
+
+  it('substitutes multiple placeholders in one call', async () => {
+    fs.writeFileSync(
+      path.join(tmpDir, 'Dockerfile.template'),
+      'ARG PORT="__PORTS_PLACEHOLDER__"\nCMD wget http://127.0.0.1:__PRIMARY_PORT_PLACEHOLDER__/health\n'
+    );
+
+    await renderFromTemplate(tmpDir, 'Dockerfile.template', 'Dockerfile', [
+      ['__PORTS_PLACEHOLDER__', '8080 8081 3000'],
+      ['__PRIMARY_PORT_PLACEHOLDER__', '8080'],
+    ]);
+
+    const output = fs.readFileSync(path.join(tmpDir, 'Dockerfile'), 'utf-8');
+    expect(output).toBe('ARG PORT="8080 8081 3000"\nCMD wget http://127.0.0.1:8080/health\n');
+  });
+
+  it('throws when the template file does not exist', async () => {
+    await expect(() =>
+      renderFromTemplate(tmpDir, 'missing.template', 'missing', [['__X__', 'y']])
+    ).toThrow('missing.template');
+  });
+
+  it('throws when a placeholder token is missing from the template, without writing the output', async () => {
+    fs.writeFileSync(path.join(tmpDir, 'nginx.conf.template'), 'listen 9090;\n');
+
+    await expect(() =>
+      renderFromTemplate(tmpDir, 'nginx.conf.template', 'nginx.conf', [
+        ['__PORTS_PLACEHOLDER__', 'listen 8080;'],
+      ])
+    ).toThrow('__PORTS_PLACEHOLDER__');
+
+    expect(fs.existsSync(path.join(tmpDir, 'nginx.conf'))).toBeFalsy();
+  });
+});

package/templates/features/docker/tools/docker/scripts/validate-docker.js.hbs

@@ -0,0 +1,30 @@
+import path from 'path';
+import { errorExit } from '../../utils/index.js';
+import nutinConfig from '../../../nutin.config.js';
+import { validateDockerPorts } from './docker-ports.js';
+import { renderFromTemplate } from './render-docker-template.js';
+
+const DOCKER_DIR = path.join(process.cwd(), 'tools', 'docker');
+const PLACEHOLDER = '__PORTS_PLACEHOLDER__';
+
+async function validateDocker() {
+  let ports;
+  try {
+    ports = validateDockerPorts(nutinConfig.dockerPorts);
+  } catch (err) {
+    errorExit(err.message);
+  }
+
+  await renderFromTemplate(DOCKER_DIR, 'Dockerfile.template', 'Dockerfile', [
+    [PLACEHOLDER, ports.join(' ')],
+    ['__PRIMARY_PORT_PLACEHOLDER__', String(ports[0])],
+  ]).catch((err) => errorExit(err.message));
+
+  await renderFromTemplate(DOCKER_DIR, 'nginx.conf.template', 'nginx.conf', [
+    [PLACEHOLDER, ports.map((port) => `listen ${port};`).join('\n    ')],
+  ]).catch((err) => errorExit(err.message));
+}
+
+validateDocker().catch((err) => {
+  errorExit(err, 'validate-docker');
+});

package/lib/src/context-builder.mjs

@@ -1,40 +0,0 @@
-import { getCiCommand } from './package-manager.mjs';
-import { packageVersion } from './version.mjs';
-
-const PRESET_MAP = {
-  default: { template: false, stylinNutin: false, i18n: false, deployHelper: false, testinNutin: false },
-  minimal: { template: true, stylinNutin: false, i18n: false, deployHelper: false, testinNutin: false },
-  standard: { template: true, stylinNutin: true,  i18n: true,  deployHelper: false, testinNutin: false },
-  full:     { template: true, stylinNutin: true,  i18n: true,  deployHelper: true,  testinNutin: true  },
-  cicd:     { template: true, stylinNutin: false, i18n: false, deployHelper: true,  testinNutin: false },
-};
-
-export const defaults = {
-  projectName: 'my-nutin-app',
-  packageManager: 'npm',
-  ...PRESET_MAP['default']
-};
-
-export class ContextBuilder {
-	buildContext(preferences) { 
-    const version = packageVersion;
-    const ciCommand = getCiCommand(preferences.packageManager);
-
-    const preset = PRESET_MAP[preferences.preset] ?? PRESET_MAP['default'];
-
-    return {
-      projectName: preferences.projectName,
-      packageManager: preferences.packageManager,
-      
-      template: preset.template,
-      stylinNutin: preset.stylinNutin,
-      i18n: preferences.i18n ?? preset.i18n,
-      deployHelper: preferences.deployHelper ?? preset.deployHelper,
-      testinNutin: preferences.testinNutin ?? preset.testinNutin,
-      transition: preferences.transition,
-
-      ciCommand: ciCommand,
-      version: version
-    };
-  }
-}

package/lib/src/file-generator.mjs

@@ -1,109 +0,0 @@
-import path from 'path';
-import { fileURLToPath } from 'url';
-import * as fsExtra from 'fs-extra';
-import { TemplateCompiler } from './template-compiler.mjs';
-import { print } from './print.mjs';
-
-const fs = fsExtra.default;
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const BINARY_EXTENSIONS = new Set([
-  '.png', '.jpg', '.jpeg', '.gif', '.webp', '.avif', '.svg',
-  '.ico', '.woff', '.woff2', '.ttf', '.otf', '.eot',
-  '.mp4', '.webm', '.mp3', '.wav', '.ogg',
-  '.pdf', '.zip', '.tar', '.gz'
-]);
-
-export class FileGenerator {
-  constructor() {
-    this.compiler = new TemplateCompiler();
-  }
-
-  async generateProjectFromTemplates(projectPath, context) {
-    const templateDir = this.getTemplateDirectory();
-    
-    print.section('📝 Processing templates...');
-    await this.processTemplateDirectory(templateDir, projectPath, context);
-    
-    await this.processFeatureTemplates(projectPath, context);
-  }
-
-  getTemplateDirectory() {
-    return path.join(__dirname, '..', '..', 'templates', 'base');
-  }
-
-  async processTemplateDirectory(templateDir, outputDir, context) {
-    if (!(await fs.pathExists(templateDir))) {
-      throw new Error(`Template directory not found: ${templateDir}`);
-    }
-
-    const entries = await fs.readdir(templateDir, { withFileTypes: true });
-    
-    for (const entry of entries) {
-      if (entry.name === '.DS_Store') continue;
-      
-      const templatePath = path.join(templateDir, entry.name);
-      
-      if (entry.isDirectory()) {
-        const outputPath = path.join(outputDir, entry.name);
-        await fs.ensureDir(outputPath);
-        await this.processTemplateDirectory(templatePath, outputPath, context);
-      } else {
-        await this.processTemplateFile(templatePath, outputDir, entry.name, context);
-      }
-    }
-  }
-
-  async processFeatureTemplates(projectPath, context) {
-    const featuresDir = path.join(__dirname, '..', '..', 'templates', 'features');
-    
-    if (!(await fs.pathExists(featuresDir))) {
-      return;
-    }
-
-    const features = [ 'template', 'i18n', 'stylinNutin', 'testinNutin', 'deployHelper' ];
-    
-    for (const feature of features) {
-      if (context[feature]) {
-        const featureTemplateDir = path.join(featuresDir, feature);
-        
-        if (await fs.pathExists(featureTemplateDir)) {
-          print.info(`  🔧 Adding ${feature} feature...`);
-          await this.processTemplateDirectory(featureTemplateDir, projectPath, context);
-        }
-      }
-    }
-  }
-
-  async processTemplateFile(templatePath, outputDir, fileName, context) {
-    if (fileName.includes("test.js") && !(context.testinNutin)) {
-      return;
-    }
-
-    const fileExt = path.extname(fileName).toLowerCase();
-    
-    if (BINARY_EXTENSIONS.has(fileExt)) {
-      const outputPath = path.join(outputDir, fileName);
-      await fs.copy(templatePath, outputPath);
-      // print.info(`📄 Copied: ${fileName}`);
-    } else if (fileName.endsWith('.hbs')) {
-
-      const outputFileName = fileName.replace('.hbs', '');
-      const outputPath = path.join(outputDir, outputFileName);
-      
-      try {
-        const compiledContent = await this.compiler.compileFile(templatePath, context);
-        await fs.writeFile(outputPath, compiledContent);
-        // print.info(`📝 Generated: ${outputFileName}`);
-      } catch (error) {
-        print.boldError(`❌ Failed to process template: ${fileName}`);
-        throw error;
-      }
-    } else {
-      const outputPath = path.join(outputDir, fileName);
-      await fs.copy(templatePath, outputPath);
-      // print.info(`📄 Copied: ${fileName}`);
-    }
-  }
-}

package/lib/src/json-generator.mjs

@@ -1,31 +0,0 @@
-import path from 'path';
-import * as fsExtra from 'fs-extra';
-import { generatePackageJson, generateTsconfigJson } from './package-manager.mjs';
-
-const fs = fsExtra.default;
-
-export class JsonGenerator {
-  async generateJsonFiles(projectPath, context) {
-    await generatePackageJson(projectPath, context);
-    await generateTsconfigJson(projectPath, context);
-    this.generateConfigFiles(projectPath, context);
-  }
-
-  async generateConfigFiles(projectPath, context) {
-    const configPath = path.join(projectPath, 'config');
-    
-    if (context.i18n) {
-      await fs.ensureDir(configPath); 
-      await this.generateLanguageConfig(configPath);
-    }
-  }
-
-  async generateLanguageConfig(configPath) {
-    const languages = {
-      "languages": [ "en" ],
-      "defaultLanguage": "en"
-    };
-
-    await fs.writeJSON(path.join(configPath, 'languages.json'), languages, { spaces: 2 });    
-  }
-}