pi-mcp-adapter 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] - 2026-01-19
+
+### Added
+
+- **npx installer** - Run `npx pi-mcp-adapter` to install (downloads files, installs deps, configures settings.json)
+
 ## [1.1.0] - 2026-01-19
 
 ### Changed

package/README.md

@@ -1,25 +1,42 @@
 # Pi MCP Adapter
 
-Connect [Pi](https://github.com/badlogic/pi-mono/) to any MCP server without burning your context window.
+Use MCP servers with [Pi](https://github.com/badlogic/pi-mono/) without burning your context window.
+
+https://github.com/user-attachments/assets/4b7c66ff-e27e-4639-b195-22c3db406a5a
+
+## Why This Exists
+
+Mario (Pi's creator) wrote about [why you might not need MCP](https://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/). The core issue: MCP servers ship dozens of tools with verbose descriptions. Playwright MCP has 21 tools eating 13.7k tokens. Chrome DevTools MCP has 26 tools eating 18k tokens. Connect a few servers and you've burned 30-50k tokens before the conversation starts. That's context bloat, slower responses, higher costs, and confused agents drowning in tool options.
+
+His solution: skip MCP, write simple CLI tools.
+
+But there's an active ecosystem of well-maintained MCP servers for databases, browsers, APIs, file systems, and more. This adapter lets you tap into that ecosystem without the context cost. One proxy tool (~200 tokens) instead of hundreds of individual tool definitions. The LLM discovers what it needs on-demand.
+
+## Install
+
+```bash
+npx pi-mcp-adapter
+```
+
+This downloads the extension to `~/.pi/agent/extensions/pi-mcp-adapter/`, installs dependencies, and configures Pi to load it. Restart Pi after installation.
+
+## Quick Start
+
+Create `~/.pi/agent/mcp.json`:
 
 ```json
 {
   "mcpServers": {
     "chrome-devtools": {
       "command": "npx",
-      "args": ["-y", "chrome-devtools-mcp@latest"]
+      "args": ["-y", "chrome-devtools-mcp@latest"],
+      "lifecycle": "keep-alive"
     }
   }
 }
 ```
 
-## The Problem
-
-MCP servers expose tools for databases, browsers, file systems, APIs. But each tool definition costs ~200 tokens when sent to the LLM. A server with 50 tools? That's 10,000 tokens gone before you've even started. Three servers and you've lost 30K tokens to tool definitions alone.
-
-## The Solution
-
-One proxy tool. The LLM searches for what it needs, sees the schema, and calls it:
+The LLM searches for tools, sees their schemas, and calls them:
 
 ```
 mcp({ search: "screenshot" })
@@ -36,71 +53,39 @@ chrome_devtools_take_screenshot
 mcp({ tool: "chrome_devtools_take_screenshot", args: { format: "png" } })
 ```
 
-Two calls. ~200 tokens for the proxy tool instead of 30K+ for every tool definition.
-
-## Install
-
-```bash
-cd ~/.pi/agent/extensions
-npm install pi-mcp-adapter
-```
-
-Or clone it:
-
-```bash
-git clone https://github.com/nicobailon/pi-mcp-adapter
-cd pi-mcp-adapter && npm install
-```
-
-Restart Pi.
+Two calls instead of 26 tools cluttering the context.
 
 ## Config
 
-Create `~/.pi/agent/mcp.json`:
+### Server Options
 
 ```json
 {
   "mcpServers": {
-    "chrome-devtools": {
+    "my-server": {
       "command": "npx",
-      "args": ["-y", "chrome-devtools-mcp@latest"],
+      "args": ["-y", "some-mcp-server"],
       "lifecycle": "keep-alive"
     }
   }
 }
 ```
 
-For HTTP servers:
-
-```json
-{
-  "mcpServers": {
-    "remote-api": {
-      "url": "https://api.example.com/mcp",
-      "auth": "bearer",
-      "bearerTokenEnv": "API_TOKEN"
-    }
-  }
-}
-```
-
-### Options
-
 | Field | Description |
 |-------|-------------|
 | `command` | Executable for stdio transport |
 | `args` | Command arguments |
-| `env` | Environment variables (`${VAR}` interpolation supported) |
-| `url` | HTTP endpoint (tries StreamableHTTP, falls back to SSE) |
+| `env` | Environment variables (`${VAR}` interpolation) |
+| `url` | HTTP endpoint (StreamableHTTP with SSE fallback) |
 | `auth` | `"bearer"` or `"oauth"` |
-| `bearerToken` / `bearerTokenEnv` | Token or env var containing token |
+| `bearerToken` / `bearerTokenEnv` | Token or env var |
 | `lifecycle` | `"keep-alive"` for auto-reconnect |
 | `exposeResources` | Expose MCP resources as tools (default: true) |
-| `debug` | Show server stderr output (default: false) |
+| `debug` | Show server stderr (default: false) |
 
 ### Import Existing Configs
 
-Already have MCP set up in Cursor or Claude? Import it:
+Already have MCP set up elsewhere? Import it:
 
 ```json
 {
@@ -113,40 +98,14 @@ Supported: `cursor`, `claude-code`, `claude-desktop`, `vscode`, `windsurf`, `cod
 
 ## Usage
 
-### Search
-
-```
-mcp({ search: "screenshot navigate" })
-```
-
-Space-separated words are OR'd. Results include parameter schemas by default.
-
-Use `includeSchemas: false` for compact output, `regex: true` for regex matching.
-
-### Describe
-
-```
-mcp({ describe: "chrome_devtools_take_screenshot" })
-```
-
-Full details for a specific tool. Mostly redundant now that search includes schemas.
+| Mode | Example |
+|------|---------|
+| Search | `mcp({ search: "screenshot navigate" })` |
+| Describe | `mcp({ describe: "tool_name" })` |
+| Call | `mcp({ tool: "...", args: {...} })` |
+| Status | `mcp({ })` or `mcp({ server: "name" })` |
 
-### Call
-
-```
-mcp({ tool: "chrome_devtools_navigate_page", args: { type: "url", url: "https://example.com" } })
-```
-
-If you pass bad arguments, the error includes the expected schema.
-
-### Status
-
-```
-mcp({ })
-mcp({ server: "chrome-devtools" })
-```
-
-See connected servers and their tools.
+Search includes parameter schemas by default. Space-separated words are OR'd.
 
 ## Commands
 
@@ -154,32 +113,16 @@ See connected servers and their tools.
 |---------|--------------|
 | `/mcp` | Server status |
 | `/mcp tools` | List all tools |
-| `/mcp reconnect` | Reconnect all servers |
-| `/mcp-auth <server>` | OAuth setup instructions |
-
-## OAuth
-
-For OAuth servers, get a token from your provider and save it:
-
-```bash
-mkdir -p ~/.pi/agent/mcp-oauth/my-server
-cat > ~/.pi/agent/mcp-oauth/my-server/tokens.json << 'EOF'
-{
-  "access_token": "your-token",
-  "token_type": "bearer"
-}
-EOF
-```
-
-Then `/mcp reconnect`.
+| `/mcp reconnect` | Reconnect servers |
+| `/mcp-auth <server>` | OAuth setup |
 
 ## How It Works
 
-See [ARCHITECTURE.md](./ARCHITECTURE.md) for the full breakdown. The short version:
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for details. Short version:
 
-- One `mcp` tool registered with Pi (~200 tokens)
+- One `mcp` tool in context (~200 tokens)
 - Tool metadata stored in a map, looked up at call time
-- MCP server validates arguments (no schema conversion needed)
+- MCP server validates arguments
 - Keep-alive servers get health checks and auto-reconnect
 
 ## Limitations

package/install.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const os = require("os");
+const { execSync } = require("child_process");
+
+const REPO_URL = "https://raw.githubusercontent.com/nicobailon/pi-mcp-adapter/master";
+const EXT_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", "pi-mcp-adapter");
+const SETTINGS_FILE = path.join(os.homedir(), ".pi", "agent", "settings.json");
+const EXT_PATH = "~/.pi/agent/extensions/pi-mcp-adapter/index.ts";
+
+const FILES = [
+  "index.ts",
+  "types.ts",
+  "config.ts",
+  "server-manager.ts",
+  "tool-registrar.ts",
+  "resource-tools.ts",
+  "lifecycle.ts",
+  "oauth-handler.ts",
+  "package.json",
+  "tsconfig.json",
+  "README.md",
+  "CHANGELOG.md",
+  "ARCHITECTURE.md",
+  "LICENSE",
+];
+
+function download(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return download(res.headers.location).then(resolve).catch(reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`Failed to download ${url}: ${res.statusCode}`));
+      }
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => resolve(data));
+      res.on("error", reject);
+    }).on("error", reject);
+  });
+}
+
+async function main() {
+  console.log("Installing pi-mcp-adapter...\n");
+
+  fs.mkdirSync(EXT_DIR, { recursive: true });
+  console.log(`Created directory: ${EXT_DIR}`);
+
+  for (const file of FILES) {
+    console.log(`Downloading ${file}...`);
+    const content = await download(`${REPO_URL}/${file}`);
+    fs.writeFileSync(path.join(EXT_DIR, file), content);
+  }
+
+  console.log("\nInstalling dependencies...");
+  try {
+    execSync("npm install --production", { cwd: EXT_DIR, stdio: "inherit" });
+  } catch (err) {
+    console.error("Warning: npm install failed. You may need to run it manually.");
+  }
+
+  console.log(`\nUpdating settings: ${SETTINGS_FILE}`);
+  
+  let settings = {};
+  if (fs.existsSync(SETTINGS_FILE)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, "utf-8"));
+    } catch (err) {
+      console.error(`Warning: Could not parse existing settings.json: ${err.message}`);
+      console.error("Creating new settings file...");
+    }
+  }
+
+  if (!Array.isArray(settings.extensions)) {
+    settings.extensions = [];
+  }
+
+  const hasMcpExt = settings.extensions.some(p => 
+    p === EXT_PATH || 
+    p.includes("/extensions/pi-mcp-adapter/index.ts") || 
+    p.includes("/extensions/pi-mcp-adapter")
+  );
+
+  if (!hasMcpExt) {
+    settings.extensions.push(EXT_PATH);
+    console.log(`Added "${EXT_PATH}" to extensions array`);
+  } else {
+    console.log("Extension already configured in settings.json");
+  }
+
+  fs.mkdirSync(path.dirname(SETTINGS_FILE), { recursive: true });
+  fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n");
+
+  console.log("\nInstallation complete!");
+  console.log("\nCreate ~/.pi/agent/mcp.json to configure MCP servers.");
+  console.log("Restart pi to load the extension.");
+}
+
+main().catch((err) => {
+  console.error(`\nInstallation failed: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "license": "MIT",
   "author": "Nico Bailon",
+  "bin": {
+    "pi-mcp-adapter": "./install.js"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/nicobailon/pi-mcp-adapter"
@@ -23,6 +26,7 @@
     "extensions": ["./index.ts"]
   },
   "files": [
+    "install.js",
     "index.ts",
     "types.ts",
     "config.ts",