HeuJung
3945b6f1b3
공개 저장소 이슈 gnuboard/g7 (@bigmsg) 제보에서 출발한 작업이다. 브라우저가 화면을 그리려고 제3자 CDN 에 도달해야 하면, 그 도달 실패는 예외도 로그도 남기지 않고 화면 기능만 조용히 사라진다. 폐쇄망·방화벽·광고차단기에서 재현되는데 자체 서버 로그에는 흔적이 없어 운영자가 원인을 특정할 수 없다. 제보된 것은 편집기 하나였지만 같은 구조가 아이콘·글꼴·코드편집기·압축 라이브러리·설치 마법사·개발 대시보드에 똑같이 있었으므로, 번들 확장과 템플릿 전체를 자체 제공으로 옮겼다. 런타임에 외부로 나가는 것은 주소 검색 서비스 하나만 남았다. 자체 제공만으로는 부족하다 — 자기 서버에서 받는 파일도 실패할 수 있고, 종전에는 그 실패가 무음이었다. CSS 경로에 재시도 계층을 세우고(스크립트 경로와 동형), 서버가 HTML 에 직접 심는 externals 까지 실패를 붙잡아 안내 배너와 [다시 시도]로 표면화했다. 편집기·코드편집기는 확보 실패 시 평문 입력으로 내려앉되 저장 계약을 유지한다. 두 번째 축은 운영자가 CSS 를 덧붙일 자리가 없던 문제다(sir.kr 문의). 확장 디렉토리의 custom/ 을 운영자 소유로 정해, 확장 교체가 그 디렉토리만은 보존하게 했다. 출처에 의존하지 않는 서술자로 해석하므로 나중에 다른 출처가 붙어도 소비자는 바뀌지 않는다. 확장 자산과 같은 메커니즘으로 정적 게시되어 CSS 내부 상대 url 도 해석되고, 파일을 고치면 그 변경을 감지해 재게시까지 예약된다. FTP 접근이 없는 운영자에게는 그 자리도 없는 것과 같으므로 레이아웃 편집기에서 직접 넣고 고칠 수 있게 했다. 모듈·플러그인·템플릿이 한 엔드포인트를 공유한다 — 타입별로 나누면 같은 검증이 세 벌로 갈리고 그중 약한 하나가 우회로가 된다. 여기서 올린 스크립트는 그 레이아웃 한 장이 아니라 사이트 전 화면에서 실행되므로 레이아웃 편집과 분리된 전용 권한으로 연다. 운영자 CSS 가 화면을 조작 불능으로 만들면 그것을 고칠 화면에도 같은 CSS 가 실려 스스로 갇히므로, 서버가 목록을 비우는 탈출구(?custom=off)를 함께 뒀다. 동봉 자산은 재생성 경로에 버전 대조 가드를 붙였다. 선언과 다른 버전을 버전 디렉토리에 써 넣는 조용한 거짓말은 배포된 뒤에는 드러나지 않는다.
1034 lines
38 KiB
PHP
1034 lines
38 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Contracts\Extension\PluginManagerInterface;
|
|
use App\Contracts\Repositories\PluginRepositoryInterface;
|
|
use App\Enums\ExtensionStatus;
|
|
use App\Exceptions\PluginOperationException;
|
|
use App\Extension\Helpers\ChangelogParser;
|
|
use App\Extension\Helpers\EditorSpecAssembler;
|
|
use App\Extension\Helpers\GithubHelper;
|
|
use App\Extension\Helpers\ZipInstallHelper;
|
|
use App\Extension\HookManager;
|
|
use App\Extension\Vendor\VendorMode;
|
|
use Illuminate\Http\UploadedFile;
|
|
use Illuminate\Support\Facades\File;
|
|
use Illuminate\Validation\ValidationException;
|
|
|
|
class PluginService
|
|
{
|
|
/**
|
|
* 검색 가능한 필드 목록
|
|
*/
|
|
private const SEARCHABLE_FIELDS = ['name', 'identifier', 'description', 'vendor'];
|
|
|
|
public function __construct(
|
|
private PluginRepositoryInterface $pluginRepository,
|
|
private PluginManagerInterface $pluginManager
|
|
) {}
|
|
|
|
/**
|
|
* 활성화된 플러그인들의 identifier 목록을 반환합니다.
|
|
*
|
|
* @return array 활성화된 플러그인 identifier 배열
|
|
*/
|
|
public function getActivePluginIdentifiers(): array
|
|
{
|
|
return $this->pluginRepository->getActivePluginIdentifiers();
|
|
}
|
|
|
|
/**
|
|
* 모든 플러그인 목록을 조회합니다 (설치된 플러그인과 미설치 플러그인 포함).
|
|
*
|
|
* @return array 모든 플러그인 목록
|
|
*/
|
|
public function getAllPlugins(): array
|
|
{
|
|
// PluginManager 초기화
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
// 설치된 플러그인과 미설치 플러그인을 분리하여 반환
|
|
$installedPlugins = $this->pluginManager->getInstalledPluginsWithDetails();
|
|
$uninstalledPlugins = $this->pluginManager->getUninstalledPlugins();
|
|
|
|
return [
|
|
'installed' => array_values($installedPlugins),
|
|
'uninstalled' => array_values($uninstalledPlugins),
|
|
'total' => count($installedPlugins) + count($uninstalledPlugins),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* 설치된 플러그인만 조회합니다.
|
|
*
|
|
* @return array 설치된 플러그인 목록
|
|
*/
|
|
public function getInstalledPluginsOnly(): array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return array_values($this->pluginManager->getInstalledPluginsWithDetails());
|
|
}
|
|
|
|
/**
|
|
* 미설치 플러그인만 조회합니다.
|
|
*
|
|
* @return array 미설치 플러그인 목록
|
|
*/
|
|
public function getUninstalledPluginsOnly(): array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return array_values($this->pluginManager->getUninstalledPlugins());
|
|
}
|
|
|
|
/**
|
|
* 특정 플러그인의 상세 정보를 조회합니다.
|
|
*
|
|
* @param string $pluginName 플러그인명
|
|
* @return array|null 플러그인 정보 또는 null
|
|
*/
|
|
public function getPluginInfo(string $pluginName): ?array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return $this->pluginManager->getPluginInfo($pluginName);
|
|
}
|
|
|
|
/**
|
|
* 플러그인 삭제 시 삭제될 데이터 정보를 조회합니다.
|
|
*
|
|
* @param string $pluginName 플러그인명
|
|
* @return array|null 삭제 정보 (테이블 목록, 스토리지 디렉토리 목록, 용량) 또는 null
|
|
*/
|
|
public function getPluginUninstallInfo(string $pluginName): ?array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return $this->pluginManager->getPluginUninstallInfo($pluginName);
|
|
}
|
|
|
|
/**
|
|
* 플러그인을 설치합니다 (before/after_install 훅 발화 + ValidationException 변환).
|
|
*
|
|
* @param string $pluginName 플러그인 식별자
|
|
* @param VendorMode $vendorMode vendor 설치 모드 (Auto/Composer/Bundled)
|
|
* @param bool $force Updating/Failed 등 진행 중 상태도 무시하고 강제 설치 여부
|
|
* @param string|null $failureReason 실패 시 사유가 담기는 out 파라미터 (성공 시 null)
|
|
* @return array|null 설치된 플러그인 정보 또는 설치 실패 시 null
|
|
*
|
|
* @throws ValidationException 플러그인 설치 실패 시
|
|
*/
|
|
public function installPlugin(
|
|
string $pluginName,
|
|
VendorMode $vendorMode = VendorMode::Auto,
|
|
bool $force = false,
|
|
?string &$failureReason = null,
|
|
): ?array {
|
|
$failureReason = null;
|
|
|
|
HookManager::doAction('core.plugins.before_install', $pluginName);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->installPlugin($pluginName, null, $vendorMode, $force, $failureReason);
|
|
|
|
if ($result) {
|
|
// 설치 후 플러그인 정보 반환
|
|
$pluginInfo = $this->pluginManager->getPluginInfo($pluginName);
|
|
|
|
HookManager::doAction('core.plugins.after_install', $pluginName, $pluginInfo);
|
|
|
|
return $pluginInfo;
|
|
}
|
|
|
|
return null;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.installation_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인을 활성화합니다 (before/after_activate 훅 발화 + ValidationException 변환).
|
|
*
|
|
* 의존성 미충족 등으로 경고 응답이 돌아오면 success/warning 형태 그대로 반환합니다.
|
|
*
|
|
* @param string $pluginName 플러그인 식별자
|
|
* @param bool $force 의존성 경고를 무시하고 강제 활성화 여부
|
|
* @return array{success: bool, plugin_info?: array, warning?: bool} 활성화 결과
|
|
*
|
|
* @throws ValidationException 활성화 실패 시
|
|
*/
|
|
public function activatePlugin(string $pluginName, bool $force = false): array
|
|
{
|
|
HookManager::doAction('core.plugins.before_activate', $pluginName);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->activatePlugin($pluginName, $force);
|
|
|
|
// 경고 응답인 경우 그대로 반환
|
|
if (isset($result['warning']) && $result['warning'] === true) {
|
|
return $result;
|
|
}
|
|
|
|
if ($result['success']) {
|
|
$pluginInfo = $this->pluginManager->getPluginInfo($pluginName);
|
|
|
|
HookManager::doAction('core.plugins.after_activate', $pluginName, $pluginInfo);
|
|
|
|
return [
|
|
'success' => true,
|
|
'plugin_info' => $pluginInfo,
|
|
];
|
|
}
|
|
|
|
// 실패 사유(reason)를 그대로 전달한다 — 여기서 떨어뜨리면 관리자 화면의
|
|
// 실패 문구에 원인 자리가 비어 자리표시자가 그대로 노출된다.
|
|
return $result;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.activation_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인을 비활성화합니다 (before/after_deactivate 훅 발화 + ValidationException 변환).
|
|
*
|
|
* 의존하는 다른 활성 확장이 있으면 경고 응답이 돌아오며 그대로 반환합니다.
|
|
*
|
|
* @param string $pluginName 플러그인 식별자
|
|
* @param bool $force 의존성 경고를 무시하고 강제 비활성화 여부
|
|
* @return array{success: bool, plugin_info?: array, warning?: bool} 비활성화 결과
|
|
*
|
|
* @throws ValidationException 비활성화 실패 시
|
|
*/
|
|
public function deactivatePlugin(string $pluginName, bool $force = false): array
|
|
{
|
|
HookManager::doAction('core.plugins.before_deactivate', $pluginName);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->deactivatePlugin($pluginName, $force);
|
|
|
|
// 경고 응답인 경우 그대로 반환
|
|
if (isset($result['warning']) && $result['warning'] === true) {
|
|
return $result;
|
|
}
|
|
|
|
if ($result['success']) {
|
|
$pluginInfo = $this->pluginManager->getPluginInfo($pluginName);
|
|
|
|
// after_deactivate 훅은 PluginManager 가 string identifier 시그니처로 이미 발화
|
|
// (Service 중복 발화 제거 — listener 2회 실행으로 인한 activity log 중복 차단)
|
|
|
|
return array_merge($result, ['plugin_info' => $pluginInfo]);
|
|
}
|
|
|
|
return $result;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.deactivation_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인을 제거합니다 (before/after_uninstall 훅 발화).
|
|
*
|
|
* @param string $pluginName 플러그인 식별자
|
|
* @param bool $deleteData 플러그인이 생성한 DB 데이터/스토리지 디렉토리까지 삭제 여부
|
|
* @param string|null $failureReason 실패 시 사유가 담기는 out 파라미터 (성공 시 null)
|
|
* @param array<int, array{directory: string, archive: string}>|null $preservedBackups
|
|
* 삭제 전에 보관한 운영자 소유 디렉토리(`custom/`)의 사본 경로가 담기는 out 파라미터
|
|
* @return bool 제거 성공 여부
|
|
*
|
|
* @throws ValidationException 제거 실패 시
|
|
*/
|
|
public function uninstallPlugin(
|
|
string $pluginName,
|
|
bool $deleteData = false,
|
|
?string &$failureReason = null,
|
|
?array &$preservedBackups = null,
|
|
): bool {
|
|
$failureReason = null;
|
|
$preservedBackups = [];
|
|
|
|
HookManager::doAction('core.plugins.before_uninstall', $pluginName, $deleteData);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
$result = $this->pluginManager->uninstallPlugin(
|
|
$pluginName,
|
|
$deleteData,
|
|
null,
|
|
$failureReason,
|
|
$preservedBackups
|
|
);
|
|
|
|
HookManager::doAction('core.plugins.after_uninstall', $pluginName, $deleteData, $result);
|
|
|
|
return $result;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.uninstallation_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 페이지네이션 및 검색 필터가 적용된 플러그인 목록을 조회합니다.
|
|
*
|
|
* @param array $filters 검색 필터 (search, filters, status)
|
|
* @param int $perPage 페이지당 항목 수
|
|
* @param int $page 현재 페이지
|
|
* @return array 페이지네이션된 플러그인 목록
|
|
*/
|
|
public function getPaginatedPlugins(array $filters, int $perPage = 12, int $page = 1): array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
// 모든 플러그인 가져오기
|
|
$installedPlugins = $this->pluginManager->getInstalledPluginsWithDetails();
|
|
$uninstalledPlugins = $this->pluginManager->getUninstalledPlugins();
|
|
|
|
// 모든 플러그인 합치기
|
|
$allPlugins = array_merge(
|
|
array_values($installedPlugins),
|
|
array_values($uninstalledPlugins)
|
|
);
|
|
|
|
// 숨김 필터 적용 (기본: 숨김 항목 제외)
|
|
$allPlugins = $this->applyHiddenFilter($allPlugins, (bool) ($filters['include_hidden'] ?? false));
|
|
|
|
// 상태 필터 적용
|
|
if (! empty($filters['status'])) {
|
|
$allPlugins = $this->applyStatusFilter($allPlugins, $filters['status']);
|
|
}
|
|
|
|
// 다중 검색 필터 적용 (우선)
|
|
if (! empty($filters['filters']) && is_array($filters['filters'])) {
|
|
$allPlugins = $this->applyMultipleSearchFilters($allPlugins, $filters['filters']);
|
|
}
|
|
// 단일 검색어 필터 (하위 호환성)
|
|
elseif (! empty($filters['search'])) {
|
|
$allPlugins = $this->applyOrSearchAcrossFields($allPlugins, $filters['search']);
|
|
}
|
|
|
|
// 총 개수
|
|
$total = count($allPlugins);
|
|
|
|
// 페이지네이션 적용
|
|
$offset = ($page - 1) * $perPage;
|
|
$paginatedPlugins = array_slice($allPlugins, $offset, $perPage);
|
|
|
|
return [
|
|
'data' => array_values($paginatedPlugins),
|
|
'total' => $total,
|
|
'current_page' => $page,
|
|
'last_page' => (int) ceil($total / $perPage),
|
|
'per_page' => $perPage,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* 숨김 필터를 적용합니다.
|
|
*
|
|
* manifest 의 hidden=true 로 마킹된 플러그인은 기본 제외되며,
|
|
* $includeHidden=true 인 경우 포함됩니다.
|
|
*
|
|
* @param array $plugins 플러그인 목록
|
|
* @param bool $includeHidden 숨김 항목 포함 여부
|
|
* @return array 필터링된 플러그인 목록
|
|
*/
|
|
private function applyHiddenFilter(array $plugins, bool $includeHidden): array
|
|
{
|
|
if ($includeHidden) {
|
|
return $plugins;
|
|
}
|
|
|
|
return array_filter($plugins, function ($plugin) {
|
|
return empty($plugin['hidden']);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 상태 필터를 적용합니다.
|
|
*
|
|
* @param array $plugins 플러그인 목록
|
|
* @param string $status 상태 (installed, not_installed, active, inactive)
|
|
* @return array 필터링된 플러그인 목록
|
|
*/
|
|
private function applyStatusFilter(array $plugins, string $status): array
|
|
{
|
|
return array_filter($plugins, function ($plugin) use ($status) {
|
|
return match ($status) {
|
|
'installed' => ($plugin['status'] ?? '') !== 'uninstalled',
|
|
'uninstalled' => ($plugin['status'] ?? '') === 'uninstalled',
|
|
'active' => ($plugin['status'] ?? '') === 'active',
|
|
'inactive' => ($plugin['status'] ?? '') === 'inactive',
|
|
default => true,
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 다중 검색 조건을 적용합니다 (AND 조건).
|
|
*
|
|
* @param array $plugins 플러그인 목록
|
|
* @param array $searchFilters 검색 필터 배열
|
|
* @return array 필터링된 플러그인 목록
|
|
*/
|
|
private function applyMultipleSearchFilters(array $plugins, array $searchFilters): array
|
|
{
|
|
if (empty($searchFilters)) {
|
|
return $plugins;
|
|
}
|
|
|
|
return array_filter($plugins, function ($plugin) use ($searchFilters) {
|
|
foreach ($searchFilters as $filter) {
|
|
if (! $this->matchesFilter($plugin, $filter)) {
|
|
return false; // AND 조건: 하나라도 실패하면 제외
|
|
}
|
|
}
|
|
|
|
return true;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 단일 필터 조건 매칭 여부를 확인합니다.
|
|
*
|
|
* @param array $plugin 플러그인 정보
|
|
* @param array $filter 필터 조건
|
|
* @return bool 매칭 여부
|
|
*/
|
|
private function matchesFilter(array $plugin, array $filter): bool
|
|
{
|
|
$field = $filter['field'] ?? null;
|
|
$value = $filter['value'] ?? null;
|
|
$operator = $filter['operator'] ?? 'like';
|
|
|
|
if (! $field || ! $value || ! in_array($field, self::SEARCHABLE_FIELDS)) {
|
|
return true; // 유효하지 않은 필터는 통과
|
|
}
|
|
|
|
// 필드 값 가져오기 (다국어 필드 처리)
|
|
$fieldValue = $this->getFieldValue($plugin, $field);
|
|
|
|
if ($fieldValue === null) {
|
|
return false;
|
|
}
|
|
|
|
return match ($operator) {
|
|
'eq' => mb_strtolower($fieldValue) === mb_strtolower($value),
|
|
'starts_with' => str_starts_with(mb_strtolower($fieldValue), mb_strtolower($value)),
|
|
'ends_with' => str_ends_with(mb_strtolower($fieldValue), mb_strtolower($value)),
|
|
default => str_contains(mb_strtolower($fieldValue), mb_strtolower($value)), // like
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 단일 검색어로 여러 필드를 OR 조건으로 검색합니다.
|
|
*
|
|
* @param array $plugins 플러그인 목록
|
|
* @param string $searchTerm 검색어
|
|
* @return array 필터링된 플러그인 목록
|
|
*/
|
|
private function applyOrSearchAcrossFields(array $plugins, string $searchTerm): array
|
|
{
|
|
$searchTerm = mb_strtolower($searchTerm);
|
|
|
|
return array_filter($plugins, function ($plugin) use ($searchTerm) {
|
|
foreach (self::SEARCHABLE_FIELDS as $field) {
|
|
$fieldValue = $this->getFieldValue($plugin, $field);
|
|
if ($fieldValue !== null && str_contains(mb_strtolower($fieldValue), $searchTerm)) {
|
|
return true; // OR 조건: 하나라도 매칭되면 포함
|
|
}
|
|
}
|
|
|
|
return false;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 플러그인에서 필드 값을 가져옵니다 (다국어 필드 처리 포함).
|
|
*
|
|
* @param array $plugin 플러그인 정보
|
|
* @param string $field 필드명
|
|
* @return string|null 필드 값
|
|
*/
|
|
private function getFieldValue(array $plugin, string $field): ?string
|
|
{
|
|
$value = $plugin[$field] ?? null;
|
|
|
|
if ($value === null) {
|
|
return null;
|
|
}
|
|
|
|
// 다국어 필드인 경우 (name, description)
|
|
if (is_array($value)) {
|
|
// 현재 로케일 우선, 없으면 ko, 그 다음 en
|
|
$locale = app()->getLocale();
|
|
|
|
return $value[$locale] ?? $value[config('app.fallback_locale', 'ko')] ?? reset($value) ?: null;
|
|
}
|
|
|
|
return (string) $value;
|
|
}
|
|
|
|
/**
|
|
* 설치된 플러그인들의 업데이트 가능 여부를 확인합니다.
|
|
*
|
|
* @return array 업데이트 확인 결과 (updated_count, details)
|
|
*
|
|
* @throws ValidationException 업데이트 확인 실패 시
|
|
*/
|
|
public function checkForUpdates(): array
|
|
{
|
|
HookManager::doAction('core.plugins.before_check_updates');
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->checkAllPluginsForUpdates();
|
|
|
|
HookManager::doAction('core.plugins.after_check_updates', $result);
|
|
|
|
return $result;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugins' => [__('plugins.check_updates_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 지정된 플러그인을 업데이트합니다.
|
|
*
|
|
* @param string $pluginName 업데이트할 플러그인 identifier
|
|
* @param VendorMode $vendorMode Vendor 설치 모드
|
|
* @param string $layoutStrategy 레이아웃 전략 (overwrite|keep)
|
|
* @param bool $force 코어 버전 비호환 강제 우회 (위험 — 사용자 명시 필요)
|
|
* @return array 업데이트 결과 (identifier, from_version, to_version 등)
|
|
*
|
|
* @throws ValidationException 업데이트 실패 시
|
|
*/
|
|
public function updatePlugin(
|
|
string $pluginName,
|
|
VendorMode $vendorMode = VendorMode::Auto,
|
|
string $layoutStrategy = 'overwrite',
|
|
bool $force = false,
|
|
): array {
|
|
HookManager::doAction('core.plugins.before_update', $pluginName);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->updatePlugin(
|
|
$pluginName,
|
|
$force,
|
|
null,
|
|
$vendorMode,
|
|
$layoutStrategy,
|
|
);
|
|
|
|
$pluginInfo = $this->pluginManager->getPluginInfo($pluginName);
|
|
|
|
HookManager::doAction('core.plugins.after_update', $pluginName, $result, $pluginInfo);
|
|
|
|
return array_merge($result, [
|
|
'plugin_info' => $pluginInfo,
|
|
]);
|
|
} catch (\Exception $e) {
|
|
// Manager의 RuntimeException은 이미 번역된 메시지를 포함하므로
|
|
// getPrevious()로 원본 에러를 추출하여 이중 래핑 방지
|
|
$rawError = $e->getPrevious() ? $e->getPrevious()->getMessage() : $e->getMessage();
|
|
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.errors.update_failed', ['plugin' => $pluginName, 'error' => $rawError])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 지정된 플러그인의 수정된 레이아웃을 확인합니다.
|
|
*
|
|
* @param string $pluginName 확인할 플러그인 identifier
|
|
* @return array{has_modified_layouts: bool, modified_count: int, modified_layouts: array}
|
|
*
|
|
* @throws ValidationException 확인 실패 시
|
|
*/
|
|
public function checkModifiedLayouts(string $pluginName): array
|
|
{
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return $this->pluginManager->hasModifiedLayouts($pluginName);
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.check_modified_layouts_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인의 레이아웃을 파일에서 다시 읽어 DB에 갱신합니다.
|
|
*
|
|
* @param string $pluginName 플러그인명
|
|
* @return array{success: bool, layouts_refreshed: int} 갱신 결과 및 갱신된 레이아웃 개수
|
|
*
|
|
* @throws ValidationException 플러그인을 찾을 수 없거나 갱신 실패 시
|
|
*/
|
|
public function refreshPluginLayouts(string $pluginName): array
|
|
{
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return $this->pluginManager->refreshPluginLayouts($pluginName);
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.refresh_layouts_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인 에셋 파일 경로를 반환합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @param string $path 파일 경로
|
|
* @return array{success: bool, filePath: string|null, mimeType: string|null, error: string|null}
|
|
*/
|
|
public function getAssetFilePath(string $identifier, string $path): array
|
|
{
|
|
// 1. 활성화된 플러그인 확인
|
|
$plugin = $this->pluginRepository->findByIdentifier($identifier);
|
|
|
|
if (! $plugin || $plugin->status !== ExtensionStatus::Active->value) {
|
|
return [
|
|
'success' => false,
|
|
'filePath' => null,
|
|
'mimeType' => null,
|
|
'error' => 'plugin_not_found',
|
|
];
|
|
}
|
|
|
|
// 2. 파일 경로 구성 (플러그인 루트 기준)
|
|
$filePath = base_path("plugins/{$identifier}/{$path}");
|
|
|
|
// 3. 파일 존재 확인
|
|
if (! file_exists($filePath) || ! is_file($filePath)) {
|
|
return [
|
|
'success' => false,
|
|
'filePath' => null,
|
|
'mimeType' => null,
|
|
'error' => 'file_not_found',
|
|
];
|
|
}
|
|
|
|
// 4. MIME 타입 감지
|
|
$mimeType = $this->getMimeType($filePath);
|
|
|
|
return [
|
|
'success' => true,
|
|
'filePath' => $filePath,
|
|
'mimeType' => $mimeType,
|
|
'error' => null,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* 플러그인 편집기 스펙(editor-spec.json) 디코드 결과를 반환합니다.
|
|
*
|
|
* 활성 플러그인만 대상으로 하며, 활성 디렉토리 → _bundled 폴백 순으로 읽습니다.
|
|
* editor-spec.json 은 수작업 작성 파일로 플러그인 루트(plugin.json 옆)에 둡니다.
|
|
* 파일 미존재/미작성 시 spec=null 로 폴백합니다(편집 컨트롤 부재).
|
|
*
|
|
* @param string $identifier 플러그인 식별자 (vendor-plugin 형식)
|
|
* @return array{success: bool, spec: array<string, mixed>|null, error: string|null}
|
|
*/
|
|
public function getEditorSpec(string $identifier): array
|
|
{
|
|
$plugin = $this->pluginRepository->findByIdentifier($identifier);
|
|
|
|
if (! $plugin || $plugin->status !== ExtensionStatus::Active->value) {
|
|
return ['success' => false, 'spec' => null, 'error' => 'plugin_not_found'];
|
|
}
|
|
|
|
// 분할 editor-spec.json 은 manifest + `$include` 블록으로 구성되므로
|
|
// 단순 디코드가 아닌 합본이 필요하다. 활성 디렉토리만 기준으로 합본한다
|
|
// (_bundled 폴백 없음). _bundled 작업분은 plugin:update 로 활성에
|
|
// 반영된 뒤에만 런타임에 보인다. 미분할 파일은 원본 그대로(하위 호환).
|
|
$spec = EditorSpecAssembler::assemble(
|
|
base_path("plugins/{$identifier}/editor-spec.json")
|
|
);
|
|
|
|
return ['success' => true, 'spec' => $spec, 'error' => null];
|
|
}
|
|
|
|
/**
|
|
* 플러그인 컴포넌트 매니페스트(components.json) 디코드 결과를 반환합니다.
|
|
*
|
|
* components.json 은 plugin:build 산출물로 플러그인 루트에 둡니다.
|
|
* 활성 디렉토리 → _bundled 폴백 순으로 읽으며, 미생성(구버전 플러그인) 시
|
|
* components=null 로 폴백합니다(무손실 보존 디그레이드 — 원칙 4.6).
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @return array{success: bool, components: array<string, mixed>|null, error: string|null}
|
|
*/
|
|
public function getComponents(string $identifier): array
|
|
{
|
|
$plugin = $this->pluginRepository->findByIdentifier($identifier);
|
|
|
|
if (! $plugin || $plugin->status !== ExtensionStatus::Active->value) {
|
|
return ['success' => false, 'components' => null, 'error' => 'plugin_not_found'];
|
|
}
|
|
|
|
$components = $this->readJsonWithBundledFallback("plugins/{$identifier}/components.json");
|
|
|
|
return ['success' => true, 'components' => $components, 'error' => null];
|
|
}
|
|
|
|
/**
|
|
* 활성 디렉토리 → _bundled 폴백 순으로 JSON 파일을 읽어 디코드합니다.
|
|
*
|
|
* @param string $relativePath base_path 기준 상대 경로 (plugins/{id}/file.json)
|
|
* @return array<string, mixed>|null 디코드된 배열, 미존재/파싱 실패 시 null
|
|
*/
|
|
private function readJsonWithBundledFallback(string $relativePath): ?array
|
|
{
|
|
$bundledPath = preg_replace('#^plugins/#', 'plugins/_bundled/', $relativePath, 1);
|
|
$candidates = [base_path($relativePath), base_path((string) $bundledPath)];
|
|
|
|
foreach ($candidates as $path) {
|
|
if (! file_exists($path) || ! is_file($path)) {
|
|
continue;
|
|
}
|
|
$decoded = json_decode((string) file_get_contents($path), true);
|
|
if (is_array($decoded)) {
|
|
return $decoded;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* MIME 타입 감지
|
|
*
|
|
* @param string $filePath 파일 경로
|
|
* @return string MIME 타입
|
|
*/
|
|
private function getMimeType(string $filePath): string
|
|
{
|
|
$mimeTypes = [
|
|
'js' => 'application/javascript',
|
|
'mjs' => 'application/javascript',
|
|
'css' => 'text/css',
|
|
'json' => 'application/json',
|
|
'png' => 'image/png',
|
|
'jpg' => 'image/jpeg',
|
|
'jpeg' => 'image/jpeg',
|
|
'svg' => 'image/svg+xml',
|
|
'webp' => 'image/webp',
|
|
'gif' => 'image/gif',
|
|
'ico' => 'image/x-icon',
|
|
'woff' => 'font/woff',
|
|
'woff2' => 'font/woff2',
|
|
'ttf' => 'font/ttf',
|
|
'otf' => 'font/otf',
|
|
'eot' => 'application/vnd.ms-fontobject',
|
|
];
|
|
|
|
$extension = strtolower(pathinfo($filePath, PATHINFO_EXTENSION));
|
|
|
|
return $mimeTypes[$extension] ?? 'application/octet-stream';
|
|
}
|
|
|
|
/**
|
|
* 플러그인의 변경 내역(changelog)을 조회합니다.
|
|
*
|
|
* source가 'github'이면 GitHub에서 원격 CHANGELOG.md를 가져와 파싱합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @param string|null $source 소스 ('active', 'bundled', 'github')
|
|
* @param string|null $fromVersion 시작 버전 (초과)
|
|
* @param string|null $toVersion 끝 버전 (이하)
|
|
* @return array 변경 내역 배열
|
|
*/
|
|
public function getPluginChangelog(string $identifier, ?string $source = null, ?string $fromVersion = null, ?string $toVersion = null): array
|
|
{
|
|
// GitHub 소스: 원격에서 CHANGELOG.md를 가져옴
|
|
if ($source === 'github') {
|
|
return $this->fetchRemoteChangelog($identifier, $fromVersion, $toVersion);
|
|
}
|
|
|
|
$basePath = base_path('plugins');
|
|
$filePath = ChangelogParser::resolveChangelogPath($basePath, $identifier, $source);
|
|
|
|
if ($filePath === null) {
|
|
return [];
|
|
}
|
|
|
|
if ($fromVersion !== null && $toVersion !== null) {
|
|
return ChangelogParser::getVersionRange($filePath, $fromVersion, $toVersion);
|
|
}
|
|
|
|
return ChangelogParser::parse($filePath);
|
|
}
|
|
|
|
/**
|
|
* GitHub에서 원격 CHANGELOG.md를 가져와 파싱합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @param string|null $fromVersion 시작 버전 (초과)
|
|
* @param string|null $toVersion 끝 버전 (이하)
|
|
* @return array 변경 내역 배열
|
|
*/
|
|
private function fetchRemoteChangelog(string $identifier, ?string $fromVersion = null, ?string $toVersion = null): array
|
|
{
|
|
$plugin = $this->pluginManager->getPlugin($identifier);
|
|
|
|
if (! $plugin) {
|
|
return [];
|
|
}
|
|
|
|
$githubUrl = $plugin->getGithubUrl();
|
|
|
|
if (empty($githubUrl)) {
|
|
return $this->getPluginChangelog($identifier, 'bundled', $fromVersion, $toVersion);
|
|
}
|
|
|
|
try {
|
|
[$owner, $repo] = GithubHelper::parseUrl($githubUrl);
|
|
} catch (\RuntimeException $e) {
|
|
return $this->getPluginChangelog($identifier, 'bundled', $fromVersion, $toVersion);
|
|
}
|
|
|
|
$ref = $toVersion ?? 'main';
|
|
$content = GithubHelper::fetchRawFile($owner, $repo, $ref, 'CHANGELOG.md');
|
|
|
|
if ($content === null) {
|
|
return $this->getPluginChangelog($identifier, 'bundled', $fromVersion, $toVersion);
|
|
}
|
|
|
|
if ($fromVersion !== null && $toVersion !== null) {
|
|
return ChangelogParser::getVersionRangeFromString($content, $fromVersion, $toVersion);
|
|
}
|
|
|
|
return ChangelogParser::parseFromString($content);
|
|
}
|
|
|
|
/**
|
|
* ZIP 파일에서 플러그인을 설치합니다.
|
|
*
|
|
* @param UploadedFile $file 업로드된 ZIP 파일
|
|
* @return array 설치된 플러그인 정보
|
|
*
|
|
* @throws \RuntimeException 설치 실패 시
|
|
*/
|
|
/**
|
|
* 업로드된 ZIP 의 manifest 와 검증 결과만 추출합니다 (실제 설치 X).
|
|
*
|
|
* 사용자가 플러그인 설치 전 plugin.json 검증 실패 사유를 미리 확인할 수 있게 합니다.
|
|
*
|
|
* @param UploadedFile $file 업로드된 ZIP 파일
|
|
* @return array{manifest: ?array<string, mixed>, validation: array<string, mixed>} 미리보기 결과
|
|
*/
|
|
public function previewManifest(UploadedFile $file): array
|
|
{
|
|
$tempPath = storage_path('app/temp/plugins');
|
|
$extractPath = $tempPath.'/preview-'.uniqid('plugin_');
|
|
$manifest = null;
|
|
$errors = [];
|
|
|
|
try {
|
|
File::ensureDirectoryExists($tempPath);
|
|
|
|
$result = ZipInstallHelper::extractAndValidate(
|
|
$file->getRealPath(), $extractPath, 'plugin.json', 'plugins'
|
|
);
|
|
|
|
$manifest = $result['config'];
|
|
} catch (\Throwable $e) {
|
|
$errors[] = $e->getMessage();
|
|
} finally {
|
|
if (File::exists($extractPath)) {
|
|
File::deleteDirectory($extractPath);
|
|
}
|
|
}
|
|
|
|
$existing = $manifest && ! empty($manifest['identifier'])
|
|
? $this->pluginRepository->findByIdentifier($manifest['identifier'])
|
|
: null;
|
|
|
|
return [
|
|
'manifest' => $manifest,
|
|
'validation' => [
|
|
'errors' => $errors,
|
|
'is_valid' => $errors === [] && $manifest !== null,
|
|
'already_installed' => $existing !== null,
|
|
'existing_version' => $existing?->version,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* 업로드된 ZIP 파일로부터 플러그인을 추출/검증하고 _pending 으로 이동 후 설치합니다.
|
|
*
|
|
* `plugin.json` 검증 → identifier 충돌 검사 → _pending 이동 → 설치 파이프라인 진입.
|
|
*
|
|
* @param UploadedFile $file 사용자가 업로드한 플러그인 ZIP 파일
|
|
* @return array 설치 결과 (identifier/version/installed_at 포함)
|
|
*/
|
|
public function installFromZipFile(UploadedFile $file): array
|
|
{
|
|
$tempPath = storage_path('app/temp/plugins');
|
|
$extractPath = $tempPath.'/'.uniqid('plugin_');
|
|
|
|
try {
|
|
File::ensureDirectoryExists($tempPath);
|
|
|
|
$result = ZipInstallHelper::extractAndValidate(
|
|
$file->getRealPath(), $extractPath, 'plugin.json', 'plugins'
|
|
);
|
|
|
|
$this->ensurePluginNotInstalled($result['identifier']);
|
|
|
|
ZipInstallHelper::moveToPending(
|
|
$result['sourcePath'], base_path('plugins/_pending'), $result['identifier']
|
|
);
|
|
|
|
try {
|
|
return $this->executePluginInstall($result['identifier']);
|
|
} catch (\Throwable $e) {
|
|
$pendingPath = base_path('plugins/_pending/'.$result['identifier']);
|
|
if (File::exists($pendingPath)) {
|
|
File::deleteDirectory($pendingPath);
|
|
}
|
|
throw $e;
|
|
}
|
|
} catch (PluginOperationException $e) {
|
|
throw $e;
|
|
} catch (\RuntimeException $e) {
|
|
// ZipInstallHelper 등 설치 원본 처리의 raw RuntimeException(깨진 zip·manifest
|
|
// 누락 같은 사용자 입력 오류)을 도메인 예외로 승격한다 — 컨트롤러의 좁혀진
|
|
// catch 가 인프라 예외와 구분해 종전 422 계약을 유지하고, 사유는 :error 로 보존.
|
|
throw new PluginOperationException('plugins.errors.install_failed', ['error' => $e->getMessage()], $e);
|
|
} finally {
|
|
if (File::exists($extractPath)) {
|
|
File::deleteDirectory($extractPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* GitHub 저장소에서 플러그인을 설치합니다.
|
|
*
|
|
* @param string $githubUrl GitHub 저장소 URL
|
|
* @return array 설치된 플러그인 정보
|
|
*
|
|
* @throws \RuntimeException 설치 실패 시
|
|
*/
|
|
public function installFromGithub(string $githubUrl): array
|
|
{
|
|
$tempPath = storage_path('app/temp/plugins');
|
|
$extractPath = $tempPath.'/'.uniqid('plugin_');
|
|
$zipPath = null;
|
|
|
|
try {
|
|
File::ensureDirectoryExists($tempPath);
|
|
|
|
[$owner, $repo] = GithubHelper::parseUrl($githubUrl);
|
|
|
|
$token = config('app.update.github_token') ?? '';
|
|
|
|
if (! GithubHelper::checkRepoExists($owner, $repo, $token)) {
|
|
throw new PluginOperationException('plugins.errors.github_repo_not_found');
|
|
}
|
|
|
|
$zipPath = GithubHelper::downloadZip($owner, $repo, $tempPath, $token);
|
|
|
|
$result = ZipInstallHelper::extractAndValidate(
|
|
$zipPath, $extractPath, 'plugin.json', 'plugins'
|
|
);
|
|
|
|
$this->ensurePluginNotInstalled($result['identifier']);
|
|
|
|
ZipInstallHelper::moveToPending(
|
|
$result['sourcePath'], base_path('plugins/_pending'), $result['identifier']
|
|
);
|
|
|
|
try {
|
|
return $this->executePluginInstall($result['identifier']);
|
|
} catch (\Throwable $e) {
|
|
$pendingPath = base_path('plugins/_pending/'.$result['identifier']);
|
|
if (File::exists($pendingPath)) {
|
|
File::deleteDirectory($pendingPath);
|
|
}
|
|
throw $e;
|
|
}
|
|
} catch (PluginOperationException $e) {
|
|
throw $e;
|
|
} catch (\RuntimeException $e) {
|
|
// GithubHelper·ZipInstallHelper 의 raw RuntimeException(잘못된 URL·다운로드
|
|
// 실패·manifest 오류)을 도메인 예외로 승격한다 — 종전 422 계약 유지, 사유 보존.
|
|
throw new PluginOperationException('plugins.errors.install_failed', ['error' => $e->getMessage()], $e);
|
|
} finally {
|
|
if (File::exists($extractPath)) {
|
|
File::deleteDirectory($extractPath);
|
|
}
|
|
if ($zipPath && File::exists($zipPath)) {
|
|
File::delete($zipPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인이 이미 설치되어 있는지 확인합니다.
|
|
*
|
|
* _bundled/_pending에만 존재하는 경우(is_installed=false)는 설치 허용합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
*
|
|
* @throws \RuntimeException 이미 설치된 경우
|
|
*/
|
|
private function ensurePluginNotInstalled(string $identifier): void
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
$existingPlugin = $this->pluginManager->getPluginInfo($identifier);
|
|
|
|
if ($existingPlugin && $existingPlugin['is_installed']) {
|
|
throw new PluginOperationException('plugins.errors.already_installed', ['plugin' => $identifier]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* _pending에서 플러그인을 설치합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @return array 설치된 플러그인 정보
|
|
*
|
|
* @throws \RuntimeException 설치 실패 시
|
|
*/
|
|
private function executePluginInstall(string $identifier): array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->installPlugin($identifier, null, VendorMode::Auto, false, $failureReason);
|
|
|
|
if (! $result) {
|
|
// 사유를 실어 올리지 않으면 'plugins.errors.install_failed' 의 치환 자리가
|
|
// 비어 관리자 화면에 리터럴 ':error' 가 그대로 노출된다.
|
|
throw new PluginOperationException('plugins.errors.install_failed', [
|
|
'error' => $failureReason ?? __('plugins.errors.unknown_error'),
|
|
]);
|
|
}
|
|
|
|
return $this->pluginManager->getPluginInfo($identifier);
|
|
}
|
|
}
|