`ccbfec2`

add Lua scripting: sessions, function keybinds, OSC 133 startup commands

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: ccbfec2aff71eab9915a1338cd2dde674a21b276
Parents: be0f637
Tree: c85b375

10 changed files

Status	File	+	-
M	`garterm-ipc/src/lib.rs`	18	2
M	`garterm/src/app.rs`	224	10
M	`garterm/src/config/keybinds.rs`	8	0
M	`garterm/src/config/lua.rs`	5	0
M	`garterm/src/config/mod.rs`	2	0
A	`garterm/src/config/runtime.rs`	691	0
M	`garterm/src/terminal/mod.rs`	41	0
M	`garterm/src/ui/manager.rs`	36	3
M	`garterm/src/ui/pane.rs`	68	0
M	`garterm/src/ui/tab.rs`	33	2

garterm-ipc/src/lib.rsmodified

          exec: Option<String>,
      },
      /// Create new tab in focused window
 -    NewTab { cwd: Option<String> },
 +    NewTab {
 +        cwd: Option<String>,
 +        /// Startup command to run after shell prompt
 +        #[serde(default, rename = "exec")]
 +        startup_cmd: Option<String>,
 +        #[serde(default)]
 +        title: Option<String>,
 +    },
      /// Close current tab
      CloseTab,
      /// Switch to next tab
      /// Switch to specific tab
      SwitchTab { index: usize },
      /// Split focused pane
 -    Split { direction: String },
 +    Split {
 +        direction: String,
 +        #[serde(default)]
 +        cwd: Option<String>,
 +        /// Startup command to run after shell prompt
 +        #[serde(default, rename = "exec")]
 +        startup_cmd: Option<String>,
 +    },
      /// Close focused pane
      ClosePane,
      /// Focus pane in direction
      ResizePane { direction: String, amount: i32 },
      /// Send text to focused terminal
      SendText { text: String },
 +    /// Load a named session from config
 +    LoadSession { name: String },
      /// Get terminal info
      GetInfo,
      /// Reload configuration

garterm/src/app.rsmodified

 -use crate::config::{Action, Config, KeybindSet, Modifiers as ConfigModifiers};
 +use crate::config::{Action, Config, KeybindSet, LuaRuntime, Modifiers as ConfigModifiers, TerminalCommand};
  use crate::input::{Clipboard, KeyboardHandler, MouseButton, MouseEvent, MouseHandler, Selection, SelectionMode};
  use crate::ipc::IpcServer;
  use crate::pty::{PtySize, ReceivedSignal, SignalHandler};
      shell: String,
      /// Working directory for new panes
      cwd: Option<std::path::PathBuf>,
 +    /// Lua runtime for scripting (callbacks, sessions)
 +    lua_runtime: Option<LuaRuntime>,
+ }
  impl App {
          let clipboard = Clipboard::new(&conn, window.id())?;
          // Load keybindings from config
 -        let keybinds = config.keybindings();
 -        info!("Loaded {} keybindings", keybinds.iter().count());
 +        let mut keybinds = config.keybindings();
 +        info!("Loaded {} keybindings from config", keybinds.iter().count());
          // Start IPC server
          let ipc = match IpcServer::new() {
+             }
          };
 +        // Initialize Lua runtime for scripting
 +        let lua_runtime = match LuaRuntime::new() {
 +            Ok(runtime) => {
 +                if let Err(e) = runtime.load() {
 +                    tracing::warn!("Lua config error: {}", e);
 +                }
 +                // Merge Lua keybinds (function callbacks, sessions) into keybind set
 +                runtime.merge_keybinds(&mut keybinds);
 +                Some(runtime)
 +            }
 +            Err(e) => {
 +                tracing::warn!("Failed to create Lua runtime: {}", e);
 +                None
 +            }
 +        };
++
          Ok(Self {
              window,
              renderer,
              height: actual_height,
              shell: config.general.shell.clone(),
              cwd: config.general.working_directory.clone(),
 +            lua_runtime,
          })
+     }
                      if pane.terminal.take_bell() {
                          tracing::debug!("Bell!");
+                     }
++
 +                    // Handle startup command: check for OSC 133 prompt ready
 +                    if pane.terminal.take_prompt_ready() {
 +                        pane.on_prompt_ready();
 +                    }
++
 +                    // Check startup command deadline (fallback for shells without OSC 133)
 +                    if pane.has_pending_startup_cmd() {
 +                        pane.check_startup_deadline();
 +                    }
+                 }
+             }
                  Ok(false)
+             }
 +            // Lua scripting
 +            Action::LuaCallback(index) => {
 +                if let Some(ref runtime) = self.lua_runtime {
 +                    if let Err(e) = runtime.execute_callback(*index) {
 +                        tracing::error!("Lua callback error: {}", e);
 +                    }
 +                    // Process any pending terminal commands from the callback
 +                    self.process_lua_commands()?;
 +                }
 +                Ok(true)
 +            }
 +            Action::LoadSession(name) => {
 +                self.load_session(name)?;
 +                Ok(true)
 +            }
++
              Action::None => Ok(false),
