api-spec-cli 0.2.2 → 0.2.3

package/README.md

@@ -189,15 +189,30 @@ spec add <name> --mcp-stdio "<cmd args>"   [--env KEY=VAL] [--cwd <path>]
 
 All options are repeatable where it makes sense (`--header`, `--env`). `--auth` adds `Authorization: Bearer <token>` unless the header is already set.
 
-For MCP entries, tool filtering is available:
+Operation filtering works for all spec types — MCP, OpenAPI, and GraphQL:
 
 ```bash
+# MCP: allow only read/list tools
 spec add <name> --mcp-http <url> \
   --allow-tool "read_*" --allow-tool "list_*" \
   --disable-tool "delete_*"
+
+# OpenAPI: allow only GET operations (by operationId)
+spec add <name> --openapi <url> \
+  --allow-tool "get*" --allow-tool "find*"
+
+# GraphQL: allow specific operations by exact name
+spec add <name> --graphql <url> \
+  --allow-tool "me" --allow-tool "publication"
 ```
 
-`--allow-tool` keeps only matching tools. `--disable-tool` removes matching tools (applied after allow). Both accept glob patterns (`*`, `?`) or plain substrings.
+`--allow-tool` keeps only matching operations. `--disable-tool` removes matching operations (applied after allow). Both are repeatable.
+
+**Matching rules:**
+- Plain text → **exact match** (case-insensitive): `"me"` matches only `me`
+- Glob patterns → anchored match: `"get*"` matches `getPetById`, `"*post*"` matches `createPost`
+
+Use `grep` for search (substring) — `--allow-tool` / `--disable-tool` for precise whitelists (exact or glob).
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-spec-cli",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Agent-friendly CLI for exploring and calling OpenAPI and GraphQL APIs",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -31,8 +31,8 @@ REGISTRY (register once, use anywhere):
     Options: --description <text>  --base-url <url>  --auth <token>
              --header k=v (repeatable)  --env KEY=VAL (repeatable, stdio only)
              --cwd <path> (stdio only)
-             --allow-tool <glob> (repeatable, MCP only)
-             --disable-tool <glob> (repeatable, MCP only)
+             --allow-tool <glob> (repeatable)
+             --disable-tool <glob> (repeatable)
 
   spec specs                           List all registered specs
   spec specs --compact false           Show full entry config

package/src/commands/add.js

@@ -66,13 +66,11 @@ export async function addCmd(args) {
     );
   }
 
-  // Tool filtering (MCP only)
-  if (entry.type === "mcp") {
-    const allowed = flags["allow-tool"];
-    const disabled = flags["disable-tool"];
-    if (allowed?.length) entry.config.allowedTools = allowed;
-    if (disabled?.length) entry.config.disabledTools = disabled;
-  }
+  // Operation filtering (all types)
+  const allowed = flags["allow-tool"];
+  const disabled = flags["disable-tool"];
+  if (allowed?.length) entry.config.allowedTools = allowed;
+  if (disabled?.length) entry.config.disabledTools = disabled;
 
   registry.push(entry);
   saveRegistry(registry);

package/src/commands/fetch.js

@@ -3,7 +3,7 @@ import { resolve } from "path";
 import YAML from "yaml";
 import { parseKV } from "../args.js";
 import { createMcpClient } from "../mcp-client.js";
-import { matchGlob } from "../glob.js";
+import { matchFilter } from "../glob.js";
 
 const INTROSPECTION_QUERY = `{
   __schema {
@@ -60,6 +60,13 @@ fragment TypeRef on __Type {
   }
 }`;
 
