feat(web,agent): hosting H1–H4 — proxy, invoke, MCP stdio, cross-module db
Close GAP-01–05 with ext/web streaming reverse proxy and HTTP→## invoke, transitive object method lookup, corpus_search plugin ensure, and agent MCP server stdio so downstream apps can drop Python side relays. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
2e068e66d4
commit
fc543f1ca5
31 files changed
+2765
-102
No files matched your search
@@ -2,6 +2,7 @@
|
||||
|
||||
mod corpus;
|
||||
mod kb;
|
||||
mod mcp_server;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::ffi::{CStr, CString};
|
||||
@@ -548,10 +549,18 @@ fn register(host: &MarqdoHostApi, name: &str, params: &str, fn_ptr: PluginFn) ->
|
||||
}
|
||||
|
||||
pub(crate) fn host_query_json(name: &str) -> Result<serde_json::Value, String> {
|
||||
host_query_json_args(name, &serde_json::json!({}))
|
||||
}
|
||||
|
||||
pub(crate) fn host_query_json_args(
|
||||
name: &str,
|
||||
args: &serde_json::Value,
|
||||
) -> Result<serde_json::Value, String> {
|
||||
let query = unsafe { HOST_QUERY }.ok_or_else(|| "host_query not available".to_string())?;
|
||||
let userdata = unsafe { HOST_USERDATA };
|
||||
let c_name = CString::new(name).map_err(|e| e.to_string())?;
|
||||
let c_args = CString::new("{}").unwrap();
|
||||
let args_s = serde_json::to_string(args).map_err(|e| e.to_string())?;
|
||||
let c_args = CString::new(args_s).map_err(|e| e.to_string())?;
|
||||
let mut out_ptr: *mut c_char = ptr::null_mut();
|
||||
let mut err_ptr: *mut c_char = ptr::null_mut();
|
||||
let rc = unsafe {
|
||||
@@ -987,6 +996,11 @@ pub unsafe extern "C" fn marqdo_plugin_init(host: *const MarqdoHostApi) -> c_int
|
||||
if register(host, "agent_mcp_fixture", "action,fixture", agent_mcp_fixture) != 0 {
|
||||
return 1;
|
||||
}
|
||||
if register(host, "agent_mcp_serve", "name,tools,transport", mcp_server::agent_mcp_serve)
|
||||
!= 0
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
if register(host, "agent_kb_add_alias", "kb_dir,slug,alias", agent_kb_add_alias) != 0 {
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,212 @@
|
||||
//! Minimal MCP Server (stdio JSON-RPC) — tools map to `lib.member` via host `call_lib_path`.
|
||||
|
||||
use serde_json::{json, Map, Value};
|
||||
use std::ffi::CStr;
|
||||
use std::io::{BufRead, BufReader, Write};
|
||||
use std::os::raw::{c_char, c_int};
|
||||
|
||||
use crate::{host_query_json_args, parse_args, set_err, set_out};
|
||||
|
||||
fn read_line_message(reader: &mut impl BufRead) -> Result<Option<Value>, String> {
|
||||
let mut line = String::new();
|
||||
let n = reader
|
||||
.read_line(&mut line)
|
||||
.map_err(|e| format!("stdin: {e}"))?;
|
||||
if n == 0 {
|
||||
return Ok(None);
|
||||
}
|
||||
let line = line.trim();
|
||||
if line.is_empty() {
|
||||
return read_line_message(reader);
|
||||
}
|
||||
let v: Value = serde_json::from_str(line).map_err(|e| format!("json-rpc parse: {e}"))?;
|
||||
Ok(Some(v))
|
||||
}
|
||||
|
||||
fn write_message(msg: &Value) -> Result<(), String> {
|
||||
let mut out = std::io::stdout().lock();
|
||||
let s = serde_json::to_string(msg).map_err(|e| e.to_string())?;
|
||||
writeln!(out, "{s}").map_err(|e| format!("stdout: {e}"))?;
|
||||
out.flush().map_err(|e| format!("flush: {e}"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn rpc_result(id: &Value, result: Value) -> Value {
|
||||
json!({
|
||||
"jsonrpc": "2.0",
|
||||
"id": id,
|
||||
"result": result,
|
||||
})
|
||||
}
|
||||
|
||||
fn rpc_error(id: &Value, code: i64, message: &str) -> Value {
|
||||
json!({
|
||||
"jsonrpc": "2.0",
|
||||
"id": id,
|
||||
"error": { "code": code, "message": message },
|
||||
})
|
||||
}
|
||||
|
||||
fn tools_list(tools: &[Value]) -> Value {
|
||||
let mut arr = Vec::new();
|
||||
for t in tools {
|
||||
let name = t.get("name").and_then(|v| v.as_str()).unwrap_or("");
|
||||
let desc = t
|
||||
.get("description")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("");
|
||||
if name.is_empty() {
|
||||
continue;
|
||||
}
|
||||
arr.push(json!({
|
||||
"name": name,
|
||||
"description": desc,
|
||||
"inputSchema": {
|
||||
"type": "object",
|
||||
"properties": {},
|
||||
"additionalProperties": true
|
||||
}
|
||||
}));
|
||||
}
|
||||
json!({ "tools": arr })
|
||||
}
|
||||
|
||||
fn call_tool(tools: &[Value], name: &str, arguments: &Value) -> Result<Value, String> {
|
||||
let tool = tools
|
||||
.iter()
|
||||
.find(|t| t.get("name").and_then(|v| v.as_str()) == Some(name))
|
||||
.ok_or_else(|| format!("unknown tool `{name}`"))?;
|
||||
let fn_path = tool
|
||||
.get("fn")
|
||||
.and_then(|v| v.as_str())
|
||||
.ok_or_else(|| format!("tool `{name}` missing fn"))?
|
||||
.to_string();
|
||||
let result = host_query_json_args(
|
||||
"call_lib_path",
|
||||
&json!({
|
||||
"path": fn_path,
|
||||
"args": arguments,
|
||||
}),
|
||||
)?;
|
||||
Ok(json!({
|
||||
"content": [{
|
||||
"type": "text",
|
||||
"text": serde_json::to_string(&result).unwrap_or_else(|_| "{}".into())
|
||||
}],
|
||||
"isError": false,
|
||||
"authority": "workbook"
|
||||
}))
|
||||
}
|
||||
|
||||
/// Blocking stdio MCP loop. `tools` is a JSON array of `{name, fn, description}`.
|
||||
pub fn serve_stdio(name: &str, tools: Vec<Value>) -> Result<Value, String> {
|
||||
let stdin = std::io::stdin();
|
||||
let mut reader = BufReader::new(stdin.lock());
|
||||
loop {
|
||||
let Some(msg) = read_line_message(&mut reader)? else {
|
||||
break;
|
||||
};
|
||||
let id = msg.get("id").cloned().unwrap_or(Value::Null);
|
||||
let method = msg.get("method").and_then(|v| v.as_str()).unwrap_or("");
|
||||
let params = msg.get("params").cloned().unwrap_or(json!({}));
|
||||
|
||||
if matches!(id, Value::Null) && method.starts_with("notifications/") {
|
||||
continue;
|
||||
}
|
||||
|
||||
let reply_msg = match method {
|
||||
"initialize" => rpc_result(
|
||||
&id,
|
||||
json!({
|
||||
"protocolVersion": "2024-11-05",
|
||||
"capabilities": { "tools": {} },
|
||||
"serverInfo": { "name": name, "version": "0.1.0" }
|
||||
}),
|
||||
),
|
||||
"tools/list" | "list_tools" => rpc_result(&id, tools_list(&tools)),
|
||||
"tools/call" | "call_tool" => {
|
||||
let tname = params.get("name").and_then(|v| v.as_str()).unwrap_or("");
|
||||
let args = params.get("arguments").cloned().unwrap_or(json!({}));
|
||||
match call_tool(&tools, tname, &args) {
|
||||
Ok(r) => rpc_result(&id, r),
|
||||
Err(e) => rpc_error(&id, -32000, &e),
|
||||
}
|
||||
}
|
||||
"ping" => rpc_result(&id, json!({})),
|
||||
"" => rpc_error(&id, -32600, "missing method"),
|
||||
other => rpc_error(&id, -32601, &format!("method not found: {other}")),
|
||||
};
|
||||
write_message(&reply_msg)?;
|
||||
}
|
||||
Ok(json!({ "ok": true, "transport": "stdio" }))
|
||||
}
|
||||
|
||||
pub fn tools_from_value(v: &Value) -> Vec<Value> {
|
||||
if let Some(arr) = v.as_array() {
|
||||
return arr.clone();
|
||||
}
|
||||
if let Value::Object(map) = v {
|
||||
let mut out = Vec::new();
|
||||
for (name, spec) in map {
|
||||
let mut m = Map::new();
|
||||
m.insert("name".into(), json!(name));
|
||||
if let Some(obj) = spec.as_object() {
|
||||
for (k, val) in obj {
|
||||
m.insert(k.clone(), val.clone());
|
||||
}
|
||||
} else if let Some(s) = spec.as_str() {
|
||||
m.insert("fn".into(), json!(s));
|
||||
}
|
||||
out.push(Value::Object(m));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
Vec::new()
|
||||
}
|
||||
|
||||
pub unsafe extern "C" fn agent_mcp_serve(
|
||||
args_json: *const c_char,
|
||||
out_json: *mut *mut c_char,
|
||||
err_msg: *mut *mut c_char,
|
||||
) -> c_int {
|
||||
let args = match parse_args(args_json) {
|
||||
Ok(v) => v,
|
||||
Err(e) => {
|
||||
set_err(err_msg, &e);
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
let transport = args
|
||||
.get("transport")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("stdio");
|
||||
if transport != "stdio" {
|
||||
set_err(
|
||||
err_msg,
|
||||
&format!("mcp serve: transport `{transport}` not implemented yet (use stdio)"),
|
||||
);
|
||||
return 1;
|
||||
}
|
||||
let name = args
|
||||
.get("name")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("marqdo");
|
||||
let tools = args
|
||||
.get("tools")
|
||||
.map(tools_from_value)
|
||||
.unwrap_or_default();
|
||||
match serve_stdio(name, tools) {
|
||||
Ok(v) => {
|
||||
set_out(out_json, &v.to_string());
|
||||
0
|
||||
}
|
||||
Err(e) => {
|
||||
set_err(err_msg, &e);
|
||||
1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Silence unused import if CStr unused in this module.
|
||||
#[allow(dead_code)]
|
||||
fn _unused(_: &CStr) {}
|
||||
Reference in new issue
Block a user