@mindexec/cli 0.2.447 → 0.2.448

package/README.md

@@ -5,9 +5,12 @@
 ## npm quick start
 
 ```bash
-npx @mindexec/cli
+npx -y mindexec@latest
 ```
 
+`mindexec` is the short official launcher alias. Existing
+`npx -y @mindexec/cli@latest` commands remain compatible.
+
 The npm CLI now starts both pieces of the local product:
 
 - MindCanvas app: `http://localhost:5147/mindcanvas`
@@ -23,7 +26,7 @@ run the command. Run it from the folder that contains your `.mindexec` data, or
 pass the workspace explicitly:
 
 ```bash
-npx @mindexec/cli --workspace /path/to/workspace
+npx -y mindexec@latest --workspace /path/to/workspace
 ```
 
 For local frontend development, keep LocalBridge running and refresh the
@@ -45,13 +48,40 @@ precompressed static files from the npm bundle by default. Use
 `-KeepPackagedGalleryImages` or `-KeepPackagedPrecompressedAssets` only when
 testing a full untrimmed local package.
 
+## Standalone Electron desktop app
+
+The Electron build contains both the published MindCanvas frontend and
+LocalBridge runtime. It does not discover, replace, or reuse a separately
+running `npx` Bridge. Each desktop launch allocates dedicated available
+LocalBridge and RemoteHub ports, starts its bundled runtime, and releases those
+ports when the app exits.
+
+Build Windows installer and portable artifacts:
+
+```powershell
+cd LocalBridge
+npm run desktop:build:win
+npm run test:desktop:win
+```
+
+Release artifacts are written to `artifacts/electron`:
+
+- `MindExec-Setup-<version>-x64.exe`
+- `MindExec-Portable-<version>-x64.exe`
+- `win-unpacked/MindExec.exe`
+
+The default desktop workspace is `Documents/MindExecution`. Set
+`MINDEXEC_DESKTOP_WORKSPACE` to use an explicit workspace. Store signing,
+Partner Center identity, Apple provisioning, and sandbox entitlements are
+release-channel credentials and are intentionally not embedded in source.
+
 ## Remote Direct quick start
 
 LocalBridge also starts a separate RemoteHub listener for direct remote-agent
 experiments. By default it binds to loopback only:
 
 ```bash
-npx @mindexec/cli
+npx -y mindexec@latest
 npx @mindexec/remote connect --manager 127.0.0.1:5198 --pair <pair-token>
 ```
 
@@ -67,7 +97,7 @@ LAN/direct mode must be enabled explicitly by changing the RemoteHub bind host:
 $env:REMOTE_HUB_HOST="0.0.0.0"
 $env:REMOTE_HUB_PORT="5198"
 $env:REMOTE_HUB_PAIR_TOKEN="<strong-token>"
