[ tool-cli ]

———   The Missing Package Manager for MCP Tools   ———

MCP solved how AI agents integrate with other systems. MCPB solved how users install them. But if you're building MCP tools, you're still copying JSON configs, wrestling with dependencies, and manually testing against clients.

tool-cli is the missing piece. It handles the entire lifecycle from scaffolding to publishing, so you can focus on building your tool.

demo.mp4

•  Growing marketplace: discover and install MCPs from tool.store
•  Works with your stack: Claude Code, Cursor, OpenCode, VS Code, and more
•  Unified proxy: run all your MCPs through a single tool run interface
•  MCPs as CLIs: invoke any tool directly from your terminal with tool call
•  Configure once: set it up once, use it everywhere
•  Built for both humans and agents: clean output that works in terminals and AI workflows
•  Encrypted by default: API keys and secrets are encrypted at rest
•  OAuth just works: browser flow, token refresh, secure storage handled for you
•  Ship your own MCP: scaffold, test, and publish with tool init

^{BUILD CONTEXT-EFFICIENT AI AGENTS WITH TOOL-CLI →}

• • •

Install

macOS / Linux:

curl -fsSL https://cli.tool.store | sh

Windows (or any system with Rust):

cargo install --git https://github.com/zerocore-ai/tool-cli --locked

Quick Start

Get your first MCP tool published in three steps.

1  ⏵  Create

tool init my-tool

This gives you a working MCP server with a valid manifest.json. Just follow the prompts to pick your language and transport.

Already have an MCP server?

Run `tool detect` in your project to see what tool-cli finds. Then `tool init` will generate a manifest from your existing code.

tool detect my-tool      # shows detected type, transport, entry point

tool init my-tool        # generates manifest.json

2  ⏵  Test

tool info my-tool

Shows you what your server exposes. Tools, prompts, resources. This is what clients will see when they connect.

tool call my-tool -m hello -p name="Steve"

You can call any method directly. No client needed.

Method shorthand

MCP tools often use `toolname__method` naming. You can use `.` as shorthand.

tool call bash -m .exec -p command="ls -la"     # expands to bash__exec

tool call files -m .fs.read -p path="/tmp"      # expands to files__fs__read

tool run my-tool

Starts the mcp server for connection.

3  ⏵  Share

tool login

tool publish my-tool --strict

Log in once, then publish. Now anyone can install your tool.

Just want to bundle it?

tool pack my-tool

Creates a .mcpb or .mcpbx file you can distribute yourself.

• • •

Multi-Platform Bundles

If your tool includes platform-specific binaries (native executables, compiled code), you can publish separate bundles for each platform. Users automatically get the right bundle for their system. Learn more about multi-platform packaging.

Packing for Multiple Platforms

tool pack --multi-platform

This creates separate bundles for each platform defined in your manifest's platform_overrides, plus a universal bundle:

my-tool-1.0.0-darwin-arm64.mcpb   # Apple Silicon Mac
my-tool-1.0.0-darwin-x64.mcpb     # Intel Mac
my-tool-1.0.0-linux-x64.mcpb      # Linux x64
my-tool-1.0.0.mcpb                # Universal (all platforms)

Publishing Multi-Platform

tool publish --multi-platform

Packs and uploads all platform variants in parallel.

Using pre-built bundles

If you've already built the bundles (e.g., in CI), you can specify paths directly:

tool publish --multi-platform \
  --darwin-arm64 ./dist/mac-arm.mcpb \
  --linux-x64 ./dist/linux.mcpb \
  --universal ./dist/all.mcpb

Installing with Platform Selection

tool install library/bash

Automatically downloads the bundle matching your system (e.g., darwin-arm64 on Apple Silicon). Falls back to universal if no platform match.

tool install library/bash --platform=universal

Explicitly install the universal bundle instead.

• • •

Using Tools

tool-cli essentially turns your MCP servers into CLIs. You can inspect, call, and compose tools directly from the terminal — no client needed. This is also the foundation for building context-efficient agents.

Find Tools

tool search filesystem

Search the registry for tools. You'll see names, descriptions, and download counts.

tool grep "file"

Search across all installed tools - server names, tool names, descriptions, and schema fields.

