Multi-Channel Hybrid Bot Engine
The Challenge
Managing automated interactions across disparate messaging platforms (Telegram, Discord, WhatsApp) required fragmented codebases, leading to duplicate logic, hard-to-maintain state machines, and inconsistent user experiences. Furthermore, scaling capabilities dynamically based on user context was nearly impossible.
The Architecture
I architected a centralized Hybrid Bot Engine in Python that acts as a universal router for incoming webhooks from multiple platforms. The system uses a modular message_handle.py logic layer paired with bot_state.py to maintain user session contexts persistently across platform boundaries.
For executing autonomous tasks, I integrated an "Octopus Workflow Engine" (octopus_legs.py) that spins up specific worker threads to handle intensive processes without blocking the main event loop. Additionally, the engine natively integrates with a local/cloud LLM layer (Gemma/LitAI) via frontman_gemma26.py to interpret unstructured intent from users across any platform seamlessly.
System Architecture Visualized
The Impact
The unified engine reduced code redundancy by 70% and enabled instant cross-platform deployment of new AI capabilities. A feature built for Discord is now immediately available on Telegram and WhatsApp without any code changes.
Autonomous AI Web Agent
The Challenge
Traditional web scrapers fail when confronted with modern JavaScript-heavy SPAs (Single Page Applications) or complex multi-step authentication flows. We needed a robust way to interact with dynamic sites automatically while bypassing simplistic bot-detection mechanisms.
The Architecture
I built an autonomous Web Browser Agent Engine residing in the server_code/web_agent directory. The core component, agent_brain.py, uses AI models to visually interpret the DOM (via dom_utils.py) and decide on actions (click, type, scroll) rather than relying on brittle CSS selectors.
The system utilizes a custom chrome_launch.py module with an integrated cookie_manager.py to maintain authenticated sessions securely, mimicking human interaction patterns to prevent rate-limiting and bans.
System Architecture Visualized
The Impact
This agent handles complex workflows like navigating e-commerce catalogs and managing social media publishing flows (Facebook, Tumblr) with near-zero maintenance overhead, adapting to UI changes dynamically through visual AI interpretation.
Smart AI Job Hunting Pipeline
The Challenge
Monitoring incoming emails for highly specific, high-paying remote job opportunities is incredibly time-consuming. Generic job alert filters often miss nuanced roles or flood the inbox with irrelevant matches.
The Architecture
I developed the main_job_finder.py pipeline. It initiates an email_fetcher.py service to securely connect via IMAP and extract raw job alert payloads. These payloads are then streamed into ai_job_analyzer.py, which interfaces directly with Gemini AI and OpenRouter.
The LLM is prompted with strict JSON-schema enforcement to extract crucial datapoints (Salary, Remote Status, Tech Stack, Visa Sponsorship) and score the job based on my specific career goals. The results are instantly compiled into a structured markdown report (job_report.md) for immediate action.
System Architecture Visualized
The Impact
Reduced daily job-searching time from hours to minutes. The pipeline acts as a personal AI recruiter, filtering noise and presenting only top-tier opportunities with summarized actionable metrics.
Massive Data Deduplication Engine
The Challenge
When aggregating e-commerce data (like ASINs and product images) from hundreds of decentralized sources, data redundancy becomes a critical performance bottleneck. Simply checking file names or textual IDs is insufficient because the same image might be re-uploaded under different metadata.
The Architecture
Located in the ultimate_data_provider module, I engineered a multi-layered deduplication system. For structured data, the unique_identifier_tracker.py ensures O(1) lookup times using MongoDB indexing for ASINs and SKUs.
To handle visual redundancy, I implemented image_phash_tracker.py. This system calculates a perceptual hash (pHash) for every incoming image. Unlike cryptographic hashes (MD5/SHA), pHash allows us to detect visually similar images even if they have been resized, compressed, or slightly cropped. The hashes are stored in MongoDB and queried using Hamming distance algorithms.
System Architecture Visualized
The Impact
Storage costs were optimized dramatically, and the database integrity remains flawless. The system processes thousands of incoming media files in real-time, instantly discarding visual duplicates before they hit the cloud storage bucket.
Blogger XML Template Engine
The Challenge
Standard CMS platforms often come with heavy backend bloat and slow load times. I needed a highly customized, ultra-fast frontend architecture hosted on Google's free Blogger infrastructure, but with the capabilities of a modern web application.
The Architecture
I fundamentally re-engineered the Blogger XML backend (`complet file.txt`). I bypassed standard Blogger widgets, injecting custom CSS grids, modern typography, and JavaScript-driven interactions. I strictly protected critical SEO metadata blocks and Google AdSense integration zones to ensure maximum monetization efficiency.
The template dynamically manages DOM manipulation based on the page type (Index vs. Item View) using conditional Blogger XML tags (e.g., <b:if cond='data:view.isSingleItem'>), ensuring optimal asset delivery.
System Architecture Visualized
The Impact
Achieved a near 100/100 Lighthouse performance score while utilizing a completely free hosting ecosystem. The custom architecture allows for rapid deployment of niche affiliate sites with robust SEO out-of-the-box.
WordPress Security Incident Response & Botnet Rescue
The Challenge
A prominent digital agency faced a highly targeted, automated botnet attack that successfully compromised their multi-domain WordPress hosting environment. The attackers exploited vulnerable plugin endpoints to drop persistent backdoors, manipulated core database settings to enable unauthorized public registration, and escalated default user roles to Administrator. Furthermore, the botnet corrupted theme headers with malformed script tags, completely breaking the layout of critical frontend pages.
Forensic Attack Vector Diagram
Technical CLI Attack Flow
│
└──► 1. Vulnerability Exploit (via wp-file-manager)
│
└──► 2. File Injection (wp-554648.php dropped in mu-plugins)
│
└──► 3. Database Tampering (Modified wp_options)
├──► Set users_can_register = 1 (Public Registration Enabled)
└──► Set default_role = administrator
│
└──► 4. Automated Rogue Admin Creation (e.g., dougzcn726879308)
│
└──► 5. Establish Persistence via REST API Application Passwords
The Architecture of Recovery
Immediate damage control required isolating the server. The recovery pipeline was executed through a structured forensic methodology:
1. Emergency Identification & Eradication: Utilizing WP-CLI over SSH, I queried the wp_users and wp_options tables, identifying and purging rogue accounts (e.g., dougzcn726879308). Malicious backdoors like wp-554648.php hidden in the Must-Use plugins (mu-plugins) directory were hunted down and deleted.
2. Registration Lockdown & Database Repair: The hijacked wp_options parameters were forcibly reverted, instantly stopping the automated creation of fake admins. I manually cleaned malformed script injections from the ihaf_insert_header options, successfully restoring the broken CSS layout on the frontend.
3. Custom Must-Use Hardening Injection: To completely sever the attacker's persistent API access, I engineered and deployed a custom server-level Must-Use plugin (security-hardening.php). This script forcefully disabled REST API Application Passwords and XML-RPC pingbacks at the core level.
4. Deep-Dive Malware Scan: Python-based SSH scripts were deployed to scan the entire document root for steganography, obfuscated PHP (eval(base64_decode...)), and malicious .htaccess overrides, ensuring a 100% clean environment.
The Impact
The entire hosting environment was 100% sanitized, hardened, and locked down without a single byte of data loss. The client's domains are now protected against further privilege escalation attacks, and the custom hardening logic guarantees that standard automated botnets cannot re-establish persistence.