@mindexec/cli 0.2.460 → 0.2.462

package/electron/update-manager.cjs

@@ -0,0 +1,297 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { resolveDesktopUpdateFeed } = require('./update-feed-resolver.cjs');
+
+function createProductUpdateManager({
+  app,
+  onStatus = () => undefined,
+  beforeInstall = async () => undefined,
+  onInstallError = async () => undefined,
+  updater = null,
+  platform = process.platform,
+  arch = process.arch,
+  installKind = 'installed',
+  startupCheckTimeoutMs = 2_500,
+  updateFeedConfig = null,
+  updateChannel = '',
+  overrideUrl = process.env.MINDEXEC_UPDATE_URL || ''
+} = {}) {
+  if (!app) throw new TypeError('desktop-update-app-required');
+  if (!updater) updater = require('electron-updater').autoUpdater;
+
+  let feedConfig = updateFeedConfig;
+  let packageMetadata = {};
+  try {
+    packageMetadata = JSON.parse(fs.readFileSync(path.join(app.getAppPath(), 'package.json'), 'utf8'));
+  } catch {
+    packageMetadata = {};
+  }
+  if (!feedConfig) {
+    try {
+      feedConfig = JSON.parse(fs.readFileSync(path.join(app.getAppPath(), 'electron', 'update-feed.json'), 'utf8'));
+    } catch {
+      feedConfig = {};
+    }
+  }
+
+  const packagedChannel = String(updateChannel || packageMetadata?.desktopUpdateChannel || '')
+    .trim()
+    .toLowerCase();
+  if (packagedChannel) feedConfig = { ...feedConfig, channel: packagedChannel };
+  const feed = resolveDesktopUpdateFeed({ config: feedConfig, overrideUrl, platform, arch });
+  const updateSupported = Boolean(app.isPackaged && installKind === 'installed' && platform === 'win32');
+
+  let status = {
+    state: 'idle',
+    currentVersion: app.getVersion(),
+    availableVersion: '',
+    downloaded: false,
+    progress: 0,
+    error: '',
+    configured: feed.configured,
+    feedUrl: feed.url,
+    channel: feed.channel,
+    platform: feed.platform,
+    arch: feed.arch,
+    installKind,
+    updateSupported,
+    startupCheck: 'idle'
+  };
+  let installPromise = null;
+  let checkPromise = null;
+  let downloadPromise = null;
+  let cyclePromise = null;
+  let startupPromise = null;
+  let checkOutcome = 'idle';
+  let installRuntimePreparationStarted = false;
+  let installRecoveryPromise = null;
+
+  const publish = patch => {
+    status = { ...status, ...patch };
+    onStatus({ ...status });
+  };
+  const snapshot = () => ({ ...status, packaged: Boolean(app.isPackaged) });
+  const recoverPreparedRuntime = error => {
+    if (!installRuntimePreparationStarted) return Promise.resolve();
+    installRuntimePreparationStarted = false;
+    if (!installRecoveryPromise) {
+      installRecoveryPromise = Promise.resolve(onInstallError(error))
+        .catch(() => undefined)
+        .finally(() => {
+          installRecoveryPromise = null;
+          if (status.state === 'error') installPromise = null;
+        });
+    }
+    return installRecoveryPromise;
+  };
+
+  updater.autoDownload = false;
+  updater.autoInstallOnAppQuit = false;
+  if (feed.url) updater.setFeedURL({ provider: 'generic', url: feed.url });
+
+  updater.on('checking-for-update', () => {
+    checkOutcome = 'checking';
+    publish({ state: 'checking', error: '' });
+  });
+  updater.on('update-available', info => {
+    checkOutcome = 'available';
+    publish({
+      state: 'available',
+      availableVersion: String(info?.version || ''),
+      downloaded: false,
+      progress: 0,
+      error: ''
+    });
+  });
+  updater.on('update-not-available', () => {
+    checkOutcome = 'current';
+    publish({ state: 'current', availableVersion: '', downloaded: false, progress: 0, error: '' });
+  });
+  updater.on('download-progress', progress => {
+    publish({ state: 'downloading', progress: Number(progress?.percent || 0), error: '' });
+  });
+  updater.on('update-downloaded', info => {
+    publish({
+      state: 'downloaded',
+      downloaded: true,
+      progress: 100,
+      availableVersion: String(info?.version || status.availableVersion || ''),
+      error: ''
+    });
+  });
+  updater.on('error', error => {
+    checkOutcome = 'error';
+    publish({ state: 'error', error: String(error?.message || error) });
+    void recoverPreparedRuntime(error);
+  });
+
+  const blockedStatus = () => {
+    if (!app.isPackaged) {
+      return { ...snapshot(), state: 'development', error: 'desktop-updates-require-packaged-app' };
+    }
+    if (!updateSupported) {
+      return { ...snapshot(), state: 'unsupported', error: 'desktop-updates-require-installed-windows-app' };
+    }
+    return null;
+  };
+  const unavailableStatus = () => ({
+    ...snapshot(),
+    state: 'unavailable',
+    error: feed.error || 'desktop-update-feed-not-configured'
+  });
+
+  const checkForUpdates = async () => {
+    const blocked = blockedStatus();
+    if (blocked) return blocked;
+    if (!feed.url) return unavailableStatus();
+    if (checkPromise) return checkPromise;
+
+    const operation = (async () => {
+      checkOutcome = 'checking';
+      publish({ state: 'checking', error: '' });
+      try {
+        const result = await updater.checkForUpdates();
+        if (checkOutcome === 'checking') {
+          const availableVersion = String(result?.updateInfo?.version || status.availableVersion || '');
+          const updateAvailable = Boolean(availableVersion && availableVersion !== app.getVersion());
+          checkOutcome = updateAvailable ? 'available' : 'current';
+          publish({
+            state: checkOutcome,
+            availableVersion: updateAvailable ? availableVersion : '',
+            downloaded: updateAvailable ? status.downloaded : false,
+            progress: updateAvailable ? status.progress : 0,
+            error: ''
+          });
+        }
+      } catch (error) {
+        checkOutcome = 'error';
+        publish({ state: 'error', error: String(error?.message || error) });
+      }
+      return snapshot();
+    })();
+    checkPromise = operation;
+    try {
+      return await operation;
+    } finally {
+      if (checkPromise === operation) checkPromise = null;
+    }
+  };
+
+  const downloadUpdate = async () => {
+    const blocked = blockedStatus();
+    if (blocked) return blocked;
+    if (!feed.url) return unavailableStatus();
+    if (status.downloaded) return snapshot();
+    if (downloadPromise) return downloadPromise;
+
+    const operation = (async () => {
+      try {
+        publish({ state: 'downloading', progress: Math.max(0, Number(status.progress || 0)), error: '' });
+        await updater.downloadUpdate();
+        if (!status.downloaded) {
+          publish({ state: 'downloaded', downloaded: true, progress: 100, error: '' });
+        }
+      } catch (error) {
+        publish({ state: 'error', error: String(error?.message || error) });
+      }
+      return snapshot();
+    })();
+    downloadPromise = operation;
+    try {
+      return await operation;
+    } finally {
+      if (downloadPromise === operation) downloadPromise = null;
+    }
+  };
+
+  const checkAndDownload = async () => {
+    if (cyclePromise) return cyclePromise;
+    const operation = (async () => {
+      const checked = await checkForUpdates();
+      if (checked.state === 'available') return downloadUpdate();
+      return checked;
+    })();
+    cyclePromise = operation;
+    try {
+      return await operation;
+    } finally {
+      if (cyclePromise === operation) cyclePromise = null;
+    }
+  };
+
+  return {
+    getStatus() {
+      return snapshot();
+    },
+    async check() {
+      return checkAndDownload();
+    },
+    async checkAtStartup() {
+      if (startupPromise) return startupPromise;
+      const operation = (async () => {
+        const blocked = blockedStatus();
+        if (blocked || !feed.url) return checkForUpdates();
+
+        publish({ startupCheck: 'checking' });
+        const background = checkAndDownload().finally(() => {
+          publish({ startupCheck: 'complete' });
+        });
+        let timeoutId;
+        const timeout = new Promise(resolve => {
+          timeoutId = setTimeout(
+            () => resolve('timeout'),
+            Math.max(10, Number(startupCheckTimeoutMs) || 2_500)
+          );
+          timeoutId.unref?.();
+        });
+        const result = await Promise.race([background, timeout]);
+        clearTimeout(timeoutId);
+        if (result === 'timeout') {
+          publish({ startupCheck: 'timed-out' });
+          return snapshot();
+        }
+        return result;
+      })();
+      startupPromise = operation;
+      try {
+        return await operation;
+      } finally {
+        if (startupPromise === operation) startupPromise = null;
+      }
+    },
+    async install() {
+      const blocked = blockedStatus();
+      if (blocked) return blocked;
+      if (!feed.url) return unavailableStatus();
+      if (installPromise) return installPromise;
+
+      const operation = (async () => {
+        try {
+          if (!status.downloaded) {
+            const downloadResult = await downloadUpdate();
+            if (!downloadResult.downloaded) return downloadResult;
+          }
+          installRuntimePreparationStarted = true;
+          await beforeInstall();
+          publish({ state: 'installing', error: '' });
+          updater.quitAndInstall(true, true);
+          return snapshot();
+        } catch (error) {
+          await recoverPreparedRuntime(error);
+          publish({ state: 'error', error: String(error?.message || error) });
+          return snapshot();
+        }
+      })();
+      installPromise = operation;
+      try {
+        return await operation;
+      } finally {
+        if (installPromise === operation && status.state !== 'installing') installPromise = null;
+      }
+    }
+  };
+}
+
+module.exports = { createProductUpdateManager };