-npx @mindexec/cli
+npx -y mindexec@latest
 ```
 
 Device inventory is intentionally not paginated:

package/electron/main.cjs

@@ -0,0 +1,347 @@
+'use strict';
+
+const { app, BrowserWindow, dialog } = require('electron');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const http = require('http');
+const net = require('net');
+const path = require('path');
+
+const DEFAULT_BRIDGE_PORT = 5147;
+const DEFAULT_REMOTE_HUB_PORT = 5198;
+const STARTUP_TIMEOUT_MS = 45_000;
+const HEALTH_POLL_MS = 250;
+
+let mainWindow = null;
+let bridgeChild = null;
+let isQuitting = false;
+let requestedExitCode = 0;
+let activeBridgePort = DEFAULT_BRIDGE_PORT;
+let activeRemoteHubPort = DEFAULT_REMOTE_HUB_PORT;
+let activeWorkspace = '';
+
+function parsePort(value) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isInteger(parsed) && parsed > 0 && parsed <= 65_535 ? parsed : 0;
+}
+
+function requestJson(url, timeoutMs = 2_000) {
+  return new Promise((resolve, reject) => {
+    const request = http.get(url, { timeout: timeoutMs }, (response) => {
+      let body = '';
+      response.setEncoding('utf8');
+      response.on('data', (chunk) => {
+        body += chunk;
+      });
+      response.on('end', () => {
+        if (response.statusCode < 200 || response.statusCode >= 300) {
+          reject(new Error(`HTTP ${response.statusCode} from ${url}`));
+          return;
+        }
+
+        try {
+          resolve(JSON.parse(body));
+        } catch (error) {
+          reject(new Error(`Invalid JSON from ${url}: ${error.message}`));
+        }
+      });
+    });
+
+    request.on('timeout', () => {
+      request.destroy(new Error(`Timed out requesting ${url}`));
+    });
+    request.on('error', reject);
+  });
+}
+
+function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+    server.once('error', () => resolve(false));
+    server.listen({ host: '127.0.0.1', port, exclusive: true }, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+async function resolveDedicatedPort(explicitValue, defaultPort, label, excludedPort = 0) {
+  const explicitPort = parsePort(explicitValue);
+  if (explicitPort) {
+    if (explicitPort === excludedPort) {
+      throw new Error(`${label} port ${explicitPort} conflicts with the bundled LocalBridge port.`);
+    }
+    if (!await isPortAvailable(explicitPort)) {
+      throw new Error(`${label} port ${explicitPort} is already occupied.`);
+    }
+    return explicitPort;
+  }
+
+  for (let offset = 0; offset < 100; offset += 1) {
+    const candidate = defaultPort + offset;
+    if (candidate !== excludedPort && candidate <= 65_535 && await isPortAvailable(candidate)) {
+      return candidate;
+    }
+  }
+
+  throw new Error(`No free ${label} port was found from ${defaultPort}.`);
+}
+
+function appendDesktopLog(message) {
+  const line = `[${new Date().toISOString()}] ${message}\n`;
+  try {
+    const logDirectory = app.getPath('logs');
+    fs.mkdirSync(logDirectory, { recursive: true });
+    fs.appendFileSync(path.join(logDirectory, 'desktop.log'), line, 'utf8');
+  } catch {
+    process.stderr.write(line);
+  }
+}
+
+function spawnBundledBridge(packageRoot) {
+  const serverPath = path.join(packageRoot, 'server.js');
+  const frontendPath = path.join(packageRoot, 'wwwroot', 'index.html');
+  if (!fs.existsSync(serverPath)) {
+    throw new Error(`Bundled LocalBridge entry is missing: ${serverPath}`);
+  }
+  if (!fs.existsSync(frontendPath)) {
+    throw new Error(`Bundled MindCanvas frontend is missing: ${frontendPath}`);
+  }
+
+  const child = spawn(process.execPath, [serverPath], {
+    cwd: packageRoot,
+    env: {
+      ...process.env,
+      ELECTRON_RUN_AS_NODE: '1',
+      MINDEXEC_DESKTOP: '1',
+      MINDEXEC_NO_OPEN: '1',
+      WORKSPACE_PATH: activeWorkspace,
+      BRIDGE_PORT: String(activeBridgePort),
+      REMOTE_HUB_PORT: String(activeRemoteHubPort)
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true
+  });
+
+  child.stdout?.on('data', (chunk) => appendDesktopLog(`[bridge] ${String(chunk).trimEnd()}`));
+  child.stderr?.on('data', (chunk) => appendDesktopLog(`[bridge:error] ${String(chunk).trimEnd()}`));
+  child.on('error', (error) => appendDesktopLog(`[bridge:spawn-error] ${error.stack || error.message}`));
+  child.on('exit', (code, signal) => {
+    appendDesktopLog(`[bridge:exit] code=${String(code)} signal=${String(signal)}`);
+    if (!isQuitting && process.env.MINDEXEC_DESKTOP_SMOKE !== '1') {
+      dialog.showErrorBox(
+        'MindExec LocalBridge stopped',
+        `The bundled local runtime exited unexpectedly (code ${String(code)}, signal ${String(signal)}).`
+      );
+    }
+  });
+
+  bridgeChild = child;
+}
+
+async function waitForBundledBridge() {
+  const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+  let lastError = null;
+
+  while (Date.now() < deadline) {
+    if (bridgeChild && bridgeChild.exitCode !== null) {
+      throw new Error(`Bundled LocalBridge exited during startup with code ${bridgeChild.exitCode}.`);
+    }
+
+    try {
+      const status = await requestJson(`http://127.0.0.1:${activeBridgePort}/api/status?refresh=cache`);
+      if (status?.status === 'ok' && status?.workspace) {
+        return status;
+      }
+    } catch (error) {
+      lastError = error;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, HEALTH_POLL_MS));
+  }
+
+  throw new Error(
+    `Bundled LocalBridge did not become ready on port ${activeBridgePort}: ${lastError?.message || 'timeout'}`
+  );
+}
+
+async function prepareBundledRuntime() {
+  const packageRoot = path.resolve(__dirname, '..');
+  activeBridgePort = await resolveDedicatedPort(process.env.BRIDGE_PORT, DEFAULT_BRIDGE_PORT, 'LocalBridge');
+  activeRemoteHubPort = await resolveDedicatedPort(
+    process.env.REMOTE_HUB_PORT,
+    DEFAULT_REMOTE_HUB_PORT,
+    'RemoteHub',
+    activeBridgePort
+  );
+  activeWorkspace = path.resolve(
+    process.env.MINDEXEC_DESKTOP_WORKSPACE
+      || process.env.WORKSPACE_PATH
+      || path.join(app.getPath('documents'), 'MindExecution')
+  );
+
+  fs.mkdirSync(activeWorkspace, { recursive: true });
+  appendDesktopLog(
+    `Starting bundled runtime: bridge=${activeBridgePort}, remoteHub=${activeRemoteHubPort}, workspace=${activeWorkspace}`
+  );
+  spawnBundledBridge(packageRoot);
+  return waitForBundledBridge();
+}
+
+function createMainWindow() {
+  const hiddenSmokeMode = process.env.MINDEXEC_DESKTOP_SMOKE === '1';
+  const window = new BrowserWindow({
+    width: 1440,
+    height: 960,
+    minWidth: 960,
+    minHeight: 640,
+    show: !hiddenSmokeMode,
+    autoHideMenuBar: true,
+    backgroundColor: '#0b1020',
+    title: 'MindExec',
+    webPreferences: {
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: true,
+      webSecurity: true
+    }
+  });
+
+  window.webContents.setWindowOpenHandler(() => ({
+    action: 'allow',
+    overrideBrowserWindowOptions: {
+      autoHideMenuBar: true,
+      webPreferences: {
+        contextIsolation: true,
+        nodeIntegration: false,
+        sandbox: true,
+        webSecurity: true
+      }
+    }
+  }));
+
+  window.on('closed', () => {
+    if (mainWindow === window) {
+      mainWindow = null;
+    }
+  });
+
+  mainWindow = window;
+  return window;
+}
+
+function writeSmokeResult(payload) {
+  const resultPath = process.env.MINDEXEC_DESKTOP_SMOKE_RESULT;
+  if (!resultPath) {
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(resultPath), { recursive: true });
+  fs.writeFileSync(resultPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+
+async function stopBundledBridge() {
+  const child = bridgeChild;
+  bridgeChild = null;
+  if (!child || child.exitCode !== null) {
+    return;
+  }
+
+  await new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolve();
+    };
+
+    child.once('exit', finish);
+    try {
+      child.kill('SIGTERM');
+    } catch {
+      finish();
+      return;
+    }
+
+    setTimeout(() => {
+      if (child.exitCode === null) {
+        try {
+          child.kill('SIGKILL');
+        } catch {
+          // The child may have exited between the check and the kill.
+        }
+      }
+      finish();
+    }, 5_000).unref();
+  });
+}
+
+async function launchDesktop() {
+  const status = await prepareBundledRuntime();
+  const window = createMainWindow();
+  const appUrl = `http://127.0.0.1:${activeBridgePort}/mindcanvas`;
+  await window.loadURL(appUrl);
+
+  if (process.env.MINDEXEC_DESKTOP_SMOKE === '1') {
+    writeSmokeResult({
+      ok: true,
+      appVersion: app.getVersion(),
+      bridgeVersion: status.version || null,
+      runtimeMode: 'bundled',
+      bridgePort: activeBridgePort,
+      remoteHubPort: activeRemoteHubPort,
+      workspace: activeWorkspace,
+      url: appUrl
+    });
+    setTimeout(() => app.quit(), 250).unref();
+  }
+}
+
+const hasSingleInstanceLock = app.requestSingleInstanceLock();
+if (!hasSingleInstanceLock) {
+  app.quit();
+} else {
+  app.on('second-instance', () => {
+    if (mainWindow) {
+      if (mainWindow.isMinimized()) {
+        mainWindow.restore();
+      }
+      mainWindow.focus();
+    }
+  });
+
+  app.on('window-all-closed', () => {
+    app.quit();
+  });
+
+  app.on('before-quit', (event) => {
+    if (isQuitting || !bridgeChild || bridgeChild.exitCode !== null) {
+      return;
+    }
+
+    event.preventDefault();
+    isQuitting = true;
+    stopBundledBridge().finally(() => app.exit(requestedExitCode));
+  });
+
+  app.whenReady()
+    .then(launchDesktop)
+    .catch((error) => {
+      const message = error?.stack || String(error);
+      appendDesktopLog(`[desktop:start-error] ${message}`);
+      writeSmokeResult({
+        ok: false,
+        appVersion: app.getVersion(),
+        runtimeMode: 'bundled',
+        error: error?.message || String(error)
+      });
+
+      requestedExitCode = 1;
+      if (process.env.MINDEXEC_DESKTOP_SMOKE !== '1') {
+        dialog.showErrorBox('MindExec failed to start', error?.message || String(error));
+      }
+      app.quit();
+    });
+}

