@lvce-editor/shared-process 0.14.7 → 0.14.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.14.7",
+  "version": "0.14.8",
   "description": "Utility package for @lvce-editor/server",
   "main": "index.js",
   "type": "module",
@@ -17,9 +17,9 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.21.4",
-    "@lvce-editor/extension-host": "0.14.7",
-    "@lvce-editor/extension-host-helper-process": "0.14.7",
-    "@lvce-editor/pty-host": "0.14.7",
+    "@lvce-editor/extension-host": "0.14.8",
+    "@lvce-editor/extension-host-helper-process": "0.14.8",
+    "@lvce-editor/pty-host": "0.14.8",
     "debug": "^4.3.4",
     "execa": "^7.1.1",
     "exit-hook": "^3.2.0",

package/src/parts/AutoUpdater/AutoUpdater.ipc.js

@@ -0,0 +1,9 @@
+import * as AutoUpdater from './AutoUpdater.js'
+
+export const name = 'AutoUpdater'
+
+export const Commands = {
+  checkForUpdatesAndNotify: AutoUpdater.checkForUpdatesAndNotify,
+  downloadUpdate: AutoUpdater.downloadUpdate,
+  installAndRestart: AutoUpdater.installAndRestart,
+}

package/src/parts/AutoUpdater/AutoUpdater.js

@@ -0,0 +1,29 @@
+import * as AutoUpdaterAppImage from '../AutoUpdaterAppImage/AutoUpdaterAppImage.js'
+import { VError } from '../VError/VError.js'
+
+export const checkForUpdatesAndNotify = async () => {
+  try {
+    return await AutoUpdaterAppImage.checkForUpdatesAndNotify()
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to check for updates`)
+  }
+}
+
+export const downloadUpdate = async (version) => {
+  try {
+    return await AutoUpdaterAppImage.downloadUpdate(version)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to download update`)
+  }
+}
+
+export const installAndRestart = async (downloadPath) => {
+  try {
+    return await AutoUpdaterAppImage.installAndRestart(downloadPath)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to install and restart`)
+  }
+}

package/src/parts/AutoUpdaterAppImage/AutoUpdaterAppImage.js

@@ -0,0 +1,85 @@
+import { spawn } from 'node:child_process'
+import { chmod, rename } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import * as Assert from '../Assert/Assert.js'
+import * as CompareVersion from '../CompareVersion/CompareVersion.js'
+import * as Download from '../Download/Download.js'
+import * as GetLatestReleaseVersion from '../GetLatestReleaseVersion/GetLatestReleaseVersion.js'
+import * as Platform from '../Platform/Platform.js'
+import { VError } from '../VError/VError.js'
+
+const getDownloadUrl = (repository, version, appImageName) => {
+  Assert.string(version)
+  return `https://github.com/${repository}/releases/download/v${version}/${appImageName}-v${version}.AppImage`
+}
+
+const getOutfilePath = (version) => {
+  Assert.string(version)
+  const outFile = join(tmpdir(), `appimage-${version}`)
+  return outFile
+}
+
+export const downloadUpdate = async (version) => {
+  try {
+    Assert.string(version)
+    const repository = Platform.getRepository()
+    const appImageName = Platform.getAppImageName()
+    const downLoadUrl = getDownloadUrl(repository, version, appImageName)
+    const outFile = getOutfilePath(version)
+    await Download.download(downLoadUrl, outFile)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to download new version ${version}`)
+  }
+}
+
+export const checkForUpdatesAndNotify = async () => {
+  const repository = Platform.getRepository()
+  const version = await GetLatestReleaseVersion.getLatestReleaseVersion(repository)
+  const currentVersion = Platform.version
+  if (CompareVersion.isGreater(version, currentVersion)) {
+    return {
+      version,
+    }
+  } else {
+    console.log('not update is available')
+  }
+}
+
+const getAppImagePath = () => {
+  return process.env.APPIMAGE
+}
+
+const installNewAppImage = async (appImageFile, downloadPath) => {
+  try {
+    await rename(downloadPath, appImageFile)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to rename AppImage file`)
+  }
+}
+
+const restart = (downloadPath) => {
+  // TODO handle errors
+  spawn(downloadPath, { stdio: 'inherit' })
+}
+
+const makeExecutable = async (file) => {
+  await chmod(file, 0o755)
+}
+
+export const installAndRestart = async (downloadPath) => {
+  try {
+    const appImageFile = getAppImagePath()
+    if (!appImageFile) {
+      throw new Error(`AppImage path not found`)
+    }
+    await makeExecutable(downloadPath)
+    await installNewAppImage(appImageFile, downloadPath)
+    await restart(downloadPath)
+  } catch (error) {
+    // @ts-ignore
+    throw new VError(error, `Failed to install AppImage update`)
+  }
+}

package/src/parts/CompareVersion/CompareVersion.js

@@ -0,0 +1,3 @@
+export const isGreater = (version, otherVersion) => {
+  return true
+}

package/src/parts/GetLatestReleaseVersion/GetLatestReleaseVersion.js

