livedesk 0.1.667 → 0.1.669

package/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/client",
-  "version": "0.1.272",
+  "version": "0.1.273",
   "description": "VuvoDesk local remote client",
   "type": "module",
   "bin": {
@@ -42,10 +42,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.467",
-    "@livedesk/fast-osx-arm64": "0.1.467",
-    "@livedesk/fast-osx-x64": "0.1.467",
-    "@livedesk/fast-win-x64": "0.1.467"
+    "@livedesk/fast-linux-x64": "0.1.468",
+    "@livedesk/fast-osx-arm64": "0.1.468",
+    "@livedesk/fast-osx-x64": "0.1.468",
+    "@livedesk/fast-win-x64": "0.1.468"
   },
   "publishConfig": {
     "access": "public"

package/electron/bounded-multipart-range-batching.mjs

@@ -0,0 +1,407 @@
+import { createReadStream } from 'node:fs';
+import { createRequire } from 'node:module';
+import { PassThrough } from 'node:stream';
+
+const require = createRequire(import.meta.url);
+
+export const SUPPORTED_ELECTRON_UPDATER_VERSION = '6.8.9';
+export const MAX_MULTIPART_RANGE_COUNT = 48;
+export const MAX_MULTIPART_RANGE_BYTES = 32 * 1024 * 1024;
+
+const COPY_OPERATION_KIND = 0;
+const DOWNLOAD_OPERATION_KIND = 1;
+const PATCH_MARKER = Symbol.for('vuvodesk.bounded-multipart-range-batching.patch');
+const UPDATER_CAPABILITY = Symbol.for('vuvodesk.bounded-multipart-range-batching.capability');
+
+function operationLength(task) {
+  const start = Number(task?.start);
+  const end = Number(task?.end);
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end <= start) {
+    throw new Error('desktop-update-invalid-differential-operation-range');
+  }
+  if (task.kind !== COPY_OPERATION_KIND && task.kind !== DOWNLOAD_OPERATION_KIND) {
+    throw new Error('desktop-update-invalid-differential-operation-kind');
+  }
+  return end - start;
+}
+
+export function planBoundedMultipartRangeBatches(tasks) {
+  if (!Array.isArray(tasks)) throw new Error('desktop-update-invalid-differential-plan');
+  if (tasks.length === 0) return [];
+
+  const batches = [];
+  let start = 0;
+  let rangeCount = 0;
+  let downloadBytes = 0;
+
+  const commit = end => {
+    if (end <= start) return;
+    batches.push({
+      start,
+      end,
+      rangeCount,
+      downloadBytes,
+      useMultipart: rangeCount > 1
+    });
+    start = end;
+    rangeCount = 0;
+    downloadBytes = 0;
+  };
+
+  for (let index = 0; index < tasks.length; index += 1) {
+    const task = tasks[index];
+    const length = operationLength(task);
+    if (task.kind !== DOWNLOAD_OPERATION_KIND) continue;
+
+    const exceedsCount = rangeCount >= MAX_MULTIPART_RANGE_COUNT;
+    const exceedsBytes = rangeCount > 0 && downloadBytes + length > MAX_MULTIPART_RANGE_BYTES;
+    if (exceedsCount || exceedsBytes) commit(index);
+
+    rangeCount += 1;
+    downloadBytes += length;
+  }
+  commit(tasks.length);
+
+  return batches;
+}
+
+function createProgressReporter(differentialDownloader, totalBytes) {
+  const onProgress = differentialDownloader.options?.onProgress;
+  const startedAt = Date.now();
+  let transferred = 0;
+
+  return nextTransferred => {
+    if (typeof onProgress !== 'function' || totalBytes <= 0) return;
+    const next = Math.max(transferred, Math.min(totalBytes, Number(nextTransferred) || 0));
+    const delta = next - transferred;
+    transferred = next;
+    const elapsedSeconds = Math.max(0.001, (Date.now() - startedAt) / 1000);
+    onProgress({
+      total: totalBytes,
+      delta,
+      transferred,
+      percent: (transferred / totalBytes) * 100,
+      bytesPerSecond: Math.round(transferred / elapsedSeconds)
+    });
+  };
+}
+
+function createExecutor({ DataSplitter, checkIsRangesSupported, CancellationError, safeGetHeader }) {
+  return function executeTasksUsingBoundedMultipartRangeRequests(
+    differentialDownloader,
+    tasks,
+    out,
+    oldFileFd,
+    reject
+  ) {
+    const batches = planBoundedMultipartRangeBatches(tasks);
+    const totalRangeCount = batches.reduce((total, batch) => total + batch.rangeCount, 0);
+    const totalDownloadBytes = batches.reduce((total, batch) => total + batch.downloadBytes, 0);
+    const reportProgress = createProgressReporter(differentialDownloader, totalDownloadBytes);
+    const cancellationToken = differentialDownloader.options?.cancellationToken;
+    const logger = differentialDownloader.logger;
+    const outputGate = new PassThrough();
+    outputGate.pipe(out, { end: false });
+
+    let started = false;
+    let active = true;
+    let batchIndex = 0;
+    let completedDownloadBytes = 0;
+    let currentRequest = null;
+    let currentResponse = null;
+    let currentCopyStream = null;
+    let currentSplitter = null;
+    let currentPostResponseTimer = null;
+
+    logger?.info?.(
+      `Differential range batching: ranges=${totalRangeCount}, batches=${batches.length}, `
+      + `downloadBytes=${totalDownloadBytes}, maxRanges=${MAX_MULTIPART_RANGE_COUNT}, `
+      + `maxBytes=${MAX_MULTIPART_RANGE_BYTES}`
+    );
+
+    const removeCancellationListener = () => {
+      if (typeof cancellationToken?.removeListener === 'function') {
+        cancellationToken.removeListener('cancel', cancelCurrentOwner);
+      }
+    };
+
+    const stopCurrentResources = () => {
+      try { currentRequest?.abort?.(); } catch { /* already terminal */ }
+      try { currentResponse?.destroy?.(); } catch { /* already terminal */ }
+      try { currentCopyStream?.destroy?.(); } catch { /* already terminal */ }
+      try { currentSplitter?.destroy?.(); } catch { /* already terminal */ }
+      if (currentPostResponseTimer) clearTimeout(currentPostResponseTimer);
+      currentRequest = null;
+      currentResponse = null;
+      currentCopyStream = null;
+      currentSplitter = null;
+      currentPostResponseTimer = null;
+    };
+
+    const rejectCurrentOwner = error => {
+      if (!active) return;
+      active = false;
+      removeCancellationListener();
+      stopCurrentResources();
+      outputGate.unpipe(out);
+      outputGate.destroy();
+      reject(error);
+    };
+
+    function cancelCurrentOwner() {
+      rejectCurrentOwner(new CancellationError());
+    }
+
+    const finishOutput = () => {
+      if (!active) return;
+      active = false;
+      removeCancellationListener();
+      if (differentialDownloader.fileMetadataBuffer != null) {
+        out.write(differentialDownloader.fileMetadataBuffer);
+      }
+      out.end();
+    };
+
+    const finishTasks = () => {
+      if (!active) return;
+      outputGate.once('end', finishOutput);
+      outputGate.end();
+    };
+
+    const executeSingleRangeBatch = (batch, resolveBatch) => {
+      let index = batch.start;
+      let batchTransferred = 0;
+      let lastProgressAt = Date.now();
+
+      const next = () => {
+        if (!active) return;
+        if (cancellationToken?.cancelled) {
+          cancelCurrentOwner();
+          return;
+        }
+        if (index >= batch.end) {
+          reportProgress(completedDownloadBytes + batch.downloadBytes);
+          resolveBatch();
+          return;
+        }
+
+        const task = tasks[index++];
+        const expectedLength = operationLength(task);
+        if (task.kind === COPY_OPERATION_KIND) {
+          const readStream = createReadStream('', {
+            fd: oldFileFd,
+            autoClose: false,
+            start: task.start,
+            end: task.end - 1
+          });
+          currentCopyStream = readStream;
+          readStream.once('error', rejectCurrentOwner);
+          readStream.once('end', () => {
+            if (currentCopyStream === readStream) currentCopyStream = null;
+            next();
+          });
+          readStream.pipe(outputGate, { end: false });
+          return;
+        }
+
+        const requestOptions = differentialDownloader.createRequestOptions();
+        requestOptions.headers.Range = `bytes=${task.start}-${task.end - 1}`;
+        const request = differentialDownloader.httpExecutor.createRequest(requestOptions, response => {
+          if (!active) {
+            response.destroy?.();
+            return;
+          }
+          currentResponse = response;
+          let received = 0;
+          response.once('error', rejectCurrentOwner);
+          response.once('aborted', () => rejectCurrentOwner(new Error('desktop-update-range-response-aborted')));
+          if (!checkIsRangesSupported(response, rejectCurrentOwner)) return;
+          response.on('data', chunk => {
+            received += chunk.length;
+            batchTransferred += chunk.length;
+            const now = Date.now();
+            if (now - lastProgressAt >= 1_000) {
+              lastProgressAt = now;
+              reportProgress(completedDownloadBytes + batchTransferred);
+            }
+          });
+          response.pipe(outputGate, { end: false });
+          response.once('end', () => {
+            if (!active) return;
+            if (received !== expectedLength) {
+              rejectCurrentOwner(new Error('desktop-update-range-length-mismatch'));
+              return;
+            }
+            if (currentRequest === request) currentRequest = null;
+            if (currentResponse === response) currentResponse = null;
+            reportProgress(completedDownloadBytes + batchTransferred);
+            next();
+          });
+        });
+        currentRequest = request;
+        differentialDownloader.httpExecutor.addErrorAndTimeoutHandlers(request, rejectCurrentOwner);
+        request.end();
+      };
+
+      next();
+    };
+
+    const executeMultipartBatch = (batch, resolveBatch) => {
+      const partIndexToTaskIndex = new Map();
+      const partIndexToLength = [];
+      const ranges = [];
+      let partIndex = 0;
+
+      for (let index = batch.start; index < batch.end; index += 1) {
+        const task = tasks[index];
+        if (task.kind !== DOWNLOAD_OPERATION_KIND) continue;
+        ranges.push(`${task.start}-${task.end - 1}`);
+        partIndexToTaskIndex.set(partIndex, index);
+        partIndexToLength.push(operationLength(task));
+        partIndex += 1;
+      }
+
+      const requestOptions = differentialDownloader.createRequestOptions();
+      requestOptions.headers.Range = `bytes=${ranges.join(', ')}`;
+      const request = differentialDownloader.httpExecutor.createRequest(requestOptions, response => {
+        if (!active) {
+          response.destroy?.();
+          return;
+        }
+        currentResponse = response;
+        let parsed = false;
+        let responseEnded = false;
+
+        const settleIfComplete = () => {
+          if (!active || !parsed || !responseEnded) return;
+          if (currentPostResponseTimer) clearTimeout(currentPostResponseTimer);
+          currentPostResponseTimer = null;
+          if (currentRequest === request) currentRequest = null;
+          if (currentResponse === response) currentResponse = null;
+          currentSplitter = null;
+          reportProgress(completedDownloadBytes + batch.downloadBytes);
+          resolveBatch();
+        };
+
+        response.once('error', rejectCurrentOwner);
+        response.once('aborted', () => rejectCurrentOwner(new Error('desktop-update-multipart-response-aborted')));
+        if (!checkIsRangesSupported(response, rejectCurrentOwner)) return;
+        const contentType = String(safeGetHeader(response, 'content-type') || '');
+        const match = /^multipart\/.+?\s*;\s*boundary=(?:"([^"]+)"|([^\s";]+))\s*$/i.exec(contentType);
+        if (!match) {
+          rejectCurrentOwner(new Error('desktop-update-multipart-content-type-invalid'));
+          return;
+        }
+
+        const batchProgress = progress => {
+          reportProgress(completedDownloadBytes + Math.min(batch.downloadBytes, Number(progress?.transferred) || 0));
+        };
+        const splitter = new DataSplitter(
+          outputGate,
+          { tasks, start: batch.start, end: batch.end, oldFileFd },
+          partIndexToTaskIndex,
+          match[1] || match[2],
+          partIndexToLength,
+          () => {
+            parsed = true;
+            settleIfComplete();
+          },
+          batch.downloadBytes,
+          batchProgress
+        );
+        currentSplitter = splitter;
+        splitter.once('error', rejectCurrentOwner);
+        response.pipe(splitter);
+        response.once('end', () => {
+          responseEnded = true;
+          if (!parsed) {
+            currentPostResponseTimer = setTimeout(() => {
+              rejectCurrentOwner(new Error('desktop-update-multipart-response-incomplete'));
+            }, 10_000);
+            currentPostResponseTimer.unref?.();
+          }
+          settleIfComplete();
+        });
+      });
+      currentRequest = request;
+      differentialDownloader.httpExecutor.addErrorAndTimeoutHandlers(request, rejectCurrentOwner);
+      request.end();
+    };
+
+    const runNextBatch = () => {
+      if (!active) return;
+      if (cancellationToken?.cancelled) {
+        cancelCurrentOwner();
+        return;
+      }
+      if (batchIndex >= batches.length) {
+        finishTasks();
+        return;
+      }
+
+      const batch = batches[batchIndex++];
+      let batchSettled = false;
+      const resolveBatch = () => {
+        if (!active || batchSettled) return;
+        batchSettled = true;
+        completedDownloadBytes += batch.downloadBytes;
+        runNextBatch();
+      };
+      if (batch.useMultipart) executeMultipartBatch(batch, resolveBatch);
+      else executeSingleRangeBatch(batch, resolveBatch);
+    };
+
+    if (typeof cancellationToken?.onCancel === 'function') {
+      cancellationToken.onCancel(cancelCurrentOwner);
+    } else if (typeof cancellationToken?.once === 'function') {
+      cancellationToken.once('cancel', cancelCurrentOwner);
+    }
+
+    return taskOffset => {
+      if (started) {
+        rejectCurrentOwner(new Error('desktop-update-range-batching-already-started'));
+        return;
+      }
+      started = true;
+      if (taskOffset !== 0) {
+        rejectCurrentOwner(new Error('desktop-update-range-batching-invalid-start'));
+        return;
+      }
+      runNextBatch();
+    };
+  };
+}
+
+export function installBoundedMultipartRangeBatching() {
+  const packageInfo = require('electron-updater/package.json');
+  if (packageInfo.version !== SUPPORTED_ELECTRON_UPDATER_VERSION) {
+    throw new Error(
+      `desktop-update-range-batching-unsupported-electron-updater:${packageInfo.version || 'unknown'}`
+    );
+  }
+
+  const multipleRangeDownloader = require('electron-updater/out/differentialDownloader/multipleRangeDownloader');
+  if (multipleRangeDownloader.executeTasksUsingMultipleRangeRequests?.[PATCH_MARKER]) return true;
+
+  const { DataSplitter } = require('electron-updater/out/differentialDownloader/DataSplitter');
+  const { CancellationError, safeGetHeader } = require('builder-util-runtime');
+  const replacement = createExecutor({
+    DataSplitter,
+    checkIsRangesSupported: multipleRangeDownloader.checkIsRangesSupported,
+    CancellationError,
+    safeGetHeader
+  });
+  Object.defineProperty(replacement, PATCH_MARKER, { value: true });
+  multipleRangeDownloader.executeTasksUsingMultipleRangeRequests = replacement;
+  return true;
+}
+
+export function markUpdaterWithBoundedMultipartRangeBatching(updater) {
+  if (!updater) return updater;
+  Object.defineProperty(updater, UPDATER_CAPABILITY, { value: true });
+  return updater;
+}
+
+export function supportsBoundedMultipartRangeBatching(updater) {
+  return Boolean(updater?.[UPDATER_CAPABILITY]);
+}