+         }
+     }
 +    /// Process pending Lua commands from callbacks
 +    fn process_lua_commands(&mut self) -> Result<()> {
 +        let Some(ref runtime) = self.lua_runtime else { return Ok(()) };
++
 +        let commands = runtime.take_pending_commands();
 +        for cmd in commands {
 +            match cmd {
 +                TerminalCommand::NewTab { cwd, cmd, title } => {
 +                    let cwd_path = cwd.map(std::path::PathBuf::from);
 +                    self.tabs.new_tab_with_command(
 +                        self.width,
 +                        self.height,
 +                        cwd_path.as_deref(),
 +                        cmd.as_deref(),
 +                    )?;
 +                    // TODO: Set title if provided (currently set via OSC title sequence from shell)
 +                    if let Some(_title) = title {
 +                        // Will be set via OSC title sequence from shell
 +                    }
 +                    self.tabs.relayout(self.width, self.height)?;
 +                    self.tabs.mark_all_dirty();
 +                }
 +                TerminalCommand::Split { direction, cwd, cmd } => {
 +                    let cwd_path = cwd.map(std::path::PathBuf::from);
 +                    match direction.to_lowercase().as_str() {
 +                        "horizontal" | "h" => {
 +                            self.tabs.split_horizontal_with_command(cwd_path.as_deref(), cmd.as_deref())?
 +                        }
 +                        _ => {
 +                            self.tabs.split_vertical_with_command(cwd_path.as_deref(), cmd.as_deref())?
 +                        }
 +                    };
 +                    self.tabs.relayout(self.width, self.height)?;
 +                    self.tabs.mark_all_dirty();
 +                }
 +                TerminalCommand::SendText { pane_id: _, text } => {
 +                    // TODO: Support pane_id targeting
 +                    if let Some(pane) = self.tabs.focused_pane_mut() {
 +                        pane.write_pty(text.as_bytes())?;
 +                    }
 +                }
 +                TerminalCommand::CloseTab { tab_id: _ } => {
 +                    self.tabs.close_tab();
 +                    self.tabs.relayout(self.width, self.height)?;
 +                    self.tabs.mark_all_dirty();
 +                }
 +                TerminalCommand::ClosePane { pane_id: _ } => {
 +                    if self.tabs.close_pane() {
 +                        self.tabs.relayout(self.width, self.height)?;
 +                        self.tabs.mark_all_dirty();
 +                    }
 +                }
 +                TerminalCommand::FocusTab { index } => {
 +                    self.tabs.switch_to_tab(index);
 +                    self.tabs.mark_all_dirty();
 +                }
 +                TerminalCommand::FocusPane { pane_id: _ } => {
 +                    // TODO: Support direct pane focusing by ID
 +                }
 +                TerminalCommand::FocusDirection { direction } => {
 +                    let dir = match direction.to_lowercase().as_str() {
 +                        "up" => crate::ui::Direction::Up,
 +                        "down" => crate::ui::Direction::Down,
 +                        "left" => crate::ui::Direction::Left,
 +                        _ => crate::ui::Direction::Right,
 +                    };
 +                    self.tabs.focus_direction(dir, self.width, self.height);
 +                    self.tabs.mark_all_dirty();
 +                }
 +                TerminalCommand::NextTab => {
 +                    self.tabs.next_tab();
 +                    self.tabs.mark_all_dirty();
 +                }
 +                TerminalCommand::PrevTab => {
 +                    self.tabs.prev_tab();
 +                    self.tabs.mark_all_dirty();
 +                }
 +                TerminalCommand::LoadSession { name } => {
 +                    self.load_session(&name)?;
 +                }
 +            }
 +        }
 +        Ok(())
 +    }
++
 +    /// Load a named session from Lua config
 +    fn load_session(&mut self, name: &str) -> Result<()> {
 +        let Some(ref runtime) = self.lua_runtime else {
 +            tracing::warn!("No Lua runtime, cannot load session");
 +            return Ok(());
 +        };
++
 +        let Some(session) = runtime.get_session(name) else {
 +            tracing::warn!("Session '{}' not found", name);
 +            return Ok(());
 +        };
++
 +        info!("Loading session '{}' with {} tabs", name, session.tabs.len());
++
 +        for tab_def in &session.tabs {
 +            // Create the tab with startup command (waits for OSC 133 prompt)
 +            self.tabs.new_tab_with_command(
 +                self.width,
 +                self.height,
 +                tab_def.cwd.as_deref(),
 +                tab_def.cmd.as_deref(),
 +            )?;
++
 +            // Create splits within the tab
 +            for split_def in &tab_def.splits {
 +                match split_def.direction.to_lowercase().as_str() {
 +                    "horizontal" | "h" => {
 +                        self.tabs.split_horizontal_with_command(
 +                            split_def.cwd.as_deref(),
 +                            split_def.cmd.as_deref(),
 +                        )?
 +                    }
 +                    _ => {
 +                        self.tabs.split_vertical_with_command(
 +                            split_def.cwd.as_deref(),
 +                            split_def.cmd.as_deref(),
 +                        )?
 +                    }
 +                };
 +            }
 +        }
++
 +        self.tabs.relayout(self.width, self.height)?;
 +        self.tabs.mark_all_dirty();
++
 +        // Focus first tab
 +        self.tabs.switch_to_tab(1);
++
 +        Ok(())
 +    }
