#!/bin/zsh
# gt-action <id> <verb> [args...]
# Performs a constrained Ghostty action. For the full action list, see references/actions.md.
set -euo pipefail

TID="${1:-}"; VERB="${2:-}"
[[ -n "$TID" && -n "$VERB" ]] || { echo "usage: gt-action <id> <verb> [args...]" >&2; exit 2; }
shift 2

need_no_args() {
  [[ $# -eq 0 ]] || { echo "gt-action: '$VERB' takes no args" >&2; exit 2; }
}

need_dir() {
  local dir="${1:-}"
  [[ -n "$dir" && "${2:-}" == "" ]] || { echo "gt-action: '$VERB' requires one direction" >&2; exit 2; }
  case "$dir" in
    right|left|up|down|previous|next) echo "$dir" ;;
    *) echo "gt-action: unsupported direction '$dir'" >&2; exit 2 ;;
  esac
}

case "$VERB" in
  next-tab) need_no_args "$@"; ACTION="next_tab" ;;
  previous-tab) need_no_args "$@"; ACTION="previous_tab" ;;
  equalize-splits) need_no_args "$@"; ACTION="equalize_splits" ;;
  toggle-split-zoom) need_no_args "$@"; ACTION="toggle_split_zoom" ;;
  clear-screen) need_no_args "$@"; ACTION="clear_screen" ;;
  reset) need_no_args "$@"; ACTION="reset" ;;
  scroll-top) need_no_args "$@"; ACTION="scroll_to_top" ;;
  scroll-bottom) need_no_args "$@"; ACTION="scroll_to_bottom" ;;
  goto-split)
    DIR="$(need_dir "$@")"
    ACTION="goto_split:$DIR"
    ;;
  resize-split)
    DIR="${1:-}"; AMOUNT="${2:-}"
    [[ -n "$DIR" && -n "$AMOUNT" && "${3:-}" == "" ]] || { echo "gt-action: resize-split requires direction and amount" >&2; exit 2; }
    case "$DIR" in right|left|up|down) ;; *) echo "gt-action: unsupported resize direction '$DIR'" >&2; exit 2 ;; esac
    [[ "$AMOUNT" == <-> ]] || { echo "gt-action: resize amount must be a positive integer" >&2; exit 2; }
    ACTION="resize_split:$DIR,$AMOUNT"
    ;;
  set-tab-title)
    [[ -n "${1:-}" && "${2:-}" == "" ]] || { echo "gt-action: set-tab-title requires one title" >&2; exit 2; }
    ACTION="set_tab_title:$1"
    ;;
  set-surface-title)
    [[ -n "${1:-}" && "${2:-}" == "" ]] || { echo "gt-action: set-surface-title requires one title" >&2; exit 2; }
    ACTION="set_surface_title:$1"
    ;;
  *)
    echo "gt-action: unsupported verb '$VERB' (see references/actions.md for raw action strings)" >&2
    exit 2
    ;;
esac

osascript - "$TID" "$ACTION" <<'EOF' >/dev/null || { echo "gt-action: failed to perform '$VERB' on $TID" >&2; exit 1; }
on run argv
    tell application "Ghostty"
        perform action (item 2 of argv) on (terminal id (item 1 of argv))
    end tell
end run
EOF

#!/bin/zsh
# gt-close <id> [--force] [--json]
# Closes the terminal with the given id without tripping Ghostty's
# "process is running" confirmation dialog (which stalls autonomous flows).
# Default: interrupt the foreground process (ctrl+c), then send EOF (ctrl+d) to
# the shell -- the surface closes itself, no dialog. If the terminal survives (e.g. a TUI
# that ignores ctrl+c), falls back to AppleScript close and auto-confirms the
# sheet if one appears. --force skips the graceful phase.
set -euo pipefail

TID="" FORCE=0 JSON=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --force) FORCE=1; shift ;;
    --json) JSON=1; shift ;;
    -h|--help) sed -n '2,7p' "$0"; exit 0 ;;
    *) if [[ -z "$TID" ]]; then TID="$1"; else echo "gt-close: unknown arg '$1'" >&2; exit 2; fi; shift ;;
  esac
done
[[ -n "$TID" ]] || { echo "usage: gt-close <id> [--force] [--json]" >&2; exit 2; }

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

emit_json() {
  local close_status="$1" method="$2" closed="$3"
  printf '{"backend":"applescript","id":"%s","status":"%s","method":"%s","closed":%s}\n' \
    "$(json_escape "$TID")" "$(json_escape "$close_status")" "$(json_escape "$method")" "$closed"
}

exists() {
  osascript - "$TID" <<'EOF' 2>/dev/null
on run argv
    tell application "Ghostty"
        try
            get id of (terminal id (item 1 of argv))
            return "yes"
        on error
            return "no"
        end try
    end tell
end run
EOF
}

if [[ "$(exists)" == "no" ]]; then
  if [[ "$JSON" == "1" ]]; then
    emit_json "already_closed" "none" true
  else
    echo "gt-close: no terminal with id $TID (already closed?)"
  fi
  exit 0
fi

graceful_once() {
  osascript - "$TID" <<'EOF' >/dev/null 2>&1
on run argv
    tell application "Ghostty"
        set t to terminal id (item 1 of argv)
        send key "c" modifiers "control" to t
        delay 0.35
        send key "d" modifiers "control" to t
    end tell
end run
EOF
}

if [[ "$FORCE" == "0" ]]; then
  # graceful: interrupt foreground process, then EOF the shell. This avoids
  # paste timing failures such as "exit~" or dropped leading characters.
  for attempt in 1 2; do
    graceful_once || true
    for i in {1..10}; do
      if [[ "$(exists)" == "no" ]]; then
        if [[ "$JSON" == "1" ]]; then
          emit_json "closed" "graceful" true
        else
          echo "closed $TID (graceful)"
        fi
        exit 0
      fi
      sleep 0.25
    done
  done
