@wangyaoshen/remux 0.3.8-dev.29e114b

package/apps/macos/Resources/shell-integration/elvish/lib/ghostty-integration.elv

@@ -0,0 +1,191 @@
+{
+  use platform
+  use str
+
+  # Clean up XDG_DATA_DIRS by removing GHOSTTY_SHELL_INTEGRATION_XDG_DIR
+  if (and (has-env GHOSTTY_SHELL_INTEGRATION_XDG_DIR) (has-env XDG_DATA_DIRS)) {
+    set-env XDG_DATA_DIRS (str:replace $E:GHOSTTY_SHELL_INTEGRATION_XDG_DIR":" "" $E:XDG_DATA_DIRS)
+    unset-env GHOSTTY_SHELL_INTEGRATION_XDG_DIR
+  }
+
+  # List of enabled shell integration features
+  var features = [(str:split ',' $E:GHOSTTY_SHELL_FEATURES)]
+
+  # State tracking for semantic prompt sequences
+  # Values: 'prompt-start', 'pre-exec', 'post-exec'
+  fn set-prompt-state {|new| set-env __ghostty_prompt_state $new }
+
+  fn mark-prompt-start {
+    if (not-eq $E:__ghostty_prompt_state 'prompt-start') {
+      printf "\e]133;D;aid="$pid"\a"
+    }
+    set-prompt-state 'prompt-start'
+    printf "\e]133;A;aid="$pid"\a"
+  }
+
+  fn mark-output-start {|_|
+    set-prompt-state 'pre-exec'
+    printf "\e]133;C\a"
+  }
+
+  fn mark-output-end {|cmd-info|
+    set-prompt-state 'post-exec'
+
+    var exit-status = 0
+
+    # in case of error: retrieve exit status,
+    # unless does not exist (= builtin function failure), then default to 1
+    if (not-eq $nil $cmd-info[error]) {
+      set exit-status = 1
+
+      if (has-key $cmd-info[error] reason) {
+        if (has-key $cmd-info[error][reason] exit-status) {
+          set exit-status = $cmd-info[error][reason][exit-status]
+        }
+      }
+    }
+
+    printf "\e]133;D;"$exit-status";aid="$pid"\a"
+  }
+
+  # NOTE: OSC 133;B (end of prompt, start of input) cannot be reliably
+  # implemented at the script level in Elvish. The prompt function's output is
+  # escaped, and writing to /dev/tty has timing issues because Elvish renders
+  # its prompts on a background thread. Full semantic prompt support requires a
+  # native implementation: https://github.com/elves/elvish/pull/1917
+
+  fn sudo-with-terminfo {|@args|
+    var sudoedit = $false
+    for arg $args {
+      if (str:has-prefix $arg --) {
+        if (eq $arg --edit) {
+          set sudoedit = $true
+          break
+        }
+      } elif (str:has-prefix $arg -) {
+        if (str:contains (str:trim-prefix $arg -) e) {
+          set sudoedit = $true
+          break
+        }
+      } elif (not (str:contains $arg =)) {
+        break
+      }
+    }
+
+    if (not $sudoedit) { set args = [ --preserve-env=TERMINFO $@args ] }
+    (external sudo) $@args
+  }
+
+  fn ssh-integration {|@args|
+    var ssh-term = "xterm-256color"
+    var ssh-opts = []
+
+    # Configure environment variables for remote session
+    if (has-value $features ssh-env) {
+      set ssh-opts = (conj $ssh-opts ^
+        -o "SetEnv COLORTERM=truecolor" ^
+        -o "SendEnv TERM_PROGRAM TERM_PROGRAM_VERSION")
+    }
+
+    if (has-value $features ssh-terminfo) {
+      var ssh-user = ""
+      var ssh-hostname = ""
+
+      # Parse ssh config
+      for line [((external ssh) -G $@args)] {
+        var parts = [(str:fields $line)]
+        if (> (count $parts) 1) {
+          var ssh-key = $parts[0]
+          var ssh-value = $parts[1]
+          if (eq $ssh-key user) {
+            set ssh-user = $ssh-value
+          } elif (eq $ssh-key hostname) {
+            set ssh-hostname = $ssh-value
+          }
+          if (and (not-eq $ssh-user "") (not-eq $ssh-hostname "")) {
+            break
+          }
+        }
+      }
+
+      if (not-eq $ssh-hostname "") {
+        var ghostty = $E:GHOSTTY_BIN_DIR/"ghostty"
+        var ssh-target = $ssh-user"@"$ssh-hostname
+
+        # Check if terminfo is already cached
+        if (bool ?($ghostty +ssh-cache --host=$ssh-target)) {
+          set ssh-term = "xterm-ghostty"
+        } elif (has-external infocmp) {
+          var ssh-terminfo = ((external infocmp) -0 -x xterm-ghostty 2>/dev/null | slurp)
+
+          if (not-eq $ssh-terminfo "") {
+            echo "Setting up xterm-ghostty terminfo on "$ssh-hostname"..." >&2
+
+            use os
+            var ssh-cpath-dir = (os:temp-dir "ghostty-ssh-"$ssh-user".*")
+            var ssh-cpath = $ssh-cpath-dir"/socket"
+
+            if (bool ?(echo $ssh-terminfo | (external ssh) $@ssh-opts -o ControlMaster=yes -o ControlPath=$ssh-cpath -o ControlPersist=60s $@args '
+                  infocmp xterm-ghostty >/dev/null 2>&1 && exit 0
+                  command -v tic >/dev/null 2>&1 || exit 1
+                  mkdir -p ~/.terminfo 2>/dev/null && tic -x - 2>/dev/null && exit 0
+                  exit 1
+                ' 2>/dev/null)) {
+              set ssh-term = "xterm-ghostty"
+              set ssh-opts = (conj $ssh-opts -o ControlPath=$ssh-cpath)
+
+              # Cache successful installation
+              $ghostty +ssh-cache --add=$ssh-target >/dev/null
+            } else {
+              echo "Warning: Failed to install terminfo." >&2
+            }
+          } else {
+            echo "Warning: Could not generate terminfo data." >&2
+          }
+        } else {
+          echo "Warning: ghostty command not available for cache management." >&2
+        }
+      }
+    }
+
+    with [E:TERM = $ssh-term] {
+      (external ssh) $@ssh-opts $@args
+    }
+  }
+
+  defer {
+    mark-prompt-start
+  }
+
+  set edit:before-readline = (conj $edit:before-readline $mark-prompt-start~)
+  set edit:after-readline  = (conj $edit:after-readline $mark-output-start~)
+  set edit:after-command   = (conj $edit:after-command $mark-output-end~)
+
+  if (str:contains $E:GHOSTTY_SHELL_FEATURES "cursor") {
+    var cursor = "5"    # blinking bar
+    if (has-value $features cursor:steady) {
+      set cursor = "6"  # steady bar
+    }
+
+    fn beam  { printf "\e["$cursor" q" }
+    fn reset { printf "\e[0 q" }
+    set edit:before-readline = (conj $edit:before-readline $beam~)
+    set edit:after-readline  = (conj $edit:after-readline {|_| reset })
+  }
+  if (and (has-value $features path) (has-env GHOSTTY_BIN_DIR)) {
+    if (not (has-value $paths $E:GHOSTTY_BIN_DIR)) {
+        set paths = [$@paths $E:GHOSTTY_BIN_DIR]
+    }
+  }
+  if (and (has-value $features sudo) (not-eq "" $E:TERMINFO) (has-external sudo)) {
+    edit:add-var sudo~ $sudo-with-terminfo~
+  }
+  if (and (str:contains $E:GHOSTTY_SHELL_FEATURES ssh-) (has-external ssh)) {
+    edit:add-var ssh~ $ssh-integration~
+  }
+
+  # Report changes to the current directory.
+  fn report-pwd { printf "\e]7;kitty-shell-cwd://%s%s\a" (platform:hostname) $pwd }
+  set after-chdir = (conj $after-chdir {|_| report-pwd })
+  report-pwd
+}

package/apps/macos/Resources/shell-integration/fish/vendor_conf.d/ghostty-shell-integration.fish

@@ -0,0 +1,246 @@
+# This shell script aims to be written in a way where it can't really fail
+# or all failure scenarios are handled, so that we never leave the shell in
+# a weird state. If you find a way to break this, please report a bug!
+
+function ghostty_restore_xdg_data_dir -d "restore the original XDG_DATA_DIR value"
+    # If we don't have our own data dir then we don't need to do anything.
+    if not set -q GHOSTTY_SHELL_INTEGRATION_XDG_DIR
+        return
+    end
+
+    # If the data dir isn't set at all then we don't need to do anything.
+    if not set -q XDG_DATA_DIRS
+        return
+    end
+
+    # We need to do this so that XDG_DATA_DIRS turns into an array.
+    set --function --path xdg_data_dirs "$XDG_DATA_DIRS"
+
+    # If our data dir is in the list then remove it.
+    if set --function index (contains --index "$GHOSTTY_SHELL_INTEGRATION_XDG_DIR" $xdg_data_dirs)
+        set --erase --function xdg_data_dirs[$index]
+    end
+
+    # Re-export our data dir
+    if set -q xdg_data_dirs[1]
+        set --global --export --unpath XDG_DATA_DIRS "$xdg_data_dirs"
+    else
+        set --erase --global XDG_DATA_DIRS
+    end
+
+    set --erase GHOSTTY_SHELL_INTEGRATION_XDG_DIR
+end
+
+function ghostty_exit -d "exit the shell integration setup"
+    functions -e ghostty_restore_xdg_data_dir
+    functions -e ghostty_exit
+    exit 0
+end
+
+# We always try to restore the XDG data dir
+ghostty_restore_xdg_data_dir
+
+# If we aren't interactive or we've already run, don't run.
+status --is-interactive || ghostty_exit
+
+# We do the full setup on the first prompt render. We do this so that other
+# shell integrations that setup the prompt and modify things are able to run
+# first. We want to run _last_.
+function __ghostty_setup --on-event fish_prompt -d "Setup ghostty integration"
+    functions -e __ghostty_setup
+
+    set --local features (string split , $GHOSTTY_SHELL_FEATURES)
+
+    # Parse the fish version for feature detection.
+    # Default to 0.0 if version is unavailable or malformed.
+    set -l fish_major 0
+    set -l fish_minor 0
+    if set -q version[1]
+        set -l fish_ver (string match -r '(\d+)\.(\d+)' -- $version[1])
+        if set -q fish_ver[2]; and test -n "$fish_ver[2]"
+            set fish_major "$fish_ver[2]"
+        end
+        if set -q fish_ver[3]; and test -n "$fish_ver[3]"
+            set fish_minor "$fish_ver[3]"
+        end
+    end
+
+    # Our OSC133A (prompt start) sequence. If we're using Fish >= 4.1
+    # then it supports click_events so we enable that.
+    set -g __ghostty_prompt_start_mark "\e]133;A\a"
+    if test "$fish_major" -gt 4; or test "$fish_major" -eq 4 -a "$fish_minor" -ge 1
+        set -g __ghostty_prompt_start_mark "\e]133;A;click_events=1\a"
+    end
+
+    if string match -q 'cursor*' -- $features
+        set -l cursor 5                                   # blinking bar
+        contains cursor:steady $features && set cursor 6  # steady bar
+
+        # Change the cursor to a beam on prompt.
+        function __ghostty_set_cursor_beam --on-event fish_prompt -V cursor -d "Set cursor shape"
+            if not functions -q fish_vi_cursor_handle
+                echo -en "\e[$cursor q"
+            end
+        end
+        function __ghostty_reset_cursor --on-event fish_preexec -d "Reset cursor shape"
+            if not functions -q fish_vi_cursor_handle
+                echo -en "\e[0 q"
+            end
+        end
+    end
+
+    # Add Ghostty binary to PATH if the path feature is enabled
+    if contains path $features; and test -n "$GHOSTTY_BIN_DIR"
+        fish_add_path --global --path --append "$GHOSTTY_BIN_DIR"
+    end
+
+    # When using sudo shell integration feature, ensure $TERMINFO is set
+    # and `sudo` is not already a function or alias
+    if contains sudo $features; and test -n "$TERMINFO"; and test file = (type -t sudo 2> /dev/null; or echo "x")
+        # Wrap `sudo` command to ensure Ghostty terminfo is preserved
+        function sudo -d "Wrap sudo to preserve terminfo"
+            set --function sudo_has_sudoedit_flags no
+            for arg in $argv
+                # Check if argument is '-e' or '--edit' (sudoedit flags)
+                if string match -q -- -e "$arg"; or string match -q -- --edit "$arg"
+                    set --function sudo_has_sudoedit_flags yes
+                    break
+                end
+                # Check if argument is neither an option nor a key-value pair
+                if not string match -r -q -- "^-" "$arg"; and not string match -r -q -- "=" "$arg"
+                    break
+                end
+            end
+            if test "$sudo_has_sudoedit_flags" = yes
+                command sudo $argv
+            else
+                command sudo --preserve-env=TERMINFO $argv
+            end
+        end
+    end
+
+    # SSH Integration
+    set -l features (string split ',' -- "$GHOSTTY_SHELL_FEATURES")
+    if contains ssh-env $features; or contains ssh-terminfo $features
+        function ssh --wraps=ssh --description "SSH wrapper with Ghostty integration"
+            set -l features (string split ',' -- "$GHOSTTY_SHELL_FEATURES")
+            set -l ssh_term xterm-256color
+            set -l ssh_opts
+
+            # Configure environment variables for remote session
+            if contains ssh-env $features
+                set -a ssh_opts -o "SetEnv COLORTERM=truecolor"
+                set -a ssh_opts -o "SendEnv TERM_PROGRAM TERM_PROGRAM_VERSION"
+            end
+
+            # Install terminfo on remote host if needed
+            if contains ssh-terminfo $features
+                set -l ssh_user
+                set -l ssh_hostname
+
+                for line in (command ssh -G $argv 2>/dev/null)
+                    set -l parts (string split ' ' -- $line)
+                    if test (count $parts) -ge 2
+                        switch $parts[1]
+                            case user
+                                set ssh_user $parts[2]
+                            case hostname
+                                set ssh_hostname $parts[2]
+                        end
+                        if test -n "$ssh_user"; and test -n "$ssh_hostname"
+                            break
+                        end
+                    end
+                end
+
+                if test -n "$ssh_hostname"
+                    set -l ssh_target "$ssh_user@$ssh_hostname"
+
+                    # Check if terminfo is already cached
+                    if test -x "$GHOSTTY_BIN_DIR/ghostty"; and "$GHOSTTY_BIN_DIR/ghostty" +ssh-cache --host="$ssh_target" >/dev/null 2>&1
+                        set ssh_term xterm-ghostty
+                    else if command -q infocmp
+                        set -l ssh_terminfo
+                        set -l ssh_cpath_dir
+                        set -l ssh_cpath
+
+                        set ssh_terminfo "$(infocmp -0 -x xterm-ghostty 2>/dev/null)"
+
+                        if test -n "$ssh_terminfo"
+                            echo "Setting up xterm-ghostty terminfo on $ssh_hostname..." >&2
+
+                            set ssh_cpath_dir (mktemp -d "/tmp/ghostty-ssh-$ssh_user.XXXXXX" 2>/dev/null; or echo "/tmp/ghostty-ssh-$ssh_user."(random))
+                            set ssh_cpath "$ssh_cpath_dir/socket"
+
+                            if echo "$ssh_terminfo" | command ssh $ssh_opts -o ControlMaster=yes -o ControlPath="$ssh_cpath" -o ControlPersist=60s $argv '
+                                infocmp xterm-ghostty >/dev/null 2>&1 && exit 0
+                                command -v tic >/dev/null 2>&1 || exit 1
+                                mkdir -p ~/.terminfo 2>/dev/null && tic -x - 2>/dev/null && exit 0
+                                exit 1
+                            ' 2>/dev/null
+                                set ssh_term xterm-ghostty
+                                set -a ssh_opts -o "ControlPath=$ssh_cpath"
+
+                                # Cache successful installation
+                                if test -x "$GHOSTTY_BIN_DIR/ghostty"
+                                    "$GHOSTTY_BIN_DIR/ghostty" +ssh-cache --add="$ssh_target" >/dev/null 2>&1; or true
+                                end
+                            else
+                                echo "Warning: Failed to install terminfo." >&2
+                            end
+                        else
+                            echo "Warning: Could not generate terminfo data." >&2
+                        end
+                    else
+                        echo "Warning: ghostty command not available for cache management." >&2
+                    end
+                end
+            end
+
+            # Execute SSH with TERM environment variable
+            TERM="$ssh_term" command ssh $ssh_opts $argv
+        end
+    end
+
+    # Setup prompt marking
+    function __ghostty_mark_prompt_start --on-event fish_prompt --on-event fish_posterror
+        # If we never got the output end event, then we need to send it now.
+        if test "$__ghostty_prompt_state" != prompt-start
+            echo -en "\e]133;D\a"
+        end
+
+        set --global __ghostty_prompt_state prompt-start
+        echo -en $__ghostty_prompt_start_mark
+    end
+
+    function __ghostty_mark_output_start --on-event fish_preexec
+        set --global __ghostty_prompt_state pre-exec
+        echo -en "\e]133;C\a"
+    end
+
+    function __ghostty_mark_output_end --on-event fish_postexec
+        set --global __ghostty_prompt_state post-exec
+        echo -en "\e]133;D;$status\a"
+    end
+
+    # Report pwd. This is actually built-in to fish but only for terminals
+    # that match an allowlist and that isn't us.
+    function __update_cwd_osc --on-variable PWD -d 'Notify capable terminals when $PWD changes'
+        if status --is-command-substitution || set -q INSIDE_EMACS
+            return
+        end
+        printf \e\]7\;file://%s%s\a $hostname (string escape --style=url $PWD)
+    end
+
+    # Enable fish to handle reflow because Ghostty clears the prompt on resize.
+    set --global fish_handle_reflow 1
+
+    # Initial calls for first prompt
+    if string match -q 'cursor*' -- $features
+        __ghostty_set_cursor_beam
+    end
+    __ghostty_mark_prompt_start
+    __update_cwd_osc
+end
+
+ghostty_exit

