Skip to content

Releases

v0.102

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:08

Archived binary mirror of jonnyzzz/mcp-steroid v0.102.

Original publication: 2026-08-07T20:32:22Z.
Upstream tag commit: c68d8f15d2f444fd7afa3333b535c8c27c9c82e8.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.102

0.102 is the largest devrig and MCP Steroid release yet — 535 pre-release commits touching both halves of the product. The headline: devrig can now bootstrap a headless Remote Development backend entirely from an agent session, completing the capability goals of the product strategy. Beyond that, devrig — the CLI you install and run — grows one unified command surface where every steroid_* MCP tool is a subcommand generated from its own schema, keeps itself up to date automatically, installs the MCP Steroid plugin into your running IDEs, and downloads 14 JetBrains IDE products. The MCP Steroid plugin compiles steroid_execute_code scripts roughly 3×–10× faster with an in-process Kotlin compiler, returns machine-parseable results, is ready for IntelliJ 2026.3 EAP, loads on Android Studio, and picked up a long list of correctness, modality, and Windows fixes.

devrig is the recommended entry point. Direct use of the plugin's HTTP server is still supported (now explicitly marked deprecated in the settings UI), but devrig owns installation, the bundled Java runtime, agent registration, updates, and backend lifecycle.

One name, one home. This release completes a transition: what started as MCP Steroid at mcp-steroid.jonnyzzz.com now lives at devrig.dev — devrig is the product you install and run; MCP Steroid remains the name of the IDE plugin it talks to. The old host redirects permanently.

