Docs
Docs menu

Running GitHub workflows

How workflows in .github/workflows run on Moru without changes, what the compatibility report says, which actions run and how to lock them, where Moru behaves differently from GitHub, and how to move to Moru's own format.

A repository imported from GitHub keeps its CI. Moru reads the workflows in .github/workflows/ and runs them as they are, on the runners of the person each run is for, the same way it runs native workflows. You don’t have to change the files. Each workflow gets a compatibility report that says what runs, what runs a little differently, and what can’t run.

Moru translates each workflow into the same jobs a native file becomes. It doesn’t run GitHub’s runner. Most workflows that build and test code run unchanged. Workflows that talk to GitHub itself (its API, its tokens, its deployment environments) don’t.

Which folder runs#

A commit’s runs read .moru/workflows/ when it holds at least one .yml or .yaml file, and .github/workflows/ otherwise. Never both, so a repository halfway through moving to the native format doesn’t run everything twice. The CI tab says which folder is in use.

A file in .github/workflows/ whose only trigger is workflow_call is a reusable workflow, not a workflow of its own: it runs only when another workflow calls it.

Triggers#

GitHubOn Moru
pushA push to a branch or tag, merges included. branches, branches-ignore, tags, tags-ignore, paths and paths-ignore work as on GitHub.
pull_requestEvery new revision of a change. branches and branches-ignore match the change’s target branch. types with opened, synchronize or reopened is ignored, with a note: Moru runs on every revision. A types list with none of them is refused.
scheduleA schedule, with cron and the optional timezone.
workflow_dispatchA manual start from the CI tab or the API, with its inputs. Input types string, boolean, choice and number work; environment is refused.
workflow_callA reusable workflow. See Reusable workflows.
pull_request_target, workflow_run, every other eventRefused. A workflow that also has a trigger Moru runs gets a note and runs on that one; a workflow with only refused triggers doesn’t run.

In a job’s if, github.event_name is GitHub’s name for the trigger: pull_request for a change’s revision, push, schedule or workflow_dispatch. So if: github.event_name == 'push' works as it did.

runs-on#

GitHub’s hosted runner labels become Moru’s own labels, which every runner has from its OS and CPU:

runs-onRuns on
ubuntu-latest, ubuntu-24.04, …linux
ubuntu-24.04-arm, …-arm64linux and arm64
macos-latest, macos-15, …macos (macos-…-arm64 adds arm64)
self-hostedDropped: every Moru runner is self-hosted.
Linux, macOS, X64, ARM64The same labels in lower case.
windows-latest, any windows-…Refused: Moru has no Windows runners.
group:Refused: Moru has no runner groups. Use labels.
any other labelKept as it is. A runner matches it if a node admin gave it that label, or if it’s the runner’s name (see Named runners).

ubuntu-latest doesn’t ask for a CPU, so it runs on any Linux runner, x64 or arm64.

When a matrix sends some combinations to Windows and others elsewhere, the Windows ones are dropped with a note and the rest run. They don’t count as jobs, so a required job doesn’t wait for them. A job that only runs on Windows is refused.

Expressions#

${{ }} works where GitHub allows it, with GitHub’s rules: its operators, loose equality, case-insensitive string comparison, .* filters, and the functions contains, startsWith, endsWith, format, join, toJSON, fromJSON, hashFiles, case, success, failure, always and cancelled.

Every expression is checked when the workflow is read, so a typo or an unknown context refuses the workflow with its line and column instead of failing halfway through a run. The node works out what it can before a job is queued: a job’s if, name, runs-on, timeout-minutes, continue-on-error and strategy. The runner works out the rest as the job runs.

The contexts are GitHub’s: github, env, vars, secrets, inputs, matrix, strategy, needs, steps, job and runner. Some of them hold less than on GitHub:

  • vars is always empty. Moru has no repository variables; put values in env.
  • github.token and secrets.GITHUB_TOKEN are empty. There’s no GitHub API to call.
  • github.event is a small payload Moru builds. For a change: action (opened for the first revision, else synchronize), number, and pull_request with number, title, draft (always false), head.sha, head.ref, base.sha and base.ref. number is the pull request’s number on GitHub when the change was delivered there, else null. For a push: ref, before, after, created, deleted, forced and head_commit.id and .message. For a manual start: inputs. For a schedule: schedule, the cron.
  • github.actor, github.triggering_actor, the …_id fields and the API URLs are empty. github.server_url is your node’s address.
  • github.run_id is the Moru run’s ID. run_number counts the workflow’s runs, and run_attempt counts re-runs. The count is kept in the node’s index, not in git, so it starts again at 1 after the index is rebuilt and after the repository moves to another node; the first run after upgrading to a version that numbers runs is 1. Don’t use run_number as a unique version number: add the commit to it.

