harness-mix 0.1.0

package/src/main/native/rs/crates/appx/src/main.rs

@@ -0,0 +1,309 @@
+// Windows activation boundary. Rust port of appx.cs: identical COM contract.
+// See Microsoft IApplicationActivationManager and IPackageDebugSettings.
+// The temporary debugging environment is removed before exit on every path.
+//
+// Dependency-free on purpose: only ole32/kernel32 imports from Rust's bundled
+// self-contained libraries, so any stock Rust toolchain can build this crate.
+#![cfg(windows)]
+#![allow(non_snake_case)]
+
+use std::env;
+use std::ffi::c_void;
+use std::process::ExitCode;
+
+type Hresult = i32;
+type Handle = *mut c_void;
+type WidePtr = *const u16;
+
+const S_OK_MIN: Hresult = 0;
+const COINIT_APARTMENTTHREADED: u32 = 0x2;
+const CLSCTX_ALL: u32 = 0x17;
+const THREAD_SUSPEND_RESUME: u32 = 0x0002;
+const THREAD_QUERY_INFORMATION: u32 = 0x0800;
+const ACTIVATEOPTIONS_VALUE: u32 = 2; // same ACTIVATEOPTIONS value as the C# build
+
+#[repr(C)]
+struct Guid {
+    data1: u32,
+    data2: u16,
+    data3: u16,
+    data4: [u8; 8],
+}
+
+// B1AEC16F-2383-4852-B0E9-8F0B1DC66B4D
+const CLSID_PACKAGE_DEBUG_SETTINGS: Guid = Guid {
+    data1: 0xB1AEC16F,
+    data2: 0x2383,
+    data3: 0x4852,
+    data4: [0xB0, 0xE9, 0x8F, 0x0B, 0x1D, 0xC6, 0x6B, 0x4D],
+};
+// 45BA127D-10A8-46EA-8AB7-56EA9078943C
+const CLSID_APPLICATION_ACTIVATION_MANAGER: Guid = Guid {
+    data1: 0x45BA127D,
+    data2: 0x10A8,
+    data3: 0x46EA,
+    data4: [0x8A, 0xB7, 0x56, 0xEA, 0x90, 0x78, 0x94, 0x3C],
+};
+// F27C3930-8029-4AD1-94E3-3DBA417810C1
+const IID_PACKAGE_DEBUG_SETTINGS: Guid = Guid {
+    data1: 0xF27C3930,
+    data2: 0x8029,
+    data3: 0x4AD1,
+    data4: [0x94, 0xE3, 0x3D, 0xBA, 0x41, 0x78, 0x10, 0xC1],
+};
+// 2E941141-7F97-4756-BA1D-9DECDE894A3D
+const IID_APPLICATION_ACTIVATION_MANAGER: Guid = Guid {
+    data1: 0x2E941141,
+    data2: 0x7F97,
+    data3: 0x4756,
+    data4: [0xBA, 0x1D, 0x9D, 0xEC, 0xDE, 0x89, 0x4A, 0x3D],
+};
+
+type QueryInterface = unsafe extern "system" fn(*mut c_void, *const Guid, *mut *mut c_void) -> Hresult;
+type AddRef = unsafe extern "system" fn(*mut c_void) -> u32;
+type Release = unsafe extern "system" fn(*mut c_void) -> u32;
+type EnableDebugging =
+    unsafe extern "system" fn(*mut c_void, WidePtr, WidePtr, WidePtr) -> Hresult;
+type DisableDebugging = unsafe extern "system" fn(*mut c_void, WidePtr) -> Hresult;
+type ActivateApplication =
+    unsafe extern "system" fn(*mut c_void, WidePtr, WidePtr, u32, *mut u32) -> Hresult;
+
+#[repr(C)]
+struct PackageDebugSettingsVtbl {
+    query_interface: QueryInterface,
+    add_ref: AddRef,
+    release: Release,
+    enable_debugging: EnableDebugging,
+    disable_debugging: DisableDebugging,
+}
+
+#[repr(C)]
+struct ApplicationActivationManagerVtbl {
+    query_interface: QueryInterface,
+    add_ref: AddRef,
+    release: Release,
+    activate_application: ActivateApplication,
+}
+
+#[repr(C)]
+struct ComObject {
+    vtbl: *const c_void,
+}
+
+struct DebugSettings(*mut c_void);
+impl DebugSettings {
+    fn vtbl(&self) -> &PackageDebugSettingsVtbl {
+        unsafe { &*((*(self.0 as *const ComObject)).vtbl as *const PackageDebugSettingsVtbl) }
+    }
+    fn disable(&self, package: WidePtr) {
+        let _ = unsafe { (self.vtbl().disable_debugging)(self.0, package) };
+    }
+}
+impl Drop for DebugSettings {
+    fn drop(&mut self) {
+        unsafe { (self.vtbl().release)(self.0) };
+    }
+}
+
+struct ActivationManager(*mut c_void);
+impl ActivationManager {
+    fn vtbl(&self) -> &ApplicationActivationManagerVtbl {
+        unsafe { &*((*(self.0 as *const ComObject)).vtbl as *const ApplicationActivationManagerVtbl) }
+    }
+}
+impl Drop for ActivationManager {
+    fn drop(&mut self) {
+        unsafe { (self.vtbl().release)(self.0) };
+    }
+}
+
+#[link(name = "ole32")]
+extern "system" {
+    fn CoInitializeEx(reserved: *mut c_void, coinit: u32) -> Hresult;
+    fn CoUninitialize();
+    fn CoCreateInstance(
+        clsid: *const Guid,
+        outer: *mut c_void,
+        clsctx: u32,
+        iid: *const Guid,
+        out: *mut *mut c_void,
+    ) -> Hresult;
+}
+
+#[link(name = "kernel32")]
+extern "system" {
+    fn OpenThread(access: u32, inherit: i32, thread_id: u32) -> Handle;
+    fn ResumeThread(thread: Handle) -> u32;
+    fn GetProcessIdOfThread(thread: Handle) -> u32;
+    fn CloseHandle(handle: Handle) -> i32;
+}
+
+fn check(hr: Hresult, what: &str) -> Result<(), String> {
+    if hr >= S_OK_MIN {
+        Ok(())
+    } else {
+        Err(format!("{what} failed (HRESULT 0x{hr:08X})"))
+    }
+}
+
+fn wide(value: &str) -> Vec<u16> {
+    value.encode_utf16().chain(std::iter::once(0)).collect()
+}
+
+fn base64_value(byte: u8) -> Result<u32, String> {
+    match byte {
+        b'A'..=b'Z' => Ok((byte - b'A') as u32),
+        b'a'..=b'z' => Ok((byte - b'a' + 26) as u32),
+        b'0'..=b'9' => Ok((byte - b'0' + 52) as u32),
+        b'+' | b'-' => Ok(62),
+        b'/' | b'_' => Ok(63),
+        _ => Err(format!("Invalid base64 byte 0x{byte:02X}")),
+    }
+}
+
+fn base64_decode(input: &str) -> Result<Vec<u8>, String> {
+    let mut out = Vec::with_capacity(input.len() * 3 / 4);
+    let mut acc: u32 = 0;
+    let mut bits: u32 = 0;
+    for &byte in input.as_bytes() {
+        if byte == b'=' || byte == b'\r' || byte == b'\n' || byte == b' ' {
+            continue;
+        }
+        acc = (acc << 6) | base64_value(byte)?;
+        bits += 6;
+        if bits >= 8 {
+            bits -= 8;
+            out.push((acc >> bits) as u8);
+        }
+    }
+    Ok(out)
+}
+
+fn resume_thread(args: &[String]) -> Result<(), String> {
+    let tid = args
+        .windows(2)
+        .find(|pair| pair[0] == "-tid")
+        .and_then(|pair| pair[1].parse::<u32>().ok())
+        .ok_or_else(|| "Missing AppX process/thread identity".to_string())?;
+    let pid = args
+        .windows(2)
+        .find(|pair| pair[0] == "-p")
+        .and_then(|pair| pair[1].parse::<u32>().ok())
+        .ok_or_else(|| "Missing AppX process/thread identity".to_string())?;
+    unsafe {
+        let thread = OpenThread(THREAD_SUSPEND_RESUME | THREAD_QUERY_INFORMATION, 0, tid);
+        if thread.is_null() {
+            return Err("Cannot open AppX thread".to_string());
+        }
+        let result = (|| {
+            if GetProcessIdOfThread(thread) != pid {
+                return Err("AppX thread ownership mismatch".to_string());
+            }
+            if ResumeThread(thread) == u32::MAX {
+                return Err("Cannot resume AppX thread".to_string());
+            }
+            Ok(())
+        })();
+        CloseHandle(thread);
+        result
+    }
+}
+
+fn co_create(clsid: &Guid, iid: &Guid) -> Result<*mut c_void, String> {
+    let mut object: *mut c_void = std::ptr::null_mut();
+    let hr = unsafe { CoCreateInstance(clsid, std::ptr::null_mut(), CLSCTX_ALL, iid, &mut object) };
+    check(hr, "CoCreateInstance")?;
+    if object.is_null() {
+        return Err("CoCreateInstance returned no object".to_string());
+    }
+    Ok(object)
+}
+
+fn activate(args: &[String]) -> Result<u32, String> {
+    if args.len() != 4 {
+        return Err("Expected package, app ID, environment block and launch arguments".to_string());
+    }
+    let package = wide(&args[0]);
+    let app_id = wide(&args[1]);
+    let arguments = wide(&args[3]);
+    // The launcher encodes the environment block as base64(utf16le double-null block).
+    let raw = base64_decode(&args[2])?;
+    let mut environment: Vec<u16> = raw
+        .chunks_exact(2)
+        .map(|pair| u16::from_le_bytes([pair[0], pair[1]]))
+        .collect();
+    if !matches!(environment.as_slice(), [.., 0, 0]) {
+        environment.push(0);
+        environment.push(0);
+    }
+
+    let hr = unsafe { CoInitializeEx(std::ptr::null_mut(), COINIT_APARTMENTTHREADED) };
+    check(hr, "CoInitializeEx")?;
+    let result = (|| {
+        let settings = DebugSettings(co_create(&CLSID_PACKAGE_DEBUG_SETTINGS, &IID_PACKAGE_DEBUG_SETTINGS)?);
+        let activation = ActivationManager(co_create(
+            &CLSID_APPLICATION_ACTIVATION_MANAGER,
+            &IID_APPLICATION_ACTIVATION_MANAGER,
+        )?);
+
+        // Clear stale debugging configuration first; the result is ignored, matching appx.cs.
+        settings.disable(package.as_ptr());
+        let current = env::current_exe().map_err(|e| e.to_string())?;
+        let debugger = wide(&format!("\"{}\" --resume", current.display()));
+        check(
+            unsafe {
+                ((settings.vtbl()).enable_debugging)(
+                    settings.0,
+                    package.as_ptr(),
+                    debugger.as_ptr(),
+                    environment.as_ptr(),
+                )
+            },
+            "EnableDebugging",
+        )?;
+        // Every path after EnableDebugging must restore DisableDebugging.
+        let activation_result = (|| {
+            let mut pid: u32 = 0;
+            check(
+                unsafe {
+                    ((activation.vtbl()).activate_application)(
+                        activation.0,
+                        app_id.as_ptr(),
+                        arguments.as_ptr(),
+                        ACTIVATEOPTIONS_VALUE,
+                        &mut pid,
+                    )
+                },
+                "ActivateApplication",
+            )?;
+            Ok(pid)
+        })();
+        settings.disable(package.as_ptr());
+        activation_result
+    })();
+    unsafe { CoUninitialize() };
+    result
+}
+
+fn main() -> ExitCode {
+    let args: Vec<String> = env::args().skip(1).collect();
+    if args.first().map(String::as_str) == Some("--resume") {
+        return match resume_thread(&args) {
+            Ok(()) => ExitCode::SUCCESS,
+            Err(message) => {
+                eprintln!("Harness Mix activation: {message}");
+                ExitCode::FAILURE
+            }
+        };
+    }
+    match activate(&args) {
+        Ok(pid) => {
+            println!("{pid}");
+            ExitCode::SUCCESS
+        }
+        Err(message) => {
+            eprintln!("Harness Mix activation: {message}");
+            ExitCode::FAILURE
+        }
+    }
+}