++
      /// Convert gartk Modifiers to config Modifiers
      fn modifiers_to_config(mods: &gartk_core::Modifiers) -> ConfigModifiers {
          ConfigModifiers {
          // Reload colors
          self.renderer.set_colors(config.color_palette());
 -        // Reload keybindings
 +        // Reload keybindings from TOML config
          self.keybinds = config.keybindings();
 -        info!("Reloaded {} keybindings", self.keybinds.iter().count());
 +        info!("Reloaded {} keybindings from config", self.keybinds.iter().count());
++
 +        // Reload Lua runtime and merge keybinds
 +        match LuaRuntime::new() {
 +            Ok(runtime) => {
 +                if let Err(e) = runtime.load() {
 +                    tracing::warn!("Lua config error on reload: {}", e);
 +                }
 +                // Merge Lua keybinds into the keybind set
 +                runtime.merge_keybinds(&mut self.keybinds);
 +                self.lua_runtime = Some(runtime);
 +            }
 +            Err(e) => {
 +                tracing::warn!("Failed to create Lua runtime on reload: {}", e);
 +            }
 +        }
          // Update shell for new panes
          self.shell = config.general.shell.clone();
                      Err(e) => Response::error(format!("Failed to reload: {}", e)),
+                 }
+             }
 -            Command::NewTab { cwd } => {
 +            Command::NewTab { cwd, startup_cmd, title: _ } => {
                  let cwd_path = cwd.as_ref().map(|s| std::path::PathBuf::from(s));
 -                match self.tabs.new_tab(self.width, self.height, cwd_path.as_deref()) {
 +                match self.tabs.new_tab_with_command(
 +                    self.width,
 +                    self.height,
 +                    cwd_path.as_deref(),
 +                    startup_cmd.as_deref(),
 +                ) {
                      Ok(_) => {
                          let _ = self.tabs.relayout(self.width, self.height);
                          self.tabs.mark_all_dirty();
                  self.tabs.mark_all_dirty();
                  Response::ok()
+             }
 -            Command::Split { direction } => {
 +            Command::Split { direction, cwd, startup_cmd } => {
 +                let cwd_path = cwd.as_ref()
 +                    .map(|s| std::path::PathBuf::from(s))
 +                    .or_else(|| self.cwd.clone());
                  let result = match direction.to_lowercase().as_str() {
 -                    "horizontal" | "h" => self.tabs.split_horizontal(self.cwd.as_deref()),
 -                    "vertical" | "v" => self.tabs.split_vertical(self.cwd.as_deref()),
 +                    "horizontal" | "h" => {
 +                        self.tabs.split_horizontal_with_command(cwd_path.as_deref(), startup_cmd.as_deref())
 +                    }
 +                    "vertical" | "v" => {
 +                        self.tabs.split_vertical_with_command(cwd_path.as_deref(), startup_cmd.as_deref())
 +                    }
                      _ => return Response::error(format!("Invalid direction: {}", direction)),
                  };
                  match result {
                      Err(e) => Response::error(format!("Failed to split: {}", e)),
+                 }
+             }
 +            Command::LoadSession { name } => {
 +                match self.load_session(&name) {
 +                    Ok(()) => Response::ok(),
 +                    Err(e) => Response::error(format!("Failed to load session: {}", e)),
 +                }
 +            }
              Command::ClosePane => {
                  if self.tabs.close_pane() {
                      let _ = self.tabs.relayout(self.width, self.height);

garterm/src/config/keybinds.rsmodified

      SendBytes(Vec<u8>),
      SendText(String),
 +    // Lua scripting
 +    LuaCallback(usize),      // Index into LuaRuntime callbacks
 +    LoadSession(String),     // Load a named session
++
      // No action (for documenting disabled defaults)
      None,
+ }
          if let Some(n) = s.strip_prefix("scroll_down_") {
              return n.parse().ok().map(Action::ScrollDown);
+         }
 +        // load_session:session_name
 +        if let Some(name) = s.strip_prefix("load_session:") {
 +            return Some(Action::LoadSession(name.to_string()));
 +        }
          match s.to_lowercase().replace(['-', '_'], "").as_str() {
              "copy" => Some(Action::Copy),

garterm/src/config/lua.rsmodified

+ }
  /// Parse gar.terminal Lua table into Config
 +/// This is also called by runtime.rs for the persistent Lua runtime
 +pub fn parse_terminal_table_internal(table: &mlua::Table) -> Config {
 +    parse_terminal_table(table)
 +}
++
  fn parse_terminal_table(table: &mlua::Table) -> Config {
      let mut config = Config::default();

garterm/src/config/mod.rsmodified

  pub mod colors;
  pub mod keybinds;
  pub mod lua;
 +pub mod runtime;
  pub use colors::{Color, ColorPalette};
  pub use keybinds::{Action, Keybind, KeybindSet, Modifiers};
 +pub use runtime::{LuaRuntime, LuaState, LuaKeybind, TerminalCommand, Session, SessionTab, SessionSplit};
  use serde::{Deserialize, Serialize};
  use std::path::PathBuf;

garterm/src/config/runtime.rsadded

 +//! Persistent Lua runtime for garterm scripting
 +//!
 +//! Provides a long-lived Lua environment that supports:
 +//! - Function keybinds (callbacks executed on keypress)
 +//! - Terminal API (gar.terminal.* functions)
 +//! - Session definitions
 +//!
 +//! Unlike the static config loader, this runtime is kept alive
 +//! for the entire application lifetime to support callbacks.
++
 +use super::keybinds::{Action, Keybind, KeybindSet, Modifiers};
 +use super::{Config, ConfigLoader};
 +use mlua::{Function, Lua, RegistryKey, Result as LuaResult, Table, Value};
 +use std::collections::HashMap;
 +use std::path::{Path, PathBuf};
 +use std::sync::{Arc, Mutex};
 +use tracing::{debug, error, info, warn};
++
 +/// Terminal commands queued by Lua callbacks
 +#[derive(Debug, Clone)]
 +pub enum TerminalCommand {
 +    NewTab {
 +        cwd: Option<String>,
 +        cmd: Option<String>,
 +        title: Option<String>,
 +    },
 +    Split {
 +        direction: String,
 +        cwd: Option<String>,
 +        cmd: Option<String>,
 +    },
 +    SendText {
 +        pane_id: Option<u32>,
 +        text: String,
 +    },
 +    CloseTab {
 +        tab_id: Option<u32>,
 +    },
 +    ClosePane {
 +        pane_id: Option<u32>,
 +    },
 +    FocusTab {
 +        index: usize,
 +    },
 +    FocusPane {
 +        pane_id: u32,
 +    },
 +    FocusDirection {
 +        direction: String,
 +    },
 +    NextTab,
 +    PrevTab,
 +    LoadSession {
 +        name: String,
 +    },
 +}
++
 +/// Session definition parsed from Lua
 +#[derive(Debug, Clone)]
 +pub struct Session {
 +    pub name: String,
 +    pub tabs: Vec<SessionTab>,
 +}
++
 +/// Tab within a session
 +#[derive(Debug, Clone)]
 +pub struct SessionTab {
 +    pub title: Option<String>,
 +    pub cwd: Option<PathBuf>,
 +    pub cmd: Option<String>,
 +    pub splits: Vec<SessionSplit>,
 +}
++
 +/// Split within a session tab
 +#[derive(Debug, Clone)]
 +pub struct SessionSplit {
 +    pub direction: String,
 +    pub cwd: Option<PathBuf>,
 +    pub cmd: Option<String>,
 +}
++
 +/// Shared state between Rust and Lua
 +pub struct LuaState {
 +    /// Registered Lua function callbacks
 +    pub callbacks: Vec<RegistryKey>,
 +    /// Parsed session definitions
 +    pub sessions: HashMap<String, Session>,
 +    /// Pending terminal commands from Lua callbacks
 +    pub pending_commands: Vec<TerminalCommand>,
 +    /// Keybinds parsed from Lua (separate from TOML keybinds)
 +    pub lua_keybinds: Vec<(String, LuaKeybind)>,
 +    /// Last assigned IDs for return values
 +    pub last_tab_id: u32,
 +    pub last_pane_id: u32,
 +}
++
 +impl Default for LuaState {
 +    fn default() -> Self {
 +        Self {
 +            callbacks: Vec::new(),
 +            sessions: HashMap::new(),
 +            pending_commands: Vec::new(),
 +            lua_keybinds: Vec::new(),
 +            last_tab_id: 0,
 +            last_pane_id: 0,
 +        }
 +    }
 +}
++
 +/// Type of keybind action from Lua
 +#[derive(Debug, Clone)]
 +pub enum LuaKeybind {
 +    /// String action name: "new_tab", "copy", etc.
 +    Action(String),
 +    /// Index into callbacks vector
 +    Callback(usize),
 +    /// Load a named session
 +    SessionLoad(String),
 +}
++
 +/// Persistent Lua runtime
 +pub struct LuaRuntime {
 +    lua: Lua,
 +    state: Arc<Mutex<LuaState>>,
 +    lua_path: PathBuf,
 +}
++
 +impl LuaRuntime {
 +    /// Create a new Lua runtime
 +    pub fn new() -> LuaResult<Self> {
 +        let lua = Lua::new();
 +        let state = Arc::new(Mutex::new(LuaState::default()));
++
 +        let config_dir = dirs::config_dir().unwrap_or_else(|| PathBuf::from("~/.config"));
 +        let lua_path = config_dir.join("gar/init.lua");
++
 +        Ok(Self {
 +            lua,
 +            state,
 +            lua_path,
 +        })
 +    }
++
 +    /// Load and execute the Lua config file
 +    pub fn load(&self) -> LuaResult<Option<Config>> {
 +        // Set up gar.* stubs for WM compatibility
 +        self.setup_gar_stubs()?;
++
 +        // Register gar.terminal.* API
 +        self.register_terminal_api()?;
++
 +        // Load the config file if it exists
 +        if !self.lua_path.exists() {
 +            debug!("No Lua config at {}", self.lua_path.display());
 +            return Ok(None);
 +        }
++
 +        let content = match std::fs::read_to_string(&self.lua_path) {
 +            Ok(c) => c,
 +            Err(e) => {
 +                warn!("Failed to read {}: {}", self.lua_path.display(), e);
 +                return Ok(None);
 +            }
 +        };
++
 +        // Execute the Lua file
 +        if let Err(e) = self.lua.load(&content).exec() {
 +            error!("Lua config error: {}", e);
 +            return Ok(None);
 +        }
++
 +        info!("Loaded Lua config from {}", self.lua_path.display());
++
 +        // Parse gar.terminal table into Config
 +        let config = self.parse_terminal_config()?;
++
 +        // Parse sessions
 +        self.parse_sessions()?;
++
 +        // Parse keybinds (including function callbacks)
 +        self.parse_keybinds()?;
++
 +        Ok(config)
 +    }
++
 +    /// Set up gar.* stub functions for WM compatibility
 +    fn setup_gar_stubs(&self) -> LuaResult<()> {
 +        let globals = self.lua.globals();
 +        let gar = self.lua.create_table()?;
++
 +        // No-op functions that accept any arguments
 +        let noop = self.lua.create_function(|_, _: mlua::MultiValue| Ok(()))?;
++
 +        gar.set("set", noop.clone())?;
 +        gar.set("bind", noop.clone())?;
 +        gar.set("exec", noop.clone())?;
 +        gar.set("exec_once", noop.clone())?;
 +        gar.set("rule", noop.clone())?;
 +        gar.set("picom_rule", noop.clone())?;
++
 +        // Action functions that return nil
 +        let nil_fn = self.lua.create_function(|_, _: mlua::MultiValue| Ok(Value::Nil))?;
++
 +        gar.set("focus", nil_fn.clone())?;
 +        gar.set("swap", nil_fn.clone())?;
 +        gar.set("resize", nil_fn.clone())?;
 +        gar.set("workspace", nil_fn.clone())?;
 +        gar.set("workspace_next", nil_fn.clone())?;
 +        gar.set("workspace_prev", nil_fn.clone())?;
 +        gar.set("move_to_workspace", nil_fn.clone())?;
 +        gar.set("focus_monitor", nil_fn.clone())?;
 +        gar.set("move_to_monitor", nil_fn.clone())?;
 +        gar.set("close_window", nil_fn.clone())?;
 +        gar.set("force_close_window", nil_fn.clone())?;
 +        gar.set("exit", nil_fn.clone())?;
 +        gar.set("reload", nil_fn.clone())?;
 +        gar.set("equalize", nil_fn.clone())?;
 +        gar.set("toggle_floating", nil_fn.clone())?;
 +        gar.set("toggle_fullscreen", nil_fn.clone())?;
++
 +        globals.set("gar", gar)?;
 +        Ok(())
 +    }
++
 +    /// Register gar.terminal.* API functions
 +    fn register_terminal_api(&self) -> LuaResult<()> {
 +        let globals = self.lua.globals();
 +        let gar: Table = globals.get("gar")?;
 +        let terminal = self.lua.create_table()?;
++
 +        // gar.terminal.new_tab({ cwd = "...", cmd = "...", title = "..." })
 +        let state = Arc::clone(&self.state);
 +        let new_tab = self.lua.create_function(move |_, opts: Option<Table>| {
 +            let (cwd, cmd, title) = if let Some(t) = opts {
 +                (
 +                    t.get::<Option<String>>("cwd").ok().flatten(),
 +                    t.get::<Option<String>>("cmd").ok().flatten(),
 +                    t.get::<Option<String>>("title").ok().flatten(),
 +                )
 +            } else {
 +                (None, None, None)
 +            };
++
 +            let mut state = state.lock().unwrap();
 +            state.last_tab_id += 1;
 +            let tab_id = state.last_tab_id;
 +            state.pending_commands.push(TerminalCommand::NewTab { cwd, cmd, title });
 +            Ok(tab_id)
 +        })?;
 +        terminal.set("new_tab", new_tab)?;
++
 +        // gar.terminal.split({ direction = "horizontal", cwd = "...", cmd = "..." })
 +        let state = Arc::clone(&self.state);
 +        let split = self.lua.create_function(move |_, opts: Option<Table>| {
 +            let (direction, cwd, cmd) = if let Some(t) = opts {
 +                (
 +                    t.get::<String>("direction").unwrap_or_else(|_| "vertical".into()),
 +                    t.get::<Option<String>>("cwd").ok().flatten(),
 +                    t.get::<Option<String>>("cmd").ok().flatten(),
 +                )
 +            } else {
 +                ("vertical".into(), None, None)
 +            };
++
 +            let mut state = state.lock().unwrap();
 +            state.last_pane_id += 1;
 +            let pane_id = state.last_pane_id;
 +            state.pending_commands.push(TerminalCommand::Split { direction, cwd, cmd });
 +            Ok(pane_id)
 +        })?;
 +        terminal.set("split", split)?;
++
 +        // gar.terminal.send_text(pane_id, text) or gar.terminal.send_text(text)
 +        let state = Arc::clone(&self.state);
 +        let send_text = self.lua.create_function(move |_, args: mlua::MultiValue| {
 +            let args: Vec<Value> = args.into_iter().collect();
 +            let (pane_id, text) = match args.len() {
 +                1 => {
 +                    // send_text("text") - send to focused pane
 +                    let text = match &args[0] {
 +                        Value::String(s) => s.to_str()?.to_string(),
 +                        _ => return Err(mlua::Error::runtime("expected string")),
 +                    };
 +                    (None, text)
 +                }
 +                2 => {
 +                    // send_text(pane_id, "text")
 +                    let pane_id = match &args[0] {
 +                        Value::Integer(n) => Some(*n as u32),
 +                        Value::Nil => None,
 +                        _ => return Err(mlua::Error::runtime("expected pane_id or nil")),
 +                    };
 +                    let text = match &args[1] {
 +                        Value::String(s) => s.to_str()?.to_string(),
 +                        _ => return Err(mlua::Error::runtime("expected string")),
 +                    };
 +                    (pane_id, text)
 +                }
 +                _ => return Err(mlua::Error::runtime("expected 1 or 2 arguments")),
 +            };
++
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::SendText { pane_id, text });
 +            Ok(())
 +        })?;
 +        terminal.set("send_text", send_text)?;
++
 +        // gar.terminal.close_tab(tab_id?)
 +        let state = Arc::clone(&self.state);
 +        let close_tab = self.lua.create_function(move |_, tab_id: Option<u32>| {
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::CloseTab { tab_id });
 +            Ok(())
 +        })?;
 +        terminal.set("close_tab", close_tab)?;
++
 +        // gar.terminal.close_pane(pane_id?)
 +        let state = Arc::clone(&self.state);
 +        let close_pane = self.lua.create_function(move |_, pane_id: Option<u32>| {
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::ClosePane { pane_id });
 +            Ok(())
 +        })?;
 +        terminal.set("close_pane", close_pane)?;
++
 +        // gar.terminal.focus_tab(n)
 +        let state = Arc::clone(&self.state);
 +        let focus_tab = self.lua.create_function(move |_, index: usize| {
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::FocusTab { index });
 +            Ok(())
 +        })?;
 +        terminal.set("focus_tab", focus_tab)?;
++
 +        // gar.terminal.focus_pane(pane_id)
 +        let state = Arc::clone(&self.state);
 +        let focus_pane = self.lua.create_function(move |_, pane_id: u32| {
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::FocusPane { pane_id });
 +            Ok(())
 +        })?;
 +        terminal.set("focus_pane", focus_pane)?;
++
 +        // gar.terminal.focus_direction(dir)
 +        let state = Arc::clone(&self.state);
 +        let focus_direction = self.lua.create_function(move |_, direction: String| {
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::FocusDirection { direction });
 +            Ok(())
 +        })?;
 +        terminal.set("focus_direction", focus_direction)?;
++
 +        // gar.terminal.next_tab()
 +        let state = Arc::clone(&self.state);
 +        let next_tab = self.lua.create_function(move |_, ()| {
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::NextTab);
 +            Ok(())
 +        })?;
 +        terminal.set("next_tab", next_tab)?;
++
 +        // gar.terminal.prev_tab()
 +        let state = Arc::clone(&self.state);
 +        let prev_tab = self.lua.create_function(move |_, ()| {
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::PrevTab);
 +            Ok(())
 +        })?;
 +        terminal.set("prev_tab", prev_tab)?;
++
 +        // gar.terminal.load_session(name)
 +        let state = Arc::clone(&self.state);
 +        let load_session = self.lua.create_function(move |_, name: String| {
 +            let mut state = state.lock().unwrap();
 +            state.pending_commands.push(TerminalCommand::LoadSession { name });
 +            Ok(())
 +        })?;
 +        terminal.set("load_session", load_session)?;
++
 +        gar.set("terminal", terminal)?;
 +        Ok(())
 +    }