Preview Tools

tool preview library/open-data

Inspect a tool from the registry without installing it. See its available methods before you commit.

tool preview library/bash -m bash__exec

Preview a specific method to see its input and output schemas.

Install Tools

tool install library/bash

Installs a tool from the registry. You can also install from a local path.

tool list

See what you have installed.

Run Tools

tool run library/bash

Starts the tool with its native transport. Connect your MCP client to it.

You can also use --expose to bridge between transports.

tool run <namespace/remote-mcp> --expose stdio      # HTTP backend to stdio

tool run <namespace/local-mcp> --expose http --port 3000   # stdio backend to HTTP

Configure Tools

tool config set library/terminal

Some tools need configuration like API keys. This walks you through setting them up interactively. You can also pass values directly with tool config set library/terminal KEY=VALUE.

tool config get library/terminal

Check what config values are set.

tool config list

See all tools that have saved configuration.

tool config unset library/terminal API_KEY

Remove specific config keys, or use --all to clear everything.

Use Tools

tool info library/bash

See what a tool exposes. Tools, prompts, resources.

tool call library/bash -m .exec -p command="echo hello"

Call a method directly. Great for testing things out.

• • •

Host Integration

Once you've installed some tools, you probably want to use them in your favorite AI app. Instead of manually editing JSON configs, just run:

tool host add claude-desktop library/open-data

This registers the tool with the host. Works with Claude Desktop, Cursor, VS Code, Claude Code, Codex, Windsurf, Zed, Gemini CLI, Kiro, Roo Code, and OpenCode.

claude-desktop	cursor	vscode	claude-code	codex
windsurf	zed	gemini-cli	kiro	roo-code	opencode

tool host list                             # see all supported hosts
tool host add cursor library/open-data     # add a tool to Cursor
tool host add vscode                       # add all installed tools
tool host remove claude-desktop            # remove tools from a host
tool host show cursor                      # preview the generated config

You can specify individual tools or omit them to register all installed tools. The command creates backups before modifying anything, so your original config is safe.

^{BUILD CONTEXT-EFFICIENT AI AGENTS WITH TOOL-CLI →}

• • •

Commands

Command	What it does
init	Create a new tool or convert an existing MCP server to MCPB
detect	Scan a project and show what tool-cli finds
validate	Check your manifest for errors
info	Show what a tool exposes
preview	Preview a registry tool without installing
call	Call a tool method directly
run	Start a tool as a server
pack	Bundle into .mcpb/.mcpbx (supports multi-platform)
publish	Upload to the registry (supports multi-platform)
install	Install a tool (auto-detects platform)
download	Download a bundle without installing
uninstall	Remove an installed tool
list	Show installed tools
search	Find tools in the registry
grep	Search tool schemas by pattern
config	Manage tool configuration
host	Register tools with MCP hosts
login	Log in to the registry
logout	Log out from the registry
whoami	Show current authentication status
self	Manage tool-cli itself (update, uninstall)

Check out the CLI docs for the full details.

• • •

Why This Exists

MCP is becoming the standard for AI tool integration. But standards only matter if people can actually use them.

Anthropic's MCPB format solved the installation problem. Users can install MCP tools with one click now. But developers still need to create those packages. They need to validate manifests, bundle dependencies, test locally, and publish somewhere discoverable.

tool-cli is that toolchain. And tool.store is that registry.

The goal is simple. Make building and sharing MCP tools as easy as publishing an npm package.

• • •

The MCPB Extension

MCPB is great for what it was designed for: bundled servers that run locally over stdio. But most MCP servers today run via npx or uvx (nothing to bundle), some are remote HTTP servers (no local code at all), and some need things like host-managed ports or OAuth flows that the spec doesn't cover.

We created MCPBX (.mcpbx) to fill those gaps. It's a superset of MCPB that adds HTTP transport, reference mode (so you can point to npx/uvx or a remote URL instead of bundling code), system config for host-managed resources, OAuth config, and template functions for constructing auth headers.

The separate file extension exists so hosts know upfront whether they can handle the manifest. tool-cli picks the right format automatically based on what your manifest uses.

• • •

Licensing

tool-cli is licensed under the Apache 2.0 License.