Node Manager (PM2) for Plesk

Name: Node Manager Pm2
Author: ghostcompiler

Manage Node.js applications with PM2 from Plesk, with admin, reseller, and customer scoped access.

Overview

Node Manager (PM2) is a Plesk extension for managing Node.js applications with PM2 without SSH.

It is built for hosting panels where admins need a clean process manager for SSR apps, API servers, queues, websocket servers, and other long-running Node.js services while keeping customers scoped to their own subscriptions.

Creator

Name: Ghost Compiler
Email: hello@ghostcompiler.in
GitHub: ghostcompiler/node-manager-pm2
Profile: github.com/ghostcompiler
Logo: assets.ghostcompiler.in/logo.png

Documentation

Full GitHub Pages documentation is available at:

ghostcompiler.github.io/node-manager-pm2

The page is maintained in docs/index.html and uses the screenshots stored in docs/screenshots. It covers installation, access control, process management, runtime setup, file editing, logs, deployment, ecosystem config, metrics, backups, settings, and troubleshooting.

Screenshots

Screenshot set:

Dashboard: dark, light
Process list: dark, light
Create process: dark, light
File picker: dark, light
File editor drawer: dark, light
Runtime setup: dark, light
Logs drawer: dark, light
Environment variables: dark, light
Deployment: dark, light
Ecosystem editor: dark, light
Metrics: dark, light
Backups: dark, light
Settings: dark, light
Action menu: dark, light

Features

PM2 process list with start, stop, restart, reload, delete, and scaling controls.
Domain-scoped dashboard for admin, reseller, and customer users.
Runtime detection for Node.js, npm, PM2, Git, and PM2 home.
Admin PM2 install/update action for detected Plesk Node.js runtimes.
Live stdout/stderr log viewer with download and clear actions.
Environment variable manager with secret storage support.
Git deployment actions with optional npm install and zero-downtime reload.
PM2 ecosystem config editor.
CPU and memory metrics history with graph and pagination.
Backup and restore for extension-managed PM2 metadata.
Plesk service-plan permissions and process limits.

Complete Option Reference

The extension is domain scoped. All relative paths are resolved from the selected domain application root, and customer/reseller actions depend on Plesk service-plan permissions.

Top Actions

Info: Opens the extension information page with version, runtime, storage, permissions, and operational paths.
Refresh: Reloads domains, process state, runtime status, metrics, and visible tab data.
New Process: Opens the create-process page for the selected domain.

Domain Context

Domain: Selects the domain or subdomain workspace.
Subscription user: Shows the system user that owns the selected domain.
Application root: Shows the absolute document/application root used for relative process paths.
Permissions: Shows the current user's effective Node Manager permission level.

Processes Tab

Process row: Opens the process detail drawer.
Start: Starts a stopped PM2 process.
Stop: Stops a running process.
Restart: Restarts the process with PM2.
Reload: Performs a PM2 reload where supported.
Scale: Updates the process instance count.
Delete: Removes the PM2 process and extension metadata after confirmation.

Create Process Page

Name: PM2 application name.
Script path: JavaScript entry file. Browse opens the domain-scoped file picker, and selecting a file fills this field.
Working directory: Process working directory. Browse opens directories inside the selected domain root.
Environment: PM2 environment name, such as production.
Instances: Number of PM2 instances to run.
Max restarts: Optional restart limit passed to PM2.
Restart delay, ms: Optional delay before PM2 restarts the process.
Git repository: Optional deployment repository URL.
Git branch: Deployment branch used by the Deploy tab.
Autorestart if the process exits: Enables or disables PM2 autorestart.
Create and Start: Creates the config and starts the process.

File Picker And Editor

Document root: Returns to the selected domain root.
Up: Moves one directory up, but never outside the selected domain root.
Open: Opens a directory inside the picker.
Select: Selects a file or directory for the active form field.
Edit: Opens editable files in a Plesk drawer with the CodeEditor component.
Save: Writes the edited file content.
Close: Closes the drawer, with confirmation when changes are unsaved.

