@suffolklitlab/alkiln 5.12.0 → 5.13.0-logs1

package/action.yml

@@ -1,5 +1,5 @@
 name: "ALKiln: Automated docassemble tests"
-description: "Automatically test any docassemble interview in a any branch on your GitHub repository whenever you commit or push. See https://suffolklitlab.org/docassemble-AssemblyLine-documentation/docs/automated_integrated_testing."
+description: "Automatically test any docassemble interview in a any branch on your GitHub repository whenever you commit or push. See https://suffolklitlab.org/docassemble-AssemblyLine-documentation/docs/alkiln/setup/#types."
 
 inputs:
   SERVER_URL:
@@ -41,6 +41,9 @@ outputs:
   PATH_TO_REPORT_FILE:
     description: 'An empty string ("") or the path to report.txt. Remember to check for the existence of the file before using it.'
     value: ${{ steps.alkiln_outputs.outputs.PATH_TO_REPORT_FILE }}
+  PATH_TO_REPORT_LOG_FILE:
+    description: 'An empty string ("") or the path to report_log.txt. Remember to check for the existence of the file before using it.'
+    value: ${{ steps.alkiln_outputs.outputs.PATH_TO_REPORT_LOG_FILE }}
   PATH_TO_UNEXPECTED_RESULTS_FILE:
     description: 'An empty string ("") or the path to unexpected_results.txt. Remember to check for the existence of the file before using it.'
     value: ${{ steps.alkiln_outputs.outputs.PATH_TO_UNEXPECTED_RESULTS_FILE }}
@@ -67,9 +70,16 @@ runs:
         DOCASSEMBLECLI_VERSION: ${{ inputs.DOCASSEMBLECLI_VERSION }}
       shell: bash
       run: |
-        # 💡 ALK0023 INFO: Set environment variables
+        log="💡 ALK0023 INFO: Set environment variables"
+
         # 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
-        echo "ARTIFACT_NAME=alkiln-$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)UTC" >> $GITHUB_ENV
+        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
+        echo "$log" >> "${debug_path}"
+
         echo "REPO_URL=${{ github.server_url }}/${{ github.repository }}" >> $GITHUB_ENV
         echo "BRANCH_PATH=$BRANCH_PATH" >> $GITHUB_ENV
         # Workflow inputs
@@ -84,18 +94,21 @@ runs:
     - name: "💡 ALK0024 INFO: Confirm environment variables"
       shell: bash
       run: |
-        # 💡 ALK0024 INFO: Confirm environment variables
-        echo -e "\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"
+        log="💡 ALK0024 INFO: Confirm environment variables"
+        echo -e "\n$log" >> "$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"
 
     # Install
-    - name: "💡 ALK0025 INFO: Install node packages"
+    - name: "💡 ALK0025 INFO: Set up node"
       uses: actions/setup-node@v4
       with:
         node-version: "18"
     - name: "💡 ALK0026 INFO: Install ALKiln directly from npm"
       shell: bash
       run: |
-        # 💡 ALK0026 INFO: Install ALKiln directly from npm
+        log="💡 ALK0026 INFO: Install ALKiln directly from npm"
+        echo -e "\n$log" >> "$DEBUG_PATH"
         npm install -g "@suffolklitlab/alkiln@$ALKILN_VERSION"
 
     # Install on playground
@@ -109,26 +122,32 @@ runs:
       if: ${{ inputs.INSTALL_METHOD == 'playground' }}
       shell: bash
       run: |
-        # 💡 ALK0027 INFO: Create a Project and install the package from GitHub
+        log="💡 ALK0027 INFO: Create a Project and install the package from GitHub"
+        echo -e "\n$log" >> "$DEBUG_PATH"
         pip install "docassemblecli==$DOCASSEMBLECLI_VERSION"