++
 +    /// Parse gar.terminal table into Config (static settings only)
 +    fn parse_terminal_config(&self) -> LuaResult<Option<Config>> {
 +        let globals = self.lua.globals();
 +        let gar: Table = match globals.get("gar") {
 +            Ok(t) => t,
 +            Err(_) => return Ok(None),
 +        };
++
 +        let terminal: Table = match gar.get("terminal") {
 +            Ok(t) => t,
 +            Err(_) => return Ok(None),
 +        };
++
 +        // Delegate to existing lua.rs parsing logic
 +        // This reuses the static config parsing
 +        let config = super::lua::parse_terminal_table_internal(&terminal);
 +        Ok(Some(config))
 +    }
++
 +    /// Parse session definitions from gar.terminal.sessions
 +    fn parse_sessions(&self) -> LuaResult<()> {
 +        let globals = self.lua.globals();
 +        let gar: Table = globals.get("gar")?;
 +        let terminal: Table = match gar.get("terminal") {
 +            Ok(t) => t,
 +            Err(_) => return Ok(()),
 +        };
++
 +        let sessions: Table = match terminal.get("sessions") {
 +            Ok(t) => t,
 +            Err(_) => return Ok(()),
 +        };
++
 +        let mut state = self.state.lock().unwrap();
++
 +        for pair in sessions.pairs::<String, Table>() {
 +            let (name, session_table) = pair?;
 +            if let Ok(session) = self.parse_session(&name, &session_table) {
 +                debug!("Parsed session: {}", name);
 +                state.sessions.insert(name, session);
 +            }
 +        }
++
 +        info!("Loaded {} sessions", state.sessions.len());
 +        Ok(())
 +    }