fi

# force path: AppleScript close, then auto-confirm the sheet if Ghostty raises one
osascript - "$TID" <<'EOF' >/dev/null 2>&1
on run argv
    tell application "Ghostty"
        try
            close (terminal id (item 1 of argv))
        end try
    end tell
    delay 0.4
    tell application "System Events" to tell process "Ghostty"
        try
            set s to sheet 1 of (first window whose subrole is "AXStandardWindow")
            click (first button of s whose name is "Close")
        end try
    end tell
end run
EOF
sleep 0.3
if [[ "$(exists)" == "no" ]]; then
  if [[ "$JSON" == "1" ]]; then
    emit_json "closed" "forced" true
  else
    echo "closed $TID (forced)"
  fi
else
  [[ "$JSON" == "1" ]] && emit_json "failed" "forced" false
  echo "gt-close: terminal $TID still open -- a dialog may need manual attention" >&2
  exit 1
fi

#!/bin/zsh
# gt-copy <id>
# Copies the terminal's current selection to the clipboard, prints it on stdout,
# then restores the user's clipboard. Empty output = no selection.
set -euo pipefail

TID="${1:-}"
[[ -n "$TID" ]] || { echo "usage: gt-copy <id>" >&2; exit 2; }

OLD_CLIP=$(pbpaste 2>/dev/null || true)
pbcopy < /dev/null

osascript - "$TID" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        perform action "copy_to_clipboard" on (terminal id (item 1 of argv))
    end tell
end run
EOF

for i in {1..20}; do
  SEL=$(pbpaste 2>/dev/null || true)
  [[ -n "$SEL" ]] && break
  sleep 0.05
done
printf '%s\n' "${SEL:-}"
printf '%s' "$OLD_CLIP" | pbcopy

#!/bin/zsh
# gt-focus <id>
# Focuses a Ghostty terminal and prints the focused terminal id.
set -euo pipefail

TID="${1:-}"
[[ -n "$TID" && "${2:-}" == "" ]] || { echo "usage: gt-focus <id>" >&2; exit 2; }

osascript - "$TID" <<'EOF' || { echo "gt-focus: failed to focus $TID" >&2; exit 1; }
on run argv
    tell application "Ghostty"
        set t to terminal id (item 1 of argv)
        focus t
        return id of t
    end tell
end run
EOF

#!/bin/zsh
# gt-list [--json]
# Lists Ghostty terminals known to the AppleScript object model.
set -euo pipefail

JSON=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --json) JSON=1; shift ;;
    -h|--help) sed -n '2,4p' "$0"; exit 0 ;;
    *) echo "gt-list: unknown arg '$1'" >&2; exit 2 ;;
  esac
done

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

bool() {
  [[ "$1" == "true" ]] && printf true || printf false
}

ROWS=$(osascript <<'EOF'
on clean(s)
    set s to s as text
    set oldDelims to AppleScript's text item delimiters
    set AppleScript's text item delimiters to {tab, linefeed, return}
    set parts to text items of s
    set AppleScript's text item delimiters to " "
    set cleaned to parts as text
    set AppleScript's text item delimiters to oldDelims
    return cleaned
end clean

tell application "Ghostty"
    set out to ""
    set d to character id 9
    repeat with w in windows
        set wid to id of w as text
        try
            set wname to my clean(name of w)
        on error
            set wname to ""
        end try
        try
            set selectedTabId to id of selected tab of w as text
        on error
            set selectedTabId to ""
        end try
        repeat with tb in tabs of w
            set tbid to id of tb as text
            try
                set tbname to my clean(name of tb)
            on error
                set tbname to ""
            end try
            set isSelected to "false"
            if tbid is selectedTabId then set isSelected to "true"
            try
                set focusedId to id of focused terminal of tb as text
            on error
                set focusedId to ""
            end try
            repeat with t in terminals of tb
                set tid to id of t as text
                try
                    set tname to my clean(name of t)
                on error
                    set tname to ""
                end try
                try
                    set cwd to my clean(working directory of t)
                on error
                    set cwd to ""
                end try
                set isFocused to "false"
                if tid is focusedId then set isFocused to "true"
                set out to out & tid & d & wid & d & tbid & d & isSelected & d & isFocused & d & wname & d & tbname & d & tname & d & cwd & linefeed
            end repeat
        end repeat
    end repeat
    return out
end tell
EOF
) || { echo "gt-list: Ghostty scripting failed" >&2; exit 1; }

if [[ "$JSON" == "1" ]]; then
  printf '{"backend":"applescript","terminals":['
  FIRST=1
  while IFS=$'\t' read -r TID WID TBID SELECTED FOCUSED WNAME TBNAME TNAME CWD; do
    [[ -n "${TID:-}" ]] || continue
    [[ "$FIRST" == "1" ]] || printf ','
    FIRST=0
    printf '{"id":"%s","window_id":"%s","tab_id":"%s","selected":%s,"focused":%s,"window_name":"%s","tab_name":"%s","terminal_name":"%s","cwd":"%s"}' \
      "$(json_escape "$TID")" "$(json_escape "$WID")" "$(json_escape "$TBID")" "$(bool "$SELECTED")" "$(bool "$FOCUSED")" \
      "$(json_escape "$WNAME")" "$(json_escape "$TBNAME")" "$(json_escape "$TNAME")" "$(json_escape "$CWD")"
  done <<< "$ROWS"
  printf ']}\n'
else
  printf '%-36s %-8s %-8s %-3s %-3s %s\n' "terminal_id" "window" "tab" "sel" "foc" "name"
  while IFS=$'\t' read -r TID WID TBID SELECTED FOCUSED WNAME TBNAME TNAME CWD; do
    [[ -n "${TID:-}" ]] || continue
    SEL="-"; [[ "$SELECTED" == "true" ]] && SEL="yes"
    FOC="-"; [[ "$FOCUSED" == "true" ]] && FOC="yes"
    NAME="$TBNAME"
    [[ -n "$NAME" ]] || NAME="$TNAME"
    [[ -n "$NAME" ]] || NAME="$WNAME"
    printf '%-36s %-8s %-8s %-3s %-3s %s\n' "$TID" "$WID" "$TBID" "$SEL" "$FOC" "$NAME"
  done <<< "$ROWS"
