Files
muSRFlow/preload.js
T
salman 3f9ecb4fd7 Report application and runtime build identity
Show version, edition, Git revision, runtime provider, musrfit, and ROOT in Quick Start across Electron and web deployments. Embed source provenance in Linux and Windows packages, repair the hardened help-window IPC path, and make Plotly controls toggle consistently by tap or click.
2026-11-04 16:27:07 +01:00

344 lines
15 KiB
JavaScript

// Copyright (C) 2026 Zaher Salman
// SPDX-License-Identifier: GPL-3.0-or-later
// Preload bridge for the Electron build. The renderer runs with
// contextIsolation:true and nodeIntegration:false, so it has no direct Node
// access. This script (which runs with full Node access because sandbox:false)
// deliberately exposes only the small, curated set of filesystem, path,
// child-process, and environment helpers the muSRFlow renderer needs. All
// values crossing the bridge are plain, serializable objects or callbacks.
const { contextBridge, ipcRenderer } = require("electron");
const fs = require("fs");
const path = require("path");
const childProcess = require("child_process");
const { pathToFileURL } = require("url");
const zlib = require("zlib");
// Plotly ships as a single bundled script under node_modules/plotly.js-dist.
// The renderer (nodeIntegration:false) cannot require it, so the bridge exposes
// a local file:// URL that the shared renderer loads through a <script> tag,
// mirroring how the web build loads Plotly from a CDN URL.
const BUNDLED_PLOTLY_PATH = path.join(
__dirname, "node_modules", "plotly.js-dist", "plotly.js"
);
// IPC channels the renderer may subscribe to or send on. Send to a channel
// that is not in this list is silently dropped; menus and dialogs in the main
// process are the only senders here.
const ALLOWED_RECEIVE_CHANNELS = [
"openFile",
"openPreferences",
"openSharedConfiguration",
"saveSession",
"openSessionHistory",
"saveFile",
"workFolderSelected",
"dataRootSelected",
"startupXmlSelected",
"binFolderSelected",
"parameterPlotData",
"quickStartSection",
"wslRuntimeStatus"
];
const ALLOWED_SEND_CHANNELS = [
"selectWorkFolder",
"selectDataRootFolder",
"selectStartupXmlFile",
"selectBinFolder",
"openParameterPlotWindow",
"openQuickStartWindow"
];
const ALLOWED_INVOKE_CHANNELS = [
"selectParameterDataFile",
"selectParameterDataFiles",
"write-clipboard",
"wslRuntimeStatus",
"ensureWslRuntime"
];
function toText(value) {
return Buffer.isBuffer(value) ? value.toString() : (value == null ? "" : String(value));
}
// Handles for running child processes, keyed by a caller-supplied job token.
// The renderer keeps the token for the last launched job, so an Abort action
// can target exactly that job without ever exposing PIDs into the page.
const runningJobs = {};
const bridge = {
ipc: {
on: function (channel, listener) {
if (!ALLOWED_RECEIVE_CHANNELS.includes(channel) || typeof listener !== "function") return;
const wrapped = function (event, ...args) { listener(...args); };
ipcRenderer.on(channel, wrapped);
return function () { ipcRenderer.removeListener(channel, wrapped); };
},
send: function (channel, ...args) {
if (ALLOWED_SEND_CHANNELS.includes(channel)) ipcRenderer.send(channel, ...args);
},
invoke: function (channel, ...args) {
if (!ALLOWED_INVOKE_CHANNELS.includes(channel)) {
return Promise.reject(new Error("IPC channel not allowed: " + channel));
}
return ipcRenderer.invoke(channel, ...args);
}
},
fs: {
existsSync: function (p) { return fs.existsSync(p); },
lstatSync: function (p) {
var s = fs.lstatSync(p);
return {
size: s.size,
isFile: function () { return s.isFile(); },
isDirectory: function () { return s.isDirectory(); },
isSymbolicLink: function () { return s.isSymbolicLink(); }
};
},
statSync: function (p) {
var s = fs.statSync(p);
return {
size: s.size,
isFile: function () { return s.isFile(); },
isDirectory: function () { return s.isDirectory(); },
isSymbolicLink: function () { return s.isSymbolicLink(); }
};
},
accessSync: function (p, mode) { return fs.accessSync(p, mode); },
readdirSync: function (p) { return fs.readdirSync(p); },
readFileSync: function (p, encoding) { return fs.readFileSync(p, encoding); },
writeFileSync: function (p, data, options) { return fs.writeFileSync(p, data, options); },
appendFileSync: function (p, data, options) { return fs.appendFileSync(p, data, options); },
copyFileSync: function (src, dest, mode) { return fs.copyFileSync(src, dest, mode); },
linkSync: function (target, pathStr) { return fs.linkSync(target, pathStr); },
renameSync: function (oldPath, newPath) { return fs.renameSync(oldPath, newPath); },
unlinkSync: function (p) { return fs.unlinkSync(p); },
rmSync: function (p, options) { return fs.rmSync(p, options); },
mkdirSync: function (p, options) { return fs.mkdirSync(p, options); },
mkdir: function (p, options, callback) {
fs.mkdir(p, options, function (err) {
if (typeof callback === "function") callback(err ? { message: err.message } : null);
});
},
readFile: function (p, encoding, callback) {
if (typeof callback === "function") {
fs.readFile(p, encoding, function (err, data) {
console.log("[bridge.readFile] " + p
+ (err ? " error: " + err.message : " ok " + (data ? data.length : 0) + " bytes"));
callback(err ? { message: err.message } : null, data);
});
}
},
constants: {
O_WRONLY: fs.constants.O_WRONLY,
COPYFILE_EXCL: fs.constants.COPYFILE_EXCL,
W_OK: fs.constants.W_OK,
X_OK: fs.constants.X_OK
}
},
path: {
join: function (...parts) { return path.join(...parts); },
resolve: function (...parts) { return path.resolve(...parts); },
basename: function (p, ext) { return path.basename(p, ext); },
dirname: function (p) { return path.dirname(p); }
},
// gzip helpers used by shared-configuration links. They cross the bridge as
// plain base64url/text strings so the sanitized renderer never holds a Buffer
// and never needs a zlib/Buffer require.
zlib: {
gzipBase64URL: function (text) {
const zipped = zlib.gzipSync(Buffer.from(String(text), "utf8"));
return zipped.toString("base64")
.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
},
gunzipBase64URL: function (payload) {
let base64 = String(payload).replace(/-/g, "+").replace(/_/g, "/");
while (base64.length % 4) base64 += "=";
const zipped = Buffer.from(base64, "base64");
return zlib.gunzipSync(zipped).toString("utf8");
}
},
// Clipboard access for the configuration-link share button, routed through
// the main process (the renderer preload has no electron.clipboard module;
// only the main process can touch the system clipboard here).
clipboard: {
writeText: function (text) {
return ipcRenderer.invoke("write-clipboard", String(text == null ? "" : text));
}
},
// Transfers are owned by the main process. IPC carries metadata and progress
// only; it never buffers raw run files in the renderer.
runData: {
configuration: function () {
return ipcRenderer.invoke('runDataConfiguration');
},
acquire: function (request) {
return ipcRenderer.invoke('acquireRunData', request);
},
cancel: function (token) {
return ipcRenderer.invoke('cancelRunData', token);
},
onProgress: function (listener) {
if (typeof listener !== 'function') return;
const wrapped = function (event, state) { listener(state); };
ipcRenderer.on('runDataProgress', wrapped);
return function () { ipcRenderer.removeListener('runDataProgress', wrapped); };
}
},
localRuntime: {
check: function (input) {
return ipcRenderer.invoke('checkLocalRuntime', input);
},
install: function (token) {
return ipcRenderer.invoke('installLocalRuntime', token);
},
cancel: function (token) {
return ipcRenderer.invoke('cancelLocalRuntime', token);
},
onProgress: function (listener) {
if (typeof listener !== 'function') return function () {};
const wrapped = function (event, state) { listener(state); };
ipcRenderer.on('localRuntimeProgress', wrapped);
return function () { ipcRenderer.removeListener('localRuntimeProgress', wrapped); };
}
},
// Windows bundled-runtime lifecycle. The main process imports the shipped
// WSL2 rootfs on first run; the renderer can subscribe for progress, read
// the current status, or force a retry after a failed import.
wslRuntime: {
status: function () { return ipcRenderer.invoke("wslRuntimeStatus"); },
ensure: function () { return ipcRenderer.invoke("ensureWslRuntime"); },
onStatus: function (listener) {
if (typeof listener !== "function") return function () {};
const wrapped = function (event, state) { listener(state); };
ipcRenderer.on("wslRuntimeStatus", wrapped);
return function () { ipcRenderer.removeListener("wslRuntimeStatus", wrapped); };
}
},
process: {
cwd: function () { return process.cwd(); },
platform: process.platform,
resourcesPath: process.resourcesPath || "",
plotlyURL: pathToFileURL(BUNDLED_PLOTLY_PATH).href,
env: Object.assign({}, process.env)
},
childProcess: {
execSync: function (command, options) {
try {
const result = childProcess.execSync(command, options || {});
return { ok: true, stdout: toText(result), error: null };
} catch (err) {
return {
ok: false,
stdout: toText(err.stdout),
stderr: toText(err.stderr),
status: typeof err.status === "number" ? err.status : 1,
error: err.message || String(err)
};
}
},
spawnSync: function (command, args, options) {
let result;
try {
result = childProcess.spawnSync(command, args || [], options || {});
} catch (err) {
return { pid: null, status: null, signal: null, stdout: "", stderr: "", error: err.message || String(err) };
}
// Normalize the synchronous child-process result into a plain object
// that the renderer shim turns back into the familiar spawnSync shape.
return {
pid: result && typeof result.pid === "number" ? result.pid : null,
status: result && typeof result.status === "number" ? result.status : null,
signal: result ? (result.signal || null) : null,
stdout: result ? toText(result.stdout) : "",
stderr: result ? toText(result.stderr) : "",
error: result && result.error ? (result.error.message || String(result.error)) : null
};
},
spawnCapture: function (command, args, options, onChunk) {
return new Promise(function (resolve) {
let child;
let stdoutText = "";
let stderrText = "";
let settled = false;
const jobKey = options && options.jobToken ? String(options.jobToken) : "";
const unregister = function () {
if (!jobKey) return;
const entry = runningJobs[jobKey];
if (entry) {
if (entry.killTimer) clearTimeout(entry.killTimer);
delete runningJobs[jobKey];
}
};
const emit = function (label, chunk) {
stdoutText += chunk;
if (typeof onChunk === "function") onChunk(label, chunk);
};
try {
child = childProcess.spawn(command, args || [], Object.assign({}, options, {
shell: false,
stdio: ["ignore", "pipe", "pipe"]
}));
} catch (err) {
resolve({ ok: 0, code: 1, signal: null, stdout: "", stderr: "", error: err.message || String(err) });
return;
}
if (jobKey) {
runningJobs[jobKey] = { child: child, done: false, killTimer: null, escalated: false };
}
child.stdout.on("data", function (chunk) { emit("stdout", chunk.toString()); });
child.stderr.on("data", function (chunk) { emit("stderr", chunk.toString()); });
child.on("error", function (err) {
if (settled) return;
settled = true;
unregister();
resolve({ ok: 0, code: 1, signal: null, stdout: stdoutText, stderr: stderrText, error: err.message || String(err) });
});
child.on("close", function (code, signal) {
if (settled) return;
settled = true;
unregister();
resolve({ ok: code === 0 ? 1 : 0, code: code, signal: signal, stdout: stdoutText, stderr: stderrText, error: null });
});
});
},
// Kill the last launched job (SIGTERM, then SIGKILL after a grace
// period). Returns { ok: false } when the token is unknown or already
// finished so the renderer can stop expecting that job to abort.
abortJob: function (token, signal) {
const key = String(token == null ? "" : token);
const entry = runningJobs[key];
if (!entry || entry.done) return { ok: false, code: "no-such-job" };
const sig = signal || "SIGTERM";
try {
if (!entry.escalated) {
entry.escalated = true;
entry.child.kill(sig);
entry.killTimer = setTimeout(function () {
const live = runningJobs[key];
if (live && !live.done) {
try { live.child.kill("SIGKILL"); } catch (ignore) {}
}
}, 3000);
}
} catch (err) {
return { ok: false, code: err && err.message ? err.message : String(err) };
}
return { ok: true, code: sig };
}
}
};
contextBridge.exposeInMainWorld("electronAPI", bridge);