Installing and upgrading (#757)

Author: HalFrgrd

.github/workflows/release.yml

@@ -109,6 +109,13 @@ jobs:
     needs: [create-release, build-release]
     runs-on: ubuntu-latest
     steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+      - name: Upload install.sh to release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release upload "${{ needs.create-release.outputs.version }}" install.sh --clobber
       - name: Mark release as prerelease
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -125,6 +132,6 @@ jobs:
         uses: docker/setup-buildx-action@v4
       - name: Test installation on Alpine and Ubuntu
         env:
-          FLYLINE_RELEASE_VERSION: ${{ needs.create-release.outputs.version }}
+          FLYLINE_INSTALL_VERSION: ${{ needs.create-release.outputs.version }}
         run: |
           docker buildx bake -f docker-bake.hcl install-test-alpine install-test-ubuntu install-test-bash-3-2-57

README.md

@@ -44,7 +44,7 @@ Flyline is similar to [ble.sh](https://github.com/akinomyoga/ble.sh) but is writ
 > [!TIP]
 > Run the following command to download flyline and update your `.bashrc` to load the latest version. No need for `sudo`!
 ```bash
-curl -sSfL https://raw.githubusercontent.com/HalFrgrd/flyline/master/install.sh | sh
+curl -sSfL https://github.com/HalFrgrd/flyline/releases/latest/download/install.sh | sh
 ```
 
 

docker-bake.hcl

@@ -6,7 +6,7 @@ variable "PRE_BASH_4_4_VERSION_MATRIX" {
     default = ["3.2.57"]
 }
 
-variable "FLYLINE_RELEASE_VERSION" {
+variable "FLYLINE_INSTALL_VERSION" {
     default = null
 }
 
@@ -231,15 +231,15 @@ target "install-test-alpine" {
     context = "."
     dockerfile = "docker/install_test_alpine.Dockerfile"
     args = {
-        FLYLINE_RELEASE_VERSION = FLYLINE_RELEASE_VERSION
+        FLYLINE_INSTALL_VERSION = FLYLINE_INSTALL_VERSION
     }
 }
 
 target "install-test-ubuntu" {
     context = "."
     dockerfile = "docker/install_test_ubuntu.Dockerfile"
     args = {
-        FLYLINE_RELEASE_VERSION = FLYLINE_RELEASE_VERSION
+        FLYLINE_INSTALL_VERSION = FLYLINE_INSTALL_VERSION
     }
 }
 
@@ -250,7 +250,7 @@ target "install-test-bash-3-2-57" {
     }
     dockerfile = "docker/install_test_bash_3.2.57.Dockerfile"
     args = {
-        FLYLINE_RELEASE_VERSION = FLYLINE_RELEASE_VERSION
+        FLYLINE_INSTALL_VERSION = FLYLINE_INSTALL_VERSION
     }
 }
 

docker/install_test_alpine.Dockerfile

@@ -1,9 +1,9 @@
 FROM alpine:latest
 
-ARG FLYLINE_RELEASE_VERSION
+ARG FLYLINE_INSTALL_VERSION
 
 RUN apk add --no-cache gcc bash curl
 
-RUN curl -sSfL https://raw.githubusercontent.com/HalFrgrd/flyline/master/install.sh | FLYLINE_RELEASE_VERSION=${FLYLINE_RELEASE_VERSION} sh
+RUN curl -sSfL https://github.com/HalFrgrd/flyline/releases/download/${FLYLINE_INSTALL_VERSION}/install.sh | FLYLINE_INSTALL_VERSION=${FLYLINE_INSTALL_VERSION} sh
 
 RUN bash -i -c "flyline --version"

docker/install_test_bash_3.2.57.Dockerfile

@@ -1,9 +1,9 @@
 FROM specific-bash-version
 
-ARG FLYLINE_RELEASE_VERSION
+ARG FLYLINE_INSTALL_VERSION
 
 RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
 
-RUN curl -sSfL https://raw.githubusercontent.com/HalFrgrd/flyline/master/install.sh | FLYLINE_RELEASE_VERSION=${FLYLINE_RELEASE_VERSION} sh
+RUN curl -sSfL https://github.com/HalFrgrd/flyline/releases/download/${FLYLINE_INSTALL_VERSION}/install.sh | FLYLINE_INSTALL_VERSION=${FLYLINE_INSTALL_VERSION} sh
 
 RUN /bin/bash -i -c "flyline --version"

docker/install_test_ubuntu.Dockerfile

@@ -1,10 +1,10 @@
 FROM ubuntu:22.04 
 
-ARG FLYLINE_RELEASE_VERSION
+ARG FLYLINE_INSTALL_VERSION
 
 RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
 
 
-RUN curl -sSfL https://raw.githubusercontent.com/HalFrgrd/flyline/master/install.sh | FLYLINE_RELEASE_VERSION=${FLYLINE_RELEASE_VERSION} sh
+RUN curl -sSfL https://github.com/HalFrgrd/flyline/releases/download/${FLYLINE_INSTALL_VERSION}/install.sh | FLYLINE_INSTALL_VERSION=${FLYLINE_INSTALL_VERSION} sh
 
 RUN /bin/bash -i -c "flyline --version"

install.sh

@@ -1,11 +1,25 @@
 #!/bin/sh
 # Flyline installer
-# Usage: curl -sSfL https://raw.githubusercontent.com/HalFrgrd/flyline/master/install.sh | sh
+# Usage: curl -sSfL https://github.com/HalFrgrd/flyline/releases/latest/download/install.sh | sh
 
 set -eu
 
+expand_path() {
+    case "$1" in
+        '~/'*) echo "${HOME}/${1#~/}" ;;
+        '~')   echo "${HOME}" ;;
+        *)     echo "$1" ;;
+    esac
+}
+
 REPO="HalFrgrd/flyline"
