Julkaistu lähde

CH-J Server Manager

Selaile hakemistoja ja tiedostoja tietyn sovelluksen julkaisua varten.

Lataa lähde ZIP

CH-J / Server Manager 377 tiedostot

core-20261019T111616Z-160a00bfcddc Lisätty: 19.10.2026 klo 22.11 · Rakennettu: 19.10.2026 klo 13.16

pluginPreload.js Lisätty: Kirjaamaton päivä 10,4 KB · 162 rivit

Koodi Lataa tiedosto

1"use strict";

3const { contextBridge, ipcRenderer } = require("electron");

5// Core provides the same chrome to bundled and already installed plugins.

6// Shadow DOM keeps plugin styles out of the title bar; the plugin remains sandboxed.

7window.addEventListener("DOMContentLoaded", () => {

8 const styleUrl = new URL("/__chj_core__/window-chrome.css", window.location.href).href;

9 const host = document.createElement("chj-plugin-chrome");

10 host.id = "chj-plugin-window-chrome";

11 const shadow = host.attachShadow({ mode: "open" });

12 let loadedStyles = 0;

13 const stylesheet = () => {

14 const link = document.createElement("link");

15 link.rel = "stylesheet";

16 link.href = styleUrl;

17 link.addEventListener("load", () => {

18 if (++loadedStyles === 2) host.dataset.ready = "true";

19 });

20 return link;

21 };

22 document.head.append(stylesheet());

23 const header = document.createElement("header");

24 header.id = "chj-chrome-header";

25 if (process.platform === "win32" || process.platform === "linux") header.className = "native-controls";

26 const mark = document.createElement("span");

27 mark.id = "chj-chrome-mark";

28 mark.textContent = "CH-J";

29 const title = document.createElement("span");

30 title.id = "chj-chrome-title";

31 title.textContent = document.title || "CH-J Server Manager";

32 const collapse = document.createElement("button");

33 collapse.type = "button";

34 collapse.id = "chj-chrome-collapse";

35 const copy = {

36 cs: ["Sbalit", "Sbalit do spodní lišty aplikace"],

37 de: ["Einklappen", "In die untere Leiste der Anwendung einklappen"],

38 en: ["Collapse", "Collapse into the application's bottom bar"]

39 };

40 const translate = (language) => {

41 const [label, description] = copy[language] || copy.en;

42 collapse.textContent = label;

43 collapse.title = description;

44 collapse.setAttribute("aria-label", description);

45 };

46 translate("en");

47 collapse.addEventListener("click", () => {

48 void ipcRenderer.invoke("plugin:window:minimize").catch((error) => console.error("Plugin collapse failed.", error));

49 });

50 ipcRenderer.on("plugin:ui:languageChanged", (_event, language) => translate(language));

51 void ipcRenderer.invoke("plugin:ui:getLanguage").then(translate).catch(() => {});

52 void ipcRenderer.invoke("plugin:getInfo").then((manifest) => { title.textContent = manifest.name; }).catch(() => {});

53 header.append(mark, title, collapse);

54 shadow.append(stylesheet(), header);

55 document.body.prepend(host);

56});

