feat(pdftract-mcp): add MCP server implementation changes
Changes from Phase 6.7 child beads that were not committed earlier: - Add subtle dependency for constant-time token comparison - Add root directory for path-traversal protection in HTTP+SSE transport - Update MCP server state to support --root flag - Minor fixes and improvements across MCP modules These changes support the 7 closed child beads: - pdftract-5xq16: JSON-RPC 2.0 framing layer - pdftract-67tm8: stdio transport - pdftract-g0ro2: HTTP+SSE transport - pdftract-24kut: transport mutual exclusion enforcement - pdftract-1rami: tool catalog (10 tools) - pdftract-6696g: path-traversal protection - pdftract-zltqd: bearer-token auth Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
jedarden
parent
40ef091952
commit
210c40de8c
16 changed files with 858 additions and 98 deletions
|
|
@ -1 +1 @@
|
|||
0da3d71670d2e2ccd59d1aae414c1dce908e2f4f
|
||||
556aa10434dfa14a1c6e4ab129ddee68957b43df
|
||||
|
|
|
|||
286
Cargo.lock
generated
286
Cargo.lock
generated
|
|
@ -8,6 +8,20 @@ version = "2.0.1"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
|
||||
|
||||
[[package]]
|
||||
name = "ahash"
|
||||
version = "0.8.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"getrandom 0.3.4",
|
||||
"once_cell",
|
||||
"serde",
|
||||
"version_check",
|
||||
"zerocopy",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aho-corasick"
|
||||
version = "1.1.4"
|
||||
|
|
@ -215,15 +229,30 @@ version = "0.22.1"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
|
||||
|
||||
[[package]]
|
||||
name = "bit-set"
|
||||
version = "0.5.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
|
||||
dependencies = [
|
||||
"bit-vec 0.6.3",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bit-set"
|
||||
version = "0.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
|
||||
dependencies = [
|
||||
"bit-vec",
|
||||
"bit-vec 0.8.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bit-vec"
|
||||
version = "0.6.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
|
||||
|
||||
[[package]]
|
||||
name = "bit-vec"
|
||||
version = "0.8.0"
|
||||
|
|
@ -282,6 +311,12 @@ version = "3.20.2"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
|
||||
|
||||
[[package]]
|
||||
name = "bytecount"
|
||||
version = "0.6.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e"
|
||||
|
||||
[[package]]
|
||||
name = "byteorder"
|
||||
version = "1.5.0"
|
||||
|
|
@ -489,6 +524,15 @@ dependencies = [
|
|||
"typenum",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deranged"
|
||||
version = "0.5.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
|
||||
dependencies = [
|
||||
"powerfmt",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "deunicode"
|
||||
version = "1.6.2"
|
||||
|
|
@ -516,6 +560,12 @@ dependencies = [
|
|||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "dyn-clone"
|
||||
version = "1.0.20"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
|
||||
|
||||
[[package]]
|
||||
name = "equivalent"
|
||||
version = "1.0.2"
|
||||
|
|
@ -532,6 +582,17 @@ dependencies = [
|
|||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fancy-regex"
|
||||
version = "0.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "531e46835a22af56d1e3b66f04844bed63158bc094a628bec1d321d9b4c44bf2"
|
||||
dependencies = [
|
||||
"bit-set 0.5.3",
|
||||
"regex-automata",
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fastrand"
|
||||
version = "2.4.1"
|
||||
|
|
@ -575,6 +636,16 @@ dependencies = [
|
|||
"percent-encoding",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fraction"
|
||||
version = "0.15.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e076045bb43dac435333ed5f04caf35c7463631d0dae2deb2638d94dd0a5b872"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
"num",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "futures-channel"
|
||||
version = "0.3.32"
|
||||
|
|
@ -1060,6 +1131,15 @@ version = "1.70.2"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
|
||||
|
||||
[[package]]
|
||||
name = "iso8601"
|
||||
version = "0.6.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e1082f0c48f143442a1ac6122f67e360ceee130b967af4d50996e5154a45df46"
|
||||
dependencies = [
|
||||
"nom",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "1.0.18"
|
||||
|
|
@ -1088,6 +1168,36 @@ dependencies = [
|
|||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "jsonschema"
|
||||
version = "0.18.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fa0f4bea31643be4c6a678e9aa4ae44f0db9e5609d5ca9dc9083d06eb3e9a27a"
|
||||
dependencies = [
|
||||
"ahash",
|
||||
"anyhow",
|
||||
"base64",
|
||||
"bytecount",
|
||||
"clap",
|
||||
"fancy-regex",
|
||||
"fraction",
|
||||
"getrandom 0.2.17",
|
||||
"iso8601",
|
||||
"itoa",
|
||||
"memchr",
|
||||
"num-cmp",
|
||||
"once_cell",
|
||||
"parking_lot",
|
||||
"percent-encoding",
|
||||
"regex",
|
||||
"reqwest",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"time",
|
||||
"url",
|
||||
"uuid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "lazy_static"
|
||||
version = "1.5.0"
|
||||
|
|
@ -1199,6 +1309,91 @@ dependencies = [
|
|||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "nom"
|
||||
version = "8.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num"
|
||||
version = "0.4.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
|
||||
dependencies = [
|
||||
"num-bigint",
|
||||
"num-complex",
|
||||
"num-integer",
|
||||
"num-iter",
|
||||
"num-rational",
|
||||
"num-traits",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-bigint"
|
||||
version = "0.4.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
|
||||
dependencies = [
|
||||
"num-integer",
|
||||
"num-traits",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-cmp"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "63335b2e2c34fae2fb0aa2cecfd9f0832a1e24b3b32ecec612c3426d46dc8aaa"
|
||||
|
||||
[[package]]
|
||||
name = "num-complex"
|
||||
version = "0.4.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
|
||||
dependencies = [
|
||||
"num-traits",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-conv"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
|
||||
|
||||
[[package]]
|
||||
name = "num-integer"
|
||||
version = "0.1.46"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
|
||||
dependencies = [
|
||||
"num-traits",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-iter"
|
||||
version = "0.1.45"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
"num-integer",
|
||||
"num-traits",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-rational"
|
||||
version = "0.4.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
|
||||
dependencies = [
|
||||
"num-bigint",
|
||||
"num-integer",
|
||||
"num-traits",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.19"
|
||||
|
|
@ -1264,14 +1459,18 @@ dependencies = [
|
|||
"http-body-util",
|
||||
"hyper",
|
||||
"hyper-util",
|
||||
"jsonschema",
|
||||
"libc",
|
||||
"lzw",
|
||||
"pdftract-core",
|
||||
"regex",
|
||||
"reqwest",
|
||||
"schemars",
|
||||
"secrecy",
|
||||
"serde",
|
||||
"serde_json",
|
||||
"sha2",
|
||||
"subtle",
|
||||
"tempfile",
|
||||
"tera",
|
||||
"tokio",
|
||||
|
|
@ -1423,6 +1622,12 @@ dependencies = [
|
|||
"zerovec",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "powerfmt"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
|
||||
|
||||
[[package]]
|
||||
name = "ppv-lite86"
|
||||
version = "0.2.21"
|
||||
|
|
@ -1457,8 +1662,8 @@ version = "1.11.0"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
|
||||
dependencies = [
|
||||
"bit-set",
|
||||
"bit-vec",
|
||||
"bit-set 0.8.0",
|
||||
"bit-vec 0.8.0",
|
||||
"bitflags",
|
||||
"num-traits",
|
||||
"rand 0.9.4",
|
||||
|
|
@ -1862,6 +2067,30 @@ dependencies = [
|
|||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "schemars"
|
||||
version = "0.8.22"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
|
||||
dependencies = [
|
||||
"dyn-clone",
|
||||
"schemars_derive",
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "schemars_derive"
|
||||
version = "0.8.22"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"serde_derive_internals",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "scopeguard"
|
||||
version = "1.2.0"
|
||||
|
|
@ -1913,6 +2142,17 @@ dependencies = [
|
|||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive_internals"
|
||||
version = "0.29.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.149"
|
||||
|
|
@ -2171,6 +2411,36 @@ dependencies = [
|
|||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "time"
|
||||
version = "0.3.47"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
|
||||
dependencies = [
|
||||
"deranged",
|
||||
"num-conv",
|
||||
"powerfmt",
|
||||
"serde_core",
|
||||
"time-core",
|
||||
"time-macros",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "time-core"
|
||||
version = "0.1.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
|
||||
|
||||
[[package]]
|
||||
name = "time-macros"
|
||||
version = "0.2.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
|
||||
dependencies = [
|
||||
"num-conv",
|
||||
"time-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinystr"
|
||||
version = "0.8.3"
|
||||
|
|
@ -2439,6 +2709,16 @@ version = "0.2.2"
|
|||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uuid"
|
||||
version = "1.23.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76"
|
||||
dependencies = [
|
||||
"js-sys",
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "version_check"
|
||||
version = "0.9.5"
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@ pdftract-core = { path = "../pdftract-core" }
|
|||
regex = "1.10"
|
||||
secrecy = { workspace = true }
|
||||
serde = { workspace = true, features = ["derive"] }
|
||||
subtle = "2.6"
|
||||
sha2 = "0.10"
|
||||
serde_json = "1.0"
|
||||
schemars = { version = "0.8", features = ["derive"] }
|
||||
|
|
|
|||
|
|
@ -83,18 +83,17 @@ enum Commands {
|
|||
/// Per ADR-006: stdio and HTTP transports are mutually exclusive because they have
|
||||
/// opposite stdout discipline (stdio: JSON-RPC sink; HTTP: log channel). Exactly one
|
||||
/// transport must be selected per invocation.
|
||||
#[group(id = "transport", multiple = false)]
|
||||
Mcp {
|
||||
/// Use stdio transport (for Claude Desktop, Claude Code, Continue, Cursor)
|
||||
///
|
||||
/// This is the default transport mode if neither --stdio nor --bind is specified.
|
||||
#[arg(long, group = "transport")]
|
||||
#[arg(long, conflicts_with = "bind")]
|
||||
stdio: bool,
|
||||
|
||||
/// Bind address for the MCP server (e.g., "127.0.0.1:8080", "[::1]:9000", "0.0.0.0:3000")
|
||||
///
|
||||
/// Enables HTTP+SSE transport mode. Mutually exclusive with --stdio.
|
||||
#[arg(short, long, value_name = "ADDR", group = "transport")]
|
||||
#[arg(short, long, value_name = "ADDR", conflicts_with = "stdio")]
|
||||
bind: Option<String>,
|
||||
|
||||
/// Path to a file containing the bearer token (RECOMMENDED)
|
||||
|
|
@ -108,6 +107,15 @@ enum Commands {
|
|||
/// Maximum request body size in MB (default: 256)
|
||||
#[arg(long, default_value = "256")]
|
||||
max_upload_mb: usize,
|
||||
|
||||
/// Root directory for local filesystem access (enforces path-traversal protection)
|
||||
///
|
||||
/// When set, all local-path tool arguments are resolved relative to DIR and any
|
||||
/// path that escapes DIR is rejected with JSON-RPC error code -32602.
|
||||
/// HTTPS URLs are not affected by this flag. Without --root, the server runs in
|
||||
/// trust-the-caller mode (no path-check applied).
|
||||
#[arg(long, value_name = "DIR")]
|
||||
root: Option<PathBuf>,
|
||||
},
|
||||
}
|
||||
|
||||
|
|
@ -182,21 +190,43 @@ fn main() -> Result<()> {
|
|||
auth_token_file,
|
||||
auth_token,
|
||||
max_upload_mb,
|
||||
root,
|
||||
} => {
|
||||
// Per ADR-006: exactly one transport must be selected.
|
||||
// If neither --stdio nor --bind is specified, default to stdio mode.
|
||||
let use_stdio = stdio || bind.is_none();
|
||||
|
||||
// Validate and canonicalize the root directory if provided
|
||||
let root_path = match root {
|
||||
Some(ref root_arg) => {
|
||||
match mcp::canonicalize_root(root_arg) {
|
||||
Ok(canonical) => Some(canonical),
|
||||
Err(e) => {
|
||||
eprintln!("Error: {}", e);
|
||||
std::process::exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
|
||||
// Report root configuration
|
||||
if let Some(ref root) = root_path {
|
||||
eprintln!("Root directory: {} (path-traversal protection enabled)", root.display());
|
||||
} else {
|
||||
eprintln!("No root directory (trust-the-caller mode)");
|
||||
}
|
||||
|
||||
if use_stdio {
|
||||
// stdio mode (default for Claude Desktop, Claude Code, etc.)
|
||||
if let Err(e) = mcp::run_stdio() {
|
||||
if let Err(e) = mcp::run_stdio(root_path.as_deref()) {
|
||||
eprintln!("Error: {}", e);
|
||||
std::process::exit(1);
|
||||
}
|
||||
} else {
|
||||
// HTTP mode (--bind was specified)
|
||||
let bind_addr = bind.expect("--bind is Some when use_stdio is false");
|
||||
if let Err(e) = mcp::run(bind_addr, auth_token_file, auth_token, Some(max_upload_mb)) {
|
||||
if let Err(e) = mcp::run(bind_addr, auth_token_file, auth_token, Some(max_upload_mb), root_path) {
|
||||
eprintln!("Error: {}", e);
|
||||
std::process::exit(1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,6 +10,27 @@ pub const EXIT_USAGE_ERROR: u8 = 64;
|
|||
/// Minimum recommended token length (bytes)
|
||||
const MIN_TOKEN_LENGTH: usize = 32;
|
||||
|
||||
/// The source of the authentication token.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum AuthSource {
|
||||
/// Token from --auth-token-file PATH (recommended)
|
||||
TokenFile,
|
||||
/// Token from PDFTRACT_MCP_TOKEN environment variable
|
||||
EnvVar,
|
||||
/// Token from --auth-token VALUE (deprecated, requires PDFTRACT_INSECURE_CLI_TOKEN=1)
|
||||
CliInsecure,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for AuthSource {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
AuthSource::TokenFile => write!(f, "--auth-token-file"),
|
||||
AuthSource::EnvVar => write!(f, "PDFTRACT_MCP_TOKEN env var"),
|
||||
AuthSource::CliInsecure => write!(f, "--auth-token (insecure)"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolves the MCP bearer token from multiple possible sources.
|
||||
///
|
||||
/// Priority order:
|
||||
|
|
@ -18,27 +39,28 @@ const MIN_TOKEN_LENGTH: usize = 32;
|
|||
/// 3. `--auth-token VALUE` (only if `PDFTRACT_INSECURE_CLI_TOKEN=1`) — DEPRECATED
|
||||
/// 4. None
|
||||
///
|
||||
/// Returns the token (if any) and the source that provided it.
|
||||
/// Tokens shorter than 32 characters emit a warning but are accepted
|
||||
/// to avoid breaking existing deployments.
|
||||
pub fn resolve_token(
|
||||
token_file: Option<&Path>,
|
||||
env_token: Option<String>,
|
||||
cli_token: Option<String>,
|
||||
) -> Result<Option<SecretString>> {
|
||||
) -> Result<Option<(SecretString, AuthSource)>> {
|
||||
// Priority 1: --auth-token-file
|
||||
if let Some(path) = token_file {
|
||||
let token_content = fs::read_to_string(path)
|
||||
.with_context(|| format!("Failed to read token file: {}", path.display()))?;
|
||||
let token = token_content.trim_end().to_string();
|
||||
check_token_length(&token);
|
||||
return Ok(Some(SecretString::new(token.into())));
|
||||
return Ok(Some((SecretString::new(token.into()), AuthSource::TokenFile)));
|
||||
}
|
||||
|
||||
// Priority 2: PDFTRACT_MCP_TOKEN env var
|
||||
if let Some(token) = env_token {
|
||||
if !token.is_empty() {
|
||||
check_token_length(&token);
|
||||
return Ok(Some(SecretString::new(token.into())));
|
||||
return Ok(Some((SecretString::new(token.into()), AuthSource::EnvVar)));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -62,7 +84,7 @@ pub fn resolve_token(
|
|||
Recommended: Use --auth-token-file PATH or PDFTRACT_MCP_TOKEN env var."
|
||||
);
|
||||
check_token_length(&token);
|
||||
return Ok(Some(SecretString::new(token.into())));
|
||||
return Ok(Some((SecretString::new(token.into()), AuthSource::CliInsecure)));
|
||||
}
|
||||
|
||||
// No token provided
|
||||
|
|
@ -93,7 +115,7 @@ mod tests {
|
|||
let temp_file = NamedTempFile::new().unwrap();
|
||||
write(temp_file.path(), "file-token\n").unwrap();
|
||||
|
||||
let token = resolve_token(
|
||||
let (token, source) = resolve_token(
|
||||
Some(temp_file.path()),
|
||||
Some("env-token".to_string()),
|
||||
Some("cli-token".to_string()),
|
||||
|
|
@ -102,11 +124,12 @@ mod tests {
|
|||
.unwrap();
|
||||
|
||||
assert_eq!(token.expose_secret(), "file-token");
|
||||
assert_eq!(source, AuthSource::TokenFile);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_resolve_token_priority_env_second() {
|
||||
let token = resolve_token(
|
||||
let (token, source) = resolve_token(
|
||||
None,
|
||||
Some("env-token".to_string()),
|
||||
Some("cli-token".to_string()),
|
||||
|
|
@ -115,6 +138,7 @@ mod tests {
|
|||
.unwrap();
|
||||
|
||||
assert_eq!(token.expose_secret(), "env-token");
|
||||
assert_eq!(source, AuthSource::EnvVar);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -127,12 +151,13 @@ mod tests {
|
|||
#[test]
|
||||
fn test_resolve_token_accepts_cli_token_with_insecure_flag() {
|
||||
env::set_var("PDFTRACT_INSECURE_CLI_TOKEN", "1");
|
||||
let token = resolve_token(None, None, Some("cli-token".to_string()))
|
||||
let (token, source) = resolve_token(None, None, Some("cli-token".to_string()))
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
env::remove_var("PDFTRACT_INSECURE_CLI_TOKEN");
|
||||
|
||||
assert_eq!(token.expose_secret(), "cli-token");
|
||||
assert_eq!(source, AuthSource::CliInsecure);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -152,11 +177,12 @@ mod tests {
|
|||
let temp_file = NamedTempFile::new().unwrap();
|
||||
write(temp_file.path(), "token-with-newline\n").unwrap();
|
||||
|
||||
let token = resolve_token(Some(temp_file.path()), None, None)
|
||||
let (token, source) = resolve_token(Some(temp_file.path()), None, None)
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(token.expose_secret(), "token-with-newline");
|
||||
assert_eq!(source, AuthSource::TokenFile);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -165,10 +191,11 @@ mod tests {
|
|||
write(temp_file.path(), "short").unwrap();
|
||||
|
||||
// Should succeed but emit warning (captured in test output)
|
||||
let token = resolve_token(Some(temp_file.path()), None, None)
|
||||
let (token, source) = resolve_token(Some(temp_file.path()), None, None)
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(token.expose_secret(), "short");
|
||||
assert_eq!(source, AuthSource::TokenFile);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -225,6 +225,20 @@ impl ErrorObject {
|
|||
self
|
||||
}
|
||||
|
||||
/// Override the message of the error.
|
||||
pub fn with_message(mut self, message: impl Into<String>) -> Self {
|
||||
self.message = message.into();
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ErrorObject {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "{} (code {})", self.message, self.code)
|
||||
}
|
||||
}
|
||||
|
||||
impl ErrorObject {
|
||||
// JSON-RPC 2.0 spec-defined error constructors
|
||||
|
||||
/// Parse error (-32700): Invalid JSON was received.
|
||||
|
|
|
|||
|
|
@ -24,6 +24,7 @@
|
|||
use crate::mcp::framing::{BatchMessage, ErrorObject, Id, Notification, Request, Response};
|
||||
use crate::mcp::tools;
|
||||
use anyhow::{anyhow, Context, Result};
|
||||
use subtle::ConstantTimeEq;
|
||||
use axum::{
|
||||
body::Body,
|
||||
extract::{DefaultBodyLimit, Request as AxumRequest, State},
|
||||
|
|
@ -35,6 +36,7 @@ use axum::{
|
|||
use secrecy::{ExposeSecret, SecretString};
|
||||
use serde_json::{json, Value};
|
||||
use std::net::SocketAddr;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
|
@ -66,11 +68,14 @@ pub struct McpServerState {
|
|||
|
||||
/// Tool registry for tools/list and tools/call
|
||||
tool_registry: Arc<tools::ToolRegistry>,
|
||||
|
||||
/// Root directory for path-traversal protection (canonicalized at startup)
|
||||
root: Option<PathBuf>,
|
||||
}
|
||||
|
||||
impl McpServerState {
|
||||
/// Create a new MCP server state.
|
||||
pub fn new(auth_token: Option<SecretString>, max_upload_mb: Option<usize>) -> Self {
|
||||
pub fn new(auth_token: Option<SecretString>, max_upload_mb: Option<usize>, root: Option<PathBuf>) -> Self {
|
||||
let max_body_bytes = max_upload_mb.unwrap_or(DEFAULT_MAX_UPLOAD_MB) * 1024 * 1024;
|
||||
let notify_tx = broadcast::channel(100).0; // Channel size 100 for buffered notifications
|
||||
|
||||
|
|
@ -80,6 +85,7 @@ impl McpServerState {
|
|||
max_body_bytes,
|
||||
client_count: Arc::new(AtomicUsize::new(0)),
|
||||
tool_registry: Arc::new(tools::all_tools()),
|
||||
root,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -111,6 +117,7 @@ impl McpServerState {
|
|||
/// * `bind_addr` - The bind address (e.g., "127.0.0.1:8080")
|
||||
/// * `auth_token` - Optional bearer token for authentication
|
||||
/// * `max_upload_mb` - Optional max upload size in MB (default 256)
|
||||
/// * `root` - Optional root directory for path-traversal protection
|
||||
///
|
||||
/// # Returns
|
||||
/// * Ok(()) when the server shuts down cleanly
|
||||
|
|
@ -119,9 +126,10 @@ pub async fn run_server(
|
|||
bind_addr: String,
|
||||
auth_token: Option<SecretString>,
|
||||
max_upload_mb: Option<usize>,
|
||||
root: Option<&std::path::Path>,
|
||||
) -> Result<()> {
|
||||
// Create the shared server state
|
||||
let state = McpServerState::new(auth_token, max_upload_mb);
|
||||
let state = McpServerState::new(auth_token, max_upload_mb, root.map(|p| p.to_path_buf()));
|
||||
let max_body_bytes = state.max_body_bytes;
|
||||
|
||||
// Build the router
|
||||
|
|
@ -208,9 +216,10 @@ async fn handle_post_request(
|
|||
let requests = batch.into_requests();
|
||||
let mut responses = Vec::with_capacity(requests.len());
|
||||
let registry = state.tool_registry.as_ref();
|
||||
let root = state.root.as_deref();
|
||||
|
||||
for request in requests {
|
||||
let response = handle_request(request, registry);
|
||||
let response = handle_request(request, registry, root);
|
||||
responses.push(response);
|
||||
}
|
||||
|
||||
|
|
@ -330,10 +339,55 @@ async fn handle_health() -> impl IntoResponse {
|
|||
}))
|
||||
}
|
||||
|
||||
/// Verify a bearer token against the configured token using constant-time comparison.
|
||||
///
|
||||
/// Returns true if the tokens match, false otherwise.
|
||||
/// This function is pure computation with no side effects, making it suitable
|
||||
/// for timing-attack resistance testing.
|
||||
///
|
||||
/// The comparison is constant-time with respect to both content and length:
|
||||
/// - All bytes are always compared
|
||||
/// - No short-circuiting on length mismatch
|
||||
/// - Timing does not reveal where the first mismatch occurred
|
||||
fn verify_token(provided: &str, configured: &str) -> bool {
|
||||
use subtle::Choice;
|
||||
|
||||
let provided_bytes = provided.as_bytes();
|
||||
let configured_bytes = configured.as_bytes();
|
||||
|
||||
// To achieve true constant-time comparison regardless of length,
|
||||
// we need to always compare the same number of bytes.
|
||||
// We use the maximum length and pad the shorter slice with zeros.
|
||||
let max_len = provided_bytes.len().max(configured_bytes.len());
|
||||
|
||||
// Create extended arrays that are both the same length (max_len)
|
||||
// The shorter slice is padded with zeros at the end
|
||||
let mut provided_ext = Vec::with_capacity(max_len);
|
||||
let mut configured_ext = Vec::with_capacity(max_len);
|
||||
|
||||
provided_ext.extend_from_slice(provided_bytes);
|
||||
provided_ext.resize(max_len, 0);
|
||||
|
||||
configured_ext.extend_from_slice(configured_bytes);
|
||||
configured_ext.resize(max_len, 0);
|
||||
|
||||
// Constant-time compare the extended arrays
|
||||
let bytes_match = provided_ext.ct_eq(&configured_ext);
|
||||
|
||||
// For the tokens to be truly equal, we also need the lengths to match.
|
||||
// We compute this in constant-time using Choice.
|
||||
let lengths_match = Choice::from(u8::from(provided_bytes.len() == configured_bytes.len()));
|
||||
|
||||
// Both bytes AND lengths must match
|
||||
(bytes_match & lengths_match).into()
|
||||
}
|
||||
|
||||
/// Check bearer token authentication.
|
||||
///
|
||||
/// Returns Err(response) if auth fails, Ok(()) if auth passes.
|
||||
/// If no auth token is configured, all requests are allowed.
|
||||
///
|
||||
/// Token comparison uses constant-time comparison to prevent timing attacks.
|
||||
fn check_auth(
|
||||
state: &McpServerState,
|
||||
headers: &HeaderMap,
|
||||
|
|
@ -346,13 +400,21 @@ fn check_auth(
|
|||
match auth_header {
|
||||
Some(header) if header.starts_with("Bearer ") => {
|
||||
let provided_token = &header[7..]; // Strip "Bearer "
|
||||
if provided_token == token.expose_secret() {
|
||||
let configured_token = token.expose_secret();
|
||||
|
||||
// Use constant-time comparison to prevent timing attacks
|
||||
if verify_token(provided_token, configured_token) {
|
||||
Ok(())
|
||||
} else {
|
||||
Err((
|
||||
let mut response = (
|
||||
StatusCode::UNAUTHORIZED,
|
||||
Json(Response::error(Id::Null, ErrorObject::new(-32001, "Invalid authentication token"))),
|
||||
).into_response())
|
||||
).into_response();
|
||||
response.headers_mut().insert(
|
||||
"WWW-Authenticate",
|
||||
HeaderValue::from_static("Bearer realm=\"pdftract\""),
|
||||
);
|
||||
Err(response)
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
|
|
@ -362,7 +424,7 @@ fn check_auth(
|
|||
).into_response();
|
||||
response.headers_mut().insert(
|
||||
"WWW-Authenticate",
|
||||
HeaderValue::from_static("Bearer"),
|
||||
HeaderValue::from_static("Bearer realm=\"pdftract\""),
|
||||
);
|
||||
Err(response)
|
||||
}
|
||||
|
|
@ -373,7 +435,7 @@ fn check_auth(
|
|||
}
|
||||
|
||||
/// Handle a single JSON-RPC request and return a response.
|
||||
fn handle_request(request: Request, registry: &tools::ToolRegistry) -> Response {
|
||||
fn handle_request(request: Request, registry: &tools::ToolRegistry, root: Option<&std::path::Path>) -> Response {
|
||||
let id = request.request_id();
|
||||
|
||||
match request.method.as_str() {
|
||||
|
|
@ -428,7 +490,7 @@ fn handle_request(request: Request, registry: &tools::ToolRegistry) -> Response
|
|||
let start = std::time::Instant::now();
|
||||
let log_path = arguments.get("path").and_then(|v| v.as_str()).map(|s| s.to_string());
|
||||
|
||||
let result = tool.execute(arguments, log_path.as_deref());
|
||||
let result = tool.execute(arguments, log_path.as_deref(), root);
|
||||
|
||||
let duration_ms = start.elapsed().as_millis();
|
||||
let response_size = result.as_ref().ok()
|
||||
|
|
@ -510,7 +572,7 @@ mod tests {
|
|||
#[test]
|
||||
fn test_mcp_server_state_creation() {
|
||||
let token = SecretString::new("test-token".into());
|
||||
let state = McpServerState::new(Some(token), Some(10));
|
||||
let state = McpServerState::new(Some(token), Some(10), None);
|
||||
|
||||
assert_eq!(state.max_body_bytes, 10 * 1024 * 1024);
|
||||
assert_eq!(state.client_count(), 0);
|
||||
|
|
@ -519,7 +581,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_mcp_server_state_no_token() {
|
||||
let state = McpServerState::new(None, None);
|
||||
let state = McpServerState::new(None, None, None);
|
||||
|
||||
assert_eq!(state.max_body_bytes, DEFAULT_MAX_UPLOAD_MB * 1024 * 1024);
|
||||
assert_eq!(state.client_count(), 0);
|
||||
|
|
@ -528,7 +590,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn test_mcp_server_state_broadcast() {
|
||||
let state = McpServerState::new(None, None);
|
||||
let state = McpServerState::new(None, None, None);
|
||||
let notification = Notification::new("test/notification", None);
|
||||
|
||||
// Broadcast with no clients should return 0
|
||||
|
|
@ -540,7 +602,7 @@ mod tests {
|
|||
fn test_handle_request_tools_list() {
|
||||
let registry = tools::all_tools();
|
||||
let request = Request::new("tools/list", None, Some(Id::Number(1)));
|
||||
let response = handle_request(request, ®istry);
|
||||
let response = handle_request(request, ®istry, None);
|
||||
|
||||
assert!(response.is_success());
|
||||
assert!(response.get_result().is_some());
|
||||
|
|
@ -550,7 +612,7 @@ mod tests {
|
|||
fn test_handle_request_initialize() {
|
||||
let registry = tools::all_tools();
|
||||
let request = Request::new("initialize", None, Some(Id::Number(1)));
|
||||
let response = handle_request(request, ®istry);
|
||||
let response = handle_request(request, ®istry, None);
|
||||
|
||||
assert!(response.is_success());
|
||||
let result = response.get_result().unwrap();
|
||||
|
|
@ -562,7 +624,7 @@ mod tests {
|
|||
fn test_handle_request_unknown_method() {
|
||||
let registry = tools::all_tools();
|
||||
let request = Request::new("unknown/method", None, Some(Id::Number(1)));
|
||||
let response = handle_request(request, ®istry);
|
||||
let response = handle_request(request, ®istry, None);
|
||||
|
||||
assert!(response.is_error());
|
||||
let error = response.get_error().unwrap();
|
||||
|
|
@ -576,4 +638,209 @@ mod tests {
|
|||
|
||||
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_auth_no_token_configured() {
|
||||
let state = McpServerState::new(None, None, None);
|
||||
let mut headers = HeaderMap::new();
|
||||
|
||||
// No token configured, so any headers should pass
|
||||
assert!(check_auth(&state, &headers).is_ok());
|
||||
|
||||
headers.insert("Authorization", HeaderValue::from_static("Bearer irrelevant"));
|
||||
assert!(check_auth(&state, &headers).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_auth_valid_token() {
|
||||
let token = SecretString::new("correct-token".into());
|
||||
let state = McpServerState::new(Some(token), None, None);
|
||||
let mut headers = HeaderMap::new();
|
||||
|
||||
headers.insert("Authorization", HeaderValue::from_static("Bearer correct-token"));
|
||||
assert!(check_auth(&state, &headers).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_auth_invalid_token() {
|
||||
let token = SecretString::new("correct-token".into());
|
||||
let state = McpServerState::new(Some(token), None, None);
|
||||
let mut headers = HeaderMap::new();
|
||||
|
||||
headers.insert("Authorization", HeaderValue::from_static("Bearer wrong-token"));
|
||||
let result = check_auth(&state, &headers);
|
||||
assert!(result.is_err());
|
||||
if let Err(resp) = result {
|
||||
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_auth_missing_token() {
|
||||
let token = SecretString::new("correct-token".into());
|
||||
let state = McpServerState::new(Some(token), None, None);
|
||||
let headers = HeaderMap::new();
|
||||
|
||||
let result = check_auth(&state, &headers);
|
||||
assert!(result.is_err());
|
||||
if let Err(resp) = result {
|
||||
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
|
||||
assert!(resp.headers().get("WWW-Authenticate").is_some());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_check_auth_malformed_header() {
|
||||
let token = SecretString::new("correct-token".into());
|
||||
let state = McpServerState::new(Some(token), None, None);
|
||||
let mut headers = HeaderMap::new();
|
||||
|
||||
// Missing "Bearer " prefix
|
||||
headers.insert("Authorization", HeaderValue::from_static("correct-token"));
|
||||
let result = check_auth(&state, &headers);
|
||||
assert!(result.is_err());
|
||||
}
|
||||
|
||||
/// Timing-attack test: verifies that token comparison is constant-time.
|
||||
///
|
||||
/// This test makes many comparisons with different token lengths and compares
|
||||
/// the timing variance. A non-constant-time comparison would show a
|
||||
/// significant difference in timing between tokens that mismatch early
|
||||
/// versus tokens that mismatch late.
|
||||
///
|
||||
/// This is a statistical test that may occasionally fail due to system
|
||||
/// noise, so we use a relatively loose threshold (5x variance allowed).
|
||||
#[test]
|
||||
fn test_check_auth_constant_time() {
|
||||
use std::time::Instant;
|
||||
|
||||
let correct_token = "correct-token-32-bytes-long!";
|
||||
|
||||
// Test 1: Token that mismatches at the first character
|
||||
let token_early = "Xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
|
||||
|
||||
// Test 2: Token that mismatches at the last character
|
||||
let token_late = "correct-token-32-bytes-long?";
|
||||
|
||||
// Test 3: Correct token (should return true)
|
||||
let token_correct = "correct-token-32-bytes-long!";
|
||||
|
||||
let iterations = 1000;
|
||||
let mut times_early = Vec::with_capacity(iterations);
|
||||
let mut times_late = Vec::with_capacity(iterations);
|
||||
let mut times_correct = Vec::with_capacity(iterations);
|
||||
|
||||
for _ in 0..iterations {
|
||||
let start = Instant::now();
|
||||
let _ = verify_token(token_early, correct_token);
|
||||
times_early.push(start.elapsed());
|
||||
|
||||
let start = Instant::now();
|
||||
let _ = verify_token(token_late, correct_token);
|
||||
times_late.push(start.elapsed());
|
||||
|
||||
let start = Instant::now();
|
||||
let _ = verify_token(token_correct, correct_token);
|
||||
times_correct.push(start.elapsed());
|
||||
}
|
||||
|
||||
// Calculate median times to reduce noise impact
|
||||
let mut sorted_early = times_early.clone();
|
||||
let mut sorted_late = times_late.clone();
|
||||
let mut sorted_correct = times_correct.clone();
|
||||
|
||||
sorted_early.sort();
|
||||
sorted_late.sort();
|
||||
sorted_correct.sort();
|
||||
|
||||
let median_early = sorted_early[iterations / 2];
|
||||
let median_late = sorted_late[iterations / 2];
|
||||
let median_correct = sorted_correct[iterations / 2];
|
||||
|
||||
// For constant-time comparison, all three should have similar timing
|
||||
// We allow up to 5x variance to account for system noise
|
||||
let max_time = median_early.max(median_late).max(median_correct);
|
||||
let min_time = median_early.min(median_late).min(median_correct);
|
||||
|
||||
let ratio = if min_time.as_nanos() > 0 {
|
||||
max_time.as_nanos() / min_time.as_nanos()
|
||||
} else {
|
||||
1 // Both are essentially zero
|
||||
};
|
||||
|
||||
// Assert that timing variance is within acceptable bounds
|
||||
// If this fails, the comparison is likely not constant-time
|
||||
assert!(
|
||||
ratio <= 5,
|
||||
"Token comparison appears to be non-constant-time: \
|
||||
early mismatch={:?}, late mismatch={:?}, correct={:?}, ratio={}",
|
||||
median_early, median_late, median_correct, ratio
|
||||
);
|
||||
|
||||
// Also verify that the correct token actually returns true
|
||||
assert!(verify_token(token_correct, correct_token));
|
||||
assert!(!verify_token(token_early, correct_token));
|
||||
assert!(!verify_token(token_late, correct_token));
|
||||
}
|
||||
|
||||
/// Test that tokens of different lengths have constant-time comparison.
|
||||
///
|
||||
/// A naive string comparison would short-circuit on length mismatch,
|
||||
/// which is a timing leak. This test verifies that our implementation
|
||||
/// does not have this leak.
|
||||
#[test]
|
||||
fn test_check_auth_constant_time_different_lengths() {
|
||||
use std::time::Instant;
|
||||
|
||||
let token = SecretString::new("correct-token-32-bytes-long!".into());
|
||||
let state = McpServerState::new(Some(token), None, None);
|
||||
|
||||
// Test 1: Token that is much shorter
|
||||
let mut headers_short = HeaderMap::new();
|
||||
headers_short.insert("Authorization", HeaderValue::from_static("Bearer short"));
|
||||
|
||||
// Test 2: Token that is much longer
|
||||
let mut headers_long = HeaderMap::new();
|
||||
headers_long.insert("Authorization", HeaderValue::from_static("Bearer this-token-is-much-longer-than-the-correct-one"));
|
||||
|
||||
let iterations = 1000;
|
||||
let mut times_short = Vec::with_capacity(iterations);
|
||||
let mut times_long = Vec::with_capacity(iterations);
|
||||
|
||||
for _ in 0..iterations {
|
||||
let start = Instant::now();
|
||||
let _ = check_auth(&state, &headers_short);
|
||||
times_short.push(start.elapsed());
|
||||
|
||||
let start = Instant::now();
|
||||
let _ = check_auth(&state, &headers_long);
|
||||
times_long.push(start.elapsed());
|
||||
}
|
||||
|
||||
// Calculate median times
|
||||
let mut sorted_short = times_short.clone();
|
||||
let mut sorted_long = times_long.clone();
|
||||
sorted_short.sort();
|
||||
sorted_long.sort();
|
||||
|
||||
let median_short = sorted_short[iterations / 2];
|
||||
let median_long = sorted_long[iterations / 2];
|
||||
|
||||
// For constant-time comparison, different lengths should have similar timing
|
||||
// We allow up to 3x variance for length differences (implementation-dependent)
|
||||
let ratio = if median_short.as_nanos() > 0 && median_long.as_nanos() > 0 {
|
||||
let max = median_short.max(median_long);
|
||||
let min = median_short.min(median_long);
|
||||
max.as_nanos() / min.as_nanos()
|
||||
} else {
|
||||
1
|
||||
};
|
||||
|
||||
assert!(
|
||||
ratio <= 3,
|
||||
"Token comparison appears to leak length information: \
|
||||
short={:?}, long={:?}, ratio={}",
|
||||
median_short, median_long, ratio
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,12 +2,14 @@ pub mod auth;
|
|||
pub mod bind;
|
||||
pub mod framing;
|
||||
pub mod http;
|
||||
pub mod root;
|
||||
pub mod server;
|
||||
pub mod stdio;
|
||||
pub mod tools;
|
||||
|
||||
pub use auth::{resolve_token, EXIT_USAGE_ERROR};
|
||||
pub use auth::{resolve_token, AuthSource, EXIT_USAGE_ERROR};
|
||||
pub use bind::{check_bind_security, EXIT_CONFIG_ERROR};
|
||||
pub use root::{canonicalize_root, resolve_path};
|
||||
pub use server::run;
|
||||
pub use stdio::run as run_stdio;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
use crate::mcp::{auth, bind, http};
|
||||
use crate::mcp::{auth, bind, http, AuthSource};
|
||||
use anyhow::{Context, Result};
|
||||
use secrecy::SecretString;
|
||||
use secrecy::{ExposeSecret, SecretString};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::env;
|
||||
use std::path::Path;
|
||||
|
||||
/// Runs the MCP server.
|
||||
///
|
||||
|
|
@ -15,6 +17,7 @@ use std::env;
|
|||
/// * `auth_token_file` - Optional path to a file containing the bearer token
|
||||
/// * `auth_token` - Optional bearer token value (deprecated, requires PDFTRACT_INSECURE_CLI_TOKEN=1)
|
||||
/// * `max_upload_mb` - Optional maximum request body size in MB (default 256)
|
||||
/// * `root` - Optional root directory for path-traversal protection
|
||||
///
|
||||
/// # Returns
|
||||
/// * Ok(()) if the server started successfully
|
||||
|
|
@ -24,9 +27,10 @@ pub fn run(
|
|||
auth_token_file: Option<std::path::PathBuf>,
|
||||
auth_token: Option<String>,
|
||||
max_upload_mb: Option<usize>,
|
||||
root: Option<std::path::PathBuf>,
|
||||
) -> Result<()> {
|
||||
// Resolve the bearer token
|
||||
let token: Option<SecretString> = match auth::resolve_token(
|
||||
let token_result: Option<(SecretString, AuthSource)> = match auth::resolve_token(
|
||||
auth_token_file.as_deref(),
|
||||
env::var("PDFTRACT_MCP_TOKEN").ok(),
|
||||
auth_token,
|
||||
|
|
@ -38,6 +42,12 @@ pub fn run(
|
|||
}
|
||||
};
|
||||
|
||||
// Extract the token and source, then drop the source to avoid keeping it in memory
|
||||
let (token, source) = match token_result {
|
||||
Some((t, s)) => (Some(t), Some(s)),
|
||||
None => (None, None),
|
||||
};
|
||||
|
||||
// Check bind security per TH-03
|
||||
let has_token = token.is_some();
|
||||
if let Err(e) = bind::check_bind_security(&bind_addr, has_token) {
|
||||
|
|
@ -46,12 +56,18 @@ pub fn run(
|
|||
}
|
||||
|
||||
// Report configuration
|
||||
if has_token {
|
||||
eprintln!("Bearer token provided via secure channel");
|
||||
eprintln!("Bind address: {}", bind_addr);
|
||||
if let Some(source) = source {
|
||||
eprintln!("Bearer token source: {}", source);
|
||||
// Log SHA-256 prefix of token for verification without leaking the value
|
||||
if let Some(ref token) = token {
|
||||
let hash = Sha256::digest(token.expose_secret().as_bytes());
|
||||
let prefix = format!("{:x}", hash).chars().take(8).collect::<String>();
|
||||
eprintln!("Bearer token SHA-256 prefix: {}", prefix);
|
||||
}
|
||||
} else {
|
||||
eprintln!("No bearer token (loopback-only mode)");
|
||||
}
|
||||
eprintln!("Bind address: {}", bind_addr);
|
||||
|
||||
// Start the HTTP+SSE server (this blocks until shutdown)
|
||||
let runtime = tokio::runtime::Runtime::new()
|
||||
|
|
@ -61,6 +77,7 @@ pub fn run(
|
|||
bind_addr,
|
||||
token,
|
||||
max_upload_mb,
|
||||
root.as_deref(),
|
||||
))?;
|
||||
|
||||
Ok(())
|
||||
|
|
|
|||
|
|
@ -11,12 +11,13 @@
|
|||
//! - Never using println! or print! macros (only eprintln!/eprint!)
|
||||
//! - Using a single BufWriter<Stdout> protected by a Mutex for all JSON-RPC output
|
||||
|
||||
use crate::mcp::framing::{ErrorObject, Id, Request, Response};
|
||||
use crate::mcp::framing::{BatchMessage, ErrorObject, Id, Request, Response};
|
||||
use crate::mcp::tools;
|
||||
use anyhow::{anyhow, Context, Result};
|
||||
use serde_json::json;
|
||||
use std::io::{self, BufRead, BufReader, BufWriter, Read, Stdin, Stdout, Write};
|
||||
use std::panic::Location;
|
||||
use std::path::Path;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
use std::sync::Mutex;
|
||||
use std::time::Instant;
|
||||
|
|
@ -234,15 +235,28 @@ fn read_message(stdin: &mut BufReader<Stdin>) -> Result<Option<Request>> {
|
|||
}
|
||||
}
|
||||
|
||||
// Parse as JSON
|
||||
let request: Request = serde_json::from_slice(&buffer)
|
||||
// Parse as JSON-RPC BatchMessage (handles both single requests and batches)
|
||||
let batch: BatchMessage = serde_json::from_slice(&buffer)
|
||||
.context("Failed to parse JSON-RPC request")?;
|
||||
|
||||
// Extract the single request from the batch
|
||||
// For now, we only support single requests (not batches)
|
||||
let request = match batch {
|
||||
BatchMessage::Single(req) => req,
|
||||
BatchMessage::Batch(reqs) => {
|
||||
// We don't support batch requests yet
|
||||
return Err(anyhow!(
|
||||
"Batch requests not supported (got {} requests in one message)",
|
||||
reqs.len()
|
||||
));
|
||||
}
|
||||
};
|
||||
|
||||
Ok(Some(request))
|
||||
}
|
||||
|
||||
/// Handle a JSON-RPC request and return a response.
|
||||
fn handle_request(request: Request, registry: &tools::ToolRegistry) -> Response {
|
||||
fn handle_request(request: Request, registry: &tools::ToolRegistry, root: Option<&Path>) -> Response {
|
||||
let id = request.request_id();
|
||||
|
||||
match request.method.as_str() {
|
||||
|
|
@ -297,7 +311,7 @@ fn handle_request(request: Request, registry: &tools::ToolRegistry) -> Response
|
|||
let start = Instant::now();
|
||||
let log_path = arguments.get("path").and_then(|v| v.as_str()).map(|s| s.to_string());
|
||||
|
||||
let result = tool.execute(arguments, log_path.as_deref());
|
||||
let result = tool.execute(arguments, log_path.as_deref(), root);
|
||||
|
||||
let duration_ms = start.elapsed().as_millis();
|
||||
let response_size = result.as_ref().ok()
|
||||
|
|
@ -342,6 +356,10 @@ fn handle_request(request: Request, registry: &tools::ToolRegistry) -> Response
|
|||
/// 7. Writes responses to stdout
|
||||
/// 8. Exits cleanly on EOF or SIGTERM
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `root` - Optional root directory for path-traversal protection
|
||||
///
|
||||
/// # Signal handling
|
||||
///
|
||||
/// - **SIGTERM**: Graceful shutdown (drain in-flight requests, exit 0)
|
||||
|
|
@ -353,7 +371,7 @@ fn handle_request(request: Request, registry: &tools::ToolRegistry) -> Response
|
|||
/// - A message cannot be read or parsed
|
||||
/// - A response cannot be written
|
||||
/// - stdin/stdout is not a TTY (but this is expected for stdio mode)
|
||||
pub fn run() -> Result<()> {
|
||||
pub fn run(root: Option<&Path>) -> Result<()> {
|
||||
// Set up panic hook FIRST (before any potential panics)
|
||||
setup_panic_hook();
|
||||
|
||||
|
|
@ -363,7 +381,7 @@ pub fn run() -> Result<()> {
|
|||
// Initialize stdout writer (only way to write to stdout in stdio mode)
|
||||
init_stdout();
|
||||
|
||||
// Create the tool registry
|
||||
// Create the tool registry with the root path
|
||||
let registry = tools::all_tools();
|
||||
|
||||
// Print startup banner to stderr (not stdout!)
|
||||
|
|
@ -371,6 +389,11 @@ pub fn run() -> Result<()> {
|
|||
eprintln!("Version: {}", env!("CARGO_PKG_VERSION"));
|
||||
eprintln!("Protocol: JSON-RPC 2.0 over stdio");
|
||||
eprintln!("Tools: {}", registry.tools_list()["tools"].as_array().map(|v| v.len()).unwrap_or(0));
|
||||
if root.is_some() {
|
||||
eprintln!("Path-traversal protection: enabled");
|
||||
} else {
|
||||
eprintln!("Path-traversal protection: disabled (trust-the-caller mode)");
|
||||
}
|
||||
eprintln!();
|
||||
|
||||
// Create buffered stdin reader
|
||||
|
|
@ -382,7 +405,7 @@ pub fn run() -> Result<()> {
|
|||
match read_message(&mut stdin) {
|
||||
Ok(Some(request)) => {
|
||||
// Handle the request
|
||||
let response = handle_request(request, ®istry);
|
||||
let response = handle_request(request, ®istry, root);
|
||||
|
||||
// Write the response
|
||||
if let Err(e) = write_response(&response) {
|
||||
|
|
@ -464,7 +487,7 @@ mod tests {
|
|||
Some(Id::Number(1)),
|
||||
);
|
||||
|
||||
let response = handle_request(request, ®istry);
|
||||
let response = handle_request(request, ®istry, None);
|
||||
|
||||
assert!(response.is_error());
|
||||
assert_eq!(response.get_error().unwrap().code, -32601);
|
||||
|
|
@ -480,7 +503,7 @@ mod tests {
|
|||
Some(Id::Number(1)),
|
||||
);
|
||||
|
||||
let response = handle_request(request, ®istry);
|
||||
let response = handle_request(request, ®istry, None);
|
||||
|
||||
assert!(response.is_success());
|
||||
assert!(response.get_result().is_some());
|
||||
|
|
@ -551,7 +574,7 @@ mod tests {
|
|||
|
||||
// Handle it
|
||||
let registry = tools::all_tools();
|
||||
let response = handle_request(request, ®istry);
|
||||
let response = handle_request(request, ®istry, None);
|
||||
|
||||
// Verify it's a success response
|
||||
assert!(response.is_success());
|
||||
|
|
|
|||
|
|
@ -21,3 +21,5 @@ pub const CODE_PDF_ENCRYPTED: &str = "PDF_ENCRYPTED";
|
|||
pub const CODE_IO_ERROR: &str = "IO_ERROR";
|
||||
pub const CODE_PATH_INVALID: &str = "PATH_INVALID";
|
||||
pub const CODE_NOT_YET_IMPLEMENTED: &str = "NOT_YET_IMPLEMENTED";
|
||||
|
||||
use std::path::Path;
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
use super::args::*;
|
||||
use super::{ERROR_NOT_YET_IMPLEMENTED, ERROR_IO_ERROR, ERROR_PATH_INVALID, CODE_IO_ERROR, CODE_PATH_INVALID};
|
||||
use crate::mcp::framing::ErrorObject;
|
||||
use crate::mcp::root::resolve_path;
|
||||
use pdftract_core::{
|
||||
parser::{self, catalog, pages, stream::{MemorySource, PdfSource}, xref},
|
||||
diagnostics::DiagCode,
|
||||
|
|
@ -35,7 +36,13 @@ pub trait Tool: Send + Sync {
|
|||
/// Execute the tool with the given arguments.
|
||||
///
|
||||
/// The arguments are already validated against input_schema.
|
||||
fn execute(&self, args: Value, log_path: Option<&str>) -> ToolResult;
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `args` - The validated tool arguments
|
||||
/// * `log_path` - Optional path for logging (extracted from args before path resolution)
|
||||
/// * `root` - Optional root directory for path-traversal protection
|
||||
fn execute(&self, args: Value, log_path: Option<&str>, root: Option<&Path>) -> ToolResult;
|
||||
}
|
||||
|
||||
/// Registry of all available MCP tools.
|
||||
|
|
@ -185,17 +192,15 @@ struct PdfContext {
|
|||
/// - The file doesn't exist or can't be read
|
||||
/// - The PDF is encrypted and no password was provided
|
||||
/// - The PDF structure is invalid
|
||||
fn open_pdf(path: &str, _password: Option<&str>) -> Result<PdfContext, ErrorObject> {
|
||||
// Validate and resolve the path
|
||||
let path_buf = PathBuf::from(path);
|
||||
|
||||
// Check if path exists
|
||||
if !path_buf.exists() {
|
||||
return Err(ErrorObject::server_error(
|
||||
ERROR_PATH_INVALID,
|
||||
format!("File not found: {}", path),
|
||||
).with_data(json!({"code": CODE_PATH_INVALID, "path": path})));
|
||||
}
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `path` - The path argument (may be a URL or local path)
|
||||
/// * `password` - Optional PDF password
|
||||
/// * `root` - Optional root directory for path-traversal protection
|
||||
fn open_pdf(path: &str, password: Option<&str>, root: Option<&Path>) -> Result<PdfContext, ErrorObject> {
|
||||
// Validate and resolve the path using the root if set
|
||||
let path_buf = resolve_path(path, root)?;
|
||||
|
||||
// Check if it's a file (not a directory)
|
||||
if !path_buf.is_file() {
|
||||
|
|
@ -359,7 +364,7 @@ impl Tool for ExtractTool {
|
|||
to_value(schemars::schema_for!(ExtractArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>, root: Option<&Path>) -> ToolResult {
|
||||
// Parse arguments
|
||||
let tool_args: ExtractArgs = serde_json::from_value(args)
|
||||
.map_err(|_| ErrorObject::invalid_params())?;
|
||||
|
|
@ -376,7 +381,7 @@ impl Tool for ExtractTool {
|
|||
}
|
||||
|
||||
// Open the PDF to check for encryption and get basic info
|
||||
let ctx = open_pdf(&tool_args.path, tool_args.password.as_deref())?;
|
||||
let ctx = open_pdf(&tool_args.path, tool_args.password.as_deref(), root)?;
|
||||
|
||||
Ok(stub_extraction_response(&tool_args.path, "extract", ctx.page_count))
|
||||
}
|
||||
|
|
@ -398,7 +403,7 @@ impl Tool for ExtractTextTool {
|
|||
to_value(schemars::schema_for!(ExtractTextArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>, root: Option<&Path>) -> ToolResult {
|
||||
let tool_args: ExtractTextArgs = serde_json::from_value(args)
|
||||
.map_err(|_| ErrorObject::invalid_params())?;
|
||||
|
||||
|
|
@ -411,7 +416,7 @@ impl Tool for ExtractTextTool {
|
|||
}));
|
||||
}
|
||||
|
||||
let ctx = open_pdf(&tool_args.path, tool_args.password.as_deref())?;
|
||||
let ctx = open_pdf(&tool_args.path, tool_args.password.as_deref(), root)?;
|
||||
Ok(stub_extraction_response(&tool_args.path, "extract_text", ctx.page_count))
|
||||
}
|
||||
}
|
||||
|
|
@ -432,7 +437,7 @@ impl Tool for ExtractMarkdownTool {
|
|||
to_value(schemars::schema_for!(ExtractMarkdownArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>, root: Option<&Path>) -> ToolResult {
|
||||
let tool_args: ExtractMarkdownArgs = serde_json::from_value(args)
|
||||
.map_err(|_| ErrorObject::invalid_params())?;
|
||||
|
||||
|
|
@ -445,7 +450,7 @@ impl Tool for ExtractMarkdownTool {
|
|||
}));
|
||||
}
|
||||
|
||||
let ctx = open_pdf(&tool_args.path, tool_args.password.as_deref())?;
|
||||
let ctx = open_pdf(&tool_args.path, tool_args.password.as_deref(), root)?;
|
||||
Ok(stub_extraction_response(&tool_args.path, "extract_markdown", ctx.page_count))
|
||||
}
|
||||
}
|
||||
|
|
@ -466,7 +471,7 @@ impl Tool for SearchTool {
|
|||
to_value(schemars::schema_for!(SearchArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>, root: Option<&Path>) -> ToolResult {
|
||||
let tool_args: SearchArgs = serde_json::from_value(args)
|
||||
.map_err(|_| ErrorObject::invalid_params())?;
|
||||
|
||||
|
|
@ -486,7 +491,7 @@ impl Tool for SearchTool {
|
|||
}));
|
||||
}
|
||||
|
||||
let ctx = open_pdf(&tool_args.path, tool_args.password.as_deref())?;
|
||||
let ctx = open_pdf(&tool_args.path, tool_args.password.as_deref(), root)?;
|
||||
let mut response = stub_extraction_response(&tool_args.path, "search", ctx.page_count);
|
||||
if let Some(obj) = response.as_object_mut() {
|
||||
obj.insert("_pattern".to_string(), json!(tool_args.pattern));
|
||||
|
|
@ -511,7 +516,7 @@ impl Tool for GetMetadataTool {
|
|||
to_value(schemars::schema_for!(GetMetadataArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>, root: Option<&Path>) -> ToolResult {
|
||||
let tool_args: GetMetadataArgs = serde_json::from_value(args)
|
||||
.map_err(|_| ErrorObject::invalid_params())?;
|
||||
|
||||
|
|
@ -526,8 +531,7 @@ impl Tool for GetMetadataTool {
|
|||
}
|
||||
|
||||
// Parse the PDF to extract metadata
|
||||
let path = &tool_args.path;
|
||||
let result = extract_metadata(path, tool_args.password.as_deref());
|
||||
let result = extract_metadata(&tool_args.path, tool_args.password.as_deref(), root);
|
||||
|
||||
match result {
|
||||
Ok(metadata) => Ok(metadata),
|
||||
|
|
@ -537,8 +541,8 @@ impl Tool for GetMetadataTool {
|
|||
}
|
||||
|
||||
/// Extract metadata from a PDF file.
|
||||
fn extract_metadata(path: &str, _password: Option<&str>) -> ToolResult {
|
||||
let ctx = open_pdf(path, _password)?;
|
||||
fn extract_metadata(path: &str, _password: Option<&str>, root: Option<&Path>) -> ToolResult {
|
||||
let ctx = open_pdf(path, _password, root)?;
|
||||
|
||||
// Build metadata response
|
||||
let mut metadata = serde_json::Map::new();
|
||||
|
|
@ -615,7 +619,7 @@ impl Tool for HashTool {
|
|||
to_value(schemars::schema_for!(HashArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, args: Value, _log_path: Option<&str>, root: Option<&Path>) -> ToolResult {
|
||||
let tool_args: HashArgs = serde_json::from_value(args)
|
||||
.map_err(|_| ErrorObject::invalid_params())?;
|
||||
|
||||
|
|
@ -628,7 +632,7 @@ impl Tool for HashTool {
|
|||
}
|
||||
|
||||
// Parse the PDF to compute fingerprint
|
||||
let result = compute_fingerprint(&tool_args.path, tool_args.password.as_deref());
|
||||
let result = compute_fingerprint(&tool_args.path, tool_args.password.as_deref(), root);
|
||||
|
||||
match result {
|
||||
Ok(fingerprint) => Ok(json!({ "fingerprint": fingerprint })),
|
||||
|
|
@ -638,8 +642,8 @@ impl Tool for HashTool {
|
|||
}
|
||||
|
||||
/// Compute the fingerprint of a PDF file.
|
||||
fn compute_fingerprint(path: &str, _password: Option<&str>) -> Result<String, ErrorObject> {
|
||||
let ctx = open_pdf(path, _password)?;
|
||||
fn compute_fingerprint(path: &str, _password: Option<&str>, root: Option<&Path>) -> Result<String, ErrorObject> {
|
||||
let ctx = open_pdf(path, _password, root)?;
|
||||
|
||||
// Compute a simplified fingerprint for now
|
||||
// Full fingerprint computation would use the Phase 1.7 algorithm with
|
||||
|
|
@ -683,7 +687,7 @@ impl Tool for GetTableTool {
|
|||
to_value(schemars::schema_for!(GetTableArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, _args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, _args: Value, _log_path: Option<&str>, _root: Option<&Path>) -> ToolResult {
|
||||
// Validate args structure but don't process
|
||||
let _args: GetTableArgs = match serde_json::from_value(_args) {
|
||||
Ok(args) => args,
|
||||
|
|
@ -718,7 +722,7 @@ impl Tool for GetFormFieldsTool {
|
|||
to_value(schemars::schema_for!(GetFormFieldsArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, _args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, _args: Value, _log_path: Option<&str>, _root: Option<&Path>) -> ToolResult {
|
||||
// Validate args structure but don't process
|
||||
let _args: GetFormFieldsArgs = match serde_json::from_value(_args) {
|
||||
Ok(args) => args,
|
||||
|
|
@ -752,7 +756,7 @@ impl Tool for GetAttachmentsTool {
|
|||
to_value(schemars::schema_for!(GetAttachmentsArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, _args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, _args: Value, _log_path: Option<&str>, _root: Option<&Path>) -> ToolResult {
|
||||
// Validate args structure but don't process
|
||||
let _args: GetAttachmentsArgs = match serde_json::from_value(_args) {
|
||||
Ok(args) => args,
|
||||
|
|
@ -786,7 +790,7 @@ impl Tool for ClassifyTool {
|
|||
to_value(schemars::schema_for!(ClassifyArgs)).unwrap()
|
||||
}
|
||||
|
||||
fn execute(&self, _args: Value, _log_path: Option<&str>) -> ToolResult {
|
||||
fn execute(&self, _args: Value, _log_path: Option<&str>, _root: Option<&Path>) -> ToolResult {
|
||||
// Validate args structure but don't process
|
||||
let _args: ClassifyArgs = match serde_json::from_value(_args) {
|
||||
Ok(args) => args,
|
||||
|
|
@ -916,28 +920,28 @@ mod tests {
|
|||
|
||||
// Test get_table
|
||||
let tool = registry.get("get_table").unwrap();
|
||||
let result = tool.execute(json!({"path": "test.pdf", "page": 0, "table_index": 0}), None);
|
||||
let result = tool.execute(json!({"path": "test.pdf", "page": 0, "table_index": 0}), None, None);
|
||||
assert!(result.is_err());
|
||||
let err = result.unwrap_err();
|
||||
assert_eq!(err.code, ERROR_NOT_YET_IMPLEMENTED);
|
||||
|
||||
// Test get_form_fields
|
||||
let tool = registry.get("get_form_fields").unwrap();
|
||||
let result = tool.execute(json!({"path": "test.pdf"}), None);
|
||||
let result = tool.execute(json!({"path": "test.pdf"}), None, None);
|
||||
assert!(result.is_err());
|
||||
let err = result.unwrap_err();
|
||||
assert_eq!(err.code, ERROR_NOT_YET_IMPLEMENTED);
|
||||
|
||||
// Test get_attachments
|
||||
let tool = registry.get("get_attachments").unwrap();
|
||||
let result = tool.execute(json!({"path": "test.pdf"}), None);
|
||||
let result = tool.execute(json!({"path": "test.pdf"}), None, None);
|
||||
assert!(result.is_err());
|
||||
let err = result.unwrap_err();
|
||||
assert_eq!(err.code, ERROR_NOT_YET_IMPLEMENTED);
|
||||
|
||||
// Test classify
|
||||
let tool = registry.get("classify").unwrap();
|
||||
let result = tool.execute(json!({"path": "test.pdf"}), None);
|
||||
let result = tool.execute(json!({"path": "test.pdf"}), None, None);
|
||||
assert!(result.is_err());
|
||||
let err = result.unwrap_err();
|
||||
assert_eq!(err.code, ERROR_NOT_YET_IMPLEMENTED);
|
||||
|
|
@ -948,7 +952,7 @@ mod tests {
|
|||
let tool = ExtractTool;
|
||||
|
||||
// Missing required field
|
||||
let result = tool.execute(json!({}), None);
|
||||
let result = tool.execute(json!({}), None, None);
|
||||
assert!(result.is_err());
|
||||
let err = result.unwrap_err();
|
||||
assert_eq!(err.code, -32602); // Invalid params
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ fn test_get_metadata_performance_on_100_page_pdf() {
|
|||
});
|
||||
|
||||
let start = Instant::now();
|
||||
let result = tool.execute(args, None);
|
||||
let result = tool.execute(args, None, None);
|
||||
let duration_ms = start.elapsed().as_millis();
|
||||
|
||||
assert!(result.is_ok(), "get_metadata should succeed: {:?}", result);
|
||||
|
|
@ -47,7 +47,7 @@ fn test_hash_performance_on_100_page_pdf() {
|
|||
});
|
||||
|
||||
let start = Instant::now();
|
||||
let result = tool.execute(args, None);
|
||||
let result = tool.execute(args, None, None);
|
||||
let duration_ms = start.elapsed().as_millis();
|
||||
|
||||
assert!(result.is_ok(), "hash should succeed: {:?}", result);
|
||||
|
|
@ -113,7 +113,7 @@ fn test_phase_7_stub_tools_return_not_implemented() {
|
|||
|
||||
for (tool_name, args) in stub_tools {
|
||||
let tool = registry.get(tool_name).unwrap();
|
||||
let result = tool.execute(args, None);
|
||||
let result = tool.execute(args, None, None);
|
||||
|
||||
assert!(result.is_err(), "{} should return error", tool_name);
|
||||
let err = result.unwrap_err();
|
||||
|
|
@ -143,7 +143,7 @@ fn test_missing_required_path_returns_error() {
|
|||
// Missing required 'path' field
|
||||
let args = serde_json::json!({});
|
||||
|
||||
let result = tool.execute(args, None);
|
||||
let result = tool.execute(args, None, None);
|
||||
assert!(result.is_err());
|
||||
|
||||
let err = result.unwrap_err();
|
||||
|
|
@ -159,7 +159,7 @@ fn test_extract_tool_with_real_pdf() {
|
|||
"path": "../../tests/sdk-conformance/fixtures/large/100pages.pdf"
|
||||
});
|
||||
|
||||
let result = tool.execute(args, None);
|
||||
let result = tool.execute(args, None, None);
|
||||
if let Err(ref e) = result {
|
||||
eprintln!("Error from tool: code={}, message={}, data={:?}", e.code, e.message, e.data);
|
||||
}
|
||||
|
|
@ -184,7 +184,7 @@ fn test_search_tool_with_invalid_regex() {
|
|||
"pattern": "(?invalid"
|
||||
});
|
||||
|
||||
let result = tool.execute(args, None);
|
||||
let result = tool.execute(args, None, None);
|
||||
assert!(result.is_err());
|
||||
|
||||
let err = result.unwrap_err();
|
||||
|
|
@ -225,7 +225,7 @@ fn test_nonexistent_file_returns_path_invalid() {
|
|||
"path": "/nonexistent/path/to/file.pdf"
|
||||
});
|
||||
|
||||
let result = tool.execute(args, None);
|
||||
let result = tool.execute(args, None, None);
|
||||
assert!(result.is_err());
|
||||
|
||||
let err = result.unwrap_err();
|
||||
|
|
@ -248,7 +248,7 @@ fn test_encrypted_pdf_returns_pdf_encrypted_error() {
|
|||
"path": "../../tests/sdk-conformance/fixtures/encrypted/encrypted.pdf"
|
||||
});
|
||||
|
||||
let result = tool.execute(args, None);
|
||||
let result = tool.execute(args, None, None);
|
||||
|
||||
// Debug: print the result if it succeeds unexpectedly
|
||||
if let Ok(ref response) = result {
|
||||
|
|
|
|||
51
crates/pdftract-core/examples/test_trailer.rs
Normal file
51
crates/pdftract-core/examples/test_trailer.rs
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
use pdftract_core::parser::xref;
|
||||
use pdftract_core::parser::stream::{MemorySource, PdfSource};
|
||||
use std::fs::File;
|
||||
use std::io::Read;
|
||||
|
||||
fn main() {
|
||||
let path = "/home/coding/pdftract/tests/sdk-conformance/fixtures/large/100pages.pdf";
|
||||
|
||||
let mut file = File::open(path).unwrap();
|
||||
let mut buffer = Vec::new();
|
||||
file.read_to_end(&mut buffer).unwrap();
|
||||
|
||||
// Find startxref BEFORE moving buffer
|
||||
let search_bytes = &buffer[buffer.len().saturating_sub(1024)..];
|
||||
let pos = search_bytes.windows(9).rposition(|w| w == b"startxref").unwrap();
|
||||
let start = buffer.len().saturating_sub(1024) + pos + 9;
|
||||
|
||||
// Skip whitespace
|
||||
let mut offset_start = start;
|
||||
while offset_start < buffer.len() && buffer[offset_start].is_ascii_whitespace() {
|
||||
offset_start += 1;
|
||||
}
|
||||
|
||||
let mut offset_end = offset_start;
|
||||
while offset_end < buffer.len() && buffer[offset_end].is_ascii_digit() {
|
||||
offset_end += 1;
|
||||
}
|
||||
|
||||
let offset_str = std::str::from_utf8(&buffer[offset_start..offset_end]).unwrap();
|
||||
let start_offset: u64 = offset_str.parse().unwrap();
|
||||
|
||||
// Now create source
|
||||
let source = MemorySource::new(buffer);
|
||||
|
||||
println!("startxref offset: {}", start_offset);
|
||||
|
||||
let xref_section = xref::load_xref_with_prev_chain(&source, start_offset);
|
||||
|
||||
println!("Has trailer: {}", xref_section.trailer.is_some());
|
||||
|
||||
if let Some(trailer) = &xref_section.trailer {
|
||||
println!("Trailer keys: {:?}", trailer.keys().collect::<Vec<_>>());
|
||||
println!("Root entry: {:?}", trailer.get("Root"));
|
||||
println!("Size entry: {:?}", trailer.get("Size"));
|
||||
}
|
||||
|
||||
println!("Diagnostics count: {}", xref_section.diagnostics.len());
|
||||
for diag in &xref_section.diagnostics {
|
||||
println!(" - {}: {} at byte_offset {:?}", diag.code, diag.message, diag.byte_offset);
|
||||
}
|
||||
}
|
||||
|
|
@ -1586,7 +1586,8 @@ impl<'de> serde::Deserialize<'de> for ExtractionOptions {
|
|||
D: serde::Deserializer<'de>,
|
||||
{
|
||||
use secrecy::SecretString;
|
||||
use serde::de::{self, Deserialize, SeqAccess, Visitor, MapAccess};
|
||||
use serde::de::{self, SeqAccess, Visitor, MapAccess};
|
||||
use serde::Deserialize;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(field_identifier)]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,41 @@
|
|||
# pdftract-1rami: MCP Tool Catalog Implementation
|
||||
|
||||
## Summary
|
||||
|
||||
Implemented the 10-tool MCP catalog for pdftract with full JSON-RPC 2.0 compliance, structured error handling, and per-invocation observability logging.
|
||||
|
||||
## Work Completed
|
||||
|
||||
### 1. Tool Registry (Already Implemented)
|
||||
|
||||
The tool registry in `crates/pdftract-cli/src/mcp/tools/` was already fully implemented with:
|
||||
- 10 tools registered with typed argument structs
|
||||
- JSON Schema generation via `schemars` crate
|
||||
- Tool trait with `name()`, `description()`, `input_schema()`, `execute()` methods
|
||||
- ToolRegistry with `tools_list()` and `get()` methods
|
||||
|
||||
### 2. Error Mapping (Enhanced)
|
||||
|
||||
Added encryption detection by checking the trailer for `/Encrypt` dictionary in `open_pdf()`.
|
||||
|
||||
### 3. Integration Tests
|
||||
|
||||
All tests pass (10 passed, 1 ignored - encrypted PDF test ignored due to lack of actual encrypted fixture).
|
||||
|
||||
## Acceptance Criteria Status
|
||||
|
||||
| Criteria | Status |
|
||||
|----------|--------|
|
||||
| tools/list returns 10 entries | ✅ PASS |
|
||||
| JSON Schema draft-07 validation | ✅ PASS |
|
||||
| get_metadata <= 250ms | ✅ PASS (~10ms) |
|
||||
| hash <= 100ms | ✅ PASS (~5ms) |
|
||||
| Phase 7 stubs return NOT_YET_IMPLEMENTED | ✅ PASS |
|
||||
| Unknown tool returns -32601 | ✅ PASS |
|
||||
| Encrypted PDF detection logic | ✅ IMPLEMENTED |
|
||||
| Observability logging | ✅ PASS |
|
||||
|
||||
## Files Modified
|
||||
|
||||
1. `crates/pdftract-cli/src/mcp/tools/registry.rs`: Added `/Encrypt` dictionary check
|
||||
2. `crates/pdftract-cli/tests/mcp-tools-integration.rs`: Added encrypted PDF test (ignored)
|
||||
Loading…
Add table
Reference in a new issue