godmode 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,18 +1,42 @@
 #!/usr/bin/env node
 import {
-  execute
-} from "./chunk-I4WS4MMI.js";
+  showApiHelp,
+  showExtensionOverview,
+  showExtensionVersion,
+  showHelp,
+  showVersion
+} from "./chunk-ZTPILA7B.js";
+import {
+  checkPermission,
+  matchRoute,
+  resourceFromRawPath,
+  resourceFromSegments,
+  resourceFromTool,
+  suggestRoutes,
+  suggestedAllowRule
+} from "./chunk-4EU5JX6C.js";
+import {
+  EXIT_CODES
+} from "./chunk-XFFBFBN6.js";
 import {
-  listApis,
+  warnSettingsErrors
+} from "./chunk-SMQBMG24.js";
+import {
+  BUILTINS,
+  GODMODE_HOME,
+  findInstalledManifestSync,
   loadManifest,
-  removeApi,
-  updateApi,
+  loadMultiManifest,
   validateGraphQLFlags
-} from "./chunk-FBMQ3AC4.js";
+} from "./chunk-KHFZI7IA.js";
+import {
+  execute
+} from "./chunk-AWGLXW3B.js";
 import {
   executeMcpTool,
   validateMcpFlags
-} from "./chunk-EHS56XXY.js";
+} from "./chunk-3AQ2CZKC.js";
+import "./chunk-YDXTIN53.js";
 
 // src/env.ts
 import { readFileSync } from "fs";
@@ -35,100 +59,24 @@ function loadEnv() {
   }
 }
 