A matrix can’t be computed from another job’s outputs yet (fromJSON(needs.setup.outputs.matrix)), and a job’s name, runs-on, timeout-minutes and strategy can’t read needs. Both refuse the workflow with a note that they come in a later version.

Environment and workflow commands#

Steps get the GITHUB_* and RUNNER_* variables GitHub sets, among them GITHUB_SHA, GITHUB_REF, GITHUB_WORKSPACE, GITHUB_EVENT_PATH, RUNNER_OS, RUNNER_ARCH and RUNNER_TEMP, plus CI=true and Moru’s own MORU_* variables. GITHUB_TOKEN is set, and empty, so a token in the runner’s own environment never reaches a step.

The command files work as on GitHub: GITHUB_OUTPUT, GITHUB_ENV, GITHUB_PATH and GITHUB_STATE, with the name<<DELIMITER form for values over several lines. GITHUB_STEP_SUMMARY is accepted, but summaries aren’t shown yet. So are the commands a step prints:

  • ::add-mask:: hides a value in everything logged after it.
  • ::group::, ::endgroup::, ::error, ::warning and ::notice stay in the log as they’re printed.
  • ::debug:: shows only when the step’s env has ACTIONS_STEP_DEBUG=true.
  • ::stop-commands:: works.
  • ::set-output and ::save-state work, with GitHub’s deprecation warning. ::set-env and ::add-path fail the step unless its env has ACTIONS_ALLOW_UNSECURE_COMMANDS=true, as on GitHub.

Steps without shell run with bash -e, or sh -e where bash isn’t installed. In a job with a container:, they run with sh -e, as on GitHub. bash, sh and python run GitHub’s exact command lines, and a custom shell with {0} works. pwsh, powershell and cmd are refused.

A job without timeout-minutes gets 240 minutes, Moru’s most. GitHub’s default is 360, and a larger value is cut to 240 with a note.

The compatibility report#

Each workflow on the CI tab has one of three verdicts:

  • Runs as is: nothing to say.
  • N notes: it runs, and the notes say what Moru does differently, such as ignoring permissions or concurrency. A run keeps its notes, and its page lists them.
  • Refused: it doesn’t run. Each problem is listed with its line and column.

Under each workflow is the list of its uses:, each with its tier:

TierMeaning
Built inThe runner does what the action does itself. Nothing is fetched. See Built-in replacements.
FetchedA JavaScript, composite or Docker action, fetched from GitHub and run on the runner, or a docker:// image.
In the repoA ./path action or reusable workflow, read from the job’s checkout.
RefusedIt can’t run on Moru, with why.

Fetched actions also say whether .moru/actions.lock locks them. See Locking actions.

A push or change that triggers a refused workflow still records a run, marked Refused. Its page lists the problems that refuse it, and the notes apart from them.

Actions#

Built-in replacements#

These actions aren’t fetched. The runner does their job with what’s already on the machine. Every major version from v3 on is accepted, along with the inputs that version has. An older major, such as actions/checkout@v2, is treated like v3: its inputs are checked against v3’s. An input the replacement can’t honour refuses the workflow and names the input; one that makes no difference on Moru (a token, a setup action’s cache) is a note.

ActionOn Moru
actions/checkoutThe job already has a checkout of the commit, with full history, branches and tags, so fetch-depth changes nothing. submodules and lfs run git submodule update and git lfs pull with the machine’s git. A repository, ref or path other than the job’s own is refused.
actions/setup-node, -python, -go, -java, -dotnetNothing is installed. The step checks that the version asked for, or the one a version file names (.nvmrc, .python-version, go.mod, global.json, …), is on the runner’s PATH, and fails with what it found otherwise: “needs node 20 on PATH; this runner has 18.19.0”. The action’s outputs are set.
jdx/mise-actionRuns the machine’s mise install and passes mise env on to later steps. Needs mise on PATH.
dtolnay/rust-toolchainChecks the toolchain is installed (rustup toolchain list), adds targets and components with rustup, and sets RUSTUP_TOOLCHAIN for later steps instead of changing the user’s default toolchain.
actions/cache, actions/cache/restore, actions/cache/saveThe runner’s own cache, with GitHub’s key and restore-keys rules.
actions/upload-artifact, actions/download-artifactThe run’s artifacts on the node. Only the same run’s artifacts can be downloaded. archive: false is refused: artifacts are always zips.
dorny/paths-filterMatches its filters against the files the change or push changed, with the action’s own pattern rules, and sets every output the action sets. Every filter is true above 3,000 changed files, and when there’s no list of changed files: a new branch, a manual or scheduled run, a local run.

