According to the github action documentation, it should work in the same workflow using multiple paths.

If you also use the paths-filter action you can get to the result you want with something like this:

Example:

name: Trigger Jenkins Build [ Build-Portal ]
on:
  push:
    branches: [ develop ]
    paths: 
       - 'frontend/**'
       - 'backend/**'
    types: [closed]
jobs:
  build:
    name: Triggering Jenkins Build [ Build-Portal ]
    runs-on: ubuntu-latest
    if: github.event.pull_request.merged == true
    steps:
      - uses: dorny/paths-filter@v2
        id: changes
        with:
           filters: |
              backend:
                - 'backend/**'
              frontend:
                - 'frontend/**'
    - name: Trigger Build-Portal FRONTEND
      # run only if some file in 'frontend' folder was changed
      if: steps.changes.outputs.frontend == 'true'
      uses: actions/trigger-jenkins@develop
      with:
        ...
        job_name: "Build-Portal"
        job_params: '{"FRESH_BUILD":"True", "UI":"True", "BUILD_BRANCH":"develop", "DEPLOY_DEV":"True"}'
        ...
     - name: Trigger Build-Portal BACKEND
      # run only if some file not 'backend' folder was changed
      if: steps.changes.outputs.backend == 'true'
      uses: actions/trigger-jenkins@develop
      with:
        ...
        job_name: "Build-Portal"
        job_params: '{"FRESH_BUILD":"True", "API":"True", "BUILD_BRANCH":"develop", "DEPLOY_DEV":"True"}'
        ...

Workflow syntax for GitHub Actions - GitHub Docs

//docs.github.com/en/actions/reference/workflow-syntax-for-github-actions

Note: If you push more than 1,000 commits, or if GitHub does not generate the diff due to a timeout (diffs that are too large diffs), the workflow will always run.

(Amusingly, this isn’t an edge I’ve hit much. I do regularly hit the 250 commit limit.)

GitHub generates the list of changed files using two-dot diffs for pushes and three-dot diffs for pull requests:

• Pull requests: Three-dot diffs are a comparison between the most recent version of the topic branch and the commit where the topic branch was last synced with the base branch.
• Pushes to existing branches: A two-dot diff compares the head and base SHAs directly with each other.
• Pushes to new branches: A two-dot diff against the parent of the ancestor of the deepest commit pushed.

Hi raquelhortab,

When use action in the same repository as workflow, we need to add actions/checkout before running your local action. And you don’t need to add @master behind your action path.

Please see my example:

name: use my action
on: push
jobs:

my_first_job:

runs-on: ubuntu-latest

steps:

- uses: actions/checkout@v1

- name: My first step

uses: ./.github/actions/my-action

>> I fond it weird that the repository name got duplicated in the path (…/hello_world_github_actions/hello_world_github_actions/…).

For this question, the path is as expected. It is the default directory path .

Please refer to this document: https://help.github.com/en/actions/automating-your-workflow-with-github-actions/using-environment-variables

One reason could be that you're using your commands in the same step or run command.

Test with another run command:

name: Temp

on:
  workflow_dispatch:

jobs:
  testingPath:
    runs-on: ubuntu-latest
    steps:

      - name: Set Path
        run: |
          echo "/HolismHolding/Commands" >> $GITHUB_PATH
      
      - name: Get Path
        run: |
          echo $GITHUB_PATH

Quote from the docs

the currently running action cannot access the updated path variable.

The difference in the $PATH variable between your GitHub Actions workflow and your local terminal might be due to differences in the shell environment.

In a local terminal, the $PATH variable is often set in a shell configuration file like .bashrc, .bash_profile, or .zshrc. These files are loaded when you start a new shell session. The $PATH variable is used to define the directories where the system should look for executable files. Different configurations or initialization scripts can lead to different values of $PATH.

In a GitHub Actions workflow, especially when using SSH or other remote connection methods, the shell environment may be non-interactive, which means it doesn't load the same configuration files that your local interactive shell does. Instead, it may use system-wide or default environment settings.

Here are a few steps you can take to investigate and potentially resolve this issue:

Explicitly Set $PATH: In your GitHub Actions workflow, you can explicitly set the $PATH variable to match your local environment. For example, you can add the following command at the beginning of your workflow:

- name: Set PATH
  run: echo "export PATH=\$PATH:/usr/local/bin:/your/custom/path" >> $GITHUB_ENV

Replace :/usr/local/bin:/your/custom/path with the paths you want to include.

Check Shell Initialization Files: Review the shell initialization files on the remote server (e.g., .bashrc, .bash_profile, .zshrc) to see if any customizations to the $PATH are present. Modify these files as needed.

Interactive vs. Non-Interactive Shell: Ensure that any modifications to the $PATH are applied in both interactive and non-interactive shell sessions. Some shell configuration files are only loaded in interactive sessions, so you may need to make these changes more globally in your server environment settings.

Debug Output: Add debug output to your GitHub Actions workflow to print the $PATH variable and other environment information to help diagnose the differences:

- name: Debug Environment
  run: |
    echo "PATH: $PATH"
    echo "SHELL: $SHELL"
  shell: bash

This will allow you to see the values of these variables during your workflow run.

By following these steps, you can ensure that the $PATH variable in your GitHub Actions workflow matches your local environment and functions as expected.