webshell-analyzer 1.0.0__tar.gz

webshell_analyzer-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adelia saputri
+
+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.

webshell_analyzer-1.0.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: webshell-analyzer
+Version: 1.0.0
+Summary: Webshell Detection Tool integrating Machine Learning based on Static Feature Extraction
+Author-email: Adelia Saputri <adelias.dev@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Adelia saputri
+        
+        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.
+        
+Keywords: webshell,detection,machine learning,security,php
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Classifier: Intended Audience :: System Administrators
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: colorama
+Requires-Dist: pyfiglet
+Requires-Dist: joblib
+Dynamic: license-file
+
+# Webshell-Analyzer
+![Webshell Analyzer Home Screen](/assets/images/home-screen.png "Home Screen")
+webshell analyzer is command line based webshell detection tool that utillizes static feature extraction and using Random Forest classification to detect malicious PHP webshell.
+
+# Table of Contens
+- About
+- Features
+- Requirements
+- Instalation
+- Usage
+- Commands
+
+# About
+webshell analyzer was developed to assist security analysts, researchers, and system administrators in identifying potentially malicious PHP files before they are executed on a web server. the tool helps to mitigate the risk of unauthorised access, web defacement attacks, and persistent backdoor attacks, which are commonly associated with webshells.
+
+this system combines three static code analysis methods: lexical analysis, statistical analysis, and Abstract Syntax Tree (AST) analysis. this approach enables the detection process to identify suspicious functions, code structure patterns, and statistical characteristics that may indicate malicious behavior.
+
+# Features
+- Scan individual PHP files for webshell indicators
+- Recursively scan entire directories
+- Static feature extraction (no code execution required)
+- Machine learning classification using Random Forest
+- Export results to only JSON file
+- Interactive CLI environment
+
+# Requirements
+before installing and running webshell analyzer, ensure that your system meets the following requirements :
+
+- Python 3.10 or later
+- Pip (oython package manager)
+- Git
+
+**Python Dependencies**
+The required python packages are listed in the ```requirements.txt``` file and can be installed automatically using :
+
+```pip install -r requirements.txt```
+
+# Installation
+to install webshell analyzer, clone this repository to your local machine using the following command :
+
+```git clone https://github.com```
+
+After the installation process is complete, the system is ready to use.
+
+# Usage
+To get started with Webshell Analyzer:
+
+Start ```bash wsanalyzer```:  this is the main command to enter the Webshell Analyzer interactive environment.
+You will be greeted with the Webshell Analyzer prompt:
+
+From here, you can run all available commands such as `scan`, `detect`, `--output`, `help`, `exit`.
+
+# Command
+1. ```scan <directory_path> [--output <output_file.json>]``` -> scan all PHP files in a directory for webshell detection
+2. ```detect <file_path> [--output <output_file.json>]``` -> detect a specific file for webshell activity
+3. ```help``` -> for show this help message
+4. ```exit``` -> For Exit the Webshell Analyzer
+5. ```--output <output_file.json>``` -> Save the detection results to a JSON file
+
+
+
+

webshell_analyzer-1.0.0/README.md

@@ -0,0 +1,62 @@
+# Webshell-Analyzer
+![Webshell Analyzer Home Screen](/assets/images/home-screen.png "Home Screen")
+webshell analyzer is command line based webshell detection tool that utillizes static feature extraction and using Random Forest classification to detect malicious PHP webshell.
+
+# Table of Contens
+- About
+- Features
+- Requirements
+- Instalation
+- Usage
+- Commands
+
+# About
+webshell analyzer was developed to assist security analysts, researchers, and system administrators in identifying potentially malicious PHP files before they are executed on a web server. the tool helps to mitigate the risk of unauthorised access, web defacement attacks, and persistent backdoor attacks, which are commonly associated with webshells.
+
+this system combines three static code analysis methods: lexical analysis, statistical analysis, and Abstract Syntax Tree (AST) analysis. this approach enables the detection process to identify suspicious functions, code structure patterns, and statistical characteristics that may indicate malicious behavior.
+
+# Features
+- Scan individual PHP files for webshell indicators
+- Recursively scan entire directories
+- Static feature extraction (no code execution required)
+- Machine learning classification using Random Forest
+- Export results to only JSON file
+- Interactive CLI environment
+
+# Requirements
+before installing and running webshell analyzer, ensure that your system meets the following requirements :
+
+- Python 3.10 or later
+- Pip (oython package manager)
+- Git
+
+**Python Dependencies**
+The required python packages are listed in the ```requirements.txt``` file and can be installed automatically using :
+
+```pip install -r requirements.txt```
+
+# Installation
+to install webshell analyzer, clone this repository to your local machine using the following command :
+
+```git clone https://github.com```
+
+After the installation process is complete, the system is ready to use.
+
+# Usage
+To get started with Webshell Analyzer:
+
+Start ```bash wsanalyzer```:  this is the main command to enter the Webshell Analyzer interactive environment.
+You will be greeted with the Webshell Analyzer prompt:
+
+From here, you can run all available commands such as `scan`, `detect`, `--output`, `help`, `exit`.
+
+# Command
+1. ```scan <directory_path> [--output <output_file.json>]``` -> scan all PHP files in a directory for webshell detection
+2. ```detect <file_path> [--output <output_file.json>]``` -> detect a specific file for webshell activity
+3. ```help``` -> for show this help message
+4. ```exit``` -> For Exit the Webshell Analyzer
+5. ```--output <output_file.json>``` -> Save the detection results to a JSON file
+
+
+
+

