mnote/rust/crates/mnote-web/src/hermes_tools/artifact.rs

use crate::app::AppState;
use crate::context::RequestContext;
use crate::error::WebError;
use crate::hermes_tools::ToolCallInput;
use crate::routes::command_support::execute_runtime_command_via_convex_with_artifacts;
use crate::routes::ensure_local_workspace_access;
use bridge_runtime::{
    RuntimeActorWire, RuntimeCommandEnvelopeWire, RuntimeSourceWire, RuntimeTargetWire,
};
use serde_json::{json, Value};
use std::fs;
use std::path::PathBuf;

pub async fn create_summary(
    state: &AppState,
    context: &RequestContext,
    input: &ToolCallInput,
) -> Result<Value, WebError> {
    create_artifact_node(
        state,
        context,
        input,
        "summary",
        "mnote.artifact.create_summary",
    )
    .await
}

pub async fn create_ai_note(
    state: &AppState,
    context: &RequestContext,
    input: &ToolCallInput,
) -> Result<Value, WebError> {
    create_artifact_node(
        state,
        context,
        input,
        "ai_note",
        "mnote.artifact.create_ai_note",
    )
    .await
}

async fn create_artifact_node(
    state: &AppState,
    context: &RequestContext,
    input: &ToolCallInput,
    node_type: &str,
    tool_name: &str,
) -> Result<Value, WebError> {
    ensure_write_contract(context, input)?;
    let document_id = input.effective_document_id().ok_or_else(|| {
        WebError::bad_request_code("mnote_tool_bad_request", "artifact 工具缺少 documentId")
            .with_context(context)
    })?;
    let workspace_id = input.effective_workspace_id();
    let content = input
        .arg_string("summary")
        .or_else(|| input.arg_string("content"))
        .ok_or_else(|| {
            WebError::bad_request_code("mnote_tool_bad_request", "artifact 工具缺少内容")
                .with_context(context)
        })?;
    let idempotency_key =
        input.idempotency_key_or_default(&format!("{tool_name}_{}", context.trace.request_id));
    let command_id = format!(
        "{}_{}",
        tool_name.replace('.', "_"),
        context.trace.request_id
    );
    let artifact_document_id = if node_type == "summary" {
        format!("summary_{}", document_id)
    } else {
        format!("ai_note_{}_{}", document_id, context.trace.request_id)
    };

    if input.effective_source_kind().as_deref() == Some("local_folder") {
        let root_uri = input.effective_root_uri().ok_or_else(|| {
            WebError::bad_request_code("local_folder_root_required", "缺少本地文件夹 rootUri")
                .with_context(context)
        })?;
        ensure_local_workspace_access(context, &root_uri)
            .map_err(|error| error.with_context(context))?;
        if input.dry_run.unwrap_or(false) {
            return Ok(json!({
                "dryRun": true,
                "commandName": "tree.node.create",
                "commandId": command_id,
                "artifactType": node_type,
                "artifactDocumentId": artifact_document_id,
                "documentId": document_id,
                "workspaceId": workspace_id,
                "diff": [{"op": "create_artifact", "artifactType": node_type}]
            }));
        }
        let root_path = parse_local_root_path(&root_uri)?;
        let artifact_dir = root_path.join(".mnote").join("artifacts");
        fs::create_dir_all(&artifact_dir).map_err(|error| {
            WebError::bad_request_code(
                "local_artifact_write_failed",
                format!(
                    "无法创建本地 artifact 目录 {}: {error}",
                    artifact_dir.display()
                ),
            )
            .with_context(context)
        })?;
        let artifact_path = artifact_dir.join(format!(
            "{}.json",
            sanitize_local_artifact_file_name(&artifact_document_id)
        ));
        let artifact_value = json!({
            "schema": "mnote.local_artifact.v1",
            "artifactType": node_type,
            "artifactDocumentId": artifact_document_id,
            "documentId": document_id,
            "workspaceId": workspace_id,
            "content": content,
            "createdAt": context.trace.trace_id,
        });
        fs::write(
            &artifact_path,
            serde_json::to_string_pretty(&artifact_value).map_err(|error| {
                WebError::internal(format!("本地 artifact 序列化失败: {error}"))
                    .with_context(context)
            })?,
        )
        .map_err(|error| {
            WebError::bad_request_code(
                "local_artifact_write_failed",
                format!(
                    "无法写入本地 artifact 文件 {}: {error}",
                    artifact_path.display()
                ),
            )
            .with_context(context)
        })?;
        return Ok(json!({
            "dryRun": false,
            "commandName": "tree.node.create",
            "commandId": command_id,
            "source": "local_folder",
            "artifactType": node_type,
            "artifactDocumentId": artifact_document_id,
            "documentId": document_id,
            "workspaceId": workspace_id,
            "result": {
                "ok": true,
                "source": "local_folder",
                "artifactPath": artifact_path,
                "artifactDocumentId": artifact_document_id,
            }
        }));
    }

    if input.dry_run.unwrap_or(false) {
        return Ok(json!({
            "dryRun": true,
            "commandName": "tree.node.create",
            "commandId": command_id,
            "artifactType": node_type,
            "artifactDocumentId": artifact_document_id,
            "documentId": document_id,
            "workspaceId": workspace_id,
            "diff": [{"op": "create_artifact", "artifactType": node_type}]
        }));
    }

    let command = RuntimeCommandEnvelopeWire {
        name: "tree.node.create".into(),
        command_id: command_id.clone(),
        idempotency_key: Some(idempotency_key),
        actor: RuntimeActorWire {
            actor_type: context.auth.actor_type.clone(),
            actor_id: context.auth.actor_id.clone(),
            session_id: input
                .session_id
                .clone()
                .or_else(|| context.auth.session_id.clone()),
        },
        source: RuntimeSourceWire {
            channel: "hermes".into(),
            client: "mnote-hermes-plugin".into(),
            source_kind: None,
            root_uri: None,
            workspace_id: workspace_id.clone(),
            capabilities: input.capability_scope.clone().unwrap_or_default(),
        },
        target: Some(RuntimeTargetWire {
            workspace_id: workspace_id.clone(),
            page_id: Some(document_id.clone()),
            block_id: None,
        }),
        payload: json!({
            "workspaceId": workspace_id,
            "parentId": document_id,
            "documentId": artifact_document_id,
            "accessScope": "private",
            "nodeType": node_type,
            "title": if node_type == "summary" { "AI Summary" } else { "AI Note" },
            "content": [
                {
                    "id": format!("{}_body", node_type),
                    "type": "paragraph",
                    "content": [{"type": "text", "text": content}]
                }
            ],
            "artifact": {
                "kind": node_type,
                "sourceDocumentId": document_id,
                "source": "hermes",
                "sessionId": input.session_id,
                "runId": input.run_id,
                "toolCallId": input.tool_call_id,
                "traceId": input.effective_trace_id(&context.trace.trace_id)
            },
            "referenceEdge": {
                "from": document_id,
                "kind": "ai_artifact_reference"
            }
        }),
        preflight_data: None,
        reason: Some(tool_name.into()),
        refs: vec![tool_name.into(), "hermes-tool-call".into()],
        dry_run: false,
        validate_only: false,
    };
    let execution = execute_runtime_command_via_convex_with_artifacts(
        &state,
        context,
        workspace_id.as_deref(),
        command,
    )
    .await?;
    Ok(json!({
        "commandName": "tree.node.create",
        "commandId": command_id,
        "artifactType": node_type,
        "artifactDocumentId": artifact_document_id,
        "referenceEdge": {
            "from": document_id,
            "to": artifact_document_id,
            "kind": "ai_artifact_reference"
        },
        "result": execution.result,
        "artifacts": execution.artifacts,
        "artifactError": execution.artifact_error
    }))
}

