fazer-lang 2.7.0 → 2.8.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
+## [2.7.0] - 2026-01-23
+
+### Added
+- **OSINT CLI Tools**: >30 native commands available directly from terminal (`fazer geo`, `scan`, `whois`, `sub`, etc.).
+- **New Built-in Functions**: Added `abs`, `min`, `max`, `pow`, `sqrt`, `pad_start`, `pad_end`, `cp`, `mv`, `ls`, `mkdir`, `rm`, `download`, `env_set`.
+- **Recursion**: Added support for recursive file operations (e.g., `rm` recursive).
+- **HTTP Redirects**: `download` function now automatically follows redirects.
+- **Cross-Platform**: CLI tools now use Node.js native modules (`net`, `dns`, `http`) for better Linux compatibility.
+
+### Changed
+- **Documentation**: Major update to `README.md` and new `CLI_TOOLS.md` guide.
+- **Error Handling**: Improved stability and error reporting for CLI commands.
+
 ## [2.6.0] - 2026-01-22
 
 ### Added

package/README.md

@@ -24,6 +24,13 @@ Exécuter un script :
 fazer mon_script.fz
 ```
 
+Utiliser les outils CLI (OSINT) :
+```bash
+fazer geo 8.8.8.8
+fazer scan google.com
+fazer whois microsoft.com
+```
+
 ## Création d'Exécutable (.exe)
 
 Transformez vos scripts Fazer en applications Windows portables et natives :
@@ -45,6 +52,7 @@ Documentation détaillée par section :
 *   [Guide de Démarrage](https://github.com/viced-1920/fazer-lang/blob/main/docs/getting-started.md)
 *   [Syntaxe du Langage](https://github.com/viced-1920/fazer-lang/blob/main/docs/syntax.md)
 *   [Bibliothèque Standard (Stdlib)](https://github.com/viced-1920/fazer-lang/blob/main/docs/stdlib.md)
+*   [Outils CLI (OSINT & Sys)](https://github.com/viced-1920/fazer-lang/blob/main/docs/CLI_TOOLS.md)
 *   [Exemples](https://github.com/viced-1920/fazer-lang/blob/main/docs/examples.md)
 
 ## Fonctionnalités Clés

package/docs/CLI_TOOLS.md

@@ -0,0 +1,48 @@
+# Fazer CLI - Outils & Commandes
+
+Fazer intègre une suite complète d'outils CLI (>30 commandes) pour l'OSINT, le réseau, la cryptographie et l'administration système.
+
+## Utilisation
+
+```bash
+fazer <commande> [arguments...]
+```
+
+## 🌐 Réseau & OSINT
+
+*   **`geo <ip/domain>`** : Géolocalisation précise (Pays, Ville, ISP, Map).
+*   **`ip`** : Affiche votre IP publique actuelle.
+*   **`scan <host> [ports]`** : Scanner de ports TCP rapide.
+*   **`ping <host> [port]`** : Ping TCP pour vérifier la connectivité.
+*   **`whois <domain>`** : Informations WHOIS complètes.
+*   **`sub <domain>`** : Énumération de sous-domaines (via Certificate Transparency).
+*   **`dns <domain>`** : Résolution DNS (A, MX, TXT, NS, SOA).
+*   **`tech <url>`** : Détection de technologies (Headers, Cookies, Server).
+*   **`headers <url>`** : Affiche les en-têtes HTTP.
+*   **`ssl <host> [port]`** : Inspecte le certificat SSL/TLS (Issuer, Validité, Fingerprint).
+*   **`curl <url>`** : Affiche le corps de la réponse HTTP (GET).
+*   **`robots <url>`** : Récupère et affiche le fichier robots.txt.
+
+## 🔒 Cryptographie & Encodage
+
+*   **`b64 <enc|dec> <str>`** : Encodage/Décodage Base64.
+*   **`hex <enc|dec> <str>`** : Encodage/Décodage Hexadécimal.
+*   **`url <enc|dec> <str>`** : Encodage/Décodage URL.
+*   **`md5 <str>`** : Hash MD5.
+*   **`sha1 <str>`** : Hash SHA1.
+*   **`sha256 <str>`** : Hash SHA256.
+*   **`uuid`** : Génère un UUID v4 aléatoire.
+
+## 💻 Système & Utilitaires
+
+*   **`ls [dir]`** : Liste les fichiers et dossiers.
+*   **`cat <file>`** : Affiche le contenu d'un fichier.
+*   **`grep <regex> <file>`** : Recherche un motif dans un fichier.
+*   **`wc <file>`** : Compte les lignes et caractères d'un fichier.
+*   **`whoami`** : Affiche l'utilisateur et la machine actuels.
+*   **`env`** : Affiche les variables d'environnement.
+*   **`pass [len]`** : Génère un mot de passe sécurisé (défaut 16 chars).
+*   **`calc <expr>`** : Calculatrice mathématique (ex: `10 * 5 + 2`).
+*   **`now`** : Affiche la date et le timestamp actuels.
+*   **`coin`** : Pile ou Face.
+*   **`dice`** : Lance un dé (1-6).

package/docs/stdlib.md

@@ -115,3 +115,28 @@ Télécharge un fichier depuis une URL vers un chemin local.
 ```fazer
 success := download("https://example.com/image.png", "img.png")
 ```
+
+## Terminal Avancé (UI & FX)
+
+Fonctionnalités pour créer des interfaces en ligne de commande (TUI) riches et animées.
+
+### Couleurs & Styles (TrueColor)
+*   `rgb(r, g, b, text)` : Texte en couleur TrueColor (16 millions de couleurs).
+*   `bg_rgb(r, g, b, text)` : Arrière-plan en couleur TrueColor.
+*   `gradient(text, r1, g1, b1, r2, g2, b2)` : Applique un dégradé linéaire sur le texte entre deux couleurs RGB.
+*   `style(text, style_name)` : Styles de base ("bold", "dim", "red", "blue", etc.).
+
+### Curseur & Affichage
+*   `term_clear()` : Efface l'écran.
+*   `term_pos(row, col)` : Déplace le curseur.
+*   `term_hide()` / `cursor_hide()` : Masque le curseur.
+*   `term_show()` / `cursor_show()` : Affiche le curseur.
+*   `term_title(text)` : Change le titre de la fenêtre du terminal.
+*   `cursor_save()` : Sauvegarde la position du curseur.
+*   `cursor_restore()` : Restaure la position sauvegardée.
+
+### Composants UI
+*   `ui_bar(val, max, width, char)` : Génère une barre de progression.
+    *   Exemple : `ui_bar(50, 100, 20)` -> `██████████          `
+*   `box(title, line1, line2, ...)` : Affiche une boîte encadrée.
+

package/fazer.js

@@ -11,6 +11,7 @@
 const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
+const os = require("os");
 const { Lexer, createToken, EmbeddedActionsParser } = require("chevrotain");
 
 /* ────────────────────────────────────────────────────────────────────────── */
@@ -21,6 +22,7 @@ const WhiteSpace = createToken({ name: "WhiteSpace", pattern: /[ \t\r\n]+/, grou
 const Comment = createToken({ name: "Comment", pattern: /(#|\/\/)[^\n]*/, group: Lexer.SKIPPED });
 
 const Assign = createToken({ name: "Assign", pattern: /:=/ });
+const SingleEq = createToken({ name: "SingleEq", pattern: /=/ });
 
 const Arrow = createToken({ name: "Arrow", pattern: /->|→/ });
 const DoublePipe = createToken({ name: "DoublePipe", pattern: /->>|\|>|→>/ });
@@ -116,6 +118,7 @@ const allTokens = [
   NotEq,
   Greater,
   Less,
+  SingleEq,
 
   LParen,
   RParen,
@@ -174,7 +177,7 @@ class FazerParser extends EmbeddedActionsParser {
             const t1 = $.LA(1).tokenType;
             if (t1 === Mut) return true;
             const t2 = $.LA(2).tokenType;
-            return t1 === Identifier && t2 === Assign;
+            return t1 === Identifier && (t2 === Assign || t2 === SingleEq);
           },
           ALT: () => $.SUBRULE($.assignStmt)
         },
@@ -261,7 +264,19 @@ class FazerParser extends EmbeddedActionsParser {
     $.RULE("assignStmt", () => {
       const mutTok = $.OPTION(() => $.CONSUME(Mut));
       const idTok = $.CONSUME(Identifier);
-      $.CONSUME(Assign);
+      
+      const op = $.OR([
+        { ALT: () => $.CONSUME(Assign) },
+        { ALT: () => $.CONSUME(SingleEq) }
+      ]);
+
+      if (op.tokenType && op.tokenType.name === "SingleEq") {
+        throw new FazerError(
+          `Invalid assignment operator '='. Use ':=' for assignment.`,
+          { line: op.startLine, col: op.startColumn }
+        );
+      }
+
       const value = $.SUBRULE($.expression);
       return node("assign", {
         name: idTok.image,
@@ -322,16 +337,22 @@ class FazerParser extends EmbeddedActionsParser {
       // Examples:
       //   > 10
       //   <= 3
-      const op = $.OR([
-        { ALT: () => $.CONSUME(GreaterEq).image },
-        { ALT: () => $.CONSUME(LessEq).image },
-        { ALT: () => $.CONSUME(Greater).image },
-        { ALT: () => $.CONSUME(Less).image },
-        { ALT: () => $.CONSUME(Eq).image },
-        { ALT: () => $.CONSUME(NotEq).image },
+      const opTok = $.OR([
+        { ALT: () => $.CONSUME(GreaterEq) },
+        { ALT: () => $.CONSUME(LessEq) },
+        { ALT: () => $.CONSUME(Greater) },
+        { ALT: () => $.CONSUME(Less) },
+        { ALT: () => $.CONSUME(Eq) },
+        { ALT: () => $.CONSUME(NotEq) },
+        { ALT: () => $.CONSUME(SingleEq) },
       ]);
+
+      if (opTok.tokenType && opTok.tokenType.name === "SingleEq") {
+        throw new FazerError("Invalid operator '=' in pattern. Use '==' or just the value.", { line: opTok.startLine, col: opTok.startColumn });
+      }
+
       const rhs = $.SUBRULE($.expression);
-      return node("cmpPat", { op, rhs });
+      return node("cmpPat", { op: opTok.image, rhs });
     });
 
     /* Expression precedence:
@@ -382,12 +403,18 @@ class FazerParser extends EmbeddedActionsParser {
     $.RULE("eqExpr", () => {
       let left = $.SUBRULE($.relExpr);
       $.MANY(() => {
-        const op = $.OR([
-          { ALT: () => $.CONSUME(Eq).image },
-          { ALT: () => $.CONSUME(NotEq).image },
+        const opTok = $.OR([
+          { ALT: () => $.CONSUME(Eq) },
+          { ALT: () => $.CONSUME(NotEq) },
+          { ALT: () => $.CONSUME(SingleEq) },
         ]);
+
+        if (opTok.tokenType && opTok.tokenType.name === "SingleEq") {
+          throw new FazerError("Invalid operator '='. Use '==' for equality.", { line: opTok.startLine, col: opTok.startColumn });
+        }
+
         const right = $.SUBRULE2($.relExpr);
-        left = node("bin", { op, left, right, loc: left.loc ?? null });
+        left = node("bin", { op: opTok.image, left, right, loc: left.loc ?? null });
       });
       return left;
     });
@@ -792,6 +819,50 @@ class FazerRuntime {
     const https = require("https");
     const child_process = require("child_process");
 
+    // Helper for gradients
+    const makeGradient = (text, startColor, endColor) => {
+        const len = text.length;
+        if (len === 0) return "";
+        const [r1, g1, b1] = startColor;
+        const [r2, g2, b2] = endColor;
+        let res = "";
+        for (let i = 0; i < len; i++) {
+            const ratio = i / (len - 1 || 1);
+            const r = Math.round(r1 + (r2 - r1) * ratio);
+            const g = Math.round(g1 + (g2 - g1) * ratio);
+            const b = Math.round(b1 + (b2 - b1) * ratio);
+            res += `\x1b[38;2;${r};${g};${b}m${text[i]}`;
+        }
+        return res + "\x1b[0m";
+    };
+
+    // Input Buffer for term_read
+    let stdinBuffer = [];
+    let stdinListener = null;
+
+    const enableRawInput = (enable) => {
+        if (!process.stdin.isTTY) return;
+        try {
+            process.stdin.setRawMode(!!enable);
+            if (enable) {
+                process.stdin.resume();
+                if (!stdinListener) {
+                    stdinListener = (chunk) => {
+                        const str = chunk.toString();
+                        for (const char of str) stdinBuffer.push(char);
+                    };
+                    process.stdin.on('data', stdinListener);
+                }
+            } else {
+                 if (stdinListener) {
+                     process.stdin.removeListener('data', stdinListener);
+                     stdinListener = null;
+                 }
+                 process.stdin.pause();
+            }
+        } catch(e) {}
+    };
+
     // register builtins in global scope
     const builtins = {
       println: (x = "") => (console.log(String(x)), null),
@@ -817,6 +888,7 @@ class FazerRuntime {
           return null;
         }
       },
+      readln: (prompt = "") => builtins.ask(prompt),
 
       // Terminal / UI Advanced
       term_clear: () => (process.stdout.write("\x1b[2J\x1b[H"), null),
@@ -842,6 +914,34 @@ class FazerRuntime {
         const chunk = process.stdin.read(1);
         return chunk ? String(chunk) : null;
       },
+      
+      sleep: (ms) => {
+          const sab = new SharedArrayBuffer(4);
+          const int32 = new Int32Array(sab);
+          Atomics.wait(int32, 0, 0, Number(ms));
+          return null;
+      },
+
+      // Advanced Colors & FX
+      rgb: (r, g, b, text) => `\x1b[38;2;${Number(r)};${Number(g)};${Number(b)}m${String(text)}\x1b[0m`,
+      bg_rgb: (r, g, b, text) => `\x1b[48;2;${Number(r)};${Number(g)};${Number(b)}m${String(text)}\x1b[0m`,
+      gradient: (text, r1, g1, b1, r2, g2, b2) => makeGradient(String(text), [Number(r1), Number(g1), Number(b1)], [Number(r2), Number(g2), Number(b2)]),
+      
+      // Cursor & Title
+      cursor_save: () => (process.stdout.write("\x1b[s"), null),
+      cursor_restore: () => (process.stdout.write("\x1b[u"), null),
+      cursor_hide: () => (process.stdout.write("\x1b[?25l"), null),
+      cursor_show: () => (process.stdout.write("\x1b[?25h"), null),
+      term_title: (t) => (process.stdout.write(`\x1b]0;${String(t)}\x07`), null),
+      
+      // UI Components
+      ui_bar: (val, max, width, char) => {
+          const v = Number(val); const m = Number(max); const w = Number(width || 20);
+          const c = String(char || "█");
+          const filled = Math.round((v / m) * w);
+          return c.repeat(filled) + " ".repeat(w - filled);
+      },
+
 
       style: (s, color) => style(s, String(color || "reset")),
       box: (title, ...lines) => box(title, lines),
@@ -986,35 +1086,290 @@ class FazerRuntime {
       exit: (code) => process.exit(Number(code||0)),
       env_set: (k, v) => { process.env[String(k)] = String(v); return null; },
 
+      // System & Red Team (Advanced)
+      sys_info: () => {
+         try {
+             const cmd = `Get-WmiObject Win32_OperatingSystem | Select-Object Caption, Version, OSArchitecture | ConvertTo-Json`;
+             const os = JSON.parse(child_process.execSync(`powershell -NoProfile -Command "${cmd}"`, { encoding: "utf8" }));
+             const user = process.env.USERNAME;
+             const domain = process.env.USERDOMAIN;
+             const admin = (() => { try { child_process.execSync("net session"); return true; } catch(e) { return false; } })();
+             return { os: os.Caption, version: os.Version, arch: os.OSArchitecture, user, domain, is_admin: admin };
+         } catch(e) { return { error: e.message }; }
+      },
+      uptime: () => {
+        try {
+            const up = child_process.execSync(`powershell -command "(Get-Date) - (Get-CimInstance Win32_OperatingSystem).LastBootUpTime | Select-Object -ExpandProperty TotalSeconds"`).toString().trim();
+            return Number(up);
+        } catch(e) { return 0; }
+      },
+      shutdown: (delay = 0) => child_process.exec(`shutdown /s /t ${Number(delay)}`),
+      restart: (delay = 0) => child_process.exec(`shutdown /r /t ${Number(delay)}`),
+      lock_screen: () => child_process.exec(`rundll32.exe user32.dll,LockWorkStation`),
+      
+      // File System Extended
+      file_size: (p) => { try { return fs.statSync(path.resolve(String(p))).size; } catch(e) { return -1; } },
+      file_exists: (p) => fs.existsSync(path.resolve(String(p))),
+      is_dir: (p) => { try { return fs.statSync(path.resolve(String(p))).isDirectory(); } catch(e) { return false; } },
+      is_file: (p) => { try { return fs.statSync(path.resolve(String(p))).isFile(); } catch(e) { return false; } },
+      dir_home: () => os.homedir(),
+      dir_temp: () => os.tmpdir(),
+
+      // Crypto Extended
+      md5: (s) => crypto.createHash('md5').update(String(s)).digest('hex'),
+      sha1: (s) => crypto.createHash('sha1').update(String(s)).digest('hex'),
+      sha256: (s) => crypto.createHash('sha256').update(String(s)).digest('hex'),
+      uuid: () => crypto.randomUUID(),
+
+      process_list: () => {
+         try {
+             const cmd = `Get-Process | Select-Object Id, ProcessName, MainWindowTitle | ConvertTo-Json -Depth 1`;
+             const out = child_process.execSync(`powershell -NoProfile -Command "${cmd}"`, { encoding: "utf8" });
+             return JSON.parse(out);
+         } catch(e) { return []; }
+      },
+
+      process_kill: (pid) => {
+         try {
+             process.kill(Number(pid));
+             return true;
+         } catch(e) { return false; }
+      },
+
+      screenshot: (pathStr) => {
+         try {
+             const p = path.resolve(String(pathStr));
+             const ps = `
+Add-Type -AssemblyName System.Windows.Forms;
+Add-Type -AssemblyName System.Drawing;
+$s = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds;
+$b = New-Object System.Drawing.Bitmap $s.Width, $s.Height;
+$g = [System.Drawing.Graphics]::FromImage($b);
+$g.CopyFromScreen($s.Location, [System.Drawing.Point]::Empty, $s.Size);
+$b.Save('${p.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png);
+$g.Dispose();
+$b.Dispose();
+             `;
+             child_process.execSync(`powershell -NoProfile -Command "${ps.replace(/\n/g, " ")}"`);
+             return true;
+         } catch(e) { return false; }
+      },
+
+      clipboard_get: () => {
+         try {
+             const ps = `Get-Clipboard`;
+             return child_process.execSync(`powershell -NoProfile -Command "${ps}"`, { encoding: "utf8" }).trim();
+         } catch(e) { return ""; }
+      },
+
+      clipboard_set: (text) => {
+         try {
+             const t = String(text).replace(/"/g, '\\"');
+             const ps = `Set-Clipboard -Value "${t}"`;
+             child_process.execSync(`powershell -NoProfile -Command "${ps}"`);
+             return true;
+         } catch(e) { return false; }
+      },
+
+      // Automation (Mouse/Keyboard)
+      mouse_move: (x, y) => {
+         try {
+             const ps = `
+Add-Type -AssemblyName System.Windows.Forms;
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Number(x)}, ${Number(y)});
+             `;
+             child_process.execSync(`powershell -NoProfile -Command "${ps.replace(/\n/g, " ")}"`);
+             return true;
+         } catch(e) { return false; }
+      },
+
+      mouse_pos: () => {
+         try {
+            const ps = `
+Add-Type -AssemblyName System.Windows.Forms;
+$p = [System.Windows.Forms.Cursor]::Position;
+Write-Output "$($p.X),$($p.Y)"
+            `;
+            const out = child_process.execSync(`powershell -NoProfile -Command "${ps.replace(/\n/g, " ")}"`, { encoding: "utf8" }).trim();
+            const parts = out.split(",");
+            return { x: Number(parts[0]), y: Number(parts[1]) };
+         } catch(e) { return { x: 0, y: 0 }; }
+      },
+      
+      msgbox: (text, title="Message") => {
+         try {
+             const ps = `
+Add-Type -AssemblyName System.Windows.Forms;
+[System.Windows.Forms.MessageBox]::Show('${String(text).replace(/'/g, "''")}', '${String(title).replace(/'/g, "''")}');
+             `;
+             child_process.execSync(`powershell -NoProfile -Command "${ps.replace(/\n/g, " ")}"`);
+             return null;
+         } catch(e) { return null; }
+      },
+
+      // Registry (Persistence)
+      registry_set: (keyPath, name, value) => {
+        // keyPath: HKCU\Software\...\Run
+        try {
+            const ps = `Set-ItemProperty -Path "Registry::${keyPath}" -Name "${name}" -Value "${value}"`;
+            child_process.execSync(`powershell -NoProfile -Command "${ps}"`);
+            return true;
+        } catch(e) { return false; }
+      },
+      
+      registry_get: (keyPath, name) => {
+        try {
+            const ps = `Get-ItemPropertyValue -Path "Registry::${keyPath}" -Name "${name}"`;
+            return child_process.execSync(`powershell -NoProfile -Command "${ps}"`, { encoding: "utf8" }).trim();
+        } catch(e) { return null; }
+      },
+
+      // Self-Destruct
+      self_destruct: () => {
+          const script = process.argv[1];
+          // We can't delete running file easily on Windows.
+          // We spawn a detached process that waits then deletes.
+          const cmd = `Start-Sleep -Seconds 2; Remove-Item -Path "${script}" -Force`;
+          const ps = `powershell -NoProfile -Command "${cmd}"`;
+          child_process.spawn(ps, { shell: true, detached: true, stdio: 'ignore' }).unref();
+          process.exit(0);
+      },
+
       // Network
       download: async (url, dest) => {
-          const downloadFile = (u, d) => {
-              return new Promise((resolve) => {
-                  const p = path.resolve(String(d));
-                  const proto = String(u).startsWith("https") ? https : http;
-                  proto.get(String(u), (response) => {
-                      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-                          // Follow redirect
-                          resolve(downloadFile(response.headers.location, d));
+          const followRedirects = (currentUrl, currentDest, maxRedirects = 5) => {
+              return new Promise((resolve, reject) => {
+                  if (maxRedirects === 0) {
+                      reject(new Error("Too many redirects"));
+                      return;
+                  }
+                  const proto = currentUrl.startsWith("https") ? https : http;
+                  const request = proto.get(currentUrl, (response) => {
+                      if ([301, 302, 303, 307, 308].includes(response.statusCode) && response.headers.location) {
+                          const redirectUrl = new URL(response.headers.location, currentUrl).href;
+                          followRedirects(redirectUrl, currentDest, maxRedirects - 1)
+                              .then(resolve)
+                              .catch(reject);
                           return;
                       }
                       if (response.statusCode !== 200) {
-                          resolve(false);
+                          reject(new Error(`Failed to download: Status Code ${response.statusCode}`));
                           return;
                       }
-                      const file = fs.createWriteStream(p);
+                      const file = fs.createWriteStream(currentDest);
                       response.pipe(file);
                       file.on('finish', () => {
-                          file.close();
-                          resolve(true);
+                          file.close(() => resolve(true));
                       });
                   }).on('error', (err) => {
-                      try { fs.unlinkSync(p); } catch(e){}
-                      resolve(false);
+                      try { fs.unlinkSync(currentDest); } catch(e){}
+                      reject(err);
                   });
               });
           };
-          return await downloadFile(url, dest);
+          try {
+              return await followRedirects(url, dest);
+          } catch (e) {
+              return false;
+          }
+      },
+
+      public_ip: async () => {
+         try {
+             return new Promise((resolve) => {
+                 https.get('https://api.ipify.org', (res) => {
+                     let data = '';
+                     res.on('data', chunk => data += chunk);
+                     res.on('end', () => resolve(data));
+                 }).on('error', () => resolve("0.0.0.0"));
+             });
+         } catch(e) { return "0.0.0.0"; }
+      },
+
+      wifi_dump: () => {
+         try {
+             const ps = `
+$profiles = netsh wlan show profiles | Select-String "All User Profile" | ForEach-Object { $_.ToString().Split(":")[1].Trim() };
+$results = @();
+foreach ($p in $profiles) {
+    $pass = netsh wlan show profile name="$p" key=clear | Select-String "Key Content" | ForEach-Object { $_.ToString().Split(":")[1].Trim() };
+    if (-not $pass) { $pass = "N/A" };
+    $results += @{ SSID = $p; Password = $pass };
+}
+$results | ConvertTo-Json -Compress
+             `;
+             const out = child_process.execSync(`powershell -NoProfile -Command "${ps.replace(/\n/g, " ")}"`, { encoding: "utf8" });
+             return JSON.parse(out);
+         } catch(e) { return []; }
+      },
+
+      // System Utils
+      zip: (source, dest) => {
+         try {
+            const s = path.resolve(String(source));
+            const d = path.resolve(String(dest));
+            child_process.execSync(`powershell -NoProfile -Command "Compress-Archive -Path '${s}' -DestinationPath '${d}' -Force"`);
+            return true;
+         } catch(e) { return false; }
+      },
+
+      unzip: (source, dest) => {
+         try {
+            const s = path.resolve(String(source));
+            const d = path.resolve(String(dest));
+            child_process.execSync(`powershell -NoProfile -Command "Expand-Archive -Path '${s}' -DestinationPath '${d}' -Force"`);
+            return true;
+         } catch(e) { return false; }
+      },
+
+      file_hide: (pathStr) => {
+         try {
+             const p = path.resolve(String(pathStr));
+             child_process.execSync(`attrib +h "${p}"`);
+             return true;
+         } catch(e) { return false; }
+      },
+      
+      file_unhide: (pathStr) => {
+         try {
+             const p = path.resolve(String(pathStr));
+             child_process.execSync(`attrib -h "${p}"`);
+             return true;
+         } catch(e) { return false; }
+      },
+
+      // Audio & Fun
+      speak: (text) => {
+         try {
+             const t = String(text).replace(/'/g, "''");
+             const ps = `Add-Type -AssemblyName System.Speech; (New-Object System.Speech.Synthesis.SpeechSynthesizer).Speak('${t}')`;
+             child_process.execSync(`powershell -NoProfile -Command "${ps}"`);
+             return true;
+         } catch(e) { return false; }
+      },
+      
+      beep: (freq, dur) => {
+         try {
+             const ps = `[Console]::Beep(${Number(freq)}, ${Number(dur)})`; 
+             child_process.execSync(`powershell -NoProfile -Command "${ps}"`);
+             return true;
+         } catch(e) { return false; }
+      },
+
+      // Crypto
+      b64_encode: (text) => {
+          return Buffer.from(String(text)).toString('base64');
+      },
+      
+      b64_decode: (text) => {
+          return Buffer.from(String(text), 'base64').toString('utf8');
+      },
+
+      hash: (algo, text) => { // algo: 'md5', 'sha256'
+          try {
+              const crypto = require('crypto');
+              return crypto.createHash(String(algo)).update(String(text)).digest('hex');
+          } catch(e) { return ""; }
       },
 
       readB64: readBytesB64,
@@ -1058,50 +1413,8 @@ class FazerRuntime {
       },
       
       server: (port, handlerName) => {
-        const srv = http.createServer(async (req, res) => {
-           // We need to call the Fazer function `handlerName`
-           // But `this._call` requires scope context.
-           // This is tricky in a sync interpreter loop.
-           // For now, simple static server or basic response?
-           // To do it properly, we need to invoke the runtime from the callback.
-           // Since we are inside the class, we can do it!
-           
-           // We need to find the function in `this.fns`
-           const fn = this.fns.get(handlerName);
-           if (!fn) {
-             res.writeHead(500);
-             res.end("Handler not found");
-             return;
-           }
-           
-           // Construct request object
-           const reqObj = {
-             method: req.method,
-             url: req.url,
-             headers: req.headers
-           };
-           
-           // Call handler(req) -> { status, body, headers }
-           try {
-             const inner = new Scope(fn.closure);
-             inner.set(fn.params[0], reqObj, true); 
-             const result = await this._execBlock(fn.body, inner);
-             const out = (result instanceof ReturnSignal) ? result.value : result;
-             
-             const status = (out && out.status) || 200;
-             const body = (out && out.body) || "";
-             const headers = (out && out.headers) || {};
-             
-             res.writeHead(status, headers);
-             res.end(String(body));
-           } catch (e) {
-             console.error(e);
-             res.writeHead(500);
-             res.end("Internal Server Error");
-           }
-        });
-        srv.listen(Number(port));
-        console.log(`Server listening on port ${port}`);
+        // This old implementation is deprecated/removed in favor of the async one below
+        throw new FazerError("This server signature is deprecated. Use server(port, router_obj).");
       },
 
       sleep: (ms) => new Promise((resolve) => setTimeout(resolve, Number(ms))),
@@ -2600,7 +2913,18 @@ Usage:
   fazer                     Start interactive shell (REPL)
   fazer <file.fz> [args...] Run a Fazer script
   fazer run <file.fz>       Run a Fazer script (explicit)
+
+CLI Commands:
+  Network/OSINT:
+    geo, scan, whois, sub, dns, tech, headers, ip, ping, 
+    ssl, curl, robots
   
+  Crypto/Encoding:
+    b64, hex, url, md5, sha1, sha256, uuid
+    
+  System/Utils:
+    ls, cat, grep, wc, whoami, env, pass, calc, now, coin, dice
+
 Flags:
   --help, -h                Show this help message
   --version, -v             Show version
@@ -2656,6 +2980,415 @@ async function main() {
     printLicense();
   }
 
+  /* ────────────────────────────────────────────────────────────────────────── */
+  /* CLI TOOLS / OSINT                                                          */
+  /* ────────────────────────────────────────────────────────────────────────── */
+  
+  const colors = {
+      red: "\x1b[31m", green: "\x1b[32m", yellow: "\x1b[33m", blue: "\x1b[34m", 
+      magenta: "\x1b[35m", cyan: "\x1b[36m", reset: "\x1b[0m", bold: "\x1b[1m"
+  };
+  
+  const CLI_COMMANDS = {
+      // --- OSINT / NETWORK ---
+      "geo": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer geo <ip/domain>${colors.reset}`);
+          const target = args[0];
+          console.log(`${colors.cyan}[*] Geo-locating: ${target}...${colors.reset}`);
+          const http = require("http");
+          http.get(`http://ip-api.com/json/${target}`, (res) => {
+              let data = "";
+              res.on("data", c => data += c);
+              res.on("end", () => {
+                  try {
+                      const j = JSON.parse(data);
+                      if (j.status === "fail") {
+                          console.log(`${colors.red}[!] Failed: ${j.message}${colors.reset}`);
+                          return;
+                      }
+                      console.log(`${colors.green}[+] Target: ${j.query}${colors.reset}`);
+                      console.log(`    ${colors.bold}Country:${colors.reset} ${j.country} (${j.countryCode})`);
+                      console.log(`    ${colors.bold}Region:${colors.reset}  ${j.regionName} (${j.region})`);
+                      console.log(`    ${colors.bold}City:${colors.reset}    ${j.city}`);
+                      console.log(`    ${colors.bold}ISP:${colors.reset}     ${j.isp}`);
+                      console.log(`    ${colors.bold}Org:${colors.reset}     ${j.org}`);
+                      console.log(`    ${colors.bold}AS:${colors.reset}      ${j.as}`);
+                      console.log(`    ${colors.bold}Loc:${colors.reset}     ${j.lat}, ${j.lon}`);
+                      console.log(`    ${colors.blue}Maps:${colors.reset}    https://www.google.com/maps?q=${j.lat},${j.lon}`);
+                  } catch(e) { console.error(e.message); }
+              });
+          }).on("error", e => console.error(e.message));
+      },
+
+      "ip": async (args) => {
+          console.log(`${colors.cyan}[*] Fetching public IP...${colors.reset}`);
+          const https = require("https");
+          https.get("https://api.ipify.org?format=json", (res) => {
+              let data = "";
+              res.on("data", c => data += c);
+              res.on("end", () => {
+                  try {
+                      const j = JSON.parse(data);
+                      console.log(`${colors.green}[+] Public IP: ${colors.bold}${j.ip}${colors.reset}`);
+                  } catch(e) { console.error("Error parsing response"); }
+              });
+          }).on("error", e => console.error(e.message));
+      },
+
+      "ping": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer ping <host> [port]${colors.reset}`);
+          const host = args[0];
+          const port = args[1] ? parseInt(args[1]) : 80;
+          console.log(`${colors.cyan}[*] Pinging ${host}:${port}...${colors.reset}`);
+          const net = require("net");
+          const start = Date.now();
+          const s = new net.Socket();
+          s.setTimeout(2000);
+          s.on('connect', () => {
+              const ms = Date.now() - start;
+              console.log(`${colors.green}[+] Connected to ${host}:${port} in ${ms}ms${colors.reset}`);
+              s.destroy();
+          });
+          s.on('timeout', () => { console.log(`${colors.red}[!] Timeout${colors.reset}`); s.destroy(); });
+          s.on('error', (e) => { console.log(`${colors.red}[!] Error: ${e.message}${colors.reset}`); });
+          s.connect(port, host);
+      },
+
+      "scan": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer scan <host> [ports/range]${colors.reset}`);
+          const host = args[0];
+          let ports = [21,22,23,25,53,80,110,111,135,139,143,443,445,993,995,1723,3306,3389,5900,8080,8443];
+          if (args[1]) {
+              if (args[1] === "full") ports = Array.from({length: 1024}, (_, i) => i + 1);
+              else ports = args[1].split(",").map(p => parseInt(p.trim())).filter(n => !isNaN(n));
+          }
+          
+          console.log(`${colors.cyan}[*] Scanning ${host} (${ports.length} ports)...${colors.reset}`);
+          const net = require("net");
+          
+          const checkPort = (port) => new Promise(resolve => {
+              const s = new net.Socket();
+              s.setTimeout(2000);
+              s.on('connect', () => { s.destroy(); resolve(port); });
+              s.on('timeout', () => { s.destroy(); resolve(null); });
+              s.on('error', () => resolve(null));
+              s.connect(port, host);
+          });
+          
+          const results = await Promise.all(ports.map(checkPort));
+          const open = results.filter(p => p !== null);
+          
+          if (open.length === 0) console.log(`${colors.yellow}[-] No open ports found.${colors.reset}`);
+          else {
+              console.log(`${colors.green}[+] Found ${open.length} open ports:${colors.reset}`);
+              open.forEach(p => console.log(`    - ${colors.bold}${p}${colors.reset} (OPEN)`));
+          }
+      },
+
+      "whois": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer whois <domain>${colors.reset}`);
+          const domain = args[0];
+          console.log(`${colors.cyan}[*] WHOIS Lookup for: ${domain}...${colors.reset}`);
+          
+          const queryWhois = (server, query) => new Promise((resolve, reject) => {
+              const net = require("net");
+              const s = new net.Socket();
+              let data = "";
+              s.connect(43, server, () => s.write(query + "\r\n"));
+              s.on("data", d => data += d);
+              s.on("end", () => resolve(data));
+              s.on("error", reject);
+          });
+          
+          try {
+              let res = await queryWhois("whois.iana.org", domain);
+              let refer = res.match(/refer:\s+(.+)/i);
+              if (refer && refer[1]) {
+                  const server = refer[1].trim();
+                  console.log(`${colors.blue}[i] Redirected to ${server}${colors.reset}`);
+                  res = await queryWhois(server, domain);
+              } else {
+                  if (domain.endsWith(".com") || domain.endsWith(".net")) {
+                       res = await queryWhois("whois.verisign-grs.com", domain);
+                  }
+              }
+              console.log(res);
+          } catch(e) { console.error(`${colors.red}[!] Error: ${e.message}${colors.reset}`); }
+      },
+
+      "dns": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer dns <domain>${colors.reset}`);
+          const domain = args[0];
+          const dns = require("dns").promises;
+          console.log(`${colors.cyan}[*] DNS Records for: ${domain}${colors.reset}`);
+          const types = ["A", "AAAA", "MX", "TXT", "NS", "SOA", "CNAME"];
+          for (const t of types) {
+              try {
+                  const res = await dns.resolve(domain, t);
+                  console.log(`${colors.bold}[${t}]${colors.reset}`);
+                  if (Array.isArray(res)) res.forEach(r => console.log(`    ${typeof r === 'object' ? JSON.stringify(r) : r}`));
+                  else console.log(`    ${JSON.stringify(res)}`);
+              } catch(e) {}
+          }
+      },
+
+      "sub": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer sub <domain>${colors.reset}`);
+          const domain = args[0];
+          console.log(`${colors.cyan}[*] Enumerating subdomains for: ${domain} (via crt.sh)...${colors.reset}`);
+          const https = require("https");
+          const fetch = (u) => new Promise((resolve, reject) => {
+              const req = https.get(u, { headers: {'User-Agent': 'Mozilla/5.0'} }, res => {
+                  let d = ""; res.on("data", c => d += c); res.on("end", () => resolve(d));
+              });
+              req.on("error", reject);
+          });
+          try {
+              const data = await fetch(`https://crt.sh/?q=%.${domain}&output=json`);
+              let json = [];
+              try { json = JSON.parse(data); } catch(e) { console.log(`${colors.red}[!] Invalid response${colors.reset}`); return; }
+              const subs = new Set();
+              json.forEach(entry => { entry.name_value.split("\n").forEach(s => subs.add(s)); });
+              console.log(`${colors.green}[+] Found ${subs.size} unique subdomains:${colors.reset}`);
+              Array.from(subs).sort().forEach(s => console.log(`    ${s}`));
+          } catch(e) { console.error(`${colors.red}[!] Error: ${e.message}${colors.reset}`); }
+      },
+
+      "headers": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer headers <url>${colors.reset}`);
+          let u = args[0]; if (!u.startsWith("http")) u = "https://" + u;
+          console.log(`${colors.cyan}[*] Fetching headers: ${u}...${colors.reset}`);
+          const proto = u.startsWith("https") ? require("https") : require("http");
+          proto.get(u, (res) => {
+              console.log(`${colors.green}[${res.statusCode} ${res.statusMessage}]${colors.reset}`);
+              Object.keys(res.headers).forEach(k => console.log(`${colors.bold}${k}${colors.reset}: ${res.headers[k]}`));
+          }).on("error", e => console.error(e.message));
+      },
+
+      "tech": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer tech <url>${colors.reset}`);
+          let u = args[0]; if (!u.startsWith("http")) u = "https://" + u;
+          console.log(`${colors.cyan}[*] Detecting tech: ${u}...${colors.reset}`);
+          const proto = u.startsWith("https") ? require("https") : require("http");
+          proto.get(u, (res) => {
+              const h = res.headers;
+              console.log(`${colors.bold}Server:${colors.reset}       ${h["server"]||"Unknown"}`);
+              console.log(`${colors.bold}X-Powered-By:${colors.reset} ${h["x-powered-by"]||"Unknown"}`);
+              if (h["set-cookie"]) {
+                  h["set-cookie"].forEach(c => {
+                      if (c.includes("PHPSESSID")) console.log(`${colors.magenta}[!] PHP Detected${colors.reset}`);
+                      if (c.includes("JSESSIONID")) console.log(`${colors.magenta}[!] Java Detected${colors.reset}`);
+                      if (c.includes("ASP.NET")) console.log(`${colors.magenta}[!] ASP.NET Detected${colors.reset}`);
+                  });
+              }
+          }).on("error", e => console.error(e.message));
+      },
+      
+      "ssl": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer ssl <host> [port]${colors.reset}`);
+          const host = args[0];
+          const port = args[1] || 443;
+          console.log(`${colors.cyan}[*] Inspecting SSL: ${host}:${port}...${colors.reset}`);
+          const tls = require("tls");
+          const socket = tls.connect(port, host, { servername: host }, () => {
+              const cert = socket.getPeerCertificate();
+              if (socket.authorized) console.log(`${colors.green}[+] Authorized${colors.reset}`);
+              else console.log(`${colors.yellow}[!] Unauthorized: ${socket.authorizationError}${colors.reset}`);
+              console.log(`${colors.bold}Subject:${colors.reset} ${cert.subject.CN} (${cert.subject.O})`);
+              console.log(`${colors.bold}Issuer:${colors.reset}  ${cert.issuer.CN} (${cert.issuer.O})`);
+              console.log(`${colors.bold}Valid:${colors.reset}   ${cert.valid_from} to ${cert.valid_to}`);
+              console.log(`${colors.bold}Fingerprint:${colors.reset} ${cert.fingerprint}`);
+              socket.destroy();
+          });
+          socket.on("error", e => console.error(e.message));
+      },
+
+      "curl": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer curl <url>${colors.reset}`);
+          let u = args[0]; if (!u.startsWith("http")) u = "https://" + u;
+          const proto = u.startsWith("https") ? require("https") : require("http");
+          proto.get(u, res => {
+              res.pipe(process.stdout);
+          }).on("error", e => console.error(e.message));
+      },
+
+      "robots": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer robots <url>${colors.reset}`);
+          let u = args[0]; if (!u.startsWith("http")) u = "https://" + u;
+          u = u.endsWith("/") ? u + "robots.txt" : u + "/robots.txt";
+          console.log(`${colors.cyan}[*] Fetching ${u}...${colors.reset}`);
+          const proto = u.startsWith("https") ? require("https") : require("http");
+          proto.get(u, res => {
+              if (res.statusCode !== 200) console.log(`${colors.yellow}[!] Status: ${res.statusCode}${colors.reset}`);
+              res.pipe(process.stdout);
+          }).on("error", e => console.error(e.message));
+      },
+
+      // --- CRYPTO / ENCODING ---
+      "b64": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer b64 <enc/dec> <string>${colors.reset}`);
+          const mode = args[0]; const str = args.slice(1).join(" ");
+          if (mode === "enc") console.log(Buffer.from(str).toString("base64"));
+          else if (mode === "dec") console.log(Buffer.from(str, "base64").toString("utf8"));
+          else console.log("Unknown mode. Use enc or dec.");
+      },
+
+      "hex": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer hex <enc/dec> <string>${colors.reset}`);
+          const mode = args[0]; const str = args.slice(1).join(" ");
+          if (mode === "enc") console.log(Buffer.from(str).toString("hex"));
+          else if (mode === "dec") console.log(Buffer.from(str, "hex").toString("utf8"));
+      },
+
+      "md5": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer md5 <string>${colors.reset}`);
+          console.log(require("crypto").createHash("md5").update(args.join(" ")).digest("hex"));
+      },
+
+      "sha1": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer sha1 <string>${colors.reset}`);
+          console.log(require("crypto").createHash("sha1").update(args.join(" ")).digest("hex"));
+      },
+      
+      "sha256": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer sha256 <string>${colors.reset}`);
+          console.log(require("crypto").createHash("sha256").update(args.join(" ")).digest("hex"));
+      },
+
+      "url": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer url <enc/dec> <string>${colors.reset}`);
+          const mode = args[0]; const str = args.slice(1).join(" ");
+          if (mode === "enc") console.log(encodeURIComponent(str));
+          else if (mode === "dec") console.log(decodeURIComponent(str));
+      },
+
+      "uuid": async (args) => {
+          console.log(require("crypto").randomUUID());
+      },
+      
+      // --- SYSTEM / UTILS ---
+      "ls": async (args) => {
+          const fs = require("fs");
+          const p = args[0] || ".";
+          try {
+              const files = fs.readdirSync(p);
+              files.forEach(f => {
+                  const stat = fs.statSync(require("path").join(p, f));
+                  const isDir = stat.isDirectory();
+                  console.log(isDir ? `${colors.blue}${f}/${colors.reset}` : f);
+              });
+          } catch(e) { console.error(e.message); }
+      },
+
+      "cat": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer cat <file>${colors.reset}`);
+          try { require("fs").createReadStream(args[0]).pipe(process.stdout); } catch(e) { console.error(e.message); }
+      },
+      
+      "grep": async (args) => {
+          if (!args[1]) return console.log(`${colors.red}Usage: fazer grep <pattern> <file>${colors.reset}`);
+          const pat = new RegExp(args[0]);
+          const file = args[1];
+          try {
+              const content = require("fs").readFileSync(file, "utf8");
+              content.split("\n").forEach((line, i) => {
+                  if (pat.test(line)) console.log(`${colors.magenta}${i+1}:${colors.reset} ${line.trim()}`);
+              });
+          } catch(e) { console.error(e.message); }
+      },
+      
+      "wc": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer wc <file>${colors.reset}`);
+          try {
+              const c = require("fs").readFileSync(args[0], "utf8");
+              console.log(`Lines: ${c.split("\n").length}, Chars: ${c.length}`);
+          } catch(e) { console.error(e.message); }
+      },
+      
+      "whoami": async (args) => {
+          const os = require("os");
+          console.log(`${os.userInfo().username} @ ${os.hostname()} (${os.platform()} ${os.release()})`);
+      },
+      
+      "env": async (args) => {
+          Object.keys(process.env).forEach(k => console.log(`${colors.bold}${k}${colors.reset}=${process.env[k]}`));
+      },
+      
+      "pass": async (args) => {
+          const len = args[0] ? parseInt(args[0]) : 16;
+          const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+";
+          let res = "";
+          for(let i=0; i<len; i++) res += chars.charAt(Math.floor(Math.random() * chars.length));
+          console.log(res);
+      },
+
+      "calc": async (args) => {
+          if (!args[0]) return console.log(`${colors.red}Usage: fazer calc <expr>${colors.reset}`);
+          try { console.log(eval(args.join(" "))); } catch(e) { console.error("Error"); }
+      },
+      
+      "now": async (args) => {
+          console.log(new Date().toISOString());
+          console.log("Timestamp: " + Date.now());
+      },
+      
+      "coin": async (args) => {
+          const r = Math.random() < 0.5 ? "Pile (Heads)" : "Face (Tails)";
+          console.log(colors.yellow(r));
+      },
+
+      "dice": async (args) => {
+          const r = Math.floor(Math.random() * 6) + 1;
+          console.log(colors.yellow("🎲 " + r));
+      },
+
+      "uptime": async (args) => {
+          const up = process.uptime();
+          const h = Math.floor(up / 3600);
+          const m = Math.floor((up % 3600) / 60);
+          const s = Math.floor(up % 60);
+          console.log(colors.cyan(`Uptime: ${h}h ${m}m ${s}s`));
+      },
+
+      "mem": async (args) => {
+          const used = process.memoryUsage();
+          console.log(colors.cyan("Memory Usage:"));
+          console.log(`  RSS:       ${Math.round(used.rss / 1024 / 1024)} MB`);
+          console.log(`  Heap Used: ${Math.round(used.heapUsed / 1024 / 1024)} MB`);
+          console.log(`  External:  ${Math.round(used.external / 1024 / 1024)} MB`);
+      },
+
+      "disk": async (args) => {
+          try {
+              require("child_process").exec("wmic logicaldisk get size,freespace,caption", (err, stdout) => {
+                  if(err) console.log(colors.red("Error fetching disk info"));
+                  else console.log(colors.cyan(stdout.trim()));
+              });
+          } catch(e) { console.log(colors.red("Disk info unavailable")); }
+      },
+
+      "rot13": async (args) => {
+          if(!args[0]) return console.log(colors.red("Usage: fazer rot13 <text>"));
+          const input = args.join(" ");
+          const out = input.replace(/[a-zA-Z]/g, (c) => {
+              const base = c <= 'Z' ? 65 : 97;
+              return String.fromCharCode(base + (c.charCodeAt(0) - base + 13) % 26);
+          });
+          console.log(colors.green(out));
+      },
+
+      "reverse": async (args) => {
+           if(!args[0]) return console.log(colors.red("Usage: fazer reverse <text>"));
+           console.log(colors.green(args.join(" ").split("").reverse().join("")));
+      }
+
+  };
+
+  if (CLI_COMMANDS[cmd]) {
+      await CLI_COMMANDS[cmd](argv.slice(1));
+      return;
+  }
+
   let fileArg = null;
   let forwarded = [];
 
@@ -2705,7 +3438,16 @@ async function main() {
 
   const parser = new FazerParser();
   parser.input = lex.tokens;
-  const ast = parser.program();
+  let ast;
+  try {
+      ast = parser.program();
+  } catch (e) {
+      if (e.name === "FazerError") {
+          console.error(prettyError(e, filePath, code));
+          process.exit(1);
+      }
+      throw e;
+  }
 
   if (parser.errors.length) {
     const e = parser.errors[0];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fazer-lang",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Fazer — The ultimate automation language. Batteries-included: Native EXE Build, Red Team Tools (Crypto/Reg/Shell), Icons, HTTP Server, System Exec, Clipboard, Discord, and Pipe Operators (->). Secure, powerful, and robust.",
   "main": "fazer.js",
   "types": "index.d.ts",