@mindexec/cli 0.2.483 → 0.2.494

package/codex-runtime.js

@@ -1120,9 +1120,11 @@ export function createCodexRuntime(options) {
             sandboxMode: API_SANDBOX_BY_SDK_VALUE[threadOptions.sandboxMode] || threadOptions.sandboxMode
         });
         let timeout = null;
+        let timedOut = false;
 
         try {
             timeout = setTimeout(() => {
+                timedOut = true;
                 try {
                     abortController.abort();
                 } catch {
@@ -1182,8 +1184,10 @@ export function createCodexRuntime(options) {
             }
         } catch (err) {
             const aborted = abortController.signal.aborted;
-            result.error = aborted ? 'Codex turn was cancelled.' : (err?.message || String(err));
-            result.status = aborted ? 'cancelled' : 'failed';
+            result.error = timedOut
+                ? 'Codex turn timed out.'
+                : (aborted ? 'Codex turn was cancelled.' : (err?.message || String(err)));
+            result.status = timedOut ? 'timed-out' : (aborted ? 'cancelled' : 'failed');
             result.success = false;
         } finally {
             if (timeout) {

package/electron/main.cjs

@@ -33,8 +33,6 @@ let desktopWorkspaceStatePath = '';
 let productUpdates = null;
 let recurringProductUpdates = null;
 let updateInstallSequenceStarted = false;
-let updatePromptPromise = null;
-let updatePromptedVersion = '';
 
 function resolveDesktopIconPath() {
   const iconPath = path.resolve(__dirname, '..', 'wwwroot', 'icon-512.png');
@@ -48,6 +46,21 @@ function resolveDesktopInstallKind() {
   return process.platform === 'win32' ? 'installed' : 'unsupported-platform';
 }
 
+function resolveNativeCoreMode() {
+  const validModes = new Set(['off', 'compare', 'native']);
+  const environmentMode = String(process.env.MINDEXEC_NATIVE_CORE_MODE || '').trim().toLowerCase();
+  if (validModes.has(environmentMode)) return environmentMode;
+  if (!app.isPackaged) return 'off';
+
+  try {
+    const packageInfo = JSON.parse(fs.readFileSync(path.join(app.getAppPath(), 'package.json'), 'utf8'));
+    const packagedMode = String(packageInfo.nativeCoreMode || '').trim().toLowerCase();
+    return validModes.has(packagedMode) ? packagedMode : 'off';
+  } catch {
+    return 'off';
+  }
+}
+
 function parsePort(value) {
   const parsed = Number.parseInt(String(value ?? ''), 10);
   return Number.isInteger(parsed) && parsed > 0 && parsed <= 65_535 ? parsed : 0;
@@ -259,34 +272,6 @@ function sendUpdateStatus(status) {
   if (mainWindow && !mainWindow.isDestroyed() && !mainWindow.webContents.isDestroyed()) {
     mainWindow.webContents.send('updates:status', status);
   }
-  if (status.state === 'downloaded') void promptForDownloadedUpdate(status);
-}
-
-async function promptForDownloadedUpdate(status = productUpdates?.getStatus()) {
-  if (!status?.downloaded || !status.availableVersion || !mainWindow || mainWindow.isDestroyed()) return;
-  if (process.env.MINDEXEC_DESKTOP_SMOKE === '1') return;
-  if (updatePromptedVersion === status.availableVersion || updatePromptPromise) return updatePromptPromise;
-
-  updatePromptedVersion = status.availableVersion;
-  updatePromptPromise = dialog.showMessageBox(mainWindow, {
-    type: 'info',
-    title: 'MindExec update ready',
-    message: `MindExec ${status.availableVersion} is ready.`,
-    detail: 'Restart now to use the new development build. Your project folder and saved data stay unchanged.',
-    buttons: ['Restart and update', 'Later'],
-    defaultId: 0,
-    cancelId: 1,
-    noLink: true
-  }).then(result => {
-    if (result.response === 0) return productUpdates?.install();
-    return productUpdates?.getStatus();
-  }).catch(error => {
-    appendDesktopLog(`[update:prompt-error] ${error?.stack || error}`);
-    return productUpdates?.getStatus();
-  }).finally(() => {
-    updatePromptPromise = null;
-  });
-  return updatePromptPromise;
 }
 
 function initializeProductUpdates() {
@@ -370,6 +355,40 @@ function writeSmokeResult(payload) {
   fs.writeFileSync(resultPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
 }
 
+async function waitForNativeCoreSmoke(browserWindow, expectedMode) {
+  if (expectedMode === 'off') return null;
+  const deadline = Date.now() + 30_000;
+  let lastSnapshot = null;
+  while (Date.now() < deadline) {
+    lastSnapshot = await browserWindow.webContents.executeJavaScript(`(() => {
+      const value = window.__mindExecutionNativeCoreStatus;
+      if (!value) return null;
+      return {
+        mode: String(value.mode || ''),
+        ready: value.ready === true,
+        backend: String(value.backend || ''),
+        buildId: String(value.buildId || ''),
+        lastError: String(value.lastError || ''),
+        fallbackActive: value.fallbackActive === true,
+        fallbackReason: String(value.fallbackReason || ''),
+        primaryResults: Number(value.primaryResults || 0),
+        lastPrimaryResultType: String(value.lastPrimaryResultType || ''),
+        lastPrimaryDurationMs: Number(value.lastPrimaryDurationMs || 0),
+        lastPrimaryRoundTripMs: Number(value.lastPrimaryRoundTripMs || 0)
+      };
+    })()`);
+    if (lastSnapshot?.lastError || lastSnapshot?.fallbackActive === true) {
+      throw new Error(`Native core smoke initialization failed: ${lastSnapshot.lastError}`);
+    }
+    const acceptedNativeResult = expectedMode !== 'native' || Number(lastSnapshot?.primaryResults || 0) > 0;
+    if (lastSnapshot?.ready === true && lastSnapshot.mode === expectedMode && acceptedNativeResult) {
+      return lastSnapshot;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error(`Native core did not become ready in ${expectedMode} mode: ${JSON.stringify(lastSnapshot)}`);
+}
+
 async function stopBundledBridge() {
   const child = bridgeChild;
   bridgeChild = null;
@@ -447,11 +466,15 @@ async function recoverRuntimeAfterUpdateInstallError(error) {
 async function launchDesktop() {
   const status = await prepareBundledRuntime();
   const window = createMainWindow();
-  const appUrl = `http://127.0.0.1:${activeBridgePort}/mindcanvas`;
+  const nativeCoreMode = resolveNativeCoreMode();
+  const nativeCoreQuery = nativeCoreMode === 'off'
+    ? ''
+    : `?nativeCore=${encodeURIComponent(nativeCoreMode)}`;
+  const appUrl = `http://127.0.0.1:${activeBridgePort}/mindcanvas${nativeCoreQuery}`;
   await window.loadURL(appUrl);
-  void promptForDownloadedUpdate();
 
   if (process.env.MINDEXEC_DESKTOP_SMOKE === '1') {
+    const nativeCore = await waitForNativeCoreSmoke(window, nativeCoreMode);
     writeSmokeResult({
       ok: true,
       appVersion: app.getVersion(),
@@ -462,6 +485,7 @@ async function launchDesktop() {
       remoteHubPort: activeRemoteHubPort,
       workspace: activeWorkspace,
       url: appUrl,
+      nativeCore,
       desktopUpdate: productUpdates?.getStatus() || null
     });
     setTimeout(() => app.quit(), 250).unref();

package/electron/preload.cjs

@@ -2,6 +2,184 @@
 
 const { contextBridge, ipcRenderer } = require('electron');
 
+const UPDATE_INDICATOR_ID = 'mindexec-desktop-update-indicator';
+const UPDATE_STYLE_ID = 'mindexec-desktop-update-indicator-style';
+let latestUpdateStatus = null;
+let updateInstallBusy = false;
+
+function updateVersion(status) {
+  return String(status?.availableVersion || '').trim();
+}
+
+function shouldShowUpdateIndicator(status) {
+  const version = updateVersion(status);
+  if (!version) return false;
+  return ['available', 'downloading', 'downloaded', 'error'].includes(String(status?.state || '').toLowerCase());
+}
+
+function buildUpdateTooltip(status) {
+  const version = updateVersion(status) || 'new version';
+  const state = String(status?.state || '').toLowerCase();
+  if (state === 'downloading') {
+    const progress = Math.max(0, Math.min(100, Math.round(Number(status?.progress || 0))));
+    return `Update available · ${version} · downloading ${progress}%`;
+  }
+  if (state === 'downloaded') return `Update available · ${version} · ready to install`;
+  if (state === 'error') return `Update available · ${version} · click to retry`;
+  return `Update available · ${version}`;
+}
+
+function ensureUpdateIndicatorStyle() {
+  if (document.getElementById(UPDATE_STYLE_ID)) return;
+  const style = document.createElement('style');
+  style.id = UPDATE_STYLE_ID;
+  style.textContent = `
+    #${UPDATE_INDICATOR_ID} {
+      position: fixed;
+      left: 16px;
+      bottom: 16px;
+      z-index: 2147483000;
+      width: 32px;
+      height: 32px;
+      box-sizing: border-box;
+      display: none;
+      align-items: center;
+      justify-content: center;
+      border: 0;
+      border-radius: 50%;
+      background: #3b82f6;
+      color: #fff;
+      box-shadow: 0 1px 3px rgba(15, 23, 42, 0.16);
+      cursor: pointer;
+      padding: 0;
+      font: inherit;
+      line-height: 0;
+      appearance: none;
+      -webkit-app-region: no-drag;
+      transition: background 120ms ease, box-shadow 120ms ease, opacity 120ms ease;
+    }
+    #${UPDATE_INDICATOR_ID}:hover {
+      background: #2563eb;
+      box-shadow: 0 2px 6px rgba(37, 99, 235, 0.28);
+    }
+    #${UPDATE_INDICATOR_ID}:focus-visible {
+      outline: 2px solid #60a5fa;
+      outline-offset: 2px;
+    }
+    #${UPDATE_INDICATOR_ID}[data-busy="true"] {
+      cursor: progress;
+      opacity: 0.72;
+    }
+    #${UPDATE_INDICATOR_ID} svg {
+      width: 20px;
+      height: 20px;
+      flex: 0 0 20px;
+      display: block;
+      pointer-events: none;
+    }
+    #${UPDATE_INDICATOR_ID} .mindexec-update-tooltip {
+      position: absolute;
+      left: 40px;
+      bottom: 50%;
+      transform: translateY(50%) translateX(-2px);
+      opacity: 0;
+      visibility: hidden;
+      pointer-events: none;
+      white-space: nowrap;
+      padding: 6px 9px;
+      border-radius: 7px;
+      background: rgba(15, 23, 42, 0.96);
+      color: #f8fafc;
+      font-size: 12px;
+      font-weight: 600;
+      line-height: 1.2;
+      letter-spacing: 0.01em;
+      box-shadow: 0 6px 20px rgba(15, 23, 42, 0.18);
+      transition: opacity 100ms ease, transform 100ms ease, visibility 100ms ease;
+    }
+    #${UPDATE_INDICATOR_ID}:hover .mindexec-update-tooltip,
+    #${UPDATE_INDICATOR_ID}:focus-visible .mindexec-update-tooltip {
+      opacity: 1;
+      visibility: visible;
+      transform: translateY(50%) translateX(0);
+    }
+  `;
+  (document.head || document.documentElement).appendChild(style);
+}
+
+function ensureUpdateIndicator() {
+  if (!document.body) return null;
+  ensureUpdateIndicatorStyle();
+  let button = document.getElementById(UPDATE_INDICATOR_ID);
+  if (button) return button;
+
+  button = document.createElement('button');
+  button.id = UPDATE_INDICATOR_ID;
+  button.type = 'button';
+  button.setAttribute('aria-live', 'polite');
+  button.innerHTML = `
+    <svg viewBox="0 0 24 24" fill="none" aria-hidden="true">
+      <path d="M12 3.5v10.75m0 0 4.25-4.25M12 14.25 7.75 10M5 19.5h14" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+    </svg>
+    <span class="mindexec-update-tooltip" role="tooltip"></span>
+  `;
+  button.addEventListener('click', async () => {
+    if (updateInstallBusy) return;
+    updateInstallBusy = true;
+    button.dataset.busy = 'true';
+    const tooltip = button.querySelector('.mindexec-update-tooltip');
+    if (tooltip) tooltip.textContent = `Updating MindExec · ${updateVersion(latestUpdateStatus) || ''}`.trim();
+    try {
+      const result = await ipcRenderer.invoke('updates:install');
+      renderUpdateIndicator(result);
+    } catch (error) {
+      renderUpdateIndicator({
+        ...(latestUpdateStatus || {}),
+        state: 'error',
+        error: String(error?.message || error)
+      });
+    } finally {
+      updateInstallBusy = false;
+      button.dataset.busy = 'false';
+    }
+  });
+  document.body.appendChild(button);
+  return button;
+}
+
+function renderUpdateIndicator(status) {
+  latestUpdateStatus = status || latestUpdateStatus || { state: 'unavailable' };
+  const button = ensureUpdateIndicator();
+  if (!button) return;
+
+  if (!shouldShowUpdateIndicator(latestUpdateStatus)) {
+    button.style.display = 'none';
+    return;
+  }
+
+  const tooltipText = buildUpdateTooltip(latestUpdateStatus);
+  button.style.display = 'flex';
+  button.dataset.state = String(latestUpdateStatus.state || 'available');
+  button.setAttribute('aria-label', `${tooltipText}. Click to update MindExec.`);
+  const tooltip = button.querySelector('.mindexec-update-tooltip');
+  if (tooltip && updateInstallBusy !== true) tooltip.textContent = tooltipText;
+}
+
+async function bootstrapUpdateIndicator() {
+  try {
+    renderUpdateIndicator(await ipcRenderer.invoke('updates:get-status'));
+  } catch {
+    renderUpdateIndicator({ state: 'unavailable' });
+  }
+}
+
+ipcRenderer.on('updates:status', (_event, payload) => renderUpdateIndicator(payload));
+if (document.readyState === 'loading') {
+  window.addEventListener('DOMContentLoaded', () => void bootstrapUpdateIndicator(), { once: true });
+} else {
+  void bootstrapUpdateIndicator();
+}
+
 contextBridge.exposeInMainWorld('mindExecDesktop', {
   updates: {
     getStatus: () => ipcRenderer.invoke('updates:get-status'),

package/electron/source-smoke.mjs

@@ -33,6 +33,9 @@ assert.match(packageJson.scripts?.['desktop:publish:update:dev'] || '', /--chann
   'The explicit development update publishing command is missing.');
 assert.equal(packageJson.dependencies?.['electron-updater'], '^6.8.9', 'The packaged updater dependency is missing.');
 assert.equal(packageJson.build?.extraMetadata?.desktopUpdateChannel, 'dev', 'Development installers must stay on the dev feed.');
+assert.equal(packageJson.build?.extraMetadata?.nativeCoreMode, 'native',
+  'Packaged development builds must use the validated native-primary core with bounded JS fallback.');
+assert.match(mainSource, /waitForNativeCoreSmoke/, 'Packaged smoke must verify the native Wasm runtime, not only its URL mode.');
 assert.equal(packageJson.build?.publish?.provider, 'generic', 'Desktop updates must use the generic R2-backed provider.');
 assert.equal(packageJson.build?.publish?.useMultipleRangeRequest, false,
   'Packaged differential downloads must use one byte range per request.');
@@ -95,7 +98,17 @@ assert.match(mainSource, /updates:check/, 'The manual updater check IPC contract
 assert.match(mainSource, /updates:install/, 'The updater install IPC contract is missing.');
 assert.match(mainSource, /await stopBundledBridge\(\)[\s\S]{0,180}await waitForBundledRuntimePortsReleased\(\)/,
   'The Bridge and RemoteHub ports must reach zero before the installer starts.');
-assert.match(mainSource, /Restart and update/, 'A downloaded update must ask before restarting active work.');
+assert.doesNotMatch(mainSource, /Restart and update|promptForDownloadedUpdate|showMessageBox\(mainWindow/, 'Update availability must not open a restart modal.');
+assert.match(preloadSource, /mindexec-desktop-update-indicator/, 'The bottom-left update indicator is missing.');
+assert.match(preloadSource, /Update available ·/, 'The update indicator tooltip must include the available version.');
+assert.match(preloadSource, /left:\s*16px[\s\S]*bottom:\s*16px/, 'The update indicator must stay at the bottom-left.');
+assert.match(preloadSource, /width:\s*32px[\s\S]{0,80}height:\s*32px/,
+  'The update indicator must keep the compact circular-button dimensions.');
+assert.match(preloadSource, /align-items:\s*center[\s\S]{0,80}justify-content:\s*center/,
+  'The update indicator icon must stay centered in both directions.');
+assert.match(preloadSource, /border:\s*0[\s\S]{0,80}border-radius:\s*50%[\s\S]{0,100}background:\s*#3b82f6[\s\S]{0,60}color:\s*#fff/,
+  'The update indicator must keep the filled blue circle and white icon style.');
+assert.match(preloadSource, /ipcRenderer\.invoke\('updates:install'\)/, 'Clicking the update indicator must use the owned install IPC path.');
 assert.match(preloadSource, /mindExecDesktop/, 'The updater preload namespace changed unexpectedly.');
 assert.match(preloadSource, /updates:\s*\{/, 'The updater preload API is missing.');
 assert.match(updateManagerSource, /autoDownload\s*=\s*false/, 'Updates must not download through an unowned implicit path.');

package/electron/windows-package-smoke.mjs

@@ -126,6 +126,22 @@ try {
   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.url,
+    `http://127.0.0.1:${bridgePort}/mindcanvas?nativeCore=native`,
+    'Packaged Electron did not enable the validated native-primary core.'
+  );
+  assert.equal(result.nativeCore?.mode, 'native', 'Packaged Electron native core mode did not reach the page runtime.');
+  assert.equal(result.nativeCore?.ready, true, 'Packaged Electron native core worker did not become ready.');
+  assert.match(result.nativeCore?.backend || '', /^wasm-(?:simd|scalar)$/,
+    'Packaged Electron native core did not load a scalar or SIMD Wasm backend.');
+  assert.equal(result.nativeCore?.fallbackActive, false,
+    `Packaged Electron fell back from its native primary: ${result.nativeCore?.fallbackReason || 'unknown reason'}`);
+  assert.ok(Number(result.nativeCore?.primaryResults || 0) > 0,
+    'Packaged Electron became ready but did not apply a native-core result.');
+  assert.match(result.nativeCore?.lastPrimaryResultType || '', /^(?:VISIBILITY|HIT_TEST|SELECTION_QUERY)_RESULT$/,
+    'Packaged Electron did not report the accepted native-core result type.');
+  assert.equal(result.nativeCore?.lastError, '', 'Packaged Electron native core reported an initialization error.');
   assert.equal(result.windowTitle, `MindExec ${packageJson.version}`,
     'Packaged Electron did not keep the version visible in the title bar.');
   assert.equal(result.bridgePort, bridgePort, 'Packaged shell did not use the requested Bridge port.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.483",
+  "version": "0.2.494",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -112,10 +112,11 @@
     "productName": "MindExec",
     "copyright": "Copyright © 2026 lovecrdm77",
     "asar": false,
-    "extraMetadata": {
-      "main": "electron/main.cjs",
-      "desktopUpdateChannel": "dev"
-    },
+    "extraMetadata": {
+      "main": "electron/main.cjs",
+      "desktopUpdateChannel": "dev",
+      "nativeCoreMode": "native"
+    },
     "directories": {
       "output": "../artifacts/electron"
     },
@@ -160,10 +161,10 @@
     "portable": {
       "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
     },
-    "publish": {
-      "provider": "generic",
-      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64",
-      "useMultipleRangeRequest": false
-    }
+    "publish": {
+      "provider": "generic",
+      "url": "https://mindexec.lovecrdm.workers.dev/dev/windows/x64",
+      "useMultipleRangeRequest": false
+    }
   }
 }