fi

#!/bin/zsh
# gt-mouse <id> click <x> <y> [--button left|right|middle] [--mods control,...]
# gt-mouse <id> move <x> <y>
# gt-mouse <id> scroll <dy> [dx]
# Coordinates are pixels, origin top-left of the terminal surface.
set -euo pipefail

TID="${1:-}"; VERB="${2:-}"; shift 2 || true
[[ -n "$TID" && -n "$VERB" ]] || { sed -n '2,5p' "$0" >&2; exit 2; }

case "$VERB" in
  click)
    X="$1"; Y="$2"; shift 2
    BUTTON="left button" MODS=""
    while [[ $# -gt 0 ]]; do
      case "$1" in
        --button) BUTTON="$2 button"; shift 2 ;;
        --mods)   MODS="$2"; shift 2 ;;
        *) echo "gt-mouse: unknown arg '$1'" >&2; exit 2 ;;
      esac
    done
    osascript - "$TID" "$X" "$Y" "$BUTTON" "$MODS" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        set t to terminal id (item 1 of argv)
        set bx to item 2 of argv as real
        set by to item 3 of argv as real
        send mouse position x bx y by to t
        delay 0.05
        if item 4 of argv is "right button" then
            set b to right button
        else if item 4 of argv is "middle button" then
            set b to middle button
        else
            set b to left button
        end if
        if item 5 of argv is "" then
            send mouse button b action press to t
            delay 0.05
            send mouse button b action release to t
        else
            send mouse button b action press modifiers (item 5 of argv) to t
            delay 0.05
            send mouse button b action release modifiers (item 5 of argv) to t
        end if
    end tell
end run
EOF
    ;;
  move)
    X="$1"; Y="$2"
    osascript - "$TID" "$X" "$Y" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        send mouse position x ((item 2 of argv) as real) y ((item 3 of argv) as real) to (terminal id (item 1 of argv))
    end tell
end run
EOF
    ;;
  scroll)
    DY="$1"; DX="${2:-0}"
    osascript - "$TID" "$DY" "$DX" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        send mouse scroll x ((item 3 of argv) as real) y ((item 2 of argv) as real) to (terminal id (item 1 of argv))
    end tell
end run
EOF
    ;;
  *) echo "gt-mouse: unknown verb '$VERB' (click|move|scroll)" >&2; exit 2 ;;
esac

#!/bin/zsh
# gt-open [sibling_id] [--cwd dir] [--cmd "command"] [--name title] [--ready-delay max_seconds] [--json]
# Opens a named tab in the window containing sibling_id (front window if omitted).
# Prints the new terminal's id on stdout — keep it; it is the handle for every other gt-* script.
# Readiness is polled, not slept: returns as soon as the new surface paints a
# non-blank, settled frame (shell prompt or TUI first paint), up to
# --ready-delay seconds (default 5). --no-wait skips the readiness poll.
set -euo pipefail

HERE="${0:A:h}"
SIBLING="" CWD="" CMD="" NAME="" READY_DELAY=5 JSON=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --cwd)  CWD="$2"; shift 2 ;;
    --cmd)  CMD="$2"; shift 2 ;;
    --name) NAME="$2"; shift 2 ;;
    --ready-delay) READY_DELAY="$2"; shift 2 ;;
    --no-wait) READY_DELAY=0; shift ;;
    --json) JSON=1; shift ;;
    -h|--help) sed -n '2,8p' "$0"; exit 0 ;;
    *) SIBLING="$1"; shift ;;
  esac
done
[[ -n "$NAME" ]] || NAME="gt: ${CMD:-shell}"
[[ "$READY_DELAY" == <->(|.<->) ]] || { echo "gt-open: --ready-delay must be a non-negative number" >&2; exit 2; }

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

ID=$(osascript - "$SIBLING" "$CWD" "$CMD" "$NAME" "$READY_DELAY" <<'EOF'
on run argv
    set sibling to item 1 of argv
    set cwd to item 2 of argv
    set cmd to item 3 of argv
    set tabName to item 4 of argv
    tell application "Ghostty"
        -- pick target window: the one containing the sibling terminal, else front
        set w to front window
        if sibling is not "" then
            repeat with cw in windows
                repeat with t in terminals of cw
                    if id of t is sibling then
                        set w to cw
                        exit repeat
                    end if
                end repeat
            end repeat
        end if
        set conf to new surface configuration
        if cwd is not "" then set initial working directory of conf to cwd
        if cmd is not "" then set initial input of conf to (cmd & linefeed)
        set tb to new tab in w with configuration conf
        delay 0.35 -- let the surface resolve; shell readiness is polled by the caller
        set t to focused terminal of tb
        perform action ("set_tab_title:" & tabName) on t
        return id of t
    end tell
end run
EOF
)
# readiness poll: first non-blank frame that holds steady two polls in a row.
# Plain shells settle as soon as the prompt paints (usually well under 1.5s);
# animated TUIs never settle and fall through at the cap, which only means the
# caller should gt-wait --for their first known pattern anyway.
if [[ "$READY_DELAY" != "0" ]]; then
  typeset -F SECONDS
  START=$SECONDS PREV=""
  while (( SECONDS - START < READY_DELAY )); do
    FRAME=$("$HERE/gt-screen" "$ID" 2>/dev/null || true)
    if [[ -n "${FRAME//[[:space:]]/}" && "$FRAME" == "$PREV" ]]; then break; fi
    PREV="$FRAME"
    sleep 0.15
  done
