@mindexec/cli 0.2.476 → 0.2.478

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

@@ -1,89 +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 });
-  }
-});
+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

@@ -1,72 +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');
-});
+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/desktop-workspace-state-smoke.mjs

@@ -1,81 +1,81 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import desktopWorkspaceState from '../desktop-workspace-state.cjs';
-
-const {
-  loadDesktopWorkspaceState,
-  resolveDesktopWorkspace,
-  saveDesktopWorkspaceState
-} = desktopWorkspaceState;
-
-const smokeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindexec-workspace-state-'));
-const savedWorkspace = path.join(smokeRoot, 'saved-workspace');
-const explicitWorkspace = path.join(smokeRoot, 'explicit-workspace');
-const fallbackWorkspace = path.join(smokeRoot, 'fallback-workspace');
-const missingWorkspace = path.join(smokeRoot, 'missing-workspace');
-const statePath = path.join(smokeRoot, 'profile', 'workspace-state.json');
-
-fs.mkdirSync(savedWorkspace, { recursive: true });
-fs.mkdirSync(explicitWorkspace, { recursive: true });
-fs.mkdirSync(fallbackWorkspace, { recursive: true });
-
-try {
-  assert.equal(saveDesktopWorkspaceState('', savedWorkspace), false, 'Non-desktop runtimes must remain a no-op.');
-  assert.equal(saveDesktopWorkspaceState(statePath, savedWorkspace), true);
-  assert.deepEqual(loadDesktopWorkspaceState(statePath), {
-    version: 1,
-    workspacePath: path.resolve(savedWorkspace)
-  });
-
-  assert.equal(saveDesktopWorkspaceState(statePath, explicitWorkspace), true);
-  assert.equal(loadDesktopWorkspaceState(statePath)?.workspacePath, path.resolve(explicitWorkspace),
-    'Changing folders must replace the prior desktop workspace state.');
-  assert.equal(saveDesktopWorkspaceState(statePath, savedWorkspace), true);
-
-  assert.deepEqual(resolveDesktopWorkspace({
-    statePath,
-    fallbackWorkspace
-  }), {
-    workspacePath: path.resolve(savedWorkspace),
-    source: 'saved'
-  });
-
-  assert.deepEqual(resolveDesktopWorkspace({
-    explicitWorkspace,
-    statePath,
-    fallbackWorkspace
-  }), {
-    workspacePath: path.resolve(explicitWorkspace),
-    source: 'explicit'
-  });
-
-  fs.writeFileSync(statePath, `${JSON.stringify({ version: 1, workspacePath: missingWorkspace })}\n`, 'utf8');
-  assert.deepEqual(resolveDesktopWorkspace({
-    statePath,
-    fallbackWorkspace
-  }), {
-    workspacePath: path.resolve(fallbackWorkspace),
-    source: 'fallback'
-  });
-  assert.equal(fs.existsSync(missingWorkspace), false, 'A deleted saved workspace must not be recreated.');
-
-  fs.writeFileSync(statePath, '{broken json', 'utf8');
-  assert.deepEqual(resolveDesktopWorkspace({
-    statePath,
-    fallbackWorkspace
-  }), {
-    workspacePath: path.resolve(fallbackWorkspace),
-    source: 'fallback'
-  });
-
-  console.log(JSON.stringify({
-    ok: true,
-    restoredWorkspace: path.resolve(savedWorkspace),
-    invalidSavedWorkspaceFallsBack: true,
-    explicitWorkspaceWins: true
-  }));
-} finally {
-  fs.rmSync(smokeRoot, { recursive: true, force: true });
-}
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import desktopWorkspaceState from '../desktop-workspace-state.cjs';
+
+const {
+  loadDesktopWorkspaceState,
+  resolveDesktopWorkspace,
+  saveDesktopWorkspaceState
+} = desktopWorkspaceState;
+
+const smokeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindexec-workspace-state-'));
+const savedWorkspace = path.join(smokeRoot, 'saved-workspace');
+const explicitWorkspace = path.join(smokeRoot, 'explicit-workspace');
+const fallbackWorkspace = path.join(smokeRoot, 'fallback-workspace');
+const missingWorkspace = path.join(smokeRoot, 'missing-workspace');
+const statePath = path.join(smokeRoot, 'profile', 'workspace-state.json');
+
+fs.mkdirSync(savedWorkspace, { recursive: true });
+fs.mkdirSync(explicitWorkspace, { recursive: true });
+fs.mkdirSync(fallbackWorkspace, { recursive: true });
+
+try {
+  assert.equal(saveDesktopWorkspaceState('', savedWorkspace), false, 'Non-desktop runtimes must remain a no-op.');
+  assert.equal(saveDesktopWorkspaceState(statePath, savedWorkspace), true);
+  assert.deepEqual(loadDesktopWorkspaceState(statePath), {
+    version: 1,
+    workspacePath: path.resolve(savedWorkspace)
+  });
+
+  assert.equal(saveDesktopWorkspaceState(statePath, explicitWorkspace), true);
+  assert.equal(loadDesktopWorkspaceState(statePath)?.workspacePath, path.resolve(explicitWorkspace),
+    'Changing folders must replace the prior desktop workspace state.');
+  assert.equal(saveDesktopWorkspaceState(statePath, savedWorkspace), true);
+
+  assert.deepEqual(resolveDesktopWorkspace({
+    statePath,
+    fallbackWorkspace
+  }), {
+    workspacePath: path.resolve(savedWorkspace),
+    source: 'saved'
+  });
+
+  assert.deepEqual(resolveDesktopWorkspace({
+    explicitWorkspace,
+    statePath,
+    fallbackWorkspace
+  }), {
+    workspacePath: path.resolve(explicitWorkspace),
+    source: 'explicit'
+  });
+
+  fs.writeFileSync(statePath, `${JSON.stringify({ version: 1, workspacePath: missingWorkspace })}\n`, 'utf8');
+  assert.deepEqual(resolveDesktopWorkspace({
+    statePath,
+    fallbackWorkspace
+  }), {
+    workspacePath: path.resolve(fallbackWorkspace),
+    source: 'fallback'
+  });
+  assert.equal(fs.existsSync(missingWorkspace), false, 'A deleted saved workspace must not be recreated.');
+
+  fs.writeFileSync(statePath, '{broken json', 'utf8');
+  assert.deepEqual(resolveDesktopWorkspace({
+    statePath,
+    fallbackWorkspace
+  }), {
+    workspacePath: path.resolve(fallbackWorkspace),
+    source: 'fallback'
+  });
+
+  console.log(JSON.stringify({
+    ok: true,
+    restoredWorkspace: path.resolve(savedWorkspace),
+    invalidSavedWorkspaceFallsBack: true,
+    explicitWorkspaceWins: true
+  }));
+} finally {
+  fs.rmSync(smokeRoot, { recursive: true, force: true });
+}

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

@@ -1,67 +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);
+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);