harness-mix 0.1.0

package/src/main/host/session-history.js

@@ -0,0 +1,63 @@
+const { listNative, readNative } = require('./native-history');
+const external = id => ({ codex: 'codex-harness', claude: 'claude-code', dsh: 'deepseek-harness' }[id] || id);
+const local = id => ({ 'codex-harness': 'codex', 'claude-code': 'claude', 'deepseek-harness': 'dsh' }[id] || id);
+
+class SessionHistory {
+  constructor(runtime, providers = { listNative, readNative }) { this.runtime = runtime; this.providers = providers; this.imports = new Map(); }
+  sources() { return { harnesses: [{ harnessId: 'all-harnesses', name: '全部历史' }, ...[...this.runtime.adapters.values()].map(a => ({ harnessId: external(a.manifest.id), name: a.manifest.name + (['pi', 'claude', 'codex'].includes(a.manifest.id) ? '' : '（Host 历史）') }))] }; }
+  async rows(id) {
+    if (id === 'all-harnesses') return (await Promise.all([...this.runtime.adapters.keys()].map(key => this.rows(key)))).flat().map(row => ({ ...row, nativeSessionId: Buffer.from(JSON.stringify([row.harnessId, row.nativeSessionId])).toString('base64url'), title: `[${row.harnessId}] ${row.title || '未命名会话'}` }));
+    id = local(id);
+    if (!this.runtime.adapters.has(id)) throw new Error('Unknown history source');
+    const managed = this.runtime.threads.filter(t => t.harnessId === id && !t.ephemeral).map(t => ({ harnessId: id, nativeSessionId: t.nativeSessionId, threadId: t.id, title: t.title || null, cwd: t.cwd, updatedAt: t.updatedAt || t.createdAt, running: this.runtime.execution.isRunning(t.id) }));
+    const native = await this.providers.listNative(id);
+    const seen = new Set(managed.map(r => r.nativeSessionId));
+    return [...managed, ...native.filter(r => !seen.has(r.nativeSessionId)).map(r => ({ ...r, harnessId: id }))];
+  }
+  async list({ harnessId, query = '', offset = 0, limit = 20 }) {
+    if (typeof query !== 'string' || !Number.isSafeInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 1 || limit > 1000) throw new Error('Invalid history query');
+    const needle = query.toLowerCase();
+    const rows = (await this.rows(harnessId)).filter(r => `${r.title} ${r.cwd} ${r.nativeSessionId}`.toLowerCase().includes(needle)).sort((a, b) => b.updatedAt - a.updatedAt || a.nativeSessionId.localeCompare(b.nativeSessionId));
+    return { total: rows.length, candidates: rows.slice(offset, offset + limit).map(({ nativeSessionId, title, cwd, updatedAt, running }) => ({ nativeSessionId, title: title?.slice(0, 4096) || null, cwd, updatedAt, running })) };
+  }
+  async import({ harnessId, nativeSessionId }) {
+    if (harnessId === 'all-harnesses') {
+      const decoded = JSON.parse(Buffer.from(nativeSessionId, 'base64url').toString());
+      if (!Array.isArray(decoded) || decoded.length !== 2 || !decoded.every(v => typeof v === 'string')) throw new Error('Invalid history identity');
+      [harnessId, nativeSessionId] = decoded;
+    }
+    harnessId = local(harnessId);
+    const key = JSON.stringify([harnessId, nativeSessionId]);
+    if (this.imports.has(key)) return this.imports.get(key);
+    const operation = (async () => {
+      const row = (await this.rows(harnessId)).find(r => r.nativeSessionId === nativeSessionId);
+      if (!row) throw new Error('Native session no longer exists');
+      if (row.threadId) return { threadId: row.threadId };
+      if (row.running) throw new Error('Native session is active');
+      const messages = await this.providers.readNative(harnessId, row);
+      const thread = await this.runtime.importNativeSession({ ...row, harnessId, messages });
+      return { threadId: thread.id };
+    })().finally(() => this.imports.delete(key));
+    this.imports.set(key, operation);
+    return operation;
+  }
+
+  async context({ harnessId = 'all-harnesses', nativeSessionId }) {
+    if (harnessId === 'all-harnesses') {
+      const decoded = JSON.parse(Buffer.from(nativeSessionId, 'base64url').toString());
+      if (!Array.isArray(decoded) || decoded.length !== 2 || !decoded.every(v => typeof v === 'string')) throw new Error('Invalid history identity');
+      [harnessId, nativeSessionId] = decoded;
+    }
+    harnessId = local(harnessId);
+    const row = (await this.rows(harnessId)).find(candidate => candidate.nativeSessionId === nativeSessionId);
+    if (!row) throw new Error('Referenced native session no longer exists');
+    const managed = row.threadId && this.runtime.threads.find(thread => thread.id === row.threadId);
+    const messages = managed ? managed.messages : await this.providers.readNative(harnessId, row);
+    const selected = messages.filter(message => ['user', 'assistant'].includes(message.role) && message.text).slice(-12);
+    return {
+      harnessId: external(harnessId), title: row.title || '未命名会话', cwd: row.cwd,
+      transcript: selected.map(message => `${message.role === 'user' ? 'User' : 'Assistant'}: ${message.text}`).join('\n').slice(-24000),
+    };
+  }
+}
+module.exports = { SessionHistory };

