sjs/vibetunnel
1
0
Fork 0
mirror of https://github.com/samsonjs/vibetunnel.git synced 2026-04-23 14:15:54 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat(cli): Improve CLI installation to copy both vt and vibetunnel

Browse source 
- Update CLIInstaller to install both vt script and vibetunnel binary
- Remove duplicate replacement dialog for better UX
- Check versions of both files and use lowest version for updates
- Prioritize finding vibetunnel in same directory as vt script
- Bump vt version to 1.0.6
- Add comprehensive CLI versioning documentation
This commit is contained in:
Peter Steinberger 2025-06-20 15:22:37 +02:00
parent f96b63c77d
commit bec49c86e1
13 changed files with 2648 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

88
docs/cli-versioning.md Normal file
View file

@ -0,0 +1,88 @@
# CLI Versioning Guide
This document explains how versioning works for the VibeTunnel CLI tools and where version numbers need to be updated.
## Overview
VibeTunnel has two CLI components that work together:
- **vt** - A bash wrapper script that provides convenient access to vibetunnel
- **vibetunnel** - The Go binary that implements the actual terminal forwarding
## Version Locations
### 1. VT Script Version
**File:** `/linux/cmd/vt/vt`
**Line:** ~5
**Format:** `VERSION="1.0.6"`
The vt script has its own version number stored as a bash variable. This version is displayed when running:
```bash
vt --version
# Output: vt version 1.0.6
```
### 2. VibeTunnel Binary Version
**File:** `/linux/cmd/vibetunnel/version.go`
**Format:** Go constants
```go
const (
Version = "1.0.3"
AppName = "VibeTunnel Linux"
)
```
This version is displayed when running:
```bash
vibetunnel version
# Output: VibeTunnel Linux v1.0.3
```
## Version Checking in macOS App
The macOS VibeTunnel app's CLI installer (`/mac/VibeTunnel/Utilities/CLIInstaller.swift`) checks both tools:
1. **Installation Check**: Both `/usr/local/bin/vt` and `/usr/local/bin/vibetunnel` must exist
2. **Version Comparison**: Takes the **lowest** version between vt and vibetunnel
3. **Update Detection**: If either tool is outdated, prompts for update
## How to Update Versions
### Raising VT Version
1. Edit `/linux/cmd/vt/vt`
2. Update the `VERSION` variable (e.g., `VERSION="1.0.7"`)
3. The macOS build process automatically copies this during build
### Raising VibeTunnel Version
1. Edit `/linux/cmd/vibetunnel/version.go`
2. Update the `Version` constant
3. Rebuild the Go binary with `./build-universal.sh`
## Build Process
### macOS App Build
The macOS build process (`/mac/scripts/build.sh`) automatically:
1. Runs `/linux/build-universal.sh` to build vibetunnel binary
2. Runs `/linux/build-vt-universal.sh` to prepare the vt script
3. Copies both to the app bundle's Resources directory
### Manual CLI Build
For development or Linux installations:
```bash
cd /linux
./build-universal.sh # Builds vibetunnel binary
./build-vt-universal.sh # Prepares vt script
```
## Version Synchronization
While the two tools can have different version numbers, it's recommended to keep them in sync for major releases to avoid confusion. The macOS installer will use the lower version number when checking for updates, ensuring both tools are updated together.
## Best Practices
1. **Patch Versions**: Increment when fixing bugs (1.0.3 → 1.0.4)
2. **Minor Versions**: Increment when adding features (1.0.x → 1.1.0)
3. **Major Versions**: Increment for breaking changes (1.x.x → 2.0.0)
4. **Sync on Release**: Consider syncing version numbers for official releases
5. **Document Changes**: Update CHANGELOG when changing versions

82
ios/VibeTunnel/Models/ServerConfig.swift
View file