++
 +    /// Parse a single session definition
 +    fn parse_session(&self, name: &str, table: &Table) -> LuaResult<Session> {
 +        let mut tabs = Vec::new();
++
 +        if let Ok(tabs_table) = table.get::<Table>("tabs") {
 +            for i in 1..=tabs_table.len()? {
 +                if let Ok(tab_table) = tabs_table.get::<Table>(i) {
 +                    tabs.push(self.parse_session_tab(&tab_table)?);
 +                }
 +            }
 +        }
++
 +        Ok(Session {
 +            name: name.to_string(),
 +            tabs,
 +        })
 +    }
++
 +    /// Parse a session tab definition
 +    fn parse_session_tab(&self, table: &Table) -> LuaResult<SessionTab> {
 +        let title = table.get::<Option<String>>("title").ok().flatten();
 +        let cwd = table.get::<Option<String>>("cwd").ok().flatten().map(PathBuf::from);
 +        let cmd = table.get::<Option<String>>("cmd").ok().flatten();
++
 +        let mut splits = Vec::new();
 +        if let Ok(splits_table) = table.get::<Table>("splits") {
 +            for i in 1..=splits_table.len()? {
 +                if let Ok(split_table) = splits_table.get::<Table>(i) {
 +                    splits.push(self.parse_session_split(&split_table)?);
 +                }
 +            }
 +        }
++
 +        Ok(SessionTab { title, cwd, cmd, splits })
 +    }