fn parse_local_root_path(root_uri: &str) -> Result<PathBuf, WebError> {
    let root_path = if let Some(stripped) = root_uri.trim().strip_prefix("file://") {
        stripped.trim()
    } else {
        root_uri.trim()
    };
    if root_path.is_empty() {
        return Err(WebError::bad_request_code(
            "local_folder_root_required",
            "缺少本地文件夹 rootUri",
        ));
    }
    Ok(PathBuf::from(root_path))
}

fn sanitize_local_artifact_file_name(value: &str) -> String {
    value
        .chars()
        .map(|ch| match ch {
            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
            _ => ch,
        })
        .collect::<String>()
        .trim()
        .to_string()
}

fn ensure_write_contract(context: &RequestContext, input: &ToolCallInput) -> Result<(), WebError> {
    if !input.has_idempotency_key() {
        return Err(WebError::bad_request_code(
            "mnote_tool_idempotency_required",
            "写入型 mnote Hermes tool 必须携带 idempotencyKey",
        )
        .with_context(context));
    }
    if input.dry_run.is_none() {
        return Err(WebError::bad_request_code(
            "mnote_tool_dry_run_required",
            "写入型 mnote Hermes tool 必须显式携带 dryRun",
        )
        .with_context(context));
    }
    Ok(())
}