package/src/main/native/rs/crates/shim/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "harness-mix-shim"
+version = "0.2.0"
+edition = "2021"
+description = "Harness Mix executable bridge: routes Codex Desktop app-server traffic to the local HostRuntime"
+license = "Apache-2.0"
+
+[[bin]]
+name = "harness-mix-shim"
+path = "src/main.rs"

package/src/main/native/rs/crates/shim/src/main.rs

@@ -0,0 +1,207 @@
+// Harness Mix executable bridge, built from this source by build-native.cjs.
+// Rust port of the original shim.cs: identical routing and stdio contract.
+//
+// - `... app-server ...`  -> node scripts/native-host.cjs (Harness Mix kernel)
+// - anything else         -> stock codex.exe passthrough
+use std::env;
+use std::fs;
+use std::io::{self, Read, Write};
+use std::path::Path;
+use std::process::{Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::thread;
+
+#[cfg(windows)]
+use std::os::windows::process::CommandExt;
+
+#[cfg(windows)]
+const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+
+fn read_trimmed(path: &Path) -> io::Result<String> {
+    Ok(fs::read_to_string(path)?.trim().to_string())
+}
+
+fn json_escape(value: &str) -> String {
+    let mut out = String::with_capacity(value.len());
+    for c in value.chars() {
+        match c {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
+            c => out.push(c),
+        }
+    }
+    out
+}
+
+// Invocation journal next to the exe: one JSON line on spawn, one on exit.
+// The desktop spawns this shim for every CLI call, so this is the ground
+// truth for which invocation fails and with what stderr.
+fn log_line(exe_dir: &Path, line: &str) {
+    let Ok(mut file) = fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(exe_dir.join("shim-invocations.log"))
+    else {
+        return;
+    };
+    let ts = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_millis())
+        .unwrap_or(0);
+    let _ = writeln!(file, "{{\"ts\":{ts},{line}}}");
+}
+
+fn log_spawn(exe_dir: &Path, mode: &str, args: &[String]) {
+    let args = args
+        .iter()
+        .map(|a| format!("\"{}\"", json_escape(a)))
+        .collect::<Vec<_>>()
+        .join(",");
+    log_line(
+        exe_dir,
+        &format!(
+            "\"pid\":{},\"mode\":\"{}\",\"args\":[{}]",
+            std::process::id(),
+            mode,
+            args
+        ),
+    );
+}
+
+fn log_exit(exe_dir: &Path, code: i32, stderr_tail: &[u8]) {
+    let tail = json_escape(&String::from_utf8_lossy(stderr_tail));
+    log_line(
+        exe_dir,
+        &format!(
+            "\"pid\":{},\"exit\":{},\"stderr_tail\":\"{}\"",
+            std::process::id(),
+            code,
+            tail
+        ),
+    );
+}
+
+fn setting(env_name: &str, file: &Path) -> io::Result<String> {
+    match env::var(env_name) {
+        Ok(value) if !value.is_empty() => Ok(value),
+        _ => read_trimmed(file),
+    }
+}
+
+fn pump<R: Read + Send + 'static, W: Write + Send + 'static>(
+    mut source: R,
+    mut destination: W,
+) -> thread::JoinHandle<()> {
+    thread::spawn(move || {
+        let _ = io::copy(&mut source, &mut destination);
+        let _ = destination.flush();
+    })
+}
+
+fn run() -> io::Result<i32> {
+    let exe = env::current_exe()?;
+    let exe_dir = exe
+        .parent()
+        .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "Shim has no base directory"))?;
+    // Path.GetFullPath equivalent: normalize without resolving symlinks or adding \\?\.
+    let root = std::path::absolute(exe_dir.join("../.."))?;
+    let args: Vec<String> = env::args().skip(1).collect();
+    let server = args.iter().any(|arg| arg == "app-server");
+
+    let build_dir = root.join("output").join("native-build");
+    let stock = setting(
+        "CODEXHOST_STOCK_CODEX_PATH",
+        &build_dir.join("stock-path.txt"),
+    )?;
+    let node = setting("HARNESS_MIX_NODE_PATH", &build_dir.join("node-path.txt"))?;
+    log_spawn(exe_dir, if server { "server" } else { "passthrough" }, &args);
+
+    let mut command = if server {
+        let mut command = Command::new(&node);
+        command.arg(root.join("scripts").join("native-host.cjs"));
+        command
+    } else {
+        Command::new(&stock)
+    };
+    command
+        .args(&args)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .env_remove("CODEX_CLI_PATH")
+        .env("CODEXHOST_STOCK_CODEX_PATH", &stock);
+    #[cfg(windows)]
+    command.creation_flags(CREATE_NO_WINDOW);
+
+    let mut child = command.spawn()?;
+    let child_stdin = child
+        .stdin
+        .take()
+        .ok_or_else(|| io::Error::new(io::ErrorKind::BrokenPipe, "child stdin unavailable"))?;
+    let child_stdout = child
+        .stdout
+        .take()
+        .ok_or_else(|| io::Error::new(io::ErrorKind::BrokenPipe, "child stdout unavailable"))?;
+    let child_stderr = child
+        .stderr
+        .take()
+        .ok_or_else(|| io::Error::new(io::ErrorKind::BrokenPipe, "child stderr unavailable"))?;
+
+    // Stdin EOF must close the child's stdin, mirroring the C# pump's finally.
+    let input = thread::spawn(move || {
+        let stdin = io::stdin();
+        let mut locked = stdin.lock();
+        let mut writer = child_stdin;
+        let _ = io::copy(&mut locked, &mut writer);
+        let _ = writer.flush();
+        drop(writer);
+    });
+    let output = pump(child_stdout, io::stdout());
+    // Tee stderr: forward live and keep the tail for the invocation journal.
+    let tail = Arc::new(Mutex::new(Vec::<u8>::new()));
+    let tail_writer = Arc::clone(&tail);
+    let error = thread::spawn(move || {
+        let mut reader = child_stderr;
+        let mut stderr = io::stderr();
+        let mut buffer = [0u8; 4096];
+        loop {
+            match reader.read(&mut buffer) {
+                Ok(0) | Err(_) => break,
+                Ok(count) => {
+                    let chunk = &buffer[..count];
+                    let _ = stderr.write_all(chunk);
+                    let _ = stderr.flush();
+                    if let Ok(mut tail) = tail_writer.lock() {
+                        tail.extend_from_slice(chunk);
+                        if tail.len() > 4096 {
+                            let excess = tail.len() - 4096;
+                            tail.drain(..excess);
+                        }
+                    }
+                }
+            }
+        }
+    });
+
+    let status = child.wait()?;
+    let _ = output.join();
+    let _ = error.join();
+    let code = status.code().unwrap_or(1);
+    let tail = tail.lock().map(|t| t.clone()).unwrap_or_default();
+    log_exit(&exe_dir, code, &tail);
+    drop(input); // stdin may outlive the child; do not block exit on it.
+    Ok(code)
+}
+
+fn main() {
+    match run() {
+        Ok(code) => std::process::exit(code),
+        Err(error) => {
+            eprintln!("Harness Mix Shim: {error}");
+            std::process::exit(1);
+        }
+    }
+}

