experimenting

Cargo.lock

@@ -10,9 +10,9 @@ checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
 
 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "1be3f42a67d6d345ecd59f675f3f012d6974981560836e938c22b424b85ce1be"
 
 [[package]]
 name = "bstr"
@@ -32,9 +32,9 @@ checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "cc"
-version = "1.2.7"
+version = "1.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a012a0df96dd6d06ba9a1b29d6402d1a5d77c6befd2566afdc26e10603dc93d7"
+checksum = "c8293772165d9345bdaaa39b45b2109591e63fe5e6fbc23c6ff930a048aa310b"
 dependencies = [
  "shlex",
 ]
@@ -45,6 +45,12 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "color-print"
 version = "0.3.7"
@@ -112,6 +118,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "ctrlc"
+version = "3.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3"
+dependencies = [
+ "nix",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "either"
 version = "1.13.0"
@@ -128,6 +144,31 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
 [[package]]
 name = "home"
 version = "0.5.11"
@@ -139,9 +180,9 @@ dependencies = [
 
 [[package]]
 name = "js-sys"
-version = "0.3.76"
+version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6717b6b5b077764fb5966237269cb3c64edddde4b14ce42647430a78ced9e7b7"
+checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -175,6 +216,7 @@ dependencies = [
  "color-print",
  "const_format",
  "crossterm",
+ "ctrlc",
  "home",
  "mlua",
  "thiserror",
@@ -210,9 +252,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "04cbf5b083de1c7e0222a7a51dbfdba1cbe1c6ab0b15e29fff3f6c077fd9cd9f"
 
 [[package]]
 name = "lua-src"
@@ -274,6 +316,7 @@ checksum = "9ea43c3ffac2d0798bd7128815212dd78c98316b299b7a902dabef13dc7b6b8d"
 dependencies = [
  "bstr",
  "either",
+ "futures-util",
  "libloading",
  "mlua-sys",
  "num-traits",
@@ -295,6 +338,18 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "nix"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
 [[package]]
 name = "nom"
 version = "7.1.3"
@@ -343,6 +398,18 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "pkg-config"
 version = "0.3.31"
@@ -351,9 +418,9 @@ checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.92"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
 dependencies = [
  "unicode-ident",
 ]
@@ -457,6 +524,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "slab"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "smallvec"
 version = "1.13.2"
@@ -465,9 +541,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "syn"
-version = "2.0.95"
+version = "2.0.96"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f71c0377baf4ef1cc3e3402ded576dccc315800fbc62dfc7fe04b009773b4a"
+checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -476,18 +552,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.10"
+version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3ac7f54ca534db81081ef1c1e7f6ea8a3ef428d2fc069097c079443d24124d3"
+checksum = "d452f284b73e6d76dd36758a0c8684b1d5be31f92b89d07fd5822175732206fc"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.10"
+version = "2.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e9465d30713b56a37ede7185763c3492a91be2f5fa68d958c44e41ab9248beb"
+checksum = "26afc1baea8a989337eeb52b6e72a039780ce45c3edfcc9c5b9d112feeb173c2"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -530,9 +606,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.99"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a474f6281d1d70c17ae7aa6a613c87fce69a127e2624002df63dcb39d6cf6396"
+checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -541,9 +617,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.99"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f89bb38646b4f81674e8f5c3fb81b562be1fd936d84320f3264486418519c79"
+checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
 dependencies = [
  "bumpalo",
  "log",
@@ -555,9 +631,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.99"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cc6181fd9a7492eef6fef1f33961e3695e4579b9872a6f7c83aee556666d4fe"
+checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -565,9 +641,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.99"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30d7a95b763d3c45903ed6c81f156801839e5ee968bb07e534c44df0fcd330c2"
+checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -578,15 +654,18 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.99"
+version = "0.2.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "943aab3fdaaa029a6e0271b35ea10b72b943135afe9bffca82384098ad0e06a6"
+checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+dependencies = [
+ "unicode-ident",
+]
 
 [[package]]
 name = "web-sys"
-version = "0.3.76"
+version = "0.3.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dd7223427d52553d3702c004d3b2fe07c148165faa56313cb00211e31c12bc"
+checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
 dependencies = [
  "js-sys",
  "wasm-bindgen",

Cargo.toml

@@ -7,8 +7,9 @@ edition = "2021"
 color-print = "0.3.7"
 const_format = { version = "0.2.34", features = ["rust_1_64"] }
 crossterm = "0.28.1"
+ctrlc = "3.4.5"
 home = "0.5.9"
-mlua = { version = "0.10.0", features = ["luau-jit", "vendored"] }
+mlua = { version = "0.10.0", features = ["luau-jit", "vendored", "async", "send"] }
 thiserror = "2.0.9"
 uzers = "0.12.1"
-whoami = "1.5.2"
+whoami = "1.5.2"

src/commands.rs

@@ -1,22 +1,16 @@
+use std::{io, process, str::SplitWhitespace, path::{Path, PathBuf}};
 use uzers::User;
-use std::{
-	io,
-	process,
-	str::SplitWhitespace,
-	path::{Path, PathBuf},
-};
 
-use crate::MapDisplay;
-
-enum ValidStatus {
-	NoRootFolder,
-	TryExists(io::Error)
-}
+use crate::{history::History, session::MapDisplay, valid_pbuf::IsValid};
 
 trait PathBufIsValid {
-	fn is_valid(&self) -> Result<PathBuf, ValidStatus>;
 	fn is_valid_or_home(&self) -> Option<PathBuf>;
 }
+impl PathBufIsValid for PathBuf {
+	fn is_valid_or_home(&self) -> Option<PathBuf> {
+		self.is_valid_or(self.is_dir(), home::home_dir)
+	}
+}
 
 trait ChangeDirectory {
 	fn change_directory(&self, args: SplitWhitespace) -> Option<PathBuf>;
@@ -26,30 +20,6 @@ trait ChangeDirectory {
 	fn previous_dir(&self) -> Option<PathBuf>;
 	fn home_dir(&self) -> Option<PathBuf>;
 }
-
-impl PathBufIsValid for PathBuf {
-	fn is_valid(&self) -> Result<PathBuf, ValidStatus> {
-		match self.try_exists() {
-			Ok(true) => Ok(self.to_path_buf()),
-			Ok(false) => Err(ValidStatus::NoRootFolder),
-			Err(trye_error) => Err(ValidStatus::TryExists(trye_error))
-		}
-	}
-
-	fn is_valid_or_home(&self) -> Option<PathBuf> {
-		match self.is_valid() {
-			Ok(valid) => Some(valid),
-			Err(valid_status) => {
-				match valid_status {
-					ValidStatus::NoRootFolder => println!("cd: /root: No such file or directory"),
-					ValidStatus::TryExists(error) => println!("cd: {error}"),
-				};
-				None
-			},
-		}
-	}
-}
-
 impl ChangeDirectory for Command {
 	fn set_current_dir(&self, new_path: &Path) -> Option<PathBuf> {
 		std::env::set_current_dir(new_path).map_or_display_none(|()| Some(new_path.to_path_buf()))
@@ -119,24 +89,25 @@ impl ChangeDirectory for Command {
 
 pub struct Command(String);
 impl Command {
-	pub fn new(input: String) -> Self {
+	pub const fn new(input: String) -> Self {
 		Self(input)
 	}
 
-	pub fn spawn(&self, command_process: io::Result<process::Child>) {
-		command_process.map_or_display_none(|mut child| Some(child.wait()));
+	pub fn spawn_sys_cmd(&mut self, history: &mut History, command_process: io::Result<process::Child>) {
+		if let Ok(mut child) = command_process {
+			history.add(self.0.as_str());
+			child.wait().ok();
+		} else {
+			println!("lambdashell: Unknown command: {}", self.0)
+		}
 	}
 
-	pub fn exec(&self) {
+	pub fn exec(&mut self, history: &mut History) {
 		let mut args = self.0.split_whitespace();
 		if let Some(command) = args.next() {
 			match command {
-				"cd" => {
-					self.change_directory(args);
-				},
-				command => {
-					self.spawn(process::Command::new(command).args(args).spawn());
-				}
+				"cd" => if self.change_directory(args).is_some() { history.add(self.0.as_str()) },
+				command => { self.spawn_sys_cmd(history, process::Command::new(command).args(args).spawn()); }
 			}
 		}
 	}

src/history.rs

@@ -0,0 +1,51 @@
+use std::{fs::{File, OpenOptions}, io::{BufRead, BufReader, Write}, path::PathBuf};
+
+use crate::{rc::{self}, session::{self, MapDisplay}, valid_pbuf::IsValid};
+
+#[derive(Debug, Clone)]
+pub struct History {
+	fs_history: Option<Vec<String>>,
+	history: Vec<String>,
+	file: Option<PathBuf>,
+}
+impl History {
+	pub fn init() -> Self {
+		let file = rc::config_dir().map(|mut config_dir| {
+			config_dir.push(".history");
+			config_dir.is_valid_file_or_create(b"");
+			config_dir
+		});
+		let fs_history = file.as_ref().and_then(|file| {
+			File::open(file).map_or_display_none(|file| {
+				Some(BufReader::new(file).lines().map_while(Result::ok).collect::<Vec<String>>())
+			})
+		});
+		Self {
+			history: Vec::new(),
+			fs_history,
+			file,
+		}
+	}
+
+	pub fn write_to_file_fallible(&mut self) {
+		if self.history.is_empty() { return; }
+
+		if let (Some(history_file), Some(fs_history)) = (&self.file, &self.fs_history) {
+			OpenOptions::new()
+				.append(true)
+				.open(history_file.as_path())
+			.map_or_display(|mut file| {
+				let newline_maybe = if fs_history.is_empty() { "" } else { "\n" };
+				let formatted = format!("{newline_maybe}{}", self.history.join("\n"));
+				file.write_all(formatted.as_bytes()).unwrap_or_else(session::shell_error)
+			});
+		}
+	}
+
+	pub fn add(&mut self, command: &str) {
+		match self.history.last() {
+		    Some(last_cmd) => if last_cmd != command { self.history.push(command.to_owned()); },
+		    None => self.history.push(command.to_owned()),
+		};
+	}
+}

src/lib.rs

@@ -2,28 +2,9 @@ pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 pub mod session;
 pub mod commands;
+pub mod history;
 pub mod ps;
 pub mod rc;
 pub mod vm;
 
-#[inline]
-pub fn shell_error<E: core::fmt::Display>(err: E) {
-	color_print::ceprintln!("<bold,r>[!]:</> {err}")
-}
-
-pub trait MapDisplay<T, E: core::fmt::Display> {
-	fn map_or_display<F: FnOnce(T)>(self, f: F);
-	fn map_or_display_none<R, F: FnOnce(T) -> Option<R>>(self, f: F) -> Option<R>;
-}
-impl<T, E: core::fmt::Display> MapDisplay<T, E> for Result<T, E> {
-	///Map but display the error to stdout
-	#[inline]
-	fn map_or_display<F: FnOnce(T)>(self, f: F) {
-		self.map_or_else(|e| shell_error(e), f)
-	}
-	///Map but display the error to stdout and return `None`
-	#[inline]
-	fn map_or_display_none<R, F: FnOnce(T) -> Option<R>>(self, f: F) -> Option<R> {
-		self.map_or_else(|e| { shell_error(e); None }, f)
-	}
-}
+mod valid_pbuf;

src/rc.rs

@@ -1,7 +1,6 @@
-use std::{path::PathBuf, fs::{self, File}, io::{self, Write}};
-use thiserror::Error;
+use std::path::PathBuf;
 
-use crate::MapDisplay;
+use crate::valid_pbuf::IsValid;
 
 pub const DEFAULT_CONFIG_CONTENT: &str = r#"--!strict
 
@@ -15,72 +14,6 @@ username = if username == "root" then red(username) else cyan(username)
 
 SHELL.PROMPT = `{username}@{hostname} λ `"#;
 
-#[derive(Debug, Error)]
-#[allow(dead_code)]
-enum IsValidDirErr {
-	#[error("Failed to see if a file exists: {0}")]
-	TryExists(#[from] io::Error),
-	#[error("Not a valid entry")]
-	NotAnEntry,
-	#[error("Directory missing")]
-	Missing
-}
-
-#[allow(dead_code)]
-enum CreateErr {
-	TryExists(io::Error),
-	Passable
-}
-
-#[allow(dead_code)]
-trait IsValid {
-	fn is_valid(&self, is_dir_or_file: bool) -> Result<PathBuf, IsValidDirErr>;
-	fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf>;
-	fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf>;
-	fn is_valid_dir_or_create(&self) -> Option<PathBuf>;
-	fn is_valid_or<F>(&self, is_content: bool, f: F) -> Option<PathBuf>
-	where
-		F: FnOnce() -> Option<PathBuf>;
-}
-impl IsValid for PathBuf {
-	fn is_valid(&self, is_content: bool) -> Result<PathBuf, IsValidDirErr> {
-		match self.try_exists() {
-			Ok(true) => if is_content { Ok(self.to_path_buf()) } else { Err(IsValidDirErr::NotAnEntry) },
-			Ok(false) => Err(IsValidDirErr::Missing),
-			Err(try_e) => Err(IsValidDirErr::TryExists(try_e))
-		}
-	}
-
-	fn is_valid_or<F>(&self, is_content: bool, f: F) -> Option<PathBuf>
-	where
-		F: FnOnce() -> Option<PathBuf>
-	{
-		self.is_valid(is_content).map_err(|e| match e {
-			IsValidDirErr::TryExists(try_e) => CreateErr::TryExists(try_e),
-			IsValidDirErr::NotAnEntry | IsValidDirErr::Missing => CreateErr::Passable
-		}).map_or_else(|e| match e {
-			CreateErr::TryExists(_) => None,
-			CreateErr::Passable => f()
-		}, Some)
-	}
-
-	fn is_valid_dir_or_create(&self) -> Option<PathBuf> {
-		self.is_valid_or(self.is_dir(), || fs::create_dir(self).map_or_display_none(|()| Some(self.to_path_buf())))
-	}
-
-	fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf> {
-		self.is_valid_or(self.is_file(), || {
-			File::create(self).map_or_display_none(|mut file| {
-				file.write_all(default_file_bytes).map_or_display_none(|()| Some(self.to_path_buf()))
-			})
-		})
-	}
-
-	fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf> {
-		self.is_valid(is_dir_or_file).ok()
-	}
-}
-
 pub fn config_dir() -> Option<PathBuf> {
 	let mut config = home::home_dir()?;
 	config.push(".config");
@@ -93,11 +26,4 @@ pub fn config_file() -> Option<PathBuf> {
 	let mut config_file = config_dir()?;
 	config_file.push("init.luau");
 	config_file.is_valid_file_or_create(DEFAULT_CONFIG_CONTENT.as_bytes())
-}
-
-// TODO: history.rs
-pub fn history_file() -> Option<PathBuf> {
-	let mut config_file = config_dir()?;
-	config_file.push(".history");
-	config_file.is_valid_file_or_create(b"")
 }

src/session.rs

@@ -1,66 +1,111 @@
-use std::{cell::RefCell, fs, io::{self}, rc::Rc};
+use std::{fs, io::{self}, sync::{Arc, Mutex}, thread};
 use core::fmt;
+use color_print::ceprintln;
 
-use crate::{
-	commands, ps::{self, Ps}, rc, shell_error, vm::{self, LuauVm}, MapDisplay
-};
+use crate::{commands, history::History, ps::{self, Ps}, rc::{self}, vm::{self, LuauVm}};
+
+#[inline]
+pub fn shell_error<E: fmt::Display>(err: E) {
+	ceprintln!("<bold,r>[!]:</> {err}")
+}
+
+pub trait MapDisplay<T, E: fmt::Display> {
+	fn map_or_display<F: FnOnce(T)>(self, f: F);
+	fn map_or_display_none<R, F: FnOnce(T) -> Option<R>>(self, f: F) -> Option<R>;
+}
+impl<T, E: fmt::Display> MapDisplay<T, E> for Result<T, E> {
+	///Map but display the error to stdout
+	#[inline]
+	fn map_or_display<F: FnOnce(T)>(self, f: F) {
+		self.map_or_else(|e| shell_error(e), f)
+	}
+	///Map but display the error to stdout and return `None`
+	#[inline]
+	fn map_or_display_none<R, F: FnOnce(T) -> Option<R>>(self, f: F) -> Option<R> {
+		self.map_or_else(|e| { shell_error(e); None }, f)
+	}
+}
+
+trait Errors {
+	fn error<E: fmt::Display>(&mut self, err: E);
+}
+impl Errors for LambdaShell {
+	fn error<E: fmt::Display>(&mut self, err: E) {
+		shell_error(err);
+		self.terminate = true;
+	}
+}
+
+trait Signals {
+	fn sigterm_event(&mut self);
+	fn input(&mut self);
+}
+impl Signals for LambdaShell {
+	fn sigterm_event(&mut self) {
+		// task::spawn(async move {
+		// 	signal::ctrl_c().await.expect("Failed to listen for a sigterm signal.");
+		// 	// self.history.write_to_file_fallible();
+		// 	std::process::exit(0x0100);
+		// });
+	}
+	fn input(&mut self) {
+		thread::spawn(|| {
+			loop {
+				if self.terminate { break } else {
+					match self.wait() {
+				        Ok(()) => self.ps.borrow().display(),
+				        Err(flush_err) => self.error(flush_err),
+				    }
+				}
+			}
+		});
+	}
+}
 
 #[derive(Debug, Clone)]
 pub struct Config {
 	pub norc: bool
 }
-
 pub struct LambdaShell {
 	terminate: bool,
+	history: History,
 	config: Config,
 	vm: LuauVm,
-	ps: Rc<RefCell<Ps>>,
+	ps: Arc<Mutex<Ps>>,
 }
 impl LambdaShell {
 	pub fn create(config: Config) -> Self {
-		let ps = Rc::new(RefCell::new(Ps::set(ps::DEFAULT_PS.to_owned())));
+		let ps = Arc::new(Mutex::new(Ps::set(ps::DEFAULT_PS.to_owned())));
 		Self {
-			ps: Rc::clone(&ps),
+			ps: Arc::clone(&ps),
 			vm: vm::LuauVm::new(ps),
+			history: History::init(),
 			terminate: false,
 			config,
 		}
 	}
 
-	pub fn wait(&mut self) -> Result<(), io::Error> {
+	fn wait(&mut self) -> Result<(), io::Error> {
 		io::Write::flush(&mut io::stdout()).map(|()| {
 			let mut input = String::new();
 			io::stdin().read_line(&mut input).map_or_display(|_size| match input.trim() {
-				"exit" => self.terminate = true,
-				trim => commands::Command::new(trim.to_owned()).exec()
+				"exit" => {
+					self.terminate = true;
+					self.history.add("exit");
+				},
+				trim => commands::Command::new(trim.to_owned()).exec(&mut self.history)
 			})
 		})
 	}
 
-	pub fn error<E: fmt::Display>(&mut self, err: E) {
-		shell_error(err);
-		self.terminate = true;
-	}
-
-	pub fn start(&mut self) {
+	pub async fn start(&mut self) {
 		if !self.config.norc {
 			if let Some(conf_file) = rc::config_file() {
-				fs::read_to_string(conf_file).map_or_display(|luau_conf| self.vm_exec(luau_conf));
+				fs::read_to_string(conf_file).map_or_display(|luau_conf| self.vm.exec(luau_conf));
 			}
-		}
-
+		};
 		self.ps.borrow().display();
-		loop {
-			if self.terminate { break } else {
-				match self.wait() {
-			        Ok(()) => self.ps.borrow().display(),
-			        Err(flush_err) => self.error(flush_err),
-			    }
-			}
-		}
+		self.sigterm_event();
+		self.input();
 	}
-
-	pub fn vm_exec(&self, source: String) {
-		self.vm.exec(source);
-	}
-}
+}

src/valid_pbuf.rs

@@ -0,0 +1,75 @@
+use std::{fs::{self, File}, io::{self, Write}, path::PathBuf};
+use thiserror::Error;
+
+use crate::session::MapDisplay;
+
+#[derive(Debug, Error)]
+#[allow(dead_code)]
+pub enum IsValidDirErr {
+	#[error("Failed to see if a file exists: {0}")]
+	TryExists(#[from] io::Error),
+	#[error("Not a valid entry")]
+	NotAnEntry,
+	#[error("Directory missing")]
+	Missing
+}
+
+#[allow(dead_code)]
+enum CreateErr {
+	TryExists(io::Error),
+	Passable
+}
+
+#[allow(dead_code)]
+pub trait IsValid {
+	fn is_valid(&self, is_dir_or_file: bool) -> Result<PathBuf, IsValidDirErr>;
+	fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf>;
+	fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf>;
+	fn is_valid_dir_or_create(&self) -> Option<PathBuf>;
+	fn is_valid_or<F>(&self, is_content: bool, f: F) -> Option<PathBuf>
+	where
+		F: FnOnce() -> Option<PathBuf>;
+}
+impl IsValid for PathBuf {
+	#[inline]
+	fn is_valid(&self, is_content: bool) -> Result<PathBuf, IsValidDirErr> {
+		match self.try_exists() {
+			Ok(true) => if is_content { Ok(self.to_path_buf()) } else { Err(IsValidDirErr::NotAnEntry) },
+			Ok(false) => Err(IsValidDirErr::Missing),
+			Err(try_e) => Err(IsValidDirErr::TryExists(try_e))
+		}
+	}
+
+	#[inline]
+	fn is_valid_or<F>(&self, is_content: bool, f: F) -> Option<PathBuf>
+	where
+		F: FnOnce() -> Option<PathBuf>
+	{
+		self.is_valid(is_content).map_err(|e| match e {
+			IsValidDirErr::TryExists(try_e) => CreateErr::TryExists(try_e),
+			IsValidDirErr::NotAnEntry | IsValidDirErr::Missing => CreateErr::Passable
+		}).map_or_else(|e| match e {
+			CreateErr::TryExists(_) => None,
+			CreateErr::Passable => f()
+		}, Some)
+	}
+
+	#[inline]
+	fn is_valid_dir_or_create(&self) -> Option<PathBuf> {
+		self.is_valid_or(self.is_dir(), || fs::create_dir(self).map_or_display_none(|()| Some(self.to_path_buf())))
+	}
+
+	#[inline]
+	fn is_valid_file_or_create(&self, default_file_bytes: &[u8]) -> Option<PathBuf> {
+		self.is_valid_or(self.is_file(), || {
+			File::create(self).map_or_display_none(|mut file| {
+				file.write_all(default_file_bytes).map_or_display_none(|()| Some(self.to_path_buf()))
+			})
+		})
+	}
+
+	#[inline]
+	fn is_valid_option(&self, is_dir_or_file: bool) -> Option<PathBuf> {
+		self.is_valid(is_dir_or_file).ok()
+	}
+}

src/vm/mod.rs

@@ -5,7 +5,7 @@ use std::{cell::RefCell, rc::Rc};
 use core::fmt;
 use shell::ShellGlobal;
 
-use crate::{ps::Ps, MapDisplay};
+use crate::{ps::Ps, session::MapDisplay};
 
 mod shell;
 mod terminal;

src/vm/shell.rs

@@ -41,7 +41,7 @@ pub trait ShellGlobal {
 }
 impl ShellGlobal for LuauVm {
 	fn global_shell(&self, luau_globals: &Table) -> lResult<()> {
-		luau_globals.set("SHELL", Shell(Rc::clone(&self.ps)))?;
+		luau_globals.raw_set("SHELL", Shell(Rc::clone(&self.ps)))?;
 		Ok(())
 	}
 }