package/src/main/host/store.js

@@ -0,0 +1,42 @@
+const { promises: fs } = require("node:fs");
+const path = require("node:path");
+
+/** 线程记录的 JSON 持久化：排队串行写入 + tmp 文件原子替换 */
+class Store {
+  constructor(directory) {
+    this.directory = directory;
+    this.file = path.join(directory, "threads.json");
+    this.queue = Promise.resolve();
+  }
+
+  async load() {
+    await this.queue;
+    await fs.mkdir(this.directory, { recursive: true });
+    try {
+      const threads = JSON.parse(await fs.readFile(this.file, "utf8"));
+      if (!Array.isArray(threads)) throw new Error('Invalid thread store; original file preserved');
+      return threads;
+    } catch (error) {
+      if (error.code === 'ENOENT') return [];
+      throw error;
+    }
+  }
+
+  /** 串行保存；data 由调用方在入队时快照，避免写放大期间引用被继续修改 */
+  save(threads) {
+    const contents = JSON.stringify(threads, null, 2);
+    this.queue = this.queue.catch(() => {}).then(async () => {
+      await fs.writeFile(`${this.file}.tmp`, contents);
+      for (let attempt = 0; ; attempt++) {
+        try { await fs.rename(`${this.file}.tmp`, this.file); break; }
+        catch (error) {
+          if (!['EPERM', 'EACCES', 'EBUSY'].includes(error.code) || attempt === 9) throw error;
+          await new Promise(resolve => setTimeout(resolve, 50));
+        }
+      }
+    });
+    return this.queue;
+  }
+}
+
+module.exports = { Store };

package/src/main/native/compatibility.js

@@ -0,0 +1,55 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MANIFEST_PATH = path.resolve(__dirname, '../../../config/codex-desktop-compatibility.json');
+const VERSION_PATTERN = /^\d+(?:\.\d+){3}$/;
+const EVIDENCE_LEVELS = new Set(['protocol-fixture', 'protocol-and-smoke', 'desktop-e2e']);
+
+function loadCompatibilityManifest(file = MANIFEST_PATH) {
+  const manifest = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (manifest?.schemaVersion !== 1) throw new Error('Unsupported Codex Desktop compatibility manifest');
+  if (!manifest.contractVersions || typeof manifest.contractVersions !== 'object') {
+    throw new Error('Compatibility contract versions are missing');
+  }
+  if (!Array.isArray(manifest.blockedDesktopVersions) ||
+      manifest.blockedDesktopVersions.some(version => !VERSION_PATTERN.test(version))) {
+    throw new Error('Compatibility blocked version list is invalid');
+  }
+  if (!Array.isArray(manifest.evidence) || manifest.evidence.some(item =>
+    !VERSION_PATTERN.test(item?.desktopVersion) || !EVIDENCE_LEVELS.has(item?.level) ||
+    typeof item?.checkedAt !== 'string' || typeof item?.notes !== 'string')) {
+    throw new Error('Compatibility evidence is invalid');
+  }
+  return manifest;
+}
+
+function evaluateDesktopCompatibility(desktopVersion, manifest = loadCompatibilityManifest()) {
+  if (!VERSION_PATTERN.test(desktopVersion)) throw new Error('Invalid Codex Desktop version');
+  if (manifest.blockedDesktopVersions.includes(desktopVersion)) {
+    return { state: 'blocked', desktopVersion, evidence: null };
+  }
+  const matches = manifest.evidence.filter(item => item.desktopVersion === desktopVersion);
+  const evidence = matches.find(item => item.level === 'desktop-e2e') || matches.at(-1) || null;
+  return {
+    state: evidence?.level === 'desktop-e2e' ? 'verified' : evidence ? 'observed' : 'unverified',
+    desktopVersion,
+    evidence,
+  };
+}
+
+function enforceDesktopCompatibility(result, environment = process.env) {
+  if (result.state === 'blocked') {
+    throw new Error(`Codex Desktop ${result.desktopVersion} is explicitly blocked by the compatibility manifest`);
+  }
+  if (environment.HARNESS_MIX_STRICT_COMPATIBILITY === '1' && result.state !== 'verified') {
+    throw new Error(`Codex Desktop ${result.desktopVersion} has not passed full Desktop E2E acceptance`);
+  }
+  return result;
+}
+
+module.exports = {
+  MANIFEST_PATH,
+  loadCompatibilityManifest,
+  evaluateDesktopCompatibility,
+  enforceDesktopCompatibility,
+};

