Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

213 KB
Raw Blame
// SiYuan - https://github.com/siyuan-note/siyuan
// Copyright (c) 2020-present, b3log.org
// SPDX-License-Identifier: AGPL-3.0-or-later

// 开发环境下隐藏 Electron 安全清单控制台提示 https://www.electronjs.org/docs/latest/tutorial/security
process.env.ELECTRON_DISABLE_SECURITY_WARNINGS = "true";

// 桌面启动器关闭输出管道后,终端日志失败不应中断文件日志或应用启动。
const console = new (require("console").Console)({
    stdout: process.stdout,
    stderr: process.stderr,
    ignoreErrors: true,
});

const {
    net,
    app,
    BrowserWindow,
    Notification,
    shell,
    session,
    Menu,
    MenuItem,
    screen,
    ipcMain,
    clipboard,
    ClipboardItem,
    globalShortcut,
    Tray,
    dialog,
    systemPreferences,
    powerMonitor
} = require("electron");
const {updateGlobalShortcutBindings} = require("./globalShortcutBindings");
const {appendChromiumSwitch} = require("./chromiumSwitches");
const {waitForPreviousWorkspaceExit, requestWorkspaceExitRecovery} = require("./workspaceExit");
const path = require("path");
const fs = require("fs");
const {pathToFileURL} = require("url");
const gNet = require("net");
const childProcess = require("child_process");
const remote = require("@electron/remote/main");
const {probeRemoteKernelAuthentication} = require("./remoteKernelAuth");
const {installKernelRequestLog} = require("./kernelRequestLog");
const {saveRemoteExport} = require("./remoteExport");
const remoteExportSenders = new WeakSet();
const {createConnectionManager, getRemoteSession} = require("./connectionManager");
const {connectionArgs, readConnections, closeConnectionWindows} = require("./connectionStore");
const {
    rawFormatType, readClipboardBuffer, readClipboardText, getClipboardFormats, parseClipboardFilePaths
} = require("./clipboard");
const {
    getAppleSiliconDownloadURL,
    shouldDownloadAppleSilicon,
    shouldShowAppleSiliconWarning,
} = require("./appleSilicon");
const {
    createRemoteDocumentContentSecurityPolicy,
    createRemoteKernelTarget,
    getArgFrom,
    getKernelConnection,
    getRemoteKernelRedirectDecision,
    getRemoteKernelRequestPolicy,
    getRemoteKernelWebRequestDestination,
    getRemoteKernelVersionStatus,
    getUnsafeRemoteChromiumSwitchName,
    isAllowedRemoteExternalURL,
    normalizeRemoteKernelOrigin,
    remoteKernelActiveStorageTypes,
    shouldBlockRemoteFrameNavigation,
    shouldForwardRemoteDeepLink,
    shouldTrustLocalKernelCertificate,
    unsafeRemoteChromiumSwitchNames,
} = require("./remoteKernel");
const {dispatchWindowMessage} = require("./windowMessaging");
const {WindowWorkspaceRegistry, flushWindowWorkspaces} = require("./windowWorkspaces");
const {captureWindowGeometry, normalizeWindowGeometry, restoreWindowGeometry} = require("./windowGeometry");
const {createSettingsWindows} = require("./settingsWindows");
const {getCaptionHeight, getTitleBarOverlayOptions, updateTitleBarOverlay} = require("./windowControlsOverlay");
const {createSettingsTaskBridge} = require("./settingsTasks");
const {bindWebviewDevToolsShortcut} = require("./webviewDevTools");
const devToolsDock = require("./devToolsDock");
const {createWebPageFetcher, installWebPageFetchIPC} = require("./webPageFetch");
const fetchRenderedWebPage = createWebPageFetcher({BrowserWindow, session});
const windowWorkspaces = new WindowWorkspaceRegistry();
const {createNotebookSystemLock, prepareNotebookSystemLock} = require("./notebookSystemLock");
const {
    readAccessibilitySetting, writeAccessibilitySetting, getAccessibilityOverride, configureAccessibility,
} = require("./accessibility");

const {
    readLinuxInputMethodSetting, writeLinuxInputMethodSetting, readLinuxInputMethodArguments,
    prepareLinuxInputMethodLaunch, linuxInputMethodRelaunchEnvironment,
} = require("./linuxInputMethod");

process.noAsar = true;
const appDir = path.dirname(app.getAppPath());
const isDevEnv = process.env.NODE_ENV === "development";
const simulateRosetta = process.argv.includes("--simulate-rosetta");
const appVer = app.getVersion();
const confDir = path.join(app.getPath("home"), ".config", "siyuan");
const windowStatePath = path.join(confDir, "windowState.json");
const linuxInputMethodSettingPath = path.join(confDir, "linux-input-method.json");
const accessibilitySettingPath = path.join(confDir, "accessibility.json");

// 在单实例锁、窗口和内核启动前完成兼容模式重启,不修改已经选定的原生后端。
let linuxInputMethodOverride = null;
let linuxInputMethodArgumentsError = null;
let linuxInputMethodEnabled = false;
let linuxInputMethodLaunchArguments = process.argv;
if (process.platform === "linux") {
    try {
        linuxInputMethodEnabled = readLinuxInputMethodSetting(linuxInputMethodSettingPath);
    } catch (error) {
        writeLog("read Linux input method setting failed: " + error.message);
    }
    try {
        const launch = prepareLinuxInputMethodLaunch(readLinuxInputMethodArguments(), linuxInputMethodEnabled,
            process.platform, process.env[linuxInputMethodRelaunchEnvironment]);
        linuxInputMethodOverride = launch.override;
        linuxInputMethodLaunchArguments = launch.args;
        if (launch.relaunchArgs) {
            if (launch.relaunchToken) {
                process.env[linuxInputMethodRelaunchEnvironment] = launch.relaunchToken;
            } else {
                delete process.env[linuxInputMethodRelaunchEnvironment];
            }
            if (app.relaunch({args: launch.relaunchArgs}) === false) {
                throw new Error("Linux input method relaunch failed");
            }
            app.exit(0);
        }
    } catch (error) {
        linuxInputMethodArgumentsError = error;
        writeLog("prepare Linux input method launch failed: " + error.message);
    }
}

const appCrashLogPath = path.join(confDir, "app.crash.log");
const appCrashMarkerPath = path.join(confDir, "app.crash.json");
const systemShutdownNone = 0;
const systemShutdownEnding = 1;
const systemShutdownForced = 2;
const systemShutdownExitTimeout = 30000;
const updateKernelExitTimeout = 30000;
const safeModeReasons = new Set(["abnormal-exit", "killed", "crashed", "oom", "memory-eviction"]);
const noSafeModeReasons = new Set(["clean-exit", "launch-failed", "integrity-failure"]);
const expectedRendererExitIds = new Set();
const expectedKernelExitPorts = new Set();
const handledCrashWebContents = new Set();
const kernelProcesses = new Map();
const exitedKernelPorts = new Set();
const localKernelStartups = new Map();
const bootWindows = new Set();
let bootWindow;
let bootIndexPath;
let latestActiveWindow;
let firstOpen = false;
let workspaces = []; // workspaceDir, id, port, webContentsId, browserWindow, tray, hideShortcut
const notebookSystemLock = createNotebookSystemLock({
    getWorkspaces: () => workspaces,
    fetch: (...args) => net.fetch(...args),
    writeLog: (message) => writeLog(message),
    prepare: (workspace) => prepareNotebookSystemLock(BrowserWindow.getAllWindows().filter(window =>
        initializedWindowIds.has(window.webContents.id) &&
        windowKernelTargets.get(window.webContents.id)?.origin === workspace.kernelTarget.origin), ipcMain),
});
const windowKernelTargets = new Map();
const initializedWindowIds = new Set();
createSettingsTaskBridge({
    ipcMain,
    getTarget: id => getWindowKernelTarget(id),
    getWindows: origin => BrowserWindow.getAllWindows().filter(win =>
        initializedWindowIds.has(win.webContents.id) && windowKernelTargets.get(win.webContents.id)?.origin === origin),
});
const settingsWindowPolicy = createSettingsWindows({
    ipcMain,
    screen,
    icon: path.join(appDir, "stage", "icon-large.png"),
    getTarget: id => getWindowKernelTarget(id),
    getWindows: origin => BrowserWindow.getAllWindows().filter(win =>
        initializedWindowIds.has(win.webContents.id) && windowKernelTargets.get(win.webContents.id)?.origin === origin),
    show: win => showWindow(win),
    log: message => writeLog(message),
    initialize: (win, target) => {
        remote.enable(win.webContents);
        bindSpellcheckContextMenu(win.webContents);
        rememberWindowKernelTarget(win, target);
        win.webContents.userAgent = "SiYuan/" + appVer + " https://b3log.org/siyuan Electron " + win.webContents.userAgent;
        windowNavigate(win, "settings", target.origin, target.mode === "remote");
    },
});
const pendingRemoteOpenURLs = [];
const blockDragSessions = new Map();
const blockDragWindowFocusOrder = new Map();
let blockDragWindowFocusSequence = 0;
const blockDragCursorPollInterval = 16;

const getBlockDragSessionKey = (sourceWebContentsId, dragId) => {
    return sourceWebContentsId + ":" + dragId;
};

const getBlockDragWindow = (webContentsId) => {
    return BrowserWindow.getAllWindows().find((item) => !item.isDestroyed() &&
        !item.webContents.isDestroyed() && item.webContents.id === webContentsId);
};

const sendBlockDragMessage = (webContentsId, data) => {
    const targetWindow = getBlockDragWindow(webContentsId);
    if (!targetWindow) {
        return false;
    }
    try {
        targetWindow.webContents.send("siyuan-block-drag", data);
        return true;
    } catch {
        return false;
    }
};

const normalizeBlockDragPoint = (point) => {
    if (!point || typeof point !== "object" || !Number.isFinite(point.screenX) ||
        !Number.isFinite(point.screenY)) {
        return;
    }
    return {
        ...point,
        screenX: point.screenX,
        screenY: point.screenY,
        clientX: Number.isFinite(point.clientX) ? point.clientX : 0,
        clientY: Number.isFinite(point.clientY) ? point.clientY : 0,
        altKey: !!point.altKey,
        ctrlKey: !!point.ctrlKey,
        metaKey: !!point.metaKey,
        sequence: Number.isSafeInteger(point.sequence) ? point.sequence : 0,
        shiftKey: !!point.shiftKey,
    };
};

const updateBlockDragCursorPoint = (dragSession, point) => {
    if (!point) {
        return;
    }
    // 跨 BrowserWindow 拖拽时以主进程获取的全局指针位置为准,避免渲染进程失焦后上报的 screen 坐标被窗口边界截断。
    const cursorPoint = screen.getCursorScreenPoint();
    dragSession.point = {
        ...point,
        screenX: cursorPoint.x,
        screenY: cursorPoint.y,
    };
};

const normalizeBlockDragPayload = (payload) => {
    if (!payload || typeof payload !== "object" || !Array.isArray(payload.items) ||
        !payload.items.every((item) => item && typeof item.type === "string" && typeof item.data === "string")) {
        return;
    }
    const normalizedPayload = {
        items: payload.items.map((item) => ({type: item.type, data: item.data})),
        dragTitle: typeof payload.dragTitle === "string" ? payload.dragTitle : "",
    };
    if (typeof payload.effectAllowed === "string") {
        normalizedPayload.effectAllowed = payload.effectAllowed;
    }
    return normalizedPayload;
};

const isPointInBounds = (point, bounds) => {
    return point.screenX >= bounds.x && point.screenX < bounds.x + bounds.width &&
        point.screenY >= bounds.y && point.screenY < bounds.y + bounds.height;
};

const getBlockDragTarget = (dragSession, expectedTargetWebContentsId) => {
    if (!dragSession.point) {
        return;
    }
    const sourceWindow = getBlockDragWindow(dragSession.sourceWebContentsId);
    if (!sourceWindow) {
        return;
    }
    const sourceContainsPoint = isPointInBounds(dragSession.point, sourceWindow.getBounds());
    const candidates = BrowserWindow.getAllWindows().filter((item) => {
        if (item.isDestroyed() || item.webContents.isDestroyed() ||
            item.webContents.id === dragSession.sourceWebContentsId ||
            !initializedWindowIds.has(item.webContents.id) || !item.isVisible() || item.isMinimized()) {
            return false;
        }
        if (expectedTargetWebContentsId !== undefined && item.webContents.id !== expectedTargetWebContentsId) {
            return false;
        }
        const kernelTarget = windowKernelTargets.get(item.webContents.id);
        return kernelTarget?.origin === dragSession.kernelOrigin && isPointInBounds(dragSession.point,
            item.getContentBounds());
    });
    candidates.sort((first, second) => {
        const alwaysOnTopDiff = Number(second.isAlwaysOnTop()) - Number(first.isAlwaysOnTop());
        if (alwaysOnTopDiff !== 0) {
            return alwaysOnTopDiff;
        }
        return (blockDragWindowFocusOrder.get(second.webContents.id) || 0) -
            (blockDragWindowFocusOrder.get(first.webContents.id) || 0);
    });
    const targetWindow = candidates[0];
    if (!targetWindow || (expectedTargetWebContentsId === undefined && sourceContainsPoint &&
        (sourceWindow.isAlwaysOnTop() || !targetWindow.isAlwaysOnTop()))) {
        // 普通目标窗口位于源窗口后方时,不应让指针穿透源窗口。
        return;
    }
    const contentBounds = targetWindow.getContentBounds();
    const zoomFactor = targetWindow.webContents.getZoomFactor() || 1;
    return {
        webContentsId: targetWindow.webContents.id,
        point: {
            ...dragSession.point,
            clientX: (dragSession.point.screenX - contentBounds.x) / zoomFactor,
            clientY: (dragSession.point.screenY - contentBounds.y) / zoomFactor,
        },
    };
};

const leaveBlockDragTarget = (dragSession) => {
    if (!dragSession.targetWebContentsId) {
        return;
    }
    sendBlockDragMessage(dragSession.targetWebContentsId, {
        phase: "leave",
        dragId: dragSession.dragId,
    });
    dragSession.targetWebContentsId = undefined;
};

const sendBlockDragRoute = (dragSession, remote, sequence = dragSession.point?.sequence) => {
    const sourceWindow = getBlockDragWindow(dragSession.sourceWebContentsId);
    sendBlockDragMessage(dragSession.sourceWebContentsId, {
        phase: "route",
        dragId: dragSession.dragId,
        remote,
        outsideSource: !sourceWindow || !dragSession.point ||
            !isPointInBounds(dragSession.point, sourceWindow.getContentBounds()),
        sequence,
    });
};

const routeBlockDragMove = (dragSession, notifySource = true, expectedTargetWebContentsId) => {
    const target = getBlockDragTarget(dragSession, expectedTargetWebContentsId);
    if (!target) {
        leaveBlockDragTarget(dragSession);
        if (notifySource) {
            sendBlockDragRoute(dragSession, false);
        }
        return;
    }
    if (!dragSession.payload) {
        if (!dragSession.payloadRequested && sendBlockDragMessage(dragSession.sourceWebContentsId, {
            phase: "request",
            dragId: dragSession.dragId,
        })) {
            dragSession.payloadRequested = true;
        }
        if (notifySource) {
            sendBlockDragRoute(dragSession, true);
        }
        return {target, ready: false};
    }
    if (dragSession.targetWebContentsId !== target.webContentsId) {
        leaveBlockDragTarget(dragSession);
        dragSession.targetWebContentsId = target.webContentsId;
        if (!sendBlockDragMessage(target.webContentsId, {
            phase: "enter",
            dragId: dragSession.dragId,
            point: target.point,
            payload: dragSession.payload,
        })) {
            dragSession.targetWebContentsId = undefined;
            if (notifySource) {
                sendBlockDragRoute(dragSession, false);
            }
            return;
        }
    }
    if (!sendBlockDragMessage(target.webContentsId, {
        phase: "move",
        dragId: dragSession.dragId,
        point: target.point,
    })) {
        dragSession.targetWebContentsId = undefined;
        if (notifySource) {
            sendBlockDragRoute(dragSession, false);
        }
        return;
    }
    if (notifySource) {
        sendBlockDragRoute(dragSession, true);
    }
    return {target, ready: true};
};

const startBlockDragCursorPolling = (sessionKey, dragSession) => {
    dragSession.cursorPollInterval = setInterval(() => {
        if (blockDragSessions.get(sessionKey) !== dragSession || dragSession.dropping || !dragSession.point) {
            return;
        }
        const cursorPoint = screen.getCursorScreenPoint();
        if (cursorPoint.x === dragSession.point.screenX && cursorPoint.y === dragSession.point.screenY) {
            return;
        }
        dragSession.point = {
            ...dragSession.point,
            screenX: cursorPoint.x,
            screenY: cursorPoint.y,
        };
        routeBlockDragMove(dragSession);
    }, blockDragCursorPollInterval);
};

const dispatchBlockDragDrop = (dragSession) => {
    const dragRoute = routeBlockDragMove(dragSession, false, dragSession.dropTargetWebContentsId);
    if (dragRoute?.target && !dragRoute.ready) {
        dragSession.waitingForDropPayload = true;
        return;
    }
    dragSession.waitingForDropPayload = false;
    if (dragRoute?.ready && dragRoute.target.webContentsId === dragSession.targetWebContentsId &&
        dragSession.payload) {
        if (sendBlockDragMessage(dragRoute.target.webContentsId, {
            phase: "drop",
            dragId: dragSession.dragId,
            point: dragRoute.target.point,
            payload: dragSession.payload,
            sequence: dragSession.pendingDropSequence,
            sourceWebContentsId: dragSession.sourceWebContentsId,
        })) {
            dragSession.dropSent = true;
            return;
        }
        leaveBlockDragTarget(dragSession);
    }
    const dropSequence = dragSession.pendingDropSequence;
    dragSession.pendingDropSequence = undefined;
    if (dragSession.dropTargetWebContentsId !== undefined) {
        sendBlockDragMessage(dragSession.sourceWebContentsId, {
            phase: "complete",
            dragId: dragSession.dragId,
            canceled: true,
        });
        finishBlockDragSession(getBlockDragSessionKey(dragSession.sourceWebContentsId, dragSession.dragId),
            dragSession);
        return;
    }
    sendBlockDragRoute(dragSession, false, dropSequence);
};

const finishBlockDragSession = (sessionKey, dragSession) => {
    if (dragSession.cursorPollInterval) {
        clearInterval(dragSession.cursorPollInterval);
    }
    if (dragSession.targetWebContentsId) {
        sendBlockDragMessage(dragSession.targetWebContentsId, {
            phase: "end",
            dragId: dragSession.dragId,
        });
    }
    blockDragSessions.delete(sessionKey);
};

const dropBlockDragFromTarget = (targetWebContentsId, data) => {
    const targetKernel = windowKernelTargets.get(targetWebContentsId);
    const point = normalizeBlockDragPoint(data.point);
    if (!targetKernel || !initializedWindowIds.has(targetWebContentsId) || !point) {
        return;
    }
    for (const dragSession of blockDragSessions.values()) {
        if (dragSession.sourceWebContentsId === targetWebContentsId || dragSession.dropping ||
            dragSession.kernelOrigin !== targetKernel.origin) {
            continue;
        }
        updateBlockDragCursorPoint(dragSession, {
            ...point,
            sequence: dragSession.point?.sequence || 0,
        });
        const target = getBlockDragTarget(dragSession, targetWebContentsId);
        if (!target) {
            continue;
        }
        dragSession.dropping = true;
        dragSession.dropTargetWebContentsId = targetWebContentsId;
        dragSession.pendingDropSequence = dragSession.point?.sequence || 0;
        dispatchBlockDragDrop(dragSession);
        return;
    }
};

const cleanupBlockDragSessions = (webContentsId) => {
    for (const [sessionKey, dragSession] of blockDragSessions) {
        if (dragSession.sourceWebContentsId === webContentsId) {
            finishBlockDragSession(sessionKey, dragSession);
        } else if (dragSession.targetWebContentsId === webContentsId) {
            // 目标渲染上下文失效后保留源窗口的拖拽会话,以便指针继续进入其他窗口。
            dragSession.targetWebContentsId = undefined;
            if (dragSession.dropping) {
                if (dragSession.pendingDropSequence !== undefined) {
                    sendBlockDragRoute(dragSession, !!dragSession.dropSent, dragSession.pendingDropSequence);
                    dragSession.pendingDropSequence = undefined;
                }
            } else {
                routeBlockDragMove(dragSession);
            }
        }
    }
};

const cleanupBlockDragWindow = (webContentsId) => {
    blockDragWindowFocusOrder.delete(webContentsId);
    cleanupBlockDragSessions(webContentsId);
};

const flushPendingRemoteOpenURLs = (window) => {
    if (!window || window.isDestroyed()) {
        return;
    }
    pendingRemoteOpenURLs.splice(0).forEach((url) => window.webContents.send("siyuan-open-url", url));
};

const getGlobalShortcutWorkspace = (fallbackWorkspace) => {
    const focusedWorkspace = workspaces.find(item => item.browserWindow &&
        !item.browserWindow.isDestroyed() && item.browserWindow.isFocused());
    if (focusedWorkspace) {
        return focusedWorkspace;
    }
    if (fallbackWorkspace?.browserWindow && !fallbackWorkspace.browserWindow.isDestroyed()) {
        return fallbackWorkspace;
    }
};
const initEventId = [];
const appMenuByWorkspaceDir = new Map();
const appMenuWorkspaceByWebContentsId = new Map();
let kernelPort = 6806;
let resetWindowStateOnRestart = false;
let openAsHidden = false;
let systemShutdownState = systemShutdownNone;
let gracefulSystemShutdownPromise;
let keepAppOpenDuringSystemShutdown = false;
let updateInstallPromise;
let keepAppOpenDuringUpdate = false;
let richClipboardOperation;
let richClipboardSequence = 0;
let appleSiliconWarningShown = false;
const openDialogSingletons = new Set();
let spellcheckContextSequence = 0;
const spellcheckContexts = new Map();
const pendingSpellcheckRequests = new Map();
const pendingNativeContextMenuRequests = new Map();
const spellcheckContextMenuContents = new Set();
const normalizeClipboardText = (text) => text.replace(/\r\n?/g, "\n");
const escapeHTML = (value) => String(value).replace(/[&<>"']/g, (character) => ({
    "&": "&amp;",
    "<": "&lt;",
    ">": "&gt;",
    "\"": "&quot;",
    "'": "&#39;",
})[character]);
const isOpenAsHidden = function () {
    return 1 === workspaces.length && openAsHidden;
};

const getArg = (name) => getArgFrom(process.argv, name);

const createLocalKernelTarget = (port = kernelPort) => ({
    mode: "local",
    origin: "https://127.0.0.1:" + port,
    ownsKernel: true,
    port: port.toString(),
});

let remoteKernelTarget;
let remoteKernelArgError;
let connectionManager;
let remoteBootCanceled = false;
let pendingConnectionArgs;
const relaunchConnection = () => {
    if (pendingConnectionArgs) {
        app.relaunch({args: pendingConnectionArgs});
        pendingConnectionArgs = undefined;
    }
};
const remoteKernelArg = getArg("--remote");
if (remoteKernelArg !== undefined) {
    try {
        remoteKernelTarget = createRemoteKernelTarget(remoteKernelArg, process.argv);
    } catch (error) {
        remoteKernelArgError = error;
    }
}

if (remoteKernelTarget) {
    const configuredUnsafeSwitchNames = new Set(process.argv.map(getUnsafeRemoteChromiumSwitchName).filter(Boolean));
    unsafeRemoteChromiumSwitchNames.forEach((switchName) => {
        if (app.commandLine.hasSwitch(switchName)) {
            configuredUnsafeSwitchNames.add(switchName);
        }
    });
    const disabledFeatures = app.commandLine.getSwitchValue("disable-features");
    if (getUnsafeRemoteChromiumSwitchName("--disable-features=" + disabledFeatures)) {
        configuredUnsafeSwitchNames.add("disable-features");
    }
    if (configuredUnsafeSwitchNames.size > 0) {
        configuredUnsafeSwitchNames.forEach((switchName) => app.commandLine.removeSwitch(switchName));
        remoteKernelArgError = new Error("--remote cannot be combined with switches that weaken web security: " +
            Array.from(configuredUnsafeSwitchNames).join(", "));
        remoteKernelArgError.code = "ERR_REMOTE_UNSAFE_CHROMIUM_SWITCH";
    }
}

const initialSiYuanOpenURL = process.argv.find((arg) => arg.startsWith("siyuan://"));
if (remoteKernelTarget && !remoteKernelArgError && initialSiYuanOpenURL) {
    pendingRemoteOpenURLs.push(initialSiYuanOpenURL);
}

