@lvce-editor/server 0.40.0 → 0.40.2

package/ThirdPartyNotices.txt

@@ -2,7 +2,7 @@ This project incorporates components from the projects listed below, that may ha
 differing from this project:
 
 
-1) License Notice for static/c76328b/icons (from https://github.com/microsoft/vscode-icons)
+1) License Notice for static/38827dc/icons (from https://github.com/microsoft/vscode-icons)
 ---------------------------------------
 
 Attribution 4.0 International
@@ -402,7 +402,7 @@ public licenses.
 Creative Commons may be contacted at creativecommons.org.
 
 
-2) License Notice for static/c76328b/fonts/FiraCode-VariableFont.ttf (from https://github.com/tonsky/FiraCode)
+2) License Notice for static/38827dc/fonts/FiraCode-VariableFont.ttf (from https://github.com/tonsky/FiraCode)
 ---------------------------------------
 
 Copyright (c) 2014, The Fira Code Project Authors (https://github.com/tonsky/FiraCode)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/server",
-  "version": "0.40.0",
+  "version": "0.40.2",
   "description": "Run LVCE Editor as a server.",
   "main": "index.js",
   "bin": "bin/server.js",
@@ -20,7 +20,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@lvce-editor/shared-process": "0.40.0",
-    "@lvce-editor/static-server": "0.40.0"
+    "@lvce-editor/shared-process": "0.40.2",
+    "@lvce-editor/static-server": "0.40.2"
   }
 }

package/src/server.js

@@ -1,22 +1,12 @@
 // based on https://github.com/microsoft/vscode/tree/1.64.2/src/vs/server/node/webClientServer.ts (License MIT)
 
-import { sharedProcessPath } from '@lvce-editor/shared-process'
 import { ChildProcess, fork } from 'node:child_process'
-import { createReadStream } from 'node:fs'
-import { readFile, readdir, stat } from 'node:fs/promises'
-import { IncomingMessage, ServerResponse, createServer } from 'node:http'
-import { dirname, extname, join, resolve } from 'node:path'
-import { pipeline } from 'node:stream/promises'
-import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createServer } from 'node:http'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const ROOT = resolve(__dirname, '../')
-const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
-const staticPath = join(staticServerPath, '..', '..', 'static')
-const STATIC = staticPath
-const builtinExtensionsPath = join(STATIC, 'c76328b', 'extensions')
-
-const isProduction = true
 
 const { argv, env } = process
 
@@ -24,6 +14,7 @@ const PORT = env.PORT ? parseInt(env.PORT) : 3000
 
 let argv2 = argv[2]
 
