feat: unified gRPC server with gRPC-Web for browser connectivity

Migrate from split REST+gRPC to unified gRPC server with tonic-web:

Proto (teckel.proto):
- Renamed PipelineService → TeckelService
- Added high-level RPCs: Health, ValidatePipeline, ExplainPipeline,
  SubmitJob, GetJob, WaitForJob, CancelJob, ListJobs
- Kept low-level Spark Connect RPCs: CreateSession, CloseSession,
  ReadInput, ApplyTransform, WriteOutput, ExecutePipeline

teckel-worker:
- Unified gRPC server implementing all RPCs (high-level + low-level)
- Built-in job queue with semaphore-bounded concurrency
- tonic-web layer for gRPC-Web browser support
- CORS enabled for cross-origin requests
- accept_http1(true) for gRPC-Web compatibility
- Job management with cancellation tokens and status tracking

teckel-remote:
- Updated to use TeckelService (renamed from PipelineService)

The UI now connects via gRPC-Web (ConnectRPC) instead of REST.

Author: rafafrdz

Cargo.toml

@@ -39,6 +39,7 @@ reqwest = { version = "0.12", features = ["json"] }
 
 # gRPC
 tonic = "0.13"
+tonic-web = "0.13"
 prost = "0.13"
 
 # Polars

crates/teckel-remote/src/backend.rs

@@ -3,7 +3,7 @@
 //! Each DataFrame is represented as a `RemoteRef` (opaque handle ID on the worker).
 //! The actual data never leaves the worker — only handles are exchanged.
 
-use crate::proto::{self, pipeline_service_client::PipelineServiceClient};
+use crate::proto::{self, teckel_service_client::TeckelServiceClient};
 use async_trait::async_trait;
 use std::collections::{BTreeMap, HashMap};
 use teckel_engine::Backend;
@@ -21,7 +21,7 @@ pub struct RemoteRef {
 
 /// Backend that delegates execution to a remote gRPC worker.
 pub struct RemoteBackend {
-    client: PipelineServiceClient<Channel>,
+    client: TeckelServiceClient<Channel>,
     session_id: String,
 }
 
@@ -34,7 +34,7 @@ impl RemoteBackend {
             .await
             .map_err(|e| TeckelError::Execution(format!("failed to connect to worker: {e}")))?;
 
-        let mut client = PipelineServiceClient::new(channel);
+        let mut client = TeckelServiceClient::new(channel);
 
         let response = client
             .create_session(proto::CreateSessionRequest {

crates/teckel-remote/src/lib.rs

@@ -5,5 +5,5 @@ pub mod proto {
 }
 
 pub use backend::RemoteBackend;
-pub use proto::pipeline_service_client::PipelineServiceClient;
-pub use proto::pipeline_service_server::{PipelineService, PipelineServiceServer};
+pub use proto::teckel_service_client::TeckelServiceClient;
+pub use proto::teckel_service_server::{TeckelService, TeckelServiceServer};

crates/teckel-worker/Cargo.toml

@@ -14,10 +14,14 @@ teckel-datafusion = { workspace = true }
 teckel-api = { workspace = true }
 teckel-remote = { workspace = true }
 tonic = { workspace = true }
+tonic-web = { workspace = true }
+tower-http = { workspace = true }
+chrono = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 uuid = { workspace = true }
 dashmap = { workspace = true }
 serde_json = { workspace = true }
 num_cpus = { workspace = true }
+tokio-util = { workspace = true }

crates/teckel-worker/src/main.rs

@@ -1,13 +1,16 @@
-//! Teckel gRPC Worker — receives pipeline execution requests from remote clients.
+//! Teckel gRPC Server — unified API for the UI and programmatic clients.
 //!
-//! Each session gets its own DataFusion SessionContext. The worker manages
-//! session lifecycle, DataFrame caching, and pipeline execution.
+//! Serves both the high-level API (validate, explain, jobs) and the
+//! low-level Spark Connect-style API (sessions, per-op execution).
+//!
+//! Enables gRPC-Web via tonic-web for direct browser connectivity.
 
 mod service;
 
 use std::net::SocketAddr;
-use teckel_remote::PipelineServiceServer;
+use teckel_remote::TeckelServiceServer;
 use tonic::transport::Server;
+use tower_http::cors::{Any, CorsLayer};
 use tracing_subscriber::EnvFilter;
 
 #[tokio::main]
@@ -18,19 +21,35 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         )
         .init();
 
-    let host = std::env::var("TECKEL_WORKER_HOST").unwrap_or_else(|_| "0.0.0.0".to_string());
-    let port: u16 = std::env::var("TECKEL_WORKER_PORT")
+    let host = std::env::var("TECKEL_HOST").unwrap_or_else(|_| "0.0.0.0".to_string());
+    let port: u16 = std::env::var("TECKEL_PORT")
         .ok()
         .and_then(|p| p.parse().ok())
         .unwrap_or(50051);
+    let max_concurrency: usize = std::env::var("TECKEL_MAX_CONCURRENCY")
+        .ok()
+        .and_then(|c| c.parse().ok())
+        .unwrap_or_else(num_cpus::get);
 
     let addr: SocketAddr = format!("{host}:{port}").parse()?;
-    let worker = service::TeckelWorker::new();
+    let worker = service::TeckelWorker::new(max_concurrency);
+
+    // gRPC-Web + CORS for browser access
+    let cors = CorsLayer::new()
+        .allow_origin(Any)
+        .allow_methods(Any)
+        .allow_headers(Any)
+        .expose_headers(Any);
+
+    let grpc_web = tonic_web::GrpcWebLayer::new();
 
-    tracing::info!(%addr, "teckel-worker starting (gRPC)");
+    tracing::info!(%addr, max_concurrency, "teckel gRPC server starting (gRPC-Web enabled)");
 
     Server::builder()
-        .add_service(PipelineServiceServer::new(worker))
+        .accept_http1(true) // Required for gRPC-Web
+        .layer(cors)
+        .layer(grpc_web)
+        .add_service(TeckelServiceServer::new(worker))
         .serve(addr)
         .await?;