@tishlang/tish-format 3.10.4 → 3.10.11

package/crates/tish_runtime/src/promise_io.rs

@@ -15,20 +15,43 @@ pub struct StringResultPromise {
     pub(crate) rx: Mutex<Option<oneshot::Receiver<Result<String, String>>>>,
 }
 
+impl StringResultPromise {
+    fn convert(
+        r: Result<Result<String, String>, oneshot::error::RecvError>,
+    ) -> std::result::Result<Value, Value> {
+        match r {
+            Ok(Ok(s)) => Ok(Value::String(s.into())),
+            Ok(Err(e)) => Err(error_value(e)),
+            Err(_) => Err(Value::String("Promise dropped".into())),
+        }
+    }
+}
+
 impl TishPromise for StringResultPromise {
     fn block_until_settled(&self) -> std::result::Result<Value, Value> {
         let rx = self.rx.lock().unwrap().take();
         if let Some(rx) = rx {
-            let result = crate::http::block_on_http(rx);
-            match result {
-                Ok(Ok(s)) => Ok(Value::String(s.into())),
-                Ok(Err(e)) => Err(error_value(e)),
-                Err(_) => Err(Value::String("Promise dropped".into())),
-            }
+            Self::convert(crate::http::block_on_http(rx))
         } else {
             Err(Value::String("Promise already consumed".into()))
         }
     }
+
+    /// Await the oneshot on the shared subscriber runtime instead of parking a
+    /// blocking thread (plus a per-call tokio runtime) per raced input (issue #702).
+    fn subscribe(
+        self: Arc<Self>,
+        on_settled: Box<dyn FnOnce(std::result::Result<Value, Value>) + Send>,
+    ) {
+        match self.rx.lock().unwrap().take() {
+            Some(rx) => {
+                crate::http::subscriber_runtime().spawn(async move {
+                    on_settled(Self::convert(rx.await));
+                });
+            }
+            None => on_settled(Err(Value::String("Promise already consumed".into()))),
+        }
+    }
 }
 
 pub fn string_result_promise(rx: oneshot::Receiver<Result<String, String>>) -> Value {

package/crates/tish_runtime/src/pty.rs

@@ -15,37 +15,100 @@
 //!   - `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
+//! A per-session reader thread fills a bounded byte buffer that `read` drains at a UTF-8
+//! boundary (see `stream_buf.rs` for the cap/backpressure and invalid-byte semantics). A global
 //! `Mutex<HashMap<id, PtySession>>` registry mirrors `ws.rs`'s `CONNS`. Errors surface as
 //! `null`/`false` rather than panicking.
+//!
+//! Session lifecycle mirrors `process_spawn.rs`: an entry lives until `kill(id)` or until it is
+//! reaped — child exited AND the buffer fully drained — by an opportunistic sweep on each
+//! `spawn` (plus a check when `read` returns `null` at EOF). The pid is tombstoned (bounded) so
+//! a late `pid(id)` still answers, and `kill(id)` on a reaped id still reports `true` once.
 
-use std::collections::HashMap;
-use std::io::{Read, Write};
+use std::collections::{BTreeMap, HashMap};
+use std::io::Write;
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::{Arc, Condvar, Mutex};
-use std::time::Duration;
+use std::sync::Mutex;
 
 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,
-}
+use crate::stream_buf::{drain_stream, is_drained, new_buf, retire_buf, spawn_reader, SharedBuf};
 
 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)>,