fi

if [[ "$JSON" == "1" ]]; then
  CMD_PRESENT=false; [[ -n "$CMD" ]] && CMD_PRESENT=true
  printf '{"backend":"applescript","id":"%s","name":"%s","cwd":"%s","command_present":%s,"ready_delay":%s}\n' \
    "$(json_escape "$ID")" "$(json_escape "$NAME")" "$(json_escape "$CWD")" "$CMD_PRESENT" "$READY_DELAY"
else
  echo "$ID"
fi

#!/bin/zsh
# gt-paste <id> [text]
# With text: puts it on the clipboard, sends a real paste event to the terminal,
# restores the user's clipboard. Without text: pastes the current clipboard.
set -euo pipefail

TID="${1:-}"
[[ -n "$TID" ]] || { echo "usage: gt-paste <id> [text]" >&2; exit 2; }
TEXT="${2-__GT_NO_TEXT__}"

if [[ "$TEXT" != "__GT_NO_TEXT__" ]]; then
  OLD_CLIP=$(pbpaste 2>/dev/null || true)
  printf '%s' "$TEXT" | pbcopy
fi

osascript - "$TID" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        perform action "paste_from_clipboard" on (terminal id (item 1 of argv))
    end tell
end run
EOF

if [[ "$TEXT" != "__GT_NO_TEXT__" ]]; then
  sleep 0.8   # paste is async; restoring the clipboard too early pastes the OLD contents
  printf '%s' "$OLD_CLIP" | pbcopy
fi

#!/bin/zsh
# gt-probe [--json]
# Preflight for this skill. Checks whether the current host can drive Ghostty
# through the script API before an agent opens tabs or sends input.
set -euo pipefail

JSON=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --json) JSON=1; shift ;;
    -h|--help) sed -n '2,5p' "$0"; exit 0 ;;
    *) echo "gt-probe: unknown arg '$1'" >&2; exit 2 ;;
  esac
done

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

bool() {
  [[ "$1" == "1" ]] && printf true || printf false
}

KERNEL="$(uname -s 2>/dev/null || echo unknown)"
DARWIN=0; [[ "$KERNEL" == "Darwin" ]] && DARWIN=1

OSASCRIPT=0; command -v osascript >/dev/null 2>&1 && OSASCRIPT=1
PBCOPY=0; command -v pbcopy >/dev/null 2>&1 && PBCOPY=1
PBPASTE=0; command -v pbpaste >/dev/null 2>&1 && PBPASTE=1
SCREENCAPTURE=0; command -v screencapture >/dev/null 2>&1 && SCREENCAPTURE=1

GHOSTTY=0
GHOSTTY_DETAIL="not checked"
if [[ "$DARWIN" == "1" && "$OSASCRIPT" == "1" ]]; then
  if OUT=$(osascript -e 'tell application "Ghostty" to new surface configuration' 2>&1 >/dev/null); then
    GHOSTTY=1
    GHOSTTY_DETAIL="Ghostty scripting available"
  else
    GHOSTTY_DETAIL="$OUT"
  fi
else
  GHOSTTY_DETAIL="requires macOS and osascript"
fi

OK=0
if [[ "$DARWIN" == "1" && "$OSASCRIPT" == "1" && "$GHOSTTY" == "1" && "$PBCOPY" == "1" && "$PBPASTE" == "1" ]]; then
  OK=1
fi

if [[ "$JSON" == "1" ]]; then
  printf '{'
  printf '"ok":%s,' "$(bool "$OK")"
  printf '"backend":"applescript",'
  printf '"checks":{'
  printf '"darwin":{"ok":%s,"detail":"%s"},' "$(bool "$DARWIN")" "$(json_escape "$KERNEL")"
  printf '"osascript":{"ok":%s},' "$(bool "$OSASCRIPT")"
  printf '"ghostty_scripting":{"ok":%s,"detail":"%s"},' "$(bool "$GHOSTTY")" "$(json_escape "$GHOSTTY_DETAIL")"
  printf '"pbcopy":{"ok":%s},' "$(bool "$PBCOPY")"
  printf '"pbpaste":{"ok":%s},' "$(bool "$PBPASTE")"
  printf '"screencapture":{"ok":%s,"required":false,"detail":"Screen Recording is verified by gt-shot when used"}' "$(bool "$SCREENCAPTURE")"
  printf '}}\n'
else
  echo "ghostty-control probe"
  [[ "$DARWIN" == "1" ]] && echo "ok   macOS: $KERNEL" || echo "fail macOS: $KERNEL"
  [[ "$OSASCRIPT" == "1" ]] && echo "ok   osascript" || echo "fail osascript: not found"
  [[ "$GHOSTTY" == "1" ]] && echo "ok   Ghostty scripting" || echo "fail Ghostty scripting: $GHOSTTY_DETAIL"
  [[ "$PBCOPY" == "1" ]] && echo "ok   pbcopy" || echo "fail pbcopy: not found"
  [[ "$PBPASTE" == "1" ]] && echo "ok   pbpaste" || echo "fail pbpaste: not found"
  [[ "$SCREENCAPTURE" == "1" ]] && echo "warn screenshots: screencapture present; Screen Recording checked by gt-shot" || echo "warn screenshots: screencapture not found"
  [[ "$OK" == "1" ]] && echo "ready: yes" || echo "ready: no"
fi

[[ "$OK" == "1" ]]

#!/bin/zsh
# gt-run <id> "command" [--timeout SECONDS] [--json]
# Runs a shell command in the terminal, blocks until it finishes, prints the screen.
# ONLY for commands that exit. Interactive programs (TUIs, pagers, REPLs) never
# fire the completion sentinel and stall here until --timeout: launch those with
# gt-open --cmd instead, then drive them with gt-send / gt-wait --screen.
# Completion is detected by a sentinel: the typed line builds the marker from two
# halves ('GT_EN''D_...') so the echoed command line can never match the pattern --
# only the printf output after the command exits does.
set -euo pipefail

