Files
dbx/apps/desktop/src/components/nacos/NacosAdminConsole.vue
T

3405 lines
160 KiB
Vue
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<script setup lang="ts">
import { computed, nextTick, onBeforeUnmount, onMounted, ref, shallowRef, useId, watch } from "vue";
import { Compartment, type Extension } from "@codemirror/state";
import { StreamLanguage } from "@codemirror/language";
import type { EditorView } from "@codemirror/view";
import { Archive, ArrowLeftRight, CheckCircle2, ChevronDown, ChevronLeft, ChevronRight, Clipboard, Columns3, Download, FileClock, FileInput, FileText, Loader2, Network, Plus, RefreshCw, Save, Search, Send, Server, Trash2, X } from "@lucide/vue";
import { Button } from "@/components/ui/button";
import { Badge } from "@/components/ui/badge";
import ProductionContextBadge from "@/components/common/ProductionContextBadge.vue";
import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
import EditorSearchPanel from "@/components/editor/EditorSearchPanel.vue";
import NacosConfigDiffDialog from "@/components/nacos/NacosConfigDiffDialog.vue";
import NacosConfigHistoryDialog from "@/components/nacos/NacosConfigHistoryDialog.vue";
import NacosConfigBatchDialog, { type NacosBatchDialogMode, type NacosConfigTransferTarget } from "@/components/nacos/NacosConfigBatchDialog.vue";
import NacosContentSearchDialog from "@/components/nacos/NacosContentSearchDialog.vue";
import { useToast } from "@/composables/useToast";
import { useNacosConfigListColumnResize, type ToggleableNacosConfigListColumnKey } from "@/composables/useNacosConfigListColumnResize";
import { useConnectionStore } from "@/stores/connectionStore";
import { useQueryStore } from "@/stores/queryStore";
import { useI18n } from "vue-i18n";
import * as api from "@/lib/backend/api";
import {
buildNacosConfigDeleteConfirm,
buildNacosConfigExportFileName,
buildNacosConfigHistoryRollbackConfirm,
buildNacosContentSearchCsv,
buildNacosInstanceConfirm,
canStartNacosConfigDelete,
canStartNacosConfigSave,
createNacosConfigDeleteSnapshot,
createNacosConfigSaveSnapshot,
createNacosLatestRequestGuard,
createNacosSaveAsCopy,
isNacosErrorCode,
isNacosConfigDeleteSnapshotInScope,
resolveNacosConfigCopyText,
resolveNacosConfigSaveCompletion,
type NacosConfigDeleteSnapshot,
} from "@/lib/nacos/nacosAdmin";
import { createNacosNamespaceRequestGuard, subscribeNacosNamespacesChanged, type NacosNamespacesChangedDetail } from "@/lib/nacos/nacosNamespaceCache";
import { nacosInstanceMatchesPatch, nacosInstanceRefIdentity, nacosIpAddressIsValid, nacosServiceDetailMatches } from "@/lib/nacos/nacosServiceManagement";
import { nacosNamespaceIdentity, normalizeNacosNamespacesForDisplay } from "@/lib/nacos/nacosNamespaceVisibility";
import { copyToClipboard, readTextFromClipboard } from "@/lib/common/clipboard";
import { trimmedSelectionLayer } from "@/lib/editor/codemirrorTrimmedSelectionLayer";
import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
import { editorFontTheme, loadEditorTheme } from "@/lib/editor/editorThemes";
import { clampEditorFontSize, createEditorZoomCommitScheduler, fontSizeFromWheelDelta } from "@/lib/editor/editorZoom";
import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
import { useSettingsStore } from "@/stores/settingsStore";
import { useTheme } from "@/composables/useTheme";
import { executeWithProductionContextGuard } from "@/lib/database/productionExecutionGuard";
import { productionContextForDatabase } from "@/lib/database/productionSafety";
import type {
NacosBatchPreview,
NacosBatchReport,
NacosConfigHistoryItem,
NacosConfigItem,
NacosConfigKey,
NacosConfigSelectionScope,
NacosConfigSelector,
NacosConfigTransferRequest,
NacosConnectionInfo,
NacosContentMatch,
NacosContentSearchResult,
NacosConflictPolicy,
NacosInstanceInfo,
NacosInstancePatch,
NacosInstanceRef,
NacosOperationCapability,
NacosNamespaceInfo,
NacosNamespaceScope,
NacosSearchProgress,
NacosServiceInfo,
NacosServiceDetail,
NacosServiceUpsert,
} from "@/types/nacos";
import { Splitpanes, Pane } from "splitpanes";
import "splitpanes/dist/splitpanes.css";
const props = defineProps<{
connectionId: string;
namespace?: string;
namespaceName?: string;
targetDataId?: string;
targetGroup?: string;
targetKeyword?: string;
targetRequestId?: number;
readOnly?: boolean;
}>();
type AdminTab = "configs" | "services";
const { toast } = useToast();
const { t } = useI18n();
const configWorkbenchId = useId();
const settingsStore = useSettingsStore();
const connectionStore = useConnectionStore();
const queryStore = useQueryStore();
const { isDark, themePalette } = useTheme();
const activeTab = ref<AdminTab>("configs");
const connectionInfo = ref<NacosConnectionInfo | null>(null);
const connectionError = ref("");
const infoLoading = ref(false);
const configLoading = ref(false);
const configError = ref("");
const configGroup = ref("");
const configDataId = ref("");
const configAppName = ref("");
const configPageNo = ref(1);
const NACOS_CONFIG_PAGE_SIZE_OPTIONS = [20, 50, 100, 200, 500] as const;
const NACOS_CONFIG_PAGE_SIZE_STORAGE_KEY = "dbx-nacos-config-page-size";
const savedNacosConfigPageSize = Number(safeLocalStorageGet(NACOS_CONFIG_PAGE_SIZE_STORAGE_KEY));
const configPageSize = ref<number>(NACOS_CONFIG_PAGE_SIZE_OPTIONS.find((size) => size === savedNacosConfigPageSize) ?? 20);
const configs = ref<NacosConfigItem[]>([]);
const configTotal = ref(0);
const selectedConfig = ref<NacosConfigItem | null>(null);
const selectedConfigOriginalKey = ref<NacosConfigKey | null>(null);
const configContent = ref("");
const originalConfigContent = ref("");
const configType = ref("text");
const originalConfigType = ref("text");
const originalConfigMetadata = ref({ appName: "", desc: "", tags: "" });
const savingConfig = ref(false);
const deletingConfig = ref(false);
const configAdvancedOpen = ref(false);
const configSaveNotice = ref("");
const pendingConfigSave = ref(false);
const pendingDeleteConfig = ref<NacosConfigDeleteSnapshot | null>(null);
interface NacosBatchDeleteSnapshot {
connectionId: string;
namespace: string;
keys: NacosConfigKey[];
}
const pendingBatchDelete = ref<NacosBatchDeleteSnapshot | null>(null);
const historyOpen = ref(false);
const historyLoading = ref(false);
const historyError = ref("");
const historyItems = ref<NacosConfigHistoryItem[]>([]);
const historyPageNo = ref(1);
const historyPageSize = ref(20);
const historyTotal = ref(0);
const historyViewingItem = ref<NacosConfigHistoryItem | null>(null);
const historyViewingContent = ref("");
const historyViewingLoading = ref(false);
const historyCompareOpen = ref(false);
const historyCompareCurrent = ref("");
const historyCompareContent = ref("");
const historyCompareLoading = ref(false);
const historyCompareItem = ref<NacosConfigHistoryItem | null>(null);
const pendingHistoryRollback = ref<NacosConfigHistoryItem | null>(null);
const rollingBackHistory = ref(false);
const rnacosConsoleAuthOpen = ref(false);
const rnacosConsoleCaptchaImage = ref("");
const rnacosConsoleCaptcha = ref("");
const rnacosConsoleAuthError = ref("");
const rnacosConsoleAuthLoading = ref(false);
const rnacosConsoleRetryAction = shallowRef<(() => Promise<void>) | null>(null);
const rnacosConsoleRetryErrorTarget = ref<"config" | "history" | "instances">("history");
const configFormatOptions = ["text", "json", "xml", "yaml", "html", "properties", "toml"];
const configEditorHost = ref<HTMLDivElement | null>(null);
const configEditorView = shallowRef<EditorView | null>(null);
const configSearchPanelRef = ref<InstanceType<typeof EditorSearchPanel>>();
const configEditorFontSize = ref(clampEditorFontSize(settingsStore.editorSettings.fontSize));
const configEditorZoomCommitScheduler = createEditorZoomCommitScheduler((fontSize) => {
if (settingsStore.editorSettings.fontSize === fontSize) return;
settingsStore.updateEditorSettings({ fontSize });
});
const knownConfigFormats = ref<Record<string, string>>({});
const selectedConfigKeys = ref<string[]>([]);
const searchOpen = ref(false);
const searchLoading = ref(false);
const searchError = ref("");
const searchResult = ref<NacosContentSearchResult | null>(null);
const searchProgress = ref<NacosSearchProgress | null>(null);
const activeSearchOperationId = ref("");
const searchExportLoading = ref(false);
const searchSessionResetKey = ref(0);
const batchOpen = ref(false);
const batchMode = ref<NacosBatchDialogMode>("export");
const batchLoading = ref(false);
const batchError = ref("");
const batchPreview = ref<NacosBatchPreview | null>(null);
const batchReport = ref<NacosBatchReport | null>(null);
const batchNamespaces = ref<NacosNamespaceInfo[]>([]);
const batchNamespacesRequestGuard = createNacosNamespaceRequestGuard();
const batchTargetConnectionId = ref("");
const batchTargetNamespaces = ref<NacosNamespaceInfo[]>([]);
const batchTargetNamespacesRequestGuard = createNacosNamespaceRequestGuard();
let stopNacosNamespacesChangedListener: (() => void) | null = null;
const importSource = shallowRef<string | File | null>(null);
const importSourceName = ref("");
const configEditorTheme = new Compartment();
const configEditorFontTheme = new Compartment();
const configEditorWordWrap = new Compartment();
const configEditorLanguage = new Compartment();
const configListRequestGuard = createNacosLatestRequestGuard();
const configDetailRequestGuard = createNacosLatestRequestGuard();
let configEditorGeneration = 0;
let configEditorSessionId = 0;
let latestConfigSaveRequestId = 0;
const servicesLoading = ref(false);
const servicesError = ref("");
const serviceGroup = ref("");
const serviceName = ref("");
const serviceCluster = ref("");
const servicePageNo = ref(1);
const servicePageSize = ref(20);
const services = ref<NacosServiceInfo[]>([]);
const serviceTotal = ref(0);
const selectedService = ref<NacosServiceInfo | null>(null);
const selectedServiceDetail = ref<NacosServiceDetail | null>(null);
const serviceDetailLoading = ref(false);
const serviceDetailError = ref("");
const serviceDetailExpanded = ref(false);
const instances = ref<NacosInstanceInfo[]>([]);
const instancesLoading = ref(false);
const instancesError = ref("");
const updatingInstanceKeys = ref<Record<string, number>>({});
const instanceWeightDrafts = ref<Record<string, string>>({});
const pendingInstanceUpdate = ref<{ instance: NacosInstanceInfo; patch: NacosInstancePatch } | null>(null);
const instanceEditorOpen = ref(false);
const instanceEditorError = ref("");
const instanceEditorTarget = ref<NacosInstanceInfo | null>(null);
const instanceEditor = ref({ weight: "1", metadata: "{}" });
const serviceEditorOpen = ref(false);
const serviceEditorLoading = ref(false);
const serviceEditorError = ref("");
const serviceEditorMode = ref<"create" | "update">("create");
const serviceEditor = ref({ serviceName: "", groupName: "", metadata: "{}", protectThreshold: "0", selector: "" });
const pendingServiceDelete = ref<NacosServiceInfo | null>(null);
const deletingService = ref(false);
const registeringInstance = ref(false);
const registerInstanceOpen = ref(false);
const registerInstanceError = ref("");
const registerInstance = ref({ ip: "", port: "", clusterName: "DEFAULT", weight: "1", metadata: "{}" });
const pendingInstanceDeregister = ref<NacosInstanceInfo | null>(null);
const servicesRequestGuard = createNacosLatestRequestGuard();
const serviceDetailRequestGuard = createNacosLatestRequestGuard();
const instancesRequestGuard = createNacosLatestRequestGuard();
let instanceUpdateSequence = 0;
let instanceOperationToken = 0;
let serviceMutationSequence = 0;
const NACOS_SPLIT_SIZE_KEY = "dbx-nacos-admin-split-size";
const savedNacosSplitSize = Number(safeLocalStorageGet(NACOS_SPLIT_SIZE_KEY));
const nacosSplitSize = ref(savedNacosSplitSize >= 20 && savedNacosSplitSize <= 80 ? savedNacosSplitSize : 42);
const CONNECTION_NOT_FOUND_RETRY_DELAYS_MS = [150, 350, 700];
const configListViewport = ref<HTMLElement | null>(null);
const configListViewportWidth = ref(0);
let configListResizeObserver: ResizeObserver | null = null;
const {
visibleColumns: configListColumns,
toggleableColumns: configListToggleableColumns,
gridTemplateColumns: configListGridTemplate,
minWidth: configListMinWidth,
resizingColumnIndex: configListResizingColumnIndex,
onResizeStart: onConfigListColumnResizeStart,
isColumnVisible: isConfigListColumnVisible,
setColumnVisible: setConfigListColumnVisible,
} = useNacosConfigListColumnResize(configListViewportWidth);
function configListColumnLabel(column: ToggleableNacosConfigListColumnKey) {
if (column === "group") return t("nacos.group");
if (column === "application") return t("nacos.configListApplication");
return t("nacos.configListFormat");
}
function isSelectedConfigListItem(item: NacosConfigItem) {
return selectedConfig.value?.dataId === item.dataId && selectedConfig.value?.group === item.group && (selectedConfig.value?.namespace || namespace.value) === (item.namespace || namespace.value);
}
const namespace = computed(() => props.namespace ?? connectionInfo.value?.namespace ?? "");
const nacosProductionContext = computed(() => productionContextForDatabase(connectionStore.getConfig(props.connectionId), namespace.value));
const batchTargetConnections = computed<NacosConfigTransferTarget[]>(() =>
connectionStore.connections
.filter((connection) => connection.db_type === "nacos" && !connection.read_only)
.map((connection) => {
const address = [connection.host, connection.port].filter(Boolean).join(":");
return { id: connection.id, label: connection.name ? `${connection.name} (${address})` : address || connection.id };
}),
);
const supportsConfigHistory = computed(() => connectionInfo.value?.capabilities.supportsConfigHistory !== false);
async function confirmNacosMutation(reviewText: string, targetConnectionId = props.connectionId, targetNamespace = namespace.value): Promise<boolean> {
const confirmed = await executeWithProductionContextGuard({
connection: connectionStore.getConfig(targetConnectionId),
database: targetNamespace,
reviewText,
source: t("production.sourceAdmin"),
execute: async () => true,
});
return confirmed === true;
}
function operationCapability(capability: NacosOperationCapability | boolean | undefined, legacySupported = true): NacosOperationCapability {
if (typeof capability === "boolean") return { supported: capability, reason: capability ? undefined : "notVerified" };
return capability ?? { supported: legacySupported, reason: legacySupported ? undefined : "notVerified" };
}
const serviceCapabilities = computed(() => connectionInfo.value?.capabilities.serviceManagement);
const legacyServiceManagementSupported = computed(() => connectionInfo.value != null && connectionInfo.value.capabilities.supportsServiceManagement !== false);
const legacyInstanceUpdateSupported = computed(() => connectionInfo.value != null && connectionInfo.value.capabilities.supportsInstanceUpdate !== false);
const listServicesCapability = computed(() => operationCapability(serviceCapabilities.value?.listServices, legacyServiceManagementSupported.value));
const getServiceCapability = computed(() => operationCapability(serviceCapabilities.value?.getService, listServicesCapability.value.supported));
const createServiceCapability = computed(() => operationCapability(serviceCapabilities.value?.createService, legacyServiceManagementSupported.value));
const updateServiceCapability = computed(() => operationCapability(serviceCapabilities.value?.updateService, createServiceCapability.value.supported));
const deleteServiceCapability = computed(() => operationCapability(serviceCapabilities.value?.deleteService, createServiceCapability.value.supported));
const listInstancesCapability = computed(() => operationCapability(serviceCapabilities.value?.listInstances, listServicesCapability.value.supported));
const updateInstanceCapability = computed(() => operationCapability(serviceCapabilities.value?.updateInstance, legacyInstanceUpdateSupported.value));
const registerInstanceCapability = computed(() => operationCapability(serviceCapabilities.value?.registerInstance, updateInstanceCapability.value.supported));
const deregisterInstanceCapability = computed(() => operationCapability(serviceCapabilities.value?.deregisterInstance, updateInstanceCapability.value.supported));
const supportsServiceManagement = computed(() => listServicesCapability.value.supported);
const supportsInstanceUpdate = computed(() => updateInstanceCapability.value.supported);
function capabilityReason(capability: NacosOperationCapability) {
if (props.readOnly) return t("nacos.capabilityReadOnly");
switch (capability.reason) {
case "implementationReadOnly":
return t("nacos.capabilityReadOnlyWrite");
case "versionUnsupported":
return t("nacos.capabilityVersionUnsupported");
case "endpointUnavailable":
return t("nacos.capabilityEndpointUnavailable");
case "connectionReadOnly":
return t("nacos.capabilityReadOnly");
default:
return t("nacos.capabilityNotVerified");
}
}
const serviceWriteNotice = computed(() => {
if (props.readOnly) return t("nacos.capabilityHeaderReadOnly");
const unsupported = [createServiceCapability.value, updateServiceCapability.value, deleteServiceCapability.value, updateInstanceCapability.value, registerInstanceCapability.value, deregisterInstanceCapability.value].find((capability) => !capability.supported);
return unsupported ? capabilityReason(unsupported) : "";
});
const selectedServiceProtectionTriggered = computed(() => {
if (selectedService.value?.triggerFlag === "true") return true;
const threshold = selectedServiceDetail.value?.protectThreshold;
if (threshold == null || threshold <= 0 || serviceCluster.value.trim()) return false;
const total = selectedService.value?.ipCount ?? instances.value.length;
const healthy = selectedService.value?.healthyInstanceCount ?? instances.value.filter((instance) => instance.healthy === true).length;
return total > 0 && healthy / total < threshold;
});
const configHistoryUnavailableTitle = computed(() => {
if (supportsConfigHistory.value) return undefined;
const reason = connectionInfo.value?.capabilities.historyUnavailableReason;
if (reason === "historyDisabled") return t("nacos.historyDisabled");
if (reason === "consoleUrlMissing") return t("nacos.historyConsoleUrlMissing");
if (reason === "consoleCredentialsMissing") return t("nacos.historyConsoleCredentialsMissing");
return t("nacos.historyUnavailable");
});
const namespaceLabel = computed(() => props.namespaceName || namespace.value || "public");
const namespaceIdLabel = computed(() => {
if (!namespace.value || namespace.value === namespaceLabel.value) return "";
return namespace.value;
});
const configTotalPages = computed(() => Math.max(1, Math.ceil(configTotal.value / Math.max(1, configPageSize.value))));
const serviceTotalPages = computed(() => Math.max(1, Math.ceil(serviceTotal.value / Math.max(1, servicePageSize.value))));
const isCreatingConfig = computed(() => !!selectedConfig.value && !selectedConfigOriginalKey.value);
const isConfigDirty = computed(() => {
if (!selectedConfig.value) return false;
return (
configContent.value !== originalConfigContent.value ||
configType.value !== originalConfigType.value ||
(selectedConfig.value.appName || "") !== originalConfigMetadata.value.appName ||
(selectedConfig.value.desc || "") !== originalConfigMetadata.value.desc ||
(selectedConfig.value.tags || "") !== originalConfigMetadata.value.tags
);
});
const configMutationGuardState = computed(() => ({
readOnly: !!props.readOnly,
saving: savingConfig.value,
deleting: deletingConfig.value,
hasPendingDelete: !!pendingDeleteConfig.value,
hasPendingSave: pendingConfigSave.value,
}));
const selectedConfigCount = computed(() => selectedConfigKeys.value.length);
const canRequestConfigSave = computed(() => canStartNacosConfigSave(configMutationGuardState.value));
const canRequestConfigDelete = computed(() => canStartNacosConfigDelete(configMutationGuardState.value, selectedConfigOriginalKey.value));
const pendingDeleteDetails = computed(() => (pendingDeleteConfig.value ? buildNacosConfigDeleteConfirm(pendingDeleteConfig.value.config, pendingDeleteConfig.value.key.namespace || "") : ""));
const canRequestBatchDeleteConfigs = computed(() => !props.readOnly && !savingConfig.value && !deletingConfig.value && !pendingConfigSave.value && !pendingDeleteConfig.value && selectedConfigCount.value > 0);
const pendingBatchDeleteDetails = computed(() => pendingBatchDelete.value?.keys.map((key) => `namespace=${key.namespace || "public"}\ndataId=${key.dataId}\ngroup=${key.group || "DEFAULT_GROUP"}`).join("\n\n") || "");
const pendingHistoryRollbackDetails = computed(() => (pendingHistoryRollback.value ? buildNacosConfigHistoryRollbackConfirm(pendingHistoryRollback.value, namespace.value) : ""));
const pendingInstanceDetails = computed(() => (pendingInstanceUpdate.value && selectedService.value ? buildNacosInstanceConfirm(selectedService.value, pendingInstanceUpdate.value.instance, pendingInstanceUpdate.value.patch, serviceGroup.value, namespace.value) : ""));
const pendingInstanceDeregisterDetails = computed(() => {
if (!pendingInstanceDeregister.value || !selectedService.value) return "";
const ref = instanceRef(pendingInstanceDeregister.value);
const lifetime = ref.ephemeral === true ? t("nacos.instanceEphemeral") : ref.ephemeral === false ? t("nacos.instancePersistent") : t("nacos.instanceUnknown");
return t("nacos.instanceConfirmDetails", {
namespace: ref.namespace || "public",
service: `${ref.groupName || "DEFAULT_GROUP"}@@${ref.serviceName}`,
ip: ref.ip,
port: ref.port,
cluster: ref.clusterName || "DEFAULT",
type: lifetime,
});
});
const hasSearchSession = computed(() => !!(searchResult.value || searchProgress.value || searchError.value));
const retainedSearchMatchCount = computed(() => searchResult.value?.matches.length ?? searchProgress.value?.matches.length ?? 0);
const currentPageConfigKeys = computed(() => configs.value.map((item) => configIdentityKey(item)));
const allCurrentPageSelected = computed(() => currentPageConfigKeys.value.length > 0 && currentPageConfigKeys.value.every((key) => selectedConfigKeys.value.includes(key)));
function configIdentityKey(item: { namespace?: string; group?: string; dataId: string }): string {
return [item.namespace || namespace.value || "", item.group || "DEFAULT_GROUP", item.dataId].join("\u0000");
}
function toggleConfigSelection(item: NacosConfigItem, checked: boolean) {
const key = configIdentityKey(item);
const next = new Set(selectedConfigKeys.value);
if (checked) next.add(key);
else next.delete(key);
selectedConfigKeys.value = [...next];
}
function toggleCurrentPageSelection(checked: boolean) {
const next = new Set(selectedConfigKeys.value);
for (const key of currentPageConfigKeys.value) {
if (checked) next.add(key);
else next.delete(key);
}
selectedConfigKeys.value = [...next];
}
function selectedKeys(): NacosConfigKey[] {
return selectedConfigKeys.value.map((value) => {
const [selectedNamespace = "", group = "DEFAULT_GROUP", dataId = ""] = value.split("\u0000");
return { namespace: selectedNamespace || undefined, group, dataId };
});
}
function isBatchDeleteSnapshotInScope(snapshot: NacosBatchDeleteSnapshot) {
return snapshot.connectionId === props.connectionId && snapshot.namespace === namespace.value;
}
function buildConfigSelector(scope: NacosConfigSelectionScope): NacosConfigSelector {
return {
namespace: namespace.value,
scope,
keys: scope === "selected" ? selectedKeys() : [],
query:
scope === "filtered"
? {
namespace: namespace.value || undefined,
group: configGroup.value.trim() || undefined,
groupContains: true,
dataId: configDataId.value.trim() || undefined,
appName: configAppName.value.trim() || undefined,
}
: undefined,
};
}
function editorThemeAppearance() {
return isDark.value ? "dark" : "light";
}
function currentCustomThemeColors() {
const settings = settingsStore.editorSettings;
if (settings.theme !== "custom") return settings.customThemeColors;
const activeTheme = settings.customThemes?.find((theme) => theme.id === settings.activeCustomThemeId) || settings.customThemes?.[0];
return activeTheme?.colors ?? settings.customThemeColors;
}
async function configLanguageExtension(format: string): Promise<Extension[]> {
switch (format) {
case "json": {
const { json } = await import("@codemirror/lang-json");
return [json()];
}
case "yaml": {
const { yaml } = await import("@codemirror/lang-yaml");
return [yaml()];
}
case "xml": {
const { xml } = await import("@codemirror/lang-xml");
return [xml()];
}
case "html": {
const { html } = await import("@codemirror/lang-html");
return [html({ matchClosingTags: false })];
}
case "properties": {
const { properties } = await import("@codemirror/legacy-modes/mode/properties");
return [StreamLanguage.define(properties)];
}
case "toml": {
const { toml } = await import("@codemirror/legacy-modes/mode/toml");
return [StreamLanguage.define(toml)];
}
default:
return [];
}
}
async function mountConfigEditor() {
await nextTick();
if (!configEditorHost.value || configEditorView.value || !selectedConfig.value) return;
const generation = ++configEditorGeneration;
const editorSessionId = configEditorSessionId;
const host = configEditorHost.value;
const content = configContent.value;
const format = configType.value;
const [{ EditorState, Prec }, { EditorView, keymap }, { basicSetup }, { defaultKeymap, historyKeymap, indentWithTab }, { search: cmSearch }, language] = await Promise.all([
import("@codemirror/state"),
import("@codemirror/view"),
import("codemirror"),
import("@codemirror/commands"),
import("@codemirror/search"),
configLanguageExtension(format),
]);
const editorSettings = settingsStore.editorSettings;
configEditorFontSize.value = clampEditorFontSize(editorSettings.fontSize);
const theme = await loadEditorTheme(editorSettings.theme, editorThemeAppearance(), currentCustomThemeColors(), themePalette.value);
if (generation !== configEditorGeneration || editorSessionId !== configEditorSessionId || host !== configEditorHost.value || configEditorView.value || !selectedConfig.value) return;
const view = new EditorView({
parent: host,
state: EditorState.create({
doc: content,
extensions: [
cmSearch({
top: true,
createPanel: () => {
const dom = document.createElement("span");
dom.style.display = "none";
return { dom };
},
}),
basicSetup,
EditorState.allowMultipleSelections.of(true),
trimmedSelectionLayer(),
Prec.highest(keymap.of([{ key: "Mod-f", run: () => configSearchPanelRef.value?.openSearch() ?? false, preventDefault: true }, { key: "Mod-h", run: () => configSearchPanelRef.value?.openReplace() ?? false, preventDefault: true }, indentWithTab])),
keymap.of([...defaultKeymap, ...historyKeymap]),
EditorView.domEventHandlers({
wheel(event, eventView) {
if (!event.metaKey && !event.ctrlKey) return false;
event.preventDefault();
const next = fontSizeFromWheelDelta(configEditorFontSize.value, event.deltaY);
if (next !== configEditorFontSize.value) {
configEditorFontSize.value = next;
eventView.dispatch({
effects: configEditorFontTheme.reconfigure(editorFontTheme(EditorView, next, settingsStore.editorSettings.fontFamily, { fixedHeight: true, scrollable: true })),
});
}
configEditorZoomCommitScheduler.schedule(next);
return true;
},
}),
configEditorLanguage.of(language),
configEditorTheme.of(theme),
configEditorFontTheme.of(editorFontTheme(EditorView, editorSettings.fontSize, editorSettings.fontFamily, { fixedHeight: true, scrollable: true })),
configEditorWordWrap.of(editorSettings.wordWrap ? EditorView.lineWrapping : []),
EditorState.readOnly.of(!!props.readOnly),
EditorView.editable.of(!props.readOnly),
EditorView.updateListener.of((update) => {
if (!update.docChanged || generation !== configEditorGeneration || editorSessionId !== configEditorSessionId) return;
configContent.value = update.state.doc.toString();
configSaveNotice.value = "";
}),
EditorView.theme({
"&": {
height: "100%",
},
".cm-scroller": {
overflow: "auto",
},
".cm-content": {
minHeight: "100%",
userSelect: "text",
WebkitUserSelect: "text",
},
".cm-lineNumbers .cm-gutterElement": {
padding: "0 10px 0 8px",
},
}),
],
}),
});
if (generation !== configEditorGeneration || editorSessionId !== configEditorSessionId || host !== configEditorHost.value) {
view.destroy();
return;
}
configEditorView.value = view;
}
function destroyConfigEditor() {
configEditorGeneration += 1;
configEditorView.value?.destroy();
configEditorView.value = null;
}
async function refreshConfigEditor() {
destroyConfigEditor();
await mountConfigEditor();
}
function handleNacosSplitResized(payload: { panes?: { size: number }[] }) {
const size = payload.panes?.[0]?.size;
if (typeof size !== "number" || size < 20 || size > 80) return;
nacosSplitSize.value = size;
safeLocalStorageSet(NACOS_SPLIT_SIZE_KEY, String(size));
}
function observeConfigListViewport(element: HTMLElement | null) {
configListResizeObserver?.disconnect();
configListResizeObserver = null;
configListViewportWidth.value = element?.clientWidth ?? 0;
if (!element || typeof ResizeObserver === "undefined") return;
configListResizeObserver = new ResizeObserver(() => {
configListViewportWidth.value = element.clientWidth;
});
configListResizeObserver.observe(element);
}
function inferConfigFormat(dataId: string): string {
const ext = dataId.trim().toLowerCase().split(".").pop() || "";
if (ext === "yml") return "yaml";
if (["yaml", "json", "xml", "html", "properties", "text"].includes(ext)) return ext;
if (ext === "txt") return "text";
return "";
}
function configFormatValue(item: Pick<NacosConfigItem, "dataId" | "configType">): string {
const value = normalizeConfigFormat(item.configType);
return value || inferConfigFormat(item.dataId);
}
function normalizeConfigFormat(value?: string): string {
const normalized = value?.trim().toLowerCase();
if (!normalized) return "";
if (normalized === "txt") return "text";
if (normalized === "yml") return "yaml";
if (normalized === "props") return "properties";
return normalized;
}
function normalizeConfigItemFormat<T extends NacosConfigItem>(item: T): T {
const value = normalizeConfigFormat(item.configType);
if (!value || value === item.configType) return item;
return { ...item, configType: value };
}
function rememberOriginalConfigState(item: NacosConfigItem, content = item.content || "", format = configFormatValue(item) || "text") {
originalConfigContent.value = content;
originalConfigType.value = format;
originalConfigMetadata.value = {
appName: item.appName || "",
desc: item.desc || "",
tags: item.tags || "",
};
}
function configFormatCacheKey(key: { namespace?: string; dataId: string; group: string }): string {
return [props.connectionId, key.namespace || namespace.value || "", key.dataId, key.group || "DEFAULT_GROUP"].join("\u0000");
}
function rememberConfigFormat(item: { namespace?: string; dataId: string; group: string; configType?: string }) {
const value = configFormatValue(item);
if (!value) return;
knownConfigFormats.value = {
...knownConfigFormats.value,
[configFormatCacheKey(item)]: value,
};
}
function applyKnownConfigFormats(items: NacosConfigItem[]): NacosConfigItem[] {
return items.map((item) => {
const existingFormat = configFormatValue(item);
if (existingFormat) {
rememberConfigFormat({ ...item, configType: existingFormat });
return item.configType === existingFormat ? item : { ...item, configType: existingFormat };
}
const knownFormat = knownConfigFormats.value[configFormatCacheKey(item)];
return knownFormat ? { ...item, configType: knownFormat } : item;
});
}
function configFormatDisplayLabel(value: string): string {
const normalized = value.trim().toLowerCase();
if (!normalized) return "-";
if (normalized === "properties") return "Properties";
return normalized.toUpperCase();
}
function configFormatLabel(item: Pick<NacosConfigItem, "dataId" | "configType">): string {
return configFormatDisplayLabel(configFormatValue(item));
}
function delay(ms: number) {
return new Promise((resolve) => window.setTimeout(resolve, ms));
}
function isConnectionNotFoundError(error: unknown): boolean {
const message = error instanceof Error ? error.message : String(error);
return /\bConnection not found\b/i.test(message);
}
function isSameConfigKey(item: NacosConfigItem, key: NacosConfigKey): boolean {
return (item.namespace || namespace.value || "") === (key.namespace || namespace.value || "") && item.dataId === key.dataId && item.group === key.group;
}
function upsertConfigInList(item: NacosConfigItem) {
item = normalizeConfigItemFormat(item);
const key = {
namespace: item.namespace || namespace.value || undefined,
dataId: item.dataId,
group: item.group,
};
const existingIndex = configs.value.findIndex((candidate) => isSameConfigKey(candidate, key));
if (existingIndex >= 0) {
configs.value.splice(existingIndex, 1, { ...configs.value[existingIndex], ...item });
return;
}
configs.value = [item, ...configs.value];
configTotal.value = Math.max(configTotal.value, configs.value.length);
}
async function loadInfo() {
infoLoading.value = true;
connectionError.value = "";
try {
connectionInfo.value = await api.nacosTestConnection(props.connectionId);
} catch (error) {
connectionError.value = error instanceof Error ? error.message : String(error);
} finally {
infoLoading.value = false;
}
}
async function loadConfigs(page = configPageNo.value): Promise<boolean> {
const requestId = configListRequestGuard.begin();
const connectionId = props.connectionId;
const requestNamespace = namespace.value;
const requestGroup = configGroup.value.trim();
const requestDataId = configDataId.value.trim();
const requestAppName = configAppName.value.trim();
const requestPageSize = configPageSize.value;
const isCurrentRequest = () =>
configListRequestGuard.isCurrent(requestId) &&
connectionId === props.connectionId &&
requestNamespace === namespace.value &&
requestGroup === configGroup.value.trim() &&
requestDataId === configDataId.value.trim() &&
requestAppName === configAppName.value.trim() &&
requestPageSize === configPageSize.value;
configLoading.value = true;
configError.value = "";
configPageNo.value = page;
try {
const result = await api.nacosListConfigs(connectionId, {
namespace: requestNamespace || undefined,
group: requestGroup || undefined,
groupContains: true,
dataId: requestDataId || undefined,
appName: requestAppName || undefined,
pageNo: page,
pageSize: requestPageSize,
});
if (!isCurrentRequest()) return false;
const lastPage = Math.max(1, Math.ceil(result.totalCount / Math.max(1, requestPageSize)));
if (page > lastPage) return loadConfigs(lastPage);
configs.value = applyKnownConfigFormats(result.items.map(normalizeConfigItemFormat));
configTotal.value = result.totalCount;
return true;
} catch (error) {
if (!isCurrentRequest()) return false;
await handleRNacosConsoleError(
error,
async () => {
await loadConfigs(page);
},
"config",
);
return true;
} finally {
if (configListRequestGuard.isCurrent(requestId)) configLoading.value = false;
}
}
async function loadConfigsWithRetry(page = configPageNo.value) {
for (let attempt = 0; ; attempt += 1) {
const current = await loadConfigs(page);
if (!current || !isConnectionNotFoundError(configError.value) || attempt >= CONNECTION_NOT_FOUND_RETRY_DELAYS_MS.length) return;
await delay(CONNECTION_NOT_FOUND_RETRY_DELAYS_MS[attempt]);
}
}
function clearConfigFilter(filter: "dataId" | "group" | "appName") {
if (filter === "dataId") configDataId.value = "";
else if (filter === "group") configGroup.value = "";
else configAppName.value = "";
void loadConfigsWithRetry(1);
}
function setConfigPageSize(value: string) {
const nextPageSize = Number(value);
if (!NACOS_CONFIG_PAGE_SIZE_OPTIONS.some((size) => size === nextPageSize) || nextPageSize === configPageSize.value) return;
configPageSize.value = nextPageSize;
safeLocalStorageSet(NACOS_CONFIG_PAGE_SIZE_STORAGE_KEY, String(nextPageSize));
void loadConfigsWithRetry(1);
}
function closePendingConfigMutationConfirmations() {
pendingConfigSave.value = false;
if (!deletingConfig.value) {
pendingDeleteConfig.value = null;
pendingBatchDelete.value = null;
}
}
async function selectConfig(item: NacosConfigItem) {
closePendingConfigMutationConfirmations();
const detailRequestId = configDetailRequestGuard.begin();
configEditorSessionId += 1;
const listItemHadFormat = !!configFormatValue(item);
destroyConfigEditor();
configSaveNotice.value = "";
selectedConfigOriginalKey.value = {
namespace: item.namespace || namespace.value || undefined,
dataId: item.dataId,
group: item.group,
};
selectedConfig.value = { ...item };
configContent.value = item.content || "";
configType.value = configFormatValue(item) || "text";
rememberOriginalConfigState(item, configContent.value, configType.value);
try {
const detail = await api.nacosGetConfig(props.connectionId, {
namespace: item.namespace || namespace.value || undefined,
dataId: item.dataId,
group: item.group,
});
if (!configDetailRequestGuard.isCurrent(detailRequestId)) return;
const normalizedDetail = normalizeConfigItemFormat(detail);
selectedConfig.value = normalizedDetail;
selectedConfigOriginalKey.value = {
namespace: normalizedDetail.namespace || item.namespace || namespace.value || undefined,
dataId: normalizedDetail.dataId || item.dataId,
group: normalizedDetail.group || item.group,
};
rememberConfigFormat({
...normalizedDetail,
namespace: selectedConfigOriginalKey.value.namespace,
dataId: selectedConfigOriginalKey.value.dataId,
group: selectedConfigOriginalKey.value.group,
});
upsertConfigInList({
...normalizedDetail,
namespace: selectedConfigOriginalKey.value.namespace || "",
dataId: selectedConfigOriginalKey.value.dataId,
group: selectedConfigOriginalKey.value.group,
});
configContent.value = normalizedDetail.content || "";
configType.value = configFormatValue(normalizedDetail) || configFormatValue(item) || "text";
rememberOriginalConfigState(normalizedDetail, configContent.value, configType.value);
await refreshConfigEditor();
if (!listItemHadFormat && configFormatValue(normalizedDetail)) {
await loadConfigs(configPageNo.value);
}
} catch (error) {
if (!configDetailRequestGuard.isCurrent(detailRequestId)) return;
await handleRNacosConsoleError(error, () => selectConfig(item), "config");
await refreshConfigEditor();
}
}
function newConfig() {
closePendingConfigMutationConfirmations();
configDetailRequestGuard.invalidate();
configEditorSessionId += 1;
destroyConfigEditor();
configSaveNotice.value = "";
selectedConfigOriginalKey.value = null;
selectedConfig.value = {
namespace: namespace.value,
dataId: configDataId.value.trim(),
group: configGroup.value.trim() || "DEFAULT_GROUP",
configType: inferConfigFormat(configDataId.value) || "text",
content: "",
appName: "",
desc: "",
tags: "",
};
configContent.value = "";
configType.value = selectedConfig.value.configType || "text";
rememberOriginalConfigState(selectedConfig.value, "", configType.value);
configAdvancedOpen.value = false;
void mountConfigEditor();
}
function saveConfigAsCopy() {
if (!selectedConfig.value) return;
closePendingConfigMutationConfirmations();
configDetailRequestGuard.invalidate();
configEditorSessionId += 1;
const copy = createNacosSaveAsCopy({ ...selectedConfig.value, content: configContent.value, configType: configType.value });
destroyConfigEditor();
selectedConfigOriginalKey.value = null;
selectedConfig.value = copy;
configContent.value = copy.content || "";
originalConfigContent.value = "";
configType.value = copy.configType || configType.value || "text";
originalConfigType.value = configType.value;
originalConfigMetadata.value = {
appName: copy.appName || "",
desc: copy.desc || "",
tags: copy.tags || "",
};
configSaveNotice.value = "";
void mountConfigEditor();
}
async function copyConfigIdentity() {
if (!selectedConfig.value) return;
const view = configEditorView.value;
const selection = view?.state.sliceDoc(view.state.selection.main.from, view.state.selection.main.to) || "";
const text = resolveNacosConfigCopyText(selection, view?.state.doc.toString(), configContent.value);
try {
await copyToClipboard(text);
try {
const copiedText = await readTextFromClipboard();
if (copiedText !== text) {
throw new Error(t("nacos.copyVerifyFailed"));
}
} catch (verifyError) {
if (isTauriRuntime()) throw verifyError;
}
toast(t("nacos.copied"), 2000);
} catch (error) {
toast(t("grid.copyFailed", { message: error instanceof Error ? error.message : String(error) }), 5000);
}
}
async function downloadConfigText(content: string, fileName: string, mimeType = "text/plain;charset=utf-8") {
const blob = new Blob([content], { type: mimeType });
const url = URL.createObjectURL(blob);
const anchor = document.createElement("a");
anchor.href = url;
anchor.download = fileName;
anchor.click();
URL.revokeObjectURL(url);
}
async function exportConfig() {
if (!selectedConfig.value) return;
const item = { ...selectedConfig.value, configType: configType.value };
const fileName = buildNacosConfigExportFileName(item);
try {
if (isTauriRuntime()) {
const { save } = await import("@tauri-apps/plugin-dialog");
const { writeTextFile } = await import("@tauri-apps/plugin-fs");
const path = await save({
defaultPath: fileName,
filters: [{ name: configFormatDisplayLabel(configType.value || item.configType || "text"), extensions: [fileName.split(".").pop() || "txt"] }],
});
if (!path) return;
await writeTextFile(path, configContent.value);
toast(t("nacos.exportedTo", { path }), 2000);
return;
}
await downloadConfigText(configContent.value, fileName);
toast(t("nacos.exported"), 2000);
} catch (error) {
toast(t("nacos.exportFailed", { message: error instanceof Error ? error.message : String(error) }), 5000);
}
}
function createOperationId(prefix: string): string {
const suffix = globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(16).slice(2)}`;
return `${prefix}-${suffix}`;
}
async function searchConfigContent(payload: { query: string; scope: NacosNamespaceScope }) {
const operationId = createOperationId("nacos-search");
activeSearchOperationId.value = operationId;
searchLoading.value = true;
searchError.value = "";
searchResult.value = null;
searchProgress.value = null;
const accumulatedMatches = new Map<string, NacosContentMatch>();
const accumulatedFailures = new Map<string, string>();
try {
const result = await api.nacosSearchConfigContent(
props.connectionId,
{
operationId,
namespace: namespace.value || undefined,
scope: payload.scope,
query: payload.query,
group: configGroup.value.trim() || undefined,
dataId: configDataId.value.trim() || undefined,
maxResults: 10_000,
},
(progress) => {
if (progress.operationId !== activeSearchOperationId.value) return;
for (const match of progress.matches) accumulatedMatches.set(configIdentityKey(match), match);
for (const failure of progress.failures) accumulatedFailures.set(failure.namespace, failure.error);
searchProgress.value = {
...progress,
matches: [...accumulatedMatches.values()],
failures: [...accumulatedFailures].map(([failedNamespace, error]) => ({ namespace: failedNamespace, error })),
};
},
);
if (activeSearchOperationId.value === operationId && searchOpen.value) searchResult.value = result;
} catch (error) {
if (activeSearchOperationId.value === operationId && searchOpen.value) searchError.value = error instanceof Error ? error.message : String(error);
} finally {
if (activeSearchOperationId.value === operationId) {
searchLoading.value = false;
activeSearchOperationId.value = "";
}
}
}
async function cancelConfigContentSearch() {
if (!activeSearchOperationId.value) return;
try {
await api.nacosCancelConfigContentSearch(activeSearchOperationId.value);
} catch (error) {
searchError.value = error instanceof Error ? error.message : String(error);
}
}
function clearContentSearchSession() {
const operationId = activeSearchOperationId.value;
activeSearchOperationId.value = "";
searchLoading.value = false;
searchResult.value = null;
searchProgress.value = null;
searchError.value = "";
searchSessionResetKey.value += 1;
if (operationId) void api.nacosCancelConfigContentSearch(operationId);
}
async function exportContentSearchResults() {
const matches = searchResult.value?.matches ?? searchProgress.value?.matches ?? [];
if (!matches.length || searchExportLoading.value) return;
searchExportLoading.value = true;
const content = buildNacosContentSearchCsv(matches);
const fileName = "nacos-content-search-results.csv";
try {
if (isTauriRuntime()) {
const { save } = await import("@tauri-apps/plugin-dialog");
const { writeTextFile } = await import("@tauri-apps/plugin-fs");
const path = await save({
defaultPath: fileName,
filters: [{ name: "CSV", extensions: ["csv"] }],
});
if (!path) return;
await writeTextFile(path, content);
toast(t("nacos.searchResultsExportedTo", { path }), 2500);
return;
}
await downloadConfigText(content, fileName, "text/csv;charset=utf-8");
toast(t("nacos.searchResultsExported"), 2500);
} catch (error) {
toast(t("nacos.exportFailed", { message: error instanceof Error ? error.message : String(error) }), 5000);
} finally {
searchExportLoading.value = false;
}
}
async function focusConfigKeyword(keyword?: string) {
if (!keyword) return;
await nextTick();
const view = configEditorView.value;
if (!view) return;
const content = view.state.doc.toString();
const from = content.indexOf(keyword);
if (from < 0) return;
view.dispatch({ selection: { anchor: from, head: from + keyword.length }, scrollIntoView: true });
configSearchPanelRef.value?.openSearch();
}
async function openTargetConfig(dataId: string, group: string, keyword?: string) {
try {
await selectConfig({
namespace: namespace.value,
dataId,
group: group || "DEFAULT_GROUP",
});
await focusConfigKeyword(keyword);
} finally {
if (props.targetRequestId !== undefined) queryStore.clearNacosNavigationTarget(props.connectionId, namespace.value, props.targetRequestId);
}
}
async function navigateToContentMatch(match: NacosContentMatch, keyword: string) {
const targetNamespace = match.namespace || "";
if (targetNamespace === namespace.value) {
searchOpen.value = false;
await openTargetConfig(match.dataId, match.group, keyword);
return;
}
const namespaceInfo = batchNamespaces.value.find((item) => nacosNamespaceIdentity(item.namespace) === nacosNamespaceIdentity(targetNamespace));
queryStore.openNacosAdmin(props.connectionId, {
namespace: targetNamespace,
namespaceName: namespaceInfo?.namespaceShowName || targetNamespace || "public",
dataId: match.dataId,
group: match.group,
keyword,
});
}
async function loadBatchNamespaces(options: { force?: boolean } = {}) {
if (!options.force && batchNamespaces.value.length) return;
const connectionId = props.connectionId;
const requestId = batchNamespacesRequestGuard.start(connectionId);
try {
const namespaces = await api.nacosListNamespaces(connectionId);
if (!batchNamespacesRequestGuard.isCurrent(requestId, props.connectionId)) return;
batchNamespaces.value = normalizeNacosNamespacesForDisplay(namespaces);
} catch (error) {
if (!batchNamespacesRequestGuard.isCurrent(requestId, props.connectionId)) return;
batchError.value = error instanceof Error ? error.message : String(error);
}
}
async function loadBatchTargetNamespaces(connectionId: string, options: { force?: boolean } = {}) {
if (!connectionId) return;
if (!options.force && batchTargetConnectionId.value === connectionId && batchTargetNamespaces.value.length) return;
const requestId = batchTargetNamespacesRequestGuard.start(connectionId);
try {
const namespaces = await api.nacosListNamespaces(connectionId);
if (!batchTargetNamespacesRequestGuard.isCurrent(requestId, connectionId) || batchTargetConnectionId.value !== connectionId) return;
batchTargetNamespaces.value = normalizeNacosNamespacesForDisplay(namespaces);
} catch (error) {
if (!batchTargetNamespacesRequestGuard.isCurrent(requestId, connectionId) || batchTargetConnectionId.value !== connectionId) return;
batchError.value = error instanceof Error ? error.message : String(error);
}
}
function invalidateBatchNamespaces(refreshOpenDialog = true) {
batchNamespacesRequestGuard.invalidate();
batchNamespaces.value = [];
if (refreshOpenDialog && ((batchOpen.value && batchMode.value === "copy") || searchOpen.value)) {
void loadBatchNamespaces({ force: true });
}
}
function invalidateBatchTargetNamespaces(connectionId: string, refreshOpenDialog = true) {
if (batchTargetConnectionId.value !== connectionId) return;
batchTargetNamespacesRequestGuard.invalidate();
batchTargetNamespaces.value = [];
if (refreshOpenDialog && batchOpen.value && batchMode.value === "copy") {
void loadBatchTargetNamespaces(connectionId, { force: true });
}
}
function handleNacosNamespacesChanged(detail: NacosNamespacesChangedDetail) {
if (detail.connectionId === props.connectionId) invalidateBatchNamespaces();
invalidateBatchTargetNamespaces(detail.connectionId);
}
async function openSearchDialog() {
searchOpen.value = true;
await loadBatchNamespaces();
}
async function openBatchDialog(mode: NacosBatchDialogMode) {
batchMode.value = mode;
resetBatchDialogState();
if (mode === "import") {
importSource.value = null;
importSourceName.value = "";
}
batchOpen.value = true;
if (mode === "copy") {
const currentConnectionIsWritable = batchTargetConnections.value.some((connection) => connection.id === props.connectionId);
const targetConnectionId = currentConnectionIsWritable ? props.connectionId : (batchTargetConnections.value[0]?.id ?? "");
batchTargetConnectionId.value = targetConnectionId;
batchTargetNamespaces.value = [];
batchTargetNamespacesRequestGuard.invalidate();
if (targetConnectionId) await loadBatchTargetNamespaces(targetConnectionId, { force: true });
}
}
async function selectBatchTargetConnection(connectionId: string) {
if (connectionId === batchTargetConnectionId.value) return;
batchTargetConnectionId.value = connectionId;
batchTargetNamespaces.value = [];
batchTargetNamespacesRequestGuard.invalidate();
resetBatchDialogState();
await loadBatchTargetNamespaces(connectionId, { force: true });
}
function resetBatchDialogState() {
batchPreview.value = null;
batchReport.value = null;
batchError.value = "";
}
async function chooseImportArchive() {
if (isTauriRuntime()) {
const { open } = await import("@tauri-apps/plugin-dialog");
const selected = await open({ multiple: false, directory: false, filters: [{ name: "Nacos ZIP", extensions: ["zip"] }] });
if (typeof selected !== "string") return;
importSource.value = selected;
importSourceName.value = selected.split(/[\\/]/).pop() || selected;
} else {
const input = document.createElement("input");
input.type = "file";
input.accept = ".zip,application/zip";
input.onchange = () => {
const file = input.files?.[0];
if (!file) return;
importSource.value = file;
importSourceName.value = file.name;
};
input.click();
}
resetBatchDialogState();
}
async function exportConfigArchive(scope: NacosConfigSelectionScope) {
batchLoading.value = true;
batchError.value = "";
const fileName = `${namespaceLabel.value || "public"}-nacos-configs.zip`;
try {
let destination = "";
if (isTauriRuntime()) {
const { save } = await import("@tauri-apps/plugin-dialog");
destination =
(await save({
defaultPath: fileName,
filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
})) || "";
if (!destination) return;
}
await api.nacosExportConfigs(props.connectionId, buildConfigSelector(scope), destination, fileName);
toast(destination ? t("nacos.exportedTo", { path: destination }) : t("nacos.exported"), 2500);
batchOpen.value = false;
} catch (error) {
batchError.value = error instanceof Error ? error.message : String(error);
} finally {
batchLoading.value = false;
}
}
const batchTransferRequest = shallowRef<NacosConfigTransferRequest | null>(null);
async function previewBatch(payload: { scope: NacosConfigSelectionScope; targetConnectionId: string; targetNamespace: string; policy: NacosConflictPolicy }) {
batchLoading.value = true;
batchError.value = "";
batchPreview.value = null;
batchReport.value = null;
try {
if (batchMode.value === "import") {
if (!importSource.value) throw new Error(t("nacos.noArchiveSelected"));
batchPreview.value = await api.nacosPreviewConfigImport(props.connectionId, namespace.value, importSource.value);
} else {
const req: NacosConfigTransferRequest = {
operationId: createOperationId("nacos-copy-preview"),
sourceConnectionId: props.connectionId,
targetConnectionId: payload.targetConnectionId,
source: buildConfigSelector(payload.scope),
targetNamespace: payload.targetNamespace,
conflictPolicy: payload.policy,
};
batchTransferRequest.value = req;
batchPreview.value = await api.nacosPreviewConfigTransfer(req);
}
} catch (error) {
batchError.value = error instanceof Error ? error.message : String(error);
} finally {
batchLoading.value = false;
}
}
async function applyBatch(payload: { scope: NacosConfigSelectionScope; targetConnectionId: string; targetNamespace: string; policy: NacosConflictPolicy }) {
if (batchLoading.value || batchReport.value || !batchPreview.value) return;
if (payload.policy === "OVERWRITE" && !window.confirm(t("nacos.overwriteConfirm"))) return;
const targetConnectionId = batchMode.value === "import" ? props.connectionId : payload.targetConnectionId;
const targetNamespace = batchMode.value === "import" ? namespace.value : payload.targetNamespace;
const operation = batchMode.value === "import" ? t("nacos.batchImport") : t("nacos.copyToNamespace");
if (!(await confirmNacosMutation(operation, targetConnectionId, targetNamespace))) return;
batchLoading.value = true;
batchError.value = "";
try {
if (batchMode.value === "import") {
if (!importSource.value) throw new Error(t("nacos.noArchiveSelected"));
batchReport.value = await api.nacosApplyConfigImport(props.connectionId, createOperationId("nacos-import"), namespace.value, importSource.value, batchPreview.value.planHash, payload.policy, batchPreview.value.archiveToken);
} else {
if (!batchTransferRequest.value) throw new Error(t("nacos.previewExpired"));
const req = { ...batchTransferRequest.value, operationId: createOperationId("nacos-copy"), conflictPolicy: payload.policy };
batchReport.value = await api.nacosApplyConfigTransfer(req, batchPreview.value.planHash);
}
batchPreview.value = null;
batchTransferRequest.value = null;
selectedConfigKeys.value = [];
await loadConfigsWithRetry(1);
} catch (error) {
if (isNacosErrorCode(error, "stalePreview")) {
batchPreview.value = null;
batchTransferRequest.value = null;
batchError.value = t("nacos.previewExpired");
} else {
batchError.value = error instanceof Error ? error.message : String(error);
}
} finally {
batchLoading.value = false;
}
}
function historyKeyFor(item: NacosConfigHistoryItem) {
return {
namespace: item.namespace || namespace.value || undefined,
dataId: item.dataId,
group: item.group,
historyId: item.historyId,
nid: item.nid,
};
}
async function openConfigHistory() {
if (!selectedConfigOriginalKey.value || !selectedConfig.value || !supportsConfigHistory.value) return;
historyOpen.value = true;
await loadConfigHistory(1);
}
async function loadConfigHistory(page = historyPageNo.value) {
if (!selectedConfigOriginalKey.value) return;
historyLoading.value = true;
historyError.value = "";
historyPageNo.value = page;
try {
const result = await api.nacosListConfigHistory(props.connectionId, {
...selectedConfigOriginalKey.value,
pageNo: historyPageNo.value,
pageSize: historyPageSize.value,
});
historyItems.value = result.items;
historyTotal.value = result.totalCount;
} catch (error) {
await handleRNacosConsoleError(error, () => loadConfigHistory(historyPageNo.value), "history");
} finally {
historyLoading.value = false;
}
}
function setRNacosConsoleActionError(target: "config" | "history" | "instances", message: string) {
if (target === "config") configError.value = message;
else if (target === "history") historyError.value = message;
else instancesError.value = message;
}
async function handleRNacosConsoleError(error: unknown, retryAction: () => Promise<void>, target: "config" | "history" | "instances") {
const message = error instanceof Error ? error.message : String(error);
if (!message.includes("[rnacosConsoleCaptchaRequired]")) {
setRNacosConsoleActionError(target, message);
return false;
}
rnacosConsoleRetryAction.value = retryAction;
rnacosConsoleRetryErrorTarget.value = target;
await requestRNacosConsoleAuthentication();
return true;
}
function retryRNacosConsoleAction() {
const retryAction = rnacosConsoleRetryAction.value;
rnacosConsoleRetryAction.value = null;
rnacosConsoleRetryErrorTarget.value = "history";
// Run after the failed action has finished its own catch/finally cleanup;
// otherwise that stale cleanup can close or clear the successfully retried UI.
setTimeout(() => void (retryAction ? retryAction() : loadConfigHistory(historyPageNo.value)), 0);
}
function rnacosCaptchaImageSource(image: string) {
return image.startsWith("data:") ? image : `data:image/png;base64,${image}`;
}
async function requestRNacosConsoleAuthentication() {
rnacosConsoleAuthError.value = "";
rnacosConsoleCaptcha.value = "";
rnacosConsoleAuthLoading.value = true;
try {
const challenge = await api.nacosGetRNacosConsoleCaptcha(props.connectionId);
if (!challenge.required) {
await api.nacosLoginRNacosConsole(props.connectionId);
void loadInfo();
retryRNacosConsoleAction();
return;
}
if (!challenge.image) throw new Error(t("nacos.rnacosCaptchaUnavailable"));
rnacosConsoleCaptchaImage.value = rnacosCaptchaImageSource(challenge.image);
rnacosConsoleAuthOpen.value = true;
} catch (error) {
setRNacosConsoleActionError(rnacosConsoleRetryErrorTarget.value, error instanceof Error ? error.message : String(error));
} finally {
rnacosConsoleAuthLoading.value = false;
}
}
async function submitRNacosConsoleAuthentication() {
if (!rnacosConsoleCaptcha.value.trim()) {
rnacosConsoleAuthError.value = t("nacos.rnacosCaptchaRequired");
return;
}
rnacosConsoleAuthLoading.value = true;
rnacosConsoleAuthError.value = "";
try {
await api.nacosLoginRNacosConsole(props.connectionId, rnacosConsoleCaptcha.value);
rnacosConsoleAuthOpen.value = false;
void loadInfo();
retryRNacosConsoleAction();
} catch (error) {
rnacosConsoleAuthError.value = error instanceof Error ? error.message : String(error);
} finally {
rnacosConsoleAuthLoading.value = false;
}
}
async function loadHistoryDetail(item: NacosConfigHistoryItem): Promise<NacosConfigItem | null> {
try {
return await api.nacosGetConfigHistory(props.connectionId, historyKeyFor(item));
} catch (error) {
await handleRNacosConsoleError(error, () => viewConfigHistory(item), "history");
return null;
}
}
async function viewConfigHistory(item: NacosConfigHistoryItem) {
historyViewingItem.value = null;
await nextTick();
historyViewingItem.value = item;
historyViewingContent.value = "";
historyViewingLoading.value = true;
const detail = await loadHistoryDetail(item);
historyViewingContent.value = detail?.content || "";
historyViewingLoading.value = false;
}
function closeHistoryDetail() {
historyViewingItem.value = null;
historyViewingContent.value = "";
historyViewingLoading.value = false;
}
async function compareConfigHistory(item: NacosConfigHistoryItem) {
if (!selectedConfigOriginalKey.value) return;
historyCompareLoading.value = true;
historyCompareOpen.value = true;
historyCompareItem.value = item;
historyCompareCurrent.value = "";
historyCompareContent.value = "";
try {
const [current, history] = await Promise.all([api.nacosGetConfig(props.connectionId, selectedConfigOriginalKey.value), api.nacosGetConfigHistory(props.connectionId, historyKeyFor(item))]);
historyCompareCurrent.value = current.content || "";
historyCompareContent.value = history.content || "";
} catch (error) {
await handleRNacosConsoleError(error, () => compareConfigHistory(item), "history");
historyCompareOpen.value = false;
} finally {
historyCompareLoading.value = false;
}
}
function requestRollbackComparedHistory() {
if (!historyCompareItem.value || props.readOnly) return;
historyCompareOpen.value = false;
requestRollbackHistory(historyCompareItem.value);
}
function requestRollbackHistory(item: NacosConfigHistoryItem) {
if (props.readOnly) return;
pendingHistoryRollback.value = item;
}
async function rollbackConfigHistory() {
if (!pendingHistoryRollback.value || props.readOnly) return;
if (!(await confirmNacosMutation(t("nacos.historyRollback"), props.connectionId, pendingHistoryRollback.value.namespace || namespace.value))) return;
rollingBackHistory.value = true;
try {
await api.nacosRollbackConfig(props.connectionId, historyKeyFor(pendingHistoryRollback.value));
pendingHistoryRollback.value = null;
configSaveNotice.value = t("nacos.rollbackSuccess");
if (selectedConfigOriginalKey.value) {
const detail = await api.nacosGetConfig(props.connectionId, selectedConfigOriginalKey.value);
const normalizedDetail = normalizeConfigItemFormat(detail);
selectedConfig.value = normalizedDetail;
configContent.value = normalizedDetail.content || "";
configType.value = configFormatValue(normalizedDetail) || "text";
rememberOriginalConfigState(normalizedDetail, configContent.value, configType.value);
await refreshConfigEditor();
}
await Promise.all([loadConfigs(configPageNo.value), loadConfigHistory(historyPageNo.value)]);
} catch (error) {
await handleRNacosConsoleError(error, () => rollbackConfigHistory(), "history");
} finally {
rollingBackHistory.value = false;
}
}
async function setConfigFormat(format: string) {
configType.value = format;
if (selectedConfig.value) selectedConfig.value.configType = format;
if (selectedConfigOriginalKey.value) rememberConfigFormat({ ...selectedConfigOriginalKey.value, configType: format });
configSaveNotice.value = "";
await refreshConfigEditor();
}
function requestSaveConfig() {
if (!selectedConfig.value || !canRequestConfigSave.value) return;
if (!isCreatingConfig.value && configContent.value !== originalConfigContent.value) {
pendingConfigSave.value = true;
return;
}
void saveConfig();
}
async function saveConfig() {
if (!selectedConfig.value || !canRequestConfigSave.value) return;
pendingConfigSave.value = false;
const requestId = ++latestConfigSaveRequestId;
const snapshot = createNacosConfigSaveSnapshot({
requestId,
editorSessionId: configEditorSessionId,
connectionId: props.connectionId,
fallbackNamespace: namespace.value,
originalKey: selectedConfigOriginalKey.value,
config: selectedConfig.value,
content: configContent.value,
configType: configType.value,
});
if (!snapshot.targetKey.dataId) {
configError.value = t("nacos.dataIdRequired");
return;
}
const pageAtRequest = configPageNo.value;
if (!(await confirmNacosMutation(t("nacos.publish"), snapshot.connectionId, snapshot.targetKey.namespace || namespace.value))) return;
savingConfig.value = true;
configError.value = "";
configSaveNotice.value = "";
try {
await api.nacosPublishConfig(snapshot.connectionId, {
namespace: snapshot.targetKey.namespace,
dataId: snapshot.targetKey.dataId,
group: snapshot.targetKey.group,
content: snapshot.content,
configType: snapshot.configType || undefined,
appName: snapshot.config.appName,
desc: snapshot.config.desc,
tags: snapshot.config.tags,
});
toast(t("nacos.saved"), 2000);
const remainsInSnapshotScope = requestId === latestConfigSaveRequestId && props.connectionId === snapshot.connectionId && (namespace.value || "") === (snapshot.targetKey.namespace || "");
if (remainsInSnapshotScope) {
await loadConfigsWithRetry(snapshot.wasCreating ? 1 : pageAtRequest);
rememberConfigFormat(snapshot.config);
upsertConfigInList(snapshot.config);
}
const currentEditorState = {
latestRequestId: latestConfigSaveRequestId,
editorSessionId: configEditorSessionId,
connectionId: props.connectionId,
originalKey: selectedConfigOriginalKey.value,
config: selectedConfig.value,
content: configContent.value,
configType: configType.value,
};
const completion = resolveNacosConfigSaveCompletion(snapshot, currentEditorState);
if (completion.kind !== "stale") {
rememberOriginalConfigState(completion.savedConfig, completion.baseline.content, completion.baseline.configType);
selectedConfigOriginalKey.value = completion.originalKey;
if (completion.kind === "saved") {
selectedConfig.value = completion.savedConfig;
configAdvancedOpen.value = false;
configSaveNotice.value = t(snapshot.wasCreating ? "nacos.createdAndLoaded" : "nacos.savedAndLoaded", { dataId: snapshot.targetKey.dataId });
} else {
configSaveNotice.value = "";
}
}
} catch (error) {
if (requestId === latestConfigSaveRequestId && snapshot.editorSessionId === configEditorSessionId && snapshot.connectionId === props.connectionId) {
configError.value = error instanceof Error ? error.message : String(error);
}
} finally {
if (requestId === latestConfigSaveRequestId) savingConfig.value = false;
}
}
function requestDeleteConfig() {
const key = selectedConfigOriginalKey.value;
if (!selectedConfig.value || !key || !canRequestConfigDelete.value) return;
pendingDeleteConfig.value = createNacosConfigDeleteSnapshot(props.connectionId, key, selectedConfig.value);
}
function reconcileDeletedConfigSelection(deletedKeys: ReadonlySet<string>) {
if (!deletedKeys.size) return;
selectedConfigKeys.value = selectedConfigKeys.value.filter((key) => !deletedKeys.has(key));
}
async function deleteConfig() {
const snapshot = pendingDeleteConfig.value;
if (!snapshot || !isNacosConfigDeleteSnapshotInScope(snapshot, props.connectionId, namespace.value)) {
pendingDeleteConfig.value = null;
return;
}
if (
!canStartNacosConfigDelete(
{
...configMutationGuardState.value,
hasPendingDelete: false,
},
snapshot.key,
)
)
return;
if (!(await confirmNacosMutation(t("nacos.delete"), snapshot.connectionId, snapshot.key.namespace || namespace.value))) return;
const editorSessionId = configEditorSessionId;
pendingDeleteConfig.value = null;
deletingConfig.value = true;
configError.value = "";
configSaveNotice.value = "";
try {
await api.nacosDeleteConfig(snapshot.connectionId, snapshot.key);
const remainsInDeletedScope = isNacosConfigDeleteSnapshotInScope(snapshot, props.connectionId, namespace.value);
if (remainsInDeletedScope) {
reconcileDeletedConfigSelection(new Set([configIdentityKey(snapshot.key)]));
await loadConfigs();
}
const stillViewingDeletedConfig =
remainsInDeletedScope &&
editorSessionId === configEditorSessionId &&
selectedConfigOriginalKey.value?.dataId === snapshot.key.dataId &&
(selectedConfigOriginalKey.value?.group || "DEFAULT_GROUP") === snapshot.key.group &&
(selectedConfigOriginalKey.value?.namespace || "") === (snapshot.key.namespace || "");
if (stillViewingDeletedConfig) {
configDetailRequestGuard.invalidate();
configEditorSessionId += 1;
selectedConfig.value = null;
selectedConfigOriginalKey.value = null;
configContent.value = "";
originalConfigContent.value = "";
destroyConfigEditor();
}
toast(t("nacos.deleted"), 2000);
} catch (error) {
if (isNacosConfigDeleteSnapshotInScope(snapshot, props.connectionId, namespace.value)) configError.value = error instanceof Error ? error.message : String(error);
} finally {
deletingConfig.value = false;
}
}
function requestBatchDeleteConfigs() {
if (!canRequestBatchDeleteConfigs.value) return;
const keys = selectedKeys();
if (!keys.length) return;
pendingBatchDelete.value = {
connectionId: props.connectionId,
namespace: namespace.value,
keys: keys.map((key) => ({
namespace: key.namespace || undefined,
dataId: key.dataId,
group: key.group || "DEFAULT_GROUP",
})),
};
}
async function deleteSelectedConfigs() {
const snapshot = pendingBatchDelete.value;
if (!snapshot || !isBatchDeleteSnapshotInScope(snapshot)) {
pendingBatchDelete.value = null;
return;
}
if (!canRequestBatchDeleteConfigs.value) return;
if (!(await confirmNacosMutation(t("nacos.batchDelete"), snapshot.connectionId, snapshot.namespace))) return;
if (!isBatchDeleteSnapshotInScope(snapshot)) {
pendingBatchDelete.value = null;
return;
}
const editorSessionId = configEditorSessionId;
pendingBatchDelete.value = null;
deletingConfig.value = true;
configError.value = "";
configSaveNotice.value = "";
const deletedKeys = new Set<string>();
let firstError = "";
let interrupted = false;
try {
// Reuse the version-aware single-config delete path rather than relying on a batch API that differs across Nacos implementations.
for (const key of snapshot.keys) {
if (!isBatchDeleteSnapshotInScope(snapshot)) {
interrupted = true;
break;
}
try {
await api.nacosDeleteConfig(snapshot.connectionId, key);
deletedKeys.add(configIdentityKey(key));
} catch (error) {
if (!firstError) firstError = error instanceof Error ? error.message : String(error);
}
}
if (!isBatchDeleteSnapshotInScope(snapshot)) interrupted = true;
if (!interrupted) {
if (deletedKeys.size) {
reconcileDeletedConfigSelection(deletedKeys);
await loadConfigs();
}
const selectedKey = selectedConfigOriginalKey.value;
const stillViewingDeletedConfig = editorSessionId === configEditorSessionId && selectedKey != null && deletedKeys.has(configIdentityKey(selectedKey));
if (stillViewingDeletedConfig) {
configDetailRequestGuard.invalidate();
configEditorSessionId += 1;
selectedConfig.value = null;
selectedConfigOriginalKey.value = null;
configContent.value = "";
originalConfigContent.value = "";
destroyConfigEditor();
}
if (firstError) {
configError.value = `${t("nacos.batchDeletePartial", { deleted: deletedKeys.size, failed: snapshot.keys.length - deletedKeys.size })} ${firstError}`;
toast(t("nacos.batchDeletePartial", { deleted: deletedKeys.size, failed: snapshot.keys.length - deletedKeys.size }), 3000);
} else {
toast(t("nacos.batchDeleteSuccess", { count: deletedKeys.size }), 2000);
}
} else {
toast(t("nacos.batchDeleteInterrupted", { deleted: deletedKeys.size }), 3000);
}
} finally {
deletingConfig.value = false;
}
}
async function loadServices(page = servicePageNo.value) {
const requestId = servicesRequestGuard.begin();
const connectionId = props.connectionId;
const requestNamespace = namespace.value;
const requestGroup = serviceGroup.value.trim();
const requestName = serviceName.value.trim();
servicesLoading.value = true;
servicesError.value = "";
servicePageNo.value = page;
try {
const result = await api.nacosListServices(connectionId, {
namespace: requestNamespace || undefined,
groupName: requestGroup || undefined,
serviceName: requestName || undefined,
pageNo: page,
pageSize: servicePageSize.value,
});
if (!servicesRequestGuard.isCurrent(requestId) || connectionId !== props.connectionId || requestNamespace !== namespace.value || requestGroup !== serviceGroup.value.trim() || requestName !== serviceName.value.trim()) return;
services.value = result.items;
serviceTotal.value = result.totalCount;
const selectedIdentity = serviceIdentity(selectedService.value);
if (selectedIdentity) {
const refreshedSelection = result.items.find((item) => serviceIdentity(item) === selectedIdentity);
if (refreshedSelection) selectedService.value = refreshedSelection;
}
} catch (error) {
if (!servicesRequestGuard.isCurrent(requestId)) return;
servicesError.value = error instanceof Error ? error.message : String(error);
} finally {
if (servicesRequestGuard.isCurrent(requestId)) servicesLoading.value = false;
}
}
async function loadServicesWithRetry(page = servicePageNo.value) {
for (let attempt = 0; ; attempt += 1) {
await loadServices(page);
if (!isConnectionNotFoundError(servicesError.value) || attempt >= CONNECTION_NOT_FOUND_RETRY_DELAYS_MS.length) return;
await delay(CONNECTION_NOT_FOUND_RETRY_DELAYS_MS[attempt]);
}
}
function clearServiceFilter(filter: "name" | "group") {
if (filter === "name") serviceName.value = "";
else serviceGroup.value = "";
void loadServicesWithRetry(1);
}
async function selectService(service: NacosServiceInfo) {
serviceMutationSequence += 1;
instanceUpdateSequence += 1;
selectedService.value = service;
selectedServiceDetail.value = null;
serviceDetailError.value = "";
instances.value = [];
instancesError.value = "";
await Promise.all([loadServiceDetail(), loadInstances()]);
}
function serviceIdentity(service: NacosServiceInfo | null) {
return service ? `${service.groupName || "DEFAULT_GROUP"}\u0000${service.serviceName}` : "";
}
async function loadServiceDetail() {
const service = selectedService.value ? { ...selectedService.value } : null;
if (!service || !getServiceCapability.value.supported) return;
const requestId = serviceDetailRequestGuard.begin();
const connectionId = props.connectionId;
const requestNamespace = namespace.value;
const identity = serviceIdentity(service);
serviceDetailLoading.value = true;
serviceDetailError.value = "";
try {
const detail = await api.nacosGetService(connectionId, {
namespace: requestNamespace || undefined,
serviceName: service.serviceName,
groupName: service.groupName || serviceGroup.value || undefined,
});
if (!serviceDetailRequestGuard.isCurrent(requestId) || connectionId !== props.connectionId || requestNamespace !== namespace.value || identity !== serviceIdentity(selectedService.value)) return;
selectedServiceDetail.value = detail;
} catch (error) {
if (!serviceDetailRequestGuard.isCurrent(requestId)) return;
serviceDetailError.value = error instanceof Error ? error.message : String(error);
} finally {
if (serviceDetailRequestGuard.isCurrent(requestId)) serviceDetailLoading.value = false;
}
}
async function reconcileServiceMutation(expected: NacosServiceUpsert, mutationId: number) {
const expectedIdentity = `${expected.groupName || "DEFAULT_GROUP"}\u0000${expected.serviceName}`;
for (const retryDelay of [0, 250, 750]) {
if (retryDelay) await delay(retryDelay);
if (mutationId !== serviceMutationSequence || expectedIdentity !== serviceIdentity(selectedService.value)) return;
try {
const detail = await api.nacosGetService(props.connectionId, {
namespace: expected.namespace,
serviceName: expected.serviceName,
groupName: expected.groupName,
});
if (mutationId !== serviceMutationSequence || expectedIdentity !== serviceIdentity(selectedService.value)) return;
if (nacosServiceDetailMatches(detail, expected)) {
selectedServiceDetail.value = detail;
serviceDetailError.value = "";
await loadServicesWithRetry(1);
if (expectedIdentity === serviceIdentity(selectedService.value)) await loadInstances();
return;
}
} catch {
// The explicit warning below preserves the optimistic detail and gives
// the user a deliberate refresh path when Nacos is briefly stale.
}
}
if (mutationId === serviceMutationSequence) serviceDetailError.value = t("nacos.serviceUpdateUnconfirmed");
}
function instanceRef(instance: NacosInstanceInfo, service = selectedService.value): NacosInstanceRef {
return {
namespace: namespace.value || undefined,
serviceName: service?.serviceName || instance.serviceName || "",
groupName: instance.groupName || service?.groupName || serviceGroup.value || undefined,
ip: instance.ip,
port: instance.port,
clusterName: instance.clusterName,
ephemeral: instance.ephemeral,
};
}
function instanceIdentity(instance: NacosInstanceInfo, service = selectedService.value) {
return instanceRefIdentity(instanceRef(instance, service));
}
function instanceRefIdentity(ref: NacosInstanceRef) {
return nacosInstanceRefIdentity(ref);
}
function beginInstanceOperation(key: string) {
const token = ++instanceOperationToken;
updatingInstanceKeys.value = { ...updatingInstanceKeys.value, [key]: token };
return token;
}
function isInstanceUpdating(instance: NacosInstanceInfo) {
return Object.prototype.hasOwnProperty.call(updatingInstanceKeys.value, instanceIdentity(instance));
}
function clearInstanceOperation(key: string, token: number) {
if (updatingInstanceKeys.value[key] !== token) return;
const next = { ...updatingInstanceKeys.value };
delete next[key];
updatingInstanceKeys.value = next;
}
function instanceWeightDraft(instance: NacosInstanceInfo) {
return instanceWeightDrafts.value[instanceIdentity(instance)] ?? String(instance.weight ?? 1);
}
function updateInstanceWeightDraft(instance: NacosInstanceInfo, value: string | number) {
instanceWeightDrafts.value[instanceIdentity(instance)] = String(value);
}
function hasInstanceWeightDraft(instance: NacosInstanceInfo) {
const value = instanceWeightDraft(instance).trim();
return value !== "" && Number.isFinite(Number(value)) && Number(value) !== (instance.weight ?? 1);
}
function resetInstanceWeightDraft(instance: NacosInstanceInfo) {
delete instanceWeightDrafts.value[instanceIdentity(instance)];
}
function requestInstanceWeightUpdate(instance: NacosInstanceInfo) {
const value = instanceWeightDraft(instance).trim();
const weight = Number(value);
if (!value || !Number.isFinite(weight) || weight < 0) {
instancesError.value = t("nacos.invalidWeight");
return;
}
requestUpdateInstance(instance, { weight });
}
function openInstanceEditor(instance: NacosInstanceInfo) {
instanceEditorTarget.value = instance;
instanceEditor.value = {
weight: String(instance.weight ?? 1),
metadata: JSON.stringify(instance.metadata ?? {}, null, 2),
};
instanceEditorError.value = "";
instanceEditorOpen.value = true;
}
function submitInstanceEditor() {
const instance = instanceEditorTarget.value;
const weight = Number(instanceEditor.value.weight);
if (!instance || !Number.isFinite(weight) || weight < 0) {
instanceEditorError.value = t("nacos.invalidWeightInput");
return;
}
try {
const metadata = parseJsonObject(instanceEditor.value.metadata, t("nacos.metadataLabel"));
instanceEditorOpen.value = false;
requestUpdateInstance(instance, { weight, metadata });
} catch (error) {
instanceEditorError.value = error instanceof Error ? error.message : String(error);
}
}
function instanceMatchesPatch(instance: NacosInstanceInfo, patch: NacosInstancePatch) {
return nacosInstanceMatchesPatch(instance, patch);
}
async function loadInstances() {
if (!selectedService.value) return;
instanceUpdateSequence += 1;
if (!listInstancesCapability.value.supported) {
instancesError.value = capabilityReason(listInstancesCapability.value);
return;
}
const requestId = instancesRequestGuard.begin();
const connectionId = props.connectionId;
const requestNamespace = namespace.value;
const service = { ...selectedService.value };
const selectedIdentity = serviceIdentity(service);
const clusters = serviceCluster.value.trim();
instancesLoading.value = true;
instancesError.value = "";
try {
const result = await api.nacosListInstances(connectionId, {
namespace: requestNamespace || undefined,
serviceName: service.serviceName,
groupName: service.groupName || serviceGroup.value || undefined,
clusters: clusters || undefined,
});
if (!instancesRequestGuard.isCurrent(requestId) || connectionId !== props.connectionId || requestNamespace !== namespace.value || selectedIdentity !== serviceIdentity(selectedService.value) || clusters !== serviceCluster.value.trim()) return;
instances.value = result;
} catch (error) {
if (!instancesRequestGuard.isCurrent(requestId)) return;
await handleRNacosConsoleError(error, () => loadInstances(), "instances");
} finally {
if (instancesRequestGuard.isCurrent(requestId)) instancesLoading.value = false;
}
}
async function refreshSelectedService() {
if (!selectedService.value) return;
await Promise.all([loadServiceDetail(), loadInstances(), loadServices(servicePageNo.value)]);
}
function requestUpdateInstance(instance: NacosInstanceInfo, patch: NacosInstancePatch) {
if (!selectedService.value || props.readOnly || !supportsInstanceUpdate.value) return;
if (patch.weight != null && (!Number.isFinite(patch.weight) || patch.weight < 0)) {
instancesError.value = t("nacos.invalidWeight");
return;
}
pendingInstanceUpdate.value = { instance, patch };
}
async function reconcileInstanceUpdate(ref: NacosInstanceRef, patch: NacosInstancePatch, updateId: number) {
const currentService = selectedService.value;
if (!currentService || serviceIdentity(currentService) !== `${ref.groupName || "DEFAULT_GROUP"}\u0000${ref.serviceName}`) return;
for (const retryDelay of [0, 250, 750]) {
if (retryDelay) await delay(retryDelay);
if (updateId !== instanceUpdateSequence || serviceIdentity(selectedService.value) !== serviceIdentity(currentService)) return;
try {
const result = await api.nacosListInstances(props.connectionId, {
namespace: ref.namespace,
serviceName: ref.serviceName,
groupName: ref.groupName,
clusters: serviceCluster.value.trim() || undefined,
});
if (updateId !== instanceUpdateSequence || serviceIdentity(selectedService.value) !== serviceIdentity(currentService)) return;
const actual = result.find((candidate) => instanceIdentity(candidate, currentService) === instanceRefIdentity(ref));
if (actual && instanceMatchesPatch(actual, patch)) {
instances.value = result;
void loadServices(servicePageNo.value);
return;
}
} catch {
// Keep the optimistic result visible. The final warning gives the user a
// deliberate refresh path instead of silently replacing it with stale data.
}
}
if (updateId === instanceUpdateSequence) instancesError.value = t("nacos.instanceUpdateUnconfirmed");
}
async function reconcileInstancePresence(ref: NacosInstanceRef, shouldExist: boolean, updateId: number) {
const currentService = selectedService.value;
if (!currentService || serviceIdentity(currentService) !== `${ref.groupName || "DEFAULT_GROUP"}\u0000${ref.serviceName}`) return;
for (const retryDelay of [0, 250, 750]) {
if (retryDelay) await delay(retryDelay);
if (updateId !== instanceUpdateSequence || serviceIdentity(selectedService.value) !== serviceIdentity(currentService)) return;
try {
const result = await api.nacosListInstances(props.connectionId, {
namespace: ref.namespace,
serviceName: ref.serviceName,
groupName: ref.groupName,
clusters: serviceCluster.value.trim() || undefined,
});
if (updateId !== instanceUpdateSequence || serviceIdentity(selectedService.value) !== serviceIdentity(currentService)) return;
const exists = result.some((candidate) => instanceIdentity(candidate, currentService) === instanceRefIdentity(ref));
if (exists === shouldExist) {
instances.value = result;
instancesError.value = "";
void loadServices(servicePageNo.value);
return;
}
} catch {
// Keep the optimistic list until the final warning offers a refresh.
}
}
if (updateId === instanceUpdateSequence) instancesError.value = shouldExist ? t("nacos.instanceRegisterUnconfirmed") : t("nacos.instanceDeregisterUnconfirmed");
}
async function updateInstance(instance: NacosInstanceInfo, patch: NacosInstancePatch) {
if (!selectedService.value || props.readOnly || !supportsInstanceUpdate.value) return;
const ref = instanceRef(instance);
if (!(await confirmNacosMutation(t("nacos.confirmInstanceTitle"), props.connectionId, ref.namespace || namespace.value))) return;
const key = instanceIdentity(instance);
const updateId = ++instanceUpdateSequence;
const operationToken = beginInstanceOperation(key);
try {
await api.nacosUpdateInstance(props.connectionId, { target: ref, patch });
if (updateId !== instanceUpdateSequence) return;
instances.value = instances.value.map((candidate) => (instanceIdentity(candidate) === key ? { ...candidate, ...patch } : candidate));
if (patch.weight != null) delete instanceWeightDrafts.value[key];
pendingInstanceUpdate.value = null;
void reconcileInstanceUpdate(ref, patch, updateId);
} catch (error) {
if (updateId === instanceUpdateSequence) {
pendingInstanceUpdate.value = null;
instancesError.value = error instanceof Error ? error.message : String(error);
}
} finally {
clearInstanceOperation(key, operationToken);
}
}
function parseJsonObject(value: string, label: string): Record<string, unknown> {
const parsed = JSON.parse(value || "{}") as unknown;
if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new Error(`${label}${t("nacos.jsonObjectValidation")}`);
return parsed as Record<string, unknown>;
}
function parseOptionalJsonObject(value: string, label: string): Record<string, unknown> | undefined {
const trimmed = value.trim();
// Nacos rejects an empty selector object because it has no selector type.
// Treat an empty editor or `{}` as the absence of a selector instead.
if (!trimmed || trimmed === "{}") return undefined;
return parseJsonObject(trimmed, label);
}
function openCreateService() {
serviceEditorMode.value = "create";
serviceEditor.value = { serviceName: "", groupName: serviceGroup.value || "DEFAULT_GROUP", metadata: "{}", protectThreshold: "0", selector: "" };
serviceEditorError.value = "";
serviceEditorOpen.value = true;
}
async function openUpdateService(service: NacosServiceInfo) {
serviceEditorLoading.value = true;
serviceEditorError.value = "";
try {
const detail: NacosServiceDetail = await api.nacosGetService(props.connectionId, { namespace: namespace.value || undefined, serviceName: service.serviceName, groupName: service.groupName });
serviceEditorMode.value = "update";
serviceEditor.value = {
serviceName: detail.serviceName,
groupName: detail.groupName || service.groupName || "DEFAULT_GROUP",
metadata: JSON.stringify(detail.metadata ?? {}, null, 2),
protectThreshold: String(detail.protectThreshold ?? 0),
selector: detail.selector && typeof detail.selector === "object" && !Array.isArray(detail.selector) && Object.keys(detail.selector).length > 0 ? JSON.stringify(detail.selector, null, 2) : "",
};
serviceEditorOpen.value = true;
} catch (error) {
instancesError.value = error instanceof Error ? error.message : String(error);
} finally {
serviceEditorLoading.value = false;
}
}
async function submitServiceEditor() {
const threshold = Number(serviceEditor.value.protectThreshold);
if (!serviceEditor.value.serviceName.trim() || !serviceEditor.value.groupName.trim() || !Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
serviceEditorError.value = t("nacos.serviceValidation");
return;
}
serviceEditorLoading.value = true;
serviceEditorError.value = "";
try {
const isCreating = serviceEditorMode.value === "create";
const targetGroup = isCreating ? serviceEditor.value.groupName.trim() : selectedService.value?.groupName || serviceEditor.value.groupName.trim();
const req: NacosServiceUpsert = {
namespace: namespace.value || undefined,
serviceName: serviceEditor.value.serviceName.trim(),
groupName: targetGroup,
metadata: parseJsonObject(serviceEditor.value.metadata, t("nacos.metadataLabel")),
protectThreshold: threshold,
selector: parseOptionalJsonObject(serviceEditor.value.selector, t("nacos.selectorLabel")),
};
const operation = isCreating ? t("nacos.createNacosService") : t("nacos.editNacosService");
if (!(await confirmNacosMutation(operation, props.connectionId, req.namespace || namespace.value))) return;
const mutationId = ++serviceMutationSequence;
if (isCreating) await api.nacosCreateService(props.connectionId, req);
else await api.nacosUpdateService(props.connectionId, req);
serviceEditorOpen.value = false;
if (isCreating && req.groupName) serviceGroup.value = req.groupName;
selectedService.value = isCreating ? { serviceName: req.serviceName, groupName: req.groupName } : { ...(selectedService.value ?? {}), serviceName: req.serviceName, groupName: req.groupName };
if (isCreating) instances.value = [];
selectedServiceDetail.value = {
serviceName: req.serviceName,
groupName: req.groupName,
metadata: req.metadata ?? {},
protectThreshold: req.protectThreshold,
selector: req.selector,
ephemeral: selectedServiceDetail.value?.ephemeral,
};
serviceDetailError.value = "";
await loadServicesWithRetry(1);
void reconcileServiceMutation(req, mutationId);
} catch (error) {
serviceEditorError.value = error instanceof Error ? error.message : String(error);
} finally {
serviceEditorLoading.value = false;
}
}
async function requestDeleteService(service: NacosServiceInfo) {
try {
const existing = await api.nacosListInstances(props.connectionId, { namespace: namespace.value || undefined, serviceName: service.serviceName, groupName: service.groupName });
if (existing.length) {
instancesError.value = t("nacos.serviceHasInstances");
return;
}
pendingServiceDelete.value = service;
} catch (error) {
instancesError.value = error instanceof Error ? error.message : String(error);
}
}
async function reconcileServiceDeletion(service: NacosServiceInfo, mutationId: number) {
const groupName = service.groupName || "DEFAULT_GROUP";
for (const retryDelay of [0, 250, 750]) {
if (retryDelay) await delay(retryDelay);
if (mutationId !== serviceMutationSequence) return;
try {
const result = await api.nacosListServices(props.connectionId, {
namespace: namespace.value || undefined,
groupName,
serviceName: service.serviceName,
pageNo: 1,
pageSize: servicePageSize.value,
});
if (mutationId !== serviceMutationSequence) return;
const stillExists = result.items.some((item) => serviceIdentity(item) === `${groupName}\u0000${service.serviceName}`);
if (!stillExists) {
servicesError.value = "";
await loadServicesWithRetry(1);
return;
}
} catch {
// A transient read failure is not proof that the service disappeared.
}
}
if (mutationId === serviceMutationSequence) servicesError.value = t("nacos.serviceDeleteUnconfirmed");
}
async function deleteService(service: NacosServiceInfo) {
if (!(await confirmNacosMutation(t("nacos.deleteNacosService"), props.connectionId, namespace.value))) return;
deletingService.value = true;
try {
const mutationId = ++serviceMutationSequence;
await api.nacosDeleteService(props.connectionId, { namespace: namespace.value || undefined, serviceName: service.serviceName, groupName: service.groupName });
pendingServiceDelete.value = null;
services.value = services.value.filter((candidate) => serviceIdentity(candidate) !== serviceIdentity(service));
if (serviceIdentity(selectedService.value) === serviceIdentity(service)) {
selectedService.value = null;
selectedServiceDetail.value = null;
instances.value = [];
}
void reconcileServiceDeletion(service, mutationId);
} catch (error) {
pendingServiceDelete.value = null;
servicesError.value = error instanceof Error ? error.message : String(error);
} finally {
deletingService.value = false;
}
}
async function submitInstanceRegistration() {
if (!selectedService.value) return;
const port = Number(registerInstance.value.port);
const weight = Number(registerInstance.value.weight);
if (!nacosIpAddressIsValid(registerInstance.value.ip) || !Number.isInteger(port) || port < 1 || port > 65535 || !Number.isFinite(weight) || weight < 0) {
registerInstanceError.value = t("nacos.instanceValidation");
return;
}
registeringInstance.value = true;
registerInstanceError.value = "";
try {
const registration = {
namespace: namespace.value || undefined,
serviceName: selectedService.value.serviceName,
groupName: selectedService.value.groupName || serviceGroup.value || undefined,
ip: registerInstance.value.ip.trim(),
port,
clusterName: registerInstance.value.clusterName.trim() || undefined,
weight,
metadata: parseJsonObject(registerInstance.value.metadata, t("nacos.metadataLabel")),
};
if (!(await confirmNacosMutation(t("nacos.registerInstance"), props.connectionId, registration.namespace || namespace.value))) return;
const updateId = ++instanceUpdateSequence;
await api.nacosRegisterInstance(props.connectionId, registration);
const ref: NacosInstanceRef = { ...registration, ephemeral: false };
if (!instances.value.some((candidate) => instanceIdentity(candidate) === instanceRefIdentity(ref))) {
instances.value = [
...instances.value,
{
ip: registration.ip,
port: registration.port,
serviceName: registration.serviceName,
groupName: registration.groupName,
clusterName: registration.clusterName,
enabled: true,
ephemeral: false,
weight: registration.weight,
metadata: registration.metadata,
},
];
}
registerInstanceOpen.value = false;
void reconcileInstancePresence(ref, true, updateId);
} catch (error) {
registerInstanceError.value = error instanceof Error ? error.message : String(error);
} finally {
registeringInstance.value = false;
}
}
async function deregisterInstance(instance: NacosInstanceInfo) {
if (!selectedService.value) return;
const ref = instanceRef(instance);
if (!(await confirmNacosMutation(t("nacos.deregisterNacosInstance"), props.connectionId, ref.namespace || namespace.value))) return;
const key = instanceIdentity(instance);
const operationToken = beginInstanceOperation(key);
try {
const updateId = ++instanceUpdateSequence;
await api.nacosDeregisterInstance(props.connectionId, ref);
pendingInstanceDeregister.value = null;
instances.value = instances.value.filter((candidate) => instanceIdentity(candidate) !== instanceIdentity(instance));
void reconcileInstancePresence(ref, false, updateId);
} catch (error) {
pendingInstanceDeregister.value = null;
instancesError.value = error instanceof Error ? error.message : String(error);
} finally {
clearInstanceOperation(key, operationToken);
}
}
watch(historyCompareOpen, (value) => {
if (!value && !historyCompareLoading.value) historyCompareItem.value = null;
});
watch(searchOpen, (value) => {
if (value) return;
const operationId = activeSearchOperationId.value;
activeSearchOperationId.value = "";
searchLoading.value = false;
if (operationId) void api.nacosCancelConfigContentSearch(operationId);
});
watch(configListViewport, observeConfigListViewport, { flush: "post" });
watch(
() => props.targetRequestId,
() => {
if (props.targetDataId) void openTargetConfig(props.targetDataId, props.targetGroup || "DEFAULT_GROUP", props.targetKeyword);
},
);
watch(
[() => settingsStore.editorSettings, () => isDark.value, () => themePalette.value],
async ([settings]) => {
const view = configEditorView.value;
if (!view) return;
const [{ EditorView }, theme] = await Promise.all([import("@codemirror/view"), loadEditorTheme(settings.theme, editorThemeAppearance(), currentCustomThemeColors(), themePalette.value)]);
if (configEditorView.value !== view) return;
configEditorFontSize.value = clampEditorFontSize(settings.fontSize);
view.dispatch({
effects: [configEditorTheme.reconfigure(theme), configEditorFontTheme.reconfigure(editorFontTheme(EditorView, settings.fontSize, settings.fontFamily, { fixedHeight: true, scrollable: true })), configEditorWordWrap.reconfigure(settings.wordWrap ? EditorView.lineWrapping : [])],
});
},
{ deep: true },
);
watch(
() => [props.connectionId, props.namespace] as const,
async () => {
closePendingConfigMutationConfirmations();
configListRequestGuard.invalidate();
configDetailRequestGuard.invalidate();
configEditorSessionId += 1;
latestConfigSaveRequestId += 1;
savingConfig.value = false;
invalidateBatchNamespaces(false);
batchTargetNamespacesRequestGuard.invalidate();
batchTargetNamespaces.value = [];
batchTargetConnectionId.value = "";
searchOpen.value = false;
clearContentSearchSession();
selectedConfig.value = null;
selectedConfigOriginalKey.value = null;
configContent.value = "";
originalConfigContent.value = "";
destroyConfigEditor();
selectedService.value = null;
selectedServiceDetail.value = null;
serviceDetailError.value = "";
servicesRequestGuard.invalidate();
serviceDetailRequestGuard.invalidate();
instancesRequestGuard.invalidate();
instanceUpdateSequence += 1;
serviceMutationSequence += 1;
instances.value = [];
instancesError.value = "";
selectedConfigKeys.value = [];
try {
await connectionStore.ensureConnected(props.connectionId);
} catch (e) {
console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
}
await loadInfo();
await Promise.all([loadConfigsWithRetry(1), loadServicesWithRetry(1)]);
},
);
onMounted(async () => {
stopNacosNamespacesChangedListener = subscribeNacosNamespacesChanged(handleNacosNamespacesChanged);
try {
await connectionStore.ensureConnected(props.connectionId);
} catch (e) {
console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
}
await loadInfo();
await Promise.all([loadConfigsWithRetry(1), loadServicesWithRetry(1)]);
if (props.targetDataId) await openTargetConfig(props.targetDataId, props.targetGroup || "DEFAULT_GROUP", props.targetKeyword);
});
onBeforeUnmount(() => {
configListRequestGuard.invalidate();
configDetailRequestGuard.invalidate();
servicesRequestGuard.invalidate();
serviceDetailRequestGuard.invalidate();
instancesRequestGuard.invalidate();
instanceUpdateSequence += 1;
serviceMutationSequence += 1;
configEditorSessionId += 1;
latestConfigSaveRequestId += 1;
batchNamespacesRequestGuard.invalidate();
batchTargetNamespacesRequestGuard.invalidate();
stopNacosNamespacesChangedListener?.();
stopNacosNamespacesChangedListener = null;
if (activeSearchOperationId.value) void api.nacosCancelConfigContentSearch(activeSearchOperationId.value);
configListResizeObserver?.disconnect();
configEditorZoomCommitScheduler.dispose();
destroyConfigEditor();
});
</script>
<template>
<div class="flex h-full min-h-0 flex-col bg-background">
<div class="flex shrink-0 flex-wrap items-center justify-between gap-3 border-b px-3 py-2">
<div class="flex min-w-0 items-center gap-2 text-sm">
<Network class="h-4 w-4 text-sky-600" />
<span class="truncate font-medium">{{ connectionInfo?.displayServerAddr || connectionInfo?.serverAddr || "Nacos" }}</span>
<Badge v-if="connectionInfo?.serverVersion" variant="secondary">{{ connectionInfo.serverVersion }}</Badge>
<Badge variant="outline">{{ namespaceLabel }}</Badge>
<Badge v-if="namespaceIdLabel" variant="outline" class="max-w-72 truncate font-mono">{{ namespaceIdLabel }}</Badge>
<ProductionContextBadge v-if="nacosProductionContext.active" compact />
<Badge v-if="readOnly" variant="outline">{{ t("nacos.readOnly") }}</Badge>
</div>
<div class="flex min-w-0 flex-wrap items-center justify-end gap-2">
<span v-if="connectionError" class="max-w-96 truncate text-xs text-destructive">{{ connectionError }}</span>
<Button v-if="connectionError" size="sm" variant="outline" class="h-8 w-8 px-0" :title="t('nacos.retryConnectionInfo')" :aria-label="t('nacos.retryConnectionInfo')" :disabled="infoLoading" @click="loadInfo">
<Loader2 v-if="infoLoading" class="h-3.5 w-3.5 animate-spin" />
<RefreshCw v-else class="h-3.5 w-3.5" />
</Button>
<div class="inline-flex">
<Button size="sm" :variant="hasSearchSession ? 'secondary' : 'outline'" class="h-8 gap-1.5" :class="hasSearchSession ? 'rounded-r-none pr-2' : ''" :title="hasSearchSession ? t('nacos.searchResultsRetainedHint') : t('nacos.contentSearch')" @click="openSearchDialog">
<Search class="h-3.5 w-3.5" />
{{ t(hasSearchSession ? "nacos.searchResults" : "nacos.contentSearch") }}
<Badge v-if="retainedSearchMatchCount" variant="outline" class="h-5 min-w-5 justify-center px-1.5">{{ retainedSearchMatchCount }}</Badge>
</Button>
<Button v-if="hasSearchSession" type="button" size="sm" variant="secondary" class="h-8 w-8 rounded-l-none border-l border-border px-0" :title="t('nacos.clearSearchResults')" :aria-label="t('nacos.clearSearchResults')" @click="clearContentSearchSession">
<X class="h-3.5 w-3.5" />
</Button>
</div>
<Button size="sm" variant="outline" class="h-8 gap-1.5" @click="openBatchDialog('export')">
<Archive class="h-3.5 w-3.5" />
{{ t("nacos.batchExport") }}
</Button>
<Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="readOnly" @click="openBatchDialog('import')">
<FileInput class="h-3.5 w-3.5" />
{{ t("nacos.batchImport") }}
</Button>
<Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="readOnly" @click="openBatchDialog('copy')">
<ArrowLeftRight class="h-3.5 w-3.5" />
{{ t("nacos.copyToNamespace") }}
</Button>
<Button v-if="activeTab === 'configs' && selectedConfigCount > 0" size="sm" variant="destructive" class="h-8 gap-1.5" :disabled="!canRequestBatchDeleteConfigs" @click="requestBatchDeleteConfigs">
<Trash2 class="h-3.5 w-3.5" />
{{ t("nacos.batchDelete") }}
<span class="border-l border-current/30 pl-1.5 text-xs font-semibold tabular-nums">{{ selectedConfigCount }}</span>
</Button>
</div>
</div>
<div class="flex shrink-0 items-center gap-1 border-b px-3 py-1.5">
<button class="rounded px-3 py-1.5 text-sm" :class="activeTab === 'configs' ? 'bg-accent font-medium' : 'text-muted-foreground hover:bg-accent/60'" @click="activeTab = 'configs'">{{ t("nacos.configs") }}</button>
<button class="rounded px-3 py-1.5 text-sm" :class="activeTab === 'services' ? 'bg-accent font-medium' : 'text-muted-foreground hover:bg-accent/60'" :disabled="!supportsServiceManagement" @click="activeTab = 'services'">{{ t("nacos.services") }}</button>
</div>
<Splitpanes v-if="activeTab === 'configs'" class="nacos-admin-splitpanes min-h-0 flex-1" @resized="handleNacosSplitResized">
<Pane :size="nacosSplitSize" min-size="24">
<div class="flex h-full min-h-0 flex-col">
<div class="grid shrink-0 grid-cols-[minmax(0,1fr)_minmax(0,1fr)_minmax(0,1fr)_auto_auto] gap-2 border-b p-2">
<div class="relative min-w-0">
<Input v-model="configDataId" class="h-8 min-w-0 pr-8" placeholder="dataId" @keyup.enter="loadConfigsWithRetry(1)" />
<button
v-if="configDataId"
type="button"
class="absolute right-2 top-1/2 flex h-5 w-5 -translate-y-1/2 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground"
:title="t('nacos.clear')"
:aria-label="t('nacos.clear')"
@click="clearConfigFilter('dataId')"
>
<X class="h-3.5 w-3.5" />
</button>
</div>
<div class="relative min-w-0">
<Input v-model="configGroup" class="h-8 min-w-0 pr-8" :placeholder="t('nacos.configListGroup')" @keyup.enter="loadConfigsWithRetry(1)" />
<button
v-if="configGroup"
type="button"
class="absolute right-2 top-1/2 flex h-5 w-5 -translate-y-1/2 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground"
:title="t('nacos.clear')"
:aria-label="t('nacos.clear')"
@click="clearConfigFilter('group')"
>
<X class="h-3.5 w-3.5" />
</button>
</div>
<div class="relative min-w-0">
<Input v-model="configAppName" class="h-8 min-w-0 pr-8" :placeholder="t('nacos.configListApplication')" @keyup.enter="loadConfigsWithRetry(1)" />
<button
v-if="configAppName"
type="button"
class="absolute right-2 top-1/2 flex h-5 w-5 -translate-y-1/2 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground"
:title="t('nacos.clear')"
:aria-label="t('nacos.clear')"
@click="clearConfigFilter('appName')"
>
<X class="h-3.5 w-3.5" />
</button>
</div>
<Button size="sm" variant="outline" class="h-8 w-9 px-0" :title="t('nacos.load')" :disabled="configLoading" @click="loadConfigsWithRetry(1)">
<Loader2 v-if="configLoading" class="h-3.5 w-3.5 animate-spin" />
<RefreshCw v-else class="h-3.5 w-3.5" />
</Button>
<Button size="sm" class="h-8 w-9 px-0" :disabled="readOnly" @click="newConfig">
<Plus class="h-3.5 w-3.5" />
</Button>
</div>
<div v-if="configError" class="border-b px-3 py-2 text-xs text-destructive">{{ configError }}</div>
<div ref="configListViewport" class="nacos-config-list-viewport min-h-0 flex-1 overflow-auto">
<div class="w-max min-w-full" :style="{ minWidth: configListMinWidth }">
<div class="sticky top-0 z-20 grid border-b bg-muted px-3 py-2 text-[11px] font-medium uppercase tracking-wide text-muted-foreground shadow-sm" :style="{ gridTemplateColumns: configListGridTemplate }">
<div v-for="(column, columnIndex) in configListColumns" :key="column" class="relative min-w-0" :class="column === 'dataId' ? 'pr-3' : columnIndex === configListColumns.length - 1 ? 'pl-3 pr-10' : 'px-3'">
<span v-if="column === 'dataId'" class="flex items-center gap-2">
<input type="checkbox" :checked="allCurrentPageSelected" :aria-label="t('nacos.selectCurrentPage')" @change="toggleCurrentPageSelection(($event.target as HTMLInputElement).checked)" />
<span class="block truncate">dataID</span>
</span>
<span v-else-if="column === 'group'" class="block truncate">{{ t("nacos.group") }}</span>
<span v-else-if="column === 'application'" class="block truncate">{{ configListColumnLabel("application") }}</span>
<span v-else class="block truncate">{{ configListColumnLabel("format") }}</span>
<div
v-if="columnIndex < configListColumns.length - 1"
data-column-resize-handle
role="separator"
aria-orientation="vertical"
:aria-label="t('nacos.resizeColumn')"
class="group absolute -right-1 top-0 z-10 h-full w-2 cursor-col-resize hover:bg-primary/10"
:class="configListResizingColumnIndex === columnIndex ? 'bg-primary/15' : ''"
@mousedown="onConfigListColumnResizeStart(columnIndex, $event)"
>
<span class="pointer-events-none absolute left-1/2 top-1/2 h-5 w-px -translate-x-1/2 -translate-y-1/2 bg-border/90 transition-colors group-hover:bg-primary" />
</div>
</div>
<DropdownMenu>
<DropdownMenuTrigger as-child>
<Button size="sm" variant="ghost" class="absolute right-1 top-1/2 z-20 h-7 w-7 -translate-y-1/2 p-0" :title="t('nacos.visibleColumns')" :aria-label="t('nacos.visibleColumns')">
<Columns3 class="h-3.5 w-3.5" />
</Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="end" class="min-w-40" @close-auto-focus.prevent>
<DropdownMenuCheckboxItem v-for="column in configListToggleableColumns" :key="column" :model-value="isConfigListColumnVisible(column)" @select.prevent @update:model-value="setConfigListColumnVisible(column, $event)">
{{ configListColumnLabel(column) }}
</DropdownMenuCheckboxItem>
</DropdownMenuContent>
</DropdownMenu>
</div>
<div
v-for="item in configs"
:key="`${item.namespace}:${item.group}:${item.dataId}`"
class="grid w-full cursor-pointer items-center border-b px-3 py-2.5 text-left text-sm transition-colors hover:bg-accent/50"
:class="{ 'border-l-2 border-l-primary': isSelectedConfigListItem(item) }"
:style="{ gridTemplateColumns: configListGridTemplate }"
@click="selectConfig(item)"
>
<template v-for="column in configListColumns" :key="column">
<span v-if="column === 'dataId'" class="flex min-w-0 items-center gap-2 pr-3" :title="item.dataId">
<input type="checkbox" :checked="selectedConfigKeys.includes(configIdentityKey(item))" :aria-label="t('nacos.selectConfigForBatch', { dataId: item.dataId })" @click.stop @change.stop="toggleConfigSelection(item, ($event.target as HTMLInputElement).checked)" />
<button type="button" class="flex min-w-0 items-center gap-2 text-left" @click.stop="selectConfig(item)">
<FileText class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
<span class="truncate font-medium text-foreground">{{ item.dataId }}</span>
</button>
</span>
<span v-else-if="column === 'group'" class="truncate px-3 text-xs text-muted-foreground" :title="item.group || 'DEFAULT_GROUP'">{{ item.group || "DEFAULT_GROUP" }}</span>
<span v-else-if="column === 'application'" class="truncate px-3 text-xs text-muted-foreground" :title="item.appName || '-'">{{ item.appName || "-" }}</span>
<span v-else class="truncate pl-3 text-xs text-muted-foreground" :title="configFormatLabel(item)">{{ configFormatLabel(item) }}</span>
</template>
</div>
</div>
<div v-if="!configLoading && configs.length === 0" class="flex h-full items-center justify-center text-sm text-muted-foreground">{{ t("nacos.noConfigs") }}</div>
</div>
<div class="grid shrink-0 grid-cols-[minmax(0,1fr)_auto] items-center gap-2 border-t px-3 py-2 text-xs text-muted-foreground">
<div class="flex min-w-0 items-center gap-3 overflow-hidden">
<span class="min-w-0 truncate">{{ t("nacos.total", { count: configTotal }) }}</span>
</div>
<div class="flex shrink-0 items-center gap-2">
<div class="flex items-center gap-1.5 whitespace-nowrap">
<span>{{ t("nacos.configPageSize") }}</span>
<Select :model-value="String(configPageSize)" :disabled="configLoading" @update:model-value="setConfigPageSize(String($event))">
<SelectTrigger size="sm" class="w-16 text-xs" :aria-label="t('nacos.configPageSize')"><SelectValue /></SelectTrigger>
<SelectContent position="popper">
<SelectItem v-for="size in NACOS_CONFIG_PAGE_SIZE_OPTIONS" :key="size" :value="String(size)">{{ size }}</SelectItem>
</SelectContent>
</Select>
</div>
<Button size="icon" variant="outline" class="h-7 w-7" :title="t('nacos.prev')" :aria-label="t('nacos.prev')" :disabled="configPageNo <= 1 || configLoading" @click="loadConfigs(configPageNo - 1)">
<ChevronLeft class="h-3.5 w-3.5" />
</Button>
<span>{{ configPageNo }} / {{ configTotalPages }}</span>
<Button size="icon" variant="outline" class="h-7 w-7" :title="t('nacos.next')" :aria-label="t('nacos.next')" :disabled="configPageNo >= configTotalPages || configLoading" @click="loadConfigs(configPageNo + 1)">
<ChevronRight class="h-3.5 w-3.5" />
</Button>
</div>
</div>
</div>
</Pane>
<Pane :size="100 - nacosSplitSize" min-size="20">
<div class="nacos-config-workbench flex h-full min-h-0 flex-col">
<template v-if="selectedConfig">
<header class="nacos-config-context-bar shrink-0 border-b bg-background px-3 py-2.5">
<div class="flex min-w-0 items-center gap-2.5">
<div class="flex h-8 w-8 shrink-0 items-center justify-center rounded-md border bg-muted/35 text-muted-foreground">
<FileText class="h-4 w-4" />
</div>
<div class="min-w-0">
<div class="flex min-w-0 items-center gap-2">
<h2 class="truncate text-sm font-semibold leading-5" :title="selectedConfig.dataId || t('nacos.newConfigDraft')">
{{ selectedConfig.dataId || t("nacos.newConfigDraft") }}
</h2>
<span v-if="isCreatingConfig" class="shrink-0 rounded border border-dashed px-1.5 py-0.5 text-[10px] font-medium uppercase tracking-wide text-muted-foreground">
{{ t("nacos.draft") }}
</span>
</div>
<div class="mt-0.5 flex min-w-0 items-center gap-1.5 text-[11px] text-muted-foreground">
<span class="truncate" :title="namespaceLabel">{{ namespaceLabel }}</span>
<span aria-hidden="true">/</span>
<span class="truncate" :title="selectedConfig.group || 'DEFAULT_GROUP'">{{ selectedConfig.group || "DEFAULT_GROUP" }}</span>
</div>
</div>
</div>
<div class="nacos-config-state shrink-0" aria-live="polite">
<span v-if="readOnly" class="rounded-md border bg-muted/30 px-2 py-1 text-[11px] font-medium text-muted-foreground">{{ t("nacos.readOnlyState") }}</span>
<span v-else-if="savingConfig" class="flex items-center gap-1.5 text-xs text-muted-foreground">
<Loader2 class="h-3.5 w-3.5 animate-spin" />
{{ t("nacos.saving") }}
</span>
<span v-else-if="isConfigDirty" class="flex items-center gap-1.5 text-xs font-medium text-amber-600 dark:text-amber-400">
<span class="h-1.5 w-1.5 rounded-full bg-current" aria-hidden="true" />
{{ t("nacos.unsaved") }}
</span>
<span v-else-if="configSaveNotice" class="flex max-w-64 items-center gap-1.5 text-xs font-medium text-emerald-600 dark:text-emerald-400">
<CheckCircle2 class="h-3.5 w-3.5 shrink-0" />
<span class="truncate" :title="configSaveNotice">{{ configSaveNotice }}</span>
</span>
<span v-else-if="isCreatingConfig" class="text-xs text-muted-foreground">{{ t("nacos.draft") }}</span>
<span v-else class="flex items-center gap-1.5 text-xs text-muted-foreground">
<CheckCircle2 class="h-3.5 w-3.5" />
{{ t("nacos.published") }}
</span>
</div>
</header>
<section v-if="isCreatingConfig" class="nacos-config-identity-grid shrink-0 border-b bg-muted/10 px-3 py-2.5" :aria-label="t('nacos.configIdentity')">
<div class="min-w-0 space-y-1">
<Label :for="`${configWorkbenchId}-data-id`" class="text-[11px] font-medium text-muted-foreground">
<span class="text-destructive">*</span>
{{ t("nacos.dataId") }}
</Label>
<Input :id="`${configWorkbenchId}-data-id`" v-model="selectedConfig.dataId" class="h-8" :placeholder="t('nacos.dataId')" @input="configSaveNotice = ''" />
</div>
<div class="min-w-0 space-y-1">
<Label :for="`${configWorkbenchId}-group`" class="text-[11px] font-medium text-muted-foreground">
<span class="text-destructive">*</span>
{{ t("nacos.group") }}
</Label>
<Input :id="`${configWorkbenchId}-group`" v-model="selectedConfig.group" class="h-8" :placeholder="t('nacos.group')" @input="configSaveNotice = ''" />
</div>
</section>
<section class="nacos-config-inspector shrink-0 border-b">
<button
type="button"
class="flex h-8 w-full items-center justify-between px-3 text-left text-xs font-medium text-muted-foreground transition-colors hover:bg-muted/40 hover:text-foreground"
:aria-expanded="configAdvancedOpen"
:aria-controls="`${configWorkbenchId}-inspector`"
:aria-label="configAdvancedOpen ? t('nacos.collapse') : t('nacos.advanced')"
@click="configAdvancedOpen = !configAdvancedOpen"
>
<span>{{ configAdvancedOpen ? t("nacos.collapse") : t("nacos.advanced") }}</span>
<ChevronDown class="h-3.5 w-3.5 transition-transform" :class="{ 'rotate-180': configAdvancedOpen }" />
</button>
<div v-if="configAdvancedOpen" :id="`${configWorkbenchId}-inspector`" class="nacos-config-inspector-grid border-t bg-muted/10 px-3 py-2.5">
<div class="min-w-0 space-y-1">
<Label :for="`${configWorkbenchId}-tags`" class="text-[11px] font-medium text-muted-foreground">{{ t("nacos.tags") }}</Label>
<Input :id="`${configWorkbenchId}-tags`" v-model="selectedConfig.tags" class="h-8" placeholder="tag1,tag2" :disabled="readOnly" @input="configSaveNotice = ''" />
</div>
<div class="min-w-0 space-y-1">
<Label :for="`${configWorkbenchId}-application`" class="text-[11px] font-medium text-muted-foreground">{{ t("nacos.application") }}</Label>
<Input :id="`${configWorkbenchId}-application`" v-model="selectedConfig.appName" class="h-8" :disabled="readOnly" @input="configSaveNotice = ''" />
</div>
<div class="nacos-config-description min-w-0 space-y-1">
<Label :for="`${configWorkbenchId}-description`" class="text-[11px] font-medium text-muted-foreground">{{ t("nacos.description") }}</Label>
<Input :id="`${configWorkbenchId}-description`" v-model="selectedConfig.desc" class="h-8" :disabled="readOnly" @input="configSaveNotice = ''" />
</div>
</div>
</section>
<div class="nacos-editor-toolbar shrink-0 border-b bg-muted/15 px-3 py-2">
<div class="nacos-editor-toolbar-format flex min-w-0 items-center gap-2">
<span class="shrink-0 text-xs font-semibold">{{ t("nacos.content") }}</span>
<div class="h-4 w-px shrink-0 bg-border" aria-hidden="true" />
<div role="group" class="nacos-config-format-options flex min-w-0 gap-1 overflow-x-auto" :aria-label="t('nacos.format')">
<button
v-for="format in configFormatOptions"
:key="format"
type="button"
class="shrink-0 rounded border px-2 py-0.5 text-[11px] font-medium transition-colors"
:class="configType === format ? 'border-foreground/80 bg-foreground text-background' : 'border-transparent text-muted-foreground hover:border-border hover:bg-background hover:text-foreground'"
:disabled="readOnly"
:aria-pressed="configType === format"
@click="setConfigFormat(format)"
>
{{ configFormatDisplayLabel(format) }}
</button>
</div>
</div>
<div class="nacos-editor-actions min-w-0">
<div class="nacos-editor-actions-secondary flex min-w-0 items-center gap-1.5 overflow-x-auto">
<Button size="sm" variant="outline" class="h-8 shrink-0 gap-1.5 px-2.5" :title="t('nacos.copy')" :aria-label="t('nacos.copy')" @click="copyConfigIdentity">
<Clipboard class="h-3.5 w-3.5" />
<span class="nacos-config-secondary-label">{{ t("nacos.copy") }}</span>
</Button>
<Button size="sm" variant="outline" class="h-8 shrink-0 gap-1.5 px-2.5" :title="t('nacos.export')" :aria-label="t('nacos.export')" @click="exportConfig">
<Download class="h-3.5 w-3.5" />
<span class="nacos-config-secondary-label">{{ t("nacos.export") }}</span>
</Button>
<span class="inline-flex shrink-0" :title="configHistoryUnavailableTitle || t('nacos.history')">
<Button size="sm" variant="outline" class="h-8 gap-1.5 px-2.5" :aria-label="t('nacos.history')" :disabled="!selectedConfigOriginalKey || !supportsConfigHistory" @click="openConfigHistory">
<FileClock class="h-3.5 w-3.5" />
<span class="nacos-config-secondary-label">{{ t("nacos.history") }}</span>
</Button>
</span>
<Button size="sm" variant="outline" class="h-8 shrink-0 gap-1.5 px-2.5" :title="t('nacos.saveAs')" :aria-label="t('nacos.saveAs')" :disabled="readOnly" @click="saveConfigAsCopy">
<Save class="h-3.5 w-3.5" />
<span class="nacos-config-secondary-label">{{ t("nacos.saveAs") }}</span>
</Button>
</div>
<div class="nacos-editor-actions-primary flex shrink-0 items-center gap-1.5 bg-muted/15">
<div class="mx-0.5 h-5 w-px shrink-0 bg-border" aria-hidden="true" />
<Button size="sm" class="h-8 gap-1.5 px-3" :disabled="!canRequestConfigSave || (!isCreatingConfig && !isConfigDirty)" @click="requestSaveConfig">
<Loader2 v-if="savingConfig" class="h-3.5 w-3.5 animate-spin" />
<Send v-else class="h-3.5 w-3.5" />
{{ savingConfig ? t("nacos.saving") : t("nacos.save") }}
</Button>
<Button size="sm" variant="ghost" class="h-8 w-8 p-0 text-muted-foreground hover:bg-destructive/10 hover:text-destructive" :title="t('nacos.delete')" :aria-label="t('nacos.delete')" :disabled="!canRequestConfigDelete || isCreatingConfig" @click="requestDeleteConfig">
<Loader2 v-if="deletingConfig" class="h-3.5 w-3.5 animate-spin" />
<Trash2 v-else class="h-3.5 w-3.5" />
</Button>
</div>
</div>
</div>
</template>
<div v-if="selectedConfig" class="relative min-h-0 flex-1 overflow-hidden bg-background">
<div ref="configEditorHost" class="nacos-config-editor h-full min-h-0 overflow-hidden" />
<EditorSearchPanel ref="configSearchPanelRef" :view="configEditorView" tone="editor" />
</div>
<div v-else class="flex h-full items-center justify-center text-sm text-muted-foreground">{{ t("nacos.selectConfig") }}</div>
</div>
</Pane>
</Splitpanes>
<Splitpanes v-else-if="activeTab === 'services'" class="nacos-admin-splitpanes min-h-0 flex-1" @resized="handleNacosSplitResized">
<Pane :size="nacosSplitSize" min-size="24">
<div class="flex h-full min-h-0 flex-col">
<div class="grid shrink-0 grid-cols-[minmax(0,1fr)_minmax(0,1fr)_auto_auto] gap-2 border-b p-2">
<div class="relative min-w-0">
<Input v-model="serviceName" class="h-8 min-w-0 pr-8" :placeholder="t('nacos.service')" @keyup.enter="loadServicesWithRetry(1)" />
<button
v-if="serviceName"
type="button"
class="absolute right-2 top-1/2 flex h-5 w-5 -translate-y-1/2 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground"
:title="t('nacos.clear')"
:aria-label="t('nacos.clear')"
@click="clearServiceFilter('name')"
>
<X class="h-3.5 w-3.5" />
</button>
</div>
<div class="relative min-w-0">
<Input v-model="serviceGroup" class="h-8 min-w-0 pr-8" :placeholder="t('nacos.allGroups')" @keyup.enter="loadServicesWithRetry(1)" />
<button
v-if="serviceGroup"
type="button"
class="absolute right-2 top-1/2 flex h-5 w-5 -translate-y-1/2 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground"
:title="t('nacos.clear')"
:aria-label="t('nacos.clear')"
@click="clearServiceFilter('group')"
>
<X class="h-3.5 w-3.5" />
</button>
</div>
<Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="readOnly || !createServiceCapability.supported" :title="readOnly || !createServiceCapability.supported ? capabilityReason(createServiceCapability) : undefined" @click="openCreateService">
<Plus class="h-3.5 w-3.5" />
{{ t("nacos.service") }}
</Button>
<Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="servicesLoading" @click="loadServicesWithRetry(1)">
<Loader2 v-if="servicesLoading" class="h-3.5 w-3.5 animate-spin" />
<RefreshCw v-else class="h-3.5 w-3.5" />
{{ t("nacos.load") }}
</Button>
</div>
<div v-if="servicesError" class="border-b px-3 py-2 text-xs text-destructive">{{ servicesError }}</div>
<div class="min-h-0 flex-1 overflow-auto">
<button
v-for="service in services"
:key="`${service.groupName}:${service.serviceName}`"
type="button"
class="grid w-full gap-1 border-b px-3 py-2 text-left text-sm hover:bg-accent/60"
:class="{ 'bg-accent': selectedService?.serviceName === service.serviceName && selectedService?.groupName === service.groupName }"
@click="selectService(service)"
>
<span class="truncate font-medium">{{ service.serviceName }}</span>
<span class="flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
<Server class="h-3.5 w-3.5" />
{{ service.groupName || serviceGroup }}
<span v-if="service.ipCount != null">· {{ t("nacos.instanceCount", { count: service.ipCount }) }}</span>
<span v-if="service.healthyInstanceCount != null">· {{ t("nacos.healthy") }} {{ service.healthyInstanceCount }}</span>
<span v-if="service.clusterCount != null">· {{ t("nacos.cluster") }} {{ service.clusterCount }}</span>
<Badge v-if="service.triggerFlag === 'true'" variant="outline" class="h-5 border-amber-500 text-amber-700">{{ t("nacos.protectionTriggered") }}</Badge>
</span>
</button>
<div v-if="!servicesLoading && services.length === 0" class="flex h-full items-center justify-center text-sm text-muted-foreground">{{ t("nacos.noServices") }}</div>
</div>
<div class="flex shrink-0 items-center justify-between border-t px-3 py-2 text-xs text-muted-foreground">
<span>{{ t("nacos.total", { count: serviceTotal }) }}</span>
<div class="flex items-center gap-2">
<Button size="sm" variant="outline" class="h-7" :disabled="servicePageNo <= 1 || servicesLoading" @click="loadServices(servicePageNo - 1)">{{ t("nacos.prev") }}</Button>
<span>{{ servicePageNo }} / {{ serviceTotalPages }}</span>
<Button size="sm" variant="outline" class="h-7" :disabled="servicePageNo >= serviceTotalPages || servicesLoading" @click="loadServices(servicePageNo + 1)">{{ t("nacos.next") }}</Button>
</div>
</div>
</div>
</Pane>
<Pane :size="100 - nacosSplitSize" min-size="20">
<div class="flex h-full min-h-0 flex-col">
<header class="shrink-0 border-b bg-background">
<div class="flex min-h-16 flex-wrap items-center gap-x-3 gap-y-2 px-4 py-3">
<div class="min-w-0 flex-1">
<div class="truncate text-base font-semibold">{{ selectedService?.serviceName || t("nacos.instances") }}</div>
<div v-if="selectedService" class="mt-1 flex flex-wrap items-center gap-x-2 gap-y-1 text-xs text-muted-foreground">
<span>{{ selectedService.groupName || "DEFAULT_GROUP" }}</span>
<span>· {{ t("nacos.loadedInstances", { count: instances.length }) }}</span>
<Badge v-if="selectedServiceProtectionTriggered" variant="outline" class="h-5 border-amber-500 text-amber-700">{{ t("nacos.protectionTriggered") }}</Badge>
</div>
</div>
<Button size="sm" variant="outline" class="h-8 shrink-0 gap-1.5" :disabled="!selectedService || instancesLoading || serviceDetailLoading" @click="refreshSelectedService">
<Loader2 v-if="instancesLoading" class="h-3.5 w-3.5 animate-spin" />
<RefreshCw v-else class="h-3.5 w-3.5" />
{{ t("nacos.refresh") }}
</Button>
</div>
<div v-if="selectedService" class="flex flex-wrap items-center gap-x-4 gap-y-2 border-t bg-muted/30 px-4 py-2">
<div class="flex shrink-0 items-center gap-1">
<Input v-model="serviceCluster" class="h-8 w-40" :placeholder="t('nacos.filterInstanceCluster')" @keyup.enter="loadInstances" />
<Button size="sm" variant="secondary" class="h-8" :disabled="instancesLoading" @click="loadInstances">{{ t("nacos.filter") }}</Button>
<Button
size="sm"
variant="ghost"
class="h-8 px-2"
:class="{ invisible: !serviceCluster }"
:disabled="instancesLoading || !serviceCluster"
@click="
serviceCluster = '';
loadInstances();
"
>{{ t("nacos.clear") }}</Button
>
</div>
<div class="ml-auto flex flex-wrap items-center gap-2">
<div class="flex items-center gap-1 rounded-md border bg-background p-1">
<span class="px-1 text-xs text-muted-foreground">{{ t("nacos.serviceSettings") }}</span>
<Button
size="sm"
variant="ghost"
class="h-7"
:disabled="readOnly || !updateServiceCapability.supported || serviceEditorLoading"
:title="readOnly || !updateServiceCapability.supported ? capabilityReason(updateServiceCapability) : undefined"
@click="openUpdateService(selectedService)"
>{{ t("nacos.edit") }}</Button
>
<Button
size="sm"
variant="ghost"
class="h-7 text-destructive hover:text-destructive"
:disabled="readOnly || !deleteServiceCapability.supported"
:title="readOnly || !deleteServiceCapability.supported ? capabilityReason(deleteServiceCapability) : undefined"
@click="requestDeleteService(selectedService)"
>{{ t("nacos.delete") }}</Button
>
</div>
<div class="flex items-center gap-1 rounded-md border bg-background p-1">
<span class="px-1 text-xs text-muted-foreground">{{ t("nacos.instances") }}</span>
<Button size="sm" class="h-7" :disabled="readOnly || !registerInstanceCapability.supported" :title="readOnly || !registerInstanceCapability.supported ? capabilityReason(registerInstanceCapability) : undefined" @click="registerInstanceOpen = true">{{
t("nacos.registerInstance")
}}</Button>
</div>
</div>
</div>
</header>
<div v-if="serviceWriteNotice" class="shrink-0 border-b bg-muted/40 px-3 py-2 text-xs text-muted-foreground">
{{ serviceWriteNotice }}
</div>
<div v-if="selectedServiceProtectionTriggered" class="shrink-0 border-b border-amber-200 bg-amber-50 px-3 py-2 text-xs text-amber-900 dark:border-amber-900/60 dark:bg-amber-950/30 dark:text-amber-200">
{{ t("nacos.protectionTriggeredDescription") }}
</div>
<section v-if="selectedService" class="shrink-0 border-b bg-background px-3 py-2">
<button type="button" class="flex w-full items-center justify-between gap-3 text-left" @click="serviceDetailExpanded = !serviceDetailExpanded">
<span class="text-xs font-medium">{{ t("nacos.serviceDetails") }}</span>
<span class="text-xs text-muted-foreground">{{ serviceDetailExpanded ? t("nacos.collapse") : t("nacos.expand") }}</span>
</button>
<div class="mt-2 grid grid-cols-2 gap-2 text-xs sm:grid-cols-4">
<div class="rounded border bg-muted/20 px-2 py-1.5">
<div class="text-muted-foreground">{{ t("nacos.instanceStat") }}</div>
<div class="mt-0.5 font-medium">{{ selectedService.ipCount ?? instances.length }}</div>
</div>
<div class="rounded border bg-muted/20 px-2 py-1.5">
<div class="text-muted-foreground">{{ t("nacos.healthyInstances") }}</div>
<div class="mt-0.5 font-medium">{{ selectedService.healthyInstanceCount ?? instances.filter((instance) => instance.healthy === true).length }}</div>
</div>
<div class="rounded border bg-muted/20 px-2 py-1.5">
<div class="text-muted-foreground">{{ t("nacos.clusterCount") }}</div>
<div class="mt-0.5 font-medium">{{ selectedService.clusterCount ?? new Set(instances.map((instance) => instance.clusterName || "DEFAULT")).size }}</div>
</div>
<div class="rounded border bg-muted/20 px-2 py-1.5">
<div class="text-muted-foreground">{{ t("nacos.protectThreshold") }}</div>
<div class="mt-0.5 font-medium">{{ selectedServiceDetail?.protectThreshold ?? "-" }}</div>
</div>
</div>
<div v-if="serviceDetailExpanded" class="mt-2 grid gap-2 text-xs lg:grid-cols-2">
<div class="min-w-0 rounded border p-2">
<div class="mb-1 flex items-center justify-between text-muted-foreground">
<span>{{ t("nacos.metadataLabel") }}</span
><span>{{ t("nacos.itemCount", { count: selectedServiceDetail?.metadata && typeof selectedServiceDetail.metadata === "object" ? Object.keys(selectedServiceDetail.metadata).length : 0 }) }}</span>
</div>
<pre class="max-h-28 overflow-auto whitespace-pre-wrap break-all rounded bg-muted p-2 font-mono text-[11px]">{{ JSON.stringify(selectedServiceDetail?.metadata ?? {}, null, 2) }}</pre>
</div>
<div class="min-w-0 rounded border p-2">
<div class="mb-1 flex items-center justify-between text-muted-foreground">
<span>{{ t("nacos.selectorLabel") }}</span
><span v-if="selectedServiceDetail?.ephemeral != null">{{ selectedServiceDetail.ephemeral ? t("nacos.temporaryService") : t("nacos.persistent") }}</span>
</div>
<pre class="max-h-28 overflow-auto whitespace-pre-wrap break-all rounded bg-muted p-2 font-mono text-[11px]">{{ JSON.stringify(selectedServiceDetail?.selector ?? {}, null, 2) }}</pre>
</div>
</div>
<div v-if="serviceDetailLoading" class="mt-2 text-xs text-muted-foreground">{{ t("nacos.loadingServiceDetail") }}</div>
<div v-if="serviceDetailError" class="mt-2 flex items-center justify-between gap-2 text-xs text-destructive">
<span>{{ serviceDetailError }}</span>
<Button size="sm" variant="outline" class="h-7 shrink-0" @click="loadServiceDetail">{{ t("nacos.refreshDetail") }}</Button>
</div>
</section>
<div v-if="instancesError" class="border-b px-3 py-2 text-xs text-destructive">{{ instancesError }}</div>
<div class="min-h-0 flex-1 overflow-auto bg-muted/20 p-3">
<div v-if="instances.length" class="space-y-2">
<article v-for="instance in instances" :key="instanceIdentity(instance)" class="rounded-lg border bg-background p-3 shadow-sm">
<div class="flex flex-col gap-3 xl:flex-row xl:items-start xl:justify-between">
<div class="min-w-0 flex-1">
<div class="flex flex-wrap items-center gap-2">
<span class="font-mono text-sm font-medium">{{ instance.ip }}:{{ instance.port }}</span>
<Badge variant="outline">{{ instance.clusterName || "DEFAULT" }}</Badge>
<Badge variant="outline" :class="instance.healthy === false ? 'border-destructive/50 text-destructive' : 'border-emerald-500/50 text-emerald-700 dark:text-emerald-300'">{{ instance.healthy === false ? t("nacos.unhealthy") : t("nacos.healthy") }}</Badge>
<Badge :variant="instance.enabled === false ? 'outline' : 'secondary'" :class="instance.enabled === false ? 'border-muted-foreground/50 text-muted-foreground' : ''">{{ instance.enabled === false ? t("nacos.offline") : t("nacos.enabled") }}</Badge>
<Badge v-if="instance.ephemeral != null" variant="outline">{{ instance.ephemeral ? t("nacos.ephemeral") : t("nacos.persistent") }}</Badge>
</div>
<div class="mt-3 grid gap-x-5 gap-y-3 text-xs sm:grid-cols-[auto_minmax(0,1fr)]">
<div class="flex items-end gap-1 self-start">
<label class="grid gap-1 text-muted-foreground">
<span>{{ t("nacos.weight") }}</span>
<Input
:model-value="instanceWeightDraft(instance)"
type="number"
min="0"
step="0.1"
class="h-7 w-24 text-xs text-foreground"
:disabled="readOnly || !supportsInstanceUpdate || isInstanceUpdating(instance)"
@update:model-value="(value: string | number) => updateInstanceWeightDraft(instance, value)"
/>
</label>
<div v-if="hasInstanceWeightDraft(instance)" class="flex items-end gap-1">
<Button size="sm" class="h-7" :disabled="readOnly || !supportsInstanceUpdate || isInstanceUpdating(instance)" @click="requestInstanceWeightUpdate(instance)">{{ t("nacos.save") }}</Button>
<Button size="sm" variant="ghost" class="h-7 px-2" :disabled="isInstanceUpdating(instance)" @click="resetInstanceWeightDraft(instance)">{{ t("nacos.restore") }}</Button>
</div>
</div>
<details v-if="instance.metadata && Object.keys(instance.metadata).length" class="min-w-0 self-start text-muted-foreground">
<summary class="cursor-pointer select-none hover:text-foreground">{{ t("nacos.metadataLabel") }}({{ t("nacos.itemCount", { count: Object.keys(instance.metadata).length }) }})</summary>
<pre class="mt-1 max-h-32 max-w-full overflow-auto rounded bg-muted p-2 font-mono text-[11px] text-foreground">{{ JSON.stringify(instance.metadata, null, 2) }}</pre>
</details>
<span v-else class="self-start text-muted-foreground">{{ t("nacos.noMetadata") }}</span>
</div>
</div>
<div class="flex shrink-0 flex-wrap items-center gap-2 xl:justify-end">
<Button size="sm" variant="outline" class="h-7" :disabled="readOnly || !supportsInstanceUpdate || isInstanceUpdating(instance)" @click="openInstanceEditor(instance)">{{ t("nacos.edit") }}</Button>
<Button
size="sm"
variant="outline"
class="h-7 gap-1"
:class="instance.enabled === false ? 'border-emerald-500/50 text-emerald-700 hover:bg-emerald-500/10 hover:text-emerald-800 dark:text-emerald-300 dark:hover:text-emerald-200' : 'border-destructive/50 text-destructive hover:bg-destructive/10'"
:disabled="readOnly || !supportsInstanceUpdate || isInstanceUpdating(instance)"
@click="requestUpdateInstance(instance, { enabled: !instance.enabled })"
>
<Loader2 v-if="isInstanceUpdating(instance)" class="h-3 w-3 animate-spin" />
{{ instance.enabled === false ? t("nacos.enable") : t("nacos.disable") }}
</Button>
<Button size="sm" variant="outline" class="h-7" :disabled="readOnly || !supportsInstanceUpdate || isInstanceUpdating(instance)" @click="requestUpdateInstance(instance, { healthy: !instance.healthy })">
{{ instance.healthy === false ? t("nacos.markHealthy") : t("nacos.markUnhealthy") }}
</Button>
<Button
size="sm"
variant="outline"
class="h-7 text-destructive"
:disabled="readOnly || !deregisterInstanceCapability.supported || isInstanceUpdating(instance)"
:title="readOnly || !deregisterInstanceCapability.supported ? capabilityReason(deregisterInstanceCapability) : undefined"
@click="pendingInstanceDeregister = instance"
>{{ t("nacos.deregister") }}</Button
>
</div>
</div>
</article>
</div>
<div v-else class="flex h-full items-center justify-center text-sm text-muted-foreground">{{ selectedService ? t("nacos.noInstances") : t("nacos.selectService") }}</div>
</div>
</div>
</Pane>
</Splitpanes>
<NacosConfigDiffDialog v-model:open="pendingConfigSave" :before="originalConfigContent" :after="configContent" :loading="savingConfig" @confirm="saveConfig" />
<NacosContentSearchDialog
v-model:open="searchOpen"
:loading="searchLoading"
:exporting="searchExportLoading"
:reset-key="searchSessionResetKey"
:result="searchResult"
:progress="searchProgress"
:error="searchError"
@search="searchConfigContent"
@cancel="cancelConfigContentSearch"
@navigate="navigateToContentMatch"
@export="exportContentSearchResults"
@clear="clearContentSearchSession"
/>
<NacosConfigBatchDialog
v-model:open="batchOpen"
:mode="batchMode"
:loading="batchLoading"
:selected-count="selectedConfigCount"
:filtered-count="configTotal"
:target-connections="batchTargetConnections"
:target-connection-id="batchTargetConnectionId"
:source-connection-id="connectionId"
:namespaces="batchTargetNamespaces"
:current-namespace="namespace"
:preview="batchPreview"
:report="batchReport"
:source-name="importSourceName"
:error="batchError"
@choose-file="chooseImportArchive"
@reset="resetBatchDialogState"
@target-connection-change="selectBatchTargetConnection"
@preview="previewBatch"
@apply="applyBatch"
@export="exportConfigArchive"
/>
<NacosConfigHistoryDialog
v-model:open="historyOpen"
:config="selectedConfig"
:items="historyItems"
:loading="historyLoading"
:error="historyError"
:page-no="historyPageNo"
:page-size="historyPageSize"
:total-count="historyTotal"
:read-only="readOnly"
:viewing-item="historyViewingItem"
:viewing-content="historyViewingContent"
:viewing-loading="historyViewingLoading"
@load="loadConfigHistory"
@view="viewConfigHistory"
@close-detail="closeHistoryDetail"
@compare="compareConfigHistory"
@rollback="requestRollbackHistory"
/>
<Dialog v-model:open="rnacosConsoleAuthOpen">
<DialogContent class="sm:max-w-md">
<DialogHeader>
<DialogTitle>{{ t("nacos.rnacosConsoleAuthTitle") }}</DialogTitle>
<DialogDescription>{{ t("nacos.rnacosConsoleAuthDescription") }}</DialogDescription>
</DialogHeader>
<div class="space-y-3">
<img v-if="rnacosConsoleCaptchaImage" :src="rnacosConsoleCaptchaImage" :alt="t('nacos.rnacosCaptchaLabel')" class="h-28 w-full rounded-md border bg-muted/30 object-contain" />
<div class="space-y-1.5">
<Label for="rnacos-console-captcha">{{ t("nacos.rnacosCaptchaLabel") }}</Label>
<Input id="rnacos-console-captcha" v-model="rnacosConsoleCaptcha" autocomplete="off" :placeholder="t('nacos.rnacosCaptchaPlaceholder')" @keyup.enter="submitRNacosConsoleAuthentication" />
</div>
<p v-if="rnacosConsoleAuthError" class="text-xs text-destructive">{{ rnacosConsoleAuthError }}</p>
</div>
<DialogFooter>
<Button variant="outline" :disabled="rnacosConsoleAuthLoading" @click="requestRNacosConsoleAuthentication">{{ t("nacos.rnacosRefreshCaptcha") }}</Button>
<Button :disabled="rnacosConsoleAuthLoading" @click="submitRNacosConsoleAuthentication">
<Loader2 v-if="rnacosConsoleAuthLoading" class="mr-2 h-4 w-4 animate-spin" />
{{ t("nacos.rnacosConsoleAuthSubmit") }}
</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<NacosConfigDiffDialog
v-model:open="historyCompareOpen"
:title="t('nacos.historyCompareTitle')"
:before-label="t('nacos.currentPublishedContent')"
:after-label="t('nacos.historyVersionContent')"
:before="historyCompareCurrent"
:after="historyCompareContent"
:loading="historyCompareLoading"
:show-confirm="!readOnly"
:confirm-label="t('nacos.rollback')"
confirm-variant="destructive"
@confirm="requestRollbackComparedHistory"
/>
<Dialog v-model:open="serviceEditorOpen">
<DialogContent class="sm:max-w-xl" @pointer-down-outside.prevent @interact-outside.prevent @escape-key-down.prevent>
<DialogHeader>
<DialogTitle>{{ serviceEditorMode === "create" ? t("nacos.createNacosService") : t("nacos.editNacosService") }}</DialogTitle>
<DialogDescription>{{ t("nacos.manageServiceMetadata") }}</DialogDescription>
</DialogHeader>
<div class="grid gap-3 sm:grid-cols-2">
<div class="space-y-1.5">
<Label>{{ t("nacos.serviceName") }}</Label
><Input v-model="serviceEditor.serviceName" :disabled="serviceEditorMode === 'update'" />
</div>
<div class="space-y-1.5">
<Label>{{ t("nacos.groupName") }}</Label
><Input v-model="serviceEditor.groupName" :disabled="serviceEditorMode === 'update'" />
</div>
<div class="space-y-1.5">
<Label>{{ t("nacos.protectThreshold") }}</Label
><Input v-model="serviceEditor.protectThreshold" inputmode="decimal" :placeholder="t('nacos.thresholdExample')" />
</div>
<div class="space-y-1.5">
<Label>{{ t("nacos.metadataLabel") }}({{ t("nacos.jsonObject") }})</Label><textarea v-model="serviceEditor.metadata" class="min-h-24 w-full rounded-md border bg-background p-2 font-mono text-xs" />
</div>
<div class="space-y-1.5 sm:col-span-2">
<Label>{{ t("nacos.selectorLabel") }}({{ t("nacos.optionalJsonObject") }})</Label><textarea v-model="serviceEditor.selector" class="min-h-20 w-full rounded-md border bg-background p-2 font-mono text-xs" />
</div>
<p v-if="serviceEditorError" class="text-xs text-destructive sm:col-span-2">{{ serviceEditorError }}</p>
</div>
<DialogFooter
><Button variant="outline" :disabled="serviceEditorLoading" @click="serviceEditorOpen = false">{{ t("nacos.cancel") }}</Button
><Button :disabled="serviceEditorLoading" @click="submitServiceEditor"><Loader2 v-if="serviceEditorLoading" class="mr-2 h-4 w-4 animate-spin" />{{ t("nacos.save") }}</Button></DialogFooter
>
</DialogContent>
</Dialog>
<Dialog v-model:open="registerInstanceOpen">
<DialogContent class="sm:max-w-lg" @pointer-down-outside.prevent @interact-outside.prevent @escape-key-down.prevent>
<DialogHeader
><DialogTitle>{{ t("nacos.registerPersistentInstance") }}</DialogTitle
><DialogDescription>{{ t("nacos.persistentInstanceHint") }}</DialogDescription></DialogHeader
>
<div class="grid gap-3 sm:grid-cols-2">
<div class="space-y-1.5">
<Label>{{ t("nacos.ipAddress") }}</Label
><Input v-model="registerInstance.ip" />
</div>
<div class="space-y-1.5">
<Label>{{ t("nacos.port") }}</Label
><Input v-model="registerInstance.port" type="number" min="1" max="65535" />
</div>
<div class="space-y-1.5">
<Label>{{ t("nacos.cluster") }}</Label
><Input v-model="registerInstance.clusterName" />
</div>
<div class="space-y-1.5">
<Label>{{ t("nacos.weight") }}</Label
><Input v-model="registerInstance.weight" type="number" min="0" step="0.1" />
</div>
<div class="space-y-1.5 sm:col-span-2">
<Label>{{ t("nacos.metadataLabel") }}({{ t("nacos.jsonObject") }})</Label><textarea v-model="registerInstance.metadata" class="min-h-20 w-full rounded-md border bg-background p-2 font-mono text-xs" />
</div>
<p v-if="registerInstanceError" class="text-xs text-destructive sm:col-span-2">{{ registerInstanceError }}</p>
</div>
<DialogFooter
><Button variant="outline" :disabled="registeringInstance" @click="registerInstanceOpen = false">{{ t("nacos.cancel") }}</Button
><Button :disabled="registeringInstance" @click="submitInstanceRegistration"><Loader2 v-if="registeringInstance" class="mr-2 h-4 w-4 animate-spin" />{{ t("nacos.registerInstance") }}</Button></DialogFooter
>
</DialogContent>
</Dialog>
<Dialog v-model:open="instanceEditorOpen">
<DialogContent class="sm:max-w-lg" @pointer-down-outside.prevent @interact-outside.prevent @escape-key-down.prevent>
<DialogHeader>
<DialogTitle>{{ t("nacos.instanceEditorTitle") }}</DialogTitle>
<DialogDescription>{{ instanceEditorTarget ? `${instanceEditorTarget.ip}:${instanceEditorTarget.port} · ${instanceEditorTarget.clusterName || "DEFAULT"}` : "" }}</DialogDescription>
</DialogHeader>
<div class="grid gap-3">
<div class="space-y-1.5">
<Label>{{ t("nacos.weight") }}</Label>
<Input v-model="instanceEditor.weight" type="number" min="0" step="0.1" />
</div>
<div class="space-y-1.5">
<Label>{{ t("nacos.metadataLabel") }}({{ t("nacos.jsonObject") }})</Label>
<textarea v-model="instanceEditor.metadata" class="min-h-36 w-full rounded-md border bg-background p-2 font-mono text-xs" />
</div>
<p v-if="instanceEditorError" class="text-xs text-destructive">{{ instanceEditorError }}</p>
</div>
<DialogFooter>
<Button variant="outline" @click="instanceEditorOpen = false">{{ t("nacos.cancel") }}</Button>
<Button @click="submitInstanceEditor">{{ t("nacos.save") }}</Button>
</DialogFooter>
</DialogContent>
</Dialog>
<DangerConfirmDialog
:open="!!pendingDeleteConfig"
:title="t('nacos.confirmDeleteTitle')"
:message="t('nacos.confirmDeleteMessage')"
:details="pendingDeleteDetails"
:confirm-label="t('nacos.delete')"
:loading="deletingConfig"
:close-on-confirm="false"
@update:open="
(value: boolean) => {
if (!value && !deletingConfig) pendingDeleteConfig = null;
}
"
@confirm="deleteConfig"
/>
<DangerConfirmDialog
:open="!!pendingBatchDelete"
:title="t('nacos.batchDeleteTitle')"
:message="t('nacos.batchDeleteConfirm', { count: pendingBatchDelete?.keys.length || 0 })"
:details="pendingBatchDeleteDetails"
:confirm-label="t('nacos.batchDelete')"
:loading="deletingConfig"
:close-on-confirm="false"
@update:open="
(value: boolean) => {
if (!value && !deletingConfig) pendingBatchDelete = null;
}
"
@confirm="deleteSelectedConfigs"
/>
<DangerConfirmDialog
:open="!!pendingHistoryRollback"
:title="t('nacos.confirmRollbackTitle')"
:message="t('nacos.confirmRollbackMessage')"
:details="pendingHistoryRollbackDetails"
:confirm-label="t('nacos.rollback')"
:loading="rollingBackHistory"
:close-on-confirm="false"
@update:open="
(value: boolean) => {
if (!value && !rollingBackHistory) pendingHistoryRollback = null;
}
"
@confirm="rollbackConfigHistory"
/>
<DangerConfirmDialog
:open="!!pendingInstanceUpdate"
:title="t('nacos.confirmInstanceTitle')"
:message="t('nacos.confirmInstanceMessage')"
:details="pendingInstanceDetails"
:confirm-label="t('dangerDialog.confirm')"
:loading="pendingInstanceUpdate ? isInstanceUpdating(pendingInstanceUpdate.instance) : false"
:close-on-confirm="false"
@update:open="
(value: boolean) => {
if (!value && (!pendingInstanceUpdate || !isInstanceUpdating(pendingInstanceUpdate.instance))) pendingInstanceUpdate = null;
}
"
@confirm="pendingInstanceUpdate && updateInstance(pendingInstanceUpdate.instance, pendingInstanceUpdate.patch)"
/>
<DangerConfirmDialog
:open="!!pendingServiceDelete"
:title="t('nacos.deleteNacosService')"
:message="t('nacos.confirmEmptyServiceDelete')"
:details="pendingServiceDelete ? `${pendingServiceDelete.groupName || 'DEFAULT_GROUP'}@@${pendingServiceDelete.serviceName}` : ''"
:confirm-label="t('nacos.delete')"
:loading="deletingService"
:close-on-confirm="false"
@update:open="
(value: boolean) => {
if (!value && !deletingService) pendingServiceDelete = null;
}
"
@confirm="pendingServiceDelete && deleteService(pendingServiceDelete)"
/>
<DangerConfirmDialog
:open="!!pendingInstanceDeregister"
:title="t('nacos.deregisterNacosInstance')"
:message="t('nacos.confirmInstanceDeregister')"
:details="pendingInstanceDeregisterDetails"
:confirm-label="t('nacos.deregister')"
:loading="pendingInstanceDeregister ? isInstanceUpdating(pendingInstanceDeregister) : false"
:close-on-confirm="false"
@update:open="
(value: boolean) => {
if (!value && (!pendingInstanceDeregister || !isInstanceUpdating(pendingInstanceDeregister))) pendingInstanceDeregister = null;
}
"
@confirm="pendingInstanceDeregister && deregisterInstance(pendingInstanceDeregister)"
/>
</div>
</template>
<style scoped>
.nacos-config-editor :deep(.cm-content),
.nacos-config-editor :deep(.cm-line) {
cursor: text;
user-select: text !important;
-webkit-user-select: text !important;
}
.nacos-config-editor :deep(.cm-selectionBackground),
.nacos-config-editor :deep(.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground),
.nacos-config-editor :deep(.cm-trimmedSelection) {
display: block !important;
background: var(--dbx-editor-selection-background, rgba(59, 130, 246, 0.35)) !important;
}
.nacos-config-editor :deep(.cm-content ::selection) {
background: var(--dbx-editor-selection-background, rgba(59, 130, 246, 0.35)) !important;
}
.nacos-config-workbench {
container-type: inline-size;
}
.nacos-config-context-bar {
display: flex;
align-items: center;
justify-content: space-between;
gap: 0.75rem;
}
.nacos-config-identity-grid,
.nacos-config-inspector-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(min(100%, 13rem), 1fr));
gap: 0.625rem 0.75rem;
}
.nacos-editor-toolbar {
display: grid;
gap: 0.5rem;
}
.nacos-editor-actions {
display: grid;
grid-template-columns: minmax(0, 1fr) auto;
align-items: center;
gap: 0.375rem;
}
.nacos-config-format-options,
.nacos-editor-actions-secondary {
scrollbar-width: thin;
}
@container (min-width: 960px) {
.nacos-config-inspector-grid {
grid-template-columns: repeat(4, minmax(0, 1fr));
}
.nacos-config-description {
grid-column: span 2;
}
.nacos-editor-toolbar {
grid-template-columns: minmax(0, 1fr) auto;
align-items: center;
}
}
@container (max-width: 620px) {
.nacos-config-context-bar {
align-items: flex-start;
}
.nacos-config-state {
padding-top: 0.25rem;
}
.nacos-editor-actions-secondary,
.nacos-config-format-options {
padding-bottom: 0.125rem;
}
}
@container (max-width: 480px) {
.nacos-config-secondary-label {
display: none;
}
}
.nacos-admin-splitpanes :deep(.splitpanes--vertical > .splitpanes__splitter) {
width: 4px !important;
border-left: 1px solid var(--border);
background: transparent;
cursor: col-resize;
}
.nacos-admin-splitpanes :deep(.splitpanes__splitter:hover) {
background: oklch(0.6 0.15 250) !important;
}
.nacos-config-list-viewport {
scrollbar-gutter: stable;
}
</style>