+    buf: SharedBuf,
     pid: Option<u32>,
 }
 
 lazy_static! {
     static ref SESSIONS: Mutex<HashMap<u64, PtySession>> = Mutex::new(HashMap::new());
+    /// Pids of reaped sessions, so a late `pid(id)` still answers (bounded: ids are
+    /// monotonic, so evicting the smallest key evicts the oldest record).
+    static ref TOMBSTONES: Mutex<BTreeMap<u64, Option<u32>>> = Mutex::new(BTreeMap::new());
+}
+
+const MAX_TOMBSTONES: usize = 1024;
+
+fn remember_tombstone(id: u64, pid: Option<u32>) {
+    if let Ok(mut m) = TOMBSTONES.lock() {
+        m.insert(id, pid);
+        while m.len() > MAX_TOMBSTONES {
+            m.pop_first();
+        }
+    }
+}
+
+/// Reap every session whose child has exited AND whose buffer is fully drained
+/// (`try_wait` also reaps the OS zombie).
+fn sweep_sessions() {
+    let mut reaped: Vec<(u64, Option<u32>)> = Vec::new();
+    {
+        let mut g = match SESSIONS.lock() {
+            Ok(g) => g,
+            Err(_) => return,
+        };
+        g.retain(|id, s| {
+            let exited = match s.child.lock() {
+                Ok(mut c) => c.try_wait().ok().flatten().is_some(),
+                Err(_) => false,
+            };
+            if exited && is_drained(&s.buf) {
+                reaped.push((*id, s.pid));
+                false
+            } else {
+                true
+            }
+        });
+    }
+    for (id, pid) in reaped {
+        remember_tombstone(id, pid);
+    }
+}
+
+/// Reap one session if (and only if) its child has exited and its buffer is drained.
+fn try_reap(id: u64) {
+    let pid = {
+        let mut g = match SESSIONS.lock() {
+            Ok(g) => g,
+            Err(_) => return,
+        };
+        let Some(s) = g.get(&id) else { return };
+        let exited = match s.child.lock() {
+            Ok(mut c) => c.try_wait().ok().flatten().is_some(),
+            Err(_) => false,
+        };
+        if !(exited && is_drained(&s.buf)) {
+            return;
+        }
+        let pid = s.pid;
+        g.remove(&id);
+        pid
+    };
+    remember_tombstone(id, pid);
 }
 
 static NEXT_ID: AtomicU64 = AtomicU64::new(1);
@@ -92,6 +155,10 @@ fn obj_num(o: &Value, key: &str) -> Option<f64> {
 /// `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 {
+    // Opportunistic reap of exited-and-drained sessions (a shell the user `exit`ed and whose
+    // output was fully read), so un-killed self-exiting ptys cannot accumulate without bound.
+    sweep_sessions();
+
     let null = Value::Null;
     let opts = args.first().unwrap_or(&null);
 
@@ -151,50 +218,10 @@ pub fn pty_spawn(args: &[Value]) -> Value {
     };
     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;
-                    }
-                }
-            }
-        });
-    }
+    // Reader thread: block on the master, append bytes (bounded, see stream_buf.rs), wake any
+    // waiting `read`. On EOF/error, mark eof so `read` can return null once the buffer drains.
+    let buf = new_buf();
+    spawn_reader(reader, buf.clone());
 
     let id = NEXT_ID.fetch_add(1, Ordering::SeqCst);
     let session = PtySession {
@@ -214,8 +241,8 @@ pub fn pty_spawn(args: &[Value]) -> Value {
 }
 
 /// `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.
+/// timeout), or `null` at EOF / for an unknown id. Drains only complete UTF-8, holding an
+/// incomplete trailing multibyte sequence for the next call (invalid bytes become U+FFFD).
 pub fn pty_read(args: &[Value]) -> Value {
     let id = match arg_u64(args, 0) {
         Some(x) => x,
@@ -237,46 +264,13 @@ pub fn pty_read(args: &[Value]) -> Value {
         }
     };
 
-    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 = drain_stream(&buf, timeout_ms);
+    if matches!(out, Value::Null) {
+        // EOF fully drained: if the child has also exited, the session is fully consumed —
+        // reap it (a pid tombstone keeps `pid(id)` answering).
+        try_reap(id);
     }
-    let out: Vec<u8> = b.data.drain(..valid).collect();
-    let s = String::from_utf8(out).unwrap_or_default();
-    Value::String(s.into())
+    out
 }
 
 /// `write(id, data)` → feed input bytes to the PTY. Returns whether the write succeeded.
@@ -345,7 +339,9 @@ pub fn pty_resize(args: &[Value]) -> Value {
     }
 }
 