package/src/main/native/config.js

@@ -0,0 +1,49 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const root = path.resolve(__dirname, '../../..');
+const settingKeys = ['HARNESS_MIX_DSH_ROOT', 'CODEXHOST_PI_COMMAND', 'CODEXHOST_CLAUDE_COMMAND', 'CODEXHOST_DEEPSEEK_HARNESS_COMMAND', 'CODEXHOST_ANTIGRAVITY_COMMAND'];
+
+function nativePaths() {
+  const build = path.join(root, 'output/native-build');
+  return {
+    cli: path.join(root, 'scripts/launch-codex.cjs'),
+    shim: path.join(build, 'harness-mix-shim.exe'),
+    activation: path.join(build, 'harness-mix-appx.exe'),
+    runtime: path.join(root, 'src/main/native/host.js'),
+    controller: path.join(build, 'desktop-controller.mjs'),
+    renderer: path.join(build, 'renderer-extension.js'),
+    wrapper: path.join(root, 'scripts', 'native-host.cjs'),
+  };
+}
+
+function nativeEnvironment(environment = process.env) {
+  const env = { ...environment };
+  env.CODEXHOST_DATA_DIR ||= path.join(env.APPDATA || os.homedir(), 'harness-mix', 'codexhost');
+  const settingsPath = path.join(env.CODEXHOST_DATA_DIR, 'harness-mix-settings.json');
+  if (fs.existsSync(settingsPath)) {
+    const saved = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    for (const key of settingKeys) {
+      if (!env[key] && typeof saved[key] === 'string') env[key] = saved[key];
+    }
+  }
+  env.CODEXHOST_DEFAULT_AGENT ||= 'codex';
+  env.HARNESS_MIX_NODE_PATH = process.execPath;
+  if (!env.CODEXHOST_DEEPSEEK_HARNESS_COMMAND && process.platform === 'win32') {
+    env.CODEXHOST_DEEPSEEK_HARNESS_COMMAND = path.join(root, 'scripts', 'dsh-native.cmd');
+  }
+  return env;
+}
+
+function saveNativeSettings(env) {
+  fs.mkdirSync(env.CODEXHOST_DATA_DIR, { recursive: true });
+  // Only executable locations are persisted; never copy the complete environment.
+  const settings = Object.fromEntries(settingKeys.filter(key => env[key] &&
+    !(key === 'CODEXHOST_DEEPSEEK_HARNESS_COMMAND' && env[key] === path.join(root, 'scripts', 'dsh-native.cmd')))
+    .map(key => [key, env[key]]));
+  const file = path.join(env.CODEXHOST_DATA_DIR, 'harness-mix-settings.json');
+  fs.writeFileSync(`${file}.tmp`, JSON.stringify(settings, null, 2));
+  fs.renameSync(`${file}.tmp`, file);
+}
+
+module.exports = { nativePaths, nativeEnvironment, saveNativeSettings };

package/src/main/native/host.js