webshell_analyzer-1.0.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "webshell-analyzer"
+version = "1.0.0"
+authors = [
+    {name = "Adelia Saputri", email = "adelias.dev@gmail.com"}
+]
+description = "Webshell Detection Tool integrating Machine Learning based on Static Feature Extraction"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.8"
+keywords = ["webshell", "detection", "machine learning", "security", "php"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Security",
+    "Intended Audience :: System Administrators",
+]
+dependencies = [
+    "pandas",
+    "scikit-learn",
+    "colorama",
+    "pyfiglet",
+    "joblib",
+]
+
+[project.scripts]
+wsanalyzer = "webshell_analyzer.cli.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["webshell_analyzer*"]
+
+[tool.setuptools.package-data]
+webshell_analyzer = [
+    # File model
+    "model/*.joblib",
+    "model/*.json",
+
+    # File PHP AST extraction — src
+    "extractor/ast_extraction/src/*.php",
+
+    # File vendor nikic/PHP-Parser
+    "extractor/ast_extraction/vendor/autoload.php",
+    "extractor/ast_extraction/vendor/composer/*.php",
+    "extractor/ast_extraction/vendor/composer/*.json",
+    "extractor/ast_extraction/vendor/nikic/**/*.php",
+
+    # File composer
+    "extractor/ast_extraction/composer.json",
+    "extractor/ast_extraction/composer.lock",
+]

webshell_analyzer-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

webshell_analyzer-1.0.0/webshell_analyzer/cli/cli.py

