@tishlang/tish-lsp 3.0.0 → 3.2.2

package/crates/tish_runtime/src/crypto.rs

@@ -0,0 +1,127 @@
+//! Cryptographic hashing + secure random for Tish (`tish:crypto`), behind the `crypto` feature.
+//!
+//!   import { sha256, sha256Hex, randomBytes } from 'tish:crypto'
+//!
+//!   - `sha256(bytesOrString) -> number[]`   (the 32-byte digest as a byte array)
+//!   - `sha256Hex(bytesOrString) -> string`  (64 lowercase hex chars)
+//!   - `randomBytes(n) -> number[]`          (n cryptographically-secure random bytes; n clamped to 1 MiB)
+//!
+//! Bytes are the `tish:fs` / `tish:encoding` representation (Numbers 0-255). A string argument is
+//! hashed as its UTF-8 bytes. For PKCE: `base64UrlEncode(sha256(verifier))` (see `tish:encoding`).
+
+use sha2::{Digest, Sha256};
+use tishlang_core::{Value, VmRef};
+
+/// Coerce arg 0 to bytes: a byte array (Numbers 0-255) or a string's UTF-8 bytes.
+fn arg_bytes(args: &[Value]) -> Option<Vec<u8>> {
+    match args.first() {
+        Some(Value::Array(a)) => Some(
+            a.borrow()
+                .iter()
+                .map(|v| if let Value::Number(n) = v { *n as u8 } else { 0 })
+                .collect(),
+        ),
+        Some(Value::String(s)) => Some(s.as_bytes().to_vec()),
+        _ => None,
+    }
+}
+
+fn bytes_to_value(bytes: &[u8]) -> Value {
+    Value::Array(VmRef::new(
+        bytes.iter().map(|b| Value::Number(*b as f64)).collect(),
+    ))
+}
+
+fn digest_of(args: &[Value]) -> Option<[u8; 32]> {
+    let b = arg_bytes(args)?;
+    let mut h = Sha256::new();
+    h.update(&b);
+    Some(h.finalize().into())
+}
+
+pub fn sha256(args: &[Value]) -> Value {
+    match digest_of(args) {
+        Some(d) => bytes_to_value(&d),
+        None => Value::Null,
+    }
+}
+
+pub fn sha256_hex(args: &[Value]) -> Value {
+    match digest_of(args) {
+        Some(d) => {
+            let mut s = String::with_capacity(64);
+            for byte in d.iter() {
+                s.push_str(&format!("{byte:02x}"));
+            }
+            Value::String(s.into())
+        }
+        None => Value::Null,
+    }
+}
+
+pub fn random_bytes(args: &[Value]) -> Value {
+    let n = match args.first() {
+        Some(Value::Number(x)) if x.is_finite() && *x >= 0.0 => (*x as usize).min(1_048_576),
+        _ => return Value::Null,
+    };
+    // rand::random draws from the thread CSPRNG (ChaCha, OS-seeded) — same source fs_ext uses.
+    let bytes: Vec<u8> = (0..n).map(|_| rand::random::<u8>()).collect();
+    bytes_to_value(&bytes)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn to_bytes(v: Value) -> Vec<u8> {
+        let Value::Array(a) = v else { panic!("not an array") };
+        let g = a.borrow();
+        let out: Vec<u8> = g
+            .iter()
+            .map(|x| if let Value::Number(n) = x { *n as u8 } else { 0 })
+            .collect();
+        out
+    }
+
+    #[test]
+    fn sha256_hex_known_vector() {
+        // The canonical NIST vector: SHA-256("abc").
+        let Value::String(s) = sha256_hex(&[Value::String("abc".into())]) else { panic!() };
+        assert_eq!(
+            s.to_string(),
+            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+        );
+    }
+
+    #[test]
+    fn sha256_returns_32_bytes_matching_hex() {
+        let bytes = to_bytes(sha256(&[Value::String("abc".into())]));
+        assert_eq!(bytes.len(), 32);
+        assert_eq!(bytes[0], 0xba);
+        assert_eq!(bytes[31], 0xad);
+    }
+
+    #[test]
+    fn sha256_accepts_byte_array() {
+        // "abc" as a byte array must hash identically to the string.
+        let arr = Value::Array(VmRef::new(vec![
+            Value::Number(97.0),
+            Value::Number(98.0),
+            Value::Number(99.0),
+        ]));
+        let Value::String(s) = sha256_hex(&[arr]) else { panic!() };
+        assert_eq!(
+            s.to_string(),
+            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+        );
+    }
+
+    #[test]
+    fn random_bytes_length_and_variance() {
+        assert_eq!(to_bytes(random_bytes(&[Value::Number(0.0)])).len(), 0);
+        let a = to_bytes(random_bytes(&[Value::Number(32.0)]));
+        let b = to_bytes(random_bytes(&[Value::Number(32.0)]));
+        assert_eq!(a.len(), 32);
+        assert_ne!(a, b, "two 32-byte draws must (almost surely) differ");
+    }
+}

