Vydané zdroje

CH-J Tools

Procházejte adresáře a soubory konkrétního vydání aplikace.

Stáhnout zdroje ZIP

CH-J / Server Manager 872 souborů

core-20261030T220507Z-61e4558d889f Přidáno: 31. 10. 2026 0:29 · Sestaveno: 30. 10. 2026 23:05

index.js Přidáno: Datum není evidováno 13,8 KB · 215 řádků

Kód Stáhnout soubor

1"use strict";

3const api = window.chjPlugin;

4const i18n = window.chjPluginI18n.createI18n("cs");

5const t = i18n.t;

6let endedSessionId = "";

7let sessionsLoading = false;

9// Guard every continuation, including sudo retries and dialog answers, against a server switch.

10async function sessionResult(promise, token) {

11 const value = await promise;

12 if (token !== generation) throw new Error("CHJ_SESSION_CHANGED");

13 return value;

14}

16const elements = Object.fromEntries([

  "pluginVersion", "closeButton", "sessionSelect", "refreshButton", "sudoPassword", "testButton", "reloadButton", "status",

18 "nginxVersion", "serviceState", "mainConfig", "configCount", "dumpButton", "configFilter", "configList", "editorMode",

19 "editorTitle", "editorMeta", "revertButton", "saveButton", "configEditor", "commandOutput", "clearOutputButton"

20].map((id) => [id, document.querySelector(`#${id}`)]));

22let sessions = [];

23let inspection = null;

24let selectedPath = "";

25let selectedKind = "";

26let originalText = "";

27let busy = false;

28let generation = 0;

29let sessionId = "";

30let editorSessionId = "";

31let disconnectedDraft = false;

33// Rebuilds the line under the editor title after a language change.

34let editorMetaText = null;

function selectedSession() { return sessions.find((session) => session.sessionId === elements.sessionSelect.value) || null; }

36function sudoPassword() { return elements.sudoPassword.value; }

function setStatus(message, error = false) { elements.status.textContent = message; elements.status.classList.toggle("error", error); }

function setOutput(text, error = false) { elements.commandOutput.textContent = String(text || "—"); elements.commandOutput.classList.toggle("error", error); }

function isDirty() { return disconnectedDraft || (Boolean(selectedPath) && elements.configEditor.value !== originalText); }

40function selectedWritable() { return selectedKind === "file" && Boolean(selectedPath); }

42function syncControls() {

43 const connected = Boolean(elements.sessionSelect.value);

44 elements.sessionSelect.disabled = busy;

45 elements.refreshButton.disabled = busy;

46 elements.testButton.disabled = busy || !connected || !inspection?.installed;

47 elements.reloadButton.disabled = busy || !connected || !inspection?.installed;

48 elements.dumpButton.disabled = busy || !connected || !inspection?.installed;

49 elements.revertButton.disabled = busy || !selectedPath;

50 elements.saveButton.disabled = busy || !selectedWritable() || !isDirty();

51 elements.configEditor.readOnly = busy || !selectedWritable();

52}

54function setBusy(value) { busy = value; syncControls(); }

56function renderIdentity() {

  elements.nginxVersion.textContent = inspection?.installed ? (inspection.version || t("nainstalován")) : t("nenalezen");

58 elements.serviceState.textContent = inspection?.serviceState || "—";

59 elements.serviceState.className = inspection?.serviceState === "active" ? "state-active" : "state-inactive";

60 elements.mainConfig.textContent = inspection?.configPath || "—";

61 elements.mainConfig.title = inspection?.configPath || "";

62 elements.configCount.textContent = String(inspection?.configs?.length || 0);

63}

