docs(readme): factor install path into $WHMCS variable

Both the Installation and Upgrading snippets previously hardcoded
/path/to/whmcs in multiple places, so a user copying the command had to
find-and-replace the placeholder twice (install) or three times (upgrade
with the addon). Set WHMCS=/path/to/whmcs once at the top of each snippet
and reference "$WHMCS/..." in every rsync destination instead — single
substitution point, less room for typos.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.github/workflows/publish-release.yml

@@ -1,19 +1,43 @@
----
 name: Publish Release
+
 on:
   push:
-    branches:
+    tags:
-      - main
+      - 'v*'
+
 jobs:
-  publish-release:
+  release:
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
-      - name: Publish Release
+      - name: Checkout code
-        uses: ncipollo/release-action@v1
+        uses: actions/checkout@v4
+
+      - name: Extract tag name
+        id: tag
+        run: echo "version=${GITHUB_REF#refs/tags/}" >> "$GITHUB_OUTPUT"
+
+      - name: Generate release notes
+        id: notes
+        run: |
+          # Get previous tag
+          PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo "")
+          if [ -n "$PREV_TAG" ]; then
+            NOTES=$(git log --pretty=format:"- %s" "$PREV_TAG"..HEAD)
+          else
+            NOTES=$(git log --pretty=format:"- %s")
+          fi
+          # Write to file for the release body
+          echo "$NOTES" > /tmp/release-notes.txt
+
+      - name: Create release
+        uses: softprops/action-gh-release@v2
         with:
-          token: ${{secrets.GITHUB_TOKEN}}
+          tag_name: ${{ steps.tag.outputs.version }}
+          name: ${{ steps.tag.outputs.version }}
+          body_path: /tmp/release-notes.txt
           draft: false
           prerelease: false
-          name: "0.0.${{ github.run_number }}"
+        env:
-          tag: "0.0.${{ github.run_number }}"
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          body: "Release 0.0.${{ github.run_number }}"

.gitignore

@@ -1 +1,3 @@
-/.idea/
+/.idea/
+/.superpowers/
+/vendor/

CHANGELOG.md

@@ -0,0 +1,123 @@
+# Changelog
+
+All notable changes to the VirtFusion Direct Provisioning Module for WHMCS.
+
+## [1.2.0] - 2026-04-17
+
+### Features
+- **PowerDNS reverse DNS (PTR) integration** — opt-in via companion `VirtFusionDns` addon module:
+  - Automatic PTR sync on server create, rename, and terminate
+  - Client-area "Reverse DNS" panel with one editable PTR per assigned IP and per-row status badges
+  - Admin services-tab widget with Reconcile (additive) and Reconcile (force reset) buttons
+  - Daily cron additive reconciliation (never overwrites existing PTRs)
+  - Forward-confirmed reverse DNS (FCrDNS) enforcement — PTR writes rejected if forward A/AAAA doesn't resolve to the target IP
+  - IPv4 + IPv6 support with full nibble-reversal for `ip6.arpa`
+  - RFC 2317 classless delegation support (both CIDR-prefix `0/26` and block-size `64/64` conventions)
+  - Automatic NOTIFY after every successful PATCH so slaves pick up SOA bumps immediately
+  - PowerDNS zone ID `=2F` URL-encoding for zones containing `/`
+- **Security hardening helpers** on the Module base class:
+  - `requirePost()` — 405 on non-POST mutations
+  - `requireSameOrigin()` — CSRF Origin/Referer check against WHMCS host
+  - `requireServiceStatus()` — filter endpoints by `tblhosting.domainstatus`
+  - Applied to all rDNS endpoints with successful-write audit logging
+- Merged Test Connection — when the DNS addon is active the admin button verifies both VirtFusion AND PowerDNS in a single check
+
+### Bug Fixes
+- `IpUtil::parseClasslessZone` now rejects misaligned start addresses (e.g., `3/26.x.y.z` — /26 ranges must begin at a multiple of 64). Prevents silent write-into-wrong-zone on misconfigured zone names.
+
+### Documentation
+- Detailed design-rationale commentary added across the module for future-developer onboarding (Cache, Curl, Log, Database, ServerResource, ConfigureService) and throughout the new PowerDNS subsystem
+- README updated with an extensive "Reverse DNS Addon (PowerDNS)" section covering activation, configuration, behaviour, and security posture
+- CLAUDE.md updated with architecture notes and PowerDNS API compatibility details
+
+## [1.0.0] - 2026-03-19
+
+### Features
+- OS template tile gallery with accordion categories, brand icons, and search
+- Inline server rename with friendly name generator
+- Traffic statistics canvas chart in resources panel
+- Backup listing timeline in manage panel
+- VNC enable/disable toggle with connection details and password copy
+- Server root password reset with auto-clipboard copy
+- Redis-backed API response caching with filesystem fallback
+- Skeleton loading, action cooldowns, progress indicators
+- Copy-to-clipboard buttons for IP addresses
+- Client-side SSH Ed25519 key generator on checkout page
+- VNC console support, resources panel, self-service billing
+- Configurable option sliders on checkout page
+
+### Bug Fixes
+- XSS escaping, null guards, and proper error handling
+- All state-mutating operations use POST instead of GET
+- Explicit break after all output() calls in client.php
+- Server-side regex validation on rename endpoint
+- Error messages sanitized (no raw API errors exposed to clients)
+
+### Removed
+- Client IP removal capability (IPs managed by VirtFusion)
+- IP add buttons (managed by VirtFusion during provisioning)
+- Firewall panel (non-functional; managed in VirtFusion admin)
+
+### Infrastructure
+- Tag-based release workflow (compatible with Gitea and GitHub)
+- Codebase consolidation: resolveServiceContext(), groupOsTemplates(), vfUrl(), vfShowAlert()
+
+## [0.0.18] - 2025-10-01
+
+### Changed
+- Updated GitHub Actions publish workflow
+- Moved custom field SQL to `modify.sql` file
+- Minor code tweaks
+
+## [0.0.17] - 2024-01-16
+
+### Fixed
+- Fix in hooks.php (PR #2 by Prophet731)
+
+## [0.0.16] - 2023-09-11
+
+### Added
+- GitHub issue templates
+
+## [0.0.15] - 2023-09-10
+
+### Fixed
+- Typo fixes in module code
+
+## [0.0.14] - 2023-09-10
+
+### Fixed
+- Fix hook event registration placement
+
+## [0.0.13] - 2023-09-10
+
+### Added
+- Contributions from BlinkohHost
+- Database-first package ID lookup with API fallback by product name
+- Server build initialization on successful server creation
+
+### Changed
+- Custom fields changed to not required
+- Removed linter workflow (not needed for this project)
+- Code cleanup
+
+## [0.0.9] - 2023-09-10
+
+### Changed
+- Refactored codebase to object-oriented architecture (OOP)
+- Updated README with badges and documentation
+
+## [0.0.6] - 2023-09-10
+
+### Added
+- Initial release
+- Core provisioning: server create, suspend, unsuspend, terminate
+- WHMCS hooks for dynamic OS template and SSH key dropdowns
+- Checkout validation for OS selection
+- Client area overview template with server information
+- Admin services tab with server ID management
+- Package change (upgrade/downgrade) support
+- Configurable option mapping for dynamic resource allocation
+- GitHub Actions CI/CD
+- Security policy (SECURITY.md)
+- License (GPL v3)

CLAUDE.md

@@ -0,0 +1,182 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+VirtFusion Direct Provisioning Module for WHMCS — a PHP module that integrates WHMCS with the VirtFusion control panel API for automated VPS provisioning, management, and client self-service. No build system or package manager; the module is pure PHP installed by copying `modules/servers/VirtFusionDirect/` into a WHMCS installation.
+
+## Development & Testing
+
+There is no automated test suite, linter, or build step. Testing is manual:
+
+- **Test connection:** WHMCS Admin → System Settings → Servers → Test Connection button
+- **Dry run validation:** `VirtFusionDirect_validateServerConfig()` tests configuration without creating a server
+- **Module logging:** WHMCS Admin → Utilities → Logs → Module Log captures all API calls and responses
+- **Server object viewer:** Admin services tab shows full JSON response from VirtFusion API
+
+## Development Rules
+
+- **Error handling:** Always use try...catch blocks around API calls, database operations, and any code that may throw exceptions. Never let exceptions bubble up unhandled to the user. Log caught exceptions via `Log::insert()`.
+- **Ownership validation:** Every client-facing action MUST verify service ownership via `validateUserOwnsService()` before performing any operation. Server IDs must be cross-referenced against the authenticated client to prevent cross-customer data access.
+- **Security:** All input must be validated server-side. Never trust client-side validation alone. Cast IDs to `(int)`, validate strings with regex, escape output with `htmlspecialchars()`.
+- **Control flow:** Every `$vf->output()` call in switch cases must be followed by `break`. Do not rely on `exit()` inside `output()` for flow control.
+- **HTTP methods:** Read-only operations use GET. State-mutating operations (power, rebuild, rename, password reset, credit, VNC toggle) use POST with data in the request body.
+- **Caching:** Use the `Cache` class for slow-changing API responses. Never cache real-time data (server status, VNC sessions, login tokens) or mutation responses.
+
+## Release Process
+
+Releases are triggered by pushing a git tag:
+```bash
+git tag v1.1.0
+git push origin v1.1.0
+```
+
+The `publish-release.yml` workflow creates a GitHub/Gitea release with auto-generated notes from the commit log. Use **conventional commits** for clear changelogs:
+- `fix:` → patch-level change
+- `feat:` → feature addition
+- `refactor:` → code improvement without behavior change
+
+## Architecture
+
+**Namespace:** `WHMCS\Module\Server\VirtFusionDirect`
+
+### Entry Points
+
+| File | Purpose |
+|------|---------|
+| `modules/servers/VirtFusionDirect/VirtFusionDirect.php` | WHMCS module interface — non-namespaced functions (`VirtFusionDirect_CreateAccount()`, etc.) that delegate to library classes |
+| `modules/servers/VirtFusionDirect/client.php` | Client-facing AJAX API — authenticated by WHMCS session + service ownership validation. POST for mutations, GET for reads. |
+| `modules/servers/VirtFusionDirect/admin.php` | Admin-facing AJAX API — requires WHMCS admin authentication |
+| `modules/servers/VirtFusionDirect/hooks.php` | WHMCS hooks — checkout validation (OS selection), OS gallery + SSH key UI injection, slider UI for configurable options, daily PowerDNS reconciliation |
+| `modules/addons/VirtFusionDns/VirtFusionDns.php` | Optional companion addon — holds PowerDNS settings and provides a Test Connection admin page. See "Reverse DNS (PowerDNS)" below. |
+
+### Core Classes (in `lib/`)
+
+| Class | Role |
+|-------|------|
+| `Module` | Base class with API integration, auth checks, and all feature methods (power, network, VNC, backup, resource, self-service, traffic, rename, password reset). Contains `resolveServiceContext()` for DRY service lookups and `groupOsTemplates()` for shared OS category logic. |
+| `ModuleFunctions` | Extends `Module`. Service lifecycle: create, suspend, unsuspend, terminate, change package, usage updates, client area rendering. |
+| `ConfigureService` | Extends `Module`. Order-time operations: package discovery, OS template fetching, server build initialization, SSH key retrieval and creation. |
+| `Database` | Static methods for `mod_virtfusion_direct` table operations and WHMCS DB queries. Auto-creates/migrates schema on first use. |
+| `Curl` | HTTP client wrapper with Bearer token auth, SSL verification, 30s timeout. Methods: `get`, `post`, `put`, `patch`, `delete`. Single-use — each instance makes one request. |
+| `Cache` | Two-tier caching: Redis (if `ext-redis` available) with atomic filesystem fallback. TTLs: OS templates 10min, traffic/backups 2min, packages 10min. |
+| `ServerResource` | Transforms VirtFusion API response into flat key-value format for Smarty templates. Only reads `interfaces[0]`; for rDNS use `PowerDns\IpUtil::extractIps()` which walks all interfaces. |
+| `AdminHTML` | Static methods generating admin services tab HTML (server ID editor, JSON viewer, action buttons, `rdnsSection()` widget). |
+| `Log` | Thin wrapper around WHMCS module logging. |
+| `PowerDns\Client` | PowerDNS HTTP API wrapper (`X-API-Key` auth): `ping`, `listZones`, `getZone`, `patchRRset`, `notifyZone`. PATCH success triggers an automatic NOTIFY so slaves pick up the SOA bump immediately. |
+| `PowerDns\Config` | Loads settings from `tbladdonmodules` (module="virtfusiondns") and decrypts `apiKey` via WHMCS `decrypt()`. `isEnabled()` gates every PowerDNS call site. |
+| `PowerDns\IpUtil` | Pure helpers: `ptrNameForIp` (v4/v6 nibble reversal), `expandIpv6`, `extractIps` (all interfaces), `findZoneAndPtrName` (standard + RFC 2317 classless), `parseClasslessZone`. |
+| `PowerDns\Resolver` | Forward-DNS verification via `dns_get_record()` with up-to-5-hop CNAME following. Cached per (hostname, ip) pair. |
+| `PowerDns\PtrManager` | Orchestrator: `syncServer`, `deleteForServer`, `listPtrs`, `setPtr`, `reconcile`, `reconcileAll`. Per-request zone cache. 10s per-IP write rate limit. Enforces FCrDNS before writes. |
+
+### Class Hierarchy
+
+`ModuleFunctions` and `ConfigureService` both extend `Module`. Most business logic lives in `Module` — it handles API calls, auth, validation, and all feature-specific operations. The `resolveServiceContext()` method provides a standardized way to look up service → WHMCS service → control panel → curl client in a single call, eliminating boilerplate across all API methods.
+
+### Client-Side
+
+- **`templates/overview.tpl`** — Smarty template for client area (server info, power, network, rebuild with OS gallery, resources with traffic chart, VNC toggle, self-service billing, billing overview, backups timeline, server rename, password reset)
+- **`templates/js/module.js`** — Vanilla JS + jQuery handling AJAX calls, DOM updates, status badges, power actions, all management UIs. Key helpers: `vfUrl()` (URL builder), `vfShowAlert()` (alert display), `vfRenderOsGallery()` (accordion gallery), `vfDrawTrafficChart()` (canvas chart)
+- **`templates/js/keygen.js`** — Client-side SSH Ed25519 key generator using Web Crypto API (loaded on checkout page)
+- **`templates/css/module.css`** — Cross-theme styles with Bootstrap 3/4/5 dual class support (`panel card`, `panel-body card-body`)
+
+### Removed Features
+
+- **Firewall** — Removed (non-functional; rulesets must be created in VirtFusion admin panel)
+- **IP add/remove buttons** — Removed; IPs are managed by VirtFusion during provisioning
+- **Upgrade/Downgrade link** — Removed from resources panel
+
+### Data Flow: Server Creation
+
+1. WHMCS calls `VirtFusionDirect_CreateAccount()` → `ModuleFunctions::createAccount()`
+2. Checks/creates VirtFusion user via external relation ID (WHMCS client ID)
+3. Reads configurable options (Package, Location, IPv4, Memory, CPU, Bandwidth, etc.)
+4. Dry-run validation → actual API POST to `/servers`
+5. Stores server ID in `mod_virtfusion_direct` table
+6. Updates WHMCS hosting record (IP, username, password, domain)
+7. If the PowerDNS addon is enabled, calls `PowerDns\PtrManager::syncServer()` to write PTRs (non-blocking; failures log but never fail provisioning)
+8. Calls `ConfigureService::initServerBuild()` with selected OS + SSH key
+
+Custom fields (`Initial Operating System`, `Initial SSH Key`) are auto-created by `Database::ensureCustomFields()` on module load for all products using this module. No manual SQL setup required.
+
+### Reverse DNS (PowerDNS)
+
+Opt-in integration via the companion `VirtFusionDns` addon module. Loose-coupled: the server module never requires addon code at runtime; it queries the addon's `tbladdonmodules` row and short-circuits when `enabled=0` or the addon isn't activated. Activate via WHMCS Admin → Addon Modules → VirtFusion DNS.
+
+**Settings** (`tbladdonmodules`, module="virtfusiondns"): `enabled` (yesno), `endpoint` (e.g. `https://ns1.example.com:8081`), `apiKey` (encrypted by WHMCS), `serverId` (usually `localhost`), `defaultTtl` (3600), `cacheTtl` (60).
+
+**Lifecycle hooks:**
+- `createAccount` → sync PTRs to server hostname (forward DNS must match before each write)
+- `renameServer` → update only PTRs whose current content equals the old hostname (preserves client-custom PTRs)
+- `terminateAccount` → delete every PTR before `Database::deleteSystemService()`
+- `VirtFusionDirect_TestConnection` → merged VirtFusion + PowerDNS health check
+- `DailyCronJob` → `PtrManager::reconcileAll()` — additive-only (never overwrites)
+
+**Client-facing actions** (`client.php`): `rdnsList`, `rdnsUpdate`. Admin (`admin.php`): `rdnsStatus`, `rdnsReconcile` (accepts `force=1` for explicit reset).
+
+**Client UI:** Reverse DNS panel in `templates/overview.tpl` (rendered by `vfLoadRdns()` / `vfRenderRdnsPanel()` / `vfUpdateRdns()` in `module.js`). Admin services tab gets a status widget via `AdminHTML::rdnsSection()`.
+
+**FCrDNS rule:** Every PTR write (auto or client-initiated) requires the hostname's forward DNS (A/AAAA) to already resolve to the target IP. On mismatch, auto-sync logs and skips; client edits return a 400 with guidance.
+
+**Zone handling:** Zones are operator-managed — the module never creates zones. Zone discovery uses `GET /zones` (cached for `cacheTtl`) + longest-suffix match. RFC 2317 classless delegations (`X/Y.octet.octet.octet.in-addr.arpa.`) are supported: both CIDR-prefix (`0/26`) and block-size (`64/64`) conventions are parsed, and PTRs are written with the classless sub-zone label in the record name.
+
+**SOA / NOTIFY:** PowerDNS auto-bumps SOA serials when `soa_edit_api=INCREASE` is set on the zone. After every successful PATCH the module issues an explicit `PUT /zones/{id}/notify` so slaves refresh immediately rather than waiting for the next scheduled poll.
+
+**Safety properties:**
+- PowerDNS failures never block VirtFusion operations (try/catch at every call site)
+- Cron is additive-only — never auto-overwrites a PTR
+- Admin Reconcile button supports `force=1` for explicit reset to hostname
+- Client edits are IP-ownership-checked against a *fresh* VirtFusion fetch (not cached `server_object`), defending against reassigned-IP stale-ownership
+- Per-IP write rate limit (10s, via `Cache`) prevents save-button abuse
+
+### Configurable Option Mapping
+
+Custom option names can be mapped in `config/ConfigOptionMapping.php` (copy from `-example.php`). Default mapping keys: `packageId`, `hypervisorId`, `ipv4`, `storage`, `memory`, `traffic`, `cpuCores`, `networkSpeedInbound`, `networkSpeedOutbound`, `networkProfile`, `storageProfile`.
+
+## Security Patterns
+
+- All PHP files start with `if (!defined("WHMCS")) die()` to prevent direct access (except entry points using `init.php`)
+- Client endpoints validate WHMCS session AND service ownership before any operation
+- API tokens stored encrypted in WHMCS server password field (decrypted via `localAPI('DecryptPassword')`)
+- Input validation: type casting (`(int)`), regex filtering, `filter_var()` for IP addresses
+- Output escaping: `htmlspecialchars()` in PHP, `$('<span>').text()` in jQuery, `{escape:'htmlall'}` in Smarty
+- SSL verification enabled on all API calls (`CURLOPT_SSL_VERIFYPEER` + `CURLOPT_SSL_VERIFYHOST = 2`)
+- Server rename validated both client-side and server-side with RFC 1123 regex
+
+## VirtFusion API Compatibility
+
+- **API reference (OpenAPI spec):** https://docs.virtfusion.com/api/openapi.yaml
+- **Base features:** VirtFusion v1.7.3+
+- **VNC console:** v6.1.0+
+- **Resource modification:** v6.2.0+
+- **Self-service billing:** Requires self-service feature enabled in VirtFusion
+- **OS icon path:** `{baseUrl}/img/logo/{icon_filename}` (public, no auth required)
+
+## PowerDNS API Compatibility
+
+- **API reference:** https://doc.powerdns.com/authoritative/http-api/
+- **Tested against:** PowerDNS Authoritative 4.8+
+- **Auth:** `X-API-Key` header (not Bearer)
+- **Required endpoints:** `GET /servers/{id}`, `GET /servers/{id}/zones`, `GET /servers/{id}/zones/{zone}`, `PATCH /servers/{id}/zones/{zone}`, `PUT /servers/{id}/zones/{zone}/notify`
+- **Zone ID URL encoding:** `/` in zone names (RFC 2317) must be encoded as `=2F` not `%2F` — handled by `Client::zoneIdEncode()`
+- **`api-allow-from`:** must include the WHMCS host's IP (PowerDNS's own ACL)
+- **Recommended zone config:** `soa_edit_api: INCREASE` for automatic serial bumping on API-driven changes
+
+## Product Config Options
+
+| Option | Name | Description | Default |
+|--------|------|-------------|---------|
+| configoption1 | Hypervisor Group ID | VirtFusion hypervisor group for server placement | 1 |
+| configoption2 | Package ID | VirtFusion package defining server resources | 1 |
+| configoption3 | Default IPv4 | Number of IPv4 addresses to assign (0-10) | 1 |
+| configoption4 | Self-Service Mode | 0=Disabled, 1=Hourly, 2=Resource Packs, 3=Both | 0 |
+| configoption5 | Auto Top-Off Threshold | Credit balance below which auto top-off triggers | 0 |
+| configoption6 | Auto Top-Off Amount | Credit amount to add on auto top-off | 100 |
+
+## WHMCS Compatibility
+
+- WHMCS 8.x+ (tested 8.0–8.10)
+- PHP 8.0+ with cURL extension
+- Redis extension optional (improves caching performance, falls back to filesystem)
+- All WHMCS themes supported (Six, Twenty-One, Lagom, custom) via Bootstrap 3/4/5 dual classes

README.md

@@ -1,90 +1,623 @@
 # VirtFusion Direct Provisioning Module for WHMCS
 
-[![GitHub Super-Linter](https://github.com/EZSCALE/virtfusion-whmcs-module/actions/workflows/publish-release.yml/badge.svg)](https://github.com/EZSCALE/virtfusion-whmcs-module/actions)
+[![Automated Release](https://github.com/EZSCALE/virtfusion-whmcs-module/actions/workflows/publish-release.yml/badge.svg)](https://github.com/EZSCALE/virtfusion-whmcs-module/actions)
 ![GitHub](https://img.shields.io/github/license/EZSCALE/virtfusion-whmcs-module)
 ![GitHub issues](https://img.shields.io/github/issues/EZSCALE/virtfusion-whmcs-module)
 ![GitHub pull requests](https://img.shields.io/github/issues-pr/EZSCALE/virtfusion-whmcs-module)
 
-This module requires VirtFusion v1.7.3 or higher as this is what it's based on. Please refer to the
+A comprehensive WHMCS provisioning module for [VirtFusion](https://virtfusion.com) that enables automated VPS server provisioning, management, and client self-service directly from WHMCS.
-official [documentation](https://docs.virtfusion.com/integrations/whmcs).
+
+## Table of Contents
+
+- [Requirements](#requirements)
+- [Features](#features)
+- [Installation](#installation)
+- [Upgrading](#upgrading)
+- [Configuration](#configuration)
+  - [Server Setup](#server-setup)
+  - [Product Setup](#product-setup)
+  - [Custom Fields](#custom-fields)
+  - [Module Configuration Options](#module-configuration-options)
+  - [Configurable Options (Dynamic Pricing)](#configurable-options-dynamic-pricing)
+  - [Custom Option Name Mapping](#custom-option-name-mapping)
+  - [Reverse DNS Addon (PowerDNS)](#reverse-dns-addon-powerdns)
+- [Client Area Features](#client-area-features)
+- [Admin Area Features](#admin-area-features)
+- [Theme Compatibility](#theme-compatibility)
+- [API Endpoints Used](#api-endpoints-used)
+- [Usage Update (Cron)](#usage-update-cron)
+- [Troubleshooting](#troubleshooting)
+- [Known Issues](#known-issues)
+- [Security](#security)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Requirements
+
+| Requirement | Minimum Version | Notes |
+|---|---|---|
+| **VirtFusion** | v1.7.3+ | v6.1.0+ required for VNC console |
+| **WHMCS** | 8.x+ | Tested with 8.0 through 8.10 |
+| **PHP** | 8.0+ | With cURL extension enabled |
+| **SSL** | Valid certificate | Required on VirtFusion panel |
+
+You also need a VirtFusion API token with the following permissions:
+- Server management (create, read, update, delete, power, build)
+- User management (create, read, reset password, authentication tokens)
+- Package and template read access
+- Network management (if using IP management features)
+
+## Features
+
+### Server Provisioning
+- Automatic server creation with VirtFusion user account linking
+- Server suspension, unsuspension, and termination
+- Package/plan upgrades and downgrades
+- Configurable options mapping for dynamic resource allocation (CPU, RAM, disk, bandwidth, network speed)
+- **Dry run validation** - Test server creation parameters before provisioning
+- Automatic memory unit conversion (GB to MB for values < 1024)
+
+### Client Area - Server Management
+- **Server Overview** - Real-time server info (hostname, IPs, resources) with status badge
+- **Power Management** - Start, restart, graceful shutdown, and force power off
+- **Control Panel SSO** - One-click login to VirtFusion panel
+- **Server Rebuild** - Reinstall with any available OS template
+- **Password Reset** - Reset VirtFusion panel login credentials
+- **Network Management** - View IPv4 addresses and IPv6 subnets with copy-to-clipboard
+- **Resources Panel** - Current memory, CPU, storage, traffic allocation with usage bars
+- **VNC Console** - Browser-based console access (panel auto-hides when VNC is disabled on the server)
+- **Self-Service Billing** - Credit balance display, usage breakdown, and credit top-up (when enabled)
+- **Bandwidth Usage** - Traffic usage display with allocation limits
+- **Billing Overview** - Product, billing cycle, dates, and payment information
+
+### Admin Area
+- **Test Connection** - Verify API connectivity from WHMCS
+- **Server Data Display** - Live server information from VirtFusion
+- **Admin Impersonation** - Log into VirtFusion panel as server owner
+- **Server ID Management** - Editable Server ID for manual adjustments
+- **Server Object Viewer** - Full JSON response from VirtFusion API
+- **Validate Server Config** - Dry run server creation to check configuration
+- **Update Server Object** - Refresh cached server data from VirtFusion
+
+### Ordering Process
+- OS template tile gallery with accordion categories, search, and brand icons
+- SSH key selection dropdown for users with saved keys, with option to paste a new public key
+- **SSH Ed25519 key generator** — Client-side keypair generation using Web Crypto API
+- Checkout validation ensuring OS selection before order placement
+- **Resource sliders** - Configurable option dropdowns are replaced with interactive range sliders
+- Compatible with all WHMCS order form templates
+
+### Usage Tracking
+- **Automated bandwidth sync** - WHMCS daily cron pulls traffic usage from VirtFusion
+- **Disk usage sync** - Storage usage updated automatically
+- Visible in WHMCS client area and admin product details
+
+### Backup Management
+- Assign backup plans to servers via the VirtFusion API
+- Remove backup plans from servers
+
+### Resource Modification
+- In-place modification of server resources (memory, CPU cores, traffic)
+- No server rebuild required for resource changes
+- **Package change** now also applies individual resource modifications from configurable options
+
+### Self-Service Billing
+- Credit balance display and top-up from client area
+- Usage breakdown reporting
+- Auto top-off via WHMCS cron when credit falls below threshold
+- Self-service mode configurable per product (Hourly, Resource Packs, or Both)
+
+### Reverse DNS (Optional PowerDNS Addon)
+- **Automatic PTR sync** on server create, rename, and terminate
+- **Client-editable rDNS** panel in the service overview — one input per assigned IP
+- **Forward-confirmed reverse DNS (FCrDNS)** — every PTR write requires the hostname's A/AAAA to already resolve to the IP; mismatches are rejected with a clear error
+- **IPv4 + IPv6** support out of the box (IPv6 nibble-reversal, `.ip6.arpa` zones)
+- **RFC 2317 classless delegation** — supports both CIDR-prefix (`0/26`) and block-size (`64/64`) zone naming conventions
+- **Admin reconciliation** — a "Reconcile" button on the services tab and an additive-only daily cron that creates any missing PTRs
+- **Client-custom PTRs preserved across renames** — only PTRs whose content matches the previous hostname get rewritten
+- **Auto NOTIFY + SOA bump** so slaves pick up changes immediately (when `soa_edit_api=INCREASE` is set on the zone)
+- **Opt-in** via a companion WHMCS addon module — no impact on existing provisioning if not activated
 
 ## Installation
 
-1. Download the latest release from the [releases](https://github.com/EZSCALE/virtfusion-whmcs-module/releases) page.
+```bash
-2. Extract the contents of the archive and upload the modules folder to your WHMCS installation directory.
+WHMCS=/path/to/whmcs
-
+git clone https://github.com/EZSCALE/virtfusion-whmcs-module.git /tmp/vf \
-## :heavy_exclamation_mark: Important Notes :heavy_exclamation_mark:
+  && rsync -ahP --delete /tmp/vf/modules/servers/VirtFusionDirect/ "$WHMCS/modules/servers/VirtFusionDirect/" \
-
+  && rm -rf /tmp/vf
-You must create two custom fields in WHMCS for this module to work. You need to configure the following custom fields on
-each product you want to use this module with.
-
-| Field Name               | Field Type | Description              | Validation  | Select Options | Admin Only | Required Field | Show on Order Form | Show on Invoice |
-|--------------------------|------------|--------------------------|-------------|----------------|------------|----------------|--------------------|-----------------|
-| Initial Operating System | Text Box   | Set to whatever you want | Leave Blank | Leave Blank    | :x:        | :x:            | :white_check_mark: | :x:             |
-| Initial SSH Key          | Text Box   | Set to whatever you want | Leave Blank | Leave Blank    | :x:        | :x:            | :white_check_mark: | :x:             |
-
-You can run this SQL query to create the custom fields:
-
-```sql
--- Insert records for Initial Operating System if they don't already exist
-INSERT INTO tblcustomfields
-(type, relid, fieldname, fieldtype, description, fieldoptions, regexpr, adminonly, required, showorder, showinvoice,
- sortorder, created_at, updated_at)
-SELECT 'product',
-       id,
-       'Initial Operating System',
-       'text',
-       '',
-       '',
-       '',
-       '',
-       '',
-       'on',
-       '',
-       0,
-       UTC_TIMESTAMP(),
-       UTC_TIMESTAMP()
-FROM tblproducts
-WHERE servertype = 'VirtFusionDirect'
-  AND NOT EXISTS (SELECT 1
-                  FROM tblcustomfields
-                  WHERE fieldname = 'Initial Operating System'
-                    AND relid = tblproducts.id);
-
--- Insert records for Initial SSH Key if they don't already exist
-INSERT INTO tblcustomfields
-(type, relid, fieldname, fieldtype, description, fieldoptions, regexpr, adminonly, required, showorder, showinvoice,
- sortorder, created_at, updated_at)
-SELECT 'product',
-       id,
-       'Initial SSH Key',
-       'text',
-       '',
-       '',
-       '',
-       '',
-       '',
-       'on',
-       '',
-       0,
-       UTC_TIMESTAMP(),
-       UTC_TIMESTAMP()
-FROM tblproducts
-WHERE servertype = 'VirtFusionDirect'
-  AND NOT EXISTS (SELECT 1
-                  FROM tblcustomfields
-                  WHERE fieldname = 'Initial SSH Key'
-                    AND relid = tblproducts.id);
 ```
 
+Set `WHMCS` once at the top — it's reused in every path below. The database table, schema migrations, and custom fields are all created automatically on first load.
 
-## What does this module change?
+Then configure in WHMCS Admin:
 
-This module changes the following things:
+1. **Add Server** — Configuration > System Settings > Servers > Add New Server. Set hostname to your VirtFusion panel (e.g. `cp.example.com`), type to "VirtFusion Direct Provisioning", and paste your API token in the Password field. Click **Test Connection** to verify.
+2. **Create Product** — Configuration > System Settings > Products/Services. On the Module Settings tab, select "VirtFusion Direct Provisioning", choose your server, and set the Hypervisor Group ID, Package ID, and Default IPv4 count.
+3. *(Optional)* **Install the Reverse DNS Addon** — also sync the `modules/addons/VirtFusionDns/` directory if you want PowerDNS-backed rDNS management. See [Reverse DNS Addon (PowerDNS)](#reverse-dns-addon-powerdns) below for activation and configuration.
 
-- Adds configurable options to the product configuration page to allow the user to select the operating system and add
+That's it. Hooks activate automatically and custom fields are created on module load.
-  an ssh key to the initial deployment.
 
-## TODO
+## Upgrading
 
-- [ ] Add post checkout checks to ensure the user has selected an operating system and added a ssh key.
+```bash
+WHMCS=/path/to/whmcs
+git clone https://github.com/EZSCALE/virtfusion-whmcs-module.git /tmp/vf \
+  && rsync -ahP --delete /tmp/vf/modules/servers/VirtFusionDirect/ "$WHMCS/modules/servers/VirtFusionDirect/" \
+  && rsync -ahP --delete /tmp/vf/modules/addons/VirtFusionDns/ "$WHMCS/modules/addons/VirtFusionDns/" \
+  && rm -rf /tmp/vf
+```
+
+The second `rsync` line is only needed if you use the Reverse DNS addon; skip it otherwise. Addon settings live in `tbladdonmodules` and survive file updates.
+
+> **Note:** If you have a custom `config/ConfigOptionMapping.php`, back it up first — `--delete` will remove it. Restore it after upgrading.
+
+If you use theme-overridden templates, review them for any new template variables. Clear the WHMCS template cache after upgrading: **Configuration > System Settings > General Settings > clear template cache**.
+
+## Configuration
+
+### Server Setup
+
+In WHMCS Admin under **Configuration > System Settings > Servers**:
+
+| Field | Value |
+|---|---|
+| Hostname | Your VirtFusion panel domain (e.g., `cp.example.com`) |
+| Password | Your VirtFusion API token |
+| Type | VirtFusion Direct Provisioning |
+
+**Important**: Do not include `https://` or `/api/v1` in the hostname. The module constructs the full URL automatically.
+
+### Product Setup
+
+Each WHMCS product using this module needs:
+1. Module set to "VirtFusion Direct Provisioning"
+2. A linked server (or the module will use any available VirtFusion server)
+3. The three configuration options set (Hypervisor Group ID, Package ID, Default IPv4)
+4. Custom fields created (see below)
+
+### Custom Fields
+
+The module requires two custom fields per product: **Initial Operating System** and **Initial SSH Key**. These are **automatically created** when the module loads — no manual setup required.
+
+The fields are hidden text boxes that are dynamically replaced by dropdown selects via JavaScript hooks on the order form. They are created for every product with the module type set to "VirtFusion Direct Provisioning".
+
+### Module Configuration Options
+
+Each product has three module-specific settings:
+
+| Option | Name | Description | Default |
+|---|---|---|---|
+| Config Option 1 | Hypervisor Group ID | VirtFusion hypervisor group for server placement | 1 |
+| Config Option 2 | Package ID | VirtFusion package defining server resources | 1 |
+| Config Option 3 | Default IPv4 | Number of IPv4 addresses to assign (0-10) | 1 |
+| Config Option 4 | Self-Service Mode | Enable VirtFusion self-service billing (0=Disabled, 1=Hourly, 2=Resource Packs, 3=Both) | 0 |
+| Config Option 5 | Auto Top-Off Threshold | Credit balance below which auto top-off triggers during cron (0=disabled) | 0 |
+| Config Option 6 | Auto Top-Off Amount | Credit amount to add when auto top-off triggers | 100 |
+
+You can find your Hypervisor Group IDs and Package IDs in the VirtFusion admin panel.
+
+### Configurable Options (Dynamic Pricing)
+
+To allow customers to select different resource levels with pricing tiers, create WHMCS Configurable Options groups with these option names:
+
+| VirtFusion Parameter | Default Option Name | Description | Unit |
+|---|---|---|---|
+| `packageId` | Package | VirtFusion package ID | ID |
+| `hypervisorId` | Location | Hypervisor group for placement | ID |
+| `ipv4` | IPv4 | Number of IPv4 addresses | Count |
+| `storage` | Storage | Disk space | GB |
+| `memory` | Memory | RAM (values < 1024 auto-converted from GB) | MB |
+| `traffic` | Bandwidth | Monthly traffic allowance | GB |
+| `cpuCores` | CPU Cores | Number of CPU cores | Count |
+| `networkSpeedInbound` | Inbound Network Speed | Inbound speed | Mbps |
+| `networkSpeedOutbound` | Outbound Network Speed | Outbound speed | Mbps |
+| `networkProfile` | Network Type | VirtFusion network profile | ID |
+| `storageProfile` | Storage Type | VirtFusion storage profile | ID |
+
+### Custom Option Name Mapping
+
+If your configurable option names differ from the defaults above:
+
+1. Copy `config/ConfigOptionMapping-example.php` to `config/ConfigOptionMapping.php`
+2. Edit the mapping array:
+
+```php
+return [
+    'memory' => 'RAM',           // Your option name for memory
+    'cpuCores' => 'vCPU Count',  // Your option name for CPU
+    'traffic' => 'Data Transfer', // Your option name for bandwidth
+    // ... add only the options that differ from defaults
+];
+```
+
+### Reverse DNS Addon (PowerDNS)
+
+Optional. Activate the `VirtFusionDns` addon module to let the provisioning module manage PTR records in a PowerDNS instance automatically (and expose an rDNS editor to clients).
+
+**Prerequisites:**
+- PowerDNS Authoritative 4.x with the HTTP API enabled (`webserver=yes`, `api=yes`, and an `api-key=...` set)
+- `api-allow-from=` must include the IP of your WHMCS host
+- **All reverse zones you intend to use must already exist in PowerDNS.** The addon never creates zones; it only PATCHes PTR RRsets into zones that are already delegated to your nameservers.
+- Zones should have `soa_edit_api=INCREASE` (or similar) so PowerDNS auto-bumps the SOA serial on API writes. The addon additionally calls `PUT /zones/{id}/notify` after every PATCH to push changes to slaves immediately.
+
+**Activation:**
+
+1. Copy the addon into your WHMCS install (see the Installation section for the `rsync` command).
+2. In WHMCS Admin → **System Settings → Addon Modules**, find **VirtFusion DNS** and click **Activate**. Grant admin role access as needed.
+3. Click **Configure** and fill in:
+
+   | Field | Meaning |
+   |---|---|
+   | **Enable rDNS Sync** | Master switch. When off, every PowerDNS call short-circuits — the provisioning module behaves exactly as before the addon. |
+   | **PowerDNS API Endpoint** | Scheme + host + port, no path (e.g. `https://ns1.example.com:8081` or `http://10.0.0.5:8081`). The module appends `/api/v1/…` itself. |
+   | **PowerDNS API Key** | Password-type field. Encrypted at rest by WHMCS; decrypted server-side only when PowerDNS is called. |
+   | **PowerDNS Server ID** | Almost always `localhost` — the PowerDNS API server identifier, not a hostname. |
+   | **Default PTR TTL** | Applied to every PTR record the module creates. Default 3600. |
+   | **Cache TTL** | How long zone listings and DNS-resolution lookups are cached. Default 60, minimum 10. |
+
+4. Click **Save Changes**.
+5. Open the addon's admin page (same menu, usually **Addons → VirtFusion DNS**) and click **Run Test**. You should see "OK — PowerDNS reachable and authenticated" followed by a list of visible zones. If you don't see your expected reverse zones here, the module won't find them either — fix PowerDNS first.
+
+**How it behaves:**
+
+| Event | Behavior |
+|---|---|
+| Server provisioning | Creates a PTR for every assigned IP pointing to the VirtFusion hostname — but only if that hostname's A/AAAA already resolves to the IP. Forward-missing IPs are logged and skipped (provisioning still succeeds). |
+| Server rename (via client or admin) | Rewrites only PTRs whose current content equals the previous hostname. Client-customised PTRs are preserved. |
+| Server termination | Deletes every PTR belonging to the server before the local record is purged. |
+| Client edits PTR in the Reverse DNS panel | Validates IP ownership (cross-checked against a fresh VirtFusion fetch), PTR regex, per-IP 10-second rate limit, and forward-DNS match. Empty value deletes. |
+| Daily cron | Creates PTRs for IPs that don't have one yet (and whose forward DNS resolves correctly). **Additive-only — never overwrites.** |
+| Admin "Reconcile (force reset)" button | The only code path that overwrites a non-matching PTR — explicit admin action. |
+
+**RFC 2317 classless delegations** are supported: the module parses zones like `64/64.38.186.66.in-addr.arpa.` (both CIDR-prefix and block-size conventions), matches IPs by range rather than suffix, and writes PTRs with the correct classless RRset name. The PowerDNS URL-safe zone ID encoding (`/` → `=2F`) is handled transparently.
+
+**Security posture:**
+- PowerDNS integration is **opt-in** — if the addon is deactivated or `Enable rDNS Sync` is off, the provisioning module behaves exactly as before.
+- Every client-facing rDNS endpoint validates service ownership and re-verifies the IP is currently assigned to the requesting user's server (defends against stale-ownership after IP reassignment).
+- The API key is stored encrypted in `tbladdonmodules` by WHMCS; it is never logged.
+- DNS write failures never block VirtFusion operations — provisioning, rename, and termination all succeed regardless of PowerDNS state, and errors are recorded in the WHMCS Module Log for review.
+
+## Client Area Features
+
+### Server Overview
+Displays real-time server information fetched from VirtFusion:
+- Server name and hostname
+- Memory, CPU cores, storage allocation
+- IPv4 and IPv6 addresses
+- Traffic usage vs. allocation
+- Server status badge (Active, Suspended, etc.)
+
+### Power Management
+Four power control buttons:
+- **Start** - Boot the server
+- **Restart** - Graceful restart
+- **Shutdown** - Graceful ACPI shutdown
+- **Force Off** - Immediate power cut (use with caution)
+
+### Network Management
+- View all IPv4 addresses and IPv6 subnets assigned to the server
+- Copy IP addresses to clipboard with one click
+
+### VNC Console
+- Opens a browser-based VNC console to the server
+- Requires VirtFusion v6.1.0+ and the server must be running
+- Opens in a new browser window/tab
+
+### Server Rebuild
+- Select from available OS templates (filtered by server package)
+- Includes a confirmation dialog warning about data loss
+- Triggers email notification on completion
+
+### Control Panel SSO
+- One-click login to the VirtFusion panel
+- Opens in a new window (with fallback to same-window navigation)
+- Password reset option for direct VirtFusion panel access
+
+### Billing Overview
+- Product name and group
+- Recurring amount and billing cycle
+- Registration and next due dates
+- Payment method
+
+### Reverse DNS *(requires the VirtFusion DNS addon)*
+A panel listing every IP assigned to the server with an inline editor for the PTR record:
+- One input per IP — populate to set a custom PTR, leave blank to delete
+- Per-row status badge (OK / unverified / no PTR / no zone / error)
+- Saves are rate-limited to one write per IP per 10 seconds
+- Forward DNS must already resolve to the IP; mismatches show an inline error guiding the client to fix their A/AAAA first
+- Hidden entirely when the addon is not activated
+
+## Admin Area Features
+
+### Admin Services Tab
+When viewing a service in WHMCS admin, the module adds:
+- **Server ID** - Editable field showing the VirtFusion server ID
+- **Server Info** - Button to load live data from VirtFusion API
+- **Server Object** - Full JSON response viewer
+- **Options** - Admin impersonation link
+- **Reverse DNS** *(when the VirtFusion DNS addon is activated)* - Live per-IP PTR status plus **Reconcile (additive)** and **Reconcile (force reset)** buttons
+
+### Module Commands (Admin Buttons)
+- **Create** - Provision a new server
+- **Suspend** / **Unsuspend** - Manage server suspension
+- **Terminate** - Delete the server (with 5-minute grace period in VirtFusion)
+- **Change Package** - Update server to a different VirtFusion package
+- **Update Server Object** - Refresh cached data from VirtFusion
+- **Validate Server Config** - Dry run server creation to test configuration
+
+## Theme Compatibility
+
+This module is designed to work with **all WHMCS themes**:
+
+| Theme | Status | Notes |
+|---|---|---|
+| Six (default) | Fully compatible | Bootstrap 3 |
+| Twenty-One | Fully compatible | Bootstrap 4 |
+| Lagom (ModulesGarden) | Fully compatible | Bootstrap 5 |
+| Custom themes | Compatible | Uses dual CSS classes |
+
+### How Theme Compatibility Works
+
+The module uses dual CSS class names that work across Bootstrap versions:
+- `panel card` - Works in BS3 (panel) and BS4/BS5 (card)
+- `panel-heading card-header` - Works in BS3 and BS4/BS5
+- `panel-body card-body` - Works in BS3 and BS4/BS5
+- `panel-title card-title` - Works in BS3 and BS4/BS5
+
+The order form hooks use vanilla JavaScript (no jQuery dependency) for maximum compatibility.
+
+### Theme Override
+
+To customize templates for a specific theme:
+
+```
+/templates/yourthemename/modules/servers/VirtFusionDirect/
+  overview.tpl    # Client area template
+  error.tpl       # Error template
+```
+
+WHMCS automatically loads theme-specific templates when they exist. Copy the originals from `modules/servers/VirtFusionDirect/templates/` as a starting point.
+
+## API Endpoints Used
+
+### Core Provisioning
+
+| Method | Endpoint | Purpose |
+|---|---|---|
+| `GET` | `/connect` | Connection testing |
+| `GET/POST` | `/users` | User lookup and creation |
+| `GET` | `/users/{id}/byExtRelation` | Find VirtFusion user by WHMCS ID |
+| `POST` | `/servers` | Server creation |
+| `POST` | `/servers?dryRun=true` | Dry run validation |
+| `POST` | `/servers/{id}/build` | OS installation / rebuild |
+| `GET` | `/servers/{id}` | Server details (also used by UsageUpdate) |
+| `DELETE` | `/servers/{id}` | Server termination |
+| `POST` | `/servers/{id}/suspend` | Server suspension |
+| `POST` | `/servers/{id}/unsuspend` | Server unsuspension |
+| `PUT` | `/servers/{id}/package/{pkgId}` | Package changes |
+
+### Client Management
+
+| Method | Endpoint | Purpose |
+|---|---|---|
+| `POST` | `/servers/{id}/power/{action}` | Power management |
+| `PATCH` | `/servers/{id}/name` | Server renaming |
+| `POST` | `/users/{id}/serverAuthenticationTokens/{serverId}` | SSO token |
+| `POST` | `/users/{id}/byExtRelation/resetPassword` | Password reset |
+| `GET` | `/media/templates/fromServerPackageSpec/{id}` | OS templates |
+| `GET` | `/ssh_keys/user/{id}` | SSH key listing |
+
+### SSH Keys
+
+| Method | Endpoint | Purpose |
+|---|---|---|
+| `POST` | `/ssh_keys` | Create SSH key for a user (checkout key paste) |
+
+### Self-Service Billing
+
+| Method | Endpoint | Purpose |
+|---|---|---|
+| `GET` | `/selfService/usage/byUserExtRelationId/{id}` | Usage data by WHMCS client ID |
+| `GET` | `/selfService/report/byUserExtRelationId/{id}` | Billing report by WHMCS client ID |
+| `POST` | `/selfService/credit/byUserExtRelationId/{id}` | Add credit by WHMCS client ID |
+| `GET` | `/servers/{id}/traffic` | Traffic statistics |
+| `GET` | `/backups/server/{id}` | Backup listing |
+| `POST` | `/servers/{id}/vnc` | Toggle VNC on/off |
+| `POST` | `/servers/{id}/resetPassword` | Reset server root password |
+
+### Advanced
+
+| Method | Endpoint | Purpose |
+|---|---|---|
+| `GET` | `/servers/{id}/vnc` | VNC console (v6.1.0+) |
+| `PUT` | `/servers/{id}/modify/memory` | Modify memory (v6.2.0+) |
+| `PUT` | `/servers/{id}/modify/cpuCores` | Modify CPU cores (v6.2.0+) |
+| `PUT` | `/servers/{id}/modify/traffic` | Modify traffic (v6.0.0+) |
+| `POST/DELETE` | `/servers/{id}/backup/plan` | Backup plan management (v4.3.0+) |
+
+### PowerDNS (Reverse DNS addon, PowerDNS Authoritative 4.x+)
+
+| Method | Endpoint | Purpose |
+|---|---|---|
+| `GET` | `/api/v1/servers/{id}` | Health check (Test Connection button) |
+| `GET` | `/api/v1/servers/{id}/zones` | Zone discovery (cached per `cacheTtl`) |
+| `GET` | `/api/v1/servers/{id}/zones/{zone}` | Fetch current RRsets for status + reads |
+| `PATCH` | `/api/v1/servers/{id}/zones/{zone}` | Create / replace / delete PTR RRsets |
+| `PUT` | `/api/v1/servers/{id}/zones/{zone}/notify` | NOTIFY slaves after every successful PATCH |
+
+Authentication is via the `X-API-Key` header (configured in the addon). Zone IDs containing `/` (RFC 2317 classless) are URL-encoded as `=2F` per PowerDNS convention.
+
+## Usage Update (Cron)
+
+The module implements the `UsageUpdate` function that is called by the WHMCS daily cron. It automatically syncs:
+
+- **Disk usage** (used and limit) from VirtFusion to WHMCS `tblhosting`
+- **Bandwidth usage** (used and limit) from VirtFusion to WHMCS `tblhosting`
+
+This data appears in the WHMCS client area and admin product details.
+
+**Requirements**: The WHMCS cron must be running (`php -q /path/to/whmcs/crons/cron.php`). No additional configuration is needed - the module registers itself automatically.
+
+**How it works**:
+1. WHMCS calls `VirtFusionDirect_UsageUpdate()` once per configured server
+2. The module queries all Active services assigned to that server
+3. For each service, it fetches server data from VirtFusion API
+4. Disk and bandwidth usage/limits are written to `tblhosting`
+
+**Data format conversion**:
+- VirtFusion traffic: bytes -> WHMCS expects: MB
+- VirtFusion storage: bytes -> WHMCS expects: MB
+- VirtFusion storage limit: GB -> WHMCS expects: MB
+- VirtFusion traffic limit: GB -> WHMCS expects: MB (0 = unlimited)
+
+## Troubleshooting
+
+### Connection Test Fails
+
+| Symptom | Cause | Solution |
+|---|---|---|
+| "Authentication failed" | Invalid or expired API token | Generate a new token in VirtFusion |
+| "Connection failed" | Hostname unreachable or SSL issue | Verify hostname, check SSL cert validity |
+| "Unexpected response" | API version mismatch or server issue | Check VirtFusion is running, verify API version |
+
+### Server Creation Fails
+
+| Symptom | Cause | Solution |
+|---|---|---|
+| "Service already exists" | Duplicate provisioning attempt | Run termination first, then create |
+| "No Control server found" | No VirtFusion server in WHMCS | Add server in System Settings > Servers |
+| "Unable to create user" | API permission issue | Check token has user create permission |
+| "Server creation failed" | Invalid config options | Use "Validate Server Config" button to diagnose |
+| HTTP 423 response | Server is locked | Wait and retry, or check VirtFusion for lock reason |
+
+### OS Templates Not Showing on Order Form
+
+1. Verify the **Package ID** (Config Option 2) is correct
+2. Check that the package has OS templates assigned in VirtFusion
+3. Ensure the **"Initial Operating System"** custom field exists (exact name match required)
+4. Check that hooks are loading: re-save product settings to trigger hook detection
+5. Inspect browser console for JavaScript errors
+
+### Client Area Shows Error Template
+
+1. Ensure a VirtFusion server is configured and linked to the product
+2. Check the service status is Active or Suspended (not Pending/Terminated)
+3. Review **Utilities > Logs > Module Log** for API errors
+4. Verify the `mod_virtfusion_direct` table has an entry for the service
+
+### SSO / Control Panel Login Fails
+
+1. VirtFusion panel must be accessible from the client's browser
+2. Verify the VirtFusion user exists (check by external relation ID in VirtFusion admin)
+3. Ensure authentication token generation is enabled on the API token
+4. Check for popup blockers if the new window doesn't open
+
+### VNC Console Not Working
+
+1. Requires VirtFusion v6.1.0 or higher
+2. The server must be powered on and running
+3. Check that VNC is enabled for the hypervisor in VirtFusion
+4. Popup blockers may prevent the console window from opening
+
+### UsageUpdate Not Syncing
+
+1. Verify the WHMCS cron is running: `php -q /path/to/whmcs/crons/cron.php`
+2. Check **Utilities > Logs > Module Log** for UsageUpdate errors
+3. Ensure services are in "Active" status (other statuses are skipped)
+4. The cron runs daily; wait for the next cycle after initial setup
+
+## Known Issues
+
+1. **VNC Console** - Requires VirtFusion v6.1.0+. Earlier versions do not expose a VNC API endpoint. The module gracefully handles this by showing an error message.
+
+2. **Resource Modification** - Memory and CPU modification requires VirtFusion v6.2.0+. Traffic modification requires v6.0.0+. Backup management requires v4.3.0+.
+
+3. **IPv6 Display** - IPv6 subnet display depends on the VirtFusion installation having IPv6 pools configured. If no IPv6 is assigned, the network panel shows "No IPv6 subnets".
+
+4. **Order Form Custom Fields** - The custom fields ("Initial Operating System" and "Initial SSH Key") must be named exactly as specified. The module matches by field name with spaces removed and converted to lowercase.
+
+5. **Hooks File Detection** - WHMCS detects the `hooks.php` file when the module is first activated. If you add the module files to an already-active installation, you may need to deactivate and reactivate the module, or re-save the product settings.
+
+6. **Bootstrap 3 Themes** - While the module supports BS3 themes, some visual differences may exist (e.g., `d-flex` not available in BS3). The module uses `display: flex` in CSS as a fallback.
+
+7. **Concurrent API Calls** - The module makes individual API calls for each feature panel on the client area page. If the VirtFusion API is slow, the page may take longer to fully load. All panels load asynchronously to minimize perceived delay.
+
+8. **Self-Signed SSL Certificates** - SSL verification is enforced by default. VirtFusion panels using self-signed certificates will cause connection failures. Use a valid SSL certificate (e.g., Let's Encrypt) on your VirtFusion panel.
+
+## Security
+
+### Architecture
+- All client API endpoints validate service ownership before processing
+- Admin endpoints require WHMCS admin authentication
+- Input sanitization on all user-supplied parameters (type casting, regex filtering, `filter_var`)
+- Proper HTTP status codes (401, 403, 400, 500) for error responses
+- XSS prevention via `htmlspecialchars()`, `encodeURIComponent()`, and jQuery `.text()`
+
+### Best Practices
+- **API Tokens**: Store only in the WHMCS server password field (encrypted at rest by WHMCS)
+- **SSL Verification**: Enabled by default. Never disable in production.
+- **File Access**: All PHP files include direct access prevention checks
+- **Module Updates**: Keep updated for security patches
+- **Permissions**: Use the minimum required API token permissions
+
+### Reporting Vulnerabilities
+If you discover a security vulnerability, please report it responsibly by emailing the maintainers rather than opening a public issue. See [SECURITY.md](SECURITY.md) for details.
+
+## File Structure
+
+```
+modules/servers/VirtFusionDirect/
+  VirtFusionDirect.php        # WHMCS module entry point (MetaData, ConfigOptions, all module functions)
+  client.php                  # Client-facing AJAX API (authenticated, ownership-validated)
+  admin.php                   # Admin-facing AJAX API (admin authentication required)
+  hooks.php                   # WHMCS hooks (order form OS/SSH dropdowns, checkout validation, daily rDNS cron)
+  lib/
+    Module.php                # Base class: API communication, power, network, VNC, rebuild
+    ModuleFunctions.php       # Provisioning: create, suspend, unsuspend, terminate, change package
+    ConfigureService.php      # Order configuration: OS templates, SSH keys, server build init
+    Database.php              # Database operations: custom table, WHMCS table queries
+    Cache.php                 # Two-tier cache: Redis with filesystem fallback
+    Curl.php                  # HTTP client: GET, POST, PUT, PATCH, DELETE with SSL verification
+    ServerResource.php        # Data transformer: VirtFusion API response -> display format
+    AdminHTML.php             # Admin interface: HTML generation for admin services tab
+    Log.php                   # Logging: WHMCS module log integration
+    PowerDns/
+      Client.php              # PowerDNS HTTP API wrapper (X-API-Key, ping, listZones, getZone, patchRRset, notifyZone)
+      Config.php              # Loads + decrypts addon settings from tbladdonmodules
+      IpUtil.php              # PTR-name generation, IP extraction, RFC 2317 parsing, zone matching
+      Resolver.php            # Forward-DNS verification (dns_get_record + CNAME chain, cached)
+      PtrManager.php          # Orchestrator: syncServer, deleteForServer, listPtrs, setPtr, reconcile, reconcileAll
+  templates/
+    overview.tpl              # Client area Smarty template (all management panels)
+    error.tpl                 # Error display template
+    css/module.css            # Module styles (responsive, BS3/4/5 compatible)
+    js/module.js              # Client JavaScript (all AJAX interactions)
+    js/keygen.js              # SSH Ed25519 key generator (Web Crypto API)
+  config/
+    ConfigOptionMapping-example.php   # Example custom option name mapping
+
+modules/addons/VirtFusionDns/   # Optional — only needed for reverse DNS support
+  VirtFusionDns.php             # Addon entry point: _config(), _activate(), _deactivate(), _output() (Test Connection page)
+```
+
+## Contributing
+
+Contributions are welcome! Please:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/your-feature`)
+3. Commit your changes with clear messages
+4. Push to your fork and open a Pull Request
+
+For bug reports, please include:
+- WHMCS version
+- VirtFusion version
+- PHP version
+- Steps to reproduce
+- Module Log output (Utilities > Logs > Module Log)
+
+## License
+
+This project is licensed under the GNU General Public License v3.0 - see the [LICENSE.md](LICENSE.md) file for details.
+
+Copyright (c) EZSCALE

SECURITY.md

@@ -2,12 +2,12 @@
 
 ## Supported Versions
 
-The support version of this module with VirtFusion
+Supported VirtFusion versions:
 
-| Version | Supported          |
+| Version  | Supported          |
-|---------|--------------------|
+|----------|--------------------|
-| > 1.7.3 | :white_check_mark: |
+| >= 1.7.3 | :white_check_mark: |
-| < 1.7.3 | :x:                |
+| < 1.7.3  | :x:                |
 
 ## Reporting a Vulnerability
 

composer.json

@@ -0,0 +1,19 @@
+{
+    "name": "ezscale/virtfusion-whmcs-module",
+    "description": "VirtFusion Direct Provisioning Module for WHMCS",
+    "type": "whmcs-module",
+    "license": "GPL-3.0-or-later",
+    "require-dev": {
+        "laravel/pint": "^1.0"
+    },
+    "scripts": {
+        "post-install-cmd": [
+            "cp hooks/pre-commit .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit"
+        ],
+        "post-update-cmd": [
+            "cp hooks/pre-commit .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit"
+        ],
+        "lint": "pint",
+        "lint-test": "pint --test"
+    }
+}

composer.lock

@@ -0,0 +1,87 @@
+{
+    "_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": "f6be98eb2bded4b127a92bc0f1e19d93",
+    "packages": [],
+    "packages-dev": [
+        {
+            "name": "laravel/pint",
+            "version": "v1.29.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/laravel/pint.git",
+                "reference": "bdec963f53172c5e36330f3a400604c69bf02d39"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/laravel/pint/zipball/bdec963f53172c5e36330f3a400604c69bf02d39",
+                "reference": "bdec963f53172c5e36330f3a400604c69bf02d39",
+                "shasum": ""
+            },
+            "require": {
+                "ext-json": "*",
+                "ext-mbstring": "*",
+                "ext-tokenizer": "*",
+                "ext-xml": "*",
+                "php": "^8.2.0"
+            },
+            "require-dev": {
+                "friendsofphp/php-cs-fixer": "^3.94.2",
+                "illuminate/view": "^12.54.1",
+                "larastan/larastan": "^3.9.3",
+                "laravel-zero/framework": "^12.0.5",
+                "mockery/mockery": "^1.6.12",
+                "nunomaduro/termwind": "^2.4.0",
+                "pestphp/pest": "^3.8.6",
+                "shipfastlabs/agent-detector": "^1.1.0"
+            },
+            "bin": [
+                "builds/pint"
+            ],
+            "type": "project",
+            "autoload": {
+                "psr-4": {
+                    "App\\": "app/",
+                    "Database\\Seeders\\": "database/seeders/",
+                    "Database\\Factories\\": "database/factories/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Nuno Maduro",
+                    "email": "enunomaduro@gmail.com"
+                }
+            ],
+            "description": "An opinionated code formatter for PHP.",
+            "homepage": "https://laravel.com",
+            "keywords": [
+                "dev",
+                "format",
+                "formatter",
+                "lint",
+                "linter",
+                "php"
+            ],
+            "support": {
+                "issues": "https://github.com/laravel/pint/issues",
+                "source": "https://github.com/laravel/pint"
+            },
+            "time": "2026-03-12T15:51:39+00:00"
+        }
+    ],
+    "aliases": [],
+    "minimum-stability": "stable",
+    "stability-flags": {},
+    "prefer-stable": false,
+    "prefer-lowest": false,
+    "platform": {},
+    "platform-dev": {},
+    "plugin-api-version": "2.9.0"
+}

hooks/pre-commit

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+# Run Pint on staged PHP files before committing.
+# Fixes formatting in-place and re-stages the corrected files.
+
+STAGED_PHP=$(git diff --cached --name-only --diff-filter=ACM | grep '\.php$')
+
+if [ -z "$STAGED_PHP" ]; then
+    exit 0
+fi
+
+# Check that Pint is installed
+if [ ! -x "./vendor/bin/pint" ]; then
+    echo "Error: laravel/pint is not installed. Run 'composer install' first."
+    exit 1
+fi
+
+echo "Running Pint on staged PHP files..."
+./vendor/bin/pint $STAGED_PHP
+
+# Re-stage any files that Pint modified
+for FILE in $STAGED_PHP; do
+    if [ -f "$FILE" ]; then
+        git add "$FILE"
+    fi
+done

modules/addons/VirtFusionDns/VirtFusionDns.php

@@ -0,0 +1,234 @@
+<?php
+
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\Client;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\Config;
+
+/**
+ * VirtFusion DNS — companion WHMCS addon module that holds PowerDNS settings for
+ * the VirtFusionDirect server module. Keeps the server module decoupled from the
+ * addon: the server module reads settings from tbladdonmodules and never loads
+ * addon code at runtime.
+ *
+ * Activation: WHMCS Admin -> System Settings -> Addon Modules -> Activate -> Configure.
+ *
+ * API key handling: WHMCS encrypts password-type addon fields in tbladdonmodules;
+ * the server module calls decrypt() on read (see lib/PowerDns/Config.php).
+ */
+if (! defined('WHMCS')) {
+    exit('This file cannot be accessed directly');
+}
+
+/**
+ * Load the server module's PowerDNS classes on demand. Done inside functions rather
+ * than at file scope so the WHMCS addon list still works if the server module is
+ * absent (e.g., uninstalled while the addon is still activated). Returns true when
+ * the classes are available.
+ */
+function virtfusiondns_load_server_libs(): bool
+{
+    $base = __DIR__ . '/../../servers/VirtFusionDirect/lib/';
+    $files = [
+        'Curl.php',
+        'Log.php',
+        'Cache.php',
+        'PowerDns/Config.php',
+        'PowerDns/IpUtil.php',
+        'PowerDns/Client.php',
+    ];
+    foreach ($files as $f) {
+        if (! is_file($base . $f)) {
+            return false;
+        }
+        require_once $base . $f;
+    }
+
+    return true;
+}
+
+/**
+ * WHMCS addon metadata.
+ */
+function VirtFusionDns_config()
+{
+    return [
+        'name' => 'VirtFusion DNS',
+        'description' => 'Adds reverse DNS (PTR) management to the VirtFusionDirect server module using a PowerDNS HTTP API. Zones must already exist in PowerDNS; the addon never creates zones. Requires the VirtFusionDirect server module.',
+        'version' => '1.0',
+        'author' => 'VirtFusionDirect',
+        'language' => 'english',
+        'fields' => [
+            'enabled' => [
+                'FriendlyName' => 'Enable rDNS Sync',
+                'Type' => 'yesno',
+                'Description' => 'Master switch. When off, the server module skips every PowerDNS call.',
+            ],
+            'endpoint' => [
+                'FriendlyName' => 'PowerDNS API Endpoint',
+                'Type' => 'text',
+                'Size' => '60',
+                'Default' => 'http://ns1.example.com:8081',
+                'Description' => 'Scheme + host + port (no path). The /api/v1/... path is appended automatically.',
+            ],
+            'apiKey' => [
+                'FriendlyName' => 'PowerDNS API Key',
+                'Type' => 'password',
+                'Size' => '60',
+                'Description' => 'X-API-Key. Stored encrypted by WHMCS; decrypted only server-side when PowerDNS is called.',
+            ],
+            'serverId' => [
+                'FriendlyName' => 'PowerDNS Server ID',
+                'Type' => 'text',
+                'Size' => '20',
+                'Default' => 'localhost',
+                'Description' => 'Almost always "localhost" (the PowerDNS API server identifier, not a hostname).',
+            ],
+            'defaultTtl' => [
+                'FriendlyName' => 'Default PTR TTL (seconds)',
+                'Type' => 'text',
+                'Size' => '10',
+                'Default' => '3600',
+                'Description' => 'TTL applied to PTR records created by the module.',
+            ],
+            'cacheTtl' => [
+                'FriendlyName' => 'Cache TTL (seconds)',
+                'Type' => 'text',
+                'Size' => '10',
+                'Default' => '60',
+                'Description' => 'How long zone lists and DNS-resolution results are cached. Minimum 10s.',
+            ],
+        ],
+    ];
+}
+
+/**
+ * Called when the addon is activated. No schema to create — settings live in tbladdonmodules.
+ */
+function VirtFusionDns_activate()
+{
+    return [
+        'status' => 'success',
+        'description' => 'VirtFusion DNS activated. Fill in the endpoint + API key in the addon configuration, then use the Test Connection button on the addon page.',
+    ];
+}
+
+/**
+ * Called when the addon is deactivated. Settings preserved (re-activating restores them).
+ */
+function VirtFusionDns_deactivate()
+{
+    return [
+        'status' => 'success',
+        'description' => 'VirtFusion DNS deactivated. Server lifecycle PowerDNS calls will now be skipped. Settings are preserved.',
+    ];
+}
+
+/**
+ * Admin status page — rendered by WHMCS when the addon is clicked from the Addons menu.
+ *
+ * Shows a settings summary, a Test Connection button (calls PowerDNS ping), the current
+ * zone count, and a recent log extract filtered to PowerDNS-related entries.
+ */
+function VirtFusionDns_output($vars)
+{
+    if (! virtfusiondns_load_server_libs()) {
+        echo '<div style="max-width:900px;padding:16px;border-radius:4px;background:#f8d7da;color:#721c24">';
+        echo '<strong>VirtFusionDirect server module not found.</strong> ';
+        echo 'This addon requires the VirtFusionDirect server module at <code>modules/servers/VirtFusionDirect/</code>. ';
+        echo 'Install or restore that module and reload this page.';
+        echo '</div>';
+
+        return;
+    }
+
+    Config::reset();
+    $config = Config::get();
+
+    $pingResult = null;
+    $zoneCount = null;
+    $zoneSample = [];
+
+    if (! empty($_GET['vfdns_test'])) {
+        if (Config::isEnabled()) {
+            $client = new Client;
+            $pingResult = $client->ping();
+            if ($pingResult['ok']) {
+                $client->forgetZoneCache();
+                $zones = $client->listZones();
+                $zoneCount = count($zones);
+                $zoneSample = array_slice($zones, 0, 8);
+            }
+        } else {
+            $pingResult = ['ok' => false, 'http' => 0, 'error' => 'Not enabled or missing endpoint/apiKey.'];
+        }
+    }
+
+    $modulelink = htmlspecialchars($vars['modulelink'] ?? '', ENT_QUOTES, 'UTF-8');
+    $endpoint = htmlspecialchars($config['endpoint'], ENT_QUOTES, 'UTF-8');
+    $serverId = htmlspecialchars($config['serverId'], ENT_QUOTES, 'UTF-8');
+    $ttl = (int) $config['defaultTtl'];
+    $cacheTtl = (int) $config['cacheTtl'];
+    $enabledBadge = $config['enabled']
+        ? '<span style="color:#28a745;font-weight:bold">enabled</span>'
+        : '<span style="color:#dc3545;font-weight:bold">disabled</span>';
+    $keyBadge = $config['apiKey'] !== '' ? '<span style="color:#28a745">set</span>' : '<span style="color:#dc3545">missing</span>';
+
+    echo '<div style="max-width:900px">';
+    echo '<h2 style="margin-top:0">VirtFusion DNS</h2>';
+    echo '<p>Reverse DNS management for the VirtFusionDirect server module. All PTR writes happen through the VirtFusion server lifecycle (create, rename, terminate) and through the client-area Reverse DNS panel. Forward DNS (A/AAAA) is verified before every PTR write; mismatches are skipped and logged.</p>';
+
+    echo '<h3>Current settings</h3>';
+    echo '<table class="table table-sm" style="max-width:700px"><tbody>';
+    echo '<tr><th style="text-align:left;width:180px">Status</th><td>' . $enabledBadge . '</td></tr>';
+    echo '<tr><th style="text-align:left">Endpoint</th><td><code>' . ($endpoint ?: '<em>not set</em>') . '</code></td></tr>';
+    echo '<tr><th style="text-align:left">API Key</th><td>' . $keyBadge . '</td></tr>';
+    echo '<tr><th style="text-align:left">Server ID</th><td><code>' . $serverId . '</code></td></tr>';
+    echo '<tr><th style="text-align:left">Default PTR TTL</th><td>' . $ttl . 's</td></tr>';
+    echo '<tr><th style="text-align:left">Cache TTL</th><td>' . $cacheTtl . 's</td></tr>';
+    echo '</tbody></table>';
+
+    echo '<h3>Test Connection</h3>';
+    echo '<p>Calls <code>GET /api/v1/servers/' . $serverId . '</code> and, on success, lists available zones.</p>';
+    echo '<a href="' . $modulelink . '&vfdns_test=1" class="btn btn-primary btn-sm">Run Test</a>';
+
+    if ($pingResult !== null) {
+        echo '<div style="margin-top:12px;padding:10px;border-radius:4px;background:' . ($pingResult['ok'] ? '#d4edda' : '#f8d7da') . ';color:' . ($pingResult['ok'] ? '#155724' : '#721c24') . '">';
+        if ($pingResult['ok']) {
+            echo '<strong>OK.</strong> PowerDNS reachable and authenticated. ';
+            if ($zoneCount !== null) {
+                echo $zoneCount . ' zone(s) visible.';
+                if (! empty($zoneSample)) {
+                    echo '<div style="margin-top:8px;font-family:monospace;font-size:12px">';
+                    foreach ($zoneSample as $z) {
+                        echo htmlspecialchars($z, ENT_QUOTES, 'UTF-8') . '<br>';
+                    }
+                    if ($zoneCount > count($zoneSample)) {
+                        echo '<em>... and ' . ($zoneCount - count($zoneSample)) . ' more</em>';
+                    }
+                    echo '</div>';
+                }
+            }
+        } else {
+            echo '<strong>Failed.</strong> HTTP ' . (int) $pingResult['http'] . ': ' . htmlspecialchars((string) ($pingResult['error'] ?? 'unknown error'), ENT_QUOTES, 'UTF-8');
+        }
+        echo '</div>';
+    }
+
+    echo '<h3 style="margin-top:24px">Operation</h3>';
+    echo '<ul>';
+    echo '<li><strong>On server creation:</strong> a PTR is created for each assigned IP, set to the server hostname, <em>only if the forward DNS already resolves to that IP</em>.</li>';
+    echo '<li><strong>On server rename:</strong> PTRs whose current content matches the <em>previous</em> hostname are updated to the new hostname; custom PTRs set by the client are preserved.</li>';
+    echo '<li><strong>On server termination:</strong> every PTR for the server\'s IPs is deleted from PowerDNS.</li>';
+    echo '<li><strong>Clients:</strong> may set a custom PTR per IP via the Reverse DNS panel on the service overview page. Forward DNS must resolve to the IP; mismatch rejects the write.</li>';
+    echo '<li><strong>Reconcile cron:</strong> runs daily, additive-only — creates PTRs where none exist, never overwrites.</li>';
+    echo '<li><strong>Reconcile (admin):</strong> a button on the admin services tab triggers an explicit reconcile with optional <em>force</em> to reset client-custom PTRs back to the server hostname.</li>';
+    echo '</ul>';
+
+    echo '<h3>Requirements</h3>';
+    echo '<ul>';
+    echo '<li>PowerDNS Authoritative with HTTP API enabled (<code>webserver=yes</code>, <code>api=yes</code>).</li>';
+    echo '<li>Reverse zones (<code>*.in-addr.arpa</code> / <code>*.ip6.arpa</code>) for your IP ranges must exist in PowerDNS already — the addon never creates zones.</li>';
+    echo '<li><code>api-allow-from</code> must include the WHMCS host\'s IP.</li>';
+    echo '</ul>';
+
+    echo '</div>';
+}

modules/servers/VirtFusionDirect/VirtFusionDirect.php

@@ -1,111 +1,411 @@
 <?php
 
-if (!defined("WHMCS")) {
+/**
-    die("This file cannot be accessed directly");
+ * VirtFusion Direct Provisioning Module — WHMCS server module entry point.
+ *
+ * This file contains the non-namespaced functions WHMCS calls via its reflection-
+ * based module dispatcher. They follow the naming convention:
+ *
+ *     {ModuleDirectoryName}_{FunctionName}(...)
+ *
+ * WHMCS looks for these on every relevant event (provisioning, UI rendering,
+ * daily cron, test connection, etc.). Every function here is a thin shim that
+ * instantiates ModuleFunctions (or Module) and delegates to a method — keeping
+ * the dispatch surface small and the business logic in unit-exercisable classes.
+ *
+ * DO NOT add significant logic directly in these shims. If you need a new
+ * lifecycle behaviour, add it as a method on ModuleFunctions and point the
+ * shim at it. This makes the module predictable: one public function, one method.
+ *
+ * RESERVED NAMES — DO NOT CHANGE
+ * ------------------------------
+ * WHMCS looks up these specific function names by convention; renaming them
+ * disables the corresponding feature in WHMCS silently:
+ *   VirtFusionDirect_MetaData        → Displayed name + API version
+ *   VirtFusionDirect_ConfigOptions   → Product-level settings fields
+ *   VirtFusionDirect_TestConnection  → Admin "Test Connection" button
+ *   VirtFusionDirect_CreateAccount   → Provisioning on order-activation
+ *   VirtFusionDirect_SuspendAccount  → Suspension
+ *   VirtFusionDirect_UnsuspendAccount → Unsuspension
+ *   VirtFusionDirect_TerminateAccount → Termination
+ *   VirtFusionDirect_ChangePackage   → Package change on upgrade/downgrade
+ *   VirtFusionDirect_AdminServicesTabFields     → Admin services tab renderer
+ *   VirtFusionDirect_AdminServicesTabFieldsSave → Admin services tab save handler
+ *   VirtFusionDirect_ClientArea      → Client-area template + vars
+ *   VirtFusionDirect_ServiceSingleSignOn → SSO button handler
+ *   VirtFusionDirect_AdminCustomButtonArray → Custom admin action buttons
+ *   VirtFusionDirect_UsageUpdate     → Daily cron bandwidth/disk usage sync
+ */
+if (! defined('WHMCS')) {
+    exit('This file cannot be accessed directly');
 }
 
+use WHMCS\Database\Capsule;
+use WHMCS\Module\Server\VirtFusionDirect\Database;
+use WHMCS\Module\Server\VirtFusionDirect\Log;
+use WHMCS\Module\Server\VirtFusionDirect\Module;
 use WHMCS\Module\Server\VirtFusionDirect\ModuleFunctions;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\Client as PowerDnsClient;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\Config as PowerDnsConfig;
 
+/**
+ * Returns module metadata consumed by WHMCS.
+ *
+ * @return array
+ */
 function VirtFusionDirect_MetaData()
 {
     return [
         'DisplayName' => 'VirtFusion Direct Provisioning',
         'APIVersion' => '1.1',
         'RequiresServer' => true,
-        'ServiceSingleSignOnLabel' => false,
+        'ServiceSingleSignOnLabel' => 'Login to VirtFusion Panel',
         'AdminSingleSignOnLabel' => false,
     ];
 }
 
+/**
+ * Returns product configuration options displayed in the WHMCS product editor.
+ *
+ * @return array
+ */
 function VirtFusionDirect_ConfigOptions()
 {
     return [
-        "defaultHypervisorGroupId" => [
+        'defaultHypervisorGroupId' => [
-            "FriendlyName" => "Hypervisor Group ID",
+            'FriendlyName' => 'Hypervisor Group ID',
-            "Type" => "text",
+            'Type' => 'text',
-            "Size" => "20",
+            'Size' => '20',
-            "Description" => "The default hypervisor group ID",
+            'Description' => 'The default hypervisor group ID for server placement.',
-            "Default" => "1",
+            'Default' => '1',
         ],
-        "packageID" => [
+        'packageID' => [
-            "FriendlyName" => "Package ID",
+            'FriendlyName' => 'Package ID',
-            "Type" => "text",
+            'Type' => 'text',
-            "Size" => "20",
+            'Size' => '20',
-            "Description" => "The package ID",
+            'Description' => 'The VirtFusion package ID that defines server resources.',
-            "Default" => "1",
+            'Default' => '1',
         ],
-        "defaultIPv4" => [
+        'defaultIPv4' => [
-            "FriendlyName" => "Default IPv4",
+            'FriendlyName' => 'Default IPv4',
-            "Type" => "dropdown",
+            'Type' => 'dropdown',
-            "Options" => "0,1,2,3,4,5,6,7,8,9,10",
+            'Options' => '0,1,2,3,4,5,6,7,8,9,10',
-            "Description" => "The default amount of IPv4 addresses to assign to the server.",
+            'Description' => 'The default number of IPv4 addresses to assign to each server.',
-            "Default" => "1",
+            'Default' => '1',
+        ],
+        'selfServiceMode' => [
+            'FriendlyName' => 'Self-Service Mode',
+            'Type' => 'dropdown',
+            'Options' => '0|Disabled,1|Hourly,2|Resource Packs,3|Both',
+            'Description' => 'Enable VirtFusion self-service billing for users created by this product.',
+            'Default' => '0',
+        ],
+        'autoTopOffThreshold' => [
+            'FriendlyName' => 'Auto Top-Off Threshold',
+            'Type' => 'text',
+            'Size' => '10',
+            'Description' => 'Credit balance below which auto top-off triggers during cron. 0 = disabled.',
+            'Default' => '0',
+        ],
+        'autoTopOffAmount' => [
+            'FriendlyName' => 'Auto Top-Off Amount',
+            'Type' => 'text',
+            'Size' => '10',
+            'Description' => 'Credit amount to add when auto top-off triggers.',
+            'Default' => '100',
         ],
     ];
 }
 
-function VirtFusionDirect_AdminCustomButtonArray()
+function VirtFusionDirect_TestConnection(array $params)
 {
-    $buttonarray = array(
+    try {
-        "Update Server Object" => "updateServerObject",
+        $hostname = trim($params['serverhostname'] ?? '');
-    );
+        $password = $params['serverpassword'] ?? '';
-    return $buttonarray;
+
+        if (empty($hostname) || empty($password)) {
+            return ['success' => false, 'error' => 'Server hostname and password are required. Please verify the server configuration.'];
+        }
+
+        $url = 'https://' . $hostname . '/api/v1';
+        $module = new Module;
+        $request = $module->initCurl($password);
+        $data = $request->get($url . '/connect');
+
+        $httpCode = $request->getRequestInfo('http_code');
+
+        if ($httpCode == 200) {
+            // Also verify PowerDNS health when the DNS addon is activated, so the
+            // admin's Test Connection button reflects the full provisioning path.
+            if (PowerDnsConfig::isEnabled()) {
+                $pdns = (new PowerDnsClient)->ping();
+                if (! $pdns['ok']) {
+                    return [
+                        'success' => false,
+                        'error' => 'VirtFusion OK; PowerDNS unreachable — '
+                            . ($pdns['error'] ?? 'unknown')
+                            . ' (HTTP ' . (int) $pdns['http'] . '). Fix the VirtFusion DNS addon settings.',
+                    ];
+                }
+            }
+
+            return ['success' => true, 'error' => ''];
+        }
+
+        if ($httpCode == 401) {
+            return ['success' => false, 'error' => 'Authentication failed. Please verify your API token is correct and has not expired.'];
+        }
+
+        if ($httpCode == 0) {
+            $curlError = $request->getRequestInfo('curl_error');
+
+            return ['success' => false, 'error' => 'Connection failed: ' . ($curlError ?: 'Unable to reach the VirtFusion server. Verify the hostname and that SSL certificates are valid.')];
+        }
+
+        return ['success' => false, 'error' => 'Unexpected response from VirtFusion API (HTTP ' . $httpCode . '). Please check the server configuration.'];
+    } catch (Throwable $e) {
+        return ['success' => false, 'error' => 'Connection test failed: ' . $e->getMessage()];
+    }
 }
 
 /**
+ * Returns custom admin action buttons shown on the service management page.
  *
- *
+ * @return array Button label => function suffix pairs
+ */
+function VirtFusionDirect_AdminCustomButtonArray()
+{
+    return [
+        'Update Server Object' => 'updateServerObject',
+        'Validate Server Config' => 'validateServerConfig',
+    ];
+}
+
+function VirtFusionDirect_ServiceSingleSignOn(array $params)
+{
+    try {
+        $module = new Module;
+        $token = $module->fetchLoginTokens($params['serviceid']);
+
+        if ($token) {
+            return ['success' => true, 'redirectTo' => $token];
+        }
+
+        return ['success' => false, 'errorMsg' => 'Unable to generate a login token. The server may not be active or the VirtFusion API may be unreachable.'];
+    } catch (Exception $e) {
+        return ['success' => false, 'errorMsg' => $e->getMessage()];
+    }
+}
+
+/**
  * Service functions
- *
  */
 function VirtFusionDirect_CreateAccount(array $params)
 {
-    return (new ModuleFunctions())->createAccount($params);
+    return (new ModuleFunctions)->createAccount($params);
 }
 
+/**
+ * Suspends the VirtFusion server associated with a WHMCS service.
+ *
+ * @param  array  $params  WHMCS module parameters
+ * @return string 'success' or error message
+ */
 function VirtFusionDirect_SuspendAccount(array $params)
 {
-    return (new ModuleFunctions())->suspendAccount($params);
+    return (new ModuleFunctions)->suspendAccount($params);
 }
 
+/**
+ * Unsuspends the VirtFusion server associated with a WHMCS service.
+ *
+ * @param  array  $params  WHMCS module parameters
+ * @return string 'success' or error message
+ */
 function VirtFusionDirect_UnsuspendAccount(array $params)
 {
-    return (new ModuleFunctions())->unsuspendAccount($params);
+    return (new ModuleFunctions)->unsuspendAccount($params);
 }
 
+/**
+ * Terminates (deletes) the VirtFusion server associated with a WHMCS service.
+ *
+ * @param  array  $params  WHMCS module parameters
+ * @return string 'success' or error message
+ */
 function VirtFusionDirect_TerminateAccount(array $params)
 {
-    return (new ModuleFunctions())->terminateAccount($params);
+    return (new ModuleFunctions)->terminateAccount($params);
 }
 
+/**
+ * Admin custom action: refreshes the local server object from the VirtFusion API.
+ *
+ * @param  array  $params  WHMCS module parameters
+ * @return string 'success' or error message
+ */
 function VirtFusionDirect_updateServerObject(array $params)
 {
-    return (new ModuleFunctions())->updateServerObject($params);
+    return (new ModuleFunctions)->updateServerObject($params);
 }
 
 /**
  * Allows changing of the package of a server
  *
- * @author https://github.com/BlinkohHost/virtfusion-whmcs-module
- * @param array $params
  * @return string
  */
 function VirtFusionDirect_ChangePackage(array $params)
 {
-    return (new ModuleFunctions())->changePackage($params);
+    return (new ModuleFunctions)->changePackage($params);
 }
 
+/**
+ * Returns HTML fields rendered in the custom admin services tab.
+ *
+ * @param  array  $params  WHMCS module parameters
+ * @return array Field name => HTML value pairs
+ */
 function VirtFusionDirect_AdminServicesTabFields(array $params)
 {
-    return (new ModuleFunctions())->adminServicesTabFields($params);
+    return (new ModuleFunctions)->adminServicesTabFields($params);
 }
 
+/**
+ * Handles saving of custom admin services tab field values.
+ *
+ * @param  array  $params  WHMCS module parameters
+ * @return void
+ */
 function VirtFusionDirect_AdminServicesTabFieldsSave(array $params)
 {
-    (new ModuleFunctions())->adminServicesTabFieldsSave($params);
+    (new ModuleFunctions)->adminServicesTabFieldsSave($params);
 }
 
+/**
+ * Returns the client area template variables and template name for the service overview page.
+ *
+ * @param  array  $params  WHMCS module parameters
+ * @return array Smarty template variables and 'templatefile' key
+ */
 function VirtFusionDirect_ClientArea(array $params)
 {
-    return (new ModuleFunctions())->clientArea($params);
+    return (new ModuleFunctions)->clientArea($params);
-}
+}
+
+/**
+ * Validates server configuration via dry run without creating the server.
+ *
+ * @return string 'success' or error message
+ */
+function VirtFusionDirect_validateServerConfig(array $params)
+{
+    return (new ModuleFunctions)->validateServerConfig($params);
+}
+
+/**
+ * Usage Update - called by WHMCS daily cron to sync bandwidth and disk usage.
+ *
+ * Updates tblhosting with disk and bandwidth usage data from VirtFusion.
+ * Fields updated: diskused, disklimit, bwused, bwlimit, lastupdate
+ *
+ * @param  array  $params  Server access credentials
+ * @return string 'success' or error message
+ */
+function VirtFusionDirect_UsageUpdate(array $params)
+{
+    try {
+        $module = new Module;
+        $cp = $module->getCP($params['serverid']);
+
+        if (! $cp) {
+            return 'No control server found for usage update.';
+        }
+
+        $services = Capsule::table('tblhosting')
+            ->where('server', $params['serverid'])
+            ->where('domainstatus', 'Active')
+            ->get();
+
+        foreach ($services as $service) {
+            try {
+                $systemService = Database::getSystemService($service->id);
+                if (! $systemService) {
+                    continue;
+                }
+
+                $request = $module->initCurl($cp['token']);
+                $data = $request->get($cp['url'] . '/servers/' . (int) $systemService->server_id);
+
+                if ($request->getRequestInfo('http_code') != 200) {
+                    continue;
+                }
+
+                $serverData = json_decode($data, true);
+                if (! isset($serverData['data'])) {
+                    continue;
+                }
+
+                $server = $serverData['data'];
+                $update = [];
+
+                // Disk usage (WHMCS expects MB)
+                if (isset($server['usage']['storage']['used'])) {
+                    $update['diskused'] = round($server['usage']['storage']['used'] / 1048576);
+                }
+                if (isset($server['settings']['resources']['storage'])) {
+                    $update['disklimit'] = (int) $server['settings']['resources']['storage'] * 1024;
+                }
+
+                // Bandwidth usage (WHMCS expects MB)
+                if (isset($server['usage']['traffic']['used'])) {
+                    $update['bwused'] = round($server['usage']['traffic']['used'] / 1048576);
+                }
+                if (isset($server['settings']['resources']['traffic'])) {
+                    $trafficGB = (int) $server['settings']['resources']['traffic'];
+                    $update['bwlimit'] = $trafficGB > 0 ? $trafficGB * 1024 : 0;
+                }
+
+                if (! empty($update)) {
+                    $update['lastupdate'] = date('Y-m-d H:i:s');
+                    Capsule::table('tblhosting')
+                        ->where('id', $service->id)
+                        ->update($update);
+                }
+
+                // Self-service auto top-off
+                $product = Capsule::table('tblproducts')
+                    ->where('id', $service->packageid)
+                    ->first();
+
+                if ($product) {
+                    $threshold = (float) ($product->configoption5 ?? 0);
+                    $topOffAmount = (float) ($product->configoption6 ?? 0);
+
+                    if ($threshold > 0 && $topOffAmount > 0) {
+                        $usageData = $module->getSelfServiceUsage($service->id);
+                        if ($usageData) {
+                            $usageInner = $usageData['data'] ?? $usageData;
+                            $credit = $usageInner['credit'] ?? $usageInner['balance'] ?? null;
+                            if ($credit !== null && (float) $credit < $threshold) {
+                                $module->addSelfServiceCredit($service->id, $topOffAmount, 'Auto top-off');
+                                Log::insert(
+                                    'UsageUpdate:autoTopOff',
+                                    ['serviceId' => $service->id, 'credit' => $credit, 'threshold' => $threshold],
+                                    ['amount' => $topOffAmount],
+                                );
+                            }
+                        }
+                    }
+                }
+            } catch (Exception $e) {
+                // Log but continue processing other services
+                Log::insert('UsageUpdate:service:' . $service->id, [], $e->getMessage());
+                continue;
+            }
+        }
+
+        return 'success';
+    } catch (Exception $e) {
+        return 'Usage update failed: ' . $e->getMessage();
+    }
+}

modules/servers/VirtFusionDirect/admin.php

@@ -2,84 +2,178 @@
 
 require dirname(__DIR__, 3) . '/init.php';
 
+/**
+ * Admin-facing AJAX API endpoint.
+ *
+ * MIRRORS client.php STRUCTURE
+ * ----------------------------
+ * Same switch-on-$action dispatch pattern, same JSON response shape, same
+ * "output + break" convention. The only substantive difference is the auth
+ * gate at the top: $vf->adminOnly() instead of $vf->isAuthenticated().
+ *
+ * WHY SEPARATE FROM client.php
+ * ----------------------------
+ * A single file with a per-action admin/client switch would risk one bug
+ * (e.g. forgetting to call adminOnly on a new admin-only action) giving a
+ * client authenticated but without admin privileges access to admin data.
+ * Having two physical entry points means the admin auth gate is enforced
+ * at file scope — any action routed here already went through adminOnly().
+ *
+ * ADMIN-LEVEL AUTH ONLY — NO SERVICE OWNERSHIP CHECK
+ * --------------------------------------------------
+ * An admin is allowed to view/operate on any service, so we don't call
+ * validateUserOwnsService() here. If you add an action that needs finer-
+ * grained auth (e.g. restrict to the admin role that owns the product
+ * group), compose the additional check inside the case branch.
+ *
+ * SAME-ORIGIN / POST GATES STILL APPLY TO MUTATIONS
+ * -------------------------------------------------
+ * Admins are still subject to requirePost + requireSameOrigin on writes —
+ * admin sessions are just as CSRF-vulnerable as client sessions. See the
+ * rdnsReconcile case for the pattern.
+ */
+
 use WHMCS\Module\Server\VirtFusionDirect\Database;
+use WHMCS\Module\Server\VirtFusionDirect\Log;
 use WHMCS\Module\Server\VirtFusionDirect\Module;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\Config as PowerDnsConfig;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\PtrManager;
 use WHMCS\Module\Server\VirtFusionDirect\ServerResource;
 
-$vf = new Module();
+$vf = new Module;
 
-$vf->adminOnly();
+try {
 
-switch ($vf->validateAction(true)) {
+    $vf->adminOnly();
 
-    /**
+    switch ($vf->validateAction(true)) {
-     *
-     * Get server information.
-     *
-     */
-    case 'serverData':
 
-        if ($vf->validateServiceID(true)) {
+        /**
+         * Get server information.
+         */
+        case 'serverData':
 
-            /** No need to validate ownership **/
+            $serviceID = $vf->validateServiceID(true);
 
-            $whmcsService = Database::getWhmcsService((int)$_GET['serviceID']);
+            $whmcsService = Database::getWhmcsService($serviceID);
 
-            if (!$whmcsService) {
+            if (! $whmcsService) {
-                $vf->output(['success' => false, 'errors' => 'Service not found.'], true, true, 200);
+                $vf->output(['success' => false, 'errors' => 'Service not found.'], true, true, 404);
+                break;
             }
 
-            if ($whmcsService->domainstatus == 'Pending' || $whmcsService->domainstatus == 'Terminated' || $whmcsService->domainstatus == 'Cancelled' || $whmcsService->domainstatus == 'Fraud') {
+            if (in_array($whmcsService->domainstatus, ['Pending', 'Terminated', 'Cancelled', 'Fraud'], true)) {
-                $vf->output(['success' => false, 'errors' => 'Server is not Active, Suspended or Completed. Not fetching remote data.'], true, true, 200);
+                $vf->output(['success' => false, 'errors' => 'Server is not Active, Suspended or Completed. Not fetching remote data.'], true, true, 400);
+                break;
             }
 
-            $data = $vf->fetchServerData((int)$_GET['serviceID']);
+            $data = $vf->fetchServerData($serviceID);
-
-            if (!$data) {
-                $vf->output(['success' => false, 'errors' => 'No data returned from VirtFusion.'], true, true, 200);
 
+            if (! $data) {
+                $vf->output(['success' => false, 'errors' => 'No data returned from VirtFusion.'], true, true, 502);
+                break;
             }
 
-            (new Module())->updateWhmcsServiceParamsOnServerObject((int)$_GET['serviceID'], $data);
+            $vf->updateWhmcsServiceParamsOnServerObject($serviceID, $data);
-            $vf->output(['success' => true, 'data' => (new ServerResource())->process($data)], true, true, 200);
+            $vf->output(['success' => true, 'data' => (new ServerResource)->process($data)], true, true, 200);
+            break;
 
-        }
+            /**
-        break;
+             * Impersonate server owner.
+             */
+        case 'impersonateServerOwner':
 
-    /**
+            $serviceID = $vf->validateServiceID(true);
-     *
-     * Impersonate server owner.
-     *
-     */
-    case 'impersonateServerOwner':
 
-        if ($vf->validateServiceID(true)) {
+            $service = Database::getSystemService($serviceID);
-
+            if (! $service) {
-            $service = Database::getSystemService((int)$_GET['serviceID']);
+                $vf->output(['success' => false, 'errors' => 'Service not found'], true, true, 404);
-
+                break;
-            if (!$service) {
-                $vf->output(['success' => false, 'errors' => 'Service not found'], true, true, 200);
             }
 
-            $whmcsService = Database::getWhmcsService((int)$_GET['serviceID']);
+            $whmcsService = Database::getWhmcsService($serviceID);
+            if (! $whmcsService) {
+                $vf->output(['success' => false, 'errors' => 'WHMCS service not found'], true, true, 404);
+                break;
+            }
 
             $cp = $vf->getCP($whmcsService->server);
-            $request = $vf->initCurl($cp['token']);
+            if (! $cp) {
+                $vf->output(['success' => false, 'errors' => 'Control server not found'], true, true, 500);
+                break;
+            }
 
-            $data = $request->get($cp['url'] . '/users/' . $whmcsService->userid . '/byExtRelation');
+            $request = $vf->initCurl($cp['token']);
+            $data = $request->get($cp['url'] . '/users/' . (int) $whmcsService->userid . '/byExtRelation');
 
             if ($request->getRequestInfo('http_code') === 200) {
                 $vf->output(['success' => true, 'url' => $cp['base_url'], 'user' => json_decode($data, true)['data']], true, true, 200);
+                break;
             }
 
-            $vf->output(['success' => false, 'errors' => 'Received HTTP code ' . $request->getRequestInfo('http_code')], true, true, 200);
+            $vf->output(['success' => false, 'errors' => 'Unable to fetch user data'], true, true, 502);
+            break;
 
-        }
+            // =================================================================
-        break;
+            // Reverse DNS (PowerDNS)
+            // =================================================================
 
-    default:
+            /**
-        /** No valid action was specified **/
+             * Admin-side PTR status for a service. Same shape as client-side rdnsList but
+             * accessible without being the service owner (admin-only guard at top).
+             */
+        case 'rdnsStatus':
 
-        $vf->output(['success' => false, 'errors' => 'invalid action'], true, true, 200);
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! PowerDnsConfig::isEnabled()) {
+                $vf->output(['success' => true, 'data' => ['enabled' => false, 'ips' => []]], true, true, 200);
+                break;
+            }
+
+            $serverData = $vf->fetchServerData($serviceID);
+            if (! $serverData) {
+                $vf->output(['success' => false, 'errors' => 'Unable to retrieve server data'], true, true, 502);
+                break;
+            }
+
+            $ptrs = (new PtrManager)->listPtrs($serverData);
+            $vf->output(['success' => true, 'data' => ['enabled' => true, 'ips' => $ptrs]], true, true, 200);
+            break;
+
+            /**
+             * Trigger PTR reconciliation for a single service. Additive-only by default
+             * (missing PTRs are created with the current hostname); pass force=1 to also
+             * reset PTRs that differ from the server hostname.
+             */
+        case 'rdnsReconcile':
+
+            // Mutating action — enforce POST + same-origin even though the session is admin-authenticated.
+            $vf->requirePost();
+            $vf->requireSameOrigin();
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! PowerDnsConfig::isEnabled()) {
+                $vf->output(['success' => false, 'errors' => 'Reverse DNS is not enabled'], true, true, 400);
+                break;
+            }
+
+            $force = ! empty($_POST['force']);
+            $summary = (new PtrManager)->reconcile($serviceID, $force);
+            Log::insert(
+                'rdnsReconcile:ok',
+                ['serviceID' => $serviceID, 'force' => $force],
+                $summary,
+            );
+            $vf->output(['success' => true, 'data' => $summary], true, true, 200);
+            break;
+
+        default:
+            $vf->output(['success' => false, 'errors' => 'invalid action'], true, true, 400);
+    }
+
+} catch (Exception $e) {
+    Log::insert('admin.php', [], $e->getMessage());
+    $vf->output(['success' => false, 'errors' => 'An unexpected error occurred'], true, true, 500);
 }
-

modules/servers/VirtFusionDirect/client.php

@@ -2,110 +2,601 @@
 
 require dirname(__DIR__, 3) . '/init.php';
 
+/**
+ * Client-facing AJAX API endpoint.
+ *
+ * ROUTING MODEL
+ * -------------
+ * Every request carries ?action=X&serviceID=Y. We dispatch on $action via the
+ * switch below. Because PHP's switch() is O(N) over case labels that's still
+ * fine at ~20 actions; if this grows large enough that dispatch cost matters
+ * we'd want a lookup table, but we're nowhere near that.
+ *
+ * WHMCS requires every action URL to re-authenticate on each request (no
+ * cross-request sticky state beyond the session cookie). That's why the
+ * isAuthenticated() call is the first thing inside the try block — nothing
+ * downstream may assume a session exists.
+ *
+ * AUTH LAYERS (ORDER MATTERS)
+ * ---------------------------
+ * Each case composes the defenses it needs:
+ *
+ *   1. $vf->isAuthenticated()              — client session (401 otherwise)
+ *   2. $vf->validateServiceID(true)        — numeric coercion + presence
+ *   3. $vf->validateUserOwnsService($id)   — the session owns this service (403)
+ *   4. Optional: requireServiceStatus      — filter by tblhosting.domainstatus
+ *   5. Optional (mutations): requirePost   — HTTP method gate (405)
+ *   6. Optional (mutations): requireSameOrigin — CSRF origin gate (403)
+ *
+ * The helpers are "fail loudly" — they exit on failure rather than returning.
+ * So everything AFTER a guard in a case branch knows the guard passed.
+ *
+ * EVERY $vf->output() FOLLOWED BY break
+ * -------------------------------------
+ * output() emits a JSON response and exits by default, so in theory `break`
+ * is redundant. In practice we always break explicitly for two reasons:
+ *   1. If someone later passes exit=false to output() the switch would fall
+ *      through to the default case and emit a second response body.
+ *   2. Code readers shouldn't have to remember that one function exits.
+ *
+ * RESPONSE SHAPE
+ * --------------
+ * Success: { success: true, data: { ... } }
+ * Error:   { success: false, errors: "human-readable message" }
+ * Status codes match HTTP semantics (200/400/401/403/404/405/429/500/502).
+ *
+ * CATCH-ALL
+ * ---------
+ * The outer try/catch guarantees we never expose a raw PHP stack trace to the
+ * client, even on bugs in our own code. All uncaught exceptions are logged and
+ * the user sees a generic 500.
+ */
+
+use WHMCS\Module\Server\VirtFusionDirect\Log;
 use WHMCS\Module\Server\VirtFusionDirect\Module;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\Config as PowerDnsConfig;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\IpUtil;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\PtrManager;
 use WHMCS\Module\Server\VirtFusionDirect\ServerResource;
 
-$vf = new Module();
+$vf = new Module;
 
-$vf->isAuthenticated();
+try {
 
-switch ($vf->validateAction(true)) {
+    $vf->isAuthenticated();
 
-    /**
+    $action = $vf->validateAction(true);
-     *
-     * Reset Password.
-     *
-     */
-    case 'resetPassword':
 
-        if ($vf->validateServiceID(true)) {
+    switch ($action) {
 
-            $client = $vf->validateUserOwnsService((int)$_GET['serviceID']);
+        /**
+         * Reset Password.
+         */
+        case 'resetPassword':
 
-            if (!$client) {
+            $serviceID = $vf->validateServiceID(true);
-                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 200);
+            $client = $vf->validateUserOwnsService($serviceID);
+
+            if (! $client) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
             }
 
-            $data = $vf->resetUserPassword((int)$_GET['serviceID'], $client);
+            $data = $vf->resetUserPassword($serviceID, $client);
 
             if ($data) {
                 $vf->output(['success' => true, 'data' => $data->data], true, true, 200);
+                break;
             }
 
-            $vf->output(['success' => false, 'errors' => 'error'], true, true, 200);
+            $vf->output(['success' => false, 'errors' => 'Password reset failed'], true, true, 500);
+            break;
 
-        }
+            /**
-        break;
+             * Get server information.
+             */
+        case 'serverData':
 
-    /**
+            $serviceID = $vf->validateServiceID(true);
-     *
-     * Get server information.
-     *
-     */
-    case 'serverData':
 
-        if ($vf->validateServiceID(true)) {
+            if (! $vf->validateUserOwnsService($serviceID)) {
-
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
-            if (!$vf->validateUserOwnsService((int)$_GET['serviceID'])) {
+                break;
-                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 200);
             }
 
-            $data = $vf->fetchServerData((int)$_GET['serviceID']);
+            $data = $vf->fetchServerData($serviceID);
 
             if ($data) {
-
+                $vf->updateWhmcsServiceParamsOnServerObject($serviceID, $data);
-                (new Module())->updateWhmcsServiceParamsOnServerObject((int)$_GET['serviceID'], $data);
+                $vf->output(['success' => true, 'data' => (new ServerResource)->process($data)], true, true, 200);
-
+                break;
-                $vf->output(['success' => true, 'data' => (new ServerResource())->process($data)], true, true, 200);
-
             }
 
-            $vf->output(['success' => false, 'errors' => 'error'], true, true, 200);
+            $vf->output(['success' => false, 'errors' => 'Unable to retrieve server data'], true, true, 500);
+            break;
 
-        }
-        break;
-
-    /**
-     *
-     * Login as server owner.
-     *
-     */
-    case 'loginAsServerOwner':
-
-        if ($vf->validateServiceID(true)) {
             /**
-             * A client can't log in as any user. Ownership should be validated.
+             * Login as server owner.
              */
+        case 'loginAsServerOwner':
 
-            if (!$vf->validateUserOwnsService((int)$_GET['serviceID'])) {
+            $serviceID = $vf->validateServiceID(true);
-                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 200);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
             }
 
-            $token = $vf->fetchLoginTokens((int)$_GET['serviceID']);
+            $token = $vf->fetchLoginTokens($serviceID);
 
             if ($token) {
-
-                /**
-                 * A valid token/url was received.
-                 */
                 $vf->output(['success' => true, 'token_url' => $token], true, true, 200);
+                break;
             }
 
+            $vf->output(['success' => false, 'errors' => 'Unable to generate login token'], true, true, 500);
+            break;
+
             /**
-             * Failed to get the token from the control panel or the service ID doesn't exist.
+             * Power management actions: boot, shutdown, restart, poweroff
              */
-            $vf->output(['success' => false, 'errors' => 'token request error'], true, true, 200);
+        case 'powerAction':
 
-        }
+            $serviceID = $vf->validateServiceID(true);
-        break;
 
-    default:
+            if (! $vf->validateUserOwnsService($serviceID)) {
-        /**
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
-         *
+                break;
-         * No valid action was specified.
+            }
-         *
+
-         */
+            $powerAction = isset($_POST['powerAction']) ? preg_replace('/[^a-zA-Z]/', '', $_POST['powerAction']) : '';
-        $vf->output(['success' => false, 'errors' => 'invalid action'], true, true, 200);
+            $allowedActions = ['boot', 'shutdown', 'restart', 'poweroff'];
+
+            if (! in_array($powerAction, $allowedActions, true)) {
+                $vf->output(['success' => false, 'errors' => 'Invalid power action'], true, true, 400);
+                break;
+            }
+
+            $result = $vf->serverPowerAction($serviceID, $powerAction);
+
+            if ($result) {
+                $vf->output(['success' => true, 'data' => ['action' => $powerAction, 'message' => 'Power action queued successfully']], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Power action failed. The server may be locked or unavailable.'], true, true, 500);
+            break;
+
+            /**
+             * Rebuild/reinstall server with new OS.
+             */
+        case 'rebuild':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $osId = isset($_POST['osId']) ? (int) $_POST['osId'] : 0;
+            $hostname = isset($_POST['hostname']) ? preg_replace('/[^a-zA-Z0-9.\-]/', '', $_POST['hostname']) : null;
+
+            if ($osId <= 0) {
+                $vf->output(['success' => false, 'errors' => 'Invalid operating system ID'], true, true, 400);
+                break;
+            }
+
+            $result = $vf->rebuildServer($serviceID, $osId, $hostname);
+
+            if ($result) {
+                $vf->output(['success' => true, 'data' => ['message' => 'Server rebuild initiated successfully']], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Server rebuild failed. The server may be locked or unavailable.'], true, true, 500);
+            break;
+
+            /**
+             * Rename server.
+             */
+        case 'rename':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $newName = isset($_POST['name']) ? trim($_POST['name']) : '';
+
+            if (empty($newName) || strlen($newName) > 63 || ! preg_match('/^[a-z0-9]([a-z0-9\-]{0,61}[a-z0-9])?$/', $newName)) {
+                $vf->output(['success' => false, 'errors' => 'Invalid server name'], true, true, 400);
+                break;
+            }
+
+            $result = $vf->renameServer($serviceID, $newName);
+
+            if ($result) {
+                $vf->output(['success' => true, 'data' => ['message' => 'Server renamed successfully']], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Server rename failed'], true, true, 500);
+            break;
+
+            /**
+             * Get available OS templates for rebuild.
+             */
+        case 'osTemplates':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $templates = $vf->fetchOsTemplates($serviceID);
+
+            if ($templates !== false) {
+                $vf->output(['success' => true, 'data' => $templates], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Unable to fetch OS templates'], true, true, 500);
+            break;
+
+            // =================================================================
+            // Server Password Reset
+            // =================================================================
+
+            /**
+             * Reset server root password.
+             */
+        case 'resetServerPassword':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $result = $vf->resetServerPassword($serviceID);
+
+            if ($result !== false) {
+                $vf->output(['success' => true, 'data' => $result], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Password reset failed'], true, true, 500);
+            break;
+
+            // =================================================================
+            // Backup Listing
+            // =================================================================
+
+            /**
+             * Get server backups.
+             */
+        case 'backups':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $result = $vf->getServerBackups($serviceID);
+
+            if ($result !== false) {
+                $vf->output(['success' => true, 'data' => $result], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Unable to retrieve backups'], true, true, 500);
+            break;
+
+            // =================================================================
+            // Traffic Statistics
+            // =================================================================
+
+            /**
+             * Get traffic statistics for a server.
+             */
+        case 'trafficStats':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $result = $vf->getTrafficStats($serviceID);
+
+            if ($result !== false) {
+                $vf->output(['success' => true, 'data' => $result], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Unable to retrieve traffic statistics'], true, true, 500);
+            break;
+
+            // =================================================================
+            // VNC Console
+            // =================================================================
+
+            /**
+             * Get VNC console URL.
+             */
+        case 'vnc':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $result = $vf->getVncConsole($serviceID);
+
+            if ($result !== false) {
+                $vf->output(['success' => true, 'data' => $result], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'VNC console unavailable. The server may be powered off or VNC is not supported.'], true, true, 500);
+            break;
+
+            /**
+             * Toggle VNC on/off.
+             */
+        case 'toggleVnc':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $enabled = isset($_POST['enabled']) && $_POST['enabled'] === '1';
+            $result = $vf->toggleVnc($serviceID, $enabled);
+
+            if ($result !== false) {
+                $vf->output(['success' => true, 'data' => $result], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Failed to toggle VNC'], true, true, 500);
+            break;
+
+            // =================================================================
+            // Self Service — Credit & Usage
+            // =================================================================
+
+            /**
+             * Get self-service usage data.
+             */
+        case 'selfServiceUsage':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $result = $vf->getSelfServiceUsage($serviceID);
+
+            if ($result !== false) {
+                $vf->output(['success' => true, 'data' => $result], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Unable to retrieve self-service usage data'], true, true, 500);
+            break;
+
+            /**
+             * Get self-service billing report.
+             */
+        case 'selfServiceReport':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $result = $vf->getSelfServiceReport($serviceID);
+
+            if ($result !== false) {
+                $vf->output(['success' => true, 'data' => $result], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Unable to retrieve self-service report'], true, true, 500);
+            break;
+
+            /**
+             * Add self-service credit.
+             */
+        case 'selfServiceAddCredit':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            $tokens = isset($_POST['tokens']) ? (float) $_POST['tokens'] : 0;
+            if ($tokens <= 0) {
+                $vf->output(['success' => false, 'errors' => 'Invalid credit amount. Must be a positive number.'], true, true, 400);
+                break;
+            }
+
+            $result = $vf->addSelfServiceCredit($serviceID, $tokens);
+
+            if ($result !== false) {
+                $vf->output(['success' => true, 'data' => $result], true, true, 200);
+                break;
+            }
+
+            $vf->output(['success' => false, 'errors' => 'Failed to add credit'], true, true, 500);
+            break;
+
+            // =================================================================
+            // Reverse DNS (PowerDNS)
+            // =================================================================
+
+            /**
+             * List PTR state for every IP assigned to the service's server.
+             *
+             * Always fetches fresh server data from VirtFusion (not cached server_object)
+             * so the displayed IPs match current reality — if an IP was reassigned out
+             * of this server since last sync, it won't appear here.
+             */
+        case 'rdnsList':
+
+            $serviceID = $vf->validateServiceID(true);
+
+            if (! $vf->validateUserOwnsService($serviceID)) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            // Reads are permitted for Active + Suspended (a suspended user can still see their rDNS);
+            // Terminated/Pending/Cancelled/Fraud return a clear 400 upfront.
+            $vf->requireServiceStatus($serviceID, ['Active', 'Suspended']);
+
+            if (! PowerDnsConfig::isEnabled()) {
+                $vf->output(['success' => true, 'data' => ['enabled' => false, 'ips' => []]], true, true, 200);
+                break;
+            }
+
+            $serverData = $vf->fetchServerData($serviceID);
+            if (! $serverData) {
+                $vf->output(['success' => false, 'errors' => 'Unable to retrieve server data'], true, true, 502);
+                break;
+            }
+
+            $ptrs = (new PtrManager)->listPtrs($serverData);
+            $vf->output(['success' => true, 'data' => ['enabled' => true, 'ips' => $ptrs]], true, true, 200);
+            break;
+
+            /**
+             * Update (or delete) the PTR for a single IP assigned to the user's server.
+             *
+             * Validation order: ownership -> IP format -> PTR regex -> IP belongs to this server
+             * -> rate-limit/forward-DNS checks inside PtrManager. Sending an empty `ptr` deletes.
+             */
+        case 'rdnsUpdate':
+
+            // Mutation: enforce POST, same-origin, active service status in that order.
+            // requirePost/requireSameOrigin exit on failure (405/403 respectively), so nothing below runs.
+            $vf->requirePost();
+            $vf->requireSameOrigin();
+
+            $serviceID = $vf->validateServiceID(true);
+
+            $clientId = $vf->validateUserOwnsService($serviceID);
+            if (! $clientId) {
+                $vf->output(['success' => false, 'errors' => 'service <> owner mismatch'], true, true, 403);
+                break;
+            }
+
+            // Writes require an Active service — Suspended/Terminated/etc. cannot mutate rDNS.
+            $vf->requireServiceStatus($serviceID, ['Active']);
+
+            if (! PowerDnsConfig::isEnabled()) {
+                $vf->output(['success' => false, 'errors' => 'Reverse DNS is not enabled on this installation'], true, true, 400);
+                break;
+            }
+
+            $ip = isset($_POST['ip']) ? trim((string) $_POST['ip']) : '';
+            $ptr = isset($_POST['ptr']) ? trim((string) $_POST['ptr']) : '';
+
+            if (filter_var($ip, FILTER_VALIDATE_IP) === false) {
+                $vf->output(['success' => false, 'errors' => 'Invalid IP address'], true, true, 400);
+                break;
+            }
+
+            if ($ptr !== '' && ! preg_match('/^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}\.?$/', $ptr)) {
+                $vf->output(['success' => false, 'errors' => 'Invalid hostname for PTR record'], true, true, 400);
+                break;
+            }
+            if (strlen($ptr) > 253) {
+                $vf->output(['success' => false, 'errors' => 'Hostname too long'], true, true, 400);
+                break;
+            }
+
+            // Cross-check: the submitted IP must be currently assigned to this user's server.
+            // Fetch fresh from VirtFusion (not the stored object) to prevent stale-ownership writes
+            // after an IP reassignment.
+            $serverData = $vf->fetchServerData($serviceID);
+            if (! $serverData) {
+                $vf->output(['success' => false, 'errors' => 'Unable to verify IP ownership'], true, true, 502);
+                break;
+            }
+            $assigned = IpUtil::extractIps($serverData)['addresses'];
+            $targetBin = @inet_pton($ip);
+            $owns = false;
+            foreach ($assigned as $a) {
+                if (@inet_pton($a) === $targetBin) {
+                    $owns = true;
+                    break;
+                }
+            }
+            if (! $owns) {
+                Log::insert('rdnsUpdate:ownership', ['serviceID' => $serviceID, 'ip' => $ip], 'IP not assigned to this service');
+                $vf->output(['success' => false, 'errors' => 'This IP is not assigned to your server'], true, true, 403);
+                break;
+            }
+
+            $result = (new PtrManager)->setPtr($ip, $ptr);
+
+            if ($result['ok']) {
+                // Audit trail for successful edits — surfaces in Utilities → Logs → Module Log,
+                // searchable by clientId / serviceId / ip for "who changed this PTR".
+                Log::insert(
+                    'rdnsUpdate:ok',
+                    ['clientId' => $clientId, 'serviceID' => $serviceID, 'ip' => $ip, 'reason' => $result['reason']],
+                    ['ptr' => $ptr === '' ? '(deleted)' : $ptr],
+                );
+                $vf->output(['success' => true, 'data' => ['reason' => $result['reason']]], true, true, 200);
+                break;
+            }
+
+            // Map internal reasons to client-facing messages/status codes.
+            switch ($result['reason']) {
+                case 'forward-missing':
+                    $vf->output(['success' => false, 'errors' => 'Forward DNS for "' . $ptr . '" does not resolve to ' . $ip . '. Configure the A/AAAA record with your DNS provider first, then try again.'], true, true, 400);
+                    break;
+                case 'rate-limited':
+                    $vf->output(['success' => false, 'errors' => 'Too many updates for this IP. Try again in a few seconds.'], true, true, 429);
+                    break;
+                case 'no-zone':
+                    $vf->output(['success' => false, 'errors' => 'This IP has no reverse DNS zone configured on the nameserver.'], true, true, 400);
+                    break;
+                case 'disabled':
+                    $vf->output(['success' => false, 'errors' => 'Reverse DNS is not enabled'], true, true, 400);
+                    break;
+                default:
+                    $vf->output(['success' => false, 'errors' => 'Reverse DNS update failed (' . $result['reason'] . ')'], true, true, 500);
+            }
+            break;
+
+        default:
+            $vf->output(['success' => false, 'errors' => 'invalid action'], true, true, 400);
+    }
+
+} catch (Exception $e) {
+    Log::insert('client.php', [], $e->getMessage());
+    $vf->output(['success' => false, 'errors' => 'An unexpected error occurred'], true, true, 500);
 }
-
-

modules/servers/VirtFusionDirect/config/ConfigOptionMapping-example.php

@@ -1,7 +1,7 @@
 <?php
 
-if (!defined("WHMCS")) {
+if (! defined('WHMCS')) {
-    die("This file cannot be accessed directly");
+    exit('This file cannot be accessed directly');
 }
 
 return [
@@ -16,4 +16,4 @@ return [
     'cpuCores' => 'CPU Cores',
     'networkProfile' => 'Network Type',
     'storageProfile' => 'Storage Type',
-];
+];

modules/servers/VirtFusionDirect/hooks.php

@@ -1,123 +1,632 @@
 <?php
 
-use WHMCS\Module\Server\VirtFusionDirect\ConfigureService;
+/**
-use WHMCS\User\User;
+ * WHMCS hooks for the VirtFusion module.
+ *
+ * HOW HOOKS WORK IN WHMCS
+ * -----------------------
+ * add_hook('EventName', $priority, $callback) registers $callback to fire on
+ * the named event. WHMCS discovers hook files by walking modules/servers/*
+ * /hooks.php and modules/addons/* /hooks.php on every page load, then invokes
+ * every registered hook for the current event.
+ *
+ * Hooks run IN-REQUEST — there's no queue or background worker. Anything
+ * expensive in a hook (like an external API call) blocks the user's page
+ * load. For that reason we only do:
+ *   - Fast in-process work (building DOM snippets, validating session state)
+ *   - Scheduled work on DailyCronJob where "in-request" means the cron worker,
+ *     not a user session
+ *
+ * HOOKS REGISTERED HERE
+ * ---------------------
+ *   DailyCronJob                — PowerDNS reconciliation across all services
+ *   ShoppingCartValidateCheckout — blocks checkout until OS is selected
+ *   ClientAreaFooterOutput      — injects the OS/SSH-key gallery on order form
+ *
+ * FAILURE SEMANTICS
+ * -----------------
+ * Every hook wraps its body in try/catch and silently absorbs any exception.
+ * A hook that throws would potentially break the entire WHMCS request for
+ * all users, not just this module — so we log and swallow, preferring
+ * degraded functionality over site-wide breakage.
+ */
 
-if (!defined("WHMCS")) {
+use WHMCS\Database\Capsule;
-    die("This file cannot be accessed directly");
+use WHMCS\Module\Server\VirtFusionDirect\ConfigureService;
+use WHMCS\Module\Server\VirtFusionDirect\Database;
+use WHMCS\Module\Server\VirtFusionDirect\Log;
+use WHMCS\Module\Server\VirtFusionDirect\Module;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\Config as PowerDnsConfig;
+use WHMCS\Module\Server\VirtFusionDirect\PowerDns\PtrManager;
+
+if (! defined('WHMCS')) {
+    exit('This file cannot be accessed directly');
 }
 
-add_hook('ClientAreaFooterOutput', 1, function ($vars) {
+/**
-    if (!isset($vars['productinfo']['module']) || $vars['productinfo']['module'] !== 'VirtFusionDirect') {
+ * Daily PowerDNS reconciliation.
-        return null;
+ *
-    }
+ * Walks every managed service and creates any missing PTRs (never overwrites existing
-
+ * values — cron is additive-only). Requires the VirtFusion DNS addon to be activated
-    $cs = new ConfigureService();
+ * and enabled; otherwise short-circuits immediately.
-
+ *
-    $templates_data = $cs->fetchTemplates(
+ * All error handling lives inside reconcileAll(); this wrapper just logs any escape
-        $cs->fetchPackageByDbId($vars['productinfo']['pid']) ?? $cs->fetchPackageId($vars['productinfo']['name'])
+ * without disturbing the rest of the daily cron run.
-    );
+ */
-
+add_hook('DailyCronJob', 1, function ($vars) {
-    if (empty($templates_data)) {
+    try {
-        return null;
+        if (PowerDnsConfig::isEnabled()) {
-    }
+            (new PtrManager)->reconcileAll();
-
-    $dropdownOptions = [];
-
-    foreach ($templates_data['data'] as $osCategory) {
-        foreach ($osCategory['templates'] as $template) {
-            $optionValue = $template['id'];
-            $optionLabel = $template['name'] . " " . $template['version'] . " " . $template['variant'];
-            $dropdownOptions[] = ['id' => $optionValue, 'name' => $optionLabel];
         }
+    } catch (Throwable $e) {
+        Log::insert('PowerDns:DailyCronJob', [], $e->getMessage());
+    }
+});
+
+/**
+ * Shopping Cart Validation Hook
+ *
+ * Validates that an operating system has been selected before checkout
+ * for all VirtFusion products in the cart.
+ */
+add_hook('ShoppingCartValidateCheckout', 1, function ($vars) {
+    $errors = [];
+
+    try {
+        if (! isset($_SESSION['cart']['products']) || ! is_array($_SESSION['cart']['products'])) {
+            return $errors;
+        }
+
+        foreach ($_SESSION['cart']['products'] as $key => $product) {
+            $pid = $product['pid'] ?? null;
+            if (! $pid) {
+                continue;
+            }
+
+            $dbProduct = Capsule::table('tblproducts')
+                ->where('id', $pid)
+                ->where('servertype', 'VirtFusionDirect')
+                ->first();
+
+            if (! $dbProduct) {
+                continue;
+            }
+
+            // Check if Initial Operating System custom field has a value
+            if (isset($product['customfields']) && is_array($product['customfields'])) {
+                $osSelected = false;
+                $customFields = Capsule::table('tblcustomfields')
+                    ->where('relid', $pid)
+                    ->where('type', 'product')
+                    ->get();
+
+                foreach ($customFields as $field) {
+                    if (strtolower(str_replace(' ', '', $field->fieldname)) === 'initialoperatingsystem') {
+                        $fieldValue = $product['customfields'][$field->id] ?? '';
+                        if (! empty($fieldValue) && is_numeric($fieldValue)) {
+                            $osSelected = true;
+                        }
+                        break;
+                    }
+                }
+
+                if (! $osSelected) {
+                    $errors[] = 'Please select an Operating System for your VPS order.';
+                }
+            }
+        }
+    } catch (Exception $e) {
+        // Don't block checkout on internal errors
     }
 
-    // Sort dropdownOptions alphabetically by the 'name' key
+    return $errors;
-    usort($dropdownOptions, function ($a, $b) {
+});
-        return strcmp($a['name'], $b['name']);
-    });
 
-    $sshKeys = $cs->getUserSshKeys($vars['loggedinuser']);
+/**
-    $sshKeysOptions = array_map(function ($sshKey) {
+ * Client Area Footer Output Hook
-        if ($sshKey['enabled'] === false) {
+ *
+ * Dynamically converts hidden text fields for OS templates and SSH keys
+ * into dropdown selects populated from the VirtFusion API.
+ * Works with all WHMCS themes by using vanilla JavaScript and standard form-control classes.
+ */
+add_hook('ClientAreaFooterOutput', 1, function ($vars) {
+    if (! isset($vars['productinfo']['module']) || $vars['productinfo']['module'] !== 'VirtFusionDirect') {
+        return null;
+    }
+
+    try {
+        $cs = new ConfigureService;
+
+        $templates_data = $cs->fetchTemplates(
+            $cs->fetchPackageByDbId($vars['productinfo']['pid']) ?? $cs->fetchPackageId($vars['productinfo']['name']),
+        );
+
+        if (empty($templates_data)) {
             return null;
         }
 
-        return [
+        $vfServer = Capsule::table('tblservers')
-            'id' => $sshKey['id'],
+            ->where('type', 'VirtFusionDirect')
-            'name' => $sshKey['name']
+            ->where('disabled', 0)
+            ->first();
+        $baseUrl = $vfServer ? rtrim('https://' . $vfServer->hostname, '/') : '';
+
+        $galleryData = [
+            'baseUrl' => $baseUrl,
+            'categories' => Module::groupOsTemplates($templates_data['data'] ?? [], true),
         ];
-    }, $sshKeys['data'] ?? []);
 
-    $osID = array_values(array_filter(array_map(function ($option) {
+        $sshKeys = [];
-        if ($option['textid'] === 'initialoperatingsystem') {
+        $sshKeysOptions = [];
-            return $option['id'];
+        if (isset($vars['loggedinuser']) && $vars['loggedinuser']) {
+            $sshKeysData = $cs->getUserSshKeys($vars['loggedinuser']);
+            if ($sshKeysData && isset($sshKeysData['data'])) {
+                $sshKeysOptions = array_values(array_filter(array_map(function ($sshKey) {
+                    if ($sshKey['enabled'] === false) {
+                        return null;
+                    }
+
+                    return [
+                        'id' => $sshKey['id'],
+                        'name' => htmlspecialchars($sshKey['name'], ENT_QUOTES, 'UTF-8'),
+                    ];
+                }, $sshKeysData['data'])));
+            }
         }
-    }, $vars['customfields'])));
 
-    $sshID = array_values(array_filter(array_map(function ($option) {
+        $osID = array_values(array_filter(array_map(function ($option) {
-        if ($option['textid'] === 'initialsshkey') {
+            if ($option['textid'] === 'initialoperatingsystem') {
-            return $option['id'];
+                return $option['id'];
+            }
+        }, $vars['customfields'] ?? [])));
+
+        $sshID = array_values(array_filter(array_map(function ($option) {
+            if ($option['textid'] === 'initialsshkey') {
+                return $option['id'];
+            }
+        }, $vars['customfields'] ?? [])));
+
+        $osFieldId = $osID[0] ?? null;
+        $sshFieldId = $sshID[0] ?? null;
+
+        if ($osFieldId === null) {
+            return null;
         }
-    }, $vars['customfields'])));
 
-    // Construct the JavaScript code
+        $systemUrl = Database::getSystemUrl();
-    return "
+
+        return '
+    <link href="' . htmlspecialchars($systemUrl, ENT_QUOTES, 'UTF-8') . 'modules/servers/VirtFusionDirect/templates/css/module.css?v=' . time() . '" rel="stylesheet">
+    <script src="' . htmlspecialchars($systemUrl, ENT_QUOTES, 'UTF-8') . 'modules/servers/VirtFusionDirect/templates/js/keygen.js?v=' . time() . "\"></script>
     <script>
     document.addEventListener('DOMContentLoaded', function() {
-        var osTemplates = " . json_encode($dropdownOptions) . ";
+        var osGalleryData = " . json_encode($galleryData, JSON_THROW_ON_ERROR | JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT) . ';
-        var sshKeys = " . json_encode($sshKeysOptions) . ";
+        var sshKeys = ' . json_encode($sshKeysOptions, JSON_THROW_ON_ERROR | JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT) . ";
 
-        var osInputField = document.querySelector('[name=\"customfield[" . ($osID[0] ?? null) . "]\"]');
+        var osInputField = document.querySelector('[name=\"customfield[" . (int) $osFieldId . "]\"]');
-        var sshInputField = document.querySelector('[name=\"customfield[" . ($sshID[0] ?? null) . "]\"]');
+        var sshInputField = " . ($sshFieldId !== null ? "document.querySelector('[name=\"customfield[" . (int) $sshFieldId . "]\"]')" : 'null') . ';
-        
+        var sshInputLabel = ' . ($sshFieldId !== null ? "document.querySelector('[for=\"customfield" . (int) $sshFieldId . "\"]')" : 'null') . ";
-        // Create dropdown options menu, then add it to the DOM then on change, update the regular input.
-        var osSelect = document.createElement('select');
-        osSelect.className = 'form-control';
 
-        osTemplates.forEach(function(template) {
+        if (!osInputField) return;
-            var option = document.createElement('option');
+
-            option.value = template.id;
+        // Brand color map (must match vfOsBrandColors in module.js)
-            option.text = template.name;
+        var brandColors = {
-            osSelect.appendChild(option);
+            'ubuntu':'#E95420','debian':'#A81D33','rocky':'#10B981','centos':'#932279',
+            'almalinux':'#0F4266','alma':'#0F4266','windows':'#0078D4','fedora':'#51A2DA',
+            'arch':'#1793D1','opensuse':'#73BA25','suse':'#73BA25','freebsd':'#AB2B28',
+            'oracle':'#F80000','rhel':'#EE0000','red hat':'#EE0000','cloudlinux':'#0095D9',
+            'gentoo':'#54487A','slackware':'#000','nixos':'#7EBAE4','alpine':'#0D597F'
+        };
+        function getBrandColor(name) {
+            var l = (name || '').toLowerCase();
+            for (var k in brandColors) { if (l.indexOf(k) !== -1) return brandColors[k]; }
+            return '#6c757d';
+        }
+
+        // Build gallery container
+        var galleryWrap = document.createElement('div');
+        galleryWrap.style.marginTop = '8px';
+
+        var searchInput = document.createElement('input');
+        searchInput.type = 'text';
+        searchInput.className = 'form-control vf-os-search';
+        searchInput.placeholder = 'Search templates...';
+        galleryWrap.appendChild(searchInput);
+
+        var galleryContainer = document.createElement('div');
+        galleryContainer.setAttribute('id', 'vf-checkout-os-gallery');
+        galleryContainer.style.marginTop = '8px';
+
+        if (osGalleryData.categories && osGalleryData.categories.length > 0) {
+            osGalleryData.categories.forEach(function(cat, ci) {
+                var section = document.createElement('div');
+                section.className = 'vf-os-category';
+
+                var header = document.createElement('div');
+                header.className = 'vf-os-category-header';
+                var catColor = getBrandColor(cat.name);
+
+                var catIcon = document.createElement('span');
+                catIcon.className = 'vf-os-category-icon';
+                if (cat.icon && osGalleryData.baseUrl) {
+                    var catImg = document.createElement('img');
+                    catImg.src = osGalleryData.baseUrl + '/img/logo/' + encodeURIComponent(cat.icon);
+                    catImg.alt = '';
+                    catImg.onerror = function() { this.parentNode.style.background = catColor; this.parentNode.textContent = (cat.name || '?')[0].toUpperCase(); };
+                    catIcon.appendChild(catImg);
+                } else if (cat.name === 'Other') {
+                    catIcon.style.background = '#6c757d';
+                    catIcon.innerHTML = '<svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"#fff\"><path d=\"M3 2a1 1 0 0 0-1 1v10a1 1 0 0 0 1 1h10a1 1 0 0 0 1-1V3a1 1 0 0 0-1-1H3zm1 2h8v2H4V4zm0 3h8v1H4V7zm0 2h5v1H4V9z\"/></svg>';
+                } else {
+                    catIcon.style.background = catColor;
+                    catIcon.textContent = (cat.name || '?')[0].toUpperCase();
+                }
+
+                var catTitle = document.createElement('span');
+                catTitle.textContent = cat.name + ' (' + cat.templates.length + ')';
+
+                var arrow = document.createElement('span');
+                arrow.className = 'vf-os-category-arrow';
+                arrow.textContent = ci === 0 ? '\u25BC' : '\u25B6';
+
+                header.appendChild(catIcon);
+                header.appendChild(catTitle);
+                header.appendChild(arrow);
+                section.appendChild(header);
+
+                var grid = document.createElement('div');
+                grid.className = 'vf-os-grid';
+                if (ci !== 0) grid.style.display = 'none';
+
+                header.addEventListener('click', function() {
+                    var isOpen = grid.style.display !== 'none';
+                    // Collapse all
+                    galleryContainer.querySelectorAll('.vf-os-grid').forEach(function(g) { g.style.display = 'none'; });
+                    galleryContainer.querySelectorAll('.vf-os-category-arrow').forEach(function(a) { a.textContent = '\u25B6'; });
+                    // Toggle this one
+                    if (!isOpen) {
+                        grid.style.display = '';
+                        arrow.textContent = '\u25BC';
+                    }
+                });
+
+                cat.templates.forEach(function(tpl) {
+                    var fullLabel = tpl.name + (tpl.version ? ' ' + tpl.version : '') + (tpl.variant ? ' ' + tpl.variant : '');
+                    var card = document.createElement('div');
+                    card.className = 'vf-os-card' + (tpl.eol ? ' vf-os-card-eol' : '');
+                    card.setAttribute('data-id', tpl.id);
+                    card.setAttribute('data-search', fullLabel.toLowerCase());
+
+                    var iconDiv = document.createElement('div');
+                    iconDiv.className = 'vf-os-icon';
+                    if (tpl.icon && osGalleryData.baseUrl) {
+                        var tplImg = document.createElement('img');
+                        tplImg.src = osGalleryData.baseUrl + '/img/logo/' + encodeURIComponent(tpl.icon);
+                        tplImg.alt = '';
+                        tplImg.onerror = function() { this.parentNode.style.background = catColor; this.parentNode.textContent = ''; var s = document.createElement('span'); s.textContent = (tpl.name || '?')[0].toUpperCase(); this.parentNode.appendChild(s); };
+                        iconDiv.appendChild(tplImg);
+                    } else {
+                        iconDiv.style.background = catColor;
+                        var sp = document.createElement('span');
+                        sp.textContent = (tpl.name || '?')[0].toUpperCase();
+                        iconDiv.appendChild(sp);
+                    }
+                    card.appendChild(iconDiv);
+
+                    var labelDiv = document.createElement('div');
+                    labelDiv.className = 'vf-os-label';
+                    labelDiv.textContent = tpl.name;
+                    card.appendChild(labelDiv);
+
+                    var verDiv = document.createElement('div');
+                    verDiv.className = 'vf-os-version';
+                    verDiv.textContent = (tpl.version || '') + (tpl.variant ? ' ' + tpl.variant : '');
+                    card.appendChild(verDiv);
+
+                    if (tpl.eol) {
+                        var eolBadge = document.createElement('span');
+                        eolBadge.className = 'vf-os-eol-badge';
+                        eolBadge.textContent = 'EOL';
+                        card.appendChild(eolBadge);
+                    }
+
+                    card.addEventListener('click', function() {
+                        galleryContainer.querySelectorAll('.vf-os-card').forEach(function(c) { c.classList.remove('vf-os-card-selected'); });
+                        card.classList.add('vf-os-card-selected');
+                        osInputField.value = tpl.id;
+                        galleryContainer.style.borderColor = '';
+                    });
+
+                    grid.appendChild(card);
+                });
+
+                section.appendChild(grid);
+                galleryContainer.appendChild(section);
+            });
+        }
+
+        galleryWrap.appendChild(galleryContainer);
+
+        // Search handler
+        searchInput.addEventListener('keyup', function() {
+            var q = this.value.toLowerCase();
+            galleryContainer.querySelectorAll('.vf-os-card').forEach(function(c) {
+                c.style.display = c.getAttribute('data-search').indexOf(q) !== -1 ? '' : 'none';
+            });
+            galleryContainer.querySelectorAll('.vf-os-category').forEach(function(s) {
+                var cards = s.querySelectorAll('.vf-os-card');
+                var hasVisible = false;
+                cards.forEach(function(c) { if (c.style.display !== 'none') hasVisible = true; });
+                s.style.display = hasVisible ? '' : 'none';
+            });
         });
-        
+
-        // Set the default value of the input field to the first option in the dropdown.
+        // Validation: red border if no selection on form submit
-        osInputField.value = osSelect.options[0].value;
+        var form = osInputField.closest('form');
-        
+        if (form) {
-        osSelect.addEventListener('change', function() {
+            form.addEventListener('submit', function(e) {
-            osInputField.value = this.value;
+                if (!osInputField.value) {
-            console.log(this.value);
+                    galleryContainer.style.border = '2px solid #dc3545';
-        });
+                    galleryContainer.style.borderRadius = '8px';
-        
+                    galleryContainer.style.padding = '4px';
-        osInputField.parentNode.insertBefore(osSelect, osInputField.nextSibling);
+                    galleryContainer.scrollIntoView({behavior: 'smooth', block: 'center'});
+                }
+            });
+        }
+
+        osInputField.parentNode.insertBefore(galleryWrap, osInputField.nextSibling);
         osInputField.style.display = 'none';
-        
+
-        if (sshKeys.length > 0) {
+        // Handle SSH keys
-            // Create dropdown options menu, then add it to the DOM then on change, update the regular input.
+        if (sshInputField) {
-            var sshSelect = document.createElement('select');
+            // Create the paste-key textarea (hidden initially if keys exist)
-            sshSelect.className = 'form-control';
+            var sshPasteContainer = document.createElement('div');
-    
+            sshPasteContainer.setAttribute('id', 'vf-ssh-paste-container');
-            sshKeys.forEach(function(sshkey) {
+            sshPasteContainer.style.display = 'none';
-                var option = document.createElement('option');
+            sshPasteContainer.style.marginTop = '8px';
-                option.value = sshkey.id;
+
-                option.text = sshkey.name;
+            var pasteLabel = document.createElement('label');
-                sshSelect.appendChild(option);
+            pasteLabel.textContent = 'Paste your SSH public key:';
+            pasteLabel.style.display = 'block';
+            pasteLabel.style.marginBottom = '4px';
+
+            var pasteArea = document.createElement('textarea');
+            pasteArea.className = 'form-control';
+            pasteArea.setAttribute('id', 'vf-ssh-paste');
+            pasteArea.setAttribute('rows', '3');
+            pasteArea.setAttribute('placeholder', 'ssh-rsa AAAA... or ssh-ed25519 AAAA...');
+
+            pasteArea.addEventListener('input', function() {
+                sshInputField.value = this.value.trim();
             });
-            
+
-            // Set the default value of the input field to the first option in the dropdown.
+            sshPasteContainer.appendChild(pasteLabel);
-            sshInputField.value = sshSelect.options[0].value;
+            sshPasteContainer.appendChild(pasteArea);
-            
+
-            sshSelect.addEventListener('change', function() {
+            // Generate key button
-                sshInputField.value = this.value;
+            var generateBtn = document.createElement('button');
+            generateBtn.type = 'button';
+            generateBtn.className = 'btn btn-outline-secondary btn-sm';
+            generateBtn.textContent = 'Generate a new key';
+            generateBtn.style.marginTop = '8px';
+
+            // Private key panel (hidden initially)
+            var privKeyPanel = document.createElement('div');
+            privKeyPanel.setAttribute('id', 'vf-privkey-panel');
+            privKeyPanel.style.display = 'none';
+            privKeyPanel.style.marginTop = '12px';
+            privKeyPanel.style.border = '2px solid #dc3545';
+            privKeyPanel.style.borderRadius = '6px';
+            privKeyPanel.style.padding = '12px';
+
+            var privKeyWarning = document.createElement('div');
+            privKeyWarning.style.color = '#dc3545';
+            privKeyWarning.style.fontWeight = 'bold';
+            privKeyWarning.style.marginBottom = '8px';
+            privKeyWarning.textContent = 'Private Key — Save This Now! It will not be shown again.';
+
+            var privKeyArea = document.createElement('textarea');
+            privKeyArea.className = 'form-control';
+            privKeyArea.setAttribute('rows', '6');
+            privKeyArea.setAttribute('readonly', 'readonly');
+            privKeyArea.style.fontFamily = 'monospace';
+            privKeyArea.style.fontSize = '12px';
+            privKeyArea.style.marginBottom = '8px';
+
+            var privKeyBtnRow = document.createElement('div');
+            privKeyBtnRow.style.display = 'flex';
+            privKeyBtnRow.style.gap = '8px';
+            privKeyBtnRow.style.alignItems = 'center';
+            privKeyBtnRow.style.flexWrap = 'wrap';
+
+            var downloadBtn = document.createElement('button');
+            downloadBtn.type = 'button';
+            downloadBtn.className = 'btn btn-primary btn-sm';
+            downloadBtn.textContent = 'Download';
+
+            var copyBtn = document.createElement('button');
+            copyBtn.type = 'button';
+            copyBtn.className = 'btn btn-default btn-secondary btn-sm';
+            copyBtn.textContent = 'Copy to Clipboard';
+
+            var pubKeyConfirm = document.createElement('span');
+            pubKeyConfirm.style.color = '#28a745';
+            pubKeyConfirm.style.fontWeight = 'bold';
+            pubKeyConfirm.textContent = 'Public key set automatically.';
+
+            privKeyBtnRow.appendChild(downloadBtn);
+            privKeyBtnRow.appendChild(copyBtn);
+            privKeyBtnRow.appendChild(pubKeyConfirm);
+            privKeyPanel.appendChild(privKeyWarning);
+            privKeyPanel.appendChild(privKeyArea);
+            privKeyPanel.appendChild(privKeyBtnRow);
+
+            downloadBtn.addEventListener('click', function() {
+                vfDownloadFile('id_ed25519', privKeyArea.value);
             });
-            
+
-            sshInputField.parentNode.insertBefore(sshSelect, sshInputField.nextSibling);
+            copyBtn.addEventListener('click', function() {
-            sshInputField.style.display = 'none';
+                navigator.clipboard.writeText(privKeyArea.value).then(function() {
-        } else {
+                    copyBtn.textContent = 'Copied!';
-            sshInputField.style.display = 'none';
+                    setTimeout(function() { copyBtn.textContent = 'Copy to Clipboard'; }, 2000);
-        }   
+                });
+            });
+
+            // Error message for unsupported browsers
+            var genErrorMsg = document.createElement('div');
+            genErrorMsg.style.display = 'none';
+            genErrorMsg.style.marginTop = '8px';
+            genErrorMsg.style.color = '#dc3545';
+            genErrorMsg.textContent = 'Your browser does not support Ed25519 key generation. Please paste your public key manually.';
+
+            generateBtn.addEventListener('click', async function() {
+                generateBtn.disabled = true;
+                generateBtn.textContent = 'Generating...';
+                try {
+                    var keys = await vfGenerateSSHKey();
+                    var sshSelect = document.getElementById('vf-ssh-select');
+                    if (sshSelect) {
+                        sshSelect.value = '__new__';
+                        sshPasteContainer.style.display = 'block';
+                    }
+                    pasteArea.value = keys.publicKey;
+                    sshInputField.value = keys.publicKey;
+                    privKeyArea.value = keys.privateKey;
+                    privKeyPanel.style.display = 'block';
+                    genErrorMsg.style.display = 'none';
+                } catch (e) {
+                    genErrorMsg.style.display = 'block';
+                    privKeyPanel.style.display = 'none';
+                } finally {
+                    generateBtn.disabled = false;
+                    generateBtn.textContent = 'Generate a new key';
+                }
+            });
+
+            if (sshKeys.length > 0) {
+                var sshSelect = document.createElement('select');
+                sshSelect.className = 'form-control';
+                sshSelect.setAttribute('id', 'vf-ssh-select');
+
+                var sshDefaultOption = document.createElement('option');
+                sshDefaultOption.value = '';
+                sshDefaultOption.text = '-- No SSH Key (Optional) --';
+                sshSelect.appendChild(sshDefaultOption);
+
+                sshKeys.forEach(function(sshkey) {
+                    var option = document.createElement('option');
+                    option.value = sshkey.id;
+                    option.text = sshkey.name;
+                    sshSelect.appendChild(option);
+                });
+
+                // Add new key option
+                var addNewOption = document.createElement('option');
+                addNewOption.value = '__new__';
+                addNewOption.text = 'Add new key...';
+                sshSelect.appendChild(addNewOption);
+
+                sshSelect.addEventListener('change', function() {
+                    if (this.value === '__new__') {
+                        sshPasteContainer.style.display = 'block';
+                        sshInputField.value = '';
+                    } else {
+                        sshPasteContainer.style.display = 'none';
+                        document.getElementById('vf-ssh-paste').value = '';
+                        sshInputField.value = this.value;
+                    }
+                });
+
+                sshInputField.parentNode.insertBefore(sshSelect, sshInputField.nextSibling);
+                sshSelect.parentNode.insertBefore(sshPasteContainer, sshSelect.nextSibling);
+                sshPasteContainer.parentNode.insertBefore(generateBtn, sshPasteContainer.nextSibling);
+                generateBtn.parentNode.insertBefore(genErrorMsg, generateBtn.nextSibling);
+                genErrorMsg.parentNode.insertBefore(privKeyPanel, genErrorMsg.nextSibling);
+                sshInputField.style.display = 'none';
+            } else {
+                // No existing keys — show the paste textarea directly
+                sshPasteContainer.style.display = 'block';
+                sshInputField.parentNode.insertBefore(sshPasteContainer, sshInputField.nextSibling);
+                sshPasteContainer.parentNode.insertBefore(generateBtn, sshPasteContainer.nextSibling);
+                generateBtn.parentNode.insertBefore(genErrorMsg, generateBtn.nextSibling);
+                genErrorMsg.parentNode.insertBefore(privKeyPanel, genErrorMsg.nextSibling);
+                sshInputField.style.display = 'none';
+            }
+        }
+
+        // Slider UI: enhance known configurable option selects with range sliders
+        var sliderResourceNames = ['Memory', 'CPU Cores', 'Storage', 'Bandwidth', 'Inbound Network Speed', 'Outbound Network Speed'];
+        var sliderUnits = {
+            'Memory': 'MB', 'CPU Cores': 'Core(s)', 'Storage': 'GB',
+            'Bandwidth': 'GB', 'Inbound Network Speed': 'Mbps', 'Outbound Network Speed': 'Mbps'
+        };
+
+        var configSelects = document.querySelectorAll('select[name^=\"configoption[\"]');
+        configSelects.forEach(function(sel) {
+            // Find the label for this select
+            var label = null;
+            var labelEl = sel.closest('.form-group, .row');
+            if (labelEl) {
+                label = labelEl.querySelector('label');
+            }
+            if (!label) return;
+
+            var labelText = label.textContent.trim();
+            var matchedResource = null;
+            sliderResourceNames.forEach(function(name) {
+                if (labelText.indexOf(name) !== -1) {
+                    matchedResource = name;
+                }
+            });
+            if (!matchedResource) return;
+
+            var options = [];
+            for (var i = 0; i < sel.options.length; i++) {
+                options.push({
+                    value: sel.options[i].value,
+                    label: sel.options[i].text
+                });
+            }
+            if (options.length < 2) return;
+
+            var unit = sliderUnits[matchedResource] || '';
+
+            // Create slider container
+            var container = document.createElement('div');
+            container.className = 'vf-slider-container';
+
+            var valueDisplay = document.createElement('div');
+            valueDisplay.className = 'vf-slider-value';
+            valueDisplay.textContent = options[sel.selectedIndex || 0].label + (unit ? ' ' + unit : '');
+
+            var slider = document.createElement('input');
+            slider.type = 'range';
+            slider.className = 'vf-slider form-range';
+            slider.min = '0';
+            slider.max = String(options.length - 1);
+            slider.step = '1';
+            slider.value = String(sel.selectedIndex || 0);
+
+            slider.addEventListener('input', function() {
+                var idx = parseInt(this.value);
+                sel.selectedIndex = idx;
+                valueDisplay.textContent = options[idx].label + (unit ? ' ' + unit : '');
+                // Trigger change event on hidden select for WHMCS pricing
+                var evt = new Event('change', { bubbles: true });
+                sel.dispatchEvent(evt);
+            });
+
+            container.appendChild(valueDisplay);
+            container.appendChild(slider);
+
+            sel.parentNode.insertBefore(container, sel.nextSibling);
+            sel.style.display = 'none';
+        });
     });
     </script>
     ";
-});
+    } catch (Throwable $e) {
+        // Silently fail - don't break the checkout page
+        return null;
+    }
+});

modules/servers/VirtFusionDirect/lib/AdminHTML.php

@@ -2,38 +2,97 @@
 
 namespace WHMCS\Module\Server\VirtFusionDirect;
 
+/**
+ * Static methods that generate HTML fragments for the WHMCS admin services tab.
+ *
+ * WHY RAW HTML STRINGS INSTEAD OF TEMPLATES
+ * -----------------------------------------
+ * WHMCS's AdminServicesTabFields hook expects an associative array of
+ * label => HTML-string pairs. It renders each entry as a table row with the
+ * label on the left and the raw HTML inserted verbatim on the right. There's
+ * no way to return a Smarty template reference from that hook — WHMCS doesn't
+ * know how to render one in that context.
+ *
+ * So we concatenate HTML here. All variable interpolation uses htmlspecialchars()
+ * at the PHP boundary — never trust that a value passed in is safe for HTML.
+ *
+ * ASSET INJECTION
+ * ---------------
+ * Some renderers (serverInfo, rdnsSection) embed <link> and <script> tags so
+ * the admin services tab picks up our CSS and JS without a separate loader
+ * hook. This is safe because WHMCS's admin CSP allows same-origin resources
+ * and the admin page is already inside an authenticated admin session.
+ *
+ * Cache-busting uses time() as a query string — fine for an admin-only surface
+ * where we'd rather pay for the extra fetch than let stale JS cause bugs.
+ */
 class AdminHTML
 {
-
+    /**
+     * Render the "Impersonate Server Owner" button for the admin services tab.
+     *
+     * @param  string  $systemUrl  WHMCS system URL
+     * @param  int  $serviceId  VirtFusion server ID
+     * @return string HTML button markup
+     */
     public static function options($systemUrl, $serviceId)
     {
+        $systemUrl = htmlspecialchars($systemUrl, ENT_QUOTES, 'UTF-8');
+
         return <<<EOT
             <button onclick="impersonateServerOwner('${serviceId}', '${systemUrl}')" type="button" class="btn btn-primary">Impersonate Server Owner</button>
             <span class="text-info">&nbsp;&nbsp;A valid VirtFusion admin session in the same browser is required for this functionality to work.</span>
 EOT;
     }
 
+    /**
+     * Render a read-only textarea containing the raw VirtFusion server JSON object.
+     *
+     * @param  string  $serverObject  JSON-encoded server object from the VirtFusion API
+     * @return string HTML textarea markup
+     */
     public static function serverObject($serverObject)
     {
+        $serverObject = htmlspecialchars($serverObject, ENT_QUOTES, 'UTF-8');
+
         return <<<EOT
             <textarea class="form-control" name="modulefields[1]" rows="10" style="width: 100%" disabled>${serverObject}</textarea>
 EOT;
 
     }
 
+    /**
+     * Render an editable text input for the VirtFusion server ID field.
+     *
+     * @param  int  $serverId  Current VirtFusion server ID
+     * @return string HTML input markup with a warning note
+     */
     public static function serverId($serverId)
     {
+        $serverId = (int) $serverId;
+
         return <<<EOT
             <input type="text" class="form-control input-200 input-inline" name="modulefields[0]" size="20" value="${serverId}" />
             <span class="text-info">&nbsp;&nbsp;Changing the Sever ID manually is not recommended. Alterations to this field are usually handled automatically.</span>
 EOT;
     }
 
+    /**
+     * Render the inline server info panel for the admin services tab, including CSS/JS assets.
+     *
+     * @param  string  $systemUrl  WHMCS system URL (used to build asset and AJAX URLs)
+     * @param  int  $serviceId  VirtFusion server ID passed to the JS data-loader
+     * @return string HTML panel markup with embedded script and asset tags
+     */
     public static function serverInfo($systemUrl, $serviceId)
     {
+        $systemUrl = htmlspecialchars($systemUrl, ENT_QUOTES, 'UTF-8');
+        $serviceId = (int) $serviceId;
+        $cacheV = time();
+
         return <<<EOT
-            <link href="${systemUrl}modules/servers/VirtFusionDirect/templates/css/module.css" rel="stylesheet">
+            <link href="${systemUrl}modules/servers/VirtFusionDirect/templates/css/module.css?v=${cacheV}" rel="stylesheet">
-            <script src="${systemUrl}modules/servers/VirtFusionDirect/templates/js/module.js"></script>
+            <script src="${systemUrl}modules/servers/VirtFusionDirect/templates/js/module.js?v=${cacheV}"></script>
             <div id="vf-loader" class="vf-loader">
                <div id="vf-loading"></div>
             </div>
@@ -111,4 +170,36 @@ EOT;
             <script>vfServerDataAdmin("${serviceId}","${systemUrl}");</script>
 EOT;
     }
-}
+
+    /**
+     * Render the admin Reverse DNS section for the services tab.
+     *
+     * Ships an empty container + a Reconcile button. Data is loaded client-side via
+     * the admin rdnsStatus AJAX endpoint once the page opens. The JS function
+     * vfAdminLoadRdns (defined in templates/js/module.js) populates #vf-rdns-list
+     * and wires up the Reconcile button's onclick to admin.php?action=rdnsReconcile.
+     *
+     * @param  string  $systemUrl  WHMCS system URL
+     * @param  int  $serviceId  WHMCS service ID
+     * @return string HTML fragment for the admin services tab
+     */
+    public static function rdnsSection($systemUrl, $serviceId)
+    {
+        $systemUrl = htmlspecialchars($systemUrl, ENT_QUOTES, 'UTF-8');
+        $serviceId = (int) $serviceId;
+
+        return <<<EOT
+            <div id="vf-rdns-admin-wrap">
+                <div id="vf-rdns-list" class="vf-rdns-list">
+                    <em class="text-muted">Loading reverse DNS…</em>
+                </div>
+                <div class="vf-rdns-actions" style="margin-top:10px">
+                    <button type="button" class="btn btn-default btn-sm" onclick="vfAdminReconcileRdns(${serviceId}, '${systemUrl}', false)">Reconcile (additive)</button>
+                    <button type="button" class="btn btn-warning btn-sm" onclick="vfAdminReconcileRdns(${serviceId}, '${systemUrl}', true)">Reconcile (force reset)</button>
+                    <span id="vf-rdns-report" style="margin-left:10px"></span>
+                </div>
+            </div>
+            <script>if(typeof vfAdminLoadRdns==='function'){vfAdminLoadRdns(${serviceId},"${systemUrl}");}</script>
+EOT;
+    }
+}

modules/servers/VirtFusionDirect/lib/Cache.php

@@ -0,0 +1,226 @@
+<?php
+
+namespace WHMCS\Module\Server\VirtFusionDirect;
+
+/**
+ * Two-tier cache: Redis when ext-redis is available, atomic filesystem fallback otherwise.
+ *
+ * WHY TWO TIERS
+ * -------------
+ * The module is deployed to every kind of WHMCS install — shared hosting, dedicated
+ * VPS, bare-metal. Requiring Redis would exclude the long tail of smaller operators
+ * who never installed the extension. But operators who DO have Redis get a huge
+ * performance win for cross-request caching (PowerDNS zone lists, OS template
+ * listings, traffic stats), so we opportunistically use it when present.
+ *
+ * The fallback is filesystem-based, using the OS temp directory. Writes are atomic
+ * via the classic tmp-file + rename pattern so a process crash mid-write can never
+ * corrupt an existing cache entry for another concurrent reader.
+ *
+ * EXPIRY SEMANTICS
+ * ----------------
+ * Redis: native SETEX — the key auto-expires on the server side.
+ * Filesystem: we store a JSON envelope {expires, data} and check expiry on read,
+ * deleting stale entries lazily. This means a cache with lots of expired entries
+ * will slowly accumulate files until accessed — acceptable for the module's scale
+ * (tens-to-hundreds of keys per install) but worth noting if someone ports this
+ * to a higher-volume context.
+ *
+ * NAMESPACE
+ * ---------
+ * Every key is prefixed with "vfd:" to avoid collisions with anything else that
+ * shares the Redis instance. Nested keys add their own sub-prefix (e.g.
+ * "pdns:zones:<hash>" for PowerDNS zone lists) for semantic clarity in the logs.
+ *
+ * FAILURE MODES
+ * -------------
+ * Redis unreachable: we set $redisAvailable = false on first failure, which
+ * permanently disables Redis for the rest of this PHP process (subsequent calls
+ * skip straight to the file cache). Prevents paying reconnect overhead on every
+ * miss when Redis is down.
+ * File cache write fails: silently skipped. Cache is best-effort; a failed SET
+ * just means the next GET will re-fetch from the authoritative source.
+ */
+class Cache
+{
+    /** Module-global key prefix — keeps us out of Redis key collisions on shared installs. */
+    const PREFIX = 'vfd:';
+
+    /** @var \Redis|null */
+    private static $redis = null;
+
+    /** @var bool|null */
+    private static $redisAvailable = null;
+
+    /** @var string */
+    private static $fileDir = '';
+
+    /**
+     * Try to connect to Redis. Returns the connection or null.
+     */
+    private static function redis(): ?\Redis
+    {
+        if (self::$redisAvailable === false) {
+            return null;
+        }
+
+        if (self::$redis !== null) {
+            return self::$redis;
+        }
+
+        if (! extension_loaded('redis')) {
+            self::$redisAvailable = false;
+
+            return null;
+        }
+
+        try {
+            $redis = new \Redis;
+            $redis->connect('127.0.0.1', 6379, 1.0);
+            self::$redis = $redis;
+            self::$redisAvailable = true;
+
+            return $redis;
+        } catch (\Exception $e) {
+            self::$redisAvailable = false;
+
+            return null;
+        }
+    }
+
+    /**
+     * Get the filesystem cache directory, creating it if needed.
+     */
+    private static function fileDir(): string
+    {
+        if (self::$fileDir !== '') {
+            return self::$fileDir;
+        }
+
+        $dir = sys_get_temp_dir() . '/vfd_cache';
+        if (! is_dir($dir)) {
+            @mkdir($dir, 0700, true);
+        }
+
+        self::$fileDir = $dir;
+
+        return $dir;
+    }
+
+    /**
+     * Convert a cache key to a safe filename.
+     */
+    private static function filePath(string $key): string
+    {
+        return self::fileDir() . '/' . md5($key) . '.cache';
+    }
+
+    /**
+     * Get a cached value.
+     *
+     * @param  string  $key
+     * @return mixed|null Returns null on miss
+     */
+    public static function get($key)
+    {
+        // Try Redis first
+        $redis = self::redis();
+        if ($redis) {
+            try {
+                $data = $redis->get(self::PREFIX . $key);
+                if ($data !== false) {
+                    return json_decode($data, true);
+                }
+
+                return null;
+            } catch (\Exception $e) {
+                // Fall through to file cache
+            }
+        }
+
+        // File cache fallback
+        $path = self::filePath($key);
+        if (! file_exists($path)) {
+            return null;
+        }
+
+        $raw = @file_get_contents($path);
+        if ($raw === false) {
+            return null;
+        }
+
+        $entry = json_decode($raw, true);
+        if (! $entry || ! isset($entry['expires']) || ! isset($entry['data'])) {
+            @unlink($path);
+
+            return null;
+        }
+
+        if ($entry['expires'] < time()) {
+            @unlink($path);
+
+            return null;
+        }
+
+        return $entry['data'];
+    }
+
+    /**
+     * Store a value in cache.
+     *
+     * @param  string  $key
+     * @param  mixed  $value
+     * @param  int  $ttl  Time-to-live in seconds
+     */
+    public static function set($key, $value, $ttl = 300)
+    {
+        // Try Redis first
+        $redis = self::redis();
+        if ($redis) {
+            try {
+                $redis->setex(self::PREFIX . $key, $ttl, json_encode($value));
+
+                return;
+            } catch (\Exception $e) {
+                // Fall through to file cache
+            }
+        }
+
+        // File cache fallback with atomic write.
+        // Writing to a temp file + rename ensures that readers either see the
+        // complete previous entry or the complete new entry — never a truncated
+        // or partially-written file. getmypid() suffix lets concurrent PHP
+        // processes write to the same key without stomping each other's temp files.
+        $path = self::filePath($key);
+        $tmp = $path . '.' . getmypid() . '.tmp';
+        $entry = json_encode(['expires' => time() + $ttl, 'data' => $value]);
+
+        if (@file_put_contents($tmp, $entry, LOCK_EX) !== false) {
+            // rename() is atomic on POSIX when source and target are on the same
+            // filesystem (which they always are here — both in sys_get_temp_dir).
+            @rename($tmp, $path);
+        }
+    }
+
+    /**
+     * Delete a cached value.
+     *
+     * @param  string  $key
+     */
+    public static function forget($key)
+    {
+        $redis = self::redis();
+        if ($redis) {
+            try {
+                $redis->del(self::PREFIX . $key);
+            } catch (\Exception $e) {
+                // Continue to file cleanup
+            }
+        }
+
+        $path = self::filePath($key);
+        if (file_exists($path)) {
+            @unlink($path);
+        }
+    }
+}

modules/servers/VirtFusionDirect/lib/ConfigureService.php

@@ -2,17 +2,61 @@
 
 namespace WHMCS\Module\Server\VirtFusionDirect;
 
-use JsonException;
 use WHMCS\Database\Capsule as DB;
 use WHMCS\User\User;
 
+/**
+ * Handles order-time and provisioning-time operations for VirtFusion servers.
+ *
+ * WHY A SIBLING OF ModuleFunctions RATHER THAN METHODS ON IT
+ * ----------------------------------------------------------
+ * ModuleFunctions handles the WHMCS LIFECYCLE (create, suspend, terminate, etc.)
+ * — operations driven by WHMCS service-state transitions.
+ *
+ * ConfigureService handles ORDER-TIME logic — package lookups, template fetching,
+ * SSH key creation, initial build triggering. These run during checkout (via the
+ * ClientAreaFooterOutput hook that populates dropdowns on the order form) and
+ * immediately after account creation (initServerBuild is called from
+ * ModuleFunctions::createAccount once the VirtFusion server exists).
+ *
+ * Splitting the concerns keeps ModuleFunctions focused on lifecycle state machines
+ * and ConfigureService focused on catalogue/discovery calls. They share the base
+ * Module's API plumbing via inheritance.
+ *
+ * CACHING
+ * -------
+ * Package/template lookups use the module's Cache class with 10-minute TTLs.
+ * These values change rarely (a package list is typically edited once per
+ * month at most) but the endpoints are on the checkout hot path, so aggressive
+ * caching matters for page-load performance.
+ *
+ * CP RESOLVED IN CONSTRUCTOR
+ * --------------------------
+ * Unlike ModuleFunctions which resolves the control panel per-request via the
+ * service ID, ConfigureService resolves it ONCE in the constructor via
+ * getCP(false, true) — "any available VirtFusion server". Order-time operations
+ * happen BEFORE a WHMCS service exists, so we can't dereference a specific
+ * server through mod_virtfusion_direct. "Any enabled server" is the pragmatic
+ * default for catalogue operations that typically return the same data
+ * regardless of which panel you hit.
+ */
 class ConfigureService extends Module
 {
     /**
-     * @var array|false $cp
+     * The first available VirtFusion control panel connection, as returned by
+     * getCP(). Holds server URL and API token used for all API calls in this
+     * class. False if no active VirtFusion server is configured in WHMCS.
+     *
+     * @var array|false
      */
     private array|bool $cp;
 
+    /**
+     * Initialize the service configurator with the first available VirtFusion server.
+     *
+     * Calls the parent Module constructor then resolves the control panel connection
+     * so all methods in this class have a ready API endpoint.
+     */
     public function __construct()
     {
         parent::__construct();
@@ -20,134 +64,298 @@ class ConfigureService extends Module
     }
 
     /**
-     * @param string $packageName
+     * Find a VirtFusion package ID by its name via the API.
-     * @return int|null
+     *
-     * @throws JsonException
+     * Searches the packages list for an enabled package whose name matches
+     * exactly. Result is cached for 10 minutes. Returns null if not found
+     * or if no control panel is available.
+     *
+     * @param  string  $packageName  Exact package name as configured in VirtFusion.
+     * @return int|null Package ID, or null if not found.
      */
     public function fetchPackageId(string $packageName): ?int
     {
-        $request = $this->initCurl($this->cp['token']);
+        try {
-
+            $cacheKey = 'pkg_name:' . md5($packageName);
-        $response = $request->get(
+            $cached = Cache::get($cacheKey);
-            sprintf("%s/packages", $this->cp['url'])
+            if ($cached !== null) {
-        );
+                return $cached;
-
-        $packages = $this->decodeResponseFromJson($response);
-
-        foreach ($packages['data'] as $package) {
-            if ($package['name'] === $packageName && $package['enabled'] === true) {
-                return $package['id'];
             }
-        }
 
-        return null;
+            if (! $this->cp) {
+                return null;
+            }
+
+            $request = $this->initCurl($this->cp['token']);
+
+            $response = $request->get(
+                sprintf('%s/packages', $this->cp['url']),
+            );
+
+            $packages = $this->decodeResponseFromJson($response);
+
+            foreach ($packages['data'] as $package) {
+                if ($package['name'] === $packageName && $package['enabled'] === true) {
+                    Cache::set($cacheKey, $package['id'], 600);
+
+                    return $package['id'];
+                }
+            }
+
+            return null;
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return null;
+        }
     }
 
-
     /**
-     * @param int $productId
+     * Get the VirtFusion package ID from a WHMCS product's config option.
-     * @return int|null
+     *
+     * Reads configoption2 directly from the tblproducts database record for
+     * the given WHMCS product ID. Returns null if the product does not exist.
+     *
+     * @param  int  $productId  WHMCS product (tblproducts) ID.
+     * @return int|null VirtFusion package ID, or null if the product is not found.
      */
     public function fetchPackageByDbId(int $productId): ?int
     {
-        $product = DB::table('tblproducts')->where('id', $productId)->first();
+        try {
+            $product = DB::table('tblproducts')->where('id', $productId)->first();
+
+            if (is_null($product)) {
+                return null;
+            }
+
+            return (int) $product->configoption2;
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
 
-        if (is_null($product)) {
             return null;
         }
-
-        return (int)$product->configoption2;
     }
 
     /**
-     * @param int $serverPackageId
+     * Fetch the available OS templates for a given VirtFusion server package.
-     * @return array|null
+     *
-     * @throws JsonException
+     * Queries the VirtFusion API for templates compatible with the specified
+     * package spec ID. Result is cached for 10 minutes. Returns null if no
+     * package ID is provided or no control panel is available.
+     *
+     * @param  int|null  $serverPackageId  VirtFusion server package spec ID.
+     * @return array|null Template list from the API, or null on failure.
      */
     public function fetchTemplates(?int $serverPackageId): ?array
     {
-        if (is_null($serverPackageId)) {
+        try {
+            if (is_null($serverPackageId)) {
+                return null;
+            }
+
+            $cacheKey = 'tpl:' . $serverPackageId;
+            $cached = Cache::get($cacheKey);
+            if ($cached !== null) {
+                return $cached;
+            }
+
+            if (! $this->cp) {
+                return null;
+            }
+
+            $request = $this->initCurl($this->cp['token']);
+
+            $response = $request->get(
+                sprintf('%s/media/templates/fromServerPackageSpec/%d', $this->cp['url'], $serverPackageId),
+            );
+
+            $result = $this->decodeResponseFromJson($response);
+            Cache::set($cacheKey, $result, 600);
+
+            return $result;
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
             return null;
         }
-
-        $request = $this->initCurl($this->cp['token']);
-
-        $response = $request->get(
-            sprintf("%s/media/templates/fromServerPackageSpec/%d", $this->cp['url'], $serverPackageId)
-        );
-
-        return $this->decodeResponseFromJson($response);
     }
 
     /**
-     * @param User|null $user
+     * Get the SSH keys registered for a VirtFusion user.
-     * @return array|null
+     *
-     * @throws JsonException
+     * Looks up the VirtFusion account for the given WHMCS user via external
+     * relation ID, then fetches their SSH key list from the API. Returns null
+     * if the user is not found in VirtFusion or no control panel is available.
+     *
+     * @param  User|null  $user  WHMCS User object.
+     * @return array|null SSH key list from the API, or null on failure.
      */
     public function getUserSshKeys(?User $user): ?array
     {
-        if (is_null($user)) {
+        try {
+            if (is_null($user)) {
+                return null;
+            }
+
+            if (! $this->cp) {
+                return null;
+            }
+
+            $request = $this->initCurl($this->cp['token']);
+
+            $vfUser = $this->getVFUserDetails($user['id']);
+
+            if (! $vfUser) {
+                return null;
+            }
+
+            $response = $request->get(
+                sprintf('%s/ssh_keys/user/%d', $this->cp['url'], $vfUser['id']),
+            );
+
+            return $this->decodeResponseFromJson($response);
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
             return null;
         }
-
-        $request = $this->initCurl($this->cp['token']);
-
-        $vfUser = $this->getVFUserDetails($user['id']);
-
-        $response = $request->get(
-            sprintf("%s/ssh_keys/user/%d", $this->cp['url'], $vfUser['id'])
-        );
-
-        return $this->decodeResponseFromJson($response);
     }
 
     /**
-     * @param int $id
+     * Look up a VirtFusion user by WHMCS external relation ID.
-     * @return array|null
+     *
-     * @throws JsonException
+     * Calls the VirtFusion API's byExtRelation endpoint using the WHMCS client
+     * ID. Returns null if the user does not exist in VirtFusion or no control
+     * panel is available.
+     *
+     * @param  int  $id  WHMCS client ID used as the VirtFusion external relation ID.
+     * @return array|null VirtFusion user data array, or null if not found.
      */
     public function getVFUserDetails(int $id): ?array
     {
-        $request = $this->initCurl($this->cp['token']);
+        try {
+            if (! $this->cp) {
+                return null;
+            }
 
-        $response = $this->decodeResponseFromJson($request->get(
+            $request = $this->initCurl($this->cp['token']);
-            sprintf("%s/users/%d/byExtRelation", $this->cp['url'], $id)
-        ));
 
-        return isset($response['msg']) && $response['msg'] === "ext_relation_id not found" ? null : $response['data'];
+            $response = $this->decodeResponseFromJson($request->get(
+                sprintf('%s/users/%d/byExtRelation', $this->cp['url'], $id),
+            ));
+
+            return isset($response['msg']) && $response['msg'] === 'ext_relation_id not found' ? null : $response['data'];
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return null;
+        }
     }
 
     /**
-     * @param int $id
+     * Trigger OS installation on a newly created VirtFusion server.
-     * @param array $vars
+     *
-     * @return bool
+     * Posts a build request to the VirtFusion API with the selected OS template
+     * and optionally an SSH key. If the custom field contains a numeric value it
+     * is treated as an existing key ID; if it is a raw public key string, the key
+     * is created first via createUserSshKey(). Returns true on HTTP 200/201.
+     *
+     * @param  int  $id  VirtFusion server ID to build.
+     * @param  array  $vars  WHMCS order vars, including customfields for OS and SSH key.
+     * @param  int|null  $vfUserId  VirtFusion user ID, required when creating a new SSH key from a raw public key.
+     * @return bool True if the build request was accepted, false otherwise.
      */
-    public function initServerBuild(int $id, array $vars): bool
+    public function initServerBuild(int $id, array $vars, ?int $vfUserId = null): bool
     {
-        $request = $this->initCurl($this->cp['token']);
+        try {
+            if (! $this->cp) {
+                return false;
+            }
 
-        // Generate a random 8 character hostname
+            $request = $this->initCurl($this->cp['token']);
-        $hostname = substr(str_shuffle('abcdefghijklmnopqrstuvwxyz'), 0, 8);
 
-        $inputData = [
+            // Generate a hostname with sufficient entropy to avoid collisions
-            "operatingSystemId" => $vars['customfields']['Initial Operating System'],
+            $hostname = 'vps-' . bin2hex(random_bytes(4));
-            "name" => $hostname,
-            "sshKeys" => [
-                $vars['customfields']['Initial SSH Key']
-            ],
-            'email' => true
-        ];
 
-        if (empty($vars['customfields']['Initial SSH Key'])) {
+            $sshKeyValue = $vars['customfields']['Initial SSH Key'] ?? null;
-            unset($inputData['sshKeys']);
+            $sshKeyId = null;
+
+            if (! empty($sshKeyValue)) {
+                if (is_numeric($sshKeyValue)) {
+                    // Existing SSH key ID
+                    $sshKeyId = (int) $sshKeyValue;
+                } elseif (preg_match('/^ssh-/', $sshKeyValue) && $vfUserId) {
+                    // Raw public key — create it via API
+                    $sshKeyId = $this->createUserSshKey($vfUserId, $sshKeyValue);
+                }
+            }
+
+            $inputData = [
+                'operatingSystemId' => $vars['customfields']['Initial Operating System'] ?? null,
+                'name' => $hostname,
+                'email' => true,
+            ];
+
+            if ($sshKeyId) {
+                $inputData['sshKeys'] = [$sshKeyId];
+            }
+
+            $request->addOption(CURLOPT_POSTFIELDS, json_encode($inputData));
+
+            $response = $request->post(
+                sprintf('%s/servers/%d/build', $this->cp['url'], $id),
+            );
+
+            $httpCode = $request->getRequestInfo('http_code');
+            Log::insert(__FUNCTION__, $request->getRequestInfo(), $response);
+
+            return $httpCode == 200 || $httpCode == 201;
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return false;
         }
-
-        $request->addOption(CURLOPT_POSTFIELDS, json_encode($inputData));
-
-        $request->post(
-            sprintf("%s/servers/%d/build", $this->cp['url'], $id)
-        );
-
-        return true;
     }
-}
+
+    /**
+     * Create an SSH key for a VirtFusion user from a raw public key string.
+     *
+     * @param  int  $userId  VirtFusion user ID
+     * @param  string  $publicKey  Raw SSH public key (ssh-rsa ..., ssh-ed25519 ..., etc.)
+     * @return int|null Created key ID or null on failure
+     */
+    public function createUserSshKey(int $userId, string $publicKey): ?int
+    {
+        try {
+            if (! $this->cp) {
+                return null;
+            }
+
+            $request = $this->initCurl($this->cp['token']);
+
+            $keyData = [
+                'userId' => $userId,
+                'name' => 'WHMCS-' . date('Y-m-d'),
+                'publicKey' => trim($publicKey),
+            ];
+
+            $request->addOption(CURLOPT_POSTFIELDS, json_encode($keyData));
+            $response = $request->post($this->cp['url'] . '/ssh_keys');
+
+            Log::insert(__FUNCTION__, $request->getRequestInfo(), $response);
+
+            $httpCode = $request->getRequestInfo('http_code');
+            if ($httpCode == 200 || $httpCode == 201) {
+                $data = json_decode($response, true);
+
+                return $data['data']['id'] ?? null;
+            }
+
+            return null;
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return null;
+        }
+    }
+}

modules/servers/VirtFusionDirect/lib/Curl.php

@@ -2,46 +2,57 @@
 
 namespace WHMCS\Module\Server\VirtFusionDirect;
 
+/**
+ * HTTP client wrapper with Bearer token auth, SSL verification, and a 30s timeout.
+ * Single-use — each instance makes one request.
+ */
 class Curl
 {
+    /** @var resource|\CurlHandle cURL handle */
     private $ch;
+
+    /** @var array Response info and parsed header data collected after exec */
     private $data;
+
+    /** @var array User-supplied cURL options that override defaults */
     private $customOptions = [];
+
+    /**
+     * @var array Default cURL options applied to every request.
+     *
+     * Rationale:
+     *   VERIFYPEER/VERIFYHOST: Full TLS chain + hostname validation. Disabling
+     *     either is a common source of MITM bugs, so we never do it silently.
+     *   RETURNTRANSFER: We always want the response body back as a string.
+     *   HEADER off: Callers almost never need headers. Saves a parse cycle.
+     *   NOBODY off: Default to GET-style body-returning requests.
+     *   TIMEOUT 30s: Covers slow API endpoints without letting a hung connection
+     *     block a whole WHMCS request indefinitely.
+     *   CONNECTTIMEOUT 10s: Separate from the total timeout so a failed TCP
+     *     handshake (firewall black-hole) fails fast rather than burning 30s.
+     */
     private $defaultOptions = [
-        CURLOPT_SSL_VERIFYPEER => false,
+        CURLOPT_SSL_VERIFYPEER => true,
-        CURLOPT_SSL_VERIFYHOST => false,
+        CURLOPT_SSL_VERIFYHOST => 2,
         CURLOPT_RETURNTRANSFER => true,
-        CURLOPT_USERAGENT => 'CURL',
+        CURLOPT_USERAGENT => 'VirtFusion-WHMCS/2.0',
         CURLOPT_HEADER => false,
         CURLOPT_NOBODY => false,
+        CURLOPT_TIMEOUT => 30,
+        CURLOPT_CONNECTTIMEOUT => 10,
     ];
 
-
+    /** Initialise the cURL handle. */
     public function __construct()
     {
         $this->ch = curl_init();
     }
 
-    public function useCookies()
-    {
-        $cookiesFile = tempnam('/tmp', 'virtfusion_cookies');
-        $this->defaultOptions[CURLOPT_COOKIEFILE] = $cookiesFile;
-        $this->defaultOptions[CURLOPT_COOKIEJAR] = $cookiesFile;
-    }
-
-    public function setLog()
-    {
-        $log = fopen(__DIR__ . '/CURL.log', 'a');
-        if ($log) {
-            fwrite($log, str_repeat('=', 80) . PHP_EOL);
-            $this->addOption(CURLOPT_STDERR, $log);
-            $this->addOption(CURLOPT_VERBOSE, true);
-        }
-    }
-
     /**
-     * @param $name
+     * Set a custom cURL option, overriding the defaults.
-     * @param $value
+     *
+     * @param  int  $name  A CURLOPT_* constant
+     * @param  mixed  $value  The option value
      */
     public function addOption($name, $value)
     {
@@ -49,8 +60,10 @@ class Curl
     }
 
     /**
-     * @param null $url
+     * Execute a PUT request.
-     * @return bool|string|void
+     *
+     * @param  string|null  $url  Target URL, or null to use a previously set CURLOPT_URL
+     * @return bool|string Response body, or false on failure
      */
     public function put($url = null)
     {
@@ -58,15 +71,30 @@ class Curl
     }
 
     /**
-     * @param $method
+     * Execute a PATCH request.
-     * @param $url
+     *
-     * @return bool|string|void
+     * @param  string|null  $url  Target URL, or null to use a previously set CURLOPT_URL
+     * @return bool|string Response body, or false on failure
+     */
+    public function patch($url = null)
+    {
+        return $this->send('PATCH', $url);
+    }
+
+    /**
+     * Set the HTTP method and URL, then execute the request.
+     *
+     * @param  string  $method  HTTP method (GET, POST, PUT, PATCH, DELETE)
+     * @param  string|null  $url  Target URL, or null to use a previously set CURLOPT_URL
+     * @return bool|string Response body, or false on failure
+     *
+     * @throws \RuntimeException If no URL is available
      */
     private function send($method, $url)
     {
         if ($url === null) {
-            if (!isset($this->customOptions[CURLOPT_URL]) || empty($this->customOptions[CURLOPT_URL])) {
+            if (! isset($this->customOptions[CURLOPT_URL]) || empty($this->customOptions[CURLOPT_URL])) {
-                exit('empty url');
+                throw new \RuntimeException('Curl: empty URL provided');
             }
         }
         $this->addOption(CURLOPT_CUSTOMREQUEST, $method);
@@ -76,7 +104,9 @@ class Curl
     }
 
     /**
-     * @return bool|string
+     * Apply options, run the cURL handle, collect response info, and close the handle.
+     *
+     * @return bool|string Response body, or false on cURL error
      */
     private function exec()
     {
@@ -84,6 +114,12 @@ class Curl
         $response = curl_exec($this->ch);
 
         $this->data['info'] = curl_getinfo($this->ch);
+
+        if ($response === false) {
+            $this->data['info']['curl_error'] = curl_error($this->ch);
+            $this->data['info']['curl_errno'] = curl_errno($this->ch);
+        }
+
         if (isset($this->customOptions[CURLOPT_HEADER]) && $this->customOptions[CURLOPT_HEADER]) {
             $this->data['info']['request_header'] = trim($this->data['info']['request_header']);
             $this->processHeaders($response);
@@ -94,6 +130,7 @@ class Curl
         return $response;
     }
 
+    /** Merge custom and default cURL options and apply them to the handle. */
     private function setOptions()
     {
         if (isset($this->customOptions[CURLOPT_HEADER]) && $this->customOptions[CURLOPT_HEADER]) {
@@ -105,7 +142,9 @@ class Curl
     }
 
     /**
-     * @param $data
+     * Split a response containing headers into header and body parts and store them.
+     *
+     * @param  string  $data  Raw response string (headers + body); replaced with body only
      */
     private function processHeaders(&$data)
     {
@@ -116,15 +155,17 @@ class Curl
 
         $tmp = explode("\r\n", $this->data['info']['response_header']);
         $this->data['data']['Message'] = $tmp[0];
-        for ($i = 1, $size = count($tmp); $i < $size; ++$i) {
+        for ($i = 1, $size = count($tmp); $i < $size; $i++) {
             $string = explode(': ', $tmp[$i], 2);
             $this->data['data'][$string[0]] = $string[1];
         }
     }
 
     /**
-     * @param null $url
+     * Execute a GET request.
-     * @return bool|string|void
+     *
+     * @param  string|null  $url  Target URL, or null to use a previously set CURLOPT_URL
+     * @return bool|string Response body, or false on failure
      */
     public function get($url = null)
     {
@@ -132,8 +173,10 @@ class Curl
     }
 
     /**
-     * @param null $url
+     * Execute a DELETE request.
-     * @return bool|string|void
+     *
+     * @param  string|null  $url  Target URL, or null to use a previously set CURLOPT_URL
+     * @return bool|string Response body, or false on failure
      */
     public function delete($url = null)
     {
@@ -141,8 +184,10 @@ class Curl
     }
 
     /**
-     * @param null $url
+     * Execute a POST request.
-     * @return bool|string|void
+     *
+     * @param  string|null  $url  Target URL, or null to use a previously set CURLOPT_URL
+     * @return bool|string Response body, or false on failure
      */
     public function post($url = null)
     {
@@ -150,17 +195,10 @@ class Curl
     }
 
     /**
-     * @param null $url
+     * Return curl_getinfo data for the completed request.
-     * @return bool|string|void
+     *
-     */
+     * @param  string|false  $param  A specific info key to retrieve, or false for the full array
-    public function head($url = null)
+     * @return mixed|null The requested info value, the full info array, or null if the key is absent
-    {
-        return $this->send('HEAD', $url);
-    }
-
-    /**
-     * @param false $param
-     * @return mixed|null
      */
     public function getRequestInfo($param = false)
     {
@@ -172,9 +210,11 @@ class Curl
     }
 
     /**
-     * @param $what
+     * Retrieve a single item from the internal data store by section and key.
-     * @param $name
+     *
-     * @return mixed|null
+     * @param  string  $what  Top-level section key (e.g. 'info', 'data')
+     * @param  string  $name  Item key within that section
+     * @return mixed|null The stored value, or null if not found
      */
     private function getDataItem($what, $name)
     {
@@ -184,17 +224,4 @@ class Curl
             return null;
         }
     }
-
+}
-    /**
-     * @param false $param
-     * @return mixed|null
-     */
-    public function getHeadersData($param = false)
-    {
-        if ($param) {
-            return $this->getDataItem('data', $param);
-        }
-
-        return $this->data['data'];
-    }
-}

modules/servers/VirtFusionDirect/lib/Database.php

@@ -4,13 +4,61 @@ namespace WHMCS\Module\Server\VirtFusionDirect;
 
 use WHMCS\Database\Capsule as DB;
 
+/**
+ * Handles all database operations for the module's custom table (mod_virtfusion_direct)
+ * and queries against core WHMCS tables (tblhosting, tblclients, tblservers, etc.).
+ *
+ * SCHEMA AUTO-MIGRATION
+ * ---------------------
+ * schema() runs on every Module construction — the first call per request creates
+ * or migrates the module table and ensures all required custom fields exist on
+ * every VirtFusionDirect product. Subsequent calls within the same request hit
+ * the $fieldsChecked idempotency flag and short-circuit, so the overhead is
+ * one SHOW-columns query per request.
+ *
+ * This design means operators never need to run a separate install script —
+ * dropping the module files into place and hitting any admin page triggers the
+ * migration. The trade-off is small per-request overhead; we take it because
+ * WHMCS modules historically had fragile install/uninstall hooks.
+ *
+ * SCHEMA VERSIONING
+ * -----------------
+ * No explicit version table. Migrations are expressed as "create if missing"
+ * checks — hasTable(), hasColumn() — which makes forward migration additive
+ * and safe to re-run. Deletions would require a proper versioning scheme, but
+ * we have none so far; every column added has been non-breaking.
+ *
+ * WHMCS TABLE ACCESS
+ * ------------------
+ * Reads from tblhosting / tblclients / tblconfiguration are done via Capsule's
+ * fluent query builder, not raw SQL, to inherit WHMCS's database abstraction
+ * (connection pooling, character set, prepared statement handling).
+ */
 class Database
 {
+    /** Module's own per-service state table. Created on first Module instantiation. */
     const SYSTEM_TABLE = 'mod_virtfusion_direct';
 
+    /**
+     * @var bool Tracks whether custom field existence has already been verified this request.
+     *
+     * Custom-field creation is idempotent (updateOrInsert) but touching every
+     * product on every request is wasteful. This flag ensures it runs exactly
+     * once per PHP request.
+     */
+    private static $fieldsChecked = false;
+
+    /**
+     * Creates or migrates the module table schema and ensures custom fields exist.
+     *
+     * Creates mod_virtfusion_direct with service_id and server_id columns if absent,
+     * adds the server_object column if missing, then calls ensureCustomFields().
+     *
+     * @return void
+     */
     public static function schema()
     {
-        if (!DB::schema()->hasTable(self::SYSTEM_TABLE)) {
+        if (! DB::schema()->hasTable(self::SYSTEM_TABLE)) {
             try {
                 DB::schema()->create(self::SYSTEM_TABLE, function ($table) {
                     $table->unsignedBigInteger('service_id')->nullable()->default(null)->index();
@@ -22,7 +70,7 @@ class Database
             }
         }
 
-        if (!DB::schema()->hasColumn(self::SYSTEM_TABLE, 'server_object')) {
+        if (! DB::schema()->hasColumn(self::SYSTEM_TABLE, 'server_object')) {
             try {
                 DB::schema()->table(self::SYSTEM_TABLE, function ($table) {
                     $table->longText('server_object')->nullable()->default(null);
@@ -31,91 +79,283 @@ class Database
                 Log::insert(__FUNCTION__, [], $e->getMessage());
             }
         }
+
+        self::ensureCustomFields();
     }
 
+    /**
+     * Ensures the "Initial Operating System" and "Initial SSH Key" custom fields exist
+     * for every VirtFusionDirect product, creating them via upsert if absent.
+     *
+     * @return void
+     */
+    public static function ensureCustomFields()
+    {
+        if (self::$fieldsChecked) {
+            return;
+        }
+        self::$fieldsChecked = true;
+
+        try {
+            $productIds = DB::table('tblproducts')
+                ->where('servertype', 'VirtFusionDirect')
+                ->pluck('id');
+
+            foreach ($productIds as $productId) {
+                foreach (['Initial Operating System', 'Initial SSH Key'] as $fieldName) {
+                    DB::table('tblcustomfields')->updateOrInsert(
+                        ['type' => 'product', 'relid' => $productId, 'fieldname' => $fieldName],
+                        [
+                            'fieldtype' => 'text',
+                            'description' => '',
+                            'fieldoptions' => '',
+                            'regexpr' => '',
+                            'adminonly' => '',
+                            'required' => '',
+                            'showorder' => 'on',
+                            'showinvoice' => '',
+                            'sortorder' => 0,
+                            'updated_at' => DB::raw('UTC_TIMESTAMP()'),
+                        ],
+                    );
+                }
+            }
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+        }
+    }
+
+    /**
+     * Fetches a VirtFusionDirect server record from tblservers.
+     *
+     * When $server is non-zero, returns the matching server by ID.
+     * When $any is true and $server is 0, returns the first enabled server.
+     *
+     * @param  int  $server  WHMCS server ID to look up (0 to skip ID filter).
+     * @param  bool  $any  If true, fall back to the first active server.
+     * @return object|false Row object on success, false on failure or not found.
+     */
     public static function getWhmcsServer(int $server, $any = false)
     {
-        if ($server) {
+        try {
-            return DB::table('tblservers')->where('type', 'VirtFusionDirect')->where('id', $server)->first();
+            if ($server) {
-        }
+                return DB::table('tblservers')->where('type', 'VirtFusionDirect')->where('id', $server)->first();
+            }
 
-        if ($any) {
+            if ($any) {
-            return DB::table('tblservers')->where('type', 'VirtFusionDirect')->where('disabled', 0)->first();
+                return DB::table('tblservers')->where('type', 'VirtFusionDirect')->where('disabled', 0)->first();
+            }
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
         }
 
         return false;
     }
 
+    /**
+     * Checks whether a WHMCS service belongs to the given client.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @param  int  $userId  WHMCS client ID.
+     * @return bool True if the service is owned by the client, false otherwise.
+     */
     public static function userWhmcsService(int $serviceId, int $userId)
     {
-        return DB::table('tblhosting')->where('id', $serviceId)->where('userid', $userId)->exists();
+        try {
+            return DB::table('tblhosting')->where('id', $serviceId)->where('userid', $userId)->exists();
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return false;
+        }
     }
 
+    /**
+     * Returns the WHMCS system URL from tblconfiguration.
+     *
+     * @return string The system URL, or an empty string if not found or on error.
+     */
     public static function getSystemUrl()
     {
-        $url = DB::table('tblconfiguration')->where('setting', '=', 'SystemURL')->first();
+        try {
-        return $url->value;
+            $url = DB::table('tblconfiguration')->where('setting', '=', 'SystemURL')->first();
+            if (! $url) {
+                return '';
+            }
+
+            return $url->value;
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return '';
+        }
     }
 
+    /**
+     * Fetches a WHMCS client record by ID.
+     *
+     * @param  int  $id  WHMCS client ID.
+     * @return object|null Row object on success, null on failure or not found.
+     */
     public static function getUser(int $id)
     {
-        return DB::table('tblclients')->where('id', $id)->first();
+        try {
+            return DB::table('tblclients')->where('id', $id)->first();
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return null;
+        }
     }
 
+    /**
+     * Fetches a WHMCS hosting service record by ID.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @return object|null Row object on success, null on failure or not found.
+     */
     public static function getWhmcsService(int $serviceId)
     {
-        return DB::table('tblhosting')->where('id', $serviceId)->first();
+        try {
+            return DB::table('tblhosting')->where('id', $serviceId)->first();
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return null;
+        }
     }
 
+    /**
+     * Upserts the VirtFusion server ID for a given WHMCS service in the module table.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @param  int  $serverId  VirtFusion server ID.
+     * @return void
+     */
     public static function updateSystemServiceServerId(int $serviceId, int $serverId)
     {
-
+        try {
-        DB::table(self::SYSTEM_TABLE)->updateOrInsert(
+            DB::table(self::SYSTEM_TABLE)->updateOrInsert(
-            [
+                [
-                "service_id" => $serviceId
+                    'service_id' => $serviceId,
-            ],
+                ],
-            [
+                [
-                'server_id' => $serverId
+                    'server_id' => $serverId,
-            ]
+                ],
-        );
+            );
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+        }
     }
 
+    /**
+     * Updates one or more WHMCS tables with the provided data for a given service ID.
+     *
+     * $data is keyed by table name; each value is an associative array of column => value
+     * pairs passed to an update() WHERE id = $serviceId.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @param  array  $data  Map of table name to column-value pairs to update.
+     * @return void
+     */
     public static function updateWhmcsServiceParams(int $serviceId, $data)
     {
-        if (count($data)) {
+        try {
-            foreach ($data as $key => $items) {
+            if (count($data)) {
-                DB::table($key)->where('id', $serviceId)->update($items);
+                foreach ($data as $key => $items) {
+                    DB::table($key)->where('id', $serviceId)->update($items);
+                }
             }
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
         }
     }
 
+    /**
+     * Checks whether a module table record exists for the given service.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @return bool True if a record exists, false otherwise.
+     */
     public static function checkSystemService(int $serviceId)
     {
-        return DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->exists();
+        try {
-    }
+            return DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->exists();
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
 
-    public static function deleteSystemService(int $serviceId)
+            return false;
-    {
-        DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->delete();
-    }
-
-    public static function updateSystemServiceServerObject(int $serviceId, $data)
-    {
-        DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->update(['server_object' => json_encode($data, JSON_PRETTY_PRINT)]);
-    }
-
-    public static function systemOnServerCreate(int $serviceId, $data)
-    {
-        if (DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->exists()) {
-            DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->update(['server_id' => $data->data->id, 'server_object' => json_encode($data, JSON_PRETTY_PRINT)]);
-        } else {
-            DB::table(self::SYSTEM_TABLE)->insert(['service_id' => $serviceId, 'server_id' => $data->data->id, 'server_object' => json_encode($data, JSON_PRETTY_PRINT)]);
         }
     }
 
-    public static function getSystemService(int $serviceId)
+    /**
+     * Deletes the module table record for the given service.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @return void
+     */
+    public static function deleteSystemService(int $serviceId)
     {
-        return DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->first();
+        try {
+            DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->delete();
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+        }
     }
 
-}
+    /**
+     * Persists the raw VirtFusion server API response as JSON in the module table.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @param  mixed  $data  Server object from the VirtFusion API (will be JSON-encoded).
+     * @return void
+     */
+    public static function updateSystemServiceServerObject(int $serviceId, $data)
+    {
+        try {
+            DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->update(['server_object' => json_encode($data, JSON_PRETTY_PRINT)]);
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+        }
+    }
+
+    /**
+     * Inserts or updates the module table record immediately after a VirtFusion server is created.
+     *
+     * Stores both the VirtFusion server ID (from $data->data->id) and the full server
+     * object JSON. Uses update if a record already exists, otherwise inserts.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @param  mixed  $data  Full API response object from the VirtFusion server creation call.
+     * @return void
+     */
+    public static function systemOnServerCreate(int $serviceId, $data)
+    {
+        try {
+            if (DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->exists()) {
+                DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->update(['server_id' => $data->data->id, 'server_object' => json_encode($data, JSON_PRETTY_PRINT)]);
+            } else {
+                DB::table(self::SYSTEM_TABLE)->insert(['service_id' => $serviceId, 'server_id' => $data->data->id, 'server_object' => json_encode($data, JSON_PRETTY_PRINT)]);
+            }
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+        }
+    }
+
+    /**
+     * Fetches the module table record for the given service.
+     *
+     * @param  int  $serviceId  WHMCS hosting service ID.
+     * @return object|null Row object on success, null on failure or not found.
+     */
+    public static function getSystemService(int $serviceId)
+    {
+        try {
+            return DB::table(self::SYSTEM_TABLE)->where('service_id', $serviceId)->first();
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, [], $e->getMessage());
+
+            return null;
+        }
+    }
+}

modules/servers/VirtFusionDirect/lib/Log.php

@@ -2,22 +2,50 @@
 
 namespace WHMCS\Module\Server\VirtFusionDirect;
 
+/**
+ * Thin wrapper around the WHMCS logModuleCall() function.
+ *
+ * WHY A WRAPPER
+ * -------------
+ * Consolidating log writes lets us:
+ *   - Pin the module name in one place (the LOG_MODULE constant). All entries
+ *     go under "VirtFusionDirect" regardless of which caller inserted them,
+ *     which keeps WHMCS Admin → Utilities → Logs → Module Log filterable.
+ *   - Get a stable import path for every file that logs (Log::insert).
+ *   - Add cross-cutting policy later (e.g. redaction, sampling) without
+ *     touching every call site.
+ *
+ * OUTPUT SURFACE
+ * --------------
+ * Entries appear in WHMCS Admin → Utilities → Logs → Module Log. The request
+ * and response parameters accept strings OR arrays — WHMCS serialises arrays
+ * to readable form automatically. Pass structured data (["zone" => $z, "ip" => $ip])
+ * rather than string-concatenated messages; the UI renders arrays as key/value
+ * pairs which makes filtering and debugging much easier.
+ *
+ * REDACTION EXPECTATION
+ * ---------------------
+ * Callers are responsible for not passing secrets into logs. In particular:
+ *   - Never log Authorization/X-API-Key headers
+ *   - Never log full request_header info from the Curl class
+ *   - Never log the decrypted VirtFusion bearer token or PowerDNS API key
+ * The Curl class deliberately defaults CURLOPT_HEADER to off so header capture
+ * doesn't accidentally populate a field that callers might log.
+ */
 class Log
 {
+    /** Keep this in sync with the WHMCS server module name, so filters work. */
     const LOG_MODULE = 'VirtFusionDirect';
 
+    /**
+     * Write an entry to the WHMCS module log.
+     *
+     * @param  string  $action  Short tag identifying the operation (used as the "Function" column in the log UI)
+     * @param  string|array  $requestString  Outbound payload or context data. Arrays preferred — rendered as key/value pairs.
+     * @param  string|array  $responseData  Inbound response or result. Same conventions as $requestString.
+     */
     public static function insert($action, $requestString, $responseData)
     {
-        /**
-         * Log module call.
-         *
-         * @param string $module The name of the module
-         * @param string $action The name of the action being performed
-         * @param string|array $requestString The input parameters for the API call
-         * @param string|array $responseData The response data from the API call
-         * @param string|array $processedData The resulting data after any post processing (eg. json decode, xml decode, etc...)
-         * @param array $replaceVars An array of strings for replacement
-         */
         logModuleCall(self::LOG_MODULE, $action, $requestString, $responseData);
     }
-}
+}

modules/servers/VirtFusionDirect/lib/ModuleFunctions.php

@@ -2,6 +2,42 @@
 
 namespace WHMCS\Module\Server\VirtFusionDirect;
 
+/**
+ * Extends Module to handle the WHMCS service lifecycle for VirtFusion servers.
+ *
+ * WHY A SEPARATE CLASS FROM MODULE
+ * --------------------------------
+ * The WHMCS module interface (VirtFusionDirect.php) expects top-level functions
+ * like VirtFusionDirect_CreateAccount(). Those functions delegate into methods
+ * on this class so:
+ *   1. The top-level functions stay one-liners that are easy to audit.
+ *   2. All lifecycle logic lives in an object we can instantiate and unit-exercise
+ *      without going through WHMCS's dispatch machinery.
+ *   3. The shared behaviour with Module (API calls, auth, validation) comes for
+ *      free via inheritance — no copy-pasted curl setup or error handling.
+ *
+ * ERROR MESSAGE CONVENTION
+ * ------------------------
+ * Every public method either returns the literal string 'success' or an error
+ * string that WHMCS will render to the admin in the service activity log. Do NOT
+ * return arrays, objects, or booleans — WHMCS treats anything other than
+ * 'success' as an error and displays it verbatim.
+ *
+ * EXCEPTION HANDLING
+ * ------------------
+ * Every public method is wrapped in try/catch. Uncaught exceptions bubbling up
+ * to WHMCS appear as stack traces in the admin UI and leak implementation detail,
+ * so we catch and convert to a human error string. Log::insert() captures the
+ * original exception message for diagnostics in the module log.
+ *
+ * PowerDNS INTEGRATION
+ * --------------------
+ * createAccount(), terminateAccount(), and (via parent Module) renameServer()
+ * call into PowerDns\PtrManager to sync rDNS. Those calls are wrapped in their
+ * OWN try/catch so DNS failures never bubble up to WHMCS — provisioning must
+ * succeed even if PowerDNS is temporarily unreachable. See cleanupPowerDnsForService()
+ * for the termination-time cleanup helper.
+ */
 class ModuleFunctions extends Module
 {
     public function __construct()
@@ -10,103 +46,96 @@ class ModuleFunctions extends Module
     }
 
     /**
+     * Provision a new VirtFusion server for a WHMCS service.
      *
-     * CREATE SERVER
+     * Ensures a matching VirtFusion user exists (creating one if needed), then creates
-     *
+     * the server and triggers the OS build via ConfigureService::initServerBuild().
-     * Before creating a server, we check to see if a user exists in VirtFusion that matches
-     * the WHMCS user. If it matches, We move on to create the server, if not, we attempt to
-     * create a user to assign to the new server.
      *
+     * @param  array  $params  WHMCS service parameters
+     * @return string 'success' or an error message
      */
     public function createAccount($params)
     {
         try {
 
             /**
-             *
+             * If the service exists in the custom table, cancel the create account action.
-             * If the service exists in the custom table, Cancel the create account action.
-             *
              */
             if (Database::checkSystemService($params['serviceid'])) {
                 return 'Service already exists. You must run a termination first.';
             }
 
-
             /**
-             *
              * If no VirtFusionDirect control server exists, cancel the create account action.
-             *
              */
-
             $server = $params['serverid'] ?: false;
-            $cp = $this->getCP($server, $server ? false : true);
+            $cp = $this->getCP($server, ! $server);
 
-            if (!$cp) {
+            if (! $cp) {
-                return 'No Control server found.';
+                return 'No Control server found. Please ensure a VirtFusion server is configured in WHMCS.';
             }
 
             Log::insert(__FUNCTION__, $params, []);
 
             /**
-             *
              * Does a user account in VirtFusion match this account (byExtRelationId) in WHMCS.
-             *
              */
             $request = $this->initCurl($cp['token']);
-            $data = $request->get($cp['url'] . '/users/' . $params['userid'] . '/byExtRelation');
+            $data = $request->get($cp['url'] . '/users/' . (int) $params['userid'] . '/byExtRelation');
 
             Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
 
             switch ($request->getRequestInfo('http_code')) {
                 case 200:
-
                     /**
-                     *
                      * A user with relation ID exists in VirtFusion. We can provision under that account.
-                     *
                      */
                     break;
 
                 case 404:
-
                     /**
-                     *
                      * A user doesn't exist in VirtFusion. We should attempt to create one.
-                     *
                      */
                     $user = Database::getUser($params['userid']);
 
+                    if (! $user) {
+                        return 'WHMCS user not found for ID ' . (int) $params['userid'];
+                    }
+
                     $request = $this->initCurl($cp['token']);
 
-                    $request->addOption(CURLOPT_POSTFIELDS, json_encode(
+                    $userData = [
-                        [
+                        'name' => $user->firstname . ' ' . $user->lastname,
-                            "name" => $user->firstname . ' ' . $user->lastname,
+                        'email' => $user->email,
-                            "email" => $user->email,
+                        'extRelationId' => $user->id,
-                            "extRelationId" => $user->id
+                    ];
-                        ]
+
-                    ));
+                    // Enable self-service billing if configured
+                    $selfServiceMode = (int) ($params['configoption4'] ?? 0);
+                    if ($selfServiceMode > 0) {
+                        $userData['selfService'] = $selfServiceMode;
+                        $userData['selfServiceHourlyCredit'] = in_array($selfServiceMode, [1, 3]);
+                    }
+
+                    $request->addOption(CURLOPT_POSTFIELDS, json_encode($userData));
 
                     $data = $request->post($cp['url'] . '/users');
 
                     Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
 
                     if ($request->getRequestInfo('http_code') !== 201) {
-                        return 'Unable to create user.';
+                        return 'Unable to create user in VirtFusion. API returned HTTP ' . $request->getRequestInfo('http_code');
                     }
                     break;
                 default:
-                    return 'Error processing user account.';
+                    return 'Error processing user account. VirtFusion API returned HTTP ' . $request->getRequestInfo('http_code');
-                    break;
             }
 
             $data = json_decode($data);
 
             /**
-             *
              * A user is available. We can now attempt to create a server.
-             *
              */
-
             $configOptionDefaultNaming = [
                 'ipv4' => 'IPv4',
                 'packageId' => 'Package',
@@ -124,26 +153,27 @@ class ModuleFunctions extends Module
             $configOptionCustomNaming = [];
 
             if (file_exists(ROOTDIR . '/modules/servers/VirtFusionDirect/config/ConfigOptionMapping.php')) {
-                $configOptionCustomNaming = require_once ROOTDIR . '/modules/servers/VirtFusionDirect/config/ConfigOptionMapping.php';
+                $configOptionCustomNaming = require ROOTDIR . '/modules/servers/VirtFusionDirect/config/ConfigOptionMapping.php';
             }
 
             $options = [
-                "packageId" => $params['configoption2'],
+                'packageId' => (int) $params['configoption2'],
-                "userId" => $data->data->id,
+                'userId' => $data->data->id,
-                "hypervisorId" => $params['configoption1'],
+                'hypervisorId' => (int) $params['configoption1'],
-                "ipv4" => $params['configoption3'],
+                'ipv4' => (int) $params['configoption3'],
             ];
 
             if (array_key_exists('configoptions', $params)) {
                 foreach ($configOptionDefaultNaming as $key => $option) {
                     $currentOption = array_key_exists($key, $configOptionCustomNaming) ? $configOptionCustomNaming[$key] : $option;
                     if (array_key_exists($currentOption, $params['configoptions'])) {
-                        // If the option key is "Memory" and the value is less than 1024, we need to convert it to MB
+                        $value = $params['configoptions'][$currentOption];
+                        // If the option key is "Memory" and the value is less than 1024, convert to MB
                         // VirtFusion expects memory in MB.
-                        if ($currentOption === 'Memory' && $params['configoptions'][$currentOption] < 1024) {
+                        if ($key === 'memory' && is_numeric($value) && $value < 1024) {
-                            $options[$key] = $params['configoptions'][$currentOption] * 1024;
+                            $options[$key] = (int) ($value * 1024);
                         } else {
-                            $options[$key] = $params['configoptions'][$currentOption];
+                            $options[$key] = is_numeric($value) ? (int) $value : $value;
                         }
                     }
                 }
@@ -163,292 +193,546 @@ class ModuleFunctions extends Module
                 Database::systemOnServerCreate($params['serviceid'], $data);
                 $this->updateWhmcsServiceParamsOnServerObject($params['serviceid'], $data);
 
-                // If the server is created successfully, we can initialize the server build.
+                // Initialize reverse DNS for the newly-assigned IPs.
-                $cs = new ConfigureService();
+                //
-                $cs->initServerBuild($data->data->id, $params);
+                // Ordering: after Database::systemOnServerCreate() AND
+                // updateWhmcsServiceParamsOnServerObject() so mod_virtfusion_direct
+                // has the stored server_object (admin reconcile later reads it) and
+                // tblhosting has the primary IP (for cross-check on client edits).
+                //
+                // But BEFORE ConfigureService::initServerBuild() so rDNS is in place
+                // when the VPS first boots — mail servers and other services that
+                // check FCrDNS during early-boot see correct PTRs.
+                //
+                // Non-blocking: rDNS failures are logged but never fail provisioning.
+                // A broken PowerDNS or missing zone must not prevent a customer
+                // from getting the VPS they paid for.
+                try {
+                    if (PowerDns\Config::isEnabled()) {
+                        // syncServer with $oldHostname=null means "create mode" — see
+                        // PtrManager::syncServer() docblock for the semantics.
+                        $hostname = PowerDns\PtrManager::extractHostname($data);
+                        if ($hostname !== null) {
+                            (new PowerDns\PtrManager)->syncServer($data, null, $hostname);
+                        }
+                    }
+                } catch (\Throwable $e) {
+                    Log::insert('PowerDns:createAccount', ['serviceid' => $params['serviceid']], $e->getMessage());
+                }
+
+                // If the server is created successfully, we can initialize the server build.
+                $cs = new ConfigureService;
+                $vfUserId = isset($data->data->owner->id) ? (int) $data->data->owner->id : null;
+                $cs->initServerBuild($data->data->id, $params, $vfUserId);
 
-                /**
-                 *
-                 * Server was created successfully.
-                 *
-                 */
                 return 'success';
             } else {
-                if ($data->errors[0]) {
+                if (isset($data->errors) && is_array($data->errors) && isset($data->errors[0])) {
                     return $data->errors[0];
                 }
-                return 'Unknown error.';
+                if (isset($data->msg)) {
+                    return $data->msg;
+                }
+
+                return 'Server creation failed. VirtFusion API returned HTTP ' . $request->getRequestInfo('http_code');
             }
         } catch (\Exception $e) {
             Log::insert(__FUNCTION__, $params, $e->getMessage());
+
             return $e->getMessage();
         }
     }
 
-    // This function was implemented by Zander Scott / awildboop of Blinkoh, LLC
-    // Please read this function thoroughly before use to ensure security & integrity
-
     /**
-     * Allows changing of the package of a server
+     * Change the VirtFusion package assigned to a server and apply resource modifications.
      *
-     * @author https://github.com/BlinkohHost/virtfusion-whmcs-module
+     * Updates the package via the API, then individually adjusts memory, CPU, and bandwidth
-     * @param $params
+     * if those configurable options are present.
-     * @return string
+     *
+     * @param  array  $params  WHMCS service parameters
+     * @return string 'success' or an error message
      */
     public function changePackage($params)
     {
-        $service = Database::getSystemService($params['serviceid']);
+        try {
+            $service = Database::getSystemService($params['serviceid']);
 
-        if ($service) {
+            if ($service) {
-            $whmcsService = Database::getWhmcsService($params['serviceid']);
+                $whmcsService = Database::getWhmcsService($params['serviceid']);
-            $cp = $this->getCP($whmcsService->server);
+                if (! $whmcsService) {
-            $request = $this->initCurl($cp['token']);
+                    return 'WHMCS service record not found.';
-            $data = $request->put($cp['url'] . '/servers/' . $service->server_id . '/package/' . $params['configoption2']);
+                }
-            $data = json_decode($data);
 
-            Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
+                $cp = $this->getCP($whmcsService->server);
+                if (! $cp) {
+                    return 'No control server found.';
+                }
 
-            switch ($request->getRequestInfo('http_code')) {
+                $request = $this->initCurl($cp['token']);
+                $data = $request->put($cp['url'] . '/servers/' . (int) $service->server_id . '/package/' . (int) $params['configoption2']);
+                $data = json_decode($data);
 
-                case 204:
+                Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
-                    return 'success';
+
-                case 404:
+                switch ($request->getRequestInfo('http_code')) {
-                    return '404 was returned from the web service without the msg property. The service may be currently unavailable.';
+
-                case 423:
+                    case 204:
-                    if (property_exists($data, 'msg')) {
+                        break;
-                        return $data->msg;
+                    case 404:
+                        return 'The server or package was not found in VirtFusion (HTTP 404).';
+                    case 423:
+                        if (isset($data->msg)) {
+                            return $data->msg;
+                        }
+
+                        return 'The server is currently locked. Please try again later.';
+                    default:
+                        return 'Update package request failed. VirtFusion API returned HTTP ' . $request->getRequestInfo('http_code');
+                }
+
+                // Apply individual resource modifications from configurable options
+                if (isset($params['configoptions']) && is_array($params['configoptions'])) {
+                    $configOptionDefaultNaming = [
+                        'memory' => 'Memory',
+                        'cpuCores' => 'CPU Cores',
+                        'traffic' => 'Bandwidth',
+                    ];
+
+                    $configOptionCustomNaming = [];
+                    if (file_exists(ROOTDIR . '/modules/servers/VirtFusionDirect/config/ConfigOptionMapping.php')) {
+                        $configOptionCustomNaming = require ROOTDIR . '/modules/servers/VirtFusionDirect/config/ConfigOptionMapping.php';
                     }
-                default:
+
-                    return 'Update package request failed. The web service reported HTTP code ' . $request->getRequestInfo('http_code');
+                    foreach ($configOptionDefaultNaming as $resource => $optionName) {
+                        $currentOption = array_key_exists($resource, $configOptionCustomNaming) ? $configOptionCustomNaming[$resource] : $optionName;
+                        if (isset($params['configoptions'][$currentOption]) && is_numeric($params['configoptions'][$currentOption])) {
+                            $value = (int) $params['configoptions'][$currentOption];
+                            if ($resource === 'memory' && $value < 1024) {
+                                $value = $value * 1024;
+                            }
+                            $this->modifyResource($params['serviceid'], $resource, $value);
+                        }
+                    }
+                }
+
+                return 'success';
             }
+
+            return 'Service not found in module database.';
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, $params, $e->getMessage());
+
+            return $e->getMessage();
         }
-        return 'Service not found.';
     }
 
     /**
+     * Delete a VirtFusion server, applying the default 5-minute grace period before destruction.
      *
-     * TERMINATE SERVER
+     * On success, removes the service record from the module database and clears WHMCS service fields.
-     *
+     * If VirtFusion reports the server is already gone (404 + "server not found"), treats it as success.
-     * When requesting to terminate a server in VirtFusion, we leave it set to
-     * the default 5-minute delay allowing to un-terminate in VirtFusion if the
-     * request was done in error.
      *
+     * @param  array  $params  WHMCS service parameters
+     * @return string 'success' or an error message
      */
     public function terminateAccount($params)
     {
-        $service = Database::getSystemService($params['serviceid']);
+        try {
+            $service = Database::getSystemService($params['serviceid']);
 
-        if ($service) {
+            if ($service) {
 
-            $whmcsService = Database::getWhmcsService($params['serviceid']);
+                $whmcsService = Database::getWhmcsService($params['serviceid']);
+                if (! $whmcsService) {
+                    return 'WHMCS service record not found.';
+                }
 
-            $cp = $this->getCP($whmcsService->server);
+                $cp = $this->getCP($whmcsService->server);
+                if (! $cp) {
+                    return 'No control server found.';
+                }
 
-            $request = $this->initCurl($cp['token']);
+                $request = $this->initCurl($cp['token']);
-            $data = $request->delete($cp['url'] . '/servers/' . $service->server_id);
+                $data = $request->delete($cp['url'] . '/servers/' . (int) $service->server_id);
-            $data = json_decode($data);
+                $data = json_decode($data);
 
-            Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
+                Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
 
-            switch ($request->getRequestInfo('http_code')) {
+                switch ($request->getRequestInfo('http_code')) {
 
-                case 204:
+                    case 204:
-                    Database::deleteSystemService($params['serviceid']);
+                        $this->cleanupPowerDnsForService($service);
-                    $this->updateWhmcsServiceParamsOnDestroy($params['serviceid']);
+                        Database::deleteSystemService($params['serviceid']);
-                    return 'success';
+                        $this->updateWhmcsServiceParamsOnDestroy($params['serviceid']);
-                    break;
 
-                case 404:
+                        return 'success';
-                    if (property_exists($data, 'msg')) {
+
-                        if ($data->msg == 'server not found') {
+                    case 404:
-                            Database::deleteSystemService($params['serviceid']);
+                        if (isset($data->msg)) {
-                            return 'success';
+                            if ($data->msg == 'server not found') {
+                                $this->cleanupPowerDnsForService($service);
+                                Database::deleteSystemService($params['serviceid']);
+
+                                return 'success';
+                            } else {
+                                return 'VirtFusion returned 404: ' . $data->msg;
+                            }
                         } else {
-                            return '404 was returned from the web service with the msg property but doesn\'t contain appropriate data to process a termination.';
+                            return 'VirtFusion returned 404 without details. The API may be unavailable.';
                         }
-                    } else {
-                        return '404 was returned from the web service without the msg property. The service may be currently unavailable.';
-                    }
-                    break;
 
-                default:
+                    default:
-                    return 'Termination request failed. The web service reported HTTP code ' . $request->getRequestInfo('http_code');
+                        return 'Termination request failed. VirtFusion API returned HTTP ' . $request->getRequestInfo('http_code');
-                    break;
+                }
             }
+
+            return 'Service not found in module database. Has termination already been run?';
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, $params, $e->getMessage());
+
+            return $e->getMessage();
         }
-        return 'Service not found. Termination routine has already been run?';
     }
 
     /**
+     * Delete any PTR records owned by this service before the local record is erased.
+     * The stored server_object is the last source of the IP list; once deleted from
+     * the module table we'd have no way to find them again. Non-fatal — DNS failures
+     * never block termination.
      *
-     * SUSPEND SERVER
+     * @param  object|null  $service  Row from mod_virtfusion_direct (has server_object JSON)
+     */
+    protected function cleanupPowerDnsForService($service): void
+    {
+        try {
+            if (! PowerDns\Config::isEnabled()) {
+                return;
+            }
+            if (! $service || empty($service->server_object)) {
+                return;
+            }
+            $decoded = json_decode($service->server_object, true);
+            if (! is_array($decoded)) {
+                return;
+            }
+            (new PowerDns\PtrManager)->deleteForServer($decoded);
+        } catch (\Throwable $e) {
+            Log::insert('PowerDns:terminate', ['service' => $service->service_id ?? null], $e->getMessage());
+        }
+    }
+
+    /**
+     * Suspend a VirtFusion server, queuing the action if another operation is in progress.
      *
-     * When requesting to suspend a server in VirtFusion it may be delayed if another action
+     * Returns 'success' whether the server is suspended immediately or queued for suspension.
-     * is being processed. This function will return success if the server is either suspended
-     * now or has been queued for suspension.
      *
+     * @param  array  $params  WHMCS service parameters
+     * @return string 'success' or an error message
      */
     public function suspendAccount($params)
     {
-        $service = Database::getSystemService($params['serviceid']);
+        try {
+            $service = Database::getSystemService($params['serviceid']);
 
-        if ($service) {
+            if ($service) {
 
-            $whmcsService = Database::getWhmcsService($params['serviceid']);
+                $whmcsService = Database::getWhmcsService($params['serviceid']);
+                if (! $whmcsService) {
+                    return 'WHMCS service record not found.';
+                }
 
-            $cp = $this->getCP($whmcsService->server);
+                $cp = $this->getCP($whmcsService->server);
-            $request = $this->initCurl($cp['token']);
+                if (! $cp) {
-            $data = $request->post($cp['url'] . '/servers/' . $service->server_id . '/suspend');
+                    return 'No control server found.';
-            $data = json_decode($data);
+                }
 
-            Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
+                $request = $this->initCurl($cp['token']);
+                $data = $request->post($cp['url'] . '/servers/' . (int) $service->server_id . '/suspend');
+                $data = json_decode($data);
 
-            switch ($request->getRequestInfo('http_code')) {
+                Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
 
-                case 204:
+                switch ($request->getRequestInfo('http_code')) {
-                    return 'success';
-                    break;
 
-                case 404:
+                    case 204:
-                    if (property_exists($data, 'msg')) {
+                        return 'success';
-                        if ($data->msg == 'server not found') {
+
-                            Database::deleteSystemService($params['serviceid']);
+                    case 404:
-                            return 'success';
+                        if (isset($data->msg)) {
+                            if ($data->msg == 'server not found') {
+                                Database::deleteSystemService($params['serviceid']);
+
+                                return 'success';
+                            } else {
+                                return 'VirtFusion returned 404: ' . $data->msg;
+                            }
                         } else {
-
+                            return 'VirtFusion returned 404 without details. The API may be unavailable.';
-                            return '404 was returned from the web service with the msg property but doesn\'t contain appropriate data to process a suspension.';
+                        }
+                    case 423:
+                        if (isset($data->msg)) {
+                            return $data->msg;
                         }
-                    } else {
-                        return '404 was returned from the web service without the msg property. The service may be currently unavailable.';
-                    }
-                    break;
-                case 423:
-                    if (property_exists($data, 'msg')) {
-                        return $data->msg;
-                    }
 
-                default:
+                        return 'The server is currently locked. Please try again later.';
-                    return 'Suspend request failed. The web service reported HTTP code ' . $request->getRequestInfo('http_code');
+
-                    break;
+                    default:
+                        return 'Suspend request failed. VirtFusion API returned HTTP ' . $request->getRequestInfo('http_code');
+                }
             }
+
+            return 'Service not found in module database.';
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, $params, $e->getMessage());
+
+            return $e->getMessage();
         }
-        return 'Service not found.';
     }
 
-    function updateServerObject($params)
+    /**
+     * Refresh the cached server object by fetching fresh data from the VirtFusion API.
+     *
+     * Updates both the module database record and the WHMCS service fields (IP, username, etc.).
+     *
+     * @param  array  $params  WHMCS service parameters
+     * @return string 'success' or an error message
+     */
+    public function updateServerObject($params)
     {
-        $service = Database::getSystemService($params['serviceid']);
+        try {
+            $service = Database::getSystemService($params['serviceid']);
 
-        if ($service) {
+            if ($service) {
 
-            $whmcsService = Database::getWhmcsService($params['serviceid']);
+                $whmcsService = Database::getWhmcsService($params['serviceid']);
+                if (! $whmcsService) {
+                    return 'WHMCS service record not found.';
+                }
 
-            $cp = $this->getCP($whmcsService->server);
+                $cp = $this->getCP($whmcsService->server);
-            $request = $this->initCurl($cp['token']);
+                if (! $cp) {
-            $data = $request->get($cp['url'] . '/servers/' . $service->server_id);
+                    return 'No control server found.';
-            $data = json_decode($data);
+                }
 
-            Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
+                $request = $this->initCurl($cp['token']);
+                $data = $request->get($cp['url'] . '/servers/' . (int) $service->server_id);
+                $data = json_decode($data);
 
-            switch ($request->getRequestInfo('http_code')) {
+                Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
 
-                case 200:
+                switch ($request->getRequestInfo('http_code')) {
-                    Database::updateSystemServiceServerObject($params['serviceid'], $data);
 
-                    $this->updateWhmcsServiceParamsOnServerObject($params['serviceid'], $data);
+                    case 200:
+                        Database::updateSystemServiceServerObject($params['serviceid'], $data);
 
-                    return 'success';
+                        $this->updateWhmcsServiceParamsOnServerObject($params['serviceid'], $data);
-                    break;
+
-                default:
+                        return 'success';
-                    return 'Request failed. The web service reported HTTP code ' . $request->getRequestInfo('http_code');
+                    default:
-                    break;
+                        return 'Request failed. VirtFusion API returned HTTP ' . $request->getRequestInfo('http_code');
+                }
             }
+
+            return 'Service not found in module database.';
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, $params, $e->getMessage());
+
+            return $e->getMessage();
         }
-        return 'Service not found.';
     }
 
-
+    /**
+     * Unsuspend a VirtFusion server, queuing the action if another operation is in progress.
+     *
+     * Returns 'success' whether the server is unsuspended immediately or queued for unsuspension.
+     *
+     * @param  array  $params  WHMCS service parameters
+     * @return string 'success' or an error message
+     */
     public function unsuspendAccount($params)
     {
-        $service = Database::getSystemService($params['serviceid']);
+        try {
+            $service = Database::getSystemService($params['serviceid']);
 
-        if ($service) {
+            if ($service) {
-            $whmcsService = Database::getWhmcsService($params['serviceid']);
+                $whmcsService = Database::getWhmcsService($params['serviceid']);
+                if (! $whmcsService) {
+                    return 'WHMCS service record not found.';
+                }
 
-            $cp = $this->getCP($whmcsService->server);
+                $cp = $this->getCP($whmcsService->server);
-            $request = $this->initCurl($cp['token']);
+                if (! $cp) {
-            $data = $request->post($cp['url'] . '/servers/' . $service->server_id . '/unsuspend');
+                    return 'No control server found.';
-            $data = json_decode($data);
+                }
 
-            Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
+                $request = $this->initCurl($cp['token']);
+                $data = $request->post($cp['url'] . '/servers/' . (int) $service->server_id . '/unsuspend');
+                $data = json_decode($data);
 
-            switch ($request->getRequestInfo('http_code')) {
+                Log::insert(__FUNCTION__, $request->getRequestInfo(), $data);
 
-                case 204:
+                switch ($request->getRequestInfo('http_code')) {
-                    return 'success';
-                    break;
 
-                case 404:
+                    case 204:
-                    if (property_exists($data, 'msg')) {
+                        return 'success';
-                        if ($data->msg == 'server not found') {
+
-                            Database::deleteSystemService($params['serviceid']);
+                    case 404:
-                            return 'success';
+                        if (isset($data->msg)) {
+                            if ($data->msg == 'server not found') {
+                                Database::deleteSystemService($params['serviceid']);
+
+                                return 'success';
+                            } else {
+                                return 'VirtFusion returned 404: ' . $data->msg;
+                            }
                         } else {
-                            return '404 was returned from the web service with the msg property but doesn\'t contain appropriate data to process an unsuspension.';
+                            return 'VirtFusion returned 404 without details. The API may be unavailable.';
+                        }
+                    case 423:
+                        if (isset($data->msg)) {
+                            return $data->msg;
                         }
-                    } else {
-                        return '404 was returned from the web service without the msg property. The service may be currently unavailable.';
-                    }
-                    break;
-                case 423:
-                    if (property_exists($data, 'msg')) {
-                        return $data->msg;
-                    }
 
-                default:
+                        return 'The server is currently locked. Please try again later.';
-                    return 'Unsuspend request failed. The web service reported HTTP code ' . $request->getRequestInfo('http_code');
+
-                    break;
+                    default:
+                        return 'Unsuspend request failed. VirtFusion API returned HTTP ' . $request->getRequestInfo('http_code');
+                }
             }
+
+            return 'Service not found in module database.';
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, $params, $e->getMessage());
+
+            return $e->getMessage();
         }
-        return 'Service not found';
     }
 
+    /**
+     * Generate the admin Services tab custom fields for a VirtFusion service.
+     *
+     * Returns fields for Server ID (editable), Server Info, Server Object (JSON viewer),
+     * and Options (action buttons), omitting Options for terminated services.
+     *
+     * @param  array  $params  WHMCS service parameters
+     * @return array Associative array of field label => HTML content
+     */
     public function adminServicesTabFields($params)
     {
-        $serverId = '';
+        try {
-        $serverObject = '';
+            $serverId = '';
+            $serverObject = '';
 
-        $service = Database::getSystemService($params['serviceid']);
+            $service = Database::getSystemService($params['serviceid']);
-        $systemUrl = Database::getSystemUrl();
+            $systemUrl = Database::getSystemUrl();
 
-        if ($service) {
+            if ($service) {
-            $serverId = $service->server_id;
+                $serverId = $service->server_id;
-            $serverObject = $service->server_object;
+                $serverObject = $service->server_object;
+            }
+            $fields = [
+                'Server ID' => AdminHTML::serverId($serverId),
+                'Server Info' => AdminHTML::serverInfo($systemUrl, $params['serviceid']),
+                'Server Object' => AdminHTML::serverObject($serverObject),
+            ];
+
+            if ($params['status'] != 'Terminated') {
+                $fields['Options'] = AdminHTML::options($systemUrl, $params['serviceid']);
+                if (PowerDns\Config::isEnabled()) {
+                    $fields['Reverse DNS'] = AdminHTML::rdnsSection($systemUrl, $params['serviceid']);
+                }
+            }
+
+            return $fields;
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, $params, $e->getMessage());
+
+            return [];
         }
-        $fields = [
-            'Server ID' => AdminHTML::serverId($serverId),
-            'Server Info' => AdminHTML::serverInfo($systemUrl, $params['serviceid']),
-            'Server Object' => AdminHTML::serverObject($serverObject),
-        ];
-
-        if ($params['status'] != 'Terminated') {
-            $fields['Options'] = AdminHTML::options($systemUrl, $params['serviceid']);
-        }
-
-        return $fields;
     }
 
+    /**
+     * Save the admin Services tab custom fields for a VirtFusion service.
+     *
+     * Deletes the module database record if the Server ID field is cleared,
+     * or updates it with the new integer server ID if a value is provided.
+     *
+     * @param  array  $params  WHMCS service parameters
+     * @return void
+     */
     public function adminServicesTabFieldsSave($params)
     {
-
+        try {
-        if ($_POST['modulefields'][0] == '') {
+            if (! isset($_POST['modulefields'][0]) || $_POST['modulefields'][0] === '') {
-            Database::deleteSystemService($params['serviceid']);
+                Database::deleteSystemService($params['serviceid']);
-        } else {
+            } else {
-
+                $serverId = (int) $_POST['modulefields'][0];
-            Database::updateSystemServiceServerId($params['serviceid'], $_POST['modulefields'][0]);
+                if ($serverId > 0) {
+                    Database::updateSystemServiceServerId($params['serviceid'], $serverId);
+                }
+            }
+        } catch (\Exception $e) {
+            Log::insert(__FUNCTION__, $params, $e->getMessage());
         }
     }
 
+    /**
+     * Perform a dry-run server creation to validate the current product configuration.
+     *
+     * Used by the WHMCS "Test Connection" button to confirm that the package, hypervisor,
+     * and IP settings are accepted by the VirtFusion API without creating a server.
+     *
+     * @param  array  $params  WHMCS service parameters
+     * @return string 'success' or an error message
+     */
+    public function validateServerConfig($params)
+    {
+        try {
+            $server = $params['serverid'] ?: false;
+            $cp = $this->getCP($server, ! $server);
+
+            if (! $cp) {
+                return 'No Control server found.';
+            }
+
+            $options = [
+                'packageId' => (int) $params['configoption2'],
+                'hypervisorId' => (int) $params['configoption1'],
+                'ipv4' => (int) $params['configoption3'],
+            ];
+
+            // We need a userId for dry run - use the service owner
+            if (isset($params['userid'])) {
+                $request = $this->initCurl($cp['token']);
+                $data = $request->get($cp['url'] . '/users/' . (int) $params['userid'] . '/byExtRelation');
+                if ($request->getRequestInfo('http_code') == 200) {
+                    $userData = json_decode($data);
+                    $options['userId'] = $userData->data->id;
+                }
+            }
+
+            $result = $this->validateServerCreation($options, $params['serverid']);
+
+            if ($result['valid']) {
+                return 'success';
+            }
+
+            return 'Validation failed: ' . implode(', ', $result['errors']);
+        } catch (\Exception $e) {
+            return 'Validation error: ' . $e->getMessage();
+        }
+    }
+
+    /**
+     * Render the client area overview tab for a VirtFusion service.
+     *
+     * Returns the template name and variables (system URL, service status, hostname,
+     * self-service mode) needed by the Smarty overview template. Falls back to an
+     * error template on any exception.
+     *
+     * @param  array  $params  WHMCS service parameters
+     * @return array Template name and variables for WHMCS to render
+     */
     public function clientArea($params)
     {
         $serverHostname = null;
@@ -463,6 +747,8 @@ class ModuleFunctions extends Module
                     'systemURL' => Database::getSystemUrl(),
                     'serviceStatus' => $params['status'],
                     'serverHostname' => $serverHostname,
+                    'selfServiceMode' => (int) ($params['configoption4'] ?? 0),
+                    'rdnsEnabled' => PowerDns\Config::isEnabled(),
                 ],
             ];
         } catch (\Throwable $e) {

modules/servers/VirtFusionDirect/lib/PowerDns/Client.php

@@ -0,0 +1,310 @@
+<?php
+
+namespace WHMCS\Module\Server\VirtFusionDirect\PowerDns;
+
+use WHMCS\Module\Server\VirtFusionDirect\Cache;
+use WHMCS\Module\Server\VirtFusionDirect\Curl;
+use WHMCS\Module\Server\VirtFusionDirect\Log;
+
+/**
+ * Thin HTTP wrapper around the PowerDNS Authoritative HTTP API.
+ *
+ * WHY A SEPARATE CLIENT INSTEAD OF REUSING MODULE::INITCURL()
+ * -----------------------------------------------------------
+ * Module::initCurl() is hardcoded to Bearer auth for VirtFusion. PowerDNS uses
+ * X-API-Key, and mixing the two authorization styles inside one factory method
+ * would either require a new flag (leaky abstraction) or accidental leakage of
+ * the VirtFusion token into a PowerDNS request. A dedicated wrapper keeps the
+ * two credential flows completely isolated — a bug in PowerDNS handling can
+ * never leak a VirtFusion token, and vice versa.
+ *
+ * LOGGING RULES
+ * -------------
+ * We NEVER pass the API key or any header containing it to Log::insert().
+ * PATCH/NOTIFY calls log the zone+operation+HTTP code, successes log minimally,
+ * errors include up to 500 bytes of response body (PowerDNS error responses are
+ * small JSON fragments, not customer data). The Curl class doesn't capture
+ * request headers by default (CURLOPT_HEADER is off), so even the internal
+ * request_header field doesn't contain the API key.
+ *
+ * CACHING
+ * -------
+ * listZones() caches the zone list via the module's Cache class (Redis/filesystem)
+ * for Config::cacheTtl() seconds. Zone lists rarely change — the TTL balances
+ * "pick up a newly-created zone soon" against "don't hammer PowerDNS for every
+ * listZones call across unrelated lifecycle events".
+ *
+ * getZone() and patchRRset() are NOT cached here; per-request memoisation of
+ * getZone results lives in PtrManager::getZoneCached so it can invalidate on
+ * write from within the same request.
+ *
+ * SINGLE-USE CURL INSTANCES
+ * -------------------------
+ * newCurl() returns a fresh Curl for every HTTP call. That's how the existing
+ * module's Curl class is designed — reusing a handle across requests produces
+ * undefined behaviour because options from the first call bleed into the second.
+ * It's cheap (curl_init is microseconds).
+ */
+class Client
+{
+    /** @var string */
+    private $endpoint;
+
+    /** @var string */
+    private $apiKey;
+
+    /** @var string */
+    private $serverId;
+
+    /**
+     * @param  array<string,mixed>|null  $config  Optional pre-resolved config; defaults to PowerDns\Config::get()
+     */
+    public function __construct(?array $config = null)
+    {
+        $config = $config ?? Config::get();
+        $this->endpoint = rtrim((string) ($config['endpoint'] ?? ''), '/');
+        $this->apiKey = (string) ($config['apiKey'] ?? '');
+        $this->serverId = (string) ($config['serverId'] ?? 'localhost');
+    }
+
+    /** Base URL for the configured PowerDNS server (no trailing slash). */
+    private function base(): string
+    {
+        return $this->endpoint . '/api/v1/servers/' . rawurlencode($this->serverId);
+    }
+
+    /**
+     * Encode a zone name to its PowerDNS URL-safe id form.
+     *
+     * PowerDNS's API uses a custom URL encoding for zone names that have characters
+     * like "/" which would collide with path semantics. Instead of using %-encoding
+     * (which many HTTP frameworks would parse back out at routing time), PowerDNS
+     * uses "=HH" where HH is the hex code — so "/" becomes "=2F".
+     *
+     * This only matters for RFC 2317 classless-delegation zone names like
+     * "64/64.113.0.203.in-addr.arpa." whose zone id in the API is
+     * "64=2F64.113.0.203.in-addr.arpa.". Standard zones pass through unchanged
+     * because they contain no "/" characters.
+     *
+     * Using rawurlencode() here would produce "%2F" which PowerDNS does NOT accept.
+     * That's why this is a plain str_replace.
+     */
+    private function zoneIdEncode(string $zoneName): string
+    {
+        return str_replace('/', '=2F', rtrim($zoneName, '.') . '.');
+    }
+
+    /** Fresh Curl instance with PowerDNS auth + JSON headers. */
+    private function newCurl(): Curl
+    {
+        $curl = new Curl;
+        $curl->addOption(CURLOPT_HTTPHEADER, [
+            'Accept: application/json',
+            'Content-Type: application/json; charset=utf-8',
+            'X-API-Key: ' . $this->apiKey,
+        ]);
+
+        return $curl;
+    }
+
+    /**
+     * Healthcheck. Returns [ok: bool, http: int, error: ?string].
+     * Used by the addon's Test Connection button and by VirtFusionDirect_TestConnection().
+     *
+     * @return array{ok: bool, http: int, error: ?string}
+     */
+    public function ping(): array
+    {
+        try {
+            $curl = $this->newCurl();
+            $body = $curl->get($this->base());
+            $http = (int) $curl->getRequestInfo('http_code');
+            if ($http === 200) {
+                return ['ok' => true, 'http' => 200, 'error' => null];
+            }
+            if ($http === 0) {
+                $err = (string) ($curl->getRequestInfo('curl_error') ?: 'connection failed');
+
+                return ['ok' => false, 'http' => 0, 'error' => $err];
+            }
+            if ($http === 401 || $http === 403) {
+                return ['ok' => false, 'http' => $http, 'error' => 'authentication failed (check API key)'];
+            }
+
+            return ['ok' => false, 'http' => $http, 'error' => 'unexpected HTTP ' . $http . ': ' . substr((string) $body, 0, 200)];
+        } catch (\Throwable $e) {
+            Log::insert('PowerDns:ping', [], $e->getMessage());
+
+            return ['ok' => false, 'http' => 0, 'error' => $e->getMessage()];
+        }
+    }
+
+    /**
+     * List every zone on the configured PowerDNS server.
+     *
+     * Result is cached for the configured cacheTtl. Used as the primary zone-discovery
+     * strategy: PtrManager finds the containing zone for a PTR name by longest-suffix
+     * matching against this list rather than probing individual zones.
+     *
+     * @return string[] Zone names with trailing dot
+     */
+    public function listZones(): array
+    {
+        $ttl = Config::cacheTtl();
+        $cacheKey = 'pdns:zones:' . md5($this->endpoint . '|' . $this->serverId);
+
+        $cached = Cache::get($cacheKey);
+        if (is_array($cached)) {
+            return $cached;
+        }
+
+        $zones = [];
+
+        try {
+            $curl = $this->newCurl();
+            $body = $curl->get($this->base() . '/zones');
+            $http = (int) $curl->getRequestInfo('http_code');
+
+            if ($http === 200) {
+                $decoded = json_decode((string) $body, true);
+                if (is_array($decoded)) {
+                    foreach ($decoded as $z) {
+                        if (! empty($z['name'])) {
+                            $zones[] = rtrim((string) $z['name'], '.') . '.';
+                        }
+                    }
+                }
+            } else {
+                Log::insert('PowerDns:listZones', ['http' => $http], substr((string) $body, 0, 500));
+            }
+        } catch (\Throwable $e) {
+            Log::insert('PowerDns:listZones', [], $e->getMessage());
+        }
+
+        Cache::set($cacheKey, $zones, $ttl);
+
+        return $zones;
+    }
+
+    /** Drop any cached zone list (call after PATCHes or settings changes). */
+    public function forgetZoneCache(): void
+    {
+        $cacheKey = 'pdns:zones:' . md5($this->endpoint . '|' . $this->serverId);
+        Cache::forget($cacheKey);
+    }
+
+    /**
+     * Fetch a single zone by name. Returns decoded JSON array, or null on 404/error.
+     *
+     * @return array<string,mixed>|null
+     */
+    public function getZone(string $zoneName): ?array
+    {
+        try {
+            $zoneName = rtrim($zoneName, '.') . '.';
+            $curl = $this->newCurl();
+            $body = $curl->get($this->base() . '/zones/' . $this->zoneIdEncode($zoneName));
+            $http = (int) $curl->getRequestInfo('http_code');
+            if ($http === 200) {
+                $decoded = json_decode((string) $body, true);
+
+                return is_array($decoded) ? $decoded : null;
+            }
+            if ($http !== 404) {
+                Log::insert('PowerDns:getZone', ['zone' => $zoneName, 'http' => $http], substr((string) $body, 0, 500));
+            }
+        } catch (\Throwable $e) {
+            Log::insert('PowerDns:getZone', ['zone' => $zoneName], $e->getMessage());
+        }
+
+        return null;
+    }
+
+    /**
+     * Apply an RRset change to a zone via PATCH.
+     *
+     * $rrset keys (per PowerDNS API): name, type, ttl?, changetype (REPLACE|DELETE|EXTEND), records[].
+     * On success PowerDNS returns 204 No Content.
+     *
+     * @return array{ok: bool, http: int, body: string}
+     */
+    public function patchRRset(string $zoneName, array $rrset): array
+    {
+        try {
+            $zoneName = rtrim($zoneName, '.') . '.';
+            if (isset($rrset['name'])) {
+                $rrset['name'] = rtrim((string) $rrset['name'], '.') . '.';
+            }
+
+            $payload = ['rrsets' => [$rrset]];
+            $curl = $this->newCurl();
+            $curl->addOption(CURLOPT_POSTFIELDS, json_encode($payload));
+            $body = $curl->patch($this->base() . '/zones/' . $this->zoneIdEncode($zoneName));
+            $http = (int) $curl->getRequestInfo('http_code');
+
+            Log::insert(
+                'PowerDns:patchRRset',
+                [
+                    'zone' => $zoneName,
+                    'name' => $rrset['name'] ?? null,
+                    'type' => $rrset['type'] ?? null,
+                    'changetype' => $rrset['changetype'] ?? null,
+                ],
+                ['http' => $http, 'body' => substr((string) $body, 0, 500)],
+            );
+
+            if ($http === 204) {
+                // Fire-and-forget NOTIFY so slaves pick up the bumped SOA serial immediately.
+                //
+                // Background: PowerDNS auto-increments SOA on every API write when the zone
+                // has soa_edit_api=INCREASE (recommended; see README). Slaves normally learn
+                // about the new serial via polling at the refresh interval (often 15+ min)
+                // OR via a NOTIFY push from the master. Without our NOTIFY, rDNS changes
+                // made via this module would take effect on the authoritative master
+                // immediately but wouldn't propagate until the next scheduled poll.
+                //
+                // Only meaningful for Master-kind zones. For Native zones (no slaves) or
+                // Slave zones (reverse direction), PowerDNS returns a 422 or similar —
+                // notifyZone() logs that and returns ok=false, but we don't care here:
+                // the PATCH itself succeeded, which is what we report upward.
+                $this->notifyZone($zoneName);
+            }
+
+            return ['ok' => $http === 204, 'http' => $http, 'body' => (string) $body];
+        } catch (\Throwable $e) {
+            Log::insert('PowerDns:patchRRset', ['zone' => $zoneName], $e->getMessage());
+
+            return ['ok' => false, 'http' => 0, 'body' => $e->getMessage()];
+        }
+    }
+
+    /**
+     * Send a DNS NOTIFY to all slaves for this zone. Only applicable to Master-kind zones;
+     * PowerDNS returns 400/422 for Native/Slave kinds and that's fine — we log and continue.
+     *
+     * SOA serial bumping itself is handled by PowerDNS (soa_edit_api=INCREASE or similar
+     * on the zone); this call just ensures slaves learn about the new serial right away
+     * rather than waiting for the next scheduled refresh.
+     *
+     * @return array{ok: bool, http: int}
+     */
+    public function notifyZone(string $zoneName): array
+    {
+        try {
+            $zoneName = rtrim($zoneName, '.') . '.';
+            $curl = $this->newCurl();
+            $body = $curl->put($this->base() . '/zones/' . $this->zoneIdEncode($zoneName) . '/notify');
+            $http = (int) $curl->getRequestInfo('http_code');
+
+            if ($http !== 200) {
+                Log::insert('PowerDns:notifyZone', ['zone' => $zoneName, 'http' => $http], substr((string) $body, 0, 300));
+            }
+
+            return ['ok' => $http === 200, 'http' => $http];
+        } catch (\Throwable $e) {
+            Log::insert('PowerDns:notifyZone', ['zone' => $zoneName], $e->getMessage());
+
+            return ['ok' => false, 'http' => 0];
+        }
+    }
+}

modules/servers/VirtFusionDirect/lib/PowerDns/Config.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace WHMCS\Module\Server\VirtFusionDirect\PowerDns;
+
+use WHMCS\Database\Capsule as DB;
+use WHMCS\Module\Server\VirtFusionDirect\Log;
+
+/**
+ * Loads PowerDNS addon settings from tbladdonmodules (module="virtfusiondns") and
+ * decrypts the API key using WHMCS's native decrypt() helper.
+ *
+ * WHY "LOOSE COUPLING" VIA TBLADDONMODULES
+ * ----------------------------------------
+ * WHMCS lets an operator activate/deactivate addon modules independently of server
+ * modules. If the server module required addon PHP code at load time (e.g. via
+ * require_once on the addon's files), deactivating the addon would fatal-error every
+ * checkout and service page.
+ *
+ * Instead, the server module reads raw rows from tbladdonmodules. If the addon is
+ * missing OR deactivated OR "enabled" is set to No, isEnabled() returns false and
+ * every PtrManager call site short-circuits. The server module never dereferences
+ * addon code directly; it just asks the DB "what are the PowerDNS settings?" and
+ * does nothing with them if they're absent.
+ *
+ * REQUEST-SCOPED CACHE
+ * --------------------
+ * get() caches the resolved config in a static property for the remainder of the
+ * PHP request. Without that, every PtrManager call would re-query tbladdonmodules
+ * and re-decrypt the API key — wasteful on the provisioning path where we touch
+ * PowerDNS 1-5 times per server. reset() is exposed for scenarios where settings
+ * change mid-request (the addon's _output() page after a vfdns_test click).
+ *
+ * API KEY HANDLING
+ * ----------------
+ * WHMCS stores password-type addon config fields encrypted in tbladdonmodules.value.
+ * We call decrypt() — the same helper the server-module uses for the VirtFusion
+ * bearer token — to get plaintext. If decryption fails (e.g. the WHMCS encryption
+ * key changed or the value was inserted manually as plaintext), we fall back to
+ * using the raw value. This is defensive; logs note the failure so an operator
+ * can diagnose.
+ *
+ * The decrypted key exists only in memory inside this process's request lifetime.
+ * It's passed to PowerDns\Client via the get() array and used for the X-API-Key
+ * header; it's never written to disk, logged, or sent anywhere except to the
+ * configured PowerDNS endpoint.
+ */
+class Config
+{
+    /**
+     * Name used for this addon in modules/addons/ AND stored in tbladdonmodules.module.
+     * These two MUST match — WHMCS auto-lowercases the module directory name when
+     * writing to the DB, so "VirtFusionDns" (directory) becomes "virtfusiondns" here.
+     */
+    public const MODULE_NAME = 'virtfusiondns';
+
+    /** @var array<string,mixed>|null Null = not loaded yet; an array = resolved settings */
+    private static $cached = null;
+
+    /**
+     * Force a reload on next get().
+     *
+     * Primary use case: the addon's _output() page calls this before re-fetching
+     * config so a test-connection click after saving settings sees the saved values.
+     * Most other code should NOT call this — the request-scoped cache is there for
+     * good performance reasons.
+     */
+    public static function reset(): void
+    {
+        self::$cached = null;
+    }
+
+    /**
+     * Return the fully-resolved configuration array with decrypted apiKey.
+     *
+     * Keys: enabled(bool), endpoint(string), apiKey(string), serverId(string),
+     *       defaultTtl(int), cacheTtl(int).
+     */
+    public static function get(): array
+    {
+        if (self::$cached !== null) {
+            return self::$cached;
+        }
+
+        $config = [
+            'enabled' => false,
+            'endpoint' => '',
+            'apiKey' => '',
+            'serverId' => 'localhost',
+            'defaultTtl' => 3600,
+            'cacheTtl' => 60,
+        ];
+
+        try {
+            // pluck('value', 'setting') returns a Collection keyed by 'setting' with
+            // 'value' as the values — so $rows['enabled'] reads the row where
+            // setting='enabled'. Efficient: one query regardless of how many
+            // settings exist.
+            $rows = DB::table('tbladdonmodules')
+                ->where('module', self::MODULE_NAME)
+                ->pluck('value', 'setting')
+                ->toArray();
+
+            // WHMCS yesno fields store either "on"/"" or "1"/"0" depending on version
+            // and form handling. Accept all common truthy representations rather than
+            // relying on a single literal.
+            $enabledRaw = $rows['enabled'] ?? '';
+            $config['enabled'] = in_array(strtolower((string) $enabledRaw), ['on', 'yes', '1', 'true'], true);
+
+            // Trim trailing slash from endpoint so Client::base() can safely concatenate
+            // "/api/v1/..." without producing doubled slashes.
+            $config['endpoint'] = rtrim((string) ($rows['endpoint'] ?? ''), '/');
+            $config['serverId'] = (string) ($rows['serverId'] ?? 'localhost');
+
+            // Floor at 60s for defaultTtl and 10s for cacheTtl. Prevents a foot-gun
+            // where an operator accidentally saves "0" and causes PowerDNS to treat
+            // PTRs as non-cacheable (which some resolvers refuse) or this module to
+            // hammer PowerDNS on every call.
+            $config['defaultTtl'] = max(60, (int) ($rows['defaultTtl'] ?? 3600));
+            $config['cacheTtl'] = max(10, (int) ($rows['cacheTtl'] ?? 60));
+
+            if (! empty($rows['apiKey'])) {
+                try {
+                    // decrypt() is WHMCS's global helper — matches how the VirtFusion
+                    // bearer token is handled in Module::getCP().
+                    $decrypted = decrypt($rows['apiKey']);
+
+                    // Fallback to raw value if decrypt returned empty or non-string —
+                    // defends against the rare case where decrypt silently fails
+                    // (wrong encryption key at rest) or the value was inserted
+                    // manually as plaintext during development.
+                    $config['apiKey'] = is_string($decrypted) && $decrypted !== '' ? $decrypted : (string) $rows['apiKey'];
+                } catch (\Throwable $e) {
+                    // Even when decrypt throws, we try the raw value so a diagnostic
+                    // path exists. Operator sees the decrypt error in the module log
+                    // but isn't locked out of using the addon while they investigate.
+                    $config['apiKey'] = (string) $rows['apiKey'];
+                    Log::insert('PowerDns:Config', 'decrypt skipped', $e->getMessage());
+                }
+            }
+        } catch (\Throwable $e) {
+            // Any DB-level failure (table doesn't exist, connection dropped, etc.)
+            // leaves $config at its safe defaults — isEnabled() returns false,
+            // nothing gets written to PowerDNS, and the server module continues
+            // to provision as if the addon weren't installed.
+            Log::insert('PowerDns:Config', 'load failed', $e->getMessage());
+        }
+
+        self::$cached = $config;
+
+        return $config;
+    }
+
+    /** True only when the addon is activated, configured, and has both endpoint and key. */
+    public static function isEnabled(): bool
+    {
+        $c = self::get();
+
+        return $c['enabled'] && $c['endpoint'] !== '' && $c['apiKey'] !== '';
+    }
+
+    public static function endpoint(): string
+    {
+        return self::get()['endpoint'];
+    }
+
+    public static function apiKey(): string
+    {
+        return self::get()['apiKey'];
+    }
+
+    public static function serverId(): string
+    {
+        return self::get()['serverId'];
+    }
+
+    public static function defaultTtl(): int
+    {
+        return self::get()['defaultTtl'];
+    }
+
+    public static function cacheTtl(): int
+    {
+        return self::get()['cacheTtl'];
+    }
+}

modules/servers/VirtFusionDirect/lib/PowerDns/IpUtil.php

@@ -0,0 +1,426 @@
+<?php
+
+namespace WHMCS\Module\Server\VirtFusionDirect\PowerDns;
+
+/**
+ * Pure static helpers for IP address manipulation and PTR-name construction.
+ *
+ * DESIGN NOTES
+ * ------------
+ * Everything here is pure — no I/O, no globals, no state. That matters for two reasons:
+ *   1. PtrManager can compose these helpers freely without worrying about test isolation.
+ *   2. They are safe to call inside tight loops (e.g. iterating every zone in PowerDNS
+ *      and testing it against a PTR name) without triggering hidden network or DB hits.
+ *
+ * Naming conventions used here:
+ *   - "PTR name"  = the fully-qualified record name the PTR lives at,
+ *                   e.g. "5.113.0.203.in-addr.arpa."  (trailing dot always).
+ *   - "zone name" = the zone the record belongs to,
+ *                   e.g. "113.0.203.in-addr.arpa."    (trailing dot always).
+ *   - "nibble"    = a single hex digit representing 4 bits, used in IPv6 reverse names.
+ *   - "classless" = an RFC 2317 sub-zone like "64/64.113.0.203.in-addr.arpa." —
+ *                   a delegation of a sub-range of a /24, covered in parseClasslessZone().
+ *
+ * All zone/PTR strings are normalised with a trailing dot because PowerDNS's canonical
+ * form always carries one, and mixing dotted/undotted forms makes string comparison
+ * unreliable (".example.com." ≠ ".example.com").
+ */
+class IpUtil
+{
+    /** Strict IPv4 validation (rejects "1", "::1", and other ambiguous forms). */
+    public static function isIpv4(string $ip): bool
+    {
+        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) !== false;
+    }
+
+    /** Strict IPv6 validation (rejects IPv4-mapped, etc. — only pure v6 addresses). */
+    public static function isIpv6(string $ip): bool
+    {
+        return filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) !== false;
+    }
+
+    /**
+     * Fully-expand an IPv6 address to 32 lowercase hex characters (no colons).
+     * e.g. 2001:db8::1 -> "20010db8000000000000000000000001"
+     *
+     * Why: PTR names under ip6.arpa use *all* 32 nibbles (no compression, no :: shorthand),
+     * so we need the fully-expanded form before we can reverse the nibbles.
+     *
+     * Implementation: inet_pton normalises any valid IPv6 notation to 16 raw bytes,
+     * and bin2hex turns that into 32 lowercase hex chars. No manual padding/splitting
+     * logic means we can't get ":" vs "::" compression wrong.
+     *
+     * @return string|null 32-char hex string, or null if input isn't valid IPv6
+     */
+    public static function expandIpv6(string $ip): ?string
+    {
+        $bin = @inet_pton($ip);
+        // inet_pton returns 16 bytes for v6, 4 bytes for v4. Guard on both conditions
+        // so a valid IPv4 like "192.0.2.1" doesn't silently pass through this v6 helper.
+        if ($bin === false || strlen($bin) !== 16) {
+            return null;
+        }
+
+        return bin2hex($bin);
+    }
+
+    /**
+     * Build the fully-qualified PTR name (trailing dot) for an IPv4 or IPv6 address.
+     *
+     * IPv4 example: 203.0.113.5 -> "5.113.0.203.in-addr.arpa."
+     * IPv6 example: 2001:db8::1 -> "1.0.0.0.[...].8.b.d.0.1.0.0.2.ip6.arpa."
+     *
+     * @return string|null PTR name with trailing dot, or null if input isn't a valid IP
+     */
+    public static function ptrNameForIp(string $ip): ?string
+    {
+        // IPv4: reverse the four octets and suffix with in-addr.arpa.
+        //   203.0.113.5  ->  5.113.0.203.in-addr.arpa.
+        if (self::isIpv4($ip)) {
+            $octets = array_reverse(explode('.', $ip));
+
+            return implode('.', $octets) . '.in-addr.arpa.';
+        }
+
+        // IPv6: expand to 32 nibbles, reverse each nibble, suffix with ip6.arpa.
+        //   2001:db8::1  ->  1.0.0.0.[...].8.b.d.0.1.0.0.2.ip6.arpa.
+        // The nibble-level reversal (not byte-level) is important: each hex digit
+        // becomes its own DNS label. inet_pton/bin2hex give us the 32-char form;
+        // str_split with no length arg defaults to 1 so each char becomes one label.
+        if (self::isIpv6($ip)) {
+            $hex = self::expandIpv6($ip);
+            if ($hex === null) {
+                return null;
+            }
+            $nibbles = array_reverse(str_split($hex));
+
+            return implode('.', $nibbles) . '.ip6.arpa.';
+        }
+
+        return null;
+    }
+
+    /**
+     * Extract every host IP address (v4 and v6) from a VirtFusion server object.
+     *
+     * Walks every interface, not just interfaces[0] (ServerResource only reads the primary).
+     * Handles both explicit `address` fields and `subnet`+`cidr` pairs.
+     * For IPv6 entries exposed only as `subnet`+`cidr`, the subnet base is used when
+     * the cidr is /128 (single host); otherwise the entry is skipped and reported.
+     *
+     * @param  object|array  $serverObject  Raw VirtFusion server payload (may be wrapped in `data`)
+     * @return array{addresses: string[], skipped: array} Deduped IP strings + array of skipped entries with reasons
+     */
+    public static function extractIps($serverObject): array
+    {
+        $addresses = [];
+        $skipped = [];
+
+        // Normalise object-or-array input. json_decode(json_encode($x), true) is the
+        // cheapest defensive way to turn a stdClass tree (VirtFusion's response) or
+        // an already-decoded array (stored server_object blob) into a uniform array.
+        if (is_object($serverObject)) {
+            $serverObject = json_decode(json_encode($serverObject), true);
+        }
+        if (! is_array($serverObject)) {
+            return ['addresses' => [], 'skipped' => []];
+        }
+
+        // VirtFusion wraps the payload in a "data" key on GET responses but the stored
+        // server_object blob is sometimes already unwrapped. Accept both shapes.
+        $data = $serverObject['data'] ?? $serverObject;
+        $interfaces = $data['network']['interfaces'] ?? [];
+        if (! is_array($interfaces)) {
+            return ['addresses' => [], 'skipped' => []];
+        }
+
+        // Walk every interface (not just interfaces[0]). ServerResource only reads [0]
+        // because it's building display data for the "primary" IP; rDNS needs PTRs
+        // for every IP no matter which interface it lives on.
+        foreach ($interfaces as $iface) {
+            foreach (($iface['ipv4'] ?? []) as $v4) {
+                // Accept both "address" and "ip" field names — VirtFusion's schema
+                // has evolved and we want the module to survive minor shape changes.
+                $candidate = $v4['address'] ?? ($v4['ip'] ?? null);
+                if ($candidate && self::isIpv4($candidate)) {
+                    // Use the IP as an array key for free de-duplication. If the same
+                    // IP appears on two interfaces (unusual but possible), we write
+                    // one PTR not two.
+                    $addresses[$candidate] = true;
+                }
+            }
+
+            foreach (($iface['ipv6'] ?? []) as $v6) {
+                // Preferred shape: a discrete host address (the normal v6 pattern).
+                $candidate = $v6['address'] ?? ($v6['ip'] ?? null);
+                if ($candidate && self::isIpv6($candidate)) {
+                    $addresses[$candidate] = true;
+
+                    continue;
+                }
+
+                // Fallback shape: VirtFusion sometimes exposes v6 only as subnet+cidr
+                // (common when a /64 is routed to the VPS and the OS auto-assigns
+                // specific host addresses). We can't set a PTR for the whole subnet,
+                // so we only accept /128 (single-host) entries and report the rest
+                // via the "skipped" channel so callers can surface a UI note.
+                $subnet = $v6['subnet'] ?? null;
+                $cidr = isset($v6['cidr']) ? (int) $v6['cidr'] : null;
+                if ($subnet && self::isIpv6($subnet)) {
+                    if ($cidr === 128) {
+                        $addresses[$subnet] = true;
+                    } else {
+                        $skipped[] = [
+                            'subnet' => $subnet,
+                            'cidr' => $cidr,
+                            'reason' => 'ipv6-subnet-without-explicit-host-address',
+                        ];
+                    }
+                }
+            }
+        }
+
+        // array_keys gives us the de-duplicated list in insertion order.
+        return ['addresses' => array_keys($addresses), 'skipped' => $skipped];
+    }
+
+    /**
+     * Find the longest-suffix zone from a list of zone names that contains a given PTR name.
+     * Both inputs are normalised to a trailing dot before matching.
+     *
+     * @param  string  $ptrName  Fully-qualified PTR name (with or without trailing dot)
+     * @param  string[]  $zones  List of zone names from PowerDNS (with or without trailing dots)
+     * @return string|null Matching zone name with trailing dot, or null if no zone covers the PTR
+     */
+    public static function findContainingZone(string $ptrName, array $zones): ?string
+    {
+        $ptrName = rtrim($ptrName, '.') . '.';
+        $best = null;
+        $bestLen = 0;
+
+        foreach ($zones as $zone) {
+            if (! is_string($zone) || $zone === '') {
+                continue;
+            }
+            if (strpos($zone, '/') !== false) {
+                // RFC 2317 classless zones can't be identified by plain suffix match:
+                // a PTR like "5.113.0.203.in-addr.arpa." does NOT end with
+                // ".64/64.113.0.203.in-addr.arpa." even when 5 is in range. Range
+                // matching lives in findZoneAndPtrName; this helper is kept for any
+                // caller that only deals with standard zones.
+                continue;
+            }
+            $z = rtrim($zone, '.') . '.';
+            // Prefix with "." so a zone "example.com." doesn't accidentally match
+            // "foo.anotherexample.com." via naive substring compare.
+            $suffix = '.' . $z;
+            if ($ptrName === $z || substr($ptrName, -strlen($suffix)) === $suffix) {
+                // Longest match wins. For nested delegations (e.g. both
+                // "0.203.in-addr.arpa." and "113.0.203.in-addr.arpa." exist),
+                // the more specific one is the correct authoritative zone.
+                $len = strlen($z);
+                if ($len > $bestLen) {
+                    $best = $z;
+                    $bestLen = $len;
+                }
+            }
+        }
+
+        return $best;
+    }
+
+    /**
+     * Parse an RFC 2317 classless-delegation IPv4 reverse zone name.
+     *
+     * RFC 2317 lets a /24 owner delegate sub-ranges of that /24 to separate
+     * authoritative servers by creating CNAMEs in the parent zone that point
+     * into a named sub-zone. The sub-zone's label conventionally uses "X/Y"
+     * where the slash carries structural meaning, not path semantics.
+     *
+     * Two "Y" conventions exist in the wild. We accept both:
+     *
+     *   (a) Y is a CIDR prefix length, Y ∈ [24, 32]. Standard per the RFC.
+     *       "64/26.113.0.203.in-addr.arpa." — /26 → 64 addresses → covers 64..127
+     *       "0/25.1.168.192.in-addr.arpa."  — /25 → 128 addresses → covers 0..127
+     *
+     *   (b) Y is a block size (count of addresses), Y > 32. Non-standard but
+     *       used by some operators because the label reads naturally:
+     *       "64/64.113.0.203.in-addr.arpa." — size 64 → covers 64..127
+     *
+     * We disambiguate by Y's magnitude: ≤32 is a prefix length, >32 is a count.
+     * (Y=32 would be "a single-host delegation", valid under convention (a).)
+     *
+     * ALIGNMENT CHECK
+     * ---------------
+     * We also verify X is a multiple of the block size. Misaligned entries
+     * like "3/26.x.y.z" don't correspond to any real DNS delegation — a /26
+     * must start at a multiple of 64 (0, 64, 128, or 192). Rejecting these
+     * prevents silent write-into-wrong-zone if an operator mis-names a zone.
+     *
+     * @return array{parent: string, start: int, end: int}|null
+     *                                                          parent: parent /24 reverse zone name with trailing dot (e.g. "113.0.203.in-addr.arpa.")
+     *                                                          start/end: inclusive last-octet range covered by this classless zone
+     */
+    public static function parseClasslessZone(string $zone): ?array
+    {
+        $zone = rtrim($zone, '.') . '.';
+
+        // Structural gate 1: must end in .in-addr.arpa. — classless only applies to IPv4.
+        if (substr($zone, -strlen('.in-addr.arpa.')) !== '.in-addr.arpa.') {
+            return null;
+        }
+
+        // Structural gate 2: must have at least 5 labels to contain both the
+        // classless label and a full /24 parent: "X/Y . o . o . o . in-addr . arpa . ''"
+        // The trailing empty label from the terminal dot bumps this to ≥ 7 in practice,
+        // but 5 is the minimum we need to safely slice below.
+        $labels = explode('.', $zone);
+        if (count($labels) < 5) {
+            return null;
+        }
+
+        // Structural gate 3: the first label must contain a "/". If not, this is a
+        // standard zone (e.g. "113.0.203.in-addr.arpa.") — let the caller handle it.
+        $first = $labels[0];
+        if (strpos($first, '/') === false) {
+            return null;
+        }
+
+        // Parse "X/Y" — reject if either side isn't a non-negative integer.
+        $parts = explode('/', $first, 2);
+        if (count($parts) !== 2 || ! ctype_digit($parts[0]) || ! ctype_digit($parts[1])) {
+            return null;
+        }
+        $x = (int) $parts[0];
+        $y = (int) $parts[1];
+
+        // X must fit in an octet; Y must be positive (0 and negative make no sense).
+        if ($x < 0 || $x > 255 || $y <= 0) {
+            return null;
+        }
+
+        // Map Y → block size using the dual-convention rule described in the doc-block.
+        if ($y <= 32) {
+            // CIDR prefix convention. Values <24 would cross /24 boundaries (outside
+            // the scope of a single-/24 delegation), >32 is impossible for IPv4.
+            if ($y < 24 || $y > 32) {
+                return null;
+            }
+            // 1 << (32 - Y) gives the block size. Y=24→256 (whole /24), Y=32→1 (host).
+            $size = 1 << (32 - $y);
+        } else {
+            // Block-size convention. Accept any positive Y that fits the /24 range check below.
+            $size = $y;
+        }
+
+        // Alignment: X must sit on a block boundary. For size=64, legal starts are
+        // 0, 64, 128, 192. Mis-alignments indicate a misconfigured zone label.
+        if ($x % $size !== 0) {
+            return null;
+        }
+
+        $end = $x + $size - 1;
+        // The range must stay within the parent /24 (last octet 0..255).
+        if ($end > 255) {
+            return null;
+        }
+
+        // The parent zone is everything after the first label, i.e. the /24 reverse zone.
+        // array_slice(labels, 1) drops "X/Y" and the implode reconstructs the trailing-dot form.
+        $parent = implode('.', array_slice($labels, 1));
+
+        return ['parent' => $parent, 'start' => $x, 'end' => $end];
+    }
+
+    /**
+     * Resolve an IP to its (zone, ptrName) pair in one shot, handling both standard
+     * reverse zones and RFC 2317 classless delegations.
+     *
+     * For a classless match, the returned ptrName includes the classless zone
+     * label (e.g. "100.64/64.113.0.203.in-addr.arpa.") — this is the actual DNS
+     * name the PTR record lives at in PowerDNS. Classless zones take precedence
+     * over any matching parent zone, because in a properly-delegated setup the
+     * parent only holds CNAMEs pointing into the classless sub-zone.
+     *
+     * @param  string[]  $zones  Zone names from PowerDNS (trailing dots optional)
+     * @return array{zone: string, ptrName: string}|null
+     */
+    public static function findZoneAndPtrName(string $ip, array $zones): ?array
+    {
+        $ptrName = self::ptrNameForIp($ip);
+        if ($ptrName === null) {
+            return null;
+        }
+
+        $ipv4 = self::isIpv4($ip);
+        // Extract the last octet up front for classless range comparison.
+        // Only meaningful for IPv4 since RFC 2317 is IPv4-only (IPv6 delegations
+        // naturally align on nibble boundaries and don't need classless tricks).
+        $lastOctet = null;
+        if ($ipv4) {
+            $octets = explode('.', $ip);
+            $lastOctet = (int) $octets[3];
+        }
+
+        $bestDirect = null;
+        $bestDirectLen = 0;
+        $classlessMatch = null;
+
+        // Single pass over the zone list, bucketing each candidate into the
+        // classless path or the direct-suffix-match path.
+        foreach ($zones as $zone) {
+            if (! is_string($zone) || $zone === '') {
+                continue;
+            }
+            $z = rtrim($zone, '.') . '.';
+
+            if (strpos($z, '/') !== false) {
+                // Classless path. Skip for IPv6 entirely.
+                if (! $ipv4) {
+                    continue;
+                }
+                $parsed = self::parseClasslessZone($z);
+                if ($parsed === null) {
+                    // Malformed classless zone name (misaligned, wrong TLD, etc.) — skip.
+                    continue;
+                }
+                // The PTR still needs to suffix-match the PARENT zone; otherwise the
+                // classless zone lives under a different /24 and isn't relevant.
+                $parentSuffix = '.' . $parsed['parent'];
+                if (substr($ptrName, -strlen($parentSuffix)) !== $parentSuffix) {
+                    continue;
+                }
+                // Range gate: the host octet must fall inside this classless zone's window.
+                if ($lastOctet < $parsed['start'] || $lastOctet > $parsed['end']) {
+                    continue;
+                }
+                // The record name inside a classless zone prepends the full host octet
+                // to the classless label, e.g. PTR "100" lives at:
+                //   "100.64/64.113.0.203.in-addr.arpa."
+                // (NOT "100.113.0.203.in-addr.arpa." — the classless sub-zone holds the RRset).
+                $classlessMatch = [
+                    'zone' => $z,
+                    'ptrName' => $lastOctet . '.' . $z,
+                ];
+
+                continue;
+            }
+
+            // Direct suffix-match path (standard reverse zones).
+            $suffix = '.' . $z;
+            if ($ptrName === $z || substr($ptrName, -strlen($suffix)) === $suffix) {
+                // Longest-match wins (see findContainingZone() for rationale).
+                if (strlen($z) > $bestDirectLen) {
+                    $bestDirect = ['zone' => $z, 'ptrName' => $ptrName];
+                    $bestDirectLen = strlen($z);
+                }
+            }
+        }
+
+        // PRECEDENCE: classless beats direct. In a correctly-delegated RFC 2317 setup
+        // the parent /24 zone only contains CNAMEs pointing into the classless sub-zone —
+        // it does NOT hold the PTR RRset directly. Writing to the parent would create a
+        // record that's shadowed by the CNAME and never consulted during resolution.
+        return $classlessMatch ?? $bestDirect;
+    }
+}

modules/servers/VirtFusionDirect/lib/PowerDns/PtrManager.php

@@ -0,0 +1,716 @@
+<?php
+
+namespace WHMCS\Module\Server\VirtFusionDirect\PowerDns;
+
+use WHMCS\Database\Capsule as DB;
+use WHMCS\Module\Server\VirtFusionDirect\Cache;
+use WHMCS\Module\Server\VirtFusionDirect\Database;
+use WHMCS\Module\Server\VirtFusionDirect\Log;
+
+/**
+ * Orchestrates PTR lifecycle against PowerDNS for VirtFusion servers.
+ *
+ * RESPONSIBILITIES
+ * ----------------
+ *  - Compute zone membership for a given IP by matching against PowerDNS's zone list
+ *  - Verify forward DNS (A/AAAA) before writing any PTR; never write a PTR whose
+ *    hostname doesn't already resolve to the target IP
+ *  - Preserve client-customised PTRs during server renames (only overwrite PTRs
+ *    whose current content equals the previous hostname)
+ *  - Provide read-through views for client-area and admin panels with status flags
+ *  - Support an explicit admin reconcile (optionally forceful) and an additive-only
+ *    cron reconciliation that never overwrites existing values
+ *
+ * CACHING MODEL
+ * -------------
+ * Two tiers, both serving different purposes:
+ *
+ *   $zoneListCache   — the list of every zone PowerDNS knows about. Populated once
+ *                      per PtrManager instance via locate(). The underlying Client
+ *                      caches the HTTP response for Config::cacheTtl() seconds across
+ *                      requests; this instance field just memoises the lookup within
+ *                      one request so multiple IPs on the same server don't each
+ *                      call Client::listZones().
+ *
+ *   $zoneCache       — decoded RRset contents of individual zones, keyed by zone
+ *                      name. Populated lazily as findPtrRRset() looks up each IP's
+ *                      zone. IMPORTANT: request-scoped only — we must invalidate on
+ *                      writes (see invalidateZone) so a read-after-write within the
+ *                      same request sees fresh data. This is why deletePtr/writePtr
+ *                      call invalidateZone before returning.
+ *
+ * Neither cache is shared between PtrManager instances (new PtrManager per WHMCS
+ * request is cheap). The Client's HTTP-response cache IS shared across requests via
+ * the module's Cache class (Redis or filesystem), which is where cross-request
+ * amortisation happens.
+ *
+ * SHORT-CIRCUIT BEHAVIOUR
+ * -----------------------
+ * Every public method checks Config::isEnabled() and returns an empty/no-op summary
+ * when the addon is inactive. This means unrelated calling code (createAccount,
+ * terminateAccount, renameServer, the client panel endpoint, cron) can always
+ * invoke PtrManager without a feature flag — the gate lives here.
+ *
+ * The summary arrays deliberately include 'enabled' => bool so test harnesses and
+ * admin UIs can tell "we did nothing because disabled" apart from "we did nothing
+ * because there were no IPs".
+ */
+class PtrManager
+{
+    /** @var Client */
+    private $client;
+
+    /** @var array<string, array<string,mixed>|null> Request-scoped zone contents cache, keyed by zone name */
+    private $zoneCache = [];
+
+    /** @var string[]|null Request-scoped zone-list memo (Client handles cross-request caching) */
+    private $zoneListCache = null;
+
+    public function __construct(?Client $client = null)
+    {
+        // Dependency-inject the Client so tests can pass a mock; default to the
+        // Config-driven instance so production code never has to wire this up.
+        $this->client = $client ?? new Client;
+    }
+
+    // -----------------------------------------------------------------------
+    // Public API
+    // -----------------------------------------------------------------------
+
+    /**
+     * Sync PTRs for every IP on the given server object.
+     *
+     * TWO MODES OF OPERATION
+     * ----------------------
+     *   CREATE  ($oldHostname = null) — provisioning path.
+     *                                   Write $newHostname to every IP that doesn't
+     *                                   already have a PTR. Pre-existing PTRs are
+     *                                   preserved (shouldn't exist on a new server,
+     *                                   but if they do they're likely left over from
+     *                                   a previous owner of the IP and must not be
+     *                                   silently overwritten).
+     *
+     *   RENAME  ($oldHostname given)  — rename path.
+     *                                   Only overwrite PTRs whose current content
+     *                                   equals $oldHostname. Anything else was set
+     *                                   by the client (custom rDNS like mail servers
+     *                                   need to match HELO) and must be preserved.
+     *
+     * The forward-DNS check runs before every write. A PTR without a matching
+     * A/AAAA is FCrDNS-broken and actively harms deliverability, so we'd rather
+     * leave the PTR absent than set a broken one.
+     *
+     * ERROR SEMANTICS
+     * ---------------
+     * This method never throws. Every per-IP failure is caught, logged, and
+     * recorded in $summary['errors']. Lifecycle callers (createAccount,
+     * renameServer) wrap the call in their own try/catch as belt-and-braces,
+     * but the expectation is that DNS issues never bubble up to WHMCS as
+     * provisioning failures.
+     *
+     * @param  object|array  $serverObject  VirtFusion server payload
+     * @return array Summary counts: written, preserved, forward_missing, no_zone, skipped_ipv6, errors, details[]
+     */
+    public function syncServer($serverObject, ?string $oldHostname, string $newHostname): array
+    {
+        $summary = [
+            'enabled' => false,
+            'written' => 0,
+            'preserved' => 0,
+            'forward_missing' => 0,
+            'no_zone' => 0,
+            'skipped_ipv6' => 0,
+            'errors' => 0,
+            'details' => [],
+        ];
+
+        if (! Config::isEnabled()) {
+            return $summary;
+        }
+        $summary['enabled'] = true;
+
+        $extracted = IpUtil::extractIps($serverObject);
+        // Report (not write) v6 subnet-only allocations. UI can surface "IPv6 PTR
+        // not configured — /64 without explicit host" as guidance.
+        $summary['skipped_ipv6'] = count($extracted['skipped']);
+
+        foreach ($extracted['addresses'] as $ip) {
+            try {
+                $loc = $this->locate($ip);
+                if ($loc === null) {
+                    // IP isn't covered by any zone we host. Not an error — the
+                    // operator may manage reverse DNS for this range elsewhere.
+                    $summary['no_zone']++;
+                    $summary['details'][] = ['ip' => $ip, 'status' => 'no-zone'];
+
+                    continue;
+                }
+
+                $current = $this->readPtr($loc);
+
+                // Rename-mode preservation check. The "current PTR equals old
+                // hostname" comparison is the whole safety mechanism for protecting
+                // client-custom rDNS across server renames — see class docblock.
+                // On CREATE mode ($oldHostname === null) we skip this branch,
+                // which means pre-existing PTRs on a new IP get overwritten; this
+                // is acceptable because a fresh IP shouldn't have PTRs yet.
+                if ($oldHostname !== null && $current !== null) {
+                    if (self::normalizeHost($current) !== self::normalizeHost($oldHostname)) {
+                        $summary['preserved']++;
+                        $summary['details'][] = ['ip' => $ip, 'status' => 'preserved', 'current' => $current];
+
+                        continue;
+                    }
+                }
+
+                if (! Resolver::resolvesTo($newHostname, $ip, Config::cacheTtl())) {
+                    $summary['forward_missing']++;
+                    $summary['details'][] = ['ip' => $ip, 'status' => 'forward-missing', 'desired' => $newHostname];
+                    Log::insert('PowerDns:syncServer', ['ip' => $ip, 'hostname' => $newHostname], 'forward DNS mismatch; PTR skipped');
+
+                    continue;
+                }
+
+                $result = $this->writePtr($loc, $newHostname);
+                if ($result['ok']) {
+                    $summary['written']++;
+                    $summary['details'][] = ['ip' => $ip, 'status' => 'written', 'content' => $newHostname];
+                } else {
+                    $summary['errors']++;
+                    $summary['details'][] = ['ip' => $ip, 'status' => 'error', 'http' => $result['http']];
+                }
+            } catch (\Throwable $e) {
+                $summary['errors']++;
+                Log::insert('PowerDns:syncServer', ['ip' => $ip], $e->getMessage());
+            }
+        }
+
+        return $summary;
+    }
+
+    /**
+     * Delete every PTR belonging to the given server.
+     *
+     * @return array Summary counts: deleted, no_zone, errors
+     */
+    public function deleteForServer($serverObject): array
+    {
+        $summary = ['enabled' => false, 'deleted' => 0, 'no_zone' => 0, 'errors' => 0];
+        if (! Config::isEnabled()) {
+            return $summary;
+        }
+        $summary['enabled'] = true;
+
+        $extracted = IpUtil::extractIps($serverObject);
+        foreach ($extracted['addresses'] as $ip) {
+            try {
+                $loc = $this->locate($ip);
+                if ($loc === null) {
+                    $summary['no_zone']++;
+
+                    continue;
+                }
+                $result = $this->deletePtr($loc);
+                if ($result['ok']) {
+                    $summary['deleted']++;
+                } else {
+                    $summary['errors']++;
+                }
+            } catch (\Throwable $e) {
+                $summary['errors']++;
+                Log::insert('PowerDns:deleteForServer', ['ip' => $ip], $e->getMessage());
+            }
+        }
+
+        return $summary;
+    }
+
+    /**
+     * Produce a per-IP status list suitable for client-area and admin display.
+     *
+     * Each entry: [ip, ptr, ttl, zone, status]
+     * Status values: ok, unverified, missing, no-zone, error, disabled.
+     *
+     * @return array<int, array<string,mixed>>
+     */
+    public function listPtrs($serverObject, ?string $expectedHostname = null): array
+    {
+        $out = [];
+        $extracted = IpUtil::extractIps($serverObject);
+
+        if (! Config::isEnabled()) {
+            foreach ($extracted['addresses'] as $ip) {
+                $out[] = ['ip' => $ip, 'ptr' => null, 'ttl' => null, 'zone' => null, 'status' => 'disabled'];
+            }
+
+            return $out;
+        }
+
+        foreach ($extracted['addresses'] as $ip) {
+            try {
+                $loc = $this->locate($ip);
+                if ($loc === null) {
+                    $out[] = ['ip' => $ip, 'ptr' => null, 'ttl' => null, 'zone' => null, 'status' => 'no-zone'];
+
+                    continue;
+                }
+                $rrset = $this->findPtrRRset($loc);
+                if ($rrset === null) {
+                    $out[] = ['ip' => $ip, 'ptr' => null, 'ttl' => null, 'zone' => $loc['zone'], 'status' => 'missing'];
+
+                    continue;
+                }
+                $ptr = $rrset['content'];
+                $status = Resolver::resolvesTo($ptr, $ip, Config::cacheTtl()) ? 'ok' : 'unverified';
+                $out[] = [
+                    'ip' => $ip,
+                    'ptr' => $ptr,
+                    'ttl' => $rrset['ttl'],
+                    'zone' => $loc['zone'],
+                    'status' => $status,
+                ];
+            } catch (\Throwable $e) {
+                Log::insert('PowerDns:listPtrs', ['ip' => $ip], $e->getMessage());
+                $out[] = ['ip' => $ip, 'ptr' => null, 'ttl' => null, 'zone' => null, 'status' => 'error'];
+            }
+        }
+
+        return $out;
+    }
+
+    /**
+     * Client-initiated PTR set/delete.
+     *
+     * Differences from syncServer():
+     *   - Only ever writes one PTR, not a whole server's worth
+     *   - Rate-limited per IP (10s window) to stop save-button abuse
+     *   - Forward-DNS failure is a HARD REJECT that surfaces to the user — not a
+     *     silent skip like the automatic paths. The client wants immediate feedback
+     *     when their A record is missing.
+     *   - Empty content path is an explicit delete (DELETE changetype, not REPLACE-empty)
+     *
+     * IP-OWNERSHIP NOTE
+     * -----------------
+     * This method TRUSTS that the caller has already verified the client owns $ip —
+     * that check lives in the calling endpoint (client.php rdnsUpdate) where it has
+     * access to the WHMCS session. If you call setPtr() from a new code path, you
+     * MUST add the ownership guard upstream of it.
+     *
+     * @return array{ok: bool, reason: string, http?: int}
+     *                                                     reason values: disabled, invalid-ip, rate-limited, no-zone,
+     *                                                     forward-missing, deleted, delete-failed, written, write-failed
+     */
+    public function setPtr(string $ip, string $content): array
+    {
+        if (! Config::isEnabled()) {
+            return ['ok' => false, 'reason' => 'disabled'];
+        }
+        if (! (IpUtil::isIpv4($ip) || IpUtil::isIpv6($ip))) {
+            return ['ok' => false, 'reason' => 'invalid-ip'];
+        }
+
+        // Rate limit: one successful check per IP per 10s. Uses the module's
+        // two-tier Cache (Redis or filesystem), so the limit spans PHP processes.
+        // md5 of IP as the key keeps filesystem filenames short and safe.
+        $rateKey = 'pdns:write-lock:' . md5($ip);
+        if (Cache::get($rateKey) !== null) {
+            return ['ok' => false, 'reason' => 'rate-limited'];
+        }
+        // Set the lock BEFORE any downstream work so a parallel request racing
+        // through the same IP sees the lock and gets rate-limited cleanly.
+        Cache::set($rateKey, 1, 10);
+
+        $loc = $this->locate($ip);
+        if ($loc === null) {
+            return ['ok' => false, 'reason' => 'no-zone'];
+        }
+
+        $content = trim($content);
+        if ($content === '') {
+            $result = $this->deletePtr($loc);
+
+            return ['ok' => $result['ok'], 'reason' => $result['ok'] ? 'deleted' : 'delete-failed', 'http' => $result['http']];
+        }
+
+        if (! Resolver::resolvesTo($content, $ip, Config::cacheTtl())) {
+            return ['ok' => false, 'reason' => 'forward-missing'];
+        }
+
+        $result = $this->writePtr($loc, $content);
+
+        return ['ok' => $result['ok'], 'reason' => $result['ok'] ? 'written' : 'write-failed', 'http' => $result['http']];
+    }
+
+    /**
+     * Admin reconciliation for a single service.
+     *
+     * The user-facing purpose: "make the PTRs match what they should be, but don't
+     * step on client customisations unless I explicitly ask".
+     *
+     * Uses the STORED server_object (from mod_virtfusion_direct) rather than fetching
+     * fresh from VirtFusion. Reasons:
+     *   1. Admin reconcile runs from the services tab — no live-data dependency
+     *   2. Cron calls this once per service; fetching fresh would mean N VirtFusion
+     *      calls per reconcile run
+     *   3. The stored object is the ground truth for "what IPs/hostname did this
+     *      service have at last sync" — if VirtFusion temporarily returns a different
+     *      shape, we'd rather work from known-good data than retry.
+     *
+     * If the stored state is materially out of date (e.g. IPs were added in VirtFusion
+     * after last sync), an admin should hit "Update Server Object" first.
+     *
+     * FORCE MODE
+     * ----------
+     * $force = true is the only code path in the entire module that overwrites a
+     * non-matching PTR. It's reachable exclusively via the admin "Reconcile (force
+     * reset)" button — never from cron, never from client writes, never from
+     * automatic lifecycle. This asymmetry is deliberate: forceful overrides are
+     * the admin's explicit choice, not a silent automation.
+     *
+     * @return array Summary counts: added, reset, preserved, forward_missing, no_zone, errors
+     */
+    public function reconcile(int $serviceId, bool $force = false): array
+    {
+        $summary = [
+            'enabled' => false,
+            'added' => 0,
+            'reset' => 0,
+            'preserved' => 0,
+            'forward_missing' => 0,
+            'no_zone' => 0,
+            'errors' => 0,
+        ];
+        if (! Config::isEnabled()) {
+            return $summary;
+        }
+        $summary['enabled'] = true;
+
+        $row = Database::getSystemService($serviceId);
+        if (! $row || empty($row->server_object)) {
+            $summary['errors']++;
+
+            return $summary;
+        }
+        $serverObject = json_decode($row->server_object, true);
+        if (! is_array($serverObject)) {
+            $summary['errors']++;
+
+            return $summary;
+        }
+
+        $hostname = self::extractHostname($serverObject);
+        if ($hostname === null) {
+            $summary['errors']++;
+
+            return $summary;
+        }
+
+        $extracted = IpUtil::extractIps($serverObject);
+        foreach ($extracted['addresses'] as $ip) {
+            try {
+                $loc = $this->locate($ip);
+                if ($loc === null) {
+                    $summary['no_zone']++;
+
+                    continue;
+                }
+
+                $current = $this->readPtr($loc);
+                $verified = Resolver::resolvesTo($hostname, $ip, Config::cacheTtl());
+
+                if ($current === null) {
+                    if (! $verified) {
+                        $summary['forward_missing']++;
+
+                        continue;
+                    }
+                    $result = $this->writePtr($loc, $hostname);
+                    if ($result['ok']) {
+                        $summary['added']++;
+                    } else {
+                        $summary['errors']++;
+                    }
+
+                    continue;
+                }
+
+                if ($force && self::normalizeHost($current) !== self::normalizeHost($hostname)) {
+                    if (! $verified) {
+                        $summary['forward_missing']++;
+
+                        continue;
+                    }
+                    $result = $this->writePtr($loc, $hostname);
+                    if ($result['ok']) {
+                        $summary['reset']++;
+                    } else {
+                        $summary['errors']++;
+                    }
+
+                    continue;
+                }
+
+                $summary['preserved']++;
+            } catch (\Throwable $e) {
+                $summary['errors']++;
+                Log::insert('PowerDns:reconcile', ['ip' => $ip, 'service' => $serviceId], $e->getMessage());
+            }
+        }
+
+        return $summary;
+    }
+
+    /**
+     * Cron reconciliation across every managed service.
+     *
+     * Called from the DailyCronJob hook. Iterates every row in mod_virtfusion_direct
+     * and runs reconcile() on each with $force = false. That means:
+     *
+     *   - IPs missing a PTR get one (if forward DNS resolves)
+     *   - Existing PTRs are NEVER touched, even if they differ from the hostname
+     *
+     * This asymmetry is the safety property. A brief forward-DNS blip during the
+     * cron window shouldn't trigger mass-rewrites that corrupt client-custom
+     * records. Admins who need forceful re-alignment must run the per-service
+     * "Reconcile (force reset)" button explicitly.
+     *
+     * Failures on individual services are logged and counted but never abort the
+     * job — a misconfigured single zone or one VirtFusion-unreachable service
+     * should not block reconciliation for the rest of the fleet.
+     *
+     * @return array Aggregate summary across all services
+     */
+    public function reconcileAll(): array
+    {
+        $summary = [
+            'enabled' => false,
+            'services' => 0,
+            'added' => 0,
+            'preserved' => 0,
+            'forward_missing' => 0,
+            'no_zone' => 0,
+            'errors' => 0,
+        ];
+        if (! Config::isEnabled()) {
+            return $summary;
+        }
+        $summary['enabled'] = true;
+
+        try {
+            $rows = DB::table(Database::SYSTEM_TABLE)->pluck('service_id');
+        } catch (\Throwable $e) {
+            Log::insert('PowerDns:reconcileAll', [], $e->getMessage());
+
+            return $summary;
+        }
+
+        foreach ($rows as $serviceId) {
+            $summary['services']++;
+
+            try {
+                $r = $this->reconcile((int) $serviceId, false);
+                $summary['added'] += $r['added'];
+                $summary['preserved'] += $r['preserved'];
+                $summary['forward_missing'] += $r['forward_missing'];
+                $summary['no_zone'] += $r['no_zone'];
+                $summary['errors'] += $r['errors'];
+            } catch (\Throwable $e) {
+                $summary['errors']++;
+                Log::insert('PowerDns:reconcileAll:service', ['service' => $serviceId], $e->getMessage());
+            }
+        }
+
+        Log::insert('PowerDns:reconcileAll', [], $summary);
+
+        return $summary;
+    }
+
+    // -----------------------------------------------------------------------
+    // Internal
+    // -----------------------------------------------------------------------
+
+    /**
+     * Resolve an IP to the (zone, ptrName) pair using the cached zone list.
+     * Handles both standard and RFC 2317 classless zones (delegates to IpUtil).
+     *
+     * Memoised within this instance: the zone list is fetched once (via the Client,
+     * which itself caches across requests per Config::cacheTtl()) and reused for
+     * every IP of the current server. A server with 3 IPs in the same /24 therefore
+     * triggers ONE listZones call, not three.
+     *
+     * @return array{zone: string, ptrName: string}|null null means "no zone covers this IP"
+     */
+    private function locate(string $ip): ?array
+    {
+        if ($this->zoneListCache === null) {
+            $this->zoneListCache = $this->client->listZones();
+        }
+
+        return IpUtil::findZoneAndPtrName($ip, $this->zoneListCache);
+    }
+
+    /** @return array<string,mixed>|null */
+    private function getZoneCached(string $zoneName): ?array
+    {
+        if (array_key_exists($zoneName, $this->zoneCache)) {
+            return $this->zoneCache[$zoneName];
+        }
+        $this->zoneCache[$zoneName] = $this->client->getZone($zoneName);
+
+        return $this->zoneCache[$zoneName];
+    }
+
+    /**
+     * Current PTR content for a located address, or null if absent.
+     *
+     * @param  array{zone: string, ptrName: string}  $loc
+     */
+    private function readPtr(array $loc): ?string
+    {
+        $rrset = $this->findPtrRRset($loc);
+
+        return $rrset === null ? null : $rrset['content'];
+    }
+
+    /**
+     * Find a PTR RRset at the located name.
+     *
+     * @param  array{zone: string, ptrName: string}  $loc
+     * @return array{content: string, ttl: int}|null
+     */
+    private function findPtrRRset(array $loc): ?array
+    {
+        $zone = $this->getZoneCached($loc['zone']);
+        if ($zone === null || empty($zone['rrsets']) || ! is_array($zone['rrsets'])) {
+            return null;
+        }
+        foreach ($zone['rrsets'] as $rrset) {
+            if (($rrset['type'] ?? '') !== 'PTR') {
+                continue;
+            }
+            if (self::normalizeHost($rrset['name'] ?? '') !== self::normalizeHost($loc['ptrName'])) {
+                continue;
+            }
+            $records = $rrset['records'] ?? [];
+            foreach ($records as $record) {
+                if (! empty($record['disabled'])) {
+                    continue;
+                }
+                if (! empty($record['content'])) {
+                    return [
+                        'content' => rtrim((string) $record['content'], '.'),
+                        'ttl' => (int) ($rrset['ttl'] ?? Config::defaultTtl()),
+                    ];
+                }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Write/replace a PTR record.
+     *
+     * Always uses REPLACE changetype rather than a create-then-update pattern —
+     * REPLACE is idempotent and atomic from PowerDNS's view, whereas separate
+     * create + update would briefly leave the record absent.
+     *
+     * Content is canonicalised to end with a trailing dot before sending (PowerDNS
+     * treats unqualified names as relative to the zone, which is not what we want
+     * for PTR content — "host.example.com" without a trailing dot would be stored
+     * as "host.example.com.113.0.203.in-addr.arpa.").
+     *
+     * @param  array{zone: string, ptrName: string}  $loc
+     * @return array{ok: bool, http: int}
+     */
+    private function writePtr(array $loc, string $content): array
+    {
+        $content = rtrim(trim($content), '.') . '.';
+        $ttl = Config::defaultTtl();
+
+        $result = $this->client->patchRRset($loc['zone'], [
+            'name' => $loc['ptrName'],
+            'type' => 'PTR',
+            'ttl' => $ttl,
+            'changetype' => 'REPLACE',
+            'records' => [['content' => $content, 'disabled' => false]],
+        ]);
+
+        $this->invalidateZone($loc['zone']);
+
+        return ['ok' => $result['ok'], 'http' => $result['http']];
+    }
+
+    /**
+     * Delete a PTR record.
+     *
+     * @param  array{zone: string, ptrName: string}  $loc
+     * @return array{ok: bool, http: int}
+     */
+    private function deletePtr(array $loc): array
+    {
+        $result = $this->client->patchRRset($loc['zone'], [
+            'name' => $loc['ptrName'],
+            'type' => 'PTR',
+            'changetype' => 'DELETE',
+        ]);
+
+        $this->invalidateZone($loc['zone']);
+
+        return ['ok' => $result['ok'], 'http' => $result['http']];
+    }
+
+    /**
+     * Drop the cached zone contents so the next read re-fetches from PowerDNS.
+     * Called after every successful write so read-after-write in the same request
+     * (e.g. listPtrs right after setPtr in a test harness) observes fresh data.
+     */
+    private function invalidateZone(string $zoneName): void
+    {
+        unset($this->zoneCache[$zoneName]);
+    }
+
+    /**
+     * Normalise a hostname for comparison: lowercase, no trailing dot.
+     *
+     * DNS hostnames are case-insensitive and the trailing dot is syntactic, not
+     * semantic. PowerDNS returns content with a trailing dot ("host.example.com.");
+     * user input typically doesn't have one. Both forms of "FooBar.example.com."
+     * vs "foobar.example.com" should compare equal, which is what this produces.
+     */
+    private static function normalizeHost(string $h): string
+    {
+        return strtolower(rtrim(trim($h), '.'));
+    }
+
+    /**
+     * Extract the server hostname from a VirtFusion server payload.
+     *
+     * Accepts either object or array shape, wrapped or unwrapped by a `data` property.
+     * Falls back to `name` when `hostname` is absent or "-", matching the semantics
+     * of the existing ServerResource::process() behavior.
+     *
+     * Public so lifecycle call sites (createAccount, renameServer) can pull the
+     * hostname from a response or stored JSON blob without duplicating the logic.
+     *
+     * @param  object|array  $serverObject
+     */
+    public static function extractHostname($serverObject): ?string
+    {
+        if (is_object($serverObject)) {
+            $serverObject = json_decode(json_encode($serverObject), true);
+        }
+        if (! is_array($serverObject)) {
+            return null;
+        }
+        $data = $serverObject['data'] ?? $serverObject;
+        if (! empty($data['hostname']) && $data['hostname'] !== '-') {
+            return (string) $data['hostname'];
+        }
+        if (! empty($data['name']) && $data['name'] !== '-') {
+            return (string) $data['name'];
+        }
+
+        return null;
+    }
+}

modules/servers/VirtFusionDirect/lib/PowerDns/Resolver.php

@@ -0,0 +1,140 @@
+<?php
+
+namespace WHMCS\Module\Server\VirtFusionDirect\PowerDns;
+
+use WHMCS\Module\Server\VirtFusionDirect\Cache;
+use WHMCS\Module\Server\VirtFusionDirect\Log;
+
+/**
+ * Public-DNS verification helper used for forward-confirmed reverse DNS (FCrDNS) checks.
+ *
+ * WHAT FCrDNS IS AND WHY IT MATTERS HERE
+ * --------------------------------------
+ * A PTR record by itself is easy to lie about — anyone who controls a reverse zone
+ * can say "this IP is mail.example.com". Receivers defend against that by looking
+ * UP the hostname the PTR claims and checking that its A/AAAA records point back
+ * at the IP. That "two-way agreement" is FCrDNS.
+ *
+ * For mail deliverability in particular, a PTR without matching forward DNS is
+ * worse than no PTR at all — some filters treat it as evidence of a compromised
+ * host. The module enforces FCrDNS before every PTR write: if the user asks us
+ * to set "mail.example.com" as the PTR for 1.2.3.4 but mail.example.com resolves
+ * to something other than 1.2.3.4, we refuse.
+ *
+ * USES PUBLIC DNS, NOT POWERDNS
+ * -----------------------------
+ * This calls dns_get_record(), which hits the system's configured recursive
+ * resolver. That's deliberate: the hostname in a PTR may live in a zone hosted
+ * anywhere (client's own domain, another DNS provider, etc.) — not necessarily
+ * in the PowerDNS instance we're managing. Using the recursive public view means
+ * our verification matches what mail servers and other FCrDNS checkers actually
+ * see downstream.
+ *
+ * CNAME FOLLOWING
+ * ---------------
+ * If the hostname is itself a CNAME, dns_get_record returns the CNAME record
+ * (with DNS_CNAME flag) rather than auto-resolving to the ultimate A/AAAA. We
+ * follow up to MAX_CNAME_DEPTH hops before giving up. The depth cap prevents
+ * accidental infinite loops from misconfigured zones and bounds work per check.
+ *
+ * CACHING
+ * -------
+ * Keyed by md5(hostname|ip). A bad-A-record result lives in the cache just like
+ * a good one, which means a client who fixes their forward DNS must wait up to
+ * cacheTtl seconds before a retry succeeds. Documented in the admin settings
+ * tooltip as the tradeoff for not hammering authoritative resolvers when a
+ * user mashes the Save button while debugging.
+ */
+class Resolver
+{
+    private const CACHE_PREFIX = 'pdns:resolve:';
+
+    /**
+     * Maximum hops through a CNAME chain before we give up.
+     * Real-world chains are usually 0-2 hops; 5 is generous headroom without
+     * letting a loop run unbounded.
+     */
+    private const MAX_CNAME_DEPTH = 5;
+
+    /**
+     * Does the public DNS A/AAAA of $hostname resolve to $ip?
+     * Follows up to 5 CNAME hops. Cached for $ttl seconds on the initial call.
+     */
+    public static function resolvesTo(string $hostname, string $ip, int $ttl = 60): bool
+    {
+        $hostname = rtrim(trim($hostname), '.');
+        if ($hostname === '' || ! (IpUtil::isIpv4($ip) || IpUtil::isIpv6($ip))) {
+            return false;
+        }
+
+        $cacheKey = self::CACHE_PREFIX . md5($hostname . '|' . $ip);
+        $cached = Cache::get($cacheKey);
+        if ($cached !== null) {
+            return (bool) $cached;
+        }
+
+        $match = self::resolveInternal($hostname, $ip, 0);
+        Cache::set($cacheKey, $match ? 1 : 0, $ttl);
+
+        return $match;
+    }
+
+    private static function resolveInternal(string $hostname, string $ip, int $depth): bool
+    {
+        if ($depth > self::MAX_CNAME_DEPTH) {
+            return false;
+        }
+
+        // Request both the matching forward type AND CNAME in one query so we see
+        // the whole picture at each hop. If the hostname is a direct A/AAAA, we
+        // see that and match immediately; if it's a CNAME, we see the target and
+        // recurse.
+        $type = IpUtil::isIpv6($ip) ? DNS_AAAA | DNS_CNAME : DNS_A | DNS_CNAME;
+        $records = [];
+
+        try {
+            // @-suppress: dns_get_record emits a PHP warning on NXDOMAIN, which we'd
+            // rather just treat as "no match". The return value (empty array or false)
+            // tells us the same thing without polluting the error log.
+            $records = @dns_get_record($hostname, $type);
+        } catch (\Throwable $e) {
+            // Some PHP configurations throw on resolver failure instead of returning false.
+            // We treat those as "no match" and log once per (hostname, ip) since callers
+            // cache the result — we won't spam the log even for a permanently-broken name.
+            Log::insert('PowerDns:Resolver', ['hostname' => $hostname, 'ip' => $ip], $e->getMessage());
+
+            return false;
+        }
+        if (! is_array($records)) {
+            // dns_get_record returns false on resolver failure. Same semantics as above.
+            return false;
+        }
+
+        // Convert target to binary once, outside the loop. inet_pton normalises
+        // "2001:db8::1" and "2001:0db8:0000:0000:0000:0000:0000:0001" to the same
+        // bytes, so we can compare regardless of how the resolver formatted its reply.
+        $targetBin = @inet_pton($ip);
+        foreach ($records as $r) {
+            $t = $r['type'] ?? null;
+            if ($t === 'CNAME') {
+                // CNAME hop: recurse on the target. We don't use a visited-set to
+                // detect cycles — MAX_CNAME_DEPTH is a simpler, sufficient guard.
+                $next = $r['target'] ?? null;
+                if ($next && self::resolveInternal(rtrim($next, '.'), $ip, $depth + 1)) {
+                    return true;
+                }
+
+                continue;
+            }
+
+            // A records expose the address under 'ip', AAAA records under 'ipv6'.
+            // Only one of these will be set per record; the other is null.
+            $candidate = $r['ip'] ?? ($r['ipv6'] ?? null);
+            if ($candidate && $targetBin !== false && @inet_pton($candidate) === $targetBin) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

modules/servers/VirtFusionDirect/lib/ServerResource.php

@@ -2,47 +2,128 @@
 
 namespace WHMCS\Module\Server\VirtFusionDirect;
 
+/**
+ * Transforms a VirtFusion API server response into a flat key-value array for Smarty templates and admin display.
+ *
+ * WHY A FLAT ARRAY
+ * ----------------
+ * Smarty templates can traverse nested structures (`{$data.network.interfaces[0].ipv4[0].address}`)
+ * but that leaks the API shape into the template layer. A flat array ("hostname",
+ * "primaryNetwork.ipv4[]", "memoryRaw", etc.) decouples the template from the upstream
+ * schema: if VirtFusion renames `network.interfaces` tomorrow, only this file needs
+ * to change.
+ *
+ * PRIMARY-INTERFACE-ONLY DESIGN
+ * -----------------------------
+ * process() only reads interfaces[0]. That's the primary network — the one the
+ * client-area "Overview" card displays. Servers with multiple interfaces (common
+ * for dedicated IPMI networks, storage networks, etc.) still work for display
+ * because the primary interface holds the customer-facing IP.
+ *
+ * The reverse-DNS subsystem (PowerDns\IpUtil::extractIps) walks ALL interfaces
+ * explicitly because PTRs matter for every IP no matter which NIC it's on.
+ * If you add a feature that needs secondary-interface data for display, do NOT
+ * generalise this class — add a new one or a helper that doesn't disturb the
+ * well-tested primary-interface behaviour.
+ *
+ * UNIT CONVERSIONS
+ * ----------------
+ * VirtFusion stores:
+ *   - traffic as bytes (usage) or GB (limits)
+ *   - storage as GB (limits) or bytes (usage)
+ *   - memory as MB
+ * WHMCS expects MB for storage/traffic in tblhosting. This class produces two
+ * pairs of values per resource: a human-readable string with unit suffix
+ * (e.g. "200 GB") AND a raw integer without the unit (for slider UIs and
+ * arithmetic). Keep both — removing one breaks a UI consumer somewhere.
+ *
+ * "-" SENTINELS
+ * -------------
+ * Fields that are missing or empty are rendered as "-" rather than empty strings.
+ * That makes the client-area card always have content (a dash is a valid visual
+ * placeholder) and distinguishes "missing data" from "empty string returned by
+ * the API". Consumers who need boolean presence checks should test against "-",
+ * not "" / null — and upstream (e.g. updateWhmcsServiceParamsOnServerObject)
+ * already does.
+ */
 class ServerResource
 {
+    /**
+     * Normalise a VirtFusion API server response into a flat associative array.
+     *
+     * @param  object  $data  VirtFusion API server response object (with a `data` property)
+     * @return array Flat associative array containing server name, hostname, resources, network info, and usage
+     */
     public function process($data)
     {
         $server = json_decode(json_encode($data->data), true);
 
-        $traffic = '∞';
+        $traffic = '-';
 
-        if ($server['settings']['resources']['traffic']) {
+        if (isset($server['settings']['resources']['traffic'])) {
             if ($server['settings']['resources']['traffic'] > 0) {
                 $traffic = $server['settings']['resources']['traffic'] . ' GB';
+            } else {
+                $traffic = 'Unlimited';
             }
         }
 
+        $trafficUsed = '-';
+        if (isset($server['usage']['traffic']['used'])) {
+            $trafficUsed = round($server['usage']['traffic']['used'] / 1073741824, 2) . ' GB';
+        } elseif (isset($server['settings']['resources']['traffic']) && $server['settings']['resources']['traffic'] > 0) {
+            $trafficUsed = '0 GB';
+        }
+
         $data = [
             'name' => $server['name'] ?: '-',
             'hostname' => $server['hostname'] ?: '-',
-            'memory' => $server['settings']['resources']['memory'] . ' MB',
+            'memory' => isset($server['settings']['resources']['memory']) ? $server['settings']['resources']['memory'] . ' MB' : '-',
             'traffic' => $traffic,
-            'storage' => $server['settings']['resources']['storage'] . ' GB',
+            'trafficUsed' => $trafficUsed,
-            'cpu' => $server['settings']['resources']['cpuCores'] . ' Core(s)',
+            'storage' => isset($server['settings']['resources']['storage']) ? $server['settings']['resources']['storage'] . ' GB' : '-',
+            'cpu' => isset($server['settings']['resources']['cpuCores']) ? $server['settings']['resources']['cpuCores'] . ' Core(s)' : '-',
+            'status' => isset($server['state']) ? $server['state'] : 'unknown',
+            'powerStatus' => isset($server['hypervisor']['settings']['state']) ? $server['hypervisor']['settings']['state'] : 'unknown',
+            'username' => isset($server['owner']['email']) ? $server['owner']['email'] : '',
+            'password' => '',
             'primaryNetwork' => [
                 'ipv4' => ['-'],
                 'ipv4Unformatted' => [],
                 'ipv6' => ['-'],
                 'ipv6Unformatted' => [],
-            ]
+                'mac' => '-',
+            ],
+            'networkSpeed' => [
+                'inbound' => isset($server['settings']['resources']['networkSpeedInbound']) ? $server['settings']['resources']['networkSpeedInbound'] . ' Mbps' : '-',
+                'outbound' => isset($server['settings']['resources']['networkSpeedOutbound']) ? $server['settings']['resources']['networkSpeedOutbound'] . ' Mbps' : '-',
+            ],
+            'vncEnabled' => isset($server['vnc']['enabled']) ? (bool) $server['vnc']['enabled'] : false,
+            'memoryRaw' => isset($server['settings']['resources']['memory']) ? (int) $server['settings']['resources']['memory'] : 0,
+            'cpuRaw' => isset($server['settings']['resources']['cpuCores']) ? (int) $server['settings']['resources']['cpuCores'] : 0,
+            'storageRaw' => isset($server['settings']['resources']['storage']) ? (int) $server['settings']['resources']['storage'] : 0,
+            'trafficRaw' => isset($server['settings']['resources']['traffic']) ? (int) $server['settings']['resources']['traffic'] : 0,
+            'trafficUsedRaw' => isset($server['usage']['traffic']['used']) ? round($server['usage']['traffic']['used'] / 1073741824, 2) : 0,
+            'networkSpeedInboundRaw' => isset($server['settings']['resources']['networkSpeedInbound']) ? (int) $server['settings']['resources']['networkSpeedInbound'] : 0,
+            'networkSpeedOutboundRaw' => isset($server['settings']['resources']['networkSpeedOutbound']) ? (int) $server['settings']['resources']['networkSpeedOutbound'] : 0,
         ];
 
         if (array_key_exists('network', $server)) {
             if (array_key_exists('interfaces', $server['network'])) {
                 if (count($server['network']['interfaces'])) {
 
-                    if (count($server['network']['interfaces'][0]['ipv4'])) {
+                    if (isset($server['network']['interfaces'][0]['mac'])) {
+                        $data['primaryNetwork']['mac'] = $server['network']['interfaces'][0]['mac'];
+                    }
+
+                    if (isset($server['network']['interfaces'][0]['ipv4']) && count($server['network']['interfaces'][0]['ipv4'])) {
                         $data['primaryNetwork']['ipv4'] = [];
                         foreach ($server['network']['interfaces'][0]['ipv4'] as $ip) {
                             $data['primaryNetwork']['ipv4'][] = $ip['address'];
                         }
                     }
 
-                    if (count($server['network']['interfaces'][0]['ipv6'])) {
+                    if (isset($server['network']['interfaces'][0]['ipv6']) && count($server['network']['interfaces'][0]['ipv6'])) {
                         $data['primaryNetwork']['ipv6'] = [];
                         foreach ($server['network']['interfaces'][0]['ipv6'] as $ip) {
                             $data['primaryNetwork']['ipv6'][] = $ip['subnet'] . '/' . $ip['cidr'];
@@ -59,4 +140,4 @@ class ServerResource
 
         return $data;
     }
-}
+}

modules/servers/VirtFusionDirect/templates/css/module.css

@@ -1 +1,547 @@
-.vf-bold{font-weight:800}.vf-small{font-size:.9rem}.vf-button{font-size:.8rem;padding:.95rem 1.5rem;font-weight:600}.vf-button-small{font-size:.8rem;padding:.75rem 1.3rem;font-weight:500}.vf-spinner-margin{margin-right:7px}.vf-badge{font-size:.8rem;padding:.5rem .9rem;text-transform:uppercase;font-weight:800}.vf-badge-active{background-color:rgba(32,177,0,.12);color:#276900;border-radius:6px}.vf-badge-awaiting{background-color:rgba(177,89,0,.12);color:#692000;border-radius:6px}#vf-login-button-spinner{display:none}#vf-password-reset-button-spinner{display:none}#vf-password-reset-error{display:none}#vf-password-reset-success{display:none}#vf-login-error{display:none}#vf-server-info{display:none}#vf-server-info-error{display:none}#vf-server-info-loader{min-height:136px}#vf-loading{display:inline-block;width:30px;height:30px;border:3px solid rgba(225,224,224,.3);border-radius:50%;border-top-color:#0e151a;animation:vf-spin 1s ease-in-out infinite;-webkit-animation:vf-spin 1s ease-in-out infinite}.vf-loader{margin:30px}@keyframes vf-spin{to{transform:rotate(360deg)}}@-webkit-keyframes vf-spin{to{transform:rotate(360deg)}}#vf-server-info-error{margin:10px}
+/* VirtFusion Direct Provisioning Module Styles */
+
+/* Typography */
+.vf-bold {
+    font-weight: 800;
+}
+.vf-small {
+    font-size: 0.9rem;
+}
+
+/* Buttons */
+.vf-spinner-margin {
+    margin-right: 7px;
+}
+
+/* Status Badges */
+.vf-badge {
+    font-size: 0.75rem;
+    padding: 0.35rem 0.75rem;
+    text-transform: uppercase;
+    font-weight: 700;
+    border-radius: 6px;
+    display: inline-block;
+}
+.vf-badge-active {
+    background-color: rgba(32, 177, 0, 0.12);
+    color: #276900;
+}
+.vf-badge-awaiting {
+    background-color: rgba(177, 89, 0, 0.12);
+    color: #692000;
+}
+.vf-badge-suspended {
+    background-color: rgba(220, 53, 69, 0.12);
+    color: #721c24;
+}
+
+/* Power Management */
+.vf-power-buttons {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+}
+.vf-btn-power {
+    min-width: 100px;
+    font-weight: 600;
+    text-transform: uppercase;
+    font-size: 0.8rem;
+    padding: 0.5rem 1rem;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 5px;
+}
+
+/* Hidden elements (initial state) */
+#vf-login-button-spinner {
+    display: none;
+}
+#vf-password-reset-button-spinner {
+    display: none;
+}
+#vf-password-reset-error {
+    display: none;
+}
+#vf-password-reset-success {
+    display: none;
+}
+#vf-login-error {
+    display: none;
+}
+#vf-server-info {
+    display: none;
+}
+#vf-server-info-error {
+    display: none;
+    margin: 10px;
+}
+
+/* Skeleton Loading */
+.vf-skeleton {
+    background: linear-gradient(90deg, #e9ecef 25%, #f4f4f4 50%, #e9ecef 75%);
+    background-size: 200% 100%;
+    animation: vf-skeleton-pulse 1.5s ease-in-out infinite;
+    border-radius: 4px;
+}
+.vf-skeleton-line {
+    height: 14px;
+    margin-bottom: 10px;
+    border-radius: 4px;
+}
+.vf-skeleton-line-short {
+    width: 60%;
+}
+.vf-skeleton-line-medium {
+    width: 80%;
+}
+@keyframes vf-skeleton-pulse {
+    0% { background-position: 200% 0; }
+    100% { background-position: -200% 0; }
+}
+
+/* Action Progress Banner */
+#vf-action-progress {
+    background: #337ab7;
+    color: #fff;
+    padding: 8px 16px;
+    border-radius: 6px;
+    margin-bottom: 12px;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    font-size: 0.85rem;
+}
+#vf-action-progress .spinner-border {
+    width: 16px;
+    height: 16px;
+    border-width: 2px;
+}
+
+/* Loader */
+#vf-server-info-loader {
+    min-height: 136px;
+}
+#vf-loading {
+    display: inline-block;
+    width: 30px;
+    height: 30px;
+    border: 3px solid rgba(225, 224, 224, 0.3);
+    border-radius: 50%;
+    border-top-color: #0e151a;
+    animation: vf-spin 1s ease-in-out infinite;
+    -webkit-animation: vf-spin 1s ease-in-out infinite;
+}
+.vf-loader {
+    margin: 30px;
+}
+
+@keyframes vf-spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+@-webkit-keyframes vf-spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+/* Network / IP Management */
+.vf-ip-row {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 4px 0;
+}
+.vf-ip-address {
+    font-family: monospace;
+    font-size: 0.9rem;
+}
+/* Backup Timeline */
+.vf-timeline {
+    position: relative;
+    padding-left: 20px;
+    border-left: 2px solid #dee2e6;
+    margin-left: 8px;
+}
+.vf-timeline-item {
+    position: relative;
+    padding: 8px 0 8px 12px;
+}
+.vf-timeline-dot {
+    position: absolute;
+    left: -27px;
+    top: 12px;
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    border: 2px solid #fff;
+}
+.vf-timeline-dot-success {
+    background: #28a745;
+}
+.vf-timeline-dot-pending {
+    background: #ffc107;
+}
+.vf-timeline-content {
+    font-size: 0.85rem;
+}
+
+/* Server Name Dropdown */
+#vf-name-dropdown {
+    position: relative;
+    background: #fff;
+    border: 1px solid #dee2e6;
+    border-radius: 6px;
+    margin-top: 4px;
+    max-width: 250px;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+    z-index: 10;
+}
+.vf-name-option {
+    padding: 6px 12px;
+    cursor: pointer;
+    font-family: monospace;
+    font-size: 0.85rem;
+    border-bottom: 1px solid #f0f0f0;
+}
+.vf-name-option:last-child {
+    border-bottom: none;
+}
+.vf-name-option:hover {
+    background: rgba(51,122,183,0.06);
+}
+
+/* Copy to Clipboard */
+.vf-ip-copy {
+    padding: 2px 5px;
+    line-height: 1;
+    color: #6c757d;
+    background: none;
+    border: 1px solid transparent;
+    border-radius: 3px;
+    cursor: pointer;
+    vertical-align: middle;
+}
+.vf-ip-copy:hover {
+    color: #337ab7;
+    background: rgba(51,122,183,0.08);
+    border-color: rgba(51,122,183,0.2);
+}
+.vf-copy-tooltip {
+    position: absolute;
+    margin-left: 4px;
+    padding: 2px 8px;
+    font-size: 0.75rem;
+    color: #fff;
+    background: #28a745;
+    border-radius: 3px;
+    white-space: nowrap;
+    animation: vf-fade-in 0.2s ease;
+}
+@keyframes vf-fade-in {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+/* OS Template Gallery */
+.vf-os-category-header {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    padding: 10px 12px;
+    margin-top: 6px;
+    border: 1px solid #dee2e6;
+    border-radius: 6px;
+    cursor: pointer;
+    font-weight: 700;
+    font-size: 0.9rem;
+    user-select: none;
+    transition: background 0.15s;
+}
+.vf-os-category:first-child .vf-os-category-header {
+    margin-top: 0;
+}
+.vf-os-category-header:hover {
+    background: rgba(0,0,0,0.03);
+}
+.vf-os-category-icon {
+    width: 28px;
+    height: 28px;
+    min-width: 28px;
+    min-height: 28px;
+    border-radius: 6px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: #fff;
+    font-weight: 700;
+    font-size: 0.85rem;
+    flex-shrink: 0;
+    overflow: hidden;
+}
+.vf-os-category-icon img {
+    max-width: 100%;
+    max-height: 100%;
+    width: auto;
+    height: auto;
+    object-fit: contain;
+}
+.vf-os-category-arrow {
+    margin-left: auto;
+    font-size: 0.7rem;
+    color: #888;
+}
+.vf-os-grid {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    padding: 10px 0;
+    margin-bottom: 4px;
+}
+.vf-os-card {
+    width: 120px;
+    border: 2px solid #dee2e6;
+    border-radius: 8px;
+    padding: 10px 8px;
+    text-align: center;
+    cursor: pointer;
+    overflow: hidden;
+    transition: border-color 0.15s, background-color 0.15s, box-shadow 0.15s;
+}
+.vf-os-card:hover {
+    border-color: #337ab7;
+}
+.vf-os-card-selected {
+    border-color: #337ab7;
+    background: rgba(51,122,183,0.06);
+    box-shadow: 0 0 0 1px rgba(51,122,183,0.3);
+}
+.vf-os-card-eol {
+    opacity: 0.6;
+}
+.vf-os-icon {
+    width: 40px;
+    height: 40px;
+    border-radius: 8px;
+    margin: 0 auto 6px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: #fff;
+    font-weight: 700;
+    font-size: 1.1rem;
+    overflow: hidden;
+    flex-shrink: 0;
+}
+.vf-os-icon img {
+    max-width: 100%;
+    max-height: 100%;
+    width: 24px;
+    height: 24px;
+    object-fit: contain;
+}
+.vf-os-label {
+    font-weight: 600;
+    font-size: 12px;
+    line-height: 1.2;
+}
+.vf-os-version {
+    font-size: 10px;
+    color: #888;
+    line-height: 1.2;
+}
+.vf-os-eol-badge {
+    display: inline-block;
+    background: #dc3545;
+    color: #fff;
+    font-size: 9px;
+    font-weight: 700;
+    padding: 1px 5px;
+    border-radius: 3px;
+    margin-top: 3px;
+}
+#vf-os-details {
+    border-top: 1px solid #dee2e6;
+    padding-top: 10px;
+}
+.vf-os-search {
+    margin-bottom: 10px;
+}
+
+@media (max-width: 768px) {
+    .vf-os-grid {
+        gap: 6px;
+    }
+    .vf-os-card {
+        width: calc(50% - 3px);
+        min-width: 100px;
+    }
+}
+
+/* Resource panel */
+.vf-resource-item .progress {
+    background-color: rgba(0,0,0,0.08);
+    border-radius: 4px;
+}
+
+/* Order form slider UI */
+.vf-slider-container {
+    padding: 8px 0;
+}
+.vf-slider-value {
+    font-weight: 600;
+    font-size: 0.95rem;
+    margin-bottom: 4px;
+    text-align: center;
+}
+.vf-slider {
+    width: 100%;
+    height: 6px;
+    -webkit-appearance: none;
+    appearance: none;
+    background: #ddd;
+    border-radius: 3px;
+    outline: none;
+    cursor: pointer;
+}
+.vf-slider::-webkit-slider-thumb {
+    -webkit-appearance: none;
+    appearance: none;
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    background: #337ab7;
+    cursor: pointer;
+    border: 2px solid #fff;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.2);
+}
+.vf-slider::-moz-range-thumb {
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    background: #337ab7;
+    cursor: pointer;
+    border: 2px solid #fff;
+    box-shadow: 0 1px 3px rgba(0,0,0,0.2);
+}
+
+/* Toggle Switch */
+.vf-toggle-input {
+    display: none;
+}
+.vf-toggle-switch {
+    position: relative;
+    display: inline-block;
+    width: 36px;
+    height: 20px;
+    background: #ccc;
+    border-radius: 10px;
+    transition: background 0.2s;
+    flex-shrink: 0;
+}
+.vf-toggle-switch::after {
+    content: '';
+    position: absolute;
+    top: 2px;
+    left: 2px;
+    width: 16px;
+    height: 16px;
+    background: #fff;
+    border-radius: 50%;
+    transition: transform 0.2s;
+}
+.vf-toggle-input:checked + .vf-toggle-switch {
+    background: #28a745;
+}
+.vf-toggle-input:checked + .vf-toggle-switch::after {
+    transform: translateX(16px);
+}
+
+/* Responsive adjustments */
+@media (max-width: 768px) {
+    .vf-power-buttons {
+        flex-direction: column;
+    }
+    .vf-btn-power {
+        width: 100%;
+    }
+    .vf-ip-row {
+        flex-wrap: wrap;
+    }
+}
+
+/* =========================================================================
+   Reverse DNS panel
+   ========================================================================= */
+.vf-rdns-row {
+    display: flex;
+    flex-wrap: wrap;
+    align-items: center;
+    gap: 10px;
+    padding: 8px 0;
+    border-bottom: 1px solid rgba(0,0,0,.06);
+}
+.vf-rdns-row:last-child { border-bottom: none; }
+.vf-rdns-ip {
+    font-family: monospace;
+    font-size: 13px;
+    min-width: 180px;
+    font-weight: 600;
+}
+.vf-rdns-edit {
+    display: flex;
+    flex: 1 1 auto;
+    gap: 6px;
+    align-items: center;
+    min-width: 240px;
+}
+.vf-rdns-input {
+    flex: 1 1 auto;
+    min-width: 180px;
+    max-width: 420px;
+    font-family: monospace;
+    font-size: 13px;
+}
+.vf-rdns-badge {
+    display: inline-block;
+    padding: 2px 8px;
+    border-radius: 10px;
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: .02em;
+    line-height: 1.4;
+    white-space: nowrap;
+}
+.vf-rdns-msg {
+    flex-basis: 100%;
+    font-size: 12px;
+    display: none;
+    padding-left: 180px;
+}
+.vf-rdns-admin-row {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 4px 0;
+    font-size: 13px;
+}
+.vf-rdns-ip-admin {
+    font-family: monospace;
+    font-weight: 600;
+    min-width: 180px;
+}
+.vf-rdns-ptr-admin {
+    font-family: monospace;
+    color: #333;
+    flex: 1 1 auto;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+@media (max-width: 768px) {
+    .vf-rdns-row { flex-direction: column; align-items: stretch; }
+    .vf-rdns-edit { flex-direction: column; align-items: stretch; }
+    .vf-rdns-msg { padding-left: 0; }
+}

modules/servers/VirtFusionDirect/templates/error.tpl

@@ -1 +1,11 @@
-<div class="alert alert-danger"><p>Oops! Something went wrong.</p></div><p>Please go back and try again.</p><p>If the problem persists, please contact support.</p>
+<div class="panel card panel-default mb-3">
+    <div class="panel-heading card-header">
+        <h3 class="panel-title card-title m-0">Error</h3>
+    </div>
+    <div class="panel-body card-body p-4">
+        <div class="alert alert-danger mb-0">
+            <p><strong>Something went wrong.</strong></p>
+            <p class="mb-0">Please go back and try again. If the problem persists, please contact support.</p>
+        </div>
+    </div>
+</div>

modules/servers/VirtFusionDirect/templates/js/keygen.js

@@ -0,0 +1,124 @@
+/**
+ * VirtFusion SSH Ed25519 Key Generator
+ *
+ * Client-side Ed25519 keypair generation using Web Crypto API.
+ * Produces OpenSSH-format public and private keys.
+ */
+
+function vfConcatArrays() {
+    var total = 0;
+    for (var i = 0; i < arguments.length; i++) total += arguments[i].length;
+    var result = new Uint8Array(total);
+    var offset = 0;
+    for (var i = 0; i < arguments.length; i++) {
+        result.set(arguments[i], offset);
+        offset += arguments[i].length;
+    }
+    return result;
+}
+
+function vfSshEncodeUint32(value) {
+    return new Uint8Array([
+        (value >>> 24) & 0xff,
+        (value >>> 16) & 0xff,
+        (value >>> 8) & 0xff,
+        value & 0xff
+    ]);
+}
+
+function vfSshEncodeString(data) {
+    if (typeof data === 'string') {
+        data = new TextEncoder().encode(data);
+    }
+    return vfConcatArrays(vfSshEncodeUint32(data.length), data);
+}
+
+function vfArrayToBase64(uint8Array) {
+    var binary = '';
+    for (var i = 0; i < uint8Array.length; i++) {
+        binary += String.fromCharCode(uint8Array[i]);
+    }
+    return btoa(binary);
+}
+
+function vfEncodeSSHPublicKey(pubKeyBytes) {
+    var blob = vfConcatArrays(
+        vfSshEncodeString('ssh-ed25519'),
+        vfSshEncodeString(pubKeyBytes)
+    );
+    return 'ssh-ed25519 ' + vfArrayToBase64(blob);
+}
+
+function vfEncodeSSHPrivateKey(seed, pubKeyBytes) {
+    var keyType = vfSshEncodeString('ssh-ed25519');
+    var pubBlob = vfConcatArrays(keyType, vfSshEncodeString(pubKeyBytes));
+
+    var checkInt = crypto.getRandomValues(new Uint8Array(4));
+    var privKey = vfConcatArrays(seed, pubKeyBytes); // 64 bytes: seed || pubkey
+
+    var privateSection = vfConcatArrays(
+        checkInt,
+        checkInt,
+        vfSshEncodeString('ssh-ed25519'),
+        vfSshEncodeString(pubKeyBytes),
+        vfSshEncodeString(privKey),
+        vfSshEncodeString('') // empty comment
+    );
+
+    // Pad to 8-byte boundary with 1,2,3,4,5...
+    var padLen = 8 - (privateSection.length % 8);
+    if (padLen < 8) {
+        var padding = new Uint8Array(padLen);
+        for (var i = 0; i < padLen; i++) padding[i] = i + 1;
+        privateSection = vfConcatArrays(privateSection, padding);
+    }
+
+    var authMagic = new TextEncoder().encode('openssh-key-v1\0');
+    var body = vfConcatArrays(
+        authMagic,
+        vfSshEncodeString('none'),   // cipher
+        vfSshEncodeString('none'),   // kdf
+        vfSshEncodeString(''),       // kdf options
+        vfSshEncodeUint32(1),        // number of keys
+        vfSshEncodeString(pubBlob),
+        vfSshEncodeString(privateSection)
+    );
+
+    var b64 = vfArrayToBase64(body);
+    var lines = ['-----BEGIN OPENSSH PRIVATE KEY-----'];
+    for (var i = 0; i < b64.length; i += 70) {
+        lines.push(b64.substring(i, i + 70));
+    }
+    lines.push('-----END OPENSSH PRIVATE KEY-----');
+    lines.push('');
+    return lines.join('\n');
+}
+
+async function vfGenerateSSHKey() {
+    var keyPair = await crypto.subtle.generateKey('Ed25519', true, ['sign', 'verify']);
+
+    var pubRaw = await crypto.subtle.exportKey('raw', keyPair.publicKey);
+    var pubKeyBytes = new Uint8Array(pubRaw);
+
+    // PKCS#8 for Ed25519 is exactly 48 bytes; bytes 16-47 are the 32-byte seed
+    var privPkcs8 = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
+    var privBytes = new Uint8Array(privPkcs8);
+    var seed = privBytes.slice(16, 48);
+
+    return {
+        publicKey: vfEncodeSSHPublicKey(pubKeyBytes),
+        privateKey: vfEncodeSSHPrivateKey(seed, pubKeyBytes)
+    };
+}
+
+function vfDownloadFile(filename, content) {
+    var blob = new Blob([content], { type: 'application/octet-stream' });
+    var url = URL.createObjectURL(blob);
+    var a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}

pint.json

@@ -0,0 +1,24 @@
+{
+    "preset": "laravel",
+    "rules": {
+        "declare_strict_types": false,
+        "blank_line_before_statement": {
+            "statements": ["return", "throw", "try"]
+        },
+        "concat_space": {
+            "spacing": "one"
+        },
+        "ordered_imports": {
+            "sort_algorithm": "alpha"
+        },
+        "single_quote": true,
+        "no_unused_imports": true,
+        "trailing_comma_in_multiline": {
+            "elements": ["arrays", "arguments"]
+        }
+    },
+    "exclude": [
+        "vendor",
+        "templates"
+    ]
+}