package/apps/macos/Resources/shell-integration/nushell/vendor/autoload/ghostty.nu

@@ -0,0 +1,110 @@
+# Ghostty shell integration
+export module ghostty {
+  def has_feature [feature: string] {
+    $feature in ($env.GHOSTTY_SHELL_FEATURES | default "" | split row ',')
+  }
+
+  # Wrap `ssh` with Ghostty TERMINFO support
+  export def --wrapped ssh [...args] {
+    mut ssh_env = {}
+    mut ssh_opts = []
+
+    # `ssh-env`: use xterm-256color and propagate COLORTERM/TERM_PROGRAM vars
+    if (has_feature "ssh-env") {
+      $ssh_env.TERM = "xterm-256color"
+      $ssh_opts = [
+        "-o" "SetEnv COLORTERM=truecolor"
+        "-o" "SendEnv TERM_PROGRAM TERM_PROGRAM_VERSION"
+      ]
+    }
+
+    # `ssh-terminfo`: auto-install xterm-ghostty terminfo on remote hosts
+    if (has_feature "ssh-terminfo") {
+      let ghostty = ($env.GHOSTTY_BIN_DIR? | default "") | path join "ghostty"
+
+      let ssh_cfg = ^ssh -G ...$args
+        | lines
+        | parse "{key} {value}"
+        | where key in ["user" "hostname"]
+        | select key value
+        | transpose -rd
+        | default {user: $env.USER hostname: "localhost"}
+      let ssh_id = $"($ssh_cfg.user)@($ssh_cfg.hostname)"
+
+      if (^$ghostty "+ssh-cache" $"--host=($ssh_id)" | complete | $in.exit_code == 0) {
+        $ssh_env.TERM = "xterm-ghostty"
+      } else {
+        $ssh_env.TERM = "xterm-256color"
+
+        let terminfo = try {
+          ^infocmp -0 -x xterm-ghostty
+        } catch {
+          print -e "infocmp failed, using xterm-256color"
+        }
+
+        if ($terminfo | is-not-empty) {
+          print $"Setting up xterm-ghostty terminfo on ($ssh_cfg.hostname)..."
+
+          let ctrl_path = (
+            mktemp -td $"ghostty-ssh-($ssh_cfg.user).XXXXXX"
+            | path join "socket"
+          )
+
+          let remote_args = $ssh_opts ++ [
+            "-o" "ControlMaster=yes"
+            "-o" $"ControlPath=($ctrl_path)"
+            "-o" "ControlPersist=60s"
+          ] ++ $args
+
+          $terminfo | ^ssh ...$remote_args '
+            infocmp xterm-ghostty >/dev/null 2>&1 && exit 0
+            command -v tic >/dev/null 2>&1 || exit 1
+            mkdir -p ~/.terminfo 2>/dev/null && tic -x - 2>/dev/null && exit 0
+            exit 1'
+          | complete
+          | if $in.exit_code == 0 {
+            ^$ghostty "+ssh-cache" $"--add=($ssh_id)" e>| print -e
+            $ssh_env.TERM = "xterm-ghostty"
+            $ssh_opts = ($ssh_opts ++ ["-o" $"ControlPath=($ctrl_path)"])
+          } else {
+            print -e "terminfo install failed, using xterm-256color"
+          }
+        }
+      }
+    }
+
+    let ssh_args = $ssh_opts ++ $args
+    with-env $ssh_env {
+      ^ssh ...$ssh_args
+    }
+  }
+
+  # Wrap `sudo` to preserve Ghostty's TERMINFO environment variable
+  export def --wrapped sudo [...args] {
+    mut sudo_args = $args
+
+    if (has_feature "sudo") {
+      # Extract just the sudo options (before the command)
+      let sudo_options = (
+        $args | take until {|arg|
+          not (($arg | str starts-with "-") or ($arg | str contains "="))
+        }
+      )
+
+      # Prepend TERMINFO preservation flag if not using sudoedit
+      if (not ("-e" in $sudo_options or "--edit" in $sudo_options)) {
+        $sudo_args = ($args | prepend "--preserve-env=TERMINFO")
+      }
+    }
+
+    ^sudo ...$sudo_args
+  }
+}
+
+# Clean up XDG_DATA_DIRS by removing GHOSTTY_SHELL_INTEGRATION_XDG_DIR
+if 'GHOSTTY_SHELL_INTEGRATION_XDG_DIR' in $env {
+  if 'XDG_DATA_DIRS' in $env {
+    $env.XDG_DATA_DIRS = ($env.XDG_DATA_DIRS | str replace $"($env.GHOSTTY_SHELL_INTEGRATION_XDG_DIR):" "")
+  }
+  hide-env GHOSTTY_SHELL_INTEGRATION_XDG_DIR
+}