HERE="${0:A:h}"
TID="" CMD="" TIMEOUT=60 JSON=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --timeout) TIMEOUT="$2"; shift 2 ;;
    --json) JSON=1; shift ;;
    -h|--help) sed -n '2,9p' "$0"; exit 0 ;;
    *) if [[ -z "$TID" ]]; then TID="$1"; else CMD="$1"; fi; shift ;;
  esac
done
[[ -n "$TID" && -n "$CMD" ]] || { echo "usage: gt-run <id> \"command\" [--timeout N] [--json]" >&2; exit 2; }

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

emit_json() {
  local ok="$1" timed_out="$2" sentinel_found="$3" exit_code="$4" screen="$5" error="${6:-}"
  printf '{"backend":"applescript","id":"%s","ok":%s,"timed_out":%s,"sentinel_found":%s,"exit_code":%s,"screen":"%s","error":"%s"}\n' \
    "$(json_escape "$TID")" "$ok" "$timed_out" "$sentinel_found" "$exit_code" "$(json_escape "$screen")" "$(json_escape "$error")"
}

NONCE="$$_$RANDOM"
# typed text contains GT_EN''D_<nonce>; rendered output contains GT_END_<nonce>.
# The sentinel goes on its OWN pasted line, not ';'-joined: a command ending in
# a comment (cmd # note) would swallow a same-line sentinel and hang to timeout.
if ! "$HERE/gt-send" "$TID" --text "$CMD"$'\n'"printf '\\nGT_EN''D_${NONCE}:%s\\n' \$?"$'\n'; then
  [[ "$JSON" == "1" ]] && emit_json false false false null "" "send_failed"
  echo "gt-run: failed to send command" >&2
  exit 1
fi

if ! "$HERE/gt-wait" "$TID" --for "GT_END_${NONCE}:" --timeout "$TIMEOUT"; then
  SCREEN=$("$HERE/gt-screen" "$TID" 2>/dev/null || true)
  FILTERED=$(printf '%s\n' "$SCREEN" | grep -v "GT_EN" || true)
  [[ "$JSON" == "1" ]] && emit_json false true false null "$FILTERED" "timeout"
  echo "gt-run: command still running after ${TIMEOUT}s" >&2
  [[ "$JSON" == "1" ]] || printf '%s\n' "$SCREEN"
  exit 1
fi

SCREEN=$("$HERE/gt-screen" "$TID")
RC=$(printf '%s' "$SCREEN" | grep -oE "GT_END_${NONCE}:[0-9]+" | tail -1 | cut -d: -f2 || true)
FILTERED=$(printf '%s\n' "$SCREEN" | grep -v "GT_EN" || true)
if [[ "$JSON" == "1" ]]; then
  OK=false; [[ "${RC:-1}" == "0" ]] && OK=true
  if [[ -n "${RC:-}" ]]; then
    emit_json "$OK" false true "$RC" "$FILTERED"
  else
    emit_json false false false null "$FILTERED" "sentinel_parse_failed"
  fi
else
  printf '%s\n' "$FILTERED"
fi
exit "${RC:-1}"

#!/bin/zsh
# gt-screen <id> [--scrollback] [--json]
# Prints the terminal's rendered screen (or full scrollback) as text on stdout.
# Saves and restores the user's clipboard.
set -euo pipefail

TID="" ACTION="write_screen_file:copy" MODE="screen" JSON=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --scrollback) ACTION="write_scrollback_file:copy"; MODE="scrollback"; shift ;;
    --json) JSON=1; shift ;;
    -h|--help) sed -n '2,4p' "$0"; exit 0 ;;
    *) TID="$1"; shift ;;
  esac
done
[[ -n "$TID" ]] || { echo "usage: gt-screen <id> [--scrollback] [--json]" >&2; exit 2; }

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

OLD_CLIP=$(pbpaste 2>/dev/null || true)
restore_clipboard() {
  printf '%s' "$OLD_CLIP" | pbcopy >/dev/null 2>&1 || true
}
trap restore_clipboard EXIT

pbcopy < /dev/null    # clear, so we can poll for arrival

if ! osascript - "$TID" "$ACTION" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        perform action (item 2 of argv) on (terminal id (item 1 of argv))
    end tell
end run
EOF
then
  [[ "$JSON" == "1" ]] && printf '{"backend":"applescript","id":"%s","mode":"%s","ok":false,"text":"","error":"capture_action_failed"}\n' "$(json_escape "$TID")" "$MODE"
  echo "gt-screen: capture action failed" >&2
  exit 1
fi

# poll clipboard until the temp-file path lands (write_*_file:copy puts a PATH there)
PATH_ON_CLIP=""
for i in {1..40}; do
  PATH_ON_CLIP=$(pbpaste 2>/dev/null || true)
  [[ -n "$PATH_ON_CLIP" ]] && break
  sleep 0.05
done

STATUS=0
if [[ -f "$PATH_ON_CLIP" ]]; then
  if [[ "$JSON" == "1" ]]; then
    TEXT=$(cat "$PATH_ON_CLIP")
    printf '{"backend":"applescript","id":"%s","mode":"%s","ok":true,"text":"%s"}\n' \
      "$(json_escape "$TID")" "$MODE" "$(json_escape "$TEXT")"
  else
    cat "$PATH_ON_CLIP"
  fi
else
  [[ "$JSON" == "1" ]] && printf '{"backend":"applescript","id":"%s","mode":"%s","ok":false,"text":"","error":"capture_failed","clipboard":"%s"}\n' "$(json_escape "$TID")" "$MODE" "$(json_escape "$PATH_ON_CLIP")"
  echo "gt-screen: capture failed (clipboard: '$PATH_ON_CLIP')" >&2
  STATUS=1
fi
exit $STATUS