58contextBridge.exposeInMainWorld("chjPlugin", Object.freeze({

59 getInfo: () => ipcRenderer.invoke("plugin:getInfo"),

60 ui: Object.freeze({

61 getLanguage: () => ipcRenderer.invoke("plugin:ui:getLanguage"),

62 onLanguageChanged: (callback) => {

63 if (typeof callback !== "function") throw new TypeError("Language callback must be a function.");

64 const listener = (_event, language) => callback(language);

65 ipcRenderer.on("plugin:ui:languageChanged", listener);

66 return () => ipcRenderer.removeListener("plugin:ui:languageChanged", listener);

67 }

68 }),

69 close: () => ipcRenderer.invoke("plugin:close"),

70 sessions: Object.freeze({

71 list: () => ipcRenderer.invoke("plugin:sessions:list")

72 }),

73 system: Object.freeze({

74 readMetrics: (sessionId) => ipcRenderer.invoke("plugin:system:metrics", { sessionId }),

    virtualMemory: (sessionId, options = {}) => ipcRenderer.invoke("plugin:system:virtualMemory", { ...options, sessionId }),

    manageVirtualMemory: (sessionId, payload) => ipcRenderer.invoke("plugin:system:manageVirtualMemory", { ...payload, sessionId })

77 }),

78 keys: Object.freeze({

79 generate: (payload) => ipcRenderer.invoke("plugin:keys:generate", payload),

80 save: (generationId) => ipcRenderer.invoke("plugin:keys:save", { generationId })

81 }),

82 logs: Object.freeze({

83 read: (options) => ipcRenderer.invoke("plugin:logs:read", options)

84 }),

85 users: Object.freeze({

86 list: (sessionId) => ipcRenderer.invoke("plugin:users:list", { sessionId }),

87 manage: (sessionId, payload) => ipcRenderer.invoke("plugin:users:manage", { ...payload, sessionId }),

88 privileges: (sessionId, refresh = false) => ipcRenderer.invoke("plugin:users:privileges", { sessionId, refresh }),

89 inventory: (sessionId, options = {}) => ipcRenderer.invoke("plugin:users:inventory", { ...options, sessionId }),

    detail: (sessionId, username, options = {}) => ipcRenderer.invoke("plugin:users:detail", { ...options, sessionId, username }),

91 keys: (sessionId, payload) => ipcRenderer.invoke("plugin:users:keys", { ...payload, sessionId }),

92 sshPolicy: (sessionId, payload) => ipcRenderer.invoke("plugin:users:sshPolicy", { ...payload, sessionId })

93 }),

94 nginx: Object.freeze({

95 inspect: (sessionId) => ipcRenderer.invoke("plugin:nginx:inspect", { sessionId }),

96 readConfig: (sessionId, payload) => ipcRenderer.invoke("plugin:nginx:readConfig", { ...payload, sessionId }),

97 dumpConfig: (sessionId, sudoPassword) => ipcRenderer.invoke("plugin:nginx:dumpConfig", { sessionId, sudoPassword }),

98 testConfig: (sessionId, sudoPassword) => ipcRenderer.invoke("plugin:nginx:testConfig", { sessionId, sudoPassword }),

99 saveConfig: (sessionId, payload) => ipcRenderer.invoke("plugin:nginx:saveConfig", { ...payload, sessionId }),

100

    reload: (sessionId, sudoPassword, confirm = false) => ipcRenderer.invoke("plugin:nginx:reload", { sessionId, sudoPassword, confirm })

101 }),

102 files: Object.freeze({

103 list: (sessionId, path, options = {}) => ipcRenderer.invoke("plugin:files:list", { sessionId, path, options }),

104 privileges: (sessionId) => ipcRenderer.invoke("plugin:files:privileges", { sessionId }),

105

    readText: (sessionId, path, options = {}) => ipcRenderer.invoke("plugin:files:readText", { sessionId, path, options }),

106

    writeText: (sessionId, path, text, options = {}) => ipcRenderer.invoke("plugin:files:writeText", { sessionId, path, text, options }),

107

    saveText: (sessionId, path, text, options = {}) => ipcRenderer.invoke("plugin:files:saveText", { sessionId, path, text, options }),

108 listRecovery: (sessionId, options = {}) => ipcRenderer.invoke("plugin:files:listRecovery", { sessionId, options }),

109

    readRecovery: (sessionId, recoveryId, options = {}) => ipcRenderer.invoke("plugin:files:readRecovery", { sessionId, recoveryId, options }),

110

    cleanupRecovery: (sessionId, recoveryId, options = {}) => ipcRenderer.invoke("plugin:files:cleanupRecovery", { sessionId, recoveryId, options }),

111 closeText: (editId) => ipcRenderer.invoke("plugin:files:closeText", { editId }),

112

    createFile: (sessionId, path, options = {}) => ipcRenderer.invoke("plugin:files:createFile", { sessionId, path, options }),

113 mkdir: (sessionId, path, options = {}) => ipcRenderer.invoke("plugin:files:mkdir", { sessionId, path, options }),

114

    rename: (sessionId, from, to, options = {}) => ipcRenderer.invoke("plugin:files:rename", { sessionId, from, to, options }),

115 remove: (sessionId, path, options = {}) => ipcRenderer.invoke("plugin:files:remove", { sessionId, path, options }),

116

    removeMany: (sessionId, paths, recursive = false, options = {}) => ipcRenderer.invoke("plugin:files:removeMany", { sessionId, paths, recursive, options }),

117 upload: (sessionId, directory) => ipcRenderer.invoke("plugin:files:upload", { sessionId, directory }),

118 download: (sessionId, path) => ipcRenderer.invoke("plugin:files:download", { sessionId, path }),

119 downloadMany: (sessionId, paths) => ipcRenderer.invoke("plugin:files:downloadMany", { sessionId, paths }),

120

    downloadArchive: (sessionId, paths, format) => ipcRenderer.invoke("plugin:files:downloadArchive", { sessionId, paths, format }),

121 transfers: Object.freeze({

122 list: () => ipcRenderer.invoke("plugin:files:transfers:list"),

123

      planUpload: (sessionId, directory, options = {}) => ipcRenderer.invoke("plugin:files:transfers:planUpload", { sessionId, directory, options }),

124

      planDownload: (sessionId, paths, options = {}) => ipcRenderer.invoke("plugin:files:transfers:planDownload", { sessionId, paths, options }),

125 start: (planId, options = {}) => ipcRenderer.invoke("plugin:files:transfers:start", { planId, options }),

126 pause: (ids) => ipcRenderer.invoke("plugin:files:transfers:pause", { ids }),

127 resume: (ids, options = {}) => ipcRenderer.invoke("plugin:files:transfers:resume", { ids, options }),

128 retry: (ids, options = {}) => ipcRenderer.invoke("plugin:files:transfers:retry", { ids, options }),

129 cancel: (ids) => ipcRenderer.invoke("plugin:files:transfers:cancel", { ids }),

130 remove: (ids) => ipcRenderer.invoke("plugin:files:transfers:remove", { ids }),

131 updateSettings: (settings) => ipcRenderer.invoke("plugin:files:transfers:settings", { settings }),

132 onUpdate: (callback) => {

133 if (typeof callback !== "function") throw new TypeError("Transfer callback must be a function.");

134 const listener = (_event, update) => callback(update);

135 ipcRenderer.on("plugin:files:transfers:update", listener);

136 return () => ipcRenderer.removeListener("plugin:files:transfers:update", listener);

137 }

138 })

139 }),

140 hashing: Object.freeze({

141 getAlgorithms: () => ipcRenderer.invoke("plugin:hashing:algorithms"),

142 selectFiles: (multiple = false) => ipcRenderer.invoke("plugin:hashing:selectFiles", { multiple }),

143 selectDirectory: () => ipcRenderer.invoke("plugin:hashing:selectDirectory"),

144 selectManifest: () => ipcRenderer.invoke("plugin:hashing:selectManifest"),

145

    selectManifestDestination: (suggestedName) => ipcRenderer.invoke("plugin:hashing:selectManifestDestination", { suggestedName }),

146 start: (payload) => ipcRenderer.invoke("plugin:hashing:start", payload),

147 verify: (payload) => ipcRenderer.invoke("plugin:hashing:verify", payload),

148 compare: (payload) => ipcRenderer.invoke("plugin:hashing:compare", payload),

149 generateManifest: (payload) => ipcRenderer.invoke("plugin:hashing:generateManifest", payload),

150 verifyManifest: (payload) => ipcRenderer.invoke("plugin:hashing:verifyManifest", payload),

151 exportResults: (payload) => ipcRenderer.invoke("plugin:hashing:exportResults", payload),

152 copyResult: (payload) => ipcRenderer.invoke("plugin:hashing:copyResult", payload),

153 status: (jobId) => ipcRenderer.invoke("plugin:hashing:status", { jobId }),

154 cancel: (jobId) => ipcRenderer.invoke("plugin:hashing:cancel", { jobId }),

155 onProgress: (callback) => {

156 if (typeof callback !== "function") throw new TypeError("Progress callback must be a function.");

157 const listener = (_event, job) => callback(job);

158 ipcRenderer.on("plugin:hashing:progress", listener);

159 return () => ipcRenderer.removeListener("plugin:hashing:progress", listener);

160 }

161 })

162}));

163

SHA-256

cc96518baec08f2fae9055617341a186d3fe83974f5c4376ceb7e9e1404f1204

CH-J Proprietary Software License 1.14 · Lähde ilmoitetaan CH-J Proprietary Software License 1.14-koodilla. Sen saatavuus ei muuta lisenssiehtoja eikä myönnä lisäoikeuksia.

Arkisto SHA-256

a9605c0870a223b6a8542bb0705edd51d8b04f3069582653417a8397fabcc09a