trilium/src/public/app/services/open.js

import utils from "./utils.js";
import server from "./server.js";

function getFileUrl(noteId) {
    return getUrlForDownload(`api/notes/${noteId}/download`);
}
function getOpenFileUrl(noteId) {
    return getUrlForDownload(`api/notes/${noteId}/open`);
}

function download(url) {
    if (utils.isElectron()) {
        const remote = utils.dynamicRequire('@electron/remote');

        remote.getCurrentWebContents().downloadURL(url);
    } else {
        window.location.href = url;
    }
}

function downloadFileNote(noteId) {
    const url = `${getFileUrl(noteId)}?${Date.now()}`; // don't use cache

    download(url);
}

async function openNoteExternally(noteId, mime) {
    if (utils.isElectron()) {
        const resp = await server.post(`notes/${noteId}/save-to-tmp-dir`);

        const electron = utils.dynamicRequire('electron');
        const res = await electron.shell.openPath(resp.tmpFilePath);

        if (res) {
            // fallback in case there's no default application for this file
            open(getFileUrl(noteId), {url: true});
        }
    }
    else {
        // allow browser to handle opening common file
         if (mime === "application/pdf" ||  mime.startsWith("image") || mime.startsWith("audio") || mime.startsWith("video")){
            window.open(getOpenFileUrl(noteId));
        }
         else {
            window.location.href = getFileUrl(noteId);
        }
    }
}

async function openNoteCustom(noteId, mime) {
    if (utils.isElectron()) {
      const resp = await server.post(`notes/${noteId}/save-to-tmp-dir`);
      const filePath = resp.tmpFilePath;
      const { exec } = utils.dynamicRequire('child_process');
      const platform = process.platform;
      if (platform === 'linux') {        
        const terminals = ['gnome-terminal', 'konsole', 'xterm', 'xfce4-terminal', 'mate-terminal', 'rxvt', 'terminator', 'terminology'];
        const openFileWithTerminal = (terminal) => {
          const command = `${terminal} -e 'mimeopen -d "${filePath}"'`;
          console.log(`Open Note custom: ${command} `);
          exec(command, (error, stdout, stderr) => {
            if (error) {
              console.error(`Open Note custom: Failed to open file with ${terminal}: ${error}`);
              searchTerminal(terminals.indexOf(terminal) + 1);
            } else {
              console.log(`Open Note custom: File opened with ${terminal}. ${stdout}`);
            }
          });
        };
        const searchTerminal = (index) => {
          const terminal = terminals[index];
          if (!terminal) {
            console.error('Open Note custom: No terminal found!');
            open(getFileUrl(noteId), { url: true });
            return;
          }
          exec(`which ${terminal}`, (error, stdout, stderr) => {
            if (stdout.trim()) {
              openFileWithTerminal(terminal);
            } else {
              searchTerminal(index + 1);
            }
          });
        };
        searchTerminal(0);
      } else if (platform === 'win32') {
        if (filePath.indexOf("/") !== -1) {
          //Note that the path separator must be \ instead of /
          filePath = filePath.replace(/\//g, "\\");
        }
        const command = `rundll32.exe shell32.dll,OpenAs_RunDLL ` + filePath;
        exec(command, (err, stdout, stderr) => {
          if (err) {
            console.error("Open Note custom: ", err);
            open(getFileUrl(noteId), { url: true });
            return;
          }
        });
      } else {
        console.log('Currently "Open Note custom" only supports linux and windows systems');
        open(getFileUrl(noteId), { url: true });
      }
    }
  }

function downloadNoteRevision(noteId, noteRevisionId) {
    const url = getUrlForDownload(`api/notes/${noteId}/revisions/${noteRevisionId}/download`);

    download(url);
}

/**
 * @param url - should be without initial slash!!!
 */
function getUrlForDownload(url) {
    if (utils.isElectron()) {
        // electron needs absolute URL, so we extract current host, port, protocol
        return `${getHost()}/${url}`;
    }
    else {
        // web server can be deployed on subdomain, so we need to use relative path
        return url;
    }
}

function getHost() {
    const url = new URL(window.location.href);
    return `${url.protocol}//${url.hostname}:${url.port}`;
}

export default {
    download,
    downloadFileNote,
    openNoteExternally,
    openNoteCustom,
    downloadNoteRevision,
    getUrlForDownload
}