-/// `kill(id)` → terminate the child and drop the session. Returns whether the id was live.
+/// `kill(id)` → terminate the child and drop the session. Returns whether the id was live
+/// (including a reaped id, whose child already exited — reported `true` once, like before
+/// reaping existed).
 pub fn pty_kill(args: &[Value]) -> Value {
     let id = match arg_u64(args, 0) {
         Some(x) => x,
@@ -364,25 +360,46 @@ pub fn pty_kill(args: &[Value]) -> Value {
                 let _ = c.kill();
                 let _ = c.wait();
             }
+            // Wake a reader parked at the buffer cap so its thread exits (a read-blocked
+            // reader exits on its own once the killed child's pty closes).
+            retire_buf(&s.buf);
             Value::Bool(true)
         }
-        None => Value::Bool(false),
+        None => {
+            // A reaped session was live from the caller's perspective; consume its tombstone.
+            match TOMBSTONES.lock() {
+                Ok(mut t) => Value::Bool(t.remove(&id).is_some()),
+                Err(_) => Value::Bool(false),
+            }
+        }
     }
 }
 
-/// `pid(id)` → the child process id, or `null` for an unknown id / no pid.
+/// `pid(id)` → the child process id, or `null` for an unknown id / no pid. Still answers after
+/// the session was reaped (the pid is tombstoned).
 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,
+    {
+        let g = match SESSIONS.lock() {
+            Ok(g) => g,
+            Err(_) => return Value::Null,
+        };
+        if let Some(s) = g.get(&id) {
+            return match s.pid {
+                Some(p) => Value::Number(p as f64),
+                None => Value::Null,
+            };
+        }
+    }
+    match TOMBSTONES.lock() {
+        Ok(t) => match t.get(&id).copied().flatten() {
+            Some(p) => Value::Number(p as f64),
+            None => Value::Null,
+        },
+        Err(_) => Value::Null,
     }
 }
 
@@ -433,6 +450,43 @@ mod tests {
         assert!(matches!(pty_kill(&[Value::Number(id)]), Value::Bool(true)));
     }
 
+    #[test]
+    fn self_exited_session_is_reaped_after_drain_with_pid_tombstoned() {
+        // `true` exits immediately on its own — the un-killed lifecycle that used to strand
+        // the session (2 fds + an unreaped child) forever.
+        let mut m = tishlang_core::ObjectMap::default();
+        m.insert(
+            std::sync::Arc::from("program"),
+            Value::String("true".into()),
+        );
+        let id = match pty_spawn(&[Value::object(m)]) {
+            Value::Number(n) => n,
+            other => panic!("spawn failed: {:?}", other),
+        };
+        // Drain to EOF; the null read reaps the exited session.
+        let mut saw_eof = false;
+        for _ in 0..200 {
+            if matches!(
+                pty_read(&[Value::Number(id), Value::Number(50.0)]),
+                Value::Null
+            ) {
+                saw_eof = true;
+                break;
+            }
+        }
+        assert!(saw_eof, "pty never reached EOF");
+        assert!(
+            !SESSIONS.lock().unwrap().contains_key(&(id as u64)),
+            "session not reaped after exit + full drain"
+        );
+        // The pid still answers from the tombstone; kill reports the id as (once) live;
+        // reads keep returning null (the read-to-EOF-then-read-again contract).
+        assert!(matches!(pty_read(&[Value::Number(id)]), Value::Null));
+        assert!(matches!(pty_pid(&[Value::Number(id)]), Value::Number(_)));
+        assert!(matches!(pty_kill(&[Value::Number(id)]), Value::Bool(true)));
+        assert!(matches!(pty_kill(&[Value::Number(id)]), Value::Bool(false)));
+    }
+
     #[test]
     fn unknown_id_surfaces_null_or_false() {
         let bad = 9_999_999.0;