Breaking changes

  • The applyPatch { } script DSL is removed (#206, #209): at eval scale it failed 64% of invocations. File edits go through the taught single-writeAction multi-edit recipe plus a new apply-unified-diff escape hatch built on the IDE's own patch engine.
  • steroid_list_windows renames projectName / projectPath to snake_case project_name / project_path (#381), matching steroid_list_projects and the tool's own documentation. Consumers reading the old camelCase keys must switch.

Headless Remote Development backends — the strategy milestone

The essential change of 0.102: devrig can now launch a downloaded IDE as a headless managed Remote Development backend with MCP Steroid pre-provisioned — no desktop session, no attached client window. With it, the capability goals of the product strategy are all in place: devrig runs in headless environments end to end, so the full IDE — inspections, refactorings, debugger, test runs — is available to every agent wherever it executes, not only next to a developer's open desktop IDE.

  • Agents bootstrap the whole discover → download → start flow themselves via the prompt articles and server instructions (#449); the backend lifecycle is hardened with pid-marker process tracking (a remoteDevelopmentBackend flag distinguishes backends from desktop IDEs, #451), single-instance locking, and artifact-safety checks (#411, #441).
  • devrig mcp advertises a steroid capability statement at initialize, so schema-deferring harnesses (like Claude Code) learn the steroid_* surface before loading any tool schema (#428, #417).
  • Clean-machine Claude/Codex Docker scenarios validate the workflow end to end. Background: devrig: MCP Steroid Goes Level 3 — Autonomous IDE Setup for AI Agents.

One devrig CLI, generated from the tools' own schemas

Every steroid_* MCP tool is now a first-class devrig subcommand auto-generated from its own schema metadata — adding a tool adds its command, and the served stdio MCP surface registers from the same canonical spec list, so the CLI and the MCP server can never drift (#284, #437, #356); a golden test pins the MCP wire unchanged.

  • One Clikt tree for everything (#442): consistent help, aliases, and error handling; project listing is canonical list_projects (projects / project stay as aliases).
  • Help that routes you (#450, #454): devrig --help is a compact index; the full tool reference moved to devrig tools; missing or invalid parameters route to focused help with the exact allowed values — and parse validation happens before any backend, file/stdin, or --out side effect.
  • Exit codes follow sysexits (#437, #450): parse errors aggregate into one USAGE=64 message, internal faults exit SOFTWARE=70 with a stderr trace, and only I/O failures (plus an open_project --wait poll timeout) map to UNAVAILABLE=69.
  • --json and --out you can build on: JSON payloads are real content[].json objects (no double-decoding for jq) in a shared {tool, command, isError, data} envelope; --out writes atomically and is accepted only where an image can exist; stdin and --*-file inputs reject malformed UTF-8, binary bytes, and >10 MiB payloads.
  • open_project --wait polls until the canonical project path appears in list_projects, then returns the fresh project_name / backend_name / canonical path — and a failed open surfaces its error immediately.
  • The whole surface is an authoritative contract in docs/devrig-cli-contract.md (#452), pinned by unit tests, a real-IDE Docker flow, and live Claude/Codex agent-usability experiments.

devrig keeps itself up to date

devrig now auto-updates (#270, #380): when the published version.json promotes a newer version, running sessions download and run the official installer, coordinated across concurrent devrig processes via per-pid marker files — simple by design: no lock files, no failure-count state, lower-pid-wins races, a stdout-purity test guarding the MCP channel (#373, #268 closed by this design). Design story: Install, Launch, Update: Shipping a CLI on Five Platforms — the devrig Approach.

  • Launcher replacement handles Windows file locks (#385): a rename-aside, rustup-style sequence validated under real NTFS contention (locks that permit rename); an older devrig never overwrites a newer launcher thanks to a version header checked during self-heal (#374).
  • Version numbers finally compare correctly (#360, #358): all build lanes share one token layout (releases are <base>.0-r-<hash>), compared by IntelliJ's VersionComparatorUtil ported into mcp-core (Apache 2.0, NOTICE shipped) — update notifications fire only when the promoted version is strictly newer than the current build.

The Kotlin compiler update: in-process compilation, 3×–10× faster

The fixed per-call Kotlin compiler startup — 7.8 seconds, 94% of wall time — is gone (#207). Snippet compilation moved onto the Kotlin Build Tools API (BTA) with one shared in-process build session per project (#361): the Kotlin daemon machinery is gone, the plugin no longer downloads a kotlinc distribution at all (the compiler jars ship in the plugin, 12→10 jars), and pinning the compiler environment per session cuts warm compiles from 367 ms to 218 ms. BTA is the lever that makes this optimization possible.

Yahor Berdnikau (@Tapchicoma) and the Kotlin team contributed this migration — thank you, Yahor and team, for the collaboration and the support along the way.

  • Compiler messages are structured, remapped to user-code coordinates, and persisted for compilation errors and OOMs.
  • In-process compilation also fixes Windows-side IDEs opening WSL-hosted projects (#78): no kotlinc subprocess to misroute into the WSL distro, and execution storage lives under ~/.mcp-steroid/runs off the \\wsl$ volume (#280) — the mcp.steroid.storage.path workaround is no longer needed.

Ready for IntelliJ 2026.3 EAP and Android Studio

  • The bundled kotlinc is bumped **2.3.20 → ...
Read more

v0.101

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:12

Archived binary mirror of jonnyzzz/mcp-steroid v0.101.

Original publication: 2026-06-24T15:25:05Z.
Upstream tag commit: 406900559ada8d7a1f77ee971369693ca35f0b45.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.101

0.100 introduced devrig. 0.101 makes it the way you actually install and run MCP Steroid.
A single command now downloads devrig and a matching Java runtime, lays them out under your home
directory, and registers a stable launcher — so your agent can connect to an IDE you already have
open, or have devrig download, prepare, start, and stop a managed IDE backend for you.

devrig is the recommended entry point. Direct use of the MCP Steroid plugin's HTTP server is
still fully supported, but we recommend migrating to devrig: it owns installation, the Java
runtime, agent registration, and backend lifecycle, so there is far less to set up and keep in sync.

Independent project. MCP Steroid / Devrig is an independent open-source project. It is
not affiliated with, sponsored by, or endorsed by JetBrains.

One-command install

You no longer assemble devrig by hand. A generated bootstrap installer does it for you:

# macOS / Linux
curl -fsSL https://mcp-steroid.jonnyzzz.com/install.sh | sh
# Windows
irm https://mcp-steroid.jonnyzzz.com/install.ps1 | iex

The installer:

  • Detects your platform (macos/linux/windows × arm64/x64) and downloads the matching
    devrig build and a Java 25 runtime — Amazon Corretto 25 on macOS, Linux, and Windows-x64;
    Azul Zulu 25 on Windows-arm64. You no longer have to install a JDK yourself.
  • Bakes every URL and SHA-256 in at build time — there is no live discovery at install time
    (no GitHub API calls, no vendor lookups). Each download is SHA-256–verified before it is unpacked.
  • Fails fast and clearly when a prerequisite is missing — it never installs system packages
    behind your back; it tells you exactly what to install and stops. musl/Alpine is detected and
    rejected up front (the IntelliJ IDEs require glibc).
  • Hands off to devrig install devrig, so the binary registers its own stable launcher and PATH
    entry. The install script never writes the wrapper itself.

A predictable layout under ~/.mcp-steroid

devrig keeps everything under one fixed home so it is easy to inspect, back up, or remove:

~/.mcp-steroid/
├── bin/
│   └── devrig                       # stable launcher on your PATH (devrig owns + self-heals it)
└── binaries/
    ├── devrig-<os>-<cpu>-<version>-<sha12>/   # unpacked devrig dist, content-addressed
    └── jdk-<os>-<cpu>-<version>-<sha12>/      # the matching Java 25 runtime
  • ~/.mcp-steroid/bin/devrig is owned by the binary, not the install script. Every devrig
    start re-checks the launcher, repairs it if it drifted, and makes sure ~/.mcp-steroid/bin is on
    your PATH (deduped to a single entry on Windows). Whatever you typed to launch it, you end up
    pointing at the one stable launcher.
  • Binaries are content-addressed (<artifact>-<os>-<cpu>-<version>-<sha12>), so the same name
    can never collide between two different downloads, and re-installs are idempotent.
  • The launcher pins the Java 25 it runs under (DEVRIG_JAVA_HOME), so devrig always runs on the
    runtime it shipped with regardless of your system Java.

devrig install is now smoother

  • devrig install <claude | codex | gemini> is idempotent — re-running it upgrades an existing
    registration in place with step-by-step narration instead of failing or duplicating entries
    (#83,
    #84). It also reviews the agent's existing MCP
    servers and consolidates stray devrig entries down to one.
  • devrig install <agent> --check is a read-only doctor: it reports whether the agent is
    registered correctly without changing anything (#86).
  • devrig mcp is now the canonical stdio subcommand (the old devrig mpc stays as a hidden
    alias) (#85).

Smarter backends — start what's installed, list what's there

devrig now reasons about backends as four explicit groups — running-compatible,
running-incompatible, startable (installed but not running), and downloadable — and acts on them:

  • steroid_open_project can start a stopped-but-installed backend for you. If the right IDE is
    installed but not running, devrig starts it, re-provisions the current plugin and VM options, and
    waits until it is reachable — no manual launch step.
  • backend_name routing lets you target a specific backend explicitly when more than one is
    running (#87).
  • list_projects / list_windows no longer mislabel the backend or duplicate their payload, and
    installed plugins are reported as a structured plugins[] section per backend
    (#88,
    #89,
    #90).
  • project_name is now an opaque <name>-<hash> routing key so two projects that share a folder
    name route to the right place, instead of colliding
    (#92).

The cross-process identity behind all of this is the IDE install home recorded in each backend's
marker; a running IDE whose marker predates this (an older, incompatible plugin) is shown in an
"Other IDEs" group and is never offered as an open_project target.

A real settings page, devrig-first

The plugin's Tools → MCP Steroid settings page is back and reworked around agents and devrig
(#80,
#103). It leads with the devrig install
one-liners (copyable, per-OS), shows the actual server port rather than a hard-coded one, carries a
fit-to-paste JSON config block, and flags the legacy raw-HTTP path as the non-recommended option with
a link to the devrig docs.

steroid_execute_code quality-of-life

  • The most-used PSI subpackages are imported by default in scripts, so common recipes need fewer
    import lines (#42).
  • steroid_take_screenshot now reports coordinates in true pixel space, scaling the JFrame
    capture to the X display so steroid_input clicks land where you expect
    (#55).

Recipes & prompts

  • The IDE recipe corpus is genuinely multi-IDE. A per-IDE coverage audit fixed articles (such as
    ide/inspect-and-fix) that were accidentally IntelliJ-only and didn't resolve in PyCharm and the
    other IDEs (#81,
    #98).
  • A "refresh-then-find" idiom teaches scripts to pick up files created outside the IDE instead of
    missing them until a manual sync (#95).
  • action-discovery documents that popup-style actions silently no-op from a headless
    DataContext, with the steroid_input click workaround
    (#62); recipes also warn against
    ActionGroup.getChildren(null) (#70).

Website & build infra

  • Devrig-first website. The homepage and the release/installation pages now lead with the
    devrig install one-liner as the main content
    (#96,
    #97), with branded artwork and a polished
    bridge diagram. The live site now deploys from a long-lived website branch so install-script
    changes that depend on an as-yet-unreleased binary stay off the live site until the matching release
    exists.
  • :installer-gen is a new build-tooling module that computes the JDK data model (latest Corretto
    25 / Azul Zulu 25, resolved live and OpenPGP-verified against pinned key fingerprints on every
    run
    ) and generates the install.sh / install.ps1 scripts from it. Nothing is hand-pinned.
  • :website-gen now generates version.json and updatePlugins.xml in Kotlin (Ktor), replacing
    the old Python/Make pipeline and matching the published XML byte-for-byte.
  • Windows launcher uses a pathing JAR, fixing the "input line is too long" failure on Windows.
  • The dead :jdk-downloader and :pgp-verifier modules were removed, and a compileAllClasses
    task + a GitHub "Compile Check" action now gate every merge.

Plugin Verifier

Verified against the primary target IntelliJ 2026.1 (261.22158.277): Compatible, 0 internal-API
usages
(the hard release gate) and 6 experimental-API usages. Against the secondary EAP target
2026.2 (262.8117.19): Compatible, 5 experimental-API usages and 8 internal-API usages —
the two PluginManagerCore methods (getPlugin, getLoadedPlugins) that 2026.2 newly marks internal
and that have no public replacement available on both 2026.1 and 2026.2 (tracked upstream as
IJPL-246183), plus six ProgressModel members used
by the new window/background-task listing (IdeWindowsCollector), which 2026.2 also marks internal.
All are public on the shipping 261 target; they will be migrated before 2026.2 ships.

Known issues

Read more

v0.100

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:14

Archived binary mirror of jonnyzzz/mcp-steroid v0.100.

Original publication: 2026-06-01T23:21:40Z.
Upstream tag commit: 409f23a20aa1bf21b78bd27c3a172b7962c8f0f2.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.100

This is a landmark release. MCP Steroid is beginning its move toward Devrig, and the
headline is a brand-new command-line tool — devrig — that becomes the foundation for where
this project is going. Try it, share what you think.

Independent project. MCP Steroid / Devrig is an independent open-source project. It is
not affiliated with, sponsored by, or endorsed by JetBrains.

Meet devrig — a CLI that gives your agent a whole IDE

devrig is a new standalone command-line tool that gives Claude Code, Codex, Gemini, and
other MCP-capable coding agents a CLI and stdio MCP bridge into a real IntelliJ-family IDE. It can
connect to an IDE you already have open, or it can download, prepare, start, and stop a managed IDE backend
itself
: fetch an IntelliJ distribution (e.g., IDEA Community, Android Studio, PyCharm, IntelliJ Ultimate),
install the MCP Steroid plugin into it, and run it, so your agent gets a working IDE with no manual setup.

The first CLI surface is intentionally practical:

  • devrig mpc — run the stdio MCP server (this is what your agent talks to).
  • devrig backend download | start | stop | provision — manage IDE backends.
  • devrig install <claude | codex | gemini> — register the devrig MCP server with an agent
    using the correct per-agent syntax, so the steroid_* tools appear immediately.
  • devrig project, devrig version, devrig help — the usual operator checks.
  • let us know which commands to add — the usual feedback request.

devrig keeps its state under a fixed ~/.mcp-steroid home. It ships without a bundled
runtime and is compiled for Java 25, so the agent host must provide a JDK/JRE 25+ —
on PATH, via JAVA_HOME, or via the DEVRIG_JAVA_HOME launcher override (which points only
devrig's own process at a Java 25). Install
Amazon Corretto 25
or any other JDK to run devrig.

devrig is a preview and the foundation for future work — expect it to grow quickly.

IntelliJ 2025.3 (build 253) is no longer supported

The plugin no longer builds or runs against IntelliJ 2025.3 (253). The primary baseline
is now IntelliJ 2026.1 (261), with 2026.2 EAP (262) kept as a secondary
verification target: since-build = 261, and the managed-backend compatibility floor is also
261. That platform move brought the build to JDK 25, Kotlin 2.3.20, and Ktor
3.3.2, matching what the 2026.1 line bundles, and the build now fails earlier when a
JDK-25 or IDE-bundled-library assumption drifts. Android Studio support starts from the Quail 2.

steroid_execute_code gets an explicit modal mode

steroid_execute_code now takes a typed modal parameter instead of the earlier mix of
dialog-killer and allow-modal switches. There are three modes:

  • smart_non_modal — the default agent workflow: close stray dialogs, verify the IDE is
    non-modal before sensitive work, commit documents, refresh VFS, and wait for smart mode.
  • non_modal — asserts the IDE is non-modal at start only; no document sync, VFS refresh,
    smart-mode wait, or mid-run dialog monitoring.
  • unleashed — for intentional modal-dialog workflows.

The lower-level context methods (closeModalDialogs, monitorAndCloseModalDialogs,
syncDocuments, allowModalDialog) remain available inside scripts for cases that need finer
control. Modal-dialog behavior is now a clear contract rather than a set of ad-hoc booleans.

A narrower, more focused tool surface (10 → 8)

Staying true to the project's philosophy — give the agent the whole IDE through
steroid_execute_code and recipes, not a wide tool catalogue — two MCP tools were removed:

  • steroid_action_discovery is gone; the same workflow now lives as the
    mcp-steroid://ide/action-discovery recipe fetched through steroid_fetch_resource.
  • steroid_apply_patch is gone; multi-site edits use the in-script applyPatch { } DSL
    from steroid_execute_code, guided by the mcp-steroid://ide/apply-patch recipe.

The MCP surface is now 8 focused tools. Two related changes for anyone upgrading from 0.95:

  • steroid_input now targets a window by window_id (from steroid_list_windows /
    steroid_take_screenshot) instead of the old screenshot_execution_id — a breaking change
    to that tool's input.
  • The mcp-steroid:// recipe corpus is now reached only through steroid_fetch_resource;
    it is no longer advertised via the generic MCP resources/list / prompts/list surfaces
    (fetching the right IDE-conditional article needs the project context the tool carries).

Human review mode removed

The human-in-the-loop review gate has been removed in full — the review.* registry keys, the
mcp.steroid.review.mode system property, the execution-storage review-file helpers, the
review configuration classes, and the associated docs and website pages are all gone. The
product is focused on agent-driven IDE execution rather than a human-gated review step.

Other improvements

  • Build-abort guidance. When a build is aborted without errors, steroid_execute_code now
    appends a short "required action" hint pointing the agent at the Maven/Gradle sync recipe,
    instead of leaving it to guess why the build produced nothing.
  • Token-efficient tabular output. printCsv and printToon helpers were added to the
    script context for compact tables in steroid_execute_code output
    (#34,
    #35).

Infra & build

  • intellij-downloader is now an in-repo Gradle subproject used by both the plugin build
    and devrig's managed-backend path. It resolves and unpacks IntelliJ archives directly
    (replacing the old useInstaller path), handles Community and Android Studio resolution, and
    extracts Windows installers via a bundled 7-Zip — no external tooling required.
  • IDE downloads and managed-backend cache entries are hash-qualified so Community and
    Ultimate archives that share a filename cannot collide.
  • kotlinx-coroutines-core is pinned to 1.10.2 and kotlinx-serialization to 1.9.0 to
    match the 261 runtime. Two new gates — verifyBundledLibraries and
    verifyBundledKotlinxRuntime — fail the build on manifest-level or runtime-linkage drift.
    These IDE-bundled jars are still never shipped inside the plugin zip.
  • The devrig↔plugin tool-call wire contract is documented as additive-only and pinned by
    contract tests, including the full steroid_execute_code parameter set
    (#23).
  • All host-side test JVMs now run headless, and a large Docker suite exercises devrig end
    to end — managed-backend provisioning and the stdio-agent matrix across Claude/Codex/Gemini.
  • The devrig CLI zip is now built and attached as a release artifact alongside the plugin zip.

Plugin Verifier

Verified against the primary target IntelliJ 2026.1 (261.22158.277): Compatible, 0
internal-API usages
(the hard release gate) and 6 experimental-API usages. Against the
secondary EAP target 2026.2 (262.6653.22): Compatible, with 6 experimental-API usages
and 2 internal-API usages — two PluginManagerCore methods (getPlugin, getLoadedPlugins)
that 2026.2 newly marks internal. There is currently no public replacement available in both
2026.1 and 2026.2 (the successor PluginDetailsService exists only in 2026.2), so this is
tracked upstream with JetBrains as IJPL-246183
and will be migrated before 2026.2 ships.

Fixed issues

  • #76 — steroid_execute_code scripts
    could fail with a ClassCastException on service<T>() for split (content-module) plugins;
    ideClasspath() / the script classloader now include content-module classloaders.
  • #75 — implemented
    resources/templates/list so MCP clients (e.g. Claude) no longer get a repeated
    "Method not found".
  • #64 — devrig install <agent>
    auto-registers the MCP server with Claude / Codex / Gemini using the correct per-agent syntax.
  • #60 — the steroid_execute_code tool
    description now states the last expression is not auto-printed and to use println()/printJson().
  • #52 — steroid_execute_code now runs in
    the smart_non_modal mode, which waits for smart mode before executing, so agent runs no longer
    start while the project is still indexing.
  • #46 — an steroid_execute_code request
    cancelled or timed out under indexing now returns a clean cancellation result instead of an
    opaque HTTP 500 (guarded by integration tests).
  • #53 — improved the debugger prompt recipes.
  • #34,
    #35 — added the printToon / printCsv
    token-efficient tabular output helpers, including dictColumns path de-duplication.
  • #23 — froze the devrig↔plugin tool-call
    wire contract as additive-only and pinned i...
Read more

v0.95.0

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:15

Archived binary mirror of jonnyzzz/mcp-steroid v0.95.0.

Original publication: 2026-05-11T13:38:16Z.
Upstream tag commit: b14969e109f0efd9747798ad959e90433f449169.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.95.0

McpEditingGuard — Memory-vs-Disk Modal Hardening

Both steroid_execute_code and steroid_apply_patch now run their bodies through a single guard that owns the before/after flow: modality fail-fast (DialogKiller dismisses leftover modals, otherwise we abort with a clean MCP error instead of parking on the EDT), pre-flight commit + saveAllDocuments + awaitRefresh (every open document's mod-stamp matches disk before the body runs, so the platform's MemoryDiskConflictResolver short-circuits naturally), prefer-disk reload override scoped to the body's lifetime (belt-and-braces against the rare race where the user edits a file while the agent writes it), and post-flight awaitRefresh (picks up disk changes from external commands the body invoked). The modal "memory differs from disk" dialog no longer blocks the IDE — #27.

New MCP Resource: mcp-steroid://ide/find-duplicates

Typed PSI-based recipe for extracting clone pairs from IntelliJ's DuplicatedCode global inspection (LocalInspectionToolWrapper(DuplicateInspection()) → InspectionEngine.runInspectionOnFile). Direct import com.jetbrains.clones.DuplicateProblemDescriptor + dpd.textClone access — the duplicates-detector module is already on the script classpath in IDEA Ultimate, so no private-field reflection or setAccessible(true) is needed. Previously agents probed JavaPsiFacade (which only sees user-project classes, not plugin classes), concluded the class was unavailable, and reached for reflection — #33.

The supporting reflection policy is now stated in mcp-steroid://skill/mcp-steroid-info (the startup-instructions text every agent reads) and the top-level coding-with-intellij skill guide: typed imports first, probes for classpath-presence are allowed, private-field reflection in shipped recipes is not.

Three Agent-First Design Tenets Codified

New canonical statement at docs/PHILOSOPHY.md, mirrored at runtime as mcp-steroid://skill/design-philosophy (fetch via steroid_fetch_resource). Three tenets that until now were implicit:

  1. The MCP tool surface stays narrow. 10 tools today; new tools require a three-gate test (rule out the IntelliJ API, rule out a richer recipe, three-agent quorum).
  2. Power lives in prompts and direct IntelliJ APIs inside steroid_execute_code, not in new tools.
  3. McpScriptContext methods are last-resort. The whole IntelliJ API surface is reachable from scripts; helpers there compete for attention with everything else.

Per-folder CLAUDE.md / AGENTS.md guides (ij-plugin, prompts, test-integration, test-experiments, docs, website) and the README now cite the tenets in their own scope. The README's tool table was genuinely stale (claimed 9 tools, listed an obsolete Capabilities Discovery row) — it now lists all 10 tools with their steroid_* API names. steroid_input's description was also stale ("OCR analysis"); fixed.

DialogWindowsLookup — Synchronous Modality Check

The old timeout-driven probe dispatched to the EDT with a 100 ms ceiling: false positives under IDE load (a busy EDT looked exactly like a parked one, so steroid_list_windows and the dialog-killer path flagged a modal whenever the IDE was just slow), and a permanent +100 ms tax on every call when the EDT was actually parked. Replaced by isModalDialogShown() — one EDT dispatch with ModalityState.any() reading ModalityState.current(). Non-equal to ModalityState.nonModal() means elevated modality, the only condition we need before enumerating dialog windows. Progress modals (Task.Modal, write-action queues) — which elevate modality but are not user-consent prompts — still get filtered out by the existing isModal predicate downstream.

Tool-Handler Architecture: Spec + Handler + IJ Service

Internal refactor. Each MCP tool now has a Spec class that owns the MCP schema and JSON-arg parsing, an interface for the handler entry point, and an @Service IDE-level implementation. Typed @Serializable param classes replace the raw JsonObject plumbing through ExecutionStorage and the handlers. Per-handler local errorResult helpers are gone — shared ToolCallResult.errorResult / successTextResult extensions instead. Tool handlers also use lazy initialization via lambda + a PromptsContextHandler interface for prompts-context injection. Improves testability and per-tool isolation.

steroid_execute_code: Drop required_plugins Parameter

The feature was never useful in practice — scripts that reference plugin classes either work (the plugin is loaded) or fail at compile time with a clear error. The parameter is removed from the tool schema; existing scripts that didn't use it are unaffected.

Other

  • steroid_fetch_resource requires project_name (was already required for the IDE-conditional filtering but the test helper omitted it on a few cases — now consistent).
  • McpScriptContext.params field dropped (was unused).
  • Editor-config added; .* imports eliminated across the codebase.
  • McpServerIntegrationTest pins protocol correctness under concurrent tools/call — 4 parallel steroid_execute_code requests on a single session must keep JSON-RPC ids, error states, and result payloads cleanly separated (regression guard for Claude's 60 s MCP-tool timeout + retry-storm path).
  • ExecutionStorageTest.findExecutionId now exercises writeNewExecution, writeToolCall, and writeExecutionFeedback — the previous gap let a params.json-write regression slip through.

Plugin Verifier: Still Zero Internal-API Usages

Compatible against both IntelliJ 2025.3 (IU-253.28294.334) and 2026.1 (IU-261.22158.277), 0 internal-API usages (hard gate). Experimental API usages: 4 (up from 3 in 0.94.0). The new entry is the suspending overload RefreshQueue.refresh(boolean, List, Continuation) invoked from VfsRefreshService.awaitRefresh — a public replacement for the old callback API. The four entries are: IdeaPluginDescriptorExtensions (class reference + getContentModules invocation in ScriptClassLoaderFactory), RefreshQueue.refresh(suspend) in VfsRefreshService, and suspending CoroutinesKt.writeAction in McpScriptContextImpl. All are public IntelliJ APIs that IntelliJ itself flags as experimental.

Test Infrastructure

The KtBlock compilation tests (under :prompts) — which compile every kotlin code fence in the prompt corpus against each downloaded IntelliJ distribution's classpath via an external kotlinc subprocess — now derive -jvm-target from the running JVM (java.specification.version) and pin the test JVM to JDK 25 to match the JBR bundled inside every tracked IDE. A new assertTestJreMatchesIdeBundled canary fails loudly if a future IDE bumps its bundled JBR major. Fixes the 2026.1.x EAP cannot inline bytecode built with JVM target 25 into bytecode that is being built with JVM target 21 error on TC.

Fixed Issues

  • #27 — VFS Modal Dialog blockage (now McpEditingGuard).
  • #33 — DuplicatedCode inspection: agents forced to use private-field reflection to extract clone pairs (now mcp-steroid://ide/find-duplicates recipe + reflection policy in root prompts).

v0.94.0

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:16

Archived binary mirror of jonnyzzz/mcp-steroid v0.94.0.

Original publication: 2026-05-05T10:28:30Z.
Upstream tag commit: 8682a5cebabea86cd3514f105a797c56ac0f252c.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.94.0

New MCP Tool: steroid_apply_patch

Atomic multi-file batch edits in one MCP call. Input: {project_name, hunks: [{file_path, old_string, new_string}, ...]}. All hunks land inside a single WriteCommandAction (one undoable command "MCP Steroid: apply-patch (N hunks)"); per-file descending offset order; pre-flight rejects missing or non-unique old_string matches before touching any document; touched documents are saved before the call returns. Microshop-2 benchmark: 8 hunks across 8 files in ~66 ms, zero Edit fallbacks. Same engine is exposed in scripts as applyPatch { hunk(file, old, new); ... } on McpScriptContext.

New MCP Resources

  • mcp-steroid://ide/apply-patch — multi-site literal-text edit recipe (DSL form).
  • mcp-steroid://skill/execute-code-gradle — Gradle test execution: prefer IDE path (ProjectTaskManager.build), wait for ProjectDataImportListener.onFinalTasksFinished, surface failure cause from BuildView, toolchain-vendor + disabled-test-task patterns.
  • mcp-steroid://skill/apply-patch-tool-description — tool-description article for the new tool.

Rewritten / Expanded Resources

  • mcp-steroid://lsp/rename — semantic rename via RenameProcessor instead of regex; correctly handles overrides, qualified references, annotation strings, dry-run.
  • mcp-steroid://skill/execute-code-maven — pinned to the SM data-model approach (poll SMTestProxy instead of layering listeners), captures Run console via ProgramRunner.Callback, two-call test pattern (compile → run).
  • mcp-steroid://skill/execute-code-tool-description — explicit threading-wrap rules surfaced on read-action errors; in-place edit recipe; apply-patch routing.
  • mcp-steroid://skill/coding-with-intellij* — Observation.awaitConfiguration + smartReadAction for indexed reads (replaces unreliable waitForSmartMode).

DialogKiller Replaces ModalityStateMonitor

The 236-line ModalityStateMonitor is gone. DialogKiller runs as a periodic EDT poll, dismisses real DialogWrapper windows, and ignores coroutine progress entities and elevated ModalityState.any() blocks. Side effects: Maven and Gradle test runs no longer get cancelled mid-flight; SDK-lookup banners stop being flagged as modals. New per-call dialog_killer: true|false parameter on steroid_execute_code lets a script opt in/out.

Bug Fixes

  • steroid_action_discovery wraps lookup in a read action and drops over-eager action-group expansion (which also removed an internal-API call to Utils.expandActionGroupSuspend) — #24.
  • steroid_open_project calls TrustedPaths.setProjectPathTrusted(true) before opening, eliminating the trust modal on freshly cloned projects — #28, #30.
  • steroid_execute_feedback now aggregates every validation error in one response instead of failing on the first.
  • Tooltip text retrieval wrapped in a read action.
  • ExceptionCaptureService survives JUL records with null LogRecord.parameters; original IDE error is no longer masked.
  • DialogWindowsLookup no longer flags elevated ModalityState.any() blocks as modal dialogs.

Output Hints from steroid_execute_code

  • Script produced no user output → response appends a hint to add println(...).
  • Build/Compile result errors=false, aborted=true → response appends REQUIRED ACTION: NEXT TOOL CALL must be mcp__mcp-steroid__steroid_fetch_resource with the matching Maven/Gradle resource URI.

VfsRefreshService (Pre-Compile Awaited + Post-Exec Refresh)

New project-level service. CodeEvalManager calls awaitRefresh() (suspending, 30 s cap, bridges RefreshQueue.refresh(async=true) via CompletableDeferred) before kotlinc compiles a script, and scheduleAsyncRefresh() (fire-and-forget) in the finally after every steroid_execute_code and steroid_apply_patch call. PSI sees up-to-date files between back-to-back script calls without callers writing their own refresh boilerplate.

Plugin Verifier: Zero Internal-API Usages

Building on 0.93.0's reduction (29 → 4): the action-group expansion path was the last avoidable internal-API call. The 0.94.0 binary reports 0 internal-API usages against both IntelliJ 2025.3 and 2026.1 under Plugin Verifier. Three experimental references remain — all of them public replacements that IntelliJ itself flags as experimental (IdeaPluginDescriptor.contentModules, suspending writeAction).

~10× Faster No-Change TDD Loop

External contributor Dmitry Protsenko (@NordCoderd) traced four orthogonal sources of cache invalidation in the build (#26): LocalDateTime.now() outside deployPlugin invocations (kept generateMetadata out-of-date), the orphaned Random.nextInt() seed in GenerateMetadataTask (orphaned after the time-bomb feature was removed), missing inputs/outputs on npmBuild, and per-run If-Modified-Since round-trips for tessdata. Atomic OCR + Kotlin compiler downloads guard against corrupted-on-disk files. No-change ./gradlew :ij-plugin:test drops from ~28 s to ~3 s.

SDK-Lookup Modal Hardening

Three independent IntelliJ entry points fire an "Unknown SDK" / "Resolving SDKs…" modal on project open. The plugin now disables all three (-Dunknown.sdk=false, -Dunknown.sdk.auto=false, -Dunknown.sdk.modal.jps=false) and ships mcpListJdks / mcpAddJdk / mcpRegisterJdks driver helpers. Pre-registers bare/corretto-N/temurin-N aliases for every JDK on the agent before the IDE's SdkLookup task can race in. JDK setup is skipped cleanly on non-Java IDEs (PyCharm, GoLand, WebStorm, Rider).

Other

  • Ktor MCP idle timeout raised to 600 s (long Maven/Gradle test runs no longer drop the connection).
  • New integration tests pinned to real flows: YouTrackDbMavenTest (split for 253 + 261), KeycloakMavenTest, RetrofitGradleTest → IntelliJPlatformGradleTest, OpenProjectTrustIntegrationTest, IntelliJThisLoggerLookupTest.
  • Dropped unused SkillReference class and SteroidsMcpServerStartupActivity.

Fixed Issues

  • #23 — VFS refresh: awaited before kotlinc + fire-and-forget after exec (now VfsRefreshService).
  • #28 — steroid_open_project should trust project path before opening.
  • #29 — Delayed IndexNotReadyException in IntelliJ monorepo MCP symbol lookup (now Observation.awaitConfiguration + smartReadAction documented in coding-with-intellij* resources, regression-tested via IntelliJThisLoggerLookupTest).

Contributors

Thank you to the contributors in this release:

v0.93.0

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:17

Archived binary mirror of jonnyzzz/mcp-steroid v0.93.0.

Original publication: 2026-04-18T07:11:24Z.
Upstream tag commit: effb0b5a3d263245408a89a40a46ae10dfdb598a.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.93.0

Plugin Verifier Compliance: Fewer Internal API Usages

Six internal IntelliJ API usages have been replaced with public or experimental alternatives. The plugin verifier now reports only 4 unavoidable internal API references (where no public alternative exists) — down from 29.

Key replacements:

  • PluginMainDescriptor → public IdeaPluginDescriptor.contentModules extension
  • DaemonCodeAnalyzerImpl.getLineMarkers() → public DocumentMarkupModel API
  • AppLifecycleListener.appStarted() → public appFrameCreated()
  • OpenProjectTask internal builder → public build().copy()
  • serviceAsync<T>() → stable service<T>()
  • writeAction {} → stable edtWriteAction {} in ReviewManager

MCP Server Instructions Rewritten

The instructions agents see when they connect to MCP Steroid are now concise and exec_code-first:

  • Declares MCP Steroid as a stateful API and drop-in replacement for LSP
  • Three-step getting started: list_projects → fetch_resource → execute_code
  • Removed the skill guide routing table that agents never read (0/69 arena runs)

New Tool: steroid_fetch_resource

A new MCP tool for loading mcp-steroid:// skill guides. Task-aware description maps intent to the right resource:

  • Running tests? → mcp-steroid://prompt/test-skill
  • Debugging? → mcp-steroid://prompt/debugger-skill
  • Any IDE task? → mcp-steroid://prompt/skill

Improved steroid_action_discovery

The tool description now explains the discovery→exec_code workflow: call action_discovery first to learn available quick-fixes and gutter actions, then invoke them via steroid_execute_code.

Maven Test Execution Fix

Fixed a critical bug where the ModalityStateMonitor killed Maven test execution prematurely. MavenShCommandLineState.startProcess() uses runWithModalProgressBlocking, which creates a JobProviderWithOwnerContext — a coroutine-based progress entity, not a UI dialog. The monitor now skips JobProvider entities.

Integration Tests for Maven and Gradle Test Execution

New Docker-based integration tests validate end-to-end test execution:

  • MavenTestExecutionTest: Maven tests via ProgramRunnerUtil.executeConfiguration() with process exit code validation
  • GradleTestExecutionTest: Gradle tests via GradleRunConfiguration.setRunAsTest(true) + SMTRunner events

Hardcoded URI Lint Rule

New NoHardcodedMcpSteroidUriUsageTest enforces that production code uses generated XxxPromptArticle().uri instead of hardcoded mcp-steroid:// string literals. Comprehensive KDoc documents how to fix violations.

CI and Infrastructure

  • GitHub Actions: FORCE_JAVASCRIPT_ACTIONS_TO_NODE24 added to all workflows
  • TeamCity: artifact post-processing for 1080p video + slim zip
  • escapeShellArgs properly quotes glob/meta characters for Docker exec
  • Linux bind-mount UID handling for TC agents
  • Codex default model updated to gpt-5.4, Gemini to gemini-3.1-pro-preview

Cleanup

  • Removed all steroid_capabilities references (tool was removed)
  • Fixed steroid_open_project docs (trust_project defaults to true, removed non-existent force_new_frame parameter)
  • Updated resource access guidance to use steroid_fetch_resource instead of ReadMcpResourceTool
  • Plugin description now says "80+ MCP Resources" (was stale "58")

v0.92.0

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:21

Archived binary mirror of jonnyzzz/mcp-steroid v0.92.0.

Original publication: 2026-04-08T11:34:36Z.
Upstream tag commit: 59b7897614ba0b24a00c19659a6da424d1b27631.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.92.0

MCP Steroid Is Now Open Source and Supported by JetBrains

MCP Steroid is now licensed under Apache 2.0 and officially supported by JetBrains. This release marks a milestone for the project — the full source is available for community contributions, audits, and forks. Read the full announcement: MCP Steroid Goes Open Source

Your IDE Skill Factory

MCP Steroid is more than a code-execution bridge — it is your IDE Skill Factory. Each prompt resource, each steroid_execute_code call, each debugging session is a scenario we collect and refine to make AI agents more capable in the IDE. We are actively gathering real-world workflows. Learn more and contribute yours: MCP Steroid as Skill Factory

Critical Bug Fix: Script Classpath (#16)

Content module JARs were missing from the script compile classpath. This caused compilation failures for code using classes from IDE content modules — including Kotlin plugin internals and Java API wrappers provided by bundled plugins. AI agents would receive unresolved reference errors even for APIs that are clearly available in the IDE.

The fix ensures that all JARs from loaded plugin classloaders are included when building the script classpath. (#16)

Exact Error Locations in Your Code

When something goes wrong, agents now see exactly where — in your code, not in the internal wrapper.

  • Compiler errors now report the line number in the user-supplied code block, not in the generated wrapper class. A syntax error on line 3 of your snippet is now reported as line 3, not line 47.
  • Runtime stack traces are remapped the same way: exception frames pointing into MCP Steroid's wrapper code are translated to the original user-code line.
  • Framework and wrapper frames are stripped from stack traces entirely, leaving only the frames that matter for diagnosis.

Cleaner Tool Output

Per-call boilerplate messages — FILE DISCOVERY, PRO Tip, TIP — have been removed from every tool response. These static hints were repeating on every invocation and adding noise without value. Output is now focused on execution results.

McpScriptContext Available as Prompt Resource

McpScriptContext — the object giving scripts access to the project, disposable, println(), progress(), and other IDE integration helpers — is now documented as a built-in MCP resource article. Agents can browse it via mcp-steroid://skill/coding-with-intellij.

Update Notification Now Includes Download Link

When a newer version of the plugin is available, the in-IDE update notification now shows a direct download link, making it faster to grab the latest release without navigating to the website.

0.91.0

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:22

Archived binary mirror of jonnyzzz/mcp-steroid v0.91.0.

Original publication: 2026-03-28T15:34:05Z.
Upstream tag commit: 584d30248ee6e42ba686eb714b9057317a9fef0e.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.91.0

Compilation Error Visibility Fix

AI agents can now see full compilation error details. Previously, when code failed to compile, agents like Claude Code only saw "Execution ID: eid_..." — the actual compiler error message (type mismatches, unresolved references, syntax errors) was invisible. This made it impossible for agents to diagnose and fix compilation failures.

Root cause: The MCP tool result contained multiple separate text content items, with the execution ID as the first entry. Some MCP clients only render the first text item when isError=true, hiding all subsequent content including the compiler output.

Fix: Tool results now always merge all text into a single content block, ensuring the complete output — compiler errors, warnings, hints — is visible to every MCP client. (#14)

Progress Reporting Fix

MCP progress notifications were silently discarded because ExecuteCodeToolHandler was not passing the progress reporter through to the execution engine. Agents using _meta.progressToken now receive real-time progress updates during code compilation and execution.

The mcpProgressReporter parameter on ExecutionManager.executeWithProgress() is now mandatory (no default value), preventing this class of bug from recurring.

Other Improvements

  • Cleaner tool output: Removed duplicate "Execution ID:" line and "use it to report feedback" noise from tool responses.
  • EULA fix: The plugin build and GitHub releases now correctly bundle the EULA instead of the Apache 2.0 license.
  • Test infrastructure: Added AiProcessResult type with rawStdout for accessing unfiltered NDJSON output. Made ProcessResult extension functions generic to preserve concrete types through chaining.
  • Compilation error/warning tests now run for all three agents (Claude, Codex, Gemini) via CliIntegrationTestBase.
  • Website restructure: The website/ folder is now a separate repo clone, gitignored from the main repository.

0.90.0

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:23

Archived binary mirror of jonnyzzz/mcp-steroid 0.90.0.

Original publication: 2026-03-02T18:21:04Z.
Upstream tag commit: a90bf9d902ca0771893d7b53c187aab6c65bd476.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.90.0

  • Previous tag: 0.89.0 (release commit b8388824)
  • Commit range: b8388824..HEAD

ClaudeCode debugs an application in Rider -- MCP Steroid

https://www.youtube.com/embed/g73vZCO-YRw

In this video, ClaudeCode drives Rider debugger workflows through MCP Steroid, including breakpoint setup, debugger control, and IDE-driven test execution.

DPAIA Arena: First Success Metrics

As of 2026-03-02, the first completed A/B comparison set shows:

  • Fix rate: 4/4 with MCP Steroid and 4/4 without MCP.
  • Average agent time: 412s with MCP vs 526s without MCP.
  • Net speedup: MCP was 22% faster on average (114s gain per case).
  • Cost: MCP was about 10% cheaper across our 4-test experiment set.
  • Strongest gains were on complex multi-file tasks (21-27% faster), while simple search-and-replace tasks were effectively neutral.

Prompt Platform Rework

  • Added a dedicated prompts-api module (ArticlePart, IdeFilter, PromptsContext) and reworked generation around article parts with computed filters.
  • Migrated prompt articles to the single-article model with line-2 filters and fence annotations, including multi-IDE filter support.
  • Replaced SkillCatalog YAML frontmatter with article properties and removed obsolete filter code paths.
  • Moved prompt quality gates into the prompts pipeline (KtBlock compilation and debugger prompt quality coverage).

Additional Validations

  • Added article quality contract tests and stricter prompt content checks.
  • Updated prompt examples to compilable fences and replaced deprecated IntelliJ 2025.3 API usages.
  • Included kotlinc version in KtBlock compilation cache keys to prevent stale cache reuse across compiler upgrades.
  • Hardened release/update validation by using actual GitHub release asset URLs for updatePlugins.xml, failing fast on missing VERSION/release URL values, and preventing non-plugin asset selection.

Rider and Debugger Workflow Maturity

  • Added Rider to IntelliJ debugger support coverage with dedicated Rider integration/debugger test flows.
  • Introduced RLVR-based Rider debugger prompt iteration: agents were trained in a virtual environment to test and refine prompts for reliable debugger support.
  • Added Rider IDE integration coverage for debugger workflows and introduced RiderPlaygroundTest for interactive debugging sessions.
  • Improved debugger prompts for event-driven suspension, idempotent breakpoints, and Rider/.NET expression handling.
  • Added run-test-at-caret prompt workflows and fixed action IDs/caret targeting in debugger demos.
  • Extracted shared debugger test helpers to reduce duplication between IntelliJ and Rider demo tests.

Build & Infrastructure

  • Extracted intellij-downloader and kotlin-cli modules and moved related tests into the new module boundaries.
  • Fixed IDE downloader platform resolution in containerized runs (correct archive per OS).
  • Improved integration-run stability via warm snapshot bootstrap hardening and test-suite parallelism controls.
  • Fixed ScriptExecutor timeout test behavior and excluded Docker CLI tests from the default fast suite.

0.89.0

Choose a tag to compare

@jonnyzzz jonnyzzz released this 02 Nov 10:23

Archived binary mirror of jonnyzzz/mcp-steroid 0.89.0.

Original publication: 2026-03-02T18:20:54Z.
Upstream tag commit: a90bf9d902ca0771893d7b53c187aab6c65bd476.

Assets retain their original filenames and bytes, verified against the upstream GitHub SHA-256 digests. The original license/EULA assets accompany each release where present. This repository hosts the static website and the binary archive.


0.89.0

  • Previous tag: 0.88.0 (release commit d681c911)
  • Commit range: d681c911..HEAD

Demo: Codex Debugs in IntelliJ IDEA

Codex debugs an application in IntelliJ IDEA

In this video, Codex debugs an application in IntelliJ IDEA. The demo is powered by the MCP Steroid plugin for IntelliJ-based IDEs, https://mcp-steroid.jonnyzzz.com.

Codex Agent Output Support

Full support for Codex NDJSON output format — handles mcp_tool_call items with their distinct field names (tool instead of name, arguments instead of input), structured result objects, and reasoning items rendered as [thinking] blocks. Raw and decoded agent logs are now saved per prompt run.

Prompt System Overhaul

  • Migrated all articles from multi-file (header + kts) to single-file .md format
  • Merged -see-also.md files into main article files
  • Added ###_NO_AUTO_TOC_### / ###_EXCLUDE_FROM_AUTO_TOC_### directives for fine-grained TOC control
  • Per-article read tests are now auto-generated
  • Removed old-format article support from buildSrc codegen
  • Migrated tool descriptions to prompt article resources

Docker Test Infrastructure Refactoring

Major refactoring of the Docker container process runner and agent infrastructure:

  • Replaced runInContainer with startProcessInContainer across all drivers
  • Consolidated container process types into docker-container-exec-detached.kt
  • Channel-driven stdin for ConsoleDriver (replacing per-line docker exec)
  • Real-time console pumping in ConsoleAwareAgentSession with raw + decoded log files
  • Interactive docker exec support (-i flag)
  • Coroutines Channel for ProcessRunner output (no busy loop)

DPAIA Arena Testing

Introduced Docker-based A/B comparison testing infrastructure (DPAIA — Developer Productivity AI Assessment) for measuring agent effectiveness with vs without MCP Steroid. Includes automated test pipeline with iterative improvement loops, bare git repo caching, JDK auto-configuration, Maven/Gradle import awaiting, and per-product smoke tests.

Plugin & Build Improvements

  • Extracted plugin build into dedicated ij-plugin/ subproject
  • Plugin deployment hot-reload via deployPlugin task
  • MCP server now starts at IDE startup via AppLifecycleListener
  • execution_id made optional in steroid_execute_feedback
  • Release builds only include release notes in plugin.xml (skip for snapshots)
  • Upload LICENSE to GitHub releases with full URLs

Settings & UI

  • New MCP Steroid project settings page (Tools > MCP Steroid) with copy buttons and structured connection info
  • Human review workflow reworked: renamed actions, isReviewRequired() logic, Always Allow option with warning icon
  • Screenshot capture now includes modal dialogs

Agent Compatibility

  • Claude Code 2.1.x new structured event format support in ClaudeOutputFilter (handles both old streaming and new structured formats)
  • Output filters pass through unknown JSON events (future-proof)
  • Generic toolDetail() extracts human-readable summary for all known tools

Stability & Bug Fixes

  • Fixed AIPromoWindowAdvisor 8-minute startup deadlock in Docker containers
  • Fixed Islands Theme onboarding dialog blocking test containers
  • Fixed CodeButcher import extraction from triple-quoted string literals
  • Fixed AiAgentDriver NPE with lazy property ordering
  • Fixed DISPLAY env var propagation in container processes
  • Fixed Docker reaper image tagging and container ancestry filter
  • Renamed "IntelliJ MCP Steroid" to "MCP Steroid" across codebase

Build & Infrastructure

  • KtBlocks compilation test infrastructure for verifying code examples in prompt articles
  • ScriptClassLoaderFactory interface for test classpath isolation
  • Compilation tests made stable across build re-runs
  • Increased IDE window detection timeout with better diagnostics
  • Concurrent test run protection documented (shared idea-sandbox/ corruption)