feat: Add custom GitHub Actions to a separate repository (#1)

I was adding the usage of our custom GitHub Actions to a lot of
repositories, and it felt confusing that actions live in a repository
called `workflows`.

I've moved them to this new repository which will contain just actions,
so that you can use them as it would make sense, e.g.:
```yaml
  - name: Commit to a new branch
    uses: apify/actions/signed-commit@v1.0.0
    with:
      commit-message: "chore: add greeting"
```

I've also done some changes to simplify the setup:
- I've rewritten the `execute-workflow` action to use a composite action
using `github-script`, so that it doesn't need to be compiled (since
`github-script` can run TypeScript files natively)
- I've renamed the `commit` action to `signed-commit` to make it clearer
why it's used just from the name

After this is merged, I will replace all the relevant usages of
`apify/workflows` in other repositories with `apify/actions` and then
delete the custom actions from the `workflows` repository.

Author: fnesveda

.editorconfig

@@ -0,0 +1,14 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+end_of_line = lf
+# editorconfig-tools is unable to ignore longs strings or urls
+max_line_length = null
+
+[{*.yaml,*.yml,*.json}]
+indent_size = 2

.github/workflows/checks.yaml

@@ -0,0 +1,39 @@
+name: Lint and test actions
+
+on:
+  workflow_dispatch:
+
+  push:
+    branches:
+      - '**'
+    tags-ignore:
+      - '**'
+
+jobs:
+  test_actions:
+    runs-on: ubuntu-22.04-arm64
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v6
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version-file: '.nvmrc'
+          check-latest: true
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v6
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile --ignore-scripts
+
+      - name: Lint
+        run: pnpm run lint
+
+      - name: Typecheck
+        run: pnpm run type-check
+
+      - name: Test
+        run: pnpm run test
+

.github/workflows/release.yaml

@@ -0,0 +1,22 @@
+# This workflow creates new github release and updates changelog
+name: release new version
+
+permissions:
+  contents: write
+  pull-requests: write
+
+on:
+  workflow_dispatch:
+
+  push:
+    branches:
+      - main
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - name: release-please
+        uses: googleapis/release-please-action@v4
+        with:
+          release-type: simple

.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+.idea
+.vscode
+.venv
+.mise.toml
+.mypy_cache
+node_modules/
+*.tsbuildinfo

.nvmrc

@@ -0,0 +1 @@
+24

README.md

@@ -0,0 +1,9 @@
+# Apify GitHub Actions
+
+This repository contains reusable GitHub Actions used in internal Apify projects.
+
+## How to release new version
+
+1. Create a PR. **IMPORTANT: Avoid using the `chore:` prefix, as it doesn't work with RELEASE-PLEASE. Use `feat:` or `fix:` instead.**
+2. Merge PR into the main branch after approval. This triggers an automated workflow that generates a new PR for the release using the RELEASE-PLEASE action.
+3. Navigate to the PR and merge it into the main branch. This will publish the release with an updated changelog.

execute-workflow/README.md

@@ -0,0 +1,30 @@
+# Execute Workflow Action
+
+A GitHub Action for triggering workflows via `workflow_dispatch`, waiting for them to complete, and reporting their results.
+
+- Triggers workflows using the `workflow_dispatch` event
+- Waits for the workflow run to start (up to 60 seconds)
+- Polls the workflow run status until completion
+- Outputs the workflow run ID and conclusion
+- Fails the action if the triggered workflow doesn't succeed
+
+## Usage
+
+```yaml
+- name: Execute workflow
+  uses: ./execute-workflow
+  with:
+      workflow: my-workflow.yaml
+      inputs: '{ "key": "value" }'
+```
+
+## Inputs
+
+- `workflow` (required): Workflow filename relative to `.github/workflows` (e.g., `my-workflow.yaml`)
+- `inputs` (optional): Inputs to pass to the workflow as a JSON string
+- `token` (optional): GitHub token for authentication (defaults to `${{ github.token }}`)
+
+## Outputs
+
+- `workflowRunId`: The ID of the triggered workflow run
+- `conclusion`: The conclusion of the workflow run (`success`, `failure`, `cancelled`, etc.)

execute-workflow/action.yaml

@@ -0,0 +1,30 @@
+name: 'Execute Workflow'
+description: 'Execute GitHub Actions workflows and wait for them to complete'
+
+inputs:
+  workflow:
+    description: "Workflow filename relative to .github/workflows (e.g., 'my-workflow.yaml')"
+    required: true
+  inputs:
+    description: 'Inputs to pass to the workflow, must be a JSON string'
+    required: false
+  token:
+    description: 'GitHub token for authentication'
+    required: false
+    default: ${{ github.token }}
+
+runs:
+  using: composite
+  steps:
+    - name: Execute workflow
+      uses: actions/github-script@v8
+      with:
+        github-token: ${{ inputs.token }}
+        script: |
+          const { main } = require('${{ github.action_path }}/index.mts');
+
+          await main({
+              github,
+              context,
+              core,
+          });