const isMatchingContextMenuRequest = (context, request) => {
    return Number.isFinite(request.requestedAt) &&
        context.createdAt >= request.requestedAt &&
        context.createdAt - request.requestedAt < 1000;
};

const NATIVE_TEXT_CONTEXT_MENU_ROLES = new Set([
    "undo", "redo", "cut", "copy", "paste", "pasteAndMatchStyle", "delete", "selectAll",
]);

const getNativeTextContextMenuItems = (contents, request = {}, params) => {
    const items = [];
    if (!Array.isArray(request.items)) {
        return items;
    }
    const misspelledWord = params?.misspelledWord;
    request.items.forEach((item) => {
        if (!item || typeof item !== "object") {
            return;
        }
        if (item.type === "addToDictionary") {
            if (!misspelledWord) {
                return;
            }
            (params.dictionarySuggestions || []).forEach((suggestion) => {
                items.push(new MenuItem({
                    label: suggestion,
                    click: () => contents.replaceMisspelling(suggestion),
                }));
            });
            items.push(new MenuItem({
                label: item.label,
                click: () => {
                    if (!contents.session.addWordToSpellCheckerDictionary(misspelledWord)) {
                        writeLog("failed to add word to spell checker dictionary");
                    }
                },
            }), {type: "separator"});
            return;
        }
        if (item.type === "separator") {
            items.push({type: "separator"});
            return;
        }
        if (!NATIVE_TEXT_CONTEXT_MENU_ROLES.has(item.role)) {
            return;
        }
        items.push(new MenuItem({
            role: item.role,
            label: item.label,
        }));
    });
    return items;
};

const popupNativeTextContextMenu = (contents, context, request) => {
    request = request || {};
    const params = context?.params;
    const template = getNativeTextContextMenuItems(contents, request, params);
    const menu = Menu.buildFromTemplate(template);
    const options = {
        window: BrowserWindow.fromWebContents(contents),
    };
    if (params) {
        options.x = params.x;
        options.y = params.y;
        options.sourceType = params.menuSourceType;
        if (params.frame) {
            options.frame = params.frame;
        }
    }
    menu.popup(options);
};

const dispatchContextMenuRequests = (contents) => {
    const context = spellcheckContexts.get(contents.id);
    if (!context || context.delivered) {
        return;
    }
    const spellcheckRequest = pendingSpellcheckRequests.get(contents.id);
    if (spellcheckRequest && isMatchingContextMenuRequest(context, spellcheckRequest)) {
        context.delivered = true;
        pendingSpellcheckRequests.delete(contents.id);
        contents.send("siyuan-spellcheck-context", {
            contextId: context.contextId,
            x: spellcheckRequest.x,
            y: spellcheckRequest.y,
            misspelledWord: context.params.misspelledWord,
            dictionarySuggestions: context.params.dictionarySuggestions,
        });
        return;
    }
    const nativeRequest = pendingNativeContextMenuRequests.get(contents.id);
    if (nativeRequest && isMatchingContextMenuRequest(context, nativeRequest)) {
        context.delivered = true;
        pendingNativeContextMenuRequests.delete(contents.id);
        popupNativeTextContextMenu(contents, context, nativeRequest);
    }
};

const bindSpellcheckContextMenu = (contents) => {
    if (spellcheckContextMenuContents.has(contents.id)) {
        return;
    }
    spellcheckContextMenuContents.add(contents.id);
    contents.on("context-menu", (event, params) => {
        const context = {
            contextId: ++spellcheckContextSequence,
            params,
            createdAt: Date.now(),
            delivered: false,
        };
        spellcheckContexts.set(contents.id, context);
        dispatchContextMenuRequests(contents);
        setTimeout(() => {
            if (spellcheckContexts.get(contents.id) === context && !context.delivered) {
                spellcheckContexts.delete(contents.id);
            }
        }, 200);
    });
    contents.once("destroyed", () => {
        spellcheckContextMenuContents.delete(contents.id);
        spellcheckContexts.delete(contents.id);
        pendingSpellcheckRequests.delete(contents.id);
        pendingNativeContextMenuRequests.delete(contents.id);
    });
};

// 顶栏空白处是窗口拖拽区域,右键会被系统当作非客户区并弹出系统菜单,这里转交渲染进程显示自定义菜单
// https://www.electronjs.org/docs/latest/api/base-window#event-system-context-menu-windows-linux
const bindTopBarContextMenu = (win) => {
    win.on("system-context-menu", (event, point) => {
        const bounds = win.getContentBounds();
        const dipPoint = screen.screenToDipPoint(point);
        const zoom = win.webContents.getZoomFactor();
        const x = (dipPoint.x - bounds.x) / zoom;
        const y = (dipPoint.y - bounds.y) / zoom;
        // 顶栏高度 32px,融合顶栏 42px,超出范围保留系统菜单
        if (y < 0 || y > 42) {
            return;
        }
        event.preventDefault();
        win.webContents.send("siyuan-topbar-context-menu", {x, y});
    });
};

remote.initialize();

// Electron 相关文件夹名称改为 `SiYuan-Electron` https://github.com/siyuan-note/siyuan/issues/3349
// getPath("userData") 会创建空的 SiYuan 目录,改为 app.getPath("appData")
app.setPath("userData", path.join(app.getPath("appData"), app.getName() + "-Electron"));

if (process.platform === "win32") {
    // Windows 需要设置 AppUserModelId 才能正确显示应用名称和应用图标 https://github.com/siyuan-note/siyuan/issues/17022
    app.setAppUserModelId("org.b3log.siyuan");
}

if (!app.requestSingleInstanceLock()) {
    app.quit();
    return;
}

// 开发环境下 Windows 需显式传入 Electron 可执行文件路径和 main.js 路径,否则 siyuan:// 会被当作相对路径
if (isDevEnv && process.defaultApp && process.argv.length >= 2) {
    const mainScript = path.resolve(process.argv[1]);
    if (process.platform === "win32") {
        app.removeAsDefaultProtocolClient("siyuan", process.execPath, [mainScript]);
        app.setAsDefaultProtocolClient("siyuan", process.execPath, [mainScript]);
    } else {
        app.setAsDefaultProtocolClient("siyuan");
    }
} else {
    app.setAsDefaultProtocolClient("siyuan");
}

app.commandLine.appendSwitch("auto-detect", "false");
if (!remoteKernelTarget) {
    app.commandLine.appendSwitch("no-proxy-server");
}
// 同源窗口共享渲染进程,按来源隔离以保留不同端口工作空间之间的进程隔离。
app.commandLine.appendSwitch("process-per-site");
appendChromiumSwitch(app.commandLine, "--enable-features=PlatformHEVCDecoderSupport,OriginKeyedProcessesByDefault");
app.commandLine.appendSwitch("xdg-portal-required-version", "4");
// 本地 HTTPS 页面加载 HTTP 外链图时,禁止自动升级为 HTTPS
appendChromiumSwitch(app.commandLine, "--disable-features=AutoupgradeMixedContent");

// Support set Chromium command line arguments on the desktop https://github.com/siyuan-note/siyuan/issues/9696
writeLog("app is packaged [" + app.isPackaged + "], command line args [" + process.argv.join(", ") + "]");
let argStart = 1;
if (!app.isPackaged) {
    argStart = 2;
}

for (let i = argStart; i < linuxInputMethodLaunchArguments.length; i++) {
    let arg = linuxInputMethodLaunchArguments[i];
    if (arg === "--") {
        break;
    }
    if (arg.startsWith("--workspace=") || arg.startsWith("--openAsHidden") || arg.startsWith("--port=") ||
        arg.startsWith("--safe-mode=") || arg.startsWith("--lang=") || arg.startsWith("--connection-session=") || arg === "--remote" ||
        arg.startsWith("--remote=") || arg === "--trust-remote-extensions" ||
        arg.startsWith("--trust-remote-extensions=") ||
        arg.startsWith("siyuan://")) {
        // 跳过内置参数
        if (arg.startsWith("--openAsHidden")) {
            openAsHidden = true;
            writeLog("open as hidden");
        }
        continue;
    }

    if (remoteKernelTarget && getUnsafeRemoteChromiumSwitchName(arg)) {
        continue;
    }

    if (appendChromiumSwitch(app.commandLine, arg)) {
        writeLog("command line switch [" + arg + "]");
    }
}

// 桌面端辅助功能配置在创建窗口前应用,对本机所有工作空间生效。
const accessibilityOverride = getAccessibilityOverride(app.commandLine);
let accessibilityEnabled = true;
try {
    accessibilityEnabled = readAccessibilitySetting(accessibilitySettingPath);
} catch (error) {
    // 配置读取失败时保留辅助功能支持,避免阻断已依赖读屏的用户。
    writeLog("read accessibility setting failed: " + error.message);
}
configureAccessibility(app.commandLine, accessibilityEnabled);

try {
    firstOpen = !remoteKernelTarget && !fs.existsSync(path.join(confDir, "workspace.json"));
    if (!fs.existsSync(confDir)) {
        fs.mkdirSync(confDir, {mode: 0o755, recursive: true});
    }
} catch (e) {
    console.error(e);
    require("electron").dialog.showErrorBox("创建配置目录失败 Failed to create config directory", "思源需要在用户家目录下创建配置文件夹(~/.config/siyuan),请确保该路径具有写入权限。\n\nSiYuan needs to create a configuration folder (~/.config/siyuan) in the user's home directory. Please make sure that the path has write permissions.");
    app.exit();
}

// 检测上次打开的工作空间是否丢失 https://github.com/siyuan-note/siyuan/issues/14748
let lastWorkspaceMissing = false;
let missingWorkspacePath = "";
let availableWorkspaces = [];
if (!remoteKernelTarget && !firstOpen && !getArg("--workspace")) {
    // 显式通过命令行指定工作空间时尊重用户参数,跳过检测
    try {
        const wsFile = path.join(confDir, "workspace.json");
        if (fs.existsSync(wsFile)) {
            const wsList = JSON.parse(fs.readFileSync(wsFile, "utf8"));
            if (Array.isArray(wsList) && 0 < wsList.length) {
                const last = wsList[wsList.length - 1];
                if (!fs.existsSync(last) || !fs.statSync(last).isDirectory()) {
                    lastWorkspaceMissing = true;
                    missingWorkspacePath = last;
                    availableWorkspaces = wsList.slice(0, -1).filter(p =>
                        fs.existsSync(p) && fs.statSync(p).isDirectory());
                }
            }
        }
    } catch (e) {
        writeLog("check missing workspace failed: " + e);
    }
}

// 读取上次打开的工作空间路径,用于崩溃恢复时默认选中该工作空间
let lastWorkspacePath = "";
if (!remoteKernelTarget && !firstOpen && !getArg("--workspace")) {
    try {
        const wsFile = path.join(confDir, "workspace.json");
        if (fs.existsSync(wsFile)) {
            const wsList = JSON.parse(fs.readFileSync(wsFile, "utf8"));
            if (Array.isArray(wsList) && 0 < wsList.length) {
                lastWorkspacePath = wsList[wsList.length - 1];
            }
        }
    } catch (e) {
        writeLog("read last workspace path failed: " + e);
    }
}

const openExternalURL = (url, remoteMode = false) => {
    if (remoteMode && !isAllowedRemoteExternalURL(url)) {
        writeLog("blocked external protocol in remote kernel mode [url=" + url + "]");
        return;
    }
    shell.openExternal(url);
};

const windowNavigate = (currentWindow, windowType, kernelOrigin, remoteMode = false) => {
    currentWindow.webContents.on("will-navigate", (event) => {
        try {
            const targetURL = new URL(event.url);
            if (targetURL.origin === kernelOrigin && (
                windowType === "app" && ["/stage/build/app/", "/check-auth"].includes(targetURL.pathname) ||
                windowType === "app" && !remoteMode && targetURL.pathname === "/" ||
                windowType === "window" && ["/stage/build/app/window.html", "/check-auth"].includes(targetURL.pathname) ||
                windowType === "settings" && ["/stage/build/app/settings.html", "/check-auth"].includes(targetURL.pathname) ||
                windowType === "export" && targetURL.pathname.startsWith("/export/temp/")
            )) {
                return;
            }
        } catch (e) {
            // 无效链接交给系统浏览器处理。
        }
        // 其他链接使用浏览器打开
        event.preventDefault();
        openExternalURL(event.url, remoteMode);
    });
};

const getWindowPathname = (window) => {
    if (!window || window.isDestroyed() || window.webContents.isDestroyed()) {
        return "";
    }
    try {
        return new URL(window.webContents.getURL()).pathname;
    } catch (error) {
        return "";
    }
};

const setProxy = (proxyURL, webContents, proxyMode) => {
    if (proxyMode === "system" || (!proxyMode && proxyURL.startsWith("://"))) {
        console.log("network proxy [system]");
        return webContents.session.setProxy({mode: "system"});
    }
    if (proxyMode === "direct") {
        console.log("network proxy [direct]");
        return webContents.session.setProxy({mode: "direct"});
    }
    console.log("network proxy [" + proxyURL + "]");
    return webContents.session.setProxy({proxyRules: proxyURL});
};

const hotKey2Electron = (key) => {
    if (!key) {
        return key;
    }
    let electronKey = "";
    if (key.indexOf("⌘") > -1) {
        electronKey += "CommandOrControl+";
    }
    if (key.indexOf("⌃") > -1) {
        electronKey += "Control+";
    }
    if (key.indexOf("⇧") > -1) {
        electronKey += "Shift+";
    }
    if (key.indexOf("⌥") > -1) {
        electronKey += "Alt+";
    }
    return electronKey + key.replace("⌘", "").replace("⇧", "").replace("⌥", "").replace("⌃", "")
        .replace("←", "Left").replace("→", "Right").replace("↑", "Up").replace("↓", "Down").replace(" ", "Space")
        .replace("+", "Plus").replace("⇥", "Tab").replace("⌫", "Backspace").replace("⌦", "Delete").replace("↩", "Return");
};

const getFeedbackUrl = (lang) => {
    return "zh-CN" === lang
        ? "https://ld246.com/article/1649901726096"
        : "https://liuyun.io/article/1686530886208";
};

const withHotkey = (hotkey, overrideRoleDefault = false) => {
    if (typeof hotkey !== "string" || !hotkey.length) {
        // 空快捷键:自定义项不注册加速键;role 项需显式覆盖系统默认加速键
        return overrideRoleDefault ? {accelerator: "", registerAccelerator: false} : {};
    }
    const acc = hotKey2Electron(hotkey);
    return acc ? {accelerator: acc} : (overrideRoleDefault ? {accelerator: "", registerAccelerator: false} : {});
};

const forgetAppMenuWebContents = (webContentsId) => {
    const workspaceDir = appMenuWorkspaceByWebContentsId.get(webContentsId);
    appMenuWorkspaceByWebContentsId.delete(webContentsId);
    const initIndex = initEventId.indexOf(webContentsId);
    if (initIndex > -1) {
        initEventId.splice(initIndex, 1);
    }
    if (!workspaceDir) {
        return;
    }
    for (const mappedDir of appMenuWorkspaceByWebContentsId.values()) {
        if (mappedDir === workspaceDir) {
            return;
        }
    }
    appMenuByWorkspaceDir.delete(workspaceDir);
};

const isInitializedAppWindow = (wnd) => {
    return !!(wnd && !wnd.isDestroyed() && initEventId.includes(wnd.webContents.id));
};

const getAppWindow = () => {
    const focused = BrowserWindow.getFocusedWindow();
    if (isInitializedAppWindow(focused)) {
        return focused;
    }
    if (isInitializedAppWindow(latestActiveWindow)) {
        return latestActiveWindow;
    }
    const workspaceWindow = workspaces.find((item) => isInitializedAppWindow(item.browserWindow));
    if (workspaceWindow) {
        return workspaceWindow.browserWindow;
    }
    return BrowserWindow.getAllWindows().find(isInitializedAppWindow) || null;
};

const appMenuLanguages = new Map();

const loadAppMenuLanguages = (language) => {
    language = resolveAppLanguage([language]);
    if (appMenuLanguages.has(language)) {
        return appMenuLanguages.get(language);
    }
    try {
        const languages = JSON.parse(fs.readFileSync(path.join(appDir, "appearance", "langs", `${language}.json`), "utf8"));
        appMenuLanguages.set(language, languages);
        return languages;
    } catch (error) {
        writeLog("load application menu language failed: " + error.message);
        return language === "en" ? {} : loadAppMenuLanguages("en");
    }
};

// Windows 的菜单栏不可见,但菜单项快捷键仍然生效,这里改用自定义菜单项把开发者工具停在底部。
const getDevToolsMenuItem = (label) => {
    if ("win32" !== process.platform) {
        return {role: "toggledevtools", label};
    }
    return {
        label,
        accelerator: "Ctrl+Shift+I",
        click: () => {
            const win = BrowserWindow.getFocusedWindow() || getAppWindow();
            if (win && !win.isDestroyed()) {
                devToolsDock.toggleDevTools(win.webContents);
            }
        },
    };
};

const applyMacAppMenu = (sync) => {
    if ("darwin" !== process.platform || !sync || typeof sync.lang !== "string" ||
        !sync.hotkey || typeof sync.hotkey !== "object") {
        return;
    }
    const languages = loadAppMenuLanguages(sync.lang);
    /** @type {import("electron").MenuItemConstructorOptions[]} */
    const template = [{
        role: "appMenu",
        label: app.name,
        submenu: [
            {role: "about", label: languages.appMenuAbout || "About SiYuan"},
            ...(sync.readonly ? [] : [{
                label: languages.config || "Settings",
                click: () => {
                    getAppWindow()?.webContents.send("siyuan-open-setting");
                },
                ...withHotkey(sync.hotkey.config),
            }]),
            {type: "separator"},
            {role: "services", label: languages.appMenuServices || "Services"},
            {type: "separator"},
            {
                label: languages.toggleWin || "Hide/Show Window",
                click: () => {
                    toggleMainWindow(getAppWindow());
                },
                ...withHotkey(sync.hotkey.toggleWin),
            },
            {role: "hide", label: languages.appMenuHide || "Hide SiYuan"},
            {role: "hideOthers", label: languages.appMenuHideOthers || "Hide Others"},
            {role: "unhide", label: languages.showAll || "Show All"},
            {type: "separator"},
            {role: "quit", label: languages.appMenuQuit || "Quit SiYuan"},
        ],
    }, {
        role: "editMenu",
        label: languages.edit || "Edit",
        submenu: [
            {role: "undo", label: languages.undo || "Undo", ...withHotkey(sync.hotkey.undo, true)},
            {role: "redo", label: languages.redo || "Redo", ...withHotkey(sync.hotkey.redo, true)},
            {type: "separator"},
            {role: "cut", label: languages.cut || "Cut"},
            {role: "copy", label: languages.copy || "Copy"},
            {role: "paste", label: languages.paste || "Paste"},
            {role: "pasteAndMatchStyle", label: languages.pasteAsPlainText || "Paste and Match Style"},
            {type: "separator"},
            {role: "selectAll", label: languages.selectAll || "Select All"},
        ],
    }, {
        role: "windowMenu",
        label: languages.appMenuWindow || "Window",
        submenu: [
            {role: "minimize", label: languages.appMenuMinimize || "Minimize"},
            {role: "zoom", label: languages.zoom || "Zoom"},
            {role: "togglefullscreen", label: languages.appMenuTogglefullscreen || "Toggle Full Screen"},
            {type: "separator"},
            {
                label: languages.appMenuBringAllToFront || "Bring All to Front",
                click: () => {
                    const windows = BrowserWindow.getAllWindows();
                    windows.forEach(showWindow);
                    const target = (latestActiveWindow && !latestActiveWindow.isDestroyed() && windows.includes(latestActiveWindow))
                        ? latestActiveWindow
                        : windows[0];
                    target?.focus();
                },
            },
        ],
    }, {
        role: "help",
        label: languages.help || "Help",
        submenu: [
            ...(sync.readonly ? [] : [{
                label: languages.userGuide || "User Guide",
                click: () => {
                    getAppWindow()?.webContents.send("siyuan-open-help");
                },
            }]),
            {
                label: languages.feedback || "Feedback",
                click: () => {
                    shell.openExternal(getFeedbackUrl(sync.lang));
                },
            },
            {
                label: languages._trayMenu?.officialWebsite || "Visit official website",
                click: () => {
                    shell.openExternal("https://b3log.org/siyuan");
                },
            },
            {
                label: languages._trayMenu?.openSource || "Visit project on GitHub",
                click: () => {
                    shell.openExternal("https://github.com/siyuan-note/siyuan");
                },
            },
            getDevToolsMenuItem(languages.debug || "Developer Tools"),
        ],
    }];
    Menu.setApplicationMenu(Menu.buildFromTemplate(template));
};

const setStartupApplicationMenu = () => {
    // 启动阶段使用现有语言资源,工作空间就绪后再同步用户配置的语言和快捷键。
    let requestedLanguage = getArg("--lang");
    const workspaceDir = getArg("--workspace") || lastWorkspacePath;
    if (!requestedLanguage && !remoteKernelTarget && workspaceDir) {
        try {
            const config = JSON.parse(fs.readFileSync(path.join(workspaceDir, "conf", "conf.json"), "utf8"));
            requestedLanguage = config.appearance?.lang || config.lang;
        } catch (error) {
            writeLog("load startup menu workspace language failed: " + error.message);
        }
    }
    const language = resolveAppLanguage(typeof requestedLanguage === "string" && requestedLanguage
        ? [requestedLanguage] : app.getPreferredSystemLanguages());
    const languages = loadAppMenuLanguages(language);
    Menu.setApplicationMenu(Menu.buildFromTemplate([{
        role: "appMenu",
        label: "SiYuan",
        submenu: [
            {role: "about", label: languages.appMenuAbout},
            {type: "separator"},
            {role: "services", label: languages.appMenuServices},
            {type: "separator"},
            {role: "hide", label: languages.appMenuHide},
            {role: "hideOthers", label: languages.appMenuHideOthers},
            {role: "unhide", label: languages.showAll},
            {type: "separator"},
            {role: "quit", label: languages.appMenuQuit},
        ],
    }, {
        role: "editMenu",
        label: languages.edit,
        submenu: [
            ...["undo", "redo"].map(role => ({role, label: languages[role]})),
            {type: "separator"},
            ...["cut", "copy", "paste"].map(role => ({role, label: languages[role]})),
            {role: "pasteAndMatchStyle", label: languages.pasteAsPlainText},
            {type: "separator"},
            {role: "selectAll", label: languages.selectAll},
        ],
    }, {
        role: "windowMenu",
        label: languages.appMenuWindow,
        submenu: [
            {role: "minimize", label: languages.appMenuMinimize},
            {role: "zoom", label: languages.zoom},
            {role: "togglefullscreen", label: languages.appMenuTogglefullscreen},
            {type: "separator"},
            getDevToolsMenuItem(languages.debug),
            {type: "separator"},
            {role: "front", label: languages.appMenuBringAllToFront},
        ],
    }]));
};

const applyMacAppMenuForWindow = (wnd) => {
    if ("darwin" !== process.platform || !wnd || wnd.isDestroyed()) {
        return;
    }
    const workspaceDir = appMenuWorkspaceByWebContentsId.get(wnd.webContents.id);
    if (!workspaceDir) {
        return;
    }
    applyMacAppMenu(appMenuByWorkspaceDir.get(workspaceDir));
};

const shouldApplyAppMenuFrom = (webContentsId, workspaceDir) => {
    const focused = BrowserWindow.getFocusedWindow();
    if (isInitializedAppWindow(focused)) {
        if (focused.webContents.id === webContentsId) {
            return true;
        }
        return appMenuWorkspaceByWebContentsId.get(focused.webContents.id) === workspaceDir;
    }
    if (isInitializedAppWindow(latestActiveWindow)) {
        if (latestActiveWindow.webContents.id === webContentsId) {
            return true;
        }
        const latestWorkspace = appMenuWorkspaceByWebContentsId.get(latestActiveWindow.webContents.id);
        return !latestWorkspace || latestWorkspace === workspaceDir;
    }
    return true;
};

/**
 * 将 RFC 5646 格式的语言标签解析为应用支持的语言代码
 * https://www.rfc-editor.org/info/rfc5646
 * @param {string[]} languageTags - 语言标签数组(如 ["zh-Hans-CN", "en-US"])
 * @returns {string} 应用支持的语言代码
 */