++
 +    /// Parse a session split definition
 +    fn parse_session_split(&self, table: &Table) -> LuaResult<SessionSplit> {
 +        let direction = table.get::<String>("direction").unwrap_or_else(|_| "vertical".into());
 +        let cwd = table.get::<Option<String>>("cwd").ok().flatten().map(PathBuf::from);
 +        let cmd = table.get::<Option<String>>("cmd").ok().flatten();
++
 +        Ok(SessionSplit { direction, cwd, cmd })
 +    }
++
 +    /// Parse keybinds from gar.terminal.keybinds (supports functions!)
 +    fn parse_keybinds(&self) -> LuaResult<()> {
 +        let globals = self.lua.globals();
 +        let gar: Table = globals.get("gar")?;
 +        let terminal: Table = match gar.get("terminal") {
 +            Ok(t) => t,
 +            Err(_) => return Ok(()),
 +        };
++
 +        let keybinds: Table = match terminal.get("keybinds") {
 +            Ok(t) => t,
 +            Err(_) => return Ok(()),
 +        };
++
 +        for pair in keybinds.pairs::<String, Value>() {
 +            let (key_combo, value) = pair?;
++
 +            let lua_keybind = match value {
 +                Value::String(s) => {
 +                    // String action: "new_tab", "copy", etc.
 +                    LuaKeybind::Action(s.to_str()?.to_string())
 +                }
 +                Value::Function(f) => {
 +                    // Lua function callback - store in registry
 +                    let key = self.lua.create_registry_value(f)?;
 +                    let mut state = self.state.lock().unwrap();
 +                    let index = state.callbacks.len();
 +                    state.callbacks.push(key);
 +                    drop(state);
 +                    debug!("Registered Lua callback {} for {}", index, key_combo);
 +                    LuaKeybind::Callback(index)
 +                }
 +                Value::Table(t) => {
 +                    // Action table: { action = "load_session", session = "webdev" }
 +                    if let Ok(session) = t.get::<String>("session") {
 +                        LuaKeybind::SessionLoad(session)
 +                    } else if let Ok(action) = t.get::<String>("action") {
 +                        LuaKeybind::Action(action)
 +                    } else {
 +                        continue;
 +                    }
 +                }
 +                _ => continue,
 +            };
++
 +            let mut state = self.state.lock().unwrap();
 +            state.lua_keybinds.push((key_combo.clone(), lua_keybind));
 +        }
++
 +        let state = self.state.lock().unwrap();
 +        info!("Loaded {} Lua keybinds ({} callbacks)",
 +              state.lua_keybinds.len(),
 +              state.callbacks.len());
 +        Ok(())
 +    }
++
 +    /// Execute a registered callback by index
 +    pub fn execute_callback(&self, index: usize) -> LuaResult<()> {
 +        let state = self.state.lock().unwrap();
 +        let key = state.callbacks.get(index)
 +            .ok_or_else(|| mlua::Error::runtime(format!("callback {} not found", index)))?;
++
 +        let func: Function = self.lua.registry_value(key)?;
 +        drop(state); // Release lock before calling Lua
++
 +        func.call::<()>(())?;
 +        Ok(())
 +    }
++
 +    /// Take pending commands (drains the queue)
 +    pub fn take_pending_commands(&self) -> Vec<TerminalCommand> {
 +        let mut state = self.state.lock().unwrap();
 +        std::mem::take(&mut state.pending_commands)
 +    }
++
 +    /// Get a session by name
 +    pub fn get_session(&self, name: &str) -> Option<Session> {
 +        let state = self.state.lock().unwrap();
 +        state.sessions.get(name).cloned()
 +    }
++
 +    /// Get Lua keybinds to merge with config keybinds
 +    pub fn get_lua_keybinds(&self) -> Vec<(String, LuaKeybind)> {
 +        let state = self.state.lock().unwrap();
 +        state.lua_keybinds.clone()
 +    }
++
 +    /// Check if we have any Lua callbacks (for feature detection)
 +    pub fn has_callbacks(&self) -> bool {
 +        let state = self.state.lock().unwrap();
 +        !state.callbacks.is_empty()
 +    }