package/electron/source-smoke.mjs

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const electronDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(electronDirectory, '..');
+const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+const mainSource = fs.readFileSync(path.join(electronDirectory, 'main.cjs'), 'utf8');
+
+assert.equal(packageJson.build?.appId, 'com.mindexec.desktop', 'Stable desktop appId is required.');
+assert.equal(packageJson.build?.productName, 'MindExec', 'Desktop product name changed unexpectedly.');
+assert.equal(packageJson.build?.extraMetadata?.main, 'electron/main.cjs', 'Packaged Electron entry point is missing.');
+assert.equal(packageJson.build?.asar, false, 'Bundled runtime executables require an unpacked app directory.');
+assert.ok(packageJson.files?.includes('electron/'), 'The npm package must include the Electron source contract.');
+assert.match(packageJson.scripts?.['desktop:build:win'] || '', /electron-builder/, 'Windows build script is missing.');
+assert.match(packageJson.scripts?.['test:desktop:win'] || '', /windows-package-smoke/, 'Packaged smoke test is missing.');
+
+const targets = packageJson.build?.win?.target || [];
+assert.ok(targets.some((target) => target.target === 'nsis'), 'NSIS target is required.');
+assert.ok(targets.some((target) => target.target === 'portable'), 'Portable target is required.');
+
+assert.match(mainSource, /contextIsolation:\s*true/, 'Electron renderer isolation must remain enabled.');
+assert.match(mainSource, /nodeIntegration:\s*false/, 'Node integration must remain disabled.');
+assert.match(mainSource, /sandbox:\s*true/, 'Electron renderer sandbox must remain enabled.');
+assert.match(mainSource, /runtimeMode:\s*'bundled'/, 'Packaged runtime must report bundled mode.');
+assert.match(mainSource, /spawnBundledBridge/, 'Electron must start its bundled LocalBridge.');
+assert.match(mainSource, /wwwroot.*index\.html/s, 'Electron must verify its bundled frontend.');
+assert.match(mainSource, /resolveDedicatedPort/, 'Electron must allocate dedicated local ports.');
+assert.doesNotMatch(mainSource, /adopted|probeBridge/, 'Electron must not adopt an external LocalBridge.');
+assert.match(mainSource, /MINDEXEC_DESKTOP_SMOKE_RESULT/, 'Packaged runtime smoke contract is missing.');
+
+console.log(JSON.stringify({
+  ok: true,
+  appId: packageJson.build.appId,
+  version: packageJson.version,
+  runtimeMode: 'bundled',
+  targets: targets.map((target) => `${target.target}:${target.arch.join(',')}`)
+}));

