`b5794f4`

Add PTY integration for shell communication

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

SHA: b5794f4c0e1bfb65268f9f398f10f231beb2f195
Parents: 22425c0
Tree: 399156a

6 changed files

Status	File	+	-
M	`CMakeLists.txt`	5	2
A	`c_src/pty_helpers.c`	197	0
M	`src/fortty.f90`	66	8
A	`src/pty/pty.f90`	126	0
A	`src/pty/pty_bindings.f90`	62	0
M	`src/window/window.f90`	12	0

CMakeLists.txtmodified

  find_package(OpenGL REQUIRED)
  find_package(Freetype REQUIRED)
 -# C helper libraries (GLAD + FreeType wrappers)
 +# C helper libraries (GLAD + FreeType + PTY wrappers)
  add_library(helpers STATIC
      src/gl/glad.c
      c_src/gl_loader.c
      c_src/freetype_helpers.c
 +    c_src/pty_helpers.c
+ )
  target_include_directories(helpers PUBLIC ${CMAKE_SOURCE_DIR}/include)
  target_include_directories(helpers PRIVATE ${FREETYPE_INCLUDE_DIRS})
 -target_link_libraries(helpers PRIVATE glfw ${FREETYPE_LIBRARIES})
 +target_link_libraries(helpers PRIVATE glfw ${FREETYPE_LIBRARIES} util)
  # Fortran module output directory
  set(CMAKE_Fortran_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/modules)
      src/text/font.f90
      src/text/atlas.f90
      src/text/renderer.f90
 +    src/pty/pty_bindings.f90
 +    src/pty/pty.f90
      src/window/glfw_bindings.f90
      src/window/window.f90
      src/fortty.f90

c_src/pty_helpers.cadded

 +/*
 + * PTY helper functions for fortty
 + * Wraps POSIX PTY operations for Fortran binding
 + */
++
 +#define _XOPEN_SOURCE 600
 +#include <pty.h>
 +#include <unistd.h>
 +#include <fcntl.h>
 +#include <sys/ioctl.h>
 +#include <sys/wait.h>
 +#include <signal.h>
 +#include <errno.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#include <stdio.h>
++
 +/* Store child PID for status checking */
 +static pid_t child_pid = -1;
++
 +/*
 + * Fork a shell process with PTY
 + * Returns master fd on success, -1 on error
 + */
 +int fortty_pty_fork(const char *shell, int rows, int cols) {
 +    int master_fd;
 +    struct winsize ws;
++
 +    /* Set initial window size */
 +    ws.ws_row = rows;
 +    ws.ws_col = cols;
 +    ws.ws_xpixel = 0;
 +    ws.ws_ypixel = 0;
++
 +    /* forkpty does: openpty + fork + login_tty */
 +    child_pid = forkpty(&master_fd, NULL, NULL, &ws);
++
 +    if (child_pid < 0) {
 +        perror("forkpty");
 +        return -1;
 +    }
++
 +    if (child_pid == 0) {
 +        /* Child process */
++
 +        /* Set environment for terminal */
 +        setenv("TERM", "xterm-256color", 1);
 +        setenv("COLORTERM", "truecolor", 1);
++
 +        /* Determine shell to use */
 +        const char *sh = shell;
 +        if (!sh || sh[0] == '\0') {
 +            sh = getenv("SHELL");
 +            if (!sh) {
 +                sh = "/bin/sh";
 +            }
 +        }
++
 +        /* Execute shell as login shell */
 +        /* Using -l flag for login shell behavior */
 +        execlp(sh, sh, "-l", (char *)NULL);
++
 +        /* If exec fails */
 +        perror("execlp");
 +        _exit(127);
 +    }
++
 +    /* Parent process */
++
 +    /* Set non-blocking mode on master */
 +    int flags = fcntl(master_fd, F_GETFL, 0);
 +    if (flags != -1) {
 +        fcntl(master_fd, F_SETFL, flags | O_NONBLOCK);
 +    }
++
 +    return master_fd;
 +}
++
 +/*
 + * Set PTY window size
 + * Returns 0 on success, -1 on error
 + */
 +int fortty_pty_set_size(int master_fd, int rows, int cols) {
 +    struct winsize ws;
 +    ws.ws_row = rows;
 +    ws.ws_col = cols;
 +    ws.ws_xpixel = 0;
 +    ws.ws_ypixel = 0;
++
 +    if (ioctl(master_fd, TIOCSWINSZ, &ws) < 0) {
 +        perror("ioctl TIOCSWINSZ");
 +        return -1;
 +    }
++
 +    return 0;
 +}
