@lvce-editor/shared-process 0.33.4 → 0.33.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.33.4",
+  "version": "0.33.6",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -17,9 +17,9 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@lvce-editor/assert": "^1.2.0",
-    "@lvce-editor/extension-host-helper-process": "0.33.4",
-    "@lvce-editor/ipc": "^10.0.4",
+    "@lvce-editor/assert": "^1.3.0",
+    "@lvce-editor/extension-host-helper-process": "0.33.6",
+    "@lvce-editor/ipc": "^10.2.1",
     "@lvce-editor/json-rpc": "^3.0.0",
     "@lvce-editor/jsonc-parser": "^1.4.0",
     "@lvce-editor/pretty-error": "^1.6.0",
@@ -35,7 +35,7 @@
     "@lvce-editor/typescript-compile-process": "^1.2.0",
     "@lvce-editor/pty-host": "^2.0.0",
     "@lvce-editor/embeds-process": "^1.5.0",
-    "@lvce-editor/preview-process": "^1.2.1",
+    "@lvce-editor/preview-process": "^2.10.0",
     "open": "^10.1.0",
     "tail": "^2.2.6",
     "tmp-promise": "^3.0.3",

package/src/parts/ContentSecurityPolicyDocument/ContentSecurityPolicyDocument.js

@@ -1,22 +1,35 @@
 import * as GetContentSecurityPolicy from '../GetContentSecurityPolicy/GetContentSecurityPolicy.js';
+import * as GetGitpodPreviewUrl from '../GetGitpodPreviewUrl/GetGitpodPreviewUrl.js';
 import * as IsElectron from '../IsElectron/IsElectron.js';
 import * as IsGitpod from '../IsGitpod/IsGitpod.js';
-const getGitpodPreviewUrl = (port) => {
-    const workspaceId = process.env.GITPOD_WORKSPACE_ID;
-    const cluster = process.env.GITPOD_WORKSPACE_CLUSTER_HOST;
-    const url = `https://${port}-${workspaceId}.${cluster}`;
-    return url;
+import * as Scheme from '../Scheme/Scheme.js';
+const getFrameSrc = () => {
+    // TODO make ports configurable
+    if (IsGitpod.isGitpod) {
+        return [`frame-src 'self' ${GetGitpodPreviewUrl.getGitpodPreviewUrl(3001)} ${GetGitpodPreviewUrl.getGitpodPreviewUrl(3002)}`];
+    }
+    if (IsElectron.isElectron) {
+        return [`frame-src ${Scheme.WebView}:`];
+    }
+    return [`frame-src 'self' http://localhost:3001 http://localhost:3002`];
+};
+const getManifestSrc = () => {
+    if (IsElectron.isElectron) {
+        return [];
+    }
+    return [`manifest-src 'self'`];
+};
+const getFrameAncestors = () => {
+    return [`frame-ancestors 'none'`];
 };
 export const value = GetContentSecurityPolicy.getContentSecurityPolicy([
     `default-src 'none'`,
     `font-src 'self'`,
-    `img-src 'self' https: data:`,
+    `img-src 'self' https: data:`, // TODO maybe disallow https and data images
     `media-src 'self'`,
     `script-src 'self'`,
     `style-src 'self'`,
-    `frame-ancestors 'none' `,
-    IsGitpod.isGitpod
-        ? `frame-src 'self' ${getGitpodPreviewUrl(3001)} ${getGitpodPreviewUrl(3002)}`
-        : `frame-src 'self' http://localhost:3001 http://localhost:3002`,
-    ...(IsElectron.isElectron ? [] : [`manifest-src 'self'`]),
+    ...getFrameAncestors(),
+    ...getFrameSrc(),
+    ...getManifestSrc(),
 ]);

package/src/parts/ExportStatic/ExportStatic.js

@@ -101,6 +101,16 @@ const applyOverrides = async ({ root, commitHash, pathPrefix }) => {
         }
         return languages;
     };
