apify-test-tools 0.9.1-beta.6 → 0.9.1-beta.7

package/.github/workflows/_move_major_tag.yaml

@@ -0,0 +1,100 @@
+name: Move major version tag
+
+# Consumer repos track a floating major tag (`...@v0`), not `master`, so merging to master does not
+# ship anything by itself. This workflow is what ships: it moves that tag forward, but only once the
+# package version the workflows pin in .github/workflows-package-version is actually on npm.
+#
+# That gate is the whole point. The workflows and the npm package release on their own schedules, so
+# the only combination that can break consumers is a workflow that calls a CLI feature which has not
+# been published yet. In that case the tag simply stays where it is and production keeps running the
+# previous workflows until someone cuts a release.
+
+on:
+    workflow_call:
+        inputs:
+            ref:
+                description: Commit to move the tag to. Defaults to the commit that triggered the caller.
+                type: string
+                default: ''
+
+permissions:
+    contents: read
+
+concurrency:
+    group: move-major-tag
+    cancel-in-progress: false
+
+jobs:
+    move_major_tag:
+        name: Move major version tag
+        runs-on: ubuntu-latest
+        permissions:
+            contents: write
+        env:
+            # The major version consumers pin, e.g.
+            # `uses: apify/apify-test-tools/.github/workflows/public_pr-build-test.yaml@v0`.
+            # Bump this only for a breaking change to a workflow's inputs, secrets or behaviour.
+            # The previous tag then stops moving and keeps working, so repos migrate when they get
+            # to it instead of all at once.
+            #
+            # This tracks the workflows' own contract, not the npm package version — the two move
+            # independently by design, so `v0` here is expected to outlive the package reaching 1.0.
+            # `uses:` cannot take an expression, so every ref into this repo hardcodes this same tag;
+            # check-major-tag-refs.mjs fails the build if one of them drifts.
+            MAJOR_TAG: v0
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v6
+              with:
+                  ref: ${{ inputs.ref || github.sha }}
+
+            - name: Check the required package version is published
+              id: check
+              run: |
+                  pinned_version=$(cat .github/workflows-package-version)
+                  echo "pinned_version=$pinned_version" >> "$GITHUB_OUTPUT"
+
+                  # The publish that satisfies a pin bump can still be in flight when this runs, so
+                  # give it a short grace period before deciding the tag has to stay put.
+                  for attempt in 1 2 3 4 5 6; do
+                      if npm view "apify-test-tools@$pinned_version" version >/dev/null 2>&1; then
+                          echo "apify-test-tools@$pinned_version is on npm"
+                          echo "published=true" >> "$GITHUB_OUTPUT"
+                          exit 0
+                      fi
+                      echo "apify-test-tools@$pinned_version is not on npm yet (attempt $attempt/6)"
+                      if [ "$attempt" -lt 6 ]; then sleep 20; fi
+                  done
+                  echo "published=false" >> "$GITHUB_OUTPUT"
+
+            - name: Move tag
+              if: steps.check.outputs.published == 'true'
+              env:
+                  TARGET_SHA: ${{ inputs.ref || github.sha }}
+              run: |
+                  git tag -f "$MAJOR_TAG" "$TARGET_SHA"
+                  git push -f origin "refs/tags/$MAJOR_TAG"
+                  {
+                      echo "### \`$MAJOR_TAG\` moved"
+                      echo
+                      echo "Now points at \`$TARGET_SHA\`."
+                      echo "Pins \`apify-test-tools@${{ steps.check.outputs.pinned_version }}\`, which is published."
+                  } >> "$GITHUB_STEP_SUMMARY"
+
+            # Not a failure. Holding the tag is the designed outcome of merging a workflow change
+            # that needs an unreleased package feature, and consumers are unaffected while it waits.
+            - name: Report held tag
+              if: steps.check.outputs.published != 'true'
+              env:
+                  TARGET_SHA: ${{ inputs.ref || github.sha }}
+              run: |
+                  {
+                      echo "### \`$MAJOR_TAG\` held"
+                      echo
+                      echo "\`$TARGET_SHA\` pins \`apify-test-tools@${{ steps.check.outputs.pinned_version }}\`, which is not on npm."
+                      echo "Consumers keep running the workflows \`$MAJOR_TAG\` already points at."
+                      echo
+                      echo "Publish that version with the **Stable release** workflow. The tag moves on the"
+                      echo "next master push, or immediately via the **Move major version tag** workflow."
+                  } >> "$GITHUB_STEP_SUMMARY"
+                  echo "::warning::$MAJOR_TAG not moved: apify-test-tools@${{ steps.check.outputs.pinned_version }} is not published yet."

