CLI Printing Press plugin
A generator of Go CLIs and MCP servers for any API: /printing-press studies docs and competitors and builds a tool with a local SQLite store
- 4,870 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The installer runs as `curl | bash`, performs `go install` and installs the skills globally into the agent
- The skill records site traffic through a browser and calls service APIs under your authorization
- The agent writes and runs generated Go code, and publishing a tool opens a PR to the shared library
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add plugins/cli-printing-pressDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The installer runs as `curl | bash`, performs `go install` and installs the skills globally into the agent
- The skill records site traffic through a browser and calls service APIs under your authorization
- The agent writes and runs generated Go code, and publishing a tool opens a PR to the shared library
This is third-party code. Review the repository files before installing.
What it does
CLI Printing Press has two parts: a Go binary called `cli-printing-press` and a set of skills. The main skill is invoked with `/printing-press <app>` in Claude Code and drives the work in phases. It first reads the official documentation, looks for existing plugins, MCP servers and command-line tools for the same API and puts every feature found into a list the new tool must match and beat. If there is no documentation, the skill launches a browser, records the site's traffic and reconstructs the API description from it, or accepts a HAR file. The output is two binaries: `<api>-pp-cli` and `<api>-pp-mcp`. The first is a command-line tool for people and agents, the second an MCP server with the same operations. API data can be synced into a local SQLite store with full-text search, which gives the tool compound commands such as `stale`, `health` and `reconcile` that a plain request wrapper cannot run. The tool prints JSON when piped, has a `--compact` mode to save tokens, `--dry-run` and typed exit codes. Installation is a script that runs `go install` for the generator and pulls the skills through `skills@latest`. The result goes through verification steps: a scorecard, a dogfood run, a behavior check and an optional live read-only smoke test. The other skills in the set polish the result (`printing-press-polish`), publish it to the shared library (`printing-press-publish`), rebuild older tools and mine a session to turn the friction found into a patch.
Who it is for. For developers and agent enthusiasts who need a ready command-line tool and MCP server for an API that has none, or only incomplete ones.
Good fit when
- The service you need has no convenient command-line tool, and the agent has to write requests by hand every time
- You want to keep API data in a local database and search it without a network call
- The service has no public spec but does have a website, and you need to reconstruct the API from its traffic
- You need both a shell CLI and an MCP server for Claude Desktop, Cursor or Cline from a single description
- A service's existing tool is incomplete and has to be rebuilt with competitors' features taken into account
Not a fit when
- You just need to call a few methods from a ready OpenAPI spec without code generation: OpenAPI to CLI in the catalog is closer
- You need an interface to a program with a graphical window rather than a web API: CLI-Anything is for that
- The machine has no Go 1.26.9 or newer or no Node with npm: the installer will not finish without them
- You cannot record a site's traffic or spend tokens on a multi-phase run: the research phases take a long time and use model requests
Example request
/printing-press LinearLimitations
The license is MIT. You need Go 1.26.9 or newer, Node with npm and a supported agent. The author tested the skills in Claude Code and recommends it for the best result, while for Codex the install runs with the `--agent codex` flag.
- The installer runs as `curl ... | bash` and performs `go install`, then installs the skills globally into the agent.
- Finished tools and working files go to `~/printing-press/`, and active runs work in a hidden `.runstate` folder.
- By the author's phase table one full run takes 29 to 63 minutes, and the model works for almost all of it.
- The `codex` mode moves code generation to Codex CLI and falls back to local generation after three failures in a row.
- The binary is called `cli-printing-press`: the older name `printing-press` still works for compatibility, but `list`, `search` and `install` now belong to the shared library installer.
How to disable. Delete the `cli-printing-press` binary from `$GOPATH/bin` and remove the set's skills through `skills` from your agent's global folder, then restart the agent. Generated tools and their data live in `~/printing-press/` and are removed separately.
FAQ
What comes out of one run?
Two binaries, `<api>-pp-cli` and `<api>-pp-mcp`, research documents, verification proofs and a quality score. Published tools go to `~/printing-press/library/<api>`.
How does it work when the service has no spec?
There are three inputs: an OpenAPI file through `--spec`, a site address where the browser records traffic and reconstructs the API, or a HAR file through `--har`. Everything found is saved in a `discovery/` folder along with the research.
Why does the tool carry a local SQLite?
`sync` pulls API data down, `search` finds it through a full-text index in milliseconds and `sql` gives direct queries. Compound commands such as `bottleneck` join several resources and analyze history.
Which skills are in the set?
Nine: the main `printing-press`, plus `printing-press-polish`, `printing-press-publish`, `printing-press-amend`, `printing-press-reprint`, `printing-press-retro`, `printing-press-score`, `printing-press-import` and `printing-press-output-review`.
What does the codex mode give?
`/printing-press HubSpot codex` hands code writing to Codex CLI while Claude keeps research, planning and scoring. The author cites a 60 percent saving in Opus tokens.
What exit codes do generated tools use?
0 for success, 2 for a usage error, 3 for not found, 4 for auth, 5 for an API error and 7 for rate limiting. An agent corrects itself from them without parsing error text.
Discussion
No questions or reviews yet.
Related
Pluginsclihub turns any MCP server into a ready CLI: each tool becomes a subcommand and the result is one static binary with no runtime dependencies
A plugin with skills for building TypeScript MCP servers and MCP apps: the agent scaffolds, edits, debugs and verifies them
A CLI that builds a ready-made TypeScript MCP server from an OpenAPI 3 spec, with tools, validation and auth generated for you
An MCP server that gives an agent search over a large Claude Code guide, official docs, releases and ready-made templates
A lightweight CLI to discover, inspect and call MCP server tools straight from the shell
skill-creator: skills from OpenAPI, GraphQL and MCP
@asnd/skill-creator
The /skill-creator command turns a link to an OpenAPI spec, GraphQL schema or MCP server into a ready skill with wrappers.
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| CLI Printing Press (this entry) | no | 4,870 | |
| OpenAPI to CLI (ocli) | no | 267 | turns an existing OpenAPI spec into commands without code generation and with BM25 search |
| CLI-Anything | no | 57,594 | generates a command interface for programs with a graphical window such as GIMP and Blender |
README in short
The English description lays out the idea: a good command-line tool saves an agent time and tokens. Then come a two-step install, a launch example in Claude Code and collapsed sections on the Codex mode, polishing, publishing and patching from a session. It goes on to show how generated tools differ from plain wrappers, how the concept of each is built using Discord and Linear as examples, how the phases work and what exactly gets created. Tables of domain types and a verification section close it. The repository holds the Go generator code, nine skills, plugin manifests, the `docs/CODEX.md` and `docs/CURSOR.md` documents and supply-chain verification scripts.