Another installation request is running. Wait for it to finish.
', 1);
exit;
}
register_shutdown_function(function () use ($installLock) { flock($installLock, LOCK_UN); fclose($installLock); });
$log = [];
// ---------- guard: never run over a *finished* install (a half-done one may resume) ----------
if (is_file("$appDir/.pharos-done")) {
pharos_page('Already installed', '
Pharos is already installed in '.h($appDir).'. This installer refuses to run over it.
Good news: this server already has a newer PHP installed. Point the domain at one of these and reload.
'.$list.'
';
}
pharos_page('This PHP is too old', '
This site runs PHP '.h(PHP_VERSION).'; Pharos needs '.PHAROS_MIN_PHP.' or later.
'.$have.'
DirectAdmin: Account Manager → Domain Setup → your domain → PHP Version → pick the 8.3+ entry, Save. Extensions are built server-wide there, so if one is missing below, your host has to enable it in CustomBuild.
cPanel / CloudLinux: Select PHP Version (or MultiPHP Manager for one domain) → choose 8.3, and tick the extensions sodium, zip, pdo_sqlite, mbstring, fileinfo, curl, xml.
';
pharos_page('One cron line. That is the whole scheduler.', '
Add this to your control panel, every minute. Pharos shows a warning in the admin until it sees the first run.
Keep your installation key for the administrator form: '.h($installKey).'
* * * * *'.h(substr($cron, 10)).'
'.$note.'
cPanelAdvanced → Cron Jobs → Add. Five stars in the time fields, the rest in "Command".
DirectAdminAdvanced Features → Cron Jobs. Keep the full path: cron gets the server default PHP, not the one you picked in Domain Setup.
PleskTools & Settings → Scheduled Tasks → Run a command.
Set up cron through your panel (optional)
cPanel uses its API token and port 2083; DirectAdmin uses a restricted Login Key and port 2222. Credentials are used for this request only. Revoke the token after setup. For Plesk or a panel with API access disabled, use Scheduled Tasks or run the CLI command php artisan pharos:cron --install with the detected PHP path.
Use a temporary Login Key restricted to CMD_API_CRON_JOBS and this server’s IP. The key is used for this request only. Existing tasks are preserved.
', 4, $errors, $log);
} else {
header('Location: ?step=1');
}
// ============================================================ helpers
function h(string $s): string { return htmlspecialchars($s, ENT_QUOTES, 'UTF-8'); }
/** PHP 7-safe stand-ins, so an old host gets the "switch to PHP 8.3" screen and not a fatal error. */
function pharos_has(string $hay, string $needle): bool { return $needle === '' || strpos($hay, $needle) !== false; }
function pharos_starts(string $hay, string $needle): bool { return substr($hay, 0, strlen($needle)) === $needle; }
function pharos_base_url(): string
{
$https = (! empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') || ($_SERVER['HTTP_X_FORWARDED_PROTO'] ?? '') === 'https';
$host = $_SERVER['HTTP_HOST'] ?? 'localhost';
$dir = rtrim(dirname($_SERVER['SCRIPT_NAME'] ?? '/'), '/');
return ($https ? 'https' : 'http').'://'.$host.$dir;
}
/** Outside the web folder if at all possible: the home directory first, a sibling folder second. */
function pharos_app_dir(string $webRoot): string
{
$home = $_SERVER['HOME'] ?? null;
$suffix = substr(hash('sha256', realpath($webRoot) ?: $webRoot), 0, 12);
$parents = [$home, dirname($webRoot)];
foreach ($parents as $parent) {
if (!$parent || !@is_dir($parent) || !@is_writable($parent)) { continue; }
$parent = rtrim(realpath($parent) ?: $parent, '/');
if ($parent === $webRoot || pharos_starts($parent.'/', rtrim($webRoot, '/').'/')) { continue; }
$legacy = $parent.'/pharos-app';
if (@is_file($legacy.'/.pharos-public') && trim((string)file_get_contents($legacy.'/.pharos-public')) === $webRoot) { return $legacy; }
return $parent.'/pharos-app-'.$suffix;
}
return dirname($webRoot).'/pharos-app-'.$suffix;
}
/** Two-part minimum, because version_compare('8.3', '8.3.0', '>=') is false. */
function pharos_min_mm(): string
{
$p = explode('.', PHAROS_MIN_PHP);
return $p[0].'.'.(isset($p[1]) ? $p[1] : '0');
}
/** Which panel this is, from what it leaves on disk. Only used to word the advice. */
function pharos_panel(): string
{
if (@is_dir('/usr/local/directadmin')) { return 'DirectAdmin'; }
if (@is_dir('/usr/local/cpanel') || @is_dir('/opt/cpanel')) { return 'cPanel'; }
if (@is_dir('/opt/psa') || @is_dir('/usr/local/psa')) { return 'Plesk'; }
return '';
}
/**
* Every PHP this server keeps on disk, newest first. Filesystem only, on purpose:
* DirectAdmin ships php.conf.d/50-webapps.ini, which disables exec, shell_exec and
* proc_open, so a binary can be found and pointed at but never run to confirm itself.
* The version therefore comes from the path and is major.minor — no patch level.
*/
function pharos_php_installs(bool $onlySupported = false): array
{
static $cache = [];
$key = $onlySupported ? 1 : 0;
if (isset($cache[$key])) { return $cache[$key]; }
$patterns = [
'/usr/local/php*/bin/php' => 'DirectAdmin', // CustomBuild: php84, plus leftovers like php74-cli
'/opt/alt/php*/usr/bin/php' => 'CloudLinux', // alt-php
'/opt/cpanel/ea-php*/root/usr/bin/php' => 'cPanel', // EasyApache
'/opt/plesk/php/*/bin/php' => 'Plesk',
'/usr/bin/php[78].[0-9]' => 'system', // Debian, Ubuntu, Remi
'/usr/local/bin/php[78].[0-9]' => 'system',
];
$found = [];
foreach ($patterns as $glob => $panel) {
$hits = @glob($glob);
if (!$hits) { continue; }
foreach ($hits as $path) {
$v = pharos_php_version_of($path);
// no version in the path (/usr/local/php/bin/php is a moving symlink) — not something to pin a cron line to
if ($v === '' || isset($found[$path]) || ! @is_executable($path)) { continue; }
if ($onlySupported && version_compare($v, pharos_min_mm(), '<')) { continue; }
$found[$path] = ['path' => $path, 'version' => $v, 'panel' => $panel];
}
}
$list = array_values($found);
// newest first; path as tiebreak, because usort is only stable from PHP 8.0
usort($list, function ($a, $b) {
$v = version_compare($b['version'], $a['version']);
return $v !== 0 ? $v : strcmp($a['path'], $b['path']);
});
return $cache[$key] = $list;
}
/** major.minor out of a path: php84 → 8.4, /opt/plesk/php/8.3/ → 8.3, /usr/bin/php8.3 → 8.3, ea-php83 → 8.3. */
function pharos_php_version_of(string $path): string
{
if (preg_match('~/(?:php|ea-php)/?(\d)\.(\d+)(?:/|$)~', $path, $m)) { return $m[1].'.'.$m[2]; }
if (preg_match('~/(?:php|ea-php|alt-php)(\d)(\d+)~', $path, $m)) { return $m[1].'.'.$m[2]; }
return '';
}
/**
* The binary for the cron line. Cron does not go through the panel's PHP selector:
* on DirectAdmin the domain answers over /usr/local/php84/bin/lsphp while cron gets
* /usr/local/bin/php, a symlink the host repoints on every CustomBuild run. So pin a
* full path, and prefer the major.minor the site itself runs on.
*/
function pharos_cron_php(): array
{
static $cache = null;
if ($cache !== null) { return $cache; }
$web = PHP_MAJOR_VERSION.'.'.PHP_MINOR_VERSION;
$installs = pharos_php_installs(true);
// A box can carry the same version twice (cPanel's ea-php next to CloudLinux alt-php).
// The one to pick is the install this very request is running out of: on DirectAdmin
// the web SAPI is /usr/local/php84/bin/lsphp, whose neighbour is the CLI php we want.
$sibling = defined('PHP_BINARY') && PHP_BINARY !== '' ? dirname(PHP_BINARY) : '';
$exact = null;
foreach ($installs as $i) {
if ($i['version'] !== $web) { continue; }
if ($exact === null) { $exact = $i; }
if ($sibling !== '' && dirname($i['path']) === $sibling) { $exact = $i; break; }
}
if ($exact !== null) {
return $cache = ['path' => $exact['path'], 'ok' => true, 'note' => 'Detected from the filesystem, not executed. The first successful scheduler run confirms it works.', 'detail' => $exact['path'].' — PHP '.$exact['version'].', same as the site ('.$exact['panel'].')'];
}
if ($installs) {
$i = $installs[0];
return $cache = ['path' => $i['path'], 'ok' => true,
'note' => 'The cron line runs PHP '.$i['version'].' while this site runs '.$web.'. This path has not been executed: confirm its extensions and a successful scheduler run before relying on monitoring.',
'detail' => $i['path'].' — PHP '.$i['version'].' ('.$i['panel'].'), site runs '.$web];
}
$self = defined('PHP_BINARY') ? PHP_BINARY : '';
if ($self !== '' && pharos_php_version_of($self) !== '' && @is_executable($self) && ! pharos_has($self, 'php-fpm') && ! pharos_has($self, 'lsphp') && ! pharos_has($self, 'php-cgi')) {
return $cache = ['path' => $self, 'ok' => true, 'note' => '', 'detail' => $self.' — the binary running this request'];
}
return $cache = ['path' => 'php', 'ok' => false,
'note' => 'No PHP binary could be found from the web, usually open_basedir. The line below says plain "php", which cron resolves to the server default — check in your panel that it is '.pharos_min_mm().' or later, or replace it with a full path such as /usr/local/php'.str_replace('.', '', $web).'/bin/php.',
'detail' => 'not found from the web — the cron line falls back to plain "php"'];
}
function pharos_checks(string $appDir, string $webRoot): array
{
$c = [];
$c[] = ['name' => 'PHP version (web)', 'ok' => version_compare(PHP_VERSION, PHAROS_MIN_PHP, '>='), 'detail' => PHP_VERSION.' (need '.PHAROS_MIN_PHP.' or later)'];
$where = pharos_panel() === 'DirectAdmin' ? 'pick a newer PHP in Domain Setup, or ask your host to build it into CustomBuild' : 'enable it under Select PHP Version (cPanel) or PHP Settings';
foreach ([['pdo', 'PDO'], ['mbstring', 'mbstring'], ['openssl', 'openssl'], ['sodium', 'sodium — verifies the release signature'], ['zip', 'ZipArchive'], ['curl', 'curl'], ['fileinfo', 'fileinfo'], ['tokenizer', 'tokenizer'], ['xml', 'xml'], ['ctype', 'ctype']] as [$ext, $label]) {
$c[] = ['name' => "Extension $ext", 'ok' => extension_loaded($ext), 'detail' => extension_loaded($ext) ? 'loaded' : "missing ($label) — $where"];
}
// The scheduler does not run under the web PHP. On DirectAdmin the domain runs
// /usr/local/php84/bin/lsphp while cron gets /usr/local/bin/php — a different,
// often older version. Say now which binary the cron line on step 4 will use.
$cli = pharos_cron_php();
$c[] = ['name' => 'PHP for cron', 'ok' => $cli['ok'], 'soft' => true, 'detail' => $cli['detail']];
$c[] = ['name'=>'Database driver', 'ok'=>extension_loaded('pdo_sqlite') || extension_loaded('pdo_mysql'), 'detail'=>'SQLite or MySQL PDO driver required; select the database during configuration'];
$parent = is_dir($appDir) ? $appDir : dirname($appDir);
$c[] = ['name' => 'App folder', 'ok' => is_writable($parent), 'detail' => $appDir.(is_dir($appDir) ? ' (exists)' : ' (will be created)')];
$c[] = ['name' => 'Web folder writable', 'ok' => is_writable($webRoot), 'detail' => $webRoot];
try {
$m = pharos_manifest();
$c[] = ['name' => 'Outbound HTTPS', 'ok' => true, 'detail' => parse_url(PHAROS_RELEASES, PHP_URL_HOST).' reachable · latest release '.$m['version']];
} catch (Throwable $e) {
$c[] = ['name' => 'Outbound HTTPS', 'ok' => false, 'detail' => $e->getMessage()];
}
$c[] = ['name' => 'Existing install', 'ok' => ! is_file("$appDir/artisan"), 'detail' => is_file("$appDir/artisan") ? "found at $appDir" : 'none found'];
return $c;
}
function pharos_http_get(string $url, ?string $toFile = null): string
{
if (function_exists('curl_init')) {
$ch = curl_init($url);
$fh = $toFile ? fopen($toFile, 'wb') : null;
curl_setopt_array($ch, [CURLOPT_FOLLOWLOCATION => true, CURLOPT_MAXREDIRS => 3, CURLOPT_TIMEOUT => 300, CURLOPT_CONNECTTIMEOUT => 10, CURLOPT_USERAGENT => 'pharos-install/1', CURLOPT_SSL_VERIFYPEER => true] + ($fh ? [CURLOPT_FILE => $fh] : [CURLOPT_RETURNTRANSFER => true]));
$out = curl_exec($ch);
$code = (int) curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
$err = curl_error($ch);
curl_close($ch);
if ($fh) { fclose($fh); }
if ($out === false || $code !== 200) { throw new RuntimeException("Could not fetch $url (".($err ?: "HTTP $code").')'); }
return $toFile ? '' : (string) $out;
}
$ctx = stream_context_create(['http' => ['timeout' => 300, 'user_agent' => 'pharos-install/1']]);
$data = @file_get_contents($url, false, $ctx);
if ($data === false) { throw new RuntimeException("Could not fetch $url (allow_url_fopen is off and curl is missing?)"); }
if ($toFile) { file_put_contents($toFile, $data); return ''; }
return $data;
}
/** The signed manifest: ".", verified with the public key above. */
function pharos_manifest(): array
{
static $cached = null;
if ($cached) { return $cached; }
$pin = PHAROS_PIN_VERSION ?: (preg_match('/^\d+\.\d+\.\d+$/', (string) ($_GET['version'] ?? '')) ? $_GET['version'] : '');
$raw = trim(pharos_http_get(PHAROS_RELEASES.($pin ? "/pharos-$pin.json" : '/latest.json')));
if (! pharos_has($raw, '.')) { throw new RuntimeException('latest.json is not a signed manifest'); }
[$p, $s] = explode('.', $raw, 2);
$b64 = fn (string $v) => base64_decode(strtr($v, '-_', '+/').str_repeat('=', (4 - strlen($v) % 4) % 4), true);
$payload = $b64($p); $sig = $b64($s);
if ($payload === false || $sig === false || strlen($sig) !== SODIUM_CRYPTO_SIGN_BYTES) { throw new RuntimeException('latest.json is malformed'); }
if (! sodium_crypto_sign_verify_detached($sig, $payload, sodium_hex2bin(PHAROS_PUBKEY_HEX))) {
throw new RuntimeException('The release manifest does not carry a valid SolutionMAX signature. Not installing.');
}
$m = json_decode($payload, true);
if (! is_array($m) || ($m['purpose'] ?? null) !== 'pharos-release' || empty($m['version']) || empty($m['url']) || empty($m['sha256'])) {
throw new RuntimeException('The manifest is not a Pharos release manifest');
}
if ($pin && $m['version'] !== $pin) {
throw new RuntimeException("Asked for $pin but the manifest says {$m['version']} — refusing.");
}
return $cached = $m;
}
function pharos_tmp_dir(string $appDir): string
{
$tmp = dirname($appDir).'/.pharos-install-tmp-'.substr(hash('sha256', $appDir), 0, 16);
pharos_rmdir($tmp);
if (! mkdir($tmp, 0755, true) && ! is_dir($tmp)) { throw new RuntimeException("Cannot create $tmp"); }
return $tmp;
}
function pharos_download(string $url, string $to): void
{
if (! pharos_starts($url, 'https://')) { throw new RuntimeException('The release URL is not https'); }
pharos_http_get($url, $to);
if (! is_file($to) || filesize($to) < 1000000) { throw new RuntimeException('Download is incomplete'); }
}
function pharos_unpack(string $zipPath, string $tmp, string $appDir): void
{
$zip = new ZipArchive;
if ($zip->open($zipPath) !== true) { throw new RuntimeException('The archive cannot be opened'); }
for ($i = 0; $i < $zip->numFiles; $i++) {
$name = (string) $zip->getNameIndex($i);
if (pharos_has($name, '..') || pharos_starts($name, '/')) { throw new RuntimeException("Refusing unsafe archive entry $name"); }
$zip->getExternalAttributesIndex($i, $opsys, $attr);
if ($opsys === ZipArchive::OPSYS_UNIX && (($attr >> 16) & 0170000) === 0120000) { throw new RuntimeException("Refusing archive entry $name: symlinks are not allowed in a release"); }
}
$x = "$tmp/x"; mkdir($x, 0755, true);
if (! $zip->extractTo($x)) { throw new RuntimeException('Unpacking failed (disk full?)'); }
$zip->close();
$entries = array_values(array_diff(scandir($x) ?: [], ['.', '..']));
$root = count($entries) === 1 && is_dir("$x/{$entries[0]}") ? "$x/{$entries[0]}" : $x;
if (! is_file("$root/artisan")) { throw new RuntimeException('That archive does not look like a Pharos release'); }
if (is_dir($appDir)) { throw new RuntimeException("Refusing to replace existing folder $appDir"); }
if (! @rename($root, $appDir)) { pharos_copy_tree($root, $appDir); }
// belt and braces if this folder ever ends up under a document root
file_put_contents("$appDir/.htaccess", "Require all denied\n");
foreach (['storage', 'bootstrap/cache', 'database'] as $d) { @chmod("$appDir/$d", 0775); }
}
/** The web folder gets public/ only; index.php is rewritten to find the app where it really is. */
function pharos_publish_public(string $appDir, string $webRoot): void
{
$pub = "$appDir/public";
// cPanel keeps its PHP handler and ini blocks in .htaccess: keep them, add Laravel's rules underneath.
$panel = is_file("$webRoot/.htaccess") ? file_get_contents("$webRoot/.htaccess") : '';
$ours = is_file("$pub/.htaccess") ? file_get_contents("$pub/.htaccess") : '';
if ($ours !== '' && strpos($panel, '# BEGIN Pharos') === false) {
// DirectAdmin ships a placeholder index.html that Apache would serve before index.php
file_put_contents("$webRoot/.htaccess", (trim($panel) === '' ? '' : rtrim($panel)."\n\n")."# BEGIN Pharos\nDirectoryIndex index.php\n".trim($ours)."\n# END Pharos\n");
}
foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($pub, FilesystemIterator::SKIP_DOTS), RecursiveIteratorIterator::SELF_FIRST) as $item) {
$rel = substr($item->getPathname(), strlen($pub) + 1);
if ($rel === '.htaccess') { continue; }
$dest = "$webRoot/$rel";
if ($item->isDir()) { @mkdir($dest, 0755, true); continue; }
if (! copy($item->getPathname(), $dest)) { throw new RuntimeException("Cannot write $dest"); }
}
$index = file_get_contents("$webRoot/index.php");
$index = str_replace("__DIR__.'/../", "'".addslashes($appDir)."/", $index);
file_put_contents("$webRoot/index.php", $index);
// the app must also know where its public folder is, for asset paths and storage:link
file_put_contents("$appDir/.pharos-public", $webRoot);
}
function pharos_write_env(string $appDir, string $url, string $db, array $in, string $setupKey = ''): void
{
$existing = is_file("$appDir/.env") ? file_get_contents("$appDir/.env") : '';
$env = file_get_contents("$appDir/.env.example");
$set = function (string $k, string $v) use (&$env) {
$line = $k.'="'.strtr($v, ["\\"=>"\\\\", '"'=>'\\"', '$'=>'\\$', "\n"=>'\\n', "\r"=>'\\r']).'"';
$env = preg_match("/^$k=.*$/m", $env) ? preg_replace_callback("/^$k=.*$/m", function () use ($line) { return $line; }, $env) : $env."\n$line";
};
$set('APP_ENV', 'production'); $set('APP_DEBUG', 'false'); $set('APP_URL', $url);
// Preserve the literal existing line, including its quoting.
if (preg_match('/^APP_KEY=(.+)$/m', $existing, $key)) {
$env = preg_replace_callback('/^APP_KEY=.*$/m', function () use ($key) { return $key[0]; }, $env);
} else { $set('APP_KEY', 'base64:'.base64_encode(random_bytes(32))); }
if ($setupKey !== '') { $set('PHAROS_SETUP_KEY', $setupKey); }
if ($db === 'mysql') {
$set('DB_CONNECTION', 'mysql'); $set('DB_HOST', (string)($in['db_host'] ?? '127.0.0.1')); $set('DB_PORT', '3306');
$set('DB_DATABASE', (string)($in['db_name'] ?? '')); $set('DB_USERNAME', (string)($in['db_user'] ?? '')); $set('DB_PASSWORD', (string)($in['db_pass'] ?? ''));
} else {
$set('DB_CONNECTION', 'sqlite');
$env = preg_replace('/^DB_DATABASE=.*$/m', '', $env);
if (!is_file("$appDir/database/database.sqlite")) { touch("$appDir/database/database.sqlite"); }
}
$tmp = "$appDir/.env.".bin2hex(random_bytes(6));
if (file_put_contents($tmp, $env) === false) { throw new RuntimeException('Cannot write configuration.'); }
chmod($tmp, 0600);
if (!rename($tmp, "$appDir/.env")) { throw new RuntimeException('Cannot publish configuration.'); }
}
function pharos_setup_key(string $path): string
{
$file = @fopen($path, 'c+');
if (!$file || !flock($file, LOCK_EX)) { throw new RuntimeException('The private installation folder is not writable. Ask your host for a writable folder outside the document root.'); }
try {
@chmod($path, 0600);
$key = trim(stream_get_contents($file));
if ($key === '') { $key = bin2hex(random_bytes(32)); fwrite($file, $key); fflush($file); }
return $key;
} finally { flock($file, LOCK_UN); fclose($file); }
}
function pharos_shell_arg(string $value): string
{
if (preg_match('/[\r\n%]/', $value)) { throw new RuntimeException('Cron paths cannot contain newlines or percent signs.'); }
return "'".str_replace("'", "'\\''", $value)."'";
}
/** Runs an artisan command inside this request, without a shell. */
function pharos_artisan(string $appDir, string $command, array $args = []): void
{
require_once "$appDir/vendor/autoload.php";
$app = require "$appDir/bootstrap/app.php";
$kernel = $app->make(Illuminate\Contracts\Console\Kernel::class);
$out = new Symfony\Component\Console\Output\BufferedOutput;
$code = $kernel->call($command, $args, $out);
if ($code !== 0) { throw new RuntimeException("artisan $command failed: ".trim($out->fetch())); }
}
function pharos_link_storage(string $appDir, string $webRoot, array &$log): void
{
$target = "$appDir/storage/app/public"; $link = "$webRoot/storage";
if (is_link($link) || is_dir($link)) { $log[] = 'storage link already present'; return; }
if (function_exists('symlink') && @symlink($target, $link)) { $log[] = 'storage link created (uploads will show)'; return; }
$log[] = 'storage symlink unavailable — current Pharos releases serve public uploads through the application';
}
function pharos_copy_tree(string $from, string $to): void
{
if (!is_dir($to) && !mkdir($to, 0755, true)) { throw new RuntimeException("Cannot create $to"); }
foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($from, FilesystemIterator::SKIP_DOTS), RecursiveIteratorIterator::SELF_FIRST) as $item) {
$dest = $to.'/'.substr($item->getPathname(), strlen($from) + 1);
$item->isDir() ? @mkdir($dest, 0755, true) : copy($item->getPathname(), $dest);
}
}
function pharos_rmdir(string $dir): void
{
if (! is_dir($dir)) { return; }
foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($dir, FilesystemIterator::SKIP_DOTS), RecursiveIteratorIterator::CHILD_FIRST) as $item) {
$item->isDir() ? @rmdir($item->getPathname()) : @unlink($item->getPathname());
}
@rmdir($dir);
}
/** Only this endpoint is used; panel credentials are neither persisted nor redirected. */
function pharos_da_request(string $panel, string $user, string $key, array $fields, string $panelType = 'directadmin'): array
{
$parts = parse_url($panel);
if (!$parts || ($parts['scheme'] ?? '') !== 'https' || empty($parts['host']) || isset($parts['user']) || isset($parts['pass']) || isset($parts['query']) || !in_array($parts['path'] ?? '', ['', '/'], true)) {
throw new RuntimeException('Use your HTTPS panel origin, for example https://panel.example.com:2222 or :2083.');
}
if (!preg_match('/^[a-zA-Z0-9_-]+$/', $user) || $key === '' || preg_match('/[\r\n]/', $key)) { throw new RuntimeException('Enter a panel username and Login Key or API token.'); }
$host = $parts['host'];
$addresses = filter_var($host, FILTER_VALIDATE_IP) ? [$host] : (gethostbynamel($host) ?: []);
if (!$addresses) { throw new RuntimeException('The panel hostname could not be resolved.'); }
foreach ($addresses as $ip) {
if (!filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_NO_PRIV_RANGE | FILTER_FLAG_NO_RES_RANGE)) {
throw new RuntimeException('Use a publicly reachable panel HTTPS address.');
}
}
$port = $parts['port'] ?? 443;
$creating = (bool)$fields;
$endpoint = '/CMD_API_CRON_JOBS';
if ($panelType === 'cpanel') {
$endpoint = '/json-api/cpanel';
$fields = ['cpanel_jsonapi_user'=>$user, 'cpanel_jsonapi_apiversion'=>2, 'cpanel_jsonapi_module'=>'Cron', 'cpanel_jsonapi_func'=>$creating ? 'add_line' : 'listcron'] + ($creating ? ['minute'=>'*', 'hour'=>'*', 'day'=>'*', 'month'=>'*', 'weekday'=>'*', 'command'=>$fields['command']] : []);
}
$ch = curl_init(rtrim($panel, '/').$endpoint);
curl_setopt_array($ch, [CURLOPT_RETURNTRANSFER=>true, CURLOPT_FOLLOWLOCATION=>false, CURLOPT_TIMEOUT=>15, CURLOPT_CONNECTTIMEOUT=>5, CURLOPT_SSL_VERIFYPEER=>true, CURLOPT_SSL_VERIFYHOST=>2, CURLOPT_USERPWD=>$user.':'.$key, CURLOPT_RESOLVE=>[$host.':'.$port.':'.$addresses[0]]]);
if ($panelType === 'cpanel') { curl_setopt($ch, CURLOPT_USERPWD, null); curl_setopt($ch, CURLOPT_HTTPHEADER, ['Authorization: cpanel '.$user.':'.$key]); }
if ($fields) { curl_setopt($ch, CURLOPT_POST, true); curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($fields)); }
$raw = curl_exec($ch); $status = (int)curl_getinfo($ch, CURLINFO_RESPONSE_CODE); curl_close($ch);
if (!is_string($raw) || $status !== 200) { throw new RuntimeException('The hosting panel did not accept the request. Check the panel address, certificate and token permissions.'); }
if ($panelType === 'cpanel') { return pharos_cpanel_result($raw, $creating); }
parse_str($raw, $result);
if ((isset($result['error']) && (string)$result['error'] !== '0') || strpos($raw, ''0'];
}
$jobs = [];
foreach ($result['data'] as $row) {
if (is_array($row) && array_keys($row) === ['count']) { continue; }
$parts = [];
foreach (['minute','hour','day','month','weekday','command'] as $field) {
if (!isset($row[$field]) || !is_scalar($row[$field])) { throw new RuntimeException('Unknown cPanel cron response; use manual setup.'); }
$parts[] = (string)$row[$field];
}
$jobs[] = implode(' ', $parts);
}
return $jobs;
}
/** Read before writing, never delete other tasks, and verify the saved task. */
function pharos_da_cron(string $panel, string $user, string $key, string $appDir, string $php, ?callable $request = null): string
{
if ($php === 'php' || pharos_php_version_of($php) === '') { throw new RuntimeException('Choose a versioned absolute CLI PHP path before adding cron automatically.'); }
$command = 'cd '.pharos_shell_arg($appDir).' && '.pharos_shell_arg($php).' artisan schedule:run >> /dev/null 2>&1';
$request = $request ?: 'pharos_da_request';
$contains = function (array $jobs) use ($command, $appDir): bool {
foreach ($jobs as $id => $line) {
if (!ctype_digit((string)$id)) { throw new RuntimeException('Unknown panel cron response; use manual setup.'); }
if (!is_string($line)) { throw new RuntimeException('Unknown panel cron response; use manual setup.'); }
$parts = preg_split('/\s+/', trim($line), 6);
if (count($parts) !== 6) { throw new RuntimeException('Unknown panel cron response; use manual setup.'); }
if ($parts[5] === $command && array_slice($parts, 0, 5) === ['*','*','*','*','*']) { return true; }
if (strpos($parts[5], $appDir) !== false && strpos($parts[5], 'artisan schedule:run') !== false) { throw new RuntimeException('A cron task for this installation already exists with different settings. Review it in your panel; Pharos will not add a duplicate.'); }
}
return false;
};
$jobs = $request($panel, $user, $key, []);
if ($contains($jobs)) { return 'The Pharos cron task already exists. Waiting for a successful scheduler run.'; }
$request($panel, $user, $key, ['action'=>'create', 'minute'=>'*', 'hour'=>'*', 'dayofmonth'=>'*', 'month'=>'*', 'dayofweek'=>'*', 'command'=>$command]);
if (!$contains($request($panel, $user, $key, []))) { throw new RuntimeException('The saved task could not be verified. Check your panel before retrying.'); }
return 'Cron task saved and verified. Monitoring is confirmed by the first successful scheduler run.';
}
function pharos_page(string $title, string $body, int $step, array $errors = [], array $log = []): void
{
$steps = ['Check the server', 'Download release', 'Configure', 'Cron', 'Done'];
$nav = '';
foreach ($steps as $i => $label) {
$n = $i + 1;
$cls = $n < $step ? 'done' : ($n === $step ? 'now' : '');
$nav .= '