const resolveAppLanguage = (languageTags) => {
    if (!languageTags || languageTags.length === 0) {
        return "en";
    }

    const tag = languageTags[0].toLowerCase();
    const parts = tag.replace(/_/g, "-").split("-");
    const language = parts[0];

    if (language === "zh") {
        if (tag.includes("hant")) {
            return "zh-TW";
        }
        if (tag.includes("hans") || tag.includes("cn") || tag.includes("sg")) {
            return "zh-CN";
        }
        if (tag.includes("tw") || tag.includes("hk") || tag.includes("mo")) {
            return "zh-TW";
        }
        return "zh-CN";
    }

    const languageMapping = {
        "en": "en",
        "ar": "ar",
        "de": "de",
        "es": "es",
        "fr": "fr",
        "he": "he",
        "hi": "hi",
        "id": "id",
        "it": "it",
        "ja": "ja",
        "ko": "ko",
        "nl": "nl",
        "pl": "pl",
        "pt": "pt-BR",
        "ru": "ru",
        "sk": "sk",
        "sr": "sr",
        "th": "th",
        "tr": "tr",
        "uk": "uk",
    };

    return languageMapping[language] || "en";
};

const loadAppleSiliconWarningLanguages = (requestedLanguage) => {
    const language = resolveAppLanguage(requestedLanguage ? [requestedLanguage] : app.getPreferredSystemLanguages());
    const languageDir = path.join(appDir, "appearance", "langs");
    try {
        const languageData = JSON.parse(fs.readFileSync(path.join(languageDir, `${language}.json`), "utf8"));
        const languages = languageData._trayMenu;
        if (languages && typeof languages.arm64TranslationTitle === "string" &&
            typeof languages.arm64TranslationMessage === "string" &&
            typeof languages.downloadAppleSilicon === "string") {
            return languages;
        }
    } catch (error) {
        writeLog("load Apple silicon warning languages failed: " + error);
    }
    return {
        arm64TranslationTitle: "Install the Apple silicon version",
        arm64TranslationMessage: "SiYuan is running the Intel version through Rosetta. This may significantly " +
            "reduce performance. Please use the Apple silicon version",
        downloadAppleSilicon: "Download the Apple silicon version",
    };
};

const markExpectedRendererExit = (window) => {
    if (window && !window.isDestroyed()) {
        expectedRendererExitIds.add(window.webContents.id);
    }
};

const exitWorkspace = (workspace, errorWindowId) => {
    if (!workspace) {
        return;
    }
    const workspaceIndex = workspaces.indexOf(workspace);
    const mainWindow = workspace.browserWindow;
    const tray = workspace.tray;
    const kernelOrigin = workspace.kernelTarget?.origin;

    // 关闭连接同一内核的所有非主窗口。
    BrowserWindow.getAllWindows().forEach((item) => {
        try {
            const currentURL = new URL(item.getURL());
            if (kernelOrigin && kernelOrigin === currentURL.origin) {
                if (!mainWindow || mainWindow.id !== item.id) {
                    item.destroy();
                }
            }
        } catch (e) {
            // load file is not a url
        }
    });
    if (workspaceIndex > -1) {
        if (workspaces.length > 1 && mainWindow && !mainWindow.isDestroyed()) {
            markExpectedRendererExit(mainWindow);
            mainWindow.destroy();
        }
        workspaces.splice(workspaceIndex, 1);
    }
    if (tray && ("win32" === process.platform || "linux" === process.platform)) {
        tray.destroy();
    }
    if (workspaces.length === 0 && mainWindow) {
        try {
            if (resetWindowStateOnRestart) {
                fs.writeFileSync(windowStatePath, "{}");
            } else {
                // 保存窗口状态供下次启动恢复。isMaximized 记录关闭时是否最大化;x/y/width/height 须用 getNormalBounds,
                // 其在任意窗口状态下均返回向下还原时的矩形。而 getBounds 在最大化时返回全屏尺寸,会导致还原时贴边。
                // https://github.com/siyuan-note/siyuan/issues/18154
                // https://www.electronjs.org/docs/latest/api/browser-window#wingetnormalbounds
                const bounds = mainWindow.getNormalBounds();
                fs.writeFileSync(windowStatePath, JSON.stringify({
                    isMaximized: mainWindow.isMaximized(),
                    fullscreen: mainWindow.isFullScreen(),
                    isDevToolsOpened: mainWindow.webContents.isDevToolsOpened(),
                    x: bounds.x,
                    y: bounds.y,
                    width: bounds.width,
                    height: bounds.height,
                }));
            }
        } catch (e) {
            writeLog(e);
        }

        if (errorWindowId) {
            markExpectedRendererExit(mainWindow);
            BrowserWindow.getAllWindows().forEach((item) => {
                if (errorWindowId !== item.id) {
                    item.destroy();
                }
            });
        } else {
            markExpectedRendererExit(mainWindow);
            if (keepAppOpenDuringSystemShutdown || keepAppOpenDuringUpdate) {
                mainWindow.destroy();
            } else {
                relaunchConnection();
                app.exit();
            }
        }
        globalShortcut.unregisterAll();
        writeLog("exited ui");
    }
};

const exitApp = (port, errorWindowId) => {
    if (port === undefined || port === null) {
        return;
    }
    const workspace = workspaces.find((item) => item.ownsKernel && port.toString() === item.port.toString());
    exitWorkspace(workspace, errorWindowId);
};

const localServer = "https://127.0.0.1";

const getServer = (port = kernelPort) => {
    return localServer + ":" + port;
};

const getKernelTarget = (target = kernelPort) => {
    if (target && typeof target === "object" && target.origin) {
        return target;
    }
    return createLocalKernelTarget(target);
};

const rememberWindowKernelTarget = (window, target) => {
    const webContentsId = window.webContents.id;
    windowKernelTargets.set(webContentsId, target);
    blockDragWindowFocusOrder.set(webContentsId, ++blockDragWindowFocusSequence);
    window.on("focus", () => {
        blockDragWindowFocusOrder.set(webContentsId, ++blockDragWindowFocusSequence);
    });
    if (target.mode === "remote") {
        window.webContents.on("will-frame-navigate", (event) => {
            if (shouldBlockRemoteFrameNavigation({isMainFrame: event.isMainFrame})) {
                event.preventDefault();
                writeLog("blocked subframe navigation in remote kernel mode [url=" + event.url + "]");
            }
        });
        window.webContents.on("will-attach-webview", (event) => {
            event.preventDefault();
            writeLog("blocked webview creation in remote kernel mode");
        });
    }
    window.webContents.on("did-start-navigation", (details) => {
        if (details.isMainFrame && !details.isSameDocument) {
            initializedWindowIds.delete(webContentsId);
            cleanupBlockDragSessions(webContentsId);
        }
    });
    window.webContents.on("render-process-gone", () => {
        initializedWindowIds.delete(webContentsId);
        cleanupBlockDragSessions(webContentsId);
    });
    window.webContents.once("destroyed", () => {
        initializedWindowIds.delete(webContentsId);
        windowKernelTargets.delete(webContentsId);
        cleanupBlockDragWindow(webContentsId);
    });
};

const getWindowKernelTarget = (webContentsId) => windowKernelTargets.get(webContentsId);

const getLocalRemoteResource = (pathname) => {
    let decodedPath;
    try {
        decodedPath = decodeURIComponent(pathname);
    } catch (error) {
        return;
    }
    if (decodedPath.includes("\0")) {
        return;
    }

    if (decodedPath === "/check-auth") {
        return isDevEnv
            ? path.join(appDir, "electron", "remote-auth.html")
            : path.join(appDir, "app", "electron", "remote-auth.html");
    }

    let resourceRoot;
    let relativePath;
    if (decodedPath.startsWith("/stage/")) {
        resourceRoot = path.join(appDir, "stage");
        relativePath = decodedPath.slice("/stage/".length);
    } else if (decodedPath.startsWith("/appearance/")) {
        resourceRoot = path.join(appDir, "appearance");
        relativePath = decodedPath.slice("/appearance/".length);
    } else {
        return;
    }

    let resourcePath = path.resolve(resourceRoot, relativePath);
    const relative = path.relative(resourceRoot, resourcePath);
    if (!relative || path.isAbsolute(relative) || relative === ".." || relative.startsWith(".." + path.sep)) {
        if (!relative && decodedPath.endsWith("/")) {
            resourcePath = path.join(resourcePath, "index.html");
        } else {
            return;
        }
    }
    try {
        if (fs.statSync(resourcePath).isDirectory()) {
            resourcePath = path.join(resourcePath, "index.html");
        }
        if (fs.statSync(resourcePath).isFile()) {
            return resourcePath;
        }
    } catch (error) {
        return;
    }
};

let remoteProtocolInstalled = false;
const installRemoteFrontendProtocol = (target) => {
    if (remoteProtocolInstalled) {
        return;
    }
    const scheme = new URL(target.origin).protocol.slice(0, -1);
    const remoteSession = getRemoteSession(target);
    remoteSession.webRequest.onBeforeRequest((details, callback) => {
        const destination = getRemoteKernelWebRequestDestination(details.resourceType);
        let requestPolicy = "remote";
        if (destination) {
            try {
                const requestURL = new URL(details.url);
                const isTargetOrigin = requestURL.origin === target.origin;
                const localResource = isTargetOrigin ? getLocalRemoteResource(requestURL.pathname) : undefined;
                requestPolicy = getRemoteKernelRequestPolicy({
                    method: details.method,
                    pathname: requestURL.pathname,
                    destination,
                    localResourceAvailable: Boolean(localResource),
                    isTargetOrigin,
                    trustRemoteExtensions: target.trustRemoteExtensions,
                });
            } catch (error) {
                requestPolicy = "deny-active-content";
            }
        }
        callback({
            cancel: shouldBlockRemoteFrameNavigation({resourceType: details.resourceType}) ||
                requestPolicy === "deny-active-content",
        });
    });
    remoteSession.protocol.handle(scheme, async (request) => {
        const forwardRequest = (includeCredentials = false) => remoteSession.fetch(request, {
            bypassCustomProtocolHandlers: true,
            redirect: "manual",
            ...(includeCredentials ? {credentials: "include"} : {}),
        });
        let requestURL;
        try {
            requestURL = new URL(request.url);
        } catch (error) {
            requestURL = undefined;
        }

        const isTargetOrigin = requestURL?.origin === target.origin;
        const requestPathname = requestURL?.pathname || "/";
        const localDocumentRequest = isTargetOrigin && (request.method === "GET" || request.method === "HEAD") &&
            ["/check-auth", "/stage/build/app/", "/stage/build/app/window.html", "/stage/build/app/settings.html"].includes(requestURL.pathname);
        const localResource = isTargetOrigin && (request.method === "GET" || request.method === "HEAD")
            ? getLocalRemoteResource(requestURL.pathname)
            : undefined;
        const requestDestination = request.headers.get("sec-fetch-dest") || request.destination;
        const requestPolicy = getRemoteKernelRequestPolicy({
            method: request.method,
            pathname: requestPathname,
            destination: requestDestination,
            localResourceAvailable: Boolean(localResource),
            isTargetOrigin,
            trustRemoteExtensions: target.trustRemoteExtensions,
        });
        if (requestPolicy === "deny-api") {
            writeLog("blocked remote kernel lifecycle request [path=" + requestPathname + "]");
            return new Response(JSON.stringify({
                code: -1,
                msg: "This operation is unavailable in remote kernel mode.",
            }), {
                status: 403,
                headers: {"Content-Type": "application/json; charset=utf-8"},
            });
        }
        if (requestPolicy === "deny-active-content") {
            return new Response("Forbidden", {
                status: 403,
                headers: {"Content-Type": "text/plain; charset=utf-8"},
            });
        }
        if (!isTargetOrigin) {
            return forwardRequest();
        }
        if (requestPolicy === "local") {
            if (localDocumentRequest) {
                let versionData;
                try {
                    versionData = await requestRemoteKernelVersion(target);
                } catch (error) {
                    writeLog("verify remote kernel version before loading local UI failed: " + error.message);
                    return new Response("Unable to verify the remote kernel version.", {
                        status: 502,
                        headers: {
                            "Cache-Control": "no-store",
                            "Content-Type": "text/plain; charset=utf-8",
                        },
                    });
                }
                const versionStatus = getRemoteKernelVersionStatus(versionData, appVer);
                if (versionStatus !== "compatible") {
                    writeLog("blocked local UI for an incompatible remote kernel [status=" + versionStatus + "]");
                    return new Response("The remote kernel version does not match this client.", {
                        status: 409,
                        headers: {
                            "Cache-Control": "no-store",
                            "Content-Type": "text/plain; charset=utf-8",
                        },
                    });
                }
            }
            if (localDocumentRequest &&
                ["/stage/build/app/", "/stage/build/app/window.html", "/stage/build/app/settings.html"].includes(requestURL.pathname)) {
                try {
                    if (!await probeRemoteKernelAuthentication(net, remoteSession, requestURL.href)) {
                        const authURL = new URL("/check-auth", target.origin);
                        authURL.searchParams.set("to", requestURL.pathname + requestURL.search);
                        authURL.searchParams.set("lang", resolveAppLanguage(app.getPreferredSystemLanguages()));
                        authURL.searchParams.set("remote", "1");
                        return new Response(null, {
                            status: 302,
                            headers: {
                                "Cache-Control": "no-store",
                                Location: authURL.href,
                            },
                        });
                    }
                } catch (error) {
                    writeLog("probe remote kernel authentication before loading local UI failed: " + error.message);
                    return new Response("Remote kernel UI probe failed.", {
                        status: error.statusCode >= 400 && error.statusCode <= 599 ? error.statusCode : 502,
                        headers: {
                            "Cache-Control": "no-store",
                            "Content-Type": "text/plain; charset=utf-8",
                        },
                    });
                }
            }
            const localResponse = await net.fetch(pathToFileURL(localResource).toString());
            if (localDocumentRequest) {
                const responseHeaders = new Headers(localResponse.headers);
                responseHeaders.set("Cache-Control", "no-store");
                responseHeaders.set("Content-Security-Policy",
                    createRemoteDocumentContentSecurityPolicy(fs.readFileSync(localResource, "utf8"), target.origin,
                        requestURL.pathname === "/check-auth" ? undefined : target.extensionScriptNonce));
                return new Response(localResponse.body, {
                    status: localResponse.status,
                    statusText: localResponse.statusText,
                    headers: responseHeaders,
                });
            }
            return localResponse;
        }
        if (requestPolicy === "not-found") {
            return new Response("Not Found", {
                status: 404,
                headers: {"Content-Type": "text/plain; charset=utf-8"},
            });
        }
        const response = await forwardRequest(true);
        const redirectDecision = getRemoteKernelRedirectDecision({
            status: response.status,
            location: response.headers.get("location"),
            origin: target.origin,
            method: request.method,
        });
        if (redirectDecision.action === "none") {
            return response;
        }
        if (redirectDecision.action === "deny") {
            await response.body?.cancel();
            writeLog("blocked remote kernel redirect outside the configured origin [path=" + requestURL.pathname + "]");
            return new Response("Forbidden redirect", {
                status: 403,
                headers: {"Content-Type": "text/plain; charset=utf-8"},
            });
        }
        const redirectLocalResource = redirectDecision.method === "GET" || redirectDecision.method === "HEAD"
            ? getLocalRemoteResource(redirectDecision.url.pathname)
            : undefined;
        const redirectPolicy = getRemoteKernelRequestPolicy({
            method: redirectDecision.method,
            pathname: redirectDecision.url.pathname,
            destination: requestDestination,
            localResourceAvailable: Boolean(redirectLocalResource),
            isTargetOrigin: true,
            trustRemoteExtensions: target.trustRemoteExtensions,
        });
        if (redirectPolicy === "deny-api" || redirectPolicy === "deny-active-content" ||
            redirectPolicy === "not-found") {
            await response.body?.cancel();
            writeLog("blocked unsafe remote kernel redirect [path=" + redirectDecision.url.pathname +
                ", policy=" + redirectPolicy + "]");
            return new Response(redirectPolicy === "not-found" ? "Not Found" : "Forbidden redirect", {
                status: redirectPolicy === "not-found" ? 404 : 403,
                headers: {"Content-Type": "text/plain; charset=utf-8"},
            });
        }
        return response;
    });
    remoteProtocolInstalled = true;
    writeLog("installed local frontend handler for remote kernel [origin=" + target.origin + "]");
};

const requestKernelExit = (port, options = {}, signal) => {
    if (!port) {
        return Promise.resolve();
    }

    const exitOptions = Object.assign({
        force: false,
        setCurrentWorkspace: true,
        execInstallPkg: 1,
    }, options);
    return net.fetch(getServer(port) + "/api/system/exit", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
        },
        body: JSON.stringify(exitOptions),
        signal,
    }).catch((error) => {
        writeLog("shutdown kernel failed [port=" + port + "]: " + error);
    });
};

const waitForKernelProcessExit = (port, timeout) => {
    const portKey = port.toString();
    const kernelProcess = kernelProcesses.get(portKey);
    if (!kernelProcess) {
        return Promise.resolve(true);
    }

    return new Promise((resolve) => {
        let timer;
        const onClose = () => {
            clearTimeout(timer);
            resolve(true);
        };
        kernelProcess.once("close", onClose);
        timer = setTimeout(() => {
            kernelProcess.removeListener("close", onClose);
            resolve(false);
        }, timeout);
    });
};

const requestUpdateKernelExit = async (port, options) => {
    const abortController = new AbortController();
    const timeout = setTimeout(() => abortController.abort(), updateKernelExitTimeout);
    try {
        const response = await requestKernelExit(port, options, abortController.signal);
        if (!response) {
            return false;
        }
        const apiData = await response.json();
        if (apiData.code === 0) {
            writeLog("update kernel exit request succeeded [port=" + port + "]");
            return apiData;
        }
        writeLog("update kernel exit request failed [port=" + port + ", code=" + apiData.code + "]");
    } catch (error) {
        writeLog("parse update kernel exit response failed [port=" + port + "]: " + error);
    } finally {
        clearTimeout(timeout);
    }
    return false;
};

const closeKernelForUpdate = async (port, initiatingPort, setCurrentWorkspace) => {
    const isInitiatingKernel = port.toString() === initiatingPort.toString();
    const exitResponse = await requestUpdateKernelExit(port, {
        force: isInitiatingKernel,
        setCurrentWorkspace: isInitiatingKernel && setCurrentWorkspace,
        execInstallPkg: isInitiatingKernel ? 2 : 1,
    });
    if (exitResponse) {
        return exitResponse;
    }

    writeLog("forcing kernel to exit for update [port=" + port + "]");
    return requestUpdateKernelExit(port, {
        force: true,
        setCurrentWorkspace: isInitiatingKernel && setCurrentWorkspace,
        execInstallPkg: isInitiatingKernel ? 2 : 1,
    });
};

const validateUpdateInstallRequest = (event, data) => {
    const workspace = workspaces.find((item) => item.webContentsId === event.sender.id);
    if (!workspace || !workspace.ownsKernel || !workspace.workspaceDir || !data || !data.port ||
        workspace.port.toString() !== data.port.toString()) {
        writeLog("rejected update install request from an unknown workspace");
        return;
    }
    if (process.platform !== "win32" && process.platform !== "darwin") {
        writeLog("rejected update install request on unsupported platform [platform=" + process.platform + "]");
        return;
    }

    return {
        initiatingPort: workspace.port.toString(),
        setCurrentWorkspace: data.setCurrentWorkspace !== false,
        workspaceDir: workspace.workspaceDir,
    };
};

const validateUpdateInstallPackage = (request, requestedInstallPkgPath) => {
    if (!requestedInstallPkgPath) {
        writeLog("the initiating kernel did not return an update install package");
        return;
    }

    try {
        const installPkgPath = fs.realpathSync(requestedInstallPkgPath);
        const installDirs = [path.join(confDir, "install"), path.join(request.workspaceDir, "temp", "install")];
        const contained = installDirs.some((directory) => {
            if (!fs.existsSync(directory)) {
                return false;
            }
            const relativePkgPath = path.relative(fs.realpathSync(directory), installPkgPath);
            return relativePkgPath && !path.isAbsolute(relativePkgPath) && path.dirname(relativePkgPath) === ".";
        });
        if (!contained) {
            writeLog("rejected update install package outside the install directories [path=" + installPkgPath + "]");
            return;
        }

        const packageName = path.basename(installPkgPath);
        const validPackageName = process.platform === "win32"
            ? /^siyuan-.+-win(?:-arm64)?\.exe$/i.test(packageName)
            : /^siyuan-.+-mac(?:-arm64)?\.dmg$/i.test(packageName);
        if (!validPackageName || !fs.statSync(installPkgPath).isFile()) {
            writeLog("rejected invalid update install package [path=" + installPkgPath + "]");
            return;
        }
        writeLog("validated update install package [path=" + installPkgPath + "]");
        return installPkgPath;
    } catch (error) {
        writeLog("validate update install package failed: " + error);
    }
};

const launchUpdateInstallPackage = (installPkgPath) => {
    return new Promise((resolve, reject) => {
        const command = process.platform === "darwin" ? "/usr/bin/open" : installPkgPath;
        const args = process.platform === "darwin" ? [installPkgPath] : [];
        const installProcess = childProcess.spawn(command, args, {
            cwd: path.dirname(installPkgPath),
            detached: true,
            stdio: "ignore",
        });
        installProcess.once("error", reject);
        installProcess.once("spawn", () => {
            writeLog("launched update install package [pid=" + installProcess.pid + ", path=" + installPkgPath + "]");
            installProcess.unref();
            resolve();
        });
    });
};

const waitForUpdateKernelExits = async (ports) => {
    if (ports.length === 0) {
        return;
    }

    const exitResults = await Promise.all(ports.map(async (port) => {
        return {
            port,
            exited: await waitForKernelProcessExit(port, updateKernelExitTimeout),
        };
    }));
    const timedOutPorts = exitResults.filter((item) => !item.exited).map((item) => item.port);
    if (timedOutPorts.length === 0) {
        return;
    }

    writeLog("kernel exit timed out before update [ports=" + timedOutPorts.join(",") + "]");
    timedOutPorts.forEach((port) => {
        const kernelProcess = kernelProcesses.get(port);
        if (kernelProcess) {
            writeLog("terminating residual kernel before update [pid=" + kernelProcess.pid + ", port=" + port + "]");
            kernelProcess.kill("SIGKILL");
        }
    });
    await Promise.all(timedOutPorts.map((port) => waitForKernelProcessExit(port, 5000)));
    const residualPorts = timedOutPorts.filter((port) => kernelProcesses.has(port));
    if (residualPorts.length > 0) {
        if (process.platform === "win32") {
            writeLog("residual kernel processes will be terminated by the installer [ports=" + residualPorts.join(",") + "]");
        } else {
            throw new Error("failed to terminate residual kernel processes [ports=" + residualPorts.join(",") + "]");
        }
    }
};

const closeUpdateKernelStage = async (ports, request) => {
    if (ports.length === 0) {
        return [];
    }

    const exitResponses = await Promise.all(ports.map((port) => closeKernelForUpdate(port, request.initiatingPort,
        request.setCurrentWorkspace)));
    ports.forEach((port) => exitApp(port));
    await waitForUpdateKernelExits(ports);
    return exitResponses;
};

// 更新时先退出其他工作空间,再退出发起更新的工作空间,确保安装器启动前所有内核已经停止。
// https://github.com/siyuan-note/siyuan/issues/18258
const coordinateUpdateInstall = async (request) => {
    const ports = Array.from(new Set(getSystemShutdownPorts().map((port) => port.toString())
        .concat(Array.from(kernelProcesses.keys()), request.initiatingPort)));
    ports.forEach((port) => expectedKernelExitPorts.add(port));
    writeLog("coordinating update install [initiatingPort=" + request.initiatingPort + ", ports=" + ports.join(",") +
        "]");

    workspaces.forEach((workspace) => {
        if (workspace.browserWindow && !workspace.browserWindow.isDestroyed()) {
            workspace.browserWindow.hide();
        }
    });

    const otherPorts = ports.filter((port) => port !== request.initiatingPort);
    writeLog("closing other workspaces for update [ports=" + otherPorts.join(",") + "]");
    await closeUpdateKernelStage(otherPorts, request);
    writeLog("closing initiating workspace for update [port=" + request.initiatingPort + "]");
    const [initiatingExitResponse] = await closeUpdateKernelStage([request.initiatingPort], request);
    const installPkgPath = validateUpdateInstallPackage(request, initiatingExitResponse?.data?.installPkgPath);
    if (!installPkgPath) {
        throw new Error("the update install package returned by the kernel is invalid");
    }

    await launchUpdateInstallPackage(installPkgPath);
    keepAppOpenDuringUpdate = false;
    app.exit();
};