#!/bin/zsh
# gt-send <id> [--key SPEC]... [--text STR]... [--enter]
# Sends input to a terminal, in argument order.
#   --key SPEC   one keystroke: "enter", "arrowDown", "c,control", "tab,control,shift"
#                Key names are camelCase Ghostty Input.Key values: a-z, digit0-9,
#                enter, escape, backspace, delete, tab, space, home, end, insert,
#                pageUp, pageDown, arrowUp/Down/Left/Right, f1-f24, comma, period,
#                slash, backslash, semicolon, quote, backquote, minus, equal,
#                bracketLeft, bracketRight, numpad0-9, numpadEnter...
#                No uppercase letters -- shifted printable chars go via --text "G".
#   --text STR   string input (paste-style / bracketed). Interior newlines do NOT
#                execute -- they stack lines in the buffer. A TRAILING newline is
#                sent as a real Enter key, so --text $'cmd\n' runs cmd, and
#                --text $'l1\nl2\n' pastes both lines then runs the block.
#                (Bracketed paste swallows a pasted trailing newline -- only a real
#                key event submits -- so this is what makes "type and run" work.)
#   --stdin      like --text but reads the block from stdin (for files/big blocks).
#                A file's trailing newline submits, so no --enter needed:
#                cat snippet.py | gt-send <id> --stdin
#   --raw STR    raw input via `perform action "text:..."` (Zig string syntax:
#                \r enter, \x1b escape). NO paste wrapping, NO key synthesis.
#                USE THIS for kitty-keyboard-protocol apps (neovim!) where
#                --key silently never arrives: gt-send <id> --raw ':wq\r'
#   --enter      shorthand for --key enter
set -euo pipefail

TID="${1:-}"; shift || true
[[ -n "$TID" ]] || { echo "usage: gt-send <id> [--key SPEC|--text STR|--enter]..." >&2; exit 2; }

# A surface can accept screen capture before it accepts input; right after
# gt-open Ghostty may transiently raise "Terminal surface model is not
# available" (-10000). Nothing is delivered when that fires, so retrying is
# safe. Any other error fails immediately.
osa_retry() {
  local out rc attempt
  for attempt in 1 2 3; do
    out=$("$@" 2>&1) && return 0
    rc=$?
    if [[ "$out" != *"not available"* && "$out" != *"-10000"* ]]; then
      print -r -- "$out" >&2; return $rc
    fi
    sleep 0.4
  done
  print -r -- "$out" >&2; return $rc
}

send_key() { osa_retry send_key_once "$@"; }
send_key_once() {  # $1 = spec like "c,control,shift"
  local key="${1%%,*}" mods=""
  [[ "$1" == *,* ]] && mods="${1#*,}"
  osascript - "$TID" "$key" "$mods" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        set t to terminal id (item 1 of argv)
        if item 3 of argv is "" then
            send key (item 2 of argv) to t
        else
            send key (item 2 of argv) modifiers (item 3 of argv) to t
        end if
    end tell
end run
EOF
}

send_text() { osa_retry send_text_once "$@"; }
send_text_once() {  # $1 = text (raw bracketed paste, no key synthesis)
  osascript - "$TID" "$1" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        input text (item 2 of argv) to (terminal id (item 1 of argv))
    end tell
end run
EOF
}

send_text_submit() {  # $1 = text; paste it, but a trailing newline becomes a real Enter
  local t="$1"
  if [[ "$t" == *$'\n' ]]; then
    t="${t%$'\n'}"               # drop exactly one trailing newline
    [[ -n "$t" ]] && send_text "$t"
    send_key "enter"             # real key event -- bracketed paste would not submit
  else
    send_text "$t"
  fi
}

send_raw() { osa_retry send_raw_once "$@"; }
send_raw_once() {  # $1 = Zig-syntax string for the text: action
  osascript - "$TID" "text:$1" <<'EOF' >/dev/null
on run argv
    tell application "Ghostty"
        perform action (item 2 of argv) on (terminal id (item 1 of argv))
    end tell
end run
EOF
}

[[ $# -gt 0 ]] || { echo "gt-send: nothing to send" >&2; exit 2; }
while [[ $# -gt 0 ]]; do
  case "$1" in
    --key)   send_key "$2"; shift 2 ;;
    --text)  send_text_submit "$2"; shift 2 ;;
    --stdin) IFS= read -rd '' _stdin || true; send_text_submit "$_stdin"; shift ;;
    --raw)   send_raw "$2"; shift 2 ;;
    --enter) send_key "enter"; shift ;;
    -h|--help) sed -n '2,7p' "$0"; exit 0 ;;
    *) echo "gt-send: unknown arg '$1'" >&2; exit 2 ;;
  esac
done

#!/bin/zsh
# gt-shot [id] [out.png]
# Captures a Ghostty terminal window as a PNG, prints the file path.
# Without id: the frontmost Ghostty window, whatever tab the user has selected.
# With id: briefly selects that terminal's tab, shoots, restores the user's tab.
# Needs Accessibility + Screen Recording permissions; window must be on screen.
set -euo pipefail

TID="" OUT=""
for a in "$@"; do
  if [[ "$a" == *.png ]]; then OUT="$a"; else TID="$a"; fi
done
[[ -n "$OUT" ]] || OUT="$(mktemp -t gt-shot).png"

if [[ -n "$TID" ]]; then
  # select target tab, remembering the user's current selection
  PREV=$(osascript - "$TID" <<'EOF'
on run argv
    tell application "Ghostty"
        set target to terminal id (item 1 of argv)
        repeat with w in windows
            repeat with tb in tabs of w
                repeat with t in terminals of tb
                    if id of t is (item 1 of argv) then
                        set prevTab to id of selected tab of w
                        select tab tb
                        delay 0.3
                        return prevTab
                    end if
                end repeat
            end repeat
        end repeat
        return ""
    end tell
end run
EOF
)
fi