65function renderConfigList() {

66 const query = elements.configFilter.value.trim().toLowerCase();

67 const files = (inspection?.configs || []).filter((item) => item.path.toLowerCase().includes(query));

68 const fragment = document.createDocumentFragment();

69 for (const file of files) {

70 const button = document.createElement("button");

71 button.type = "button";

72 button.className = `config-item${file.path === selectedPath ? " active" : ""}`;

73 button.dataset.path = file.path;

74 button.dataset.kind = file.kind;

75 const path = document.createElement("span"); path.textContent = file.path;

    const type = document.createElement("small"); type.textContent = file.kind === "symlink" ? t("symlink · pouze čtení") : t("soubor");

77 button.append(path, type); fragment.append(button);

78 }

79 elements.configList.replaceChildren(fragment);

  if (!files.length) { const empty = document.createElement("p"); empty.className = "empty"; empty.textContent = t("Filtru neodpovídá žádný konfigurační soubor."); elements.configList.replaceChildren(empty); }

81}

83function resetSession(id) {

84 generation += 1; sessionId = id; editorSessionId = ""; disconnectedDraft = false;

85 inspection = null; selectedPath = ""; selectedKind = ""; originalText = "";

86 elements.configEditor.value = ""; elements.sudoPassword.value = "";

87 elements.editorTitle.textContent = "—"; elements.editorMeta.textContent = ""; editorMetaText = null;

88 elements.configFilter.value = ""; setOutput("");

89 renderIdentity(); renderConfigList(); setBusy(false);

90}

92async function loadSessions() {

93 if (sessionsLoading) return;

94 sessionsLoading = true;

95 try {

96 sessions = (await api.sessions.list()).filter((session) => session.state === "connected");

97 const next = api.sessions.reconcile(endedSessionId || sessionId, sessions);

    elements.sessionSelect.replaceChildren(new Option(sessions.length ? t("Vyberte relaci…") : t("Žádná připojená relace"), ""));

    for (const session of sessions) elements.sessionSelect.add(new Option(api.sessions.displayName(session), session.sessionId));

100 elements.sessionSelect.value = next.id;

101 if (next.reason === "choose") api.sessions.offerChoice(elements.sessionSelect, sessions, t("Vyberte relaci…"));

102 if (next.reason === "gone") endedSessionId ||= sessionId;

103 if (next.id !== sessionId) {

104 // A disconnected editor stays available for copying unsaved text, but cannot save.

105 const draft = isDirty() ? elements.configEditor.value : null;

106 resetSession(next.id);

107 if (draft !== null) { elements.configEditor.value = draft; disconnectedDraft = true; }

108 if (next.id) void inspect();

109 }

110 if (next.reason === "gone") setStatus(t("Relace skončila. Vyberte server."), true);

111 } finally { sessionsLoading = false; }

112}

113

114async function inspect() {

115 const requestGeneration = generation;

116

  if (!elements.sessionSelect.value) { inspection = null; renderIdentity(); renderConfigList(); syncControls(); return; }

117 setBusy(true); setStatus(t("Zjišťuji instalaci, službu a konfigurační soubory NGINX…"));

118 try {

119 inspection = await sessionResult(api.nginx.inspect(elements.sessionSelect.value), requestGeneration);

120 renderIdentity(); renderConfigList();

121

    setStatus(inspection.installed ? t("NGINX {version} je dostupný; nalezeno {count} souborů.", { version: inspection.version || "", count: inspection.configs.length }) : t("NGINX nebyl na serveru nalezen."), !inspection.installed);

122

  } catch (error) { if (requestGeneration !== generation) return; inspection = null; renderIdentity(); renderConfigList(); setStatus(error?.message || String(error), true); }

123 finally { if (requestGeneration === generation) { setBusy(false);} }

124}

125

