lix/mnote
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 收口 Rust Web 3000 主链

Browse Source
This commit is contained in:
lix-2026
2026-05-11 13:16:34 +08:00
parent 7f3f7d4e2f
commit 17c003976b
61 changed files with 2090 additions and 2256 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rust/crates/mnote-web/src/routes/compat.rs
+14 -743
View File
@@ -1,36 +1,22 @@
use crate::app::AppState;
use crate::context::RequestContext;
use crate::error::WebError;
use crate::routes::query_support::resolve_effective_workspace_id;
use crate::routes::snapshot_support::{load_projection_snapshot, ProjectionSnapshotSpec};
use axum::body::{Body, Bytes};
use axum::extract::Query;
use axum::body::Body;
use axum::extract::{Extension, State};
use axum::http::{header, HeaderMap, HeaderName, HeaderValue, Request, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::Json;
use core_protocol::KernelProjectionKind;
use futures_util::{StreamExt, TryStreamExt};
use serde::Deserialize;
use serde_json::{json, Value};
use std::env;
use std::fs;
use std::path::PathBuf;
use std::process::Command;
use std::time::Duration;
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CompatSidebarQuery {
pub workspace_id: Option<String>,
}
pub async fn next_ai_agent_run(
State(state): State<AppState>,
Extension(context): Extension<RequestContext>,
request: Request<Body>,
) -> Result<Response, WebError> {
let (parts, body) = request.into_parts();
let (_parts, body) = request.into_parts();
let body = axum::body::to_bytes(body, 10 * 1024 * 1024)
.await
.map_err(|error| WebError::internal(format!("读取 AI 请求体失败: {error}")))?;
@@ -43,24 +29,11 @@ pub async fn next_ai_agent_run(
.with_header("x-mnote-web-owner", "mnote-web")
})?;
if state.config().enable_legacy_next_compat {
if let Some(base_url) = state.config().legacy_next_base_url.as_deref() {
if let Ok(response) =
proxy_ai_agent_run_to_next(base_url, &context, &parts.headers, body.clone()).await
{
return Ok(response);
}
}
}
if let Some(provider) = explicit_agent_provider(&payload) {
if provider == "hermes" {
return run_direct_hermes_agent(&context, &payload).await;
}
return Err(WebError::bad_gateway_code(
"ai_provider_bridge_unavailable",
format!(
"{provider} provider 需要可用的 Next AI bridge，不能静默降级到本地页面工具 host。"
"{provider} provider 直连链路已退场；当前仅保留 mnote-cli host 主路径，不再静默降级。"
),
)
.with_context(&context)
@@ -68,69 +41,7 @@ pub async fn next_ai_agent_run(
.with_header("x-mnote-ai-execution-owner", "provider-bridge-unavailable"));
}
if let Ok(response) = run_local_mnote_cli_ai_host(&state, &context, &payload).await {
return Ok(response);
}
let Some(backend_url) = resolve_ai_orchestrator_backend_url() else {
return Err(WebError::bad_gateway_code(
"ai_orchestrator_unavailable",
"未配置 BACKEND_URL，无法连接 document AI orchestrator。",
)
.with_context(&context)
.with_header("x-mnote-web-owner", "mnote-web"));
};
let upstream_url = reqwest::Url::parse(&format!(
"{}/api/v1/ai-agent/document/run",
backend_url.trim_end_matches('/')
))
.map_err(|error| WebError::internal(format!("AI orchestrator URL 非法: {error}")))?;
let forward_payload = build_document_ai_orchestrator_payload(&state, &context, &payload);
let client = reqwest::Client::builder()
.connect_timeout(Duration::from_secs(5))
.redirect(reqwest::redirect::Policy::none())
.build()
.map_err(|error| {
WebError::internal(format!("AI orchestrator HTTP 客户端创建失败: {error}"))
})?;
let mut upstream_request = client.post(upstream_url).json(&forward_payload);
upstream_request = apply_ai_forward_headers(upstream_request, &parts.headers, &context);
if let Some(api_key) = read_env_or_dotenv("MNOTE_AI_ORCHESTRATOR_API_KEY") {
upstream_request = upstream_request.header("x-mnote-ai-key", api_key);
}
let upstream_response = upstream_request.send().await.map_err(|error| {
WebError::bad_gateway_code(
"ai_orchestrator_proxy_error",
format!("document AI orchestrator 请求失败: {error}"),
)
.with_context(&context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "document-ai-orchestrator")
})?;
if !upstream_response.status().is_success() {
let status = upstream_response.status();
let body = upstream_response
.text()
.await
.unwrap_or_else(|error| format!("读取 upstream 错误响应失败: {error}"));
return Err(WebError::bad_gateway_code(
"ai_orchestrator_upstream_error",
format!(
"document AI orchestrator 返回 HTTP {}: {}",
status.as_u16(),
body
),
)
.with_context(&context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "document-ai-orchestrator"));
}
build_ai_sse_proxy_response(upstream_response, &context)
run_local_mnote_cli_ai_host(&state, &context, &payload).await
}
fn explicit_agent_provider(payload: &Value) -> Option<&'static str> {
@@ -149,369 +60,6 @@ fn explicit_agent_provider(payload: &Value) -> Option<&'static str> {
}
}
async fn run_direct_hermes_agent(
context: &RequestContext,
payload: &Value,
) -> Result<Response, WebError> {
let base_url = resolve_hermes_api_base_url();
let api_key = read_env_or_dotenv("MNOTE_HERMES_API_KEY").ok_or_else(|| {
WebError::bad_gateway_code(
"hermes_bridge_unconfigured",
"未配置 MNOTE_HERMES_API_KEY，无法直连 Hermes API。",
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-mnote-ai-execution-owner", "hermes")
})?;
let client = reqwest::Client::builder()
.connect_timeout(Duration::from_secs(5))
.timeout(Duration::from_secs(180))
.redirect(reqwest::redirect::Policy::none())
.build()
.map_err(|error| WebError::internal(format!("Hermes HTTP 客户端创建失败: {error}")))?;
let start_url = reqwest::Url::parse(&format!("{}/v1/runs", base_url.trim_end_matches('/')))
.map_err(|error| WebError::internal(format!("Hermes runs URL 非法: {error}")))?;
let start_response = client
.post(start_url)
.bearer_auth(&api_key)
.json(&build_hermes_run_payload(payload))
.send()
.await
.map_err(|error| {
WebError::bad_gateway_code(
"hermes_bridge_start_error",
format!("Hermes run 启动请求失败: {error}"),
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "hermes-api")
.with_header("x-mnote-ai-execution-owner", "hermes")
})?;
if !start_response.status().is_success() {
let status = start_response.status();
let body = start_response
.text()
.await
.unwrap_or_else(|error| format!("读取 Hermes 错误响应失败: {error}"));
return Err(WebError::bad_gateway_code(
"hermes_bridge_start_rejected",
format!("Hermes run 启动返回 HTTP {}: {}", status.as_u16(), body),
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "hermes-api")
.with_header("x-mnote-ai-execution-owner", "hermes"));
}
let started: Value = start_response.json().await.map_err(|error| {
WebError::bad_gateway_code(
"hermes_bridge_bad_start_response",
format!("Hermes run 启动响应不是合法 JSON: {error}"),
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "hermes-api")
.with_header("x-mnote-ai-execution-owner", "hermes")
})?;
let run_id = started
.get("run_id")
.and_then(Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty())
.ok_or_else(|| {
WebError::bad_gateway_code(
"hermes_bridge_missing_run_id",
"Hermes run 启动响应缺少 run_id。",
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "hermes-api")
.with_header("x-mnote-ai-execution-owner", "hermes")
})?;
let mut events_url =
reqwest::Url::parse(&format!("{}/v1/runs/", base_url.trim_end_matches('/')))
.map_err(|error| WebError::internal(format!("Hermes events URL 非法: {error}")))?;
events_url
.path_segments_mut()
.map_err(|_| WebError::internal("Hermes events URL 不支持路径拼接"))?
.pop_if_empty()
.push(run_id)
.push("events");
let events_response = client
.get(events_url)
.bearer_auth(api_key)
.send()
.await
.map_err(|error| {
WebError::bad_gateway_code(
"hermes_bridge_events_error",
format!("Hermes 事件流请求失败: {error}"),
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "hermes-api")
.with_header("x-mnote-ai-execution-owner", "hermes")
})?;
if !events_response.status().is_success() {
let status = events_response.status();
let body = events_response
.text()
.await
.unwrap_or_else(|error| format!("读取 Hermes 事件流错误响应失败: {error}"));
return Err(WebError::bad_gateway_code(
"hermes_bridge_events_rejected",
format!("Hermes 事件流返回 HTTP {}: {}", status.as_u16(), body),
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "hermes-api")
.with_header("x-mnote-ai-execution-owner", "hermes"));
}
let events_text = events_response.text().await.map_err(|error| {
WebError::bad_gateway_code(
"hermes_bridge_events_read_error",
format!("读取 Hermes 事件流失败: {error}"),
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "hermes-api")
.with_header("x-mnote-ai-execution-owner", "hermes")
})?;
build_hermes_sse_response(context, parse_sse_data_json_values(&events_text))
}
fn resolve_hermes_api_base_url() -> String {
read_env_or_dotenv("MNOTE_HERMES_API_BASE_URL")
.unwrap_or_else(|| "http://127.0.0.1:8642".into())
.trim()
.trim_end_matches('/')
.to_string()
}
fn build_hermes_run_payload(payload: &Value) -> Value {
let messages = payload
.get("messages")
.and_then(Value::as_array)
.cloned()
.unwrap_or_default();
let input: Vec<Value> = messages
.iter()
.map(|message| {
json!({
"role": message.get("role").and_then(Value::as_str).unwrap_or("user"),
"content": message.get("content").and_then(Value::as_str).unwrap_or(""),
})
})
.collect();
let conversation_history = if input.len() > 1 {
input[..input.len() - 1].to_vec()
} else {
Vec::new()
};
let session_id = payload
.get("options")
.and_then(|value| value.get("ai"))
.and_then(|value| value.get("sessionId"))
.and_then(Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty());
json!({
"input": input,
"conversation_history": conversation_history,
"session_id": session_id,
})
}
fn parse_sse_data_json_values(text: &str) -> Vec<Value> {
text.split("\n\n")
.filter_map(|frame| {
let data = frame
.lines()
.filter_map(|line| line.strip_prefix("data:"))
.map(str::trim_start)
.collect::<Vec<_>>()
.join("\n");
if data.trim().is_empty() {
return None;
}
serde_json::from_str::<Value>(&data).ok()
})
.collect()
}
fn sse_frame(event: &str, data: Value) -> String {
format!("event: {event}\ndata: {}\n\n", data.to_string())
}
fn build_hermes_sse_response(
context: &RequestContext,
events: Vec<Value>,
) -> Result<Response, WebError> {
let mut body = String::new();
let mut assistant_text = String::new();
let mut completed = false;
body.push_str(&sse_frame(
"ready",
json!({"ok": true, "bridgeOwner": "hermes", "requestId": context.trace.request_id}),
));
for event in events {
let event_name = event.get("event").and_then(Value::as_str).unwrap_or("");
match event_name {
"message.delta" => {
if let Some(delta) = event.get("delta").and_then(Value::as_str) {
assistant_text.push_str(delta);
body.push_str(&sse_frame("assistant_delta", json!({"text": delta})));
}
}
"run.completed" => {
completed = true;
let output = event
.get("output")
.and_then(Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty())
.unwrap_or_else(|| assistant_text.trim());
let text = if output.is_empty() {
"（无输出）"
} else {
output
};
body.push_str(&sse_frame("assistant_message", json!({"text": text})));
body.push_str(&sse_frame(
"completion",
json!({"ok": true, "text": text, "steps": 1}),
));
}
"run.failed" => {
completed = true;
let message = event
.get("error")
.and_then(Value::as_str)
.unwrap_or("Hermes 执行失败");
body.push_str(&sse_frame(
"error",
json!({"ok": false, "message": message}),
));
}
_ => {}
}
}
if !completed {
let text = assistant_text.trim();
let text = if text.is_empty() {
"（无输出）"
} else {
text
};
body.push_str(&sse_frame("assistant_message", json!({"text": text})));
body.push_str(&sse_frame(
"completion",
json!({"ok": true, "text": text, "steps": 1}),
));
}
let mut response = Response::builder()
.status(StatusCode::OK)
.header(header::CONTENT_TYPE, "text/event-stream; charset=utf-8")
.header(header::CACHE_CONTROL, "no-cache, no-transform")
.header(header::CONNECTION, "keep-alive")
.header("x-accel-buffering", "no")
.header("x-mnote-ai-execution-owner", "hermes")
.body(Body::from(body))
.map_err(|error| WebError::internal(format!("Hermes SSE 响应构造失败: {error}")))?;
stamp_owner_header(response.headers_mut());
Ok(response)
}
async fn proxy_ai_agent_run_to_next(
base_url: &str,
context: &RequestContext,
headers: &HeaderMap,
body_bytes: Bytes,
) -> Result<Response, WebError> {
let upstream_url = reqwest::Url::parse(&format!(
"{}/api/ai-agent/run",
base_url.trim_end_matches('/')
))
.map_err(|error| WebError::internal(format!("Next AI route URL 非法: {error}")))?;
let client = reqwest::Client::builder()
.connect_timeout(Duration::from_secs(5))
.redirect(reqwest::redirect::Policy::none())
.build()
.map_err(|error| WebError::internal(format!("Next AI HTTP 客户端创建失败: {error}")))?;
let mut upstream_request = client.post(upstream_url).body(body_bytes.clone());
for (name, value) in headers.iter() {
if is_hop_by_hop_header(name.as_str())
|| name == header::HOST
|| name == header::CONTENT_LENGTH
|| name == header::COOKIE
|| name == header::AUTHORIZATION
{
continue;
}
upstream_request = upstream_request.header(name.as_str(), value.as_bytes());
}
if let Some(cookie) = context.auth.cookie_header.as_deref() {
upstream_request = upstream_request.header(header::COOKIE, cookie);
}
if let Some(authorization) = context.auth.authorization.as_deref() {
upstream_request = upstream_request.header(header::AUTHORIZATION, authorization);
}
upstream_request = upstream_request.header("x-request-id", context.trace.request_id.as_str());
upstream_request = upstream_request.header("x-trace-id", context.trace.trace_id.as_str());
upstream_request = upstream_request.header("x-mnote-source-channel", "rust_web_route");
upstream_request = upstream_request.header("x-mnote-source-client", "mnote-web");
upstream_request = upstream_request.header("x-mnote-actor-id", context.auth.actor_id.as_str());
upstream_request =
upstream_request.header("x-mnote-actor-type", context.auth.actor_type.as_str());
if let Some(workspace_id) = context.workspace.workspace_id.as_deref() {
upstream_request = upstream_request.header("x-mnote-workspace-id", workspace_id);
}
if let Some(session_id) = context.auth.session_id.as_deref() {
upstream_request = upstream_request.header("x-mnote-session-id", session_id);
}
let upstream_response = upstream_request.send().await.map_err(|error| {
WebError::bad_gateway_code(
"next_ai_proxy_error",
format!("Next /api/ai-agent/run 请求失败: {error}"),
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "next-ai-route")
})?;
if !upstream_response.status().is_success() {
let status = upstream_response.status();
let body = upstream_response
.text()
.await
.unwrap_or_else(|error| format!("读取 Next AI 错误响应失败: {error}"));
return Err(WebError::bad_gateway_code(
"next_ai_upstream_error",
format!(
"Next /api/ai-agent/run 返回 HTTP {}: {}",
status.as_u16(),
body
),
)
.with_context(context)
.with_header("x-mnote-web-owner", "mnote-web")
.with_header("x-upstream-service", "next-ai-route"));
}
build_ai_sse_proxy_response(upstream_response, context)
}
fn resolve_repo_root() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../..")
}
@@ -705,241 +253,18 @@ async fn run_local_mnote_cli_ai_host(
Ok(response)
}
fn build_document_ai_orchestrator_payload(
state: &AppState,
context: &RequestContext,
payload: &Value,
) -> Value {
let ai_options = payload.get("options").and_then(|value| value.get("ai"));
let user_id = if context.auth.actor_id.trim().is_empty() || context.auth.actor_id == "anonymous"
{
state.config().dev_user_id.clone()
} else {
context.auth.actor_id.clone()
};
json!({
"userId": user_id,
"sessionId": ai_options
.and_then(|value| value.get("sessionId"))
.and_then(Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty()),
"model": ai_options
.and_then(|value| value.get("model"))
.and_then(Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty()),
"modelKey": ai_options
.and_then(|value| value.get("modelKey"))
.and_then(Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty()),
"profileId": ai_options
.and_then(|value| value.get("profileId"))
.and_then(Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty()),
"maxSteps": payload.get("maxSteps").filter(|value| !value.is_null()).cloned().unwrap_or_else(|| json!(10)),
"messages": payload.get("messages").cloned().unwrap_or_else(|| json!([])),
"context": build_document_ai_context(payload.get("context")),
})
}
fn build_document_ai_context(context: Option<&Value>) -> Value {
let get = |key: &str| {
context
.and_then(|value| value.get(key))
.cloned()
.unwrap_or(Value::Null)
};
json!({
"source": get("source"),
"action": get("action"),
"documentId": get("documentId"),
"workspaceId": get("workspaceId"),
"selectedBlockId": get("selectedBlockId"),
"selectedBlockIndex": get("selectedBlockIndex"),
"selectedUids": get("selectedUids"),
"selectedText": get("selectedText"),
"selection": get("selection"),
"tiptapDocument": get("tiptapDocument"),
"documentBlocks": get("documentBlocks"),
"node": get("node"),
"subtree": get("subtree"),
"outline": get("outline"),
"evidence": get("evidence"),
"pageOptions": get("pageOptions"),
})
}
fn apply_ai_forward_headers(
mut request: reqwest::RequestBuilder,
headers: &HeaderMap,
context: &RequestContext,
) -> reqwest::RequestBuilder {
for (name, value) in headers.iter() {
if is_hop_by_hop_header(name.as_str())
|| name == header::HOST
|| name == header::CONTENT_LENGTH
|| name == header::CONTENT_TYPE
{
continue;
}
request = request.header(name.as_str(), value.as_bytes());
}
request = request.header(header::CONTENT_TYPE.as_str(), "application/json");
request = request.header("x-request-id", context.trace.request_id.as_str());
request = request.header("x-trace-id", context.trace.trace_id.as_str());
request = request.header("x-mnote-source-channel", "rust_web_route");
request = request.header("x-mnote-source-client", "mnote-web");
request = request.header("x-mnote-actor-id", context.auth.actor_id.as_str());
request.header("x-mnote-actor-type", context.auth.actor_type.as_str())
}
fn build_ai_sse_proxy_response(
upstream_response: reqwest::Response,
context: &RequestContext,
) -> Result<Response, WebError> {
let status =
StatusCode::from_u16(upstream_response.status().as_u16()).unwrap_or(StatusCode::OK);
let ready = Bytes::from(format!(
"event: ready\ndata: {}\n\n",
json!({"ok": true, "requestId": context.trace.request_id}).to_string()
));
let upstream_stream = upstream_response
.bytes_stream()
.map_err(std::io::Error::other);
let body_stream = futures_util::stream::once(async move { Ok::<Bytes, std::io::Error>(ready) })
.chain(upstream_stream);
let mut response = Response::builder()
.status(status)
.header(header::CONTENT_TYPE, "text/event-stream; charset=utf-8")
.header(header::CACHE_CONTROL, "no-cache, no-transform")
.header(header::CONNECTION, "keep-alive")
.header("x-accel-buffering", "no")
.body(Body::from_stream(body_stream))
.map_err(|error| WebError::internal(format!("AI SSE 响应构造失败: {error}")))?;
stamp_owner_header(response.headers_mut());
Ok(response)
}
fn stamp_owner_header(headers: &mut HeaderMap) {
if let Ok(name) = HeaderName::from_lowercase(b"x-mnote-web-owner") {
headers.insert(name, HeaderValue::from_static("mnote-web"));
}
}
fn resolve_ai_orchestrator_backend_url() -> Option<String> {
read_env_or_dotenv("BACKEND_INTERNAL_URL")
.or_else(|| read_env_or_dotenv("BACKEND_URL"))
.map(|value| value.trim().trim_end_matches('/').to_string())
.filter(|value| !value.is_empty())
}
fn read_env_or_dotenv(key: &str) -> Option<String> {
if let Ok(value) = env::var(key) {
let trimmed = value.trim().trim_matches('"').to_string();
if !trimmed.is_empty() {
return Some(trimmed);
}
}
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../..")
.join(".env.all");
let content = fs::read_to_string(root).ok()?;
for line in content.lines() {
let line = line.trim_end_matches('\r');
if line.starts_with('#') || line.trim().is_empty() {
continue;
}
let Some((k, v)) = line.split_once('=') else {
continue;
};
if k.trim() != key {
continue;
}
let trimmed = v.trim().trim_matches('"').to_string();
if !trimmed.is_empty() {
return Some(trimmed);
}
}
None
}
fn is_hop_by_hop_header(name: &str) -> bool {
matches!(
name.to_ascii_lowercase().as_str(),
"connection"
| "keep-alive"
| "proxy-authenticate"
| "proxy-authorization"
| "te"
| "trailers"
| "transfer-encoding"
| "upgrade"
)
}
pub async fn next_sidebar(
State(state): State<AppState>,
Extension(context): Extension<RequestContext>,
Query(query): Query<CompatSidebarQuery>,
) -> Result<(StatusCode, Json<Value>), WebError> {
let effective_workspace_id =
resolve_effective_workspace_id(&context, query.workspace_id.as_deref(), true)?
.expect("workspace_required 已确保存在");
let snapshot = load_projection_snapshot(
state.config(),
&context,
&ProjectionSnapshotSpec {
workspace_id: &effective_workspace_id,
root_node_id: None,
depth: None,
query: None,
max_results: None,
projection: KernelProjectionKind::SidebarTree,
},
)
.await?;
let mut dataset_object = snapshot.dataset.as_object().cloned().ok_or_else(|| {
WebError::bad_gateway_code("convex_bad_response", "sidebar.dataset.list 返回值不是对象")
.with_context(&context)
.with_header("x-error-phase", "compat_sidebar_shape")
.with_header("x-upstream-service", "convex")
})?;
dataset_object.insert("kernel_sidebar_projection".into(), snapshot.projection);
Ok((
StatusCode::OK,
Json(json!({
"ok": true,
"boundary": "next_sidebar_compat",
"requestId": context.trace.request_id,
"traceId": context.trace.trace_id,
"workspaceId": effective_workspace_id,
"result": Value::Object(dataset_object),
})),
))
}
#[cfg(test)]
mod tests {
use crate::app::{build_app, AppConfig, AppState};
use crate::context::RequestContext;
use crate::routes::compat::{
build_hermes_run_payload, build_hermes_sse_response, parse_sse_data_json_values,
};
use axum::body::Body;
use axum::http::{HeaderMap, Method, Request, StatusCode, Uri};
use axum::http::{Request, StatusCode};
use axum::response::IntoResponse;
use serde_json::json;
use tokio::net::TcpListener;
use tower::util::ServiceExt;
@@ -966,7 +291,7 @@ mod tests {
}
#[tokio::test]
async fn compat_sidebar_route_returns_dataset_and_projection() {
async fn compat_next_sidebar_route_is_not_registered_by_default() {
let response = app()
.oneshot(
Request::builder()
@@ -977,7 +302,7 @@ mod tests {
.await
.expect("response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.status(), StatusCode::NOT_FOUND);
}
#[tokio::test]
@@ -1027,60 +352,6 @@ mod tests {
assert!(!text.contains("legacy_next_compat_disabled"));
}
#[test]
fn hermes_payload_uses_page_messages_and_session_id() {
let payload = json!({
"messages": [
{"role": "system", "content": "系统约束"},
{"role": "user", "content": "总结当前页面"}
],
"options": {
"ai": {
"provider": "hermes",
"sessionId": "hermes-session-1"
}
}
});
let hermes_payload = build_hermes_run_payload(&payload);
assert_eq!(hermes_payload["session_id"], "hermes-session-1");
assert_eq!(hermes_payload["input"][1]["content"], "总结当前页面");
assert_eq!(hermes_payload["conversation_history"][0]["role"], "system");
}
#[tokio::test]
async fn hermes_sse_is_translated_to_page_ai_events() {
let events = parse_sse_data_json_values(
"data: {\"event\":\"message.delta\",\"delta\":\"Hel\"}\n\n\
data: {\"event\":\"message.delta\",\"delta\":\"lo\"}\n\n\
data: {\"event\":\"run.completed\",\"output\":\"Hello\"}\n\n",
);
let context = RequestContext::from_http_parts(
&Method::POST,
&"/api/ai-agent/run".parse::<Uri>().expect("uri"),
&HeaderMap::new(),
);
let response = build_hermes_sse_response(&context, events).expect("response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(
response
.headers()
.get("x-mnote-ai-execution-owner")
.and_then(|value| value.to_str().ok()),
Some("hermes")
);
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.expect("body");
let text = String::from_utf8(body.to_vec()).expect("utf8");
assert!(text.contains("event: assistant_message"));
assert!(text.contains("event: completion"));
assert!(text.contains("Hello"));
}
#[tokio::test]
async fn explicit_agent_provider_does_not_fallback_to_mnote_cli_when_next_unavailable() {
let response = build_app(AppState::new(AppConfig {
@@ -1126,11 +397,11 @@ mod tests {
.expect("body");
let text = String::from_utf8(body.to_vec()).expect("utf8");
assert!(text.contains("codex"));
assert!(!text.contains("mnote-cli"));
assert!(text.contains("provider 直连链路已退场"));
}
#[tokio::test]
async fn ai_agent_run_proxies_to_next_ai_route_when_legacy_next_compat_enabled() {
async fn explicit_hermes_provider_fails_instead_of_using_legacy_next_or_direct_bridge() {
let next_app = axum::Router::new().route(
"/api/ai-agent/run",
axum::routing::post(|| async move {
@@ -1180,20 +451,20 @@ mod tests {
.await
.expect("response");
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
assert_eq!(
response
.headers()
.get("x-mnote-web-owner")
.get("x-mnote-ai-execution-owner")
.and_then(|value| value.to_str().ok()),
Some("mnote-web")
Some("provider-bridge-unavailable")
);
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.expect("body");
let text = String::from_utf8(body.to_vec()).expect("utf8");
assert!(text.contains("assistant_message"));
assert!(text.contains("hello from next ai"));
assert!(text.contains("hermes"));
assert!(!text.contains("hello from next ai"));
server.abort();
}
rust/crates/mnote-web/src/routes/gateway.rs
+165 -1
View File
@@ -13,12 +13,15 @@ use crate::workspace_shell::{
build_workspace_shell_projection, render_workspace_shell_sidebar_html,
};
use axum::body::Body;
use axum::extract::ws::{Message as AxumWsMessage, WebSocket, WebSocketUpgrade};
use axum::extract::{Extension, Query, State};
use axum::http::{header, HeaderName, HeaderValue, Request, StatusCode};
use axum::http::{header, HeaderName, HeaderValue, Request, StatusCode, Uri};
use axum::response::{Html, IntoResponse, Response};
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use serde_json::json;
use std::time::Duration;
use tokio_tungstenite::tungstenite::Message as TungsteniteMessage;
const HEADER_MNOTE_WEB_OWNER: &str = "x-mnote-web-owner";
const HEADER_MNOTE_LEGACY_UPSTREAM: &str = "x-mnote-legacy-upstream";
@@ -482,6 +485,132 @@ pub async fn legacy_next_proxy(
Ok(response)
}
#[allow(dead_code)]
pub async fn legacy_next_websocket_proxy(
ws: WebSocketUpgrade,
State(state): State<AppState>,
Extension(context): Extension<RequestContext>,
uri: Uri,
) -> Result<Response, WebError> {
if !state.config().enable_legacy_next_compat {
return Err(WebError::service_unavailable_code(
"legacy_next_compat_disabled",
"Next App Router legacy compat 已关闭，当前路径未迁到 Rust Web gateway。",
)
.with_context(&context)
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web"));
}
let Some(base_url) = state.config().legacy_next_base_url.as_deref() else {
return Err(WebError::service_unavailable_code(
"legacy_next_upstream_missing",
"未配置 MNOTE_WEB_LEGACY_NEXT_BASE_URL，无法代理 legacy Next WebSocket。",
)
.with_context(&context)
.with_header(HEADER_MNOTE_WEB_OWNER, "mnote-web"));
};
let upstream_url = build_legacy_next_ws_url(base_url, &uri)?;
Ok(ws.on_upgrade(move |socket| async move {
if let Err(error) = proxy_legacy_next_websocket(socket, upstream_url).await {
tracing::warn!(error = %error, "legacy Next WebSocket 代理已断开");
}
}))
}
#[allow(dead_code)]
fn build_legacy_next_ws_url(base_url: &str, uri: &Uri) -> Result<String, WebError> {
let upstream = reqwest::Url::parse(base_url)
.map_err(|error| WebError::internal(format!("legacy Next upstream URL 非法: {error}")))?;
let scheme = match upstream.scheme() {
"https" => "wss",
_ => "ws",
};
let host = upstream
.host_str()
.filter(|value| !value.trim().is_empty())
.ok_or_else(|| WebError::internal("legacy Next upstream URL 缺少 host"))?;
let host_with_port = match upstream.port() {
Some(port) => format!("{host}:{port}"),
None => host.to_string(),
};
let path_and_query = uri
.path_and_query()
.map(|value| value.as_str())
.unwrap_or("/");
Ok(format!("{scheme}://{host_with_port}{path_and_query}"))
}
#[allow(dead_code)]
async fn proxy_legacy_next_websocket(
socket: WebSocket,
upstream_url: String,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let (upstream, _) = tokio_tungstenite::connect_async(upstream_url.as_str()).await?;
let (mut client_tx, mut client_rx) = socket.split();
let (mut upstream_tx, mut upstream_rx) = upstream.split();
let client_to_upstream = async {
while let Some(message) = client_rx.next().await {
let Ok(message) = message else {
break;
};
if upstream_tx
.send(axum_ws_to_tungstenite(message))
.await
.is_err()
{
break;
}
}
};
let upstream_to_client = async {
while let Some(message) = upstream_rx.next().await {
let Ok(message) = message else {
break;
};
if client_tx
.send(tungstenite_to_axum_ws(message))
.await
.is_err()
{
break;
}
}
};
tokio::select! {
_ = client_to_upstream => {}
_ = upstream_to_client => {}
}
Ok(())
}
#[allow(dead_code)]
fn axum_ws_to_tungstenite(message: AxumWsMessage) -> TungsteniteMessage {
match message {
AxumWsMessage::Text(value) => TungsteniteMessage::Text(value.to_string().into()),
AxumWsMessage::Binary(value) => TungsteniteMessage::Binary(value),
AxumWsMessage::Ping(value) => TungsteniteMessage::Ping(value),
AxumWsMessage::Pong(value) => TungsteniteMessage::Pong(value),
AxumWsMessage::Close(_) => TungsteniteMessage::Close(None),
}
}
#[allow(dead_code)]
fn tungstenite_to_axum_ws(message: TungsteniteMessage) -> AxumWsMessage {
match message {
TungsteniteMessage::Text(value) => AxumWsMessage::Text(value.to_string().into()),
TungsteniteMessage::Binary(value) => AxumWsMessage::Binary(value),
TungsteniteMessage::Ping(value) => AxumWsMessage::Ping(value),
TungsteniteMessage::Pong(value) => AxumWsMessage::Pong(value),
TungsteniteMessage::Close(_) => AxumWsMessage::Close(None),
TungsteniteMessage::Frame(_) => AxumWsMessage::Close(None),
}
}
async fn resolve_root_workspace_id(
state: &AppState,
context: &RequestContext,
@@ -947,6 +1076,18 @@ mod tests {
format!("http://{addr}")
}
async fn spawn_legacy_unmatched_upstream() -> String {
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("legacy listener");
let addr = listener.local_addr().expect("legacy addr");
let app = axum::Router::new().route("/unmigrated", get(|| async { "legacy-ok" }));
tokio::spawn(async move {
axum::serve(listener, app).await.expect("legacy server");
});
format!("http://{addr}")
}
#[tokio::test]
async fn gateway_health_declares_mnote_web_owner() {
let response = app()
@@ -1377,4 +1518,27 @@ mod tests {
.iter()
.any(|value| value.contains("__convexAuthRefreshToken=refresh-demo")));
}
#[tokio::test]
async fn unmigrated_route_returns_not_found_instead_of_proxying_to_legacy_next() {
let legacy_base_url = spawn_legacy_unmatched_upstream().await;
let response = app_with_legacy_next_base_url(legacy_base_url)
.oneshot(
Request::builder()
.uri("/unmigrated")
.body(Body::empty())
.expect("request"),
)
.await
.expect("response");
assert_eq!(response.status(), StatusCode::NOT_FOUND);
assert_eq!(
response
.headers()
.get("x-mnote-legacy-upstream")
.and_then(|value| value.to_str().ok()),
None
);
}
}
rust/crates/mnote-web/src/routes/local_folder_events.rs
+7 -8
View File
@@ -57,12 +57,12 @@ pub async fn local_folder_events(
let stream = stream::unfold(
(Some(initial), subscription, document_relative_path),
|(initial, mut subscription, document_relative_path)| async move {
if let Some(payload) = initial {
return Some((
Ok(stream_event("ready", &payload)),
(None, subscription, document_relative_path),
));
}
if let Some(payload) = initial {
return Some((
Ok(stream_event("ready", &payload)),
(None, subscription, document_relative_path),
));
}
loop {
match subscription.receiver.recv().await {
Ok(payload) => {
@@ -152,8 +152,7 @@ mod tests {
#[test]
fn local_markdown_document_id_maps_to_relative_path() {
assert_eq!(
local_markdown_relative_path_from_document_id("local-md:docs~2FREADME.md")
.as_deref(),
local_markdown_relative_path_from_document_id("local-md:docs~2FREADME.md").as_deref(),
Some("docs/README.md")
);
}
rust/crates/mnote-web/src/routes/local_folder_source.rs
+6 -5
View File
@@ -3156,8 +3156,11 @@ fn main() {}
.to_string();
std::thread::sleep(std::time::Duration::from_millis(5));
std::fs::write(root.join("README.md"), "---\ntitle: Stale\n---\n# External\n")
.expect("external write");
std::fs::write(
root.join("README.md"),
"---\ntitle: Stale\n---\n# External\n",
)
.expect("external write");
let error = save_local_markdown_page(
&root_uri,
@@ -3168,9 +3171,7 @@ fn main() {}
]),
)
.expect_err("stale save should fail");
assert!(error
.message()
.contains("本地 Markdown 文件已被外部修改"));
assert!(error.message().contains("本地 Markdown 文件已被外部修改"));
let saved = std::fs::read_to_string(root.join("README.md")).expect("read md");
assert!(saved.contains("# External"));
rust/crates/mnote-web/src/routes/mod.rs
+122 -13
View File
@@ -7,8 +7,8 @@ mod gateway;
mod health;
mod hermes;
mod kernel;
mod local_folder_source;
mod local_folder_events;
mod local_folder_source;
mod local_markdown_parser;
mod media;
mod mindmap_api;
@@ -30,7 +30,6 @@ use axum::Router;
pub fn build_router(state: AppState) -> Router {
let hermes_base_path = state.config().hermes_base_path.clone();
let compat_next_base_path = state.config().compat_next_base_path.clone();
let enable_debug_shell_routes = state.config().enable_debug_shell_routes;
let mut router = Router::new()
@@ -91,7 +90,6 @@ pub fn build_router(state: AppState) -> Router {
)
.route("/api/documents/meta", get(documents::meta))
.route("/api/documents/content", get(documents::content))
.route("/api/documents/page", get(web_shell::documents_page_compat))
.route("/api/documents/purge", post(documents::purge))
.route("/api/documents/title", post(documents::title))
.route("/api/documents/options", post(documents::options))
@@ -137,21 +135,132 @@ pub fn build_router(state: AppState) -> Router {
Router::new()
.route("/health", get(hermes::health))
.route("/bridge", post(hermes::bridge_runtime)),
)
.nest(
&compat_next_base_path,
Router::new()
.route("/ai-agent/run", post(compat::next_ai_agent_run))
.route("/sidebar", get(compat::next_sidebar)),
)
.fallback(gateway::legacy_next_proxy);
);
if enable_debug_shell_routes {
router = router
.route("/tree", get(tree::tree_shell))
.route("/document-debug", get(editor::document_editor_shell))
.route("/document", get(editor::document_editor_shell));
.route("/document-debug", get(editor::document_editor_shell));
}
router.with_state(state)
}
#[cfg(test)]
mod tests {
use super::build_router;
use crate::app::{AppConfig, AppState};
use axum::body::Body;
use axum::http::{Request, StatusCode};
use axum::Router;
use tower::ServiceExt;
fn app(enable_debug_shell_routes: bool) -> Router {
build_router(AppState::new(AppConfig {
service_name: "mnote-web".into(),
service_version: "0.1.0".into(),
bind_addr: "127.0.0.1:0".into(),
public_bind_addr: "127.0.0.1:3000".into(),
legacy_next_base_url: Some("http://127.0.0.1:3100".into()),
enable_legacy_next_compat: false,
enable_debug_shell_routes,
hermes_base_path: "/api/hermes".into(),
compat_next_base_path: "/api/compat/next".into(),
convex_url: None,
convex_admin_key: None,
allow_dev_fixtures: false,
query_fixtures_json: None,
mutation_fixtures_json: None,
dev_user_id: "dev-user".into(),
dev_user_name: "开发用户".into(),
dev_user_email: "dev@mnote.local".into(),
}))
}
#[tokio::test]
async fn debug_shell_routes_are_not_mounted_by_default() {
for path in ["/tree", "/document-debug"] {
let response = app(false)
.oneshot(
Request::builder()
.uri(path)
.body(Body::empty())
.expect("request"),
)
.await
.expect("response");
assert_eq!(
response.status(),
StatusCode::NOT_FOUND,
"{path} 默认不应暴露"
);
}
}
#[tokio::test]
async fn debug_shell_routes_are_only_available_when_explicitly_enabled() {
let tree_response = app(true)
.oneshot(
Request::builder()
.uri("/tree")
.body(Body::empty())
.expect("request"),
)
.await
.expect("response");
assert_ne!(
tree_response.status(),
StatusCode::NOT_FOUND,
"/tree 显式启用 debug gate 后不应继续返回 404",
);
let document_debug_response = app(true)
.oneshot(
Request::builder()
.uri("/document-debug")
.body(Body::empty())
.expect("request"),
)
.await
.expect("response");
assert_ne!(
document_debug_response.status(),
StatusCode::NOT_FOUND,
"/document-debug 显式启用 debug gate 后不应继续返回 404",
);
}
#[tokio::test]
async fn onlyoffice_and_media_transport_routes_are_explicitly_mounted() {
for (method, path) in [
("GET", "/onlyoffice"),
("POST", "/api/onlyoffice/sign"),
("GET", "/api/onlyoffice/proxy?u=x"),
("POST", "/api/onlyoffice/callback"),
("POST", "/api/onlyoffice/forcesave"),
("POST", "/api/media/upload"),
("GET", "/api/media/sign?assetId=x"),
("POST", "/api/tree/filetree/upload-target-preflight"),
(
"GET",
"/onlyoffice-server/web-apps/apps/api/documents/api.js",
),
] {
let response = app(false)
.oneshot(
Request::builder()
.method(method)
.uri(path)
.body(Body::empty())
.expect("request"),
)
.await
.expect("response");
assert_ne!(
response.status(),
StatusCode::NOT_FOUND,
"{method} {path} 应显式挂到 Rust 3000 单入口边界",
);
}
}
}
rust/crates/mnote-web/src/routes/sse.rs
+9 -2
View File
@@ -73,7 +73,8 @@ pub async fn events(
match change.kind {
StreamChangeKind::Delta => {
let payload = build_stream_delta_payload(
let Ok(payload) = build_stream_delta_payload(
state.app_state.config(),
&state.context,
&state.query,
&workspace_id,
@@ -82,7 +83,11 @@ pub async fn events(
change
.delta
.unwrap_or_else(|| serde_json::json!({ "op": "noop" })),
);
)
.await
else {
return None;
};
return Some((Ok(stream_event("delta", &payload)), Some(state)));
}
StreamChangeKind::Resync => {
@@ -260,6 +265,8 @@ mod tests {
let text = String::from_utf8(body.to_vec()).expect("utf8");
assert!(text.contains("event: snapshot") || text.contains("event:snapshot"));
assert!(text.contains("\"kind\":\"snapshot\""));
assert!(text.contains("\"kernel_sidebar_projection\""));
assert!(text.contains("\"kernel_file_tree_projection\""));
}
#[tokio::test]
rust/crates/mnote-web/src/routes/stream_support.rs
+159 -25
View File
@@ -455,6 +455,114 @@ pub fn read_stream_cursor_from_payload(payload: &Value) -> Option<String> {
read_string_field(payload, &["cursor"])
}
fn attach_workspace_dataset_projections(
mut dataset: Value,
sidebar_projection: Value,
file_tree_projection: Value,
) -> Value {
let Some(map) = dataset.as_object_mut() else {
return dataset;
};
map.insert(
"kernel_sidebar_projection".into(),
sidebar_projection.clone(),
);
map.insert("kernelSidebarProjection".into(), sidebar_projection);
map.insert(
"kernel_file_tree_projection".into(),
file_tree_projection.clone(),
);
map.insert("kernelFileTreeProjection".into(), file_tree_projection);
dataset
}
async fn load_workspace_stream_snapshot(
config: &AppConfig,
context: &RequestContext,
workspace_id: &str,
depth: Option<u32>,
) -> Result<Value, WebError> {
let sidebar_loaded = load_projection_snapshot(
config,
context,
&ProjectionSnapshotSpec {
workspace_id,
root_node_id: None,
depth,
query: None,
max_results: None,
projection: KernelProjectionKind::SidebarTree,
},
)
.await?;
let file_tree_loaded = load_projection_snapshot(
config,
context,
&ProjectionSnapshotSpec {
workspace_id,
root_node_id: None,
depth,
query: None,
max_results: None,
projection: KernelProjectionKind::FileTree,
},
)
.await?;
let dataset = attach_workspace_dataset_projections(
sidebar_loaded.dataset,
sidebar_loaded.projection.clone(),
file_tree_loaded.projection,
);
Ok(json!({
"dataset": dataset,
"tree": sidebar_loaded.projection,
}))
}
fn delta_document_patch_is_title_only(candidate: &Value) -> bool {
let Some(map) = candidate.as_object() else {
return false;
};
map.keys().all(|key| {
matches!(
key.as_str(),
"id" | "documentId" | "title" | "updatedAt" | "updated_at"
)
})
}
fn delta_requires_projection_snapshot(delta: &Value) -> bool {
let Some(map) = delta.as_object() else {
return false;
};
let op = map
.get("op")
.and_then(Value::as_str)
.map(str::trim)
.unwrap_or("");
if op.is_empty() || op == "noop" {
return false;
}
if op == "upsert_document" {
return !map
.get("node")
.or_else(|| map.get("document"))
.is_some_and(delta_document_patch_is_title_only);
}
if op == "upsert_documents" {
let Some(items) = map
.get("upsertDocuments")
.or_else(|| map.get("upsert_documents"))
.and_then(Value::as_array)
else {
return true;
};
return !items.iter().all(delta_document_patch_is_title_only);
}
true
}
pub fn with_stream_kind(payload: &Value, kind: &str) -> Value {
if let Some(mut map) = payload.as_object().cloned() {
map.insert("kind".into(), Value::String(kind.into()));
@@ -466,16 +574,23 @@ pub fn with_stream_kind(payload: &Value, kind: &str) -> Value {
})
}
pub fn build_stream_delta_payload(
pub async fn build_stream_delta_payload(
config: &AppConfig,
context: &RequestContext,
query: &StreamSnapshotQuery,
workspace_id: &str,
overview: &Value,
cursor: Option<String>,
delta: Value,
) -> Value {
) -> Result<Value, WebError> {
let scope = resolve_stream_scope(query);
json!({
let snapshot =
if scope == StreamSnapshotScope::Workspace && delta_requires_projection_snapshot(&delta) {
load_workspace_stream_snapshot(config, context, workspace_id, query.depth).await?
} else {
Value::Null
};
Ok(json!({
"kind": "delta",
"revision": cursor.clone().unwrap_or_else(|| "0".into()),
"stream": scope.as_str(),
@@ -487,9 +602,9 @@ pub fn build_stream_delta_payload(
"depth": query.depth,
"cursor": cursor,
"data": delta,
"snapshot": Value::Null,
"snapshot": snapshot,
"overview": overview,
})
}))
}
pub async fn load_stream_overview(
@@ -522,24 +637,8 @@ pub async fn load_stream_snapshot(
let snapshot = match scope {
StreamSnapshotScope::Workspace => {
let loaded = load_projection_snapshot(
config,
context,
&ProjectionSnapshotSpec {
workspace_id: &effective_workspace_id,
root_node_id: None,
depth: query.depth,
query: None,
max_results: None,
projection: KernelProjectionKind::SidebarTree,
},
)
.await?;
json!({
"dataset": loaded.dataset,
"tree": loaded.projection,
})
load_workspace_stream_snapshot(config, context, &effective_workspace_id, query.depth)
.await?
}
StreamSnapshotScope::Subtree => {
let root_node_id =
@@ -590,8 +689,8 @@ pub async fn load_stream_snapshot(
#[cfg(test)]
mod tests {
use super::{
resolve_stream_change, resolve_stream_cursor, resolve_stream_scope, StreamChangeKind,
StreamSnapshotQuery, StreamSnapshotScope,
delta_requires_projection_snapshot, resolve_stream_change, resolve_stream_cursor,
resolve_stream_scope, StreamChangeKind, StreamSnapshotQuery, StreamSnapshotScope,
};
use serde_json::json;
@@ -1192,4 +1291,39 @@ mod tests {
assert_eq!(change.kind, StreamChangeKind::Resync);
assert_eq!(change.delta, None);
}
#[test]
fn title_only_delta_does_not_require_projection_snapshot() {
assert!(!delta_requires_projection_snapshot(&json!({
"op": "upsert_document",
"document": {
"id": "page_1",
"title": "新标题"
}
})));
assert!(!delta_requires_projection_snapshot(&json!({
"op": "upsert_documents",
"upsertDocuments": [
{
"id": "page_1",
"title": "新标题"
}
]
})));
}
#[test]
fn structural_delta_requires_projection_snapshot() {
assert!(delta_requires_projection_snapshot(&json!({
"op": "move_document",
"documentId": "page_1",
"parentId": "page_2"
})));
assert!(delta_requires_projection_snapshot(&json!({
"op": "upsert_assets",
"upsertAssets": [
{ "id": "asset_1" }
]
})));
}
}
rust/crates/mnote-web/src/routes/tree.rs
+11 -10
View File
@@ -404,6 +404,15 @@ pub(crate) fn collect_page_tree_render_rows(projection: &Value) -> Vec<PageTreeR
.get("expandedByDefault")
.and_then(Value::as_bool)
.unwrap_or(false),
openable: item
.get("resourceMeta")
.and_then(Value::as_object)
.and_then(|meta| meta.get("documentId"))
.and_then(Value::as_str)
.map(str::trim)
.filter(|value| !value.is_empty())
.is_some()
|| !node_id.starts_with("local-dir:"),
})
})
.collect()
@@ -7475,7 +7484,7 @@ mod tests {
}
#[tokio::test]
async fn tree_route_contracts_compat_sidebar_keeps_boundary_and_trace_fields() {
async fn tree_route_contracts_compat_sidebar_route_is_not_registered_by_default() {
let response = app()
.oneshot(
Request::builder()
@@ -7487,15 +7496,7 @@ mod tests {
.await
.expect("response");
assert_eq!(response.status(), StatusCode::OK);
let body = axum::body::to_bytes(response.into_body(), usize::MAX)
.await
.expect("body");
let payload: Value = serde_json::from_slice(&body).expect("json");
assert_eq!(payload["boundary"], "next_sidebar_compat");
assert_eq!(payload["workspaceId"], "ws_demo");
assert!(payload["requestId"].as_str().is_some());
assert!(payload["traceId"].as_str().is_some());
assert_eq!(response.status(), StatusCode::NOT_FOUND);
}
#[test]
rust/crates/mnote-web/src/routes/web_shell.rs
+48 -78
View File
@@ -50,13 +50,6 @@ pub struct DocumentShellQuery {
pub secondary_root_uri: Option<String>,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DocumentPageCompatQuery {
pub document_id: String,
pub workspace_id: Option<String>,
}
pub async fn document_page_shell(
State(state): State<AppState>,
Extension(context): Extension<RequestContext>,
@@ -434,30 +427,38 @@ pub(crate) fn render_document_title_controller_script() -> &'static str {
inputs.forEach((input) => {
input.setAttribute('data-title-controller', CONTRACT);
const endpoint = input.getAttribute('data-title-endpoint') || '/api/documents/title';
const paneRole = (input.getAttribute('data-pane-role') || 'primary').trim();
const rawDocumentId = (input.getAttribute('data-document-id') || '').trim();
const documentId = rawDocumentId || (
paneRole === 'primary'
? (document.body?.dataset.documentId || '').trim()
: ''
);
const query = new URLSearchParams(window.location.search);
const paneQueryParams = paneRole === 'secondary'
? { sourceKindParam: 'secondarySourceKind', rootUriParam: 'secondaryRootUri' }
: { sourceKindParam: 'sourceKind', rootUriParam: 'rootUri' };
const sourceKindParam = paneQueryParams.sourceKindParam;
const rootUriParam = paneQueryParams.rootUriParam;
const workspaceId = (input.getAttribute('data-workspace-id') || query.get('workspaceId') || '').trim();
const sourceKind = (query.get(sourceKindParam) || '').trim();
const rootUri = (query.get(rootUriParam) || '').trim();
let lastSavedTitle = input.value.trim() || '无标题';
const resolveTitleTarget = (targetInput) => {
const paneRole = (targetInput.getAttribute('data-pane-role') || 'primary').trim();
const rawDocumentId = (targetInput.getAttribute('data-document-id') || '').trim();
const documentId = rawDocumentId || (
paneRole === 'primary'
? (document.body?.dataset.documentId || '').trim()
: ''
);
const query = new URLSearchParams(window.location.search);
const paneQueryParams = paneRole === 'secondary'
? { sourceKindParam: 'secondarySourceKind', rootUriParam: 'secondaryRootUri' }
: { sourceKindParam: 'sourceKind', rootUriParam: 'rootUri' };
return {
documentId,
workspaceId: (targetInput.getAttribute('data-workspace-id') || query.get('workspaceId') || '').trim(),
sourceKind: (query.get(paneQueryParams.sourceKindParam) || '').trim(),
rootUri: (query.get(paneQueryParams.rootUriParam) || '').trim(),
};
};
const readLastSavedTitle = () => input.getAttribute('data-title-last-saved') || '无标题';
const writeLastSavedTitle = (title) => {
input.setAttribute('data-title-last-saved', title || '无标题');
};
writeLastSavedTitle(input.value.trim() || '无标题');
let saving = false;
const saveTitle = async () => {
const title = input.value.trim() || '无标题';
const currentTarget = resolveTitleTarget(input);
autosize(input);
if (!documentId || saving || title === lastSavedTitle) {
updateVisibleTitle(input, title, documentId);
if (!currentTarget.documentId || saving || title === readLastSavedTitle()) {
updateVisibleTitle(input, title, currentTarget.documentId);
setStatus(input, 'saved');
return;
}
@@ -468,10 +469,10 @@ pub(crate) fn render_document_title_controller_script() -> &'static str {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({
documentId,
workspaceId: workspaceId || null,
sourceKind: sourceKind || undefined,
rootUri: rootUri || undefined,
documentId: currentTarget.documentId,
workspaceId: currentTarget.workspaceId || null,
sourceKind: currentTarget.sourceKind || undefined,
rootUri: currentTarget.rootUri || undefined,
title,
commandName: 'page.head.updateTitle',
}),
@@ -480,11 +481,11 @@ pub(crate) fn render_document_title_controller_script() -> &'static str {
if (!response.ok || !payload || payload.ok !== true) {
throw new Error(payload?.error?.message || payload?.message || `title_failed_${response.status}`);
}
lastSavedTitle = title;
updateVisibleTitle(input, title, documentId);
writeLastSavedTitle(title);
updateVisibleTitle(input, title, currentTarget.documentId);
setStatus(input, 'saved');
window.dispatchEvent(new CustomEvent('tree:title-updated', {
detail: { documentId, workspaceId: workspaceId || null, title, payload },
detail: { documentId: currentTarget.documentId, workspaceId: currentTarget.workspaceId || null, title, payload },
}));
} catch (error) {
setStatus(input, 'error', error instanceof Error ? error.message : String(error));
@@ -495,7 +496,7 @@ pub(crate) fn render_document_title_controller_script() -> &'static str {
input.addEventListener('input', () => {
autosize(input);
setStatus(input, input.value.trim() === lastSavedTitle ? 'saved' : 'dirty');
setStatus(input, (input.value.trim() || '无标题') === readLastSavedTitle() ? 'saved' : 'dirty');
});
input.addEventListener('keydown', (event) => {
if (event.key === 'Enter' && !event.shiftKey) {
@@ -505,7 +506,7 @@ pub(crate) fn render_document_title_controller_script() -> &'static str {
});
input.addEventListener('blur', () => { void saveTitle(); });
autosize(input);
updateVisibleTitle(input, lastSavedTitle, documentId);
updateVisibleTitle(input, readLastSavedTitle(), resolveTitleTarget(input).documentId);
setStatus(input, 'saved');
});
})();
@@ -681,6 +682,12 @@ pub(crate) fn render_editor_island_adapter_script() -> &'static str {
throw new Error('island runtime 导出不完整');
}
await runtime.default(wasmUrl);
if (typeof runtime.mount_mindmap_shell === 'function' && typeof runtime.unmount_mindmap_shell === 'function') {
window.__MNOTE_MINDMAP_RUST_SHELL__ = {
mount: runtime.mount_mindmap_shell,
unmount: runtime.unmount_mindmap_shell,
};
}
return runtime;
})();
return window.__mnoteLeptosTiptapRuntimePromise;
@@ -1560,6 +1567,7 @@ pub(crate) fn render_editor_island_adapter_script() -> &'static str {
node.value = title;
node.setAttribute('data-document-id', documentId);
node.setAttribute('data-workspace-id', workspaceId);
node.setAttribute('data-title-last-saved', title);
node.setAttribute('data-title-save-status', 'saved');
node.style.height = 'auto';
node.style.height = `${Math.max(48, node.scrollHeight)}px`;
@@ -2015,49 +2023,6 @@ pub async fn leptos_tiptap_asset(Path(asset_path): Path<String>) -> Result<Respo
Ok(response)
}
pub async fn documents_page_compat(
State(state): State<AppState>,
Extension(context): Extension<RequestContext>,
Query(query): Query<DocumentPageCompatQuery>,
) -> Result<Response, WebError> {
let document_id = query.document_id.trim().to_string();
if document_id.is_empty() {
return Err(
WebError::bad_request_code("document_id_required", "缺少有效 documentId")
.with_context(&context),
);
}
let aggregate = build_page_aggregate_snapshot(
&state,
&context,
&document_id,
query.workspace_id.as_deref(),
None,
None,
)
.await?;
let projection_owner = aggregate.source_label();
let mut response = (
StatusCode::OK,
Json(json!({
"ok": true,
"owner": "mnote-web",
"schema": "mnote.documents_page_compat.v1",
"page": aggregate,
"requestId": context.trace.request_id,
"traceId": context.trace.trace_id,
})),
)
.into_response();
stamp_shell_headers(response.headers_mut(), "documents-page-compat");
if let Ok(name) = HeaderName::from_lowercase(b"x-mnote-page-aggregate-owner") {
if let Ok(value) = HeaderValue::from_str(projection_owner) {
response.headers_mut().insert(name, value);
}
}
Ok(response)
}
pub async fn page_aggregate(
State(state): State<AppState>,
Extension(context): Extension<RequestContext>,
@@ -2488,6 +2453,8 @@ mod tests {
assert!(html.contains("data-page-title-input=\"true\""));
assert!(html.contains("data-title-endpoint=\"/api/documents/title\""));
assert!(html.contains("mnote.document_title_controller.v1"));
assert!(html.contains("const currentTarget = resolveTitleTarget(input);"));
assert!(html.contains("documentId: currentTarget.documentId"));
assert!(html.contains(
r#".tree-row[data-shell-mode="page"][data-node-id="' + escaped + '"] > .tree-link > .tree-link-title"#
));
@@ -2642,6 +2609,9 @@ mod tests {
assert!(html.contains("Child Page"));
assert!(html.contains("asset.png"));
assert!(html.contains("data-row-kind=\"markdown\""));
assert!(html.contains("data-page-openable=\"false\""));
assert!(html.contains("fileAction === 'open' && rowKind === 'folder'"));
assert!(html.contains("btn.getAttribute('data-page-openable') === 'false'"));
assert!(html.contains("data-mnote-action=\"open-local-folder\""));
assert!(html.contains("refreshSessionFromExternalFileChange"));
assert!(html.contains("/api/local-folder/events"));