@@ -0,0 +1,151 @@
+import pyfiglet
+import cmd
+import os
+import shlex
+import json
+import sys
+from colorama import Fore, Style, init
+from webshell_analyzer.modules.detector import detect_file
+from webshell_analyzer.modules.scanner import scan_directory
+
+sys.stdout.reconfigure(encoding='utf-8')
+init(autoreset=True)
+
+def banner ():
+    f = pyfiglet.figlet_format("W3bshell-Analyzer", font="big_money-se")
+    print(Fore.MAGENTA + f)
+    print(Fore.MAGENTA + "Webshell Analyzer Tool Integrating Machine Learning".center(80))
+    print(Fore.MAGENTA + "Based on Extracting Features from PHP Source Code".center(80))
+    print(Fore.MAGENTA + "=" * 80)
+    print(Fore.MAGENTA + "Author : Adelia Saputri")
+    print(Fore.MAGENTA + "Github : https://github.com/adeliasaputri")
+    print(Fore.MAGENTA + "Email  : adelias.dev@gmail.com")
+    print(Fore.MAGENTA + "Engine : AST + Lexical + Statistical Features")
+    print(Fore.MAGENTA + "=" * 80 + "\n")
+
+def parse_args(args):
+    path = None
+    output = None
+    output_missing = False
+
+    i = 0
+    while i < len(args):
+        if args[i] == "--output":
+            if i + 1 < len(args) and not args[i + 1].startswith("--"):
+                output = args[i + 1]
+                i += 1
+            else:
+                output_missing = True
+        else:
+            path = args[i]
+        i += 1
+    return path, output, output_missing
+
+class webshell_cmd(cmd.Cmd):
+    prompt = Fore.MAGENTA + "w3bshell-analyzer> "
+
+    def do_scan(self, arg):
+        """Scan Directory: scan <directory_path>"""
+        try :
+            args = shlex.split(arg)
+        except :
+            print(Fore.RED + "Error: Invalid arguments. Usage: scan <path> [--output <output_file>]")
+            return
+        
+        if len(args) == 0:
+            print(Fore.RED + "[ERROR] Path is required. Usage: scan <path> [--output <output_file>]")
+            return
+        
+        directorypath, output, output_missing = parse_args(args)
+
+        if output_missing:
+            print(Fore.RED + "[ERROR] flag '--output' is requires a filename argument. Usage: detect <file_path> --output <output_file.json>")
+            return
+
+        if not os.path.isdir(directorypath):
+            print(Fore.RED + f"[ERROR] Path '{directorypath}' is not a valid directory.")
+            return
+        
+        #Validasi output
+        if output is not None:
+            output_dir = os.path.dirname(output)
+            if output_dir != "" and not os.path.isdir(output_dir):
+                print(Fore.RED + f"[ERROR] Cannot save output to Directory \"{output_dir}\". Please ensure the destination folder exists before saving!")
+                return
+            if not output.endswith(".json"):
+                print(Fore.RED + f"[ERROR] Output file must have a .json extension")
+                return
+
+        print(Fore.GREEN + f"[SCANNING DIRECTORY..]: {directorypath}\n")
+        result = scan_directory(directorypath, output_file=output)
+    
+    def do_detect(self, arg):
+        """Detect File: detect <file_path>"""
+        try :
+            args = shlex.split(arg)
+        except :
+            print(Fore.RED + "[ERROR] Invalid arguments. Usage: detect <file_path> [--output <output_file>]")
+            return
+        
+        if len(args) == 0:
+            print(Fore.RED + "[ERROR] Path is required. Usage: detect <path> [--output <output_file>]")
+            return
+        
+        filepath, output, output_missing = parse_args(args)
+
+        if output_missing:
+            print(Fore.RED + "[ERROR] flag '--output' is requires a filename argument. Usage: detect <file_path> --output <output_file.json>")
+            return
+
+        if not os.path.isfile(filepath):
+            print(Fore.RED + f"[ERROR] File '{filepath}' does not exist.")
+            return
+
+        #Validasi output
+        if output is not None:
+            output_dir = os.path.dirname(output)
+            if output_dir != "" and not os.path.isdir(output_dir):
+                print(Fore.RED + f"[ERROR] Cannot save output to Directory {output_dir}")
+                print(Fore.RED + f"Please ensure the destination folder exists before saving")
+                return
+            if not output.endswith(".json"):
+                print(Fore.RED + f"[ERROR] Output file must have a .json extension")
+                return
+        
+        print (Fore.GREEN + f"[ANALYZING..] {filepath}")
+        detect_file(filepath, output_file=output)
+
+
+    def do_help(self, arg):
+        """Show help message"""
+        print(Fore.CYAN + "=" * 50)
+        print(Fore.CYAN + "AVAILABLE COMMANDS: \n")
+        print(Fore.CYAN + "scan <directory_path> [--output <output_file.json>] -> scan all PHP files in a directory for webshell detection")
+        print(Fore.CYAN + "detect <file_path> [--output <output_file.json>] -> detect a specific file for webshell activity")
+        print(Fore.CYAN + "help -> for show this help message")
+        print(Fore.CYAN + "exit -> For Exit the Webshell Analyzer")
+        print(Fore.CYAN + "=" * 50)
+        print(Fore.CYAN + "OPTIONAL ARGUMENTS: \n")
+        print(Fore.CYAN + "--output <output_file.json> -> Save the detection results to a JSON file")
+        print(Fore.CYAN + "=" * 50 + "\n")
+
+    def do_exit(self, arg):
+        """Exit the webshell analyzer"""
+        print(Fore.GREEN + "Exiting webshell analyzer, Goodbye!")
+        return True
+    
+    def default(self, line):
+        """Handle unknown commands"""
+        print(Fore.RED +  "Unknown command: " + f'{line}')
+        print("Type 'help' for a list of available commands.\n")
+
+    def emptyline(self):
+        pass
+
+def main() :
+    banner()
+    webshell_cmd().cmdloop()
+
+if __name__ == "__main__":
+    main()
+