Runtime Tab

Use detected paths: Applies detected Node.js, npm, PM2, Git, and PM2 home values to settings.
Install or update PM2: Installs or updates PM2 using the detected runtime. The button is disabled while the action is running.
Runtime table: Shows Node.js, npm, PM2, and Git status, detected version, and resolved path.
PM2 home: Shows the PM2 home directory used for managed processes.

Settings Tab

Node binary path: Absolute path to node.
npm binary path: Absolute path to npm.
PM2 binary path: Absolute path to pm2.
Git binary path: Absolute path to git.
PM2 home: Directory used by PM2 for process state.
Extra PATH: Additional PATH entries for PM2 commands.
Polling interval: Process and metrics refresh interval.
Max log bytes: Maximum bytes read from stdout/stderr in the log drawer.
Metrics retention days: How long sampled CPU and memory metrics are kept.
Deployment timeout: Maximum deployment command runtime.
Save Settings: Persists settings for the extension.

Backups Tab

Create Backup: Exports extension-managed metadata and settings.
Restore: Imports a previous backup.
Delete: Removes a backup archive.
Backup list: Shows backup name, creation time, size, and available actions.

Process Detail Drawer

Logs: View stdout or stderr, refresh, clear by truncating the log file, and download logs.
Env: Add, edit, save, mark secret, or delete environment variables.
Deploy: Pull from Git, optionally run npm install, choose production dependencies, and reload after deployment.
Ecosystem: Edit the PM2 ecosystem configuration, save it, or save and start the process.
Metrics: View CPU and memory chart data plus the latest five metric samples by default.

Requirements

Plesk Obsidian 18.0.34 or newer on Linux.
Physical hosting enabled for domains that will run Node.js apps.
Plesk Node.js extension or another Node.js/npm runtime available on the server.
SQLite PDO extension available to the Plesk PHP runtime.
Git installed for deployment features.
PM2 installed globally or installed from the extension runtime page by an administrator.

Installation

Install the latest runner-built package directly from GitHub:

plesk bin extension --install-url https://github.com/ghostcompiler/node-manager-pm2/releases/download/latest/node-manager-pm2.zip

This URL points to the rolling latest release asset. The Package Latest workflow rebuilds node-manager-pm2.zip from the current main branch on every push and whenever it is started manually, so the install command stays stable and does not depend on a hardcoded version number.

Pinned version installs are also available after publishing a versioned release:

plesk bin extension --install-url https://github.com/ghostcompiler/node-manager-pm2/releases/download/v1.0.0/node-manager-pm2-1.0.0.zip

Build the extension ZIP locally:

./packaging/build.sh

Install the locally built archive through Plesk CLI:

plesk bin extension --install node-manager-pm2-1.0.0.zip

Or install through Plesk UI:

Open Plesk Admin.
Go to Extensions.
Click Upload Extension.
Upload node-manager-pm2-1.0.0.zip.
Open Node Manager (PM2) from the Plesk sidebar or a domain page.

Testing

Run the same local checks used by the CI runner:

npm ci --ignore-scripts --legacy-peer-deps
npm run build
find plib htdocs -type f \( -name '*.php' -o -name '*.phtml' \) -print0 | xargs -0 -n1 php -l
xmllint --noout meta.xml
node -e "JSON.parse(require('fs').readFileSync('packaging/manifest.json', 'utf8'))"
sh -n packaging/build.sh
sh -n sbin/pm2-helper
./packaging/build.sh
zip -T node-manager-pm2-1.0.0.zip

GitHub Actions runners are included:

CI runs on every branch push, pull request, and manual dispatch. It validates PHP, JavaScript, documentation screenshots, metadata, shell scripts, builds the extension, tests the ZIP, and uploads package artifacts.
Package Latest runs on main and manual dispatch. It builds and publishes the stable node-manager-pm2.zip asset to the rolling latest GitHub release.
Release runs on v<version> tags and manual dispatch. It verifies the tag matches meta.xml, builds node-manager-pm2-<version>.zip, and publishes the versioned release.
Pages runs when documentation changes on main and manual dispatch. It validates docs/index.html screenshot references and deploys the docs/ folder to GitHub Pages.