-INSTALL_DIR="${HOME}/.local/lib"
+if [ -n "${FLYLINE_INSTALL_DIR:-}" ]; then
+    INSTALL_DIR="$(expand_path "$FLYLINE_INSTALL_DIR")"
+elif [ -n "${FLYLINE_LOAD_DIR:-}" ]; then
+    INSTALL_DIR="$(expand_path "$FLYLINE_LOAD_DIR")"
+else
+    INSTALL_DIR="${HOME}/.local/lib"
+fi
 BASHRC="${HOME}/.bashrc"
 
 # ---------------------------------------------------------------------------
@@ -193,9 +207,9 @@ main() {
 
     say "Detected target: ${TARGET}"
 
-    if [ -n "${FLYLINE_RELEASE_VERSION:-}" ]; then
-        say "Using specified release version: ${FLYLINE_RELEASE_VERSION}"
-        VERSION="${FLYLINE_RELEASE_VERSION}"
+    if [ -n "${FLYLINE_INSTALL_VERSION:-}" ]; then
+        say "Using specified release version: ${FLYLINE_INSTALL_VERSION}"
+        VERSION="${FLYLINE_INSTALL_VERSION}"
     else
         say "Fetching latest release information..."
         VERSION="$(get_latest_version)"
@@ -220,7 +234,8 @@ main() {
     # shellcheck disable=SC2064
     trap "rm -rf '$TMP_DIR'" EXIT
 
-    say "Downloading ${ARCHIVE} from ${DOWNLOAD_URL}..."
+    say "Downloading ${ARCHIVE} from
+    ${DOWNLOAD_URL}..."
     download "$DOWNLOAD_URL" "${TMP_DIR}/${ARCHIVE}"
 
     if [ -n "$SHA256_URL" ]; then
@@ -233,25 +248,6 @@ main() {
             || err "Checksum verification failed for ${ARCHIVE}."
     fi
 
-    # Prompt for install directory; read from /dev/tty so it works when piped.
-    # Falls back to the default when no terminal is available (e.g. CI).
-    say "Enter install directory (leave blank to use: ~/.local/lib)"
-    printf '> ' >&2
-    input_dir=""
-    if [ -t 0 ]; then
-        read -r input_dir || true
-    elif [ -r /dev/tty ]; then
-        read -r input_dir </dev/tty || true
-    fi
-    if [ -n "$input_dir" ]; then
-        # Expand a leading ~/ to $HOME/.
-        # shellcheck disable=SC2088
-        case "$input_dir" in
-            '~/'*) input_dir="${HOME}/${input_dir#~/}" ;;
-            '~')   input_dir="${HOME}" ;;
-        esac
-        INSTALL_DIR="$input_dir"
-    fi
 
     mkdir -p "$INSTALL_DIR"
 
@@ -276,14 +272,12 @@ main() {
     say "Installed: ${LIB_PATH}"
 
     # Update or add 'enable -f ... flyline' in ~/.bashrc.
-    ENABLE_CMD="enable -f ${LIB_PATH} flyline"
-    if [ -f "$BASHRC" ] && grep -qE '^enable( -f [^ ]*)? flyline( |$)' "$BASHRC"; then
-        new_content=$(sed -E "s|^enable( -f [^ ]*)? flyline( .*)?$|${ENABLE_CMD}|" "$BASHRC")
-        printf '%s' "$new_content" > "$BASHRC"
-        say "Updated flyline configuration in ${BASHRC}"
-    else
+    if [ -z "${FLYLINE_VERSION:-}" ]; then
+        ENABLE_CMD="enable -f ${LIB_PATH} flyline"
         printf '\n# Flyline - enhanced Bash experience\n%s\n' "$ENABLE_CMD" >> "$BASHRC"
         say "Added flyline to ${BASHRC}"
+    else
+        say "Flyline is already installed (detected ${FLYLINE_VERSION}); skipping .bashrc modification."
     fi
 
 
@@ -307,11 +301,27 @@ main() {
     fi
 
     say ""
-    say "Installation complete!"
-    say '    To activate in the current shell:'
-    say "        $ENABLE_CMD"
-    say '    Or open a new terminal and run the tutorial:'
-    say "        flyline run-tutorial"
+    if [ -n "${FLYLINE_VERSION:-}" ]; then
+        say "Upgrade from ${FLYLINE_VERSION} -> ${VERSION}, run \`flyline changelog\` to see what's changed."
+        say "To activate the upgrade, open a new shell."
+        if [ -n "${FLYLINE_LOAD_DIR:-}" ]; then
+            resolved_load_dir="$(expand_path "$FLYLINE_LOAD_DIR")"
+            if [ "$resolved_load_dir" != "$INSTALL_DIR" ]; then
+                warn "The upgrade installation directory ($INSTALL_DIR) is different from the currently running load directory ($resolved_load_dir)."
+                warn "Please make sure to update your ~/.bashrc or other startup scripts to point to the new libflyline."
+            fi
+        fi
+    else
+        say "Installation complete!"
+        say '    To activate in the current shell:'
+        if [ -z "${FLYLINE_INSTALL_DIR:-}" ]; then
+            say "        $ENABLE_CMD"
+        else
+            say "        enable -d flyline && enable -f ${LIB_PATH} flyline"
+        fi
+        say '    Or open a new terminal and run the tutorial:'
+        say "        flyline run-tutorial"
+    fi
 
     # Detect if ble.sh is running or configured in ~/.bashrc
     if [ -n "${_ble_version:-}" ] || { [ -f "$BASHRC" ] && grep -q 'ble\.sh' "$BASHRC"; }; then

src/active_suggestions.rs

@@ -1220,6 +1220,7 @@ impl ActiveSuggestionsBuilder {
         self
     }
 
+    #[allow(dead_code)]
     pub fn with_should_run_flycomp(mut self, should_run_flycomp: bool) -> Self {
         self.should_run_flycomp = should_run_flycomp;
         self

src/app/mod.rs

@@ -409,8 +409,8 @@ impl<'a> App<'a> {
     fn new(settings: &'a mut Settings) -> Self {
         let unfinished_from_prev_command =
             unsafe { crate::bash_symbols::current_command_line_count } > 0;
-
-        let buffer = TextBuffer::new("");
+        let initial_buf_val = settings.initial_buffer.take().unwrap_or_default();
+        let buffer = TextBuffer::new(&initial_buf_val);
         let formatted_buffer_cache = FormattedBuffer::default();
 
         bash_funcs::reset_caches();
@@ -423,7 +423,7 @@ impl<'a> App<'a> {
         });
         crate::threads::register_thread(crate::threads::ThreadTag::Warming, warming_handle);
 
-        App {
+        let mut app = App {
             mode: AppRunningState::Running,
             buffer,
             formatted_buffer_cache,
@@ -470,7 +470,10 @@ impl<'a> App<'a> {
             right_click_popup_pos: None,
             right_click_copy_target: None,
             last_activity_time: std::time::Instant::now(),
-        }
+        };
+
+        app.on_possible_buffer_change();
+        app
     }
 
     /// Return a mutable reference to the history manager for the given fuzzy source.
@@ -1489,7 +1492,7 @@ impl<'a> App<'a> {
             ContentMode::TabCompletion(_) | ContentMode::TabCompletionWaiting { .. }
         );
 
-        if self.settings.auto_suggest || is_tab_completion_active {
+        if (self.settings.auto_suggest || is_tab_completion_active) && self.last_key.is_some() {
             #[derive(Debug, Clone, Copy, PartialEq, Eq)]
             enum CompletionAction {
                 Keep,

src/bash_funcs.rs

@@ -1834,6 +1834,7 @@ pub fn read_terminating_signal() -> c_int {
 }
 
 #[cfg(not(test))]
+#[allow(dead_code)]
 pub fn set_env_var(name: &str, value: &str) -> Result<()> {
     unsafe {
         let name_cstr = std::ffi::CString::new(name)?;
@@ -1850,13 +1851,38 @@ pub fn set_env_var(name: &str, value: &str) -> Result<()> {
 }
 
 #[cfg(test)]
+#[allow(dead_code)]
 pub fn set_env_var(name: &str, value: &str) -> Result<()> {
     // SAFETY: Tests that mutate process env vars run inside `rusty_fork_test!`
     // forked subprocesses, so the mutation cannot race with other threads.
     unsafe { std::env::set_var(name, value) };
     Ok(())
 }
 
+#[cfg(not(test))]
+pub fn export_env_var(name: &str, value: &str) -> Result<()> {
+    unsafe {
+        let name_cstr = std::ffi::CString::new(name)?;
+        let value_cstr = std::ffi::CString::new(value)?;
+        let var = bash_symbols::bind_variable(name_cstr.as_ptr(), value_cstr.as_ptr(), 0);
+        if var.is_null() {
+            return Err(anyhow::anyhow!(
+                "Failed to export environment variable '{}'",
+                name
+            ));
+        }
+        (*var).attributes |= 0x0000001; // att_exported
+        bash_symbols::array_needs_making = 1;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+pub fn export_env_var(name: &str, value: &str) -> Result<()> {
+    unsafe { std::env::set_var(name, value) };
+    Ok(())
+}
+
 #[cfg(not(test))]
 pub fn unset_env_var(name: &str) -> Result<()> {
     unsafe {