-        alkiln-setup
-    - name: "😞 ALK0028 ERROR: Unable to create a Project"
+        alkiln-setup --path="$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
-        echo -e "\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"
+        # "🤕 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"
 
     # Server installations - find folders and save session vars
     - name: "💡 ALK0029 INFO: Install the GitHub package onto the server"
       if: ${{ inputs.INSTALL_METHOD == 'server' }}
       shell: bash
-      run: alkiln-server-install
-    - name: "😞 ALK0030 ERROR: Unable to install the package"
+      run: |
+        log="💡 ALK0029 INFO: Install the GitHub package onto the server"
+        echo -e "\n$log" >> "$DEBUG_PATH"
+        alkiln-server-install --path="$ARTIFACT_FOLDER"
+    - name: "🤕 ALK0030 ERROR: Unable to install the package"
       if: ${{ inputs.INSTALL_METHOD == 'server' && failure() }}
       shell: bash
       run: |
-        echo -e "\n\n====\n😞 ALK0030 ERROR: Unable to install the package on the temporary GitHub docassemble server. Check the steps above this line.\n\n"
+        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"
 
     # run tests
     - name: "💡 ALK0031 INFO: Run tests"
@@ -136,20 +155,26 @@ runs:
       env:
         ALKILN_TAG_EXPRESSION: ${{ inputs.ALKILN_TAG_EXPRESSION || github.event.inputs.tags && format('{0}', github.event.inputs.tags) }}
       shell: bash
-      run: alkiln-run "$ALKILN_TAG_EXPRESSION"
+      run: |
+        log="💡 ALK0031 INFO: Run tests"
+        echo -e "\n$log" >> "$DEBUG_PATH"
+        alkiln-run "$ALKILN_TAG_EXPRESSION" --path="$ARTIFACT_FOLDER"
     
     # on playground, delete project
     - name: "💡 ALK0032 INFO: Delete the Project from the Playground"
       if: ${{ always() && inputs.INSTALL_METHOD == 'playground' }}
-      run: alkiln-takedown
       shell: bash
+      run: |
+        log="💡 ALK0032 INFO: Delete the Project from the Playground"
+        echo -e "\n$log" >> "$DEBUG_PATH"
+        alkiln-takedown --path="$ARTIFACT_FOLDER"
     
     # Upload artifacts that subscribers can download on the Actions summary page
     - name: "💡 ALK0033 INFO: Upload artifacts folder"
       if: ${{ always() }}
       uses: actions/upload-artifact@v4
       with:
-        name: ${{ env.ARTIFACT_NAME }}
+        name: ${{ env.ARTIFACT_FOLDER }}
         path: ./alkiln-*
 
     # Download artifacts folder internally to create action output
@@ -157,45 +182,56 @@ runs:
       if: ${{ always() }}
       uses: actions/download-artifact@v4
       with:
-        name: ${{ env.ARTIFACT_NAME }}
+        name: ${{ env.ARTIFACT_FOLDER }}
 
     - name: "💡 ALK0184 INFO: Prepare ALKiln output file paths"
       if: ${{ always() }}
       id: alkiln_outputs
       shell: bash
       run: |
-        # 💡 ALK0184 INFO: Prepare ALKiln output file paths
+        log="💡 ALK0184 INFO: Prepare ALKiln output file paths"
+        echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"
 
         FOLDER=$(ls -d */ | grep -E '^alkiln-*' || true)
 
-        echo "Test results artifacts folder is $FOLDER"
+        log_folder="Test results artifacts folder is $FOLDER"
+        echo -e "\n$log_folder" >> "$DEBUG_PATH" && echo "$log_folder"
 
         if [[ "$FOLDER" = "" ]]; then
-          echo "Artifacts folder is missing. The path is an empty string: '$FOLDER'"
+          log_missing="Artifacts folder is missing. The path is an empty string: '$FOLDER'"
+          echo -e "\n$log_missing" >> "$DEBUG_PATH" && echo "$log_missing"
 
         else
           REPORT_PATH="${FOLDER}report.txt"