First Run

Open the affected service plan or subscription.
Enable Node Manager (PM2) access.
Enable the needed action permissions: control, logs, and manage.
Set Maximum PM2 applications to a non-zero value for subscriptions that can create processes.
Sync existing subscriptions if Plesk marks them as customized or out of sync.
Open Node Manager (PM2) as admin, reseller, or customer.
Review the Runtime tab and install PM2 if needed.

Example SSR Process

For a subdomain such as assets.example.com where the app root is:

/var/www/vhosts/example.com/assets.example.com

Use:

Name: assets-ssr
Script path: server.js
Working directory: .
Environment: production
Instances: 1
Autorestart: enabled

The extension resolves relative paths from the selected domain application root, so server.js becomes:

/var/www/vhosts/example.com/assets.example.com/server.js

Troubleshooting Logs

When the UI reports a 500 error, check:

tail -n 200 /var/log/plesk/panel.log
tail -n 200 /var/log/sw-cp-server/error_log
tail -n 200 /usr/local/psa/var/modules/node-manager-pm2/logs/node-manager-pm2.log

On some Plesk builds, the panel log is stored at:

tail -n 200 /usr/local/psa/admin/logs/panel.log

Security Model

Admins can view and manage all enabled domains.
Resellers and customers only see domains where Node Manager access is enabled.
Customer and reseller access is controlled by Plesk service plan permissions.
Process script and working-directory paths are locked inside the selected domain application root.
PM2 commands run under the selected domain system user when Plesk pm_ApiCli::callDomain() is available.
The extension stores PM2 metadata and secrets in SQLite under the Plesk module var directory.

Development Notes

PHP classes live in plib/library/NodeManagerPm2.
Authenticated UI and JSON APIs are served by plib/controllers/IndexController.php.
The Plesk React UI Library bundle lives in frontend/ and is built to htdocs/dist/node-manager-pm2-ui.js.
The public deployment webhook lives at htdocs/public/webhook.php.
Persistent state is stored in SQLite under the module var directory.
Package configuration lives in packaging/manifest.json and packaging/build.sh.

See docs/INSTALL.md, docs/SECURITY.md, docs/API.md, and docs/ARCHITECTURE.md for operational details.

Development Environment

Built using ServBay

Mac M4 Tested
macOS Apple Silicon
Powered by ServBay

Files main

Repository Files

Loading file structure...

plib/controllers/IndexController.php

<?php
require_once dirname(__DIR__) . '/library/NodeManagerPm2/Autoload.php';
Modules_NodeManagerPm2_Autoload::register();

class IndexController extends pm_Controller_Action
{
    protected $_accessLevel = ['admin', 'reseller', 'client'];

    private $domains;

    public function init()
    {
        parent::init();
        Modules_NodeManagerPm2_Store::instance()->initialize();
        Modules_NodeManagerPm2_Config::ensureDefaults();
        $this->domains = new Modules_NodeManagerPm2_DomainRepository();
        $this->view->pageTitle = $this->lmsg('page_title');
        $this->view->extensionInfo = $this->extensionInfo();
        $assetVersion = rawurlencode($this->assetVersion());
        $this->view->headLink()->appendStylesheet(pm_Context::getBaseUrl() . 'css/app.css?v=' . $assetVersion);
    }

    public function indexAction()
    {
        $domainId = $this->requestedDomainId();
        $this->view->appConfig = [
            'csrf' => Modules_NodeManagerPm2_Security::csrfToken(),
            'endpoints' => $this->endpoints(),
            'initialDomainId' => $domainId,
            'domainContextId' => $domainId,
            'domainLocked' => $domainId !== null,
            'title' => 'Node Manager (PM2)',
            'info' => $this->extensionInfo(),
            'infoUrl' => $this->infoUrl($domainId),
        ];
    }