const beginUpdateInstall = (event, data) => {
    if (updateInstallPromise) {
        writeLog("ignored duplicate update install request");
        return true;
    }
    if (systemShutdownState !== systemShutdownNone) {
        writeLog("rejected update install request during system shutdown");
        return false;
    }

    const request = validateUpdateInstallRequest(event, data);
    if (!request) {
        return false;
    }

    keepAppOpenDuringUpdate = true;
    updateInstallPromise = coordinateUpdateInstall(request).catch((error) => {
        writeLog("coordinate update install failed: " + error);
        keepAppOpenDuringUpdate = false;
        updateInstallPromise = undefined;
        app.relaunch();
        app.exit();
    });
    return true;
};

const getSystemShutdownPorts = () => {
    const ports = new Set();
    workspaces.forEach((workspaceItem) => {
        if (workspaceItem.ownsKernel && workspaceItem.port) {
            ports.add(workspaceItem.port);
        }
    });
    if (!remoteKernelTarget) {
        bootWindows.forEach(window => {
            if (!window.isDestroyed() && window.kernelPort) ports.add(window.kernelPort);
        });
    }
    return Array.from(ports);
};

const requestGracefulKernelExit = async (port) => {
    const portKey = port.toString();
    if (exitedKernelPorts.has(portKey)) {
        return true;
    }
    const abortController = new AbortController();
    const timeout = setTimeout(() => abortController.abort(), systemShutdownExitTimeout);
    try {
        const response = await requestKernelExit(port, {
            force: false,
            setCurrentWorkspace: false,
            execInstallPkg: 1,
        }, abortController.signal);
        if (!response) {
            return exitedKernelPorts.has(portKey);
        }

        const apiData = await response.json();
        if (apiData.code !== 0) {
            writeLog("graceful system shutdown failed [port=" + port + ", code=" + apiData.code + "]");
            return exitedKernelPorts.has(portKey);
        }
        writeLog("graceful system shutdown succeeded [port=" + port + "]");
        return true;
    } catch (error) {
        writeLog("parse graceful system shutdown response failed [port=" + port + "]: " + error);
        return exitedKernelPorts.has(portKey);
    } finally {
        clearTimeout(timeout);
    }
};

const resetSystemShutdown = (ports) => {
    if (systemShutdownState === systemShutdownForced) {
        return;
    }

    systemShutdownState = systemShutdownNone;
    gracefulSystemShutdownPromise = undefined;
    keepAppOpenDuringSystemShutdown = false;
    writeLog("system shutdown canceled because SiYuan failed to exit gracefully [ports=" + ports.join(",") + "]");
    ports.forEach((port) => {
        const workspace = workspaces.find((item) => port.toString() === item.port.toString());
        if (workspace && workspace.browserWindow && !workspace.browserWindow.isDestroyed()) {
            showWindow(workspace.browserWindow);
        }
    });
    bootWindows.forEach(window => {
        if (ports.includes(window.kernelPort)) showWindow(window);
    });
};

const beginGracefulSystemShutdown = () => {
    if (gracefulSystemShutdownPromise || systemShutdownState === systemShutdownForced) {
        return;
    }

    systemShutdownState = systemShutdownEnding;
    const ports = getSystemShutdownPorts();
    if (ports.length === 0) {
        app.exit();
        return;
    }

    keepAppOpenDuringSystemShutdown = true;
    gracefulSystemShutdownPromise = Promise.all(ports.map(async (port) => {
        return {
            port,
            success: await requestGracefulKernelExit(port),
        };
    })).then((results) => {
        const succeededPorts = results.filter((item) => item.success).map((item) => item.port);
        const failedPorts = results.filter((item) => !item.success).map((item) => item.port);
        succeededPorts.forEach((port) => exitApp(port));
        bootWindows.forEach(window => {
            if (!window.isDestroyed() && succeededPorts.includes(window.kernelPort)) window.destroy();
        });

        const remainingPorts = getSystemShutdownPorts();
        const incompletePorts = Array.from(new Set(failedPorts.concat(remainingPorts)));
        if (incompletePorts.length > 0) {
            resetSystemShutdown(incompletePorts);
            return;
        }
        keepAppOpenDuringSystemShutdown = false;
        app.exit();
    }).catch((error) => {
        writeLog("graceful system shutdown failed: " + error);
        resetSystemShutdown(getSystemShutdownPorts());
    });
};

const beginForcedSystemShutdown = () => {
    if (systemShutdownState === systemShutdownForced) {
        return;
    }

    systemShutdownState = systemShutdownForced;
    keepAppOpenDuringSystemShutdown = false;
    getSystemShutdownPorts().forEach((port) => {
        requestKernelExit(port, {
            force: true,
            setCurrentWorkspace: false,
        });
    });
};

if (process.platform === "win32") {
    // Windows 关机、重启或注销时取消本次会话结束,等待内核安全退出后再关闭思源。
    app.on("browser-window-created", (event, window) => {
        window.on("query-session-end", (sessionEvent) => {
            writeLog("query-session-end");
            sessionEvent.preventDefault();
            beginGracefulSystemShutdown();
        });
        window.on("session-end", () => {
            writeLog("session-end");
            beginForcedSystemShutdown();
        });
    });
}

const sleep = (ms) => {
    return new Promise(resolve => setTimeout(resolve, ms));
};

const showErrorWindow = (titleZh, titleEn, content, emoji = "⚠️", logPath = "") => {
    if (connectionManager && (remoteKernelTarget || remoteKernelArgError)) {
        return connectionManager.show({lang: getArg("--lang"), error: titleZh + "\n" + titleEn + "\n" +
            content.replace(/<[^>]*>/g, " ")});
    }
    let errorHTMLPath = path.join(appDir, "app", "electron", "error.html");
    if (isDevEnv) {
        errorHTMLPath = path.join(appDir, "electron", "error.html");
    }
    const errWindow = new BrowserWindow({
        width: Math.floor(screen.getPrimaryDisplay().size.width * 0.5),
        height: Math.floor(screen.getPrimaryDisplay().workAreaSize.height * 0.8),
        frame: "darwin" === process.platform,
        titleBarStyle: "hidden",
        fullscreenable: false,
        icon: path.join(appDir, "stage", "icon-large.png"),
        transparent: "darwin" === process.platform, // 避免深色模式关闭窗口时闪现白色背景
        webPreferences: {
            nodeIntegration: true, webviewTag: true, webSecurity: false, contextIsolation: false,
        },
    });
    errWindow.loadFile(errorHTMLPath, {
        query: {
            home: app.getPath("home"),
            v: appVer,
            title: `<h2>${titleZh}</h2><h2>${titleEn}</h2>`,
            emoji,
            content,
            logPath,
            icon: path.join(appDir, "stage", "icon-large.png"),
        },
    });
    errWindow.show();
    return errWindow.id;
};

const initMainWindow = (kernel = kernelPort, remoteAuthenticated = true) => {
    if (!app.isReady()) {
        writeLog("initMainWindow: app not ready, skipping");
        return;
    }
    const kernelTarget = getKernelTarget(kernel);
    const currentKernelPort = kernelTarget.port;
    const startup = kernelTarget.mode === "remote" ? undefined : Array.from(localKernelStartups.values())
        .find(item => item.port?.toString() === currentKernelPort.toString());
    const currentBootWindow = startup ? startup.window : (kernelTarget.mode === "remote" ? bootWindow : undefined);

    // 恢复主窗体状态
    let oldWindowState = {};
    try {
        oldWindowState = JSON.parse(fs.readFileSync(windowStatePath, "utf8"));
    } catch (e) {
        writeLog("read window state failed: " + e);
        fs.writeFileSync(windowStatePath, "{}");
    }
    let defaultWidth;
    let defaultHeight;
    let workArea;
    try {
        defaultWidth = Math.floor(screen.getPrimaryDisplay().size.width * 0.8);
        defaultHeight = Math.floor(screen.getPrimaryDisplay().workAreaSize.height * 0.8);
        workArea = screen.getPrimaryDisplay().workArea;
    } catch (e) {
        writeLog("get screen size failed: " + e);
    }
    const windowState = Object.assign({}, {
        isMaximized: false,
        fullscreen: false,
        isDevToolsOpened: false,
        x: 0,
        y: 0,
        width: defaultWidth,
        height: defaultHeight,
    }, oldWindowState);

    writeLog("window stat [x=" + windowState.x + ", y=" + windowState.y + ", width=" + windowState.width + ", height=" + windowState.height + ", isMaximized=" + windowState.isMaximized + "], " +
        "default [x=0, y=0, width=" + defaultWidth + ", height=" + defaultHeight + "], " +
        "old [x=" + oldWindowState.x + ", y=" + oldWindowState.y + ", width=" + oldWindowState.width + ", height=" + oldWindowState.height + ", isMaximized=" + oldWindowState.isMaximized + "]");

    let resetToCenter = false;
    let x = windowState.x;
    if (-32 < x && 0 > x) {
        x = 0;
    }
    let y = windowState.y;
    if (-32 < y && 0 > y) {
        y = 0;
    }
    if (workArea) {
        // 窗口大于 workArea 时缩小会隐藏到左下角,这里使用最小值重置
        if (windowState.width > workArea.width + 32 || windowState.height > workArea.height + 32) {
            // 重启后窗口大小恢复默认问题 https://github.com/siyuan-note/siyuan/issues/7755 https://github.com/siyuan-note/siyuan/issues/13732
            // 这里 +32 是因为在某种情况下窗口大小会比 workArea 大几个像素导致恢复默认,+32 可以避免这种特殊情况
            windowState.width = Math.min(defaultWidth, workArea.width);
            windowState.height = Math.min(defaultHeight, workArea.height);
            writeLog("reset window size [width=" + windowState.width + ", height=" + windowState.height + "]");
        }

        if (x >= workArea.width * 0.8 || y >= workArea.height * 0.8) {
            resetToCenter = true;
            writeLog("reset window to center cause x or y >= 80% of workArea");
        }
    }

    if (x < 0 || y < 0) {
        resetToCenter = true;
        writeLog("reset window to center cause x or y < 0");
    }

    if (windowState.width < 493) {
        windowState.width = 493;
        writeLog("reset window width [493]");
    }
    if (windowState.height < 376) {
        windowState.height = 376;
        writeLog("reset window height [376]");
    }

    // 创建主窗体
    const currentWindow = new BrowserWindow({
        title: "SiYuan",
        show: false,
        width: windowState.width,
        height: windowState.height,
        minWidth: 493,
        minHeight: 376,
        fullscreenable: true,
        fullscreen: windowState.fullscreen,
        trafficLightPosition: {x: 8, y: 8},
        webPreferences: {
            nodeIntegration: true,
            nodeIntegrationInSubFrames: false,
            nodeIntegrationInWorker: false,
            webviewTag: kernelTarget.mode !== "remote",
            webSecurity: kernelTarget.mode === "remote",
            ...(kernelTarget.mode === "remote" ? {session: getRemoteSession(kernelTarget)} : {}),
            contextIsolation: false,
            autoplayPolicy: "user-gesture-required" // 桌面端禁止自动播放多媒体 https://github.com/siyuan-note/siyuan/issues/7587
        },
        frame: "darwin" === process.platform,
        titleBarStyle: "hidden",
        // 首帧按默认主题的工具栏高度预留,融合页签与自定义主题由渲染进程校正。
        titleBarOverlay: getTitleBarOverlayOptions(),
        icon: path.join(appDir, "stage", "icon-large.png"),
    });
    remote.enable(currentWindow.webContents);
    bindSpellcheckContextMenu(currentWindow.webContents);
    bindTopBarContextMenu(currentWindow);
    rememberWindowKernelTarget(currentWindow, kernelTarget);

    if (resetToCenter) {
        currentWindow.center();
    } else {
        writeLog("window position [x=" + x + ", y=" + y + "]");
        currentWindow.setPosition(x, y);
    }
    currentWindow.webContents.userAgent = "SiYuan/" + appVer + " https://b3log.org/siyuan Electron " + currentWindow.webContents.userAgent;

    // 加载主界面。setProxy 用超时兜底包装:Electron 在某些系统代理配置下 session.setProxy 可能永久
    // pending(既不 resolve 也不 reject),会导致 loadURL 永不执行,主窗口卡在启动页无法显示。
    // 这里无论 setProxy 是否完成,最多等待 5 秒后强制加载主界面。
    const loadMainURL = () => {
        const appURL = new URL("/stage/build/app/", kernelTarget.origin);
        appURL.searchParams.set("v", Date.now().toString());
        if (kernelTarget.mode === "remote") {
            appURL.searchParams.set("remote", "1");
        }
        if (kernelTarget.mode === "remote" && !remoteAuthenticated) {
            const authURL = new URL("/check-auth", kernelTarget.origin);
            authURL.searchParams.set("to", appURL.pathname + appURL.search);
            authURL.searchParams.set("lang", resolveAppLanguage(app.getPreferredSystemLanguages()));
            authURL.searchParams.set("remote", "1");
            currentWindow.loadURL(authURL.href);
        } else {
            currentWindow.loadURL(appURL.href);
        }
    };
    if (kernelTarget.mode === "remote") {
        loadMainURL();
    } else {
        net.fetch(getServer(currentKernelPort) + "/api/system/getNetwork", {method: "POST"}).then((response) => {
            return response.json();
        }).then((response) => {
            const proxyMode = response.data.proxy.scheme === "system" ? "system" : response.data.proxy.scheme === "" ? "direct" : "fixed_servers";
            const setProxyDone = setProxy(`${response.data.proxy.scheme}://${response.data.proxy.host}:${response.data.proxy.port}`,
                currentWindow.webContents, proxyMode);
            Promise.race([
                Promise.resolve(setProxyDone),
                new Promise((resolve) => setTimeout(resolve, 5000)), // setProxy 永久 pending 时的超时兜底
            ]).then(loadMainURL).catch(() => {
                writeLog("setProxy failed, load main UI without proxy");
                loadMainURL();
            });
        }).catch((e) => {
            // getNetwork 失败也要继续加载主界面,避免主窗口不加载导致卡在启动页
            writeLog("getNetwork failed, load main UI without proxy: " + e.message);
            loadMainURL();
        });
    }

    // 发起互联网服务请求时绕过安全策略 https://github.com/siyuan-note/siyuan/issues/5516
    currentWindow.webContents.session.webRequest.onBeforeSendHeaders((details, cb) => {
        if (-1 < details.url.toLowerCase().indexOf("bili")) {
            // B 站不移除 Referer https://github.com/siyuan-note/siyuan/issues/94
            cb({requestHeaders: details.requestHeaders});
            return;
        }

        if (-1 < details.url.toLowerCase().indexOf("douyin")) {
            // 抖音不移除 Referer,iframe 块内登录依赖 Referer 校验 https://github.com/siyuan-note/siyuan/issues/18070
            cb({requestHeaders: details.requestHeaders});
            return;
        }

        if (-1 < details.url.toLowerCase().indexOf("youtube")) {
            // YouTube 设置 Referer https://github.com/siyuan-note/siyuan/issues/16319
            details.requestHeaders["Referer"] = "https://b3log.org/siyuan/";
            cb({requestHeaders: details.requestHeaders});
            return;
        }

        for (let key in details.requestHeaders) {
            if ("referer" === key.toLowerCase()) {
                delete details.requestHeaders[key];
            }
        }
        cb({requestHeaders: details.requestHeaders});
    });
    currentWindow.webContents.session.webRequest.onHeadersReceived((details, cb) => {
        let preserveRemoteDocumentCSP = false;
        if (kernelTarget.mode === "remote") {
            try {
                const responseURL = new URL(details.url);
                preserveRemoteDocumentCSP = responseURL.origin === kernelTarget.origin &&
                    ["/check-auth", "/stage/build/app/", "/stage/build/app/window.html", "/stage/build/app/settings.html"].includes(responseURL.pathname);
            } catch (error) {
                preserveRemoteDocumentCSP = false;
            }
        }
        for (let key in details.responseHeaders) {
            if ("x-frame-options" === key.toLowerCase()) {
                delete details.responseHeaders[key];
            } else if ("content-security-policy" === key.toLowerCase()) {
                if (!preserveRemoteDocumentCSP) {
                    delete details.responseHeaders[key];
                }
            }
        }
        cb({responseHeaders: details.responseHeaders});
    });

    currentWindow.webContents.on("did-finish-load", () => {
        if (kernelTarget.mode === "remote") {
            if (getWindowPathname(currentWindow) === "/check-auth") {
                currentWindow.show();
                if (currentBootWindow && !currentBootWindow.isDestroyed()) {
                    currentBootWindow.destroy();
                }
            }
            return;
        }
    });

    if ("darwin" !== process.platform) {
        setStartupApplicationMenu();
    }
    // 当前页面链接使用浏览器打开
    windowNavigate(currentWindow, "app", kernelTarget.origin, kernelTarget.mode === "remote");
    currentWindow.on("close", (event) => {
        if (kernelTarget.mode === "remote" && (getWindowPathname(currentWindow) !== "/stage/build/app/" ||
            !initializedWindowIds.has(currentWindow.webContents.id))) {
            event.preventDefault();
            exitWorkspace(workspaces.find((item) => item.webContentsId === currentWindow.webContents.id));
            return;
        }
        if (currentWindow && !currentWindow.isDestroyed()) {
            currentWindow.webContents.send("siyuan-save-close", false);
        }
        event.preventDefault();
    });
    workspaces.push({
        browserWindow: currentWindow,
        webContentsId: currentWindow.webContents.id,
        port: currentKernelPort,
        ownsKernel: kernelTarget.ownsKernel,
        kernelTarget,
        workspaceDir: startup?.workspace,
    });
    if (startup) localKernelStartups.delete(getWorkspaceStartupKey(startup.workspace));
    bindMainWindowReady(currentWindow, currentBootWindow, windowState, () => {
        if (kernelTarget.mode === "remote") return;
        const siyuanOpenURL = process.argv.find((arg) => arg.startsWith("siyuan://"));
        if (siyuanOpenURL) {
            writeLog(siyuanOpenURL);
            currentWindow.webContents.send("siyuan-open-url", siyuanOpenURL);
        }
    });
};

const bindMainWindowReady = (currentWindow, currentBootWindow, windowState, onReady) => {
    // loadURL 后设置超时兜底:前端 app bundle 加载或初始化异常导致 siyuan-ready-to-show 迟迟不发时,
    // 强制销毁 boot 窗口并显示主窗口,避免永久卡在启动页
    const readyToShowTimeout = setTimeout(() => {
        ipcMain.removeListener("siyuan-ready-to-show", readyToShow);
        if (currentBootWindow && !currentBootWindow.isDestroyed()) {
            if (!currentWindow.isDestroyed()) {
                writeLog("siyuan-ready-to-show timeout, force showing main window");
                currentWindow.show();
            }
            currentBootWindow.destroy();
        }
    }, 60000);
    const readyToShow = (event) => {
        if (event.sender !== currentWindow.webContents) return;
        ipcMain.removeListener("siyuan-ready-to-show", readyToShow);
        clearTimeout(readyToShowTimeout); // 正常收到信号则取消超时兜底
        if (isOpenAsHidden()) {
            if (windowState.isMaximized) {
                // 隐藏启动时延迟到首次还原再最大化,避免最大化操作提前显示窗口。
                currentWindow.once("restore", () => {
                    currentWindow.maximize();
                });
            }
            currentWindow.minimize();
        } else {
            currentWindow.show();
            if (windowState.isMaximized) {
                currentWindow.maximize();
            } else {
                currentWindow.unmaximize();
            }
            if (windowState.isDevToolsOpened) {
                devToolsDock.openDevTools(currentWindow.webContents); // 保证开发者工具窗口在前
            }
        }
        if (currentBootWindow && !currentBootWindow.isDestroyed()) {
            currentBootWindow.destroy();
        }
        onReady?.();
    };
    ipcMain.on("siyuan-ready-to-show", readyToShow);
    currentWindow.once("closed", () => {
        clearTimeout(readyToShowTimeout);
        ipcMain.removeListener("siyuan-ready-to-show", readyToShow);
        if (currentBootWindow && !currentBootWindow.isDestroyed()) currentBootWindow.destroy();
    });
};

const showWindow = (wnd) => {
    if (!wnd || wnd.isDestroyed()) {
        return;
    }

    if (wnd.isMinimized()) {
        wnd.restore();
    }
    wnd.show();
};

const hideWindow = (wnd) => {
    // 通过 `Alt+M` 最小化后焦点回到先前的窗口 https://github.com/siyuan-note/siyuan/issues/7275
    wnd.minimize();
    // Mac 隐藏后无法再 Dock 中显示
    if ("win32" === process.platform || "linux" === process.platform) {
        wnd.hide();
    }
};

const toggleMainWindow = (mainWindow) => {
    if (!mainWindow || mainWindow.isDestroyed()) {
        return;
    }
    if (mainWindow.isMinimized()) {
        mainWindow.restore();
        mainWindow.show(); // 按 `Alt+M` 后隐藏窗口,再次按 `Alt+M` 显示窗口后会卡住不能编辑 https://github.com/siyuan-note/siyuan/issues/8456
    } else if (mainWindow.isVisible()) {
        if (!mainWindow.isFocused()) {
            mainWindow.show();
        } else {
            hideWindow(mainWindow);
        }
    } else {
        mainWindow.show();
    }
};

const showAppleSiliconWarning = async (lang) => {
    if (!shouldShowAppleSiliconWarning({
        isDevelopment: isDevEnv,
        isPackaged: app.isPackaged,
        platform: process.platform,
        runningUnderARM64Translation: app.runningUnderARM64Translation,
        simulateRosetta,
    })) {
        return true;
    }
    if (appleSiliconWarningShown) {
        return false;
    }

    appleSiliconWarningShown = true;
    const languages = loadAppleSiliconWarningLanguages(lang);
    try {
        const {response} = await dialog.showMessageBox({
            type: "warning",
            title: languages.arm64TranslationTitle,
            message: languages.arm64TranslationTitle,
            detail: languages.arm64TranslationMessage,
            buttons: [languages.downloadAppleSilicon],
            defaultId: 0,
            // 使用按钮数组之外的取消 ID,以区分关闭弹窗和点击下载。
            cancelId: 1,
            noLink: true,
        });
        if (shouldDownloadAppleSilicon(response)) {
            await shell.openExternal(getAppleSiliconDownloadURL(appVer));
        }
    } catch (error) {
        writeLog("show Apple silicon warning or open package download failed: " + error);
    }
    return false;
};

const loadBootWindow = (disableAppearance = false, currentBootWindow = bootWindow, port = kernelPort, lang = getArg("--lang")) => {
    if (!currentBootWindow || currentBootWindow.isDestroyed() || !bootIndexPath) {
        return;
    }
    if (disableAppearance) {
        currentBootWindow.appearanceFallback = true;
    }
    const query = {v: appVer, port, lang: lang || resolveAppLanguage(app.getPreferredSystemLanguages())};
    currentBootWindow.kernelPort = port;
    currentBootWindow.lang = lang;
    if (currentBootWindow.previousExitWaiting) {
        query.previousExitWaiting = currentBootWindow.previousExitWaiting;
    }
    if (remoteKernelTarget) {
        query.remote = remoteKernelTarget.origin;
        query.appearance = "0";
    }
    if (currentBootWindow.appearanceFallback) {
        query.appearance = "0";
    }
    currentBootWindow.loadFile(bootIndexPath, {query}).catch((error) => {
        writeLog("load boot window failed: " + error);
    });
};

const createBootWindow = () => {
    bootWindow = new BrowserWindow({
        show: false,
        width: Math.floor(screen.getPrimaryDisplay().size.width / 2),
        height: Math.floor(screen.getPrimaryDisplay().workAreaSize.height / 2),
        frame: false,
        backgroundColor: "#1e1e1e",
        resizable: false,
        icon: path.join(appDir, "stage", "icon-large.png"),
        webPreferences: {
            nodeIntegration: true,
            contextIsolation: false,
            webSecurity: false,
        },
    });
    const currentBootWindow = bootWindow;
    bootWindows.add(currentBootWindow);
    currentBootWindow.once("closed", () => bootWindows.delete(currentBootWindow));
    bootIndexPath = path.join(appDir, "app", "electron", "boot.html");
    if (isDevEnv) {
        bootIndexPath = path.join(appDir, "electron", "boot.html");
    }
    currentBootWindow.on("unresponsive", () => {
        if (!currentBootWindow.appearanceFallback) {
            writeLog("boot window is unresponsive, reload without custom appearance");
            loadBootWindow(true, currentBootWindow, currentBootWindow.kernelPort, currentBootWindow.lang);
        }
    });
    return currentBootWindow;
};

const getAvailablePort = (port, useDevKernel = isDevEnv && workspaces.length === 0) => {
    if (useDevKernel) {
        return Promise.resolve(kernelPort);
    }
    if (port) {
        kernelPort = port;
        return Promise.resolve(kernelPort);
    }
    return new Promise((resolve) => {
        const server = gNet.createServer();
        server.on("error", error => {
            writeLog(error);
            kernelPort = "";
            resolve("");
        });
        server.listen(0, () => {
            const availablePort = server.address().port;
            kernelPort = availablePort;
            server.close(() => resolve(availablePort));
        });
    });
};

