@harness-mix/cli 0.1.3

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 => ({ workbuddy: 'codebuddy', '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', 'codebuddy'].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,75 @@
+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.writing = false;
+    this.pendingData = null;
+    this.pendingResolvers = [];
+    this.pendingRejecters = [];
+  }
+
+  async load() {
+    if (this.writing || this.pendingData) {
+      await new Promise((resolve, reject) => {
+        this.pendingResolvers.push(resolve);
+        this.pendingRejecters.push(reject);
+      });
+    }
+    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;
+    }
+  }
+
+  save(threads) {
+    this.pendingData = threads;
+    const promise = new Promise((resolve, reject) => {
+      this.pendingResolvers.push(resolve);
+      this.pendingRejecters.push(reject);
+    });
+    void this.#drain();
+    return promise;
+  }
+
+  async #drain() {
+    if (this.writing) return;
+    this.writing = true;
+    while (this.pendingData) {
+      const data = this.pendingData;
+      this.pendingData = null;
+      const resolvers = this.pendingResolvers;
+      const rejecters = this.pendingRejecters;
+      this.pendingResolvers = [];
+      this.pendingRejecters = [];
+      const tmpFile = `${this.file}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+      try {
+        const contents = JSON.stringify(data, null, 2);
+        await fs.mkdir(this.directory, { recursive: true });
+        await fs.writeFile(tmpFile, contents);
+        for (let attempt = 0; ; attempt++) {
+          try { await fs.rename(tmpFile, this.file); break; }
+          catch (error) {
+            if (!['EPERM', 'EACCES', 'EBUSY'].includes(error.code) || attempt === 9) throw error;
+            await new Promise(resolve => setTimeout(resolve, 50));
+          }
+        }
+        for (const r of resolvers) r();
+      } catch (error) {
+        await fs.unlink(tmpFile).catch(() => {});
+        for (const r of rejecters) r(error);
+      }
+    }
+    this.writing = false;
+  }
+}
+
+module.exports = { Store };

package/src/main/native/compatibility.js

@@ -0,0 +1,56 @@
+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+){1,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(), platform = process.platform) {
+  if (!VERSION_PATTERN.test(desktopVersion)) throw new Error('Invalid Codex Desktop version');
+  if (manifest.blockedDesktopVersions.includes(desktopVersion)) {
+    return { state: 'blocked', desktopVersion, evidence: null };
+  }
+  // Legacy evidence was collected on Windows; it cannot certify another OS.
+  const matches = manifest.evidence.filter(item => item.desktopVersion === desktopVersion && (item.platform || 'win32') === platform);
+  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,55 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { dataDirectory, executableName } = require('./platform');
+const root = path.resolve(__dirname, '../../..');
+const settingKeys = ['HARNESS_MIX_DSH_ROOT', 'CODEXHOST_PI_COMMAND', 'CODEXHOST_CLAUDE_COMMAND', 'CODEXHOST_DEEPSEEK_HARNESS_COMMAND', 'CODEXHOST_ANTIGRAVITY_COMMAND', 'HARNESS_MIX_CODEBUDDY_EXECUTABLE', 'HARNESS_MIX_WORKBUDDY_EXECUTABLE', 'HARNESS_MIX_KIRO_EXECUTABLE', 'HARNESS_MIX_CURSOR_EXECUTABLE', 'HARNESS_MIX_QODER_EXECUTABLE', 'HARNESS_MIX_ZCODE_ACP_EXECUTABLE', 'HARNESS_MIX_TRAE_EXECUTABLE'];
+
+function nativePaths(platform = process.platform) {
+  const build = path.join(root, 'output/native-build');
+  return {
+    cli: path.join(root, 'scripts/launch-codex.cjs'),
+    shim: path.join(build, executableName('harness-mix-shim', platform)),
+    ...(platform === 'win32' ? {
+      activation: path.join(build, 'harness-mix-appx.exe'),
+      secret: path.join(build, 'harness-mix-secret.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 = dataDirectory(env);
+  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.NODE_OPTIONS || !env.NODE_OPTIONS.includes('--max-old-space-size')) {
+    env.NODE_OPTIONS = [env.NODE_OPTIONS, '--max-old-space-size=8192'].filter(Boolean).join(' ');
+  }
+  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,153 @@
+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');
+const { terminateTree } = require('./process-utils');
+const { redact } = require('./redact');
+const { dataDirectory } = require('./platform');
+
+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(dataDirectory(), '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;
+  };
+  // Keep the debug journal bounded (5MB × 3) and free of credential-looking text.
+  const rotateTraffic = () => {
+    try {
+      if (!fs.existsSync(trafficLog) || fs.statSync(trafficLog).size < 5 * 1024 * 1024) return;
+      fs.rmSync(`${trafficLog}.2`, { force: true });
+      if (fs.existsSync(`${trafficLog}.1`)) fs.renameSync(`${trafficLog}.1`, `${trafficLog}.2`);
+      fs.renameSync(trafficLog, `${trafficLog}.1`);
+    } catch { /* best-effort */ }
+  };
+  const traffic = (kind, message) => {
+    try { fs.appendFileSync(trafficLog, JSON.stringify({ ts: Date.now(), pid: process.pid, kind, message: redact(slim(message)) }) + '\n'); } catch {}
+  };
+  const runtime = new HostRuntime({ dataDirectory: directory });
+  // Heartbeat: lets the launcher tell a live instance from leftovers, and gives
+  // crash recovery a timestamp to reason about.
+  const startedAt = Date.now();
+  const instanceFile = path.join(path.dirname(directory), 'runtime', 'instance.json');
+  const writeInstance = () => {
+    try {
+      rotateTraffic();
+      fs.mkdirSync(path.dirname(instanceFile), { recursive: true });
+      fs.writeFileSync(`${instanceFile}.tmp`, JSON.stringify({ pid: process.pid, version: process.env.HARNESS_MIX_VERSION || null, startedAt, beatAt: Date.now(), mode: 'native-host' }));
+      fs.renameSync(`${instanceFile}.tmp`, instanceFile);
+    } catch { /* heartbeat is best-effort */ }
+  };
+  writeInstance();
+  const heartbeat = setInterval(writeInstance, 5000);
+  if (heartbeat.unref) heartbeat.unref();
+  const writeCrash = (kind, error) => {
+    try {
+      fs.writeFileSync(path.join(path.dirname(instanceFile), `crash-${Date.now()}.json`), JSON.stringify({
+        kind, pid: process.pid, version: process.env.HARNESS_MIX_VERSION || null, at: Date.now(),
+        message: String((error && error.message) || error), stack: String((error && error.stack) || ''),
+      }, null, 2));
+    } catch { /* diagnostics are best-effort */ }
+  };
+  process.on('uncaughtException', error => {
+    writeCrash('uncaughtException', error);
+    const bail = setTimeout(() => process.exit(1), 3000);
+    if (bail.unref) bail.unref();
+    void close().finally(() => process.exit(1));
+  });
+  process.on('unhandledRejection', reason => writeCrash('unhandledRejection', reason));
+  process.on('SIGBREAK', () => void close());
+  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;
+    clearInterval(heartbeat);
+    try { fs.rmSync(instanceFile, { force: true }); } catch { /* already gone */ }
+    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(() => { void terminateTree(official.pid); }, 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,105 @@
+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: 'grok', regex: /grok|x[.-]?ai\b/i, file: 'grok-color.svg', label: 'Grok' },
+  { id: 'astra', regex: /.*/, file: 'model-astra.svg', label: 'Astra' },
+];
+
+const HARNESS_ICONS = [
+  { id: 'kiro-cli', file: 'kiro-cli-color.svg', label: 'Kiro' },
+  { id: 'cursor-cli', file: 'cursor.svg', label: 'Cursor' },
+  { id: 'cursor', file: 'cursor.svg', label: 'Cursor' },
+  { 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: 'codebuddy', file: 'codebuddy-color.svg', label: 'CodeBuddy' },
+  { 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.find(h => h.id === 'codex');
+  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 };