@lvce-editor/shared-process 0.115.22 → 0.115.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.115.22",
+  "version": "0.115.24",
   "main": "index.js",
   "type": "module",
   "keywords": [

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

@@ -1,7 +1,9 @@
 import * as UpdateLog from '../UpdateLog/UpdateLog.js'
+import * as WindowsStagedUpdate from '../WindowsStagedUpdate/WindowsStagedUpdate.js'
 import * as AutoUpdater from './AutoUpdater.js'
 
 export const Commands = {
+  'AutoUpdater.checkWindowsUpdate': WindowsStagedUpdate.check,
   'AutoUpdater.getAutoUpdateType': AutoUpdater.getAutoUpdateType,
   'AutoUpdater.getLatestVersion': AutoUpdater.getLatestVersion,
   'AutoUpdater.getPlatform': AutoUpdater.getPlatform,

package/src/parts/BuiltinExtensionsPath/BuiltinExtensionsPath.js

@@ -3,6 +3,6 @@ import { fileURLToPath } from 'url'
 
 export const getBuiltinExtensionsPath = () => {
   const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
-  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '05a51a8', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '5c8581c', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/HandleElectronReady/HandleElectronReady.js

@@ -7,6 +7,7 @@ import * as Preferences from '../Preferences/Preferences.js'
 import * as PreloadUrl from '../PreloadUrl/PreloadUrl.js'
 import * as Process from '../Process/Process.js'
 import * as TransientLinkedExtensions from '../TransientLinkedExtensions/TransientLinkedExtensions.js'
+import * as WindowsStagedUpdate from '../WindowsStagedUpdate/WindowsStagedUpdate.js'
 
 export const handleElectronReady = async (parsedArgs, workingDirectory) => {
   Assert.object(parsedArgs)
@@ -25,6 +26,7 @@ export const handleElectronReady = async (parsedArgs, workingDirectory) => {
     const preferences = await Preferences.getAllSafe()
     const preloadUrl = PreloadUrl.getPreloadUrl()
     await AppWindow.createAppWindow({ parsedArgs, preferences, preloadUrl, workingDirectory })
+    await WindowsStagedUpdate.confirmStartup()
   } catch (error) {
     Logger.error(error)
     Process.exit(ExitCode.ExpectedError)

package/src/parts/ModuleMap/ModuleMap.js

@@ -7,6 +7,7 @@ export const getModuleId = (commandId) => {
       return ModuleId.TextDocument
     case 'AttachDebugger.attachDebugger':
       return ModuleId.AttachDebugger
+    case 'AutoUpdater.checkWindowsUpdate':
     case 'AutoUpdater.getAutoUpdateType':
     case 'AutoUpdater.getLatestVersion':
     case 'AutoUpdater.getPlatform':

package/src/parts/Platform/Platform.js

@@ -56,11 +56,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.115.22'
+export const version = '0.115.24'
 
-export const commit = '05a51a8'
+export const commit = '5c8581c'
 
-export const date = '2026-09-19T11:10:55.000Z'
+export const date = '2026-09-19T12:57:04.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/PreloadUrl/PreloadUrl.js

@@ -2,5 +2,5 @@ import { join } from 'node:path'
 import * as Root from '../Root/Root.js'
 
 export const getPreloadUrl = () => {
-  return join(Root.root, 'static', '05a51a8', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', '5c8581c', 'packages', 'preload', 'dist', 'index.js')
 }

package/src/parts/WindowsStagedUpdate/WindowsStagedUpdate.js

@@ -0,0 +1,230 @@
+import { execFile, spawn } from 'node:child_process'
+import { createHash, randomBytes } from 'node:crypto'
+import { closeSync, createReadStream, createWriteStream } from 'node:fs'
+import { access, copyFile, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { basename, dirname, join } from 'node:path'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { promisify } from 'node:util'
+import * as CompareVersion from '../CompareVersion/CompareVersion.js'
+import * as ElectronDialog from '../ElectronDialog/ElectronDialog.js'
+import * as Exit from '../Exit/Exit.js'
+import * as Platform from '../Platform/Platform.js'
+import * as UpdateLog from '../UpdateLog/UpdateLog.js'
+import * as WindowsUpdateScripts from '../WindowsUpdateScripts/WindowsUpdateScripts.js'
+
+                
+                 
+                
+             
+                 
+             
+                   
+               
+               
+               
+                 
+ 
+
+let running = false
+let prepared                                          
+const RE_VERSION = /^\d+\.\d+\.\d+$/
+const RE_DIGEST = /^sha256:[a-f0-9]{64}$/
+const RE_TAG = /^v/
+const RE_TOKEN = /^[a-f0-9]{32}$/
+
+const powershell = () => join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+const argumentsFor = (script) => [
+  '-NoProfile',
+  '-NonInteractive',
+  '-EncodedCommand',
+  Buffer.from(script, 'utf16le').toString('base64'),
+]
+
+export const validateAsset = (asset, version, arch) => {
+  if (!RE_VERSION.test(version) || !['x64', 'arm64'].includes(arch)) {
+    throw new Error('Unsupported Windows update version or architecture')
+  }
+  const name = `Lvce-Update-v${version}-${arch}.zip`
+  if (asset.name !== name || asset.browser_download_url !== `https://github.com/lvce-editor/lvce-editor/releases/download/v${version}/${name}`) {
+    throw new Error('Unexpected Windows update asset')
+  }
+  if (!RE_DIGEST.test(asset.digest)) {
+    throw new Error('Windows update requires a published SHA256 digest')
+  }
+}
+
+export const verifyDigest = async (path, expected) => {
+  const hash = createHash('sha256')
+  for await (const chunk of createReadStream(path)) {
+    hash.update(chunk)
+  }
+  if (`sha256:${hash.digest('hex')}` !== expected) {
+    throw new Error('Windows update checksum mismatch')
+  }
+}
+
+const prepare = async (asset, version) => {
+  if (prepared?.plan.version === version) {
+    return prepared
+  }
+  validateAsset(asset, version, process.arch)
+  const install = dirname(process.execPath)
+  // Sibling directories guarantee same-volume renames. Never stage inside the
+  // live application: the old installer may remove that entire tree.
+  const token = randomBytes(16).toString('hex')
+  const stage = `${install}.stage-${token}`
+  const work = `${install}.updates`
+  await mkdir(work, { recursive: true })
+  const path = join(work, `${token}.json`)
+  const plan       = {
+    archive: join(work, `${token}.zip`),
+    backup: `${install}.backup-${token}`,
+    exe: basename(process.execPath),
+    install,
+    log: UpdateLog.getPath(),
+    parentPid: process.ppid,
+    ready: join(work, `${token}.ready`),
+    stage,
+    token,
+    version,
+  }
+  await writeFile(path, JSON.stringify(plan), { flag: 'wx' })
+  UpdateLog.write(`Staged update download started version=${version}`)
+  const response = await fetch(asset.browser_download_url, { signal: AbortSignal.timeout(600_000) })
+  if (!response.ok || !response.body) {
+    throw new Error(`Update download failed: ${response.status}`)
+  }
+  await pipeline(Readable.fromWeb(response.body), createWriteStream(plan.archive, { flags: 'wx' }))
+  await verifyDigest(plan.archive, asset.digest)
+  UpdateLog.write(`Staged update download verified version=${version}; extraction started`)
+  await promisify(execFile)(powershell(), argumentsFor(WindowsUpdateScripts.extract), {
+    env: { ...process.env, LVCE_UPDATE_PLAN: path },
+    timeout: 600_000,
+    windowsHide: true,
+  })
+  const config = JSON.parse(await readFile(join(stage, 'resources', 'app', 'config.json'), 'utf8'))
+  if (config.version !== version) {
+    throw new Error('Extracted application version does not match release')
+  }
+  await access(join(stage, plan.exe))
+  // Retain the registered NSIS uninstaller for normal uninstall / repair.
+  // The update archive contains only application files, never user data.
+  await copyFile(join(install, `Uninstall ${Platform.productNameLong}.exe`), join(stage, `Uninstall ${Platform.productNameLong}.exe`))
+  await copyFile(join(install, 'uninstallerIcon.ico'), join(stage, 'uninstallerIcon.ico')).catch((error) => {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  })
+  await writeFile(join(stage, '.lvce-update.json'), JSON.stringify({ token, version }))
+  UpdateLog.write(`Staged update ready version=${version} stage=${stage}`)
+  prepared = { path, plan }
+  return prepared
+}
+
+const restart = async ({ path, plan }                              ) => {
+  await writeFile(path, JSON.stringify({ ...plan, parentPid: process.ppid }))
+  await rm(`${path}.started`, { force: true })
+  await writeFile(`${path}.helper.ps1`, WindowsUpdateScripts.activate)
+  const output = UpdateLog.openOutput()
+  const child = spawn(powershell(), argumentsFor(WindowsUpdateScripts.activate), {
+    cwd: dirname(plan.install),
+    detached: true,
+    env: { ...process.env, LVCE_UPDATE_PLAN: path },
+    stdio: ['ignore', output, output],
+    windowsHide: true,
+  })
+  closeSync(output)
+  await new Promise      ((resolve, reject) => {
+    child.once('spawn', resolve)
+    child.once('error', reject)
+  })
+  child.unref()
+  // Do not exit if PowerShell is blocked or the helper cannot initialize.
+  for (let attempt = 0; attempt < 300; attempt++) {
+    if ((await readFile(`${path}.started`, 'utf8').catch(() => '')) === 'ready') {
+      UpdateLog.write('Staged update helper acknowledged; exiting editor')
+      await Exit.exit()
+      return
+    }
+    if (child.exitCode !== null) {
+      throw new Error(`Update helper exited before startup (${child.exitCode})`)
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100))
+  }
+  child.kill()
+  throw new Error('Update helper did not acknowledge startup; editor left running')
+}
+
+// Returns false only when the release predates staged-update artifacts, allowing
+// the caller to retain the existing NSIS update path for those releases.
+export const check = async (silent, windowId) => {
+  if (running) {
+    return true
+  }
+  running = true
+  try {
+    const response = await fetch('https://api.github.com/repos/lvce-editor/lvce-editor/releases/latest', { signal: AbortSignal.timeout(30_000) })
+    if (!response.ok) {
+      throw new Error(`Release check failed: ${response.status}`)
+    }
+    const release      = await response.json()
+    const version = release.tag_name.replace(RE_TAG, '')
+    if (!CompareVersion.isGreater(version, Platform.version)) {
+      if (!silent) {
+        await ElectronDialog.showMessageBox({ buttons: ['OK'], message: 'No update available.', type: 'info', windowId })
+      }
+      return true
+    }
+    const asset = release.assets.find((item) => item.name === `Lvce-Update-v${version}-${process.arch}.zip`)
+    if (!asset) {
+      return false
+    }
+    if (!silent) {
+      const answer = await ElectronDialog.showMessageBox({
+        buttons: ['Prepare Update', 'Cancel'],
+        defaultId: 0,
+        message: `Download and prepare update ${version}?`,
+        type: 'question',
+        windowId,
+      })
+      if (answer !== 0) {
+        return true
+      }
+    }
+    const update = await prepare(asset, version)
+    const answer = await ElectronDialog.showMessageBox({
+      buttons: ['Restart', 'Later'],
+      defaultId: 0,
+      message: `Update ${version} is ready. Restart now?`,
+      type: 'question',
+      windowId,
+    })
+    if (answer === 0) {
+      await restart(update)
+    }
+    return true
+  } catch (error) {
+    UpdateLog.writeSafe(`Staged update failed: ${error.stack || error.message}`)
+    throw error
+  } finally {
+    running = false
+  }
+}
+
+export const confirmStartup = async () => {
+  if (!Platform.isWindows || !Platform.isProduction) {
+    return
+  }
+  const install = dirname(process.execPath)
+  const marker = await readFile(join(install, '.lvce-update.json'), 'utf8').catch(() => '')
+  if (!marker) {
+    return
+  }
+  const { token, version } = JSON.parse(marker)
+  if (!RE_TOKEN.test(token) || version !== Platform.version) {
+    throw new Error('Invalid staged update startup marker')
+  }
+  await writeFile(join(`${install}.updates`, `${token}.ready`), token)
+  UpdateLog.write(`Staged update startup confirmed version=${version}`)
+}

package/src/parts/WindowsUpdateScripts/WindowsUpdateScripts.js

@@ -0,0 +1,123 @@
+// Executed by Windows PowerShell outside the directory being replaced. All
+// variable input is read from a JSON plan, never interpolated into PowerShell.
+export const activate = String.raw`
+$ErrorActionPreference = 'Stop'
+$plan = Get-Content -LiteralPath $env:LVCE_UPDATE_PLAN -Raw | ConvertFrom-Json
+$install = [IO.Path]::GetFullPath($plan.install)
+$stage = [IO.Path]::GetFullPath($plan.stage)
+$backup = [IO.Path]::GetFullPath($plan.backup)
+$parent = Split-Path -Parent $install
+if ((Split-Path -Parent $stage) -ne $parent -or (Split-Path -Parent $backup) -ne $parent) { throw 'Update folders must be siblings' }
+if ($stage -eq $install -or $backup -eq $install -or $stage -eq $backup) { throw 'Update folders must be distinct' }
+if ((Split-Path -Leaf $stage) -ne ((Split-Path -Leaf $install) + '.stage-' + $plan.token)) { throw 'Invalid stage path' }
+if ((Split-Path -Leaf $backup) -ne ((Split-Path -Leaf $install) + '.backup-' + $plan.token)) { throw 'Invalid backup path' }
+if ($plan.token -notmatch '^[a-f0-9]{32}$') { throw 'Invalid update token' }
+Set-Location -LiteralPath $parent
+function Log($message) {
+  $line = [DateTime]::UtcNow.ToString('o') + ' [windows-swap] ' + $message + [Environment]::NewLine
+  [IO.File]::AppendAllText($plan.log, $line)
+}
+function Journal($phase) {
+  [IO.File]::WriteAllText($env:LVCE_UPDATE_PLAN + '.state', $phase)
+  Log $phase
+}
+function MoveFolder($from, $to) {
+  for ($attempt=0; $attempt -lt 50; $attempt++) {
+    try { [IO.Directory]::Move($from, $to); return } catch {
+      if ($attempt -eq 49) { throw }
+      Start-Sleep -Milliseconds 100
+    }
+  }
+}
+$movedOld = $false
+$movedNew = $false
+$editorExited = $false
+$newProcess = $null
+try {
+  Journal 'helper-ready'
+  [IO.File]::WriteAllText($env:LVCE_UPDATE_PLAN + '.started', 'ready')
+  # The application exits only after the helper acknowledges startup. Never
+  # kill an editor that refuses to exit, for example with an unsaved document.
+  $deadline = [DateTime]::UtcNow.AddSeconds(60)
+  while (Get-Process -Id $plan.parentPid -ErrorAction SilentlyContinue) {
+    if ([DateTime]::UtcNow -gt $deadline) { throw 'Editor did not exit; installation left intact' }
+    Start-Sleep -Milliseconds 100
+  }
+  Journal 'editor-exited'
+  $editorExited = $true
+  # Rerunning the saved helper after interruption restores a missing install.
+  if (!(Test-Path -LiteralPath $install) -and (Test-Path -LiteralPath $backup)) {
+    MoveFolder $backup $install
+    throw 'Recovered previous installation; retry the update'
+  }
+  if (Test-Path -LiteralPath $backup) { throw 'Backup already exists; recovery required' }
+  $config = Get-Content -LiteralPath (Join-Path $stage 'resources/app/config.json') -Raw | ConvertFrom-Json
+  if ($config.version -ne $plan.version) { throw 'Staged version does not match update plan' }
+  Journal 'moving-old'
+  MoveFolder $install $backup
+  $movedOld = $true
+  Journal 'moving-new'
+  MoveFolder $stage $install
+  $movedNew = $true
+  Journal 'launching-new'
+  $newProcess = Start-Process -FilePath (Join-Path $install $plan.exe) -ArgumentList '--updated' -WorkingDirectory $install -PassThru -WindowStyle Hidden
+  $deadline = [DateTime]::UtcNow.AddSeconds(60)
+  while (!(Test-Path -LiteralPath $plan.ready)) {
+    $newProcess.Refresh()
+    if ($newProcess.HasExited) { throw 'Updated application exited before confirming startup' }
+    if ([DateTime]::UtcNow -gt $deadline) { throw 'Updated application did not confirm startup' }
+    Start-Sleep -Milliseconds 100
+  }
+  if ((Get-Content -LiteralPath $plan.ready -Raw) -ne $plan.token) { throw 'Invalid startup acknowledgment' }
+  Journal 'startup-confirmed'
+  try {
+    Get-ChildItem 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall' | ForEach-Object {
+      $entry = Get-ItemProperty -LiteralPath $_.PSPath
+      if ($entry.InstallLocation -and $entry.InstallLocation.TrimEnd('\') -eq $install.TrimEnd('\')) {
+        Set-ItemProperty -LiteralPath $_.PSPath -Name DisplayVersion -Value $plan.version
+      }
+    }
+  } catch { Log ('Could not refresh installed version metadata: ' + $_.Exception.Message) }
+  # Keep rollback files until after startup, outside the user-visible outage.
+  Start-Sleep -Seconds 5
+  $newProcess.Refresh()
+  if ($newProcess.HasExited) { throw 'Updated application exited during startup' }
+  Journal 'cleanup-started'
+  try {
+    Remove-Item -LiteralPath $backup -Recurse -Force
+    if ($plan.archive -eq (Join-Path ($install + '.updates') ($plan.token + '.zip'))) {
+      Remove-Item -LiteralPath $plan.archive -Force -ErrorAction SilentlyContinue
+    }
+    Journal 'complete'
+  }
+  catch { Log ('Cleanup deferred; backup retained: ' + $_.Exception.Message) }
+} catch {
+  Log ('Update failed: ' + $_.Exception.Message)
+  if ($movedOld) {
+    if ($newProcess -and !$newProcess.HasExited) {
+      & taskkill.exe /PID $newProcess.Id /T /F | Out-Null
+    }
+    try {
+      if ($movedNew) { MoveFolder $install $stage }
+      MoveFolder $backup $install
+      Journal 'rolled-back'
+      Start-Process -FilePath (Join-Path $install $plan.exe) -WorkingDirectory $install -WindowStyle Hidden
+    } catch { Log ('Recovery required; previous installation preserved at ' + $backup + ': ' + $_.Exception.Message) }
+  } elseif ($editorExited -and (Test-Path -LiteralPath (Join-Path $install $plan.exe))) {
+    # A locked old folder or rejected plan must not leave the user without the
+    # still-intact editor after the requested shutdown.
+    try { Start-Process -FilePath (Join-Path $install $plan.exe) -WorkingDirectory $install -WindowStyle Hidden }
+    catch { Log ('Could not relaunch previous installation: ' + $_.Exception.Message) }
+  }
+  exit 1
+}
+`
+
+export const extract = String.raw`
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+$plan = Get-Content -LiteralPath $env:LVCE_UPDATE_PLAN -Raw | ConvertFrom-Json
+# ExtractToDirectory rejects entries outside the destination and does not
+# overwrite existing files. Preparation never modifies the running app.
+[IO.Compression.ZipFile]::ExtractToDirectory($plan.archive, $plan.stage)
+`