openvsx-webui-test 0.17.1 → 0.18.0-dev.0

package/src/extension-registry-service.ts

@@ -12,7 +12,9 @@ import {
     Extension, UserData, ExtensionCategory, ExtensionReviewList, PersonalAccessToken, SearchResult, NewReview,
     SuccessResult, ErrorResult, CsrfTokenJson, isError, Namespace, NamespaceDetails, MembershipRole, SortBy,
     SortOrder, UrlString, NamespaceMembershipList, PublisherInfo, SearchEntry, RegistryVersion,
-    LoginProviders
+    LoginProviders, ScanResultJson, ScanCounts, ScanResultsResponse, ScanFilterOptions,
+    FilesResponse, FileDecisionCountsJson, ScanDecisionRequest, ScanDecisionResponse,
+    FileDecisionRequest, FileDecisionResponse, FileDecisionDeleteRequest, FileDecisionDeleteResponse
 } from './extension-registry-types';
 import { createAbsoluteURL, addQuery } from './utils';
 import { sendRequest, ErrorResponse } from './server-request';
@@ -209,6 +211,22 @@ export class ExtensionRegistryService {
         });
     }
 
+    async deleteUserReview(abortController: AbortController, extension: Extension, user: UserData): Promise<Readonly<SuccessResult | ErrorResult>> {
+        const csrfResponse = await this.getCsrfToken(abortController);
+        const headers: Record<string, string> = {};
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.serverUrl, 'admin', 'extension', extension.namespace, extension.name, 'review', user.provider || 'github', user.loginName, 'delete']),
+            headers
+        });
+    }
+
     getUser(abortController: AbortController): Promise<Readonly<UserData | ErrorResult>> {
         return sendRequest({
             abortController,
@@ -470,6 +488,17 @@ export interface AdminService {
     getPublisherInfo(abortController: AbortController, provider: string, login: string): Promise<Readonly<PublisherInfo>>
     revokePublisherContributions(abortController: AbortController, provider: string, login: string): Promise<Readonly<SuccessResult | ErrorResult>>
     revokeAccessTokens(abortController: AbortController, provider: string, login: string): Promise<Readonly<SuccessResult | ErrorResult>>
+    getAllScans(abortController: AbortController, params?: { size?: number; offset?: number; status?: string | string[]; publisher?: string; namespace?: string; name?: string; validationType?: string[]; threatScannerName?: string[]; dateStartedFrom?: string; dateStartedTo?: string; enforcement?: 'enforced' | 'notEnforced' | 'all' }): Promise<Readonly<ScanResultsResponse>>
+    getScan(abortController: AbortController, scanId: string): Promise<Readonly<ScanResultJson>>
+    getScanCounts(abortController: AbortController, params?: { dateStartedFrom?: string; dateStartedTo?: string; enforcement?: 'enforced' | 'notEnforced' | 'all'; threatScannerName?: string[]; validationType?: string[] }): Promise<Readonly<ScanCounts>>
+    getScanFilterOptions(abortController: AbortController): Promise<Readonly<ScanFilterOptions>>
+    // Files API
+    getFiles(abortController: AbortController, params?: { size?: number; offset?: number; decision?: string; publisher?: string; namespace?: string; name?: string; dateDecidedFrom?: string; dateDecidedTo?: string; sortBy?: string; sortOrder?: 'asc' | 'desc' }): Promise<Readonly<FilesResponse>>;
+    getFileCounts(abortController: AbortController, params?: { dateDecidedFrom?: string; dateDecidedTo?: string }): Promise<Readonly<FileDecisionCountsJson>>
+    // Decision APIs
+    makeScanDecision(abortController: AbortController, request: ScanDecisionRequest): Promise<Readonly<ScanDecisionResponse>>
+    makeFileDecision(abortController: AbortController, request: FileDecisionRequest): Promise<Readonly<FileDecisionResponse>>
+    deleteFileDecisions(abortController: AbortController, request: FileDecisionDeleteRequest): Promise<Readonly<FileDecisionDeleteResponse>>
 }
 
 export interface AdminServiceConstructor {
@@ -593,6 +622,192 @@ export class AdminServiceImpl implements AdminService {
             headers
         });
     }
+
+    getAllScans(abortController: AbortController, params?: { size?: number; offset?: number; status?: string | string[]; publisher?: string; namespace?: string; name?: string; validationType?: string[]; threatScannerName?: string[]; dateStartedFrom?: string; dateStartedTo?: string; enforcement?: 'enforced' | 'notEnforced' | 'all'; adminDecision?: string[] }): Promise<Readonly<ScanResultsResponse>> {
+        const query: { key: string, value: string | number }[] = [];
+        if (params) {
+            if (params.size !== undefined)
+                query.push({ key: 'size', value: params.size });
+            if (params.offset !== undefined)
+                query.push({ key: 'offset', value: params.offset });
+            if (params.status) {
+                const statusValue = Array.isArray(params.status) ? params.status.join(',') : params.status;
+                query.push({ key: 'status', value: statusValue });
+            }
+            if (params.publisher)
+                query.push({ key: 'publisher', value: params.publisher });
+            if (params.namespace)
+                query.push({ key: 'namespace', value: params.namespace });
+            if (params.name)
+                query.push({ key: 'name', value: params.name });
+            if (params.validationType && params.validationType.length > 0)
+                query.push({ key: 'validationType', value: params.validationType.join(',') });
+            if (params.threatScannerName && params.threatScannerName.length > 0)
+                query.push({ key: 'threatScannerName', value: params.threatScannerName.join(',') });
+            if (params.dateStartedFrom)
+                query.push({ key: 'dateStartedFrom', value: params.dateStartedFrom });
+            if (params.dateStartedTo)
+                query.push({ key: 'dateStartedTo', value: params.dateStartedTo });
+            if (params.enforcement)
+                query.push({ key: 'enforcement', value: params.enforcement });
+            if (params.adminDecision && params.adminDecision.length > 0)
+                query.push({ key: 'adminDecision', value: params.adminDecision.join(',') });
+        }
+        const endpoint = createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans'], query);
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint
+        });
+    }
+
+    getScan(abortController: AbortController, scanId: string): Promise<Readonly<ScanResultJson>> {
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', scanId])
+        });
+    }
+
+    getScanCounts(abortController: AbortController, params?: { dateStartedFrom?: string; dateStartedTo?: string; enforcement?: 'enforced' | 'notEnforced' | 'all'; threatScannerName?: string[]; validationType?: string[] }): Promise<Readonly<ScanCounts>> {
+        const query: { key: string, value: string | number }[] = [];
+        if (params) {
+            if (params.dateStartedFrom)
+                query.push({ key: 'dateStartedFrom', value: params.dateStartedFrom });
+            if (params.dateStartedTo)
+                query.push({ key: 'dateStartedTo', value: params.dateStartedTo });
+            if (params.enforcement)
+                query.push({ key: 'enforcement', value: params.enforcement });
+            if (params.threatScannerName && params.threatScannerName.length > 0) {
+                query.push({ key: 'threatScannerName', value: params.threatScannerName.join(',') });
+            }
+            if (params.validationType && params.validationType.length > 0) {
+                query.push({ key: 'validationType', value: params.validationType.join(',') });
+            }
+        }
+        const endpoint = createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'counts'], query);
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint
+        });
+    }
+
+    getScanFilterOptions(abortController: AbortController): Promise<Readonly<ScanFilterOptions>> {
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'filterOptions'])
+        });
+    }
+
+    getFiles(abortController: AbortController, params?: { size?: number; offset?: number; decision?: string; publisher?: string; namespace?: string; name?: string; dateDecidedFrom?: string; dateDecidedTo?: string; sortBy?: string; sortOrder?: 'asc' | 'desc' }): Promise<Readonly<FilesResponse>> {
+        const query: { key: string, value: string | number }[] = [];
+        if (params) {
+            if (params.size !== undefined)
+                query.push({ key: 'size', value: params.size });
+            if (params.offset !== undefined)
+                query.push({ key: 'offset', value: params.offset });
+            if (params.decision)
+                query.push({ key: 'decision', value: params.decision });
+            if (params.publisher)
+                query.push({ key: 'publisher', value: params.publisher });
+            if (params.namespace)
+                query.push({ key: 'namespace', value: params.namespace });
+            if (params.name)
+                query.push({ key: 'name', value: params.name });
+            if (params.dateDecidedFrom)
+                query.push({ key: 'dateDecidedFrom', value: params.dateDecidedFrom });
+            if (params.dateDecidedTo)
+                query.push({ key: 'dateDecidedTo', value: params.dateDecidedTo });
+            if (params.sortBy)
+                query.push({ key: 'sortBy', value: params.sortBy });
+            if (params.sortOrder)
+                query.push({ key: 'sortOrder', value: params.sortOrder });
+        }
+        const endpoint = createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files'], query);
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint
+        });
+    }
+
+    getFileCounts(abortController: AbortController, params?: { dateDecidedFrom?: string; dateDecidedTo?: string }): Promise<Readonly<FileDecisionCountsJson>> {
+        const query: { key: string, value: string | number }[] = [];
+        if (params) {
+            if (params.dateDecidedFrom)
+                query.push({ key: 'dateDecidedFrom', value: params.dateDecidedFrom });
+            if (params.dateDecidedTo)
+                query.push({ key: 'dateDecidedTo', value: params.dateDecidedTo });
+        }
+        const endpoint = createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'counts'], query);
+        return sendRequest({
+            abortController,
+            credentials: true,
+            endpoint
+        });
+    }
+
+    async makeScanDecision(abortController: AbortController, request: ScanDecisionRequest): Promise<Readonly<ScanDecisionResponse>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'decisions']),
+            headers,
+            payload: request
+        });
+    }
+
+    async makeFileDecision(abortController: AbortController, request: FileDecisionRequest): Promise<Readonly<FileDecisionResponse>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+
+        return sendRequest({
+            abortController,
+            method: 'POST',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'decisions']),
+            headers,
+            payload: request
+        });
+    }
+
+    async deleteFileDecisions(abortController: AbortController, request: FileDecisionDeleteRequest): Promise<Readonly<FileDecisionDeleteResponse>> {
+        const csrfResponse = await this.registry.getCsrfToken(abortController);
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json;charset=UTF-8'
+        };
+        if (!isError(csrfResponse)) {
+            const csrfToken = csrfResponse as CsrfTokenJson;
+            headers[csrfToken.header] = csrfToken.value;
+        }
+
+        return sendRequest({
+            abortController,
+            method: 'DELETE',
+            credentials: true,
+            endpoint: createAbsoluteURL([this.registry.serverUrl, 'admin', 'scans', 'files', 'decisions']),
+            headers,
+            payload: request
+        });
+    }
 }
 
 export interface ExtensionFilter {

package/src/extension-registry-types.ts

@@ -78,6 +78,8 @@ export interface Extension {
     // key: version, value: url
     allVersions: { [version: string]: UrlString };
     active?: boolean;
+    reviewStatus?: 'published' | 'under_review' | 'rejected';
+    reviewMessage?: string;
 
     averageRating?: number;
     downloadCount: number;
@@ -258,3 +260,158 @@ export interface LoginProviders {
 export type MembershipRole = 'contributor' | 'owner';
 export type SortBy = 'relevance' | 'timestamp' | 'rating' | 'downloadCount';
 export type SortOrder = 'asc' | 'desc';
+
+// Scan and file decision types (used by admin scan UI)
+export interface ScanResultJson {
+    id: string;
+    namespace: string;
+    extensionName: string;
+    version: string;
+    displayName: string;
+    publisher: string;
+    extensionIcon?: string;
+    downloadUrl?: string;
+    publisherUrl?: string;
+    status: string;
+    dateScanStarted: string;
+    dateScanEnded?: string;
+    errorMessage?: string;
+    dateQuarantined?: string;
+    dateRejected?: string;
+    threats?: Array<{
+        id: string;
+        fileName: string;
+        fileHash: string;
+        type: string;
+        severity?: string;
+        reason: string;
+        fileExtension: string;
+        dateDetected: string;
+        ruleName: string;
+        enforcedFlag?: boolean;
+    }>;
+    validationFailures?: Array<{
+        id: string;
+        type: string;
+        ruleName: string;
+        reason: string;
+        dateDetected: string;
+        enforcedFlag: boolean;
+    }>;
+    adminDecision?: {
+        decision: string;
+        decidedBy: string;
+        dateDecided: string;
+    };
+}
+
+export interface ScanCounts {
+    STARTED: number;
+    VALIDATING: number;
+    SCANNING: number;
+    PASSED: number;
+    QUARANTINED: number;
+    AUTO_REJECTED: number;
+    ERROR: number;
+    ALLOWED: number;
+    BLOCKED: number;
+    NEEDS_REVIEW: number;
+}
+
+export interface ScanResultsResponse {
+    success?: string;
+    warning?: string;
+    error?: string;
+    offset: number;
+    totalSize: number;
+    scans: ScanResultJson[];
+}
+
+export interface ScanFilterOptions {
+    validationTypes: string[];
+    threatScannerNames: string[];
+}
+
+export interface FileDecisionJson {
+    id: string;
+    fileName: string;
+    fileHash: string;
+    fileType: string;
+    decision: string;
+    decidedBy: string;
+    dateDecided: string;
+    displayName: string;
+    namespace: string;
+    extensionName: string;
+    publisher: string;
+    version: string;
+    scanId?: string;
+}
+
+export interface FilesResponse {
+    success?: string;
+    warning?: string;
+    error?: string;
+    offset: number;
+    totalSize: number;
+    files: FileDecisionJson[];
+}
+
+export interface FileDecisionCountsJson {
+    allowed: number;
+    blocked: number;
+    total: number;
+}
+
+export interface ScanDecisionRequest {
+    scanIds: string[];
+    decision: string;
+}
+
+export interface ScanDecisionResult {
+    scanId: string;
+    success: boolean;
+    error?: string;
+}
+
+export interface ScanDecisionResponse {
+    processed: number;
+    successful: number;
+    failed: number;
+    results: ScanDecisionResult[];
+}
+
+export interface FileDecisionRequest {
+    fileHashes: string[];
+    decision: string;
+}
+
+export interface FileDecisionResult {
+    fileHash: string;
+    success: boolean;
+    error?: string;
+}
+
+export interface FileDecisionResponse {
+    processed: number;
+    successful: number;
+    failed: number;
+    results: FileDecisionResult[];
+}
+
+export interface FileDecisionDeleteRequest {
+    fileIds: string[];
+}
+
+export interface FileDecisionDeleteResult {
+    fileId: string;
+    success: boolean;
+    error?: string;
+}
+
+export interface FileDecisionDeleteResponse {
+    processed: number;
+    successful: number;
+    failed: number;
+    results: FileDecisionDeleteResult[];
+}

package/src/hooks/scan-admin/index.ts

@@ -0,0 +1,48 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+// Core hooks
+export { useTabNavigation, TAB_DEFINITIONS } from './use-tab-navigation';
+export type { UseTabNavigationReturn, TabIndex, TabName } from './use-tab-navigation';
+
+export { useScanFilters } from './use-scan-filters';
+export type { UseScanFiltersReturn } from './use-scan-filters';
+
+export { usePagination } from './use-pagination';
+export type { UsePaginationReturn } from './use-pagination';
+
+export { useSearch } from './use-search';
+export type { UseSearchReturn } from './use-search';
+
+export { useDialogs } from './use-dialogs';
+export type { UseDialogsReturn } from './use-dialogs';
+
+// Tab-specific hooks
+export { useScansTab } from './use-scans-tab';
+export type { UseScansTabReturn } from './use-scans-tab';
+
+export { useQuarantinedTab } from './use-quarantined-tab';
+export type { UseQuarantinedTabReturn } from './use-quarantined-tab';
+
+export { useAutoRejectedTab } from './use-auto-rejected-tab';
+export type { UseAutoRejectedTabReturn } from './use-auto-rejected-tab';
+
+export { useFileListTab, useAllowListTab, useBlockListTab } from './use-file-list-tab';
+export type { UseFileListTabReturn, UseAllowListTabReturn, UseBlockListTabReturn } from './use-file-list-tab';
+
+// URL sync hook
+export { useUrlSync } from './use-url-sync';
+export type { UseUrlSyncReturn } from './use-url-sync';
+
+// Component-specific hooks
+export { useScanCardState } from './use-scan-card-state';

package/src/hooks/scan-admin/use-auto-rejected-tab.ts

@@ -0,0 +1,85 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+import { useMemo } from 'react';
+import { useScanContext } from '../../context/scan-admin';
+import { useScanFilters } from './use-scan-filters';
+import { usePagination } from './use-pagination';
+import { useSearch } from './use-search';
+
+/**
+ * Hook for the Auto Rejected tab (tab index 2).
+ * Provides auto-rejected scan data and validation type filtering.
+ */
+export const useAutoRejectedTab = () => {
+    const { state, actions } = useScanContext();
+    const { globalFilters, validationTypeFilters } = useScanFilters();
+    const pagination = usePagination();
+    const search = useSearch();
+
+    // Use scans directly from state - backend handles filtering based on tab and enforcement
+    const autoRejectedScans = state.scans;
+
+    // Get validation type breakdown
+    const validationTypeBreakdown = useMemo(() => {
+        const breakdown: Record<string, number> = {};
+        autoRejectedScans.forEach(scan => {
+            scan.validationFailures?.forEach(failure => {
+                const type = failure.type || 'Unknown';
+                breakdown[type] = (breakdown[type] || 0) + 1;
+            });
+        });
+        return breakdown;
+    }, [autoRejectedScans]);
+
+    // Get total count from the counts API (unaffected by search filters)
+    const totalCount = (state.scanCounts?.STARTED ?? 0) + (state.scanCounts?.VALIDATING ?? 0) +
+        (state.scanCounts?.SCANNING ?? 0) + (state.scanCounts?.PASSED ?? 0) +
+        (state.scanCounts?.QUARANTINED ?? 0) + (state.scanCounts?.AUTO_REJECTED ?? 0) +
+        (state.scanCounts?.ERROR ?? 0);
+
+    // Check if there are any validation types available to filter by
+    const hasValidationTypes = state.availableValidationTypes.length > 0;
+
+    return useMemo(() => ({
+        tabIndex: 2,
+        tabName: 'Auto Rejected',
+        scans: autoRejectedScans,
+        isLoading: state.isLoadingScans,
+        lastRefreshed: state.lastRefreshed,
+        autoRefresh: state.autoRefresh,
+        onAutoRefreshChange: actions.setAutoRefresh,
+        totalCount,
+        hasValidationTypes,
+        search,
+        globalFilters,
+        validationTypeFilters,
+        pagination,
+        validationTypeBreakdown,
+    }), [
+        autoRejectedScans,
+        state.isLoadingScans,
+        state.lastRefreshed,
+        state.autoRefresh,
+        actions.setAutoRefresh,
+        totalCount,
+        hasValidationTypes,
+        search,
+        globalFilters,
+        validationTypeFilters,
+        pagination,
+        validationTypeBreakdown,
+    ]);
+};
+
+export type UseAutoRejectedTabReturn = ReturnType<typeof useAutoRejectedTab>;

package/src/hooks/scan-admin/use-dialogs.ts

@@ -0,0 +1,83 @@
+/********************************************************************************
+ * Copyright (c) 2026 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ ********************************************************************************/
+
+import { useMemo } from 'react';
+import { useScanContext } from '../../context/scan-admin';
+import { ConfirmActionType, FileActionType, ScanResult, FileDecision } from '../../context/scan-admin/scan-types';
+
+/**
+ * Return type for the useDialogs hook
+ */
+export interface UseDialogsReturn {
+    /** Confirm dialog state and actions (for extension-level allow/block) */
+    confirmDialog: {
+        isOpen: boolean;
+        action: ConfirmActionType;
+        selectedExtensions: ScanResult[];
+        close: () => void;
+        execute: () => void;
+    };
+    /** File dialog state and actions (for file-level allow/block/delete) */
+    fileDialog: {
+        isOpen: boolean;
+        actionType: FileActionType;
+        selectedFiles: FileDecision[];
+        close: () => void;
+        execute: () => void;
+    };
+    openAllowDialog: () => void;
+    openBlockDialog: () => void;
+    openFileDialog: (action: FileActionType) => void;
+}
+
+/**
+ * Hook for dialog state and actions.
+ * Provides a clean interface for dialog components to consume.
+ */
+export const useDialogs = (): UseDialogsReturn => {
+    const { state, actions, derived } = useScanContext();
+
+    return useMemo(() => ({
+        confirmDialog: {
+            isOpen: state.confirmDialogOpen,
+            action: state.confirmAction,
+            selectedExtensions: derived.selectedExtensions,
+            close: actions.closeConfirmDialog,
+            execute: actions.executeConfirmAction,
+        },
+        fileDialog: {
+            isOpen: state.fileDialogOpen,
+            actionType: state.fileActionType,
+            selectedFiles: derived.selectedFiles,
+            close: actions.closeFileDialog,
+            execute: actions.executeFileAction,
+        },
+        openAllowDialog: actions.openAllowDialog,
+        openBlockDialog: actions.openBlockDialog,
+        openFileDialog: actions.openFileDialog,
+    }), [
+        state.confirmDialogOpen,
+        state.confirmAction,
+        state.fileDialogOpen,
+        state.fileActionType,
+        derived.selectedExtensions,
+        derived.selectedFiles,
+        actions.closeConfirmDialog,
+        actions.executeConfirmAction,
+        actions.closeFileDialog,
+        actions.executeFileAction,
+        actions.openAllowDialog,
+        actions.openBlockDialog,
+        actions.openFileDialog,
+    ]);
+};