+          REPORT_LOG_PATH="${FOLDER}report_log.txt"
           UNEXPECTED_RESULTS_PATH="${FOLDER}unexpected_results.txt"
           DEBUG_LOG_PATH="${FOLDER}debug_log.txt"
 
           if [ -f "$REPORT_PATH" ]; then
-            echo "$REPORT_PATH exists"
+            echo -e "\n$REPORT_PATH exists" >> "$DEBUG_PATH" && echo "$REPORT_PATH exists"
           else
-            echo "$REPORT_PATH is missing"
+            echo -e "\n$REPORT_PATH is missing" >> "$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"
+          else
+            echo -e "\n$REPORT_LOG_PATH is missing" >> "$DEBUG_PATH" && echo "$REPORT_LOG_PATH is missing"
+            REPORT_LOG_PATH=""
+          fi
+
           if [ -f "$UNEXPECTED_RESULTS_PATH" ]; then
-            echo "$UNEXPECTED_RESULTS_PATH exists"
+            echo -e "\n$UNEXPECTED_RESULTS_PATH exists" >> "$DEBUG_PATH" && echo "$UNEXPECTED_RESULTS_PATH exists"
           else
-            echo "$UNEXPECTED_RESULTS_PATH is missing"
+            echo -e "\n$UNEXPECTED_RESULTS_PATH is missing" >> "$DEBUG_PATH" && echo "$UNEXPECTED_RESULTS_PATH is missing"
             UNEXPECTED_RESULTS_PATH=""
           fi
 
           if [ -f "$DEBUG_LOG_PATH" ]; then
-            echo "$DEBUG_LOG_PATH exists"
+            echo -e "\n$DEBUG_LOG_PATH exists" >> "$DEBUG_PATH" && echo "$DEBUG_LOG_PATH exists"
           else
-            echo "$DEBUG_LOG_PATH is missing"
+            echo -e "\n$DEBUG_LOG_PATH is missing" >> "$DEBUG_PATH" && echo "$DEBUG_LOG_PATH is missing"
             DEBUG_LOG_PATH=""
           fi
 
@@ -203,6 +239,7 @@ runs:
 
         echo "PATH_TO_ARTIFACTS=$FOLDER" >> "$GITHUB_OUTPUT"
         echo "PATH_TO_REPORT_FILE=$REPORT_PATH" >> "$GITHUB_OUTPUT"
+        echo "PATH_TO_REPORT_LOG_FILE=$REPORT_LOG_PATH" >> "$GITHUB_OUTPUT"
         echo "PATH_TO_UNEXPECTED_RESULTS_FILE=$UNEXPECTED_RESULTS_PATH" >> "$GITHUB_OUTPUT"
         echo "PATH_TO_DEBUG_LOG_FILE=$DEBUG_LOG_PATH" >> "$GITHUB_OUTPUT"
 
@@ -212,4 +249,5 @@ runs:
     - shell: bash
       if: ${{ always() }}
       run: |
-        echo "💡 ALK0034 INFO: ALkiln finished running tests"
+        log="💡 ALK0034 INFO: ALkiln finished running tests. See above for more details."
+        echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"

package/action_for_github_server/action.yml

@@ -47,12 +47,25 @@ runs:
       # Place the root directory in this branch
       - uses: actions/checkout@v4
 
+      - shell: bash
+        if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
+        name: "💡 ALK0018 INFO: Get path names 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)"
+
+          echo "DEBUG_PATH=/tmp/alkiln_docker_logs-${timestamp}UTC.txt" >> "$GITHUB_ENV"
+          echo "GITHUB_SERVER_ARTIFACT_NAME=alkiln_github_server-${timestamp}UTC" >> "$GITHUB_ENV"
+          echo -e "$log" >> "$DEBUG_PATH"
+
       - shell: bash
         env:
           MAX_SECONDS_FOR_DOCKER: ${{ inputs.MAX_SECONDS_FOR_DOCKER }}
           DOCASSEMBLECLI_VERSION: ${{ inputs.DOCASSEMBLECLI_VERSION }}
         run: |
