serial-mcp 0.4.2

MCP server for serial port communication. 13 tools (open/read/read_line/write/wait_for/subscribe/...), resources, prompts, task cancellation, stdio + streamable-HTTP transports.
Documentation
use std::sync::Arc;
use std::time::Instant;

use rmcp::{model::Meta, Json, Peer, RoleServer};
use tracing::{debug, info};

use crate::codec;
use crate::serial::ConnectionManager;
use crate::tools::helpers::{
    build_read_result, clamp_or_err, clamp_timeout_or_err, log_tool_err, lookup_connection,
    parse_encoding, read_bytes, read_until_pattern, require_min_or_err, DEFAULT_READ_TIMEOUT_MS,
    MAX_READ_BYTES, MAX_TIMEOUT_MS, MAX_WAIT_BYTES, MAX_WRITE_BYTES, MIN_READ_BYTES,
};
use crate::tools::types::{
    FlushArgs, FlushResult, ReadArgs, ReadLineArgs, ReadLineResult, ReadResult, WriteArgs,
    WriteResult,
};

pub async fn write(
    connections: &Arc<ConnectionManager>,
    args: WriteArgs,
) -> Result<Json<WriteResult>, String> {
    debug!("Write to {} ({})", args.connection_id, args.encoding);

    let encoding = parse_encoding(&args.encoding)?;
    let connection = lookup_connection(connections, &args.connection_id).await?;
    let bytes =
        codec::decode(encoding, &args.data).map_err(|e| format!("Data decoding failed - {e}"))?;
    clamp_or_err("write.data.len()", bytes.len(), MAX_WRITE_BYTES)?;
    let bytes_written = connection.write(&bytes).await.map_err(|e| {
        log_tool_err(
            "write",
            &format!("Data sending failed on {}", args.connection_id),
            e,
        )
    })?;

    debug!("Wrote {} bytes to {}", bytes_written, args.connection_id);
    Ok(Json(WriteResult {
        connection_id: args.connection_id,
        bytes_written,
        encoding: encoding.to_string(),
    }))
}

pub async fn read(
    connections: &Arc<ConnectionManager>,
    meta: Meta,
    ct: tokio_util::sync::CancellationToken,
    peer: Peer<RoleServer>,
    args: ReadArgs,
) -> Result<Json<ReadResult>, String> {
    debug!(
        "Read from {} (timeout {:?})",
        args.connection_id, args.timeout_ms
    );

    let encoding = parse_encoding(&args.encoding)?;
    let connection = lookup_connection(connections, &args.connection_id).await?;
    let _rx_lease = crate::serial::SerialConnection::acquire_rx(&connection, "read")?;
    let max_bytes = require_min_or_err("read.max_bytes", args.max_bytes.0, MIN_READ_BYTES)?;
    let max_bytes = clamp_or_err("read.max_bytes", max_bytes, MAX_READ_BYTES)?;
    let timeout_ms: Option<u64> = args.timeout_ms.into();
    if let Some(ms) = timeout_ms {
        clamp_timeout_or_err("read.timeout_ms", ms, MAX_TIMEOUT_MS)?;
    }
    let progress_token = meta.get_progress_token();
    let outcome = read_bytes(
        &connection,
        max_bytes,
        timeout_ms,
        &ct,
        progress_token,
        Some(&peer),
    )
    .await?;
    build_read_result(outcome, args.connection_id, encoding, timeout_ms)
}

pub async fn flush(
    connections: &Arc<ConnectionManager>,
    args: FlushArgs,
) -> Result<Json<FlushResult>, String> {
    debug!("Flush {} target={:?}", args.connection_id, args.target);

    let connection = lookup_connection(connections, &args.connection_id).await?;
    connection.flush_buffers(args.target).await.map_err(|e| {
        log_tool_err(
            "flush",
            &format!("Failed to flush {}", args.connection_id),
            e,
        )
    })?;
    info!("Flushed {} ({:?})", args.connection_id, args.target);

    Ok(Json(FlushResult {
        connection_id: args.connection_id,
        target: args.target,
    }))
}

pub async fn read_line(
    connections: &Arc<ConnectionManager>,
    meta: Meta,
    ct: tokio_util::sync::CancellationToken,
    peer: Peer<RoleServer>,
    args: ReadLineArgs,
) -> Result<Json<ReadLineResult>, String> {
    debug!(
        "read_line {} (timeout {:?})",
        args.connection_id, args.timeout_ms
    );

    let encoding = parse_encoding(&args.encoding)?;
    let connection = lookup_connection(connections, &args.connection_id).await?;
    let _rx_lease = crate::serial::SerialConnection::acquire_rx(&connection, "read_line")?;
    let max_bytes = require_min_or_err("read_line.max_bytes", args.max_bytes.0, MIN_READ_BYTES)?;
    let max_bytes = clamp_or_err("read_line.max_bytes", max_bytes, MAX_WAIT_BYTES)?;
    let timeout_ms: u64 =
        Into::<Option<u64>>::into(args.timeout_ms).unwrap_or(DEFAULT_READ_TIMEOUT_MS);
    clamp_timeout_or_err("read_line.timeout_ms", timeout_ms, MAX_TIMEOUT_MS)?;

    let progress_token = meta.get_progress_token();
    let start = Instant::now();
    let outcome = read_until_pattern(
        &connection,
        b"\n",
        timeout_ms,
        max_bytes,
        &ct,
        progress_token,
        Some(&peer),
    )
    .await?;

    let elapsed_ms = start.elapsed().as_millis() as u64;

    if outcome.timed_out {
        return Err(format!(
            "read_line timed out after {timeout_ms}ms on {}",
            args.connection_id
        ));
    }

    let match_idx = outcome.match_index.unwrap_or(outcome.bytes.len());
    let mut line_bytes = Vec::from(&outcome.bytes[..match_idx]);
    let trailing = outcome.bytes.get(match_idx + 1..).unwrap_or(&[]);
    connection.unread(trailing).await;
    if line_bytes.last() == Some(&b'\r') {
        line_bytes.pop();
    }

    let bytes_read = line_bytes.len();
    let data =
        codec::encode(encoding, &line_bytes).map_err(|e| format!("Data encoding failed - {e}"))?;

    info!(
        "read_line {} returned {bytes_read} bytes in {elapsed_ms}ms",
        args.connection_id
    );

    Ok(Json(ReadLineResult {
        connection_id: args.connection_id,
        bytes_read,
        encoding: encoding.to_string(),
        line: data,
        timeout_ms,
        elapsed_ms,
    }))
}