Model or dataset
oisee/vibing-steampunk avatar
oisee/vibing-steampunk

vsp reads SAP's cluster tables over ADT, and its safety switches ship commented out

vs-punk: ADT to MCP bridge - Vibe code in ABAP / AMDP

530 stars138 forksGoMIT

At a glance

What is it?
Vibing Steampunk is a Go binary that puts SAP's ADT APIs behind an MCP bridge so an assistant can read code, write code and debug without anything installed on the server. Its documentation is unusually specific about protocol warts, and its shipped configuration is unusually permissive: read only mode, free SQL blocking and the package allow list exist as switches and all ship switched off.
Who is it for?
This is the most technically specific project in this batch, and the parts worth trusting are the parts where it admits a limitation: a breakpoint GET that answers 200 with nothing in it, a transport chosen because an ABAP roll area cannot be correlated, a Makefile comment explaining a stale binary that agents were running without noticing. Use it if you already have ADT and a client that speaks MCP, and expect to read the source as much as the file.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • oisee/vibing-steampunk530 ★ · +64
Star history
Repository2026-09-122026-11-15
oisee/vibing-steampunk466530

64 Stars in the last 64 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Three names for one binary and a floor of 7.50

The project carries three identifiers. The repository is vibing-steampunk, the Go module is github.com/oisee/vibing-steampunk, and the binary the documentation tells you to run is vsp. The repository description adds a fourth spelling, calling it vs-punk in the line that advertises an ADT to MCP bridge for vibe coding in ABAP and AMDP, so a reader who searches the index for the name in the description will not find the one in the commands. What the file is careful about is the floor: any system with ADT enabled from 7.50 upwards, with the caveat that the available surface varies by release. There is a command for that, `vsp compat`, which reports per system what is actually there, and three facts worth knowing before planning anything: RAP needs S/4, AMDP needs HANA, and some ADT resources present on S/4 are simply absent on ERP. The scope is read code, write code, debug, deploy and run tests, and for anyone deciding whether to try it there is a reviewer guide with eleven hands-on tasks, six of which run fully offline. A sibling repository covers the OData side of the same idea. A separate block collects what the last three releases added, and it reads like a changelog written by someone who was annoyed by one specific thing each time: a dump post-mortem that reads the whole ST22 document rather than just the stack, giving the message with its variables, the system fields, the failing source line and the variables the runtime chose per frame; the application log by object and date range, plus the same log extracted from a bare table export of two tables; spool and jobs, with the job list decoded from the spool store and a job's steps and log exported for a whole night in one command; a map of where settings live, covering report variants with the screen's own labels, saved test data, documentation converted to Markdown, and the image catalogue searched by title with the activity's transaction; selection texts and text symbols written as a plan with a diff and then activated so they persist; and a response cache that turns a four second call into ten milliseconds on a native SQLite database.

Every safety switch in the shipped configuration is commented out

The environment file example is where this project is most surprising, because the controls exist and the defaults do not use them. The header states the precedence outright: command line flags beat environment variables, which beat the .env file, which beats the built-in defaults. The required values are the host on port 50000, a user and a password. Of the optional SAP options only the client number 001, the language EN and an insecure flag set to false are active. Everything under the heading for safety options is commented out: read only mode, blocking of free SQL, a package allow list written as Z star and Y star, and an allowed operations list reading RSQ. Under tool mode the file is explicit that focused means 81 essential tools and expert means all 122, and it ships focused. The feature flags sit alongside, one per capability area, each defaulting to auto: HANA, abapGit, RAP, AMDP, UI5 and transport, with values of auto, on or off. So the file a new user copies grants 81 write-capable tools with no read only mode and no SQL restriction unless they edit it first.

255 byte lines and one field make a blob read back exactly

One of the newer additions reads the MIME repository, meaning the content anyone uploaded through SMW0: images, audio, a font, a game. The problem it solves is arithmetic rather than permissions. Those bytes are stored as a data cluster of 255-byte lines whose last line is padded, so the cluster itself cannot say where the file ends and any reader has to guess. The step that makes the result exact rather than nearly right is a single field: the file size recorded in a parameter table, which the tool reads and uses to cut the stream at the right byte. Nothing is installed on the server to achieve it, and the file is explicit that this is a decode over plain ADT rather than a new capability on the backend. It is a small piece of work with a clear failure mode, and it is the kind of gap that a wrapper covering the obvious fields would otherwise leave as a truncated image. The value of doing it on the client rather than on the server is that it needs no transport object and no installed program on the system being read, which is the same constraint every other feature in this file is working under.