package/src/main/native/thread-list.js

@@ -0,0 +1,38 @@
+// Match Desktop queries before merging local threads into an official page.
+function includesThread(thread, query = {}, threads = []) {
+  if (thread.ephemeral || Boolean(thread.archived) !== Boolean(query.archived)) return false;
+  // 父子归属查询（协作子任务/子代理列表）：按 parentThreadId 链匹配
+  if (query.parentThreadId != null) return thread.parentThreadId === query.parentThreadId;
+  if (query.ancestorThreadId != null) {
+    const byId = new Map(threads.map(entry => [entry.id, entry]));
+    for (let current = thread; current?.parentThreadId; current = byId.get(current.parentThreadId)) {
+      if (current.parentThreadId === query.ancestorThreadId) return true;
+    }
+    return false;
+  }
+  if (Object.hasOwn(query, 'sectionId') && (thread.section?.id ?? null) !== query.sectionId) return false;
+  if (Object.hasOwn(query, 'projectId') && (thread.projectId ?? null) !== query.projectId) return false;
+  if (query.isPinned === true && !thread.isPinned) return false;
+  if (query.isPinned === false && thread.isPinned) return false;
+  if (query.cwd != null && !(Array.isArray(query.cwd) ? query.cwd : [query.cwd]).includes(thread.cwd)) return false;
+  if (query.modelProviders?.length && !query.modelProviders.includes('codexhost')) return false;
+  if (query.sourceKinds?.length && !query.sourceKinds.includes('vscode')) return false;
+  if (query.searchTerm && !(thread.title || '').toLowerCase().includes(query.searchTerm.toLowerCase())) return false;
+  return true;
+}
+
+function mergeThreadPage(page, threads, query, project) {
+  if (query.cursor) return page;
+  const local = threads.filter(thread => includesThread(thread, query, threads));
+  if (query.sortKey === 'section_position') local.sort((a, b) => (a.sectionPosition || 0) - (b.sectionPosition || 0));
+  const byId = new Map(page.data.map(thread => [thread.id, thread]));
+  for (const thread of local) byId.set(thread.id, project(thread));
+  const data = [...byId.values()];
+  if (query.sortKey !== 'section_position') {
+    const key = { updated_at: 'updatedAt', recency_at: 'recencyAt' }[query.sortKey] || 'createdAt';
+    data.sort((a, b) => (query.sortDirection === 'asc' ? 1 : -1) * ((a[key] || 0) - (b[key] || 0)));
+  }
+  return { ...page, data };
+}
+
+module.exports = { includesThread, mergeThreadPage };