@@ -0,0 +1,108 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const readline = require('node:readline');
+const { spawn } = require('node:child_process');
+const { HostRuntime } = require('../host/runtime');
+const { NativeProtocol } = require('./protocol');
+const { mergeThreadPage } = require('./thread-list');
+
+async function runNativeHost() {
+  const stock = process.env.CODEXHOST_STOCK_CODEX_PATH;
+  if (!stock || !fs.existsSync(stock)) throw new Error('Official Codex CLI path is missing');
+  const directory = path.join(process.env.CODEXHOST_DATA_DIR || path.join(process.env.APPDATA, 'harness-mix/native'), 'mix-core');
+  const trafficLog = path.join(path.dirname(directory), 'host-traffic.jsonl');
+  const slim = value => {
+    if (typeof value === 'string') return value.length > 1500 ? `${value.slice(0, 1500)}…[${value.length}]` : value;
+    if (Array.isArray(value)) return value.map(slim);
+    if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, slim(v)]));
+    return value;
+  };
+  const traffic = (kind, message) => {
+    try { fs.appendFileSync(trafficLog, JSON.stringify({ ts: Date.now(), pid: process.pid, kind, message: slim(message) }) + '\n'); } catch {}
+  };
+  const runtime = new HostRuntime({ dataDirectory: directory });
+  const ready = runtime.initialize();
+  const write = message => { traffic('out', message); process.stdout.write(`${JSON.stringify(message)}\n`); };
+  const internal = new Map();
+  let internalId = 0;
+  const requestOfficial = (method, params) => new Promise((resolve, reject) => {
+    const id = `harness-mix:internal:${++internalId}`;
+    const timer = setTimeout(() => { internal.delete(id); reject(new Error(`${method} timed out`)); }, 15000);
+    internal.set(id, { resolve, reject, timer });
+    official.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+  });
+  const protocol = new NativeProtocol(runtime, write, requestOfficial);
+  const env = { ...process.env };
+  delete env.CODEX_CLI_PATH;
+  // Forward the Desktop's original CLI arguments (the shim preserves them in argv):
+  // -c overrides such as features.* and mcp_servers.codex_app must reach the stock
+  // app-server, otherwise per-thread configs referencing them fail config loading.
+  const passthrough = process.argv.slice(2);
+  const officialArgs = passthrough.includes('--listen') ? passthrough : [...passthrough, '--listen', 'stdio://'];
+  const official = spawn(stock, officialArgs, { env, windowsHide: true, stdio: ['pipe', 'pipe', 'inherit'] });
+  const forwarded = new Map();
+  const lines = readline.createInterface({ input: official.stdout });
+  lines.on('line', line => {
+    try {
+      const value = JSON.parse(line);
+      const pending = internal.get(value.id);
+      if (pending) {
+        internal.delete(value.id); clearTimeout(pending.timer);
+        if (value.error) pending.reject(new Error(value.error.message));
+        else pending.resolve(value.result);
+        return;
+      }
+      const request = forwarded.get(value.id);
+      if (request) {
+        forwarded.delete(value.id);
+        if (value.error) traffic('official-error', { method: request.method, error: value.error });
+        if (request.method === 'thread/list' && value.result?.data && !request.params?.cursor) {
+          value.result = mergeThreadPage(value.result, runtime.threads, request.params || {}, t => protocol.projectThread(t, false));
+        }
+      }
+      write(value);
+    } catch (error) { console.error('[Harness Mix protocol]', error.message); }
+  });
+  const input = readline.createInterface({ input: process.stdin });
+  let closing = false;
+  async function close() {
+    if (closing) return;
+    closing = true;
+    input.close(); protocol.close();
+    for (const pending of internal.values()) { clearTimeout(pending.timer); pending.reject(new Error('Native host closed')); }
+    internal.clear();
+    await ready.catch(() => {});
+    await runtime.close();
+    official.stdin.end();
+    const timer = setTimeout(() => official.kill(), 2000); timer.unref();
+  }
+  input.on('line', line => {
+    void (async () => {
+      let message;
+      try {
+        message = JSON.parse(line);
+        traffic('in', message);
+        if (!message.method) {
+          if (String(message.id).startsWith('harness-mix:approval:')) { await ready; await protocol.respond(message); return; }
+        } else if (message.id !== undefined && message.method !== 'initialize') {
+          await ready;
+          const result = await protocol.request(message.method, message.params);
+          if (result !== undefined) { write({ id: message.id, result }); return; }
+        }
+        if (message.id !== undefined && message.method) { forwarded.set(message.id, message); traffic('forward', message); }
+        official.stdin.write(`${JSON.stringify(message)}\n`);
+      } catch (error) {
+        if (message?.method && message.id !== undefined) write({ id: message.id, error: { code: -32603, message: error.message } });
+        else console.error('[Harness Mix host]', error.message);
+      }
+    })();
+  });
+  input.on('close', () => void close());
+  process.once('SIGTERM', () => void close());
+  process.once('SIGINT', () => void close());
+  official.on('error', error => { console.error(error); void close(); });
+  official.on('exit', () => { void close(); });
+  await ready;
+  console.error('[Harness Mix] native protocol -> local HostRuntime -> local ProtocolCore');
+}
+module.exports = { runNativeHost };

