feat: port el-ui vessels — rename crates→vessels, add El source + manifests

ui/vessels/el-services/src/binding/mod.rs

@@ -0,0 +1,114 @@
+//! Service binding implementations.
+//!
+//! Each binding protocol implements the `Binding` trait.
+//! The proxy uses whatever binding is configured in `el.toml`.
+
+pub mod direct;
+pub mod grpc;
+pub mod rest;
+pub mod websocket;
+
+use crate::ServiceResult;
+use std::collections::HashMap;
+
+/// Which protocol this service binding uses.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BindingKind {
+    /// HTTP REST — maps service methods to HTTP endpoints.
+    Rest,
+    /// WebSocket — persistent connection, message-based RPC.
+    WebSocket,
+    /// gRPC — protobuf over HTTP/2 (stub; codegen is a future TODO).
+    Grpc,
+    /// Direct — server-side only; calls Rust functions directly, zero network.
+    Direct,
+}
+
+impl BindingKind {
+    pub fn from_str(s: &str) -> Option<Self> {
+        match s.to_lowercase().as_str() {
+            "rest" => Some(Self::Rest),
+            "websocket" | "ws" => Some(Self::WebSocket),
+            "grpc" => Some(Self::Grpc),
+            "direct" => Some(Self::Direct),
+            _ => None,
+        }
+    }
+
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Rest => "rest",
+            Self::WebSocket => "websocket",
+            Self::Grpc => "grpc",
+            Self::Direct => "direct",
+        }
+    }
+}
+
+/// A service call request — method name and parameters.
+#[derive(Debug, Clone)]
+pub struct ServiceRequest {
+    pub service: String,
+    pub method: String,
+    /// Parameters as key-value pairs. Complex types are JSON-serialized strings.
+    pub params: HashMap<String, String>,
+}
+
+impl ServiceRequest {
+    pub fn new(service: impl Into<String>, method: impl Into<String>) -> Self {
+        Self {
+            service: service.into(),
+            method: method.into(),
+            params: HashMap::new(),
+        }
+    }
+
+    pub fn with_param(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.params.insert(key.into(), value.into());
+        self
+    }
+}
+
+/// A service call response — raw body string (JSON, protobuf bytes as hex, etc.)
+#[derive(Debug, Clone)]
+pub struct ServiceResponse {
+    pub status: u16,
+    pub body: String,
+    pub headers: HashMap<String, String>,
+}
+
+impl ServiceResponse {
+    pub fn ok(body: impl Into<String>) -> Self {
+        Self {
+            status: 200,
+            body: body.into(),
+            headers: HashMap::new(),
+        }
+    }
+
+    pub fn error(status: u16, body: impl Into<String>) -> Self {
+        Self {
+            status,
+            body: body.into(),
+            headers: HashMap::new(),
+        }
+    }
+
+    pub fn is_success(&self) -> bool {
+        (200..300).contains(&self.status)
+    }
+}
+
+/// The core binding trait — implemented by each protocol.
+pub trait Binding: Send + Sync {
+    /// The kind of binding this is.
+    fn kind(&self) -> BindingKind;
+
+    /// Execute a service method call and return the response.
+    fn call(&self, request: ServiceRequest) -> ServiceResult<ServiceResponse>;
+
+    /// Whether this binding supports streaming responses.
+    fn supports_streaming(&self) -> bool {
+        false
+    }
+}