-          # 💡ALK0001 INFO: Set environment variables
+          log="💡ALK0001 INFO: Set environment variables"
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo "$log"
+
           echo "MAX_SECONDS_FOR_DOCKER=$MAX_SECONDS_FOR_DOCKER" >> $GITHUB_ENV
           echo "DOCASSEMBLECLI_VERSION=$DOCASSEMBLECLI_VERSION" >> $GITHUB_ENV
           echo "DA_ADMIN_API_KEY=abcd1234abcd1234abcd5678abdc5678" >> $GITHUB_ENV
@@ -63,7 +76,8 @@ runs:
         id: api_key_output_step
         shell: bash
         run: |
-          # 💡 ALK0002 INFO: Create GitHub step output variables
+          log="💡 ALK0002 INFO: Create GitHub step output variables"
+          echo -e "\n$log" >> "$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"
@@ -73,16 +87,20 @@ runs:
           CONFIG: ${{ inputs.CONFIG_CONTENTS }}
         shell: bash
         run: |
-          # 💡 ALK0003 INFO: Get config
+          log="💡 ALK0003 INFO: Get config"
+          echo -e "\n$log" >> "$DEBUG_PATH"
+
           mkdir /tmp/config
           # Worth making this silent by defining a variable with > /dev/null...?
           if [ -n "$CONFIG" ]
           then
-            echo "💡 ALK0004 INFO: The developer did provide a custom docassemble config file as an input into this action."
+            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 "$CONFIG" > /tmp/config/myconfig.yml
             echo "CONFIG_ARGS=--env DA_CONFIG=/tmp/config/myconfig.yml --volume /tmp/config:/tmp/config " >> $GITHUB_ENV
           else
-            echo "💡 ALK0005 INFO: The developer did NOT provide a custom docassemble config file as an input into this action. Docassemble will use its default config."
+            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 "CONFIG_ARGS=" >> $GITHUB_ENV
           fi
 
@@ -97,11 +115,14 @@ runs:
           SHOW_DOCKER_OUTPUT: ${{ inputs.SHOW_DOCKER_OUTPUT }}
         shell: bash
         run: |
-          # 💡 ALK0006 INFO: Determine docker logs visibility
+          log="💡 ALK0006 INFO: Determine docker logs visibility"
+          echo -e "\n$log" >> "$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"
           else
             echo "OUTPUT_DOCKER=false" >> $GITHUB_ENV
+            echo -e "\nfalse" >> "$DEBUG_PATH"
           fi
 
       # Messages about output
@@ -110,13 +131,15 @@ runs:
         shell: bash
         run: |
           # 💡 ALK0007 INFO: ALKiln will now hide docker output
-          echo -e '===\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==='
+          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"
       - name: "💡 ALK0008 INFO: ALKiln will show docker output"
         if: ${{ env.OUTPUT_DOCKER == 'true' }}
         shell: bash
         run: |
           # 💡 ALK0008 INFO: ALKiln will show docker output
-          echo -e '===\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==='
+          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"
 
       # TODO: Reduce these to 1 block by putting ` > /dev/null 2>&1` into an env var
       # No docker output
@@ -126,13 +149,14 @@ runs:
           CONFIG_ARGS: ${{ env.CONFIG_ARGS }}
         shell: bash
         run: |
-          # 💡 ALK0009 INFO: Download and start docker silently
+          log="💡 ALK0009 INFO: Download and start docker silently"
+          echo -e "\n$log" >> "$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
@@ -142,13 +166,14 @@ runs:
           CONFIG_ARGS: ${{ env.CONFIG_ARGS }}
         shell: bash
         run: |
-          # 💡 ALK0010 INFO: Download and start docker
+          log="💡 ALK0010 INFO: Download and start docker"
+          echo -e "\n$log" >> "$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
 
@@ -159,12 +184,14 @@ runs:
         shell: bash
         run: |
           # 💡 ALK0011 INFO: The following messages are not docker output