package/crates/tish_runtime/src/encoding.rs

@@ -0,0 +1,157 @@
+//! Base64 encoding for Tish (`tish:encoding`), behind the `encoding` feature.
+//!
+//!   import { base64Encode, base64Decode, base64UrlEncode, base64UrlDecode } from 'tish:encoding'
+//!
+//!   - `base64Encode(bytesOrString) -> string`       (standard alphabet, padded)
+//!   - `base64Decode(string) -> number[] | null`     (bytes 0-255; null on invalid input)
+//!   - `base64UrlEncode(bytesOrString) -> string`    (URL-safe alphabet, NO padding — PKCE etc.)
+//!   - `base64UrlDecode(string) -> number[] | null`
+//!
+//! Bytes are the same representation `tish:fs` uses: an array of Numbers 0-255 (`readFileBytes`
+//! returns this; `writeFile` accepts it). A string argument is encoded as its UTF-8 bytes, so
+//! `base64Encode("hi")` works without a byte round-trip.
+
+use base64::Engine;
+use tishlang_core::{Value, VmRef};
+
+/// Coerce arg 0 to bytes: a byte array (Numbers 0-255) or a string's UTF-8 bytes.
+fn arg_bytes(args: &[Value]) -> Option<Vec<u8>> {
+    match args.first() {
+        Some(Value::Array(a)) => Some(
+            a.borrow()
+                .iter()
+                .map(|v| if let Value::Number(n) = v { *n as u8 } else { 0 })
+                .collect(),
+        ),
+        Some(Value::String(s)) => Some(s.as_bytes().to_vec()),
+        _ => None,
+    }
+}
+
+fn bytes_to_value(bytes: Vec<u8>) -> Value {
+    Value::Array(VmRef::new(
+        bytes.into_iter().map(|b| Value::Number(b as f64)).collect(),
+    ))
+}
+
+pub fn base64_encode(args: &[Value]) -> Value {
+    match arg_bytes(args) {
+        Some(b) => Value::String(base64::engine::general_purpose::STANDARD.encode(&b).into()),
+        None => Value::Null,
+    }
+}
+
+pub fn base64_decode(args: &[Value]) -> Value {
+    let s = match args.first() {
+        Some(Value::String(s)) => s.to_string(),
+        _ => return Value::Null,
+    };
+    match base64::engine::general_purpose::STANDARD.decode(s.as_bytes()) {
+        Ok(b) => bytes_to_value(b),
+        Err(_) => Value::Null,
+    }
+}
+
+pub fn base64_url_encode(args: &[Value]) -> Value {
+    match arg_bytes(args) {
+        Some(b) => Value::String(
+            base64::engine::general_purpose::URL_SAFE_NO_PAD
+                .encode(&b)
+                .into(),
+        ),
+        None => Value::Null,
+    }
+}
+
+pub fn base64_url_decode(args: &[Value]) -> Value {
+    let s = match args.first() {
+        Some(Value::String(s)) => s.to_string(),
+        _ => return Value::Null,
+    };
+    match base64::engine::general_purpose::URL_SAFE_NO_PAD.decode(s.as_bytes()) {
+        Ok(b) => bytes_to_value(b),
+        Err(_) => Value::Null,
+    }
+}
+
+/// `utf8Decode(byteArray) -> string` — decode bytes as UTF-8 (lossy: invalid sequences become the
+/// replacement char). The counterpart to `readFileBytes` / a streaming `reader.read()` chunk, whose
+/// `value` is a byte array. Split streamed bytes on a newline BEFORE decoding a line so a multi-byte
+/// sequence is never cut mid-decode (a `\n`=0x0A byte never occurs inside a UTF-8 multi-byte char).
+pub fn utf8_decode(args: &[Value]) -> Value {
+    match arg_bytes(args) {
+        Some(b) => Value::String(String::from_utf8_lossy(&b).into_owned().into()),
+        None => Value::Null,
+    }
+}
+
+/// `utf8Encode(string) -> number[]` — the string's UTF-8 bytes as a byte array. (A byte-array
+/// argument is passed through, so `utf8Encode(utf8Decode(x))` is a no-op round trip.)
+pub fn utf8_encode(args: &[Value]) -> Value {
+    match arg_bytes(args) {
+        Some(b) => bytes_to_value(b),
+        None => Value::Null,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn to_bytes(v: Value) -> Vec<u8> {
+        let Value::Array(a) = v else { panic!("not an array") };
+        let g = a.borrow();
+        let out: Vec<u8> = g
+            .iter()
+            .map(|x| if let Value::Number(n) = x { *n as u8 } else { 0 })
+            .collect();
+        out
+    }
+
+    #[test]
+    fn encode_string_matches_known_vector() {
+        let enc = base64_encode(&[Value::String("hello world".into())]);
+        let Value::String(s) = &enc else { panic!() };
+        assert_eq!(s.to_string(), "aGVsbG8gd29ybGQ=");
+    }
+
+    #[test]
+    fn roundtrip_all_byte_values() {
+        let arr = Value::Array(VmRef::new(
+            (0u8..=255).map(|b| Value::Number(b as f64)).collect(),
+        ));
+        let enc = base64_encode(&[arr]);
+        assert_eq!(to_bytes(base64_decode(&[enc])), (0u8..=255).collect::<Vec<u8>>());
+    }
+
+    #[test]
+    fn url_safe_has_no_pad_plus_or_slash() {
+        // 0xFB,0xFF,0xBF encodes to +/ in standard; url-safe must use -_ and drop padding.
+        let arr = Value::Array(VmRef::new(vec![
+            Value::Number(251.0),
+            Value::Number(255.0),
+            Value::Number(191.0),
+        ]));
+        let Value::String(sv) = base64_url_encode(&[arr]) else { panic!() };
+        let s = sv.to_string();
+        assert!(!s.contains('=') && !s.contains('+') && !s.contains('/'), "got {s}");
+        // and it round-trips
+        assert_eq!(to_bytes(base64_url_decode(&[Value::String(sv)])), vec![251u8, 255, 191]);
+    }
+
+    #[test]
+    fn decode_invalid_is_null() {
+        assert!(matches!(
+            base64_decode(&[Value::String("!!! not base64 !!!".into())]),
+            Value::Null
+        ));
+    }
+
+    #[test]
+    fn utf8_roundtrip_multibyte() {
+        // "héllo 🚀" exercises 2-byte (é) and 4-byte (🚀) sequences.
+        let bytes = utf8_encode(&[Value::String("héllo 🚀".into())]);
+        let Value::String(s) = utf8_decode(&[bytes]) else { panic!() };
+        assert_eq!(s.to_string(), "héllo 🚀");
+    }
+}

package/crates/tish_runtime/src/fs_ext.rs

@@ -230,6 +230,32 @@ pub fn truncate_core(args: &[Value]) -> Result<Value, Value> {
         .map_err(io_err)
 }
 
+/// `chmod(path, mode)` — set the file mode (a number, e.g. `0o600` = 384). Unix only; a no-op that
+/// succeeds on other platforms. Needed to write a secrets file 0600.
+pub fn chmod_core(args: &[Value]) -> Result<Value, Value> {
+    let mode = match args.get(1) {
+        Some(Value::Number(n)) if n.is_finite() && *n >= 0.0 => *n as u32,
+        _ => {
+            return Err(io_err(std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                "chmod: mode must be a number",
+            )))
+        }
+    };
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        std::fs::set_permissions(path_arg(args, 0), std::fs::Permissions::from_mode(mode))
+            .map(|_| Value::Null)
+            .map_err(io_err)
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = mode;
+        Ok(Value::Null)
+    }
+}
+
 /// `mkdtemp(prefix)` — create a uniquely-named temp dir and return its path. Node appends 6 RANDOM
 /// characters; a timestamp suffix is both predictable (a temp-dir security smell) and collision-prone
 /// under rapid calls. Use a random suffix and rely on `create_dir`'s exclusive semantics, retrying on
