Allow changing font and shell

Author: nab138

src-tauri/src/main.rs

@@ -44,7 +44,7 @@ use tauri::Manager;
 use tauri_plugin_cli::CliExt;
 use tauri_plugin_store::StoreExt;
 use templates::create_template;
-use terminal::{create_terminal, write_terminal, TermManager};
+use terminal::{close_terminal, create_terminal, write_terminal, TermManager};
 use tokio::sync::Mutex;
 use windows::{has_wsl, install_wsl, is_windows};
 
@@ -162,6 +162,7 @@ fn main() {
             take_screenshot,
             create_terminal,
             write_terminal,
+            close_terminal,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/terminal.rs

@@ -41,16 +41,30 @@ impl TermInfo {
 pub async fn create_terminal(
     window: Window,
     term_info: State<'_, TermManager>,
+    shell: Option<String>,
 ) -> Result<String, String> {
     let (pty, pts) = pty_process::open().map_err(|e| format!("Failed to spawn terminal: {}", e))?;
-    let mut cmd = pty_process::Command::new("/bin/bash");
+    let command = match shell {
+        Some(s) => s,
+        None => {
+            #[cfg(target_os = "windows")]
+            {
+                String::from("pwsh.exe")
+            }
+            #[cfg(not(target_os = "windows"))]
+            {
+                std::env::var("SHELL").unwrap_or_else(|_| String::from("sh"))
+            }
+        }
+    };
+    let cmd = pty_process::Command::new(command);
     let child = cmd
         .spawn(pts)
         .map_err(|e| format!("Failed to spawn shell: {}", e))?;
 
     let (reader, writer) = split(pty);
 
-    let (term_id, writer_ref) = {
+    let (term_id, _) = {
         let mut terms = term_info.terminals.write().await;
         let term_id = format!("term-{}", terms.len() + 1);
         let info = TermInfo::new(writer, child);
@@ -101,3 +115,22 @@ pub async fn write_terminal(
         .await
         .map_err(|e| format!("Failed to write to terminal: {}", e))
 }
+
+#[tauri::command]
+pub async fn close_terminal(term_info: State<'_, TermManager>, id: String) -> Result<(), String> {
+    let child = {
+        let terms = term_info.terminals.read().await;
+        terms
+            .get(&id)
+            .map(|info| info.child.clone())
+            .ok_or_else(|| "Terminal ID not found".to_string())?
+    };
+    let mut guard = child.lock().await;
+    if let Some(mut child_proc) = guard.take() {
+        child_proc
+            .kill()
+            .await
+            .map_err(|e| format!("Failed to kill terminal process: {}", e))?;
+    }
+    Ok(())
+}

src/components/Tiles/MultiTerminal.tsx

@@ -4,6 +4,7 @@ import { Button, Tab, TabList, TabPanel, Tabs } from "@mui/joy";
 import TerminalComponent from "./Terminal";
 import { listen } from "@tauri-apps/api/event";
 import { Terminal } from "@xterm/xterm";
+import { useStore } from "../../utilities/StoreContext";
 
 declare global {
   interface Window {
@@ -14,13 +15,16 @@ declare global {
 export default function MultiTerminal({}: {}) {
   const [terminals, setTerminals] = useState<string[]>([]);
   const isListening = useRef<boolean>(false);
+  const [shell] = useStore<string | null>("terminal/shell", null);
 
   const createTerm = useCallback(async () => {
-    const id = await invoke<string>("create_terminal");
+    const id = await invoke<string>("create_terminal", {
+      shell: shell !== "" ? shell : null,
+    });
     setTerminals((old) => {
       return [...old, id];
     });
-  }, []);
+  }, [shell]);
 
   useEffect(() => {
     let unlisten: () => void = () => {};

src/components/Tiles/Terminal.tsx

@@ -2,25 +2,39 @@ import { Terminal } from "@xterm/xterm";
 import { useEffect, useRef } from "react";
 import "@xterm/xterm/css/xterm.css";
 import { invoke } from "@tauri-apps/api/core";
+import { useStore } from "../../utilities/StoreContext";
 
 export default ({ id }: { id: string }) => {
   const elem = useRef<HTMLDivElement>(null);
+  const termRef = useRef<Terminal>();
+  const [font] = useStore<string | null>("terminal/font-family", null);
 
   useEffect(() => {
     if (!elem.current) return;
     if (!window.terminals) window.terminals = {};
 
-    const term = new Terminal();
+    const term = new Terminal({
+      fontFamily: font !== "" ? font || undefined : undefined,
+    });
     window.terminals[id] = term;
     term.open(elem.current);
     term.onData(async (data) => {
-      console.log(await invoke("write_terminal", { id: id, data: data }));
+      await invoke("write_terminal", { id: id, data: data });
     });
+    termRef.current = term;
 
     return () => {
       term.dispose();
     };
   }, [id]);
 
+  useEffect(() => {
+    if (termRef.current) {
+      termRef.current.options.fontFamily =
+        font !== "" ? font || undefined : undefined;
+      termRef.current.refresh(0, termRef.current.rows - 1);
+    }
+  }, [font]);
+
   return <div ref={elem}></div>;
 };

src/preferences/pages/index.ts

@@ -9,11 +9,12 @@ import { appIdsPage } from "./appIds";
 import { developerPage } from "./developer";
 import { swiftPage } from "./swift";
 import { sourceKitPage } from "./sourcekit";
+import { terminalPage } from "./terminal";
 
 const generalCategory: PreferenceCategory = {
   id: "general",
   name: "General",
-  pages: [generalPage, appearancePage],
+  pages: [generalPage, appearancePage, terminalPage],
 };
 
 const appleCategory: PreferenceCategory = {

src/preferences/pages/terminal.ts

@@ -0,0 +1,23 @@
+import { createItems, createPreferencePage } from "../helpers";
+
+export const terminalPage = createPreferencePage(
+  "terminal",
+  "Terminal",
+  [
+    createItems.text(
+      "shell",
+      "Default Shell",
+      "The shell to use (e.x /bin/bash). If unset, defaults to $SHELL on linux/macOS and pwsh.exe on Windows."
+    ),
+    createItems.text(
+      "font-family",
+      "Font Family",
+      "Recommended to use a monospace font (e.x. monospace)",
+      "monospace"
+    ),
+  ],
+  {
+    description: "Configure the integrated terminal",
+    category: "general",
+  }
+);