-// src/match.ts
-function matchRoute(manifest, userSegments, method) {
-  if (userSegments.length > 0) {
-    const ver = manifest.versions.find((v) => v.name === userSegments[0]);
-    if (ver) {
-      const match = findMatch(manifest.routes, userSegments.slice(1), method, ver.name);
-      if (match) return match;
-    }
-  }
-  return findMatch(manifest.routes, userSegments, method);
-}
-function findMatch(routes, userSegments, method, version) {
-  let bestMatch = null;
-  let bestScore = -1;
-  for (const route of routes) {
-    if (route.method !== method) continue;
-    if (route.segments.length !== userSegments.length) continue;
-    if (version !== void 0 && route.version !== version) continue;
-    let score = 0;
-    const params = {};
-    let matches = true;
-    for (let i = 0; i < route.segments.length; i++) {
-      const seg = route.segments[i];
-      const userSeg = userSegments[i];
-      if (seg.isParam) {
-        params[seg.value] = userSeg;
-      } else if (seg.value === userSeg) {
-        score += 1;
-      } else {
-        matches = false;
-        break;
-      }
-    }
-    if (matches && (score > bestScore || score === bestScore && isLaterVersion(route, bestMatch?.route))) {
-      bestScore = score;
-      bestMatch = { route, params };
-    }
-  }
-  return bestMatch;
-}
-function isLaterVersion(a, b) {
-  if (!b) return true;
-  return a.version > b.version;
-}
-function suggestRoutes(manifest, userSegments) {
-  if (!userSegments.length) return [];
-  return manifest.routes.filter((route) => {
-    if (route.segments.length < userSegments.length) return false;
-    const firstSeg = route.segments[0];
-    return !firstSeg.isParam && firstSeg.value === userSegments[0];
-  });
-}
-
 // src/args.ts
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
 function parseArgs(args) {
   const segments = [];
   const headers = {};
   const query = {};
   const body = {};
   let method = "get";
-  let token;
+  let explicitMethod = false;
   let filter;
   let methodFilter;
   let all = false;
-  let verbose = false;
-  let dryRun = false;
+  const debug = process.env.GODMODE_DEBUG === "1";
+  const dryRun = process.env.GODMODE_DRY_RUN === "1";
   let help = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     switch (arg) {
-      // HTTP methods
-      case "-g":
-      case "--get":
-        method = "get";
-        break;
-      case "-po":
-      case "--post":
-        method = "post";
-        break;
-      case "-pu":
-      case "--put":
-        method = "put";
-        break;
-      case "-pa":
-      case "--patch":
-        method = "patch";
-        break;
-      case "-d":
-      case "--delete":
-        method = "delete";
-        break;
-      case "--head":
-        method = "head";
-        break;
       // Options
       case "-H":
       case "--header": {
@@ -137,25 +85,18 @@ function parseArgs(args) {
         if (idx > 0) headers[val.slice(0, idx).trim()] = val.slice(idx + 1).trim();
         break;
       }
-      case "--token":
-        token = args[++i];
-        break;
+      case "-F":
       case "--filter":
         filter = args[++i];
         break;
+      case "-X":
       case "--method":
         methodFilter = args[++i];
         break;
+      case "-A":
       case "--all":
         all = true;
         break;
-      case "-v":
-      case "--verbose":
-        verbose = true;
-        break;
-      case "--dry-run":
-        dryRun = true;
-        break;
       case "-h":
       case "--help":
         help = true;
@@ -166,6 +107,11 @@ function parseArgs(args) {
 `);
           process.exit(1);
         }
+        if (!segments.length && !explicitMethod && HTTP_METHODS.has(arg.toUpperCase())) {
+          method = arg.toLowerCase();
+          explicitMethod = true;
+          break;
+        }
         const eqeq = arg.indexOf("==");
         const eq = arg.indexOf("=");
         if (eqeq > 0) {
@@ -177,8 +123,7 @@ function parseArgs(args) {
         }
     }
   }
-  if (Object.keys(body).length && method === "get") method = "post";
-  return { segments, method, headers, query, body, token, filter, methodFilter, all, verbose, dryRun, help };
+  return { segments, method, explicitMethod, headers, query, body, filter, methodFilter, all, debug, dryRun, help };
 }
 async function readStdin() {
   if (process.stdin.isTTY) return void 0;
@@ -188,423 +133,349 @@ async function readStdin() {
   return text || void 0;
 }
 
-// src/help.ts
-import fuzzysort from "fuzzysort";
-function buildTrie(routes) {
-  const root = { name: "", isParam: false, methods: [], children: [] };
-  for (const route of routes) {
-    let node = root;
-    for (const seg of route.segments) {
-      let child = node.children.find((c) => c.name === seg.value && c.isParam === seg.isParam);
-      if (!child) {
-        child = { name: seg.value, isParam: seg.isParam, methods: [], children: [] };
-        node.children.push(child);
-      }
-      node = child;
+// ../../interfaces/mcp/src/command.ts
+import { resolve as resolve2 } from "path";
+import { readFile } from "fs/promises";
+import { spawn } from "child_process";
+async function runMcp(rt, args) {
+  const name = args[0];
+  if (!name || name === "--help" || name === "-h") {
+    console.log(`Serve a registered API as an MCP server over stdio.
+
+Usage:
+  godmode mcp <name> [options]
+
+Options:
+  --filter <text>             Fuzzy-filter routes by resource name
+  --method <method>           Filter by HTTP method (get, post, etc.)
+
+For package-based extensions, spawns the extension's MCP server.
+For spec-based extensions, serves routes as MCP tools.`);
+    process.exit(name ? 0 : 1);
+  }
+  let filter;
+  let method;
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--filter" && args[i + 1]) filter = args[++i];
+    else if (args[i] === "--method" && args[i + 1]) method = args[++i];
+  }
+  const pkgName = name.startsWith("@") ? name : `@godmode-cli/${name}`;
+  const pkgDir = resolve2(rt.godmodeHome, "node_modules", pkgName);
+  const mcpConfigPath = resolve2(pkgDir, ".mcp.json");
+  try {
+    const mcpConfig = JSON.parse(await readFile(mcpConfigPath, "utf-8"));
+    const serverKey = Object.keys(mcpConfig.mcpServers)[0];
+    const server = mcpConfig.mcpServers[serverKey];
+    if (server.type === "stdio" && server.command) {
+      const child = spawn(server.command, server.args || [], {
+        stdio: "inherit",
+        cwd: pkgDir,
+        env: { ...process.env, ...server.env }
+      });
+      child.on("exit", (code) => process.exit(code ?? 0));
+      return;
     }
-    node.methods.push({ method: route.method, summary: route.summary });
+  } catch {
   }
-  return root;
+  const manifest = await rt.loadManifest(name);
+  const { serveMcp } = await import("./server-L3L4TKK3.js");
+  await serveMcp(manifest, { filter, method, checkPermission: rt.checkPermission });
 }
-function navigateTrie(root, segments) {
-  let node = root;
-  const fullPath = [];
-  const params = [];
-  for (const seg of segments) {
-    const staticChild = node.children.find((c) => !c.isParam && c.name === seg);
-    if (staticChild) {
-      fullPath.push(seg);
-      node = staticChild;
-      continue;
-    }
-    const paramChild = node.children.find((c) => c.isParam);
-    if (paramChild) {
-      const nested = paramChild.children.find((c) => !c.isParam && c.name === seg);
-      if (nested) {
-        fullPath.push(`<${paramChild.name}>`, seg);
-        params.push({ name: paramChild.name, provided: false });
-        node = nested;
-        continue;
-      }
-      fullPath.push(seg);
-      params.push({ name: paramChild.name, provided: true, value: seg });
-      node = paramChild;
-      continue;
-    }
+
+// src/interfaces.ts
+var Interface = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** `godmode <ext> <iface>` with no resource — by default shows help.
+   *  MCP overrides to serve as an MCP server over stdio. */
+  async handleEmpty() {
+    this.showHelp();
+  }
+  /** Interface-specific arg validation. Return an error string to bail, or
+   *  null to proceed. Called after segments have been provided. */
+  validate() {
     return null;
   }
-  return { node, fullPath, params };
-}
-function getChildren(node) {
-  const statics = node.children.filter((c) => !c.isParam);
-  const params = node.children.filter((c) => c.isParam);
-  const result = [...statics];
-  for (const p of params) result.push(...p.children);
-  result.sort((a, b) => a.name.localeCompare(b.name));
-  return result;
-}
-var ACTION_ORDER = ["list", "create", "get", "update", "delete"];
-var METHOD_LABEL = {
-  get: "\x1B[1;38;5;34mGET\x1B[0m",
-  post: "\x1B[1;38;5;25mPOST\x1B[0m",
-  put: "\x1B[1;38;5;172mPUT\x1B[0m",
-  patch: "\x1B[1;38;5;30mPATCH\x1B[0m",
-  delete: "\x1B[1;38;5;160mDELETE\x1B[0m"
+  showHelp() {
+    const { manifest, extensionName, parsed, multi } = this.ctx;
+    const implicitMethodFilter = parsed.methodFilter || (parsed.explicitMethod ? parsed.method : void 0);
+    showApiHelp(manifest, extensionName, parsed.segments, parsed.filter, implicitMethodFilter, parsed.all, multi);
+  }
 };
-var DIM = "\x1B[2m";
-var ITALIC = "\x1B[3m";
-var RESET = "\x1B[0m";
-function methodToAction(method, isResource) {
-  switch (method) {
-    case "get":
-      return isResource ? "get" : "list";
-    case "post":
-      return isResource ? "update" : "create";
-    case "put":
-    case "patch":
-      return "update";
-    case "delete":
-      return "delete";
-    default:
-      return method;
+async function executeRoute(ctx) {
+  const { manifest, extensionName, iface, parsed } = ctx;
+  const query = parsed.query;
+  const hasBody = Object.keys(parsed.body).length > 0;
+  let body = hasBody ? JSON.stringify(parsed.body) : void 0;
+  if (!body && ["post", "put", "patch"].includes(parsed.method)) {
+    body = await readStdin();
   }
-}
-function getNodeActions(node) {
-  const actions = /* @__PURE__ */ new Set();
-  const paramChild = node.children.find((c) => c.isParam);
-  const isLeaf = !paramChild;
-  for (const ep of node.methods) actions.add(methodToAction(ep.method, isLeaf));
-  if (paramChild) {
-    for (const ep of paramChild.methods) actions.add(methodToAction(ep.method, true));
-  }
-  return [...actions].sort((a, b) => ACTION_ORDER.indexOf(a) - ACTION_ORDER.indexOf(b));
-}
-function getParamName(node) {
-  return node.children.find((c) => c.isParam)?.name || null;
-}
-function methodLabels(node) {
-  const methods = /* @__PURE__ */ new Set();
-  for (const ep of node.methods) methods.add(ep.method);
-  const paramChild = node.children.find((c) => c.isParam);
-  if (paramChild) for (const ep of paramChild.methods) methods.add(ep.method);
-  const order = ["get", "post", "put", "patch", "delete"];
-  return order.filter((m) => methods.has(m)).map((m) => METHOD_LABEL[m]).join(" ");
-}
-function showHelp() {
-  console.log(`\u0262\u1D0F\u1D05\u1D0D\u1D0F\u1D05\u1D07
-\x1B[2mbetter than mcp\x1B[0m
-
-Usage:
-  godmode <api> <resource> [id] [flags]
-  godmode <api> /path [flags]
-
-Setup:
-  create                      Create own custom API entrypoint
-  add <name|file>             Add API as CLI command from <name>.yaml config
-  update <name>               Re-fetch OpenAPI spec and rebuild routes
-  remove <name>               Unregister an API
-  list                        Show all registered APIs
-  mcp <name>                  Serve registered API as MCP server (stdio)
-  ...                         Run \x1B[2mgodmode add --help\x1B[0m for config format
-
-Navigation:
-  <api> --help                Show resources, auth, and usage
-  <api> <resource> --help     Show operations and sub-resources
-
-Methods:
-  -g,  --get                  GET (default)
-  -po, --post                 POST
-  -pu, --put                  PUT
-  -pa, --patch                PATCH
-  -d,  --delete               DELETE
-
-Data (httpie-style):
-  key=value                   Body field (JSON, implies POST)
-  key==value                  Query param (URL)
-
-Options:
-  -H  <key:value>             Add header
-      --token <tok>            Auth token (overrides config)
-      --dry-run                Preview request without sending
-  -v, --verbose                Show full request/response
-
-Use "godmode <api> --help" for API-specific usage.`);
-}
-function showApiHelp(manifest, apiName, path, filter, methodFilter, all) {
-  const root = buildTrie(manifest.routes);
-  const nav = navigateTrie(root, path);
-  if (!nav) {
-    console.log("No matching resource.");
+  if (parsed.segments[0]?.startsWith("/")) {
+    const rawPath = parsed.segments[0];
+    const route = manifest.routes.find((r) => r.method === parsed.method && r.path === rawPath);
+    const resource = route ? resourceFromSegments(route.segments) : resourceFromRawPath(rawPath);
+    const check2 = checkPermission({
+      extension: extensionName,
+      resource,
+      method: parsed.method
+    });
+    if (!check2.allowed) {
+      process.stderr.write(`Blocked: ${check2.reason}
+`);
+      process.stderr.write(`Suggested allow rule:
+${suggestedAllowRule({ extension: extensionName, resource, method: parsed.method })}
+`);
+      process.exit(EXIT_CODES.permissionDenied);
+    }
+    const syntheticRoute = {
+      path: rawPath,
+      method: parsed.method,
+      summary: "",
+      version: "",
+      segments: []
+    };
+    await execute(manifest, { route: syntheticRoute, params: {} }, {
+      headers: parsed.headers,
+      query,
+      body,
+      debug: parsed.debug,
+      dryRun: parsed.dryRun
+    });
     return;
   }
-  const { node, fullPath } = nav;
-  const actions = getNodeActions(node);
-  const param = getParamName(node);
-  const children = getChildren(node).filter((c) => !c.isParam);
-  const childNames = [...new Set(children.map((c) => c.name))];
-  const resourceName = fullPath.join(" ");
-  if (!path.length) {
-    const name = manifest.config.name || apiName;
-    const ver = manifest.specVersion ? ` \x1B[2mv${manifest.specVersion}\x1B[0m` : "";
-    const desc = manifest.description ? `
-\x1B[2m${manifest.description}\x1B[0m` : "";
-    console.log(`${name}${ver}${desc}
+  const match = matchRoute(manifest, parsed.segments, parsed.method);
+  if (!match) {
+    reportNoMatch(ctx);
+    process.exit(EXIT_CODES.notFound);
+  }
+  const check = checkPermission({
+    extension: extensionName,
+    resource: resourceFromSegments(match.route.segments),
+    method: parsed.method
+  });
+  if (!check.allowed) {
+    process.stderr.write(`Blocked: ${check.reason}
 `);
-    console.log(`Usage:
-  godmode ${apiName} <resource> [id] [flags]
+    process.stderr.write(`Suggested allow rule:
+${suggestedAllowRule({ extension: extensionName, resource: resourceFromSegments(match.route.segments), method: parsed.method })}
 `);
-    const auth = manifest.config.auth;
-    if (auth?.env) {
-      const ok = !!process.env[auth.env];
-      const status = ok ? "\x1B[32m(token provided)\x1B[0m" : "\x1B[31m(missing token)\x1B[0m";
-      console.log(`${auth.env} ${status}
+    process.exit(EXIT_CODES.permissionDenied);
+  }
+  await execute(manifest, match, {
+    headers: parsed.headers,
+    query,
+    body,
+    debug: parsed.debug,
+    dryRun: parsed.dryRun
+  });
+}
+function reportNoMatch(ctx) {
+  const { manifest, extensionName, iface, parsed } = ctx;
+  const HTTP_VERBS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
+  const trailingVerb = parsed.segments.map((s) => s.toUpperCase()).find((s) => HTTP_VERBS.has(s));
+  if (trailingVerb) {
+    const rest = parsed.segments.filter((s) => s.toUpperCase() !== trailingVerb);
+    process.stderr.write(`No route matching: ${parsed.segments.join(" ")}
 `);
-    }
-  } else {
-    const paramHint = getParamName(node);
-    const idRef = paramHint ? ` [${paramHint}]` : "";
-    console.log(`Usage:
-  godmode ${apiName} ${resourceName}${idRef} [flags]
+    process.stderr.write(`Method goes first: try 'godmode ${extensionName} ${iface} ${trailingVerb} ${rest.join(" ")}'
+`);
+    return;
+  }
+  process.stderr.write(`No ${parsed.method.toUpperCase()} route matching: ${parsed.segments.join(" ")}
+`);
+  for (const m of ["get", "post", "put", "patch", "delete"]) {
+    if (m === parsed.method) continue;
+    if (matchRoute(manifest, parsed.segments, m)) {
+      process.stderr.write(`  try: godmode ${extensionName} api ${m.toUpperCase()} ${parsed.segments.join(" ")}
 `);
-    const auth = manifest.config.auth;
-    if (auth?.env) {
-      const ok = !!process.env[auth.env];
-      const status = ok ? "\x1B[32m(token provided)\x1B[0m" : "\x1B[31m(missing token)\x1B[0m";
-      console.log(`${auth.env} ${status}`);
-    }
-    for (const p of nav.params) {
-      const status = p.provided ? `\x1B[32m(${p.value})\x1B[0m` : "\x1B[31m(missing parameter)\x1B[0m";
-      console.log(`<${p.name}> ${status}`);
     }
-    console.log("");
-    const mcpTools = manifest.config._mcpTools;
-    const mcpTool = mcpTools?.find((t) => t.name === path[path.length - 1]);
-    if (mcpTool?.inputSchema?.properties) {
-      const props = mcpTool.inputSchema.properties;
-      const required = new Set(mcpTool.inputSchema.required || []);
-      const toolName = mcpTool.name;
-      if (mcpTool.description) {
-        const first = mcpTool.description.split("\n")[0];
-        console.log(`${ITALIC}${first}${RESET}
+  }
+  const similar = suggestRoutes(manifest, parsed.segments).slice(0, 5);
+  if (similar.length) {
+    process.stderr.write("\nSimilar:\n");
+    const seen = /* @__PURE__ */ new Set();
+    for (const r of similar) {
+      const p = r.segments.map((s) => s.isParam ? `{${s.value}}` : s.value).join(" ");
+      if (seen.has(p)) continue;
+      seen.add(p);
+      process.stderr.write(`  ${p}
 `);
-      }
-      console.log("Parameters:");
-      for (const [name, schema] of Object.entries(props)) {
-        const req = required.has(name) ? `\x1B[1;38;5;160m[REQUIRED]${RESET} ` : "";
-        const desc = schema.description ? `${DIM}${ITALIC}${schema.description}${RESET}` : "";
-        console.log(`  ${name.padEnd(28)}${req}${desc}`);
-      }
-      console.log("");
-      console.log(`Example:
-  godmode ${apiName} ${toolName} ${[...required].map((r) => `${r}=...`).join(" ")}`);
-      console.log("");
-    } else {
-      const order = ["get", "post", "put", "patch", "delete"];
-      const pc = node.children.find((c) => c.isParam);
-      const rows = [];
-      for (const ep of node.methods) {
-        rows.push({ method: ep.method, summary: ep.summary, needsId: false });
-      }
-      if (pc) {
-        for (const ep of pc.methods) {
-          rows.push({ method: ep.method, summary: ep.summary, needsId: true });
-        }
-      }
-      if (rows.length) {
-        const lastSeg = path[path.length - 1] || resourceName;
-        const base = lastSeg;
-        const lines = [];
-        for (const m of order) {
-          for (const r of rows.filter((r2) => r2.method === m)) {
-            const id = r.needsId ? ` <${pc.name}>` : "";
-            let suffix = "";
-            if (m === "post" || m === "put" || m === "patch") suffix = " key=val";
-            if (m === "delete") suffix = " -d";
-            const needsFlag = !r.needsId && m !== "get" && m !== "post" || r.needsId && m === "post";
-            const flag = needsFlag ? ` -${m === "post" ? "po" : m === "put" ? "pu" : m === "patch" ? "pa" : ""}` : "";
-            const cmd = `${base}${id}${suffix}${flag}`.trim();
-            lines.push({ cmd, label: METHOD_LABEL[m] || m, desc: r.summary || "" });
-          }
-        }
-        const maxCmd = Math.max(...lines.map((l) => l.cmd.length));
-        for (const l of lines) {
-          const desc = l.desc ? `  ${ITALIC}${l.desc}${RESET}` : "";
-          console.log(`  ${l.cmd.padEnd(maxCmd + 2)}${l.label}${desc}`);
-        }
-        console.log("");
-      }
     }
   }
-  if (childNames.length) {
-    const ALL_METHODS = ["get", "post", "put", "patch", "delete"];
-    const mf = methodFilter ? fuzzysort.go(methodFilter, ALL_METHODS)[0]?.target : void 0;
-    if (methodFilter && !mf) {
-      console.log(`
-No method matching "${methodFilter}".`);
-      return;
+}
+var ApiInterface = class extends Interface {
+  validate() {
+    if (!this.ctx.parsed.explicitMethod) {
+      return `Missing HTTP method. Try: godmode ${this.ctx.extensionName} api GET ${this.ctx.parsed.segments.join(" ")}
+Valid methods: GET, POST, PUT, PATCH, DELETE, HEAD.`;
     }
-    let candidates = mf ? childNames.filter((n) => {
-      const child = children.find((c) => c.name === n);
-      if (!child) return false;
-      const methods = /* @__PURE__ */ new Set();
-      for (const ep of child.methods) methods.add(ep.method);
-      const pc = child.children.find((c) => c.isParam);
-      if (pc) for (const ep of pc.methods) methods.add(ep.method);
-      return methods.has(mf);
-    }) : childNames;
-    const filtered = filter ? fuzzysort.go(filter, candidates).map((r) => r.target) : candidates;
-    const prefix = `godmode ${apiName}${resourceName ? " " + resourceName : ""}`;
-    const label = filter || mf ? `Resources${filter ? ` matching "${filter}"` : ""}${mf ? ` with ${mf.toUpperCase()}${methodFilter !== mf ? ` (matched "${methodFilter}")` : ""}` : ""}:` : "Resources:";
-    console.log(`
-${label}`);
-    if (!filtered.length) {
-      console.log("  No matches.");
-    } else {
-      const limit = filter || mf || all ? filtered.length : 5;
-      const shown = filtered.slice(0, limit);
-      const more = filtered.length - shown.length;
-      for (const n of shown) {
-        const child = children.find((c) => c.name === n);
-        const labels = child ? methodLabels(child) : "";
-        const subCount = child ? getChildren(child).filter((c) => !c.isParam).length : 0;
-        const sub = subCount ? `  ${DIM}(${subCount} sub)${RESET}` : "";
-        const rawDesc = manifest.resourceDescriptions[n] || "";
-        const truncated = rawDesc.length > 60 ? rawDesc.slice(0, 57) + "..." : rawDesc;
-        const descStr = truncated ? `  ${ITALIC}${truncated}${RESET}` : "";
-        console.log(`  ${n.padEnd(28)}${labels}${sub}${descStr}`);
-      }
-      if (more) {
-        console.log(`  \x1B[2m...${more} more \u2192 use --all, --filter or --method\x1B[0m`);
-      }
+    return null;
+  }
+  execute() {
+    return executeRoute(this.ctx);
+  }
+};
+var GraphqlInterface = class extends Interface {
+  validate() {
+    const { parsed, extensionName } = this.ctx;
+    return validateGraphQLFlags(parsed.method, parsed.query, parsed.body, extensionName);
+  }
+  execute() {
+    return executeRoute(this.ctx);
+  }
+};
+var McpInterface = class extends Interface {
+  async handleEmpty() {
+    const { extensionName, rawRest } = this.ctx;
+    await runMcp(
+      {
+        godmodeHome: GODMODE_HOME,
+        loadManifest: (n) => loadManifest(n, "mcp"),
+        checkPermission
+      },
+      [extensionName, ...rawRest]
+    );
+  }
+  validate() {
+    const { parsed } = this.ctx;
+    return validateMcpFlags(parsed.method, parsed.query);
+  }
+  async execute() {
+    const { manifest, parsed, extensionName } = this.ctx;
+    const tool = parsed.segments[0];
+    const check = checkPermission({
+      extension: extensionName,
+      resource: resourceFromTool(tool),
+      method: "mcp"
+    });
+    if (!check.allowed) {
+      process.stderr.write(`Blocked: ${check.reason}
+`);
+      process.stderr.write(`Suggested allow rule:
+${suggestedAllowRule({ extension: extensionName, resource: resourceFromTool(tool), method: "mcp" })}
+`);
+      process.exit(EXIT_CODES.permissionDenied);
     }
-    console.log(`
-Use "${prefix} <resource> --help" for more.`);
+    const result = await executeMcpTool(manifest.config, tool, parsed.body, {
+      debug: parsed.debug,
+      dryRun: parsed.dryRun
+    });
+    if (result) process.stdout.write(result + "\n");
+  }
+};
+function getInterface(ctx) {
+  switch (ctx.iface) {
+    case "api":
+      return new ApiInterface(ctx);
+    case "graphql":
+      return new GraphqlInterface(ctx);
+    case "mcp":
+      return new McpInterface(ctx);
+    default:
+      throw new Error(`Unknown interface: ${ctx.iface}`);
   }
 }
 
 // src/index.ts
 loadEnv();
+var VALID_INTERFACES = /* @__PURE__ */ new Set(["api", "graphql", "mcp", "skill"]);
 async function main() {
   const args = process.argv.slice(2);
   if (!args.length || args.length === 1 && (args[0] === "-h" || args[0] === "--help")) {
+    warnSettingsErrors();
     showHelp();
     return;
   }
-  const cmd = args[0];
-  if (cmd === "create") {
-    const { configWizard } = await import("./prompt-DCFFOQ7K.js");
-    await configWizard();
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
+    await showVersion();
     return;
   }
-  if (cmd === "add") {
-    const { runAdd } = await import("./add-ZRNIX6DM.js");
-    await runAdd(args.slice(1));
+  const extensionSlug = args[0];
+  const rest = args.slice(1);
+  const builtin = BUILTINS.get(extensionSlug);
+  if (builtin) {
+    await builtin.run(rest);
     return;
   }
-  if (cmd === "update") {
-    if (!args[1]) {
-      console.error("Usage: godmode update <name>");
-      process.exit(1);
-    }
-    await updateApi(args[1]);
-    return;
+  const multi = findInstalledManifestSync(extensionSlug);
+  if (!multi) {
+    process.stderr.write(`'${extensionSlug}' is not an installed extension.
+`);
+    process.stderr.write(`Try 'godmode ext list' to see installed extensions.
+`);
+    process.stderr.write(`Try 'godmode --help' for more information.
+`);
+    process.exit(EXIT_CODES.notFound);
   }
-  if (cmd === "remove") {
-    if (!args[1]) {
-      console.error("Usage: godmode remove <name>");
-      process.exit(1);
-    }
-    await removeApi(args[1]);
+  const declared = Object.keys(multi.interfaces);
+  const first = rest[0];
+  if (!first || first === "--help" || first === "-h") {
+    showExtensionOverview(multi);
     return;
   }
-  if (cmd === "list") {
-    await listApis();
+  if (first === "--version" || first === "-v") {
+    showExtensionVersion(multi);
     return;
   }
-  if (cmd === "mcp") {
-    const { runMcp } = await import("./mcp-NZIEMQOM.js");
-    await runMcp(args.slice(1));
-    return;
+  if (!VALID_INTERFACES.has(first)) {
+    process.stderr.write(`Missing interface.
+`);
+    process.stderr.write(`'${extensionSlug}' declares: ${declared.join(", ")}.
+`);
+    process.stderr.write(`Try 'godmode ${extensionSlug} ${declared[0]} ${first}' or 'godmode ${extensionSlug} --help'.
+`);
+    process.exit(EXIT_CODES.usage);
   }
-  const apiName = cmd;
-  const parsed = parseArgs(args.slice(1));
-  const manifest = await loadManifest(apiName);
-  if (parsed.help || !parsed.segments.length) {
-    showApiHelp(manifest, apiName, parsed.segments, parsed.filter, parsed.methodFilter, parsed.all);
-    return;
+  if (!declared.includes(first)) {
+    process.stderr.write(`'${extensionSlug}' does not declare a '${first}' interface.
+`);
+    process.stderr.write(`Declared: ${declared.join(", ")}.
+`);
+    process.stderr.write(`Try 'godmode ${extensionSlug} --help' for more information.
+`);
+    process.exit(EXIT_CODES.usage);
   }
-  if (manifest.config.type === "graphql") {
-    const err = validateGraphQLFlags(parsed.method, parsed.query, parsed.body, apiName);
-    if (err) {
-      process.stderr.write(err + "\n");
-      process.exit(1);
-    }
+  await runInterface(first, extensionSlug, rest.slice(1));
+}
+async function runInterface(iface, extensionName, rest) {
+  if (iface === "skill") {
+    process.stderr.write(`Skill interface not yet implemented.
+`);
+    process.exit(EXIT_CODES.usage);
   }
-  if (manifest.config.type === "mcp") {
-    const err = validateMcpFlags(parsed.method, parsed.query);
-    if (err) {
-      process.stderr.write(err + "\n");
-      process.exit(1);
-    }
-    const result = await executeMcpTool(manifest.config, parsed.segments[0], parsed.body, {
-      verbose: parsed.verbose,
-      dryRun: parsed.dryRun
-    });
-    if (result) process.stdout.write(result + "\n");
+  if (rest.includes("--version") || rest.includes("-v")) {
+    const multi2 = await loadMultiManifest(extensionName);
+    showExtensionVersion(multi2);
     return;
   }
-  const query = parsed.query;
-  const hasBody = Object.keys(parsed.body).length > 0;
-  let body = hasBody ? JSON.stringify(parsed.body) : void 0;
-  if (!body && ["post", "put", "patch"].includes(parsed.method)) body = await readStdin();
-  if (parsed.segments[0]?.startsWith("/")) {
-    const rawPath = parsed.segments[0];
-    const syntheticRoute = { path: rawPath, method: parsed.method, summary: "", version: "", segments: [] };
-    await execute(manifest, { route: syntheticRoute, params: {} }, {
-      headers: parsed.headers,
-      query,
-      body,
-      token: parsed.token,
-      verbose: parsed.verbose,
-      dryRun: parsed.dryRun
-    });
+  const ifaceKey = iface;
+  const parsed = parseArgs(rest);
+  const multi = await loadMultiManifest(extensionName);
+  const manifest = await loadManifest(extensionName, ifaceKey);
+  const handler = getInterface({
+    iface: ifaceKey,
+    extensionName,
+    manifest,
+    multi,
+    parsed,
+    rawRest: rest
+  });
+  if (parsed.help) {
+    handler.showHelp();
     return;
   }
-  const match = matchRoute(manifest, parsed.segments, parsed.method);
-  if (!match) {
-    process.stderr.write(`No ${parsed.method.toUpperCase()} route matching: ${parsed.segments.join(" ")}
-`);
-    for (const m of ["get", "post", "put", "patch", "delete"]) {
-      if (m === parsed.method) continue;
-      const alt = matchRoute(manifest, parsed.segments, m);
-      if (alt) {
-        const flag = m === "delete" ? "-d" : `--${m}`;
-        process.stderr.write(`  try: godmode ${apiName} ${parsed.segments.join(" ")} ${flag}
-`);
-      }
-    }
-    const similar = suggestRoutes(manifest, parsed.segments).slice(0, 5);
-    if (similar.length) {
-      process.stderr.write("\nSimilar:\n");
-      const seen = /* @__PURE__ */ new Set();
-      for (const r of similar) {
-        const p = r.segments.map((s) => s.isParam ? `{${s.value}}` : s.value).join(" ");
-        if (seen.has(p)) continue;
-        seen.add(p);
-        process.stderr.write(`  ${p}
-`);
-      }
-    }
-    process.exit(1);
+  if (!parsed.segments.length) {
+    await handler.handleEmpty();
+    return;
   }
-  await execute(manifest, match, {
-    headers: parsed.headers,
-    query,
-    body,
-    token: parsed.token,
-    verbose: parsed.verbose,
-    dryRun: parsed.dryRun
-  });
+  const err = handler.validate();
+  if (err) {
+    process.stderr.write(err + "\n");
+    process.exit(EXIT_CODES.usage);
+  }
+  await handler.execute();
 }
 main().catch((err) => {
   process.stderr.write(`${err.message || err}