execute-workflow/index.mts

@@ -0,0 +1,127 @@
+import type * as Core from '@actions/core';
+import { type Octokit } from '@octokit/rest';
+import { type context as Context } from '@actions/github';
+
+import * as PackageJSON from '../package.json' with { type: 'json' };
+
+type Workflow = {
+    id: number;
+    name: string;
+    path: string;
+};
+
+type WorkflowRun = {
+    id: number;
+    status: string;
+    conclusion: string | null;
+    html_url: string;
+};
+
+export async function main({ github, context, core }: { github: Octokit, context: typeof Context, core: typeof Core }) {
+    core.info(`🏃 Execute Workflow Action v${PackageJSON.version}`);
+    try {
+        const workflowFileName = core.getInput('workflow');
+
+        const inputsJson = core.getInput('inputs');
+        const inputs = inputsJson ? JSON.parse(inputsJson) : {};
+
+        const { owner, repo } = context.repo;
+        const { ref } = context;
+
+        const workflows: Workflow[] = await github.paginate(
+            github.rest.actions.listRepoWorkflows.endpoint.merge({
+                owner,
+                repo,
+            }),
+        );
+
+        const workflowPath = `.github/workflows/${workflowFileName}`;
+        const foundWorkflow = workflows.find((workflow) => workflow.path === workflowPath);
+
+        if (!foundWorkflow) throw new Error(`Unable to find workflow '${workflowPath}' in ${owner}/${repo} 😥`);
+
+        core.info(
+            `🔎 Found workflow, id: ${foundWorkflow.id}, name: ${foundWorkflow.name}, path: ${foundWorkflow.path}`,
+        );
+
+        // Get current workflow runs before dispatching
+        const runsBefore = await github.rest.actions.listWorkflowRuns({
+            owner,
+            repo,
+            workflow_id: foundWorkflow.id,
+            per_page: 5,
+        });
+
+        // Call workflow_dispatch API
+        core.info('🚀 Calling GitHub API to dispatch workflow...');
+        await github.request(`POST /repos/${owner}/${repo}/actions/workflows/${foundWorkflow.id}/dispatches`, {
+            ref,
+            inputs,
+        });
+
+        // Wait for the new run to appear
+        core.info('⏳ Waiting for workflow run to start...');
+        let workflowRun: WorkflowRun | undefined;
+        const maxWaitTime = 60000; // 60 seconds
+        const pollInterval = 1000; // 1 second
+        const startTime = Date.now();
+
+        while (!workflowRun && Date.now() - startTime < maxWaitTime) {
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+
+            const runsAfter = await github.rest.actions.listWorkflowRuns({
+                owner,
+                repo,
+                workflow_id: foundWorkflow.id,
+                per_page: 5,
+            });
+
+            // Find the new run (one that wasn't in the before list)
+            const newRun = runsAfter.data.workflow_runs.find(
+                (run) => !runsBefore.data.workflow_runs.some((oldRun) => oldRun.id === run.id),
+            );
+
+            if (newRun) {
+                workflowRun = newRun as WorkflowRun;
+            }
+        }
+
+        if (!workflowRun) {
+            throw new Error('Timeout waiting for workflow run to start');
+        }
+
+        core.info(`✅ Workflow run started: ${workflowRun.html_url}`);
+        core.setOutput('workflowRunId', workflowRun.id);
+
+        // Poll until the workflow completes
+        core.info('⏳ Waiting for workflow run to complete...');
+        while (workflowRun.status !== 'completed') {
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+
+            const runStatus = await github.rest.actions.getWorkflowRun({
+                owner,
+                repo,
+                run_id: workflowRun.id,
+            });
+
+            workflowRun = runStatus.data as WorkflowRun;
+            core.info(`📊 Status: ${workflowRun.status}`);
+        }
+
+        core.info(`🏁 Workflow run completed with conclusion: ${workflowRun.conclusion}`);
+        core.setOutput('conclusion', workflowRun.conclusion);
+
+        if (workflowRun.conclusion !== 'success') {
+            throw new Error(`Workflow run failed with conclusion: ${workflowRun.conclusion}`);
+        }
+    } catch (error) {
+        const e = error as Error;
+
+        if (e.message.endsWith('a disabled workflow')) {
+            core.warning('Workflow is disabled, no action was taken');
+            return;
+        }
+
+        core.setFailed(e.message);
+    }
+}