@tishlang/tish-format 2.37.3 → 2.39.0

package/crates/tish_compile/src/codegen.rs

@@ -1702,6 +1702,7 @@ impl Codegen {
                     "Server" => Some("Value::native(|args: &[Value]| tish_ws_server_construct(args))"),
                     "wsSend" => Some("Value::native(|args: &[Value]| Value::Bool(tishlang_runtime::ws_send_native(args.first().unwrap_or(&Value::Null), &args.get(1).map(|v| v.to_display_string()).unwrap_or_default())))"),
                     "wsBroadcast" => Some("Value::native(|args: &[Value]| tishlang_runtime::ws_broadcast_native(args))"),
+                    "wsAccept" => Some("Value::native(|args: &[Value]| tishlang_runtime::ws_serve_accept(args))"),
                     _ => None,
                 },
             "tish:tty" if self.has_feature("tty") => match export_name {
@@ -1714,6 +1715,15 @@ impl Codegen {
                     "readLine" => Some("Value::native(|args: &[Value]| tishlang_runtime::tty_read_line(args))"),
                     _ => None,
                 },
+            "tish:pty" if self.has_feature("pty") => match export_name {
+                    "spawn" => Some("Value::native(|args: &[Value]| tishlang_runtime::pty_spawn(args))"),
+                    "read" => Some("Value::native(|args: &[Value]| tishlang_runtime::pty_read(args))"),
+                    "write" => Some("Value::native(|args: &[Value]| tishlang_runtime::pty_write(args))"),
+                    "resize" => Some("Value::native(|args: &[Value]| tishlang_runtime::pty_resize(args))"),
+                    "kill" => Some("Value::native(|args: &[Value]| tishlang_runtime::pty_kill(args))"),
+                    "pid" => Some("Value::native(|args: &[Value]| tishlang_runtime::pty_pid(args))"),
+                    _ => None,
+                },
             _ => return None,
         };
         init.map(String::from)
