Build your personal knowledge base with Trilium Notes
TypeScript electronelectron-appknowledge-baseknowledge-graphknowledge-managementknowledge-management-graphlocal-firstnote-managmentnote-takernote-takingnotebooknotesnotes-apppersonal-knowledge-basepersonal-wikiscriptableself-hostedself-hostingwiki
import type {
BackupPassphraseChange,
BackupPassphraseStatus,
ElectronApi,
ElectronContextMenuParams,
NativeImportOptions,
OneNoteLoginResult,
RendererStartupMetric,
TranscriptionState,
TranscriptSource
} from "@triliumnext/commons";
import { contextBridge, ipcRenderer, webFrame, webUtils } from "electron";
contextBridge.exposeInMainWorld("electronApi", {
window: {
// Zoom
setZoomFactor(factor: number) {
webFrame.setZoomFactor(factor);
},
getZoomFactor(): number {
return webFrame.getZoomFactor();
},
// Theme
setNativeThemeSource(source: "system" | "light" | "dark") {
ipcRenderer.send("set-native-theme-source", source);
},
// Title bar
setTitleBarOverlay(options: { color: string; symbolColor: string; height?: number }) {
ipcRenderer.send("set-title-bar-overlay", options);
},
setWindowButtonPosition(position: { x: number; y: number }) {
ipcRenderer.send("set-window-button-position", position);
},
// Full screen
onEnterFullScreen(callback: () => void) {
ipcRenderer.on("enter-full-screen", () => callback());
},
onLeaveFullScreen(callback: () => void) {
ipcRenderer.on("leave-full-screen", () => callback());
},
isFullScreen(): boolean {
return ipcRenderer.sendSync("is-full-screen");
},
setFullScreen(enabled: boolean) {
ipcRenderer.send("set-full-screen", enabled);
},
// Window state
minimizeWindow() {
ipcRenderer.send("minimize-window");
},
maximizeWindow() {
ipcRenderer.send("maximize-window");
},
unmaximizeWindow() {
ipcRenderer.send("unmaximize-window");
},
isMaximized(): boolean {
return ipcRenderer.sendSync("is-maximized");
},
closeWindow() {
ipcRenderer.send("close-window");
},
isAlwaysOnTop(): boolean {
return ipcRenderer.sendSync("is-always-on-top");
},
setAlwaysOnTop(enabled: boolean) {
ipcRenderer.send("set-always-on-top", enabled);
},
toggleDevTools() {
ipcRenderer.send("toggle-dev-tools");
},
isDevToolsDocked(): boolean {
return ipcRenderer.sendSync("is-dev-tools-docked");
},
// App lifecycle
reloadAllWindows() {
ipcRenderer.send("reload-all-windows");
},
restartApp() {
ipcRenderer.send("restart-app");
},
toggleAllWindows() {
ipcRenderer.send("toggle-all-windows");
},
clearCache(): Promise<void> {
return ipcRenderer.invoke("clear-cache");
},
showWindow() {
ipcRenderer.send("show-window");
},
reportStartupMetric(metric: RendererStartupMetric) {
ipcRenderer.send("report-startup-metric", metric);
},
// Background effects
setBackgroundMaterial(material: string) {
ipcRenderer.send("set-background-material", material);
},
setVibrancy(vibrancy: string) {
ipcRenderer.send("set-vibrancy", vibrancy);
},
// Main → renderer events
onGlobalShortcut(callback: (actionName: string) => void) {
ipcRenderer.on("globalShortcut", (_event, actionName) => callback(actionName));
},
onOpenInSameTab(callback: (noteId: string) => void) {
ipcRenderer.on("openInSameTab", (_event, noteId) => callback(noteId));
},
onDevToolsDockChanged(callback: (docked: boolean) => void) {
ipcRenderer.on("dev-tools-dock-changed", (_event, docked: boolean) => callback(docked));
}
},
clipboard: {
copyImageToClipboard(buffer: Uint8Array) {
ipcRenderer.send("copy-image-to-clipboard", buffer);
},
readText() {
return ipcRenderer.invoke("read-clipboard-text");
},
readHTML() {
return ipcRenderer.invoke("read-clipboard-html");
}
},
shell: {
openExternal(url: string) {
ipcRenderer.send("open-external", url);
},
openPath(path: string): Promise<string> {
return ipcRenderer.invoke("open-path", path);
},
showItemInFolder(path: string) {
ipcRenderer.send("show-item-in-folder", path);
},
openFileUrl(fileUrl: string): Promise<string> {
return ipcRenderer.invoke("open-file-url", fileUrl);
},
downloadURL(url: string) {
ipcRenderer.send("download-url", url);
},
openCustom(filePath: string): Promise<boolean> {
return ipcRenderer.invoke("open-custom", filePath);
}
},
contextMenu: {
onContextMenu(callback: (params: ElectronContextMenuParams) => void) {
ipcRenderer.on("context-menu", (_event, params: ElectronContextMenuParams) => callback(params));
},
webContentsAction(action: "cut" | "copy" | "paste" | "pasteAndMatchStyle" | "insertText", text?: string) {
ipcRenderer.send("web-contents-action", action, text);
}
},
spellcheck: {
addWordToDictionary(word: string) {
ipcRenderer.send("add-word-to-dictionary", word);
},
getAvailableSpellCheckerLanguages(): string[] {
return ipcRenderer.sendSync("get-available-spellchecker-languages");
},
setSpellCheckerLanguages(languageCodes: string[]) {
ipcRenderer.send("set-spellchecker-languages", languageCodes);
},
setSpellCheckerEnabled(enabled: boolean) {
ipcRenderer.send("set-spellchecker-enabled", enabled);
}
},
systemIntegration: {
reloadTray() {
ipcRenderer.send("reload-tray");
},
reapplyLaunchOnStartup() {
ipcRenderer.send("reapply-launch-on-startup");
}
},
printing: {
sendPrintProgress(progress: number) {
ipcRenderer.send("print-progress", progress);
},
onPrintProgress(callback: (data: { progress: number; action: string }) => void) {
ipcRenderer.on("print-progress", (_event, data) => callback(data));
},
onPrintDone(callback: (printReport: unknown, liveJobId?: number) => void) {
ipcRenderer.on("print-done", (_event, printReport, liveJobId) => callback(printReport, liveJobId));
},
removePrintListeners() {
ipcRenderer.removeAllListeners("print-progress");
ipcRenderer.removeAllListeners("print-done");
},
getPrinters(): Promise<unknown[]> {
return ipcRenderer.invoke("get-printers");
},
exportAsPdfPreview(opts: Record<string, unknown>) {
ipcRenderer.send("export-as-pdf-preview", opts);
},
onExportAsPdfPreviewResult(callback: (result: { buffer?: Uint8Array; error?: string; requestId?: number }) => void) {
ipcRenderer.on("export-as-pdf-preview-result", (_event, result) => callback(result));
},
removeExportAsPdfPreviewResultListener() {
ipcRenderer.removeAllListeners("export-as-pdf-preview-result");
},
savePdf(data: { title: string; buffer: Uint8Array }) {
ipcRenderer.send("save-pdf", data);
},
printFromPreview(opts: Record<string, unknown>) {
ipcRenderer.send("print-from-preview", opts);
}
},
nativeExport: {
exportSubtreeToFile(opts: { branchId: string; format: string; title: string; taskId: string }) {
return ipcRenderer.invoke("export-subtree-to-file", opts);
}
},
nativeImport: {
pickFiles() {
return ipcRenderer.invoke("import-pick-files");
},
grantDroppedFiles(files: File[]) {
// Resolve each dropped File to its on-disk path here in the preload: getPathForFile returns a
// real path only for a genuinely user-supplied file (empty for anything a script built), so the
// File is the capability. Only the resolved paths cross to the main process — the path-accepting
// channel is never exposed to the renderer, so a script can't smuggle in an arbitrary path.
const paths = files.map((file) => webUtils.getPathForFile(file)).filter((path) => !!path);
return ipcRenderer.invoke("import-grant-dropped", paths);
},
importFromToken(opts: { token: string; parentNoteId: string; taskId: string; options: NativeImportOptions; last: boolean; format?: string }) {
return ipcRenderer.invoke("import-from-token", opts);
}
},
dialog: {
pickDirectory(opts?: { defaultPath?: string }) {
return ipcRenderer.invoke("dialog-pick-directory", opts);
},
confirmStartOver(): Promise<boolean> {
return ipcRenderer.invoke("dialog-confirm-start-over");
}
},
restore: {
pickBackup() {
return ipcRenderer.invoke("restore-pick-backup");
}
},
transcription: {
isSupported() {
return ipcRenderer.invoke("transcription-is-supported");
},
start(noteId: string) {
return ipcRenderer.invoke("transcription-start", noteId);
},
stop() {
return ipcRenderer.invoke("transcription-stop");
},
getState() {
return ipcRenderer.invoke("transcription-get-state");
},
renameSpeaker(attachmentId: string, key: string, name: string) {
return ipcRenderer.invoke("transcription-rename-speaker", attachmentId, key, name);
},
getRecordingsDirectory() {
return ipcRenderer.invoke("transcription-get-recordings-directory");
},
onStateChanged(callback: (state: TranscriptionState) => void) {
const listener = (_event: unknown, state: TranscriptionState) => callback(state);
ipcRenderer.on("transcription-state", listener);
return () => ipcRenderer.removeListener("transcription-state", listener);
},
onLevel(callback: (source: TranscriptSource, level: number) => void) {
const listener = (_event: unknown, source: TranscriptSource, level: number) =>
callback(source, level);
ipcRenderer.on("transcription-level", listener);
return () => ipcRenderer.removeListener("transcription-level", listener);
}
},
ws: {
// Renderer → main process. Mirror channel name with the server-side
// IpcMessagingProvider constants.
send(message: unknown) {
ipcRenderer.send("trilium-ws-from-renderer", message);
},
onMessage(callback: (message: unknown) => void) {
const listener = (_event: unknown, message: unknown) => callback(message);
ipcRenderer.on("trilium-ws-message", listener);
return () => ipcRenderer.removeListener("trilium-ws-message", listener);
}
},
navigation: {
clearNavigationHistory() {
ipcRenderer.send("clear-navigation-history");
},
navigationCanGoBack(): boolean {
return ipcRenderer.sendSync("navigation-history", "canGoBack");
},
navigationCanGoForward(): boolean {
return ipcRenderer.sendSync("navigation-history", "canGoForward");
},
navigationGetAllEntries(): Array<{ url: string; title: string }> {
return ipcRenderer.sendSync("navigation-history", "getAllEntries");
},
navigationGetActiveIndex(): number {
return ipcRenderer.sendSync("navigation-history", "getActiveIndex");
},
navigationLength(): number {
return ipcRenderer.sendSync("navigation-history", "length");
},
navigationGoToIndex(index: number) {
ipcRenderer.send("navigation-history-go-to-index", index);
},
onDidNavigate(callback: () => void) {
ipcRenderer.on("did-navigate", () => callback());
},
onDidNavigateInPage(callback: () => void) {
ipcRenderer.on("did-navigate-in-page", () => callback());
},
removeDidNavigateListeners() {
ipcRenderer.removeAllListeners("did-navigate");
ipcRenderer.removeAllListeners("did-navigate-in-page");
}
},
security: {
setBackendScriptingEnabled(enabled: boolean): Promise<boolean> {
return ipcRenderer.invoke("security-set-backend-scripting", enabled);
},
setSqlConsoleEnabled(enabled: boolean): Promise<boolean> {
return ipcRenderer.invoke("security-set-sql-console", enabled);
},
setLanAccessEnabled(enabled: boolean): Promise<boolean> {
return ipcRenderer.invoke("security-set-lan-access", enabled);
}
},
backupPassphrase: {
getStatus(): Promise<BackupPassphraseStatus> {
return ipcRenderer.invoke("backup-passphrase-status");
},
// No getter by design: the plaintext passphrase never comes back to the renderer.
set(passphrase: string): Promise<BackupPassphraseChange> {
return ipcRenderer.invoke("backup-passphrase-set", passphrase);
},
clear(): Promise<BackupPassphraseChange> {
return ipcRenderer.invoke("backup-passphrase-clear");
}
},
onenote: {
login(): Promise<OneNoteLoginResult> {
return ipcRenderer.invoke("onenote-login");
}
}
} satisfies ElectronApi);