Setup actions check the tools; they don’t install them. Put the versions your workflows need on the runner’s machine, with mise, asdf, Homebrew or your package manager.

JavaScript and composite actions#

Any other uses: owner/repo@ref is fetched from GitHub by the runner, at the commit the run resolved, and run there:

  • JavaScript actions run with node from the runner’s PATH. runs.using: node20 needs Node 20 or later and node24 needs 24 or later; older values count as node20. A missing or older node fails the step with the version it needs. pre and post scripts run as on GitHub, posts last first.
  • Composite actions run their steps inside the step that uses them, with their own inputs. They can use other actions, up to 10 deep.
  • Local actions (uses: ./path) are read from the job’s checkout.

A runner fetches an action once and keeps it in its cache directory. Use moru-runner run --actions-url to fetch from a mirror instead of https://github.com.

Services, job containers and Docker actions#

services:, container:, Docker actions (runs.using: docker) and uses: docker://… run on a runner with docker or podman, as described in Containers. GitHub’s keys and values work as they are: image, env, ports, volumes, options and credentials, and a service’s command and entrypoint. Expressions in them can read what GitHub allows, and secrets only in env and credentials. Steps can read job.services.<id>.ports['5432'], job.services.<id>.network, job.container.id and job.container.network, and they get the MORU_SERVICE_<ID>_HOST and MORU_SERVICE_<ID>_PORT_<port> variables too.

A job with container: or services: goes to the runner of the person the run is for, like any job: runs-on: ubuntu-latest still means a Linux runner, and a Mac runner with Docker Desktop takes self-hosted container jobs. What runs differently from GitHub is listed under Differences from GitHub.

Actions and secrets#

An action gets no secret unless the workflow passes it through with: or env:, as on GitHub. Inside a composite action, secrets is empty. This holds in native workflows too: a native job’s secrets reach its own run steps, never its uses: steps.

Locking actions#

A tag such as actions/setup-node@v4 can be moved to other code at any time. A lock pins every action to a commit and checks its content. Run this in your checkout and commit the file:

moru-runner ci lock

It writes .moru/actions.lock, with the commit and the tree of every action your workflows use, including the actions that composite actions use. Built-in replacements, refused actions and ./path actions get no entry. The runner then fetches each action at its locked commit and refuses it if the content doesn’t match. Run ci lock again after you change a uses:, and ci lock --check in a hook or a CI step to catch a stale lock. See ci lock.

Images are locked by digest. For each uses: docker://…, and each Docker action whose runs.image is docker://…, ci lock pulls the image with your docker or podman and records its digest. Without an engine it writes the entry without a digest and says so. After pulling, the runner checks the image against the lock and fails the step if the digest changed since, naming both. An image pinned with @sha256:… counts as locked. The image of a Docker action in the repository (uses: ./path) is never in the lock: pin it with @sha256:….

Without a lock, a run still goes ahead. The node looks up each tag or branch on GitHub when the run starts (at most 32 per run, and 64 for all the runs of one pushed ref, revision, manual start or minute of a repository’s schedules), puts the commits it found in the run, and marks the run Unlocked actions. A re-run uses the same commits. Actions nested in an unlocked action are looked up by the runner and recorded with the run. A uses: pinned to a full 40-character commit needs no lookup, but it’s still listed as unlocked: without a lock entry there’s no tree to check.

A repository admin can turn on Require locked actions in the repository’s settings, under Merging (or moru-node repo-policy --require-locked-actions true). Runs whose workflow uses an action the lock doesn’t list, or a docker:// image without a digest there, are then refused, with the list and the command to fix it. The runner refuses an image without a digest that an action uses, too. The check covers the workflow’s own uses:. An action that a locked action uses is locked when ci lock wrote the entry; otherwise the runner looks it up and the run’s record lists it as unlocked.

