@evantahler/mcpcli 0.5.0 → 0.5.2

package/{skills → .claude/skills}/mcpcli.md

@@ -87,6 +87,9 @@ mcpcli deauth <server>      # remove stored auth
 | `mcpcli auth <server> -s`              | Check token status and TTL        |
 | `mcpcli auth <server> -r`              | Force token refresh               |
 | `mcpcli deauth <server>`               | Remove stored authentication      |
+| `mcpcli ping`                          | Check connectivity to all servers |
+| `mcpcli ping <server> [server2...]`    | Check specific server(s)          |
 | `mcpcli add <name> --command <cmd>`    | Add a stdio MCP server            |
 | `mcpcli add <name> --url <url>`        | Add an HTTP MCP server            |
 | `mcpcli remove <name>`                 | Remove an MCP server              |
+| `mcpcli skill install --claude`        | Install mcpcli skill for Claude   |

package/README.md

@@ -68,6 +68,9 @@ mcpcli search -q "manage pull requests"
 | `mcpcli add <name> --command <cmd>`  | Add a stdio MCP server to your config        |
 | `mcpcli add <name> --url <url>`      | Add an HTTP MCP server to your config        |
 | `mcpcli remove <name>`               | Remove an MCP server from your config        |
+| `mcpcli ping`                        | Check connectivity to all configured servers |
+| `mcpcli ping <server> [server2...]`  | Check connectivity to specific server(s)     |
+| `mcpcli skill install --claude`      | Install the mcpcli skill for Claude Code     |
 
 ## Options
 
@@ -405,11 +408,20 @@ cat params.json | mcpcli exec server tool
 
 ### Claude Code Skill
 
-mcpcli ships a Claude Code skill at `skills/mcpcli.md` that teaches Claude Code how to discover and use MCP tools. Install it:
+mcpcli ships a Claude Code skill at `.claude/skills/mcpcli.md` that teaches Claude Code how to discover and use MCP tools. Install it:
 
 ```bash
-# Copy the skill to your global Claude Code skills
-cp skills/mcpcli.md ~/.claude/skills/mcpcli.md
+# Install to the current project (.claude/skills/mcpcli.md)
+mcpcli skill install --claude
+
+# Install globally (~/.claude/skills/mcpcli.md)
+mcpcli skill install --claude --global
+
+# Install to both locations
+mcpcli skill install --claude --global --project
+
+# Overwrite an existing skill file
+mcpcli skill install --claude --force
 ```
 
 Then in any Claude Code session, the agent can use `/mcpcli` or the skill triggers automatically when the agent needs to interact with external services. The skill instructs the agent to:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evantahler/mcpcli",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "A command-line interface for MCP servers. curl for MCP.",
   "type": "module",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "files": [
     "src",
-    "skills",
+    ".claude",
     "README.md",
     "LICENSE"
   ],

package/src/cli.ts

@@ -9,6 +9,8 @@ import { registerAuthCommand, registerDeauthCommand } from "./commands/auth.ts";
 import { registerIndexCommand } from "./commands/index.ts";
 import { registerAddCommand } from "./commands/add.ts";
 import { registerRemoveCommand } from "./commands/remove.ts";
+import { registerSkillCommand } from "./commands/skill.ts";
+import { registerPingCommand } from "./commands/ping.ts";
 
 declare const BUILD_VERSION: string | undefined;
 
@@ -33,5 +35,7 @@ registerDeauthCommand(program);
 registerIndexCommand(program);
 registerAddCommand(program);
 registerRemoveCommand(program);
+registerSkillCommand(program);
+registerPingCommand(program);
 
 program.parse();

package/src/commands/ping.ts