package/.github/workflows/_update_release_metadata.yaml

@@ -77,6 +77,18 @@ jobs:
                   write-mode: overwrite
                   contents: ${{ needs.release_metadata.outputs.changelog }}
 
+            # The reusable workflows install this exact version, so the commit that releases a
+            # version is the commit that pins it. That is what lets a frozen major tag keep
+            # installing the library it was tested against instead of drifting to whatever is
+            # newest.
+            #
+            # Skipped for prereleases: master pushes release a `-beta` that consumer repos must
+            # never install. Their pin stays on the last stable, and the beta stays reachable
+            # through the lockfile path in the setup action, which is how branch testing works.
+            - name: Update the version the workflows pin
+              if: inputs.release_type != 'prerelease'
+              run: echo "${{ needs.release_metadata.outputs.version_number }}" > .github/workflows-package-version
+
             - name: Commit changes
               id: commit
               uses: apify/actions/signed-commit@v1.0.0

package/.github/workflows/manual_move_major_tag.yaml

@@ -0,0 +1,26 @@
+name: Move major version tag
+
+# Escape hatch for the two cases the automatic move does not cover: shipping a workflow change right
+# after the release that unblocked it, without waiting for the next master push, and rolling the tag
+# back to an earlier commit when a shipped workflow turns out to be broken.
+
+on:
+    workflow_dispatch:
+        inputs:
+            ref:
+                description: Commit, branch or tag to move the major tag to (defaults to master)
+                required: false
+                type: string
+                default: ''
+
+permissions:
+    contents: read
+
+jobs:
+    move_major_tag:
+        name: Move major version tag
+        permissions:
+            contents: write
+        uses: ./.github/workflows/_move_major_tag.yaml
+        with:
+            ref: ${{ inputs.ref }}

package/.github/workflows/manual_release_stable.yaml

@@ -79,3 +79,15 @@ jobs:
                           "ref": "${{ needs.release_metadata.outputs.changelog_commitish }}",
                           "tag": "latest"
                       }
+
+    # This release is what unblocks a major tag being held for an unpublished package version, so
+    # try the move again now rather than making someone wait for the next master push. A no-op when
+    # the tag was not being held.
+    move_major_tag:
+        name: Move major version tag
+        needs: [release_metadata, npm_publish]
+        permissions:
+            contents: write
+        uses: ./.github/workflows/_move_major_tag.yaml
+        with:
+            ref: ${{ needs.release_metadata.outputs.changelog_commitish }}

package/.github/workflows/on_master.yaml

@@ -25,6 +25,17 @@ jobs:
         name: Tests
         uses: ./.github/workflows/_tests.yaml
 
+    # Ships any workflow change in this push to consumer repos. Deliberately independent of the npm
+    # release below: a workflow-only change needs no release, and a package-only release leaves the
+    # workflows byte-identical. `code_checks` runs actionlint, which is what validates the workflows;
+    # `tests` covers the npm package and is skipped for docs commits, so it is not a dependency here.
+    move_major_tag:
+        name: Move major version tag
+        needs: [code_checks]
+        permissions:
+            contents: write
+        uses: ./.github/workflows/_move_major_tag.yaml
+
     release_metadata:
         if: >-
             startsWith(github.event.head_commit.message, 'feat') ||

package/.github/workflows/on_pull_request.yaml

@@ -21,3 +21,51 @@ jobs:
     tests:
         name: Tests
         uses: ./.github/workflows/_tests.yaml