package/electron/windows-package-smoke.mjs

@@ -129,6 +129,8 @@ try {
   assert.equal(result.bridgePort, bridgePort, 'Packaged shell did not use the requested Bridge port.');
   assert.equal(result.remoteHubPort, remoteHubPort, 'Packaged shell did not use the requested RemoteHub port.');
   assert.equal(path.resolve(result.workspace), path.resolve(workspace), 'Packaged Electron did not restore the saved workspace.');
+  assert.equal(result.desktopUpdate?.installKind, 'unpacked', 'The unpacked EXE must identify its non-self-updating package kind.');
+  assert.equal(result.desktopUpdate?.updateSupported, false, 'The unpacked EXE must never replace itself.');
 
   const exitCode = await waitForExit(child, 15_000);
   assert.equal(exitCode, 0, `Packaged Electron smoke exited with code ${exitCode}.`);
@@ -142,6 +144,7 @@ try {
     executablePath,
     version: result.appVersion,
     runtimeMode: result.runtimeMode,
+    desktopUpdateKind: result.desktopUpdate.installKind,
     bridgePortReleased: true,
     remoteHubPortReleased: true
   }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.460",
+  "version": "0.2.462",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -27,11 +27,16 @@
   "scripts": {
     "start": "node launch-bridge.cjs",
     "dev": "node launch-bridge.cjs --watch",
-    "desktop:start": "electron electron/main.cjs",
-    "desktop:build:win": "electron-builder --win --x64 --publish never",
-    "test:desktop": "node electron/source-smoke.mjs && node scripts/desktop-workspace-state-smoke.mjs",
+    "desktop:start": "electron electron/main.cjs",
+    "desktop:build:win": "electron-builder --win --x64 --publish never",
+    "desktop:inspect:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned",
+    "desktop:publish:update:dev": "node scripts/publish-mindexec-desktop-updates.mjs --channel dev --platform windows-x64 --dir ../artifacts/electron --allow-unsigned --publish",
+    "desktop:deploy:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
+    "desktop:check:update-worker": "node ../r2-auth-proxy/node_modules/wrangler/wrangler-dist/cli.js deploy --dry-run --config ../workers/mindexec-desktop-updates/wrangler.jsonc",
+    "test:desktop:update": "node --test electron/update-manager-smoke.mjs electron/recurring-update-owner-smoke.mjs scripts/desktop-update-worker-smoke.mjs scripts/desktop-update-publisher-smoke.mjs",
+    "test:desktop": "node electron/source-smoke.mjs && node scripts/desktop-workspace-state-smoke.mjs && npm run test:desktop:update",
     "test:desktop:win": "node electron/windows-package-smoke.mjs",
-    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check lzo1x.js && node --check mode4-atlas.js && node --check mode4-atlas-worker.js && node --check codex-runtime.js && node --check codex-model-catalog.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check desktop-workspace-state.cjs && node --check electron/main.cjs && node --check electron/source-smoke.mjs && node --check electron/windows-package-smoke.mjs && node --check scripts/desktop-workspace-state-smoke.mjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/npm-fresh-install-smoke.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/codex-model-catalog-smoke.mjs && node --check scripts/codex-sdk-runtime-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
+    "test:syntax": "node --check server.js && node --check remote-hub.js && node --check lzo1x.js && node --check mode4-atlas.js && node --check mode4-atlas-worker.js && node --check codex-runtime.js && node --check codex-model-catalog.js && node --check launch-bridge.cjs && node --check port-guard.cjs && node --check desktop-workspace-state.cjs && node --check electron/main.cjs && node --check electron/preload.cjs && node --check electron/update-manager.cjs && node --check electron/update-feed-resolver.cjs && node --check electron/recurring-update-owner.cjs && node --check electron/source-smoke.mjs && node --check electron/windows-package-smoke.mjs && node --check electron/update-manager-smoke.mjs && node --check electron/recurring-update-owner-smoke.mjs && node --check scripts/desktop-workspace-state-smoke.mjs && node --check scripts/desktop-update-worker-smoke.mjs && node --check scripts/desktop-update-publisher-smoke.mjs && node --check scripts/publish-mindexec-desktop-updates.mjs && node --check ../workers/mindexec-desktop-updates/src/index.mjs && node --check scripts/setup-tree-sitter-grammars.mjs && node --check scripts/npm-fresh-install-smoke.mjs && node --check scripts/auth-session-smoke.mjs && node --check scripts/codex-model-catalog-smoke.mjs && node --check scripts/codex-sdk-runtime-smoke.mjs && node --check scripts/remote-hub-smoke.mjs && node --check scripts/remote-hub-scale-smoke.mjs && node --check scripts/remote-fleet-render-smoke.mjs && node --check scripts/remote-http-smoke.mjs && node --check scripts/remote-frame-ws-smoke.mjs && node --check scripts/remote-input-ws-smoke.mjs && node --check scripts/remote-agent-ws-smoke.mjs && node --check scripts/remote-agent-managed-smoke.mjs && node --check scripts/remote-registry-follower-smoke.mjs && node --check scripts/remote-agent-package-smoke.mjs && node --check scripts/remote-fast-live-rate-smoke.mjs && node --check scripts/remote-fast-mdm-browser-smoke.mjs",
     "test:codex-sdk": "node scripts/codex-sdk-runtime-smoke.mjs",
     "test:codex-sdk:live": "node scripts/codex-sdk-runtime-smoke.mjs --live",
     "test:codex-sdk:live-tools": "node scripts/codex-sdk-runtime-smoke.mjs --live-tools",
@@ -78,8 +83,9 @@
     "cors": "^2.8.5",
     "express": "^4.18.2",
     "ffmpeg-static": "^5.3.0",
-    "multer": "^2.2.0",
-    "playwright-core": "^1.53.0",
+    "multer": "^2.2.0",
+    "electron-updater": "^6.8.9",
+    "playwright-core": "^1.53.0",
     "sharp": "^0.35.3",
     "web-tree-sitter": "^0.22.6",
     "ws": "^8.16.0"
@@ -101,8 +107,9 @@
     "productName": "MindExec",
     "copyright": "Copyright © 2026 lovecrdm77",
     "asar": false,
-    "extraMetadata": {
-      "main": "electron/main.cjs"
+    "extraMetadata": {
+      "main": "electron/main.cjs",
+      "desktopUpdateChannel": "dev"
     },
     "directories": {
       "output": "../artifacts/electron"
@@ -111,7 +118,7 @@
       "*.js",
       "*.cjs",
       "*.json",
-      "electron/main.cjs",
+      "electron/**/*",
       "remote-fast/**/*",
       "scripts/**/*",
       "tree-sitter-grammars/**/*",
@@ -136,8 +143,8 @@
         }
       ]
     },
-    "nsis": {
-      "artifactName": "MindExec-Setup-${version}-${arch}.${ext}",
+    "nsis": {
+      "artifactName": "MindExec-${version}-dev-${arch}.${ext}",
       "oneClick": false,
       "perMachine": false,
       "allowToChangeInstallationDirectory": true,
@@ -145,8 +152,12 @@
       "createStartMenuShortcut": true,
       "shortcutName": "MindExec"
     },
-    "portable": {
-      "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
-    }
+    "portable": {
+      "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
+    },
+    "publish": {
+      "provider": "generic",
+      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64"
+    }
   }
 }