@@ -1723,7 +1733,7 @@ impl Codegen {
         if self.features.contains("full") {
             matches!(
                 name,
-                "http" | "timers" | "fs" | "process" | "regex" | "ws" | "tty"
+                "http" | "timers" | "fs" | "process" | "regex" | "ws" | "tty" | "pty"
             )
         } else {
             self.features.contains(name)
@@ -2259,6 +2269,10 @@ impl Codegen {
             self.write("use tishlang_runtime::register_static_route as tish_register_static_route;\n");
             if self.is_async {
                 self.write("use tishlang_runtime::{fetch_promise as tish_fetch_promise, fetch_all_promise as tish_fetch_all_promise, http_serve as tish_http_serve, promise_object as tish_promise_object, await_promise as tish_await_promise, await_promise_throw as tish_await_promise_throw};\n");
+            } else if self.has_feature("ws") {
+                // ws programs get `Promise.spawn` (send-values OS-thread spawn) even when not async,
+                // so a server can run a background accept/pump loop alongside the blocking `serve()`.
+                self.write("use tishlang_runtime::{fetch_promise as tish_fetch_promise, fetch_all_promise as tish_fetch_all_promise, http_serve as tish_http_serve, promise_object as tish_promise_object};\n");
             } else {
                 self.write("use tishlang_runtime::{fetch_promise as tish_fetch_promise, fetch_all_promise as tish_fetch_all_promise, http_serve as tish_http_serve};\n");
             }
@@ -2684,7 +2698,7 @@ impl Codegen {
                 "let fetch = Value::native(|args: &[Value]| tish_fetch_promise(args.to_vec()));",
             );
             self.writeln("let fetchAll = Value::native(|args: &[Value]| tish_fetch_all_promise(args.to_vec()));");
-            if self.is_async {
+            if self.is_async || self.has_feature("ws") {
                 self.writeln("let Promise = tish_promise_object();");
             }
             // `serve` supports two shapes:

package/crates/tish_compile/src/resolve.rs

@@ -59,6 +59,7 @@ const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("process", "tish:process"),
     ("ws", "tish:ws"),
     ("tty", "tish:tty"),
+    ("pty", "tish:pty"),
 ];
 
 /// Normalize built-in spec to canonical form. Handles the Node `node:` prefix
@@ -87,9 +88,10 @@ pub fn is_builtin_native_spec(spec: &str) -> bool {
             | "tish:process"
             | "tish:ws"
             | "tish:tty"
+            | "tish:pty"
     ) || matches!(
         spec,
-        "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty"
+        "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty" | "pty"
     )
 }
 

package/crates/tish_compile/src/types.rs

@@ -453,9 +453,13 @@ impl RustType {
                 )
             }
             RustType::Option(inner) => {
-                let inner_to_value = inner.to_value_expr("v");
+                // Box by REFERENCE so the source Option is NOT moved — it may be a local captured by
+                // an FnMut closure (a `serve()` handler, called per request) or used again after this
+                // conversion. Mirrors the Vec arm's `.iter()` (which likewise avoids moving). `(*v)`
+                // derefs the `&inner` the ref-match binds, so the inner's own clone/copy still applies.
+                let inner_to_value = inner.to_value_expr("(*v)");
                 format!(
-                    "match {} {{ Some(v) => {}, None => Value::Null }}",
+                    "match &({}) {{ Some(v) => {}, None => Value::Null }}",
                     native_expr, inner_to_value
                 )
             }

package/crates/tish_compile/tests/regr_serve_closure.rs

@@ -0,0 +1,22 @@
+//! tishlang/tish — a typed Option (`string?`) captured by a long-lived FnMut closure (a `serve()`
+//! handler, called per request) must not be MOVED when boxed to a Value for a `=== null` comparison.
+//! `to_value_expr(Option)` must match by REFERENCE (`match &(…)`), like the Vec arm's `.iter()`.
+use std::path::PathBuf;
+use tishlang_compile::compile_project_full;
+fn compile(rel: &str) -> String {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    compile_project_full(&path, path.parent(), &[], true).unwrap().0
+}
+#[test]
+fn option_boxing_borrows_not_moves() {
+    let rust = compile("tests/regression/serve_closure_captures_typed.tish");
+    assert!(
+        rust.contains("match &(sToken)"),
+        "Option→Value boxing must match by reference so the source isn't moved"
+    );
+    assert!(
+        !rust.contains("match sToken { Some(v)"),
+        "Option→Value boxing must not match by value (moves the closure-captured Option)"
+    );
+}

package/crates/tish_fmt/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_fmt"
-version = "2.37.3"
+version = "2.39.0"
 edition = "2021"
 description = "Opinionated formatter for Tish source (parse → pretty-print)"
 license-file = { workspace = true }

package/crates/tish_native/src/build.rs

@@ -17,6 +17,7 @@ const RUNTIME_CARGO_FEATURES: &[&str] = &[
     "regex",
     "ws",
     "tty",
+    "pty",
 ];
 
 /// Map CLI/compile features to flags passed to `tishlang_runtime` in the temp crate's Cargo.toml.

package/crates/tish_runtime/Cargo.toml

@@ -58,6 +58,9 @@ fs = ["promise", "dep:rand"]
 process = []
 # Interactive terminal I/O (issue #101): raw mode, key/resize events, size, alt screen.
 tty = ["dep:crossterm"]
+# Pseudoterminal hosting (issue #493): spawn a shell/program on a real PTY, read/write/resize/kill —
+# so an interactive terminal emulator on the other end of a socket behaves like a real TTY.
+pty = ["dep:portable-pty", "dep:lazy_static"]
 regex = ["tishlang_core/regex"]
 # WebSocket (JS-like API). Modular: import { WebSocket, Server } from 'tish:ws'.
 # Requires `send-values` because the WS server keeps an `Arc<dyn Fn + Send +
@@ -90,6 +93,8 @@ libc = { version = "0.2", optional = true }
 arc-swap = { version = "1", optional = true }
 # Interactive terminal I/O (feature = tty): cross-platform raw mode, key/resize events, size.
 crossterm = { version = "0.28", optional = true }
+# Pseudoterminal hosting (feature = pty): cross-platform openpty + shell spawn (same crate Dune uses).
+portable-pty = { version = "0.9", optional = true }
 # hyper backend (feature = http-hyper)
 hyper = { version = "1", default-features = false, features = ["server", "http1", "http2"], optional = true }
 hyper-util = { version = "0.1", features = ["server", "tokio"], optional = true }

package/crates/tish_runtime/src/http_hyper.rs

@@ -289,6 +289,9 @@ fn worker_thread(
                     // headers slower than this instead of pinning the worker task.
                     .header_read_timeout(std::time::Duration::from_secs(30))
                     .serve_connection(io, svc)
+                    // Required for `hyper::upgrade::on` to hand off the socket after a 101 — without
+                    // this, a WebSocket upgrade sends the 101 but the upgrade future never resolves.
+                    .with_upgrades()
                     .await
                 {
                     // Chatty connection errors (resets, client timeouts) are
@@ -314,6 +317,13 @@ async fn handle_request(
         return Ok(static_route_response(route));
     }
 
+    // WebSocket upgrade: complete the handshake here and hand the socket to `ws.rs` — the VM handler
+    // never sees it. The program picks the connection up via `wsAccept`. (Single-port WS, issue #495.)
+    #[cfg(feature = "ws")]
+    if is_ws_upgrade(&req) {
+        return Ok(handle_ws_upgrade(req));
+    }
+
     // Slow path: cross the mpsc to the VM thread.
     let (method, url, path, query, headers, body_bytes) = extract_request(req).await;
     // Lossy UTF-8 decode to match the tiny_http path (`http.rs`): a body with invalid UTF-8 becomes
@@ -455,6 +465,66 @@ fn simple_error_response(status: StatusCode, msg: &str) -> Response<Full<Bytes>>
         .unwrap()
 }
 
+/// A well-formed WebSocket upgrade handshake request (RFC 6455): `Upgrade: websocket`,
+/// `Connection: Upgrade`, and a `Sec-WebSocket-Key`.
+#[cfg(feature = "ws")]
+fn is_ws_upgrade(req: &Request<hyper::body::Incoming>) -> bool {
+    let h = req.headers();
+    let upgrade_ws = h
+        .get(hyper::header::UPGRADE)
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.eq_ignore_ascii_case("websocket"))
+        .unwrap_or(false);
+    let conn_upgrade = h
+        .get(hyper::header::CONNECTION)
+        .and_then(|v| v.to_str().ok())
+        .map(|s| s.to_ascii_lowercase().split(',').any(|p| p.trim() == "upgrade"))
+        .unwrap_or(false);
+    upgrade_ws && conn_upgrade && h.contains_key(hyper::header::SEC_WEBSOCKET_KEY)
+}
+
+/// Complete a WebSocket handshake on the HTTP port: reply `101` with the derived accept key, then
+/// (after the response flushes) take over the connection, wrap it as a server-role WebSocket, and
+/// register it with `ws.rs` so the program can pick it up via `wsAccept`.
+#[cfg(feature = "ws")]
+fn handle_ws_upgrade(mut req: Request<hyper::body::Incoming>) -> Response<Full<Bytes>> {
+    use tokio_tungstenite::tungstenite::handshake::derive_accept_key;
+    use tokio_tungstenite::tungstenite::protocol::Role;
+
+    let accept = match req.headers().get(hyper::header::SEC_WEBSOCKET_KEY) {
+        Some(k) => derive_accept_key(k.as_bytes()),
+        None => return simple_error_response(StatusCode::BAD_REQUEST, "missing Sec-WebSocket-Key"),
+    };
+
+    let on_upgrade = hyper::upgrade::on(&mut req);
+    tokio::spawn(async move {
+        match on_upgrade.await {
+            Ok(upgraded) => {
+                let io = TokioIo::new(upgraded);
+                let ws = tokio_tungstenite::WebSocketStream::from_raw_socket(io, Role::Server, None)
+                    .await;
+                let id = crate::ws::register_ws_stream(ws);
+                crate::ws::enqueue_upgraded_conn(id);
+            }
+            Err(e) => {
+                if std::env::var_os("TISH_HTTP_DEBUG").is_some() {
+                    eprintln!("[tish http/hyper] ws upgrade failed: {}", e);
+                }
+            }
+        }
+    });
+
+    Response::builder()
+        .status(StatusCode::SWITCHING_PROTOCOLS)
+        .header(hyper::header::UPGRADE, "websocket")
+        .header(hyper::header::CONNECTION, "Upgrade")
+        .header(hyper::header::SEC_WEBSOCKET_ACCEPT, accept)
+        .body(Full::new(Bytes::new()))
+        .unwrap_or_else(|_| {
+            simple_error_response(StatusCode::INTERNAL_SERVER_ERROR, "ws upgrade build failed")
+        })
+}
+
 /// Marker used by external callers (like the bench) to gate the backend
 /// choice. Returns true when `TISH_HTTP_BACKEND=hyper` is in the env.
 pub fn is_enabled_via_env() -> bool {

package/crates/tish_runtime/src/lib.rs

@@ -1727,10 +1727,15 @@ pub use tty::{
     tty_enter_alt_screen, tty_is_tty, tty_leave_alt_screen, tty_read, tty_read_line, tty_set_raw_mode, tty_size,
 };
 
+#[cfg(feature = "pty")]
+pub mod pty;
+#[cfg(feature = "pty")]
+pub use pty::{pty_kill, pty_pid, pty_read, pty_resize, pty_spawn, pty_write};
+
 #[cfg(feature = "ws")]
 pub use ws::{
     web_socket_client, web_socket_server_accept, web_socket_server_construct,
-    web_socket_server_listen, ws_broadcast_native, ws_send_native,
+    web_socket_server_listen, ws_broadcast_native, ws_send_native, ws_serve_accept,
 };
 
 #[cfg(feature = "http")]

package/crates/tish_runtime/src/pty.rs

@@ -0,0 +1,451 @@
+//! Pseudoterminal (PTY) module for Tish (`tish:pty`), behind the `pty` feature.
+//!
+//! Spawns a real OS pseudoterminal with a live shell/program attached — so an interactive
+//! terminal emulator (xterm.js) on the other end of a socket behaves like a real TTY:
+//! `isatty()` passes, so line-editing and curses apps (vim, top, ssh, tab-completion, and
+//! `SIGWINCH` resize) all work. This is what `tish:process` (run-to-completion capture) and
+//! `tish:tty` (this process's OWN controlling terminal) cannot do. Imported as
+//! `import { spawn, read, write, resize, kill } from 'tish:pty'`.
+//!
+//! Polling model (transport-agnostic — pairs with a `tish:ws` pump or an HTTP long-poll):
+//!   - `spawn({ program?, cwd?, cols?, rows?, env? }) -> id | null`
+//!   - `read(id, timeoutMs?) -> string | null`   (`""` = live but no output yet; `null` = EOF/unknown)
+//!   - `write(id, data) -> bool`
+//!   - `resize(id, cols, rows) -> bool`
+//!   - `kill(id) -> bool`
+//!   - `pid(id) -> number | null`
+//!
+//! A per-session reader thread fills a byte buffer that `read` drains at a UTF-8 boundary
+//! (incomplete trailing multibyte sequences are held for the next read — no mojibake). A global
+//! `Mutex<HashMap<id, PtySession>>` registry mirrors `ws.rs`'s `CONNS`. Errors surface as
+//! `null`/`false` rather than panicking.
+
+use std::collections::HashMap;
+use std::io::{Read, Write};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Condvar, Mutex};
+use std::time::Duration;
+
+use lazy_static::lazy_static;
+use portable_pty::{native_pty_system, Child, CommandBuilder, MasterPty, PtySize};
+use tishlang_core::Value;
+
+/// Output accumulated by the reader thread, drained by `read`.
+struct PtyBuf {
+    data: Vec<u8>,
+    eof: bool,
+}
+
+struct PtySession {
+    child: Mutex<Box<dyn Child + Send + Sync>>,
+    master: Mutex<Box<dyn MasterPty + Send>>,
+    writer: Mutex<Box<dyn Write + Send>>,
+    buf: Arc<(Mutex<PtyBuf>, Condvar)>,
+    pid: Option<u32>,
+}
+
+lazy_static! {
+    static ref SESSIONS: Mutex<HashMap<u64, PtySession>> = Mutex::new(HashMap::new());
+}
+
+static NEXT_ID: AtomicU64 = AtomicU64::new(1);
+
+// --- Value helpers (mirror the ws.rs idioms) ---
+
+fn arg_u64(args: &[Value], i: usize) -> Option<u64> {
+    match args.get(i) {
+        Some(Value::Number(n)) if n.is_finite() && *n >= 0.0 => Some(*n as u64),
+        _ => None,
+    }
+}
+
+fn arg_u16(args: &[Value], i: usize) -> Option<u16> {
+    match args.get(i) {
+        Some(Value::Number(n)) if n.is_finite() && *n >= 0.0 => Some(*n as u16),
+        _ => None,
+    }
+}
+
+/// Clone a field out of an options object (`{ key: value }`), or `None` if the arg isn't an object.
+fn obj_field(o: &Value, key: &str) -> Option<Value> {
+    if let Value::Object(m) = o {
+        return m.borrow().strings.get(key).cloned();
+    }
+    None
+}
+
+fn obj_str(o: &Value, key: &str) -> Option<String> {
+    match obj_field(o, key) {
+        Some(Value::String(s)) => Some(s.to_string()),
+        Some(Value::Null) | None => None,
+        Some(v) => Some(v.to_display_string()),
+    }
+}
+
+fn obj_num(o: &Value, key: &str) -> Option<f64> {
+    match obj_field(o, key) {
+        Some(Value::Number(n)) if n.is_finite() => Some(n),
+        _ => None,
+    }
+}
+
+/// `spawn({ program?, cwd?, cols?, rows?, env? })` → a stable id for read/write/resize/kill,
+/// or `null` on failure.
+pub fn pty_spawn(args: &[Value]) -> Value {
+    let null = Value::Null;
+    let opts = args.first().unwrap_or(&null);
+
+    let cols = obj_num(opts, "cols").filter(|n| *n > 0.0).unwrap_or(80.0) as u16;
+    let rows = obj_num(opts, "rows").filter(|n| *n > 0.0).unwrap_or(24.0) as u16;
+
+    let pty_system = native_pty_system();
+    let pair = match pty_system.openpty(PtySize {
+        rows,
+        cols,
+        pixel_width: 0,
+        pixel_height: 0,
+    }) {
+        Ok(p) => p,
+        Err(_) => return Value::Null,
+    };
+
+    let mut cmd = if let Some(prog) = obj_str(opts, "program") {
+        CommandBuilder::new(prog)
+    } else if cfg!(windows) {
+        CommandBuilder::new("powershell.exe")
+    } else {
+        let shell = std::env::var("SHELL").unwrap_or_else(|_| "/bin/bash".to_string());
+        CommandBuilder::new(shell)
+    };
+
+    if let Some(cwd) = obj_str(opts, "cwd") {
+        cmd.cwd(cwd);
+    }
+
+    // Caller-supplied env overrides inherit the parent environment (portable_pty default); we
+    // only add. Ensure TERM is set so curses apps negotiate correctly unless overridden.
+    let mut has_term = false;
+    if let Some(Value::Object(em)) = obj_field(opts, "env") {
+        for (k, v) in em.borrow().strings.iter() {
+            if k.as_ref() == "TERM" {
+                has_term = true;
+            }
+            cmd.env(k.as_ref(), v.to_display_string());
+        }
+    }
+    if !has_term {
+        cmd.env("TERM", "xterm-256color");
+    }
+
+    let child = match pair.slave.spawn_command(cmd) {
+        Ok(c) => c,
+        Err(_) => return Value::Null,
+    };
+    let reader = match pair.master.try_clone_reader() {
+        Ok(r) => r,
+        Err(_) => return Value::Null,
+    };
+    let writer = match pair.master.take_writer() {
+        Ok(w) => w,
+        Err(_) => return Value::Null,
+    };
+    let pid = child.process_id();
+
+    let buf = Arc::new((
+        Mutex::new(PtyBuf {
+            data: Vec::new(),
+            eof: false,
+        }),
+        Condvar::new(),
+    ));
+
+    // Reader thread: block on the master, append bytes, wake any waiting `read`. On EOF/error,
+    // mark eof so `read` can return null once the buffer drains.
+    {
+        let buf = buf.clone();
+        let mut reader = reader;
+        std::thread::spawn(move || {
+            let mut tmp = [0u8; 8192];
+            loop {
+                match reader.read(&mut tmp) {
+                    Ok(0) => {
+                        let (lock, cv) = &*buf;
+                        if let Ok(mut b) = lock.lock() {
+                            b.eof = true;
+                        }
+                        cv.notify_all();
+                        break;
+                    }
+                    Ok(n) => {
+                        let (lock, cv) = &*buf;
+                        if let Ok(mut b) = lock.lock() {
+                            b.data.extend_from_slice(&tmp[..n]);
+                        }
+                        cv.notify_all();
+                    }
+                    Err(_) => {
+                        let (lock, cv) = &*buf;
+                        if let Ok(mut b) = lock.lock() {
+                            b.eof = true;
+                        }
+                        cv.notify_all();
+                        break;
+                    }
+                }
+            }
+        });
+    }
+
+    let id = NEXT_ID.fetch_add(1, Ordering::SeqCst);
+    let session = PtySession {
+        child: Mutex::new(child),
+        master: Mutex::new(pair.master),
+        writer: Mutex::new(writer),
+        buf,
+        pid,
+    };
+    match SESSIONS.lock() {
+        Ok(mut g) => {
+            g.insert(id, session);
+        }
+        Err(_) => return Value::Null,
+    }
+    Value::Number(id as f64)
+}
+
+/// `read(id, timeoutMs?)` → available output as a string (possibly `""` if none arrived within the
+/// timeout), or `null` at EOF / for an unknown id. Drains only a valid UTF-8 prefix, holding any
+/// incomplete trailing multibyte bytes for the next call.
+pub fn pty_read(args: &[Value]) -> Value {
+    let id = match arg_u64(args, 0) {
+        Some(x) => x,
+        None => return Value::Null,
+    };
+    let timeout_ms = match args.get(1) {
+        Some(Value::Number(n)) if n.is_finite() && *n >= 0.0 => *n as u64,
+        _ => 0,
+    };
+
+    let buf = {
+        let g = match SESSIONS.lock() {
+            Ok(g) => g,
+            Err(_) => return Value::Null,
+        };
+        match g.get(&id) {
+            Some(s) => s.buf.clone(),
+            None => return Value::Null,
+        }
+    };
+
+    let (lock, cv) = &*buf;
+    let mut b = match lock.lock() {
+        Ok(b) => b,
+        Err(_) => return Value::Null,
+    };
+    if b.data.is_empty() && !b.eof && timeout_ms > 0 {
+        let res = cv.wait_timeout_while(b, Duration::from_millis(timeout_ms), |b| {
+            b.data.is_empty() && !b.eof
+        });
+        b = match res {
+            Ok((g, _)) => g,
+            Err(e) => e.into_inner().0,
+        };
+    }
+
+    if b.data.is_empty() {
+        if b.eof {
+            return Value::Null;
+        }
+        return Value::String("".into());
+    }
+
+    // Drain up to the last complete UTF-8 code point; keep the incomplete tail for next time.
+    let valid = match std::str::from_utf8(&b.data) {
+        Ok(_) => b.data.len(),
+        Err(e) => e.valid_up_to(),
+    };
+    if valid == 0 {
+        // A leading incomplete multibyte sequence. If the stream is done, flush it lossily so
+        // nothing is stranded; otherwise wait for the rest.
+        if b.eof {
+            let s = String::from_utf8_lossy(&b.data).into_owned();
+            b.data.clear();
+            return Value::String(s.into());
+        }
+        return Value::String("".into());
+    }
+    let out: Vec<u8> = b.data.drain(..valid).collect();
+    let s = String::from_utf8(out).unwrap_or_default();
+    Value::String(s.into())
+}
+
+/// `write(id, data)` → feed input bytes to the PTY. Returns whether the write succeeded.
+pub fn pty_write(args: &[Value]) -> Value {
+    let id = match arg_u64(args, 0) {
+        Some(x) => x,
+        None => return Value::Bool(false),
+    };
+    let data = match args.get(1) {
+        Some(Value::String(s)) => s.to_string(),
+        Some(v) => v.to_display_string(),
+        None => return Value::Bool(false),
+    };
+    let g = match SESSIONS.lock() {
+        Ok(g) => g,
+        Err(_) => return Value::Bool(false),
+    };
+    let s = match g.get(&id) {
+        Some(s) => s,
+        None => return Value::Bool(false),
+    };
+    let mut w = match s.writer.lock() {
+        Ok(w) => w,
+        Err(_) => return Value::Bool(false),
+    };
+    match w.write_all(data.as_bytes()).and_then(|_| w.flush()) {
+        Ok(_) => Value::Bool(true),
+        Err(_) => Value::Bool(false),
+    }
+}
+
+/// `resize(id, cols, rows)` → tell the PTY its new window size (fires `SIGWINCH` in the child).
+pub fn pty_resize(args: &[Value]) -> Value {
+    let id = match arg_u64(args, 0) {
+        Some(x) => x,
+        None => return Value::Bool(false),
+    };
+    let cols = match arg_u16(args, 1) {
+        Some(c) if c > 0 => c,
+        _ => return Value::Bool(false),
+    };
+    let rows = match arg_u16(args, 2) {
+        Some(r) if r > 0 => r,
+        _ => return Value::Bool(false),
+    };
+    let g = match SESSIONS.lock() {
+        Ok(g) => g,
+        Err(_) => return Value::Bool(false),
+    };
+    let s = match g.get(&id) {
+        Some(s) => s,
+        None => return Value::Bool(false),
+    };
+    let m = match s.master.lock() {
+        Ok(m) => m,
+        Err(_) => return Value::Bool(false),
+    };
+    match m.resize(PtySize {
+        rows,
+        cols,
+        pixel_width: 0,
+        pixel_height: 0,
+    }) {
+        Ok(_) => Value::Bool(true),
+        Err(_) => Value::Bool(false),
+    }
+}
+
+/// `kill(id)` → terminate the child and drop the session. Returns whether the id was live.
+pub fn pty_kill(args: &[Value]) -> Value {
+    let id = match arg_u64(args, 0) {
+        Some(x) => x,
+        None => return Value::Bool(false),
+    };
+    let sess = {
+        let mut g = match SESSIONS.lock() {
+            Ok(g) => g,
+            Err(_) => return Value::Bool(false),
+        };
+        g.remove(&id)
+    };
+    match sess {
+        Some(s) => {
+            if let Ok(mut c) = s.child.lock() {
+                let _ = c.kill();
+                let _ = c.wait();
+            }
+            Value::Bool(true)
+        }
+        None => Value::Bool(false),
+    }
+}
+
+/// `pid(id)` → the child process id, or `null` for an unknown id / no pid.
+pub fn pty_pid(args: &[Value]) -> Value {
+    let id = match arg_u64(args, 0) {
+        Some(x) => x,
+        None => return Value::Null,
+    };
+    let g = match SESSIONS.lock() {
+        Ok(g) => g,
+        Err(_) => return Value::Null,
+    };
+    match g.get(&id).and_then(|s| s.pid) {
+        Some(p) => Value::Number(p as f64),
+        None => Value::Null,
+    }
+}
+
+#[cfg(all(test, unix))]
+mod tests {
+    use super::*;
+
+    /// Proves a LIVE interactive PTY (persistent shell on a pseudoterminal), not run-to-completion:
+    /// spawn a shell, write a command, and read its executed output back.
+    #[test]
+    fn spawn_write_read_roundtrip() {
+        let id = match pty_spawn(&[]) {
+            Value::Number(n) => n,
+            other => panic!("spawn failed: {:?}", other),
+        };
+        // Drain the shell's startup banner/prompt.
+        let _ = pty_read(&[Value::Number(id), Value::Number(300.0)]);
+        assert!(matches!(
+            pty_write(&[Value::Number(id), Value::String("echo pty_ok_123\n".into())]),
+            Value::Bool(true)
+        ));
+        let mut acc = String::new();
+        for _ in 0..100 {
+            match pty_read(&[Value::Number(id), Value::Number(50.0)]) {
+                Value::String(s) => acc.push_str(&s),
+                Value::Null => break,
+                _ => {}
+            }
+            if acc.contains("pty_ok_123") {
+                break;
+            }
+        }
+        let _ = pty_kill(&[Value::Number(id)]);
+        assert!(acc.contains("pty_ok_123"), "pty output missing echo: {:?}", acc);
+    }
+
+    #[test]
+    fn resize_live_session_ok() {
+        let id = match pty_spawn(&[]) {
+            Value::Number(n) => n,
+            other => panic!("spawn failed: {:?}", other),
+        };
+        assert!(matches!(
+            pty_resize(&[Value::Number(id), Value::Number(120.0), Value::Number(40.0)]),
+            Value::Bool(true)
+        ));
+        assert!(matches!(pty_pid(&[Value::Number(id)]), Value::Number(_)));
+        assert!(matches!(pty_kill(&[Value::Number(id)]), Value::Bool(true)));
+    }
+
+    #[test]
+    fn unknown_id_surfaces_null_or_false() {
+        let bad = 9_999_999.0;
+        assert!(matches!(pty_read(&[Value::Number(bad)]), Value::Null));
+        assert!(matches!(
+            pty_write(&[Value::Number(bad), Value::String("x".into())]),
+            Value::Bool(false)
+        ));
+        assert!(matches!(
+            pty_resize(&[Value::Number(bad), Value::Number(80.0), Value::Number(24.0)]),
+            Value::Bool(false)
+        ));
+        assert!(matches!(pty_kill(&[Value::Number(bad)]), Value::Bool(false)));
+        assert!(matches!(pty_pid(&[Value::Number(bad)]), Value::Null));
+    }
+}

package/crates/tish_runtime/src/ws.rs

@@ -82,6 +82,83 @@ fn unregister(id: u32) {
     CONNS.lock().unwrap().remove(&id);
 }
 
+/// Bridge an already-handshaked WebSocket stream into the `CONNS` registry — spawning the read and
+/// write pump tasks — and return its connection id. Shared by the `tish:ws` server-accept loop and
+/// the `serve()` HTTP→WS upgrade path (see `http_hyper.rs`). Must be called inside a tokio runtime.
+pub(crate) fn register_ws_stream<S>(ws_stream: tokio_tungstenite::WebSocketStream<S>) -> u32
+where
+    S: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin + Send + 'static,
+{
+    let (send_tx, mut send_rx) = tokio_mpsc::unbounded_channel::<String>();
+    let (recv_tx, recv_rx) = mpsc::sync_channel::<String>(64);
+    let id = register(send_tx, recv_rx);
+    let recv_tx_task = Arc::new(recv_tx);
+    let (mut write, mut read) = ws_stream.split();
+    tokio::spawn(async move {
+        while let Some(Ok(msg)) = read.next().await {
+            if let tokio_tungstenite::tungstenite::Message::Text(t) = msg {
+                let _ = recv_tx_task.send(t.to_string());
+            }
+        }
+        unregister(id);
+    });
+    tokio::spawn(async move {
+        while let Some(text) = send_rx.recv().await {
+            let _ = write
+                .send(tokio_tungstenite::tungstenite::Message::Text(text.into()))
+                .await;
+        }
+    });
+    id
+}
+
+lazy_static! {
+    /// Connections upgraded from HTTP by `serve()` (http_hyper), waiting for the program to pick them
+    /// up via `wsAccept`. Per-process: an upgraded socket stays in whatever SO_REUSEPORT worker
+    /// accepted it, so each worker drains its own queue and there's no cross-process routing problem.
+    static ref UPGRADE_QUEUE: (Mutex<std::collections::VecDeque<u32>>, std::sync::Condvar) =
+        (Mutex::new(std::collections::VecDeque::new()), std::sync::Condvar::new());
+}
+
+/// Enqueue a `serve()`-upgraded connection id for `wsAccept` to hand to the program.
+pub(crate) fn enqueue_upgraded_conn(id: u32) {
+    let (m, cv) = &*UPGRADE_QUEUE;
+    if let Ok(mut q) = m.lock() {
+        q.push_back(id);
+    }
+    cv.notify_all();
+}
+
+/// `wsAccept(timeoutMs?)` — return the next connection upgraded on the HTTP server's port (see the
+/// `serve()` HTTP→WS upgrade path) as a normal `tish:ws` connection object, or `Null` if none arrives
+/// within the timeout (default 0 = non-blocking).
+pub fn ws_serve_accept(args: &[Value]) -> Value {
+    let timeout_ms = match args.first() {
+        Some(Value::Number(n)) if n.is_finite() && *n >= 0.0 => (*n as u64).min(3_600_000),
+        _ => 0,
+    };
+    let (m, cv) = &*UPGRADE_QUEUE;
+    let mut q = match m.lock() {
+        Ok(q) => q,
+        Err(_) => return Value::Null,
+    };
+    if q.is_empty() && timeout_ms > 0 {
+        let res = cv.wait_timeout_while(
+            q,
+            std::time::Duration::from_millis(timeout_ms),
+            |q| q.is_empty(),
+        );
+        q = match res {
+            Ok((g, _)) => g,
+            Err(e) => e.into_inner().0,
+        };
+    }
+    match q.pop_front() {
+        Some(id) => conn_object(id),
+        None => Value::Null,
+    }
+}
+
 /// Max simultaneous WebSocket connections. Each accepted conn registers in `CONNS` and
 /// spawns tasks + channels, freed only on close — unbounded accepts exhaust tasks/memory.
 /// Override with `TISH_WS_MAX_CONNS`; default 10000.
@@ -399,27 +476,7 @@ pub fn web_socket_server_listen(args: &[Value]) -> Value {
                         continue;
                     }
                 };