+    const getWebViews = (extension) => {
+        const webViews = [];
+        for (const webView of extension.webViews || []) {
+            webViews.push({
+                ...webView,
+                path: `${pathPrefix}/${commitHash}/extensions/${webView.path}`,
+            });
+        }
+        return webViews;
+    };
     /**
      * @param {string} dirent
      */
@@ -111,6 +121,8 @@ const applyOverrides = async ({ root, commitHash, pathPrefix }) => {
     const manifests = await Promise.all(manifestPaths.map(readExtensionManifest));
     const languages = manifests.flatMap(getLanguages);
     await JsonFile.writeJson(Path.join(root, 'dist', commitHash, 'config', 'languages.json'), languages);
+    const webViews = manifests.flatMap(getWebViews);
+    await JsonFile.writeJson(Path.join(root, 'dist', commitHash, 'config', 'webViews.json'), webViews);
     for (const languageBasicsDirent of languageBasicsDirents) {
         await FileSystem.copy(Path.join(root, 'node_modules', '@lvce-editor', 'server', 'static', commitHash, 'extensions', languageBasicsDirent), Path.join(root, 'dist', commitHash, 'extensions', languageBasicsDirent));
     }

package/src/parts/GetElectronFileResponse/GetElectronFileResponse.js

@@ -1,4 +1,4 @@
-import { stat } from 'fs/promises';
+import { stat } from 'node:fs/promises';
 import * as GetElectronFileResponseAbsolutePath from '../GetElectronFileResponseAbsolutePath/GetElectronFileResponseAbsolutePath.js';
 import * as GetElectronFileResponseContent from '../GetElectronFileResponseContent/GetElectronFileResponseContent.js';
 import * as GetElectronFileResponseRelativePath from '../GetElectronFileResponseRelativePath/GetElectronFileResponseRelativePath.js';
@@ -7,27 +7,35 @@ import * as GetHeaders from '../GetHeaders/GetHeaders.js';
 import * as GetNotFoundResponse from '../GetNotFoundResponse/GetNotFoundResponse.js';
 import * as GetNotModifiedResponse from '../GetNotModifiedResponse/GetNotModifiedResponse.js';
 import * as GetServerErrorResponse from '../GetServerErrorResponse/GetServerErrorResponse.js';
+import * as HttpHeader from '../HttpHeader/HttpHeader.js';
 import * as HttpStatusCode from '../HttpStatusCode/HttpStatusCode.js';
 import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js';
 import * as Logger from '../Logger/Logger.js';
+// TODO maybe handle app responses and webview responses separately
+// maybe send webview requests directly to preview process
 export const getElectronFileResponse = async (url, request) => {
     try {
         const pathName = GetElectronFileResponseRelativePath.getElectronFileResponseRelativePath(url);
-        const absolutePath = GetElectronFileResponseAbsolutePath.getElectronFileResponseAbsolutePath(pathName);
+        let absolutePath = GetElectronFileResponseAbsolutePath.getElectronFileResponseAbsolutePath(pathName);
         let etag;
+        // TODO when is there no request?
         if (request) {
-            const stats = await stat(absolutePath);
+            let stats = await stat(absolutePath);
+            if (stats.isDirectory()) {
+                absolutePath += '/index.html';
+                stats = await stat(absolutePath);
+            }
             etag = GetEtag.getEtag(stats);
-            if (request.headers['if-none-match'] === etag) {
+            if (request.headers[HttpHeader.IfNotMatch] === etag) {
                 const headers = GetHeaders.getHeaders(absolutePath, pathName);
                 return GetNotModifiedResponse.getNotModifiedResponse(headers);
             }
         }
         const content = await GetElectronFileResponseContent.getElectronFileResponseContent(request, absolutePath, url);
         const headers = GetHeaders.getHeaders(absolutePath, pathName);
-        headers['Cache-Control'] = 'public, max-age=0, must-revalidate';
+        headers[HttpHeader.CacheControl] = 'public, max-age=0, must-revalidate';
         if (etag) {
-            headers['Etag'] = etag;
+            headers[HttpHeader.Etag] = etag;
         }
         return {
             body: content,

package/src/parts/GetElectronFileResponseAbsolutePath/GetElectronFileResponseAbsolutePath.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import * as Path from '../Path/Path.js';
 import * as Platform from '../Platform/Platform.js';
 import * as Root from '../Root/Root.js';
+// TODO clean up this code
 export const getElectronFileResponseAbsolutePath = (pathName) => {
     // TODO remove if/else in prod (use replacement)
     if (pathName === `/` || pathName.startsWith(`/?`)) {
@@ -30,5 +31,9 @@ export const getElectronFileResponseAbsolutePath = (pathName) => {
         const processExplorerThemeCss = join(tmpdir(), 'process-explorer-theme.css');
         return processExplorerThemeCss;
     }
+    // TODO move this to preview process
+    if (pathName.startsWith('/home')) {
+        return pathName;
+    }
     return Path.join(Root.root, 'static', pathName);
 };

package/src/parts/GetElectronFileResponseRelativePath/GetElectronFileResponseRelativePath.js

@@ -1,12 +1,30 @@
 import * as Platform from '../Platform/Platform.js';
+import * as Scheme from '../Scheme/Scheme.js';
 const { scheme } = Platform;
 const prefix = `${scheme}://-`;
 const prefixLength = prefix.length;
+const webViewPrefix = `${Scheme.WebView}://-`;
+const webViewPrefixLength = webViewPrefix.length;
 export const getElectronFileResponseRelativePath = (requestUrl) => {
+    if (requestUrl.startsWith(prefix)) {
+        // TODO only support reading from app root and extensions
+        // maybe add a separate protocol for extensions (e.g. lvce-remote)
+        const decoded = decodeURI(requestUrl);
+        const pathName = decoded.slice(prefixLength);
+        return pathName;
+    }
+    if (requestUrl.startsWith(webViewPrefix)) {
+        // TODO group this by extension so that
+        // extension-a can only access resources in extension-a folder and
+        // extension-b can only access resources in extension-b folder
+        const decoded = decodeURI(requestUrl);
+        const pathName = decoded.slice(webViewPrefixLength);
+        return pathName;
+    }
     if (requestUrl.startsWith('/')) {
+        // TODO this should not be supported anymore and could probably be removed
         return requestUrl;
     }
-    const decoded = decodeURI(requestUrl);
-    const pathName = decoded.slice(prefixLength);
-    return pathName;
+    console.log({ requestUrl });
+    return '';
 };

package/src/parts/GetGitpodPreviewUrl/GetGitpodPreviewUrl.js

@@ -0,0 +1,6 @@
+export const getGitpodPreviewUrl = (port) => {
+    const workspaceId = process.env.GITPOD_WORKSPACE_ID;
+    const cluster = process.env.GITPOD_WORKSPACE_CLUSTER_HOST;
+    const url = `https://${port}-${workspaceId}.${cluster}`;
+    return url;
+};

package/src/parts/LaunchPreviewProcess/LaunchPreviewProcess.js

@@ -1,12 +1,23 @@
 import * as HandleIpc from '../HandleIpc/HandleIpc.js';
 import * as IpcParent from '../IpcParent/IpcParent.js';
 import * as IpcParentType from '../IpcParentType/IpcParentType.js';
+import * as IsElectron from '../IsElectron/IsElectron.js';
+import * as Preferences from '../Preferences/Preferences.js';
 import * as PreviewProcessPath from '../PreviewProcessPath/PreviewProcessPath.js';
+const getMethod = (isElectron) => {
+    if (isElectron) {
+        return IpcParentType.ElectronUtilityProcess;
+    }
+    return IpcParentType.NodeForkedProcess;
+};
 export const launchPreviewProcess = async () => {
-    const method = IpcParentType.NodeForkedProcess;
+    const preferences = await Preferences.getUserPreferences();
+    const customPreviewProcessPath = preferences['develop.previewProcessPath'];
+    const previewProcessPath = customPreviewProcessPath || PreviewProcessPath.previewProcessPath;
+    const method = getMethod(IsElectron.isElectron);
     const previewProcess = await IpcParent.create({
         method,
-        path: PreviewProcessPath.previewProcessPath,
+        path: previewProcessPath,
         argv: [],
         stdio: 'inherit',
         name: 'Preview Process',

package/src/parts/ModuleMap/ModuleMap.js

@@ -279,8 +279,10 @@ export const getModuleId = (commandId) => {
             return ModuleId.FileWatcher;
         case 'Transferrable.transfer':
             return ModuleId.Transferrable;
+        case 'WebViewServer.create':
         case 'WebViewServer.start':
         case 'WebViewServer.setHandler':
+        case 'WebViewServer.registerProtocol':
             return ModuleId.WebViewServer;
         default:
             throw new CommandNotFoundError(commandId);

package/src/parts/Platform/Platform.js

@@ -41,9 +41,9 @@ export const getAppImageName = () => {
 export const getSetupName = () => {
     return 'Lvce-Setup';
 };
-export const version = '0.33.4';
-export const commit = 'da8ae3e';
-export const date = '2024-08-28T17:12:51.000Z';
+export const version = '0.33.6';
+export const commit = '0fe4838';
+export const date = '2024-09-01T17:57:05.000Z';
 export const getVersion = () => {
     return version;
 };

package/src/parts/PreviewProcess/PreviewProcess.js

@@ -16,3 +16,7 @@ export const invoke = async (method, ...params) => {
     const ipc = await getOrCreate();
     return JsonRpc.invoke(ipc, method, ...params);
 };
+export const invokeAndTransfer = async (method, ...params) => {
+    const ipc = await getOrCreate();
+    return JsonRpc.invokeAndTransfer(ipc, method, ...params);
+};

package/src/parts/Scheme/Scheme.js

@@ -0,0 +1 @@
+export const WebView = 'lvce-oss-webview';

package/src/parts/WebViewServer/WebViewServer.ipc.js

@@ -2,5 +2,7 @@ import * as WebViewServer from '../WebViewServer/WebViewServer.js';
 export const name = 'WebViewServer';
 export const Commands = {
     start: WebViewServer.start,
+    create: WebViewServer.create,
     setHandler: WebViewServer.setHandler,
+    registerProtocol: WebViewServer.registerProtocol,
 };

package/src/parts/WebViewServer/WebViewServer.js

@@ -1,7 +1,26 @@
 import * as PreviewProcess from '../PreviewProcess/PreviewProcess.js';
-export const start = async (port) => {
-    await PreviewProcess.invoke('WebViewServer.start', port);
+import * as ParentIpc from '../ParentIpc/ParentIpc.js';
+import * as GetPortTuple from '../GetPortTuple/GetPortTuple.js';
+export const registerProtocol = async () => {
+    // TODO only do this once
+    // TODO send messageport to proview process
+    // TODO send other messageport to parent process
+    console.time('get-ports');
+    const { port1, port2 } = await GetPortTuple.getPortTuple();
+    console.timeEnd('get-ports');
+    console.time('register-protocol');
+    await ParentIpc.invokeAndTransfer('ElectronSession.registerWebviewProtocol', port1);
+    console.timeEnd('register-protocol');
+    console.time('handle-port');
+    await PreviewProcess.invokeAndTransfer('HandleElectronMessagePort.handleElectronMessagePort', port2);
+    console.timeEnd('handle-port');
 };
-export const setHandler = async (frameAncestors, webViewRoot) => {
-    await PreviewProcess.invoke('WebViewServer.setHandler', frameAncestors, webViewRoot);
+export const create = async (previewId) => {
+    await PreviewProcess.invoke('WebViewServer.create', previewId);
+};
+export const start = async (previewId, port) => {
+    await PreviewProcess.invoke('WebViewServer.start', previewId, port);
+};
+export const setHandler = async (previewId, frameAncestors, webViewRoot) => {
+    await PreviewProcess.invoke('WebViewServer.setHandler', previewId, frameAncestors, webViewRoot);
 };