webshell_analyzer-1.0.0/webshell_analyzer/extractor/ast_extraction/composer.json

@@ -0,0 +1,5 @@
+{
+    "require": {
+        "nikic/php-parser": "^5.7"
+    }
+}

webshell_analyzer-1.0.0/webshell_analyzer/extractor/ast_extraction/composer.lock

@@ -0,0 +1,77 @@
+{
+    "_readme": [
+        "This file locks the dependencies of your project to a known state",
+        "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
+        "This file is @generated automatically"
+    ],
+    "content-hash": "efef34747d233325e6e1b13c0f9b9df0",
+    "packages": [
+        {
+            "name": "nikic/php-parser",
+            "version": "v5.7.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/nikic/PHP-Parser.git",
+                "reference": "dca41cd15c2ac9d055ad70dbfd011130757d1f82"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/dca41cd15c2ac9d055ad70dbfd011130757d1f82",
+                "reference": "dca41cd15c2ac9d055ad70dbfd011130757d1f82",
+                "shasum": ""
+            },
+            "require": {
+                "ext-ctype": "*",
+                "ext-json": "*",
+                "ext-tokenizer": "*",
+                "php": ">=7.4"
+            },
+            "require-dev": {
+                "ircmaxell/php-yacc": "^0.0.7",
+                "phpunit/phpunit": "^9.0"
+            },
+            "bin": [
+                "bin/php-parse"
+            ],
+            "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "5.x-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "PhpParser\\": "lib/PhpParser"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "BSD-3-Clause"
+            ],
+            "authors": [
+                {
+                    "name": "Nikita Popov"
+                }
+            ],
+            "description": "A PHP parser written in PHP",
+            "keywords": [
+                "parser",
+                "php"
+            ],
+            "support": {
+                "issues": "https://github.com/nikic/PHP-Parser/issues",
+                "source": "https://github.com/nikic/PHP-Parser/tree/v5.7.0"
+            },
+            "time": "2025-12-06T11:56:16+00:00"
+        }
+    ],
+    "packages-dev": [],
+    "aliases": [],
+    "minimum-stability": "stable",
+    "stability-flags": {},
+    "prefer-stable": false,
+    "prefer-lowest": false,
+    "platform": {},
+    "platform-dev": {},
+    "plugin-api-version": "2.6.0"
+}

webshell_analyzer-1.0.0/webshell_analyzer/extractor/ast_extraction/src/NodeVisitor.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace NodeVisitor;
+
+require_once __DIR__ . '/../vendor/autoload.php';
+require_once __DIR__ . '/featuresDeclare.php';
+
+use Features\featureWrapper;
+use PhpParser\NodeVisitorAbstract;
+use PhpParser\Node;
+use PhpParser\Node\Name;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt;
+
+class NodeVisitor extends NodeVisitorAbstract {
+    private featureWrapper $features;
+    private array $superglobal = ['_GET', '_POST', '_COOKIE', '_REQUEST', '_FILES', '_ENV', '_SERVER', '_SESSION', 'GLOBALS'];
+
+     public function __construct(featureWrapper $features){
+        $this->features = $features;
+    }
+
+    public function enterNode(Node $node) {
+        $this->handleDynamicFeatures($node);
+        $this->handleStructuralFeatures($node);
+    }
+    
+    private function getFuncName(Node $node): ?string {
+        if($node instanceof Expr\FuncCall && $node->name instanceof Name){
+            return strtolower($node->name->toString());
+        }
+        return null;
+    }
+
+    private function isSuperglobal(Node $node): bool {
+        return $node instanceof Expr\ArrayDimFetch && $node->var instanceof Expr\Variable && is_string($node->var->name) && in_array($node->var->name, $this->superglobal);
+    }
+
+    private function handleDynamicFeatures(Node $node){
+        #dynamic function call exists (dynamicFuncCallExists feature)
+        if($node instanceof Expr\FuncCall && $node->name instanceof Expr\Variable){
+            $this->features->dynamicFeatures->dynamicFuncCallExists = true;
+        }
+        #check for variable variables (varExists feature)
+        if($node instanceof Expr\Variable && $node->name instanceof Expr\Variable){
+            $this->features->dynamicFeatures->varExists = true;
+        }
+        #count variable usage (varUsageCount feature)
+        if($node instanceof Expr\Variable){
+            $this->features->dynamicFeatures->varUsageCount++;
+        }
+        #count assignments (assignmentCount feature)
+        if($node instanceof Expr\Assign){
+            $this->features->dynamicFeatures->assignmentCount++;
+        }
+    }
+
+    private function handleStructuralFeatures(Node $node) {
+
+        #class definition exists (classDefExists feature)
+        if($node instanceof Stmt\Class_){
+            $this->features->structuralFeatures->classDefExists = true;
+        }
+
+        #count function definitions (funcDefCount feature)
+        if($node instanceof Stmt\Function_ || $node instanceof Stmt\ClassMethod){
+            $this->features->structuralFeatures->funcDefCount++;
+        }
+
+        #count superglobal used as function argument (superglobalAsFuncArg feature)
+        if($node instanceof Expr\FuncCall ){
+            foreach($node->args as $arg){
+                if($this->isSuperglobal($arg->value)){
+                    $this->features->structuralFeatures->superglobalAsFuncArg++;
+                }
+            }
+        }
+
+        #count suspicious concatenation (suspiciousConcat feature)
+        if($node instanceof Expr\BinaryOp\Concat){
+            $this->features->structuralFeatures->suspiciousConcat = ($this->features->structuralFeatures->suspiciousConcat ?? 0) + 1;
+        }
+    }
+}
+?>