++
 +/*
 + * Read from PTY (non-blocking)
 + * Returns: bytes read (>0), 0 if would block, -1 on error/EOF
 + */
 +int fortty_pty_read(int fd, char *buf, int count) {
 +    ssize_t n = read(fd, buf, count);
++
 +    if (n < 0) {
 +        if (errno == EAGAIN || errno == EWOULDBLOCK) {
 +            return 0;  /* No data available */
 +        }
 +        return -1;  /* Actual error */
 +    }
++
 +    if (n == 0) {
 +        return -1;  /* EOF - child closed PTY */
 +    }
++
 +    return (int)n;
 +}
++
 +/*
 + * Write to PTY
 + * Returns: bytes written, -1 on error
 + */
 +int fortty_pty_write(int fd, const char *buf, int count) {
 +    ssize_t n = write(fd, buf, count);
 +    if (n < 0) {
 +        if (errno == EAGAIN || errno == EWOULDBLOCK) {
 +            return 0;  /* Would block, try again later */
 +        }
 +        perror("write to pty");
 +        return -1;
 +    }
 +    return (int)n;
 +}
++
 +/*
 + * Close PTY and wait for child
 + */
 +void fortty_pty_close(int master_fd) {
 +    if (master_fd >= 0) {
 +        close(master_fd);
 +    }
++
 +    if (child_pid > 0) {
 +        /* Send SIGHUP to child (standard terminal close behavior) */
 +        kill(child_pid, SIGHUP);
++
 +        /* Wait for child to exit (with timeout via WNOHANG loop) */
 +        int status;
 +        int attempts = 0;
 +        while (waitpid(child_pid, &status, WNOHANG) == 0 && attempts < 100) {
 +            usleep(10000);  /* 10ms */
 +            attempts++;
 +        }
++
 +        /* Force kill if still running */
 +        if (attempts >= 100) {
 +            kill(child_pid, SIGKILL);
 +            waitpid(child_pid, &status, 0);
 +        }
++
 +        child_pid = -1;
 +    }
 +}
++
 +/*
 + * Check if child process is still alive
 + * Returns: 1 if alive, 0 if dead/not started
 + */
 +int fortty_pty_child_alive(void) {
 +    if (child_pid <= 0) {
 +        return 0;
 +    }
++
 +    int status;
 +    pid_t result = waitpid(child_pid, &status, WNOHANG);
++
 +    if (result == 0) {
 +        /* Child still running */
 +        return 1;
 +    }
++
 +    if (result == child_pid) {
 +        /* Child exited */
 +        child_pid = -1;
 +        return 0;
 +    }
++
 +    /* Error (treat as dead) */
 +    return 0;
 +}
++
 +/*
 + * Get the child PID (for debugging/signals)
 + */
 +int fortty_pty_get_child_pid(void) {
 +    return (int)child_pid;
 +}

src/fortty.f90modified

    use window_mod
    use gl_bindings
    use renderer_mod
 +  use pty_mod
    implicit none
    type(window_t) :: win
    type(renderer_t) :: ren
 +  type(pty_t) :: pty
    integer :: win_width, win_height
 +  integer :: prev_width, prev_height
 +  integer :: term_rows, term_cols
 +  integer :: new_rows, new_cols
    character(len=256) :: font_path
 +  character(len=4096) :: pty_buffer
 +  integer :: nbytes
 +  integer, parameter :: CELL_WIDTH = 10   ! Approximate char width
 +  integer, parameter :: CELL_HEIGHT = 20  ! Approximate line height
    ! Window dimensions
    win_width = 800
    font_path = "/usr/share/fonts/TTF/DejaVuSansMono.ttf"
    ! Create renderer with font
 -  ren = renderer_create(trim(font_path), 24)
 +  ren = renderer_create(trim(font_path), 16)
    if (.not. ren%initialized) then
      print *, "Warning: Could not load font, trying alternate path..."
      font_path = "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf"
 -    ren = renderer_create(trim(font_path), 24)
 +    ren = renderer_create(trim(font_path), 16)
    end if
    if (.not. ren%initialized) then
    ! Set up projection matrix
    call renderer_set_projection(ren, win_width, win_height)
 +  ! Calculate terminal dimensions based on font metrics
 +  term_cols = win_width / CELL_WIDTH
 +  term_rows = win_height / CELL_HEIGHT
 +  prev_width = win_width
 +  prev_height = win_height
++
 +  ! Open PTY with shell
 +  pty = pty_open("", term_rows, term_cols)  ! Empty string = use $SHELL
++
 +  if (.not. pty%active) then
 +    print *, "Error: Could not open PTY"
 +    call renderer_destroy(ren)
 +    call window_destroy(win)
 +    stop 1
 +  end if
++
 +  print *, "PTY opened successfully"
 +  print *, "Terminal size:", term_cols, "x", term_rows
