@mindexec/cli 0.2.447 → 0.2.449

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.449",
   "description": "MindExec local runtime and bridge CLI",
   "main": "server.js",
   "type": "module",
@@ -16,16 +16,24 @@
     "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/codex-sdk-runtime-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-sdk": "node scripts/codex-sdk-runtime-smoke.mjs",
+    "test:codex-sdk:live": "node scripts/codex-sdk-runtime-smoke.mjs --live",
+    "test:codex-sdk:live-tools": "node scripts/codex-sdk-runtime-smoke.mjs --live-tools",
     "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 +61,7 @@
     "local",
     "ai"
   ],
-  "author": "",
+  "author": "lovecrdm77",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -82,7 +90,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}"
+    }
+  }
+}

package/scripts/codex-sdk-runtime-smoke.mjs

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createCodexRuntime } from '../codex-runtime.js';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(scriptDir, '..');
+const workspaceRoot = path.resolve(packageRoot, '..');
+const runLiveTurn = process.argv.includes('--live');
+const runLiveTools = process.argv.includes('--live-tools');
+
+const runtime = createCodexRuntime({
+    packageRoot,
+    resolveWorkingDirectory: async () => workspaceRoot,
+    getCurrentRuntime: () => ({}),
+    getModelCatalog: async () => ({
+        models: [],
+        source: 'smoke',
+        updatedAt: new Date().toISOString()
+    }),
+    log: () => {}
+});
+
+const capabilities = await runtime.getCapabilities();
+const sdkProvider = capabilities.providers.find(provider => provider.kind === 'TypeScriptSdk');
+assert.equal(sdkProvider?.available, true, sdkProvider?.error || 'Codex TypeScript SDK must be available.');
+assert.equal(capabilities.preferredProviderKind, 'TypeScriptSdk');
+
+const started = await runtime.startThread({
+    providerKind: 'TypeScriptSdk',
+    prompt: 'smoke',
+    workingDir: workspaceRoot,
+    sandbox: 'read_only',
+    approvalPolicy: 'on-request',
+    networkAccessEnabled: true,
+    webSearchMode: 'live'
+});
+assert.equal(started.success, true);
+assert.equal(started.providerKind, 'TypeScriptSdk');
+
+const status = runtime.getThreadStatus(started.threadId);
+assert.equal(status.providerKind, 'TypeScriptSdk');
+assert.equal(status.options.sandboxMode, 'read_only');
+assert.equal(status.options.networkAccessEnabled, true);
+assert.equal(status.options.webSearchMode, 'live');
+
+if (runLiveTurn) {
+    const marker = `CODEX_SDK_RUNTIME_OK_${Date.now()}`;
+    const result = await runtime.runThread({
+        providerKind: 'TypeScriptSdk',
+        prompt: `Return exactly this marker and nothing else: ${marker}`,
+        workingDir: workspaceRoot,
+        sandbox: 'read_only',
+        approvalPolicy: 'on-request',
+        networkAccessEnabled: false,
+        webSearchMode: 'disabled'
+    });
+
+    assert.equal(result.providerKind, 'TypeScriptSdk');
+    assert.equal(result.success, true, result.error || 'Codex SDK live turn failed.');
+    assert.match(result.finalResponse, new RegExp(marker));
+}
+
+if (runLiveTools) {
+    const result = await runtime.runThread({
+        providerKind: 'TypeScriptSdk',
+        prompt: 'Use the built-in web search tool to find the title of the official OpenAI Codex SDK documentation page. Return the title and its source URL.',
+        workingDir: workspaceRoot,
+        sandbox: 'read_only',
+        approvalPolicy: 'on-request',
+        networkAccessEnabled: true,
+        webSearchMode: 'live'
+    });
+
+    assert.equal(result.providerKind, 'TypeScriptSdk');
+    assert.equal(result.success, true, result.error || 'Codex SDK live tool turn failed.');
+    assert.equal(
+        result.toolEvents.some(event => event.type === 'web_search'),
+        true,
+        `Expected a web_search tool event, got: ${JSON.stringify(result.toolEvents)}`);
+}
+
+console.log(JSON.stringify({
+    ok: true,
+    providerKind: capabilities.preferredProviderKind,
+    sdkVersion: sdkProvider?.version || null,
+    liveTurn: runLiveTurn,
+    liveTools: runLiveTools
+}));