The lock covers uses: only. The images of container: and services: aren’t locked, so pin those by digest (image: postgres:17@sha256:…) if you need them fixed. A Docker action’s Dockerfile is locked with the action, but the FROM image it builds on isn’t. A run whose only unlocked reference is a docker:// image is still marked unlocked.

A lock that doesn’t parse refuses every run whose workflow fetches actions or uses ./path actions, with the line and column of the problem. The CI tab shows it above the workflows.

Reusable workflows#

A job can call a workflow from the same repository:

jobs:
  ci:
    uses: ./.github/workflows/build.yml
    with: { target: release }
    secrets: inherit

The called workflow’s jobs are added to the run as <job>/<called job>, here ci/test and ci/lint, and its inputs and secrets are mapped as on GitHub. They can call other workflows in turn, 10 levels deep in all. A required job inside one is named the same way: checks/ci/test.

Reusable workflows from other repositories (uses: owner/repo/.github/workflows/x.yml@v1) are refused. Copy the workflow into your repository. A called workflow’s outputs can’t be read by the calling workflow yet.

ci import keeps these calls in the native files it writes.

Secrets#

A job is given the secrets its steps read as secrets.NAME, from the runner’s ci.toml, the same way a native job lists them in secrets:. A runner that can’t give a job every secret it reads doesn’t take the job, and the run page names the missing secret. secrets.GITHUB_TOKEN is never one of them: it’s empty.

The secret’s name in ci.toml is the name the workflow uses. A reusable workflow called with secrets: { token: ${{ secrets.NPM_TOKEN }} } reads NPM_TOKEN from the runner as its token; with secrets: inherit, the names stay as they are.

A step reads a secret only through ${{ secrets.NAME }}, as on GitHub. Unlike a native job, a GitHub job’s secrets aren’t put in the steps’ environment by name.

Caches, artifacts and required jobs#

actions/cache uses the runner’s cache store, which native cache: uses too. A workflow’s or job’s cache-mode works: read restores and never saves, write-only saves and never restores, none does neither. Runs for changes default to read. See Caches.

Actions that talk to GitHub’s cache service themselves, such as Swatinem/rust-cache, are fetched and run, but there’s no such service on Moru: they restore and save nothing, and the job goes on without a cache. Use actions/cache, or a native cache:, with the paths they would cache (for Rust, ~/.cargo/registry, ~/.cargo/git and target). ci import keeps a Swatinem/rust-cache step and adds a note saying so.

actions/upload-artifact and download-artifact use the run’s artifacts on the node. See Artifacts.

Required jobs are named <workflow>/<job> as for native workflows: ci/test for the job test in .github/workflows/ci.yml. A job skipped by its own if counts as passed when the jobs it needs succeeded. See Required jobs.

What’s refused, and what to do instead#

RefusedInstead
runs-on: windows-…, shell: pwsh, shell: cmdNothing on Moru. A matrix’s Windows combinations are dropped and the rest run.
environment:Give the job’s runner the secrets it needs, scoped in ci.toml, and gate the job with if. For deploys, use a deploy runner.
pull_request_target, workflow_run and GitHub’s other eventspull_request for changes, needs between jobs of one workflow.
actions/github-script, create-github-app-token, labeler, stale, dependency-review-action, github/codeql-action, softprops/action-gh-release, docker/setup-buildx-action and other actions that use GitHub’s APIA run step that does the work with a token from ci.toml.
actions/attest*, deploy-pages, and sign-ins with GitHub’s OIDC token (aws-actions/configure-aws-credentials with only role-to-assume, google-github-actions/auth with workload_identity_provider, azure/login with client-id)Keys from a secret: the same actions take them.
Reusable workflows from other repositoriesCopy the workflow into .github/workflows/.
runs-on: { group: … }, snapshot:Labels.
Concurrent steps (background, parallel, …), matrices computed from needsThese come in a later version.
Writing GITHUB_ARTIFACTS or reading github.artifactsactions/upload-artifact.

Differences from GitHub#