++
 +    /// Merge Lua keybinds into an existing KeybindSet
 +    ///
 +    /// This converts LuaKeybind variants to Action variants and adds them
 +    /// to the keybind set, overriding any existing bindings.
 +    pub fn merge_keybinds(&self, keybinds: &mut KeybindSet) {
 +        let state = self.state.lock().unwrap();
++
 +        for (key_combo, lua_bind) in &state.lua_keybinds {
 +            // Parse the key combo
 +            let Some((modifiers, key)) = Keybind::parse_key_combo(key_combo) else {
 +                warn!("Invalid key combo from Lua: {}", key_combo);
 +                continue;
 +            };
++
 +            // Convert LuaKeybind to Action
 +            let action = match lua_bind {
 +                LuaKeybind::Action(s) => {
 +                    // Parse string action
 +                    if let Some(a) = Action::from_str_loose(s) {
 +                        a
 +                    } else {
 +                        warn!("Unknown action '{}' for Lua keybind '{}'", s, key_combo);
 +                        continue;
 +                    }
 +                }
 +                LuaKeybind::Callback(index) => Action::LuaCallback(*index),
 +                LuaKeybind::SessionLoad(name) => Action::LoadSession(name.clone()),
 +            };
++
 +            // Add to keybind set (overrides existing)
 +            if let Some(old) = keybinds.add(Keybind::new(modifiers, key, action)) {
 +                if old.action != Action::None {
 +                    debug!("Lua keybind {} overrides {:?}", key_combo, old.action);
 +                }
 +            }
 +        }
++
 +        info!("Merged {} Lua keybinds", state.lua_keybinds.len());
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_runtime_creation() {
 +        let runtime = LuaRuntime::new().unwrap();
 +        assert!(!runtime.has_callbacks());
 +    }
++
 +    #[test]
 +    fn test_terminal_api_registration() {
 +        let runtime = LuaRuntime::new().unwrap();
 +        runtime.setup_gar_stubs().unwrap();
 +        runtime.register_terminal_api().unwrap();
++
 +        // Execute Lua that calls the API
 +        runtime.lua.load(r#"
 +            local tab = gar.terminal.new_tab({ cwd = "/tmp", title = "Test" })
 +            gar.terminal.send_text(tab, "echo hello\n")
 +        "#).exec().unwrap();
++
 +        let commands = runtime.take_pending_commands();
 +        assert_eq!(commands.len(), 2);
 +    }
++
 +    #[test]
 +    fn test_session_parsing() {
 +        let runtime = LuaRuntime::new().unwrap();
 +        runtime.setup_gar_stubs().unwrap();
 +        runtime.register_terminal_api().unwrap();
++
 +        runtime.lua.load(r#"
 +            gar.terminal.sessions = {
 +                webdev = {
 +                    tabs = {
 +                        { title = "Frontend", cwd = "~/app", cmd = "npm run dev" },
 +                        { title = "Backend", cmd = "python manage.py runserver" },
 +                    }
 +                }
 +            }
 +        "#).exec().unwrap();
++
 +        runtime.parse_sessions().unwrap();
++
 +        let session = runtime.get_session("webdev").unwrap();
 +        assert_eq!(session.tabs.len(), 2);
 +        assert_eq!(session.tabs[0].title, Some("Frontend".into()));
 +        assert_eq!(session.tabs[0].cmd, Some("npm run dev".into()));
 +    }
++
 +    #[test]
 +    fn test_function_keybind() {
 +        let runtime = LuaRuntime::new().unwrap();
 +        runtime.setup_gar_stubs().unwrap();
 +        runtime.register_terminal_api().unwrap();
++
 +        runtime.lua.load(r#"
 +            gar.terminal.keybinds = {
 +                ["alt+t"] = function()
 +                    gar.terminal.new_tab({ title = "From callback" })
 +                end
 +            }
 +        "#).exec().unwrap();
++
 +        runtime.parse_keybinds().unwrap();
++
 +        assert!(runtime.has_callbacks());
++
 +        // Execute the callback
 +        runtime.execute_callback(0).unwrap();
++
 +        let commands = runtime.take_pending_commands();
 +        assert_eq!(commands.len(), 1);
 +        match &commands[0] {
 +            TerminalCommand::NewTab { title, .. } => {
 +                assert_eq!(title.as_deref(), Some("From callback"));
 +            }
 +            _ => panic!("expected NewTab command"),
 +        }
 +    }
 +}

garterm/src/terminal/mod.rsmodified

      current_hyperlink_id: u16,
      /// Clipboard events pending processing
      clipboard_events: VecDeque<ClipboardEvent>,
 +    /// Prompt ready flag (from OSC 133;A - shell integration)
 +    prompt_ready: bool,
+ }
  impl Terminal {
              next_hyperlink_id: 1,
              current_hyperlink_id: 0,
              clipboard_events: VecDeque::new(),
 +            prompt_ready: false,
+         }
+     }
          std::mem::replace(&mut self.bell_pending, false)
+     }
 +    /// Check and clear prompt ready flag (from OSC 133;A)
 +    pub fn take_prompt_ready(&mut self) -> bool {
 +        std::mem::replace(&mut self.prompt_ready, false)
 +    }
++
      /// Get current working directory (from OSC 7)
      pub fn cwd(&self) -> Option<&str> {
          self.cwd.as_deref()
+                     }
+                 }
+             }
 +            // OSC 133: Shell integration (prompt marking)
 +            // Format: OSC 133 ; A ST (prompt start)
 +            //         OSC 133 ; B ST (command start)
 +            //         OSC 133 ; C ST (command output start)
 +            //         OSC 133 ; D ; exit_code ST (command finished)
 +            b"133" => {
 +                if params.len() >= 2 {
 +                    match params[1] {
 +                        b"A" => {
 +                            // Prompt start - shell is ready for input
 +                            trace!("OSC 133;A - prompt ready");
 +                            self.term.prompt_ready = true;
 +                        }
 +                        b"B" => {
 +                            // Command start (user pressed enter)
 +                            trace!("OSC 133;B - command start");
 +                        }
 +                        b"C" => {
 +                            // Command output start
 +                            trace!("OSC 133;C - output start");
 +                        }
 +                        b"D" => {
 +                            // Command finished
 +                            if params.len() >= 3 {
 +                                if let Ok(code) = std::str::from_utf8(params[2]) {
 +                                    trace!("OSC 133;D - command finished with code {}", code);
 +                                }
 +                            }
 +                        }
 +                        _ => {}
 +                    }
 +                }
 +            }
              _ => {
                  trace!("unhandled OSC: {:?}", params);
+             }

garterm/src/ui/manager.rsmodified

          width: u32,
          height: u32,
          cwd: Option<&std::path::Path>,
 +    ) -> Result<TabId> {
 +        self.new_tab_with_command(width, height, cwd, None)
 +    }