package/src/main/native/icons.js

@@ -0,0 +1,101 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ICONS_DIR = path.resolve(__dirname, '../../assets/icons');
+
+const MODEL_FAMILIES = [
+  { id: 'gemini', regex: /gemini/i, file: 'model-gemini.svg', label: 'Gemini' },
+  { id: 'deepseek', regex: /deepseek/i, file: 'model-deepseek.svg', label: 'DeepSeek' },
+  { id: 'xiaomimimo', regex: /mimo|xiaomi/i, file: 'model-xiaomimimo.svg', label: 'Xiaomi MIMO' },
+  { id: 'qwen', regex: /qwen|qwq/i, file: 'model-qwen-color.svg', label: 'Qwen' },
+  { id: 'hunyuan', regex: /hunyuan|混元/i, file: 'model-hunyuan.svg', label: 'Hunyuan' },
+  { id: 'minimax', regex: /minimax|abab/i, file: 'model-minimax.svg', label: 'MiniMax' },
+  { id: 'claude', regex: /claude|anthropic/i, file: 'model-claude.svg', label: 'Claude' },
+  { id: 'kimi', regex: /kimi|moonshot/i, file: 'model-kimi.svg', label: 'Kimi' },
+  { id: 'zai', regex: /glm|zhipu|智谱|z[.-]?ai\b/i, file: 'model-zai.svg', label: 'GLM / Zai' },
+  { id: 'openai', regex: /gpt|openai|o[134](?:-|\b)/i, file: 'model-openai.svg', label: 'OpenAI' },
+  { id: 'astra', regex: /.*/, file: 'model-astra.svg', label: 'Astra' },
+];
+
+const HARNESS_ICONS = [
+  { id: 'antigravity', file: 'antigravity-color.svg', label: 'Antigravity' },
+  { id: 'claude', file: 'claude-color.svg', label: 'Claude Code' },
+  { id: 'codex', file: 'codex-harness.svg', label: 'Codex' },
+  { id: 'dsh', file: 'deepseek-color.svg', label: 'DeepSeek Harness' },
+  { id: 'pi', file: 'pi.svg', label: 'Pi' },
+  { id: 'omp', file: 'omp-color.svg', label: 'Oh My Pi' },
+  { id: 'opencode', file: 'opencode-color.svg', label: 'OpenCode' },
+  { id: 'grok', file: 'grok-color.svg', label: 'Grok' },
+  { id: 'openclaw', file: 'openclaw-color.svg', label: 'OpenClaw' },
+  { id: 'hermes', file: 'hermes-color.svg', label: 'Hermes' },
+  { id: 'qoder', file: 'qoder-color.svg', label: 'Qoder' },
+  { id: 'workbuddy', file: 'workbuddy-color.svg', label: 'Workbuddy' },
+  { id: 'zcode', file: 'zcode-color.svg', label: 'ZCode' },
+  { id: 'trae', file: 'trae-color.svg', label: 'Trae' },
+];
+
+const svgCache = new Map();
+
+function readSvg(filename) {
+  if (svgCache.has(filename)) return svgCache.get(filename);
+  try {
+    const filePath = path.join(ICONS_DIR, filename);
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8').trim();
+      svgCache.set(filename, content);
+      return content;
+    }
+  } catch (_e) {
+    // fallback
+  }
+  return '';
+}
+
+function matchModelFamily(modelOrName) {
+  const text = typeof modelOrName === 'string'
+    ? modelOrName
+    : [modelOrName?.id, modelOrName?.name, modelOrName?.provider].filter(Boolean).join(' ');
+  for (const family of MODEL_FAMILIES) {
+    if (family.regex.test(text)) return family;
+  }
+  return MODEL_FAMILIES[MODEL_FAMILIES.length - 1];
+}
+
+function getModelSvg(modelOrName) {
+  const family = matchModelFamily(modelOrName);
+  return readSvg(family.file);
+}
+
+function getHarnessSvg(harnessId) {
+  const item = HARNESS_ICONS.find(h => h.id === harnessId) || HARNESS_ICONS[2];
+  return readSvg(item.file);
+}
+
+function getAllIconsDictionary() {
+  const dict = {
+    models: {},
+    harnesses: {},
+  };
+  for (const f of MODEL_FAMILIES) {
+    dict.models[f.id] = {
+      label: f.label,
+      svg: readSvg(f.file),
+    };
+  }
+  for (const h of HARNESS_ICONS) {
+    dict.harnesses[h.id] = {
+      label: h.label,
+      svg: readSvg(h.file),
+    };
+  }
+  return dict;
+}
+
+module.exports = {
+  MODEL_FAMILIES,
+  HARNESS_ICONS,
+  matchModelFamily,
+  getModelSvg,
+  getHarnessSvg,
+  getAllIconsDictionary,
+};