+function applyFilter(items, nameFn, allowed, disabled) {
+  let result = items;
+  if (allowed?.length) result = result.filter((item) => allowed.some((p) => matchFilter(p, nameFn(item))));
+  if (disabled?.length) result = result.filter((item) => !disabled.some((p) => matchFilter(p, nameFn(item))));
+  return result;
+}
+
 /**
  * Resolve a spec from a registry entry or inline flags entry.
  * Entry shape:
@@ -69,10 +76,20 @@ fragment TypeRef on __Type {
  */
 export async function fetchSpec(entry) {
   if (entry.type === "mcp") return await loadMCPFromEntry(entry);
-  if (entry.type === "graphql") return await loadGraphQL(entry.source, entry.config?.headers);
+  if (entry.type === "graphql") {
+    const spec = await loadGraphQL(entry.source, entry.config?.headers);
+    return {
+      ...spec,
+      operations: applyFilter(spec.operations, (op) => op.name, entry.config?.allowedTools, entry.config?.disabledTools),
+    };
+  }
   // openapi — url or file; skip GraphQL probe since type is explicitly declared
   const isUrl = entry.source?.startsWith("http://") || entry.source?.startsWith("https://");
-  return isUrl ? await loadFromUrl(entry.source, true) : loadFromFile(entry.source);
+  const spec = isUrl ? await loadFromUrl(entry.source, true) : loadFromFile(entry.source);
+  return {
+    ...spec,
+    operations: applyFilter(spec.operations, (op) => op.id, entry.config?.allowedTools, entry.config?.disabledTools),
+  };
 }
 
 /**
@@ -80,6 +97,13 @@ export async function fetchSpec(entry) {
  * Returns null if no inline source flags present.
  */
 export function inlineEntryFromFlags(flags) {
+  const allowed = flags["allow-tool"];
+  const disabled = flags["disable-tool"];
+  const filterConfig = {
+    ...(allowed?.length ? { allowedTools: allowed } : {}),
+    ...(disabled?.length ? { disabledTools: disabled } : {}),
+  };
+
   if (flags["mcp-stdio"]) {
     const raw = flags["mcp-stdio"];
     const parts = (raw.trim() ? raw.match(/(?:[^\s"]+|"[^"]*")+/g) : null)?.map((p) => p.replace(/^"|"$/g, ""));
@@ -90,7 +114,7 @@ export function inlineEntryFromFlags(flags) {
       command: parts[0],
       args: parts.slice(1),
       cwd: flags.cwd,
-      config: { env: parseKV(flags.env) },
+      config: { env: parseKV(flags.env), ...filterConfig },
     };
   }
   if (flags["mcp-sse"]) {
@@ -98,7 +122,7 @@ export function inlineEntryFromFlags(flags) {
       type: "mcp",
       transport: "sse",
       url: flags["mcp-sse"],
-      config: { headers: parseKV(flags.header) },
+      config: { headers: parseKV(flags.header), ...filterConfig },
     };
   }
   if (flags["mcp-http"]) {
@@ -106,14 +130,14 @@ export function inlineEntryFromFlags(flags) {
       type: "mcp",
       transport: "streamable-http",
       url: flags["mcp-http"],
-      config: { headers: parseKV(flags.header) },
+      config: { headers: parseKV(flags.header), ...filterConfig },
     };
   }
   if (flags.graphql) {
-    return { type: "graphql", source: flags.graphql, config: { headers: parseKV(flags.header) } };
+    return { type: "graphql", source: flags.graphql, config: { headers: parseKV(flags.header), ...filterConfig } };
   }
   if (flags.openapi) {
-    return { type: "openapi", source: flags.openapi, config: { headers: parseKV(flags.header), baseUrl: flags["base-url"] || null } };
+    return { type: "openapi", source: flags.openapi, config: { headers: parseKV(flags.header), baseUrl: flags["base-url"] || null, ...filterConfig } };
   }
   return null;
 }
@@ -130,10 +154,7 @@ async function loadMCPFromEntry(entry) {
       inputSchema: t.inputSchema || null,
     }));
 
-    const allowed = entry.config?.allowedTools;
-    const disabled = entry.config?.disabledTools;
-    if (allowed?.length) mapped = mapped.filter((t) => allowed.some((p) => matchGlob(p, t.name)));
-    if (disabled?.length) mapped = mapped.filter((t) => !disabled.some((p) => matchGlob(p, t.name)));
+    mapped = applyFilter(mapped, (t) => t.name, entry.config?.allowedTools, entry.config?.disabledTools);
 
     return {
       type: "mcp",

package/src/glob.js

@@ -1,15 +1,29 @@
+function globToRegex(pattern) {
+  return new RegExp(
+    "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$",
+    "i"
+  );
+}
+
 /**
- * Match a string against a glob pattern or a plain substring.
- * - Glob chars (* ?) use regex matching
- * - Plain text uses case-insensitive substring matching
+ * Search match: plain text = substring, glob chars (* ?) = anchored glob.
+ * Used by grep — broad matching is desirable for search.
  */
 export function matchGlob(pattern, str) {
   if (!pattern.includes("*") && !pattern.includes("?")) {
     return str.toLowerCase().includes(pattern.toLowerCase());
   }
-  const re = new RegExp(
-    "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$",
-    "i"
-  );
-  return re.test(str);
+  return globToRegex(pattern).test(str);
+}
+
+/**
+ * Filter match: plain text = exact (case-insensitive), glob chars (* ?) = anchored glob.
+ * Used by --allow-tool / --disable-tool — precision is required for whitelists.
+ * Use *pattern* for explicit substring matching.
+ */
+export function matchFilter(pattern, str) {
+  if (!pattern.includes("*") && !pattern.includes("?")) {
+    return str.toLowerCase() === pattern.toLowerCase();
+  }
+  return globToRegex(pattern).test(str);
 }