Things that run, but not quite as they do on GitHub:

  • Cancelling. Cancelling a run ends all its jobs at once, so jobs with if: always() or if: cancelled() don’t run afterwards. When a job is cancelled or times out, its remaining steps don’t run, if: always() ones included, and neither do actions’ post steps. cancelled() is always false.
  • Superseding. A new revision or push cancels the unfinished jobs of the run it replaces, whatever concurrency says.
  • Re-runs are new runs: github.run_id changes, run_attempt goes up. Run numbers start again from 1 if the node’s index is ever rebuilt.
  • pull_request types are ignored when they include opened, synchronize or reopened: every revision runs. A list with none of them, such as [labeled], is refused.
  • No GitHub token. GITHUB_TOKEN and github.token are empty, and permissions is ignored.
  • Setup actions install nothing. They check what’s on the runner. setup-java doesn’t set JAVA_HOME for later steps, and rust-toolchain sets RUSTUP_TOOLCHAIN rather than the user’s default.
  • Caches are the runner’s own, not shared with other runners. A change’s runs restore but don’t save unless cache-mode says write. With lookup-only, actions/cache never saves.
  • hashFiles hashes files in name order, where GitHub follows the file system’s order. The same files can give a different hash than on GitHub; it matters only if you compare keys across the two.
  • Artifacts. upload-artifact’s artifact-id output is the artifact’s name, and artifact-url is the run’s page (in a local run, the zip’s path on your machine). A symbolic link in the checkout (or the job’s temporary folder) whose target is outside them is left out of the artifact, with a warning naming the link; GitHub follows it. This keeps a link committed to the repository from uploading files from the runner’s machine. Links that stay inside the checkout are followed, and a folder outside it that you name in path is uploaded as on GitHub.
  • Timeouts. A job gets at most 240 minutes; that’s also the default.
  • Matrix values. An unquoted 3.10 is the number 3.1, as on GitHub. The report notes it: quote it to keep 3.10.
  • Conditions with text around ${{ }} (if: ${{ a }} && b) are read as a string, true whenever it isn’t empty, as on GitHub. The report notes it.
  • run-name is ignored. Runs are named by their trigger.
  • Job summaries written to GITHUB_STEP_SUMMARY aren’t shown yet.

In containers:

  • Same paths, not /__w. A job container sees the job’s folders at the same paths as the runner’s machine, so GITHUB_WORKSPACE and RUNNER_TEMP are the machine’s paths. GitHub mounts them under /__w. A workflow that hard-codes /__w/... needs changing.
  • One workspace per repository. As on GitHub, every job of a repository gets the same GITHUB_WORKSPACE, <work-dir>/<owner>/<name>, so a build from one job (a nextest archive, say) runs in another. Across machines that holds when their runners share one --work-dir. A runner runs one job of a repository at a time; see Where a job runs.
  • RUNNER_OS is the runner’s own OS, so macOS on a Mac, even in a Linux container. GitHub has no containers on macOS.
  • HOME in a job container is the image’s own. Docker actions get /github/home, as on GitHub.
  • Ports are published on 127.0.0.1 only, never on every interface. -p and --publish in options are refused; list ports in ports:.
  • Pulls. If a pull fails and the image is already on the machine, that one is used, with a warning in the log.
  • Timeouts. When a step in a job container times out, its process gets SIGTERM, then SIGKILL after 10 seconds. A process the step started that moved to a group of its own can keep running until the job’s container is removed at the end of the job.
  • with.args and with.entrypoint are used for a Docker action only when its action.yml has no args or entrypoint, as GitHub’s runner does. For a uses: docker://… step they’re always used. with.args that doesn’t split like a shell command line is split at spaces, with a note.
  • No Docker socket. Docker actions don’t get /var/run/docker.sock mounted. Mount it in options yourself if a job needs it.
  • Read-only actions. A job container sees the runner’s copies of fetched actions read-only.
  • Variables that point at the machine. Docker actions don’t get RUNNER_TEMP, RUNNER_TOOL_CACHE, GITHUB_ACTION_PATH or MORU_OUTPUT, which name folders the action’s container doesn’t see.
  • Logins. credentials with only one of username and password is skipped with a note, and the image is pulled without a login, as on GitHub.
  • Non-root images. Files a container wrote as root are given back to the runner’s user when the job ends. An image whose USER isn’t root gets the job’s temporary folder and command files opened to it, but on rootful Docker on Linux it can’t write to the checkout (or a Docker action to /github/workspace), as on GitHub.

Run a workflow on your machine#

moru-runner ci run reads .github/workflows/ too, with the same expressions, actions, caches and artifacts. Jobs’ if, continue-on-error and strategy.fail-fast work as they do on a node, and --input name=value gives a manual run its workflow_dispatch inputs. Actions in .moru/actions.lock run at their locked commits, and --offline runs only those, from the cache. A local run’s caches are kept apart from a runner’s. Services, job containers and Docker actions use your docker or podman. See ci run.