-                let (send_tx, mut send_rx) = tokio_mpsc::unbounded_channel::<String>();
-                let (recv_tx, recv_rx) = mpsc::sync_channel::<String>(64);
-                let id = register(send_tx, recv_rx);
-                let recv_tx = Arc::new(recv_tx);
-                let recv_tx_task = Arc::clone(&recv_tx);
-                let (mut write, mut read) = ws_stream.split();
-                tokio::spawn(async move {
-                    while let Some(Ok(msg)) = read.next().await {
-                        if let tokio_tungstenite::tungstenite::Message::Text(t) = msg {
-                            let _ = recv_tx_task.send(t.to_string());
-                        }
-                    }
-                    unregister(id);
-                });
-                tokio::spawn(async move {
-                    while let Some(text) = send_rx.recv().await {
-                        let _ = write
-                            .send(tokio_tungstenite::tungstenite::Message::Text(text.into()))
-                            .await;
-                    }
-                });
+                let id = register_ws_stream(ws_stream);
                 if conn_tx.send(id).is_err() {
                     break;
                 }
@@ -578,6 +635,22 @@ mod tests {
     use std::thread;
     use std::time::Duration;
 
+    /// The serve() HTTP→WS upgrade queue: `wsAccept` hands out enqueued conns FIFO and returns Null
+    /// when empty. (End-to-end upgrade over a live hyper port is covered by the native smoke test.)
+    #[test]
+    fn upgrade_queue_drains_then_empty() {
+        assert!(matches!(ws_serve_accept(&[Value::Number(0.0)]), Value::Null));
+        enqueue_upgraded_conn(4242);
+        match ws_serve_accept(&[Value::Number(0.0)]) {
+            Value::Object(o) => {
+                let b = o.borrow();
+                assert!(matches!(b.strings.get("_id"), Some(Value::Number(n)) if *n == 4242.0));
+            }
+            other => panic!("expected a conn object, got {:?}", other),
+        }
+        assert!(matches!(ws_serve_accept(&[Value::Number(0.0)]), Value::Null));
+    }
+
     #[test]
     fn ws_echo_roundtrip() {
         let port: u16 = 18_742;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-format",
-  "version": "2.37.3",
+  "version": "2.39.0",
   "description": "Tish code formatter",
   "license": "PIF",
   "repository": {