-          echo "💡 ALK0011 INFO: The following messages are not docker output, just ALKiln waiting for the server to start"
+          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"
 
       - name: "💡 ALK0012 INFO: Waiting for server to start"
         shell: bash
         run: |
-          # 💡 ALK0012 INFO: Waiting for server to start
+          log="💡 ALK0012 INFO: Waiting for server to start"
+          echo -e "\n$log" >> "$DEBUG_PATH"
 
           # Reset the SECONDS variable
           SECONDS=0
@@ -173,23 +200,28 @@ runs:
 
           response="start"
           while [[ $response != *"200"* ]]; do
-            echo "💡 ALK0013 INFO: Time elapsed: $SECONDS seconds"
+            log2="💡 ALK0013 INFO: Time elapsed: $SECONDS seconds"
+            echo -e "\n$log2" >> "$DEBUG_PATH" && echo -e "$log2"
 
             # Check if max seconds till loading has passed
             if [[ $SECONDS -ge $MAX_SECONDS_FOR_DOCKER ]]; then
-              echo "🤕 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."
+              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"
               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)
-            echo "💡 ALK0015 INFO: Response is $response"
+            log4="💡 ALK0015 INFO: Response is $response"
+            echo -e "\n$log4" >> "$DEBUG_PATH" && echo -e "$log4"
 
             # Check if the string includes the desired text
             if [[ $response == *"200"* ]]; then
-              echo "🌈 ALK0016 SUCCESS: Success! The docker container is ready!"
+              log5="💡 ALK0016 SUCCESS: Success! The docker container is ready!"
+              echo -e "\n$log5" >> "$DEBUG_PATH" && echo -e "$log5"
             else
-              echo "💡 ALK0017 INFO: The docker container is not ready yet. Will check again in 30 seconds."
+              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"
               sleep 30
             fi
 
@@ -219,32 +251,28 @@ runs:
 
       # Upload artifacts that devs can download on the Actions summary page
       # Only if the developer wants to get that info, though
-      - name: "💡 ALK0018 INFO: Get path names with date and time"
-        if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
-        shell: bash
-        run: |
-          # 💡 ALK0018 INFO: Get path names with date and time
-          echo "GITHUB_SERVER_LOG_FILE_NAME=/tmp/alkiln_docker_logs-$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)UTC.txt" >> $GITHUB_ENV
-          echo "GITHUB_SERVER_ARTIFACT_NAME=alkiln_github_server-$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)UTC" >> $GITHUB_ENV
       - name: "💡 ALK0019 INFO: Create docker artifact data"
         if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
         shell: bash
         run: |
-          # 💡 ALK0019 INFO: Create docker artifact data
-          echo "$(docker output docassemble_container)" > "${{ env.GITHUB_SERVER_LOG_FILE_NAME }}"
+          log="💡 ALK0019 INFO: Create docker artifact data"
+          echo -e "\n$log" >> "$DEBUG_PATH"
+          echo "$(docker output docassemble_container)" >> "${{ env.DEBUG_PATH }}"
       - name: "💡 ALK0020 INFO: Upload artifacts folder"
         if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
         uses: actions/upload-artifact@v4
         with:
           name: ${{ env.GITHUB_SERVER_ARTIFACT_NAME }}
-          path: ${{ env.GITHUB_SERVER_LOG_FILE_NAME }}
+          path: ${{ env.DEBUG_PATH }}
 
       - shell: bash
         if: ${{ success() }}
         run: |
-          echo "🌈 ALK0021 SUCCESS: ALKiln created the docker container and started the server!"
+          log="💡 ALK0021 SUCCESS: ALKiln created the docker container and started the server!"
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"
 
       - shell: bash
         if: ${{ failure() }}
         run: |
-          echo "🤕 ALK0022 ERROR: Something went wrong. See above for more details."
+          log="🤕 ALK0022 ERROR: Something went wrong. See above for more details."
+          echo -e "\n$log" >> "$DEBUG_PATH" && echo -e "$log"