BOUNDS=$(osascript <<'EOF'
tell application "System Events" to tell process "Ghostty"
    set w to first window whose subrole is "AXStandardWindow"
    set {x, y} to position of w
    set {wd, ht} to size of w
    return (x as text) & "," & (y as text) & "," & (wd as text) & "," & (ht as text)
end tell
EOF
)
STATUS=0
if [[ "$BOUNDS" =~ ^-?[0-9]+,-?[0-9]+,[0-9]+,[0-9]+$ ]]; then
  screencapture -x -R"$BOUNDS" "$OUT"
  [[ -s "$OUT" ]] && echo "$OUT" || { echo "gt-shot: screencapture produced nothing — Screen Recording permission?" >&2; STATUS=1; }
else
  echo "gt-shot: could not get window bounds ('$BOUNDS') — Accessibility permission?" >&2
  STATUS=1
fi

# restore the user's tab selection
if [[ -n "${PREV:-}" ]]; then
  osascript - "$PREV" <<'EOF' >/dev/null 2>&1
on run argv
    tell application "Ghostty"
        repeat with w in windows
            repeat with tb in tabs of w
                if id of tb is (item 1 of argv) then
                    select tab tb
                    return
                end if
            end repeat
        end repeat
    end tell
end run
EOF
fi
exit $STATUS

#!/bin/zsh
# gt-split <id> right|left|up|down [--cwd DIR] [--cmd CMD] [--title TITLE] [--json]
# Splits a terminal and prints the new terminal id.
set -euo pipefail

TID="" DIR="" CWD="" CMD="" TITLE="" JSON=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --cwd) CWD="$2"; shift 2 ;;
    --cmd) CMD="$2"; shift 2 ;;
    --title|--name) TITLE="$2"; shift 2 ;;
    --json) JSON=1; shift ;;
    -h|--help) sed -n '2,4p' "$0"; exit 0 ;;
    *)
      if [[ -z "$TID" ]]; then
        TID="$1"
      elif [[ -z "$DIR" ]]; then
        DIR="$1"
      else
        echo "gt-split: unknown arg '$1'" >&2; exit 2
      fi
      shift
      ;;
  esac
done

[[ -n "$TID" && -n "$DIR" ]] || { echo "usage: gt-split <id> right|left|up|down [--cwd DIR] [--cmd CMD] [--title TITLE] [--json]" >&2; exit 2; }
case "$DIR" in
  right|left|up|down) ;;
  *) echo "gt-split: direction must be right, left, up, or down" >&2; exit 2 ;;
esac

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

NEW_ID=$(osascript - "$TID" "$DIR" "$CWD" "$CMD" "$TITLE" <<'EOF'
on run argv
    set tid to item 1 of argv
    set dirName to item 2 of argv
    set cwd to item 3 of argv
    set cmd to item 4 of argv
    set titleName to item 5 of argv
    tell application "Ghostty"
        set t to terminal id tid
        focus t
        set conf to new surface configuration
        if cwd is not "" then set initial working directory of conf to cwd
        if cmd is not "" then set initial input of conf to (cmd & linefeed)

        if dirName is "right" then
            split t direction right with configuration conf
        else if dirName is "left" then
            split t direction left with configuration conf
        else if dirName is "up" then
            split t direction up with configuration conf
        else
            split t direction down with configuration conf
        end if

        delay 0.5
        set newTerm to focused terminal of selected tab of front window
        if titleName is not "" then perform action ("set_surface_title:" & titleName) on newTerm
        return id of newTerm
    end tell
end run
EOF
) || { echo "gt-split: failed to split $TID" >&2; exit 1; }

if [[ "$JSON" == "1" ]]; then
  CMD_PRESENT=false; [[ -n "$CMD" ]] && CMD_PRESENT=true
  printf '{"backend":"applescript","id":"%s","parent_id":"%s","direction":"%s","cwd":"%s","title":"%s","command_present":%s}\n' \
    "$(json_escape "$NEW_ID")" "$(json_escape "$TID")" "$(json_escape "$DIR")" "$(json_escape "$CWD")" "$(json_escape "$TITLE")" "$CMD_PRESENT"
else
  echo "$NEW_ID"
fi

#!/bin/zsh
# gt-status <id> [--json]
# Validates a terminal id and prints its current Ghostty object-model status.
set -euo pipefail

TID="" JSON=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --json) JSON=1; shift ;;
    -h|--help) sed -n '2,4p' "$0"; exit 0 ;;
    *) if [[ -z "$TID" ]]; then TID="$1"; else echo "gt-status: unknown arg '$1'" >&2; exit 2; fi; shift ;;
  esac
done
[[ -n "$TID" ]] || { echo "usage: gt-status <id> [--json]" >&2; exit 2; }

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

bool() {
  [[ "$1" == "true" ]] && printf true || printf false
}

ROW=$(osascript - "$TID" <<'EOF'
on clean(s)
    set s to s as text
    set oldDelims to AppleScript's text item delimiters
    set AppleScript's text item delimiters to {tab, linefeed, return}
    set parts to text items of s
    set AppleScript's text item delimiters to " "
    set cleaned to parts as text
    set AppleScript's text item delimiters to oldDelims
    return cleaned
end clean

on run argv
    set wanted to item 1 of argv
    tell application "Ghostty"
        set d to character id 9
        repeat with w in windows
            set wid to id of w as text
            try
                set wname to my clean(name of w)
            on error
                set wname to ""
            end try
            try
                set selectedTabId to id of selected tab of w as text
            on error
                set selectedTabId to ""
            end try
            repeat with tb in tabs of w
                set tbid to id of tb as text
                try
                    set tbname to my clean(name of tb)
                on error
                    set tbname to ""
                end try
                set isSelected to "false"
                if tbid is selectedTabId then set isSelected to "true"
                try
                    set focusedId to id of focused terminal of tb as text
                on error
                    set focusedId to ""
                end try
                repeat with t in terminals of tb
                    set tid to id of t as text
                    if tid is wanted then
                        try
                            set tname to my clean(name of t)
                        on error
                            set tname to ""
                        end try
                        try
                            set cwd to my clean(working directory of t)
                        on error
                            set cwd to ""
                        end try
                        set isFocused to "false"
                        if tid is focusedId then set isFocused to "true"
                        return tid & d & wid & d & tbid & d & isSelected & d & isFocused & d & wname & d & tbname & d & tname & d & cwd
                    end if
                end repeat
            end repeat
        end repeat
    end tell
    return ""
end run
EOF
) || { echo "gt-status: Ghostty scripting failed" >&2; exit 1; }

