From 44c2df23610d1d730836eba51986f8580c673e27 Mon Sep 17 00:00:00 2001 From: cflmy Date: Fri, 20 Nov 2026 11:52:26 +0800 Subject: [PATCH] feat(m0.6-r2): isolated plugin worker transport - add a hidden __plugin-worker mode that loads one native library in a child process and serves length-prefixed JSON invoke frames - add host WorkerPlugin with ready handshake, export cross-check, per-call timeout and crash/EOF propagation - route kind: worker without in-process trust; native still requires explicit trust; wasm is rejected explicitly - report worker_processes=true while keeping strict OS isolation unavailable - test successful worker calls and worker crash isolation - update plugin ABI spec and R2 status --- crates/cli/src/commands.rs | 4 +- crates/cli/src/main.rs | 14 ++ crates/cli/tests/plugin_worker.rs | 156 +++++++++++++++++++ crates/marqdo-host/src/host.rs | 94 ++++++++---- crates/marqdo-host/src/lib.rs | 1 + crates/marqdo-host/src/plugin_worker.rs | 192 ++++++++++++++++++++++++ crates/marqdo-plugin-abi/src/lib.rs | 1 + crates/marqdo-plugin-abi/src/worker.rs | 191 +++++++++++++++++++++++ crates/marqdo-sandbox/src/lib.rs | 10 +- docs/STATUS.md | 2 +- examples/plugin-demo/solver.c | 5 + spec/plugin-abi.md | 38 +++-- 12 files changed, 661 insertions(+), 47 deletions(-) create mode 100644 crates/cli/tests/plugin_worker.rs create mode 100644 crates/marqdo-host/src/plugin_worker.rs create mode 100644 crates/marqdo-plugin-abi/src/worker.rs diff --git a/crates/cli/src/commands.rs b/crates/cli/src/commands.rs index de22ea5..4d766ba 100644 --- a/crates/cli/src/commands.rs +++ b/crates/cli/src/commands.rs @@ -883,9 +883,9 @@ fn load_plugin_into_host( manifest .validate() .map_err(|error| format!("{}: {}", error.code, error.message))?; - if !trusted { + if manifest.plugin.kind == marqdo_plugin_abi::PluginKind::Native && !trusted { return Err(format!( - "loading `{}` in-process requires --trust-native-plugin: no isolated worker transport is implemented in this build", + "loading `{}` in-process requires --trust-native-plugin; use `kind: worker` for crash isolation", manifest.plugin.name )); } diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs index ade6d99..ea715e9 100644 --- a/crates/cli/src/main.rs +++ b/crates/cli/src/main.rs @@ -58,6 +58,17 @@ enum Command { /// Unknown top-level command: dispatch to a registered external tool. #[command(external_subcommand)] External(Vec), + /// Internal isolated plugin worker (not a user-facing command). + #[command(name = "__plugin-worker", hide = true)] + PluginWorker(PluginWorkerArgs), +} + +#[derive(Args)] +struct PluginWorkerArgs { + /// plugin.yaml path. + manifest: PathBuf, + /// Plugin package directory. + base_dir: PathBuf, } #[derive(Args)] @@ -386,6 +397,9 @@ fn main() { ToolCommand::Remove(args) => tool::remove(&args.command, args.json), }, Command::External(args) => tool::dispatch(&args), + Command::PluginWorker(args) => { + marqdo_plugin_abi::worker::serve(&args.manifest, &args.base_dir) + } }; std::process::exit(code); } diff --git a/crates/cli/tests/plugin_worker.rs b/crates/cli/tests/plugin_worker.rs new file mode 100644 index 0000000..ce8b76a --- /dev/null +++ b/crates/cli/tests/plugin_worker.rs @@ -0,0 +1,156 @@ +//! Isolated plugin worker transport (ADR-0010). +#![cfg(unix)] + +use std::path::{Path, PathBuf}; +use std::process::{Command, Output}; +use std::sync::atomic::{AtomicU32, Ordering}; + +use marqdo_plugin_abi::{sha256_file, HostTarget}; + +static COUNTER: AtomicU32 = AtomicU32::new(0); + +struct TempDir(PathBuf); + +impl TempDir { + fn new(tag: &str) -> Self { + let id = COUNTER.fetch_add(1, Ordering::Relaxed); + let path = std::env::temp_dir().join(format!( + "marqdo-worker-test-{}-{id}-{tag}", + std::process::id() + )); + std::fs::create_dir_all(&path).unwrap(); + Self(path) + } + + fn path(&self) -> &Path { + &self.0 + } +} + +impl Drop for TempDir { + fn drop(&mut self) { + let _ = std::fs::remove_dir_all(&self.0); + } +} + +fn repo() -> PathBuf { + Path::new(env!("CARGO_MANIFEST_DIR")) + .parent() + .unwrap() + .parent() + .unwrap() + .to_path_buf() +} + +fn have_cc() -> bool { + Command::new("cc") + .arg("--version") + .output() + .map(|output| output.status.success()) + .unwrap_or(false) +} + +fn compile(dir: &Path, extra: &[&str]) -> PathBuf { + let output = dir.join("solver.so"); + let status = Command::new("cc") + .args(["-std=c11", "-O2", "-shared", "-fPIC"]) + .arg("-I") + .arg(repo().join("include")) + .args(extra) + .arg(repo().join("examples/plugin-demo/solver.c")) + .arg("-o") + .arg(&output) + .status() + .expect("cc"); + assert!(status.success(), "cc failed"); + output +} + +fn write_manifest(dir: &Path, sha: &str) { + std::fs::write( + dir.join("plugin.yaml"), + format!( + r#"plugin: + name: demo.solver + version: 0.1.0 + abi: "^1.0" + kind: worker + exports: + - name: solver.add + signature: "($a: Int, $b: Int) -> Int" + requires: + - math.compute + artifacts: + - target: {} + file: solver.so + sha256: "{}" +"#, + HostTarget::current().triple(), + sha + ), + ) + .unwrap(); + std::fs::write( + dir.join("doc.mq.md"), + "## main\n\n**结果 = solver.add(a=20, b=22)**\n\n> 打印(结果)\n", + ) + .unwrap(); +} + +fn run(dir: &Path) -> Output { + Command::new(env!("CARGO_BIN_EXE_marqdo")) + .args([ + "run", + dir.join("doc.mq.md").to_str().unwrap(), + "--plugin", + dir.to_str().unwrap(), + "--allow-plugin", + "demo.solver", + ]) + .output() + .unwrap() +} + +#[test] +fn worker_transport_runs_without_in_process_trust() { + if !have_cc() { + eprintln!("skipping: cc is unavailable"); + return; + } + let dir = TempDir::new("ok"); + let artifact = compile(dir.path(), &[]); + write_manifest(dir.path(), &sha256_file(&artifact).unwrap()); + let output = run(dir.path()); + assert_eq!( + output.status.code(), + Some(0), + "{}", + String::from_utf8_lossy(&output.stderr) + ); + assert_eq!(String::from_utf8_lossy(&output.stdout), "42\n"); +} + +#[test] +fn worker_crash_is_isolated_from_the_host() { + if !have_cc() { + eprintln!("skipping: cc is unavailable"); + return; + } + let dir = TempDir::new("crash"); + let artifact = compile(dir.path(), &["-DMQ_SOLVER_CRASH"]); + write_manifest(dir.path(), &sha256_file(&artifact).unwrap()); + let output = run(dir.path()); + assert_eq!(output.status.code(), Some(1)); + let stderr = String::from_utf8_lossy(&output.stderr); + assert!( + stderr.contains("plugin.crashed") || stderr.contains("plugin.failure"), + "{stderr}" + ); + // The host process survived and still runs a native Marqdo program. + let survivor = Command::new(env!("CARGO_BIN_EXE_marqdo")) + .args(["run", "examples/hello.mq.md"]) + .current_dir(repo()) + .output() + .unwrap(); + assert_eq!(survivor.status.code(), Some(0)); +} diff --git a/crates/marqdo-host/src/host.rs b/crates/marqdo-host/src/host.rs index 966944d..24c1c24 100644 --- a/crates/marqdo-host/src/host.rs +++ b/crates/marqdo-host/src/host.rs @@ -8,7 +8,9 @@ use std::collections::{BTreeMap, BTreeSet}; use std::sync::{Arc, Mutex}; use std::time::{Duration, Instant}; -use marqdo_plugin_abi::{ErrorKind as PluginErrorKind, LoadedPlugin, PluginError, PluginManifest}; +use marqdo_plugin_abi::{ + ErrorKind as PluginErrorKind, LoadedPlugin, PluginError, PluginKind, PluginManifest, +}; use marqdo_span::Span; use marqdo_value::{ErrorCategory, RuntimeError, Value}; @@ -17,6 +19,7 @@ use crate::capability::{Capabilities, CapabilityAudit, CapabilityBroker}; use crate::context::ExecutionContext; use crate::fs::ProjectFs; use crate::handles::{contains_plugin_handle, PluginHandleTable}; +use crate::plugin_worker::WorkerPlugin; use crate::trace::{EffectTrace, SemanticEvent, TraceEntry}; use marqdo_sandbox::{PlatformCapabilities, SandboxMode}; @@ -150,7 +153,24 @@ struct PluginSlot { manifest_digest: String, /// Complete export name -> declared signature. exports: BTreeMap, - plugin: LoadedPlugin, + plugin: PluginTransport, +} + +enum PluginTransport { + Native(LoadedPlugin), + Worker(WorkerPlugin), +} + +impl PluginTransport { + fn invoke( + &mut self, + request: &marqdo_plugin_abi::WireRequest, + ) -> Result { + match self { + PluginTransport::Native(plugin) => plugin.invoke(request), + PluginTransport::Worker(plugin) => plugin.invoke(request), + } + } } impl StdHost { @@ -199,18 +219,6 @@ impl StdHost { base_dir: &std::path::Path, trusted: bool, ) -> Result, RuntimeError> { - if !trusted { - let mut error = RuntimeError::new( - ErrorCategory::PermissionDenied, - None, - "loading an in-process native plugin requires explicit trust", - ); - error.effect_trace.push( - "hint: no isolated plugin worker transport is implemented in this build; in-process native code shares the host address space" - .to_string(), - ); - return Err(error); - } self.capabilities .check_plugin(&manifest.plugin.name, None)?; manifest.validate().map_err(map_plugin_error)?; @@ -239,26 +247,56 @@ impl StdHost { .resolve_artifact(&marqdo_plugin_abi::HostTarget::current()) .map_err(map_plugin_error)?; let manifest_digest = artifact.sha256.clone(); - let mut broker = - CapabilityBroker::with_audit(self.capabilities.clone(), Arc::clone(&self.broker_audit)); - for capability in &self.vendor_capabilities { - broker.allow_vendor(capability.clone()); - } - let package = manifest.plugin.name.clone(); - let options = marqdo_plugin_abi::LoadOptions { - host_target: marqdo_plugin_abi::HostTarget::current(), - capability_handler: Some(Box::new(move |capability, request| { - broker.authorize(&package, capability, request) - })), + let transport = match manifest.plugin.kind { + PluginKind::Native => { + if !trusted { + let mut error = RuntimeError::new( + ErrorCategory::PermissionDenied, + None, + "loading an in-process native plugin requires explicit trust", + ); + error.effect_trace.push( + "hint: use `kind: worker` for crash isolation, or pass --trust-native-plugin for in-process native code" + .to_string(), + ); + return Err(error); + } + let mut broker = CapabilityBroker::with_audit( + self.capabilities.clone(), + Arc::clone(&self.broker_audit), + ); + for capability in &self.vendor_capabilities { + broker.allow_vendor(capability.clone()); + } + let package = manifest.plugin.name.clone(); + let options = marqdo_plugin_abi::LoadOptions { + host_target: marqdo_plugin_abi::HostTarget::current(), + capability_handler: Some(Box::new(move |capability, request| { + broker.authorize(&package, capability, request) + })), + }; + PluginTransport::Native( + LoadedPlugin::open_with(manifest, base_dir, options) + .map_err(map_plugin_error)?, + ) + } + PluginKind::Worker => PluginTransport::Worker( + WorkerPlugin::spawn(manifest, base_dir).map_err(map_plugin_error)?, + ), + PluginKind::Wasm => { + return Err(RuntimeError::new( + ErrorCategory::KernelUnavailable, + None, + "plugin kind `wasm` is not supported in this build", + )) + } }; - let loaded = - LoadedPlugin::open_with(manifest, base_dir, options).map_err(map_plugin_error)?; let index = self.plugins.len(); self.plugins.push(PluginSlot { package: manifest.plugin.name.clone(), manifest_digest, exports: exports.clone(), - plugin: loaded, + plugin: transport, }); let names: Vec = exports.keys().cloned().collect(); for name in &names { diff --git a/crates/marqdo-host/src/lib.rs b/crates/marqdo-host/src/lib.rs index cf5b33d..41eb3ed 100644 --- a/crates/marqdo-host/src/lib.rs +++ b/crates/marqdo-host/src/lib.rs @@ -11,6 +11,7 @@ pub mod fs; pub mod handles; pub mod host; pub mod kernels; +mod plugin_worker; pub mod trace; pub use budget::{Budget, DEFAULT_FUEL, DEFAULT_OUTPUT_BYTES, DEFAULT_STACK_LIMIT}; diff --git a/crates/marqdo-host/src/plugin_worker.rs b/crates/marqdo-host/src/plugin_worker.rs new file mode 100644 index 0000000..81ee08a --- /dev/null +++ b/crates/marqdo-host/src/plugin_worker.rs @@ -0,0 +1,192 @@ +//! Host side of the isolated plugin worker transport (ADR-0010). +//! +//! The worker is a child process running the same core binary with the hidden +//! `__plugin-worker` command. It isolates crashes and keeps native code out of +//! the interpreter process. A plain process is **not** an OS sandbox; strict +//! mode still refuses without a real isolation adapter. + +use std::collections::BTreeMap; +use std::path::Path; +use std::process::{Child, ChildStdin, Command, Stdio}; +use std::sync::mpsc::{self, Receiver}; +use std::thread; +use std::time::Duration; + +use marqdo_plugin_abi::worker::{read_frame, write_frame, WORKER_COMMAND}; +use marqdo_plugin_abi::{PluginError, PluginManifest, WireRequest, WireResponse}; +use serde_json::json; + +/// A native plugin running in an isolated worker process. +pub struct WorkerPlugin { + child: Child, + stdin: ChildStdin, + frames: Receiver>, + exports: BTreeMap, +} + +const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(30); +const CALL_TIMEOUT: Duration = Duration::from_secs(10); + +impl std::fmt::Debug for WorkerPlugin { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("WorkerPlugin") + .field("pid", &self.child.id()) + .field("exports", &self.exports.keys().collect::>()) + .finish() + } +} + +impl WorkerPlugin { + /// Spawn a worker for `manifest` and wait for its ready frame. + pub fn spawn(manifest: &PluginManifest, base_dir: &Path) -> Result { + let manifest_path = if base_dir.join("plugin.yaml").is_file() { + base_dir.join("plugin.yaml") + } else { + return Err(PluginError::load( + "worker_manifest_missing", + format!("no plugin.yaml in `{}`", base_dir.display()), + )); + }; + let executable = std::env::current_exe().map_err(|error| { + PluginError::load( + "worker_spawn_failed", + format!("cannot find the current executable: {error}"), + ) + })?; + let mut child = Command::new(executable) + .arg(WORKER_COMMAND) + .arg(&manifest_path) + .arg(base_dir) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::inherit()) + .spawn() + .map_err(|error| { + PluginError::load( + "worker_spawn_failed", + format!("cannot start plugin worker: {error}"), + ) + })?; + let Some(stdin) = child.stdin.take() else { + let _ = child.kill(); + return Err(PluginError::load( + "worker_spawn_failed", + "worker stdin unavailable", + )); + }; + let Some(mut stdout) = child.stdout.take() else { + let _ = child.kill(); + return Err(PluginError::load( + "worker_spawn_failed", + "worker stdout unavailable", + )); + }; + let (sender, frames) = mpsc::channel(); + thread::Builder::new() + .name("marqdo-plugin-worker-reader".to_string()) + .spawn(move || loop { + let frame = read_frame(&mut stdout); + let failed = frame.is_err(); + if sender.send(frame).is_err() || failed { + break; + } + }) + .map_err(|error| { + let _ = child.kill(); + PluginError::load( + "worker_spawn_failed", + format!("cannot start worker reader: {error}"), + ) + })?; + let ready = frames.recv_timeout(HANDSHAKE_TIMEOUT).map_err(|_| { + let _ = child.kill(); + PluginError::invoke("plugin.timeout", "plugin worker handshake timed out") + })??; + if ready.get("kind").and_then(serde_json::Value::as_str) != Some("ready") { + let _ = child.kill(); + return Err(PluginError::load( + "worker_handshake_failed", + "worker did not report ready", + )); + } + let mut exports = BTreeMap::new(); + if let Some(entries) = ready.get("exports").and_then(serde_json::Value::as_array) { + for entry in entries { + let Some(name) = entry.get("name").and_then(serde_json::Value::as_str) else { + continue; + }; + let signature = entry + .get("signature") + .and_then(serde_json::Value::as_str) + .unwrap_or_default() + .to_string(); + exports.insert(name.to_string(), signature); + } + } + let declared: std::collections::BTreeSet<&str> = manifest + .plugin + .exports + .iter() + .map(|export| export.name.as_str()) + .collect(); + let actual: std::collections::BTreeSet<&str> = exports.keys().map(String::as_str).collect(); + if declared != actual { + let _ = child.kill(); + return Err(PluginError::manifest( + "worker_export_mismatch", + "worker exports do not match the manifest", + )); + } + Ok(Self { + child, + stdin, + frames, + exports, + }) + } + + /// Invoke one export in the worker. + pub fn invoke(&mut self, request: &WireRequest) -> Result { + let request_value: serde_json::Value = serde_json::from_slice(&request.to_json_bytes()?) + .map_err(|error| PluginError::wire("worker_encode_failed", error.to_string()))?; + write_frame( + &mut self.stdin, + &json!({"kind": "invoke", "request": request_value}), + )?; + let frame = match self.frames.recv_timeout(CALL_TIMEOUT) { + Ok(frame) => frame?, + Err(_) => { + let _ = self.child.kill(); + return Err(PluginError::invoke( + "plugin.timeout", + "plugin worker exceeded its invocation timeout", + )); + } + }; + match frame.get("kind").and_then(serde_json::Value::as_str) { + Some("response") => marqdo_plugin_abi::worker::response_from_frame(&frame), + Some("error") => Err(PluginError::invoke( + frame + .get("code") + .and_then(serde_json::Value::as_str) + .unwrap_or("plugin_call_failed"), + frame + .get("message") + .and_then(serde_json::Value::as_str) + .unwrap_or("worker reported an error"), + )), + _ => Err(PluginError::invoke( + "plugin.crashed", + "plugin worker closed or violated the frame protocol", + )), + } + } +} + +impl Drop for WorkerPlugin { + fn drop(&mut self) { + let _ = write_frame(&mut self.stdin, &json!({"kind": "shutdown"})); + let _ = self.child.kill(); + let _ = self.child.wait(); + } +} diff --git a/crates/marqdo-plugin-abi/src/lib.rs b/crates/marqdo-plugin-abi/src/lib.rs index 811e068..b176f4a 100644 --- a/crates/marqdo-plugin-abi/src/lib.rs +++ b/crates/marqdo-plugin-abi/src/lib.rs @@ -25,6 +25,7 @@ pub mod error; pub mod loader; pub mod manifest; pub mod wire; +pub mod worker; pub use abi::result as result_code; pub use abi::{ diff --git a/crates/marqdo-plugin-abi/src/worker.rs b/crates/marqdo-plugin-abi/src/worker.rs new file mode 100644 index 0000000..099ddaf --- /dev/null +++ b/crates/marqdo-plugin-abi/src/worker.rs @@ -0,0 +1,191 @@ +//! Isolated plugin worker transport (length-prefixed JSON frames). +//! +//! The worker is the same core binary invoked with the hidden +//! `__plugin-worker` command. It loads one native plugin in a child process and +//! serves invoke frames over stdin/stdout. This isolates crashes and provides a +//! process boundary; it is **not** an OS sandbox and does not make arbitrary +//! untrusted native code safe. + +use std::io::{Read, Write}; +use std::path::Path; + +use serde_json::{json, Value}; + +use crate::error::PluginError; +use crate::loader::LoadedPlugin; +use crate::manifest::{PluginKind, PluginManifest}; +use crate::wire::{WireRequest, WireResponse}; + +/// Hidden CLI command name used to start a worker. +pub const WORKER_COMMAND: &str = "__plugin-worker"; +/// Maximum frame size accepted by either side. +pub const MAX_FRAME_BYTES: usize = 64 * 1024 * 1024; + +/// Read one length-prefixed frame (4-byte big-endian length + JSON). +pub fn read_frame(reader: &mut R) -> Result { + let mut length = [0_u8; 4]; + reader.read_exact(&mut length).map_err(|error| { + PluginError::invoke( + "plugin.crashed", + format!("worker frame read failed: {error}"), + ) + })?; + let length = u32::from_be_bytes(length) as usize; + if length == 0 || length > MAX_FRAME_BYTES { + return Err(PluginError::wire( + "worker_frame_invalid", + format!("worker frame length {length} is invalid"), + )); + } + let mut bytes = vec![0_u8; length]; + reader.read_exact(&mut bytes).map_err(|error| { + PluginError::invoke( + "plugin.crashed", + format!("worker frame read failed: {error}"), + ) + })?; + serde_json::from_slice(&bytes).map_err(|error| { + PluginError::wire( + "worker_frame_invalid", + format!("worker frame is not valid JSON: {error}"), + ) + }) +} + +/// Write one length-prefixed frame. +pub fn write_frame(writer: &mut W, value: &Value) -> Result<(), PluginError> { + let bytes = serde_json::to_vec(value).map_err(|error| { + PluginError::wire( + "worker_encode_failed", + format!("cannot encode worker frame: {error}"), + ) + })?; + if bytes.len() > MAX_FRAME_BYTES { + return Err(PluginError::wire( + "worker_frame_too_large", + format!("worker frame is {} bytes", bytes.len()), + )); + } + writer + .write_all(&(bytes.len() as u32).to_be_bytes()) + .and_then(|()| writer.write_all(&bytes)) + .and_then(|()| writer.flush()) + .map_err(|error| { + PluginError::invoke( + "plugin.crashed", + format!("worker frame write failed: {error}"), + ) + }) +} + +/// Run one worker until shutdown/EOF. Returns a process exit code. +pub fn serve(manifest_path: &Path, base_dir: &Path) -> i32 { + let manifest = match PluginManifest::load(manifest_path) { + Ok(manifest) => manifest, + Err(error) => { + eprintln!("worker: {}: {}", error.code, error.message); + return 2; + } + }; + // The worker is the isolated transport; the library itself is loaded + // natively inside this child process. + let mut native_manifest = manifest.clone(); + native_manifest.plugin.kind = PluginKind::Native; + let mut plugin = match LoadedPlugin::open(&native_manifest, base_dir) { + Ok(plugin) => plugin, + Err(error) => { + eprintln!("worker: {}: {}", error.code, error.message); + return 2; + } + }; + let exports: Vec = plugin + .exports() + .map(|export| json!({"name": export.name(), "signature": export.signature()})) + .collect(); + let mut stdin = std::io::stdin(); + let mut stdout = std::io::stdout(); + if let Err(error) = write_frame(&mut stdout, &json!({"kind": "ready", "exports": exports})) { + eprintln!("worker: {}: {}", error.code, error.message); + return 1; + } + loop { + let frame = match read_frame(&mut stdin) { + Ok(frame) => frame, + Err(_) => return 0, + }; + match frame.get("kind").and_then(Value::as_str) { + Some("shutdown") => return 0, + Some("invoke") => { + let Some(request_value) = frame.get("request") else { + let _ = write_frame( + &mut stdout, + &json!({"kind":"error","code":"worker_request_invalid","message":"missing request"}), + ); + continue; + }; + let request_bytes = match serde_json::to_vec(request_value) { + Ok(bytes) => bytes, + Err(error) => { + let _ = write_frame( + &mut stdout, + &json!({"kind":"error","code":"worker_request_invalid","message":error.to_string()}), + ); + continue; + } + }; + let request = match WireRequest::from_json_bytes(&request_bytes) { + Ok(request) => request, + Err(error) => { + let _ = write_frame( + &mut stdout, + &json!({"kind":"error","code":error.code,"message":error.message}), + ); + continue; + } + }; + match plugin.invoke(&request) { + Ok(response) => { + let body = response + .to_json_bytes() + .ok() + .and_then(|bytes| serde_json::from_slice::(&bytes).ok()) + .unwrap_or_else(|| json!({"wire_version":1,"kind":"response"})); + if write_frame(&mut stdout, &json!({"kind":"response","response":body})).is_err() { + return 1; + } + } + Err(error) => { + if write_frame( + &mut stdout, + &json!({"kind":"error","code":error.code,"message":error.message,"error_kind":error.kind.as_str()}), + ) + .is_err() + { + return 1; + } + } + } + } + _ => { + if write_frame( + &mut stdout, + &json!({"kind":"error","code":"worker_frame_invalid","message":"unknown frame kind"}), + ) + .is_err() + { + return 1; + } + } + } + } +} + +/// Build a successful response from an embedded wire response value. +pub fn response_from_frame(frame: &Value) -> Result { + let body = frame + .get("response") + .ok_or_else(|| PluginError::wire("worker_response_invalid", "missing response body"))?; + let bytes = serde_json::to_vec(body) + .map_err(|error| PluginError::wire("worker_response_invalid", error.to_string()))?; + WireResponse::from_json_bytes(&bytes) +} diff --git a/crates/marqdo-sandbox/src/lib.rs b/crates/marqdo-sandbox/src/lib.rs index 5c004d5..9114707 100644 --- a/crates/marqdo-sandbox/src/lib.rs +++ b/crates/marqdo-sandbox/src/lib.rs @@ -98,10 +98,10 @@ pub struct PlatformCapabilities { impl PlatformCapabilities { /// Detect capabilities for the current build and platform. /// - /// M0.5 intentionally reports strict isolation as unavailable: no OS - /// isolation adapter is implemented yet, and pretending otherwise would - /// violate the security contract. The worker process transport is likewise - /// not implemented in this build. + /// Strict OS isolation remains intentionally unavailable: no OS isolation + /// adapter is implemented, and pretending otherwise would violate the + /// security contract. The isolated worker transport is implemented, but a + /// plain child process is not an OS sandbox. pub fn detect() -> Self { let reason = if cfg!(target_os = "linux") { "no OS isolation adapter (namespaces/seccomp/cgroups) is implemented in this build" @@ -118,7 +118,7 @@ impl PlatformCapabilities { strict: StrictIsolation::Unavailable { reason: reason.to_string(), }, - worker_processes: false, + worker_processes: true, } } } diff --git a/docs/STATUS.md b/docs/STATUS.md index 59de265..764ef55 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -41,7 +41,7 @@ providers). |---|---|---| | R0 baseline + ADRs | **Done** | this section; `docs/adr/0008`–`0012`; full workspace gate | | R1 package-aware identity + callable registry | **Done for statics** | `ModuleId { instance, relative_path }`; `PackageResolver` path sources; `lock_version: 2` with v1 migration; `CallableRegistry` for builtins/marqdo/declared ABI exports; external manifest wiring is R2 | -| R2 ABI/Kernel/Broker | **In progress** | `KernelRegistry` external providers; complete-name plugin export routing; `CapabilityBroker` with vendor policy; static `check --plugin` signatures; multi-export C test; provider tests. Isolated worker and handle table still pending | +| R2 ABI/Kernel/Broker | **Done (worker = crash isolation)** | `KernelRegistry` external providers; complete-name export routing; `CapabilityBroker`; static `check --plugin`; multi-export C test; isolated worker with timeout/crash tests; host handle table. Native/worker are not an OS sandbox | | R3 Tool Protocol | **Done** | `tool install/list/remove`; unknown-command fallback; atomic local install; SHA/tamper checks; black-box tests for arbitrary names, Unicode args, conflicts, traversal and PATH hijacking | | R4 Analysis/Trace v1 | **Done** | `check --emit` Analysis v1; `run/call --trace-file` Trace v1; deterministic schema tests; independent Python consumer; stale-artifact removal; value redaction | | R5 environment/isolation | **Partial** | Pinned Git fetch/cache, transitive `@alias` resolution, atomic `.marqdo/env` materialization, foreign process-group cleanup. Strict OS isolation remains explicitly unavailable (fail-closed) | diff --git a/examples/plugin-demo/solver.c b/examples/plugin-demo/solver.c index ebcc7b7..14dbd69 100644 --- a/examples/plugin-demo/solver.c +++ b/examples/plugin-demo/solver.c @@ -198,6 +198,11 @@ static int32_t solver_add(MqCallContext *ctx, MqBytes args_wire, } free(json); +#ifdef MQ_SOLVER_CRASH + /* Test-only crash injection for isolated-worker crash tests. */ + abort(); +#endif + if (__builtin_add_overflow(a, b, &sum)) { return emit_error("integer_overflow", "solver.add overflowed i64", error_wire, MQ_ERR_INTERNAL); diff --git a/spec/plugin-abi.md b/spec/plugin-abi.md index 665b15c..e81e783 100644 --- a/spec/plugin-abi.md +++ b/spec/plugin-abi.md @@ -7,9 +7,11 @@ C header is `include/marqdo_plugin_abi_v1.h`; the Rust mirrors are in > **A C ABI is not a sandbox.** A native plugin is loaded into the host > process. It can read host memory, call arbitrary syscalls, bypass the -> capability model and crash the host. Loading requires an explicit trust -> decision. The isolated worker transport described by the blueprint is **not -> implemented** in this build. +> capability model and crash the host. In-process loading requires an explicit +> trust decision. `kind: worker` runs the same native library in an isolated +> child process with length-prefixed JSON frames; that isolates crashes and +> enforces a handshake/call timeout, but a plain child process is **not** an OS +> sandbox. `strict` still refuses without a real isolation adapter. ## 1. Independent versions @@ -164,8 +166,9 @@ Validation (`crates/marqdo-plugin-abi/src/manifest.rs::PluginManifest::validate` * `abi`: caret-style requirement `^1`, `^1.0`, `1` or `1.0`. Caret semantics: `^M.m` means `>=M.m, }` and `{"kind":"shutdown"}`. +Worker → host responses are `{"kind":"response","response":}` or +`{"kind":"error","code":...,"message":...}`. The worker validates that the +declared manifest exports exactly match the library's registrations. ## 10. SDK usage (`crates/marqdo-plugin-sdk`) @@ -410,9 +426,9 @@ when no C compiler is available. | Item | Status | |---|---| -| Isolated plugin worker transport (length-prefixed IPC) | Not implemented; `PlatformCapabilities::worker_processes = false`. | -| Wasm Component + WIT | Not implemented. | -| Hot unload/reload | Not supported by ABI v1 (no shutdown callback). | +| Isolated plugin worker transport (length-prefixed IPC) | Implemented for crash isolation with handshake/call timeouts; a child process is not an OS sandbox. | +| Wasm Component + WIT | Not implemented; `kind: wasm` is rejected explicitly. | +| Hot unload/reload | Not supported by ABI v1; the worker is killed on unload. | | Plugin installation by package manager | Not implemented; `marqdo.yaml` `plugins:` is declarative only. | | Vendor capability handlers | The broker and vendor-name validation exist; no concrete vendor handler is shipped in this build. | | Static validation without an explicit manifest | `check` needs `--plugin `; descriptors are not discovered from the network. |