const showLocalBootWindow = (currentBootWindow = bootWindow, port = kernelPort, lang) => {
    const bootWindowCreatedAt = Date.now();
    if (!openAsHidden) {
        if ("win32" === process.platform) {
            currentBootWindow.setOpacity(0);
        }
        currentBootWindow.once("ready-to-show", () => {
            if (!currentBootWindow.isDestroyed()) {
                currentBootWindow.show();
                writeLog("boot window ready to show [" + (Date.now() - bootWindowCreatedAt) + "ms since load]");
                if ("win32" === process.platform) {
                    setImmediate(() => {
                        if (!currentBootWindow.isDestroyed()) {
                            currentBootWindow.setOpacity(1);
                        }
                    });
                }
            }
        });
    }
    loadBootWindow(false, currentBootWindow, port, lang);
    if (openAsHidden) {
        currentBootWindow.minimize();
    }
};

const getWorkspaceStartupKey = workspace => {
    const resolved = path.resolve(workspace);
    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
};

const initKernel = async (workspace, port, lang, safeMode, preparedBoot) => {
    workspace = [workspace, process.env.SIYUAN_WORKSPACE_PATH, lastWorkspacePath]
        .find(item => typeof item === "string" && item);
    const key = getWorkspaceStartupKey(workspace);
    const existing = localKernelStartups.get(key);
    const opened = workspaces.find(item => item.workspaceDir && getWorkspaceStartupKey(item.workspaceDir) === key &&
        item.browserWindow && !item.browserWindow.isDestroyed());
    if (existing || opened) {
        showWindow(existing ? existing.window : opened.browserWindow);
        return false;
    }
    // 必须在首次异步等待前登记并创建窗口,避免重复启动以及无窗口时应用退出。
    const startup = {
        workspace,
        window: preparedBoot ? preparedBoot.window : createBootWindow(),
        ownsKernel: !isDevEnv || workspaces.length > 0 || localKernelStartups.size > 0,
        devPort: kernelPort,
    };
    localKernelStartups.set(key, startup);
    const cancelStartup = () => {
        startup.canceled = true;
        if (startup.kernelRunning && !startup.exitRequested) {
            startup.exitRequested = true;
            expectedKernelExitPorts.add(startup.port.toString());
            requestKernelExit(startup.port, {setCurrentWorkspace: false});
        }
        // 其他工作空间可能阻止应用退出,主动关闭本次启动页,避免留下无法继续的等待窗口。
        if (!startup.window.isDestroyed()) {
            startup.window.destroy();
        }
    };
    app.on("before-quit", cancelStartup);
    let retryDeadline;
    let started = false;
    try {
        for (;;) {
            const result = await initKernelAttempt(workspace,
                port, lang, safeMode, preparedBoot, startup);
            if (result !== "workspace-locked") {
                started = !!result;
                return result;
            }
            const currentBootWindow = startup.window;
            const canceled = () => startup.canceled || currentBootWindow.isDestroyed();
            if (canceled()) return false;
            // 只限制锁冲突的自动重试;已进入正常退出的同步恢复仍使用原有等待期限。
            retryDeadline ??= Date.now() + 90000;
            const failLocked = () => {
                exitApp(startup.port, showWorkspaceLocked());
                if (!currentBootWindow.isDestroyed()) currentBootWindow.destroy();
                return false;
            };
            if (Date.now() >= retryDeadline) return failLocked();
            try {
                const languages = loadAppMenuLanguages(lang || resolveAppLanguage(app.getPreferredSystemLanguages()));
                currentBootWindow.previousExitWaiting = languages.workspaceLockWaiting;
                await currentBootWindow.webContents.executeJavaScript(
                    `window.setPreviousExitWaiting(${JSON.stringify(languages.workspaceLockWaiting)})`);
                writeLog("workspace is locked, waiting to retry kernel startup");
                for (let elapsed = 0; elapsed < 1000 && !canceled(); elapsed += 100) {
                    await sleep(100);
                }
                if (canceled()) return false;
                if (Date.now() >= retryDeadline) return failLocked();
            } catch (error) {
                writeLog("wait to retry kernel startup failed: " + error);
                return canceled() ? false : failLocked();
            }
        }
    } finally {
        app.removeListener("before-quit", cancelStartup);
        if (!started) {
            cancelStartup();
            localKernelStartups.delete(key);
        }
    }
};

const showWorkspaceLocked = () => {
    if (workspaces && 0 < workspaces.length) {
        showWindow(workspaces[0].browserWindow);
    }
    return showErrorWindow("工作空间已被锁定", "The workspace is locked", "<div>该工作空间正在被使用,请尝试在任务管理器中结束 SiYuan-Kernel 进程或者重启操作系统后再启动思源。</div><div>The workspace is being used, please try to end the SiYuan-Kernel process in the task manager or restart the operating system and then start SiYuan.</div>");
};

const initKernelAttempt = (workspace, port, lang, safeMode, preparedBoot, startup) => {
    return new Promise(async (resolve) => {
        const currentWorkspace = startup.workspace;
        const currentBootWindow = startup.window;
        const canceled = () => startup.canceled || currentBootWindow.isDestroyed();
        const workspaceLogPath = currentWorkspace ? path.resolve(currentWorkspace, "temp", "siyuan.log") : "";
        const kernelLogPath = path.join(confDir, "kernel.log");
        if (!startup.port && !await showAppleSiliconWarning(lang)) {
            app.quit();
            resolve(false);
            return;
        }
        const kernelName = "win32" === process.platform ? "SiYuan-Kernel.exe" : "SiYuan-Kernel";
        const kernelPath = path.join(appDir, "kernel", kernelName);
        if (!fs.existsSync(kernelPath)) {
            showErrorWindow("内核程序丢失", "Kernel program is missing", `<div>内核程序丢失,请重新安装思源,并将思源内核程序加入杀毒软件信任列表。</div><div>The kernel program is not found, please reinstall SiYuan and add SiYuan Kernel prgram into the trust list of your antivirus software.</div><div><i>${kernelPath}</i></div>`);
            resolve(false);
            return;
        }

        const firstAttempt = !startup.port;
        const currentKernelPort = startup.port || (preparedBoot ? await preparedBoot.ready :
            startup.ownsKernel ? await getAvailablePort(port, false) : startup.devPort);
        startup.port = currentKernelPort;
        writeLog("got kernel port [" + currentKernelPort + "]");
        if (!currentKernelPort || canceled()) {
            resolve(false);
            return;
        }
        if (firstAttempt && !preparedBoot) {
            showLocalBootWindow(currentBootWindow, currentKernelPort, lang);
        }
        let kernelExited = false;
        let kernelStarted = false;
        const bootCanceled = () => canceled() || kernelExited;
        if (startup.ownsKernel) {
            let waiting = !!currentBootWindow.previousExitWaiting;
            const language = lang || resolveAppLanguage(app.getPreferredSystemLanguages());
            const languages = loadAppMenuLanguages(language);
            try {
                const ready = await waitForPreviousWorkspaceExit(currentWorkspace, {
                    canceled: bootCanceled,
                    hasActiveWindow: () => workspaces.some(item => item.workspaceDir === currentWorkspace &&
                        item.browserWindow && !item.browserWindow.isDestroyed()),
                    recover: (marker, signal, force) => requestWorkspaceExitRecovery(currentWorkspace, marker, signal, net.fetch,
                        undefined, force),
                    onRecoveryFailed: async syncFailed => {
                        if (bootCanceled()) return false;
                        const {response} = await dialog.showMessageBox(currentBootWindow, {
                            type: "warning",
                            message: syncFailed ? languages._kernel[96] : languages.previousExitWaitFailed,
                            buttons: syncFailed ? [languages.retry, languages.cancel, languages._kernel[97]] :
                                [languages.retry, languages.cancel],
                            defaultId: 0,
                            cancelId: 1,
                        });
                        if (bootCanceled()) return false;
                        return response === 2 && syncFailed ? "force" : response === 0;
                    },
                    onWaiting: async () => {
                        waiting = true;
                        writeLog("waiting for previous workspace exit");
                        currentBootWindow.previousExitWaiting = languages.previousExitWaiting;
                        await currentBootWindow.webContents.executeJavaScript(
                            `window.setPreviousExitWaiting(${JSON.stringify(languages.previousExitWaiting)})`);
                    },
                });
                if (!ready || bootCanceled()) {
                    if (!bootCanceled()) currentBootWindow.destroy();
                    resolve(false);
                    return;
                }
                if (waiting) {
                    currentBootWindow.previousExitWaiting = "";
                    await currentBootWindow.webContents.executeJavaScript("window.setPreviousExitWaiting(\"\")");
                    if (bootCanceled()) {
                        resolve(false);
                        return;
                    }
                }
            } catch (error) {
                writeLog("wait for previous workspace exit failed: " + error);
                if (!bootCanceled()) {
                    showErrorWindow(languages.previousExitWaiting, "", escapeHTML(languages.previousExitWaitFailed));
                    currentBootWindow.destroy();
                }
                resolve(false);
                return;
            }
        }
        const cmds = ["serve", "--port", currentKernelPort, "--wd", appDir, "--attach-ui"];
        if (!startup.ownsKernel) {
            cmds.push("--mode", "dev");
        }
        if (workspace && "" !== workspace) {
            cmds.push("--workspace", workspace);
        }
        if (lang && "" !== lang) {
            cmds.push("--lang", lang);
        }
        if (safeMode) {
            cmds.push("--safe-mode", "true");
        }
        let cmd = `ui version [${appVer}], booting kernel [${kernelPath} ${cmds.join(" ")}]`;
        writeLog(cmd);
        if (startup.ownsKernel) {
            const spawnStartedAt = Date.now();
            const kernelProcess = childProcess.spawn(kernelPath, cmds, {
                detached: false, // 桌面端内核进程不再以游离模式拉起 https://github.com/siyuan-note/siyuan/issues/6336
                stdio: "ignore",
            },);

            writeLog("spawned kernel process [" + (Date.now() - spawnStartedAt) + "ms]");
            const kernelPortKey = currentKernelPort.toString();
            exitedKernelPorts.delete(kernelPortKey);
            kernelProcesses.set(kernelPortKey, kernelProcess);
            startup.kernelRunning = true;
            startup.process = kernelProcess;
            writeLog("booted kernel process [pid=" + kernelProcess.pid + ", port=" + currentKernelPort + "]");
            kernelProcess.on("close", (code, signal) => {
                kernelExited = true;
                if (startup.process === kernelProcess) startup.kernelRunning = false;
                if (kernelProcesses.get(kernelPortKey) === kernelProcess) {
                    kernelProcesses.delete(kernelPortKey);
                    exitedKernelPorts.add(kernelPortKey);
                }
                const expectedExit = expectedKernelExitPorts.delete(kernelPortKey);
                writeLog(`kernel [pid=${kernelProcess.pid}, port=${currentKernelPort}] exited with code [${code}], signal [${signal}], expected [${expectedExit}]`);
                if (startup.canceled) {
                    resolve(false);
                    return;
                }
                if (code === 24 && !expectedExit && !kernelStarted) {
                    resolve(canceled()
                        ? false : "workspace-locked");
                    return;
                }
                if (0 !== code && !expectedExit) {
                    let errorWindowId;
                    switch (code) {
                        case 20:
                            errorWindowId = showErrorWindow("数据库不可用", "The database is unavailable", "<div>无法访问数据库文件,请查看 <a href=\"#\" data-log-path>工作空间/temp/siyuan.log</a> 获取详细报错信息</div><div>Cannot access the database file. Please check <a href=\"#\" data-log-path>workspace/temp/siyuan.log</a> for detailed error information.</div>", "⚠️", workspaceLogPath);
                            break;
                        case 21:
                            errorWindowId = showErrorWindow("监听端口 " + currentKernelPort + " 失败", "Failed to listen to port " + currentKernelPort, "<div>监听 " + currentKernelPort + " 端口失败,请确保程序拥有网络权限并不受防火墙和杀毒软件阻止。</div><div>Failed to listen to port " + currentKernelPort + ", please make sure the program has network permissions and is not blocked by firewalls and antivirus software.</div>");
                            break;
                        case 24: // 工作空间已被锁定,尝试切换到第一个打开的工作空间
                            errorWindowId = showWorkspaceLocked();
                            break;
                        case 25:
                            errorWindowId = showErrorWindow("初始化工作空间失败", "Failed to create workspace directory", "<div>工作空间文件夹权限不足,请查看 <a href=\"#\" data-log-path>~/.config/siyuan/kernel.log</a> 获取详细报错信息</div><div>Insufficient permissions for the workspace folder. Please check <a href=\"#\" data-log-path>~/.config/siyuan/kernel.log</a> for detailed error information.</div>", "⚠️", kernelLogPath);
                            break;
                        case 26:
                            errorWindowId = showErrorWindow("文件系统访问失败", "File system access failed", "<div>思源内核无法访问所需文件,现已安全退出。可能原因包括文件或文件夹权限不足、文件为只读、文件被其他程序占用,以及同步盘或安全软件干预。</div><div>请查看 <a href=\"#\" data-log-path>工作空间/temp/siyuan.log</a> 获取详细错误信息。</div><div>SiYuan Kernel could not access a required file and has exited safely. Possible causes include insufficient permissions, read-only files, another process using a file, or interference from sync or security software.</div><div>Please check <a href=\"#\" data-log-path>workspace/temp/siyuan.log</a> for details.</div>", "⚠️", workspaceLogPath);
                            break;
                        case 0:
                            break;
                        default:
                            errorWindowId = showErrorWindow("内核因未知原因退出", "The kernel exited for unknown reasons", `<div>思源内核因未知原因退出 [code=${code}],请尝试重启操作系统后再启动思源。如果该问题依然发生,请检查杀毒软件是否阻止思源内核启动。</div><div>SiYuan Kernel exited for unknown reasons [code=${code}], please try to reboot your operating system and then start SiYuan again. If occurs this problem still, please check your anti-virus software whether kill the SiYuan Kernel.</div>`);
                            break;
                    }

                    exitApp(currentKernelPort, errorWindowId);
                    if (!currentBootWindow.isDestroyed()) {
                        currentBootWindow.destroy();
                    }
                    resolve(false);
                }
            });
        }

        let apiData;
        let count = 0;
        writeLog("checking kernel version");
        for (; ;) {
            if (bootCanceled()) {
                resolve(false);
                return;
            }
            try {
                apiData = await fetchLocalKernelJSON(getServer(currentKernelPort) + "/api/system/version");
                break;
            } catch (e) {
                writeLog("get kernel version failed: " + e.message);
                if (bootCanceled()) {
                    resolve(false);
                    return;
                }
                if (14 < ++count) {
                    const versionTimedOut = isLocalKernelRequestTimeout(e);
                    writeLog("get kernel ver failed [timeout=" + versionTimedOut + "]");
                    if (versionTimedOut) {
                        showKernelUnresponsiveWindow(lang);
                    } else {
                        showErrorWindow("获取内核服务端口失败", "Failed to Obtain Kernel Service Port", "<div>获取内核服务端口失败,请确保程序拥有网络权限并不受防火墙和杀毒软件阻止。</div><div>Failed to obtain kernel service port. Please ensure SiYuan has network permissions and is not blocked by firewalls or antivirus software.</div>");
                    }
                    currentBootWindow.destroy();
                    resolve(false);
                    return;
                }
                await sleep(500);
            }
        }

        if (bootCanceled()) {
            resolve(false);
            return;
        }
        if (0 === apiData.code) {
            kernelStarted = true;
            writeLog("got kernel version [" + apiData.data + "]");
            if (!isDevEnv && apiData.data !== appVer) {
                writeLog(`kernel [${apiData.data}] is running, shutdown it now and then start kernel [${appVer}]`);
                currentBootWindow.destroy();
                resolve(false);
            } else {
                let progressing = false;
                let progressFailures = 0;
                const retryableProgressErrors = new Set([
                    "net::ERR_CERT_DATABASE_CHANGED",
                    "net::ERR_CERT_VERIFIER_CHANGED",
                    "net::ERR_NETWORK_CHANGED",
                ]);
                const bootShowStart = Date.now();
                // 启动超时兜底,防止内核异常时永久卡在 boot 轮询。数据同步、首次全量索引重建、
                // 数据库版本变更触发的全表重建都发生在 SetBooted() 之前,会计入此循环,故给足余量
                const bootTimeout = 300000;
                while (!progressing) {
                    if (bootCanceled()) {
                        resolve(false);
                        return;
                    }
                    if (Date.now() - bootShowStart > bootTimeout) {
                        writeLog("boot progress timeout after " + bootTimeout + "ms, exiting boot");
                        showErrorWindow("启动超时", "Boot timeout",
                            "<div>内核启动超时,请查看 <a href=\"#\" data-log-path>工作空间/temp/siyuan.log</a> 获取详细报错信息,或尝试重启思源。</div>" +
                            "<div>Kernel boot timed out. Please check <a href=\"#\" data-log-path>workspace/temp/siyuan.log</a> for details, or try restarting SiYuan.</div>",
                            "⚠️", workspaceLogPath);
                        currentBootWindow.destroy();
                        resolve(false);
                        progressing = true;
                        break;
                    }
                    try {
                        const progressData = await fetchLocalKernelJSON(getServer(currentKernelPort) + "/api/system/bootProgress");
                        if (bootCanceled()) {
                            resolve(false);
                            return;
                        }
                        progressFailures = 0;
                        if (progressData.data.progress >= 100) {
                            // 内核完成后等待动画快进收尾(200ms)再进入主窗口
                            await sleep(200);
                            resolve(bootCanceled() ? false : currentKernelPort);
                            progressing = true;
                        } else {
                            await sleep(100);
                        }
                    } catch (e) {
                        writeLog("get boot progress failed: " + e.message);
                        if (bootCanceled()) {
                            resolve(false);
                            return;
                        }
                        // 只读启动查询在证书、网络配置变化或本机请求超时后有限重试,不延长总启动期限。
                        if ((retryableProgressErrors.has(e.message) || isLocalKernelRequestTimeout(e)) && ++progressFailures < 15) {
                            writeLog("retrying boot progress [attempt=" + progressFailures + "/14]");
                            await sleep(500);
                            continue;
                        }
                        if (isLocalKernelRequestTimeout(e)) {
                            showKernelUnresponsiveWindow(lang);
                        }
                        currentBootWindow.destroy();
                        resolve(false);
                        progressing = true;
                    }
                }
            }
        } else {
            writeLog(`get kernel version failed: ${apiData.code}, ${apiData.msg}`);
            resolve(false);
        }
    });
};

// 本地内核请求超时上限:内核可能已经监听端口,但本机请求既不会成功也不会失败,因此必须限时失败。
const localKernelRequestTimeout = 5000;

const localKernelRequestTimeoutError = () => {
    const error = new Error("local kernel request timed out");
    error.name = "LocalKernelRequestTimeoutError";
    return error;
};

const isLocalKernelRequestTimeout = error => "LocalKernelRequestTimeoutError" === error?.name;

// 本机请求超时后收集 Windows TCP 配置写入日志,便于排查回环通道异常;show 命令不需要管理员权限。
const windowsTCPConfigCommands = [["int", "tcp", "show", "supplemental"], ["int", "ipv4", "show", "global"], ["int", "ipv6", "show", "global"]];

const execFileAsync = (file, args, options) => new Promise((resolve, reject) => {
    childProcess.execFile(file, args, options, (error, stdout) => error ? reject(error) : resolve(stdout));
});

const collectWindowsTCPConfig = async () => {
    if ("win32" !== process.platform) {
        return [];
    }
    const lines = [];
    for (const args of windowsTCPConfigCommands) {
        const command = "netsh " + args.join(" ");
        try {
            // netsh 输出随系统语言本地化,这里只记录输出原文;命令行标记保持 ASCII,便于识别输出来源。
            const stdout = await execFileAsync("netsh.exe", args, {timeout: 5000, windowsHide: true});
            lines.push("[tcp config] " + command + ":\n" + String(stdout).trimEnd());
        } catch (error) {
            lines.push("[tcp config] " + command + " failed: " + error.message);
        }
    }
    return lines;
};

// 内核已经启动但本机请求一直没有响应时的错误窗口,提示用户排查本机访问。
const showKernelUnresponsiveWindow = (lang) => {
    const language = resolveAppLanguage(lang ? [lang] : app.getPreferredSystemLanguages());
    const languages = loadAppMenuLanguages(language);
    const english = loadAppMenuLanguages("en");
    const content = [...new Set([languages, english])].map((strings) => {
        const message = escapeHTML(strings.kernelUnresponsiveMessage)
            .replace("${log}", "<a href=\"#\" data-log-path>~/.config/siyuan/app.log</a>");
        const windowsHint = "win32" === process.platform ?
            "<div>" + escapeHTML(strings.kernelUnresponsiveWindowsHint) + "</div>" : "";
        return "<div>" + message + "</div>" + windowsHint;
    }).join("");
    showErrorWindow(languages.kernelUnresponsiveTitle, english.kernelUnresponsiveTitle,
        content, "⚠️", path.join(confDir, "app.log"));
    // 诊断命令在后台执行,不延迟结束本次启动流程。
    collectWindowsTCPConfig().then(lines => lines.forEach(line => writeLog(line)))
        .catch(error => writeLog("collect Windows TCP configuration failed: " + error.message));
};

// 超时覆盖响应头和响应体读取,防止本机通道异常时启动查询永久挂起。
const fetchLocalKernelJSON = async (url) => {
    const abortController = new AbortController();
    const timer = setTimeout(() => abortController.abort(), localKernelRequestTimeout);
    try {
        const response = await net.fetch(url, {signal: abortController.signal});
        return await response.json();
    } catch (error) {
        if (abortController.signal.aborted) {
            throw localKernelRequestTimeoutError();
        }
        throw error;
    } finally {
        clearTimeout(timer);
    }
};

const fetchWithTimeout = async (url, options = {}, timeout = 5000) => {
    const abortController = new AbortController();
    const timer = setTimeout(() => abortController.abort(), timeout);
    try {
        return await getRemoteSession({origin: new URL(url).origin}).fetch(url, Object.assign({
            credentials: "include",
            bypassCustomProtocolHandlers: true,
            redirect: "manual",
        }, options, {signal: abortController.signal}));
    } finally {
        clearTimeout(timer);
    }
};

const requestRemoteKernelVersion = async (target) => {
    const response = await fetchWithTimeout(target.origin + "/api/system/version", {method: "GET"});
    if (!response.ok) {
        await response.body?.cancel();
        throw new Error("version request returned HTTP " + response.status);
    }
    return response.json();
};

const isRemoteKernelAuthenticated = (target) =>
    probeRemoteKernelAuthentication(net, getRemoteSession(target), target.origin + "/stage/build/app/");