+// TODO pass argv to shared process instead of using environment variables / global variables
 const argvSliced = argv.slice(2)
 for (const arg of argvSliced) {
   if (arg.startsWith('--only-extension=')) {
@@ -33,86 +24,12 @@ for (const arg of argvSliced) {
   }
 }
 
-process.env.BUILTIN_EXTENSIONS_PATH = builtinExtensionsPath
-
 if (!argv2) {
   argv2 = resolve(__dirname, '../../../playground')
 }
 
-const isImmutable = true
-
 const isPublic = argv.includes('--public')
 
-const addSemicolon = (line) => {
-  return line + ';'
-}
-
-const ContentSecurityPolicy = {
-  key: 'Content-Security-Policy',
-  value: [
-    `default-src 'none'`,
-    `connect-src 'self'`,
-    `font-src 'self'`,
-    `frame-src *`,
-    `img-src 'self' https: data: blob:`,
-    `script-src 'self'`,
-    `media-src 'self'`,
-    `manifest-src 'self'`,
-    `style-src 'self'`,
-  ]
-    .map(addSemicolon)
-    .join(' '),
-}
-
-const CrossOriginResourcePolicy = {
-  key: 'Cross-Origin-Resource-Policy',
-  value: 'same-origin',
-}
-
-const ContentSecurityPolicyRendererWorker = {
-  key: 'Content-Security-Policy',
-  value: [`default-src 'none'`, `connect-src 'self'`, `script-src 'self'`, `font-src 'self'`].map(addSemicolon).join(' '),
-}
-
-const ContentSecurityPolicyExtensionHostWorker = {
-  key: 'Content-Security-Policy',
-  value: [`default-src 'none'`, `connect-src 'self'`, `script-src 'self'`, `font-src 'self'`].map(addSemicolon).join(' '),
-}
-
-const ContentSecurityPolicyTerminalWorker = {
-  key: 'Content-Security-Policy',
-  value: [`default-src 'none'`, `connect-src 'self'`, `script-src 'self'`].map(addSemicolon).join(' '),
-}
-
-const CrossOriginOpenerPolicy = {
-  key: 'Cross-Origin-Opener-Policy',
-  value: 'same-origin',
-}
-
-const CrossOriginEmbedderPolicy = {
-  key: 'Cross-Origin-Embedder-Policy',
-  value: 'require-corp',
-}
-
-const textMimeType = {
-  '.html': 'text/html',
-  '.js': 'text/javascript',
-  '.ts': 'text/javascript',
-  '.mjs': 'text/javascript',
-  '.json': 'application/json',
-  '.css': 'text/css',
-  '.svg': 'image/svg+xml',
-  '.avif': 'image/avif',
-  '.woff': 'application/font-woff',
-  '.ttf': 'font/ttf',
-  '.png': 'image/png',
-  '.jpe': 'image/jpg',
-  '.ico': 'image/x-icon',
-  '.jpeg': 'image/jpg',
-  '.jpg': 'image/jpg',
-  '.webp': 'image/webp',
-}
-
 /**
  * @enum {string}
  */
@@ -124,296 +41,29 @@ const ErrorCodes = {
   EADDRINUSE: 'EADDRINUSE',
 }
 
-/**
- * @enum {string}
- */
-const CachingHeaders = {
-  Empty: '',
-  NoCache: 'public, max-age=0, must-revalidate',
-  OneYear: 'public, max-age=31536000, immutable',
-}
-
-/**
- * @enum {number}
- */
-const StatusCode = {
-  NotFound: 404,
-  ServerError: 500,
-  Ok: 200,
-  MultipleChoices: 300,
-  NotModified: 304,
-}
-
-const getPath = (url) => {
-  return url.split(/[?#]/)[0]
-}
-
-const getContentType = (filePath) => {
-  return textMimeType[extname(filePath)] || 'text/plain'
-}
-
-const getPathName = (request) => {
-  const { pathname } = new URL(request.url || '', `https://${request.headers.host}`)
-  return pathname
-}
-
-const isWorkerUrl = (url) => {
-  return url.endsWith('WorkerMain.js') || url.endsWith('WorkerMain.ts')
-}
-
-const isRendererWorkerUrl = (url) => {
-  return url.endsWith('rendererWorkerMain.js') || url.endsWith('rendererWorkerMain.ts')
-}
-
-const isExtensionHostWorkerUrl = (url) => {
-  return url.endsWith('extensionHostWorkerMain.js') || url.endsWith('extensionHostWorkerMain.ts')
-}
-
-const isTerminalWorkerUrl = (url) => {
-  return url.endsWith('terminalWorkerMain.js') || url.endsWith('terminalWorkerMain.ts')
-}
-
-const getEtag = (fileStat) => {
-  return `W/"${[fileStat.ino, fileStat.size, fileStat.mtime.getTime()].join('-')}"`
-}
-
-const serveStatic = (root, skip = '') =>
-  async function serveStatic(req, res, next) {
-    const pathName = getPathName(req)
-    let relativePath = getPath(pathName.slice(skip.length))
-    if (relativePath.endsWith('/')) {
-      relativePath += 'index.html'
-    }
-    // TODO on linux this could be more optimized because it is already encoded correctly (no backslashes)
-    const filePath = fileURLToPath(`file://${root}${relativePath}`)
-    let fileStat
-    try {
-      fileStat = await stat(filePath)
-    } catch {
-      return next()
-    }
-    const etag = getEtag(fileStat)
-    if (req.headers['if-none-match'] === etag) {
-      res.writeHead(StatusCode.NotModified)
-      return res.end()
-    }
-    const isHtml = relativePath.endsWith('index.html')
-    let cachingHeader = CachingHeaders.NoCache
-    if (isHtml) {
-      cachingHeader = CachingHeaders.NoCache
-    } else if (isImmutable && root === STATIC) {
-      cachingHeader = CachingHeaders.OneYear
-    }
-    const contentType = getContentType(filePath)
-    const headers = {
-      'Content-Type': contentType,
-      Etag: etag,
-      'Cache-Control': cachingHeader,
-      [CrossOriginResourcePolicy.key]: CrossOriginResourcePolicy.value,
-    }
-    if (contentType === 'text/html') {
-      headers[ContentSecurityPolicy.key] = ContentSecurityPolicy.value
-      // enables access for performance.measureUserAgentSpecificMemory, see https://web.dev/monitor-total-page-memory-usage/
-      headers[CrossOriginEmbedderPolicy.key] = CrossOriginEmbedderPolicy.value
-      headers[CrossOriginOpenerPolicy.key] = CrossOriginOpenerPolicy.value
-    }
-    if (isRendererWorkerUrl(filePath)) {
-      headers[CrossOriginEmbedderPolicy.key] = CrossOriginEmbedderPolicy.value
-      headers[ContentSecurityPolicyRendererWorker.key] = ContentSecurityPolicyRendererWorker.value
-    } else if (isExtensionHostWorkerUrl(filePath)) {
-      headers[CrossOriginEmbedderPolicy.key] = CrossOriginEmbedderPolicy.value
-      headers[ContentSecurityPolicyExtensionHostWorker.key] = ContentSecurityPolicyExtensionHostWorker.value
-    } else if (isTerminalWorkerUrl(filePath)) {
-      headers[CrossOriginEmbedderPolicy.key] = CrossOriginEmbedderPolicy.value
-      headers[ContentSecurityPolicyTerminalWorker.key] = ContentSecurityPolicyTerminalWorker.value
-    } else if (isWorkerUrl(filePath)) {
-      headers[CrossOriginEmbedderPolicy.key] = CrossOriginEmbedderPolicy.value
-    }
-    res.writeHead(StatusCode.Ok, headers)
-    try {
-      await pipeline(createReadStream(filePath), res)
-    } catch (error) {
-      // @ts-ignore
-      if (error && error.code === ErrorCodes.ERR_STREAM_PREMATURE_CLOSE) {
-        return
-      }
-      // @ts-ignore
-      if (error && error.code === ErrorCodes.EISDIR) {
-        res.writeHead(StatusCode.NotFound)
-        res.end()
-        return
-      }
-      console.info('failed to send request', error)
-      // TODO it is unclear how to handle errors here
-    }
-  }
-
-const serve404 = () =>
-  function serve404(req, res, next) {
-    console.info(`[server] Failed to serve static file "${req.url}"`)
-    const headers = {
-      'Content-Type': 'text/plain',
-    }
-    if (isWorkerUrl(req.url)) {
-      headers[CrossOriginEmbedderPolicy.key] = CrossOriginEmbedderPolicy.value
-      headers[ContentSecurityPolicyRendererWorker.key] = ContentSecurityPolicyRendererWorker.value
-    }
-    res.writeHead(StatusCode.NotFound, headers)
-    return res.end('Not found')
-  }
-
-const createApp = () => {
-  const handlerMap = Object.create(null)
-  const callback = (req, res) => {
-    // TODO avoid closure
-    req.on('error', (error) => {
-      // @ts-ignore
-      if (error && error.code === ErrorCodes.ECONNRESET) {
-        return
-      }
-      console.info('[info: request error]', error)
-    })
-    // @ts-ignore
-    const pathName = getPathName(req)
-    const lastSlashIndex = pathName.indexOf('/', 1)
-    const prefix = lastSlashIndex === -1 ? pathName : pathName.slice(0, lastSlashIndex)
-    const handlers = handlerMap[prefix] || handlerMap['*']
-    let i = 0
-    const next = () => {
-      const fn = i < handlers.length ? handlers[i++] : serve404()
-      fn(req, res, next)
-    }
-    next()
+const isStatic = (url) => {
+  if(url === '/'){
+    return true
   }
-  callback.use = (path, ...handlers) => {
-    handlerMap[path] = handlers
+  if (url.startsWith('/38827dc')) {
+    return true
   }
-  return callback
-}
-
-const app = createApp()
-
-/**
- *
- * @param {IncomingMessage} req
- * @param {ServerResponse} res
- */
-const serveTests = async (req, res, next) => {
-  // TODO figure out if shared process can
-  // find out where the static folder is located
-  const indexHtmlPath = join(ROOT, 'static', 'index.html')
-  sendHandleSharedProcess(req, res.socket, 'HandleRequestTest.handleRequestTest', indexHtmlPath)
-}
-
-/**
- *
- * @param {IncomingMessage} req
- * @param {ServerResponse} res
- */
-const servePackages = async (req, res, next) => {
-  sendHandleSharedProcess(req, res.socket, 'HandleRemoteRequest.handleRemoteRequest')
-}
-
-const getAbsolutePath = (extensionName) => {
-  return join(ROOT, 'extensions', extensionName, 'extension.json')
-}
-
-const isLanguageBasics = (name) => {
-  return name.startsWith('builtin.language-basics')
-}
-
-const readJson = async (path) => {
-  const content = await readFile(path, 'utf8')
-  return JSON.parse(content)
-}
-
-const combineLanguages = (extensions) => {
-  const languages = []
-  for (const extension of extensions) {
-    if (extension.languages) {
-      for (const language of extension.languages) {
-        languages.push({
-          ...language,
-          tokenize: `/extensions/${extension.id}/${language.tokenize}`,
-        })
-      }
-    }
+  if (url.startsWith('/favicon.ico')) {
+    return true
   }
-  return languages
-}
-
-const getLanguagesJson = async () => {
-  const extensionNames = await readdir(join(ROOT, 'extensions'))
-  const languageBasics = extensionNames.filter(isLanguageBasics)
-  const extensionPaths = languageBasics.map(getAbsolutePath)
-  const extensions = await Promise.all(extensionPaths.map(readJson))
-  const languages = combineLanguages(extensions)
-  return languages
-}
-
-const sendFile = async (path, res) => {
-  const type = getContentType(path)
-  res.setHeader('Content-Type', type)
-  try {
-    await pipeline(createReadStream(path), res)
-  } catch (error) {
-    // @ts-ignore
-    if (error && error.code === ErrorCodes.ERR_STREAM_PREMATURE_CLOSE) {
-      return
-    }
-    // @ts-ignore
-    if (error && error.code === ErrorCodes.EISDIR) {
-      res.statusCode = StatusCode.NotFound
-      res.end()
-      return
-    }
-    console.info('failed to send request', error)
-    res.statusCode = StatusCode.ServerError
-    // TODO escape error html
-    res.end(`${error}`)
+  if (url.startsWith('/manifest.ico')) {
+    return true
   }
-  return
+  return false
 }
 
-const serveConfig = async (req, res, next) => {
-  const pathName = getPathName(req)
-  if (pathName === '/config/languages.json') {
-    const languagesJson = await getLanguagesJson()
-    res.statusCode = StatusCode.Ok
-    res.end(JSON.stringify(languagesJson, null, 2))
-    return
-  }
-  switch (pathName) {
-    case '/config/defaultKeyBindings.json':
-    case '/config/builtinCommands.json':
-    case '/config/defaultSettings.json':
-    case '/config/webExtensions.json':
-    case '/config/fileMap.json':
-      return sendFile(join(ROOT, 'static', pathName), res)
-    default:
-      break
+const handleRequest = (req, res) => {
+  if (isStatic(req.url)) {
+    return sendHandleStaticServerProcess(req, res.socket, 'HandleRequest.handleRequest')
   }
-  next()
-}
-
-const handleRemote = (req, res) => {
-  sendHandleSharedProcess(req, res.socket, 'HandleRemoteRequest.handleRemoteRequest')
-}
-
-const serveWithStaticServer = (req, res) => {
-  sendHandleStaticServerProcess(req, res.socket, 'HandleRequest.handleRequest')
+  return sendHandleSharedProcess(req, res.socket, 'HandleRequest.handleRequest')
 }
 
-// serve other files in shared process
-app.use('/remote', handleRemote)
-app.use('/tests', serveTests, serve404())
-app.use('/config', serveConfig, serve404())
-app.use('/packages', servePackages, serve404())
-
-
-// TODO deprecate this part, serve files statically or in shared process
-app.use('*', serveStatic(ROOT), serveStatic(STATIC), serve404())
-
 const state = {
   /**
    * @type {Promise<ChildProcess>|undefined}
@@ -482,6 +132,7 @@ const launchProcess = async (processPath, execArgv) => {
  * @returns {Promise<ChildProcess>}
  */
 const launchSharedProcess = async () => {
+  const { sharedProcessPath } = await import('@lvce-editor/shared-process')
   return launchProcess(sharedProcessPath, ['--enable-source-maps', '--ipc-type=node-forked-process', ...argvSliced])
 }
 
@@ -501,6 +152,7 @@ const getOrCreateSharedProcess = () => {
  * @returns {Promise<ChildProcess>}
  */
 const launchStaticServerProcess = async () => {
+  const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
   return launchProcess(staticServerPath, [])
 }
 
@@ -610,7 +262,7 @@ const handleUncaughtExceptionMonitor = (error, origin) => {
 const main = () => {
   process.on('message', handleMessageFromParent)
   process.on('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor)
-  const server = createServer(app)
+  const server = createServer(handleRequest)
   server.on('listening', handleAppReady)
   server.on('upgrade', handleUpgrade)
   server.on('error', handleServerError)