+
+    # Catches the one combination that breaks consumers: a workflow starting to use a CLI feature
+    # from the same PR. Merging ships the workflow immediately, so the pinned version has to move in
+    # the same change or the workflow goes live calling something that is not published.
+    package_version_bump_needed:
+        name: Package version bump needed
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v6
+              with:
+                  fetch-depth: 0
+                  ref: ${{ github.event.pull_request.head.sha }}
+
+            - name: Check whether this PR needs a version bump
+              env:
+                  BASE_REF: ${{ github.base_ref }}
+                  PR_LABELS: ${{ join(github.event.pull_request.labels.*.name, ',') }}
+              run: |
+                  git fetch --no-tags origin "$BASE_REF"
+                  git diff --name-only FETCH_HEAD...HEAD | node .github/scripts/check-package-version-bump.mjs
+
+    # Reports whether merging this PR will ship the workflows or hold the major tag until a release.
+    # Never fails: pinning a version ahead of the release that publishes it is a supported way to
+    # land the package change and the workflow change that needs it in one PR.
+    workflows_package_version:
+        name: Workflows package version
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v6
+
+            - name: Check the pinned package version is published
+              run: |
+                  pinned_version=$(cat .github/workflows-package-version)
+                  if npm view "apify-test-tools@$pinned_version" version >/dev/null 2>&1; then
+                      echo "Workflows pin apify-test-tools@$pinned_version, which is published."
+                      echo "The major tag moves on merge and these workflows go live." >> "$GITHUB_STEP_SUMMARY"
+                  else
+                      {
+                          echo "### Major tag will be held on merge"
+                          echo
+                          echo "These workflows pin \`apify-test-tools@$pinned_version\`, which is not on npm yet."
+                          echo "Merging is fine: consumers keep running the current workflows until you cut a"
+                          echo "stable release, and the tag moves once that version is published."
+                      } >> "$GITHUB_STEP_SUMMARY"
+                      echo "::notice::Merging will not ship these workflows until apify-test-tools $pinned_version is released."
+                  fi

package/.github/workflows/public_claude.yaml

