@mindexec/cli 0.2.476 → 0.2.478

package/electron/windows-package-smoke.mjs

@@ -1,156 +1,156 @@
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import net from 'node:net';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import desktopWorkspaceState from '../desktop-workspace-state.cjs';
-
-const { saveDesktopWorkspaceState } = desktopWorkspaceState;
-
-const electronDirectory = path.dirname(fileURLToPath(import.meta.url));
-const packageRoot = path.resolve(electronDirectory, '..');
-const repositoryRoot = path.resolve(packageRoot, '..');
-const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
-const outputDirectory = process.env.MINDEXEC_ELECTRON_OUTPUT
-  ? path.resolve(process.env.MINDEXEC_ELECTRON_OUTPUT)
-  : path.join(repositoryRoot, 'artifacts', 'electron');
-const executablePath = path.join(outputDirectory, 'win-unpacked', 'MindExec.exe');
-
-assert.equal(process.platform, 'win32', 'The packaged Electron smoke test requires Windows.');
-assert.ok(fs.existsSync(executablePath), `Packaged Electron executable is missing: ${executablePath}`);
-
-function reservePort() {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.once('error', reject);
-    server.listen({ host: '127.0.0.1', port: 0, exclusive: true }, () => {
-      const address = server.address();
-      server.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve(address.port);
-      });
-    });
-  });
-}
-
-async function waitForFile(filePath, child, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (fs.existsSync(filePath)) {
-      return;
-    }
-    if (child.exitCode !== null) {
-      throw new Error(`Packaged Electron exited before reporting smoke status (code ${child.exitCode}).`);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 200));
-  }
-  throw new Error(`Timed out waiting for packaged smoke result: ${filePath}`);
-}
-
-function waitForExit(child, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    if (child.exitCode !== null) {
-      resolve(child.exitCode);
-      return;
-    }
-
-    const timeout = setTimeout(() => {
-      child.kill('SIGKILL');
-      reject(new Error('Packaged Electron did not exit after its smoke run.'));
-    }, timeoutMs);
-
-    child.once('error', (error) => {
-      clearTimeout(timeout);
-      reject(error);
-    });
-    child.once('exit', (code) => {
-      clearTimeout(timeout);
-      resolve(code);
-    });
-  });
-}
-
-function canBind(port) {
-  return new Promise((resolve) => {
-    const server = net.createServer();
-    server.once('error', () => resolve(false));
-    server.listen({ host: '127.0.0.1', port, exclusive: true }, () => {
-      server.close(() => resolve(true));
-    });
-  });
-}
-
-const bridgePort = await reservePort();
-const remoteHubPort = await reservePort();
-const smokeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindexec-electron-smoke-'));
-const workspace = path.join(smokeRoot, 'saved-workspace');
-const resultPath = path.join(smokeRoot, 'result.json');
-const workspaceStatePath = path.join(smokeRoot, 'workspace-state.json');
-fs.mkdirSync(workspace, { recursive: true });
-saveDesktopWorkspaceState(workspaceStatePath, workspace);
-
-let child;
-try {
-  child = spawn(executablePath, [`--user-data-dir=${path.join(smokeRoot, 'electron-profile')}`], {
-    cwd: path.dirname(executablePath),
-    env: {
-      ...process.env,
-      MINDEXEC_DESKTOP_SMOKE: '1',
-      MINDEXEC_DESKTOP_SMOKE_RESULT: resultPath,
-      MINDEXEC_DESKTOP_WORKSPACE_STATE_PATH: workspaceStatePath,
-      MINDEXEC_NO_OPEN: '1',
-      BRIDGE_PORT: String(bridgePort),
-      REMOTE_HUB_PORT: String(remoteHubPort)
-    },
-    stdio: ['ignore', 'pipe', 'pipe'],
-    windowsHide: true
-  });
-
-  let stdout = '';
-  let stderr = '';
-  child.stdout?.on('data', (chunk) => {
-    stdout += String(chunk);
-  });
-  child.stderr?.on('data', (chunk) => {
-    stderr += String(chunk);
-  });
-
-  await waitForFile(resultPath, child, 90_000);
-  const result = JSON.parse(fs.readFileSync(resultPath, 'utf8'));
-  assert.equal(result.ok, true, `Packaged Electron smoke failed: ${result.error || stderr || stdout}`);
-  assert.equal(result.appVersion, packageJson.version, 'Electron app version does not match the npm package version.');
-  assert.equal(result.bridgeVersion, packageJson.version, 'Bundled LocalBridge version does not match Electron.');
-  assert.equal(result.runtimeMode, 'bundled', 'Electron did not use its bundled runtime.');
-  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}.`);
-
-  await new Promise((resolve) => setTimeout(resolve, 500));
-  assert.equal(await canBind(bridgePort), true, 'Bridge port was not released after Electron exit.');
-  assert.equal(await canBind(remoteHubPort), true, 'RemoteHub port was not released after Electron exit.');
-
-  console.log(JSON.stringify({
-    ok: true,
-    executablePath,
-    version: result.appVersion,
-    runtimeMode: result.runtimeMode,
-    desktopUpdateKind: result.desktopUpdate.installKind,
-    bridgePortReleased: true,
-    remoteHubPortReleased: true
-  }));
-} finally {
-  if (child && child.exitCode === null) {
-    child.kill('SIGKILL');
-  }
-  fs.rmSync(smokeRoot, { recursive: true, force: true });
-}
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import desktopWorkspaceState from '../desktop-workspace-state.cjs';
+
+const { saveDesktopWorkspaceState } = desktopWorkspaceState;
+
+const electronDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(electronDirectory, '..');
+const repositoryRoot = path.resolve(packageRoot, '..');
+const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+const outputDirectory = process.env.MINDEXEC_ELECTRON_OUTPUT
+  ? path.resolve(process.env.MINDEXEC_ELECTRON_OUTPUT)
+  : path.join(repositoryRoot, 'artifacts', 'electron');
+const executablePath = path.join(outputDirectory, 'win-unpacked', 'MindExec.exe');
+
+assert.equal(process.platform, 'win32', 'The packaged Electron smoke test requires Windows.');
+assert.ok(fs.existsSync(executablePath), `Packaged Electron executable is missing: ${executablePath}`);
+
+function reservePort() {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.once('error', reject);
+    server.listen({ host: '127.0.0.1', port: 0, exclusive: true }, () => {
+      const address = server.address();
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(address.port);
+      });
+    });
+  });
+}
+
+async function waitForFile(filePath, child, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (fs.existsSync(filePath)) {
+      return;
+    }
+    if (child.exitCode !== null) {
+      throw new Error(`Packaged Electron exited before reporting smoke status (code ${child.exitCode}).`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 200));
+  }
+  throw new Error(`Timed out waiting for packaged smoke result: ${filePath}`);
+}
+
+function waitForExit(child, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    if (child.exitCode !== null) {
+      resolve(child.exitCode);
+      return;
+    }
+
+    const timeout = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error('Packaged Electron did not exit after its smoke run.'));
+    }, timeoutMs);
+
+    child.once('error', (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once('exit', (code) => {
+      clearTimeout(timeout);
+      resolve(code);
+    });
+  });
+}
+
+function canBind(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.listen({ host: '127.0.0.1', port, exclusive: true }, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+const bridgePort = await reservePort();
+const remoteHubPort = await reservePort();
+const smokeRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindexec-electron-smoke-'));
+const workspace = path.join(smokeRoot, 'saved-workspace');
+const resultPath = path.join(smokeRoot, 'result.json');
+const workspaceStatePath = path.join(smokeRoot, 'workspace-state.json');
+fs.mkdirSync(workspace, { recursive: true });
+saveDesktopWorkspaceState(workspaceStatePath, workspace);
+
+let child;
+try {
+  child = spawn(executablePath, [`--user-data-dir=${path.join(smokeRoot, 'electron-profile')}`], {
+    cwd: path.dirname(executablePath),
+    env: {
+      ...process.env,
+      MINDEXEC_DESKTOP_SMOKE: '1',
+      MINDEXEC_DESKTOP_SMOKE_RESULT: resultPath,
+      MINDEXEC_DESKTOP_WORKSPACE_STATE_PATH: workspaceStatePath,
+      MINDEXEC_NO_OPEN: '1',
+      BRIDGE_PORT: String(bridgePort),
+      REMOTE_HUB_PORT: String(remoteHubPort)
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true
+  });
+
+  let stdout = '';
+  let stderr = '';
+  child.stdout?.on('data', (chunk) => {
+    stdout += String(chunk);
+  });
+  child.stderr?.on('data', (chunk) => {
+    stderr += String(chunk);
+  });
+
+  await waitForFile(resultPath, child, 90_000);
+  const result = JSON.parse(fs.readFileSync(resultPath, 'utf8'));
+  assert.equal(result.ok, true, `Packaged Electron smoke failed: ${result.error || stderr || stdout}`);
+  assert.equal(result.appVersion, packageJson.version, 'Electron app version does not match the npm package version.');
+  assert.equal(result.bridgeVersion, packageJson.version, 'Bundled LocalBridge version does not match Electron.');
+  assert.equal(result.runtimeMode, 'bundled', 'Electron did not use its bundled runtime.');
+  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}.`);
+
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  assert.equal(await canBind(bridgePort), true, 'Bridge port was not released after Electron exit.');
+  assert.equal(await canBind(remoteHubPort), true, 'RemoteHub port was not released after Electron exit.');
+
+  console.log(JSON.stringify({
+    ok: true,
+    executablePath,
+    version: result.appVersion,
+    runtimeMode: result.runtimeMode,
+    desktopUpdateKind: result.desktopUpdate.installKind,
+    bridgePortReleased: true,
+    remoteHubPortReleased: true
+  }));
+} finally {
+  if (child && child.exitCode === null) {
+    child.kill('SIGKILL');
+  }
+  fs.rmSync(smokeRoot, { recursive: true, force: true });
+}