@mindexec/cli 0.2.476 → 0.2.478

package/electron/update-feed-resolver.cjs

@@ -1,79 +1,79 @@
-'use strict';
-
-const LOCAL_HTTP_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]']);
-const CHANNEL_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
-const SEGMENT_PATTERN = /^[a-z0-9][a-z0-9/-]{0,127}$/;
-
-function normalizeUrl(value) {
-  return String(value || '').trim().replace(/\/+$/, '');
-}
-
-function validateFeedUrl(value) {
-  const normalized = normalizeUrl(value);
-  if (!normalized) return { url: '', error: 'desktop-update-feed-not-configured' };
-
-  let parsed;
-  try {
-    parsed = new URL(normalized);
-  } catch {
-    return { url: '', error: 'desktop-update-feed-invalid' };
-  }
-
-  const localHttp = parsed.protocol === 'http:' && LOCAL_HTTP_HOSTS.has(parsed.hostname);
-  if (parsed.protocol !== 'https:' && !localHttp) {
-    return { url: '', error: 'desktop-update-feed-insecure' };
-  }
-  if (parsed.username || parsed.password || parsed.search || parsed.hash) {
-    return { url: '', error: 'desktop-update-feed-invalid' };
-  }
-
-  return { url: normalizeUrl(parsed.toString()), error: '' };
-}
-
-function resolveDesktopUpdateFeed({
-  config = {},
-  overrideUrl = '',
-  platform = process.platform,
-  arch = process.arch
-} = {}) {
-  const exactOverride = validateFeedUrl(overrideUrl);
-  if (String(overrideUrl || '').trim()) {
-    return {
-      ...exactOverride,
-      configured: Boolean(exactOverride.url),
-      platform,
-      arch,
-      channel: 'override'
-    };
-  }
-
-  const channel = String(config?.channel || 'dev').trim().toLowerCase();
-  const pathSegment = String(config?.paths?.[platform]?.[arch] || '')
-    .trim()
-    .replace(/^\/+|\/+$/g, '');
-  if (!CHANNEL_PATTERN.test(channel)) {
-    return { url: '', configured: false, error: 'desktop-update-channel-invalid', platform, arch, channel };
-  }
-  if (!SEGMENT_PATTERN.test(pathSegment)) {
-    return { url: '', configured: false, error: 'desktop-update-platform-unsupported', platform, arch, channel };
-  }
-
-  const base = validateFeedUrl(config?.baseUrl);
-  if (!base.url) {
-    return { ...base, configured: false, platform, arch, channel };
-  }
-
-  return {
-    url: `${base.url}/${channel}/${pathSegment}`,
-    configured: true,
-    error: '',
-    platform,
-    arch,
-    channel
-  };
-}
-
-module.exports = {
-  resolveDesktopUpdateFeed,
-  validateFeedUrl
-};
+'use strict';
+
+const LOCAL_HTTP_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]']);
+const CHANNEL_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+const SEGMENT_PATTERN = /^[a-z0-9][a-z0-9/-]{0,127}$/;
+
+function normalizeUrl(value) {
+  return String(value || '').trim().replace(/\/+$/, '');
+}
+
+function validateFeedUrl(value) {
+  const normalized = normalizeUrl(value);
+  if (!normalized) return { url: '', error: 'desktop-update-feed-not-configured' };
+
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
+    return { url: '', error: 'desktop-update-feed-invalid' };
+  }
+
+  const localHttp = parsed.protocol === 'http:' && LOCAL_HTTP_HOSTS.has(parsed.hostname);
+  if (parsed.protocol !== 'https:' && !localHttp) {
+    return { url: '', error: 'desktop-update-feed-insecure' };
+  }
+  if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+    return { url: '', error: 'desktop-update-feed-invalid' };
+  }
+
+  return { url: normalizeUrl(parsed.toString()), error: '' };
+}
+
+function resolveDesktopUpdateFeed({
+  config = {},
+  overrideUrl = '',
+  platform = process.platform,
+  arch = process.arch
+} = {}) {
+  const exactOverride = validateFeedUrl(overrideUrl);
+  if (String(overrideUrl || '').trim()) {
+    return {
+      ...exactOverride,
+      configured: Boolean(exactOverride.url),
+      platform,
+      arch,
+      channel: 'override'
+    };
+  }
+
+  const channel = String(config?.channel || 'dev').trim().toLowerCase();
+  const pathSegment = String(config?.paths?.[platform]?.[arch] || '')
+    .trim()
+    .replace(/^\/+|\/+$/g, '');
+  if (!CHANNEL_PATTERN.test(channel)) {
+    return { url: '', configured: false, error: 'desktop-update-channel-invalid', platform, arch, channel };
+  }
+  if (!SEGMENT_PATTERN.test(pathSegment)) {
+    return { url: '', configured: false, error: 'desktop-update-platform-unsupported', platform, arch, channel };
+  }
+
+  const base = validateFeedUrl(config?.baseUrl);
+  if (!base.url) {
+    return { ...base, configured: false, platform, arch, channel };
+  }
+
+  return {
+    url: `${base.url}/${channel}/${pathSegment}`,
+    configured: true,
+    error: '',
+    platform,
+    arch,
+    channel
+  };
+}
+
+module.exports = {
+  resolveDesktopUpdateFeed,
+  validateFeedUrl
+};