const initRemoteKernel = async (target) => {
    remoteBootCanceled = false;
    await connectionManager.prepareSession(target);
    await connectionManager.restoreSession(target, getArg("--connection-session"));
    createBootWindow();
    if (!await showAppleSiliconWarning(getArg("--lang") || "")) {
        bootWindow.destroy();
        app.quit();
        return;
    }
    loadBootWindow();
    if (openAsHidden) {
        bootWindow.minimize();
    } else {
        bootWindow.show();
    }

    try {
        await getRemoteSession(target).clearStorageData({
            origin: target.origin,
            storages: remoteKernelActiveStorageTypes,
        });
    } catch (error) {
        throw new Error("failed to clear remote kernel active storage: " + error.message, {cause: error});
    }

    writeLog("connecting to remote kernel [origin=" + target.origin + "]");
    let versionData;
    let connectionError = "";
    for (let count = 0; count < 5; count++) {
        if (remoteBootCanceled) {
            return;
        }
        try {
            versionData = await requestRemoteKernelVersion(target);
            break;
        } catch (error) {
            connectionError = error.message;
            writeLog("get remote kernel version failed: " + error.message);
            if (count < 4) {
                await sleep(500);
            }
        }
    }
    if (remoteBootCanceled) {
        return;
    }
    const versionStatus = getRemoteKernelVersionStatus(versionData, appVer);
    if (versionStatus === "invalid") {
        showErrorWindow("连接远程内核失败", "Failed to connect to the remote kernel",
            "<div>无法连接远程内核,请检查地址、网络和 TLS 证书。</div>" +
            "<div>Unable to connect to the remote kernel. Check the address, network, and TLS certificate.</div>" +
            "<div>" + escapeHTML(connectionError) + "</div>");
        bootWindow.destroy();
        return;
    }
    writeLog("got remote kernel version [" + versionData.data + "]");
    if (versionStatus === "mismatch") {
        const remoteVersion = escapeHTML(versionData.data);
        showErrorWindow("远程内核版本不匹配", "Remote kernel version mismatch",
            "<div>客户端版本 " + appVer + " 与远程内核版本 " + remoteVersion + " 不一致。</div>" +
            "<div>Client version " + appVer + " does not match remote kernel version " + remoteVersion + ".</div>");
        bootWindow.destroy();
        return;
    }

    const bootShowStart = Date.now();
    let booted = false;
    while (!remoteBootCanceled && Date.now() - bootShowStart <= 300000) {
        try {
            const response = await fetchWithTimeout(target.origin + "/api/system/bootProgress");
            if (!response.ok) {
                await response.body?.cancel();
                throw new Error("boot progress request returned HTTP " + response.status);
            }
            const progressData = await response.json();
            if (progressData?.data?.progress >= 100) {
                booted = true;
                break;
            }
        } catch (error) {
            writeLog("get remote boot progress failed: " + error.message);
        }
        await sleep(500);
    }
    if (remoteBootCanceled) {
        return;
    }
    if (!booted) {
        showErrorWindow("连接远程内核超时", "Remote kernel connection timed out",
            "<div>等待远程内核完成启动超时。</div><div>Timed out waiting for the remote kernel to finish booting.</div>");
        bootWindow.destroy();
        return;
    }

    let authenticated;
    try {
        authenticated = await isRemoteKernelAuthenticated(target);
    } catch (error) {
        writeLog("probe remote kernel authentication failed: " + error.message);
        if (remoteBootCanceled) {
            return;
        }
        showErrorWindow("检查远程内核鉴权失败", "Failed to check remote kernel authentication",
            "<div>无法检查远程内核的鉴权状态。</div><div>Unable to check the remote kernel authentication state.</div>" +
            "<div>" + escapeHTML(error.message) + "</div>");
        bootWindow.destroy();
        return;
    }
    if (remoteBootCanceled) {
        return;
    }
    connectionManager.remember(target.origin);
    installRemoteFrontendProtocol(target);
    return {
        target,
        authenticated,
    };
};