++
 +    /// Create a new tab with an optional startup command
 +    pub fn new_tab_with_command(
 +        &mut self,
 +        width: u32,
 +        height: u32,
 +        cwd: Option<&std::path::Path>,
 +        startup_cmd: Option<&str>,
      ) -> Result<TabId> {
          // After adding this tab, we'll have tabs.len() + 1 tabs
          let new_tab_count = self.tabs.len() + 1;
          let tab_id = TabId(self.next_tab_id);
          self.next_tab_id += 1;
 -        let tab = Tab::new(tab_id, &self.shell, cols, rows, width, content_height, cwd)?;
 +        let tab = Tab::new_with_command(
 +            tab_id, &self.shell, cols, rows, width, content_height, cwd, startup_cmd
 +        )?;
          self.tabs.insert(tab_id, tab);
          self.tab_order.push(tab_id);
          self.active_tab = tab_id;
      pub fn split_horizontal(
          &mut self,
          cwd: Option<&std::path::Path>,
 +    ) -> Result<Option<PaneId>> {
 +        self.split_horizontal_with_command(cwd, None)
 +    }
++
 +    /// Split the focused pane horizontally with an optional startup command
 +    pub fn split_horizontal_with_command(
 +        &mut self,
 +        cwd: Option<&std::path::Path>,
 +        startup_cmd: Option<&str>,
      ) -> Result<Option<PaneId>> {
          if let Some(tab) = self.tabs.get_mut(&self.active_tab) {
 -            let pane_id = tab.split(
 +            let pane_id = tab.split_with_command(
                  super::split::SplitDirection::Horizontal,
                  &self.shell,
                  self.cell_width,
                  self.cell_height,
                  cwd,
 +                startup_cmd,
              )?;
              Ok(Some(pane_id))
          } else {
      pub fn split_vertical(
          &mut self,
          cwd: Option<&std::path::Path>,
 +    ) -> Result<Option<PaneId>> {
 +        self.split_vertical_with_command(cwd, None)
 +    }
++
 +    /// Split the focused pane vertically with an optional startup command
 +    pub fn split_vertical_with_command(
 +        &mut self,
 +        cwd: Option<&std::path::Path>,
 +        startup_cmd: Option<&str>,
      ) -> Result<Option<PaneId>> {
          if let Some(tab) = self.tabs.get_mut(&self.active_tab) {
 -            let pane_id = tab.split(
 +            let pane_id = tab.split_with_command(
                  super::split::SplitDirection::Vertical,
                  &self.shell,
                  self.cell_width,
                  self.cell_height,
                  cwd,
 +                startup_cmd,
              )?;
              Ok(Some(pane_id))
          } else {

garterm/src/ui/pane.rsmodified

  use crate::pty::{Pty, PtySize};
  use crate::terminal::Terminal;
  use anyhow::Result;
 +use std::time::{Duration, Instant};
++
 +/// State for pending startup command
 +#[derive(Debug)]
 +enum StartupCmdState {
 +    /// No pending command
 +    None,
 +    /// Waiting for shell prompt (OSC 133;A) or deadline
 +    WaitingForPrompt { cmd: String, deadline: Instant },
 +    /// Command has been sent
 +    Sent,
 +}
  /// Unique identifier for a pane
  #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
      pub y: u32,
      /// Whether this pane is focused
      pub focused: bool,
 +    /// Startup command state (for cmd parameter)
 +    startup_cmd_state: StartupCmdState,
+ }
  impl Pane {
              x: 0,
              y: 0,
              focused: false,
 +            startup_cmd_state: StartupCmdState::None,
          })
+     }
 +    /// Create a new pane with an optional startup command
 +    pub fn new_with_command(
 +        id: PaneId,
 +        shell: &str,
 +        cols: usize,
 +        rows: usize,
 +        width: u32,
 +        height: u32,
 +        cwd: Option<&std::path::Path>,
 +        startup_cmd: Option<&str>,
 +    ) -> Result<Self> {
 +        let mut pane = Self::new(id, shell, cols, rows, width, height, cwd)?;
++
 +        if let Some(cmd) = startup_cmd {
 +            pane.startup_cmd_state = StartupCmdState::WaitingForPrompt {
 +                cmd: cmd.to_string(),
 +                deadline: Instant::now() + Duration::from_millis(500),
 +            };
 +        }
++
 +        Ok(pane)
 +    }
++
      /// Resize the pane
      pub fn resize(&mut self, cols: usize, rows: usize, width: u32, height: u32) -> Result<()> {
          self.width = width;
      pub fn mark_dirty(&mut self) {
          self.terminal.mark_dirty();
+     }
++
 +    /// Called when terminal receives OSC 133;A prompt marker
 +    pub fn on_prompt_ready(&mut self) {
 +        if let StartupCmdState::WaitingForPrompt { ref cmd, .. } = self.startup_cmd_state {
 +            let cmd_with_newline = format!("{}\n", cmd);
 +            if let Err(e) = self.write_pty(cmd_with_newline.as_bytes()) {
 +                tracing::error!("Failed to send startup command: {}", e);
 +            }
 +            self.startup_cmd_state = StartupCmdState::Sent;
 +        }
 +    }
++
 +    /// Check startup deadline and send command if timed out
 +    pub fn check_startup_deadline(&mut self) {
 +        if let StartupCmdState::WaitingForPrompt { ref cmd, deadline } = self.startup_cmd_state {
 +            if Instant::now() >= deadline {
 +                // Fallback: send anyway after timeout
 +                let cmd_with_newline = format!("{}\n", cmd);
 +                if let Err(e) = self.write_pty(cmd_with_newline.as_bytes()) {
 +                    tracing::error!("Failed to send startup command (deadline): {}", e);
 +                }
 +                self.startup_cmd_state = StartupCmdState::Sent;
 +            }
 +        }
 +    }
++
 +    /// Check if there's a pending startup command
 +    pub fn has_pending_startup_cmd(&self) -> bool {
 +        matches!(self.startup_cmd_state, StartupCmdState::WaitingForPrompt { .. })
 +    }
+ }

garterm/src/ui/tab.rsmodified

          width: u32,
          height: u32,
          cwd: Option<&std::path::Path>,
 +    ) -> Result<Self> {
 +        Self::new_with_command(id, shell, cols, rows, width, height, cwd, None)
 +    }
++
 +    /// Create a new tab with an initial pane and optional startup command
 +    pub fn new_with_command(
 +        id: TabId,
 +        shell: &str,
 +        cols: usize,
 +        rows: usize,
 +        width: u32,
 +        height: u32,
 +        cwd: Option<&std::path::Path>,
 +        startup_cmd: Option<&str>,
      ) -> Result<Self> {
          let pane_id = PaneId(0);
 -        let mut pane = Pane::new(pane_id, shell, cols, rows, width, height, cwd)?;
 +        let mut pane = Pane::new_with_command(
 +            pane_id, shell, cols, rows, width, height, cwd, startup_cmd
 +        )?;
          pane.focused = true;
          let mut panes = HashMap::new();
          cell_width: f32,
          cell_height: f32,
          cwd: Option<&std::path::Path>,
 +    ) -> Result<PaneId> {
 +        self.split_with_command(direction, shell, cell_width, cell_height, cwd, None)
 +    }
++
 +    /// Split the focused pane with an optional startup command
 +    pub fn split_with_command(
 +        &mut self,
 +        direction: SplitDirection,
 +        shell: &str,
 +        cell_width: f32,
 +        cell_height: f32,
 +        cwd: Option<&std::path::Path>,
 +        startup_cmd: Option<&str>,
      ) -> Result<PaneId> {
          let focused_pane = self.panes.get(&self.focused).ok_or_else(|| {
              anyhow::anyhow!("No focused pane")
          let new_id = PaneId(self.next_pane_id);
          self.next_pane_id += 1;
 -        let new_pane = Pane::new(new_id, shell, cols, rows, new_width, new_height, cwd)?;
 +        let new_pane = Pane::new_with_command(
 +            new_id, shell, cols, rows, new_width, new_height, cwd, startup_cmd
 +        )?;
          self.panes.insert(new_id, new_pane);
          // Update layout tree