package/apps/macos/Resources/shell-integration/zsh/.zshenv

@@ -0,0 +1,61 @@
+# Based on (started as) a copy of Kitty's zsh integration. Kitty is
+# distributed under GPLv3, so this file is also distributed under GPLv3.
+# The license header is reproduced below:
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# This script is sourced automatically by zsh when ZDOTDIR is set to this
+# directory. It therefore assumes it's running within our shell integration
+# environment and should not be sourced manually (unlike ghostty-integration).
+#
+# This file can get sourced with aliases enabled. To avoid alias expansion
+# we quote everything that can be quoted. Some aliases will still break us
+# though.
+
+# Restore the original ZDOTDIR value if GHOSTTY_ZSH_ZDOTDIR is set.
+# Otherwise, unset the ZDOTDIR that was set during shell injection.
+if [[ -n "${GHOSTTY_ZSH_ZDOTDIR+X}" ]]; then
+    'builtin' 'export' ZDOTDIR="$GHOSTTY_ZSH_ZDOTDIR"
+    'builtin' 'unset' 'GHOSTTY_ZSH_ZDOTDIR'
+else
+    'builtin' 'unset' 'ZDOTDIR'
+fi
+
+# Use try-always to have the right error code.
+{
+    # Zsh treats unset ZDOTDIR as if it was HOME. We do the same.
+    #
+    # Source the user's .zshenv before sourcing ghostty-integration because the
+    # former might set fpath and other things without which ghostty-integration
+    # won't work.
+    #
+    # Use typeset in case we are in a function with warn_create_global in
+    # effect. Unlikely but better safe than sorry.
+    'builtin' 'typeset' _ghostty_file=${ZDOTDIR-$HOME}"/.zshenv"
+    # Zsh ignores unreadable rc files. We do the same.
+    # Zsh ignores rc files that are directories, and so does source.
+    [[ ! -r "$_ghostty_file" ]] || 'builtin' 'source' '--' "$_ghostty_file"
+} always {
+    if [[ -o 'interactive' ]]; then
+        # ${(%):-%x} is the path to the current file.
+        # On top of it we add :A:h to get the directory.
+        'builtin' 'typeset' _ghostty_file="${${(%):-%x}:A:h}"/ghostty-integration
+        if [[ -r "$_ghostty_file" ]]; then
+            'builtin' 'autoload' '-Uz' '--' "$_ghostty_file"
+            "${_ghostty_file:t}"
+            'builtin' 'unfunction' '--' "${_ghostty_file:t}"
+        fi
+    fi
+    'builtin' 'unset' '_ghostty_file'
+}