webshell_analyzer-1.0.0/webshell_analyzer/extractor/ast_extraction/src/astBuilder.php

@@ -0,0 +1,50 @@
+<?php
+
+require_once __DIR__ . '/../vendor/autoload.php';
+require_once __DIR__ . '/featuresDeclare.php';
+require_once __DIR__ . '/NodeVisitor.php';
+
+
+use PhpParser\ParserFactory;
+use PhpParser\NodeTraverser;
+use Features\featureWrapper;
+use NodeVisitor\NodeVisitor;
+use PhpParser\PhpVersion;
+
+class astBuilder
+{
+    public $parser;
+
+    public function __construct()
+    {
+        $factory = new ParserFactory();
+        $this->parser = $factory->createForVersion(PhpParser\PhpVersion::fromString('5.6'));
+    }
+
+    public function builder($code)
+    {
+        
+        $feature = new featureWrapper();
+#debug
+        $code = preg_replace('/\$(\w+)\{([^}]+)\}/', '$\1[\2]', $code);
+        $code = str_replace(["<?PHP", "<?Php"], "<?php", $code);
+        $code = str_replace('@', '', $code);
+
+        try {
+            $stmts = $this->parser->parse($code);
+        } catch (\Throwable $e) {
+            error_log("Parse error in code: " . $e->getMessage());
+            return $feature->toArray();
+        }
+
+        $traverser = new NodeTraverser();
+        $visitor = new NodeVisitor($feature);
+        $traverser->addVisitor($visitor);
+        $traverser->traverse($stmts);
+
+        return $feature->toArray();
+    }
+
+}
+
+?>

webshell_analyzer-1.0.0/webshell_analyzer/extractor/ast_extraction/src/astExtractor.php

@@ -0,0 +1,50 @@
+<?php
+error_reporting(0);
+ini_set('display_errors', 0);
+ini_set('log_errors', 0);
+
+ob_start();
+
+
+require_once __DIR__ . '/../vendor/autoload.php';
+require_once __DIR__ . '/astBuilder.php';
+
+if($argc < 2) {
+    echo json_encode("Error: No file path provided") . "\n";
+    exit(1);
+}
+
+$filepath = $argv[1];
+
+if(!file_exists($filepath)) {
+    echo json_encode("Error: File not found: $filepath") . "\n";
+    exit(1);
+}
+
+
+$code = file_get_contents($filepath);
+$code = trim($code);
+
+
+if ($code === false || trim($code) === '') {
+    echo json_encode("Error Empty file");
+    exit(1);
+}
+
+$builder = new astBuilder();
+
+$result = $builder->builder($code);
+
+
+if (!is_array($result)) {
+    echo json_encode(["error" => "Builder did not return array"]);
+    exit(1);
+}
+
+if(ob_get_length()){
+    ob_clean();
+}
+
+// Output valid
+echo json_encode($result);
+?>