use crate::spec::{
ModifiedEnterEncoding, PtySubmitContract, RuntimePlatform, WindowsPasteNewline,
};
use crate::AgentId;
use serde::{Deserialize, Serialize};
use thiserror::Error;
pub const TERMINAL_INPUT_CHUNK_MAX_BYTES: usize = 16 * 1024;
pub const TERMINAL_INPUT_MAX_BYTES: usize = 16 * 1024 * 1024;
pub const TERMINAL_BYTES_MAX_BYTES: usize = 64;
pub const TERMINAL_SUBMIT_DELAY_MS: u64 = 500;
pub const TERMINAL_WRITE_DELAY_MAX_MS: u64 = 400_000;
pub const SEMANTIC_PROMPT_MAX_BYTES: usize = TERMINAL_INPUT_MAX_BYTES;
pub const BRACKETED_PASTE_START: &[u8] = b"\x1b[200~";
pub const BRACKETED_PASTE_END: &[u8] = b"\x1b[201~";
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum PromptFraming {
BracketedPaste,
Literal,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct PromptPayload {
pub text: String,
pub framing: PromptFraming,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct AgentCommand {
pub agent_id: AgentId,
pub name: String,
pub arguments: Vec<String>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct ShellCommand {
pub text: String,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct TerminalText {
pub text: String,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum TerminalControl {
Interrupt,
EndOfFile,
ControlA,
ControlB,
ControlE,
ControlF,
ControlG,
ControlH,
ControlI,
ControlJ,
ControlK,
ControlL,
ControlM,
ControlN,
ControlO,
ControlP,
ControlQ,
ControlR,
ControlS,
ControlT,
ControlU,
ControlV,
ControlW,
ControlX,
ControlY,
ControlZ,
Enter,
LineFeed,
Escape,
Backspace,
Tab,
BackTab,
Insert,
Delete,
Home,
End,
PageUp,
PageDown,
ArrowUp,
ArrowDown,
ArrowRight,
ArrowLeft,
Function1,
Function2,
Function3,
Function4,
Function5,
Function6,
Function7,
Function8,
Function9,
Function10,
Function11,
Function12,
}
impl TerminalControl {
pub fn bytes(self) -> &'static [u8] {
match self {
Self::Interrupt => b"\x03",
Self::EndOfFile => b"\x04",
Self::ControlA => b"\x01",
Self::ControlB => b"\x02",
Self::ControlE => b"\x05",
Self::ControlF => b"\x06",
Self::ControlG => b"\x07",
Self::ControlH => b"\x08",
Self::ControlI => b"\x09",
Self::ControlJ => b"\x0a",
Self::ControlK => b"\x0b",
Self::ControlL => b"\x0c",
Self::ControlM => b"\x0d",
Self::ControlN => b"\x0e",
Self::ControlO => b"\x0f",
Self::ControlP => b"\x10",
Self::ControlQ => b"\x11",
Self::ControlR => b"\x12",
Self::ControlS => b"\x13",
Self::ControlT => b"\x14",
Self::ControlU => b"\x15",
Self::ControlV => b"\x16",
Self::ControlW => b"\x17",
Self::ControlX => b"\x18",
Self::ControlY => b"\x19",
Self::ControlZ => b"\x1a",
Self::Enter => b"\r",
Self::LineFeed => b"\n",
Self::Escape => b"\x1b",
Self::Backspace => b"\x08",
Self::Tab => b"\t",
Self::BackTab => b"\x1b[Z",
Self::Insert => b"\x1b[2~",
Self::Delete => b"\x1b[3~",
Self::Home => b"\x1b[H",
Self::End => b"\x1b[F",
Self::PageUp => b"\x1b[5~",
Self::PageDown => b"\x1b[6~",
Self::ArrowUp => b"\x1b[A",
Self::ArrowDown => b"\x1b[B",
Self::ArrowRight => b"\x1b[C",
Self::ArrowLeft => b"\x1b[D",
Self::Function1 => b"\x1bOP",
Self::Function2 => b"\x1bOQ",
Self::Function3 => b"\x1bOR",
Self::Function4 => b"\x1bOS",
Self::Function5 => b"\x1b[15~",
Self::Function6 => b"\x1b[17~",
Self::Function7 => b"\x1b[18~",
Self::Function8 => b"\x1b[19~",
Self::Function9 => b"\x1b[20~",
Self::Function10 => b"\x1b[21~",
Self::Function11 => b"\x1b[23~",
Self::Function12 => b"\x1b[24~",
}
}
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum InputAction {
InsertDraft(PromptPayload),
SubmitPrompt(PromptPayload),
AgentCommand(AgentCommand),
ShellCommand(ShellCommand),
TerminalText(TerminalText),
TerminalBytes(Vec<u8>),
TerminalControl(TerminalControl),
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum PreparedWriteKind {
Framing,
Data,
Submit,
Control,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct PreparedWrite {
pub kind: PreparedWriteKind,
pub bytes: Vec<u8>,
pub delay_before_ms: u64,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub struct PreparedInput {
kind: PreparedInputKind,
writes: Vec<PreparedWrite>,
}
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
pub enum PreparedInputKind {
InsertDraft,
SubmitPrompt,
AgentCommand,
ShellCommand,
TerminalText,
TerminalBytes,
TerminalControl,
}
impl PreparedInput {
pub fn kind(&self) -> PreparedInputKind {
self.kind
}
pub fn writes(&self) -> &[PreparedWrite] {
&self.writes
}
pub fn into_writes(self) -> Vec<PreparedWrite> {
self.writes
}
}
pub fn prepare_input(action: InputAction) -> Result<PreparedInput, InputPrepareError> {
prepare_input_with_limits(
action,
TERMINAL_INPUT_CHUNK_MAX_BYTES,
TERMINAL_INPUT_MAX_BYTES,
)
}
pub fn normalize_semantic_prompt(text: &str) -> Result<String, InputPrepareError> {
if text.len() > SEMANTIC_PROMPT_MAX_BYTES {
return Err(InputPrepareError::InputTooLarge {
bytes: text.len(),
max: SEMANTIC_PROMPT_MAX_BYTES,
});
}
Ok(sanitize_prompt_text(text))
}
pub fn prepare_input_with_limits(
action: InputAction,
max_chunk_bytes: usize,
max_total_bytes: usize,
) -> Result<PreparedInput, InputPrepareError> {
if max_chunk_bytes == 0 {
return Err(InputPrepareError::ZeroChunkLimit);
}
match action {
InputAction::InsertDraft(payload) => {
prepare_prompt(payload, false, max_chunk_bytes, max_total_bytes)
}
InputAction::SubmitPrompt(payload) => {
prepare_prompt(payload, true, max_chunk_bytes, max_total_bytes)
}
InputAction::TerminalText(text) => {
if let Some((index, character)) = text
.text
.char_indices()
.find(|(_, character)| character.is_control())
{
return Err(InputPrepareError::ControlCharacterInTerminalText {
index,
codepoint: character as u32,
});
}
bounded_chunks(&text.text, max_chunk_bytes, max_total_bytes).map(|chunks| {
PreparedInput {
kind: PreparedInputKind::TerminalText,
writes: chunks
.into_iter()
.map(|bytes| PreparedWrite {
kind: PreparedWriteKind::Data,
bytes,
delay_before_ms: 0,
})
.collect(),
}
})
}
InputAction::TerminalBytes(bytes) => {
if bytes.is_empty() {
return Err(InputPrepareError::EmptyTerminalBytes);
}
let max_bytes = TERMINAL_BYTES_MAX_BYTES
.min(max_chunk_bytes)
.min(max_total_bytes);
if bytes.len() > max_bytes {
return Err(InputPrepareError::InputTooLarge {
bytes: bytes.len(),
max: max_bytes,
});
}
Ok(PreparedInput {
kind: PreparedInputKind::TerminalBytes,
writes: vec![PreparedWrite {
kind: PreparedWriteKind::Control,
bytes,
delay_before_ms: 0,
}],
})
}
InputAction::TerminalControl(control) => Ok(PreparedInput {
kind: PreparedInputKind::TerminalControl,
writes: vec![PreparedWrite {
kind: PreparedWriteKind::Control,
bytes: control.bytes().to_vec(),
delay_before_ms: 0,
}],
}),
InputAction::AgentCommand(_) => Err(InputPrepareError::AgentDispatcherRequired),
InputAction::ShellCommand(_) => Err(InputPrepareError::ShellDispatcherRequired),
}
}
pub fn prepare_agent_command(
command: AgentCommand,
target_agent: &AgentId,
) -> Result<PreparedInput, InputPrepareError> {
if &command.agent_id != target_agent {
return Err(InputPrepareError::AgentTargetMismatch {
command_agent: command.agent_id,
target_agent: target_agent.clone(),
});
}
if command.name.is_empty()
|| command.name.len() > 128
|| !command.name.chars().all(|character| {
character.is_ascii_lowercase()
|| character.is_ascii_digit()
|| matches!(character, '-' | '_')
})
{
return Err(InputPrepareError::InvalidAgentCommandName(command.name));
}
let mut text = format!("/{}", command.name);
for (argument_index, argument) in command.arguments.iter().enumerate() {
if argument.is_empty()
|| argument
.chars()
.any(|character| character.is_control() || character == '\u{1b}')
{
return Err(InputPrepareError::InvalidAgentCommandArgument { argument_index });
}
text.push(' ');
text.push_str(argument);
}
let chunks = bounded_chunks(
&text,
TERMINAL_INPUT_CHUNK_MAX_BYTES,
TERMINAL_INPUT_MAX_BYTES,
)?;
let mut writes: Vec<_> = chunks
.into_iter()
.map(|bytes| PreparedWrite {
kind: PreparedWriteKind::Data,
bytes,
delay_before_ms: 0,
})
.collect();
writes.push(PreparedWrite {
kind: PreparedWriteKind::Submit,
bytes: TerminalControl::Enter.bytes().to_vec(),
delay_before_ms: TERMINAL_SUBMIT_DELAY_MS,
});
Ok(PreparedInput {
kind: PreparedInputKind::AgentCommand,
writes,
})
}
pub fn prepare_shell_command(command: ShellCommand) -> Result<PreparedInput, InputPrepareError> {
if command.text.trim().is_empty() {
return Err(InputPrepareError::EmptyShellCommand);
}
if let Some((index, character)) = command
.text
.char_indices()
.find(|(_, character)| character.is_control())
{
return Err(InputPrepareError::ControlCharacterInShellCommand {
index,
codepoint: character as u32,
});
}
let chunks = bounded_chunks(
&command.text,
TERMINAL_INPUT_CHUNK_MAX_BYTES,
TERMINAL_INPUT_MAX_BYTES,
)?;
let mut writes: Vec<_> = chunks
.into_iter()
.map(|bytes| PreparedWrite {
kind: PreparedWriteKind::Data,
bytes,
delay_before_ms: 0,
})
.collect();
writes.push(PreparedWrite {
kind: PreparedWriteKind::Submit,
bytes: TerminalControl::Enter.bytes().to_vec(),
delay_before_ms: TERMINAL_SUBMIT_DELAY_MS,
});
Ok(PreparedInput {
kind: PreparedInputKind::ShellCommand,
writes,
})
}
pub fn shift_enter_sequence(encoding: WindowsPasteNewline) -> &'static [u8] {
shift_enter_str(encoding).as_bytes()
}
pub fn ctrl_enter_sequence() -> &'static [u8] {
b"\x1b[13;5u"
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct PtyHostGates {
pub platform: RuntimePlatform,
pub kitty_flags: u32,
pub modify_other_keys: u32,
pub local_windows_conpty: bool,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PtyShortcut {
ShiftEnter,
AltEnter,
CtrlEnter,
CtrlBackspace,
CmdBackspace,
CmdDelete,
CmdArrowLeft,
CmdArrowRight,
AltBackspace,
AltDelete {
numpad: bool,
non_agent_fullscreen: bool,
},
AltArrowLeft,
AltArrowRight,
CtrlArrowLeft,
CtrlArrowRight,
}
pub fn local_plain(platform: RuntimePlatform) -> PtyHostGates {
PtyHostGates {
platform,
kitty_flags: 0,
modify_other_keys: 0,
local_windows_conpty: platform == RuntimePlatform::Windows,
}
}
pub fn encode_pty_shortcut(
shortcut: PtyShortcut,
contract: &PtySubmitContract,
host: PtyHostGates,
) -> Option<&'static [u8]> {
match shortcut {
PtyShortcut::ShiftEnter => Some(encode_shift_enter(contract, host)),
PtyShortcut::AltEnter => encode_alt_enter(host),
PtyShortcut::CtrlEnter => Some(encode_ctrl_enter(contract, host)),
PtyShortcut::CtrlBackspace => Some(b"\x17"),
PtyShortcut::CmdBackspace => mac_command(host, b"\x15"),
PtyShortcut::CmdDelete => mac_command(host, b"\x0b"),
PtyShortcut::CmdArrowLeft => mac_command(host, b"\x01"),
PtyShortcut::CmdArrowRight => mac_command(host, b"\x05"),
PtyShortcut::AltBackspace => {
if host.kitty_flags > 0 {
None
} else {
Some(b"\x1b\x7f")
}
}
PtyShortcut::AltDelete {
numpad,
non_agent_fullscreen,
} => {
if host.platform == RuntimePlatform::MacOs
&& !numpad
&& !non_agent_fullscreen
&& host.kitty_flags == 0
{
Some(b"\x1bd")
} else {
None
}
}
PtyShortcut::AltArrowLeft => {
word_motion(host.kitty_flags > 0 || host.local_windows_conpty, b"\x1bb")
}
PtyShortcut::AltArrowRight => {
word_motion(host.kitty_flags > 0 || host.local_windows_conpty, b"\x1bf")
}
PtyShortcut::CtrlArrowLeft => word_motion(
host.platform == RuntimePlatform::MacOs || host.local_windows_conpty,
b"\x1bb",
),
PtyShortcut::CtrlArrowRight => word_motion(
host.platform == RuntimePlatform::MacOs || host.local_windows_conpty,
b"\x1bf",
),
}
}
fn encode_shift_enter(contract: &PtySubmitContract, host: PtyHostGates) -> &'static [u8] {
let windows_host = host.platform == RuntimePlatform::Windows;
let trusted_windows_csi_u =
windows_host && contract.windows_shift_enter == Some(ModifiedEnterEncoding::CsiU);
let can_csi_u = trusted_windows_csi_u || host.kitty_flags > 0;
if can_csi_u {
shift_enter_sequence(WindowsPasteNewline::CsiU)
} else if host.modify_other_keys > 0 {
b"\x1b[27;2;13~"
} else {
shift_enter_sequence(WindowsPasteNewline::AltEnter)
}
}
fn encode_alt_enter(host: PtyHostGates) -> Option<&'static [u8]> {
if host.kitty_flags > 0 {
None
} else if host.modify_other_keys > 0 {
Some(b"\x1b[27;3;13~")
} else {
None
}
}
fn encode_ctrl_enter(contract: &PtySubmitContract, host: PtyHostGates) -> &'static [u8] {
let can_csi_u = !host.local_windows_conpty
|| host.kitty_flags > 0
|| contract.ctrl_enter == Some(ModifiedEnterEncoding::CsiU);
if can_csi_u {
ctrl_enter_sequence()
} else {
b"\r"
}
}
fn mac_command(host: PtyHostGates, bytes: &'static [u8]) -> Option<&'static [u8]> {
if host.platform == RuntimePlatform::MacOs {
Some(bytes)
} else {
None
}
}
fn word_motion(suppressed: bool, bytes: &'static [u8]) -> Option<&'static [u8]> {
if suppressed {
None
} else {
Some(bytes)
}
}
pub fn prepare_pty_shortcut(
shortcut: PtyShortcut,
contract: &PtySubmitContract,
host: PtyHostGates,
) -> Option<PreparedInput> {
let bytes = encode_pty_shortcut(shortcut, contract, host)?;
Some(PreparedInput {
kind: PreparedInputKind::TerminalControl,
writes: vec![PreparedWrite {
kind: PreparedWriteKind::Control,
bytes: bytes.to_vec(),
delay_before_ms: 0,
}],
})
}
fn shift_enter_str(encoding: WindowsPasteNewline) -> &'static str {
match encoding {
WindowsPasteNewline::AltEnter => "\u{1b}\r",
WindowsPasteNewline::CsiU => "\u{1b}[13;2u",
}
}
pub fn prepare_agent_prompt(
text: &str,
submit: bool,
contract: &PtySubmitContract,
platform: RuntimePlatform,
lead: Option<&str>,
) -> Result<PreparedInput, InputPrepareError> {
if text.len() > TERMINAL_INPUT_MAX_BYTES {
return Err(InputPrepareError::InputTooLarge {
bytes: text.len(),
max: TERMINAL_INPUT_MAX_BYTES,
});
}
let input_record = (platform == RuntimePlatform::Windows)
.then_some(contract.windows_paste_newline)
.flatten();
let mut framed = String::new();
if contract.paste_needs_typed_request {
if let Some(lead) = lead {
framed.push_str(&fold_typed_request_lead(lead));
}
}
if let Some(newline) = input_record {
framed.push_str(&encode_windows_input_record_paste_text(text, newline));
} else {
let body = sanitize_prompt_text(text);
framed.push_str("\u{1b}[200~");
framed.push_str(&body);
framed.push_str("\u{1b}[201~");
debug_assert_eq!("\u{1b}[200~".as_bytes(), BRACKETED_PASTE_START);
debug_assert_eq!("\u{1b}[201~".as_bytes(), BRACKETED_PASTE_END);
}
if framed.len() > TERMINAL_INPUT_MAX_BYTES {
return Err(InputPrepareError::InputTooLarge {
bytes: framed.len(),
max: TERMINAL_INPUT_MAX_BYTES,
});
}
let framed_len = framed.len();
let mut chunks = if input_record.is_some() {
bounded_chunks_atomic_records(
&framed,
TERMINAL_INPUT_CHUNK_MAX_BYTES,
TERMINAL_INPUT_MAX_BYTES,
)?
} else {
bounded_chunks(
&framed,
TERMINAL_INPUT_CHUNK_MAX_BYTES,
TERMINAL_INPUT_MAX_BYTES,
)?
};
if submit && contract.submit_joins_paste_frame {
match chunks.last_mut() {
Some(last) => last.extend_from_slice(b"\r"),
None => chunks.push(b"\r".to_vec()),
}
}
let mut writes: Vec<_> = chunks
.into_iter()
.map(|bytes| PreparedWrite {
kind: PreparedWriteKind::Data,
bytes,
delay_before_ms: 0,
})
.collect();
if submit && !contract.submit_joins_paste_frame {
writes.push(PreparedWrite {
kind: PreparedWriteKind::Submit,
bytes: TerminalControl::Enter.bytes().to_vec(),
delay_before_ms: separate_submit_delay_ms(text, framed_len, contract, platform),
});
}
Ok(PreparedInput {
kind: if submit {
PreparedInputKind::SubmitPrompt
} else {
PreparedInputKind::InsertDraft
},
writes,
})
}
fn separate_submit_delay_ms(
prompt: &str,
framed_len: usize,
contract: &PtySubmitContract,
platform: RuntimePlatform,
) -> u64 {
TERMINAL_SUBMIT_DELAY_MS
.saturating_add(paste_ingest_ms(framed_len, platform))
.saturating_add(line_settle_ms(prompt, contract.submit_line_settle_ms_per_line))
}
fn paste_ingest_ms(utf8_len: usize, platform: RuntimePlatform) -> u64 {
if utf8_len == 0 {
return 0;
}
let divisor: u64 = if platform == RuntimePlatform::Windows {
64
} else {
4096
};
(utf8_len as u64).div_ceil(divisor)
}
fn line_settle_ms(prompt: &str, per_line: u64) -> u64 {
if per_line == 0 {
return 0;
}
let line_count = (prompt.matches('\n').count() as u64).saturating_add(1).max(1);
line_count.saturating_mul(per_line)
}
fn fold_typed_request_lead(lead: &str) -> String {
let mut out = String::new();
let mut last_was_space = false;
let mut any_text = false;
for character in lead.chars() {
if character.is_control() || character == ' ' {
if any_text && !last_was_space {
out.push(' ');
last_was_space = true;
}
} else {
out.push(character);
last_was_space = false;
any_text = true;
}
}
if !any_text {
return String::new();
}
out.push(' ');
out
}
fn encode_windows_input_record_paste_text(text: &str, newline: WindowsPasteNewline) -> String {
let sequence = shift_enter_str(newline);
let mut encoded = String::with_capacity(text.len());
let mut chars = text.chars().peekable();
while let Some(character) = chars.next() {
match character {
'\r' => {
encoded.push_str(sequence);
if chars.peek() == Some(&'\n') {
chars.next();
}
}
'\n' => encoded.push_str(sequence),
'\u{1b}' => encoded.push('\u{241b}'),
other => encoded.push(other),
}
}
encoded
}
fn prepare_prompt(
payload: PromptPayload,
submit: bool,
max_chunk_bytes: usize,
max_total_bytes: usize,
) -> Result<PreparedInput, InputPrepareError> {
if payload.text.len() > max_total_bytes {
return Err(InputPrepareError::InputTooLarge {
bytes: payload.text.len(),
max: max_total_bytes,
});
}
let sanitized = sanitize_prompt_text(&payload.text);
let chunks = bounded_chunks(&sanitized, max_chunk_bytes, max_total_bytes)?;
let mut writes = Vec::with_capacity(chunks.len() + 3);
if payload.framing == PromptFraming::BracketedPaste {
writes.push(PreparedWrite {
kind: PreparedWriteKind::Framing,
bytes: BRACKETED_PASTE_START.to_vec(),
delay_before_ms: 0,
});
}
writes.extend(chunks.into_iter().map(|bytes| PreparedWrite {
kind: PreparedWriteKind::Data,
bytes,
delay_before_ms: 0,
}));
if payload.framing == PromptFraming::BracketedPaste {
writes.push(PreparedWrite {
kind: PreparedWriteKind::Framing,
bytes: BRACKETED_PASTE_END.to_vec(),
delay_before_ms: 0,
});
}
if submit {
writes.push(PreparedWrite {
kind: PreparedWriteKind::Submit,
bytes: TerminalControl::Enter.bytes().to_vec(),
delay_before_ms: TERMINAL_SUBMIT_DELAY_MS,
});
}
Ok(PreparedInput {
kind: if submit {
PreparedInputKind::SubmitPrompt
} else {
PreparedInputKind::InsertDraft
},
writes,
})
}
pub fn sanitize_prompt_text(text: &str) -> String {
let mut sanitized = String::with_capacity(text.len());
for character in text.chars() {
match character {
'\n' | '\r' | '\t' => sanitized.push(character),
'\u{1b}' => sanitized.push_str("<ESC>"),
'\u{009b}' => sanitized.push_str("<CSI>"),
'\u{009d}' => sanitized.push_str("<OSC>"),
value if value.is_control() => {
use std::fmt::Write;
let _ = write!(sanitized, "<U+{:04X}>", value as u32);
}
value => sanitized.push(value),
}
}
sanitized
}
fn bounded_chunks(
text: &str,
max_chunk_bytes: usize,
max_total_bytes: usize,
) -> Result<Vec<Vec<u8>>, InputPrepareError> {
if text.len() > max_total_bytes {
return Err(InputPrepareError::InputTooLarge {
bytes: text.len(),
max: max_total_bytes,
});
}
if text.is_empty() {
return Ok(Vec::new());
}
let mut chunks = Vec::new();
let mut start = 0;
let mut current_bytes = 0;
for (index, character) in text.char_indices() {
let character_bytes = character.len_utf8();
if character_bytes > max_chunk_bytes {
return Err(InputPrepareError::ChunkLimitTooSmall {
bytes: character_bytes,
max: max_chunk_bytes,
});
}
if current_bytes + character_bytes > max_chunk_bytes {
chunks.push(text.as_bytes()[start..index].to_vec());
start = index;
current_bytes = 0;
}
current_bytes += character_bytes;
}
chunks.push(text.as_bytes()[start..].to_vec());
Ok(chunks)
}
fn bounded_chunks_atomic_records(
text: &str,
max_chunk_bytes: usize,
max_total_bytes: usize,
) -> Result<Vec<Vec<u8>>, InputPrepareError> {
if text.len() > max_total_bytes {
return Err(InputPrepareError::InputTooLarge {
bytes: text.len(),
max: max_total_bytes,
});
}
if text.is_empty() {
return Ok(Vec::new());
}
let mut chunks = Vec::new();
let mut current = Vec::new();
let mut rest = text;
while !rest.is_empty() {
let piece = next_atomic_record(rest);
let bytes = piece.as_bytes();
if bytes.len() > max_chunk_bytes {
return Err(InputPrepareError::ChunkLimitTooSmall {
bytes: bytes.len(),
max: max_chunk_bytes,
});
}
if !current.is_empty() && current.len() + bytes.len() > max_chunk_bytes {
chunks.push(std::mem::take(&mut current));
}
current.extend_from_slice(bytes);
rest = &rest[piece.len()..];
}
if !current.is_empty() {
chunks.push(current);
}
Ok(chunks)
}
fn next_atomic_record(text: &str) -> &str {
let Some(first) = text.chars().next() else {
return "";
};
if first != '\u{1b}' {
return &text[..first.len_utf8()];
}
let bytes = text.as_bytes();
if bytes.len() >= 2 && bytes[1] == b'\r' {
return &text[..2];
}
const CSI_U: &str = "\u{1b}[13;2u";
if text.starts_with(CSI_U) {
return &text[..CSI_U.len()];
}
&text[..first.len_utf8()]
}
#[derive(Clone, Debug, Deserialize, Eq, Error, PartialEq, Serialize)]
pub enum InputPrepareError {
#[error("terminal input chunk limit cannot be zero")]
ZeroChunkLimit,
#[error("input is {bytes} bytes; the configured limit is {max} bytes")]
InputTooLarge { bytes: usize, max: usize },
#[error("a {bytes}-byte UTF-8 code point does not fit the {max}-byte chunk limit")]
ChunkLimitTooSmall { bytes: usize, max: usize },
#[error("terminal byte sequence cannot be empty")]
EmptyTerminalBytes,
#[error(
"terminal text contains control U+{codepoint:04X} at byte {index}; use TerminalControl"
)]
ControlCharacterInTerminalText { index: usize, codepoint: u32 },
#[error("agent commands require a provider-specific capability dispatcher")]
AgentDispatcherRequired,
#[error("agent command targets '{command_agent}', but foreground dispatcher selected '{target_agent}'")]
AgentTargetMismatch {
command_agent: AgentId,
target_agent: AgentId,
},
#[error("invalid agent command name '{0}'")]
InvalidAgentCommandName(String),
#[error("agent command argument {argument_index} is empty or contains terminal controls")]
InvalidAgentCommandArgument { argument_index: usize },
#[error("shell commands require a confirmed foreground shell dispatcher")]
ShellDispatcherRequired,
#[error("shell command cannot be empty")]
EmptyShellCommand,
#[error("shell command contains control U+{codepoint:04X} at byte {index}")]
ControlCharacterInShellCommand { index: usize, codepoint: u32 },
}
#[cfg(test)]
mod tests {
use super::*;
fn payload(text: &str) -> PromptPayload {
PromptPayload {
text: text.to_owned(),
framing: PromptFraming::BracketedPaste,
}
}
#[test]
fn draft_and_submit_have_distinct_write_sequences() {
let draft = prepare_input(InputAction::InsertDraft(payload("hello"))).unwrap();
let submit = prepare_input(InputAction::SubmitPrompt(payload("hello"))).unwrap();
assert_eq!(draft.writes.last().unwrap().bytes, BRACKETED_PASTE_END);
assert_eq!(
submit.writes.last().unwrap().kind,
PreparedWriteKind::Submit
);
assert_eq!(submit.writes.last().unwrap().bytes, b"\r");
assert_eq!(
submit.writes.last().unwrap().delay_before_ms,
TERMINAL_SUBMIT_DELAY_MS
);
}
#[test]
fn prompt_controls_are_inert_inside_bracketed_paste() {
let prepared = prepare_input(InputAction::InsertDraft(payload("a\x1b[31m\0b"))).unwrap();
let joined: Vec<u8> = prepared
.writes
.iter()
.flat_map(|write| write.bytes.iter().copied())
.collect();
assert_eq!(
String::from_utf8(joined).unwrap(),
"\x1b[200~a<ESC>[31m<U+0000>b\x1b[201~"
);
}
#[test]
fn chunks_never_split_unicode() {
let prepared = prepare_input_with_limits(
InputAction::TerminalText(TerminalText {
text: "aЖ🙂b".to_owned(),
}),
4,
32,
)
.unwrap();
let decoded: Vec<_> = prepared
.writes
.iter()
.map(|write| std::str::from_utf8(&write.bytes).unwrap())
.collect();
assert_eq!(decoded, ["aЖ", "🙂", "b"]);
}
#[test]
fn raw_controls_require_the_control_variant() {
let error = prepare_input(InputAction::TerminalText(TerminalText {
text: "hello\n".to_owned(),
}))
.unwrap_err();
assert!(matches!(
error,
InputPrepareError::ControlCharacterInTerminalText { .. }
));
}
#[test]
fn terminal_bytes_preserve_one_bounded_sequence_without_framing() {
let sequence = b"\x1b[1;5D".to_vec();
let prepared = prepare_input(InputAction::TerminalBytes(sequence.clone())).unwrap();
assert_eq!(prepared.kind(), PreparedInputKind::TerminalBytes);
assert_eq!(
prepared.writes(),
&[PreparedWrite {
kind: PreparedWriteKind::Control,
bytes: sequence,
delay_before_ms: 0,
}]
);
}
#[test]
fn terminal_bytes_reject_empty_and_oversized_sequences() {
assert_eq!(
prepare_input(InputAction::TerminalBytes(Vec::new())).unwrap_err(),
InputPrepareError::EmptyTerminalBytes,
);
assert_eq!(
prepare_input(InputAction::TerminalBytes(vec![0; TERMINAL_BYTES_MAX_BYTES + 1]))
.unwrap_err(),
InputPrepareError::InputTooLarge {
bytes: TERMINAL_BYTES_MAX_BYTES + 1,
max: TERMINAL_BYTES_MAX_BYTES,
},
);
}
#[test]
fn arrow_controls_preserve_terminal_escape_sequences() {
assert_eq!(TerminalControl::ArrowUp.bytes(), b"\x1b[A");
assert_eq!(TerminalControl::ArrowDown.bytes(), b"\x1b[B");
assert_eq!(TerminalControl::ArrowRight.bytes(), b"\x1b[C");
assert_eq!(TerminalControl::ArrowLeft.bytes(), b"\x1b[D");
}
#[test]
fn interactive_terminal_controls_preserve_xterm_sequences() {
assert_eq!(TerminalControl::BackTab.bytes(), b"\x1b[Z");
assert_eq!(TerminalControl::Insert.bytes(), b"\x1b[2~");
assert_eq!(TerminalControl::Delete.bytes(), b"\x1b[3~");
assert_eq!(TerminalControl::Home.bytes(), b"\x1b[H");
assert_eq!(TerminalControl::End.bytes(), b"\x1b[F");
assert_eq!(TerminalControl::PageUp.bytes(), b"\x1b[5~");
assert_eq!(TerminalControl::PageDown.bytes(), b"\x1b[6~");
assert_eq!(TerminalControl::Function1.bytes(), b"\x1bOP");
assert_eq!(TerminalControl::Function12.bytes(), b"\x1b[24~");
assert_eq!(TerminalControl::ControlA.bytes(), b"\x01");
assert_eq!(TerminalControl::ControlZ.bytes(), b"\x1a");
}
#[test]
fn agent_command_is_target_bound_and_delays_submit() {
let agent = AgentId::new("codex").unwrap();
let prepared = prepare_agent_command(
AgentCommand {
agent_id: agent.clone(),
name: "review".to_owned(),
arguments: vec!["focus on PTY ordering".to_owned()],
},
&agent,
)
.unwrap();
assert_eq!(prepared.writes[0].bytes, b"/review focus on PTY ordering");
assert_eq!(
prepared.writes.last().unwrap().delay_before_ms,
TERMINAL_SUBMIT_DELAY_MS
);
}
#[test]
fn agent_command_rejects_controls_and_foreign_targets() {
let codex = AgentId::new("codex").unwrap();
let kimi = AgentId::new("kimi").unwrap();
let foreign = prepare_agent_command(
AgentCommand {
agent_id: codex.clone(),
name: "help".to_owned(),
arguments: Vec::new(),
},
&kimi,
)
.unwrap_err();
assert!(matches!(
foreign,
InputPrepareError::AgentTargetMismatch { .. }
));
let control = prepare_agent_command(
AgentCommand {
agent_id: codex.clone(),
name: "rename".to_owned(),
arguments: vec!["unsafe\rsubmit".to_owned()],
},
&codex,
)
.unwrap_err();
assert!(matches!(
control,
InputPrepareError::InvalidAgentCommandArgument { .. }
));
}
#[test]
fn shell_command_preserves_syntax_and_submits_separately() {
let prepared = prepare_shell_command(ShellCommand {
text: "printf '%s' \"hello world\" | sed 's/world/shell/'".to_owned(),
})
.unwrap();
assert_eq!(prepared.kind(), PreparedInputKind::ShellCommand);
assert_eq!(
prepared.writes[0].bytes,
b"printf '%s' \"hello world\" | sed 's/world/shell/'"
);
assert_eq!(prepared.writes.last().unwrap().bytes, b"\r");
assert_eq!(
prepared.writes.last().unwrap().delay_before_ms,
TERMINAL_SUBMIT_DELAY_MS
);
}
fn claude_contract() -> PtySubmitContract {
PtySubmitContract {
paste_needs_typed_request: true,
ctrl_enter: Some(crate::ModifiedEnterEncoding::CsiU),
..PtySubmitContract::default()
}
}
#[test]
fn prepare_agent_prompt_omp_joins_enter_into_the_paste_frame() {
let contract = PtySubmitContract {
submit_joins_paste_frame: true,
..PtySubmitContract::default()
};
let prepared = prepare_agent_prompt(
"brief",
true,
&contract,
crate::RuntimePlatform::Linux,
None,
)
.unwrap();
assert_eq!(prepared.writes().len(), 1);
assert!(prepared.writes()[0].bytes.ends_with(b"\x1b[201~\r"));
assert!(prepared
.writes()
.iter()
.all(|write| write.kind != PreparedWriteKind::Submit));
let mut expected = BRACKETED_PASTE_START.to_vec();
expected.extend_from_slice(b"brief");
expected.extend_from_slice(BRACKETED_PASTE_END);
expected.extend_from_slice(b"\r");
assert_eq!(prepared.writes()[0].bytes, expected);
}
#[test]
fn prepare_agent_prompt_claude_lead_is_outside_the_frame() {
let lead = "Please\r\nfollow\x03\x1b[201~\x7f";
let prepared = prepare_agent_prompt(
"brief",
true,
&claude_contract(),
crate::RuntimePlatform::Linux,
Some(lead),
)
.unwrap();
let mut frame = b"Please follow [201~ ".to_vec();
frame.extend_from_slice(BRACKETED_PASTE_START);
frame.extend_from_slice(b"brief");
frame.extend_from_slice(BRACKETED_PASTE_END);
assert_eq!(prepared.writes().len(), 2);
assert_eq!(prepared.writes()[0].bytes, frame);
assert_eq!(prepared.writes()[1].kind, PreparedWriteKind::Submit);
assert_eq!(prepared.writes()[1].bytes, b"\r");
let ingest = (frame.len() as u64).div_ceil(4096);
assert_eq!(
prepared.writes()[1].delay_before_ms,
TERMINAL_SUBMIT_DELAY_MS + ingest
);
let empty_lead = prepare_agent_prompt(
"brief",
false,
&claude_contract(),
crate::RuntimePlatform::Linux,
Some(""),
)
.unwrap();
assert_eq!(
empty_lead.writes()[0].bytes,
{
let mut bare = BRACKETED_PASTE_START.to_vec();
bare.extend_from_slice(b"brief");
bare.extend_from_slice(BRACKETED_PASTE_END);
bare
}
);
}
#[test]
fn prepare_agent_prompt_antigravity_line_settle_scales_with_newlines() {
let antigravity = PtySubmitContract {
submit_line_settle_ms_per_line: 45,
..PtySubmitContract::default()
};
let one = prepare_agent_prompt(
"one",
true,
&antigravity,
crate::RuntimePlatform::Linux,
None,
)
.unwrap();
let many = prepare_agent_prompt(
&"\n".repeat(100),
true,
&antigravity,
crate::RuntimePlatform::MacOs,
None,
)
.unwrap();
let aider = prepare_agent_prompt(
"one",
true,
&PtySubmitContract::default(),
crate::RuntimePlatform::Linux,
None,
)
.unwrap();
let one_delay = one.writes().last().unwrap().delay_before_ms;
let many_delay = many.writes().last().unwrap().delay_before_ms;
let aider_delay = aider.writes().last().unwrap().delay_before_ms;
assert!(many_delay - one_delay >= 4_500);
assert_eq!(aider_delay, one_delay - 45);
assert!(one_delay > TERMINAL_SUBMIT_DELAY_MS);
}
#[test]
fn prepare_input_submit_keeps_separate_enter_delay() {
let prepared = prepare_input(InputAction::SubmitPrompt(payload("brief"))).unwrap();
let submit = prepared
.writes()
.iter()
.find(|write| write.kind == PreparedWriteKind::Submit)
.unwrap();
assert_eq!(submit.bytes, b"\r");
assert_eq!(submit.delay_before_ms, 500);
assert!(prepared.writes().len() > 1);
}
#[test]
fn shell_command_rejects_empty_and_control_bearing_text() {
assert_eq!(
prepare_shell_command(ShellCommand {
text: " ".to_owned(),
})
.unwrap_err(),
InputPrepareError::EmptyShellCommand
);
assert!(matches!(
prepare_shell_command(ShellCommand {
text: "echo first\necho second".to_owned(),
})
.unwrap_err(),
InputPrepareError::ControlCharacterInShellCommand {
index: 10,
codepoint: 10
}
));
}
fn windows_newline(encoding: crate::WindowsPasteNewline) -> PtySubmitContract {
PtySubmitContract {
windows_paste_newline: Some(encoding),
..PtySubmitContract::default()
}
}
#[test]
fn encode_windows_alt_enter_rewrites_a_newline_without_brackets() {
let prepared = prepare_agent_prompt(
"a\nb",
true,
&windows_newline(crate::WindowsPasteNewline::AltEnter),
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
assert_eq!(prepared.writes().len(), 2);
assert_eq!(prepared.writes()[0].bytes, b"a\x1b\rb");
assert!(
!prepared.writes()[0].bytes.windows(6).any(|window| {
window == b"\x1b[200~" || window == b"\x1b[201~"
})
);
assert_eq!(prepared.writes()[1].kind, PreparedWriteKind::Submit);
assert_eq!(prepared.writes()[1].bytes, b"\r");
assert!(!prepared.writes()[0].bytes.windows(7).any(|window| window == b"\x1b[13;5u"));
}
#[test]
fn encode_windows_csi_u_newline_is_shift_enter() {
let prepared = prepare_agent_prompt(
"a\nb",
false,
&windows_newline(crate::WindowsPasteNewline::CsiU),
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
assert_eq!(prepared.writes().len(), 1);
assert_eq!(prepared.writes()[0].bytes, b"a\x1b[13;2ub");
}
#[test]
fn encode_windows_crlf_is_one_alt_enter() {
let contract = windows_newline(crate::WindowsPasteNewline::AltEnter);
let crlf = prepare_agent_prompt(
"a\r\nb",
false,
&contract,
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
let lf = prepare_agent_prompt(
"a\nb",
false,
&contract,
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
let cr = prepare_agent_prompt(
"a\rb",
false,
&contract,
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
assert_eq!(crlf.writes()[0].bytes, b"a\x1b\rb");
assert_eq!(crlf.writes()[0].bytes, lf.writes()[0].bytes);
assert_eq!(cr.writes()[0].bytes, lf.writes()[0].bytes);
let two = prepare_agent_prompt(
"a\r\n\r\nb",
false,
&contract,
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
assert_eq!(two.writes()[0].bytes, b"a\x1b\r\x1b\rb");
}
#[test]
fn encode_windows_esc_becomes_symbol_for_escape() {
let prepared = prepare_agent_prompt(
"a\u{1b}b",
false,
&windows_newline(crate::WindowsPasteNewline::AltEnter),
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
assert_eq!(prepared.writes()[0].bytes, "a\u{241b}b".as_bytes());
assert!(!prepared.writes()[0]
.bytes
.windows(5)
.any(|window| window == b"<ESC>"));
}
#[test]
fn encode_windows_lead_stays_outside_the_newline_encoder() {
let contract = PtySubmitContract {
paste_needs_typed_request: true,
windows_paste_newline: Some(crate::WindowsPasteNewline::AltEnter),
..PtySubmitContract::default()
};
let prepared = prepare_agent_prompt(
"a\nb",
false,
&contract,
crate::RuntimePlatform::Windows,
Some("Please\r\nfollow\x03\x1b[201~\x7f"),
)
.unwrap();
assert_eq!(prepared.writes()[0].bytes, b"Please follow [201~ a\x1b\rb");
assert!(
!prepared.writes()[0]
.bytes
.windows(6)
.any(|window| window == b"\x1b[200~" || window == b"\x1b[201~")
);
}
#[test]
fn encode_windows_newline_is_not_split_across_chunks() {
let mut body = "a".repeat(TERMINAL_INPUT_CHUNK_MAX_BYTES - 1);
body.push('\n');
body.push('b');
let prepared = prepare_agent_prompt(
&body,
false,
&windows_newline(crate::WindowsPasteNewline::AltEnter),
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
assert_eq!(prepared.writes().len(), 2);
assert_eq!(
prepared.writes()[0].bytes,
vec![b'a'; TERMINAL_INPUT_CHUNK_MAX_BYTES - 1]
);
assert_eq!(prepared.writes()[1].bytes, b"\x1b\rb");
}
#[test]
fn encode_windows_newline_stays_bracketed_off_windows() {
let contract = windows_newline(crate::WindowsPasteNewline::AltEnter);
for platform in [
crate::RuntimePlatform::Linux,
crate::RuntimePlatform::MacOs,
crate::RuntimePlatform::Wsl,
] {
let prepared = prepare_agent_prompt("a\nb\u{1b}c", false, &contract, platform, None)
.unwrap();
let joined: Vec<u8> = prepared
.writes()
.iter()
.flat_map(|write| write.bytes.iter().copied())
.collect();
assert_eq!(
String::from_utf8(joined).unwrap(),
"\u{1b}[200~a\nb<ESC>c\u{1b}[201~"
);
}
}
#[test]
fn encode_windows_without_newline_contract_stays_bracketed() {
let prepared = prepare_agent_prompt(
"a\nb\u{1b}c",
false,
&PtySubmitContract::default(),
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
let joined: Vec<u8> = prepared
.writes()
.iter()
.flat_map(|write| write.bytes.iter().copied())
.collect();
assert_eq!(
String::from_utf8(joined).unwrap(),
"\u{1b}[200~a\nb<ESC>c\u{1b}[201~"
);
}
#[test]
fn shift_enter_sequence_matches_the_newline_encoder() {
assert_eq!(
shift_enter_sequence(crate::WindowsPasteNewline::AltEnter),
b"\x1b\r"
);
assert_eq!(
shift_enter_sequence(crate::WindowsPasteNewline::CsiU),
b"\x1b[13;2u"
);
}
#[test]
fn ctrl_enter_sequence_is_csi_u_and_is_not_a_paste_newline() {
assert_eq!(ctrl_enter_sequence(), b"\x1b[13;5u");
let prepared = prepare_agent_prompt(
"a\nb",
true,
&windows_newline(crate::WindowsPasteNewline::CsiU),
crate::RuntimePlatform::Windows,
None,
)
.unwrap();
let joined: Vec<u8> = prepared
.writes()
.iter()
.flat_map(|write| write.bytes.iter().copied())
.collect();
assert!(!joined.windows(7).any(|window| window == b"\x1b[13;5u"));
assert_eq!(prepared.writes().last().unwrap().bytes, b"\r");
}
fn csi_u_contract(shift: bool, ctrl: bool) -> PtySubmitContract {
PtySubmitContract {
windows_shift_enter: shift.then_some(crate::ModifiedEnterEncoding::CsiU),
ctrl_enter: ctrl.then_some(crate::ModifiedEnterEncoding::CsiU),
..PtySubmitContract::default()
}
}
fn gates(platform: RuntimePlatform, kitty: u32, modify: u32, conpty: bool) -> PtyHostGates {
PtyHostGates {
platform,
kitty_flags: kitty,
modify_other_keys: modify,
local_windows_conpty: conpty,
}
}
#[test]
fn local_plain_conpty_is_windows_only() {
assert!(local_plain(RuntimePlatform::Windows).local_windows_conpty);
for platform in [
RuntimePlatform::MacOs,
RuntimePlatform::Linux,
RuntimePlatform::Wsl,
] {
let host = local_plain(platform);
assert!(!host.local_windows_conpty);
assert_eq!(host.kitty_flags, 0);
assert_eq!(host.modify_other_keys, 0);
}
}
#[test]
fn encode_pty_shortcut_shift_enter_follows_the_csi_u_gate() {
let csi_u = b"\x1b[13;2u".as_slice();
let fallback = b"\x1b\r".as_slice();
let modify = b"\x1b[27;2;13~".as_slice();
assert_eq!(csi_u, shift_enter_sequence(crate::WindowsPasteNewline::CsiU));
assert_eq!(fallback, shift_enter_sequence(crate::WindowsPasteNewline::AltEnter));
assert_eq!(
encode_pty_shortcut(
PtyShortcut::ShiftEnter,
&csi_u_contract(true, false),
local_plain(RuntimePlatform::Windows),
),
Some(csi_u)
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::ShiftEnter,
&csi_u_contract(true, false),
local_plain(RuntimePlatform::MacOs),
),
Some(fallback)
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::ShiftEnter,
&csi_u_contract(false, false),
gates(RuntimePlatform::Linux, 1, 0, false),
),
Some(csi_u)
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::ShiftEnter,
&csi_u_contract(false, false),
gates(RuntimePlatform::Linux, 0, 1, false),
),
Some(modify)
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::ShiftEnter,
&csi_u_contract(true, false),
local_plain(RuntimePlatform::Wsl),
),
Some(fallback)
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::ShiftEnter,
&csi_u_contract(true, false),
gates(RuntimePlatform::MacOs, 0, 4, false),
),
Some(modify)
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::ShiftEnter,
&csi_u_contract(false, false),
gates(RuntimePlatform::Windows, 0, 2, true),
),
Some(modify)
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::ShiftEnter,
&PtySubmitContract::default(),
local_plain(RuntimePlatform::Windows),
),
Some(fallback)
);
}
#[test]
fn encode_pty_shortcut_alt_enter_is_modify_other_keys_or_nothing() {
let modifier_3 = b"\x1b[27;3;13~".as_slice();
assert_eq!(
encode_pty_shortcut(
PtyShortcut::AltEnter,
&PtySubmitContract::default(),
gates(RuntimePlatform::Linux, 1, 9, false),
),
None
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::AltEnter,
&PtySubmitContract::default(),
local_plain(RuntimePlatform::MacOs),
),
None
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::AltEnter,
&PtySubmitContract::default(),
gates(RuntimePlatform::Windows, 0, 1, true),
),
Some(modifier_3)
);
}
#[test]
fn encode_pty_shortcut_ctrl_enter_is_cr_only_on_local_conpty() {
let csi_u = ctrl_enter_sequence();
assert_eq!(csi_u, b"\x1b[13;5u");
let conpty = gates(RuntimePlatform::Windows, 0, 0, true);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CtrlEnter, &PtySubmitContract::default(), conpty),
Some(b"\r".as_slice())
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::CtrlEnter,
&PtySubmitContract::default(),
gates(RuntimePlatform::Windows, 2, 0, true),
),
Some(csi_u)
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::CtrlEnter,
&csi_u_contract(false, true),
conpty,
),
Some(csi_u)
);
for platform in [
RuntimePlatform::MacOs,
RuntimePlatform::Linux,
RuntimePlatform::Wsl,
] {
assert_eq!(
encode_pty_shortcut(
PtyShortcut::CtrlEnter,
&PtySubmitContract::default(),
local_plain(platform),
),
Some(csi_u)
);
}
assert_eq!(
encode_pty_shortcut(
PtyShortcut::CtrlEnter,
&PtySubmitContract::default(),
gates(RuntimePlatform::Windows, 0, 0, false),
),
Some(csi_u)
);
}
#[test]
fn encode_pty_shortcut_editing_and_word_motion() {
let plain = PtySubmitContract::default();
let mac = local_plain(RuntimePlatform::MacOs);
let linux = local_plain(RuntimePlatform::Linux);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CmdBackspace, &plain, mac),
Some(b"\x15".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CmdDelete, &plain, mac),
Some(b"\x0b".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CmdArrowLeft, &plain, mac),
Some(b"\x01".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CmdArrowRight, &plain, mac),
Some(b"\x05".as_slice())
);
for shortcut in [
PtyShortcut::CmdBackspace,
PtyShortcut::CmdDelete,
PtyShortcut::CmdArrowLeft,
PtyShortcut::CmdArrowRight,
] {
assert_eq!(encode_pty_shortcut(shortcut, &plain, linux), None);
assert_eq!(
encode_pty_shortcut(shortcut, &plain, local_plain(RuntimePlatform::Windows)),
None
);
}
assert_eq!(
encode_pty_shortcut(PtyShortcut::CtrlBackspace, &plain, gates(RuntimePlatform::Windows, 3, 0, true)),
Some(b"\x17".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::AltBackspace, &plain, linux),
Some(b"\x1b\x7f".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::AltBackspace, &plain, gates(RuntimePlatform::Linux, 1, 0, false)),
None
);
let alt_delete = PtyShortcut::AltDelete {
numpad: false,
non_agent_fullscreen: false,
};
assert_eq!(
encode_pty_shortcut(alt_delete, &plain, mac),
Some(b"\x1bd".as_slice())
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::AltDelete {
numpad: true,
non_agent_fullscreen: false,
},
&plain,
mac,
),
None
);
assert_eq!(
encode_pty_shortcut(
PtyShortcut::AltDelete {
numpad: false,
non_agent_fullscreen: true,
},
&plain,
mac,
),
None
);
assert_eq!(
encode_pty_shortcut(alt_delete, &plain, gates(RuntimePlatform::MacOs, 1, 0, false)),
None
);
assert_eq!(encode_pty_shortcut(alt_delete, &plain, linux), None);
assert_eq!(
encode_pty_shortcut(PtyShortcut::AltArrowLeft, &plain, linux),
Some(b"\x1bb".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::AltArrowRight, &plain, linux),
Some(b"\x1bf".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::AltArrowLeft, &plain, gates(RuntimePlatform::Linux, 1, 0, false)),
None
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::AltArrowRight, &plain, local_plain(RuntimePlatform::Windows)),
None
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::AltArrowLeft, &plain, local_plain(RuntimePlatform::Wsl)),
Some(b"\x1bb".as_slice())
);
assert_eq!(encode_pty_shortcut(PtyShortcut::CtrlArrowLeft, &plain, mac), None);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CtrlArrowRight, &plain, local_plain(RuntimePlatform::Windows)),
None
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CtrlArrowLeft, &plain, linux),
Some(b"\x1bb".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CtrlArrowRight, &plain, local_plain(RuntimePlatform::Wsl)),
Some(b"\x1bf".as_slice())
);
assert_eq!(
encode_pty_shortcut(PtyShortcut::CtrlArrowLeft, &plain, gates(RuntimePlatform::Linux, 1, 0, false)),
Some(b"\x1bb".as_slice())
);
}
#[test]
fn prepare_pty_shortcut_wraps_bytes_and_keeps_none() {
let prepared = prepare_pty_shortcut(
PtyShortcut::CtrlBackspace,
&PtySubmitContract::default(),
local_plain(RuntimePlatform::Linux),
)
.expect("ctrl+backspace always has bytes");
assert_eq!(prepared.kind(), PreparedInputKind::TerminalControl);
assert_eq!(prepared.writes().len(), 1);
assert_eq!(prepared.writes()[0].kind, PreparedWriteKind::Control);
assert_eq!(prepared.writes()[0].delay_before_ms, 0);
assert_eq!(prepared.writes()[0].bytes, b"\x17");
assert!(prepare_pty_shortcut(
PtyShortcut::AltEnter,
&PtySubmitContract::default(),
local_plain(RuntimePlatform::Linux),
)
.is_none());
}
}