++
    ! Main event loop
 -  do while (.not. window_should_close(win))
 +  do while (.not. window_should_close(win) .and. pty_is_alive(pty))
 +    ! Check for window resize
 +    call window_get_size(win, win_width, win_height)
 +    if (win_width /= prev_width .or. win_height /= prev_height) then
 +      prev_width = win_width
 +      prev_height = win_height
++
 +      ! Update projection matrix
 +      call renderer_set_projection(ren, win_width, win_height)
++
 +      ! Calculate new terminal size and notify PTY
 +      new_cols = win_width / CELL_WIDTH
 +      new_rows = win_height / CELL_HEIGHT
 +      if (new_cols /= term_cols .or. new_rows /= term_rows) then
 +        term_cols = new_cols
 +        term_rows = new_rows
 +        call pty_resize(pty, term_rows, term_cols)
 +      end if
 +    end if
++
 +    ! Read from PTY (non-blocking)
 +    nbytes = pty_read(pty, pty_buffer, 4096)
 +    if (nbytes > 0) then
 +      ! For now, just print to stdout (Phase 4 will render to screen)
 +      write(*,'(A)', advance='no') pty_buffer(1:nbytes)
 +    end if
++
      ! Clear screen with dark gray background
      call glClearColor(0.1, 0.1, 0.12, 1.0)
      call glClear(GL_COLOR_BUFFER_BIT)
      ! Begin new frame
      call renderer_begin(ren)
 -    ! Draw test text
 -    call renderer_draw_string(ren, 50.0, 100.0, "Hello, Fortran!", &
 -                              1.0, 1.0, 1.0, 1.0)
 +    ! Draw status text
 +    call renderer_draw_string(ren, 10.0, 30.0, "fortty - Shell connected", &
 +                              0.0, 1.0, 0.0, 1.0)
 -    call renderer_draw_string(ren, 50.0, 150.0, "Terminal emulator in progress...", &
 -                              0.7, 0.7, 0.7, 1.0)
 +    call renderer_draw_string(ren, 10.0, 60.0, "(Shell output goes to stdout for now)", &
 +                              0.5, 0.5, 0.5, 1.0)
      ! Flush to GPU
      call renderer_flush(ren)
      call window_poll_events()
    end do
 +  print *, ""
 +  print *, "Shell exited or window closed"
++
    ! Cleanup
 +  call pty_close(pty)
    call renderer_destroy(ren)
    call window_destroy(win)

src/pty/pty.f90added

 +module pty_mod
 +  use, intrinsic :: iso_c_binding
 +  use pty_bindings
 +  implicit none
 +  private
++
 +  public :: pty_t
 +  public :: pty_open, pty_close, pty_resize
 +  public :: pty_read, pty_write, pty_is_alive
++
 +  type :: pty_t
 +    integer :: master_fd = -1
 +    integer :: rows = 24
 +    integer :: cols = 80
 +    logical :: active = .false.
 +  end type pty_t
++
 +contains
++
 +  ! Open PTY and spawn shell
 +  function pty_open(shell, rows, cols) result(p)
 +    character(len=*), intent(in) :: shell
 +    integer, intent(in) :: rows, cols
 +    type(pty_t) :: p
 +    integer(c_int) :: fd
++
 +    p%rows = rows
 +    p%cols = cols