package/src/main/native/updater.js

@@ -0,0 +1,102 @@
+// Harness Mix auto-update: fast-forward the local checkout from its git upstream,
+// reinstall dependencies and rebuild native artifacts when their inputs changed.
+// Never touches a dirty or diverged working tree; update failures never block launch.
+const { execFileSync, spawnSync } = require('node:child_process');
+const path = require('node:path');
+
+function makeGit(root, exec = spawnSync) {
+  return (args, timeout = 20000) => {
+    const result = exec('git', args, {
+      cwd: root,
+      encoding: 'utf8',
+      timeout,
+      windowsHide: true,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    });
+    if (result.error) throw result.error;
+    if (result.status !== 0) throw new Error(String(result.stderr || `git ${args[0]} failed`).trim());
+    return String(result.stdout).trim();
+  };
+}
+
+// remoteState classifies the checkout relative to its upstream:
+// current | ahead | diverged | dirty | available (fast-forward possible).
+function remoteState(root, git = makeGit(root)) {
+  const head = git(['rev-parse', 'HEAD']);
+  let upstream = 'origin/main';
+  try {
+    upstream = git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']);
+  } catch { /* no upstream configured: fall back to origin/main */ }
+  git(['fetch', '--quiet', ...upstream.split('/')], 30000);
+  const remote = git(['rev-parse', upstream]);
+  if (remote === head) return { state: 'current', head, remote, upstream };
+  const base = git(['merge-base', 'HEAD', upstream]);
+  if (base === remote) return { state: 'ahead', head, remote, upstream };
+  if (base !== head) return { state: 'diverged', head, remote, upstream };
+  const dirty = git(['status', '--porcelain', '--untracked-files=no']).length > 0;
+  if (dirty) return { state: 'dirty', head, remote, upstream };
+  return { state: 'available', head, remote, upstream };
+}
+
+function defaultHooks(root) {
+  return {
+    install() {
+      const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+      execFileSync(npm, ['install'], { cwd: root, stdio: 'inherit', windowsHide: true });
+    },
+    build() {
+      execFileSync(process.execPath, [path.join(root, 'scripts/build-native.cjs')], { cwd: root, stdio: 'inherit', windowsHide: true });
+    },
+  };
+}
+
+function applyUpdate(root, state, git = makeGit(root), hooks = defaultHooks(root)) {
+  git(['merge', '--ff-only', state.upstream]);
+  const changed = git(['diff', '--name-only', state.head, state.remote]).split('\n').filter(Boolean);
+  const install = changed.some(file => file === 'package.json' || file === 'package-lock.json');
+  const rebuild = install || changed.some(file => file.startsWith('src/') || file.startsWith('scripts/'));
+  if (install) hooks.install();
+  if (rebuild) hooks.build();
+  return {
+    updated: true,
+    from: state.head.slice(0, 8),
+    to: state.remote.slice(0, 8),
+    changed: changed.length,
+    installed: install,
+    rebuilt: rebuild,
+  };
+}
+
+async function autoUpdate({ root, log = console.log, exec, hooks } = {}) {
+  const git = makeGit(root, exec);
+  let state;
+  try {
+    state = remoteState(root, git);
+  } catch (error) {
+    log(`[Harness Mix] 自动更新检查失败（不影响启动）：${error.message}`);
+    return { updated: false, failed: true };
+  }
+  switch (state.state) {
+    case 'current':
+      log('[Harness Mix] 已是最新版本');
+      return { updated: false, state: state.state };
+    case 'ahead':
+      log('[Harness Mix] 本地提交领先远端，跳过自动更新');
+      return { updated: false, state: state.state };
+    case 'diverged':
+      log('[Harness Mix] 本地与远端已分叉，请手动处理后重启，跳过自动更新');
+      return { updated: false, state: state.state };
+    case 'dirty':
+      log('[Harness Mix] 工作区存在未提交改动，跳过自动更新');
+      return { updated: false, state: state.state };
+    default: {
+      log(`[Harness Mix] 发现新版本 ${state.head.slice(0, 8)} → ${state.remote.slice(0, 8)}，正在更新…`);
+      const outcome = applyUpdate(root, state, git, hooks || defaultHooks(root));
+      log(`[Harness Mix] 更新完成：${outcome.changed} 个文件` +
+        `${outcome.installed ? '，依赖已重装' : ''}${outcome.rebuilt ? '，原生组件已重建' : ''}`);
+      return outcome;
+    }
+  }
+}
+
+module.exports = { autoUpdate, remoteState, applyUpdate, makeGit, defaultHooks };