126async function readConfig(path, kind) {

127 const requestGeneration = generation;

128 if (isDirty() && !window.confirm(t("Zahodit neuložené změny aktuální konfigurace?"))) return;

129 setBusy(true); setStatus(t("Načítám {path}…", { path }));

130 try {

131

    const result = await sessionResult(api.nginx.readConfig(elements.sessionSelect.value, { path, sudoPassword: sudoPassword() }), requestGeneration);

132 editorSessionId = sessionId; selectedPath = result.path; selectedKind = kind; originalText = result.text;

133 elements.configEditor.value = result.text;

134 elements.editorMode.textContent = kind === "symlink" ? t("NÁHLED SYMLINKU") : t("EDITOR");

135 elements.editorTitle.textContent = result.path;

136

    editorMetaText = () => `${result.size.toLocaleString(i18n.locale())} B · ${kind === "symlink" ? t("upravte zdroj v sites-available") : t("změny se ukládají se zálohou")}`;

137 elements.editorMeta.textContent = editorMetaText();

138 renderConfigList(); setStatus(t("Konfigurace byla načtena."));

139 } catch (error) { if (requestGeneration !== generation) return; setStatus(error?.message || String(error), true); }

140 finally { if (requestGeneration === generation) { elements.sudoPassword.value = ""; setBusy(false);} }

141}

142

143async function runTest() {

144 const requestGeneration = generation;

145 setBusy(true); setStatus(t("Spouštím nginx -t…"));

146 try {

147

    const result = await sessionResult(api.nginx.testConfig(elements.sessionSelect.value, sudoPassword()), requestGeneration);

148

    setOutput(result.output, !result.ok); setStatus(result.ok ? t("Konfigurace NGINX je platná.") : t("Test konfigurace selhal."), !result.ok);

149

  } catch (error) { if (requestGeneration !== generation) return; setOutput(error?.message || String(error), true); setStatus(error?.message || String(error), true); }

150 finally { if (requestGeneration === generation) { elements.sudoPassword.value = ""; setBusy(false);} }

151}

152

153async function dumpEffectiveConfig() {

154 const requestGeneration = generation;

155 if (isDirty() && !window.confirm(t("Zahodit neuložené změny a zobrazit efektivní konfiguraci?"))) return;

156 setBusy(true); setStatus(t("Načítám efektivní konfiguraci pomocí nginx -T…"));

157 try {

158

    const result = await sessionResult(api.nginx.dumpConfig(elements.sessionSelect.value, sudoPassword()), requestGeneration);

159 selectedPath = ""; selectedKind = ""; originalText = result.text; elements.configEditor.value = result.text;

160 elements.editorMode.textContent = t("EFEKTIVNÍ KONFIGURACE"); elements.editorTitle.textContent = "nginx -T";

161

    editorMetaText = () => t("Kombinovaný výstup je pouze pro čtení."); elements.editorMeta.textContent = editorMetaText(); renderConfigList(); setStatus(t("Efektivní konfigurace byla načtena."));

162

  } catch (error) { if (requestGeneration !== generation) return; setOutput(error?.message || String(error), true); setStatus(error?.message || String(error), true); }

163 finally { if (requestGeneration === generation) { elements.sudoPassword.value = ""; setBusy(false);} }

164}

165

166async function saveConfig() {

167 const requestGeneration = generation;

168 if (!selectedWritable() || !isDirty()) return;

169

  if (!window.confirm(`${api.sessions.displayName(selectedSession())}\n\n${t("Uložit {path}, vytvořit zálohu a spustit nginx -t? Neplatná konfigurace se automaticky vrátí.", { path: selectedPath })}`)) return;

170 setBusy(true); setStatus(t("Ukládám zálohu a ověřuji novou konfiguraci…"));

171 try {

172

    const result = await sessionResult(api.nginx.saveConfig(editorSessionId, { path: selectedPath, text: elements.configEditor.value, sudoPassword: sudoPassword() }), requestGeneration);

173

    originalText = elements.configEditor.value; setOutput(`${result.testOutput}\n\n${t("Záloha: {path}", { path: result.backupPath })}`); setStatus(t("Konfigurace byla uložena a nginx -t uspěl. Reload zatím nebyl proveden."));

174

  } catch (error) { if (requestGeneration !== generation) return; setOutput(error?.message || String(error), true); setStatus(error?.message || String(error), true); }

175 finally { if (requestGeneration === generation) { elements.sudoPassword.value = ""; setBusy(false);} }

176}