    public function infoAction()
    {
        $domainId = $this->requestedDomainId();
        $this->view->domainId = $domainId;
        $this->view->backUrl = $this->indexUrl($domainId);
    }

    public function domainAction()
    {
        $domainId = $this->requestedDomainId();
        if ($domainId === null || $domainId === '') {
            throw new Modules_NodeManagerPm2_Exception('Unable to detect the selected domain. Open Node Manager (PM2) from the domain card again.');
        }

        $this->_helper->viewRenderer->setNoRender(true);
        $this->_helper->layout()->disableLayout();
        $this->getResponse()->setRedirect(pm_Context::getBaseUrl() . 'index.php/index/index?site_id=' . urlencode($domainId));
    }

    public function apiBootstrapAction()
    {
        $this->api(function () {
            $domains = $this->domains->listDomains();
            $selected = $this->requestedDomainId();
            $locked = $selected !== null;
            $requestedDenied = false;
            if ($selected !== null) {
                $allowed = false;
                foreach ($domains as $domainRow) {
                    if ((int) $domainRow['id'] === (int) $selected) {
                        $allowed = true;
                        break;
                    }
                }
                if (!$allowed) {
                    $requestedDenied = true;
                    $selected = null;
                    $domains = [];
                }
            }
            if ($selected === null) {
                $selected = $domains ? $domains[0]['id'] : null;
            }
            if ($locked && $selected !== null) {
                $domains = array_values(array_filter($domains, function ($domainRow) use ($selected) {
                    return (int) $domainRow['id'] === (int) $selected;
                }));
            }
            $runtime = null;
            if ($selected !== null) {
                $runtime = (new Modules_NodeManagerPm2_RuntimeService())->versions($this->domains->getDomain($selected));
            }
            $accessEnabled = !$requestedDenied && ($this->domains->isAdmin() || count($domains) > 0);
            $accessMessage = '';
            if ($requestedDenied) {
                $accessMessage = 'Node Manager (PM2) is not enabled for this domain. Ask the server administrator to enable Node Manager (PM2) access for this subscription and sync the subscription.';
            } elseif (!$accessEnabled) {
                $accessMessage = 'Node Manager (PM2) is not enabled for this account. Ask the server administrator to enable Node Manager (PM2) access for this subscription or service plan.';
            }

            return [
                'accessEnabled' => $accessEnabled,
                'accessMessage' => $accessMessage,
                'domains' => $domains,
                'selectedDomainId' => $selected,
                'domainLocked' => $locked,
                'settings' => $accessEnabled ? Modules_NodeManagerPm2_Config::all() : [],
                'runtime' => $runtime,
                'alerts' => $accessEnabled ? Modules_NodeManagerPm2_Store::instance()->unreadAlerts(20) : [],
                'permissions' => $this->permissionsFor($selected),
            ];
        }, false);
    }

    public function apiProcessesAction()
    {
        $this->api(function () {
            $domain = $this->domainFromRequest();
            return [
                'processes' => (new Modules_NodeManagerPm2_Pm2Service())->listProcesses($domain),
                'domain' => $this->domains->serialize($domain),
            ];
        }, false);
    }

