nginx-pretty 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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,185 @@
+# 🛡️ nginx-pretty
+
+A **standalone CLI utility** to safely format and apply NGINX configuration files using the embedded logic of [`nginxbeautifier`](https://www.npmjs.com/package/nginxbeautifier). Designed to work in secure environments **without modifying original files unless explicitly approved**, and **without needing global Node or NPM dependencies**.
+
+---
+
+## 🚀 Features
+
+- 📄 Reads and formats: `/etc/nginx/sites-available/default` (or custom path via `--file`)
+- 🛡️ Never modifies the original unless confirmed
+- 🔍 Shows unified diff before applying
+- 🧪 Runs `nginx -t` to validate before reload
+- 🧰 Works with `sudo`, in disconnected or hardened servers
+- 🧱 CLI structure is standalone, can be bundled with [`pkg`](https://github.com/vercel/pkg)
+
+---
+
+## 🧱 Directory Structure
+
+```
+nginx-pretty/
+├── cli.js                         # Main script with embedded formatting logic
+├── beautifier/                    # Vendored logic from nginxbeautifier
+│   └── index.js                   # Main formatter engine
+├── bin/
+│   └── nginx-pretty               # Optional wrapper bash script
+├── README.md
+├── package.json
+```
+
+---
+
+## ⚙️ Usage
+
+### Global install (recommended)
+
+Install globally with npm, then run with `sudo` when modifying system NGINX config:
+
+```bash
+npm install -g nginx-pretty
+sudo nginx-pretty
+```
+
+### As Bash Script (with embedded Node)
+
+```bash
+sudo ./bin/nginx-pretty
+```
+
+### Via npx
+
+```bash
+npx nginx-pretty
+```
+
+### If Bundled as a Binary (using pkg)
+
+```bash
+sudo ./nginx-pretty
+```
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `--file`, `-f <path>` | Config file path (default: `/etc/nginx/sites-available/default`) |
+| `--check-only` | Show diff only, do not prompt or apply |
+| `--dry-run` | Same as `--check-only` |
+| `--no-prompt` | Apply without prompting (for CI; use with caution) |
+| `--help`, `-h` | Show help |
+
+### Help
+
+To print usage and options to the terminal:
+
+```bash
+nginx-pretty --help
+# or
+nginx-pretty -h
+```
+
+Output:
+
+```
+nginx-pretty - Safely format and apply NGINX config files
+
+Usage: nginx-pretty [OPTIONS]
+
+Options:
+  --file, -f <path>    Config file path (default: /etc/nginx/sites-available/default)
+  --check-only         Show diff only, do not prompt or apply
+  --dry-run            Same as --check-only
+  --no-prompt          Apply without prompting (for CI; use with caution)
+  --help, -h           Show this help
+```
+
+---
+
+## 📜 Example Flow
+
+```bash
+🧪 Running nginx-pretty...
+📄 Copying original file to: /tmp/tmp_nginx_formatted.conf
+🆕 Ensuring temp file is writable...
+🎨 Formatting the copied config...
+
+🔍 Showing unified diff (ORIGINAL vs FORMATTED):
+...
+diff output...
+
+⚠️  Do you want to apply the formatted config? (yes/no): yes
+🚀 Config test passed. You can now reload NGINX
+   Run: sudo service nginx reload to apply the changes
+```
+
+---
+
+## 🛠️ Build Instructions (Optional)
+
+To package this into a true standalone binary:
+
+```bash
+npm install
+npm install -g pkg
+pkg cli.js --output nginx-pretty
+```
+
+Or use the npm script:
+
+```bash
+npm run build:pkg
+```
+
+> ✅ This produces a native binary: no Node required on the target machine.
+
+---
+
+## 🧪 How to test
+
+From the project directory (no global install needed):
+
+**1. Help**
+```bash
+node cli.js --help
+```
+
+**2. Dry-run (no nginx required)**  
+Use a temporary config so nothing is modified. You should see a unified diff and “Dry run / check-only: not applying.”
+```bash
+echo 'server { listen 80; root /var/www; }' > /tmp/test-nginx.conf
+node cli.js --file /tmp/test-nginx.conf --dry-run
+```
+
+**3. Optional: real NGINX config**  
+If you have NGINX and a config (e.g. `/etc/nginx/sites-available/default`), run with `--dry-run` first to only view the diff:
+```bash
+sudo node cli.js --file /etc/nginx/sites-available/default --dry-run
+```
+Without `--dry-run`, the CLI will prompt to apply; answer `yes` only if you want to overwrite the file.
+
+---
+
+## 🔐 Security Notes
+
+- This CLI never overwrites original config unless approved.
+- Temporary files are cleaned and written to `/tmp`.
+- Requires `sudo` for NGINX reload steps.
+- Uses `spawn` with array arguments only; no user input is passed to shell.
+
+---
+
+## 📦 Dependencies
+
+Vendored internally:
+- [`nginxbeautifier`](https://github.com/vasilevich/nginxbeautifier) (Apache 2.0)
+
+Runtime:
+- Node.js 14+ (or embedded via `pkg`)
+- `diff` on PATH (for unified diff; standard on Linux)
+
+---
+
+## 📜 License
+
+MIT © You

package/beautifier/index.js

@@ -0,0 +1,221 @@
+/**
+ * Vendored from nginxbeautifier (https://github.com/vasilevich/nginxbeautifier)
+ * Original: Ported by Yosef from https://github.com/1connect/nginx-config-formatter (nginxfmt.py)
+ * License: Apache-2.0
+ *
+ * Adapted for nginx-pretty: 4-space indent, format() export, polyfills removed (Node 14+).
+ */
+
+/**
+ * Grabs text in between two separators
+ */
+function extractTextBySeperator(input, seperator1, seperator2) {
+  if (seperator2 == undefined) seperator2 = seperator1;
+  const catchRegex = new RegExp(seperator1 + '(.*?)' + seperator2);
+  if (new RegExp(seperator1).test(input) && new RegExp(seperator2).test(input)) {
+    return input.match(catchRegex)[1];
+  }
+  return '';
+}
+
+function extractAllPossibleText(input, seperator1, seperator2) {
+  if (seperator2 == undefined) seperator2 = seperator1;
+  const extracted = {};
+  let textInBetween;
+  let cnt = 0;
+  const seperator1CharCode = seperator1.length > 0 ? seperator1.charCodeAt(0) : '';
+  const seperator2CharCode = seperator2.length > 0 ? seperator2.charCodeAt(0) : '';
+  while ((textInBetween = extractTextBySeperator(input, seperator1, seperator2)) !== '') {
+    const placeHolder =
+      '#$#%#$#placeholder' + cnt + '' + seperator1CharCode + '' + seperator2CharCode + '#$#%#$#';
+    extracted[placeHolder] = seperator1 + textInBetween + seperator2;
+    input = input.replace(extracted[placeHolder], placeHolder);
+    cnt++;
+  }
+  return {
+    filteredInput: input,
+    extracted: extracted,
+    getRestored: function () {
+      let textToFix = this.filteredInput;
+      for (const key in extracted) {
+        textToFix = textToFix.replace(key, extracted[key]);
+      }
+      return textToFix;
+    },
+  };
+}
+
+function strip_line(single_line) {
+  const trimmed = single_line.trim();
+  const removedDoubleQuatations = extractAllPossibleText(trimmed, '"', '"');
+  if (!removedDoubleQuatations.filteredInput.includes('sub_filter')) {
+    removedDoubleQuatations.filteredInput = removedDoubleQuatations.filteredInput.replace(
+      /\s\s+/g,
+      ' '
+    );
+  }
+  return removedDoubleQuatations.getRestored();
+}
+
+function clean_lines(configContents) {
+  const splittedByLines = configContents.split(/\r\n|\r|\n/g);
+
+  for (let index = 0, newline = 0; index < splittedByLines.length; index++) {
+    splittedByLines[index] = splittedByLines[index].trim();
+    if (
+      !splittedByLines[index].startsWith('#') &&
+      splittedByLines[index] !== ''
+    ) {
+      newline = 0;
+      let line = (splittedByLines[index] = strip_line(splittedByLines[index]));
+      if (
+        line !== '}' &&
+        line !== '{' &&
+        !(
+          line.includes("('{") ||
+          line.includes("}')") ||
+          line.includes("'{'") ||
+          line.includes("'}'")
+        )
+      ) {
+        const startOfComment = line.indexOf('#');
+        const code =
+          startOfComment >= 0 ? line.slice(0, startOfComment) : line;
+        const removedDoubleQuatations = extractAllPossibleText(code, '"', '"');
+        let codeProcessed = removedDoubleQuatations.filteredInput;
+
+        const startOfParanthesis = codeProcessed.indexOf('}');
+        if (startOfParanthesis >= 0) {
+          if (startOfParanthesis > 0) {
+            splittedByLines[index] = strip_line(
+              codeProcessed.slice(0, startOfParanthesis - 1)
+            );
+          }
+          splittedByLines.splice(index + 1, 0, '}');
+          const l2 = strip_line(codeProcessed.slice(startOfParanthesis + 1));
+          if (l2 !== '') splittedByLines.splice(index + 2, 0, l2);
+          codeProcessed = splittedByLines[index];
+        }
+        const endOfParanthesis = codeProcessed.indexOf('{');
+        if (endOfParanthesis >= 0) {
+          splittedByLines[index] = strip_line(
+            codeProcessed.slice(0, endOfParanthesis)
+          );
+          splittedByLines.splice(index + 1, 0, '{');
+          const l2 = strip_line(codeProcessed.slice(endOfParanthesis + 1));
+          if (l2 !== '') splittedByLines.splice(index + 2, 0, l2);
+        }
+        removedDoubleQuatations.filteredInput = splittedByLines[index];
+        line = removedDoubleQuatations.getRestored();
+        splittedByLines[index] = line;
+      }
+    } else if (splittedByLines[index] === '') {
+      if (newline++ >= 2) {
+        splittedByLines.splice(index, 1);
+        index--;
+      }
+    }
+  }
+  return splittedByLines;
+}
+
+function join_opening_bracket(lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === '{' && i >= 1) {
+      lines[i] = lines[i - 1] + ' {';
+      lines.splice(i - 1, 1);
+      i--;
+    }
+  }
+  return lines;
+}
+
+const INDENTATION = '    '; // 4 spaces
+
+function perform_indentation(lines) {
+  const indented_lines = [];
+  let current_indent = 0;
+  for (let index1 = 0; index1 < lines.length; index1++) {
+    const line = lines[index1];
+    if (
+      !line.startsWith('#') &&
+      /.*?\}(\s*#.*)?$/.test(line) &&
+      current_indent > 0
+    ) {
+      current_indent -= 1;
+    }
+    if (line !== '') {
+      indented_lines.push(INDENTATION.repeat(current_indent) + line);
+    } else {
+      indented_lines.push('');
+    }
+    if (!line.startsWith('#') && /.*?\{(\s*#.*)?$/.test(line)) {
+      current_indent += 1;
+    }
+  }
+  return indented_lines;
+}
+
+function perform_alignment(lines) {
+  const all_lines = [];
+  const attribute_lines = [];
+  let minAlignColumn = 0;
+
+  for (let index1 = 0; index1 < lines.length; index1++) {
+    const line = lines[index1];
+    if (
+      line !== '' &&
+      !/.*?\{(\s*#.*)?$/.test(line) &&
+      !line.startsWith('#') &&
+      !/.*?\}(\s*#.*)?$/.test(line) &&
+      !line.trim().startsWith('upstream') &&
+      !line.trim().includes('location')
+    ) {
+      const splitLine = line.match(/\S+/g);
+      if (splitLine && splitLine.length > 1) {
+        attribute_lines.push(line);
+        const columnAtAttrValue = line.indexOf(splitLine[1]) + 1;
+        if (minAlignColumn < columnAtAttrValue) {
+          minAlignColumn = columnAtAttrValue;
+        }
+      }
+    }
+    all_lines.push(line);
+  }
+
+  for (let index1 = 0; index1 < all_lines.length; index1++) {
+    let line = all_lines[index1];
+    if (attribute_lines.includes(line)) {
+      const split = line.match(/\S+/g);
+      const indentMatch = line.match(/\s+/g);
+      const indent = indentMatch ? indentMatch[0] : '';
+      line =
+        indent +
+        split[0] +
+        ' '.repeat(
+          minAlignColumn - split[0].length - indent.length
+        ) +
+        split.slice(1, split.length).join(' ');
+      all_lines[index1] = line;
+    }
+  }
+  return all_lines;
+}
+
+/**
+ * Format NGINX config contents into a readable format.
+ * Pipeline: clean_lines -> join_opening_bracket -> perform_indentation -> perform_alignment
+ *
+ * @param {string} contents - Raw NGINX config file contents
+ * @returns {string} Formatted config
+ */
+function format(contents) {
+  let lines = clean_lines(contents);
+  lines = join_opening_bracket(lines);
+  lines = perform_indentation(lines);
+  lines = perform_alignment(lines);
+  return lines.join('\n');
+}
+
+module.exports = { format };

package/bin/nginx-pretty

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec node "$SCRIPT_DIR/../cli.js" "$@"

package/cli.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * nginx-pretty - Safely format and apply NGINX config files
+ * Never modifies originals unless user confirms. Shows diff, validates with nginx -t.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { spawn } = require('child_process');
+
+const DEFAULT_CONFIG = '/etc/nginx/sites-available/default';
+const FORMATTED_TMP = '/tmp/tmp_nginx_formatted.conf';
+
+function loadBeautifier() {
+  const beautifier = require('./beautifier');
+  return beautifier.format.bind(beautifier);
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = {
+    file: DEFAULT_CONFIG,
+    checkOnly: false,
+    dryRun: false,
+    noPrompt: false,
+  };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--file' || args[i] === '-f') {
+      opts.file = args[++i] || DEFAULT_CONFIG;
+    } else if (args[i] === '--check-only' || args[i] === '--dry-run') {
+      opts.checkOnly = true;
+      opts.dryRun = true;
+    } else if (args[i] === '--no-prompt') {
+      opts.noPrompt = true;
+    } else if (args[i] === '--help' || args[i] === '-h') {
+      printHelp();
+      process.exit(0);
+    }
+  }
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+nginx-pretty - Safely format and apply NGINX config files
+
+Usage: nginx-pretty [OPTIONS]
+
+Options:
+  --file, -f <path>    Config file path (default: /etc/nginx/sites-available/default)
+  --check-only         Show diff only, do not prompt or apply
+  --dry-run            Same as --check-only
+  --no-prompt          Apply without prompting (for CI; use with caution)
+  --help, -h           Show this help
+`);
+}
+
+function getTempPath() {
+  return FORMATTED_TMP;
+}
+
+function runDiff(fileA, fileB) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('diff', ['-u', fileA, fileB], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let out = '';
+    let err = '';
+    proc.stdout.on('data', (d) => (out += d.toString()));
+    proc.stderr.on('data', (d) => (err += d.toString()));
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve(null);
+      } else if (code === 1) {
+        resolve(out || '(files differ)');
+      } else {
+        reject(new Error(err || `diff exited ${code}`));
+      }
+    });
+  });
+}
+
+function runNginxTest() {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('nginx', ['-t'], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let out = '';
+    let err = '';
+    proc.stdout.on('data', (d) => (out += d.toString()));
+    proc.stderr.on('data', (d) => (err += d.toString()));
+    proc.on('error', (e) => {
+      reject(e);
+    });
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve((answer || '').trim().toLowerCase());
+    });
+  });
+}
+
+function main() {
+  const opts = parseArgs();
+  const format = loadBeautifier();
+
+  const originalPath = path.resolve(opts.file);
+
+  console.log('🧪 Running nginx-pretty...');
+
+  const tempPath = getTempPath();
+  try {
+    fs.unlinkSync(tempPath);
+  } catch (_) {}
+
+  let originalContent;
+  try {
+    originalContent = fs.readFileSync(originalPath, 'utf8');
+  } catch (e) {
+    console.error('❌ Cannot read file:', originalPath);
+    console.error(e.message);
+    process.exit(1);
+  }
+
+  console.log('📄 Copying original file to:', tempPath);
+  try {
+    fs.writeFileSync(tempPath, originalContent, { mode: 0o644 });
+  } catch (e) {
+    console.error('❌ Cannot write temp file:', tempPath);
+    console.error(e.message);
+    process.exit(1);
+  }
+
+  console.log('🆕 Ensuring', tempPath, 'is writable...');
+  console.log('🎨 Formatting the copied config...');
+
+  const formattedContent = format(originalContent);
+
+  fs.writeFileSync(tempPath, formattedContent, { mode: 0o644 });
+
+  runDiff(originalPath, tempPath)
+    .then((diffOutput) => {
+      if (diffOutput === null) {
+        console.log('✅ No changes detected.');
+        try {
+          fs.unlinkSync(tempPath);
+        } catch (_) {}
+        process.exit(0);
+        return;
+      }
+
+      console.log('\n🔍 Showing unified diff (ORIGINAL vs FORMATTED):');
+      console.log(diffOutput);
+      console.log('❌ Changes detected. Review diff and rerun if needed.');
+
+      if (opts.checkOnly || opts.dryRun) {
+        console.log('ℹ️  Dry run / check-only: not applying.');
+        try {
+          fs.unlinkSync(tempPath);
+        } catch (_) {}
+        process.exit(0);
+        return;
+      }
+
+      const doApply = () => {
+        try {
+          fs.copyFileSync(tempPath, originalPath);
+        } catch (e) {
+          console.error('❌ Failed to apply config:', e.message);
+          try {
+            fs.unlinkSync(tempPath);
+          } catch (_) {}
+          process.exit(1);
+        }
+
+        runNginxTest()
+          .then((ok) => {
+            try {
+              fs.unlinkSync(tempPath);
+            } catch (_) {}
+            if (ok) {
+              console.log('🚀 Config test passed. You can now reload NGINX');
+              console.log('   Run: sudo service nginx reload to apply the changes');
+            } else {
+              console.log(
+                '⚠️  Config was applied but nginx -t reported issues. Review your config.'
+              );
+            }
+          })
+          .catch((e) => {
+            try {
+              fs.unlinkSync(tempPath);
+            } catch (_) {}
+            if (e.code === 'ENOENT') {
+              console.log('✅ Config applied. (nginx not found on PATH; run nginx -t and reload on a server with NGINX.)');
+            } else {
+              console.error('❌ nginx -t failed:', e.message);
+            }
+          });
+      };
+
+      if (opts.noPrompt) {
+        doApply();
+      } else {
+        console.log('');
+        prompt('⚠️  Do you want to apply the formatted config? (yes/no): ')
+          .then((answer) => {
+            if (answer === 'yes' || answer === 'y') {
+              doApply();
+            } else {
+              console.log('❌ Skipping apply step. Review diff and rerun if needed.');
+              try {
+                fs.unlinkSync(tempPath);
+              } catch (_) {}
+              process.exit(0);
+            }
+          });
+      }
+    })
+    .catch((err) => {
+      console.error('⚠️  diff failed:', err.message);
+      console.log('\nFormatted output preview:\n');
+      console.log(formattedContent);
+      console.log('\nConsider applying manually if acceptable.');
+      try {
+        fs.unlinkSync(tempPath);
+      } catch (_) {}
+      process.exit(1);
+    });
+}
+
+main();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "nginx-pretty",
+  "version": "1.0.0",
+  "description": "Safely format and apply NGINX config files. Never modifies originals unless confirmed. Shows diff, validates with nginx -t.",
+  "main": "cli.js",
+  "bin": {
+    "nginx-pretty": "cli.js"
+  },
+  "keywords": [
+    "nginx",
+    "formatter",
+    "beautifier",
+    "config",
+    "cli",
+    "pretty"
+  ],
+  "author": "",
+  "license": "MIT",
+  "files": [
+    "cli.js",
+    "beautifier",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "scripts": {
+    "build:pkg": "pkg cli.js --output nginx-pretty --targets node18-linux-x64,node18-darwin-x64,node18-darwin-arm64"
+  },
+  "devDependencies": {
+    "pkg": "^5.8.1"
+  },
+  "pkg": {
+    "assets": ["beautifier/**"]
+  }
+}