if [[ -z "$ROW" ]]; then
  if [[ "$JSON" == "1" ]]; then
    printf '{"backend":"applescript","exists":false,"id":"%s"}\n' "$(json_escape "$TID")"
  else
    echo "gt-status: no terminal with id $TID" >&2
  fi
  exit 1
fi

IFS=$'\t' read -r RID WID TBID SELECTED FOCUSED WNAME TBNAME TNAME CWD <<< "$ROW"

if [[ "$JSON" == "1" ]]; then
  printf '{"backend":"applescript","exists":true,"id":"%s","window_id":"%s","tab_id":"%s","selected":%s,"focused":%s,"window_name":"%s","tab_name":"%s","terminal_name":"%s","cwd":"%s"}\n' \
    "$(json_escape "$RID")" "$(json_escape "$WID")" "$(json_escape "$TBID")" "$(bool "$SELECTED")" "$(bool "$FOCUSED")" \
    "$(json_escape "$WNAME")" "$(json_escape "$TBNAME")" "$(json_escape "$TNAME")" "$(json_escape "$CWD")"
else
  echo "id=$RID"
  echo "window_id=$WID"
  echo "tab_id=$TBID"
  echo "selected=$SELECTED"
  echo "focused=$FOCUSED"
  echo "window_name=$WNAME"
  echo "tab_name=$TBNAME"
  echo "terminal_name=$TNAME"
  echo "cwd=$CWD"
fi

#!/bin/zsh
# gt-wait <id> [--for PATTERN] [--timeout SECONDS] [--interval SECONDS] [--screen] [--json]
# Pattern mode (--for): block until PATTERN (grep -E) appears on the screen. Exit 1 on timeout.
# Settle mode (no --for): block until two consecutive frames are identical (repaint finished).
# --screen: print the final frame on success — saves a follow-up gt-screen call.
# On timeout the last captured frame is dumped to stderr for debugging.
# Note: spinners/progress bars never settle — use --for on animated screens.
set -euo pipefail

HERE="${0:A:h}"
TID="" PATTERN="" TIMEOUT=15 INTERVAL=0.15 JSON=0 SCREEN_OUT=0
while [[ $# -gt 0 ]]; do
  case "$1" in
    --for)      PATTERN="$2"; shift 2 ;;
    --timeout)  TIMEOUT="$2"; shift 2 ;;
    --interval) INTERVAL="$2"; shift 2 ;;
    --screen)   SCREEN_OUT=1; shift ;;
    --json)     JSON=1; shift ;;
    -h|--help)  sed -n '2,7p' "$0"; exit 0 ;;
    *) TID="$1"; shift ;;
  esac
done
[[ -n "$TID" ]] || { echo "usage: gt-wait <id> [--for PATTERN] [--timeout N] [--json]" >&2; exit 2; }

json_escape() {
  local s="${1-}"
  s="${s//\\/\\\\}"
  s="${s//\"/\\\"}"
  s="${s//$'\n'/\\n}"
  s="${s//$'\r'/\\r}"
  s="${s//$'\t'/\\t}"
  printf '%s' "$s"
}

emit_json() {
  local ok="$1" matched="$2" settled="$3" timed_out="$4" elapsed="$5"
  local mode="settle"
  [[ -n "$PATTERN" ]] && mode="pattern"
  printf '{"backend":"applescript","id":"%s","ok":%s,"mode":"%s","pattern":"%s","matched":%s,"settled":%s,"timed_out":%s,"timeout":%s,"elapsed_seconds":%s}\n' \
    "$(json_escape "$TID")" "$ok" "$mode" "$(json_escape "$PATTERN")" "$matched" "$settled" "$timed_out" "$TIMEOUT" "$elapsed"
}

START=$(date +%s)
DEADLINE=$(( $(date +%s) + TIMEOUT ))
PREV="" FRAME=""
while (( $(date +%s) < DEADLINE )); do
  FRAME=$("$HERE/gt-screen" "$TID" 2>/dev/null || true)
  if [[ -n "$PATTERN" ]]; then
    if printf '%s' "$FRAME" | grep -qE "$PATTERN"; then
      [[ "$JSON" == "1" ]] && emit_json true true false false "$(( $(date +%s) - START ))"
      [[ "$SCREEN_OUT" == "1" && "$JSON" != "1" ]] && printf '%s\n' "$FRAME"
      exit 0
    fi
  else
    if [[ -n "$FRAME" && "$FRAME" == "$PREV" ]]; then
      [[ "$JSON" == "1" ]] && emit_json true false true false "$(( $(date +%s) - START ))"
      [[ "$SCREEN_OUT" == "1" && "$JSON" != "1" ]] && printf '%s\n' "$FRAME"
      exit 0
    fi
    PREV="$FRAME"
  fi
  sleep "$INTERVAL"
done
[[ "$JSON" == "1" ]] && emit_json false false false true "$(( $(date +%s) - START ))"
echo "gt-wait: timeout after ${TIMEOUT}s${PATTERN:+ waiting for /$PATTERN/}" >&2
if [[ -n "$PREV$FRAME" ]]; then
  { echo "gt-wait: last frame:"; printf '%s\n' "${FRAME:-$PREV}"; } >&2
fi
exit 1