@harness-mix/cli 0.1.3

package/src/main/native/launcher.js

@@ -0,0 +1,188 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const net = require('node:net');
+const crypto = require('node:crypto');
+const { spawn, spawnSync, execFileSync } = require('node:child_process');
+const { nativePaths, nativeEnvironment, saveNativeSettings } = require('./config');
+const { runUpdateFlow, reexecLauncher } = require('./updater');
+const { markBootOk, pidAlive } = require('./update-state');
+const { inspectPosix, assertDesktopStopped } = require('./platform');
+const {
+  evaluateDesktopCompatibility,
+  enforceDesktopCompatibility,
+} = require('./compatibility');
+
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+
+function cacheCodexRuntime(resources, cache) {
+  fs.mkdirSync(cache, { recursive: true });
+  // The CLI resolves helper executables next to itself, including code mode.
+  // Repair existing caches as well as preparing a new version.
+  for (const entry of fs.readdirSync(resources, { withFileTypes: true })) {
+    if (!entry.isFile() || !/^(?:codex(?:-.+)?|rg)\.exe$/i.test(entry.name)) continue;
+    const source = path.join(resources, entry.name);
+    const destination = path.join(cache, entry.name);
+    if (!fs.existsSync(destination) || fs.statSync(destination).size !== fs.statSync(source).size) {
+      fs.copyFileSync(source, destination);
+    }
+  }
+  return path.join(cache, 'codex.exe');
+}
+
+function powershell(source) {
+  return execFileSync('pwsh.exe', ['-NoLogo', '-NoProfile', '-Command', source], { encoding: 'utf8', windowsHide: true, timeout: 20000 }).trim();
+}
+
+// Match the verified installation executable; never terminate unrelated apps.
+function stopDesktopProcesses(installation) {
+  if (process.platform !== 'win32') return assertDesktopStopped(installation);
+  const target = installation.executable.replace(/'/g, "''");
+  powershell(`Get-CimInstance Win32_Process | Where-Object { $_.ExecutablePath -eq '${target}' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }`);
+}
+
+// Reports a live host instance and reaps leftovers from crashed or force-killed
+// sessions before a new desktop is activated. Only processes that belong to this
+// project (shim binary path or our known entry scripts) are touched.
+function sweepLeftovers(root, dataDir) {
+  if (process.platform !== 'win32') return;
+  try {
+    const instanceFile = path.join(dataDir, 'runtime', 'instance.json');
+    let instance = null;
+    try { instance = JSON.parse(fs.readFileSync(instanceFile, 'utf8')); } catch { /* no live instance record */ }
+    if (instance && instance.pid && pidAlive(instance.pid) && Date.now() - Number(instance.beatAt || 0) < 30000) {
+      console.warn(`[Harness Mix] 另一宿主实例（pid ${instance.pid}）心跳仍在；继续清扫其残留。`);
+    }
+    const shimDir = path.join(root, 'output', 'native-build').replace(/'/g, "''");
+    const query = `Get-CimInstance Win32_Process | Where-Object { ($_.ExecutablePath -like '${shimDir}\\harness-mix-*.exe') -or ($_.Name -eq 'node.exe' -and ($_.CommandLine -like '*native-host.cjs*' -or $_.CommandLine -like '*desktop-controller.mjs*')) } | Select-Object -ExpandProperty ProcessId`;
+    const output = powershell(query);
+    const start = Date.now();
+    const pids = output.split(/\s+/)
+      .map(value => Number.parseInt(value, 10))
+      .filter(pid => Number.isInteger(pid) && pid > 0 && pid !== process.pid && pid !== process.ppid);
+    for (const pid of pids) spawnSync('taskkill.exe', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+    if (pids.length) console.log(`[Harness Mix] 启动前清扫残留进程 ${pids.length} 个（${Date.now() - start}ms）`);
+  } catch (error) {
+    console.warn(`[Harness Mix] 残留进程清扫失败（不影响启动）：${error.message}`);
+  }
+}
+
+// Stream a file into a sha256 digest. Avoids loading multi-hundred-MB binaries
+// into a single buffer via Buffer.allocUnsafe, which Node rejects with
+// ERR_MEMORY_ALLOCATION_FAILED on 64-bit Windows once the file outgrows the
+// internal pool size (Codex Desktop's bundled codex.exe is ~295 MB).
+function sha256OfFile(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath, { highWaterMark: 1 << 20 });
+    stream.on('data', chunk => hash.update(chunk));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+async function inspect() {
+  if (process.platform !== 'win32') return inspectPosix();
+  const installation = JSON.parse(powershell("$p = Get-AppxPackage -Name OpenAI.Codex | Select-Object -First 1; if (-not $p) { throw 'Codex Desktop not installed' }; $m = Get-AppxPackageManifest $p; @{ root=$p.InstallLocation; fullName=$p.PackageFullName; appId=($p.PackageFamilyName + '!' + @($m.Package.Applications.Application)[0].Id); version=$p.Version.ToString() } | ConvertTo-Json -Compress"));
+  const packaged = path.join(installation.root, 'app/resources/codex.exe');
+  if (!fs.existsSync(packaged)) throw new Error('Packaged Codex CLI not found');
+  // An executable outside WindowsApps avoids package ACL/activation constraints.
+  const digest = (await sha256OfFile(packaged)).slice(0, 16);
+  const cache = path.join(process.env.LOCALAPPDATA, 'Harness Mix/codex', digest);
+  const stock = cacheCodexRuntime(path.dirname(packaged), cache);
+  return { ...installation, stock, executable: path.join(installation.root, 'app/ChatGPT.exe') };
+}
+async function freePort() {
+  const server = net.createServer();
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', resolve); });
+  const port = server.address().port;
+  await new Promise(resolve => server.close(resolve));
+  return port;
+}
+async function launch(args = []) {
+  const root = REPO_ROOT;
+  const flags = new Set(args);
+  const unknown = args.filter(arg => !['--check', '--update', '--no-update'].includes(arg));
+  if (unknown.length) throw new Error('Unsupported Launcher arguments');
+  const dataDir = nativeEnvironment().CODEXHOST_DATA_DIR;
+  if (flags.has('--update')) {
+    const outcome = await runUpdateFlow({
+      root, dataDir, mode: 'apply',
+      stopDesktop: async () => stopDesktopProcesses(await inspect()),
+    });
+    if (outcome.updated || outcome.repaired || outcome.rolledBack) {
+      console.log('[Harness Mix] 更新流程完成，重新运行 npm start 生效。');
+    }
+    return;
+  }
+  const installation = await inspect();
+  const compatibility = installation.version === 'unknown'
+    ? { state: 'unverified', desktopVersion: 'unknown', evidence: null }
+    : evaluateDesktopCompatibility(installation.version);
+  const paths = nativePaths();
+  for (const file of Object.values(paths)) if (!fs.existsSync(file)) throw new Error(`Missing ${file}; run npm run build:native`);
+  if (flags.has('--check')) {
+    console.log(`platform=${process.platform}\narchitecture=${process.arch}\ndesktop_version=${installation.version}\ndesktop_compatibility=${compatibility.state}\ndesktop_evidence=${compatibility.evidence?.level || 'none'}\nexecutable_codex_cli=${installation.stock}\nlauncher=${paths.cli}\nshim=${paths.shim}\nruntime=${paths.runtime}\nrenderer=${paths.renderer}\ncore=src/main/protocol-core`);
+    return;
+  }
+  const skipUpdate = flags.has('--no-update') || process.env.HARNESS_MIX_AUTO_UPDATE === '0';
+  if (!skipUpdate) {
+    const outcome = await runUpdateFlow({
+      root, dataDir, mode: 'apply',
+      stopDesktop: async () => stopDesktopProcesses(installation),
+    });
+    if (outcome.restartRequired) {
+      if (process.env.HARNESS_MIX_UPDATED === '1') throw new Error('更新后重启循环，已停止：请手动运行 npm run check:native 检查安装');
+      console.log('[Harness Mix] 代码已更新，重新加载启动器…');
+      process.exitCode = await reexecLauncher(root, args);
+      return;
+    }
+  }
+  enforceDesktopCompatibility(compatibility);
+  if (compatibility.state !== 'verified') {
+    console.warn(`[Harness Mix] Codex Desktop ${installation.version} compatibility is ${compatibility.state}; protocol checks continue, but full restarted Desktop acceptance is not recorded.`);
+  }
+  const env = nativeEnvironment();
+  saveNativeSettings(env);
+  fs.writeFileSync(path.join(path.dirname(paths.shim), 'node-path.txt'), process.execPath);
+  fs.writeFileSync(path.join(path.dirname(paths.shim), 'stock-path.txt'), installation.stock);
+  const port = await freePort();
+  const attachmentPort = await freePort();
+  const nonce = crypto.randomBytes(16).toString('hex');
+  const overrides = { CODEX_CLI_PATH: paths.shim, CODEXHOST_STOCK_CODEX_PATH: installation.stock,
+    CODEXHOST_DATA_DIR: env.CODEXHOST_DATA_DIR, HARNESS_MIX_NODE_PATH: process.execPath,
+    CODEXHOST_DEFAULT_AGENT: 'codex' };
+  const block = Buffer.from(Object.entries(overrides).map(([k, v]) => `${k}=${v}`).join('\0') + '\0\0', 'utf16le').toString('base64');
+  console.log('[Harness Mix] Restarting Codex Desktop with the local Shim and ProtocolCore.');
+  stopDesktopProcesses(installation);
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  sweepLeftovers(root, dataDir);
+  let desktop;
+  let pid;
+  if (process.platform === 'win32') {
+    pid = execFileSync(paths.activation, [installation.fullName, installation.appId, block, `--remote-debugging-port=${port}`], { encoding: 'utf8', windowsHide: true }).trim();
+  } else {
+    desktop = spawn(installation.executable, [`--remote-debugging-port=${port}`, '--remote-debugging-address=127.0.0.1'],
+      { env: { ...env, ...overrides }, stdio: 'ignore' });
+    await new Promise((resolve, reject) => { desktop.once('spawn', resolve); desktop.once('error', reject); });
+    pid = desktop.pid;
+  }
+  console.log(`[Harness Mix] Desktop PID ${pid}, CDP ${port}`);
+  const controller = spawn(process.execPath, [paths.controller, '--renderer-cdp-endpoint', `http://127.0.0.1:${port}`,
+    '--renderer', paths.renderer, '--default-agent', 'codex', '--attachment-port', String(attachmentPort), '--attachment-nonce', nonce],
+  { env, stdio: 'inherit', windowsHide: true });
+  controller.on('error', error => { console.error(error.message); process.exitCode = 1; });
+  controller.on('exit', code => { process.exitCode = code || 0; });
+  if (desktop) {
+    desktop.once('exit', () => controller.kill('SIGTERM'));
+    // The GUI may remain open after controller failure; do not hold the launcher alive.
+    controller.once('exit', () => desktop.unref());
+    const stop = () => { controller.kill('SIGTERM'); desktop.kill('SIGTERM'); };
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+  }
+  // A healthy boot = the controller still alive after 20s; then a freshly applied
+  // update is marked good and the crash-loop counter resets.
+  const bootTimer = setTimeout(() => { if (controller.exitCode === null) markBootOk(dataDir); }, 20000);
+  controller.on('exit', () => clearTimeout(bootTimer));
+  return controller;
+}
+module.exports = { inspect, launch, cacheCodexRuntime };

package/src/main/native/platform.js

@@ -0,0 +1,64 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { execFileSync } = require('node:child_process');
+
+function dataDirectory(env = process.env, platform = process.platform, home = os.homedir()) {
+  if (env.CODEXHOST_DATA_DIR) return env.CODEXHOST_DATA_DIR;
+  const base = platform === 'win32' ? env.APPDATA || home
+    : platform === 'darwin' ? path.join(home, 'Library', 'Application Support')
+      : env.XDG_DATA_HOME && path.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path.join(home, '.local', 'share');
+  return path.join(base, 'harness-mix', 'codexhost');
+}
+
+function executableName(name, platform = process.platform) {
+  return name + (platform === 'win32' ? '.exe' : '');
+}
+
+function requireExecutable(file, label) {
+  if (!file || !path.isAbsolute(file)) throw new Error(`${label} must be an absolute executable path`);
+  try {
+    if (!fs.statSync(file).isFile()) throw new Error('not a file');
+    fs.accessSync(file, fs.constants.X_OK);
+  } catch { throw new Error(`${label} is missing or not executable: ${file}`); }
+  return fs.realpathSync(file);
+}
+
+// Never modify a signed app bundle or guess a Linux download/vendor URL.
+function inspectPosix(env = process.env, platform = process.platform, run = execFileSync) {
+  if (!['darwin', 'linux'].includes(platform)) throw new Error(`Unsupported platform: ${platform}`);
+  let executable = env.HARNESS_MIX_DESKTOP_EXECUTABLE;
+  let stock = env.CODEXHOST_STOCK_CODEX_PATH;
+  let version = env.HARNESS_MIX_DESKTOP_VERSION;
+  let root;
+  if (platform === 'darwin') {
+    root = env.HARNESS_MIX_DESKTOP_APP || ['/Applications/Codex.app', path.join(os.homedir(), 'Applications/Codex.app')].find(file => fs.existsSync(file));
+    if (root) {
+      const plist = JSON.parse(run('/usr/bin/plutil', ['-convert', 'json', '-o', '-', path.join(root, 'Contents/Info.plist')], { encoding: 'utf8' }));
+      if (!executable && (typeof plist.CFBundleExecutable !== 'string' || !plist.CFBundleExecutable || /[\\/]/.test(plist.CFBundleExecutable))) throw new Error('Invalid CFBundleExecutable in Codex Info.plist');
+      executable ||= path.join(root, 'Contents/MacOS', plist.CFBundleExecutable);
+      stock ||= path.join(root, 'Contents/Resources/codex');
+      version ||= plist.CFBundleShortVersionString || plist.CFBundleVersion;
+    }
+  }
+  if (!executable || !stock) throw new Error('Install Codex Desktop first. On Linux set HARNESS_MIX_DESKTOP_EXECUTABLE and CODEXHOST_STOCK_CODEX_PATH to absolute paths of a compatible Electron desktop and its bundled Codex CLI; Linux desktop availability is not guaranteed. On macOS set HARNESS_MIX_DESKTOP_APP if the .app is outside Applications.');
+  executable = requireExecutable(executable, 'HARNESS_MIX_DESKTOP_EXECUTABLE');
+  stock = requireExecutable(stock, 'CODEXHOST_STOCK_CODEX_PATH');
+  if (version && !/^\d+(?:\.\d+){1,3}$/.test(String(version))) throw new Error('HARNESS_MIX_DESKTOP_VERSION must be a numeric desktop version');
+  return { root: root || path.dirname(executable), executable, stock, version: String(version || 'unknown'), platform };
+}
+
+function assertDesktopStopped(installation) {
+  // An existing Electron singleton would silently discard the new CLI environment.
+  // macOS comm is a path; Linux comm is only a name, so resolve /proc/PID/exe.
+  const rows = execFileSync('ps', ['-ax', '-o', 'pid=', '-o', 'comm='], { encoding: 'utf8' });
+  for (const row of rows.split('\n')) {
+    const match = row.trim().match(/^(\d+)\s+(.+)$/);
+    if (!match || Number(match[1]) === process.pid) continue;
+    let file = match[2];
+    try { file = fs.realpathSync(process.platform === 'linux' ? `/proc/${match[1]}/exe` : file); } catch { /* inaccessible process */ }
+    if (file === installation.executable) throw new Error(`Quit Codex Desktop (PID ${match[1]}) before launching Harness Mix so the Shim environment can take effect.`);
+  }
+}
+
+module.exports = { dataDirectory, executableName, inspectPosix, assertDesktopStopped };

package/src/main/native/process-utils.js

@@ -0,0 +1,57 @@
+// Child-process lifecycle helpers shared by adapters, host runtime and launcher.
+// On Windows a plain child.kill() only terminates the direct child, so CLI
+// wrappers (cmd → npm → node) need taskkill /T to reach the whole tree.
+const { spawn, execFile } = require('node:child_process');
+
+function descendantPids(rows, root) {
+  const children = new Map();
+  for (const row of rows.split('\n')) {
+    const match = row.trim().match(/^(\d+)\s+(\d+)$/);
+    if (!match) continue;
+    const pid = Number(match[1]), parent = Number(match[2]);
+    if (!children.has(parent)) children.set(parent, []);
+    children.get(parent).push(pid);
+  }
+  const result = [], visited = new Set([root]);
+  function visit(parent) {
+    for (const pid of children.get(parent) || []) {
+      if (visited.has(pid) || pid === process.pid) continue;
+      visited.add(pid);
+      visit(pid);
+      result.push(pid);
+    }
+  }
+  visit(root);
+  return result;
+}
+
+// Force-terminate a process tree. Resolves once the attempt finished; never
+// throws and never rejects, so callers can fire-and-forget with `void`.
+function terminateTree(pid, { timeoutMs = 5000 } = {}) {
+  if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid) return Promise.resolve();
+  return new Promise(resolve => {
+    if (process.platform !== 'win32') {
+      execFile('ps', ['-ax', '-o', 'pid=', '-o', 'ppid='], { encoding: 'utf8', timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024 }, (error, rows) => {
+        const descendants = error ? [] : descendantPids(rows, pid);
+        for (const target of [...descendants, pid]) {
+          try { process.kill(target, 'SIGKILL'); } catch { /* already gone */ }
+        }
+        resolve();
+      });
+      return;
+    }
+    let settled = false;
+    const killer = spawn('taskkill.exe', ['/PID', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+    const timer = setTimeout(() => { try { killer.kill(); } catch { /* ignore */ } done(); }, timeoutMs);
+    function done() {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve();
+    }
+    killer.on('error', done);
+    killer.on('close', done);
+  });
+}
+
+module.exports = { terminateTree, descendantPids };