feat(resource): add grant-checked fs resource operations
This commit is contained in:
1 parent
cd90f059b4
commit
fbe36bcc43
16 files changed
+812
-31
No files matched your search
@@ -62,7 +62,16 @@ fn product_tests() -> Vec<TestFile> {
|
||||
_ => ("", ""),
|
||||
};
|
||||
let args = if name == "fs.mq.md" {
|
||||
&["--allow-read", "out/*", "--allow-write", "out/*"][..]
|
||||
&[
|
||||
"--allow-read",
|
||||
"out",
|
||||
"--allow-read",
|
||||
"out/**",
|
||||
"--allow-write",
|
||||
"out",
|
||||
"--allow-write",
|
||||
"out/**",
|
||||
][..]
|
||||
} else {
|
||||
&[][..]
|
||||
};
|
||||
@@ -148,7 +157,7 @@ fn the_whole_bundled_library_runs_through_std_imports() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fs_test_reads_writes_and_copies_project_files() {
|
||||
fn fs_test_exercises_the_file_operation_surface() {
|
||||
let _guard = lock_fs("fs.mq.md");
|
||||
let report = run_product_test(
|
||||
product_tests()
|
||||
@@ -157,18 +166,21 @@ fn fs_test_reads_writes_and_copies_project_files() {
|
||||
.expect("fs test"),
|
||||
);
|
||||
let items = report["value"]["items"].as_array().expect("list");
|
||||
assert_eq!(items[0]["decimal"], "7");
|
||||
assert_eq!(items[1]["value"], "你好\n");
|
||||
assert_eq!(items[2]["decimal"], "7");
|
||||
assert_eq!(items[3]["value"], "你好\n");
|
||||
let out = stdlib_dir().join("tests/out");
|
||||
assert_eq!(
|
||||
std::fs::read(out.join("fs-a.txt")).unwrap(),
|
||||
"你好\n".as_bytes()
|
||||
);
|
||||
assert_eq!(
|
||||
std::fs::read(out.join("fs-b.txt")).unwrap(),
|
||||
"你好\n".as_bytes()
|
||||
assert_eq!(items[0]["value"], true);
|
||||
assert_eq!(items[1]["decimal"], "7");
|
||||
assert_eq!(items[2]["value"], true);
|
||||
assert_eq!(items[3]["value"], "file");
|
||||
assert_eq!(items[4]["decimal"], "7");
|
||||
assert_eq!(items[5]["items"][0]["value"], "fs-a.txt");
|
||||
assert_eq!(items[6]["value"], true);
|
||||
assert_eq!(items[7]["value"], true);
|
||||
assert_eq!(items[8]["value"], true);
|
||||
assert_eq!(items[9]["value"], "你好\n");
|
||||
assert_eq!(items[10]["value"], true);
|
||||
assert_eq!(items[11]["value"], true);
|
||||
assert!(
|
||||
!stdlib_dir().join("tests/out").exists(),
|
||||
"the fs test did not remove its directory"
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -7,7 +7,8 @@
|
||||
use std::path::{Component, Path, PathBuf};
|
||||
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{ErrorCategory, RuntimeError};
|
||||
use marqdo_value::{ErrorCategory, RuntimeError, Value};
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
/// Maximum size for a single file read.
|
||||
pub const MAX_READ_BYTES: u64 = 8 * 1024 * 1024;
|
||||
@@ -143,6 +144,266 @@ impl ProjectFs {
|
||||
})
|
||||
}
|
||||
|
||||
/// Execute a path operation on the project filesystem.
|
||||
///
|
||||
/// This is the host side of `resource.request`; it validates every path
|
||||
/// against the project root, then returns the recoverable `Result` map.
|
||||
/// Capability checks are performed by the host before this method is
|
||||
/// called. Unknown operations are a programming error and stay fatal.
|
||||
pub fn request(
|
||||
&self,
|
||||
operation: &str,
|
||||
args: &[String],
|
||||
span: Option<Span>,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
match operation {
|
||||
"exists" => {
|
||||
let (absolute, relative) = self.resolve(one_arg(operation, args, span)?, span)?;
|
||||
if !absolute.exists() {
|
||||
return Ok(fs_ok(Value::Bool(false)));
|
||||
}
|
||||
self.ensure_inside(&absolute, &relative, span)?;
|
||||
Ok(fs_ok(Value::Bool(true)))
|
||||
}
|
||||
"metadata" => {
|
||||
let (absolute, relative) = self.resolve(one_arg(operation, args, span)?, span)?;
|
||||
if !absolute.exists() {
|
||||
return Ok(fs_error(
|
||||
"fs.not_found",
|
||||
&format!("`{relative}` does not exist"),
|
||||
));
|
||||
}
|
||||
let absolute = self.ensure_inside(&absolute, &relative, span)?;
|
||||
let metadata = std::fs::metadata(&absolute).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot stat `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
let kind = if metadata.is_file() {
|
||||
"file"
|
||||
} else if metadata.is_dir() {
|
||||
"directory"
|
||||
} else {
|
||||
"other"
|
||||
};
|
||||
let size = if metadata.is_file() {
|
||||
metadata.len()
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let mut value = BTreeMap::new();
|
||||
value.insert("kind".to_string(), Value::text(kind));
|
||||
value.insert(
|
||||
"size".to_string(),
|
||||
Value::int(size.min(i64::MAX as u64) as i64),
|
||||
);
|
||||
Ok(fs_ok(Value::Map(value)))
|
||||
}
|
||||
"list" => {
|
||||
let (absolute, relative) = self.resolve(one_arg(operation, args, span)?, span)?;
|
||||
if !absolute.exists() {
|
||||
return Ok(fs_error(
|
||||
"fs.not_found",
|
||||
&format!("`{relative}` does not exist"),
|
||||
));
|
||||
}
|
||||
let absolute = self.ensure_inside(&absolute, &relative, span)?;
|
||||
let metadata = std::fs::metadata(&absolute).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot stat `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
if !metadata.is_dir() {
|
||||
return Ok(fs_error(
|
||||
"fs.not_directory",
|
||||
&format!("`{relative}` is not a directory"),
|
||||
));
|
||||
}
|
||||
let mut names = Vec::new();
|
||||
let entries = std::fs::read_dir(&absolute).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot list `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
for entry in entries {
|
||||
let entry = entry.map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot list `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
names.push(entry.file_name().to_string_lossy().to_string());
|
||||
}
|
||||
names.sort();
|
||||
Ok(fs_ok(Value::List(
|
||||
names.into_iter().map(Value::text).collect(),
|
||||
)))
|
||||
}
|
||||
"mkdir" => {
|
||||
let (absolute, relative) = self.resolve(one_arg(operation, args, span)?, span)?;
|
||||
self.ensure_parent_inside(&absolute, &relative, span)?;
|
||||
if absolute.exists() {
|
||||
return Ok(fs_error(
|
||||
"fs.exists",
|
||||
&format!("`{relative}` already exists"),
|
||||
));
|
||||
}
|
||||
match std::fs::create_dir(&absolute) {
|
||||
Ok(()) => Ok(fs_ok(Value::None)),
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(fs_error(
|
||||
"fs.not_found",
|
||||
&format!("parent directory of `{relative}` does not exist"),
|
||||
)),
|
||||
Err(error) => Err(RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot create directory `{relative}`: {error}"),
|
||||
)),
|
||||
}
|
||||
}
|
||||
"remove" => {
|
||||
let (absolute, relative) = self.resolve(one_arg(operation, args, span)?, span)?;
|
||||
if !absolute.exists() {
|
||||
return Ok(fs_error(
|
||||
"fs.not_found",
|
||||
&format!("`{relative}` does not exist"),
|
||||
));
|
||||
}
|
||||
let absolute = self.ensure_inside(&absolute, &relative, span)?;
|
||||
let metadata = std::fs::metadata(&absolute).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot stat `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
if metadata.is_dir() {
|
||||
let mut entries = std::fs::read_dir(&absolute).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot list `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
if entries.next().is_some() {
|
||||
return Ok(fs_error(
|
||||
"fs.not_empty",
|
||||
&format!("`{relative}` is not empty"),
|
||||
));
|
||||
}
|
||||
std::fs::remove_dir(&absolute).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot remove `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
} else {
|
||||
std::fs::remove_file(&absolute).map_err(|error| {
|
||||
let category = if error.kind() == std::io::ErrorKind::PermissionDenied {
|
||||
ErrorCategory::PermissionDenied
|
||||
} else {
|
||||
ErrorCategory::HostError
|
||||
};
|
||||
RuntimeError::new(
|
||||
category,
|
||||
span,
|
||||
format!("cannot remove `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
}
|
||||
Ok(fs_ok(Value::None))
|
||||
}
|
||||
"rename" => {
|
||||
if args.len() != 2 {
|
||||
return Err(fs_arity(operation, 2, args.len(), span));
|
||||
}
|
||||
let (from_absolute, from) = self.resolve(&args[0], span)?;
|
||||
let (to_absolute, to) = self.resolve(&args[1], span)?;
|
||||
if !from_absolute.exists() {
|
||||
return Ok(fs_error(
|
||||
"fs.not_found",
|
||||
&format!("`{from}` does not exist"),
|
||||
));
|
||||
}
|
||||
let from_absolute = self.ensure_inside(&from_absolute, &from, span)?;
|
||||
self.ensure_parent_inside(&to_absolute, &to, span)?;
|
||||
if to_absolute.exists() {
|
||||
return Ok(fs_error("fs.exists", &format!("`{to}` already exists")));
|
||||
}
|
||||
match std::fs::rename(&from_absolute, &to_absolute) {
|
||||
Ok(()) => Ok(fs_ok(Value::None)),
|
||||
Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(fs_error(
|
||||
"fs.not_found",
|
||||
&format!("parent directory of `{to}` does not exist"),
|
||||
)),
|
||||
Err(error) => Err(RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot rename `{from}` to `{to}`: {error}"),
|
||||
)),
|
||||
}
|
||||
}
|
||||
other => Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
span,
|
||||
format!("unsupported filesystem operation `{other}`"),
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
fn ensure_inside(
|
||||
&self,
|
||||
absolute: &Path,
|
||||
relative: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<PathBuf, RuntimeError> {
|
||||
let canonical = absolute.canonicalize().map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot resolve `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
if !canonical.starts_with(&self.root) {
|
||||
return Err(invalid_path(span, "path escapes the project root"));
|
||||
}
|
||||
Ok(canonical)
|
||||
}
|
||||
|
||||
fn ensure_parent_inside(
|
||||
&self,
|
||||
absolute: &Path,
|
||||
relative: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let mut ancestor = absolute.parent();
|
||||
while let Some(current) = ancestor {
|
||||
if current.exists() {
|
||||
let canonical = current.canonicalize().map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot resolve `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
if !canonical.starts_with(&self.root) {
|
||||
return Err(invalid_path(span, "path escapes the project root"));
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
ancestor = current.parent();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Write a file inside the project root, creating parent directories.
|
||||
pub fn write(
|
||||
&self,
|
||||
@@ -204,6 +465,40 @@ fn invalid_path(span: Option<Span>, message: impl Into<String>) -> RuntimeError
|
||||
RuntimeError::new(ErrorCategory::PermissionDenied, span, message)
|
||||
}
|
||||
|
||||
fn one_arg<'a>(
|
||||
operation: &str,
|
||||
args: &'a [String],
|
||||
span: Option<Span>,
|
||||
) -> Result<&'a str, RuntimeError> {
|
||||
if args.len() != 1 {
|
||||
return Err(fs_arity(operation, 1, args.len(), span));
|
||||
}
|
||||
Ok(&args[0])
|
||||
}
|
||||
|
||||
fn fs_arity(operation: &str, expected: usize, actual: usize, span: Option<Span>) -> RuntimeError {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::Arity,
|
||||
span,
|
||||
format!("filesystem operation `{operation}` expects {expected} argument(s), got {actual}"),
|
||||
)
|
||||
}
|
||||
|
||||
fn fs_ok(value: Value) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("ok".to_string(), Value::Bool(true));
|
||||
map.insert("value".to_string(), value);
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
fn fs_error(code: &str, message: &str) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("ok".to_string(), Value::Bool(false));
|
||||
map.insert("code".to_string(), Value::text(code));
|
||||
map.insert("message".to_string(), Value::text(message));
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
@@ -139,6 +139,23 @@ pub trait Host {
|
||||
))
|
||||
}
|
||||
|
||||
/// Execute one non-streaming resource operation (ADR-0041).
|
||||
///
|
||||
/// Default: unavailable. The standard host implements the `fs.*` group;
|
||||
/// every call is capability-checked and project-mode only.
|
||||
fn resource_request(
|
||||
&mut self,
|
||||
_operation: &str,
|
||||
_args: Vec<Value>,
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
"this host does not provide resource operations",
|
||||
))
|
||||
}
|
||||
|
||||
/// Consume evaluation fuel.
|
||||
fn consume_fuel(&mut self, amount: u64, span: Option<Span>) -> Result<(), RuntimeError>;
|
||||
|
||||
@@ -1089,6 +1106,93 @@ impl Host for StdHost {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn resource_request(
|
||||
&mut self,
|
||||
operation: &str,
|
||||
args: Vec<Value>,
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
let started = Instant::now();
|
||||
if self.mode != SandboxMode::Project {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::PermissionDenied,
|
||||
ctx.span,
|
||||
"resource operations are available only in project mode",
|
||||
));
|
||||
}
|
||||
if args.iter().any(Value::contains_memory) || args.iter().any(Value::contains_resource) {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
"resource operations accept only Text path arguments",
|
||||
));
|
||||
}
|
||||
let Some(name) = operation.strip_prefix("fs.") else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
format!("unsupported resource operation `{operation}`"),
|
||||
));
|
||||
};
|
||||
let expected = match name {
|
||||
"exists" | "metadata" | "list" | "mkdir" | "remove" => 1,
|
||||
"rename" => 2,
|
||||
other => {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
format!("unsupported filesystem operation `{other}`"),
|
||||
))
|
||||
}
|
||||
};
|
||||
if args.len() != expected {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::Arity,
|
||||
ctx.span,
|
||||
format!(
|
||||
"resource operation `{operation}` expects {expected} argument(s), got {}",
|
||||
args.len()
|
||||
),
|
||||
));
|
||||
}
|
||||
let mut paths = Vec::with_capacity(args.len());
|
||||
for value in args {
|
||||
let value_type = value.type_name();
|
||||
let Value::Text(path) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
ctx.span,
|
||||
format!(
|
||||
"resource operation `{operation}` expects Text paths, got {value_type}"
|
||||
),
|
||||
));
|
||||
};
|
||||
paths.push(path);
|
||||
}
|
||||
match name {
|
||||
"exists" | "metadata" | "list" => {
|
||||
self.capabilities.check_read(&paths[0], ctx.span)?;
|
||||
}
|
||||
"mkdir" | "remove" => {
|
||||
self.capabilities.check_write(&paths[0], ctx.span)?;
|
||||
}
|
||||
"rename" => {
|
||||
self.capabilities.check_write(&paths[0], ctx.span)?;
|
||||
self.capabilities.check_write(&paths[1], ctx.span)?;
|
||||
}
|
||||
_ => unreachable!(),
|
||||
}
|
||||
let result = self.fs.request(name, &paths, ctx.span)?;
|
||||
self.record_semantic(
|
||||
"resource.request",
|
||||
None,
|
||||
Some(&ctx.module_id),
|
||||
ctx.span,
|
||||
Some(&format!("op=fs.{name}")),
|
||||
);
|
||||
self.record_resource_effect("resource.request", ctx, started, &format!("fs.{name}"));
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
fn consume_fuel(&mut self, amount: u64, span: Option<Span>) -> Result<(), RuntimeError> {
|
||||
self.budget.consume_fuel(amount, span)
|
||||
}
|
||||
|
||||
@@ -511,3 +511,106 @@ fn tcp_requires_network_grant_and_rejects_dns_names() {
|
||||
assert_eq!(error.category, ErrorCategory::PermissionDenied);
|
||||
}
|
||||
}
|
||||
|
||||
fn field<'a>(value: &'a Value, name: &str) -> &'a Value {
|
||||
match value {
|
||||
Value::Map(map) => map.get(name).unwrap_or_else(|| panic!("missing `{name}`")),
|
||||
other => panic!("expected a Map, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resource_requests_are_project_only_and_grant_checked() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let ctx = context();
|
||||
let mut pure = StdHost::new(SandboxMode::Pure, Capabilities::pure(), dir.path());
|
||||
let error = pure
|
||||
.resource_request("fs.exists", vec![Value::text("out")], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::PermissionDenied);
|
||||
|
||||
let mut project = StdHost::new(SandboxMode::Project, Capabilities::project(), dir.path());
|
||||
let error = project
|
||||
.resource_request("fs.mkdir", vec![Value::text("out")], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::PermissionDenied);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fs_requests_create_list_rename_and_remove() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let capabilities = Capabilities::project()
|
||||
.allow_read("out")
|
||||
.allow_read("out/**")
|
||||
.allow_write("out")
|
||||
.allow_write("out/**");
|
||||
let mut host = StdHost::new(SandboxMode::Project, capabilities, dir.path());
|
||||
let ctx = context();
|
||||
|
||||
let missing = host
|
||||
.resource_request("fs.exists", vec![Value::text("out")], &ctx)
|
||||
.unwrap();
|
||||
assert_eq!(field(&missing, "value"), &Value::Bool(false));
|
||||
|
||||
let created = host
|
||||
.resource_request("fs.mkdir", vec![Value::text("out")], &ctx)
|
||||
.unwrap();
|
||||
assert_eq!(field(&created, "ok"), &Value::Bool(true));
|
||||
|
||||
std::fs::write(dir.path().join("out/a.txt"), b"hello").unwrap();
|
||||
let metadata = host
|
||||
.resource_request("fs.metadata", vec![Value::text("out/a.txt")], &ctx)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
field(&metadata, "value"),
|
||||
&Value::Map({
|
||||
let mut map = std::collections::BTreeMap::new();
|
||||
map.insert("kind".to_string(), Value::text("file"));
|
||||
map.insert("size".to_string(), Value::int(5));
|
||||
map
|
||||
})
|
||||
);
|
||||
|
||||
let listed = host
|
||||
.resource_request("fs.list", vec![Value::text("out")], &ctx)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
field(&listed, "value"),
|
||||
&Value::List(vec![Value::text("a.txt")])
|
||||
);
|
||||
|
||||
let renamed = host
|
||||
.resource_request(
|
||||
"fs.rename",
|
||||
vec![Value::text("out/a.txt"), Value::text("out/b.txt")],
|
||||
&ctx,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(field(&renamed, "ok"), &Value::Bool(true));
|
||||
assert!(!dir.path().join("out/a.txt").exists());
|
||||
assert!(dir.path().join("out/b.txt").exists());
|
||||
|
||||
let removed = host
|
||||
.resource_request("fs.remove", vec![Value::text("out/b.txt")], &ctx)
|
||||
.unwrap();
|
||||
assert_eq!(field(&removed, "ok"), &Value::Bool(true));
|
||||
let removed_dir = host
|
||||
.resource_request("fs.remove", vec![Value::text("out")], &ctx)
|
||||
.unwrap();
|
||||
assert_eq!(field(&removed_dir, "ok"), &Value::Bool(true));
|
||||
assert!(!dir.path().join("out").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fs_requests_reject_traversal_before_touching_the_filesystem() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let capabilities = Capabilities::project()
|
||||
.allow_write("../**")
|
||||
.allow_read("../**");
|
||||
let mut host = StdHost::new(SandboxMode::Project, capabilities, dir.path());
|
||||
let ctx = context();
|
||||
let error = host
|
||||
.resource_request("fs.mkdir", vec![Value::text("../escape")], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::PermissionDenied);
|
||||
}
|
||||
@@ -298,6 +298,13 @@ const RESOURCE_CLOSE: Builtin = Builtin {
|
||||
named_only: false,
|
||||
effectful: true,
|
||||
};
|
||||
const RESOURCE_REQUEST: Builtin = Builtin {
|
||||
name: "resource.request",
|
||||
aliases: &[],
|
||||
params: &[req("operation"), req("arguments")],
|
||||
named_only: false,
|
||||
effectful: true,
|
||||
};
|
||||
const TABLE_CELL: Builtin = Builtin {
|
||||
name: "table.cell",
|
||||
aliases: &[],
|
||||
@@ -345,6 +352,7 @@ pub const BUILTINS: &[Builtin] = &[
|
||||
RESOURCE_READ,
|
||||
RESOURCE_WRITE,
|
||||
RESOURCE_CLOSE,
|
||||
RESOURCE_REQUEST,
|
||||
];
|
||||
|
||||
/// Find a builtin by canonical name or alias.
|
||||
|
||||
@@ -478,6 +478,17 @@ pub(crate) fn dispatch(
|
||||
Err(error) => resource_recoverable(error),
|
||||
}
|
||||
}
|
||||
"resource.request" => {
|
||||
let operation = expect_text_value(take(&bound, "operation", builtin, span)?, span)?;
|
||||
let value_type = bound["arguments"].type_name();
|
||||
let Value::List(arguments) = take(&bound, "arguments", builtin, span)? else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("resource.request arguments must be a List, got {value_type}"),
|
||||
));
|
||||
};
|
||||
interpreter.resource_request(&operation, arguments, &module, span)
|
||||
}
|
||||
other => Err(RuntimeError::new(
|
||||
ErrorCategory::KernelUnavailable,
|
||||
span,
|
||||
|
||||
@@ -903,6 +903,23 @@ impl<'a> Interpreter<'a> {
|
||||
})
|
||||
}
|
||||
|
||||
/// Execute one non-streaming resource operation.
|
||||
pub(crate) fn resource_request(
|
||||
&mut self,
|
||||
operation: &str,
|
||||
args: Vec<Value>,
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_request(operation, args, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Close a resource stream.
|
||||
pub(crate) fn resource_close(
|
||||
&mut self,
|
||||
|
||||
Reference in new issue
Block a user