@@ -319,6 +345,7 @@ fs_method!(copy_file, copy_file_promise, copy_file_core);
 fs_method!(realpath, realpath_promise, realpath_core);
 fs_method!(readlink, readlink_promise, readlink_core);
 fs_method!(truncate, truncate_promise, truncate_core);
+fs_method!(chmod, chmod_promise, chmod_core);
 fs_method!(mkdtemp, mkdtemp_promise, mkdtemp_core);
 fs_method!(cp, cp_promise, cp_core);
 

package/crates/tish_runtime/src/lib.rs

@@ -1778,6 +1778,38 @@ pub mod pty;
 #[cfg(feature = "pty")]
 pub use pty::{pty_kill, pty_pid, pty_read, pty_resize, pty_spawn, pty_write};
 
+#[cfg(feature = "process")]
+pub mod process_spawn;
+#[cfg(feature = "process")]
+pub use process_spawn::{
+    process_close_stdin, process_kill, process_pid, process_read_stderr, process_read_stdout,
+    process_spawn, process_wait, process_write_stdin,
+};
+
+#[cfg(feature = "net")]
+pub mod net;
+#[cfg(feature = "net")]
+pub use net::{
+    net_accept, net_close, net_connect, net_listen, net_probe, net_read, net_sleep, net_write,
+};
+
+#[cfg(feature = "encoding")]
+pub mod encoding;
+#[cfg(feature = "encoding")]
+pub use encoding::{
+    base64_decode, base64_encode, base64_url_decode, base64_url_encode, utf8_decode, utf8_encode,
+};
+
+#[cfg(feature = "crypto")]
+pub mod crypto;
+#[cfg(feature = "crypto")]
+pub use crypto::{random_bytes, sha256, sha256_hex};
+
+#[cfg(feature = "zip")]
+pub mod zip;
+#[cfg(feature = "zip")]
+pub use zip::{zip_entries, zip_extract};
+
 #[cfg(feature = "ws")]
 pub use ws::{
     web_socket_client, web_socket_server_accept, web_socket_server_construct,