@@ -0,0 +1,69 @@
+import { green, red } from "ansis";
+import type { Command } from "commander";
+import { getContext } from "../context.ts";
+import { formatError } from "../output/formatter.ts";
+import { logger } from "../output/logger.ts";
+
+interface PingResult {
+  server: string;
+  success: boolean;
+  latencyMs?: number;
+  error?: string;
+}
+
+export function registerPingCommand(program: Command) {
+  program
+    .command("ping [servers...]")
+    .description("Check connectivity to MCP servers")
+    .action(async (servers: string[]) => {
+      const { manager, formatOptions } = await getContext(program);
+
+      const targetServers = servers.length > 0 ? servers : manager.getServerNames();
+
+      if (targetServers.length === 0) {
+        console.error(formatError("No servers configured", formatOptions));
+        await manager.close();
+        process.exit(1);
+      }
+
+      const spinner = logger.startSpinner(
+        `Pinging ${targetServers.length} server(s)...`,
+        formatOptions,
+      );
+
+      const results: PingResult[] = [];
+
+      try {
+        await Promise.all(
+          targetServers.map(async (serverName) => {
+            const start = Date.now();
+            try {
+              await manager.getClient(serverName);
+              results.push({ server: serverName, success: true, latencyMs: Date.now() - start });
+            } catch (err) {
+              results.push({ server: serverName, success: false, error: String(err) });
+            }
+          }),
+        );
+
+        spinner.stop();
+
+        if (formatOptions.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else {
+          for (const r of results) {
+            if (r.success) {
+              console.log(`${green("✔")} ${r.server} connected (${r.latencyMs}ms)`);
+            } else {
+              console.log(`${red("✖")} ${r.server} failed: ${r.error}`);
+            }
+          }
+        }
+      } finally {
+        await manager.close();
+      }
+
+      const anyFailed = results.some((r) => !r.success);
+      if (anyFailed) process.exit(1);
+    });
+}

package/src/commands/skill.ts

@@ -0,0 +1,70 @@
+import type { Command } from "commander";
+import { resolve, dirname, join } from "path";
+import { readFile, mkdir, writeFile, access } from "fs/promises";
+import { homedir } from "os";
+
+export function registerSkillCommand(program: Command) {
+  const skill = program.command("skill").description("manage mcpcli skills");
+
+  skill
+    .command("install")
+    .description("install the mcpcli skill for an AI agent")
+    .requiredOption("--claude", "install for Claude Code")
+    .option("--global", "install to ~/.claude/skills/")
+    .option("--project", "install to ./.claude/skills/ (default)")
+    .option("-f, --force", "overwrite if file already exists")
+    .action(
+      async (options: {
+        claude?: boolean;
+        global?: boolean;
+        project?: boolean;
+        force?: boolean;
+      }) => {
+        // Resolve the bundled skill file
+        const skillSource = resolve(dirname(Bun.main), "..", ".claude", "skills", "mcpcli.md");
+
+        let content: string;
+        try {
+          content = await readFile(skillSource, "utf-8");
+        } catch {
+          console.error(`Could not read skill file: ${skillSource}`);
+          process.exit(1);
+        }
+
+        // Determine targets — default to project if neither flag is set
+        const targets: { label: string; dir: string }[] = [];
+
+        if (options.global) {
+          targets.push({
+            label: "global",
+            dir: join(homedir(), ".claude", "skills"),
+          });
+        }
+        if (options.project || !options.global) {
+          targets.push({
+            label: "project",
+            dir: resolve(".claude", "skills"),
+          });
+        }
+
+        for (const target of targets) {
+          const dest = join(target.dir, "mcpcli.md");
+
+          // Check if file already exists
+          if (!options.force) {
+            try {
+              await access(dest);
+              console.error(`${dest} already exists (use --force to overwrite)`);
+              process.exit(1);
+            } catch {
+              // File doesn't exist — good
+            }
+          }
+
+          await mkdir(target.dir, { recursive: true });
+          await writeFile(dest, content, "utf-8");
+          console.log(`Installed mcpcli skill (${target.label}): ${dest}`);
+        }
+      },
+    );
+}