@@ -0,0 +1,101 @@
+name: Claude Code
+
+on:
+    workflow_call:
+        inputs:
+            model:
+                default: sonnet
+                type: string
+                description: Model to use for Claude Code (best, sonnet, opus, haiku, sonnet[1m], opus[1m], opusplan)
+                required: false
+            extra_allowed_tools:
+                default: ''
+                type: string
+                description: Comma-separated list of additional tool patterns to append to --allowedTools (e.g. "Bash(npm run e2e),Bash(npm run typecheck)")
+                required: false
+        secrets:
+            ANTHROPIC_API_KEY:
+                required: true
+                description: Claude API key
+
+jobs:
+    claude:
+        runs-on: ubuntu-latest
+        permissions:
+            contents: write
+            pull-requests: write
+            issues: write
+            id-token: write
+            actions: read
+        if: |
+            (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+            (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+            (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+            (github.event_name == 'pull_request_review' && github.event.review.state == 'changes_requested' && github.event.pull_request.user.login == 'claude[bot]') ||
+            (github.event_name == 'issues' && github.event.action == 'labeled' && github.event.label.name == 'claude' && !contains(github.event.issue.labels.*.name, 'claude:done')) ||
+            (github.event_name == 'issues' && github.event.action != 'labeled' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v6
+              with:
+                  fetch-depth: 1
+
+            - name: Compute allowed tools
+              id: tools
+              env:
+                  EXTRA_ALLOWED_TOOLS: ${{ inputs.extra_allowed_tools }}
+              run: |
+                  BASE_TOOLS="Bash(gh pr*),Bash(gh api*),Bash(gh issue*),Bash(npm ci)"
+                  if [ -n "$EXTRA_ALLOWED_TOOLS" ]; then
+                      ALLOWED_TOOLS="${BASE_TOOLS},${EXTRA_ALLOWED_TOOLS}"
+                  else
+                      ALLOWED_TOOLS="${BASE_TOOLS}"
+                  fi
+                  echo "allowed_tools=${ALLOWED_TOOLS}" >> "$GITHUB_OUTPUT"
+
+            - name: Compute PR instruction
+              id: pr_instruction
+              env:
+                  EVENT_NAME: ${{ github.event_name }}
+                  IS_PR_COMMENT: ${{ github.event_name == 'issue_comment' && github.event.issue.pull_request != null }}
+              run: |
+                  if [ "$EVENT_NAME" = "pull_request_review_comment" ] || [ "$EVENT_NAME" = "pull_request_review" ] || [ "$IS_PR_COMMENT" = "true" ]; then
+                      INSTRUCTION="After completing the requested changes, push them to the existing pull request's branch. Do not open a new pull request."
+                  else
+                      INSTRUCTION="After completing the requested changes, always open a pull request with your work. Do not just push commits or leave a comment without opening a PR."
+                  fi
+                  echo "instruction=${INSTRUCTION}" >> "$GITHUB_OUTPUT"
+
+            - name: Run Claude Code
+              id: claude
+              uses: anthropics/claude-code-action@v1
+              with:
+                  anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+                  track_progress: true
+                  use_commit_signing: true
+                  claude_args: |
+                      --model "${{ inputs.model }}"
+                      --allowedTools "${{ steps.tools.outputs.allowed_tools }}"
+                      --append-system-prompt "${{ steps.pr_instruction.outputs.instruction }}"
+
+            - name: Mark issue as processed by Claude
+              if: |
+                  github.event_name == 'issues' &&
+                  github.event.action == 'labeled' &&
+                  github.event.label.name == 'claude' &&
+                  steps.claude.conclusion == 'success'
+              uses: actions/github-script@v7
+              with:
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  script: |
+                      try {
+                          await github.rest.issues.addLabels({
+                              owner: context.repo.owner,
+                              repo: context.repo.repo,
+                              issue_number: context.issue.number,
+                              labels: ['claude:done']
+                          });
+                          console.log('Label claude:done added to issue.');
+                      } catch (e) {
+                          console.log('Label claude:done does not exist. Skipping.');
+                      }

package/.github/workflows/public_platform-tests-claude-investigate-and-fix.yaml

@@ -0,0 +1,208 @@
+name: 'Platform tests: Claude failure investigation and fix'
+
+# Notion page docs: https://app.notion.com/p/apify/374f39950a2280d99c89f27fc9fb49c5
+
+# Reusable workflow that uses Claude Code to investigate a failing E2E platform test and
+# attempt an automated fix.
+#
+# Two-phase execution:
+#   1. investigate: Claude reviews test logs, recent workflow history, and existing issues,
+#      then opens a GitHub issue with its findings. Skips silently if a duplicate exists.
+#      On success, adds a "claude" label to the issue for visibility.
+#   2. fix: Runs only when investigate created a new issue. Claude reads the issue,
+#      implements a fix, and opens a PR. On success, adds a "claude:done" label to the issue.
+#
+# Note: this workflow is intended to be called from a scheduled workflow. Scheduled runs use
+# GITHUB_TOKEN with reduced permissions that cannot trigger other workflow runs. For this reason
+# the PR phase is chained as a direct job dependency rather than relying on a label-based trigger.
+#
+# Example usage:
+#
+# jobs:
+#     platformTestsCore:
+#         uses: apify/apify-test-tools/.github/workflows/public_platform-tests.yaml@v0
+#         with:
+#             subtest: core
+#         secrets: inherit
+#
+#     handle-failure:
+#         needs: platformTestsCore
+#         if: ${{ failure() }}
+#         uses: apify/apify-test-tools/.github/workflows/public_platform-tests-claude-investigate-and-fix.yaml@v0
+#         secrets: inherit
+
+on:
+    workflow_call:
+        inputs:
+            model:
+                required: false
+                type: string
+                default: sonnet
+                description: Claude model to use for investigation and fix
+            investigate_prompt:
+                required: false
+                type: string
+                default: |
+                    Investigate the failing E2E platform test and open a GitHub issue documenting your findings. Start by reviewing the test logs, error messages, and recent workflow run history to determine the root cause.
+
+                    The failure will typically fall into one of these categories:
+                    - Flaky test: The test is non-deterministic or depends on timing/external state and fails intermittently. Check past workflow runs to see if this test has failed before.
+                    - Real bug: Genuine broken functionality — either a pre-existing issue or an environment/dependency change outside the codebase (e.g. a website changed its structure, an external API changed behavior).
+
+                    Use available tools to check previous workflow runs, git history, and existing GitHub issues to gather context and avoid creating duplicate issues. For deeper context,
+                    use tools to investigate the run on Apify platform, review its logs, datasets, key-value stores.
+
+                    Look specifically for debug traces, not just the top-level error:
+                    - Debug snapshots: often stored as a field on dataset items (e.g. `_debugSnapshots`) or as records in a key-value store, keyed so they can be matched to the log line for the failing request.
+                    - Any other debug artifacts the Actor produced (extra logs, error/state fields on output items) that narrow down the failing request.
+
+                    When you create the issue, write it like an incident postmortem: a short summary and impact up top for anyone skimming, full technical detail below for whoever fixes it. Don't water down the engineering detail to make the top readable.
+                    - Title: short and clean, describing the actual problem in plain terms — no dates, run numbers, or other noise. Prefix it with a conventional-commit-style type, e.g. "fix: blocking issue on detail endpoint".
+                    - Body, section 1 ("## Summary"): one line stating what's broken plus its impact, in plain language a PM can understand at a glance — no jargon, internal field names, or stack traces (e.g. "Scraping product detail pages fails when a listing has no reviews, affecting N% of runs").
+                    - A `---` divider, then section 2 ("## Details"): the engineering bug report — root cause, relevant log lines, links to the failing run, and any other internals an engineer needs. If a single item/request failed among otherwise-good ones, show or link that specific one (e.g. the dataset item index/id, or its matching debug snapshot) rather than just describing the run as failed.
+
+                    If you create a new issue, you MUST write its issue number (just the number, nothing else) to $GITHUB_WORKSPACE/issue-number.txt as the very last thing you do. If you skip creating one because a duplicate already exists, do not create the file.
+                description: Prompt given to Claude for the investigation phase. Override to customize how issues are investigated, titled, and described.
+        secrets:
+            ANTHROPIC_API_KEY:
+                required: true
+                description: Claude API key
+            TESTER_APIFY_TOKEN_READ_ONLY:
+                required: true
+                description: Apify token used only for read-only investigation — reading the failing run, its log and its storages.
+
+jobs:
+    investigate:
+        runs-on: ubuntu-latest
+        permissions:
+            contents: write
+            pull-requests: read
+            issues: write
+            actions: read
+        outputs:
+            issue_number: ${{ steps.issue.outputs.number }}
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v5
+
+            - name: Run Claude Code
+              id: claude
+              uses: anthropics/claude-code-action@8251c103ac8c1d761882c86aba1412c7f583c844 # v1.0.213
+              env:
+                  TESTER_APIFY_TOKEN_READ_ONLY: ${{ secrets.TESTER_APIFY_TOKEN_READ_ONLY }}
+              with:
+                  prompt: |
+                      The failing E2E platform test ran in workflow run ${{ github.run_id }} of this repo.
+
+                      ${{ inputs.investigate_prompt }}
+                  github_token: ${{ secrets.GITHUB_TOKEN }}
+                  anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+                  # The `tools` query parameter below selects which tools the Apify MCP server
+                  # exposes: reading an Actor run — its status, exit code, storage ids and log — and
+                  # reading that run's dataset items and its key-value store keys and records, e.g.
+                  # INPUT, OUTPUT and error snapshots. WARN: the server adds `abort-actor-run` on top
+                  # even when not listed here, see https://github.com/apify/apify-mcp-server
+                  claude_args: |
+                      --mcp-config '{"mcpServers":{"apify":{"type":"http","url":"https://mcp.apify.com/?tools=get-actor-run,get-actor-log,get-dataset-list,get-dataset,get-dataset-items,get-key-value-store-list,get-key-value-store,get-key-value-store-keys,get-key-value-store-record","headers":{"Authorization":"Bearer ${TESTER_APIFY_TOKEN_READ_ONLY}"}}}}'
+                      --model ${{ inputs.model }}
+                      --dangerously-skip-permissions
+
+            - name: Upload Claude output (for debugging)
+              if: always()
+              uses: actions/upload-artifact@v6
+              with:
+                  name: claude-output-investigate
+                  path: /home/runner/work/_temp/claude-execution-output.json
+
+            - name: Read created issue
+              id: issue
+              # Claude writes the issue number to a file because there is no direct way to pass
+              # structured output from a Claude Code action step to subsequent steps.
+              run: |
+                  if [ -f "$GITHUB_WORKSPACE/issue-number.txt" ]; then
+                      ISSUE_NUMBER=$(cat "$GITHUB_WORKSPACE/issue-number.txt")
+                      echo "number=$ISSUE_NUMBER" >> "$GITHUB_OUTPUT"
+                      echo "Issue created: #$ISSUE_NUMBER"
+                  else
+                      echo "number=" >> "$GITHUB_OUTPUT"
+                      echo "No issue created (duplicate skipped)"
+                  fi
+
+            # Adds the "claude" label for visibility. Normally this would trigger the claude.yaml
+            # workflow, but scheduled runs lack the permissions to trigger other workflows, so the
+            # PR phase is driven by the fix job dependency instead.
+            - name: Add Claude label to issue
+              if: steps.issue.outputs.number != ''
+              uses: actions/github-script@v7
+              with:
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  script: |
+                      try {
+                          await github.rest.issues.createLabel({
+                              owner: context.repo.owner,
+                              repo: context.repo.repo,
+                              name: "claude",
+                              color: "d93f0b",
+                          });
+                      } catch (e) {
+                          // Label already exists
+                      }
+
+                      await github.rest.issues.addLabels({
+                          owner: context.repo.owner,
+                          repo: context.repo.repo,
+                          issue_number: parseInt('${{ steps.issue.outputs.number }}'),
+                          labels: ["claude"],
+                      });
+
+    fix:
+        needs: investigate
+        if: needs.investigate.outputs.issue_number != ''
+        runs-on: ubuntu-latest
+        permissions:
+            contents: write
+            pull-requests: write
+            issues: write
+            id-token: write
+            actions: read
+        steps:
+            - name: Checkout repository
+              uses: actions/checkout@v5
+
+            - name: Run Claude Code
+              id: claude
+              uses: anthropics/claude-code-action@8251c103ac8c1d761882c86aba1412c7f583c844 # v1.0.213
+              with:
+                  anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+                  use_commit_signing: true
+                  prompt: 'Open a pull request to address GitHub issue #${{ needs.investigate.outputs.issue_number }}. Use `gh issue view ${{ needs.investigate.outputs.issue_number }}` to read the issue details first, then implement the fix and create a PR.'
+                  claude_args: |
+                      --model ${{ inputs.model }}
+                      --dangerously-skip-permissions
+
+            - name: Upload Claude output (for debugging)
+              if: always()
+              uses: actions/upload-artifact@v6
+              with:
+                  name: claude-output-fix
+                  path: /home/runner/work/_temp/claude-execution-output.json
+
+            # Adds "claude:done" to the issue to signal that a fix PR was opened. Pure status
+            # tracking — does not trigger any further automation.
+            - name: Mark issue as processed by Claude
+              if: steps.claude.conclusion == 'success'
+              uses: actions/github-script@v7
+              with:
+                  github-token: ${{ secrets.GITHUB_TOKEN }}
+                  script: |
+                      try {
+                          await github.rest.issues.addLabels({
+                              owner: context.repo.owner,
+                              repo: context.repo.repo,
+                              issue_number: parseInt('${{ needs.investigate.outputs.issue_number }}'),
+                              labels: ['claude:done']
+                          });
+                          console.log('Label claude:done added to issue.');
+                      } catch (e) {
+                          console.log('Label claude:done does not exist. Skipping.');
+                      }

package/.github/workflows/public_platform-tests.yaml

@@ -0,0 +1,75 @@
+name: Platform tests
+
+on:
+    workflow_call:
+        inputs:
+            # Deprecated, use `test-files-glob`
+            subtest:
+                type: string
+                default: ''
+                required: false
+            # Specify what tests you want to run, relative to `test/platform`
+            test-files-glob:
+                type: string
+                default: ''
+                required: false
+            working-directory:
+                type: string
+                default: .
+                required: false
+            additional-working-directory:
+                type: string
+                required: false
+            # Defaults to #notif-<repo-name> when empty, matching the previous behavior.
+            report-slack-channel:
+                type: string
+                default: ''
+                required: false
+
+jobs:
+    scheduledPlatformTests:
+        name: Scheduled Platform tests
+        if: github.ref == 'refs/heads/master' || github.ref == 'refs/heads/main'
+        runs-on: ubuntu-latest
+        defaults:
+            run:
+                working-directory: ${{ inputs.working-directory }}
+        steps:
+            - name: Setup repository and dependencies
+              # For testing, you have to temporarily change the branch
+              uses: apify/apify-test-tools/.github/actions/checkout-restore-dependencies@v0
+              with:
+                  working-directory: ${{ inputs.working-directory }}
+                  additional-working-directory: ${{ inputs.additional-working-directory }}
+                  npm-token: ${{ secrets.NPM_TOKEN }}
+
+            - name: Test
+              env:
+                  TESTER_APIFY_TOKEN: ${{ secrets.TESTER_APIFY_TOKEN }}
+                  SLACK_TOKEN_TESTS_BOT: ${{ secrets.SLACK_TOKEN_TESTS_BOT }}
+              run: |
+                  set +e
+                  export RUN_ALL_PLATFORM_TESTS=1
+                  npx vitest ./test/platform/${{ inputs.test-files-glob || inputs.subtest }} \
+                    --run \
+                    --reporter=default \
+                    --reporter=json \
+                    --outputFile=./test-output.json \
+                    --maxConcurrency 20 \
+                    --fileParallelism=true \
+                    --maxWorkers 100
+                  return_code=$?
+                  npx apify-test-tools report-tests \
+                    --report-file ./test-output.json \
+                    --workspace . \
+                    --workflow-name "${{ github.workflow }}" \
+                    --job-url "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" \
+                    --report-slack-channel "${{ inputs.report-slack-channel || format('#notif-{0}', github.event.repository.name) }}"
+                  exit $return_code
+
+            - name: Upload Vitest JSON artifact
+              uses: actions/upload-artifact@v6
+              if: always()
+              with:
+                  name: vitest-results
+                  path: ./test-output.json