package/scripts/desktop-update-publisher-smoke.mjs

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  createWranglerPutCommand,
+  parseUpdateManifest,
+  readReleasePlan
+} from './publish-mindexec-desktop-updates.mjs';
+
+test('publisher launches Wrangler directly and targets the private update bucket', () => {
+  const command = createWranglerPutCommand({
+    key: 'dev/windows/x64/MindExec-0.2.461-dev-x64.exe',
+    filePath: 'C:\\release\\MindExec-0.2.461-dev-x64.exe',
+    immutable: true
+  });
+  assert.equal(command.executable, process.execPath);
+  assert.match(command.args[0], /wrangler(?:-dist)?[\\/]cli\.js$/i);
+  assert.ok(command.args.includes('mindexec-desktop-updates/dev/windows/x64/MindExec-0.2.461-dev-x64.exe'));
+  assert.equal(command.args.includes('npx.cmd'), false);
+  assert.equal(command.args.at(-1), '--remote');
+});
+
+test('publisher validates version, size, and SHA-512 before upload', async () => {
+  const directory = await mkdtemp(join(tmpdir(), 'mindexec-update-publisher-'));
+  try {
+    const artifact = 'MindExec-1.2.3-dev-x64.exe';
+    const bytes = Buffer.from('unsigned-development-artifact');
+    const sha512 = createHash('sha512').update(bytes).digest('base64');
+    await writeFile(join(directory, artifact), bytes);
+    await writeFile(join(directory, 'latest.yml'), [
+      'version: 1.2.3',
+      'files:',
+      `  - url: ${artifact}`,
+      `    sha512: ${sha512}`,
+      `    size: ${bytes.length}`,
+      `path: ${artifact}`,
+      `sha512: ${sha512}`,
+      'releaseDate: 2026-08-16T00:00:00.000Z',
+      ''
+    ].join('\n'));
+
+    const parsed = parseUpdateManifest(await (await import('node:fs/promises')).readFile(join(directory, 'latest.yml'), 'utf8'));
+    assert.equal(parsed.version, '1.2.3');
+    assert.equal(parsed.files[0].name, artifact);
+    assert.throws(
+      () => readReleasePlan({
+        platform: 'windows-x64',
+        directory,
+        packageVersion: '1.2.3',
+        channel: 'dev'
+      }),
+      /desktop-update-dev-unsigned-ack-required/
+    );
+    const plan = readReleasePlan({
+      platform: 'windows-x64',
+      directory,
+      packageVersion: '1.2.3',
+      channel: 'dev',
+      allowUnsigned: true
+    });
+    assert.equal(plan.prefix, 'dev/windows/x64');
+    assert.deepEqual(plan.artifacts.map(item => item.fileName), [artifact]);
+    assert.throws(
+      () => readReleasePlan({
+        platform: 'windows-x64',
+        directory,
+        packageVersion: '1.2.4',
+        channel: 'dev',
+        allowUnsigned: true
+      }),
+      /desktop-update-version-mismatch/
+    );
+    assert.throws(
+      () => readReleasePlan({
+        platform: 'windows-x64',
+        directory,
+        packageVersion: '1.2.3',
+        channel: 'stable',
+        allowUnsigned: true
+      }),
+      /desktop-update-stable-unsigned-forbidden/
+    );
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});

package/scripts/desktop-update-worker-smoke.mjs

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import worker, { resolveUpdateObjectKey } from '../../workers/mindexec-desktop-updates/src/index.mjs';
+
+function storedObject(body = 'release') {
+  const bytes = new TextEncoder().encode(body);
+  return {
+    body: new ReadableStream({ start(controller) { controller.enqueue(bytes); controller.close(); } }),
+    size: bytes.byteLength,
+    httpEtag: '"release-etag"',
+    writeHttpMetadata(headers) { headers.set('content-type', 'application/octet-stream'); }
+  };
+}
+
+test('only fixed Windows stable and development update paths are public', () => {
+  assert.equal(resolveUpdateObjectKey('/stable/windows/x64/latest.yml'), 'stable/windows/x64/latest.yml');
+  assert.equal(resolveUpdateObjectKey('/dev/windows/x64/latest.yml'), 'dev/windows/x64/latest.yml');
+  assert.equal(
+    resolveUpdateObjectKey('/dev/windows/x64/MindExec-0.2.461-dev-x64.exe'),
+    'dev/windows/x64/MindExec-0.2.461-dev-x64.exe'
+  );
+  assert.equal(resolveUpdateObjectKey('/private/secret.txt'), '');
+  assert.equal(resolveUpdateObjectKey('/dev/windows/x64/../secret.txt'), '');
+  assert.equal(resolveUpdateObjectKey('/preview/windows/x64/latest.yml'), '');
+  assert.equal(resolveUpdateObjectKey('/dev/macos/arm64/latest-mac.yml'), '');
+});
+
+test('worker exposes health but rejects writes and bucket listing', async () => {
+  const env = { UPDATE_BUCKET: { head: async () => null, get: async () => null } };
+  assert.equal((await worker.fetch(new Request('https://updates.example/healthz'), env)).status, 200);
+  assert.equal((await worker.fetch(new Request('https://updates.example/', { method: 'PUT' }), env)).status, 405);
+  assert.equal((await worker.fetch(new Request('https://updates.example/'), env)).status, 404);
+});
+
+test('worker streams a manifest without caching it', async () => {
+  const object = storedObject('version: 0.2.461');
+  let observedOptions = null;
+  const env = {
+    UPDATE_BUCKET: {
+      head: async () => object,
+      get: async (_key, options) => { observedOptions = options; return object; }
+    }
+  };
+  const response = await worker.fetch(new Request('https://updates.example/dev/windows/x64/latest.yml'), env);
+  assert.equal(response.status, 200);
+  assert.equal('range' in observedOptions, false);
+  assert.equal(await response.text(), 'version: 0.2.461');
+  assert.equal(response.headers.get('cache-control'), 'no-store, max-age=0');
+  assert.equal(response.headers.get('etag'), '"release-etag"');
+});
+
+test('worker preserves resumable byte-range responses for large installers', async () => {
+  const object = storedObject('part');
+  object.size = 20;
+  object.range = { offset: 8, length: 4 };
+  const env = {
+    UPDATE_BUCKET: {
+      head: async () => object,
+      get: async (_key, options) => {
+        assert.ok(options.range, 'an explicit Range request must reach R2');
+        return object;
+      }
+    }
+  };
+  const response = await worker.fetch(new Request(
+    'https://updates.example/dev/windows/x64/MindExec-0.2.461-dev-x64.exe',
+    { headers: { range: 'bytes=8-11' } }
+  ), env);
+  assert.equal(response.status, 206);
+  assert.equal(response.headers.get('content-range'), 'bytes 8-11/20');
+  assert.equal(response.headers.get('content-length'), '4');
+});

package/scripts/drive-installed-update-smoke.mjs

@@ -0,0 +1,67 @@
+import { chromium } from 'playwright-core';
+
+function readArgument(name, fallback = '') {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? String(process.argv[index + 1] || fallback) : fallback;
+}
+
+const debugPort = Number.parseInt(readArgument('--debug-port'), 10);
+const expectedVersion = readArgument('--expected-version');
+const timeoutMs = Number.parseInt(readArgument('--timeout-ms', '300000'), 10);
+if (!Number.isInteger(debugPort) || debugPort <= 0 || !expectedVersion) {
+  throw new Error('usage: --debug-port <port> --expected-version <version> [--timeout-ms <ms>]');
+}
+
+const endpoint = `http://127.0.0.1:${debugPort}`;
+const deadline = Date.now() + timeoutMs;
+let browser = null;
+let page = null;
+let lastError = null;
+
+while (Date.now() < deadline && !page) {
+  try {
+    browser = await chromium.connectOverCDP(endpoint);
+    const contexts = browser.contexts();
+    page = contexts.flatMap(context => context.pages()).find(candidate =>
+      candidate.url().startsWith('http://127.0.0.1:')) || contexts[0]?.pages()[0] || null;
+    if (!page) throw new Error('desktop-page-not-ready');
+    await page.waitForFunction(() => Boolean(window.mindExecDesktop?.updates), null, { timeout: 5_000 });
+  } catch (error) {
+    lastError = error;
+    page = null;
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+}
+if (!page) throw new Error(`desktop-cdp-not-ready:${lastError?.message || 'timeout'}`);
+
+await page.evaluate(() => window.mindExecDesktop.updates.check());
+let status = null;
+while (Date.now() < deadline) {
+  status = await page.evaluate(() => window.mindExecDesktop.updates.getStatus());
+  if (status?.state === 'error') throw new Error(`desktop-update-check-failed:${status.error}`);
+  if (status?.downloaded && status?.availableVersion === expectedVersion) break;
+  await new Promise(resolve => setTimeout(resolve, 500));
+}
+if (!status?.downloaded || status?.availableVersion !== expectedVersion) {
+  throw new Error(`desktop-update-not-downloaded:${JSON.stringify(status)}`);
+}
+
+let rendererClosedDuringInstall = false;
+try {
+  await page.evaluate(() => window.mindExecDesktop.updates.install());
+} catch (error) {
+  const message = String(error?.message || error);
+  if (!/Target page, context or browser has been closed|Execution context was destroyed|Protocol error|closed/i.test(message)) {
+    throw error;
+  }
+  rendererClosedDuringInstall = true;
+}
+
+console.log(JSON.stringify({
+  ok: true,
+  downloadedVersion: status.availableVersion,
+  progress: status.progress,
+  installInvoked: true,
+  rendererClosedDuringInstall
+}));
+process.exit(0);