@@ -0,0 +1,60 @@
+import got, { HTTPError } from 'got'
+import { VError } from '../VError/VError.js'
+
+/**
+ *
+ * @param {HTTPError} error
+ */
+const getHttpErrorMessage = (error) => {
+  try {
+    const body = error.response.body
+    if (error.response.url.includes('api.github.com') && typeof body === 'string') {
+      const json = JSON.parse(body)
+      if (json.message) {
+        const message = json.message
+        if (message.includes('rate limit exceeded')) {
+          const reset = error.response.headers['x-ratelimit-reset']
+          const limit = error.response.headers['x-ratelimit-limit']
+          if (reset && typeof reset === 'string' && typeof limit === 'string') {
+            const resetDate = new Date(parseInt(reset) * 1000)
+            const limitAmount = parseInt(limit)
+            return `GitHub rate limit of ${limitAmount} requests per hour execeeded, resets at ${resetDate}`
+          }
+        }
+        return json.message
+      }
+    }
+  } catch {}
+  return `${error.message}`
+}
+
+const parseVersionFromUrl = (url, repository) => {
+  if (!url.includes('releases/tag')) {
+    if (url.endsWith('/releases')) {
+      throw new Error(`no releases found for ${repository}`)
+    }
+    throw new Error(`cannot parse release version from url ${url}`)
+  }
+  const slashIndex = url.lastIndexOf('/')
+  const version = url.slice(slashIndex + 1)
+  if (version.startsWith('v')) {
+    return version.slice(1)
+  }
+  return version
+}
+
+export const getLatestReleaseVersion = async (repository) => {
+  try {
+    const json = await got.head(`https://github.com/${repository}/releases/latest`)
+    const finalUrl = json.url
+    const version = parseVersionFromUrl(finalUrl, repository)
+    return version
+  } catch (error) {
+    if (error instanceof HTTPError) {
+      const httpErrorMessage = getHttpErrorMessage(error)
+      throw new VError(`Failed to get latest release for ${repository}: ${httpErrorMessage}`)
+    }
+    // @ts-ignore
+    throw new VError(error, `Failed to get latest release for ${repository}`)
+  }
+}

package/src/parts/IsAutoUpdateSupported/IsAutoUpdateSupported.ipc.js

@@ -0,0 +1,7 @@
+import * as IsAutoUpdateSupported from './IsAutoUpdateSupported.js'
+
+export const name = 'IsAutoUpdateSupported'
+
+export const Commands = {
+  isAutoUpdateSupported: IsAutoUpdateSupported.isAutoUpdateSupported,
+}

package/src/parts/IsAutoUpdateSupported/IsAutoUpdateSupported.js

@@ -0,0 +1,10 @@
+import * as Platform from '../Platform/Platform.js'
+
+export const isAutoUpdateSupported = () => {
+  return true
+  // return Platform.isWindows || Platform.isMacOs
+}
+
+export const useElectronBuilderAutoUpdate = () => {
+  return Platform.isWindows
+}

package/src/parts/Module/Module.js

@@ -44,6 +44,10 @@ export const load = (moduleId) => {
       return import('../Workspace/Workspace.ipc.js')
     case ModuleId.InstallExtension:
       return import('../InstallExtension/InstallExtension.ipc.js')
+    case ModuleId.AutoUpdater:
+      return import('../AutoUpdater/AutoUpdater.ipc.js')
+    case ModuleId.IsAutoUpdateSupported:
+      return import('../IsAutoUpdateSupported/IsAutoUpdateSupported.ipc.js')
     default:
       throw new Error(`module ${moduleId} not found`)
   }

package/src/parts/ModuleId/ModuleId.js

@@ -19,3 +19,5 @@ export const Download = 18
 export const GitLsFiles = 19
 export const BulkReplacement = 20
 export const InstallExtension = 21
+export const AutoUpdater = 22
+export const IsAutoUpdateSupported = 23

package/src/parts/ModuleMap/ModuleMap.js

@@ -3,6 +3,10 @@ import * as ModuleId from '../ModuleId/ModuleId.js'
 
 export const getModuleId = (commandId) => {
   switch (commandId) {
+    case 'AutoUpdater.checkForUpdatesAndNotify':
+    case 'AutoUpdater.downloadUpdate':
+    case 'AutoUpdater.installAndRestart':
+      return ModuleId.AutoUpdater
     case 'BulkReplacement.applyBulkReplacement':
       return ModuleId.BulkReplacement
     case 'ChromeExtension.install':
@@ -99,6 +103,8 @@ export const getModuleId = (commandId) => {
     case 'GitLsFiles.gitLsFilesHash':
     case 'GitLsFiles.resolveGit':
       return ModuleId.GitLsFiles
+    case 'IsAutoUpdateSupported.isAutoUpdateSupported':
+      return ModuleId.IsAutoUpdateSupported
     case 'Native.openFolder':
       return ModuleId.Native
     case 'OutputChannel.close':

package/src/parts/Platform/Platform.js

@@ -147,3 +147,13 @@ export const getDownloadDir = () => {
   const { XDG_DOWNLOAD_DIR } = env
   return XDG_DOWNLOAD_DIR || join(homeDir, 'Downloads')
 }
+
+export const getRepository = () => {
+  return `lvce-editor/lvce-editor`
+}
+
+export const getAppImageName = () => {
+  return 'Lvce'
+}
+
+export const version = '0.0.0-dev'