actup MCP server
Commit Nov 14, 2026Manages GitHub Actions versions by checking for outdated refs, updating to latest versions, and pinning to immutable commit SHAs.
Also known as kjanat/actup
- Stars
- 0
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 14, 2026
- License
- Apache-2.0
What is actup MCP?
actup manages GitHub Actions versions by checking for outdated refs, updating to latest versions, and pinning to immutable commit SHAs.
Summary generated from the project's README
About actup MCP server
Maintaining secure and up-to-date CI/CD pipelines is what actup enables for DevOps engineers and developers using GitHub, GitLab, Gitea, or Forgejo. This MCP server provides a stdio interface that allows AI clients to scan workflows for outdated action versions, update them to the latest releases following semver policies, or pin them to immutable commit SHAs to prevent supply chain attacks.
Users interact with the server through read tools and dry-runnable mutators that are confined to a single root directory. The system supports various providers and can be integrated into local development environments or remote CI runners. It manages version information through a local cache to handle rate limits and network issues efficiently. When performing updates or pinning, the server ensures file integrity by writing to temporary files before replacing the originals, preventing corruption during the automation process.
What you can do with it
- 1Audit workflow securityScan all existing workflows to identify outdated or floating action references that need attention.
- 2Automate dependency updatesUpdate all GitHub Actions in the repository to their latest versions while respecting semantic versioning.
- 3Harden pipelines against attacksConvert version tags into immutable commit SHAs to ensure workflow stability and security.
- 4Preview automation changesRun a dry run to see which files would be modified by an update command without actually changing them.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
ACTUP_CACHE__TTLACTUP_DEFAULT_HOSTACTUP_FETCH__MAX_TAGS_PER_REPOACTUP_POLICY__BUMPACTUP_SCAN__IGNORE
| Name | Description | |
|---|---|---|
| ACTUP_CACHE__TTL | — | |
| ACTUP_DEFAULT_HOST | — | |
| ACTUP_FETCH__MAX_TAGS_PER_REPO | — | |
| ACTUP_POLICY__BUMP | — | |
| ACTUP_SCAN__IGNORE | — |
Automated checks
Ran Nov 15, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablekjanat/actup is public and reachablegithub.com/kjanat/actup ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-14github.com/kjanat/actup ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubGitHub Actions version manager. CLI + LSP + MCP for checking and updating
uses: refs across workflows and composite actions.
Features
- Check workflows for outdated action versions
- Update to latest versions (respecting semver policy)
- Pin refs to immutable commit SHAs for security
- Providers: GitHub, GitHub Enterprise, GitLab and Gitea/Forgejo
(
docs/providers.md) - LSP: Editor diagnostics and code actions
- MCP: stdio server with read tools and dry-runnable mutators confined to one root
Local paths (./, ../) and same-repository references ($/) are skipped when
checking, updating or pinning versions. This includes actions and reusable
workflows such as $/.github/actions/setup and $/.github/workflows/ci.yml.
Installation
# From source (requires Rust 1.96+)
cargo install --git https://github.com/kjanat/actup actup
cargo install --git https://github.com/kjanat/actup actup-lsp
cargo install --git https://github.com/kjanat/actup actup-mcp
GitHub Action
The action downloads the release that its ref names, checks the archive against
the release's SHA256SUMS.txt, and runs it. Linux runners get the static musl
build.
- uses: kjanat/actup@<commit SHA of v1.2.3> # v1.2.3
with:
version: v1.2.3 # needed when the ref is a commit SHA
command: check # check, update, pin or config
args: --strict # split on whitespace
| Input | Default | Meaning |
|---|---|---|
command |
check |
actup subcommand |
args |
"" |
Extra arguments after the subcommand |
working-directory |
. |
Directory to run actup in |
version |
"" |
Release tag to run when the action ref is not a release |
github-token |
${{ github.token }} |
Passed to actup as GITHUB_TOKEN |
A ref that is neither a release tag like v1.2.3 nor paired with version
fails the step. Inside another composite action, github.action_ref names that
outer action, and actup then needs version. The download always comes from the
kjanat/actup releases. Outputs: exit-code (see Exit Codes)
and actup-bin, the path of the verified binary for later steps.
examples/workflows/ holds a check workflow and a reusable workflow that opens
an update pull request with the token secret it receives. After tagging a
release, just examples-pin <tag> pins both examples to the tag's commit.
Quick Start
# Check current directory for outdated actions
actup check
# Check with strict mode (exit 1 if outdated)
actup check --strict
# Exit 1 only for major bumps or floating branch refs
actup check --fail-on major --fail-on floating
# Update all actions to latest versions
actup update
# Pin all actions to their current SHA
actup pin
# Turn `@<sha> # v4` back into `@v4` where the tag is still on that commit
actup pin --unpin
# Preview changes without applying
actup update --dry-run
Commands
| Command | Description |
|---|---|
check |
Scan workflows, report outdated (read-only) |
update |
Update actions to latest versions |
fix |
Alias for update |
pin |
Pin all actions to their current commit SHA |
pin --unpin |
Unpin marked SHA pins back to their tag |
config |
Show effective configuration |
cache |
Manage version cache (info, clear, path) |
schema |
Output JSON schema for config file |
completions |
Generate shell completions |
Output Formats
actup check --format json # Machine-readable JSON
actup check --format toml # TOML format
actup check --format human # Default, colored output
actup check --format table # One aligned row per finding
actup check --format sarif # SARIF 2.1.0 for code scanning
--format table prints the columns LOCATION (file:line), ACTION,
CURRENT, TARGET (- when there is none) and STATUS (the JSON status
name). Only check accepts table and sarif; other commands reject them,
also when ACTUP_FORMAT sets them.
--format sarif writes one result per finding other than up-to-date and ignored
refs, under one rule per status (actup/outdated, actup/floating,
actup/unresolvable and so on). Levels follow the LSP severities: error for
an unresolvable ref, warning for an outdated or floating ref, and note for
pinned and unknown refs, environment errors and same-commit refs. Paths are
percent-encoded URIs relative to the scanned directory, or file:/// URIs for
absolute paths. A backslash separates segments and a drive letter makes a path
absolute on Windows alone. Columns count UTF-16 code units. Files that could not
be read appear as execution notifications.
check --github-annotations also writes one ::error or ::warning workflow
command per error or warning finding to stderr, whatever --format is.
- run: actup check --format sarif --github-annotations > actup.sarif
- uses: github/codeql-action/upload-sarif@v3
if: always()
with: { sarif_file: actup.sarif }
check --fail-on <kind> exits 1 when a finding of that kind exists. Repeat it
for several kinds. outdated covers outdated refs and branch refs to pin,
major covers outdated refs whose target is a newer major version, and
floating covers floating branch refs and branch refs to pin. --strict is
--fail-on outdated. Unresolvable refs exit 2 and environment errors exit 3
with or without --fail-on.
Human output is coloured only on a terminal. --color always and
--color never force the choice. Under the default --color auto, a non-empty
NO_COLOR turns colour off, and a CLICOLOR_FORCE other than 0 turns it on
for piped output. NO_COLOR wins when both are set.
Human output, LSP messages and --github-annotations lines replace control
characters other than tab and line feed, zero-width and bidi control characters,
and the byte order mark with U+FFFD. Human output and LSP messages also replace
line feeds in paths, uses: values, refs, versions, reasons and error messages.
JSON output writes DEL as \u007f and ##[ as ##\u005b, and keeps the rest
of the raw text. A GitHub Actions runner splits output into lines at CR and LF,
reads a line that starts with :: as a workflow command and reads a line that
contains ##[ as a legacy one. Human output, TOML output and logs replace the
first colon of such a line and the [ of every ##[ with U+FFFD. The runner
then reads only --github-annotations lines as workflow commands. Annotations
percent-encode %, CR and LF, and also : and , in the file name.
With --format json or toml, check prints one entry per finding and
update and pin print a report with dry_run and the lists edited,
skipped and errors. Every entry names the file, line, action, owner, repo,
host, provider and reference (the ref as found). host is the ref's own host,
or the default host for a ref without one. An edited entry adds to (the ref
written) and comment when the edit writes a comment after it. A skipped
entry adds reason: ignored when scan.ignore matches the ref, or
unplaceable, overlap or out_of_bounds when the writer cannot edit it. Only
the last three make update and pin exit 1. When two edits of a file overlap,
every edit of that file is skipped with overlap and the file stays unchanged.
An errors entry adds kind (such as invalid_ref, not_found,
rate_limited, provider_not_found, write, changed or invalid_edit) and
message. With no workflow files, the report has empty lists and check prints
no findings.
A remote uses: value without @, with an empty ref, or with a ref that is not
a git ref name (such as o/r@a~1 or o/r@v1.lock) reaches no provider. check
reports it as unresolvable, update and pin report it with kind
invalid_ref, and all three exit 2. The language server marks it with an error
diagnostic. This holds for a value under jobs.<id>.uses,
jobs.<id>.steps[*].uses or runs.steps[*].uses, including steps nested inside
parallel: lists. An invalid value under any other uses key, such as a step
input, is skipped.
An unresolvable ref that names no tag can get a suggested tag. A partial version
names the highest tag that completes it (v4.2 names the highest v4.2.x). A
full version names a listed tag of the same version (4.2.0 names v4.2.0),
and gets no suggestion when none exists. Any other ref names the tag within two
edits of it, and the higher version wins a tie (v4.2.O names v4.2.0). A
partial version that no tag completes takes only full X.Y.Z tags within two
edits (v42.0 names v4.2.0, v7 names nothing). Prerelease tags count only
under policy.prerelease = true. check prints the suggestion on a hint:
line and adds suggestion to the JSON and TOML entry. The LSP offers a
Change to quick fix that writes the tag in the policy.pin style.
check, update and pin read every file first. They then fetch the versions
of each repo that an unignored ref names, once per repo and in one batch through
the version cache, before they report or edit.
While they fetch, they draw a one-line resolving N repos counter on stderr
when stderr is a terminal and --verbose is off. Piped and redirected runs
print no progress.
--offline reads versions only from the cache. A repo missing from the cache,
or cached longer ago than cache.ttl, makes its refs environment errors (exit
3), and no command touches the network. --no-cache neither reads nor writes
the cache, the same as cache.enabled = false. --refresh skips cached
versions and writes the freshly fetched ones. A repo that fails to fetch keeps
its cache entry. Only one of the three flags can be given. The quick lookup
actup owner/repo uses the cache too.
A cache entry past its TTL stays on disk. When the provider then rate limits the
refresh or the network fails, check reports the finding from that entry,
prints stale (fetched 26h ago, rate limited, resets in 12m) under it, adds
stale with age_secs, reason (rate_limited or network) and
retry_after_secs (when the provider named a reset) to the JSON and TOML entry,
and exits 3. update and pin refuse to write from such data, report the ref
with kind stale and exit 3. actup-lsp appends the same note to the
diagnostic and offers no quick fix and no fix-all edit for it. A REST refresh
sends the stored ETags of the tags, repository and default branch requests,
and an answer of 304 to all three renews the entry without a new listing.
update and pin write each file to a temp file in its directory, flush it,
give it the mode of the original and rename it over the original. A failed write
leaves the original intact. A write through a symlink replaces the file it
points to, and a leading byte order mark stays. They re-read each file before
writing it. When a line they edit differs from the scan, they leave the file
untouched, report each of its refs with kind changed and the message
edit refused: <path> changed since scan, and exit 3. They also parse the
edited text before writing it. When it is not valid YAML or holds a different
number of uses: values, they leave the file untouched, report each of its refs
with kind invalid_edit, and exit 2. A dry run reports the same refusal. The
LSP command actup-lsp/fixAllInWorkspace applies both checks and leaves out a
refused file.
Configuration
Create actup.toml or .actup.toml in your repo root, or write the user config
(see Config Discovery):
# Default host for bare owner/repo refs (user or explicit config only)
default_host = "github.com"
[policy]
bump = "minor" # patch | minor | major | latest
pin = "preserve" # preserve | tag | sha
track = "keep" # keep | major | exact
major_tag = "exact" # exact | contains
branch = "warn" # ignore | warn | update
prerelease = false
archived = "hint" # hint | ignore
[pin]
comment = true # add version labels to SHA pins
[scan]
ignore = ["my-org/*", "dtolnay/rust-toolchain@1.91.0"]
extra_paths = [".gitea/workflows"] # user or explicit config only
# Ordered; for each policy key the last matching entry wins.
# Patterns are `[host/]owner/repo[/subpath][@ref]` globs.
[[overrides]]
pattern = "my-org/*"
policy = { pin = "sha" }
[[overrides]]
pattern = "ghe.example.com/platform/*"
policy = { bump = "patch", track = "exact" }
# API fallback, used only when a host refuses a git connection
[fetch]
api_mode = "graphql" # preferred: "graphql" or "rest"; REST-only providers use REST
max_tags_per_repo = 10 # Tags to fetch per repo (1-255)
# Enterprise GitHub (api_base and token_env: user or explicit config only)
[hosts."ghe.example.com"]
kind = "github"
api_base = "https://ghe.example.com/api/v3"
token_env = "GHE_TOKEN"
Action Patterns
scan.ignore and [[overrides]] patterns read a host with the uses: rule.
The first segment is a host when the pattern has at least three segments and
that segment is localhost, a dotted DNS name, a DNS name with a :port, or a
bracketed IPv6 literal such as [::1]. Glob characters count as DNS name
characters, so *.corp.com/o/* and ghe.*/o/r name hosts. A bracketed IPv6
host matches literally.
Host matching ignores case, and a ref without a host matches as default_host.
A pattern without a host matches every host. Owner, repo, subpath and ref match
case-sensitively. * stays within one segment and ** spans segments.
In uses: refs, actup lower-cases the host. Owner and repo must match
[A-Za-z0-9._-]+ and must not be . or ...
A pattern whose owner or repo holds any other character is an error at config
load. Glob syntax is the exception: *, ? and a [...] class, whose members
may also be ! and ]. Outside a class, ! and ] are errors. So is a host
with a glob port such as ghe.corp:*; write the port number.
Pin Style
policy.pin sets how update, the LSP quick fixes, fix-all and the wasm
planUpdates write an outdated ref. An [[overrides]] entry can set it per
action.
pin |
Tag ref @v4.0.0 |
SHA pin @<old> # v4.0.0 |
|---|---|---|
preserve |
@v4.2.0 |
@<new> # v4.2.0 |
sha |
@<new> # v4.2.0 |
@<new> # v4.2.0 |
tag |
@v4.2.0 |
@v4.2.0 |
A comment after the ref whose first word is a label gets the new label and keeps
the note after it: # v4.0.0 pinned for node16 becomes
# v4.2.0 pinned for node16. A label is a version such as v4.0.0, the ref
being replaced, or a tag or branch that the fetched refs of the action list. A
SHA pin gets # <version> <note>, a tag written over a tag or branch gets
# <tag> <note>, and a branch, or a tag written over a SHA pin, gets
# <note>. @main # main keep moved to v4.2.0 becomes
@v4.2.0 # v4.2.0 keep, and @<sha> # main keep re-pinned becomes
@<new> # v4.2.0 keep. Any other comment, such as # lint keep or
# TODO fix, stays as written.
A new # vX.Y.Z comment is added only where the line can take it: never next to
another comment, never on a line that holds other uses: values or ends inside
a scalar, and never in a plain-text file. The comment goes after the closing
quote and the flow } or ] that close the value, as in
{ uses: "o/b@<sha>" } # v4.2.0, and replaces the trailing whitespace of the
line. Other text after the value, such as more flow keys, means no new comment,
but a label comment at the end of the line is still rewritten and keeps its
note. actup pin and branch = "update" place their # <ref> comment the same
way. The CLI, the LSP, the MCP server and the wasm package follow the same rule.
Set [pin] comment = false to omit generated labels from SHA edits on all four
surfaces. Replacing a ref removes its recognized label and keeps the note:
@v4.0.0 # v4.0.0 keep becomes @<sha> # keep. Other comments and closing
quotes stay intact. This setting does not change policy.pin, tag updates, or
already-current refs that need no edit. ACTUP_PIN__COMMENT=false overrides it.
Action hovers show the action's inputs (description, required flag, and default)
and outputs from action.yml, followed by its README at the referenced
revision. Metadata is cached per host, repository, action subpath, and ref for
cache.ttl. A missing README or metadata fetch failure does not hide the other
hover content.
The LSP also offers Update to {version} & pin to SHA for an outdated ref at
the cursor. It pins the target selected by the update policy and per-action
overrides, even with policy.pin = "tag" or "preserve". Pin to commit SHA
still pins the current version, including when it is up to date. Pin refactors
are available with the cursor anywhere in owner/repo@ref, including inside
parallel: steps; their edits replace only the ref and its applicable comment.
The update-and-pin refactor is omitted when the ordinary quick fix already makes
the identical edit; it remains available in a refactor-only request. Cached SHA
targets must be exactly 40 hexadecimal characters, and edits use current
document diagnostics.
On a line that takes no new comment, such as a line of a plain-text file, a
label comment right after the value is still rewritten. Writers read the word
after # as the label and the next word as the note, and leave the rest of the
line as written: run("uses: o/p@<sha> # v4.0.0 keep this") re-pinned becomes
run("uses: o/p@<new> # v4.2.0 keep this"). A word ends at whitespace, a quote,
a backslash, a bracket, <, >, ; or ,. After the only uses: value of a
plain-text line, the comment may also follow a closing quote and }, ] or
,, as in {"uses": "o/p@<sha>"}, # v4.0.0.
Major tags must identify the selected release commit by default
(policy.major_tag = "exact"). If a major tag is ahead of the release or has
diverged, Actup reports a mismatch and offers no automatic rewrite. An ancestor
is outdated. If ancestry cannot be verified, the result is unknown and no
automatic rewrite is offered. This prevents a newer major tag from being
replaced by an older release commit, including SHA pins on that major tag.
For actions that publish an image from a release and then move their major tag to a subsequent digest-pinning commit, opt into verified containment:
[[overrides]]
pattern = "kjanat/actionlint"
policy = { major_tag = "contains" }
contains also accepts major tags whose commits descend from the selected
release. It does not accept divergent history or unverified ancestry, change
track, or relax bump restrictions. track = "exact" still selects the full
release; it never automatically downgrades a current major tag to its ancestor.
Comparisons use immutable commit SHAs and run only when needed. Successful
comparisons are cached per provider, host, repository and SHA pair with the
provider's existing retention policy. Failures and unsupported comparisons are
not cached. Providers without ancestry support return unknown.
Strict mismatches appear as warnings without fixes in the LSP. CLI check reports
them as an error with the mismatch reason (exit 3); MCP getLatest returns
status: "unknown", check: "mismatch", a reason, and no target. Explicit MCP
mutators retain their requested-target semantics.
A SHA pin whose comment starts with a fetched branch name tracks that branch:
uses: owner/repo@<sha> # master is outdated when master points at a
different commit. update and pin refresh the SHA, retaining the branch label
and any note under the default pin/comment settings. This also works inside
parallel: steps and for custom branch names. A matching head is a no-op. The
comment's branch takes precedence over release tags on the old commit; if a tag
and branch share the comment's name, the tag takes precedence. Unrecognized
comments and pins without comments keep the existing tag-based resolution.
scan.ignore still applies. The policy.branch setting controls floating
references such as @master, not these existing SHA pins. Cache freshness and
stale-write guards apply as usual; use --refresh to fetch current heads.
actup pin --unpin and the LSP refactor action actup: unpin to `v4`
rewrite @<sha> # v4 note to @v4 # note. They act only on a SHA pin whose
comment starts with a tag, and only when the fetched tags hold that tag on the
pinned commit. pin --unpin skips actions that scan.ignore matches. Neither
update nor fix-all unpins this way.
[!WARNING]
pin = "tag"unpins. It rewrites an outdated SHA pin to its target's tag, which the action's owner can move, and drops the label from its comment. A note after the label stays as the comment. Settagonly to leave SHA pins on purpose.
Archived Repositories
The LSP asks the provider whether each action's repository is archived (GitHub,
GitLab, Gitea) or disabled (GitHub). It asks once per repository per
cache.ttl, and hover reuses the answer. An archived or disabled repository
gets a hint diagnostic with code archived on each uses: line and a warning
line in hover. A failed or rate-limited lookup reports nothing, and an action
that scan.ignore matches gets no lookup. policy.archived = "ignore" turns
both off, also per [[overrides]] entry.
actup MCP questions
Does actup support local or same-repository references?
No, local paths and same-repository references are skipped during checking, updating, or pinning.