os.pty

What people get wrong:

• Sending \n for Enter. A terminal sends \r when Enter is pressed and the line discipline turns it into a newline for programs that read lines, so type \r. A program in raw mode sees the \r itself.
• Expecting \n in the output. The terminal turns each newline into \r\n, so look for \r\n when waiting for a line end.
• Reading without a time limit. Use ReadUntil with a prompt and a number of milliseconds, and check timed_out, so a program that never prints the prompt cannot hang yours.
• Forgetting that your own typing is echoed. After Write the first thing to come back is the echo of what you typed.
• Setting TERM. Programs that draw on the screen read it; put it in the command with Env("TERM", "xterm").

Open a terminal and type into it

Start the program with Open and the window size in rows and columns (0 means 24 by 80). Writing the text of a key press, with \r for Enter, reaches the program as input; reading returns the terminal echo first and then the program's answer. Calling CloseStdin ends the input of a program such as cat.

import os.process
import os.pty

func main:
    mut cmd := process.NewCommand("cat")
    mut term := pty.Open(cmd, 24, 80)
    term.Write("typed on a terminal\r")
    echoed := term.ReadUntil("terminal\r\n", 2000)
    println "the terminal echoed it:", not echoed.timed_out
    echoed.Free()
    answer := term.ReadUntil("terminal\r\n", 2000)
    println "cat answered:", not answer.timed_out
    answer.Free()
    term.CloseStdin()
    println "exit:", term.Wait(2000).code
    term.Close()
    cmd.Free()
end

Wait for a prompt

An interactive program prints a prompt and then waits. ReadUntil returns as soon as the prompt text has arrived, or reports timed_out after the time you gave. That is the loop of every terminal test: wait for the prompt, type a line, wait for the answer.

import os.process
import os.pty

func main:
    mut cmd := process.NewCommand("sh")
    cmd.Arg("-c")
    cmd.Arg("printf 'name? '; read name; echo \"hi $name\"")
    mut term := pty.Open(cmd, 24, 80)
    ask := term.ReadUntil("name? ", 2000)
    println "prompt seen:", not ask.timed_out
    ask.Free()
    term.Write("Sara\r")
    reply := term.ReadUntil("hi Sara", 2000)
    println "reply seen:", not reply.timed_out
    reply.Free()
    println "exit:", term.Wait(2000).code
    term.Close()
    cmd.Free()
end

Change the window size

Resize sets the size of the terminal and the system tells the program, which is how a full-screen program learns to redraw. GetSize reads the size back. The program sees the new size the next time it asks, for example through stty size.

import os.process
import os.pty

func main:
    mut cmd := process.NewCommand("sh")
    cmd.Arg("-c")
    cmd.Arg("stty size; read x; stty size")
    mut term := pty.Open(cmd, 24, 80)
    first := term.ReadUntil("24 80", 2000)
    println "first size seen:", not first.timed_out
    first.Free()
    println "resize:", pty.Resize(term, 50, 132)
    term.Write("\r")
    second := term.ReadUntil("50 132", 2000)
    println "second size seen:", not second.timed_out
    second.Free()
    println "exit:", term.Wait(2000).code
    term.Close()
    cmd.Free()
end

Types

struct Size

import os.process
import os.pty

func main:
    mut cmd := process.NewCommand("sh")
    cmd.Arg("-c")
    cmd.Arg("read line; stty size")
    mut term := pty.Open(cmd, 24, 80)
    println "start:", pty.GetSize(term).rows, pty.GetSize(term).cols
    println "resized:", pty.Resize(term, 40, 120)
    println "now:", pty.GetSize(term).rows, pty.GetSize(term).cols
    term.Write("go\r")
    out := term.ReadUntil("40 120", 2000)
    println "child sees the new size:", not out.timed_out
    out.Free()
    println "exit:", term.Wait(2000).code
    term.Close()
    cmd.Free()
end

Functions