@lvce-editor/server 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022-present, Le Vivilet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# web
+
+The web process is a nodejs process that runs
+
+- `web` runs a static file server that serves the html, css and javascript to the browser
+- `web` can accept WebSocket connections, it sends the WebSocket connection to `shared-process`
+- `web` spawns the `shared-process`

package/ThirdPartyNotices.txt

@@ -0,0 +1,134 @@
+This project incorporates components from the projects listed below, that may have licenses
+differing from this project:
+
+
+1) License Notice for static/1914fad/file-icons (from https://github.com/vscode-icons/vscode-icons)
+---------------------------------------
+
+The icons are licensed under the Creative Commons - ShareAlike (CC BY-SA) license.
+
+Branded icons are licensed under their copyright license.
+
+
+2) License Notice for static/1914fad/icons (from https://github.com/microsoft/vscode)
+---------------------------------------
+
+MIT License
+
+Copyright (c) 2015 - present Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+3) License Notice for static/1914fad/fonts/FiraCode-VariableFont.ttf (from https://github.com/tonsky/FiraCode)
+---------------------------------------
+
+Copyright (c) 2014, The Fira Code Project Authors (https://github.com/tonsky/FiraCode)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/bin/server.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../src/server.js'

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@lvce-editor/server",
+  "version": "0.0.2",
+  "description": "",
+  "main": "index.js",
+  "bin": "bin/server.js",
+  "type": "module",
+  "scripts": {},
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@lvce-editor/shared-process": "0.0.2"
+  }
+}

package/src/server.js