Cluster tables are decompressed in Go, so EXPORT TO DATABASE becomes readable

The second addition takes on every table that an EXPORT to database statement ever wrote: BALDAT, INDX and STXL, the three names behind ABAP's cluster storage. The file describes them as read over plain ADT and decoded on the client, with SAP's LZH and LZC decompression handled in Go, the cluster format itself walked field by field, and the field names resolved from DD03L, the data dictionary table that holds them. The claim attached to it is that this is data only IMPORT could read, achieved without a line of ABAP. That is a meaningful boundary: anyone who has tried to inspect a cluster table over a development endpoint knows that the rows come back as opaque compressed lines rather than fields. The dependency list behind that decode is worth reading on its own. The module targets Go 1.26 with a pinned toolchain, and its direct requirements include a headless browser driver and its protocol package, a WebSocket library, a WebAssembly runtime, a Lua interpreter, a pure Go SQLite, the MCP server library, the Cobra and Viper pair for commands and configuration, and the author's own RFC module. None of the browser, WebAssembly or Lua entries has a visible explanation in the file, though an examples directory does include a Lua folder beside scripts and workflows. There is a Node manifest as well, whose only runtime dependency is an ABAP linter, with TypeScript kept as a development dependency, so a JavaScript toolchain exists in a Go repository for one purpose. Walking the format on the client also means the decode is version-sensitive, since it reproduces a storage format rather than consuming a supported interface, and nothing in the file says how that is pinned.

The breakpoint GET answers 200 with an empty body

Breakpoints need no ABAP on either transport: posting to the breakpoints resource answers 200 on both and writes the same row a Z module facade would. The asymmetry is on the read side. SAP answers the GET with 200 and nothing in the body, because in ADT the breakpoint set is the IDE's own state, posted whole by Eclipse rather than fetched. The consequences fall on the client. A client has to keep its own record of what it believes is set, and adding a single breakpoint becomes a read, modify and write cycle against a server that will not tell it what is there. The file is honest that this one is real rather than papering over it, which is more than most protocol wrappers do, and it is also the reason a breakpoint loop built on the HTTP resources alone is awkward: the state lives on whichever side last posted it. The file also notes a smaller typed path over a short ABAP facade for systems where the payload matters, kept in the abap directory of the repository, which is the only piece of ABAP anywhere in an otherwise client-side story.

RFC was chosen because an ABAP roll area cannot be correlated

The debugger needs one thing above all, a stable ABAP session, because attach_debuggee returns an object reference and stepping, the stack and the variables all hang off it. That is the stated reason an earlier debug loop spread over independent HTTP calls kept losing its debuggee. A pinned classic-RFC conversation is that session natively, with no ICF, no CSRF and no WebSocket upgrade, so the loop runs as one held session:

bash
vsp rfc debug
dbg> ebp ZADT_DEBUG_LOOP 9
dbg> eclipse 120
dbg> elocals
dbg> estep over
dbg> estack

Those six lines are the whole loop: open the debug session, set a breakpoint by object name, listen and attach, read the stopped frame's variables, step over, print the stack. The commands drive ADT's own debugger resources, tunnelled through an RFC endpoint, because the only reason an ordinary tool cannot call them is that ADT parks the debug session in an ABAP roll area reachable again only through a context cookie. Over a pinned conversation the roll area is the session, so there is nothing to correlate. What comes back is ADT's own answer: source URIs per stack frame, screen frames, authorization flags and the action catalogue, and SAP labels the pinned session itself with the instance it belongs to, which is the visible sign that the conversation is the session rather than a transport bolted onto one.

The same loop works over HTTPS, and a test holds the two honest

There is a second transport and it is not a fallback in name only. The same six commands run under `vsp adt debug` over one stateful HTTPS session, against systems with no gateway port, using the stateful ICF session that the context cookie selects. The argument for it is stated plainly: listen, attach, stack and step were never an RFC feature, they are ADT resources, and RFC was one way to carry them, so what they need is a session and HTTPS supplies one. The file says this path was verified against a system over plain HTTPS, with either a cookie or a password, and points at a design document for systems where you can sign on to ADT but nobody will give you an RFC user. What holds the two transports to the same behaviour is a test rather than a promise: an integration test runs that script over both and fails if they disagree about where the debuggee stopped or what it could see, and the file names the command that runs it. From an MCP client the loop becomes five tool calls, and the listen step attaches for the caller, because a debuggee is only attachable while it waits.