package/electron/windows-package-smoke.mjs

@@ -0,0 +1,147 @@
+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';
+
+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, 'workspace');
+const resultPath = path.join(smokeRoot, 'result.json');
+fs.mkdirSync(workspace, { recursive: true });
+
+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: workspace,
+      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.');
+
+  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,
+    bridgePortReleased: true,
+    remoteHubPortReleased: true
+  }));
+} finally {
+  if (child && child.exitCode === null) {
+    child.kill('SIGKILL');
+  }
+  fs.rmSync(smokeRoot, { recursive: true, force: true });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindexec/cli",
-  "version": "0.2.447",
+  "version": "0.2.448",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -16,16 +16,21 @@
     "codex-runtime.js",
     "codex-model-catalog.js",
     "port-guard.cjs",
-    "remote-fast/",
-    "wwwroot/",
-    "scripts/",
+    "remote-fast/",
+    "wwwroot/",
+    "electron/",
+    "scripts/",
     "tree-sitter-grammars/",
     "README.md"
   ],
-  "scripts": {
-    "start": "node launch-bridge.cjs",
-    "dev": "node launch-bridge.cjs --watch",
-    "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 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/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",
+  "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",
+    "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 electron/main.cjs && node --check electron/source-smoke.mjs && node --check electron/windows-package-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/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-model-catalog": "node scripts/codex-model-catalog-smoke.mjs",
     "test:codex-model-catalog:live": "node scripts/codex-model-catalog-smoke.mjs --live",
     "test:auth": "node scripts/auth-session-smoke.mjs",
@@ -53,7 +58,7 @@
     "local",
     "ai"
   ],