++
 +    ! Fork shell with PTY
 +    fd = c_pty_fork(trim(shell) // c_null_char, int(rows, c_int), int(cols, c_int))
++
 +    if (fd < 0) then
 +      print *, "Error: Failed to create PTY"
 +      p%active = .false.
 +      return
 +    end if
++
 +    p%master_fd = fd
 +    p%active = .true.
++
 +  end function pty_open
++
 +  ! Close PTY and cleanup
 +  subroutine pty_close(p)
 +    type(pty_t), intent(inout) :: p
++
 +    if (p%master_fd >= 0) then
 +      call c_pty_close(int(p%master_fd, c_int))
 +      p%master_fd = -1
 +    end if
++
 +    p%active = .false.
++
 +  end subroutine pty_close
++
 +  ! Resize PTY
 +  subroutine pty_resize(p, rows, cols)
 +    type(pty_t), intent(inout) :: p
 +    integer, intent(in) :: rows, cols
 +    integer(c_int) :: result
++
 +    if (.not. p%active) return
++
 +    result = c_pty_set_size(int(p%master_fd, c_int), &
 +                            int(rows, c_int), int(cols, c_int))
++
 +    if (result == 0) then
 +      p%rows = rows
 +      p%cols = cols
 +    end if
++
 +  end subroutine pty_resize
++
 +  ! Read from PTY (non-blocking)
 +  ! Returns: bytes read (>0), 0 if no data, -1 on error/EOF
 +  function pty_read(p, buffer, maxlen) result(nbytes)
 +    type(pty_t), intent(in) :: p
 +    character(len=*), intent(out) :: buffer
 +    integer, intent(in) :: maxlen
 +    integer :: nbytes
++
 +    if (.not. p%active) then
 +      nbytes = -1
 +      return
 +    end if
++
 +    nbytes = c_pty_read(int(p%master_fd, c_int), buffer, int(maxlen, c_int))
++
 +  end function pty_read
++
 +  ! Write to PTY
 +  subroutine pty_write(p, data, length)
 +    type(pty_t), intent(in) :: p
 +    character(len=*), intent(in) :: data
 +    integer, intent(in) :: length
 +    integer(c_int) :: result
++
 +    if (.not. p%active) return
++
 +    result = c_pty_write(int(p%master_fd, c_int), data, int(length, c_int))
++
 +  end subroutine pty_write
++
 +  ! Check if child shell is alive
 +  function pty_is_alive(p) result(alive)
 +    type(pty_t), intent(inout) :: p
 +    logical :: alive
 +    integer(c_int) :: status
++
 +    if (.not. p%active) then
 +      alive = .false.
 +      return
 +    end if
++
 +    status = c_pty_child_alive()
 +    alive = (status /= 0)
++
 +    ! Update active flag if child died
 +    if (.not. alive) then
 +      p%active = .false.
 +    end if
++
 +  end function pty_is_alive
++
 +end module pty_mod

src/pty/pty_bindings.f90added

 +module pty_bindings
 +  use, intrinsic :: iso_c_binding
 +  implicit none
 +  private
++
 +  public :: c_pty_fork, c_pty_set_size, c_pty_read, c_pty_write
 +  public :: c_pty_close, c_pty_child_alive, c_pty_get_child_pid
++
 +  interface
++
 +    ! Fork shell and return master fd (-1 on error)
 +    integer(c_int) function c_pty_fork(shell, rows, cols) &
 +        bind(C, name="fortty_pty_fork")
 +      import :: c_int, c_char
 +      character(kind=c_char), intent(in) :: shell(*)
 +      integer(c_int), value :: rows, cols
 +    end function c_pty_fork
++
 +    ! Set PTY window size (0 on success, -1 on error)
 +    integer(c_int) function c_pty_set_size(master_fd, rows, cols) &
 +        bind(C, name="fortty_pty_set_size")
 +      import :: c_int
 +      integer(c_int), value :: master_fd, rows, cols
 +    end function c_pty_set_size
++
 +    ! Read from PTY (returns bytes read, 0 if would block, -1 on error/EOF)
 +    integer(c_int) function c_pty_read(fd, buf, count) &
 +        bind(C, name="fortty_pty_read")
 +      import :: c_int, c_char
 +      integer(c_int), value :: fd, count
 +      character(kind=c_char), intent(out) :: buf(*)
 +    end function c_pty_read
++
 +    ! Write to PTY (returns bytes written, -1 on error)
 +    integer(c_int) function c_pty_write(fd, buf, count) &
 +        bind(C, name="fortty_pty_write")
 +      import :: c_int, c_char
 +      integer(c_int), value :: fd, count
 +      character(kind=c_char), intent(in) :: buf(*)
 +    end function c_pty_write
++
 +    ! Close PTY and wait for child
 +    subroutine c_pty_close(master_fd) bind(C, name="fortty_pty_close")
 +      import :: c_int
 +      integer(c_int), value :: master_fd
 +    end subroutine c_pty_close
++
 +    ! Check if child is alive (1 = alive, 0 = dead)
 +    integer(c_int) function c_pty_child_alive() &
 +        bind(C, name="fortty_pty_child_alive")
 +      import :: c_int
 +    end function c_pty_child_alive
++
 +    ! Get child PID
 +    integer(c_int) function c_pty_get_child_pid() &
 +        bind(C, name="fortty_pty_get_child_pid")
 +      import :: c_int
 +    end function c_pty_get_child_pid
++
 +  end interface
++
 +end module pty_bindings

src/window/window.f90modified

    public :: window_t
    public :: window_create, window_destroy
    public :: window_should_close, window_swap_buffers, window_poll_events
 +  public :: window_get_size
    type :: window_t
      type(c_ptr) :: handle = c_null_ptr
      call glfwPollEvents()
    end subroutine window_poll_events
 +  ! Get current framebuffer size
 +  subroutine window_get_size(win, width, height)
 +    type(window_t), intent(in) :: win
 +    integer, intent(out) :: width, height
 +    integer(c_int) :: w, h
++
 +    call glfwGetFramebufferSize(win%handle, w, h)
 +    width = int(w)
 +    height = int(h)
 +  end subroutine window_get_size
++
    ! Callback: handle window resize
    subroutine framebuffer_size_callback(window, width, height) bind(C)
      type(c_ptr), value :: window