The Makefile documents a stale binary, and update replaces the running one

The build file carries the most useful line in the repository, and it is a comment about a bug that already happened. Cross compilation targets cover Linux on amd64, arm64, 386 and arm, Darwin on amd64 and arm64, and Windows on amd64, arm64 and 386. The comment explains that the local build now carries its platform in the same naming scheme as the cross compiled ones, and that the plain build path is a link to it, so tool configs pointing at either name resolve to the same file. Then it explains what went wrong before: the build target wrote one output while every MCP config pointed at a platform specific name that only the build all target refreshed, so the binary the agents ran silently fell behind the source. The update command has the same care about the installed copy: it fetches the release for the running platform, verifies it against a checksums file, and renames it into place of the binary already running, with a flag to point at another repository. One wart survives in the same file, since the single sign-on helper is hardcoded to a Windows executable name while the platform list includes Linux and Darwin. The release titles are prose rather than labels, and the newest was published after the last recorded push to the branch. The rest of that root describes how the project is worked on rather than what it does: a vision file, a roadmap, an architecture document, a changelog, a file about MCP usage and another about the tools, both an active and an archived agent instruction file, a githooks directory, a formatter wired to a stricter Go formatter and a linter with its configuration at the root, three Go source roots beside cmd and tools, an abap directory with the optional facade, and a NOTICE file next to the MIT licence.

Editorial conclusion

This is the most technically specific project in this batch, and the parts worth trusting are the parts where it admits a limitation: a breakpoint GET that answers 200 with nothing in it, a transport chosen because an ABAP roll area cannot be correlated, a Makefile comment explaining a stale binary that agents were running without noticing. Use it if you already have ADT and a client that speaks MCP, and expect to read the source as much as the file. Before you point it at anything you care about, set the safety switches yourself rather than trusting the shipped defaults, run `vsp compat` against your own system rather than assuming S/4 parity, and decide whether the focused set of 81 tools is the one you want. The module also pulls in a browser driver, a WebAssembly runtime and a Lua interpreter that the README never explains, which is the clearest sign that the documented surface is narrower than the built one.

Frequently asked questions

What is oisee/vibing-steampunk?

It is a MIT licensed Go project that bridges SAP's ADT APIs to MCP clients, so an assistant can read code, write code, debug, deploy and run tests through natural language. The binary is called vsp and it targets any system with ADT enabled from 7.50 upwards.

Does vibing-steampunk need software installed on the SAP server?

No. The file states that nothing is installed for the debugger path, which drives ADT's own debugger resources over a pinned classic-RFC conversation or a stateful HTTPS session. An optional typed facade exists under abap/src/zadt_debug/ for systems that need a smaller payload path.

How do I configure the SAP connection for vsp?

Copy the .env example to .env and fill in the host on port 50000, a user and a password, with optional client 001, language EN and an insecure flag. Precedence is command line flags, then environment variables, then .env, then defaults, and .vsp.json is the file to use for more than one system, and a change grouping attribute can be set for transport requests at the CR level.

Is vibing-steampunk read only by default?

No. The .env example ships the read only flag, the free SQL block, the allowed package list and the allowed operations list all commented out, so none of them is switched on. The one limit that is active is tool mode, set to focused, which is described as 81 essential tools against 122 in expert mode.

How does the vsp debugger keep its session alive?

Over a pinned classic-RFC conversation with `vsp rfc debug`, or over a stateful ICF HTTPS session with `vsp adt debug`. The file explains that ADT parks the debug session in an ABAP roll area reachable only through a context cookie, so the transport has to supply a session rather than a fresh request each time.

Which SAP releases does vsp support?

Any system with ADT enabled from 7.50 upwards, though the surface varies. The file says `vsp compat` reports what a given system actually has, and that RAP needs S/4, AMDP needs HANA, and some ADT resources present on S/4 are absent on ERP.

Official sources

  1. Issues
  2. License: MIT
  3. oisee/vibing-steampunk on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/oisee-vibing-steampunk.svg)](https://hysenlabs.com/projects/oisee-vibing-steampunk)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/oisee-vibing-steampunk.svg)](https://hysenlabs.com/projects/oisee-vibing-steampunk)

Was this useful?