package/electron/update-manager.mjs

@@ -3,6 +3,11 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { EventEmitter } from 'node:events';
 import { resolveDesktopUpdateFeed } from './update-feed-resolver.mjs';
+import {
+  installBoundedMultipartRangeBatching,
+  markUpdaterWithBoundedMultipartRangeBatching,
+  supportsBoundedMultipartRangeBatching
+} from './bounded-multipart-range-batching.mjs';
 
 const require = createRequire(import.meta.url);
 
@@ -14,7 +19,22 @@ const MINIMUM_DEADLINE_MS = 10;
 
 export function createPlatformProductUpdater(platform = process.platform) {
   const module = require('electron-updater');
-  if (platform === 'win32') return new module.NsisUpdater();
+  if (platform === 'win32') {
+    let boundedMultipartReady = false;
+    let boundedMultipartError = null;
+    try {
+      boundedMultipartReady = installBoundedMultipartRangeBatching();
+    } catch (error) {
+      boundedMultipartError = error;
+    }
+    const updater = new module.NsisUpdater();
+    if (boundedMultipartReady) return markUpdaterWithBoundedMultipartRangeBatching(updater);
+    updater.logger?.warn?.(
+      `Bounded differential range batching unavailable; using single-range requests: `
+      + `${boundedMultipartError?.message || 'unknown'}`
+    );
+    return updater;
+  }
   if (platform === 'darwin') return new module.MacUpdater();
   try {
     const packageType = String(readFileSync(join(process.resourcesPath, 'package-type'), 'utf8')).trim();
@@ -399,13 +419,14 @@ export function createProductUpdateManager({
     candidate.autoDownload = false;
     candidate.autoInstallOnAppQuit = true;
     if (feed.url) {
-      // R2 exposes one byte range per read. Keep current clients on simple
-      // single-range differential requests; the Worker retains bounded
-      // multipart compatibility for already-installed older versions.
+      // Enable multipart reads only for the exact supported electron-updater
+      // implementation patched with VuvoDesk's 48-range/32 MiB batch owner.
+      // Injected, replaced, or unsupported updater instances stay on the safe
+      // single-range path.
       candidate.setFeedURL({
         provider: 'generic',
         url: feed.url,
-        useMultipleRangeRequest: false
+        useMultipleRangeRequest: supportsBoundedMultipartRangeBatching(candidate)
       });
     }
     for (const eventName of forwardedUpdaterEvents) {

package/hub/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.67",
+  "version": "0.1.68",
   "description": "VuvoDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",