package/electron/update-feed.json

@@ -1,10 +1,10 @@
-{
-  "provider": "generic",
-  "baseUrl": "https://mindexec.lovecrdm.workers.dev",
-  "channel": "dev",
-  "paths": {
-    "win32": {
-      "x64": "windows/x64"
-    }
-  }
-}
+{
+  "provider": "generic",
+  "baseUrl": "https://mindexec.lovecrdm.workers.dev",
+  "channel": "dev",
+  "paths": {
+    "win32": {
+      "x64": "windows/x64"
+    }
+  }
+}

package/electron/update-manager-smoke.mjs

@@ -1,146 +1,146 @@
-import assert from 'node:assert/strict';
-import { EventEmitter } from 'node:events';
-import test from 'node:test';
-import updateManagerModule from './update-manager.cjs';
-import updateFeedResolverModule from './update-feed-resolver.cjs';
-
-const { createProductUpdateManager } = updateManagerModule;
-const { resolveDesktopUpdateFeed } = updateFeedResolverModule;
-
-const feedConfig = {
-  baseUrl: 'https://updates.example',
-  channel: 'dev',
-  paths: { win32: { x64: 'windows/x64' } }
-};
-
-class FakeUpdater extends EventEmitter {
-  checkCalls = 0;
-  downloadCalls = 0;
-  feed = null;
-  installStarted = false;
-
-  setFeedURL(feed) { this.feed = feed; }
-
-  async checkForUpdates() {
-    this.checkCalls += 1;
-    this.emit('checking-for-update');
-    await new Promise(resolve => setTimeout(resolve, 5));
-    this.emit('update-available', { version: '1.1.0' });
-    return { updateInfo: { version: '1.1.0' } };
-  }
-
-  async downloadUpdate() {
-    this.downloadCalls += 1;
-    this.emit('download-progress', { percent: 42 });
-    await new Promise(resolve => setTimeout(resolve, 5));
-    this.emit('update-downloaded', { version: '1.1.0' });
-  }
-
-  quitAndInstall() { this.installStarted = true; }
-}
-
-function createManager(updater, hooks = {}) {
-  return createProductUpdateManager({
-    app: {
-      isPackaged: true,
-      getVersion: () => '1.0.0',
-      getAppPath: () => process.cwd()
-    },
-    updater,
-    platform: 'win32',
-    arch: 'x64',
-    installKind: 'installed',
-    updateFeedConfig: feedConfig,
-    overrideUrl: '',
-    ...hooks
-  });
-}
-
-test('feed resolver pins Windows x64 to the exact development path and rejects insecure servers', () => {
-  assert.equal(
-    resolveDesktopUpdateFeed({ config: feedConfig, platform: 'win32', arch: 'x64' }).url,
-    'https://updates.example/dev/windows/x64'
-  );
-  assert.equal(
-    resolveDesktopUpdateFeed({ config: { ...feedConfig, baseUrl: 'http://updates.example' }, platform: 'win32', arch: 'x64' }).error,
-    'desktop-update-feed-insecure'
-  );
-  assert.equal(
-    resolveDesktopUpdateFeed({ config: feedConfig, platform: 'win32', arch: 'arm64' }).error,
-    'desktop-update-platform-unsupported'
-  );
-});
-
-test('concurrent checks share one version request and one download', async () => {
-  const updater = new FakeUpdater();
-  const manager = createManager(updater);
-  const [first, second] = await Promise.all([manager.check(), manager.check()]);
-  assert.equal(first.state, 'downloaded');
-  assert.equal(second.state, 'downloaded');
-  assert.equal(updater.checkCalls, 1);
-  assert.equal(updater.downloadCalls, 1);
-  assert.deepEqual(updater.feed, { provider: 'generic', url: 'https://updates.example/dev/windows/x64' });
-});
-
-test('portable and unpacked executables never call electron-updater', async () => {
-  for (const installKind of ['portable', 'unpacked']) {
-    const updater = new FakeUpdater();
-    const manager = createManager(updater, { installKind });
-    const result = await manager.check();
-    assert.equal(result.state, 'unsupported');
-    assert.equal(result.updateSupported, false);
-    assert.equal(updater.checkCalls, 0);
-    assert.equal(updater.downloadCalls, 0);
-  }
-});
-
-test('install starts only after the owned runtime and ports are released', async () => {
-  const order = [];
-  const updater = new FakeUpdater();
-  updater.quitAndInstall = () => { order.push('installer'); updater.installStarted = true; };
-  const manager = createManager(updater, {
-    beforeInstall: async () => { order.push('runtime-and-ports-zero'); }
-  });
-  await manager.check();
-  await manager.install();
-  assert.deepEqual(order, ['runtime-and-ports-zero', 'installer']);
-  assert.equal(updater.installStarted, true);
-});
-
-test('a preparation or installer failure restores runtime ownership and allows retry', async () => {
-  const order = [];
-  const updater = new FakeUpdater();
-  let prepareAttempts = 0;
-  const manager = createManager(updater, {
-    beforeInstall: async () => {
-      prepareAttempts += 1;
-      order.push(`prepare-${prepareAttempts}`);
-      if (prepareAttempts === 1) throw new Error('runtime-release-failed');
-    },
-    onInstallError: async () => { order.push('runtime-restored'); }
-  });
-  await manager.check();
-  assert.equal((await manager.install()).state, 'error');
-  assert.equal((await manager.install()).state, 'installing');
-  assert.deepEqual(order, ['prepare-1', 'runtime-restored', 'prepare-2']);
-  assert.equal(updater.installStarted, true);
-});
-
-test('a slow update server never holds startup beyond its small budget', async () => {
-  const updater = new FakeUpdater();
-  updater.checkForUpdates = async () => {
-    updater.checkCalls += 1;
-    updater.emit('checking-for-update');
-    await new Promise(resolve => setTimeout(resolve, 80));
-    updater.emit('update-not-available');
-    return { updateInfo: { version: '1.0.0' } };
-  };
-  const manager = createManager(updater, { startupCheckTimeoutMs: 20 });
-  const startedAt = Date.now();
-  const status = await manager.checkAtStartup();
-  assert.ok(Date.now() - startedAt < 70, 'startup must continue while a slow check finishes in the background');
-  assert.equal(status.startupCheck, 'timed-out');
-  await new Promise(resolve => setTimeout(resolve, 90));
-  assert.equal(manager.getStatus().state, 'current');
-  assert.equal(manager.getStatus().startupCheck, 'complete');
-});
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import test from 'node:test';
+import updateManagerModule from './update-manager.cjs';
+import updateFeedResolverModule from './update-feed-resolver.cjs';
+
+const { createProductUpdateManager } = updateManagerModule;
+const { resolveDesktopUpdateFeed } = updateFeedResolverModule;
+
+const feedConfig = {
+  baseUrl: 'https://updates.example',
+  channel: 'dev',
+  paths: { win32: { x64: 'windows/x64' } }
+};
+
+class FakeUpdater extends EventEmitter {
+  checkCalls = 0;
+  downloadCalls = 0;
+  feed = null;
+  installStarted = false;
+
+  setFeedURL(feed) { this.feed = feed; }
+
+  async checkForUpdates() {
+    this.checkCalls += 1;
+    this.emit('checking-for-update');
+    await new Promise(resolve => setTimeout(resolve, 5));
+    this.emit('update-available', { version: '1.1.0' });
+    return { updateInfo: { version: '1.1.0' } };
+  }
+
+  async downloadUpdate() {
+    this.downloadCalls += 1;
+    this.emit('download-progress', { percent: 42 });
+    await new Promise(resolve => setTimeout(resolve, 5));
+    this.emit('update-downloaded', { version: '1.1.0' });
+  }
+
+  quitAndInstall() { this.installStarted = true; }
+}
+
+function createManager(updater, hooks = {}) {
+  return createProductUpdateManager({
+    app: {
+      isPackaged: true,
+      getVersion: () => '1.0.0',
+      getAppPath: () => process.cwd()
+    },
+    updater,
+    platform: 'win32',
+    arch: 'x64',
+    installKind: 'installed',
+    updateFeedConfig: feedConfig,
+    overrideUrl: '',
+    ...hooks
+  });
+}
+
+test('feed resolver pins Windows x64 to the exact development path and rejects insecure servers', () => {
+  assert.equal(
+    resolveDesktopUpdateFeed({ config: feedConfig, platform: 'win32', arch: 'x64' }).url,
+    'https://updates.example/dev/windows/x64'
+  );
+  assert.equal(
+    resolveDesktopUpdateFeed({ config: { ...feedConfig, baseUrl: 'http://updates.example' }, platform: 'win32', arch: 'x64' }).error,
+    'desktop-update-feed-insecure'
+  );
+  assert.equal(
+    resolveDesktopUpdateFeed({ config: feedConfig, platform: 'win32', arch: 'arm64' }).error,
+    'desktop-update-platform-unsupported'
+  );
+});
+
+test('concurrent checks share one version request and one download', async () => {
+  const updater = new FakeUpdater();
+  const manager = createManager(updater);
+  const [first, second] = await Promise.all([manager.check(), manager.check()]);
+  assert.equal(first.state, 'downloaded');
+  assert.equal(second.state, 'downloaded');
+  assert.equal(updater.checkCalls, 1);
+  assert.equal(updater.downloadCalls, 1);
+  assert.deepEqual(updater.feed, { provider: 'generic', url: 'https://updates.example/dev/windows/x64' });
+});
+
+test('portable and unpacked executables never call electron-updater', async () => {
+  for (const installKind of ['portable', 'unpacked']) {
+    const updater = new FakeUpdater();
+    const manager = createManager(updater, { installKind });
+    const result = await manager.check();
+    assert.equal(result.state, 'unsupported');
+    assert.equal(result.updateSupported, false);
+    assert.equal(updater.checkCalls, 0);
+    assert.equal(updater.downloadCalls, 0);
+  }
+});
+
+test('install starts only after the owned runtime and ports are released', async () => {
+  const order = [];
+  const updater = new FakeUpdater();
+  updater.quitAndInstall = () => { order.push('installer'); updater.installStarted = true; };
+  const manager = createManager(updater, {
+    beforeInstall: async () => { order.push('runtime-and-ports-zero'); }
+  });
+  await manager.check();
+  await manager.install();
+  assert.deepEqual(order, ['runtime-and-ports-zero', 'installer']);
+  assert.equal(updater.installStarted, true);
+});
+
+test('a preparation or installer failure restores runtime ownership and allows retry', async () => {
+  const order = [];
+  const updater = new FakeUpdater();
+  let prepareAttempts = 0;
+  const manager = createManager(updater, {
+    beforeInstall: async () => {
+      prepareAttempts += 1;
+      order.push(`prepare-${prepareAttempts}`);
+      if (prepareAttempts === 1) throw new Error('runtime-release-failed');
+    },
+    onInstallError: async () => { order.push('runtime-restored'); }
+  });
+  await manager.check();
+  assert.equal((await manager.install()).state, 'error');
+  assert.equal((await manager.install()).state, 'installing');
+  assert.deepEqual(order, ['prepare-1', 'runtime-restored', 'prepare-2']);
+  assert.equal(updater.installStarted, true);
+});
+
+test('a slow update server never holds startup beyond its small budget', async () => {
+  const updater = new FakeUpdater();
+  updater.checkForUpdates = async () => {
+    updater.checkCalls += 1;
+    updater.emit('checking-for-update');
+    await new Promise(resolve => setTimeout(resolve, 80));
+    updater.emit('update-not-available');
+    return { updateInfo: { version: '1.0.0' } };
+  };
+  const manager = createManager(updater, { startupCheckTimeoutMs: 20 });
+  const startedAt = Date.now();
+  const status = await manager.checkAtStartup();
+  assert.ok(Date.now() - startedAt < 70, 'startup must continue while a slow check finishes in the background');
+  assert.equal(status.startupCheck, 'timed-out');
+  await new Promise(resolve => setTimeout(resolve, 90));
+  assert.equal(manager.getStatus().state, 'current');
+  assert.equal(manager.getStatus().startupCheck, 'complete');
+});