app.whenReady().then(() => {
    const startupStartedAt = Date.now();
    writeLog("app ready, preparing startup window");
    const appCrashInfo = readAppCrashInfo();
    writeLog("read app crash info [" + (Date.now() - startupStartedAt) + "ms since app ready]");
    let preparedBoot;
    // 仅普通本地启动提前创建窗口,其他启动分支使用各自的窗口。
    if (!remoteKernelArgError && !remoteKernelTarget && !firstOpen && !appCrashInfo && !lastWorkspaceMissing) {
        createBootWindow();
        const currentBootWindow = bootWindow;
        preparedBoot = {
            window: currentBootWindow,
            ready: getAvailablePort(getArg("--port")).then((port) => {
                if (port && !currentBootWindow.isDestroyed()) {
                    showLocalBootWindow(currentBootWindow, port, getArg("--lang"));
                }
                return port;
            }),
        };
    }
    connectionManager = createConnectionManager({
        confDir,
        languageDir: path.join(appDir, "appearance", "langs"),
        version: appVer,
        currentTarget: () => remoteKernelTarget,
        isTrustedDialogSender: event => event.senderFrame === event.sender.mainFrame &&
            !!getWindowKernelTarget(event.sender.id) &&
            getWindowPathname(BrowserWindow.fromWebContents(event.sender)) === "/stage/build/app/",
        log: writeLog,
        restart: async (target) => {
            if (pendingConnectionArgs || updateInstallPromise || systemShutdownState !== systemShutdownNone) {
                return;
            }
            pendingConnectionArgs = connectionArgs(linuxInputMethodLaunchArguments.slice(1), target, remoteKernelTarget?.origin);
            try {
                await closeConnectionWindows(BrowserWindow.getAllWindows().filter(window =>
                    windowKernelTargets.has(window.webContents.id) &&
                    getWindowPathname(window) === "/stage/build/app/window.html"));
            } catch (error) {
                pendingConnectionArgs = undefined;
                throw error;
            }
            // 先通过现有保存与退出流程关闭全部工作空间,最后一个窗口退出后再安排重启。
            app.quit();
        },
    });
    writeLog("created connection manager [" + (Date.now() - startupStartedAt) + "ms since app ready]");
    ipcMain.on("siyuan-manage-connections", (event, options) => {
        const target = getWindowKernelTarget(event.sender.id);
        const localPages = ["init.html", "workspace.html", ...(remoteKernelTarget ? ["boot.html"] : [])].map(name =>
            pathToFileURL(path.join(__dirname, name)).href);
        const localPage = localPages.includes(event.senderFrame?.url.split("?")[0]);
        if (event.senderFrame === event.sender.mainFrame && (localPage || (target &&
            ["/stage/build/app/", "/check-auth"].includes(getWindowPathname(BrowserWindow.fromWebContents(event.sender)))))) {
            connectionManager.show({lang: options?.lang, origin: options?.origin});
            if (remoteKernelTarget && bootWindow && !bootWindow.isDestroyed()) {
                remoteBootCanceled = true;
                bootWindow.destroy();
            }
        }
    });
    // 前端菜单同步完成前也保留原生编辑操作,避免复制、粘贴依赖界面初始化成功。
    setStartupApplicationMenu();
    installKernelRequestLog(session.defaultSession, {getTarget: getWindowKernelTarget, writeLog});
    // 仅本进程启动的本地内核允许自签名证书,远程内核始终使用系统信任链。
    session.defaultSession.setCertificateVerifyProc((request, callback) => {
        const kernelMode = remoteKernelTarget ? "remote" : "local";
        if (shouldTrustLocalKernelCertificate(kernelMode, request.hostname)) {
            callback(0); // 验证通过
        } else {
            callback(-3); // 交由 Chromium 默认处理
        }
    });

    // 渲染进程崩溃监听,只有工作空间主窗口的非预期崩溃才会触发安全模式。
    app.on("render-process-gone", (event, webContents, details) => {
        writeLog("Render process gone [reason=" + details.reason + ", exitCode=" + details.exitCode + "]");
        cleanupBlockDragSessions(webContents.id);
        if (updateInstallPromise) {
            writeLog("ignore renderer exit during update [webContentsId=" + webContents.id + "]");
            return;
        }
        if (systemShutdownState !== systemShutdownNone) {
            writeLog("ignore renderer exit during system shutdown [webContentsId=" + webContents.id + "]");
            return;
        }
        if (expectedRendererExitIds.delete(webContents.id)) {
            writeLog("ignore expected renderer exit [webContentsId=" + webContents.id + "]");
            return;
        }

        const crashedBootWindow = Array.from(bootWindows)
            .find(window => window && !window.isDestroyed() && window.webContents.id === webContents.id);
        if (crashedBootWindow) {
            if (!crashedBootWindow.appearanceFallback) {
                writeLog("boot renderer exited, reload without custom appearance");
                loadBootWindow(true, crashedBootWindow, crashedBootWindow.kernelPort, crashedBootWindow.lang);
            }
            return;
        }

        const workspace = workspaces.find((item) => item.webContentsId === webContents.id);
        if (!workspace) {
            writeLog("ignore non-workspace renderer exit [webContentsId=" + webContents.id + "]");
            return;
        }
        if (!safeModeReasons.has(details.reason)) {
            writeLog("ignore renderer exit reason [reason=" + details.reason + "]");
            return;
        }
        if (handledCrashWebContents.has(webContents.id)) {
            return;
        }

        handledCrashWebContents.add(webContents.id);
        if (!workspace.ownsKernel) {
            writeLog("remote renderer exited without stopping the remote kernel [origin=" +
                workspace.kernelTarget.origin + "]");
            exitWorkspace(workspace);
            return;
        }
        writeAppCrashMarker(workspace, details);
        requestKernelExit(workspace.port, {
            force: true,
            setCurrentWorkspace: false,
        });
        exitApp(workspace.port); // 退出崩溃的工作空间,下次启动时由用户选择启动方式。
    });

    const resetTrayMenu = (tray, lang, mainWindow) => {
        if (!mainWindow || mainWindow.isDestroyed()) {
            return;
        }

        const trayMenuTemplate = [{
            label: mainWindow.isVisible() ? lang.hideWindow : lang.showWindow, click: () => {
                showHideWindow(tray, lang, mainWindow);
            },
        }, {
            label: lang.officialWebsite, click: () => {
                shell.openExternal("https://b3log.org/siyuan/");
            },
        }, {
            label: lang.openSource, click: () => {
                shell.openExternal("https://github.com/siyuan-note/siyuan");
            },
        }, {
            label: lang.resetWindow, type: "checkbox", click: v => {
                resetWindowStateOnRestart = v.checked;
                mainWindow.webContents.send("siyuan-save-close", true);
            },
        }, {
            label: lang.quit, click: () => {
                mainWindow.webContents.send("siyuan-save-close", true);
            },
        },];

        if ("win32" === process.platform) {
            // Windows 端支持窗口置顶 https://github.com/siyuan-note/siyuan/issues/6860
            trayMenuTemplate.splice(1, 0, {
                label: mainWindow.isAlwaysOnTop() ? lang.cancelWindowTop : lang.setWindowTop, click: () => {
                    if (!mainWindow.isAlwaysOnTop()) {
                        mainWindow.setAlwaysOnTop(true, "pop-up-menu");
                    } else {
                        mainWindow.setAlwaysOnTop(false);
                    }
                    resetTrayMenu(tray, lang, mainWindow);
                },
            });
        }
        const contextMenu = Menu.buildFromTemplate(trayMenuTemplate);
        tray.setContextMenu(contextMenu);
    };
    const showHideWindow = (tray, lang, mainWindow) => {
        if (!mainWindow || mainWindow.isDestroyed()) {
            return;
        }

        if (!mainWindow.isVisible()) {
            if (mainWindow.isMinimized()) {
                mainWindow.restore();
            }
            mainWindow.show();
        } else {
            hideWindow(mainWindow);
        }

        resetTrayMenu(tray, lang, mainWindow);
    };
    // 渲染进程只同步语言标识和菜单配置,文案由主进程读取。
    ipcMain.on("siyuan-sync-app-menu", (event, sync) => {
        if ("darwin" !== process.platform) {
            return;
        }
        if (!sync || typeof sync.lang !== "string" || !sync.hotkey || typeof sync.hotkey !== "object") {
            return;
        }
        const kernelTarget = getWindowKernelTarget(event.sender.id);
        const workspaceDir = kernelTarget?.mode === "remote"
            ? "remote:" + kernelTarget.origin
            : (typeof sync.workspaceDir === "string" && sync.workspaceDir)
                ? sync.workspaceDir
                : ("webContents:" + event.sender.id);
        appMenuByWorkspaceDir.set(workspaceDir, sync);
        appMenuWorkspaceByWebContentsId.set(event.sender.id, workspaceDir);
        if (shouldApplyAppMenuFrom(event.sender.id, workspaceDir)) {
            applyMacAppMenu(sync);
        }
    });

    const getWindowByContentId = (id) => {
        return BrowserWindow.getAllWindows().find((win) => win.webContents.id === id);
    };
    ipcMain.on("siyuan-context-menu", (event, langs) => {
        pendingSpellcheckRequests.delete(event.sender.id);
        pendingNativeContextMenuRequests.set(event.sender.id, langs);
        dispatchContextMenuRequests(event.sender);
        setTimeout(() => {
            if (pendingNativeContextMenuRequests.get(event.sender.id) === langs) {
                pendingNativeContextMenuRequests.delete(event.sender.id);
                if (!event.sender.isDestroyed()) {
                    popupNativeTextContextMenu(event.sender, undefined, langs);
                }
            }
        }, 100);
    });
    ipcMain.on("siyuan-spellcheck-context", (event, position) => {
        pendingNativeContextMenuRequests.delete(event.sender.id);
        pendingSpellcheckRequests.set(event.sender.id, position);
        dispatchContextMenuRequests(event.sender);
        setTimeout(() => {
            if (pendingSpellcheckRequests.get(event.sender.id) === position) {
                pendingSpellcheckRequests.delete(event.sender.id);
            }
        }, 200);
    });
    ipcMain.handle("siyuan-spellcheck-action", (event, data) => {
        const context = spellcheckContexts.get(event.sender.id);
        if (!context || context.contextId !== data.contextId || !context.params.misspelledWord) {
            return false;
        }
        if (data.action === "replace") {
            if (typeof data.suggestion !== "string" ||
                !context.params.dictionarySuggestions.includes(data.suggestion)) {
                return false;
            }
            event.sender.replaceMisspelling(data.suggestion);
            spellcheckContexts.delete(event.sender.id);
            return true;
        }
        if (data.action === "addToDictionary") {
            const result = event.sender.session.addWordToSpellCheckerDictionary(context.params.misspelledWord);
            spellcheckContexts.delete(event.sender.id);
            return result;
        }
        return false;
    });
    ipcMain.on("siyuan-confirm-dialog", (event, options) => {
        event.returnValue = dialog.showMessageBoxSync(BrowserWindow.fromWebContents(event.sender) || BrowserWindow.getFocusedWindow(), options);
    });
    ipcMain.on("siyuan-alert-dialog", (event, options) => {
        dialog.showMessageBoxSync(BrowserWindow.fromWebContents(event.sender) || BrowserWindow.getFocusedWindow(), options);
        event.returnValue = undefined;
    });
    ipcMain.on("siyuan-first-quit", () => {
        app.exit();
    });
    installWebPageFetchIPC(ipcMain, fetchRenderedWebPage,
        sender => initializedWindowIds.has(sender.id) && !!getWindowKernelTarget(sender.id));
    ipcMain.handle("siyuan-get", async (event, data) => {
        if (data.cmd === "getWindowGeometry" || data.cmd === "setWindowGeometry") {
            const window = getWindowByContentId(event.sender.id);
            if (!window || !getWindowKernelTarget(event.sender.id) || event.senderFrame !== event.sender.mainFrame) {
                return false;
            }
            return data.cmd === "getWindowGeometry" ? captureWindowGeometry(window) :
                restoreWindowGeometry(window, data.geometry, screen);
        }
        if (data.cmd === "getLinuxInputMethodSetting" || data.cmd === "setLinuxInputMethodSetting") {
            if (process.platform !== "linux" || !initializedWindowIds.has(event.sender.id) ||
                !getWindowKernelTarget(event.sender.id) || event.senderFrame !== event.sender.mainFrame) {
                throw new Error("Linux input method setting is unavailable");
            }
            if (linuxInputMethodArgumentsError) {
                throw linuxInputMethodArgumentsError;
            }
            if (data.cmd === "setLinuxInputMethodSetting") {
                writeLinuxInputMethodSetting(linuxInputMethodSettingPath, data.enabled);
                linuxInputMethodEnabled = data.enabled;
            }
            return {enabled: linuxInputMethodEnabled, override: linuxInputMethodOverride};
        }
        if (data.cmd === "getAccessibilitySetting" || data.cmd === "setAccessibilitySetting") {
            if (!initializedWindowIds.has(event.sender.id) ||
                !getWindowKernelTarget(event.sender.id) || event.senderFrame !== event.sender.mainFrame) {
                throw new Error("Accessibility setting is unavailable");
            }
            if (data.cmd === "setAccessibilitySetting") {
                writeAccessibilitySetting(accessibilitySettingPath, data.enabled);
                accessibilityEnabled = data.enabled;
            }
            return {enabled: accessibilityEnabled, override: accessibilityOverride};
        }
        if (data.cmd === "remoteConnections") {
            if (!getWindowKernelTarget(event.sender.id) || event.senderFrame !== event.sender.mainFrame) {
                return [];
            }
            try {
                return readConnections(path.join(confDir, "connections.json")).origins;
            } catch (error) {
                writeLog("read connection history failed: " + error.message);
                return [];
            }
        }
        if (data.cmd === "kernelConnection") {
            return getKernelConnection(getWindowKernelTarget(event.sender.id));
        }
        const remoteSender = getWindowKernelTarget(event.sender.id)?.mode === "remote";
        if (data.cmd === "saveRemoteExport") {
            if (!remoteSender || !initializedWindowIds.has(event.sender.id) ||
                event.senderFrame !== event.sender.mainFrame || remoteExportSenders.has(event.sender)) {
                return {status: "error"};
            }
            const controller = new AbortController();
            const abort = () => controller.abort();
            remoteExportSenders.add(event.sender);
            event.sender.once("destroyed", abort);
            try {
                return await saveRemoteExport({
                    uri: data.uri,
                    origin: getWindowKernelTarget(event.sender.id).origin,
                    choosePath: (defaultPath) => dialog.showSaveDialog(BrowserWindow.fromWebContents(event.sender), {
                        defaultPath, properties: ["showOverwriteConfirmation"],
                    }),
                    fetch: (url, options) => event.sender.session.fetch(url, options),
                    signal: controller.signal,
                });
            } catch (error) {
                writeLog("save remote export failed: " + error.message);
                return {status: "error"};
            } finally {
                event.sender.removeListener("destroyed", abort);
                remoteExportSenders.delete(event.sender);
            }
        }
        if (remoteSender && ["beginRichClipboard", "completeRichClipboard", "cancelRichClipboard", "clipboardRead", "clipboardReadFiles"]
            .includes(data.cmd)) {
            writeLog("ignored local file clipboard processing in remote kernel mode");
            return false;
        }
        // 原生剪贴板格式(公式、Office、WPS)同样属于本地机密,远程内核窗口禁止读取。
        if (remoteSender && ["clipboardReadMathML", "clipboardReadOffice", "clipboardReadWPS"].includes(data.cmd)) {
            writeLog("ignored local native clipboard processing in remote kernel mode");
            return "";
        }
        if (remoteSender && data.cmd === "showOpenDialog") {
            writeLog("ignored local open dialog in remote kernel mode");
            return {canceled: true, filePaths: []};
        }
        if (remoteSender && data.cmd === "showSaveDialog") {
            writeLog("ignored local save dialog in remote kernel mode");
            return {canceled: true, filePath: ""};
        }
        if (remoteSender && data.cmd === "printToPDF") {
            writeLog("ignored local PDF export in remote kernel mode");
            return;
        }
        if (remoteSender && data.cmd === "setProxy") {
            writeLog("ignored applying a server proxy to the remote client");
            return false;
        }
        if (data.cmd === "clipboardRead") {
            return readClipboardText(await clipboard.read(), rawFormatType(data.format));
        }
        if (data.cmd === "clipboardReadFiles") {
            return parseClipboardFilePaths(await readClipboardText(await clipboard.read(), "text/uri-list"));
        }
        if (data.cmd === "clipboardReadMathML") {
            const items = await clipboard.read();
            if (typeof data.text !== "string" ||
                normalizeClipboardText(await readClipboardText(items, "text/plain")) !== normalizeClipboardText(data.text)) {
                return "";
            }
            const formats = getClipboardFormats(items).filter((format) =>
                /^mathml(?: presentation)?$/i.test(format));
            formats.push("MathML", "MathML Presentation");
            // 按原生格式读取 UTF-16 编码的 Office 公式。
            for (const format of new Set(formats)) {
                const buffer = await readClipboardBuffer(items, rawFormatType(format));
                if (buffer.length === 0 || buffer.length > 1024 * 1024 || buffer.length % 2 !== 0) {
                    continue;
                }
                const mathML = buffer.toString("utf16le")
                    .replace(/^\uFEFF/, "")
                    .replace(/\0+$/, "")
                    .trim();
                if (/<(?:[A-Za-z_][\w.-]*:)?math(?:\s|>)/i.test(mathML)) {
                    return mathML;
                }
            }
            return "";
        }
        if (data.cmd === "clipboardReadOffice") {
            const items = await clipboard.read();
            if (typeof data.text !== "string" ||
                normalizeClipboardText(await readClipboardText(items, "text/plain")) !== normalizeClipboardText(data.text)) {
                return "";
            }
            const buffer = await readClipboardBuffer(items, rawFormatType("Embed Source"));
            const compoundFileSignature = Buffer.from([0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1]);
            if (buffer.length === 0 || buffer.length > 8 * 1024 * 1024 ||
                !buffer.subarray(0, compoundFileSignature.length).equals(compoundFileSignature)) {
                return "";
            }
            return buffer.toString("base64");
        }
        if (data.cmd === "clipboardReadWPS") {
            const items = await clipboard.read();
            if (typeof data.text !== "string" ||
                normalizeClipboardText(await readClipboardText(items, "text/plain")) !== normalizeClipboardText(data.text)) {
                return "";
            }
            const formats = getClipboardFormats(items).filter((format) =>
                /kingsoft.*wps.*format/i.test(format));
            formats.push("Kingsoft WPS Format");
            for (let version = 6; version <= 20; version++) {
                formats.push(`Kingsoft WPS ${version}.0 Format`);
            }
            // 按原生格式读取 WPS 的压缩包数据。
            for (const format of new Set(formats)) {
                const buffer = await readClipboardBuffer(items, rawFormatType(format));
                if (buffer.length <= 8 * 1024 * 1024 && buffer[0] === 0x50 && buffer[1] === 0x4b) {
                    return buffer.toString("base64");
                }
            }
            return "";
        }
        if (data.cmd === "beginRichClipboard") {
            richClipboardOperation = undefined;
            const sequence = ++richClipboardSequence;
            const items = await clipboard.read();
            const text = await readClipboardText(items, "text/plain");
            const html = await readClipboardText(items, "text/html");
            if (sequence !== richClipboardSequence) {
                return;
            }
            if (typeof data.text !== "string" || typeof data.marker !== "string" ||
                normalizeClipboardText(text) !== normalizeClipboardText(data.text) ||
                !data.marker || !html.includes(data.marker)) {
                return;
            }

            const token = `${Date.now()}-${richClipboardSequence}`;
            richClipboardOperation = {
                token,
                senderId: event.sender.id,
                requestedText: data.text,
                text,
                html
            };
            return token;
        }
        if (data.cmd === "completeRichClipboard") {
            const operation = richClipboardOperation;
            if (!operation || operation.token !== data.token || operation.senderId !== event.sender.id) {
                return false;
            }
            const items = await clipboard.read();
            const text = await readClipboardText(items, "text/plain");
            const clipboardHTML = await readClipboardText(items, "text/html");
            if (richClipboardOperation !== operation) {
                return false;
            }
            if (operation.requestedText !== data.text || text !== operation.text ||
                clipboardHTML !== operation.html || typeof data.html !== "string" ||
                !Array.isArray(data.replacements) || 1024 < data.replacements.length) {
                richClipboardOperation = undefined;
                return false;
            }

            let html = data.html;
            for (const replacement of data.replacements) {
                let isFile = false;
                if (replacement && typeof replacement.path === "string" && path.isAbsolute(replacement.path)) {
                    try {
                        isFile = fs.statSync(replacement.path).isFile();
                    } catch {
                        isFile = false;
                    }
                }
                if (!replacement || typeof replacement.placeholder !== "string" || !replacement.placeholder ||
                    !isFile || !html.includes(replacement.placeholder)) {
                    richClipboardOperation = undefined;
                    return false;
                }
                const fileURL = pathToFileURL(replacement.path).href.replaceAll("&", "&amp;");
                html = html.split(replacement.placeholder).join(fileURL);
            }

            richClipboardOperation = undefined;
            await clipboard.write([new ClipboardItem({"text/plain": data.text, "text/html": html})]);
            return true;
        }
        if (data.cmd === "cancelRichClipboard") {
            if (richClipboardOperation?.token === data.token && richClipboardOperation.senderId === event.sender.id) {
                richClipboardOperation = undefined;
            }
        }
        if (data.cmd === "showOpenDialog") {
            if (data.singleton) {
                const singleton = `${event.sender.id}:${data.singleton}`;
                if (openDialogSingletons.has(singleton)) {
                    return {canceled: true, filePaths: []};
                }
                openDialogSingletons.add(singleton);
                const options = {...data};
                delete options.cmd;
                delete options.singleton;
                return dialog.showOpenDialog(options).finally(() => {
                    openDialogSingletons.delete(singleton);
                });
            }
            return dialog.showOpenDialog(data);
        }
        if (data.cmd === "getContentsId") {
            return event.sender.id;
        }
        if (["siyuan-window-workspace-set", "siyuan-window-workspace-focus", "siyuan-window-workspace-get-open",
            "siyuan-window-workspace-flush-all"].includes(data.cmd)) {
            const kernelTarget = getWindowKernelTarget(event.sender.id);
            if (!kernelTarget) {
                return false;
            }
            if (data.cmd === "siyuan-window-workspace-get-open") {
                return windowWorkspaces.list(kernelTarget.origin);
            }
            if (data.cmd === "siyuan-window-workspace-flush-all") {
                return flushWindowWorkspaces(windowWorkspaces.list(kernelTarget.origin)
                    .map(id => windowWorkspaces.get(kernelTarget.origin, id)).filter(Boolean), ipcMain);
            }
            if (data.cmd === "siyuan-window-workspace-focus") {
                const window = windowWorkspaces.get(kernelTarget.origin, data.id);
                if (window) {
                    showWindow(window);
                    return true;
                }
                return false;
            }
            const window = getWindowByContentId(event.sender.id);
            if (!window || getWindowPathname(window) !== "/stage/build/app/window.html") {
                return false;
            }
            return windowWorkspaces.associate(window, kernelTarget.origin, data.id);
        }
        if (data.cmd === "isAlwaysOnTop") {
            const wnd = getWindowByContentId(event.sender.id);
            if (!wnd) {
                return false;
            }
            return wnd.isAlwaysOnTop();
        }
        if (data.cmd === "availableSpellCheckerLanguages") {
            return event.sender.session.availableSpellCheckerLanguages;
        }
        if (data.cmd === "setProxy") {
            return setProxy(data.proxyURL, event.sender, data.proxyMode);
        }
        if (data.cmd === "showSaveDialog") {
            return dialog.showSaveDialog(data);
        }
        if (data.cmd === "isFullScreen") {
            const wnd = getWindowByContentId(event.sender.id);
            if (!wnd) {
                return false;
            }
            return wnd.isFullScreen();
        }
        if (data.cmd === "isMaximized") {
            const wnd = getWindowByContentId(event.sender.id);
            if (!wnd) {
                return false;
            }
            return wnd.isMaximized();
        }
        if (data.cmd === "getMicrophone") {
            return systemPreferences.getMediaAccessStatus("microphone");
        }
        if (data.cmd === "askMicrophone") {
            return systemPreferences.askForMediaAccess("microphone");
        }
        if (data.cmd === "printToPDF") {
            try {
                return getWindowByContentId(data.webContentsId).webContents.printToPDF(data.pdfOptions);
            } catch (e) {
                writeLog("printToPDF: ", e);
                throw e;
            }
        }
        if (data.cmd === "siyuan-open-file") {
            const options = JSON.parse(data.options);
            return BrowserWindow.getAllWindows().some(item => {
                if (item.isDestroyed() || item.webContents.isDestroyed() ||
                    item.webContents.id === event.sender.id) {
                    return false;
                }

                let url;
                let ids;
                try {
                    const currentURL = item.webContents.getURL();
                    if (!currentURL) {
                        return false;
                    }
                    url = new URL(currentURL);
                    ids = decodeURIComponent(url.hash.substring(1)).split("\u200b");
                } catch {
                    return false;
                }
                if (data.port !== url.port) {
                    return false;
                }
                if (ids.includes(options.rootID) || ids.includes(options.assetPath)) {
                    item.focus();
                    item.webContents.send("siyuan-open-file", options);
                    return true;
                }
                return false;
            });
        }
    });

    ipcMain.on("siyuan-event", (event) => {
        if (initEventId.includes(event.sender.id)) {
            return;
        }
        initEventId.push(event.sender.id);
        const currentWindow = getWindowByContentId(event.sender.id);
        if (!currentWindow) {
            return;
        }
        latestActiveWindow = currentWindow;
        applyMacAppMenuForWindow(currentWindow);
        const webContentsId = currentWindow.webContents.id;
        currentWindow.on("closed", () => {
            forgetAppMenuWebContents(webContentsId);
        });
        currentWindow.on("focus", () => {
            event.sender.send("siyuan-event", "focus");
            latestActiveWindow = currentWindow;
            applyMacAppMenuForWindow(currentWindow);
        });
        currentWindow.on("blur", () => {
            event.sender.send("siyuan-event", "blur");
        });
        if ("darwin" !== process.platform) {
            currentWindow.on("maximize", () => {
                event.sender.send("siyuan-event", "maximize");
            });
            currentWindow.on("unmaximize", () => {
                event.sender.send("siyuan-event", "unmaximize");
            });
        }
        currentWindow.on("enter-full-screen", () => {
            event.sender.send("siyuan-event", "enter-full-screen");
        });
        currentWindow.on("leave-full-screen", () => {
            event.sender.send("siyuan-event", "leave-full-screen");
        });
    });
    ipcMain.on("siyuan-cmd", (event, data) => {
        let cmd = data;
        let webContentsId = event.sender.id;
        if (typeof data !== "string") {
            cmd = data.cmd;
            if (data.webContentsId) {
                webContentsId = data.webContentsId;
            }
        }
        const currentWindow = getWindowByContentId(webContentsId);
        const remoteSender = getWindowKernelTarget(event.sender.id)?.mode === "remote";
        switch (cmd) {
            case "showItemInFolder":
                if (remoteSender) {
                    writeLog("ignored showing a server path in remote kernel mode");
                    break;
                }
                shell.showItemInFolder(data.filePath);
                break;
            case "notification": {
                const n = new Notification({
                    title: data.title,
                    body: data.body,
                    timeoutType: data.timeoutType,
                });
                n.on("click", () => {
                    currentWindow.focus();
                    currentWindow.show();
                });
                n.show();
                break;
            }
            case "setSpellCheckerLanguages":
                BrowserWindow.getAllWindows().forEach(item => {
                    item.webContents.session.setSpellCheckerLanguages(data.languages);
                });
                break;
            case "openPath":
                if (remoteSender) {
                    writeLog("ignored opening a server path in remote kernel mode");
                    break;
                }
                shell.openPath(data.filePath);
                break;
            case "openDevTools":
                devToolsDock.openDevTools(event.sender, process.platform, data);
                break;
            case "toggleDevTools":
                devToolsDock.toggleDevTools(event.sender);
                break;
            case "unregisterGlobalShortcut": {
                const workspaceItem = workspaces.find(item => item.webContentsId === event.sender.id);
                if (!workspaceItem) {
                    break;
                }
                if (data.accelerator) {
                    globalShortcut.unregister(hotKey2Electron(data.accelerator));
                }
                break;
            }
            case "registerGlobalShortcut": {
                const workspaceItem = workspaces.find(item => item.webContentsId === event.sender.id);
                if (!workspaceItem) {
                    break;
                }
                if (data.accelerator) {
                    globalShortcut.unregister(hotKey2Electron(data.accelerator));
                    globalShortcut.register(hotKey2Electron(data.accelerator), () => {
                        const targetWorkspace = getGlobalShortcutWorkspace(workspaceItem);
                        if (targetWorkspace) {
                            targetWorkspace.browserWindow.webContents.send("siyuan-hotkey", {
                                hotkey: data.accelerator
                            });
                        }
                    });
                }
                break;
            }
            case "setTitleBarOverlay":
                if (event.senderFrame === event.sender.mainFrame && webContentsId === event.sender.id) {
                    updateTitleBarOverlay(currentWindow, data);
                }
                break;
            case "setTrafficLightPosition":
                if (!currentWindow || !currentWindow.setWindowButtonPosition) {
                    return;
                }
                if (new URL(currentWindow.getURL()).pathname === "/stage/build/app/window.html") {
                    data.position.y += 5 * data.zoom;
                }
                currentWindow.setWindowButtonPosition(data.position);
                break;
            case "show":
                if (!currentWindow) {
                    return;
                }
                showWindow(currentWindow);
                break;
            case "hide":
                if (!currentWindow) {
                    return;
                }
                currentWindow.hide();
                break;
            case "minimize":
                if (!currentWindow) {
                    return;
                }
                currentWindow.minimize();
                break;
            case "maximize":
                if (!currentWindow) {
                    return;
                }
                currentWindow.maximize();
                break;
            case "restore":
                if (!currentWindow) {
                    return;
                }
                if (currentWindow.isFullScreen()) {
                    currentWindow.setFullScreen(false);
                } else {
                    currentWindow.unmaximize();
                }
                break;
            case "focus":
                if (!currentWindow) {
                    return;
                }
                currentWindow.focus();
                break;
            case "setAlwaysOnTopFalse":
                if (!currentWindow) {
                    return;
                }
                currentWindow.setAlwaysOnTop(false);
                break;
            case "setAlwaysOnTopTrue":
                if (!currentWindow) {
                    return;
                }
                // Windows 置顶窗口使用不受任务栏后置限制的级别。
                currentWindow.setAlwaysOnTop(true, "win32" === process.platform ? "pop-up-menu" : "floating");
                break;
            case "clearCache":
                event.sender.session.clearCache();
                break;
            case "redo":
                event.sender.redo();
                break;
            case "undo":
                event.sender.undo();
                break;
            case "destroy":
                if (!currentWindow) {
                    return;
                }
                currentWindow.destroy();
                break;
            case "writeLog":
                writeLog(data.msg);
                break;
            case "closeButtonBehavior":
                if (!currentWindow) {
                    return;
                }
                if (currentWindow.isFullScreen()) {
                    currentWindow.once("leave-full-screen", () => {
                        currentWindow.hide();
                    });
                    currentWindow.setFullScreen(false);
                } else {
                    currentWindow.hide();
                }
                break;
        }
    });
    ipcMain.on("siyuan-config-tray", (event, data) => {
        workspaces.find(item => {
            if (item.browserWindow.webContents.id === event.sender.id) {
                hideWindow(item.browserWindow);
                if ("win32" === process.platform || "linux" === process.platform) {
                    resetTrayMenu(item.tray, data.languages, item.browserWindow);
                }
                return true;
            }
        });
    });
    ipcMain.on("siyuan-export-pdf", (event, data) => {
        if (getWindowKernelTarget(event.sender.id)?.mode === "remote") {
            writeLog("ignored local PDF export in remote kernel mode");
            return;
        }
        data.webContentsId = event.sender.id;
        getWindowByContentId(data.parentWindowId).send("siyuan-export-pdf", data);
    });
    ipcMain.on("siyuan-export-newwindow", (event, data) => {
        const kernelTarget = getWindowKernelTarget(event.sender.id);
        if (kernelTarget?.mode === "remote") {
            writeLog("ignored local PDF export window for remote kernel");
            return;
        }
        // The PDF/Word export preview window automatically adjusts according to the size of the main window https://github.com/siyuan-note/siyuan/issues/10554
        const wndBounds = getWindowByContentId(event.sender.id).getBounds();
        const wndScreen = screen.getDisplayNearestPoint({x: wndBounds.x, y: wndBounds.y});
        const printWin = new BrowserWindow({
            title: "SiYuan",
            show: true,
            width: Math.floor(wndScreen.size.width * 0.8),
            height: Math.floor(wndScreen.size.height * 0.8),
            resizable: true,
            frame: "darwin" === process.platform,
            icon: path.join(appDir, "stage", "icon-large.png"),
            titleBarStyle: "hidden",
            webPreferences: {
                contextIsolation: false,
                nodeIntegration: true,
                webviewTag: true,
                webSecurity: false,
                autoplayPolicy: "user-gesture-required" // 桌面端禁止自动播放多媒体 https://github.com/siyuan-note/siyuan/issues/7587
            },
        });
        printWin.center();
        rememberWindowKernelTarget(printWin, kernelTarget || createLocalKernelTarget());
        printWin.webContents.userAgent = "SiYuan/" + appVer + " https://b3log.org/siyuan Electron " + printWin.webContents.userAgent;
        printWin.loadURL(data);
        windowNavigate(printWin, "export", (kernelTarget || createLocalKernelTarget()).origin);
    });
    ipcMain.on("siyuan-quit", (event, port) => {
        const kernelTarget = getWindowKernelTarget(event.sender.id);
        const workspace = workspaces.find((item) => item.webContentsId === event.sender.id);
        if (kernelTarget?.mode === "remote") {
            if (workspace) {
                exitWorkspace(workspace);
            } else {
                const senderWindow = BrowserWindow.fromWebContents(event.sender);
                markExpectedRendererExit(senderWindow);
                senderWindow?.destroy();
            }
            return;
        }
        exitApp(port);
    });
    ipcMain.handle("siyuan-install-update", (event, data) => {
        return beginUpdateInstall(event, data);
    });
    ipcMain.on("siyuan-show-window", (event) => {
        const mainWindow = getWindowByContentId(event.sender.id);
        if (!mainWindow) {
            return;
        }

        if (mainWindow.isMinimized()) {
            mainWindow.restore();
        }
        mainWindow.show();
    });
    ipcMain.on("siyuan-open-window", (event, data) => {
        const kernelTarget = getWindowKernelTarget(event.sender.id);
        if (!kernelTarget) {
            writeLog("ignored opening a window without a kernel target");
            return;
        }
        let windowURL;
        try {
            windowURL = new URL(data.url);
        } catch (error) {
            writeLog("ignored opening a window with an invalid URL");
            return;
        }
        if (windowURL.origin !== kernelTarget.origin || windowURL.pathname !== "/stage/build/app/window.html") {
            writeLog("ignored opening a window outside the kernel origin");
            return;
        }
        if (kernelTarget.mode === "remote") {
            windowURL.searchParams.set("remote", "1");
        }
        const workspaceID = windowURL.searchParams.get("windowWorkspace");
        if (workspaceID) {
            if (!/^\d{14}-[a-z0-9]{7}$/.test(workspaceID)) {
                return;
            }
            const existingWindow = windowWorkspaces.get(kernelTarget.origin, workspaceID);
            if (existingWindow) {
                showWindow(existingWindow);
                return;
            }
        }
        const themeMode = data.themeMode === "dark" ? "dark" : "light";
        const backgroundColor = /^#[\da-f]{6}$/i.test(data.backgroundColor) ? data.backgroundColor :
            (themeMode === "dark" ? "#1e1e1e" : "#ffffff");
        const foregroundColor = /^#[\da-f]{6}$/i.test(data.foregroundColor) ? data.foregroundColor :
            (themeMode === "dark" ? "#d4d4d4" : "#222222");
        windowURL.searchParams.set("windowThemeMode", themeMode);
        windowURL.searchParams.set("windowBackground", backgroundColor);
        windowURL.searchParams.set("windowForeground", foregroundColor);
        const mainWindow = BrowserWindow.getFocusedWindow() || BrowserWindow.getAllWindows()[0];
        const mainBounds = mainWindow.getBounds();
        const mainScreen = screen.getDisplayNearestPoint({x: mainBounds.x, y: mainBounds.y});
        const geometry = workspaceID ? normalizeWindowGeometry(data.windowGeometry, screen) : undefined;
        const win = new BrowserWindow({
            title: "SiYuan",
            // 先在隐藏状态完成定位和加载,等画面就绪或短暂延迟后再显示,
            // 避免窗口映射早于首帧提交时出现系统填充的近白色占位帧。
            show: false,
            backgroundColor,
            trafficLightPosition: {x: 8, y: 13},
            width: Math.floor(data.width || mainScreen.size.width * 0.7),
            height: Math.floor(data.height || mainScreen.size.height * 0.9),
            ...geometry,
            minWidth: 493,
            minHeight: 376,
            fullscreenable: true,
            frame: "darwin" === process.platform,
            icon: path.join(appDir, "stage", "icon-large.png"),
            titleBarStyle: "hidden",
            // 独立文档窗口的顶栏使用面板高度,并跟随当前界面密度预留。
            titleBarOverlay: getTitleBarOverlayOptions(process.platform, getCaptionHeight(data.compactMode, true)),
            webPreferences: {
                contextIsolation: false,
                nodeIntegration: true,
                nodeIntegrationInSubFrames: false,
                nodeIntegrationInWorker: false,
                webviewTag: kernelTarget.mode !== "remote",
                webSecurity: kernelTarget.mode === "remote",
                ...(kernelTarget.mode === "remote" ? {session: getRemoteSession(kernelTarget)} : {}),
                autoplayPolicy: "user-gesture-required" // 桌面端禁止自动播放多媒体 https://github.com/siyuan-note/siyuan/issues/7587
            },
        });
        remote.enable(win.webContents);
        bindSpellcheckContextMenu(win.webContents);
        rememberWindowKernelTarget(win, kernelTarget);

        if (workspaceID) {
            windowWorkspaces.associate(win, kernelTarget.origin, workspaceID);
        }

        if (!geometry && data.position) {
            win.setPosition(data.position.x, data.position.y);
        } else if (!geometry) {
            win.center();
        }
        win.setAlwaysOnTop(data.alwaysOnTop, "win32" === process.platform ? "pop-up-menu" : "floating");
        win.webContents.userAgent = "SiYuan/" + appVer + " https://b3log.org/siyuan Electron " + win.webContents.userAgent;
        win.webContents.session.setSpellCheckerLanguages(["en-US"]);
        // 显示时机:首帧(ready-to-show)或短延迟,谁先到用谁。
        // ready-to-show 在本应用里可能晚到 1 秒以上,定时器保证窗口及时出现;
        // 两者都晚于创建,因此首帧直接是主题背景,不会闪白。
        const revealDelay = 150;
        let revealed = false;
        let revealTimer;
        const revealWindow = () => {
            if (revealed || win.isDestroyed()) {
                return;
            }
            revealed = true;
            clearTimeout(revealTimer);
            // 隐藏窗口上最大化或进入全屏会直接映射窗口,因此和显示一起执行。
            if (geometry && data.windowGeometry.maximized) {
                win.maximize();
            }
            if (geometry && data.windowGeometry.fullscreen) {
                win.setFullScreen(true);
            }
            showWindow(win);
        };
        win.once("ready-to-show", revealWindow);
        revealTimer = setTimeout(revealWindow, revealDelay);
        // 渲染异常时仍显示窗口,避免留下无法访问的隐藏窗口。
        const forceRevealTimer = setTimeout(() => {
            if (!revealed) {
                writeLog("detached window ready-to-show timeout, show it anyway");
                revealWindow();
            }
        }, 60000);
        win.once("closed", () => {
            clearTimeout(revealTimer);
            clearTimeout(forceRevealTimer);
        });
        win.loadURL(windowURL.href);
        windowNavigate(win, "window", kernelTarget.origin, kernelTarget.mode === "remote");
        win.on("close", (event) => {
            if (!initializedWindowIds.has(win.webContents.id) ||
                (kernelTarget.mode === "remote" && getWindowPathname(win) !== "/stage/build/app/window.html")) {
                event.preventDefault();
                markExpectedRendererExit(win);
                win.destroy();
                return;
            }
            if (win && !win.isDestroyed()) {
                win.webContents.send("siyuan-save-close");
            }
            event.preventDefault();
        });
        const targetScreen = screen.getDisplayNearestPoint(screen.getCursorScreenPoint());
        if (!geometry && mainScreen.id !== targetScreen.id) {
            win.setBounds(targetScreen.workArea);
        }
    });
    ipcMain.on("siyuan-open-workspace", (event, data) => {
        if (getWindowKernelTarget(event.sender.id)?.mode === "remote") {
            writeLog("ignored opening a local workspace in remote kernel mode");
            return;
        }
        if (updateInstallPromise) {
            writeLog("ignored opening workspace while installing update");
            return;
        }
        const foundWorkspace = workspaces.find((item) => {
            if (item.workspaceDir === data.workspace) {
                showWindow(item.browserWindow);
                return true;
            }
        });
        if (!foundWorkspace) {
            initKernel(data.workspace, "", "").then((startedKernelPort) => {
                if (startedKernelPort) {
                    initMainWindow(startedKernelPort);
                }
            });
        }
    });
    ipcMain.handle("siyuan-init", async (event, data) => {
        const kernelTarget = getWindowKernelTarget(event.sender.id);
        if (kernelTarget) {
            initializedWindowIds.add(event.sender.id);
        }
        const capabilities = getKernelConnection(kernelTarget);
        const exitWS = workspaces.find(item => {
            if (event.sender.id === item.webContentsId && item.initialized) {
                if (item.tray && ("win32" === process.platform || "linux" === process.platform)) {
                    // Tray menu text does not change with the appearance language https://github.com/siyuan-note/siyuan/issues/7935
                    resetTrayMenu(item.tray, data.languages, item.browserWindow);
                }
                return true;
            }
        });
        if (exitWS) {
            if (!exitWS.ownsKernel) {
                setTimeout(() => flushPendingRemoteOpenURLs(exitWS.browserWindow), 100);
            }
            return capabilities;
        }

        const workspaceItem = workspaces.find((item) => event.sender.id === item.webContentsId);
        if (workspaceItem) {
            workspaceItem.initialized = true;
            workspaceItem.workspaceDir = workspaceItem.ownsKernel ? data.workspaceDir : "";
            let tray;
            if ("win32" === process.platform || "linux" === process.platform) {
                // 系统托盘
                tray = new Tray(path.join(appDir, "stage", "icon-large.png"));
                const trayName = workspaceItem.ownsKernel ? path.basename(data.workspaceDir) :
                    new URL(workspaceItem.kernelTarget.origin).host;
                tray.setToolTip(`${trayName} - SiYuan v${appVer}`);
                const mainWindow = getWindowByContentId(event.sender.id);
                if (!mainWindow || mainWindow.isDestroyed()) {
                    tray.destroy();
                    tray = undefined;
                } else {
                    resetTrayMenu(tray, data.languages, mainWindow);
                    tray.on("click", () => {
                        showHideWindow(tray, data.languages, mainWindow);
                    });
                }
            }
            workspaceItem.tray = tray;
        }
        if (workspaceItem?.ownsKernel) {
            await net.fetch(workspaceItem.kernelTarget.origin + "/api/system/uiproc?pid=" + process.pid, {method: "POST"});
        } else if (workspaceItem) {
            setTimeout(() => flushPendingRemoteOpenURLs(workspaceItem.browserWindow), 100);
        }
        return capabilities;
    });
    ipcMain.on("siyuan-hotkey", (event, data) => {
        if (!Array.isArray(data.hotkeys)) {
            return;
        }
        const ownerWorkspace = workspaces.find(workspaceItem =>
            event.sender.id === workspaceItem.browserWindow.webContents.id);
        if (!ownerWorkspace) {
            return;
        }
        const failed = updateGlobalShortcutBindings(ownerWorkspace, data, {
            workspaces,
            globalShortcut,
            convert: hotKey2Electron,
            getActiveId: () => latestActiveWindow && !latestActiveWindow.isDestroyed() ?
                latestActiveWindow.webContents.id : undefined,
            toggle: workspace => {
                toggleMainWindow(workspace.browserWindow);
                if (process.platform === "win32" || process.platform === "linux") {
                    resetTrayMenu(workspace.tray, workspace.hotkeyLanguages, workspace.browserWindow);
                }
            },
            dispatch: (workspace, hotkey) => workspace.browserWindow.webContents.send("siyuan-hotkey", {hotkey}),
            reportError: error => console.error("Global shortcut registration failed:", error),
        });
        event.sender.send("siyuan-hotkey", {failed});
    });
    ipcMain.on("siyuan-send-windows", (event, data) => {
        dispatchWindowMessage(data, {
            senderWebContentsId: event.sender.id,
            getKernelTarget: getWindowKernelTarget,
            getAllWindows: () => BrowserWindow.getAllWindows(),
        });
    });
    ipcMain.on("siyuan-block-drag", (event, data) => {
        if (!data || typeof data !== "object") {
            return;
        }
        if (data.phase === "release") {
            dropBlockDragFromTarget(event.sender.id, data);
            return;
        }
        if (typeof data.dragId !== "string" || !data.dragId ||
            !["begin", "move", "payload", "drop", "drop-ack", "end"].includes(data.phase)) {
            return;
        }
        if (data.phase === "drop-ack") {
            if (!Number.isSafeInteger(data.sourceWebContentsId) || !Number.isSafeInteger(data.sequence)) {
                return;
            }
            const sourceSessionKey = getBlockDragSessionKey(data.sourceWebContentsId, data.dragId);
            const sourceDragSession = blockDragSessions.get(sourceSessionKey);
            if (!sourceDragSession || sourceDragSession.targetWebContentsId !== event.sender.id ||
                sourceDragSession.pendingDropSequence !== data.sequence) {
                return;
            }
            sourceDragSession.pendingDropSequence = undefined;
            sourceDragSession.waitingForDropPayload = false;
            if (sourceDragSession.dropTargetWebContentsId !== undefined) {
                sendBlockDragMessage(sourceDragSession.sourceWebContentsId, {
                    phase: "complete",
                    dragId: sourceDragSession.dragId,
                    remote: true,
                });
                finishBlockDragSession(sourceSessionKey, sourceDragSession);
                return;
            }
            sendBlockDragRoute(sourceDragSession, true, data.sequence);
            return;
        }
        const sourceWebContentsId = event.sender.id;
        const sessionKey = getBlockDragSessionKey(sourceWebContentsId, data.dragId);
        if (data.phase === "begin") {
            const kernelTarget = windowKernelTargets.get(sourceWebContentsId);
            if (!kernelTarget || !initializedWindowIds.has(sourceWebContentsId)) {
                return;
            }
            for (const [activeSessionKey, activeSession] of blockDragSessions) {
                if (activeSession.sourceWebContentsId === sourceWebContentsId) {
                    finishBlockDragSession(activeSessionKey, activeSession);
                }
            }
            const point = normalizeBlockDragPoint(data.point);
            const payload = normalizeBlockDragPayload(data.payload);
            const dragSession = {
                dragId: data.dragId,
                sourceWebContentsId,
                kernelOrigin: kernelTarget.origin,
                point,
                payload,
                payloadRequested: false,
                targetWebContentsId: undefined,
            };
            blockDragSessions.set(sessionKey, dragSession);
            startBlockDragCursorPolling(sessionKey, dragSession);
            return;
        }
        const dragSession = blockDragSessions.get(sessionKey);
        if (!dragSession) {
            return;
        }
        if (dragSession.dropping && data.phase !== "end" &&
            !(data.phase === "payload" && dragSession.waitingForDropPayload)) {
            return;
        }
        const point = normalizeBlockDragPoint(data.point);
        if (point) {
            updateBlockDragCursorPoint(dragSession, point);
        }
        if (data.payload !== undefined) {
            const payload = normalizeBlockDragPayload(data.payload);
            if (payload) {
                dragSession.payload = payload;
                dragSession.payloadRequested = false;
            }
        }
        switch (data.phase) {
            case "move":
                routeBlockDragMove(dragSession);
                break;
            case "payload":
                if (dragSession.dropping) {
                    dispatchBlockDragDrop(dragSession);
                } else {
                    routeBlockDragMove(dragSession);
                }
                break;
            case "drop": {
                dragSession.dropping = true;
                dragSession.pendingDropSequence = dragSession.point?.sequence;
                dispatchBlockDragDrop(dragSession);
                break;
            }
            case "end":
                finishBlockDragSession(sessionKey, dragSession);
                break;
        }
    });
    ipcMain.on("siyuan-auto-launch", (event, data) => {
        const kernelTarget = getWindowKernelTarget(event.sender.id);
        const args = [];
        if (kernelTarget?.mode === "remote") {
            args.push("--remote=" + kernelTarget.origin);
        }
        if (data.openAsHidden) {
            args.push("--openAsHidden");
        }
        app.setLoginItemSettings({
            openAtLogin: data.openAtLogin,
            args,
        });
    });
    if (remoteKernelArgError) {
        if (remoteKernelArgError.code === "ERR_REMOTE_UNSAFE_CHROMIUM_SWITCH") {
            showErrorWindow("远程内核启动参数不安全", "Unsafe remote kernel arguments",
                "<div>远程内核模式不能与弱化网页或 TLS 安全的参数同时使用。</div>" +
                "<div>Remote kernel mode cannot be used with arguments that weaken web or TLS security.</div>");
        } else {
            showErrorWindow("远程内核地址无效", "Invalid remote kernel address",
                "<div>--remote 仅接受不带路径、查询或凭据的 HTTPS origin。</div>" +
                "<div>--remote only accepts an HTTPS origin without a path, query, or credentials.</div>");
        }
    } else if (remoteKernelTarget) {
        initRemoteKernel(remoteKernelTarget).then((result) => {
            if (result) {
                initMainWindow(result.target, result.authenticated);
            }
        }).catch((error) => {
            writeLog("initialize remote kernel failed: " + error);
            if (bootWindow && !bootWindow.isDestroyed()) {
                bootWindow.destroy();
            }
            showErrorWindow("连接远程内核失败", "Failed to connect to the remote kernel",
                "<div>连接远程内核时发生意外错误。</div><div>An unexpected error occurred while connecting to the remote kernel.</div>");
        });
    } else if (firstOpen) {
        const firstOpenWindow = new BrowserWindow({
            width: Math.floor(screen.getPrimaryDisplay().size.width * 0.6),
            height: Math.floor(screen.getPrimaryDisplay().workAreaSize.height * 0.8),
            frame: "darwin" === process.platform,
            titleBarStyle: "hidden",
            fullscreenable: false,
            icon: path.join(appDir, "stage", "icon-large.png"),
            transparent: "darwin" === process.platform,
            webPreferences: {
                nodeIntegration: true, webviewTag: true, webSecurity: false, contextIsolation: false,
            },
        });
        let initHTMLPath = path.join(appDir, "app", "electron", "init.html");
        if (isDevEnv) {
            initHTMLPath = path.join(appDir, "electron", "init.html");
        }

        // 改进桌面端初始化时使用的外观语言 https://github.com/siyuan-note/siyuan/issues/6803
        const languages = app.getPreferredSystemLanguages();
        const language = resolveAppLanguage(languages);
        firstOpenWindow.loadFile(initHTMLPath, {
            query: {
                lang: language,
                home: app.getPath("home"),
                v: appVer,
                icon: path.join(appDir, "stage", "icon-large.png"),
            },
        });
        firstOpenWindow.show();
        // 初始化启动
        ipcMain.on("siyuan-first-init", (event, data) => {
            initKernel(data.workspace, "", data.lang).then((startedKernelPort) => {
                if (startedKernelPort) {
                    initMainWindow(startedKernelPort);
                }
            });
            firstOpenWindow.destroy();
        });
    } else if (appCrashInfo) {
        // 上次工作空间渲染进程崩溃,弹出安全模式选择窗口。
        const safeModeWindow = new BrowserWindow({
            width: Math.floor(screen.getPrimaryDisplay().size.width * 0.55),
            height: Math.floor(screen.getPrimaryDisplay().workAreaSize.height * 0.65),
            frame: "darwin" === process.platform,
            titleBarStyle: "hidden",
            fullscreenable: false,
            icon: path.join(appDir, "stage", "icon-large.png"),
            transparent: "darwin" === process.platform,
            webPreferences: {
                nodeIntegration: true, webviewTag: true, webSecurity: false, contextIsolation: false,
            },
        });
        let safeModeHTMLPath = path.join(appDir, "app", "electron", "workspace.html");
        if (isDevEnv) {
            safeModeHTMLPath = path.join(appDir, "electron", "workspace.html");
        }

        // 改进桌面端初始化时使用的外观语言 https://github.com/siyuan-note/siyuan/issues/6803
        const languages = app.getPreferredSystemLanguages();
        const language = resolveAppLanguage(languages);
        let crashWorkspace = appCrashInfo.workspaceDir || lastWorkspacePath;
        if (!appCrashInfo.workspaceDir && !isDirectory(crashWorkspace)) {
            crashWorkspace = availableWorkspaces[availableWorkspaces.length - 1] || lastWorkspacePath;
        }
        const crashWorkspaceMissing = !isDirectory(crashWorkspace);
        safeModeWindow.loadFile(safeModeHTMLPath, {
            query: {
                lang: language,
                home: app.getPath("home"),
                v: appVer,
                icon: path.join(appDir, "stage", "icon-large.png"),
                crash: "1",
                workspace: crashWorkspace,
                crashWorkspaceMissing: crashWorkspaceMissing ? "1" : "0",
                missing: crashWorkspaceMissing ? crashWorkspace : "",
                crashInfo: appCrashInfo.crashInfo,
            },
        });
        safeModeWindow.show();
        // 用户选择启动方式后启动内核,仅在内核启动成功后删除崩溃信息。
        ipcMain.on("siyuan-select-workspace", (event, data) => {
            initKernel(data.workspace, "", data.lang, data.safeMode).then((startedKernelPort) => {
                if (startedKernelPort) {
                    clearAppCrashInfo();
                    initMainWindow(startedKernelPort);
                }
            });
            safeModeWindow.destroy();
        });
    } else if (lastWorkspaceMissing) {
        // 上次使用的工作空间丢失,弹出选择工作空间窗口 https://github.com/siyuan-note/siyuan/issues/14748
        const missingWorkspaceWindow = new BrowserWindow({
            width: Math.floor(screen.getPrimaryDisplay().size.width * 0.55),
            height: Math.floor(screen.getPrimaryDisplay().workAreaSize.height * 0.65),
            frame: "darwin" === process.platform,
            titleBarStyle: "hidden",
            fullscreenable: false,
            icon: path.join(appDir, "stage", "icon-large.png"),
            transparent: "darwin" === process.platform,
            webPreferences: {
                nodeIntegration: true, webviewTag: true, webSecurity: false, contextIsolation: false,
            },
        });
        let missingWorkspaceHTMLPath = path.join(appDir, "app", "electron", "workspace.html");
        if (isDevEnv) {
            missingWorkspaceHTMLPath = path.join(appDir, "electron", "workspace.html");
        }

        // 改进桌面端初始化时使用的外观语言 https://github.com/siyuan-note/siyuan/issues/6803
        const languages = app.getPreferredSystemLanguages();
        const language = resolveAppLanguage(languages);
        missingWorkspaceWindow.loadFile(missingWorkspaceHTMLPath, {
            query: {
                lang: language,
                home: app.getPath("home"),
                v: appVer,
                icon: path.join(appDir, "stage", "icon-large.png"),
                missing: missingWorkspacePath,
                workspaces: availableWorkspaces.join("\n"),
            },
        });
        missingWorkspaceWindow.show();
        // 选择工作空间后启动内核
        ipcMain.on("siyuan-select-workspace", (event, data) => {
            initKernel(data.workspace, "", data.lang).then((startedKernelPort) => {
                if (startedKernelPort) {
                    initMainWindow(startedKernelPort);
                }
            });
            missingWorkspaceWindow.destroy();
        });
    } else {
        const workspace = getArg("--workspace");
        if (workspace) {
            writeLog("got arg [--workspace=" + workspace + "]");
        }
        const port = getArg("--port");
        if (port) {
            writeLog("got arg [--port=" + port + "]");
        }
        const safeMode = getArg("--safe-mode") === "true";
        if (safeMode) {
            writeLog("got arg [--safe-mode=true]");
        }
        const lang = getArg("--lang") || "";
        if (lang) {
            writeLog("got arg [--lang=" + lang + "]");
        }
        writeLog("initializing local kernel [" + (Date.now() - startupStartedAt) + "ms since app ready]");
        initKernel(workspace, port, lang, safeMode, preparedBoot).then((startedKernelPort) => {
            if (startedKernelPort) {
                initMainWindow(startedKernelPort);
            }
        });
    }

    // 电源相关事件必须放在 whenReady 里面,否则会导致 Linux 端无法正常启动 Trace/breakpoint trap (core dumped) https://github.com/siyuan-note/siyuan/issues/9347
    powerMonitor.on("suspend", () => {
        writeLog("system suspend");
    });
    powerMonitor.on("resume", async () => {
        // 桌面端系统休眠唤醒后判断网络连通性后再执行数据同步 https://github.com/siyuan-note/siyuan/issues/6687
        writeLog("system resume");
        void notebookSystemLock.retry();

        const isOnline = async () => {
            return net.isOnline();
        };
        let online = false;
        for (let i = 0; i < 7; i++) {
            if (await isOnline()) {
                online = true;
                break;
            }

            writeLog("network is offline");
            await sleep(1000);
        }

        if (!online) {
            writeLog("network is offline, do not sync after system resume");
            return;
        }

        await Promise.all(workspaces.map(async item => {
            const server = item.kernelTarget.origin;
            writeLog("sync after system resume [" + server + "/api/sync/performSync" + "]");
            try {
                const response = await (item.ownsKernel ? session.defaultSession : getRemoteSession(item.kernelTarget)).fetch(server + "/api/sync/performSync", {
                    method: "POST",
                    credentials: "include",
                    bypassCustomProtocolHandlers: !item.ownsKernel,
                    redirect: item.ownsKernel ? "follow" : "manual",
                });
                if (!response.ok) {
                    writeLog("sync after system resume rejected [HTTP " + response.status + "]");
                }
            } catch {
                writeLog("sync after system resume request failed");
            }
        }));
    });
    powerMonitor.on("shutdown", () => {
        writeLog("system shutdown");
        beginForcedSystemShutdown();
    });
    powerMonitor.on("lock-screen", () => {
        writeLog("system lock-screen");
        let applicationLocked = false;
        const lockApplication = () => {
            if (applicationLocked) {
                return;
            }
            applicationLocked = true;
            BrowserWindow.getAllWindows().forEach(item => {
                item.webContents.send("siyuan-send-windows", {cmd: "lockscreenByMode"});
            });
        };
        // 编辑器提交完成前保留访问会话,但内核请求失败不能延迟应用锁屏。
        const timeout = setTimeout(lockApplication, 1000);
        void notebookSystemLock.lock().finally(() => {
            clearTimeout(timeout);
            lockApplication();
        });
    });
    powerMonitor.on("unlock-screen", () => {
        void notebookSystemLock.retry();
    });
});