Moving to Moru’s format#

Workflows in .github/workflows/ keep running as they are. To switch to native workflows, run moru-runner ci import in your checkout:

moru-runner ci import            # every workflow in .github/workflows/
moru-runner ci import ci         # just ci.yml

It writes .moru/workflows/<name>.yml for each workflow, with the same file name and job IDs, so required jobs (ci/test) keep their names. Each file starts with how many TODOs it has, and # Note: lines for what changed without losing anything, such as concurrency being dropped.

What maps: push, pull_request (as change), schedule and workflow_dispatch (as manual, with its inputs) and their branch and path filters; env, runs-on, needs, timeout-minutes, plain matrices, container and services, the secrets a job reads, and uses: steps with plain with: values. A job without timeout-minutes gets timeout: 4h (GitHub’s default is 6 hours; Moru’s limit is 4), and run: steps without a shell now run with pipefail, so a pipeline fails when any command in it does; each file’s # Note: lines say so. In run: scripts, ${{ matrix.k }}, ${{ env.X }}, ${{ secrets.X }}, ${{ inputs.x }}, ${{ needs.j.outputs.k }} and github.sha, ref, ref_name, repository and run_id become the variables a native step gets. A job if that checks the event, the ref or the base branch becomes when:.

Everything else gets a # TODO: comment with the reason:

  • A step that can’t be mapped stays in the file as a comment, and in its place is a step that fails: echo "moru: this step needs porting (see the TODO above)"; exit 1. Fixing the TODO means writing the replacement and deleting that failing step.
  • A job whose if can’t be written as when:, or that has an environment:, gets that failing step first, a guard: dropping a deploy job’s condition would otherwise run it on every push.

An imported workflow fails rather than silently skip what it couldn’t carry over. The import checks each file with the native reader on its own before writing it: a file that wouldn’t read is skipped and reported, and the others are still written. It refuses to overwrite a file in .moru/workflows/ without --force.

A job that calls a reusable workflow of the repository stays a call: uses: ./.github/workflows/build.yml becomes uses: ./.moru/workflows/build.yml, and build.yml is imported too, with workflow_call as a call trigger and its inputs. The called jobs keep their required-job names (ci/build/compile). In with:, ${{ inputs.x }} becomes {input.x} and ${{ matrix.k }} becomes {matrix.k}; any other expression gets a TODO and a placeholder value. secrets: inherit is dropped, since a called job gets its secrets from the runner by name, and a secret passed under another name gets a TODO. A calling job can’t hold the failing guard step, so one whose if can’t be written as when:, or whose matrix has an exclude, becomes a job to port, and so does a call to a workflow in another repository. See Calling a workflow.

A few things differ from GitHub, and the import notes each one in the file it writes:

  • Empty inputs. On GitHub, ${{ inputs.x }} is empty in a push run. Natively, {input.x} gets the input’s default there.
  • One type per input. A native file gives each input one type. An input that workflow_dispatch declares as a choice and workflow_call as a string becomes the choice. One declared with other clashing types is left out of call, with a TODO.
  • Matrix keys. A calling job’s matrix key that the called jobs’ matrix also has is renamed <job>-<key>, since a called job has one value per key.

If you import only the calling file, the import warns that the file it calls isn’t in .moru/workflows/ and names the command that imports it. After writing, the import also expands each call the way Moru will, and prints anything that would refuse the run as a warning with its file, line and column.

With --flatten, the jobs of a reusable workflow become jobs of the file that calls it instead, and a file that is only a reusable workflow isn’t written. That changes their required-job names (ci/build/compile becomes ci/compile), and the import prints each name that changes: update Required CI jobs, under Merging in the repository’s settings, to match.

Once .moru/workflows/ has a file, .github/workflows/ stops running on Moru. If you import only some workflows, the import lists the ones that stop. Commit the new files in one change, run each job with moru-runner ci run, and keep .github/workflows/ if GitHub still runs them.

On the CI tab of a repository that runs GitHub workflows, people with write access see Move CI to Moru’s format. It opens a new request with the steps above and their acceptance criteria filled in, ready to hand to an agent or a person.

See ci import for its flags and exit codes.

Command menu
Search for a page, repository, change or request, or run a command