@mindexec/cli 0.2.447 → 0.2.449

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/codex-runtime.js

@@ -247,12 +247,28 @@ function makeEmptyResult(overrides = {}) {
         changedFiles: [],
         commandLogs: [],
         approvalEvents: [],
+        toolEvents: [],
         rawEventCount: 0,
         ...overrides
     };
 }
 
-function collectItem(result, item) {
+function upsertToolEvent(result, event) {
+    const id = String(event?.id || '').trim();
+    const type = String(event?.type || '').trim();
+    const name = String(event?.name || '').trim();
+    const key = id || `${type}:${name}`;
+    const index = result.toolEvents.findIndex(existing =>
+        (String(existing?.id || '').trim() || `${existing?.type || ''}:${existing?.name || ''}`) === key);
+    if (index >= 0) {
+        result.toolEvents[index] = event;
+        return;
+    }
+
+    result.toolEvents.push(event);
+}
+
+function collectItem(result, item, eventType = '') {
     if (!item || typeof item !== 'object') {
         return;
     }
@@ -295,6 +311,51 @@ function collectItem(result, item) {
             exitCode: Number.isFinite(Number(item.exit_code)) ? Number(item.exit_code) : null,
             output: truncateLog(item.aggregated_output)
         });
+        upsertToolEvent(result, {
+            id: String(item.id || ''),
+            type: 'command_execution',
+            name: String(item.command || '').trim() || 'Shell',
+            status: String(item.status || eventType || ''),
+            summary: truncateLog(item.aggregated_output, 1200)
+        });
+        return;
+    }
+
+    if (item.type === 'web_search') {
+        upsertToolEvent(result, {
+            id: String(item.id || ''),
+            type: 'web_search',
+            name: 'WebSearch',
+            status: eventType === 'item.completed' ? 'completed' : 'running',
+            summary: truncateLog(item.query, 1200)
+        });
+        return;
+    }
+
+    if (item.type === 'mcp_tool_call') {
+        const server = String(item.server || '').trim();
+        const tool = String(item.tool || '').trim();
+        upsertToolEvent(result, {
+            id: String(item.id || ''),
+            type: 'mcp_tool_call',
+            name: [server, tool].filter(Boolean).join('.') || 'MCP',
+            status: String(item.status || eventType || ''),
+            summary: item.error?.message
+                ? truncateLog(item.error.message, 1200)
+                : truncateLog(JSON.stringify(item.arguments ?? {}), 1200)
+        });
+        return;
+    }
+
+    if (item.type === 'todo_list') {
+        const items = Array.isArray(item.items) ? item.items : [];
+        upsertToolEvent(result, {
+            id: String(item.id || ''),
+            type: 'todo_list',
+            name: 'Plan',
+            status: eventType === 'item.completed' ? 'completed' : 'running',
+            summary: truncateLog(items.map(entry => `${entry?.completed ? '[x]' : '[ ]'} ${entry?.text || ''}`).join('\n'), 1200)
+        });
         return;
     }
 
@@ -422,6 +483,8 @@ function serializeThreadOptionsForStatus(options) {
         sandboxMode: API_SANDBOX_BY_SDK_VALUE[options?.sandboxMode] || options?.sandboxMode || null,
         reasoningEffort: options?.modelReasoningEffort || null,
         approvalPolicy: options?.approvalPolicy || null,
+        networkAccessEnabled: options?.networkAccessEnabled ?? null,
+        webSearchMode: options?.webSearchMode || null,
         workingDirectory: options?.workingDirectory || null
     };
 }
@@ -548,11 +611,6 @@ export function createCodexRuntime(options) {
             return PROVIDER_KIND.legacyExec;
         }
 
-        const fallbackLegacy = legacy || await checkLegacyAvailability();
-        if (requested === PROVIDER_KIND.typeScriptSdk && fallbackLegacy?.available) {
-            return PROVIDER_KIND.legacyExec;
-        }
-
         return PROVIDER_KIND.unavailable;
     }
 
@@ -711,7 +769,7 @@ export function createCodexRuntime(options) {
                     result.threadId = record.officialThreadId;
                     threads.set(record.officialThreadId, record);
                 } else if (event.type === 'item.completed' || event.type === 'item.updated' || event.type === 'item.started') {
-                    collectItem(result, event.item);
+                    collectItem(result, event.item, event.type);
                 } else if (event.type === 'turn.failed') {
                     result.error = event.error?.message || 'Codex turn failed.';
                     result.status = 'failed';

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(',')}`)
+}));