app.on("open-url", async (event, url) => { // for macOS
    if (updateInstallPromise) {
        writeLog("ignored URL while installing update");
        return;
    }
    if (url.startsWith("siyuan://")) {
        if (remoteKernelTarget) {
            const mainWorkspace = workspaces[0];
            if (mainWorkspace?.browserWindow && !mainWorkspace.browserWindow.isDestroyed() &&
                initializedWindowIds.has(mainWorkspace.webContentsId)) {
                showWindow(mainWorkspace.browserWindow);
                mainWorkspace.browserWindow.webContents.send("siyuan-open-url", url);
            } else {
                pendingRemoteOpenURLs.push(url);
            }
            return;
        }
        let isBackground = true;
        if (workspaces.length === 0) {
            isBackground = false;
            let index = 0;
            while (index < 10) {
                index++;
                await sleep(500);
                if (workspaces.length > 0) {
                    break;
                }
            }
        }
        if (!isBackground) {
            await sleep(1500);
        }
        workspaces.forEach(item => {
            if (item.browserWindow && !item.browserWindow.isDestroyed()) {
                item.browserWindow.webContents.send("siyuan-open-url", url);
            }
        });
    }
});

app.on("second-instance", (event, argv) => {
    writeLog("second-instance [" + argv + "]");
    if (updateInstallPromise) {
        writeLog("ignored second instance while installing update");
        return;
    }
    if (remoteKernelArgError) {
        writeLog("ignored second instance because the primary remote kernel argument is invalid");
        return;
    }
    const secondRemoteArg = getArgFrom(argv, "--remote");
    if (secondRemoteArg !== undefined || remoteKernelTarget) {
        const siyuanURL = argv.find((arg) => arg.startsWith("siyuan://"));
        const localTargetRequested = getArgFrom(argv, "--workspace") !== undefined ||
            getArgFrom(argv, "--port") !== undefined;
        let secondRemoteOrigin;
        if (secondRemoteArg !== undefined) {
            try {
                secondRemoteOrigin = normalizeRemoteKernelOrigin(secondRemoteArg);
                writeLog("got second-instance remote kernel [origin=" + secondRemoteOrigin + "]");
                if (!remoteKernelTarget || secondRemoteOrigin !== remoteKernelTarget.origin) {
                    writeLog("ignored a different remote kernel while another SiYuan instance is running");
                }
            } catch (error) {
                writeLog("ignored invalid second-instance remote kernel: " + error.message);
            }
        }
        if (remoteKernelTarget && localTargetRequested) {
            writeLog("ignored opening a local kernel target while remote kernel mode is running");
        }
        const allowDeepLink = shouldForwardRemoteDeepLink({
            currentOrigin: remoteKernelTarget?.origin,
            requestedOrigin: secondRemoteOrigin,
            remoteArgumentPresent: secondRemoteArg !== undefined,
            localTargetRequested,
        });
        if (workspaces.length > 0) {
            const mainWindow = workspaces[0].browserWindow;
            showWindow(mainWindow);
            if (siyuanURL && allowDeepLink && initializedWindowIds.has(mainWindow.webContents.id)) {
                mainWindow.webContents.send("siyuan-open-url", siyuanURL);
            } else if (siyuanURL && allowDeepLink) {
                pendingRemoteOpenURLs.push(siyuanURL);
            }
        } else if (siyuanURL && allowDeepLink) {
            pendingRemoteOpenURLs.push(siyuanURL);
        }
        return;
    }
    let workspace = getArgFrom(argv, "--workspace");
    if (workspace) {
        writeLog("got second-instance arg [--workspace=" + workspace + "]");
    }
    let port = getArgFrom(argv, "--port");
    if (port) {
        writeLog("got second-instance arg [--port=" + port + "]");
    } else {
        port = 0;
    }
    let lang = getArgFrom(argv, "--lang");
    if (lang) {
        writeLog("got second-instance arg [--lang=" + lang + "]");
    } else {
        lang = "";
    }
    const foundWorkspace = workspaces.find(item => {
        if (item.browserWindow && !item.browserWindow.isDestroyed()) {
            if (workspace && workspace === item.workspaceDir) {
                showWindow(item.browserWindow);
                return true;
            }
        }
    });
    if (foundWorkspace) {
        return;
    }
    if (workspace) {
        initKernel(workspace, port, lang).then((startedKernelPort) => {
            if (startedKernelPort) {
                initMainWindow(startedKernelPort);
            }
        });
        return;
    }

    const siyuanURL = argv.find((arg) => arg.startsWith("siyuan://"));
    workspaces.forEach(item => {
        if (item.browserWindow && !item.browserWindow.isDestroyed() && siyuanURL) {
            item.browserWindow.webContents.send("siyuan-open-url", siyuanURL);
        }
    });

    if (!siyuanURL && 0 < workspaces.length) {
        showWindow(workspaces[0].browserWindow);
    } else if (!siyuanURL && localKernelStartups.size > 0) {
        showWindow(localKernelStartups.values().next().value.window);
    }
});

app.on("activate", () => {
    if (updateInstallPromise || remoteKernelArgError) {
        return;
    }
    if (workspaces.length > 0) {
        const mainWindow = (latestActiveWindow && !latestActiveWindow.isDestroyed()) ? latestActiveWindow : workspaces[0].browserWindow;
        if (mainWindow && !mainWindow.isDestroyed()) {
            mainWindow.show();
        }
    }
    if (BrowserWindow.getAllWindows().length === 0) {
        if (remoteKernelTarget) {
            initRemoteKernel(remoteKernelTarget).then((result) => {
                if (result) {
                    initMainWindow(result.target, result.authenticated);
                }
            }).catch((error) => writeLog("reactivate remote kernel failed: " + error));
        } else {
            initMainWindow();
        }
    }
});

app.on("web-contents-created", (webContentsCreatedEvent, contents) => {
    bindWebviewDevToolsShortcut(contents, getWindowKernelTarget);
    contents.setWindowOpenHandler((details) => {
        const settings = settingsWindowPolicy(contents, details);
        if (settings) {
            return settings;
        }
        const kernelTarget = getWindowKernelTarget(contents.id);
        if (kernelTarget?.mode === "remote") {
            openExternalURL(details.url, true);
            return {action: "deny"};
        }
        // https://github.com/siyuan-note/siyuan/issues/10567
        if (details.url.startsWith("file:///") && details.disposition === "foreground-tab") {
            return;
        }
        // 在编辑器内打开链接的处理,比如 iframe 上的打开链接。
        shell.openExternal(details.url);
        return {action: "deny"};
    });
});

app.on("before-quit", (event) => {
    if (keepAppOpenDuringUpdate) {
        event.preventDefault();
        return;
    }
    workspaces.slice().forEach(item => {
        const pathname = getWindowPathname(item.browserWindow);
        if (!item.ownsKernel && (pathname !== "/stage/build/app/" ||
            !initializedWindowIds.has(item.webContentsId))) {
            const workspaceIndex = workspaces.indexOf(item);
            if (workspaceIndex > -1) {
                workspaces.splice(workspaceIndex, 1);
            }
            markExpectedRendererExit(item.browserWindow);
            item.browserWindow.destroy();
            return;
        }
        if (item.browserWindow && !item.browserWindow.isDestroyed()) {
            event.preventDefault();
            item.browserWindow.webContents.send("siyuan-save-close", true);
        }
    });
});

app.on("will-quit", relaunchConnection);

function writeLog(out) {
    console.log(out);
    const logFile = path.join(confDir, "app.log");
    let log = "";
    const maxLogLines = 1024;
    try {
        if (fs.existsSync(logFile)) {
            log = fs.readFileSync(logFile).toString();
            let lines = log.split("\n");
            if (maxLogLines < lines.length) {
                log = lines.slice(maxLogLines / 2, maxLogLines).join("\n") + "\n";
            }
        }
        out = out.toString();
        out = new Date().toISOString().replace(/T/, " ").replace(/\..+/, "") + " " + out;
        log += out + "\n";
        fs.writeFileSync(logFile, log);
    } catch (e) {
        console.error(e);
    }
}

// 同步记录工作空间主渲染进程崩溃标记,确保主进程退出前落盘。
const writeAppCrashMarker = (workspace, details) => {
    const timestamp = new Date().toISOString();
    const marker = {
        version: 1,
        timestamp: timestamp,
        reason: details.reason,
        exitCode: details.exitCode,
        workspaceDir: workspace.workspaceDir || "",
    };

    try {
        fs.writeFileSync(appCrashMarkerPath, JSON.stringify(marker, null, 2));
    } catch (e) {
        console.error(e);
    }

    try {
        const line = timestamp.replace(/T/, " ").replace(/\..+/, "") +
            " Render process gone [reason=" + details.reason + ", exitCode=" + details.exitCode +
            ", workspace=" + JSON.stringify(marker.workspaceDir) + "]";
        let log = "";
        if (fs.existsSync(appCrashLogPath)) {
            log = fs.readFileSync(appCrashLogPath, "utf8");
        }
        const lines = (log + line).trimEnd().split("\n").slice(-20);
        fs.writeFileSync(appCrashLogPath, lines.join("\n") + "\n");
    } catch (e) {
        console.error(e);
    }
};

const isDirectory = (filePath) => {
    if (!filePath) {
        return false;
    }

    try {
        return fs.statSync(filePath).isDirectory();
    } catch (e) {
        return false;
    }
};

// 优先读取结构化标记,并兼容旧版本的 app.crash.log。
const readAppCrashInfo = () => {
    if (fs.existsSync(appCrashMarkerPath)) {
        try {
            const markerText = fs.readFileSync(appCrashMarkerPath, "utf8");
            const marker = JSON.parse(markerText);
            if (noSafeModeReasons.has(marker.reason)) {
                fs.unlinkSync(appCrashMarkerPath);
            } else {
                let crashInfo = markerText;
                if (fs.existsSync(appCrashLogPath)) {
                    crashInfo = fs.readFileSync(appCrashLogPath, "utf8");
                }
                return {
                    workspaceDir: typeof marker.workspaceDir === "string" ? marker.workspaceDir : "",
                    crashInfo: crashInfo,
                };
            }
        } catch (e) {
            writeLog("read crash marker failed: " + e);
            try {
                return {
                    workspaceDir: "",
                    crashInfo: fs.readFileSync(appCrashMarkerPath, "utf8"),
                };
            } catch (readError) {
                writeLog("read invalid crash marker failed: " + readError);
                return {
                    workspaceDir: "",
                    crashInfo: "Invalid renderer crash marker",
                };
            }
        }
    }

    if (!fs.existsSync(appCrashLogPath)) {
        return undefined;
    }

    try {
        const crashInfo = fs.readFileSync(appCrashLogPath, "utf8");
        const legacyLines = crashInfo.split(/\r?\n/).filter((line) => line.trim());
        const reasons = legacyLines.map((line) => {
            const match = line.match(/reason=([^,\]]+)/);
            return match ? match[1] : undefined;
        });
        if (reasons.length > 0 && reasons.every((reason) => reason && noSafeModeReasons.has(reason))) {
            fs.unlinkSync(appCrashLogPath);
            writeLog("ignored legacy crash log without safe mode reason");
            return undefined;
        }
        return {
            workspaceDir: "",
            crashInfo: crashInfo,
        };
    } catch (e) {
        writeLog("read crash log failed: " + e);
        return {
            workspaceDir: "",
            crashInfo: "Unreadable renderer crash log",
        };
    }
};

// 安全模式选择后内核启动成功,删除本次恢复所使用的崩溃信息。
const clearAppCrashInfo = () => {
    // 诊断副本不参与启动判断,恢复成功后仍可导出最近一次崩溃记录。
    const archiveDir = path.join(confDir, "crash-history");
    [appCrashMarkerPath, appCrashLogPath].forEach((filePath) => {
        try {
            fs.mkdirSync(archiveDir, {recursive: true});
            const archivePath = path.join(archiveDir, path.basename(filePath));
            if (fs.existsSync(filePath)) {
                fs.copyFileSync(filePath, archivePath);
            } else {
                fs.rmSync(archivePath, {force: true});
            }
        } catch (e) {
            writeLog("archive crash info failed: " + e);
        }
        try {
            fs.unlinkSync(filePath);
        } catch (e) {
            // 文件不存在等异常忽略。
        }
    });
};