@suffolklitlab/alkiln 5.13.0-logs2 → 5.13.0-logs4

package/CHANGELOG.md

@@ -43,7 +43,21 @@ Format:
 - 
 -->
 
-## [Unreleased]
+<!-- ## [Unreleased] -->
+
+## [5.13.3] - 2025-01-05
+
+### Fixed
+
+- Updates to latest docassemble HTML. See [#960](https://github.com/SuffolkLITLab/ALKiln/issues/960). Changes all appearances of `fieldset` to keep the code consistent.
+
+## [5.13.2] - 2024-11-23
+
+### Fixed
+
+- Fixes download Step unable to use a partial filename match. The Step needed the whole name, including the extension. See [#725](https://github.com/SuffolkLITLab/ALKiln/issues/725).
+
+## [5.13.1] - 2024-10-23
 
 ### Changed
 
@@ -52,6 +66,8 @@ Format:
 ### Fixed
 
 - Detects failed sign in. Closes [#918](https://github.com/SuffolkLITLab/ALKiln/issues/918).
+- Fixes undefined `errors` var in `After()`
+- Closes [#924](https://github.com/SuffolkLITLab/ALKiln/issues/924), remove extra interview url print
 
 ### Internal
 
@@ -62,6 +78,11 @@ Format:
 - Adds decision docs
 - Updated CONTRIBUTING.md
 - Added example.env, closes [#374](https://github.com/SuffolkLITLab/ALKiln/issues/374)
+- Closes [#805](https://github.com/SuffolkLITLab/ALKiln/issues/805), create verbose-type log
+- Closes [#659](https://github.com/SuffolkLITLab/ALKiln/issues/659), abstract adding to debug_log
+- Closes [#925](https://github.com/SuffolkLITLab/ALKiln/issues/925), allow a `Log` to throw an error
+- Addresses [#461](https://github.com/SuffolkLITLab/ALKiln/issues/461), setup and takedown reports
+- Updates pdfjs-dist for node v20 and v22. See [#952](https://github.com/SuffolkLITLab/ALKiln/issues/952).
 
 ## [5.13.0] - 2024-07-11
 

package/README.md

@@ -41,25 +41,46 @@ Read about contributing in our [CONTRIBUTING.md document](CONTRIBUTING.md). Here
 ## Cheat sheet
 
 *Once you've already read the contributing documentation, you can use these as quick reminders for running our internal tests.*
-To set up for the integration tests, create the project on the server:
+
+### `setup` before starting development of a feature/fix
+
+Set up for the cucumber integration tests.
+
+Add the feature branch name to your `.env` file:
+
+```
+BRANCH=42_feat_life_the_univers_and_everything
+```
+
+Then create the project on the server:
 
 ```bash
 npm run setup
 ```
 
-Use the syntax below to trigger specific tags:
+### Run tests repeatedly
+
+Run all cucumber tests that are not currently blocked by upstream changes:
+
+```bash
+npm run pass
+```
+
+Trigger cucumber tests with specific tags:
 
 ```bash
-npm run cucumber -- "--tags" "@tagname"
+npm run cucumber "@tagname"
 ```
 
-To run the unit tests in isolation:
+Run the unit tests:
 
 ```bash
 npm run unit
 ```
 
-If you or someone else changes the interview code in `./docassemble`, you have to clean up the old data on the server before running `setup` again:
+### Always run `takedown` before running `setup` again
+
+If you or someone else changes the interview code in our `./docassemble` directory, you have to delete the code currently on the testing server before running `setup` again. Also do this when you're done with the feature/fix or starting a new feature/fix.
 
 ```bash
 npm run takedown

package/action.yml

@@ -70,18 +70,20 @@ runs:
         DOCASSEMBLECLI_VERSION: ${{ inputs.DOCASSEMBLECLI_VERSION }}
       shell: bash
       run: |
-        log="💡 ALK0023 INFO: Set environment variables"
+        log="💡 ALK0023 INFO: Set environment variables and create artifacts folder"
 
         # Human-readable date/time: https://www.shell-tips.com/linux/how-to-format-date-and-time-in-linux-macos-and-bash/#how-to-format-a-date-in-bash
         timestamp="$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)"
         artifact_folder="alkiln-${timestamp}UTC"
-        echo "ARTIFACT_FOLDER=$artifact_folder" >> $GITHUB_ENV
         debug_path="${artifact_folder}/debug_log.txt"
-        echo "DEBUG_PATH=$debug_path" >> $GITHUB_ENV
-
-        mkdir -p "$artifact_path"
+        mkdir -p "$artifact_folder"
         echo "$log" >> "$debug_path"
 
+        # Action-specific vars
+        echo "ARTIFACT_FOLDER=$artifact_folder" >> $GITHUB_ENV
+        echo "DEBUG_PATH=$debug_path" >> $GITHUB_ENV
+
+        # Required for all tests
         echo "REPO_URL=${{ github.server_url }}/${{ github.repository }}" >> $GITHUB_ENV
         echo "BRANCH_PATH=$BRANCH_PATH" >> $GITHUB_ENV
         # Workflow inputs
@@ -97,9 +99,9 @@ runs:
       shell: bash
       run: |
         log="💡 ALK0024 INFO: Confirm environment variables"
-        echo -e "\n$log" >> "$DEBUG_PATH"
+        echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
         vars_log="\nALKiln version is $ALKILN_VERSION\nRepo is $REPO_URL\nBranch ref is $BRANCH_PATH\nMAX_SECONDS_FOR_SETUP is $MAX_SECONDS_FOR_SETUP\nSERVER_RELOAD_TIMEOUT_SECONDS is $SERVER_RELOAD_TIMEOUT_SECONDS\n"
-        echo -e "$vars_log" >> "$DEBUG_PATH" && echo -e "$vars_log"
+        echo -e "$vars_log" >> "${{ env.DEBUG_PATH }}" && echo -e "$vars_log"
 
     # Install
     - name: "💡 ALK0025 INFO: Set up node"
@@ -110,7 +112,7 @@ runs:
       shell: bash
       run: |
         log="💡 ALK0026 INFO: Install ALKiln directly from npm"
-        echo -e "\n$log" >> "$DEBUG_PATH"
+        echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
         npm install -g "@suffolklitlab/alkiln@$ALKILN_VERSION"
 
     # Install on playground
@@ -125,16 +127,16 @@ runs:
       shell: bash
       run: |
         log="💡 ALK0027 INFO: Create a Project and install the package from GitHub"
-        echo -e "\n$log" >> "$DEBUG_PATH"
+        echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
         pip install "docassemblecli==$DOCASSEMBLECLI_VERSION"
-        alkiln-setup --path="$ARTIFACT_FOLDER"
+        alkiln-setup --path="${{ env.ARTIFACT_FOLDER }}"
     - name: "🤕 ALK0028 ERROR: Unable to create a Project"
       if: ${{ inputs.INSTALL_METHOD == 'playground' && failure() }}
       shell: bash
       run: |
         # "🤕 ALK0028 ERROR: Unable to create a Project"
         long_log="\n\n―――\n🤕 ALK0028 ERROR: Unable to create a Project on your server's testing account or pull your package into it. Check the messages above this line.\n\n"
-        echo -e "$long_log" >> "$DEBUG_PATH" && echo -e "$long_log"
+        echo -e "$long_log" >> "${{ env.DEBUG_PATH }}" && echo -e "$long_log"
 
     # Server installations - find folders and save session vars
     - name: "💡 ALK0029 INFO: Install the GitHub package onto the server"
@@ -142,14 +144,14 @@ runs:
       shell: bash
       run: |
         log="💡 ALK0029 INFO: Install the GitHub package onto the server"
-        echo -e "\n$log" >> "$DEBUG_PATH"
-        alkiln-server-install --path="$ARTIFACT_FOLDER"
+        echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+        alkiln-server-install --path="${{ env.ARTIFACT_FOLDER }}"
     - name: "🤕 ALK0030 ERROR: Unable to install the package"
       if: ${{ inputs.INSTALL_METHOD == 'server' && failure() }}
       shell: bash
       run: |
         log="\n\n―――\n🤕 ALK0030 ERROR: Unable to install the package on the temporary GitHub docassemble server. Check the steps above this line.\n\n"
-        echo -e "$log" >> "$DEBUG_PATH" && echo -e "$log"
+        echo -e "$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
 
     # run tests
     - name: "💡 ALK0031 INFO: Run tests"
@@ -159,8 +161,8 @@ runs:
       shell: bash
       run: |
         log="💡 ALK0031 INFO: Run tests"
-        echo -e "\n$log" >> "$DEBUG_PATH"
-        alkiln-run "$ALKILN_TAG_EXPRESSION" --path="$ARTIFACT_FOLDER"
+        echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+        alkiln-run "$ALKILN_TAG_EXPRESSION" --path="${{ env.ARTIFACT_FOLDER }}"
     
     # on playground, delete project
     - name: "💡 ALK0032 INFO: Delete the Project from the Playground"
@@ -168,8 +170,8 @@ runs:
       shell: bash
       run: |
         log="💡 ALK0032 INFO: Delete the Project from the Playground"
-        echo -e "\n$log" >> "$DEBUG_PATH"
-        alkiln-takedown --path="$ARTIFACT_FOLDER"
+        echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+        alkiln-takedown --path="${{ env.ARTIFACT_FOLDER }}"
     
     # Upload artifacts that subscribers can download on the Actions summary page
     - name: "💡 ALK0033 INFO: Upload artifacts folder"
@@ -192,16 +194,16 @@ runs:
       shell: bash
       run: |
         log="💡 ALK0184 INFO: Prepare ALKiln output file paths"
-        echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"
+        echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo "$log"
 
         FOLDER=$(ls -d */ | grep -E '^alkiln-*' || true)
 
         log_folder="Test results artifacts folder is $FOLDER"
-        echo -e "\n$log_folder" >> "$DEBUG_PATH" && echo "$log_folder"
+        echo -e "\n$log_folder" >> "${{ env.DEBUG_PATH }}" && echo "$log_folder"
 
         if [[ "$FOLDER" = "" ]]; then
           log_missing="Artifacts folder is missing. The path is an empty string: '$FOLDER'"
-          echo -e "\n$log_missing" >> "$DEBUG_PATH" && echo "$log_missing"
+          echo -e "\n$log_missing" >> "${{ env.DEBUG_PATH }}" && echo "$log_missing"
 
         else
           REPORT_PATH="${FOLDER}report.txt"
@@ -210,30 +212,30 @@ runs:
           DEBUG_LOG_PATH="${FOLDER}debug_log.txt"
 
           if [ -f "$REPORT_PATH" ]; then
-            echo -e "\n$REPORT_PATH exists" >> "$DEBUG_PATH" && echo "$REPORT_PATH exists"
+            echo -e "\n$REPORT_PATH exists" >> "${{ env.DEBUG_PATH }}" && echo "$REPORT_PATH exists"
           else
-            echo -e "\n$REPORT_PATH is missing" >> "$DEBUG_PATH" && echo "$REPORT_PATH is missing"
+            echo -e "\n$REPORT_PATH is missing" >> "${{ env.DEBUG_PATH }}" && echo "$REPORT_PATH is missing"
             REPORT_PATH=""
           fi
 
           if [ -f "$REPORT_LOG_PATH" ]; then
-            echo -e "\n$REPORT_LOG_PATH exists" >> "$DEBUG_PATH" && echo "$REPORT_LOG_PATH exists"
+            echo -e "\n$REPORT_LOG_PATH exists" >> "${{ env.DEBUG_PATH }}" && echo "$REPORT_LOG_PATH exists"
           else
-            echo -e "\n$REPORT_LOG_PATH is missing" >> "$DEBUG_PATH" && echo "$REPORT_LOG_PATH is missing"
+            echo -e "\n$REPORT_LOG_PATH is missing" >> "${{ env.DEBUG_PATH }}" && echo "$REPORT_LOG_PATH is missing"
             REPORT_LOG_PATH=""
           fi
 
           if [ -f "$UNEXPECTED_RESULTS_PATH" ]; then
-            echo -e "\n$UNEXPECTED_RESULTS_PATH exists" >> "$DEBUG_PATH" && echo "$UNEXPECTED_RESULTS_PATH exists"
+            echo -e "\n$UNEXPECTED_RESULTS_PATH exists" >> "${{ env.DEBUG_PATH }}" && echo "$UNEXPECTED_RESULTS_PATH exists"
           else
-            echo -e "\n$UNEXPECTED_RESULTS_PATH is missing" >> "$DEBUG_PATH" && echo "$UNEXPECTED_RESULTS_PATH is missing"
+            echo -e "\n$UNEXPECTED_RESULTS_PATH is missing" >> "${{ env.DEBUG_PATH }}" && echo "$UNEXPECTED_RESULTS_PATH is missing"
             UNEXPECTED_RESULTS_PATH=""
           fi
 
           if [ -f "$DEBUG_LOG_PATH" ]; then
-            echo -e "\n$DEBUG_LOG_PATH exists" >> "$DEBUG_PATH" && echo "$DEBUG_LOG_PATH exists"
+            echo -e "\n$DEBUG_LOG_PATH exists" >> "${{ env.DEBUG_PATH }}" && echo "$DEBUG_LOG_PATH exists"
           else
-            echo -e "\n$DEBUG_LOG_PATH is missing" >> "$DEBUG_PATH" && echo "$DEBUG_LOG_PATH is missing"
+            echo -e "\n$DEBUG_LOG_PATH is missing" >> "${{ env.DEBUG_PATH }}" && echo "$DEBUG_LOG_PATH is missing"
             DEBUG_LOG_PATH=""
           fi
 
@@ -252,4 +254,4 @@ runs:
       if: ${{ always() }}
       run: |
         log="💡 ALK0034 INFO: ALkiln finished running tests. See above for more details."
-        echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"
+        echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo "$log"

package/action_for_github_server/action.yml

@@ -48,29 +48,27 @@ runs:
       - uses: actions/checkout@v4
 
       - shell: bash
-        if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
-        name: "💡 ALK0018 INFO: Create artifact paths with date and time"
         run: |
           log="💡 ALK0018 INFO: Get path names with date and time"
           timestamp="$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)"
           debug_dir="/tmp"
           debug_path="$debug_dir/alkiln_docker_logs-${timestamp}UTC.txt"
-          artifact_path="alkiln_github_server-${timestamp}UTC"
+          artifact_folder="alkiln_github_server-${timestamp}UTC"
 
           mkdir -p "$debug_dir"
-          mkdir -p "$artifact_path"
+          mkdir -p "$artifact_folder"
           echo -e "$log" >> "$debug_path"
 
-          echo "DEBUG_PATH=$debug_path" >> "$GITHUB_ENV"
-          echo "GITHUB_SERVER_ARTIFACT_NAME=$artifact_path" >> "$GITHUB_ENV"
+          echo "DEBUG_PATH=$debug_path" >> $GITHUB_ENV
+          echo "GITHUB_SERVER_ARTIFACT_NAME=$artifact_folder" >> $GITHUB_ENV
 
       - shell: bash
         env:
           MAX_SECONDS_FOR_DOCKER: ${{ inputs.MAX_SECONDS_FOR_DOCKER }}
           DOCASSEMBLECLI_VERSION: ${{ inputs.DOCASSEMBLECLI_VERSION }}
         run: |
-          log="💡ALK0001 INFO: Set environment variables"
-          echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"
+          log="💡 ALK0001 INFO: Set environment variables"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
 
           echo "MAX_SECONDS_FOR_DOCKER=$MAX_SECONDS_FOR_DOCKER" >> $GITHUB_ENV
           echo "DOCASSEMBLECLI_VERSION=$DOCASSEMBLECLI_VERSION" >> $GITHUB_ENV
@@ -83,7 +81,7 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0002 INFO: Create GitHub step output variables"
-          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
           echo "DOCASSEMBLE_DEVELOPER_API_KEY=$DA_ADMIN_API_KEY" >> "$GITHUB_OUTPUT"
           echo "DA_ADMIN_EMAIL=$DA_ADMIN_EMAIL" >> "$GITHUB_OUTPUT"
           echo "DA_ADMIN_PASSWORD=$DA_ADMIN_PASSWORD" >> "$GITHUB_OUTPUT"
@@ -94,19 +92,19 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0003 INFO: Get config"
-          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
 
           mkdir /tmp/config
           # Worth making this silent by defining a variable with > /dev/null...?
           if [ -n "$CONFIG" ]
           then
             log2="💡 ALK0004 INFO: The developer did provide a custom docassemble config file as an input into this action."
-            echo -e "\n$log2" >> "$DEBUG_PATH" echo "$log2"
+            echo -e "\n$log2" >> "${{ env.DEBUG_PATH }}" echo "$log2"
             echo "$CONFIG" > /tmp/config/myconfig.yml
             echo "CONFIG_ARGS=--env DA_CONFIG=/tmp/config/myconfig.yml --volume /tmp/config:/tmp/config " >> $GITHUB_ENV
           else
             log3="💡 ALK0005 INFO: The developer did NOT provide a custom docassemble config file as an input into this action. Docassemble will use its default config."
-            echo -e "\n$log3" >> "$DEBUG_PATH" echo "$log3"
+            echo -e "\n$log3" >> "${{ env.DEBUG_PATH }}" echo "$log3"
             echo "CONFIG_ARGS=" >> $GITHUB_ENV
           fi
 
@@ -122,13 +120,13 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0006 INFO: Determine docker logs visibility"
-          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
             echo "OUTPUT_DOCKER=$SHOW_DOCKER_OUTPUT" >> $GITHUB_ENV
-            echo -e "\n$SHOW_DOCKER_OUTPUT" >> "$DEBUG_PATH"
+            echo -e "\n$SHOW_DOCKER_OUTPUT" >> "${{ env.DEBUG_PATH }}"
           else
             echo "OUTPUT_DOCKER=false" >> $GITHUB_ENV
-            echo -e "\nfalse" >> "$DEBUG_PATH"
+            echo -e "\nfalse" >> "${{ env.DEBUG_PATH }}"
           fi
 
       # Messages about output
@@ -138,14 +136,14 @@ runs:
         run: |
           # 💡 ALK0007 INFO: ALKiln will now hide docker output
           log="===\n💡 ALK0007 INFO: ALKiln will now hide docker output to avoid possibly showing details about your config. If you want to get output to see more of what is going on, use \"with:\" and set the input \"SHOW_DOCKER_OUTPUT\" to \"true\". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==="
-          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
       - name: "💡 ALK0008 INFO: ALKiln will show docker output"
         if: ${{ env.OUTPUT_DOCKER == 'true' }}
         shell: bash
         run: |
           # 💡 ALK0008 INFO: ALKiln will show docker output
           log="===\n💡 ALK0008 INFO: ALKiln will show docker output. ALKiln cannot control this output. If you want to prevent output, use \"with:\" and set the input \"SHOW_DOCKER_OUTPUT\" to \"false\". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==="
-          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
 
       # TODO: Reduce these to 1 block by putting ` > /dev/null 2>&1` into an env var
       # No docker output
@@ -156,13 +154,13 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0009 INFO: Download and start docker silently"
-          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
           docker pull jhpyle/docassemble > /dev/null 2>&1
           docker run --name docassemble_container \
                      --env DA_ADMIN_EMAIL="$DA_ADMIN_EMAIL" \
                      --env DA_ADMIN_PASSWORD="$DA_ADMIN_PASSWORD" \
                      --env DA_ADMIN_API_KEY="$DA_ADMIN_API_KEY" \
-                     "$CONFIG_ARGS" \
+                     $CONFIG_ARGS \
                      --cap-add SYS_PTRACE \
                      --memory="4gb" -d -p 80:80 jhpyle/docassemble > /dev/null 2>&1
       # With output
@@ -173,13 +171,13 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0010 INFO: Download and start docker"
-          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
           docker pull jhpyle/docassemble
           docker run --name docassemble_container \
                      --env DA_ADMIN_EMAIL="$DA_ADMIN_EMAIL" \
                      --env DA_ADMIN_PASSWORD="$DA_ADMIN_PASSWORD" \
                      --env DA_ADMIN_API_KEY="$DA_ADMIN_API_KEY" \
-                     "$CONFIG_ARGS" \
+                     $CONFIG_ARGS \
                      --cap-add SYS_PTRACE \
                      --memory="4gb" -d -p 80:80 jhpyle/docassemble
 
@@ -191,13 +189,13 @@ runs:
         run: |
           # 💡 ALK0011 INFO: The following messages are not docker output
           log="💡 ALK0011 INFO: The following messages are NOT docker output, just ALKiln waiting for the server to start"
-          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
 
       - name: "💡 ALK0012 INFO: Waiting for server to start"
         shell: bash
         run: |
           log="💡 ALK0012 INFO: Waiting for server to start"
-          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
 
           # Reset the SECONDS variable
           SECONDS=0
@@ -207,27 +205,27 @@ runs:
           response="start"
           while [[ $response != *"200"* ]]; do
             log2="💡 ALK0013 INFO: Time elapsed: $SECONDS seconds"
-            echo -e "\n$log2" >> "$DEBUG_PATH" && echo -e "$log2"
+            echo -e "\n$log2" >> "${{ env.DEBUG_PATH }}" && echo -e "$log2"
 
             # Check if max seconds till loading has passed
             if [[ $SECONDS -ge $MAX_SECONDS_FOR_DOCKER ]]; then
               log3="🤕 ALK0014 ERROR: Timed out waiting for docker container to serve the site. If you want to give your docker container more timem to install, set the MAX_SECONDS_FOR_DOCKER input for this action."
-              echo -e "\n$log3" >> "$DEBUG_PATH" && echo -e "$log3"
+              echo -e "\n$log3" >> "${{ env.DEBUG_PATH }}" && echo -e "$log3"
               exit 1
             fi
 
             # Set the variable to a new string value in each iteration
             response=$(curl -o /dev/null -s -w "%{http_code}\n" http://localhost:80/health_check?ready=1)
             log4="💡 ALK0015 INFO: Response is $response"
-            echo -e "\n$log4" >> "$DEBUG_PATH" && echo -e "$log4"
+            echo -e "\n$log4" >> "${{ env.DEBUG_PATH }}" && echo -e "$log4"
 
             # Check if the string includes the desired text
             if [[ $response == *"200"* ]]; then
               log5="💡 ALK0016 SUCCESS: Success! The docker container is ready!"
-              echo -e "\n$log5" >> "$DEBUG_PATH" && echo -e "$log5"
+              echo -e "\n$log5" >> "${{ env.DEBUG_PATH }}" && echo -e "$log5"
             else
               log6="💡 ALK0017 INFO: The docker container is not ready yet. Will check again in 30 seconds."
-              echo -e "\n$log6" >> "$DEBUG_PATH" && echo -e "$log6"
+              echo -e "\n$log6" >> "${{ env.DEBUG_PATH }}" && echo -e "$log6"
               sleep 30
             fi
 
@@ -262,7 +260,7 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0019 INFO: Create docker artifact data"
-          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
           echo "$(docker output docassemble_container)" >> "${{ env.DEBUG_PATH }}"
       - name: "💡 ALK0020 INFO: Upload artifacts folder"
         if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
@@ -275,10 +273,10 @@ runs:
         if: ${{ success() }}
         run: |
           log="💡 ALK0021 SUCCESS: ALKiln created the docker container and started the server!"
-          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
 
       - shell: bash
         if: ${{ failure() }}
         run: |
           log="🤕 ALK0022 ERROR: Something went wrong. See above for more details."
-          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"