Files
marqdo-cli/crates/cli/tests/plugin_worker.rs
T
cflmy e029853e32 feat(lang): implement RFC-LANG-0002 unified semantics (breaking)
One Markdown-to-program mapping, no version selector or legacy mapper.

Frontend/runtime:
- resolve @exec/@knowledge heading declarations with nearest-ancestor
  inheritance; only an Exec H2 is callable; add UnitKind::Knowledge and
  sem.* diagnostics (mode marker, unit name, exec-without-function,
  payload nesting/empty, syntax, control stack, params position,
  version directive, inferred-signature lint)
- extract Strong/Emph/inline Code as one-statement carriers, refuse
  nested carriers, and honour heading segment boundaries so an if/while
  cannot be closed across a heading
- lower if/else/while/end to the existing Branch/Loop/Return IR with a
  compile-time control stack; keep payload-relative source spans through
  expression parsing and rewrite them onto the file
- accept params(...) only as the first direct Exec H2 payload; keep the
  existing free-variable inference and named-only rule for inferred
  signatures; fix duplicate-mode/else/end and Knowledge-body inertness
- reject marqdo_semantics/syntax front matter directives

Data and tests:
- migrate stdlib/**/*.mq.md, regenerate stdlib.json digest
- migrate examples and the full semantics/negative/runtime corpus to
  the only current syntax; expected values/runtime codes preserved
- migrate Rust-embedded .mq.md fixtures, init template, CLI help and
  security-lane fixtures

Verified: cargo fmt --check, cargo clippy -D warnings and
cargo test --workspace --locked (green).
2026-11-21 12:26:46 +08:00

297 lines
7.8 KiB
Rust

//! 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()
}
/// Platform dynamic-library name for the test fixture.
fn library_name() -> &'static str {
if cfg!(target_os = "macos") {
"solver.dylib"
} else {
"solver.so"
}
}
/// Flags for building a shared library with the platform C compiler.
fn shared_flags() -> &'static [&'static str] {
if cfg!(target_os = "macos") {
&["-dynamiclib", "-fPIC"]
} else {
&["-shared", "-fPIC"]
}
}
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(library_name());
let status = Command::new("cc")
.args(["-std=c11", "-O2"])
.args(shared_flags())
.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: {}
sha256: "{}"
"#,
HostTarget::current().triple(),
library_name(),
sha
),
)
.unwrap();
std::fs::write(
dir.join("doc.mq.md"),
"## @exec 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));
}
fn compile_capability(dir: &Path, extra: &[&str]) -> PathBuf {
let output = dir.join(if cfg!(target_os = "macos") {
"capability.dylib"
} else {
"capability.so"
});
let status = Command::new("cc")
.args(["-std=c11", "-O2"])
.args(shared_flags())
.arg("-I")
.arg(repo().join("include"))
.args(extra)
.arg(repo().join("tests/abi/capability_plugin.c"))
.arg("-o")
.arg(&output)
.status()
.expect("cc");
assert!(status.success(), "cc failed");
output
}
fn write_capability_manifest(dir: &Path, sha: &str) {
std::fs::write(
dir.join("plugin.yaml"),
format!(
r#"plugin:
name: demo.capability
version: 0.1.0
abi: "^1.0"
kind: worker
exports:
- name: capability.read
signature: "() -> Text"
requires:
- fs.read
artifacts:
- target: {}
file: {}
sha256: "{}"
"#,
HostTarget::current().triple(),
if cfg!(target_os = "macos") {
"capability.dylib"
} else {
"capability.so"
},
sha
),
)
.unwrap();
std::fs::write(
dir.join("doc.mq.md"),
"## @exec main\n\n`结果 = capability.read()`\n\n`打印(结果)`\n",
)
.unwrap();
std::fs::create_dir_all(dir.join("data")).unwrap();
std::fs::write(dir.join("data/allowed.txt"), "hello-worker").unwrap();
}
fn run_capability(dir: &Path, allow_read: bool) -> Output {
let mut command = Command::new(env!("CARGO_BIN_EXE_marqdo"));
command.args([
"run",
dir.join("doc.mq.md").to_str().unwrap(),
"--plugin",
dir.to_str().unwrap(),
"--allow-plugin",
"demo.capability",
]);
if allow_read {
command.args(["--allow-read", "data/**"]);
}
command.output().unwrap()
}
#[test]
fn worker_capability_bridge_reads_granted_file_and_denies_without_grant() {
if !have_cc() {
eprintln!("skipping: cc is unavailable");
return;
}
let dir = TempDir::new("capability");
let artifact = compile_capability(dir.path(), &[]);
write_capability_manifest(dir.path(), &sha256_file(&artifact).unwrap());
let output = run_capability(dir.path(), true);
assert_eq!(
output.status.code(),
Some(0),
"{}",
String::from_utf8_lossy(&output.stderr)
);
assert_eq!(String::from_utf8_lossy(&output.stdout), "hello-worker\n");
let denied = run_capability(dir.path(), false);
assert_eq!(denied.status.code(), Some(1));
let stderr = String::from_utf8_lossy(&denied.stderr);
assert!(
stderr.contains("permission.denied") || stderr.contains("fs.read"),
"{stderr}"
);
assert!(!String::from_utf8_lossy(&denied.stdout).contains("hello-worker"));
}
#[test]
fn worker_capability_request_budget_stops_a_runaway_plugin() {
if !have_cc() {
eprintln!("skipping: cc is unavailable");
return;
}
let dir = TempDir::new("capability-budget");
let artifact = compile_capability(dir.path(), &["-DMQ_CAPABILITY_LOOP"]);
write_capability_manifest(dir.path(), &sha256_file(&artifact).unwrap());
let output = run_capability(dir.path(), true);
assert_eq!(output.status.code(), Some(1));
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(stderr.contains("capability.budget_exceeded"), "{stderr}");
assert!(!String::from_utf8_lossy(&output.stdout).contains("hello-worker"));
}