Home Reference Source

cables_dev/cables_electron/src/electron/electron_endpoint.js

  1. // eslint-disable-next-line import/no-extraneous-dependencies
  2. import { net, protocol, session, shell } from "electron";
  3. import fs from "fs";
  4. import path from "path";
  5. import mime from "mime";
  7. import cables from "../cables.js";
  8. import logger from "../utils/logger.js";
  9. import doc from "../utils/doc_util.js";
  10. import opsUtil from "../utils/ops_util.js";
  11. import subPatchOpUtil from "../utils/subpatchop_util.js";
  12. import settings from "./electron_settings.js";
  13. import helper from "../utils/helper_util.js";
  14. import electronApp from "./main.js";
  15. import projectsUtil from "../utils/projects_util.js";
  17. protocol.registerSchemesAsPrivileged([
  18.     {
  19.         "scheme": "cables",
  20.         "privileges": {
  21.             "bypassCSP": true,
  22.             "supportFetchAPI": true
  23.         }
  24.     },
  25.     {
  26.         "scheme": "file",
  27.         "privileges": {
  28.             "stream": true,
  29.             "bypassCSP": true,
  30.             "supportFetchAPI": true
  31.         }
  32.     }
  33. ]);
  35. class ElectronEndpoint
  36. {
  37.     constructor()
  38.     {
  39.         this._log = logger;
  40.     }
  42.     init()
  43.     {
  44.         const partition = settings.SESSION_PARTITION;
  45.         const ses = session.fromPartition(partition, { "cache": false });
  47.         ses.protocol.handle("file", async (request) =>
  48.         {
  49.             let urlFile = request.url;
  50.             let absoluteFile = helper.fileURLToPath(urlFile, false);
  51.             let projectFile = helper.fileURLToPath(urlFile, true);
  53.             let absoluteReadable = false;
  54.             let projectReadable = false;
  55.             try
  56.             {
  57.                 const statsAbs = fs.statSync(absoluteFile);
  58.                 if (statsAbs && statsAbs.isFile())
  59.                 {
  60.                     fs.accessSync(absoluteFile, fs.constants.R_OK);
  61.                     absoluteReadable = true;
  62.                 }
  63.             }
  64.             catch (e)
  65.             {
  66.                 this._log.info("failed to read absoluteFile", absoluteFile, e);
  67.                 try
  68.                 {
  69.                     const statsProj = fs.statSync(projectFile);
  70.                     if (statsProj && statsProj.isFile())
  71.                     {
  72.                         fs.accessSync(projectFile, fs.constants.R_OK);
  73.                         projectReadable = true;
  74.                     }
  75.                 }
  76.                 catch (eproj)
  77.                 {
  78.                     // handle in next steps
  79.                     this._log.info("failed to read projectFile", projectFile, eproj);
  80.                 }
  82.             }
  84.             if (absoluteReadable)
  85.             {
  86.                 Object.defineProperty(request, "url", { "value": helper.pathToFileURL(absoluteFile) });
  87.                 const response = await net.fetch(request, { "bypassCustomProtocolHandlers": true });
  88.                 this._addDefaultHeaders(request, response, absoluteFile);
  89.                 return response;
  90.             }
  91.             else if (projectReadable)
  92.             {
  93.                 Object.defineProperty(request, "url", { "value": helper.pathToFileURL(projectFile) });
  94.                 const response = await net.fetch(request, { "bypassCustomProtocolHandlers": true });
  95.                 this._addDefaultHeaders(request, response, projectFile);
  96.                 return response;
  97.             }
  98.             else
  99.             {
  100.                 try
  101.                 {
  102.                     if (projectFile.includes("?"))
  103.                     {
  104.                         projectFile = projectFile.split("?")[0];
  105.                     }
  106.                     try
  107.                     {
  108.                         const statsProj = fs.statSync(projectFile);
  109.                         if (statsProj && statsProj.isFile())
  110.                         {
  111.                             fs.accessSync(projectFile, fs.constants.R_OK);
  113.                             const response = await net.fetch(helper.pathToFileURL(projectFile), { "bypassCustomProtocolHandlers": true });
  114.                             this._addDefaultHeaders(request, response, projectFile);
  115.                             return response;
  116.                         }
  117.                         else
  118.                         {
  119.                             return new Response(null, { "headers": { "status": 404 } });
  120.                         }
  121.                     }
  122.                     catch (e)
  123.                     {
  124.                         return new Response(null, { "headers": { "status": 404 } });
  125.                     }
  127.                 }
  128.                 catch (e)
  129.                 {
  130.                     return net.fetch(request.url, { "bypassCustomProtocolHandlers": true });
  131.                 }
  132.             }
  133.         });
  135.         ses.protocol.handle("cables", async (request) =>
  136.         {
  137.             const url = new URL(request.url);
  138.             const urlPath = url.pathname;
  139.             const queryParams = new URLSearchParams(url.search);
  140.             const params = {};
  141.             const req = request;
  142.             req.params = params;
  143.             req.query = {};
  144.             for (let key in queryParams)
  145.             {
  146.                 req.query[key] = queryParams.get(key);
  147.             }
  148.             if (urlPath.startsWith("/api/corelib/"))
  149.             {
  150.                 req.params.name = urlPath.split("/", 4)[3];
  151.                 const libCode = this.apiGetCoreLibs(req);
  152.                 if (libCode)
  153.                 {
  154.                     return new Response(libCode, {
  155.                         "headers": { "content-type": "application/javascript" }
  156.                     });
  157.                 }
  158.                 else
  159.                 {
  160.                     return new Response(libCode, {
  161.                         "headers": { "content-type": "application/javascript" },
  162.                         "status": 500
  163.                     });
  164.                 }
  165.             }
  166.             else if (urlPath.startsWith("/api/lib/"))
  167.             {
  168.                 req.params.name = urlPath.split("/", 4)[3];
  169.                 const libCode = this.apiGetLibs(req);
  170.                 if (libCode)
  171.                 {
  172.                     return new Response(libCode, {
  173.                         "headers": { "content-type": "application/javascript" }
  174.                     });
  175.                 }
  176.                 else
  177.                 {
  178.                     return new Response(libCode, {
  179.                         "headers": { "content-type": "application/javascript" },
  180.                         "status": 500
  181.                     });
  182.                 }
  183.             }
  184.             else if (urlPath.startsWith("/api/oplib/"))
  185.             {
  186.                 const parts = urlPath.split("/", 5);
  187.                 let opName = parts[3];
  188.                 let libName = parts[4];
  189.                 if (opsUtil.isOpId(opName))
  190.                 {
  191.                     opName = opsUtil.getOpNameById(opName);
  192.                 }
  193.                 if (opName)
  194.                 {
  195.                     const opPath = opsUtil.getOpAbsolutePath(opName);
  196.                     const libPath = path.join(opPath, libName);
  197.                     const libUrl = helper.pathToFileURL(libPath);
  198.                     const response = await net.fetch(libUrl, { "bypassCustomProtocolHandlers": true });
  199.                     this._addDefaultHeaders(request, response, libPath);
  200.                     return response;
  201.                 }
  202.                 else
  203.                 {
  204.                     return new Response("", {
  205.                         "headers": { "content-type": "application/javascript" },
  206.                         "status": 404
  207.                     });
  208.                 }
  209.             }
  210.             else if (urlPath === "/api/changelog")
  211.             {
  212.                 return new Response(JSON.stringify(this.apiGetChangelog(req)), {
  213.                     "headers": { "content-type": "application/json" }
  214.                 });
  215.             }
  216.             else if (urlPath.startsWith("/api/ops/code/project"))
  217.             {
  218.                 const code = this.apiGetProjectOpsCode(req);
  219.                 return new Response(code, {
  220.                     "headers": { "content-type": "application/json" }
  221.                 });
  222.             }
  223.             else if (urlPath.startsWith("/api/ops/code"))
  224.             {
  225.                 const code = this.apiGetCoreOpsCode(req);
  226.                 if (code)
  227.                 {
  228.                     return new Response(code, {
  229.                         "headers": { "content-type": "application/javascript" }
  230.                     });
  231.                 }
  232.                 else
  233.                 {
  234.                     return new Response(code, {
  235.                         "headers": { "content-type": "application/javascript" },
  236.                         "status": 500
  237.                     });
  238.                 }
  239.             }
  240.             else if (urlPath.startsWith("/api/op/layout/"))
  241.             {
  242.                 let opName = urlPath.split("/", 5)[4];
  243.                 if (opsUtil.isOpId(opName))
  244.                 {
  245.                     opName = opsUtil.getOpNameById(opName);
  246.                 }
  247.                 req.params.opName = opName;
  248.                 const layoutSvg = this.apiOpLayout(req);
  249.                 if (layoutSvg)
  250.                 {
  251.                     return new Response(layoutSvg, {
  252.                         "headers": { "content-type": "image/svg+xml" }
  253.                     });
  254.                 }
  255.                 else
  256.                 {
  257.                     return new Response("", {
  258.                         "headers": { "content-type": "image/svg+xml" },
  259.                         "status": 500
  260.                     });
  261.                 }
  262.             }
  263.             else if (urlPath.startsWith("/api/op/"))
  264.             {
  265.                 let opName = urlPath.split("/", 4)[3];
  266.                 if (opsUtil.isOpId(opName))
  267.                 {
  268.                     opName = opsUtil.getOpNameById(opName);
  269.                 }
  270.                 if (opName)
  271.                 {
  272.                     req.params.opName = opName;
  273.                     const opCode = this.apiGetOpCode(req);
  274.                     if (opCode)
  275.                     {
  276.                         return new Response(opCode, {
  277.                             "headers": { "content-type": "application/javascript" }
  278.                         });
  279.                     }
  280.                     else
  281.                     {
  282.                         return new Response(opCode, {
  283.                             "headers": { "content-type": "application/javascript" },
  284.                             "status": 500
  285.                         });
  286.                     }
  287.                 }
  288.                 else
  289.                 {
  290.                     return new Response("", {
  291.                         "headers": { "content-type": "application/javascript" },
  292.                         "status": 404
  293.                     });
  294.                 }
  295.             }
  296.             else if (urlPath.startsWith("/op/screenshot"))
  297.             {
  298.                 let opName = urlPath.split("/", 4)[3];
  299.                 if (opName) opName = opName.replace(/.png$/, "");
  300.                 const absolutePath = opsUtil.getOpAbsolutePath(opName);
  301.                 let file = path.join(absolutePath, "screenshot.png");
  302.                 let response = null;
  303.                 try
  304.                 {
  305.                     response = await net.fetch(helper.pathToFileURL(file), { "bypassCustomProtocolHandlers": true });
  306.                 }
  307.                 catch (e)
  308.                 {
  309.                     file = path.resolve(cables.getAssetLibraryPath(), "../op_screenshot_placeholder.png");
  310.                     response = await net.fetch(helper.pathToFileURL(file), { "bypassCustomProtocolHandlers": true });
  311.                 }
  312.                 this._addDefaultHeaders(request, response, file);
  313.                 return response;
  314.             }
  315.             else if (urlPath.startsWith("/edit/"))
  316.             {
  317.                 let patchId = urlPath.split("/", 3)[2];
  318.                 let projectFile = null;
  319.                 if (patchId)
  320.                 {
  321.                     projectFile = settings.getRecentProjectFile(patchId);
  322.                 }
  323.                 if (projectFile)
  324.                 {
  325.                     await electronApp.openPatch(projectFile, true);
  326.                 }
  327.                 else
  328.                 {
  329.                     await electronApp.pickProjectFileDialog();
  330.                 }
  331.                 return new Response(null, { "status": 302 });
  332.             }
  333.             else if (urlPath.startsWith("/openDir/"))
  334.             {
  335.                 let dir = urlPath.replace("/openDir/", "");
  336.                 await shell.showItemInFolder(dir);
  337.                 return new Response(null, { "status": 404 });
  338.             }
  339.             else if (urlPath === "/")
  340.             {
  341.                 return new Response(JSON.stringify({ "sandbox": true }), {
  342.                     "headers": { "content-type": "application/json" }
  343.                 });
  344.             }
  345.             else
  346.             {
  347.                 return new Response("", {
  348.                     "headers": { "content-type": "application/javascript" },
  349.                     "status": 404
  350.                 });
  351.             }
  352.         });
  353.     }
  355.     apiGetCoreOpsCode(req)
  356.     {
  357.         const preview = req.query.preview;
  358.         const opDocs = doc.getOpDocs();
  359.         const code = opsUtil.buildCode(cables.getCoreOpsPath(), null, true, true, opDocs, preview);
  360.         if (!code) this._log.warn("FAILED TO GET CODE FOR COREOPS FROM", cables.getCoreOpsPath());
  361.         return code;
  362.     }
  364.     apiGetProjectOpsCode(req)
  365.     {
  366.         const preview = req.query.preview;
  367.         const project = settings.getCurrentProject();
  369.         let code = "";
  370.         let missingOps = [];
  371.         if (project)
  372.         {
  373.             let opDocs = doc.getOpDocs(true, true);
  374.             let allOps = [];
  375.             if (project.ops) allOps = project.ops.filter((op) => { return !opDocs.some((d) => { return d.id === op.opId; }); });
  376.             const opsInProjectDir = projectsUtil.getOpDocsInProjectDirs(project);
  377.             const opsInSubPatches = subPatchOpUtil.getOpsUsedInSubPatches(project);
  378.             allOps = allOps.concat(opsInProjectDir);
  379.             allOps = allOps.concat(opsInSubPatches);
  380.             missingOps = allOps.filter((op) => { return !opDocs.some((d) => { return d.id === op.opId || d.id === op.id; }); });
  381.         }
  383.         const opsWithCode = [];
  384.         let codeNamespaces = [];
  386.         missingOps.forEach((missingOp) =>
  387.         {
  388.             const opId = missingOp.opId || missingOp.id;
  389.             const opName = missingOp.name || opsUtil.getOpNameById(opId);
  390.             if (opId && opName)
  391.             {
  392.                 if (!opsWithCode.includes(opName))
  393.                 {
  394.                     const parts = opName.split(".");
  395.                     for (let k = 1; k < parts.length; k++)
  396.                     {
  397.                         let partPartname = "";
  398.                         for (let j = 0; j < k; j++) partPartname += parts[j] + ".";
  400.                         partPartname = partPartname.substr(0, partPartname.length - 1);
  401.                         codeNamespaces.push(partPartname + "=" + partPartname + " || {};");
  402.                     }
  403.                     const fn = opsUtil.getOpAbsoluteFileName(opName);
  404.                     if (fn)
  405.                     {
  406.                         code += opsUtil.getOpFullCode(fn, opName, opId);
  407.                         opsWithCode.push(opName);
  408.                     }
  409.                 }
  410.                 doc.addOpToLookup(opId, opName);
  411.             }
  412.         });
  414.         codeNamespaces = helper.sortAndReduce(codeNamespaces);
  415.         let fullCode = opsUtil.OPS_CODE_PREFIX;
  416.         if (codeNamespaces && codeNamespaces.length > 0)
  417.         {
  418.             codeNamespaces[0] = "var " + codeNamespaces[0];
  419.             fullCode += codeNamespaces.join("\n") + "\n\n";
  420.         }
  422.         fullCode += code;
  423.         return fullCode;
  424.     }
  426.     apiGetOpCode(req)
  427.     {
  428.         const preview = !!req.query.preview;
  429.         const opName = req.params.opName;
  430.         let code = "";
  431.         const currentProject = settings.getCurrentProject();
  432.         try
  433.         {
  434.             const attachmentOps = opsUtil.getSubPatchOpAttachment(opName);
  435.             const bpOps = subPatchOpUtil.getOpsUsedInSubPatches(attachmentOps);
  437.             if (!bpOps)
  438.             {
  439.                 return code;
  440.             }
  441.             else
  442.             {
  443.                 let opNames = [];
  444.                 for (let i = 0; i < bpOps.length; i++)
  445.                 {
  446.                     const bpOp = bpOps[i];
  447.                     const bpOpName = opsUtil.getOpNameById(bpOp.opId);
  448.                     if (opsUtil.isCoreOp(bpOpName) && (!opsUtil.isOpOldVersion(bpOpName) && !opsUtil.isDeprecated(bpOpName))) continue;
  449.                     if (currentProject && currentProject.ops && currentProject.ops.some((projectOp) => { return projectOp.opId === bpOp.opId; })) continue;
  450.                     opNames.push(bpOpName);
  451.                 }
  453.                 if (opsUtil.isExtension(opName) || opsUtil.isTeamNamespace(opName))
  454.                 {
  455.                     const collectionName = opsUtil.getCollectionNamespace(opName);
  456.                     opNames = opNames.concat(opsUtil.getCollectionOpNames(collectionName));
  457.                     opNames.push(opName);
  458.                 }
  459.                 else
  460.                 {
  461.                     opNames.push(opName);
  462.                 }
  464.                 const ops = [];
  465.                 opNames.forEach((name) =>
  466.                 {
  467.                     ops.push({
  468.                         "objName": name,
  469.                         "opId": opsUtil.getOpIdByObjName(name)
  470.                     });
  471.                 });
  473.                 code = preview ? opsUtil.buildPreviewCode(ops) : opsUtil.buildFullCode(ops, "none");
  474.                 return code;
  475.             }
  476.         }
  477.         catch (e)
  478.         {
  479.             this._log.error("FAILED TO BUILD OPCODE FOR", opName, e);
  480.             return code;
  481.         }
  482.     }
  484.     apiGetCoreLibs(req)
  485.     {
  486.         const name = req.params.name;
  487.         const fn = path.join(cables.getCoreLibsPath(), name + ".js");
  489.         if (fs.existsSync(fn))
  490.         {
  491.             return fs.readFileSync(fn);
  492.         }
  493.         else
  494.         {
  495.             this._log.error("COULD NOT FIND CORELIB FILE AT", fn);
  496.             return "";
  497.         }
  498.     }
  500.     apiGetLibs(req)
  501.     {
  502.         const name = req.params.name;
  503.         const fn = path.join(cables.getLibsPath(), name);
  504.         if (fs.existsSync(fn))
  505.         {
  506.             return fs.readFileSync(fn);
  507.         }
  508.         else
  509.         {
  510.             this._log.error("COULD NOT FIND LIB FILE AT", fn);
  511.             return "";
  512.         }
  513.     }
  515.     apiGetChangelog()
  516.     {
  517.         return {
  518.             "ts": Date.now(),
  519.             "items": []
  520.         };
  521.     }
  523.     apiOpLayout(req)
  524.     {
  525.         const opName = req.params.opName;
  526.         return opsUtil.getOpSVG(opName);
  527.     }
  529.     _addDefaultHeaders(request, response, existingFile)
  530.     {
  531.         try
  532.         {
  533.             const stats = fs.statSync(existingFile);
  534.             if (stats)
  535.             {
  536.                 response.headers.append("Accept-Ranges", "bytes");
  537.                 response.headers.append("Last-Modified", stats.mtime.toUTCString());
  539.                 // large mp4 and range headers cause problems somehow...
  540.                 // https://github.com/laurent22/joplin/blob/e607a7376f8403082e87087a3e07f37cb2e1ce76/packages/app-desktop/utils/customProtocols/handleCustomProtocols.ts#L106
  541.                 const rangeHeader = request.headers.get("Range");
  542.                 const startByte = Number(rangeHeader.match(/(\d+)-/)?.[1] || "0");
  543.                 const endByte = Number(rangeHeader.match(/-(\d+)/)?.[1] || stats.size - 1);
  544.                 response.headers.append("Content-Range", "bytes 0-" + stats.size + "/" + (stats.size + 1));
  545.                 response.headers.append("Content-Length", (endByte + 1) - startByte);
  546.             }
  547.             let mimeType = mime.getType(existingFile);
  548.             if (mimeType)
  549.             {
  550.                 if (mimeType === "application/node") mimeType = "text/javascript";
  551.                 response.headers.set("Content-Type", mimeType);
  552.             }
  553.         }
  554.         catch (e) {}
  555.         return response;
  556.     }
  557. }
  559. export default new ElectronEndpoint();