package/src/main/native/usage.js

@@ -0,0 +1,29 @@
+const integer = n => Number.isSafeInteger(n) && n >= 0;
+const number = n => typeof n === 'number' && Number.isFinite(n) && n >= 0;
+
+function projectUsage(source = {}) {
+  const result = {};
+  const fields = {
+    inputTokens: ['inputTokens', 'input'], outputTokens: ['outputTokens', 'output'],
+    cachedInputTokens: ['cachedInputTokens', 'cacheRead'], cacheWriteInputTokens: ['cacheWriteInputTokens', 'cacheWrite'],
+    reasoningOutputTokens: ['reasoningOutputTokens'], totalTokens: ['totalTokens'],
+    totalCostUsd: ['totalCostUsd', 'cost'], contextUsagePercent: ['contextUsagePercent', 'contextPercent'],
+    cacheHitRatePercent: ['cacheHitRatePercent', 'cacheHitPercent'],
+  };
+  for (const [target, keys] of Object.entries(fields)) {
+    const value = keys.map(key => source[key]).find(number);
+    if (value === undefined || target.endsWith('Tokens') && !integer(value)) continue;
+    if (target === 'cacheHitRatePercent' && value > 100) continue;
+    result[target] = value;
+  }
+  const used = source.contextUsedTokens ?? source.tokens;
+  const window = source.contextWindowTokens ?? source.contextWindow;
+  if (integer(used) && integer(window) && window > 0) {
+    result.contextUsedTokens = used;
+    result.contextWindowTokens = window;
+    result.contextUsagePercent = 100 * used / window;
+  }
+  return Object.keys(result).length ? result : null;
+}
+
+module.exports = { projectUsage };