177

178async function reloadNginx() {

179 const requestGeneration = generation;

180 if (isDirty()) { setStatus(t("Nejprve uložte nebo zahoďte neuložené změny."), true); return; }

181

  if (!window.confirm(`${api.sessions.displayName(selectedSession())}\n\n${t("Provést graceful reload NGINX? Core před reloadem znovu spustí nginx -t.")}`)) return;

182 setBusy(true); setStatus(t("Ověřuji konfiguraci a provádím graceful reload…"));

183 try {

184

    const result = await sessionResult(api.nginx.reload(elements.sessionSelect.value, sudoPassword(), true), requestGeneration);

185

    setOutput(result.output); setStatus(t("NGINX byl bezpečně reloadován.")); await sessionResult(inspect(), requestGeneration);

186

  } catch (error) { if (requestGeneration !== generation) return; setOutput(error?.message || String(error), true); setStatus(error?.message || String(error), true); }

187 finally { if (requestGeneration === generation) { elements.sudoPassword.value = ""; setBusy(false);} }

188}

189

190elements.closeButton.addEventListener("click", () => api.close());

191elements.refreshButton.addEventListener("click", async () => { await loadSessions(); await inspect(); });

192elements.sessionSelect.addEventListener("change", async () => {

193

  if ((isDirty() || (!sessionId && elements.configEditor.value)) && !window.confirm(t("Zahodit neuložené změny aktuální konfigurace?"))) { elements.sessionSelect.value = sessionId; return; }

194 endedSessionId = ""; resetSession(elements.sessionSelect.value); await inspect();

195});

196elements.configFilter.addEventListener("input", renderConfigList);

197

elements.configList.addEventListener("click", (event) => { const item = event.target.closest("button[data-path]"); if (item) void readConfig(item.dataset.path, item.dataset.kind); });

198elements.configEditor.addEventListener("input", syncControls);

199

elements.revertButton.addEventListener("click", () => { if (selectedPath) void readConfig(selectedPath, selectedKind); });

200elements.saveButton.addEventListener("click", saveConfig);

201elements.testButton.addEventListener("click", runTest);

202elements.dumpButton.addEventListener("click", dumpEffectiveConfig);

203elements.reloadButton.addEventListener("click", reloadNginx);

204elements.clearOutputButton.addEventListener("click", () => setOutput(""));

205

window.addEventListener("beforeunload", (event) => { if (isDirty()) { event.preventDefault(); event.returnValue = ""; } });

206

207(async () => {

208 try { i18n.setLanguage(await api.ui.getLanguage()); } catch {}

209 i18n.apply(document);

210

  api.ui.onLanguageChanged((language) => { i18n.setLanguage(language); i18n.apply(document); renderIdentity(); renderConfigList(); if (editorMetaText) { elements.editorMeta.textContent = editorMetaText(); elements.editorMode.textContent = selectedKind === "symlink" ? t("NÁHLED SYMLINKU") : t("EDITOR"); } });

211

  const info = await api.getInfo(); elements.pluginVersion.textContent = `${info.name} v${info.version} · ${info.publisher}`;

212 await loadSessions(); await inspect();

213})().catch((error) => setStatus(error?.message || String(error), true));

214

215setInterval(() => { if (!document.hidden) void loadSessions().catch(() => {}); }, 3000);

216

SHA-256

0cd074a56f4621ca05973f8c8545ffc9e44a716317614c673e9dee2b415a1011

CH-J Proprietary Software License 1.14 · Zdroje jsou zveřejněny pod CH-J Proprietary Software License 1.14. Jejich dostupnost nemění licenční podmínky ani neposkytuje další oprávnění.

SHA-256 archivu

77380d4805485ffa4027fbe7858b5836f197a4aa9d52358a43e2d12d018744df