@ -1,5 +1,20 @@
import Foundation
/// Authentication type for server connections
enum AuthType: String, Codable, CaseIterable {
case none = "none"
case basic = "basic"
case bearer = "bearer"
var displayName: String {
switch self {
case .none: return "No Authentication"
case .basic: return "Basic Auth (Username/Password)"
case .bearer: return "Bearer Token"
}
}
}
/// Configuration for connecting to a VibeTunnel server.
///
/// ServerConfig stores all necessary information to establish
@ -10,6 +25,24 @@ struct ServerConfig: Codable, Equatable {
let port: Int
let name: String?
let password: String?
let authType: AuthType
let bearerToken: String?
init(
host: String,
port: Int,
name: String? = nil,
password: String? = nil,
authType: AuthType = .none,
bearerToken: String? = nil
) {
self.host = host
self.port = port
self.name = name
self.password = password
self.authType = authType
self.bearerToken = bearerToken
}
/// Constructs the base URL for API requests.
///
@ -34,27 +67,46 @@ struct ServerConfig: Codable, Equatable {
/// Indicates whether the server requires authentication.
///
/// - Returns: true if a non-empty password is set, false otherwise.
/// - Returns: true if authentication is configured, false otherwise.
var requiresAuthentication: Bool {
if let password {
return !password.isEmpty
switch authType {
case .none:
return false
case .basic:
if let password {
return !password.isEmpty
}
return false
case .bearer:
if let bearerToken {
return !bearerToken.isEmpty
}
return false
}
return false
}
/// Generates the Basic Authentication header value.
/// Generates the Authorization header value based on auth type.
///
/// - Returns: A properly formatted Basic Auth header string,
/// or nil if no password is set.
/// - Returns: A properly formatted auth header string,
/// or nil if no authentication is configured.
///
/// The authentication uses "admin" as the username and the
/// configured password. The credentials are base64 encoded
/// following the HTTP Basic Authentication scheme.
/// For Basic auth: uses "admin" as the username with the configured password.
/// For Bearer auth: uses the configured bearer token.
var authorizationHeader: String? {
guard let password, !password.isEmpty else { return nil }
let credentials = "admin:\(password)"
guard let data = credentials.data(using: .utf8) else { return nil }
let base64 = data.base64EncodedString()
return "Basic \(base64)"
switch authType {
case .none:
return nil
case .basic:
guard let password, !password.isEmpty else { return nil }
let credentials = "admin:\(password)"
guard let data = credentials.data(using: .utf8) else { return nil }
let base64 = data.base64EncodedString()
return "Basic \(base64)"
case .bearer:
guard let bearerToken, !bearerToken.isEmpty else { return nil }
return "Bearer \(bearerToken)"
}
}
}

28
ios/VibeTunnel/Services/BufferWebSocketClient.swift
View file

@ -174,7 +174,12 @@ class BufferWebSocketClient: NSObject {
}
private func handleBinaryMessage(_ data: Data) {
guard data.count > 5 else { return }
print("[BufferWebSocket] Received binary message: \(data.count) bytes")
guard data.count > 5 else {
print("[BufferWebSocket] Binary message too short")
return
}
var offset = 0
@ -183,7 +188,7 @@ class BufferWebSocketClient: NSObject {
offset += 1
guard magic == Self.bufferMagicByte else {
print("[BufferWebSocket] Invalid magic byte: \(magic)")
print("[BufferWebSocket] Invalid magic byte: \(String(format: "0x%02X", magic))")
return
}
@ -194,19 +199,30 @@ class BufferWebSocketClient: NSObject {
offset += 4
// Read session ID
guard data.count >= offset + Int(sessionIdLength) else { return }
guard data.count >= offset + Int(sessionIdLength) else {
print("[BufferWebSocket] Not enough data for session ID")
return
}
let sessionIdData = data.subdata(in: offset..<(offset + Int(sessionIdLength)))
guard let sessionId = String(data: sessionIdData, encoding: .utf8) else { return }
guard let sessionId = String(data: sessionIdData, encoding: .utf8) else {
print("[BufferWebSocket] Failed to decode session ID")
return
}
print("[BufferWebSocket] Session ID: \(sessionId)")
offset += Int(sessionIdLength)
// Remaining data is the message payload
let messageData = data.subdata(in: offset..<data.count)
print("[BufferWebSocket] Message payload: \(messageData.count) bytes")
// Decode terminal event
if let event = decodeTerminalEvent(from: messageData),
let handler = subscriptions[sessionId]
{
print("[BufferWebSocket] Dispatching event to handler")
handler(event)
} else {
print("[BufferWebSocket] No handler for session ID: \(sessionId)")
}
}
@ -216,11 +232,14 @@ class BufferWebSocketClient: NSObject {
if let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
let type = json["type"] as? String
{
print("[BufferWebSocket] Received event type: \(type)")
switch type {
case "header":
if let width = json["width"] as? Int,
let height = json["height"] as? Int
{
print("[BufferWebSocket] Terminal header: \(width)x\(height)")
return .header(width: width, height: height)
}
@ -228,6 +247,7 @@ class BufferWebSocketClient: NSObject {
if let timestamp = json["timestamp"] as? Double,
let outputData = json["data"] as? String
{
print("[BufferWebSocket] Terminal output: \(outputData.count) bytes")
return .output(timestamp: timestamp, data: outputData)
}

9
ios/VibeTunnel/Views/Terminal/TerminalHostingView.swift
View file

@ -96,7 +96,14 @@ struct TerminalHostingView: UIViewRepresentable {
func feedData(_ data: String) {
Task { @MainActor in
guard let terminal else { return }
guard let terminal else {
print("[Terminal] No terminal instance available")
return
}
// Debug: Log first 100 chars of data
let preview = String(data.prefix(100))
print("[Terminal] Feeding \(data.count) bytes: \(preview)")
// Store current scroll position before feeding data
let wasAtBottom = viewModel.isAutoScrollEnabled

43
ios/VibeTunnel/Views/Terminal/TerminalView.swift
View file

@ -318,6 +318,13 @@ class TerminalViewModel {
// Connect to WebSocket
bufferWebSocketClient?.connect()
// Load initial snapshot after a brief delay to ensure terminal is ready
Task { @MainActor in
// Wait for terminal view to be initialized
try? await Task.sleep(nanoseconds: 200_000_000) // 0.2s
await loadSnapshot()
}
// Subscribe to terminal events
bufferWebSocketClient?.subscribe(to: session.id) { [weak self] event in
Task { @MainActor in
@ -362,13 +369,23 @@ class TerminalViewModel {
@MainActor
private func loadSnapshot() async {
guard let snapshotURL = APIClient.shared.snapshotURL(for: session.id) else { return }
do {
let (data, _) = try await URLSession.shared.data(from: snapshotURL)
if let snapshot = String(data: data, encoding: .utf8) {
// Feed the snapshot to the terminal
terminalCoordinator?.feedData(snapshot)
let snapshot = try await APIClient.shared.getSessionSnapshot(sessionId: session.id)
// Process the snapshot events
if let header = snapshot.header {
// Initialize terminal with dimensions from header
terminalCols = header.width
terminalRows = header.height
print("Snapshot header: \(header.width)x\(header.height)")
}
// Feed all output events to the terminal
for event in snapshot.events {
if event.type == "o", let outputData = event.data {
// Feed the actual terminal output data
terminalCoordinator?.feedData(outputData)
}
}
} catch {
print("Failed to load terminal snapshot: \(error)")
@ -396,7 +413,19 @@ class TerminalViewModel {
case .output(_, let data):
// Feed output data directly to the terminal
terminalCoordinator?.feedData(data)
if let coordinator = terminalCoordinator {
coordinator.feedData(data)
} else {
// Queue the data to be fed once coordinator is ready
print("Warning: Terminal coordinator not ready, queueing data")
Task {
// Wait a bit for coordinator to be initialized
try? await Task.sleep(nanoseconds: 100_000_000) // 0.1s
if let coordinator = self.terminalCoordinator {
coordinator.feedData(data)
}
}
}
// Record output if recording
castRecorder.recordOutput(data)

2
linux/cmd/vt/vt
View file

@ -2,7 +2,7 @@
# vt - VibeTunnel CLI wrapper
# Simple bash wrapper that passes through to vibetunnel with shell expansion
VERSION="1.0.5"
VERSION="1.0.6"
# Handle version flag
if [ "$1" = "--version" ] || [ "$1" = "-v" ]; then

478
linux/pkg/protocol/asciinema_test.go Normal file
View file

@ -0,0 +1,478 @@
package protocol
import (
"bytes"
"encoding/json"
"strings"
"testing"
"time"
)
func TestAsciinemaHeader(t *testing.T) {
header := AsciinemaHeader{
Version: 2,
Width: 80,
Height: 24,
Timestamp: 1234567890,
Command: "/bin/bash",
Title: "Test Recording",
Env: map[string]string{
"TERM": "xterm-256color",
},
}
// Test JSON marshaling
data, err := json.Marshal(header)
if err != nil {
t.Fatalf("Failed to marshal header: %v", err)
}
// Verify it contains expected fields
jsonStr := string(data)
if !strings.Contains(jsonStr, `"version":2`) {
t.Error("JSON should contain version")
}
if !strings.Contains(jsonStr, `"width":80`) {
t.Error("JSON should contain width")
}
if !strings.Contains(jsonStr, `"height":24`) {
t.Error("JSON should contain height")
}
// Test unmarshaling
var decoded AsciinemaHeader
if err := json.Unmarshal(data, &decoded); err != nil {
t.Fatalf("Failed to unmarshal header: %v", err)
}
if decoded.Version != header.Version {
t.Errorf("Version = %d, want %d", decoded.Version, header.Version)
}
if decoded.Width != header.Width {
t.Errorf("Width = %d, want %d", decoded.Width, header.Width)
}
}
func TestStreamWriter_WriteHeader(t *testing.T) {
var buf bytes.Buffer
header := &AsciinemaHeader{
Version: 2,
Width: 80,
Height: 24,
}
writer := NewStreamWriter(&buf, header)
// Write header
if err := writer.WriteHeader(); err != nil {
t.Fatalf("WriteHeader() error = %v", err)
}
// Check output
output := buf.String()
if !strings.HasSuffix(output, "\n") {
t.Error("Header should end with newline")
}
// Parse the header
var decoded AsciinemaHeader
headerLine := strings.TrimSpace(output)
if err := json.Unmarshal([]byte(headerLine), &decoded); err != nil {
t.Fatalf("Failed to decode header: %v", err)
}
if decoded.Version != 2 {
t.Errorf("Version = %d, want 2", decoded.Version)
}
if decoded.Timestamp == 0 {
t.Error("Timestamp should be set automatically")
}
}
func TestStreamWriter_WriteOutput(t *testing.T) {
var buf bytes.Buffer
header := &AsciinemaHeader{
Version: 2,
Width: 80,
Height: 24,
}
writer := NewStreamWriter(&buf, header)
// Write some output
testData := []byte("Hello, World!")
if err := writer.WriteOutput(testData); err != nil {
t.Fatalf("WriteOutput() error = %v", err)
}
// Check output format
output := buf.String()
if !strings.HasSuffix(output, "\n") {
t.Error("Event should end with newline")
}
// Parse the event
var event []interface{}
eventLine := strings.TrimSpace(output)
if err := json.Unmarshal([]byte(eventLine), &event); err != nil {
t.Fatalf("Failed to decode event: %v", err)
}
if len(event) != 3 {
t.Fatalf("Event should have 3 elements, got %d", len(event))
}
// Check timestamp (should be close to 0 for first event)
timestamp, ok := event[0].(float64)
if !ok {
t.Fatalf("First element should be float64 timestamp")
}
if timestamp < 0 || timestamp > 1 {
t.Errorf("Timestamp = %f, want close to 0", timestamp)
}
// Check event type
eventType, ok := event[1].(string)
if !ok || eventType != "o" {
t.Errorf("Event type = %v, want 'o'", event[1])
}
// Check data
data, ok := event[2].(string)
if !ok || data != string(testData) {
t.Errorf("Event data = %v, want %q", event[2], testData)
}
}
func TestStreamWriter_WriteInput(t *testing.T) {
var buf bytes.Buffer
header := &AsciinemaHeader{Version: 2}
writer := NewStreamWriter(&buf, header)
testInput := []byte("ls -la")
if err := writer.WriteInput(testInput); err != nil {
t.Fatalf("WriteInput() error = %v", err)
}
// Parse the event
var event []interface{}
if err := json.Unmarshal([]byte(strings.TrimSpace(buf.String())), &event); err != nil {
t.Fatal(err)
}
if event[1] != "i" {
t.Errorf("Event type = %v, want 'i'", event[1])
}
if event[2] != string(testInput) {
t.Errorf("Event data = %v, want %q", event[2], testInput)
}
}
func TestStreamWriter_WriteResize(t *testing.T) {
var buf bytes.Buffer
header := &AsciinemaHeader{Version: 2}
writer := NewStreamWriter(&buf, header)
if err := writer.WriteResize(120, 40); err != nil {
t.Fatalf("WriteResize() error = %v", err)
}
// Parse the event
var event []interface{}
if err := json.Unmarshal([]byte(strings.TrimSpace(buf.String())), &event); err != nil {
t.Fatal(err)
}
if event[1] != "r" {
t.Errorf("Event type = %v, want 'r'", event[1])
}
if event[2] != "120x40" {
t.Errorf("Event data = %v, want '120x40'", event[2])
}
}
func TestStreamWriter_EscapeSequenceHandling(t *testing.T) {
var buf bytes.Buffer
header := &AsciinemaHeader{Version: 2}
writer := NewStreamWriter(&buf, header)
// Write data with incomplete escape sequence
part1 := []byte("Hello \x1b[31")
part2 := []byte("mRed Text\x1b[0m")
// First write - incomplete sequence should be buffered
if err := writer.WriteOutput(part1); err != nil {
t.Fatal(err)
}
// Should only write "Hello "
var event1 []interface{}
if buf.Len() > 0 {
line := strings.TrimSpace(buf.String())
if err := json.Unmarshal([]byte(line), &event1); err != nil {
t.Fatal(err)
}
if event1[2] != "Hello " {
t.Errorf("First write data = %q, want %q", event1[2], "Hello ")
}
}
buf.Reset()
// Second write - should complete the sequence
if err := writer.WriteOutput(part2); err != nil {
t.Fatal(err)
}
// Should write the complete escape sequence
var event2 []interface{}
line := strings.TrimSpace(buf.String())
if err := json.Unmarshal([]byte(line), &event2); err != nil {
t.Fatal(err)
}
expected := "\x1b[31mRed Text\x1b[0m"
if event2[2] != expected {
t.Errorf("Second write data = %q, want %q", event2[2], expected)
}
}
func TestStreamWriter_Close(t *testing.T) {
var buf bytes.Buffer
header := &AsciinemaHeader{Version: 2}
writer := NewStreamWriter(&buf, header)
// Write some data with incomplete sequence
if err := writer.WriteOutput([]byte("test\x1b[")); err != nil {
t.Fatal(err)
}
initialLen := buf.Len()
// Close should flush remaining data
if err := writer.Close(); err != nil {
t.Fatalf("Close() error = %v", err)
}
// Should have written more data (the flushed incomplete sequence)
if buf.Len() <= initialLen {
t.Error("Close() should flush remaining data")
}
// Try to write after close
if err := writer.WriteOutput([]byte("more")); err == nil {
t.Error("Writing after close should return error")
}
}
func TestStreamWriter_Timing(t *testing.T) {
var buf bytes.Buffer
header := &AsciinemaHeader{Version: 2}
writer := NewStreamWriter(&buf, header)
// Write first event
if err := writer.WriteOutput([]byte("first")); err != nil {
t.Fatal(err)
}
// Wait a bit
time.Sleep(100 * time.Millisecond)
// Write second event
buf.Reset() // Clear first event
if err := writer.WriteOutput([]byte("second")); err != nil {
t.Fatal(err)
}
// Parse second event
var event []interface{}
if err := json.Unmarshal([]byte(strings.TrimSpace(buf.String())), &event); err != nil {
t.Fatal(err)
}
// Timestamp should be > 0.1 seconds
timestamp := event[0].(float64)
if timestamp < 0.09 || timestamp > 0.2 {
t.Errorf("Timestamp = %f, want ~0.1", timestamp)
}
}
func TestStreamReader_ReadHeader(t *testing.T) {
// Create test data
header := AsciinemaHeader{
Version: 2,
Width: 80,
Height: 24,
Command: "/bin/bash",
}
headerData, _ := json.Marshal(header)
input := string(headerData) + "\n"
reader := NewStreamReader(strings.NewReader(input))
// Read header
event, err := reader.Next()
if err != nil {
t.Fatalf("Next() error = %v", err)
}
if event.Type != "header" {
t.Errorf("Event type = %s, want 'header'", event.Type)
}
if event.Header == nil {
t.Fatal("Header should not be nil")
}
if event.Header.Version != 2 {
t.Errorf("Version = %d, want 2", event.Header.Version)
}
}
func TestStreamReader_ReadEvents(t *testing.T) {
// Create test data with header and events
header := AsciinemaHeader{Version: 2}
headerData, _ := json.Marshal(header)
event1 := []interface{}{0.5, "o", "Hello"}
event1Data, _ := json.Marshal(event1)
event2 := []interface{}{1.0, "i", "input"}
event2Data, _ := json.Marshal(event2)
input := string(headerData) + "\n" + string(event1Data) + "\n" + string(event2Data) + "\n"
reader := NewStreamReader(strings.NewReader(input))
// Read header
headerEvent, err := reader.Next()
if err != nil || headerEvent.Type != "header" {
t.Fatal("Failed to read header")
}
// Read first event
ev1, err := reader.Next()
if err != nil {
t.Fatal(err)
}
if ev1.Type != "event" || ev1.Event == nil {
t.Fatal("Expected event type")
}
if ev1.Event.Type != "o" || ev1.Event.Data != "Hello" {
t.Errorf("Event 1 mismatch: %+v", ev1.Event)
}
// Read second event
ev2, err := reader.Next()
if err != nil {
t.Fatal(err)
}
if ev2.Event.Type != "i" || ev2.Event.Data != "input" {
t.Errorf("Event 2 mismatch: %+v", ev2.Event)
}
// Read EOF
endEvent, err := reader.Next()
if err != nil {
t.Fatal(err)
}
if endEvent.Type != "end" {
t.Errorf("Expected end event, got %s", endEvent.Type)
}
}
func TestExtractCompleteUTF8(t *testing.T) {
tests := []struct {
name string
input []byte
wantComplete []byte
wantRemaining []byte
}{
{
name: "all ASCII",
input: []byte("Hello"),
wantComplete: []byte("Hello"),
wantRemaining: []byte{},
},
{
name: "complete UTF-8",
input: []byte("Hello 世界"),
wantComplete: []byte("Hello 世界"),
wantRemaining: []byte{},
},
{
name: "incomplete 2-byte",
input: []byte("Hello \xc3"),
wantComplete: []byte("Hello "),
wantRemaining: []byte("\xc3"),
},
{
name: "incomplete 3-byte",
input: []byte("Hello \xe4\xb8"),
wantComplete: []byte("Hello "),
wantRemaining: []byte("\xe4\xb8"),
},
{
name: "incomplete 4-byte",
input: []byte("Hello \xf0\x9f\x98"),
wantComplete: []byte("Hello "),
wantRemaining: []byte("\xf0\x9f\x98"),
},
{
name: "empty",
input: []byte{},
wantComplete: nil,
wantRemaining: nil,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
complete, remaining := extractCompleteUTF8(tt.input)
if !bytes.Equal(complete, tt.wantComplete) {
t.Errorf("complete = %q, want %q", complete, tt.wantComplete)
}
if !bytes.Equal(remaining, tt.wantRemaining) {
t.Errorf("remaining = %q, want %q", remaining, tt.wantRemaining)
}
})
}
}
func BenchmarkStreamWriter_WriteOutput(b *testing.B) {
var buf bytes.Buffer
header := &AsciinemaHeader{Version: 2}
writer := NewStreamWriter(&buf, header)
data := []byte("This is a line of terminal output with some \x1b[31mcolor\x1b[0m\n")
b.ResetTimer()
for i := 0; i < b.N; i++ {
writer.WriteOutput(data)
buf.Reset()
}
}
func BenchmarkStreamReader_Next(b *testing.B) {
// Create test data
header := AsciinemaHeader{Version: 2}
headerData, _ := json.Marshal(header)
var events []string
events = append(events, string(headerData))
for i := 0; i < 100; i++ {
event := []interface{}{float64(i) * 0.1, "o", "Line of output\n"}
eventData, _ := json.Marshal(event)
events = append(events, string(eventData))
}
input := strings.Join(events, "\n")
b.ResetTimer()
for i := 0; i < b.N; i++ {
reader := NewStreamReader(strings.NewReader(input))
for {
event, err := reader.Next()
if err != nil || event.Type == "end" {
break
}
}
}
}

436
linux/pkg/protocol/escape_parser_test.go Normal file
View file

@ -0,0 +1,436 @@
package protocol
import (
"bytes"
"testing"
)
func TestEscapeParser_ProcessData(t *testing.T) {
tests := []struct {
name string
input []byte
wantProcessed []byte
wantRemaining []byte
}{
{
name: "simple text",
input: []byte("Hello, World!"),
wantProcessed: []byte("Hello, World!"),
wantRemaining: []byte{},
},
{
name: "complete CSI sequence",
input: []byte("text\x1b[31mred\x1b[0m"),
wantProcessed: []byte("text\x1b[31mred\x1b[0m"),
wantRemaining: []byte{},
},
{
name: "incomplete CSI sequence",
input: []byte("text\x1b[31"),
wantProcessed: []byte("text"),
wantRemaining: []byte("\x1b[31"),
},
{
name: "cursor movement",
input: []byte("\x1b[1A\x1b[2B\x1b[3C\x1b[4D"),
wantProcessed: []byte("\x1b[1A\x1b[2B\x1b[3C\x1b[4D"),
wantRemaining: []byte{},
},
{
name: "OSC sequence with BEL",
input: []byte("\x1b]0;Terminal Title\x07rest"),
wantProcessed: []byte("\x1b]0;Terminal Title\x07rest"),
wantRemaining: []byte{},
},
{
name: "OSC sequence with ST",
input: []byte("\x1b]0;Terminal Title\x1b\\rest"),
wantProcessed: []byte("\x1b]0;Terminal Title\x1b\\rest"),
wantRemaining: []byte{},
},
{
name: "incomplete OSC sequence",
input: []byte("\x1b]0;Terminal"),
wantProcessed: []byte{},
wantRemaining: []byte("\x1b]0;Terminal"),
},
{
name: "charset selection",
input: []byte("\x1b(B\x1b)0text"),
wantProcessed: []byte("\x1b(B\x1b)0text"),
wantRemaining: []byte{},
},
{
name: "incomplete charset",
input: []byte("text\x1b("),
wantProcessed: []byte("text"),
wantRemaining: []byte("\x1b("),
},
{
name: "DCS sequence",
input: []byte("\x1bPdata\x1b\\text"),
wantProcessed: []byte("\x1bPdata\x1b\\text"),
wantRemaining: []byte{},
},
{
name: "incomplete DCS",
input: []byte("\x1bPdata"),
wantProcessed: []byte{},
wantRemaining: []byte("\x1bPdata"),
},
{
name: "mixed content",
input: []byte("normal\x1b[1mbold\x1b[0m\x1b["),
wantProcessed: []byte("normal\x1b[1mbold\x1b[0m"),
wantRemaining: []byte("\x1b["),
},
{
name: "UTF-8 text",
input: []byte("Hello 世界"),
wantProcessed: []byte("Hello 世界"),
wantRemaining: []byte{},
},
{
name: "incomplete UTF-8 at end",
input: []byte("Hello \xe4\xb8"), // Missing last byte of 世
wantProcessed: []byte("Hello "),
wantRemaining: []byte("\xe4\xb8"),
},
{
name: "invalid UTF-8 byte",
input: []byte("Hello\xff\xfeWorld"),
wantProcessed: []byte("Hello\xff\xfeWorld"),
wantRemaining: []byte{},
},
{
name: "escape at end",
input: []byte("text\x1b"),
wantProcessed: []byte("text"),
wantRemaining: []byte("\x1b"),
},
{
name: "CSI with invalid terminator",
input: []byte("\x1b[31\x00text"),
wantProcessed: []byte("\x1b[31\x00text"),
wantRemaining: []byte{},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
parser := NewEscapeParser()
processed, remaining := parser.ProcessData(tt.input)
if !bytes.Equal(processed, tt.wantProcessed) {
t.Errorf("ProcessData() processed = %q, want %q", processed, tt.wantProcessed)
}
if !bytes.Equal(remaining, tt.wantRemaining) {
t.Errorf("ProcessData() remaining = %q, want %q", remaining, tt.wantRemaining)
}
})
}
}
func TestEscapeParser_MultipleChunks(t *testing.T) {
parser := NewEscapeParser()
// First chunk ends with incomplete escape sequence
chunk1 := []byte("Hello\x1b[31")
processed1, remaining1 := parser.ProcessData(chunk1)
if !bytes.Equal(processed1, []byte("Hello")) {
t.Errorf("Chunk1 processed = %q, want %q", processed1, "Hello")
}
if !bytes.Equal(remaining1, []byte("\x1b[31")) {
t.Errorf("Chunk1 remaining = %q, want %q", remaining1, "\x1b[31")
}
// Second chunk completes the sequence
chunk2 := []byte("mRed Text\x1b[0m")
processed2, remaining2 := parser.ProcessData(chunk2)
expected := []byte("\x1b[31mRed Text\x1b[0m")
if !bytes.Equal(processed2, expected) {
t.Errorf("Chunk2 processed = %q, want %q", processed2, expected)
}
if len(remaining2) > 0 {
t.Errorf("Chunk2 remaining = %q, want empty", remaining2)
}
}
func TestEscapeParser_Flush(t *testing.T) {
parser := NewEscapeParser()
// Process data with incomplete sequence
input := []byte("text\x1b[incomplete")
processed, _ := parser.ProcessData(input)
if !bytes.Equal(processed, []byte("text")) {
t.Errorf("Processed = %q, want %q", processed, "text")
}
// Flush should return the incomplete sequence
flushed := parser.Flush()
if !bytes.Equal(flushed, []byte("\x1b[incomplete")) {
t.Errorf("Flush() = %q, want %q", flushed, "\x1b[incomplete")
}
// Buffer should be empty after flush
if parser.BufferSize() != 0 {
t.Errorf("BufferSize() after flush = %d, want 0", parser.BufferSize())
}
// Second flush should return nothing
flushed2 := parser.Flush()
if len(flushed2) > 0 {
t.Errorf("Second Flush() = %q, want empty", flushed2)
}
}
func TestEscapeParser_Reset(t *testing.T) {
parser := NewEscapeParser()
// Add some incomplete data
parser.ProcessData([]byte("text\x1b[31"))
if parser.BufferSize() == 0 {
t.Error("Buffer should not be empty before reset")
}
// Reset
parser.Reset()
if parser.BufferSize() != 0 {
t.Errorf("BufferSize() after reset = %d, want 0", parser.BufferSize())
}
}
func TestEscapeParser_ComplexSequences(t *testing.T) {
tests := []struct {
name string
input []byte
expected []byte
}{
{
name: "SGR with multiple parameters",
input: []byte("\x1b[1;31;40mBold Red on Black\x1b[0m"),
expected: []byte("\x1b[1;31;40mBold Red on Black\x1b[0m"),
},
{
name: "cursor position",
input: []byte("\x1b[10;20H"),
expected: []byte("\x1b[10;20H"),
},
{
name: "clear screen",
input: []byte("\x1b[2J\x1b[H"),
expected: []byte("\x1b[2J\x1b[H"),
},
{
name: "save and restore cursor",
input: []byte("\x1b7text\x1b8"),
expected: []byte("\x1b7text\x1b8"),
},
{
name: "alternate screen buffer",
input: []byte("\x1b[?1049h\x1b[?1049l"),
expected: []byte("\x1b[?1049h\x1b[?1049l"),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
parser := NewEscapeParser()
processed, remaining := parser.ProcessData(tt.input)
if !bytes.Equal(processed, tt.expected) {
t.Errorf("ProcessData() = %q, want %q", processed, tt.expected)
}
if len(remaining) > 0 {
t.Errorf("Unexpected remaining data: %q", remaining)
}
})
}
}
func TestIsCompleteEscapeSequence(t *testing.T) {
tests := []struct {
name string
input []byte
expected bool
}{
{
name: "complete CSI",
input: []byte("\x1b[31m"),
expected: true,
},
{
name: "incomplete CSI",
input: []byte("\x1b[31"),
expected: false,
},
{
name: "not escape sequence",
input: []byte("hello"),
expected: false,
},
{
name: "empty",
input: []byte{},
expected: false,
},
{
name: "just escape",
input: []byte("\x1b"),
expected: false,
},
{
name: "complete two-char",
input: []byte("\x1b7"),
expected: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := IsCompleteEscapeSequence(tt.input); got != tt.expected {
t.Errorf("IsCompleteEscapeSequence() = %v, want %v", got, tt.expected)
}
})
}
}
func TestStripEscapeSequences(t *testing.T) {
tests := []struct {
name string
input []byte
expected []byte
}{
{
name: "colored text",
input: []byte("\x1b[31mRed\x1b[0m Normal \x1b[1mBold\x1b[0m"),
expected: []byte("Red Normal Bold"),
},
{
name: "cursor movements",
input: []byte("A\x1b[1AB\x1b[2CC"),
expected: []byte("ABC"),
},
{
name: "OSC sequence",
input: []byte("Text\x1b]0;Title\x07More"),
expected: []byte("TextMore"),
},
{
name: "no escape sequences",
input: []byte("Plain text"),
expected: []byte("Plain text"),
},
{
name: "incomplete sequence at end",
input: []byte("Text\x1b["),
expected: []byte("Text\x1b["),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := StripEscapeSequences(tt.input)
if !bytes.Equal(result, tt.expected) {
t.Errorf("StripEscapeSequences() = %q, want %q", result, tt.expected)
}
})
}
}
func TestSplitEscapeSequences(t *testing.T) {
tests := []struct {
name string
input []byte
expected [][]byte
}{
{
name: "mixed content",
input: []byte("text\x1b[31mred\x1b[0m"),
expected: [][]byte{[]byte("text\x1b[31mred\x1b[0m")},
},
{
name: "incomplete at end",
input: []byte("complete\x1b["),
expected: [][]byte{[]byte("complete"), []byte("\x1b[")},
},
{
name: "empty input",
input: []byte{},
expected: nil,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := SplitEscapeSequences(tt.input)
if len(result) != len(tt.expected) {
t.Fatalf("SplitEscapeSequences() returned %d chunks, want %d", len(result), len(tt.expected))
}
for i, chunk := range result {
if !bytes.Equal(chunk, tt.expected[i]) {
t.Errorf("Chunk %d = %q, want %q", i, chunk, tt.expected[i])
}
}
})
}
}
func TestEscapeParser_UTF8Handling(t *testing.T) {
parser := NewEscapeParser()
// Test multi-byte UTF-8 split across chunks
chunk1 := []byte("Hello 世")[:8] // Split in middle of 世
chunk2 := []byte("Hello 世")[8:]
processed1, _ := parser.ProcessData(chunk1)
if !bytes.Equal(processed1, []byte("Hello ")) {
t.Errorf("Chunk1 should process only complete UTF-8: %q", processed1)
}
processed2, remaining := parser.ProcessData(chunk2)
expected := []byte("世")
if !bytes.Equal(processed2, expected) {
t.Errorf("Chunk2 processed = %q, want %q", processed2, expected)
}
if len(remaining) > 0 {
t.Errorf("Should have no remaining data: %q", remaining)
}
}
func BenchmarkEscapeParser_ProcessData(b *testing.B) {
parser := NewEscapeParser()
// Typical terminal output with colors and cursor movements
data := []byte("Normal text \x1b[31mRed\x1b[0m \x1b[1mBold\x1b[0m \x1b[10;20HPosition\x1b[2J\x1b[H")
b.ResetTimer()
for i := 0; i < b.N; i++ {
parser.ProcessData(data)
parser.Reset()
}
}
func BenchmarkEscapeParser_LargeData(b *testing.B) {
parser := NewEscapeParser()
// Create large data with mixed content
var buf bytes.Buffer
for i := 0; i < 100; i++ {
buf.WriteString("Line ")
buf.WriteString("\x1b[32m")
buf.WriteString("colored")
buf.WriteString("\x1b[0m")
buf.WriteString(" text with UTF-8: 你好世界\n")
}
data := buf.Bytes()
b.ResetTimer()
for i := 0; i < b.N; i++ {
parser.ProcessData(data)
parser.Reset()
}
}

318
linux/pkg/session/errors_test.go Normal file
View file

@ -0,0 +1,318 @@
package session
import (
"errors"
"testing"
)
func TestSessionError(t *testing.T) {
tests := []struct {
name string
err *SessionError
wantMsg string
wantCode ErrorCode
wantID string
}{
{
name: "basic error with session ID",
err: &SessionError{
Message: "test error",
Code: ErrSessionNotFound,
SessionID: "12345678-1234-1234-1234-123456789012",
},
wantMsg: "test error (session: 12345678, code: SESSION_NOT_FOUND)",
wantCode: ErrSessionNotFound,
wantID: "12345678-1234-1234-1234-123456789012",
},
{
name: "error without session ID",
err: &SessionError{
Message: "test error",
Code: ErrInvalidArgument,
},
wantMsg: "test error (code: INVALID_ARGUMENT)",
wantCode: ErrInvalidArgument,
wantID: "",
},
{
name: "error with cause",
err: &SessionError{
Message: "wrapped error",
Code: ErrPTYCreationFailed,
SessionID: "abcdef12-1234-1234-1234-123456789012",
Cause: errors.New("underlying error"),
},
wantMsg: "wrapped error (session: abcdef12, code: PTY_CREATION_FAILED)",
wantCode: ErrPTYCreationFailed,
wantID: "abcdef12-1234-1234-1234-123456789012",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := tt.err.Error(); got != tt.wantMsg {
t.Errorf("Error() = %v, want %v", got, tt.wantMsg)
}
if tt.err.Code != tt.wantCode {
t.Errorf("Code = %v, want %v", tt.err.Code, tt.wantCode)
}
if tt.err.SessionID != tt.wantID {
t.Errorf("SessionID = %v, want %v", tt.err.SessionID, tt.wantID)
}
if tt.err.Cause != nil {
if unwrapped := tt.err.Unwrap(); unwrapped != tt.err.Cause {
t.Errorf("Unwrap() = %v, want %v", unwrapped, tt.err.Cause)
}
}
})
}
}
func TestNewSessionError(t *testing.T) {
sessionID := "test-session-id"
message := "test message"
code := ErrSessionNotFound
err := NewSessionError(message, code, sessionID)
if err.Message != message {
t.Errorf("Message = %v, want %v", err.Message, message)
}
if err.Code != code {
t.Errorf("Code = %v, want %v", err.Code, code)
}
if err.SessionID != sessionID {
t.Errorf("SessionID = %v, want %v", err.SessionID, sessionID)
}
if err.Cause != nil {
t.Errorf("Cause = %v, want nil", err.Cause)
}
}
func TestNewSessionErrorWithCause(t *testing.T) {
sessionID := "test-session-id"
message := "test message"
code := ErrPTYCreationFailed
cause := errors.New("root cause")
err := NewSessionErrorWithCause(message, code, sessionID, cause)
if err.Message != message {
t.Errorf("Message = %v, want %v", err.Message, message)
}
if err.Code != code {
t.Errorf("Code = %v, want %v", err.Code, code)
}
if err.SessionID != sessionID {
t.Errorf("SessionID = %v, want %v", err.SessionID, sessionID)
}
if err.Cause != cause {
t.Errorf("Cause = %v, want %v", err.Cause, cause)
}
}
func TestWrapError(t *testing.T) {
tests := []struct {
name string
err error
code ErrorCode
sessionID string
wantNil bool
wantType string
}{
{
name: "wrap nil error",
err: nil,
code: ErrInternal,
sessionID: "test",
wantNil: true,
},
{
name: "wrap regular error",
err: errors.New("regular error"),
code: ErrStdinWriteFailed,
sessionID: "12345678",
wantType: "regular",
},
{
name: "wrap session error",
err: &SessionError{
Message: "original",
Code: ErrSessionNotFound,
SessionID: "original-id",
},
code: ErrInternal,
sessionID: "new-id",
wantType: "session",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
wrapped := WrapError(tt.err, tt.code, tt.sessionID)
if tt.wantNil {
if wrapped != nil {
t.Errorf("WrapError() = %v, want nil", wrapped)
}
return
}
if wrapped == nil {
t.Fatal("WrapError() = nil, want non-nil")
}
if wrapped.Code != tt.code {
t.Errorf("Code = %v, want %v", wrapped.Code, tt.code)
}
if wrapped.SessionID != tt.sessionID {
t.Errorf("SessionID = %v, want %v", wrapped.SessionID, tt.sessionID)
}
if tt.wantType == "session" {
// When wrapping a SessionError, the cause should be the original
if _, ok := wrapped.Cause.(*SessionError); !ok {
t.Errorf("Cause type = %T, want *SessionError", wrapped.Cause)
}
}
})
}
}
func TestIsSessionError(t *testing.T) {
tests := []struct {
name string
err error
code ErrorCode
expected bool
}{
{
name: "matching session error",
err: &SessionError{
Code: ErrSessionNotFound,
},
code: ErrSessionNotFound,
expected: true,
},
{
name: "non-matching session error",
err: &SessionError{
Code: ErrSessionNotFound,
},
code: ErrPTYCreationFailed,
expected: false,
},
{
name: "regular error",
err: errors.New("regular"),
code: ErrSessionNotFound,
expected: false,
},
{
name: "nil error",
err: nil,
code: ErrSessionNotFound,
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := IsSessionError(tt.err, tt.code); got != tt.expected {
t.Errorf("IsSessionError() = %v, want %v", got, tt.expected)
}
})
}
}
func TestGetSessionID(t *testing.T) {
tests := []struct {
name string
err error
expected string
}{
{
name: "session error with ID",
err: &SessionError{
SessionID: "test-id-123",
},
expected: "test-id-123",
},
{
name: "session error without ID",
err: &SessionError{
SessionID: "",
},
expected: "",
},
{
name: "regular error",
err: errors.New("regular"),
expected: "",
},
{
name: "nil error",
err: nil,
expected: "",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := GetSessionID(tt.err); got != tt.expected {
t.Errorf("GetSessionID() = %v, want %v", got, tt.expected)
}
})
}
}
func TestErrorConstructors(t *testing.T) {
sessionID := "12345678-1234-1234-1234-123456789012"
t.Run("ErrSessionNotFoundError", func(t *testing.T) {
err := ErrSessionNotFoundError(sessionID)
if err.Code != ErrSessionNotFound {
t.Errorf("Code = %v, want %v", err.Code, ErrSessionNotFound)
}
if err.SessionID != sessionID {
t.Errorf("SessionID = %v, want %v", err.SessionID, sessionID)
}
expectedMsg := "Session 12345678 not found"
if err.Message != expectedMsg {
t.Errorf("Message = %v, want %v", err.Message, expectedMsg)
}
})
t.Run("ErrProcessSignalError", func(t *testing.T) {
cause := errors.New("signal failed")
err := ErrProcessSignalError(sessionID, "SIGTERM", cause)
if err.Code != ErrProcessSignalFailed {
t.Errorf("Code = %v, want %v", err.Code, ErrProcessSignalFailed)
}
if err.Cause != cause {
t.Errorf("Cause = %v, want %v", err.Cause, cause)
}
})
t.Run("ErrPTYCreationError", func(t *testing.T) {
cause := errors.New("pty failed")
err := ErrPTYCreationError(sessionID, cause)
if err.Code != ErrPTYCreationFailed {
t.Errorf("Code = %v, want %v", err.Code, ErrPTYCreationFailed)
}
if err.Cause != cause {
t.Errorf("Cause = %v, want %v", err.Cause, cause)
}
})
t.Run("ErrStdinWriteError", func(t *testing.T) {
cause := errors.New("write failed")
err := ErrStdinWriteError(sessionID, cause)
if err.Code != ErrStdinWriteFailed {
t.Errorf("Code = %v, want %v", err.Code, ErrStdinWriteFailed)
}
if err.Cause != cause {
t.Errorf("Cause = %v, want %v", err.Cause, cause)
}
})
}

227
linux/pkg/session/process_test.go Normal file
View file

@ -0,0 +1,227 @@
package session
import (
"os"
"os/exec"
"runtime"
"testing"
"time"
)
func TestProcessTerminator_TerminateGracefully(t *testing.T) {
// Skip on Windows as signal handling is different
if runtime.GOOS == "windows" {
t.Skip("Skipping signal tests on Windows")
}
tests := []struct {
name string
setupSession func() *Session
expectGraceful bool
checkInterval time.Duration
}{
{
name: "already exited session",
setupSession: func() *Session {
s := &Session{
ID: "test-session-1",
info: &Info{
Status: string(StatusExited),
},
}
return s
},
expectGraceful: true,
},
{
name: "no process to terminate",
setupSession: func() *Session {
s := &Session{
ID: "test-session-2",
info: &Info{
Status: string(StatusRunning),
Pid: 0,
},
}
return s
},
expectGraceful: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
session := tt.setupSession()
terminator := NewProcessTerminator(session)
err := terminator.TerminateGracefully()
if tt.expectGraceful && err != nil {
t.Errorf("TerminateGracefully() error = %v, want nil", err)
}
if !tt.expectGraceful && err == nil {
t.Error("TerminateGracefully() error = nil, want error")
}
})
}
}
func TestProcessTerminator_RealProcess(t *testing.T) {
// Skip in CI or on Windows
if os.Getenv("CI") == "true" || runtime.GOOS == "windows" {
t.Skip("Skipping real process test in CI/Windows")
}
// Start a sleep process that ignores SIGTERM
cmd := exec.Command("sh", "-c", "trap '' TERM; sleep 10")
if err := cmd.Start(); err != nil {
t.Skipf("Cannot start test process: %v", err)
}
session := &Session{
ID: "test-real-process",
info: &Info{
Status: string(StatusRunning),
Pid: cmd.Process.Pid,
},
}
// Create a flag to track cleanup
cleanupCalled := false
originalCleanup := session.cleanup
session.cleanup = func() {
cleanupCalled = true
originalCleanup()
}
terminator := NewProcessTerminator(session)
terminator.gracefulTimeout = 1 * time.Second // Shorter timeout for test
terminator.checkInterval = 100 * time.Millisecond
start := time.Now()
err := terminator.TerminateGracefully()
elapsed := time.Since(start)
if err != nil {
t.Errorf("TerminateGracefully() error = %v", err)
}
// Should have waited about 1 second before SIGKILL
if elapsed < 900*time.Millisecond || elapsed > 1500*time.Millisecond {
t.Errorf("Expected termination after ~1s, but took %v", elapsed)
}
// Process should be dead now
if err := cmd.Process.Signal(os.Signal(nil)); err == nil {
t.Error("Process should be terminated")
}
}
func TestWaitForProcessExit(t *testing.T) {
tests := []struct {
name string
pid int
timeout time.Duration
expected bool
}{
{
name: "non-existent process",
pid: 999999,
timeout: 100 * time.Millisecond,
expected: true,
},
{
name: "current process (should not exit)",
pid: os.Getpid(),
timeout: 100 * time.Millisecond,
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := waitForProcessExit(tt.pid, tt.timeout)
if result != tt.expected {
t.Errorf("waitForProcessExit() = %v, want %v", result, tt.expected)
}
})
}
}
func TestIsProcessRunning(t *testing.T) {
tests := []struct {
name string
pid int
expected bool
}{
{
name: "invalid pid",
pid: 0,
expected: false,
},
{
name: "negative pid",
pid: -1,
expected: false,
},
{
name: "current process",
pid: os.Getpid(),
expected: true,
},
{
name: "non-existent process",
pid: 999999,
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := isProcessRunning(tt.pid)
if result != tt.expected {
t.Errorf("isProcessRunning(%d) = %v, want %v", tt.pid, result, tt.expected)
}
})
}
}
func TestProcessTerminator_CheckInterval(t *testing.T) {
session := &Session{
ID: "test-session",
info: &Info{
Status: string(StatusRunning),
Pid: 999999, // Non-existent
},
}
terminator := NewProcessTerminator(session)
// Verify default values match Node.js
if terminator.gracefulTimeout != 3*time.Second {
t.Errorf("gracefulTimeout = %v, want 3s", terminator.gracefulTimeout)
}
if terminator.checkInterval != 500*time.Millisecond {
t.Errorf("checkInterval = %v, want 500ms", terminator.checkInterval)
}
}
func BenchmarkIsProcessRunning(b *testing.B) {
pid := os.Getpid()
b.ResetTimer()
for i := 0; i < b.N; i++ {
isProcessRunning(pid)
}
}
func BenchmarkWaitForProcessExit(b *testing.B) {
// Use non-existent PID for immediate return
pid := 999999
timeout := 1 * time.Millisecond
b.ResetTimer()
for i := 0; i < b.N; i++ {
waitForProcessExit(pid, timeout)
}
}

452
linux/pkg/session/session_test.go Normal file
View file

@ -0,0 +1,452 @@
package session
import (
"os"
"path/filepath"
"testing"
"time"
)
func TestNewSession(t *testing.T) {
// Skip this test as newSession is not exported
t.Skip("newSession is an internal function")
tmpDir := t.TempDir()
controlPath := filepath.Join(tmpDir, "control")
config := &Config{
Name: "test-session",
Cmdline: []string{"/bin/sh", "-c", "echo test"},
Cwd: tmpDir,
Width: 80,
Height: 24,
}
session, err := newSession(controlPath, *config)
if err != nil {
t.Fatalf("newSession() error = %v", err)
}
if session == nil {
t.Fatal("NewSession returned nil")
}
if session.ID == "" {
t.Error("Session ID should not be empty")
}
if session.controlPath != controlPath {
t.Errorf("controlPath = %s, want %s", session.controlPath, controlPath)
}
// Check session info
if session.info.Name != config.Name {
t.Errorf("Name = %s, want %s", session.info.Name, config.Name)
}
if session.info.Width != config.Width {
t.Errorf("Width = %d, want %d", session.info.Width, config.Width)
}
if session.info.Height != config.Height {
t.Errorf("Height = %d, want %d", session.info.Height, config.Height)
}
if session.info.Status != string(StatusStarting) {
t.Errorf("Status = %s, want %s", session.info.Status, StatusStarting)
}
}
func TestNewSession_Defaults(t *testing.T) {
// Skip this test as newSession is not exported
t.Skip("newSession is an internal function")
tmpDir := t.TempDir()
controlPath := filepath.Join(tmpDir, "control")
// Minimal config
config := &Config{}
session, err := newSession(controlPath, *config)
if err != nil {
t.Fatalf("newSession() error = %v", err)
}
// Should have default shell
if len(session.info.Args) == 0 {
t.Error("Should have default shell command")
}
// Should have default dimensions
if session.info.Width <= 0 {
t.Error("Should have default width")
}
if session.info.Height <= 0 {
t.Error("Should have default height")
}
// Should have default working directory
if session.info.Cwd == "" {
t.Error("Should have default working directory")
}
}
func TestSession_Paths(t *testing.T) {
// Skip this test as newSession is not exported
t.Skip("newSession is an internal function")
tmpDir := t.TempDir()
controlPath := filepath.Join(tmpDir, "control")
session := NewSession(controlPath, &Config{})
sessionID := session.ID
// Test path methods
expectedBase := filepath.Join(controlPath, sessionID)
if session.Path() != expectedBase {
t.Errorf("Path() = %s, want %s", session.Path(), expectedBase)
}
if session.StdinPath() != filepath.Join(expectedBase, "stdin") {
t.Errorf("Unexpected StdinPath: %s", session.StdinPath())
}
if session.StreamOutPath() != filepath.Join(expectedBase, "stream-out") {
t.Errorf("Unexpected StreamOutPath: %s", session.StreamOutPath())
}
if session.NotificationPath() != filepath.Join(expectedBase, "notification-stream") {
t.Errorf("Unexpected NotificationPath: %s", session.NotificationPath())
}
if session.InfoPath() != filepath.Join(expectedBase, "session.json") {
t.Errorf("Unexpected InfoPath: %s", session.InfoPath())
}
}
func TestSession_Signal(t *testing.T) {
session := &Session{
ID: "test-session",
info: &Info{
Pid: 0, // No process
Status: string(StatusRunning),
},
}
// Test signaling with no process
err := session.Signal("SIGTERM")
if err == nil {
t.Error("Signal should fail with no process")
}
if !IsSessionError(err, ErrProcessNotFound) {
t.Errorf("Expected ErrProcessNotFound, got %v", err)
}
// Test with already exited session
session.info.Status = string(StatusExited)
err = session.Signal("SIGTERM")
if err != nil {
t.Errorf("Signal should succeed for exited session: %v", err)
}
// Test unsupported signal
session.info.Status = string(StatusRunning)
session.info.Pid = os.Getpid() // Use current process for testing
err = session.Signal("SIGUSR3")
if err == nil {
t.Error("Should fail for unsupported signal")
}
if !IsSessionError(err, ErrInvalidArgument) {
t.Errorf("Expected ErrInvalidArgument, got %v", err)
}
}
func TestSession_Resize(t *testing.T) {
session := &Session{
ID: "test-session",
info: &Info{
Width: 80,
Height: 24,
Status: string(StatusRunning),
},
}
// Test resize without PTY
err := session.Resize(100, 30)
if err == nil {
t.Error("Resize should fail without PTY")
}
if !IsSessionError(err, ErrSessionNotRunning) {
t.Errorf("Expected ErrSessionNotRunning, got %v", err)
}
// Test resize on exited session
session.info.Status = string(StatusExited)
err = session.Resize(100, 30)
if err == nil {
t.Error("Resize should fail on exited session")
}
// Test invalid dimensions
session.info.Status = string(StatusRunning)
err = session.Resize(0, 30)
if err == nil {
t.Error("Resize should fail with invalid width")
}
if !IsSessionError(err, ErrInvalidArgument) {
t.Errorf("Expected ErrInvalidArgument, got %v", err)
}
err = session.Resize(100, -1)
if err == nil {
t.Error("Resize should fail with invalid height")
}
}
func TestSession_IsAlive(t *testing.T) {
tests := []struct {
name string
session *Session
expected bool
}{
{
name: "no pid",
session: &Session{
ID: "test1",
info: &Info{Pid: 0},
},
expected: false,
},
{
name: "exited status",
session: &Session{
ID: "test2",
info: &Info{
Pid: 12345,
Status: string(StatusExited),
},
},
expected: false,
},
{
name: "current process",
session: &Session{
ID: "test3",
info: &Info{
Pid: os.Getpid(),
Status: string(StatusRunning),
},
},
expected: true,
},
{
name: "non-existent process",
session: &Session{
ID: "test4",
info: &Info{
Pid: 999999,
Status: string(StatusRunning),
},
},
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := tt.session.IsAlive()
if result != tt.expected {
t.Errorf("IsAlive() = %v, want %v", result, tt.expected)
}
})
}
}
func TestSession_Kill(t *testing.T) {
session := &Session{
ID: "test-kill",
info: &Info{
Status: string(StatusExited),
},
stdinPipe: nil, // Initialize to avoid nil pointer
}
// Kill already exited session
err := session.Kill()
if err != nil {
t.Errorf("Kill() on exited session should succeed: %v", err)
}
}
func TestSession_KillWithSignal(t *testing.T) {
session := &Session{
ID: "test-kill-signal",
info: &Info{
Status: string(StatusExited),
},
}
// Mock cleanup
cleanupCalled := false
session.cleanup = func() {
cleanupCalled = true
}
// Test SIGKILL
err := session.KillWithSignal("SIGKILL")
if err != nil {
t.Errorf("KillWithSignal(SIGKILL) error = %v", err)
}
if !cleanupCalled {
t.Error("cleanup should be called for SIGKILL")
}
// Test numeric signal
cleanupCalled = false
err = session.KillWithSignal("9")
if err != nil {
t.Errorf("KillWithSignal(9) error = %v", err)
}
if !cleanupCalled {
t.Error("cleanup should be called for signal 9")
}
// Test other signal (should use graceful termination)
err = session.KillWithSignal("SIGTERM")
if err != nil {
t.Errorf("KillWithSignal(SIGTERM) error = %v", err)
}
}
func TestSession_SendInput(t *testing.T) {
tmpDir := t.TempDir()
session := &Session{
ID: "test-input",
controlPath: tmpDir,
info: &Info{},
}
// Create stdin pipe
stdinPath := session.StdinPath()
if err := os.MkdirAll(filepath.Dir(stdinPath), 0755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(stdinPath, []byte{}, 0644); err != nil {
t.Fatal(err)
}
// Test sending text input
input := SessionInput{Text: "test input"}
err := session.sendInput(input)
if err != nil {
t.Errorf("SendInput() error = %v", err)
}
// Verify data was written
data, err := os.ReadFile(stdinPath)
if err != nil {
t.Fatal(err)
}
if string(data) != "test input" {
t.Errorf("Written data = %q, want %q", data, "test input")
}
// Test sending special key
os.WriteFile(stdinPath, []byte{}, 0644) // Clear file
input = SessionInput{Key: "arrow_up"}
err = session.sendInput(input)
if err != nil {
t.Errorf("SendInput() with key error = %v", err)
}
data, err = os.ReadFile(stdinPath)
if err != nil {
t.Fatal(err)
}
if string(data) != "\x1b[A" {
t.Errorf("Written data = %q, want %q", data, "\x1b[A")
}
}
func TestSessionStatus(t *testing.T) {
// Test status constants
if StatusStarting != "starting" {
t.Errorf("StatusStarting = %s, want 'starting'", StatusStarting)
}
if StatusRunning != "running" {
t.Errorf("StatusRunning = %s, want 'running'", StatusRunning)
}
if StatusExited != "exited" {
t.Errorf("StatusExited = %s, want 'exited'", StatusExited)
}
}
func TestSessionInput_SpecialKeys(t *testing.T) {
tests := []struct {
key string
expected string
}{
{"arrow_up", "\x1b[A"},
{"arrow_down", "\x1b[B"},
{"arrow_right", "\x1b[C"},
{"arrow_left", "\x1b[D"},
{"escape", "\x1b"},
{"enter", "\r"},
{"ctrl_enter", "\n"},
{"shift_enter", "\r\n"},
}
for _, tt := range tests {
t.Run(tt.key, func(t *testing.T) {
result := specialKeyMap[tt.key]
if result != tt.expected {
t.Errorf("specialKeyMap[%s] = %q, want %q", tt.key, result, tt.expected)
}
})
}
}
func TestInfo_SaveLoad(t *testing.T) {
tmpDir := t.TempDir()
infoPath := filepath.Join(tmpDir, "session.json")
// Create test info
info := &Info{
ID: "test-id",
Name: "test-session",
Cmdline: "bash",
Cwd: "/tmp",
Pid: 12345,
Status: "running",
StartedAt: time.Now(),
Term: "xterm",
Width: 80,
Height: 24,
Args: []string{"bash"},
IsSpawned: true,
}
// Save
if err := info.Save(tmpDir); err != nil {
t.Fatalf("Save() error = %v", err)
}
// Verify file exists
if _, err := os.Stat(infoPath); err != nil {
t.Fatalf("Info file not created: %v", err)
}
// Load
loaded, err := LoadInfo(tmpDir)
if err != nil {
t.Fatalf("LoadInfo() error = %v", err)
}
// Compare
if loaded.ID != info.ID {
t.Errorf("ID = %s, want %s", loaded.ID, info.ID)
}
if loaded.Name != info.Name {
t.Errorf("Name = %s, want %s", loaded.Name, info.Name)
}
if loaded.Pid != info.Pid {
t.Errorf("Pid = %d, want %d", loaded.Pid, info.Pid)
}
if loaded.Width != info.Width {
t.Errorf("Width = %d, want %d", loaded.Width, info.Width)
}
}

266
linux/pkg/session/stdin_watcher_test.go Normal file
View file

@ -0,0 +1,266 @@
package session
import (
"io"
"os"
"path/filepath"
"testing"
"time"
)
func TestNewStdinWatcher(t *testing.T) {
// Create temporary directory for testing
tmpDir := t.TempDir()
// Create a named pipe
pipePath := filepath.Join(tmpDir, "stdin")
if err := os.MkdirAll(filepath.Dir(pipePath), 0755); err != nil {
t.Fatal(err)
}
// Create the pipe file (will be a regular file in tests)
if err := os.WriteFile(pipePath, []byte{}, 0644); err != nil {
t.Fatal(err)
}
// Create a mock PTY file
ptyFile, err := os.CreateTemp(tmpDir, "pty")
if err != nil {
t.Fatal(err)
}
defer ptyFile.Close()
// Test creating stdin watcher
watcher, err := NewStdinWatcher(pipePath, ptyFile)
if err != nil {
t.Fatalf("NewStdinWatcher() error = %v", err)
}
defer watcher.Stop()
if watcher.stdinPath != pipePath {
t.Errorf("stdinPath = %v, want %v", watcher.stdinPath, pipePath)
}
if watcher.ptyFile != ptyFile {
t.Errorf("ptyFile = %v, want %v", watcher.ptyFile, ptyFile)
}
if watcher.watcher == nil {
t.Error("watcher should not be nil")
}
if watcher.stdinFile == nil {
t.Error("stdinFile should not be nil")
}
}
func TestStdinWatcher_StartStop(t *testing.T) {
// Create temporary directory for testing
tmpDir := t.TempDir()
// Create a named pipe
pipePath := filepath.Join(tmpDir, "stdin")
if err := os.WriteFile(pipePath, []byte{}, 0644); err != nil {
t.Fatal(err)
}
// Create a mock PTY file
ptyFile, err := os.CreateTemp(tmpDir, "pty")
if err != nil {
t.Fatal(err)
}
defer ptyFile.Close()
watcher, err := NewStdinWatcher(pipePath, ptyFile)
if err != nil {
t.Fatal(err)
}
// Start the watcher
watcher.Start()
// Give it a moment to start
time.Sleep(10 * time.Millisecond)
// Stop the watcher
done := make(chan bool)
go func() {
watcher.Stop()
done <- true
}()
// Should stop quickly
select {
case <-done:
// Success
case <-time.After(1 * time.Second):
t.Error("Stop() took too long")
}
}
func TestStdinWatcher_HandleStdinData(t *testing.T) {
// Create temporary directory for testing
tmpDir := t.TempDir()
// Create a named pipe path
pipePath := filepath.Join(tmpDir, "stdin")
// Create PTY pipe for reading what's written
ptyReader, ptyWriter, err := os.Pipe()
if err != nil {
t.Fatal(err)
}
defer ptyReader.Close()
defer ptyWriter.Close()
// Create stdin file
stdinFile, err := os.Create(pipePath)
if err != nil {
t.Fatal(err)
}
defer stdinFile.Close()
// Create watcher
watcher := &StdinWatcher{
stdinPath: pipePath,
ptyFile: ptyWriter,
stdinFile: stdinFile,
buffer: make([]byte, 4096),
stopChan: make(chan struct{}),
stoppedChan: make(chan struct{}),
}
// Write test data to stdin
testData := []byte("Hello, World!")
if _, err := stdinFile.Write(testData); err != nil {
t.Fatal(err)
}
if _, err := stdinFile.Seek(0, 0); err != nil {
t.Fatal(err)
}
// Handle the data
watcher.handleStdinData()
// Read from PTY to verify data was forwarded
result := make([]byte, len(testData))
if _, err := io.ReadFull(ptyReader, result); err != nil {
t.Fatalf("Failed to read forwarded data: %v", err)
}
if string(result) != string(testData) {
t.Errorf("Forwarded data = %q, want %q", result, testData)
}
}
func TestIsEAGAIN(t *testing.T) {
tests := []struct {
name string
err error
expected bool
}{
{
name: "nil error",
err: nil,
expected: false,
},
{
name: "EAGAIN error",
err: &os.PathError{Err: os.NewSyscallError("read", os.ErrDeadlineExceeded)},
expected: false, // Our simple implementation checks string
},
{
name: "other error",
err: io.EOF,
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := isEAGAIN(tt.err)
if result != tt.expected {
t.Errorf("isEAGAIN() = %v, want %v", result, tt.expected)
}
})
}
}
func TestStdinWatcher_Cleanup(t *testing.T) {
// Create temporary directory for testing
tmpDir := t.TempDir()
// Create a named pipe
pipePath := filepath.Join(tmpDir, "stdin")
if err := os.WriteFile(pipePath, []byte{}, 0644); err != nil {
t.Fatal(err)
}
// Create a mock PTY file
ptyFile, err := os.CreateTemp(tmpDir, "pty")
if err != nil {
t.Fatal(err)
}
defer ptyFile.Close()
watcher, err := NewStdinWatcher(pipePath, ptyFile)
if err != nil {
t.Fatal(err)
}
// Store references to check if closed
stdinFile := watcher.stdinFile
fsWatcher := watcher.watcher
// Clean up
watcher.cleanup()
// Verify files are closed
if err := stdinFile.Close(); err == nil {
t.Error("stdinFile should have been closed")
}
// Verify watcher is closed by trying to add a path
if err := fsWatcher.Add("/tmp"); err == nil {
t.Error("fsnotify watcher should have been closed")
}
}
func BenchmarkStdinWatcher_HandleData(b *testing.B) {
// Create temporary directory for testing
tmpDir := b.TempDir()
// Create pipes
_, ptyWriter, err := os.Pipe()
if err != nil {
b.Fatal(err)
}
defer ptyWriter.Close()
// Create stdin file with data
stdinPath := filepath.Join(tmpDir, "stdin")
testData := []byte("This is test data for benchmarking stdin handling\n")
b.ResetTimer()
for i := 0; i < b.N; i++ {
// Create fresh stdin file each time
stdinFile, err := os.Create(stdinPath)
if err != nil {
b.Fatal(err)
}
if _, err := stdinFile.Write(testData); err != nil {
b.Fatal(err)
}
if _, err := stdinFile.Seek(0, 0); err != nil {
b.Fatal(err)
}
watcher := &StdinWatcher{
stdinPath: stdinPath,
ptyFile: ptyWriter,
stdinFile: stdinFile,
buffer: make([]byte, 4096),
}
watcher.handleStdinData()
stdinFile.Close()
}
}

247
linux/pkg/session/terminal_test.go Normal file
View file

@ -0,0 +1,247 @@
package session
import (
"os"
"testing"
"golang.org/x/sys/unix"
)
func TestConfigurePTYTerminal(t *testing.T) {
// Skip if not on a Unix system
if os.Getenv("CI") == "true" {
t.Skip("Skipping PTY tests in CI environment")
}
// Create a PTY for testing
master, slave, err := unix.Openpty()
if err != nil {
t.Skipf("Cannot create PTY for testing: %v", err)
}
defer unix.Close(master)
defer unix.Close(slave)
masterFile := os.NewFile(uintptr(master), "master")
defer masterFile.Close()
// Test terminal configuration
err = configurePTYTerminal(masterFile)
if err != nil {
t.Fatalf("configurePTYTerminal() error = %v", err)
}
// Verify terminal attributes were set
fd := int(masterFile.Fd())
termios, err := unix.IoctlGetTermios(fd, unix.TIOCGETA)
if err != nil {
t.Fatalf("Failed to get terminal attributes: %v", err)
}
// Check input flags
inputFlags := termios.Iflag
if inputFlags&unix.IXON == 0 {
t.Error("IXON should be set for flow control")
}
if inputFlags&unix.IXOFF == 0 {
t.Error("IXOFF should be set for flow control")
}
if inputFlags&unix.IXANY == 0 {
t.Error("IXANY should be set for flow control")
}
if inputFlags&unix.ICRNL == 0 {
t.Error("ICRNL should be set for CR to NL mapping")
}
// Check output flags
outputFlags := termios.Oflag
if outputFlags&unix.OPOST == 0 {
t.Error("OPOST should be set for output processing")
}
if outputFlags&unix.ONLCR == 0 {
t.Error("ONLCR should be set for NL to CR-NL mapping")
}
// Check local flags
localFlags := termios.Lflag
if localFlags&unix.ISIG == 0 {
t.Error("ISIG should be set for signal generation")
}
if localFlags&unix.ICANON == 0 {
t.Error("ICANON should be set for canonical mode")
}
if localFlags&unix.ECHO == 0 {
t.Error("ECHO should be set")
}
// Check control characters
if termios.Cc[unix.VINTR] != 3 {
t.Errorf("VINTR = %d, want 3 (Ctrl+C)", termios.Cc[unix.VINTR])
}
if termios.Cc[unix.VQUIT] != 28 {
t.Errorf("VQUIT = %d, want 28 (Ctrl+\\)", termios.Cc[unix.VQUIT])
}
if termios.Cc[unix.VERASE] != 127 {
t.Errorf("VERASE = %d, want 127 (DEL)", termios.Cc[unix.VERASE])
}
if termios.Cc[unix.VKILL] != 21 {
t.Errorf("VKILL = %d, want 21 (Ctrl+U)", termios.Cc[unix.VKILL])
}
if termios.Cc[unix.VSUSP] != 26 {
t.Errorf("VSUSP = %d, want 26 (Ctrl+Z)", termios.Cc[unix.VSUSP])
}
if termios.Cc[unix.VSTART] != 17 {
t.Errorf("VSTART = %d, want 17 (Ctrl+Q)", termios.Cc[unix.VSTART])
}
if termios.Cc[unix.VSTOP] != 19 {
t.Errorf("VSTOP = %d, want 19 (Ctrl+S)", termios.Cc[unix.VSTOP])
}
}
func TestSetPTYSize(t *testing.T) {
// Skip if not on a Unix system
if os.Getenv("CI") == "true" {
t.Skip("Skipping PTY tests in CI environment")
}
// Create a PTY for testing
master, slave, err := unix.Openpty()
if err != nil {
t.Skipf("Cannot create PTY for testing: %v", err)
}
defer unix.Close(master)
defer unix.Close(slave)
masterFile := os.NewFile(uintptr(master), "master")
defer masterFile.Close()
// Test setting PTY size
testCols := uint16(120)
testRows := uint16(40)
err = setPTYSize(masterFile, testCols, testRows)
if err != nil {
t.Fatalf("setPTYSize() error = %v", err)
}
// Verify size was set
gotCols, gotRows, err := getPTYSize(masterFile)
if err != nil {
t.Fatalf("getPTYSize() error = %v", err)
}
if gotCols != testCols {
t.Errorf("cols = %d, want %d", gotCols, testCols)
}
if gotRows != testRows {
t.Errorf("rows = %d, want %d", gotRows, testRows)
}
}
func TestGetPTYSize(t *testing.T) {
// Skip if not on a Unix system
if os.Getenv("CI") == "true" {
t.Skip("Skipping PTY tests in CI environment")
}
// Create a PTY for testing
master, slave, err := unix.Openpty()
if err != nil {
t.Skipf("Cannot create PTY for testing: %v", err)
}
defer unix.Close(master)
defer unix.Close(slave)
masterFile := os.NewFile(uintptr(master), "master")
defer masterFile.Close()
// Get default size
cols, rows, err := getPTYSize(masterFile)
if err != nil {
t.Fatalf("getPTYSize() error = %v", err)
}
// Should have some default size
if cols == 0 || rows == 0 {
t.Errorf("getPTYSize() = (%d, %d), want non-zero values", cols, rows)
}
}
func TestIsTerminal(t *testing.T) {
tests := []struct {
name string
getFd func() (int, func())
expected bool
}{
{
name: "stdout (may be terminal)",
getFd: func() (int, func()) {
return int(os.Stdout.Fd()), func() {}
},
expected: os.Getenv("CI") != "true", // Expect false in CI, true in dev
},
{
name: "regular file",
getFd: func() (int, func()) {
f, err := os.CreateTemp("", "test")
if err != nil {
t.Fatal(err)
}
return int(f.Fd()), func() {
f.Close()
os.Remove(f.Name())
}
},
expected: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
fd, cleanup := tt.getFd()
defer cleanup()
result := isTerminal(fd)
// Skip assertion if we're testing stdout in an unknown environment
if tt.name == "stdout (may be terminal)" && os.Getenv("CI") == "" {
t.Logf("isTerminal(stdout) = %v (skipping assertion in non-CI environment)", result)
return
}
if result != tt.expected {
t.Errorf("isTerminal() = %v, want %v", result, tt.expected)
}
})
}
}
func TestTerminalMode(t *testing.T) {
// Test TerminalMode struct
mode := TerminalMode{
Raw: false,
Echo: true,
LineMode: true,
FlowControl: true,
}
if mode.Raw {
t.Error("Raw mode should be false by default")
}
if !mode.Echo {
t.Error("Echo should be true")
}
if !mode.LineMode {
t.Error("LineMode should be true")
}
if !mode.FlowControl {
t.Error("FlowControl should be true")
}
}
func TestSendSignalToPTY(t *testing.T) {
// Skip if not on a Unix system
if os.Getenv("CI") == "true" {
t.Skip("Skipping PTY tests in CI environment")
}
// This test would require a running process in the PTY
// For now, just test that the function exists and compiles
t.Log("sendSignalToPTY function exists and compiles")
}