@@ -0,0 +1,299 @@
+// based on https://github.com/microsoft/vscode/tree/1.64.2/src/vs/server/node/webClientServer.ts
+
+import { ChildProcess, fork } from 'child_process'
+import { createReadStream } from 'fs'
+import { stat } from 'fs/promises'
+import { createServer } from 'http'
+import { dirname, extname, join, normalize, resolve } from 'path'
+import { pipeline } from 'stream/promises'
+import { fileURLToPath } from 'url'
+import { sharedProcessPath } from '@lvce-editor/shared-process'
+
+// @ts-ignore
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const ROOT = resolve(__dirname, '../../../')
+const STATIC = resolve(__dirname, '../../../static')
+const PORT = process.env.PORT || 3000
+
+let argv2 = process.argv[2]
+
+if (!argv2) {
+  argv2 = resolve(__dirname, '../../../playground')
+}
+
+const FOLDER = resolve(process.cwd(), argv2)
+
+const IS_WINDOWS = process.platform === 'win32'
+
+const textMimeType = {
+  '.html': 'text/html',
+  '.js': 'text/javascript',
+  '.json': 'application/json',
+  '.css': 'text/css',
+  '.svg': 'image/svg+xml',
+}
+
+const getPath = (url) => {
+  return url.split(/[?#]/)[0]
+}
+
+const serveStatic = (root, skip = '') =>
+  async function serveStatic(req, res, next) {
+    let relativePath = getPath(req.url.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 = `W/"${[
+      fileStat.ino,
+      fileStat.size,
+      fileStat.mtime.getTime(),
+    ].join('-')}"`
+    if (req.headers['if-none-match'] === etag) {
+      res.writeHead(304)
+      return res.end()
+    }
+    res.writeHead(200, {
+      'Content-Type': textMimeType[extname(filePath)] || 'text/plain',
+      Etag: etag,
+      // enables access for performance.measureUserAgentSpecificMemory, see https://web.dev/monitor-total-page-memory-usage/
+      'Cross-Origin-Embedder-Policy': 'require-corp',
+      'Cross-Origin-Opener-Policy': 'same-origin',
+    })
+    try {
+      await pipeline(createReadStream(filePath), res)
+    } catch (error) {
+      // @ts-ignore
+      if (error && error.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+        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(`[web] Failed to serve static file "${req.url}"`)
+    res.writeHead(404, {
+      'Content-Type': 'text/plain',
+    })
+    return res.end('Not found')
+  }
+
+const createApp = () => {
+  const handlerMap = Object.create(null)
+  const server = createServer((req, res) => {
+    req.on('error', (error) => {
+      // @ts-ignore
+      if (error && error.code === 'ECONNRESET') {
+        return
+      }
+      console.info('[info: request error]', error)
+    })
+    // @ts-ignore
+    const pathMatch = req.url.match(/^(\/[^\/]*)/)
+    // @ts-ignore
+    const path = pathMatch[1]
+    const handlers = handlerMap[path] || handlerMap['*']
+    let i = 0
+    const next = () => {
+      const fn = i < handlers.length ? handlers[i++] : serve404()
+      fn(req, res, next)
+    }
+    next()
+  })
+  return {
+    use(path, ...handlers) {
+      handlerMap[path] = handlers
+    },
+    listen: server.listen.bind(server),
+    on: server.on.bind(server),
+    close: server.close.bind(server),
+  }
+}
+
+const app = createApp()
+
+const serveGitHub = async (req, res) => {
+  try {
+    await pipeline(createReadStream(join(ROOT, 'static', 'index.html')), res)
+  } catch (error) {
+    console.info('failed to send request', error)
+  }
+}
+
+app.use('/github', serveGitHub, serve404())
+app.use('/remote', serveStatic('', '/remote'), serve404())
+app.use('*', serveStatic(ROOT), serveStatic(STATIC), serve404())
+
+const state = {
+  /**
+   * @type {(()=>void)[]}
+   */
+  onSharedProcessReady: [],
+  /**
+   * @type{ChildProcess|undefined}
+   */
+  sharedProcess: undefined,
+  /**
+   * @type{0|1|2}
+   */
+  sharedProcessState: /* off */ 0,
+}
+
+const handleMessage = (message) => {
+  if (!process.send) {
+    console.log('send not available (2)')
+    return
+  }
+  process.send(message)
+}
+
+const handleMessageFromParent = (message) => {
+  console.log('got message from parent')
+  switch (state.sharedProcessState) {
+    case /* off */ 0:
+      console.warn('cannot send message')
+      break
+    case /* launching */ 1:
+      console.warn('cannot send message')
+      break
+    case /* on */ 2:
+      // @ts-ignore
+      state.sharedProcess.send(message)
+      break
+    default:
+      break
+  }
+}
+
+const handleExit = (code) => {
+  process.exit(code)
+}
+
+const handleDisconnect = () => {
+  console.info('[web] shared process disconnected')
+}
+
+const launchSharedProcess = () => {
+  state.sharedProcessState = /* launching */ 1
+  delete process.env.ELECTRON_RUN_AS_NODE
+
+  const sharedProcess = fork(sharedProcessPath, {
+    stdio: 'inherit',
+    // execArgv: ['--trace-deopt'],
+    execArgv: ['--enable-source-maps'],
+    env: {
+      ...process.env,
+      ELECTRON_RUN_AS_NODE: '1',
+    },
+  })
+  const handleFirstMessage = (message) => {
+    state.sharedProcessState = /* on */ 2
+    for (const listener of state.onSharedProcessReady) {
+      listener()
+    }
+    state.onSharedProcessReady = []
+    sharedProcess.on('message', handleMessage)
+  }
+  sharedProcess.once('message', handleFirstMessage)
+  sharedProcess.on('exit', handleExit)
+  sharedProcess.on('disconnect', handleDisconnect)
+  state.sharedProcess = sharedProcess
+}
+
+// TODO handle all possible errors from shared process
+
+const handleUpgrade = (request, socket) => {
+  request.on('error', (error) => {
+    console.info('[info]: request upgrade error', error)
+  })
+  socket.on('error', () => {
+    // @ts-ignore
+    console.info('[info] request socket upgrade error', error)
+  })
+  switch (state.sharedProcessState) {
+    case /* off */ 0:
+      state.onSharedProcessReady.push(() => {
+        // @ts-ignore
+        state.sharedProcess.send(
+          { headers: request.headers, method: request.method },
+          // @ts-ignore
+          socket
+        )
+      })
+      launchSharedProcess()
+      break
+    case /* launching */ 1:
+      state.onSharedProcessReady.push(() => {
+        handleUpgrade(request, socket)
+      })
+      break
+    case /* on */ 2:
+      // @ts-ignore
+      state.sharedProcess.send(
+        { headers: request.headers, method: request.method },
+        // @ts-ignore
+        socket
+      )
+      break
+    default:
+      break
+  }
+}
+
+app.on('upgrade', handleUpgrade)
+
+app.on('error', (error) => {
+  console.error('[info: server error]', error)
+})
+
+const handleProcessExit = (code) => {
+  console.info(`[web] Process will exit with code ${code}`)
+  app.close()
+  if (state.sharedProcess && !state.sharedProcess.killed) {
+    state.sharedProcess.kill()
+    state.sharedProcess = undefined
+  }
+}
+
+const handleSigInt = () => {
+  console.info(`[web] Process will exit because of sigint`)
+  app.close()
+  if (state.sharedProcess && !state.sharedProcess.killed) {
+    state.sharedProcess.kill()
+    state.sharedProcess = undefined
+  }
+}
+
+const handleAppReady = () => {
+  if (process.send) {
+    console.log('send ready')
+    process.send('ready')
+  } else {
+    console.info(`[web] listening on http://localhost:${PORT}`)
+  }
+}
+
+const handleUncaughtExceptionMonitor = (error, origin) => {
+  console.info('[web] Uncaught exception')
+  console.info(error)
+}
+
+const main = () => {
+  process.on('message', handleMessageFromParent)
+  process.on('exit', handleProcessExit)
+  process.on('SIGINT', handleSigInt)
+  process.on('uncaughtExceptionMonitor', handleUncaughtExceptionMonitor)
+  app.listen(PORT, handleAppReady)
+}
+
+main()