-  "author": "",
+  "author": "lovecrdm77",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -82,7 +87,62 @@
     "mindexec": "launch-bridge.cjs",
     "mind-bridge": "launch-bridge.cjs"
   },
-  "devDependencies": {
-    "tree-sitter-wasms": "^0.1.13"
-  }
-}
+  "devDependencies": {
+    "electron": "43.2.0",
+    "electron-builder": "26.15.3",
+    "tree-sitter-wasms": "^0.1.13"
+  },
+  "build": {
+    "appId": "com.mindexec.desktop",
+    "productName": "MindExec",
+    "copyright": "Copyright © 2026 lovecrdm77",
+    "asar": false,
+    "extraMetadata": {
+      "main": "electron/main.cjs"
+    },
+    "directories": {
+      "output": "../artifacts/electron"
+    },
+    "files": [
+      "*.js",
+      "*.cjs",
+      "*.json",
+      "electron/main.cjs",
+      "remote-fast/**/*",
+      "scripts/**/*",
+      "tree-sitter-grammars/**/*",
+      "wwwroot/**/*",
+      "node_modules/**/*"
+    ],
+    "win": {
+      "icon": "../MindExecution.Web/wwwroot/icon-512.png",
+      "executableName": "MindExec",
+      "target": [
+        {
+          "target": "nsis",
+          "arch": [
+            "x64"
+          ]
+        },
+        {
+          "target": "portable",
+          "arch": [
+            "x64"
+          ]
+        }
+      ]
+    },
+    "nsis": {
+      "artifactName": "MindExec-Setup-${version}-${arch}.${ext}",
+      "oneClick": false,
+      "perMachine": false,
+      "allowToChangeInstallationDirectory": true,
+      "createDesktopShortcut": true,
+      "createStartMenuShortcut": true,
+      "shortcutName": "MindExec"
+    },
+    "portable": {
+      "artifactName": "MindExec-Portable-${version}-${arch}.${ext}"
+    }
+  }
+}