package/src/main/native/input.js

@@ -0,0 +1,43 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const MAX_BYTES = 10 * 1024 * 1024;
+const mimeTypes = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp' };
+
+// Convert Desktop input into the existing native adapter attachment contract.
+async function prepareInput(input = [], cwd = process.cwd()) {
+  if (!Array.isArray(input)) throw new Error('Invalid native input');
+  const texts = [], attachments = [];
+  for (const item of input) {
+    if (item?.type === 'text' && typeof item.text === 'string') {
+      texts.push(item.text);
+      continue;
+    }
+    if (!['localImage', 'image'].includes(item?.type)) throw new Error(`Unsupported native input type: ${item?.type}`);
+    if (attachments.length >= 6) throw new Error('一次最多携带 6 个附件');
+    let data, mime, name, sourcePath;
+    if (item.type === 'localImage') {
+      if (typeof item.path !== 'string' || !item.path) throw new Error('图片缺少本地路径');
+      sourcePath = path.resolve(cwd, item.path);
+      name = path.basename(sourcePath);
+      mime = mimeTypes[path.extname(name).toLowerCase()];
+      if (!mime) throw new Error(`不支持的图片格式：${name}`);
+      const file = await fs.open(sourcePath, 'r');
+      try {
+        const stat = await file.stat();
+        if (!stat.isFile() || stat.size > MAX_BYTES) throw new Error(`图片「${name}」必须是 10MB 以内的文件`);
+        data = (await file.readFile()).toString('base64');
+      } finally { await file.close(); }
+    } else {
+      const match = typeof item.url === 'string' && /^data:(image\/(?:png|jpeg|gif|webp));base64,([A-Za-z0-9+/]+={0,2})$/.exec(item.url);
+      if (!match) throw new Error('图片需要本地文件或 PNG/JPEG/GIF/WebP base64 数据');
+      [, mime, data] = match;
+      name = `image-${attachments.length + 1}.${mime.split('/')[1]}`;
+    }
+    if (!data || data.length > Math.ceil(MAX_BYTES / 3) * 4 || Buffer.from(data, 'base64').length > MAX_BYTES) throw new Error(`图片「${name}」为空或超过 10MB 上限`);
+    attachments.push({ kind: 'image', name, mime, data, size: Buffer.from(data, 'base64').length, ...(sourcePath ? { path: sourcePath } : {}) });
+  }
+  return { text: texts.join('\n'), attachments };
+}
+
+module.exports = { prepareInput };

package/src/main/native/launcher.js

@@ -0,0 +1,100 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const net = require('node:net');
+const crypto = require('node:crypto');
+const { spawn, execFileSync } = require('node:child_process');
+const { nativePaths, nativeEnvironment, saveNativeSettings } = require('./config');
+const { autoUpdate, defaultHooks } = require('./updater');
+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();
+}
+function inspect() {
+  if (process.platform !== 'win32') throw new Error('The local native Launcher currently supports Windows');
+  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 = crypto.createHash('sha256').update(fs.readFileSync(packaged)).digest('hex').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');
+  if (flags.has('--update')) {
+    await autoUpdate({ root, hooks: defaultHooks(root) });
+    return;
+  }
+  const skipUpdate = flags.has('--no-update') || process.env.HARNESS_MIX_AUTO_UPDATE === '0';
+  if (!flags.has('--check') && !skipUpdate) {
+    await autoUpdate({ root, hooks: defaultHooks(root) });
+  }
+  const installation = inspect();
+  const compatibility = 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(`desktop_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;
+  }
+  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.');
+  // Match the verified installation executable; never terminate unrelated apps.
+  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 }`);
+  const pid = execFileSync(paths.activation, [installation.fullName, installation.appId, block, `--remote-debugging-port=${port}`], { encoding: 'utf8', windowsHide: true }).trim();
+  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; });
+  return controller;
+}
+module.exports = { inspect, launch, cacheCodexRuntime };