package/docs/decisions/006_which_log_level_to_pick_2024_09_5.md

@@ -0,0 +1,46 @@
+# Which log levels to pick
+
+## Context and Problem Statement
+
+The log levels we're giving access to in Log are `success` (`info` with a special icon), `info`, `warn`, and `throw` (`error` and throw the error). Sometimes, like in the log file itself, we hard-code the icons and such. Those places have access to other levels, like `error`.
+
+We want to avoid distracting our users by logging errors everywhere, even when an error is what triggered the log. Does that hold true in the debug log? Successes can also be misleading about whether tests have passed or not.
+
+When picking the log level for a log, how do we know which level to choose?
+
+## Considered Options
+
+- Stay as true to technical behavior as possible.
+- Stay as clear to users as possible - use levels that will help users pay attention to what affects them.
+
+For example:
+
+`success`:
+  - Use whenever anything completes successfully.
+  - Only use for success of major operations.
+  - Use for every test success.
+  - Use for success of all the tests.
+`error`:
+- Always use `error` when an error happens.
+- Use `error` when an unexpected error happens.
+- Only use `error` for user-relevant errors.
+
+
+## Decision Outcome
+
+Distract the user as little as possible everywhere.
+
+`success`:
+  - Only log success once for success of all tests.
+  - Include the `success` icon in the Scenario "Passed" section of the report.
+`throw`:
+  - Use this level to throw errors for the user's tests (or our own internal tests).
+  - Use this if ALKiln itself needs to abort a test or the test suite.
+`error`:
+  - Avoid using `error` explicitly. Only the debug logs should use the `error` level, and only to record critical errors that come in with `throw`.
+`info`:
+  - Log expected errors as `info`. For example, the aborted promises when awaiting navigation.
+`warn`:
+  - Avoid using the word "error" in warnings if possible.
+  - Use `warn` in the console for messages the user should investigate.
+  - Use `warn` in the debug log for messages ALKiln devs might investigate if necessary. If the warning comes from non-critical unexpected behavior, do try to be clear about what happened, but also try to avoid using the word "error" if possible. E.g. "Skipped creating metadata for the logs" instead of "Error while creating metadata for the logs".

package/docs/decisions/adopt_architectural_decision_records.md

@@ -0,0 +1,58 @@
+# Document decisions
+
+## Context and Problem Statement
+
+What is a good way to avoid re-hashing old decisions, or to at least know why those decisions were made?
+
+## Considered Options
+
+- GitHub issues
+- GitHub discussions
+- Actual files in the repo
+
+Formats:
+- https://adr.github.io/madr
+
+
+## Decision Outcome
+
+Use in-repo .md files using the https://adr.github.io/madr format. We found keeping the data within the repo to be the most compelling factor.
+
+## Pros and Cons of the Options
+
+### GitHub issues
+
+Pros:
+
+- Easy to search.
+- Can add labels and such.
+- In one of the most common places to search.
+- Allows comments
+
+Cons:
+
+- Not actually in the repository, so any forks or clones would lose that info.
+- Comments can get confusing and hard to read.
+
+### GitHub discussions
+
+Pros:
+
+- Labels and such.
+- Probably easy to search?
+
+Cons:
+
+- A separate place from issues. Not everyone even knows those exist.
+- All the cons of GitHub issues
+
+### Actual files in the repo
+
+Pros:
+
+- They go everywhere the repo goes.
+
+Cons:
+
+- Probably not as searchable, though maybe we could institute a way to "label"/tag them.
+- Not very visible.

package/docs/decisions/detect_sign_in.md