    public function apiCreateProcessAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::MANAGE, $domain->getId());
            Modules_NodeManagerPm2_PermissionService::assertCapacity(
                $domain->getId(),
                Modules_NodeManagerPm2_Store::instance()->countAppsByDomain($domain->getId())
            );
            $app = (new Modules_NodeManagerPm2_Pm2Service())->createProcess($domain, $input);
            return ['app' => $app];
        });
    }

    public function apiBrowseAction()
    {
        $this->api(function () {
            $domain = $this->domainFromRequest();
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::MANAGE, $domain->getId());
            $mode = $this->_getParam('mode', 'file') === 'directory' ? 'directory' : 'file';
            $path = $this->_getParam('path', '');
            return (new Modules_NodeManagerPm2_BrowseService())->browse($domain, $path, $mode);
        }, false);
    }

    public function apiFileAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::MANAGE, $domain->getId());
            $path = isset($input['path']) ? $input['path'] : '';
            $service = new Modules_NodeManagerPm2_BrowseService();
            if (isset($input['content'])) {
                return $service->saveFile($domain, $path, $input['content']);
            }

            return $service->readFile($domain, $path);
        });
    }

    public function apiProcessAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            $action = isset($input['action']) ? $input['action'] : '';
            $pm2Name = isset($input['pm2Name']) ? $input['pm2Name'] : '';
            $service = new Modules_NodeManagerPm2_Pm2Service();

            if ($action === 'scale') {
                Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::CONTROL, $domain->getId());
                return $service->scale($domain, $pm2Name, isset($input['instances']) ? $input['instances'] : 1);
            }

            Modules_NodeManagerPm2_PermissionService::assertDomain(
                $action === 'delete' ? Modules_NodeManagerPm2_PermissionService::MANAGE : Modules_NodeManagerPm2_PermissionService::CONTROL,
                $domain->getId()
            );

            return $service->action($domain, $pm2Name, $action);
        });
    }

    public function apiMetricsAction()
    {
        $this->api(function () {
            $domain = $this->domainFromRequest();
            $pm2Name = Modules_NodeManagerPm2_Validator::processName($this->_getParam('pm2Name', ''));
            return [
                'metrics' => Modules_NodeManagerPm2_Store::instance()->metrics($domain->getId(), $pm2Name, 60),
            ];
        }, false);
    }

    public function apiLogsAction()
    {
        $this->api(function () {
            $domain = $this->domainFromRequest();
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::LOGS, $domain->getId());
            $pm2Name = $this->_getParam('pm2Name', '');
            $stream = $this->_getParam('stream', 'stdout');
            $bytes = (int) $this->_getParam('bytes', Modules_NodeManagerPm2_Config::get('maxLogBytes', 200000));
            return (new Modules_NodeManagerPm2_LogService())->read($domain, $pm2Name, $stream, $bytes);
        }, false);
    }

    public function apiClearLogsAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::MANAGE, $domain->getId());
            (new Modules_NodeManagerPm2_LogService())->clear(
                $domain,
                isset($input['pm2Name']) ? $input['pm2Name'] : '',
                isset($input['stream']) ? $input['stream'] : 'all'
            );
            return ['cleared' => true];
        });
    }

    public function downloadLogsAction()
    {
        try {
            $domain = $this->domainFromRequest();
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::LOGS, $domain->getId());
            $pm2Name = $this->_getParam('pm2Name', '');
            $stream = $this->_getParam('stream', 'stdout');
            $file = (new Modules_NodeManagerPm2_LogService())->download($domain, $pm2Name, $stream);

            header('Content-Type: text/plain; charset=utf-8');
            header('Content-Disposition: attachment; filename="' . basename($file) . '"');
            header('Content-Length: ' . filesize($file));
            readfile($file);
            exit;
        } catch (Exception $e) {
            Modules_NodeManagerPm2_Response::error($this, $e->getMessage(), 400);
        }
    }

    public function apiEnvAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::MANAGE, $domain->getId());
            $service = new Modules_NodeManagerPm2_EnvService();
            $method = isset($_SERVER['REQUEST_METHOD']) ? strtoupper($_SERVER['REQUEST_METHOD']) : 'GET';
            $appId = isset($input['appId']) ? $input['appId'] : $this->_getParam('appId', '');

            if ($method === 'GET') {
                return ['env' => $service->listForApp($domain, $appId)];
            }

            if (!empty($input['delete'])) {
                $service->delete($domain, $appId, isset($input['name']) ? $input['name'] : '');
            } else {
                $service->save($domain, $appId, $input);
            }

            return ['env' => $service->listForApp($domain, $appId)];
        });
    }

    public function apiEcosystemAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::MANAGE, $domain->getId());
            $pm2 = new Modules_NodeManagerPm2_Pm2Service();
            $method = isset($_SERVER['REQUEST_METHOD']) ? strtoupper($_SERVER['REQUEST_METHOD']) : 'GET';
            $appId = isset($input['appId']) ? $input['appId'] : $this->_getParam('appId', '');

            if ($method === 'GET') {
                return $pm2->readEcosystem($domain, $appId);
            }

            $content = isset($input['content']) ? $input['content'] : '';
            if (isset($_FILES['file']) && is_uploaded_file($_FILES['file']['tmp_name'])) {
                $content = file_get_contents($_FILES['file']['tmp_name']);
            }

            $result = $pm2->writeEcosystem($domain, $appId, $content);
            if (!empty($input['start'])) {
                $pm2->startEcosystem($domain, $appId);
            }
            return $result;
        });
    }

    public function apiDeployAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::MANAGE, $domain->getId());
            $appId = isset($input['appId']) ? $input['appId'] : '';
            return (new Modules_NodeManagerPm2_DeployService())->deploy($domain, $appId, [
                'npmInstall' => !empty($input['npmInstall']),
                'reload' => !empty($input['reload']),
                'production' => !empty($input['production']),
            ]);
        });
    }

    public function apiWebhookAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            Modules_NodeManagerPm2_PermissionService::assertDomain(Modules_NodeManagerPm2_PermissionService::MANAGE, $domain->getId());
            return (new Modules_NodeManagerPm2_DeployService())->configureWebhook(
                $domain,
                isset($input['appId']) ? $input['appId'] : '',
                !empty($input['enabled'])
            );
        });
    }

    public function apiRuntimeAction()
    {
        $this->api(function ($input) {
            $domain = $this->domainFromInput($input);
            $runtime = new Modules_NodeManagerPm2_RuntimeService();
            if (!empty($input['applyDetectedPaths'])) {
                if (!$this->domains->isAdmin()) {
                    throw new Modules_NodeManagerPm2_Exception('Only administrators can update runtime paths.');
                }
                $settings = $runtime->applyDetectedPaths();
                return ['settings' => $settings, 'runtime' => $runtime->versions($domain)];
            }
            if (!empty($input['installPm2'])) {
                if (!$this->domains->isAdmin()) {
                    throw new Modules_NodeManagerPm2_Exception('Only administrators can install or update PM2.');
                }
                Modules_NodeManagerPm2_Logger::info('PM2 install requested.', [
                    'domainId' => $domain->getId(),
                    'domainName' => $domain->getName(),
                    'requestUri' => isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : '',
                ]);
                return ['output' => $runtime->installOrUpdatePm2(), 'runtime' => $runtime->versions($domain)];
            }
            return ['runtime' => $runtime->versions($domain)];
        });
    }

    public function apiSettingsAction()
    {
        $this->api(function ($input) {
            if (!$this->domains->isAdmin()) {
                throw new Modules_NodeManagerPm2_Exception('Only administrators can update extension settings.');
            }

            foreach (Modules_NodeManagerPm2_Config::defaults() as $key => $value) {
                if (isset($input[$key])) {
                    Modules_NodeManagerPm2_Config::set($key, $input[$key]);
                }
            }

            return ['settings' => Modules_NodeManagerPm2_Config::all()];
        });
    }

    public function apiBackupAction()
    {
        $this->api(function ($input) {
            if (!$this->domains->isAdmin()) {
                throw new Modules_NodeManagerPm2_Exception('Only administrators can manage backups.');
            }
            $service = new Modules_NodeManagerPm2_BackupService();
            if (!empty($input['create'])) {
                return $service->create();
            }
            if (!empty($input['restore'])) {
                return $service->restore($input['restore']);
            }
            return ['backups' => $service->listBackups()];
        });
    }

    private function api($callback, $csrf = true)
    {
        try {
            $input = $this->input();
            if ($csrf) {
                Modules_NodeManagerPm2_Security::assertCsrf();
            }
            Modules_NodeManagerPm2_Response::ok($this, $callback($input));
        } catch (Modules_NodeManagerPm2_Exception $e) {
            Modules_NodeManagerPm2_Logger::warning('API request failed.', $this->errorContext($e));
            Modules_NodeManagerPm2_Response::error($this, $e->getMessage(), 400);
        } catch (Exception $e) {
            Modules_NodeManagerPm2_Logger::error('API request failed unexpectedly.', $this->errorContext($e));
            Modules_NodeManagerPm2_Response::error($this, 'Unexpected error: ' . $e->getMessage(), 500);
        } catch (Throwable $e) {
            Modules_NodeManagerPm2_Logger::error('API request failed fatally.', $this->throwableContext($e));
            Modules_NodeManagerPm2_Response::error($this, 'Unexpected error: ' . $e->getMessage(), 500);
        }
    }

    private function input()
    {
        $raw = file_get_contents('php://input');
        $json = json_decode($raw, true);
        if (is_array($json)) {
            return $json;
        }

        return $_POST;
    }

    private function domainFromRequest()
    {
        $domainId = (int) $this->_getParam('domainId', 0);
        if ($domainId <= 0) {
            $domainId = (int) $this->requestedDomainId();
        }
        if ($domainId <= 0) {
            $domains = $this->domains->listDomains();
            if (!$domains) {
                throw new Modules_NodeManagerPm2_Exception('No hosted domains are available.');
            }
            $domainId = $domains[0]['id'];
        }

        return $this->domains->getDomain($domainId);
    }

    private function domainFromInput($input)
    {
        $domainId = isset($input['domainId']) ? (int) $input['domainId'] : (int) $this->_getParam('domainId', 0);
        if ($domainId <= 0) {
            throw new Modules_NodeManagerPm2_Exception('Domain is required.');
        }

        return $this->domains->getDomain($domainId);
    }

    private function endpoints()
    {
        return [
            'bootstrap' => pm_Context::getActionUrl('index', 'api-bootstrap'),
            'processes' => pm_Context::getActionUrl('index', 'api-processes'),
            'createProcess' => pm_Context::getActionUrl('index', 'api-create-process'),
            'browse' => pm_Context::getActionUrl('index', 'api-browse'),
            'file' => pm_Context::getActionUrl('index', 'api-file'),
            'process' => pm_Context::getActionUrl('index', 'api-process'),
            'metrics' => pm_Context::getActionUrl('index', 'api-metrics'),
            'logs' => pm_Context::getActionUrl('index', 'api-logs'),
            'clearLogs' => pm_Context::getActionUrl('index', 'api-clear-logs'),
            'downloadLogs' => pm_Context::getActionUrl('index', 'download-logs'),
            'env' => pm_Context::getActionUrl('index', 'api-env'),
            'ecosystem' => pm_Context::getActionUrl('index', 'api-ecosystem'),
            'deploy' => pm_Context::getActionUrl('index', 'api-deploy'),
            'webhook' => pm_Context::getActionUrl('index', 'api-webhook'),
            'runtime' => pm_Context::getActionUrl('index', 'api-runtime'),
            'settings' => pm_Context::getActionUrl('index', 'api-settings'),
            'backup' => pm_Context::getActionUrl('index', 'api-backup'),
        ];
    }

    private function permissionsFor($domainId)
    {
        $admin = $this->domains->isAdmin();
        return [
            'admin' => $admin,
            'canInstallPm2' => $admin,
            'canManage' => $admin || Modules_NodeManagerPm2_PermissionService::can(Modules_NodeManagerPm2_PermissionService::MANAGE, $domainId),
            'canControl' => $admin || Modules_NodeManagerPm2_PermissionService::can(Modules_NodeManagerPm2_PermissionService::CONTROL, $domainId),
            'canLogs' => $admin || Modules_NodeManagerPm2_PermissionService::can(Modules_NodeManagerPm2_PermissionService::LOGS, $domainId),
        ];
    }

    private function requestedDomainId()
    {
        $siteId = $this->requestValue('site_id');
        if ($siteId !== null) {
            return $this->normalizeDomainId($siteId);
        }

        foreach (['domainId', 'domain_id', 'contextDomainId', 'context_domain_id'] as $name) {
            $value = $this->requestValue($name);
            if ($value !== null) {
                return $this->normalizeDomainId($value);
            }
        }

        $domId = $this->requestValue('dom_id');
        if ($domId !== null) {
            return $this->resolveSubscriptionDomainId($domId);
        }

        return null;
    }

    private function requestValue($name)
    {
        $value = $this->_request->getParam($name);
        return $value !== null && $value !== '' ? $value : null;
    }

    private function normalizeDomainId($domainId)
    {
        try {
            $domain = pm_Domain::getByDomainId((int) $domainId);
            return (int) $domain->getId();
        } catch (Exception $e) {
            try {
                $domain = new pm_Domain((int) $domainId);
                return (int) $domain->getId();
            } catch (Exception $inner) {
                return null;
            }
        }
    }

    private function resolveSubscriptionDomainId($subscriptionId)
    {
        $directDomainId = $this->normalizeDomainId($subscriptionId);
        if ($directDomainId !== null) {
            return $directDomainId;
        }

        try {
            foreach (pm_Domain::getAllDomains(false) as $domain) {
                if (!$domain->hasHosting()) {
                    continue;
                }
                foreach (['webspace_id', 'parentDomainId'] as $property) {
                    try {
                        if ((int) $domain->getProperty($property) === (int) $subscriptionId) {
                            return (int) $domain->getId();
                        }
                    } catch (Exception $e) {
                    }
                }
            }
        } catch (Exception $e) {
        }

        return null;
    }

    private function assetVersion()
    {
        if (class_exists('pm_Context') && method_exists('pm_Context', 'getMetaData')) {
            try {
                $meta = pm_Context::getMetaData();
                if (is_array($meta) && !empty($meta['version'])) {
                    return $meta['version'];
                }
            } catch (Exception $e) {
            }
        }

        return '1.0.0';
    }

    private function extensionInfo()
    {
        $version = $this->assetVersion();
        return [
            'name' => 'Node Manager (PM2)',
            'version' => $version,
            'creator' => 'Ghost Compiler',
            'email' => 'hello@ghostcompiler.in',
            'profileUrl' => 'https://github.com/ghostcompiler',
            'github' => 'node-manager-pm2',
            'githubUrl' => 'https://github.com/ghostcompiler/node-manager-pm2',
            'logPath' => '/usr/local/psa/var/modules/node-manager-pm2/logs/node-manager-pm2.log',
            'icon' => pm_Context::getBaseUrl() . 'images/icon.png',
        ];
    }

    private function indexUrl($domainId)
    {
        return pm_Context::getActionUrl('index', 'index') . $this->domainQuery($domainId);
    }

    private function infoUrl($domainId)
    {
        return pm_Context::getActionUrl('index', 'info') . $this->domainQuery($domainId);
    }

    private function domainQuery($domainId)
    {
        if ($domainId === null || $domainId === '') {
            return '';
        }

        return '?site_id=' . urlencode($domainId);
    }

    private function errorContext(Exception $e)
    {
        return [
            'requestUri' => isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : '',
            'method' => isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : '',
            'exception' => $e,
        ];
    }

    private function throwableContext($e)
    {
        return [
            'requestUri' => isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : '',
            'method' => isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : '',
            'exception' => [
                'class' => get_class($e),
                'message' => $e->getMessage(),
                'file' => $e->getFile(),
                'line' => $e->getLine(),
                'trace' => method_exists($e, 'getTraceAsString') ? $e->getTraceAsString() : '',
            ],
        ];
    }
}