@kromatv/sdk 0.1.39-canary.3579809

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@kromatv/sdk",
+  "version": "0.1.39-canary.3579809",
+  "description": "Build KROMA modules: the SDK, the design system types, the Rust crates and the kroma CLI in one package.",
+  "author": "Maxime Scharwath <maxscharwath@gmail.com>",
+  "license": "AGPL-3.0-or-later",
+  "homepage": "https://kroma.tv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kromatv/kroma.git",
+    "directory": "packages/module-sdk"
+  },
+  "keywords": [
+    "kroma",
+    "module",
+    "kmod",
+    "sdk",
+    "cli",
+    "media-server"
+  ],
+  "type": "module",
+  "bin": {
+    "kroma": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./types/module-sdk/src/index.d.ts"
+    },
+    "./shared": {
+      "types": "./types/module-sdk/src/shared.d.ts"
+    },
+    "./tsconfig": "./tsconfig.module.json"
+  },
+  "imports": {
+    "#ui/*": {
+      "types": [
+        "./types/ui/src/*.d.ts",
+        "./types/ui/src/*/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "types",
+    "rust",
+    "templates",
+    "tsconfig.module.json",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "vite": "8.3.5"
+  },
+  "peerDependencies": {
+    "react": "^19.3.0"
+  }
+}

package/rust/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+resolver = "2"
+members = ["kroma-module-sdk", "kroma-module-runtime", "kroma-module-host", "kroma-module-manifest", "kroma-module-macros", "kroma-module-wire", "kroma-media", "kroma-sqlite", "kroma-http", "kroma-i18n", "kroma-primitives", "kroma-testing"]

package/rust/kroma-http/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "kroma-http"
+version = "0.1.39-canary.3579809"
+edition = "2021"
+rust-version = "1.88"
+description = "KROMA's two HTTP transports: a curl process per call for the outside world, and a pooled client for the loopback seam between the core and its module sidecars"
+license = "AGPL-3.0-or-later"
+
+[dependencies]
+anyhow = { version = "1" }
+# curl's header dump goes to a guarded temp file, so a failed spawn leaves none.
+tempfile = { version = "3" }
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1" }
+hyper = { version = "1", features = ["client", "http1"] }
+hyper-util = { version = "0.1", features = ["client-legacy", "http1", "tokio"] }
+http-body-util = { version = "0.1" }
+bytes = { version = "1" }
+tokio = { version = "1", features = ["full"] }
+form_urlencoded = "1"

package/rust/kroma-http/examples/seam-bench.rs

@@ -0,0 +1,73 @@
+//! What one exchange on the internal seam costs, per transport.
+//!
+//!     cargo run -p kroma-http --release --example seam-bench
+
+use std::io::{Read, Write};
+use std::net::TcpListener;
+use std::time::{Duration, Instant};
+
+use kroma_http::{Fetch, Loopback};
+
+const BODY: &str = r#"{"ok":true,"items":[]}"#;
+const CALLS: u32 = 200;
+
+fn serve() -> u16 {
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let port = listener.local_addr().unwrap().port();
+    let response = format!(
+        "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: keep-alive\r\n\r\n{BODY}",
+        BODY.len()
+    );
+    std::thread::spawn(move || {
+        for mut stream in listener.incoming().flatten() {
+            stream.set_nodelay(true).ok();
+            let response = response.clone();
+            std::thread::spawn(move || {
+                let mut buf = [0u8; 16384];
+                while matches!(stream.read(&mut buf), Ok(n) if n > 0) {
+                    if stream.write_all(response.as_bytes()).is_err() {
+                        return;
+                    }
+                }
+            });
+        }
+    });
+    port
+}
+
+fn time(label: &str, mut call: impl FnMut()) -> Duration {
+    call();
+    let start = Instant::now();
+    for _ in 0..CALLS {
+        call();
+    }
+    let elapsed = start.elapsed();
+    let per_call = elapsed.as_secs_f64() * 1000.0 / f64::from(CALLS);
+    println!("  {label:<38} {per_call:>9.3} ms/call");
+    elapsed
+}
+
+fn main() {
+    let port = serve();
+    let url = format!("http://127.0.0.1:{port}/_port/acquisition/search");
+    let body = serde_json::json!({ "query": "test", "limit": 50 });
+
+    println!("\n  {CALLS} POSTs to a loopback peer, one warm-up call each\n");
+
+    let curl = time("Fetch (a curl process per call)", || {
+        Fetch::new()
+            .header("authorization", "Bearer tok")
+            .post_json(&url, &body)
+            .unwrap();
+    });
+
+    let tcp = time("Loopback / tcp", || {
+        Loopback::new()
+            .header("authorization", "Bearer tok")
+            .post_json(&url, &body)
+            .unwrap();
+    });
+
+    let ratio = curl.as_secs_f64() / tcp.as_secs_f64();
+    println!("\n  tcp is {ratio:.0}x faster than a curl process per call\n");
+}

package/rust/kroma-http/src/builder.rs

@@ -0,0 +1,35 @@
+//! The options every transport takes, defined once.
+//!
+//! [`crate::Fetch`] and [`crate::Loopback`] accumulate headers, query pairs and
+//! a time budget identically -- they differ in what they do with them, not in
+//! how they are collected. Each expands this over its own fields, so the two
+//! builders cannot drift and neither carries a copy of the other.
+
+macro_rules! request_builder {
+    ($transport:ty, query = $query_doc:expr) => {
+        impl $transport {
+            pub fn new() -> Self {
+                Self::default()
+            }
+
+            pub fn header(mut self, name: &str, value: impl Into<String>) -> Self {
+                self.headers.push((name.to_string(), value.into()));
+                self
+            }
+
+            #[doc = $query_doc]
+            pub fn query(mut self, name: &str, value: impl Into<String>) -> Self {
+                self.query.push((name.to_string(), value.into()));
+                self
+            }
+
+            /// Budget for the whole transfer (default 30s).
+            pub fn max_time(mut self, secs: u32) -> Self {
+                self.max_time_secs = secs;
+                self
+            }
+        }
+    };
+}
+
+pub(crate) use request_builder;

package/rust/kroma-http/src/config.rs

@@ -0,0 +1,50 @@
+//! Encoding of one option line in a curl config file.
+
+// Within a double-quoted curl config value only `\\ \" \t \n \r \v` survive as
+// escapes; an unescaped newline would end the option and start another one.
+pub(crate) fn option_line(name: &str, value: &str) -> String {
+    let mut line = String::with_capacity(name.len() + value.len() + 8);
+    line.push_str(name);
+    line.push_str(" = \"");
+    for c in value.chars() {
+        match c {
+            '\\' => line.push_str("\\\\"),
+            '"' => line.push_str("\\\""),
+            '\t' => line.push_str("\\t"),
+            '\n' => line.push_str("\\n"),
+            '\r' => line.push_str("\\r"),
+            '\u{b}' => line.push_str("\\v"),
+            _ => line.push(c),
+        }
+    }
+    line.push_str("\"\n");
+    line
+}
+
+// RFC 9110 §5.5 forbids CR and LF in a field value, and curl forwards whatever
+// it is handed, so a value carrying one would split the request in two.
+pub(crate) fn header_line(name: &str, value: &str) -> String {
+    let field: String = format!("{name}: {value}")
+        .chars()
+        .filter(|c| !matches!(c, '\r' | '\n'))
+        .collect();
+    option_line("header", &field)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_config_value_escapes_what_would_end_the_option() {
+        assert_eq!(
+            option_line("header", r#"X: a"b"#),
+            "header = \"X: a\\\"b\"\n"
+        );
+        assert_eq!(option_line("header", r"X: a\b"), "header = \"X: a\\\\b\"\n");
+        assert_eq!(
+            option_line("url", "a\nb\r\tc\u{b}d"),
+            "url = \"a\\nb\\r\\tc\\vd\"\n"
+        );
+    }
+}

package/rust/kroma-http/src/curl.rs

@@ -0,0 +1,131 @@
+//! Running the `curl` process and reading its header dump back.
+
+use std::process::Command;
+
+use anyhow::{bail, Context, Result};
+
+use crate::config::option_line;
+use crate::response::Response;
+
+// Every option travels on stdin: argv is world-readable through `ps`, and these
+// requests carry an indexer's API key in a header and the download client's
+// password in a form field.
+fn curl_command() -> Command {
+    let mut cmd = Command::new("curl");
+    cmd.arg("--config").arg("-");
+    cmd
+}
+
+// Writing the config on this thread is safe because curl reads it whole before
+// making the request, so it never deadlocks on a full stdout pipe.
+pub(crate) fn run(mut config: String) -> Result<Response> {
+    use std::io::Write;
+
+    // A guard, not a path: every `?` below returns before the read, and a dump
+    // left behind on a failed spawn is one file per attempt forever.
+    let hdr = tempfile::Builder::new()
+        .prefix("kroma-http-hdr-")
+        .tempfile()
+        .context("create the curl header dump")?;
+    let hdr_path = hdr.path().to_path_buf();
+    config.push_str(&option_line("dump-header", &hdr_path.to_string_lossy()));
+
+    let mut child = curl_command()
+        .stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::piped())
+        .stderr(std::process::Stdio::piped())
+        .spawn()
+        .context("spawn curl")?;
+    let mut stdin = child.stdin.take().context("curl stdin was not piped")?;
+    let written = stdin.write_all(config.as_bytes());
+    // Closes the pipe so curl sees EOF. A curl that already gave up breaks it,
+    // so reap the child before reporting that write.
+    drop(stdin);
+    let out = child.wait_with_output().context("wait for curl")?;
+    if out.status.success() {
+        written.context("write the curl config")?;
+    }
+    let raw_headers = std::fs::read_to_string(&hdr_path).unwrap_or_default();
+    if !out.status.success() {
+        bail!(
+            "curl exit {}: {}",
+            out.status.code().unwrap_or(-1),
+            String::from_utf8_lossy(&out.stderr).trim()
+        );
+    }
+    let (status, headers) = parse_last_block(&raw_headers)?;
+    Ok(Response {
+        status,
+        headers,
+        body: out.stdout,
+    })
+}
+
+// With `-L`, curl appends one header block per hop to the dump; only the
+// final block describes the response whose body we hold.
+fn parse_last_block(raw: &str) -> Result<(u16, Vec<(String, String)>)> {
+    let mut status = None;
+    let mut headers = Vec::new();
+    for line in raw.lines() {
+        let line = line.trim_end_matches('\r');
+        if let Some(rest) = line.strip_prefix("HTTP/") {
+            // New block: "HTTP/1.1 200 OK" or "HTTP/2 302". Reset accumulation.
+            status = rest
+                .split_whitespace()
+                .nth(1)
+                .and_then(|c| c.parse::<u16>().ok());
+            headers.clear();
+        } else if let Some((k, v)) = line.split_once(':') {
+            headers.push((k.trim().to_string(), v.trim().to_string()));
+        }
+    }
+    let status =
+        status.ok_or_else(|| anyhow::anyhow!("no HTTP status line in curl header dump"))?;
+    Ok((status, headers))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_single_block() {
+        let raw = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nX-Thing: a\r\n\r\n";
+        let (status, headers) = parse_last_block(raw).unwrap();
+        assert_eq!(status, 200);
+        assert_eq!(headers.len(), 2);
+        assert_eq!(
+            headers[0],
+            ("Content-Type".to_string(), "application/json".to_string())
+        );
+    }
+
+    #[test]
+    fn keeps_only_the_final_redirect_block() {
+        let raw = concat!(
+            "HTTP/1.1 302 Found\r\nLocation: https://elsewhere\r\n\r\n",
+            "HTTP/2 200\r\ncontent-type: text/xml\r\n\r\n",
+        );
+        let (status, headers) = parse_last_block(raw).unwrap();
+        assert_eq!(status, 200);
+        assert_eq!(
+            headers,
+            vec![("content-type".to_string(), "text/xml".to_string())]
+        );
+    }
+
+    #[test]
+    fn parse_last_block_errors_without_a_status_line() {
+        let err = parse_last_block("Content-Type: text/plain\r\n\r\n").unwrap_err();
+        assert!(err.to_string().contains("no HTTP status line"), "{err}");
+    }
+
+    #[test]
+    fn the_argv_carries_nothing_but_the_config_pipe() {
+        let args: Vec<String> = curl_command()
+            .get_args()
+            .map(|a| a.to_string_lossy().into_owned())
+            .collect();
+        assert_eq!(args, vec!["--config".to_string(), "-".to_string()]);
+    }
+}