@@ -0,0 +1,124 @@
+# Use response data to detect sign-in success
+
+## Context and Problem Statement
+
+What is a robust way to detect whether signing in worked or not?
+
+## Considered Options
+
+- Elements in the DOM.
+  - Use some class or ID that only the sign-in page has, so we can detect that a user is on a new page and succeeded.
+  - User-facing invalidation message elements in the DOM on failure.
+- URL change.
+- Response data.
+
+## Decision Outcome
+
+Use a change in the URL to detect sign-in navigation.
+
+## Pros and Cons of the Options
+
+### DOM
+
+Pros:
+
+- It can be easy to do with the tools we are using.
+
+Cons:
+
+- The DOM can, and has been, changed by docassemble and these kinds of changes are made pretty quietly so we find it hard to keep track of them.
+- It is pretty easy for site developers to change the HTML of standard pages like the sign-in page.
+
+### URL change
+
+Pros:
+
+- It seems very likely that developers will keep an unsuccessful sign-in on the same page, even if they change some other functionality.
+- It seems very likely that developers will change the url when the sign-in succeeds.
+- Sticking with checking the url would mesh with how we currently detecting page navigation. See the cons for issues with that.
+
+Cons:
+
+- It seems precarious, though I haven't yet been able to articulate why. I know it hasn't been a sufficient full solution in the past for interview pages. For example, in a `show if` infinite page loop.
+- Developers can manipulate a page's url, though it seems unlikely in this situation.
+
+### Response data
+
+Use the response data from the sign in request.
+
+Pros:
+
+- It seems reliable - it seems very likely that developers will re-direct their users to a different page, even if they change some other functionality.
+- Less likely to change than the DOM.
+- Has some standard values we can expect, like status codes.
+
+Cons:
+
+- DA's responses are not typical. There's no 400's in unsuccessful responses.
+- Regular interview page navigation doesn't get a 302, so this method would be a special case for signing in.
+
+Options are:
+
+- 302 redirection status. It seems fairly reliable that a developer will send a user to a different page after they sign in, and also likely that they will keep the user on the same page if the sign-in failed.
+- Cache-Control header value that contains "must-revalidate" (See [MDN cache control directives](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#directives)). It makes sure this data isn't cached. I'm not familiar with this and I'm not sure what might or might not trigger this.
+- Cookie with the name "secret". This seems promising, but I don't know much about cookies.
+
+Based on our current knowledge, we think the 302 status response will be most reliable.
+
+Notes for response data:
+
+I have isolated the differences between the sign-in success and failure responses.
+
+Key for following entries:
+
+```
+<key of object containing the data>
+  🌈 <sign in success data>
+vs
+  🤕 <sign in failure data>
+```
+
+Findings:
+
+```
+response
+  🌈 "redirectURL": "/path", "headersSize": 552, "bodySize": 0, "_transferSize": 552,
+vs
+  🤕 "redirectURL": "", "headersSize": 570, "bodySize": 1998, "_transferSize": 2568,
+---
+response
+  🌈 "status": 302, "statusText": "FOUND",
+vs
+  🤕 "status": 200, "statusText": "OK",
+
+---
+headers
+  🌈 no cache-control
+vs
+  🤕 { "name": "Cache-Control", "value": "no-store, no-cache, must-revalidate, post-check=0, pre-check=0, max-age=0" },
+---
+headers
+  🌈 { "name": "Content-Length", "value": "209" },
+vs
+  🤕 { "name": "Content-Encoding", "value": "gzip" },
+---
+headers
+  🌈 { "name": "Location", "value": "/interviews" },
+vs
+  🤕 no location
+---
+headers
+  🌈 { "name": "Set-Cookie", "value": "secret=secretchars; Secure; HttpOnly; Path=/; SameSite=Lax" },
+vs
+  🤕 no secret
+---
+headers
+  🌈 no transfer-encoding
+vs
+  🤕 { "name": "Transfer-Encoding", "value": "chunked" },
+---
+cookies
+  🌈 { "name": "secret", "value": "secretchars", "path": "/", "domain": "site.com", "expires": null, "httpOnly": true, "secure": true, "sameSite": "Lax" },
+vs
+  🤕 no secret
+```