godmode 0.0.2 → 0.0.3

package/dist/index.js

@@ -1,25 +1,42 @@
 #!/usr/bin/env node
 import {
-  execute
-} from "./chunk-GJCJO7YT.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 {
+  warnSettingsErrors
+} from "./chunk-SMQBMG24.js";
 import {
-  GODMODE_EXTENSIONS_DIR,
+  BUILTINS,
   GODMODE_HOME,
-  listApis,
+  findInstalledManifestSync,
   loadManifest,
   loadMultiManifest,
-  removeApi,
-  updateApi,
   validateGraphQLFlags
-} from "./chunk-2J2VDCQ4.js";
+} from "./chunk-KHFZI7IA.js";
+import {
+  execute
+} from "./chunk-AWGLXW3B.js";
 import {
   executeMcpTool,
   validateMcpFlags
-} from "./chunk-EXWYJU2I.js";
-
-// src/index.ts
-import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve5 } from "path";
+} from "./chunk-3AQ2CZKC.js";
+import "./chunk-YDXTIN53.js";
 
 // src/env.ts
 import { readFileSync } from "fs";
@@ -42,108 +59,6 @@ function loadEnv() {
   }
 }
 
-// ../../interfaces/api/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];
-  });
-}
-
-// ../../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;
-    }
-  } catch {
-  }
-  const manifest = await rt.loadManifest(name);
-  const { serveMcp } = await import("./server-4YVOAJJG.js");
-  await serveMcp(manifest, { filter, method });
-}
-
 // src/args.ts
 var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
 function parseArgs(args) {
@@ -156,7 +71,7 @@ function parseArgs(args) {
   let filter;
   let methodFilter;
   let all = false;
-  const verbose = process.env.GODMODE_VERBOSE === "1";
+  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++) {
@@ -208,7 +123,7 @@ function parseArgs(args) {
         }
     }
   }
-  return { segments, method, explicitMethod, headers, query, body, 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;
@@ -218,1266 +133,258 @@ async function readStdin() {
   return text || void 0;
 }
 
-// src/help.ts
-import fuzzysort from "fuzzysort";
+// ../../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.
 
-// ../cli-tools/src/index.ts
-var USE_COLOR = process.stdout.isTTY;
-var DIM = USE_COLOR ? "\x1B[2m" : "";
-var ITALIC = USE_COLOR ? "\x1B[3m" : "";
-var RESET = USE_COLOR ? "\x1B[0m" : "";
-var RED = USE_COLOR ? "\x1B[31m" : "";
-function visibleLength(s) {
-  return s.replace(/\x1b\[[0-9;]*m/g, "").length;
-}
-function wrapText(text, width) {
-  if (text.length <= width) return [text];
-  const out = [];
-  let line = "";
-  for (const word of text.split(/\s+/)) {
-    if (!line) {
-      line = word;
-      continue;
-    }
-    if (line.length + 1 + word.length <= width) {
-      line += " " + word;
-    } else {
-      out.push(line);
-      line = word;
-    }
-  }
-  if (line) out.push(line);
-  return out;
-}
-function renderSections(sections, maxLineWidth = 80) {
-  const INDENT = "  ";
-  const GAP = "  ";
-  const flattened = sections.map((s) => {
-    if (!s.rows.length) return { title: s.title, rows: [] };
-    const cols = Math.max(...s.rows.map((r) => r.length));
-    const widths = Array(cols).fill(0);
-    for (const row of s.rows) {
-      for (let i = 0; i < cols; i++) {
-        widths[i] = Math.max(widths[i], visibleLength(row[i] ?? ""));
-      }
-    }
-    const rows = s.rows.map((row) => {
-      const left = row.slice(0, cols - 1).map((cell, i) => (cell ?? "") + " ".repeat(widths[i] - visibleLength(cell ?? ""))).join(GAP).replace(/\s+$/, "");
-      const desc = row[cols - 1] ?? "";
-      return [left, desc];
-    });
-    return { title: s.title, rows };
-  });
-  const allRows = flattened.flatMap((s) => s.rows);
-  if (!allRows.length) return;
-  const rowsWithDesc = allRows.filter((r) => r[1].length > 0);
-  const widthCandidates = (rowsWithDesc.length ? rowsWithDesc : allRows).map((r) => visibleLength(r[0]));
-  const globalLeft = Math.max(...widthCandidates);
-  const descBudget = Math.max(20, maxLineWidth - INDENT.length - globalLeft - GAP.length);
-  for (const s of flattened) {
-    if (!s.rows.length) continue;
-    if (s.title) {
-      console.log("");
-      console.log(s.title);
-    }
-    for (const [left, desc] of s.rows) {
-      const pad = " ".repeat(Math.max(0, globalLeft - visibleLength(left)));
-      const plain = desc.replace(/\x1b\[[0-9;]*m/g, "");
-      if (!plain) {
-        console.log(`${INDENT}${left}${pad}`.trimEnd());
-        continue;
-      }
-      if (plain.length <= descBudget) {
-        console.log(`${INDENT}${left}${pad}${GAP}${desc}`);
-        continue;
-      }
-      const italic = /^\x1b\[3m/.test(desc);
-      const wrap = (s2) => italic ? `${ITALIC}${s2}${RESET}` : s2;
-      const lines = wrapText(plain, Math.max(10, descBudget));
-      console.log(`${INDENT}${left}${pad}${GAP}${wrap(lines[0])}`);
-      for (let i = 1; i < lines.length; i++) {
-        console.log(`${INDENT}${" ".repeat(Math.max(0, globalLeft))}${GAP}${wrap(lines[i])}`);
-      }
-    }
-  }
-}
-function authMissingLabel(type) {
-  switch (type) {
-    case "api-key":
-      return "missing api-key";
-    case "basic":
-      return "missing basic auth credentials";
-    case "bearer":
-    default:
-      return "missing bearer token";
-  }
-}
-var HelpPage = class {
-  title() {
-    return null;
-  }
-  tagline() {
-    return null;
-  }
-  authNote() {
-    return null;
-  }
-  usage() {
-    return [];
-  }
-  sections() {
-    return [];
-  }
-  footer() {
-    return null;
-  }
-  toJSON() {
-    return {
-      title: this.title(),
-      tagline: this.tagline(),
-      authNote: this.authNote(),
-      usage: this.usage(),
-      sections: this.sections(),
-      footer: this.footer()
-    };
-  }
-  render() {
-    const d = this.toJSON();
-    let wrote = false;
-    if (d.title) {
-      console.log(d.title);
-      wrote = true;
-    }
-    if (d.tagline) {
-      if (wrote) console.log("");
-      console.log(d.tagline);
-      wrote = true;
-    }
-    if (d.authNote && !d.authNote.present) {
-      const arrow = USE_COLOR ? `${RED}-->${RESET}` : "-->";
-      const label = authMissingLabel(d.authNote.authType);
-      const body = USE_COLOR ? `${RED}${label}${RESET}` : label;
-      if (wrote) console.log("");
-      console.log(`${arrow} ${d.authNote.env}: ${body}`);
-      wrote = true;
-    }
-    if (d.usage.length) {
-      if (wrote) console.log("");
-      for (let i = 0; i < d.usage.length; i++) {
-        const prefix = i === 0 ? "Usage:" : "   or:";
-        console.log(`${prefix} ${d.usage[i]}`);
-      }
-      wrote = true;
-    }
-    renderSections(d.sections);
-    if (d.footer) {
-      if (d.footer.extras?.length) {
-        console.log("");
-        for (const line of d.footer.extras) console.log(line);
-      }
-      if (d.footer.reportBugs || d.footer.homepage) {
-        console.log("");
-        if (d.footer.reportBugs) console.log(`Report bugs to <${d.footer.reportBugs}>.`);
-        if (d.footer.homepage) console.log(`Godmode home page: <${d.footer.homepage}>.`);
-      }
-    }
-  }
-};
+Usage:
+  godmode mcp <name> [options]
 
-// src/help.ts
-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;
-    }
-    node.methods.push({ method: route.method, summary: route.summary });
-  }
-  return root;
-}
-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;
-    }
-    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 METHOD_LABEL = USE_COLOR ? {
-  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"
-} : { get: "GET", post: "POST", put: "PUT", patch: "PATCH", delete: "DELETE" };
-var INTERFACE_LABEL = {
-  api: "API",
-  graphql: "GraphQL",
-  mcp: "MCP",
-  skill: "Skill"
-};
-var titleCase = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-var ROOT_OPTION_ROWS = [
-  ["-v, --version", "output version information and exit"]
-];
-var INTERFACE_OPTION_ROWS = [
-  ["-H, --header <key:value>", "add a request header"],
-  ["-A, --all", "list all resources"],
-  ["-F, --filter <text>", "fuzzy-filter resources by name"],
-  ["-X, --method <verb>", "filter resources by HTTP method"],
-  ["-h, --help", "show help for this subcommand"],
-  ["-v, --version", "show extension spec versions"]
-];
-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(" ");
-}
-var RootHelp = class extends HelpPage {
-  tagline() {
-    return "A control surface of agentic I/O.";
-  }
-  usage() {
-    return [
-      "godmode <extension> [args]...",
-      "godmode <extension> <interface> [args]..."
-    ];
-  }
-  sections() {
-    return [
-      { title: "Built-in extensions:", rows: [
-        ["ext", "Install and manage godmode extensions"],
-        ["agent", "Coding-agent workflows"]
-      ] },
-      { title: "Options:", rows: ROOT_OPTION_ROWS }
-    ];
-  }
-  footer() {
-    return {
-      extras: [
-        'Run "godmode ext list" to see installed extensions.',
-        'Run "godmode <extension> --help" for extension-specific usage.'
-      ],
-      reportBugs: "https://github.com/tomsiwik/godmode/issues",
-      homepage: "https://godmode.so"
-    };
-  }
-};
-var ExtensionOverview = class extends HelpPage {
-  constructor(multi) {
-    super();
-    this.multi = multi;
-  }
-  title() {
-    return titleCase(this.multi.name || this.multi.slug);
-  }
-  usage() {
-    const declared = Object.keys(this.multi.interfaces);
-    const args = (iface) => iface === "mcp" ? " <tool> [args]" : iface === "graphql" ? " <query> [flags]" : " <method> <resource> [id] [flags]";
-    return declared.map((iface) => `godmode ${this.multi.slug} ${iface}${args(iface)}`);
-  }
-  sections() {
-    const declared = Object.keys(this.multi.interfaces);
-    return [
-      { title: "Interfaces:", rows: declared.map((iface) => {
-        const d = this.multi.interfaces[iface];
-        const url = d && "url" in d && d.url ? d.url : "(local)";
-        return [iface, url];
-      }) },
-      { title: "Options:", rows: [["-v, --version", "show extension spec versions"]] }
-    ];
-  }
-};
-var ExtensionVersionPage = class extends HelpPage {
-  constructor(multi) {
-    super();
-    this.multi = multi;
-  }
-  title() {
-    return titleCase(this.multi.name || this.multi.slug);
-  }
-  sections() {
-    const declared = Object.keys(this.multi.interfaces);
-    return [
-      { title: "", rows: declared.map((iface) => {
-        const d = this.multi.interfaces[iface];
-        return [iface, d?.specVersion || "(unversioned)"];
-      }) }
-    ];
-  }
-};
-var InterfaceHelp = class extends HelpPage {
-  constructor(manifest, apiName, rawPath = [], opts = {}) {
-    super();
-    this.manifest = manifest;
-    this.apiName = apiName;
-    this.opts = opts;
-    const HTTP_VERBS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD"]);
-    const cleaned = [...rawPath];
-    while (cleaned.length && HTTP_VERBS.has(cleaned[cleaned.length - 1].toUpperCase())) {
-      cleaned.pop();
-    }
-    this.path = cleaned;
-  }
-  path;
-  get ifaceType() {
-    return this.manifest.config.type;
-  }
-  getNav() {
-    const root = buildTrie(this.manifest.routes);
-    return navigateTrie(root, this.path);
-  }
-  title() {
-    if (this.path.length) return null;
-    return `${titleCase(this.manifest.config.name || this.apiName)} ${INTERFACE_LABEL[this.ifaceType] || this.ifaceType}`;
-  }
-  authNote() {
-    const auth = this.manifest.config.auth;
-    if (!auth?.env) return null;
-    return {
-      env: auth.env,
-      authType: auth.type || "bearer",
-      present: !!process.env[auth.env]
-    };
+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);
   }
-  usage() {
-    if (!this.path.length) {
-      const multi = this.opts.multi;
-      const declared = multi ? Object.keys(multi.interfaces) : [this.ifaceType];
-      const ordered = [this.ifaceType, ...declared.filter((k) => k !== this.ifaceType)];
-      const args = (iface) => iface === "mcp" ? " <tool> [args]" : iface === "graphql" ? " <query> [flags]" : " <method> <resource> [id] [flags]";
-      return ordered.map((iface) => `godmode ${this.apiName} ${iface}${args(iface)}`);
-    }
-    const nav = this.getNav();
-    if (!nav) return [];
-    const paramHint = getParamName(nav.node);
-    const idRef = paramHint ? ` [${paramHint}]` : "";
-    const methodSlot = this.ifaceType === "api" ? "<method> " : "";
-    return [`godmode ${this.apiName} ${this.ifaceType} ${methodSlot}${nav.fullPath.join(" ")}${idRef} [flags]`];
+  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];
   }
-  sections() {
-    const nav = this.getNav();
-    if (!nav) return [];
-    const sections = [];
-    if (!this.path.length) {
-      if (this.ifaceType === "api") {
-        const methodsPresent = new Set(this.manifest.routes.map((r) => r.method.toLowerCase()));
-        const METHOD_DESC = {
-          get: "retrieve a resource",
-          post: "create a resource or send a command",
-          put: "replace a resource",
-          patch: "modify a resource",
-          delete: "remove a resource",
-          head: "retrieve headers only"
-        };
-        const order = ["get", "post", "put", "patch", "delete", "head"];
-        const methodsHere = order.filter((m) => methodsPresent.has(m));
-        if (methodsHere.length) {
-          sections.push({
-            title: "Methods:",
-            rows: methodsHere.map((m) => [METHOD_LABEL[m] || m.toUpperCase(), METHOD_DESC[m]])
-          });
-        }
-      }
-    } else {
-      const mcpTools = this.manifest.config._mcpTools;
-      const mcpTool = mcpTools?.find((t) => t.name === this.path[this.path.length - 1]);
-      if (mcpTool?.inputSchema?.properties) {
-        const props = mcpTool.inputSchema.properties;
-        const required = new Set(mcpTool.inputSchema.required || []);
-        const rows = [];
-        for (const [name, schema] of Object.entries(props)) {
-          const req = required.has(name) ? `${RED}[REQUIRED]${RESET}` : "";
-          const desc = schema.description ? `${ITALIC}${schema.description}${RESET}` : "";
-          rows.push([name, req, desc]);
-        }
-        sections.push({ title: "Parameters:", rows });
-      } else {
-        const order = ["get", "post", "put", "patch", "delete"];
-        const pc = nav.node.children.find((c) => c.isParam);
-        const items = [];
-        for (const ep of nav.node.methods) items.push({ method: ep.method, summary: ep.summary, needsId: false });
-        if (pc) for (const ep of pc.methods) items.push({ method: ep.method, summary: ep.summary, needsId: true });
-        if (items.length) {
-          const rows = [];
-          for (const m of order) {
-            for (const r of items.filter((r2) => r2.method === m)) {
-              const label = METHOD_LABEL[m] || m.toUpperCase();
-              const idArg = r.needsId ? `<${pc.name}>` : "";
-              const desc = r.summary ? `${ITALIC}${r.summary}${RESET}` : "";
-              rows.push([label, idArg, desc]);
-            }
-          }
-          sections.push({ title: "Methods:", rows });
-        }
-      }
+  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;
     }
-    const children = getChildren(nav.node).filter((c) => !c.isParam);
-    const childNames = [...new Set(children.map((c) => c.name))];
-    const resourceSection = buildResourceSection(
-      children,
-      childNames,
-      this.manifest,
-      this.opts.filter,
-      this.opts.methodFilter,
-      this.opts.all
-    );
-    if (resourceSection) sections.push(resourceSection.section);
-    sections.push({ title: "Options:", rows: INTERFACE_OPTION_ROWS });
-    return sections;
-  }
-  /** Drilled-in view also shows param status lines (ANSI-only). */
-  render() {
-    super.render();
+  } catch {
   }
-};
-function showHelp() {
-  new RootHelp().render();
-}
-function showExtensionOverview(multi) {
-  new ExtensionOverview(multi).render();
-}
-function showExtensionVersion(multi) {
-  new ExtensionVersionPage(multi).render();
-}
-function showApiHelp(manifest, apiName, path, filter, methodFilter, all, multi) {
-  new InterfaceHelp(manifest, apiName, path, { multi, filter, methodFilter, all }).render();
+  const manifest = await rt.loadManifest(name);
+  const { serveMcp } = await import("./server-L3L4TKK3.js");
+  await serveMcp(manifest, { filter, method, checkPermission: rt.checkPermission });
 }
-async function showVersion() {
-  const { readFile: readFile2 } = await import("fs/promises");
-  const { resolve: resolve6, dirname } = await import("path");
-  const { fileURLToPath } = await import("url");
-  const root = resolve6(dirname(fileURLToPath(import.meta.url)), "..");
-  const pkg = JSON.parse(await readFile2(resolve6(root, "package.json"), "utf-8"));
-  const license = await readFile2(resolve6(root, "LICENSE"), "utf-8");
-  const copyright = license.match(/^Copyright.*$/m)?.[0] ?? "";
-  console.log(`godmode ${pkg.version}
 
-${pkg.license} License
-${copyright}`);
-}
-function buildResourceSection(children, childNames, manifest, filter, methodFilter, all) {
-  if (!childNames.length) return null;
-  const ALL_METHODS = ["get", "post", "put", "patch", "delete"];
-  const mf = methodFilter ? fuzzysort.go(methodFilter, ALL_METHODS)[0]?.target : void 0;
-  if (methodFilter && !mf) return null;
-  const 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 title = filter || mf ? `Resources${filter ? ` matching "${filter}"` : ""}${mf ? ` with ${mf.toUpperCase()}` : ""}:` : "Resources:";
-  if (!filtered.length) return { section: { title, rows: [["  No matches.", ""]] } };
-  const limit = filter || mf || all ? filtered.length : 5;
-  const shown = filtered.slice(0, limit);
-  const more = filtered.length - shown.length;
-  const rows = [];
-  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 ? `(${subCount} sub)` : "";
-    const rawDesc = manifest.resourceDescriptions[n] || "";
-    const desc = rawDesc ? `${ITALIC}${rawDesc}${RESET}` : "";
-    const parts = [labels, sub, desc].filter(Boolean);
-    rows.push([n, parts.join("  ")]);
-  }
-  if (more) {
-    const verb = mf ? ` ${mf.toUpperCase()}` : "";
-    const hintText = `${more} more${verb} resources. Use options to display more`;
-    const dots = USE_COLOR ? `${DIM}...${RESET}` : "...";
-    const body = USE_COLOR ? `${DIM}${hintText}${RESET}` : hintText;
-    rows.push([dots, body]);
+// 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 { section: { title, rows } };
-}
-
-// ../../commands/agent/dist/index.js
-import { spawnSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve3 } from "path";
-import { closeSync, existsSync as existsSync2, openSync, readFileSync as readFileSync2, readSync, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve22 } from "path";
-import { randomUUID } from "crypto";
-import { mkdirSync, readFileSync as readFileSync4, writeFileSync, existsSync, readdirSync } from "fs";
-import { homedir } from "os";
-import { resolve as resolve4 } from "path";
-var DEFAULT_HARNESS_ORDER = ["claude", "codex", "gemini", "pi"];
-var HARNESSES = {
-  claude: {
-    id: "claude",
-    displayName: "Claude Code",
-    command: "claude",
-    modelFlags: ["--model"],
-    effortFlags: ["--effort"],
-    helpArgs: ["--help"],
-    promptHints: ["[prompt]", "your prompt"],
-    buildTurnArgs: ({ prompt, model, effort, passthroughArgs, resumeToken }) => [
-      "-p",
-      "--verbose",
-      "--output-format",
-      "stream-json",
-      ...resumeToken ? ["--resume", resumeToken] : [],
-      ...model ? ["--model", model] : [],
-      ...effort ? ["--effort", effort] : [],
-      prompt,
-      ...passthroughArgs
-    ]
-  },
-  codex: {
-    id: "codex",
-    displayName: "Codex CLI",
-    command: "codex",
-    modelFlags: ["-m", "--model"],
-    effortFlags: [],
-    helpArgs: ["--help"],
-    promptHints: ["[prompt]", "optional user prompt"],
-    buildTurnArgs: ({ prompt, model, passthroughArgs }) => [
-      "exec",
-      "--json",
-      ...model ? ["-m", model] : [],
-      prompt,
-      ...passthroughArgs
-    ]
-  },
-  gemini: {
-    id: "gemini",
-    displayName: "Gemini CLI",
-    command: "gemini",
-    modelFlags: ["-m", "--model"],
-    effortFlags: [],
-    helpArgs: ["--help"],
-    promptHints: ["query", "initial prompt"],
-    buildTurnArgs: ({ prompt, model, passthroughArgs, resumeToken }) => [
-      ...resumeToken ? ["--resume", resumeToken] : [],
-      ...model ? ["-m", model] : [],
-      "-p",
-      prompt,
-      "-o",
-      "stream-json",
-      ...passthroughArgs
-    ]
-  },
-  pi: {
-    id: "pi",
-    displayName: "Pi",
-    command: "pi",
-    modelFlags: ["--model"],
-    effortFlags: ["--thinking"],
-    helpArgs: ["--help"],
-    promptHints: ["[messages...]", "initial prompt"],
-    buildTurnArgs: ({ prompt, model, effort, passthroughArgs, resumeToken, sessionDir }) => [
-      "--print",
-      "--mode",
-      "json",
-      ...sessionDir ? ["--session-dir", sessionDir] : [],
-      ...resumeToken ? ["--continue"] : [],
-      ...model ? ["--model", model] : [],
-      ...effort ? ["--thinking", effort] : [],
-      prompt,
-      ...passthroughArgs
-    ]
+  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);
   }
 };
-function detectHarness(executor, requested) {
-  const ids = requested ? [requested] : DEFAULT_HARNESS_ORDER;
-  for (const id of ids) {
-    const harness = HARNESSES[id];
-    const result = executor(harness.command, harness.helpArgs);
-    if (!result.error && result.status === 0) return harness;
-  }
-  throw new Error(requested ? `Harness "${requested}" not found.` : "No supported coding harness found.");
-}
-function event(ts, id, turn, partial) {
-  return { ts, id, turn, ...partial };
-}
-function normalizeTurn(harness, id, turn, stdout, stderr, ts) {
-  const lines = stdout.split(/\r?\n/);
-  if (harness === "claude") return parseClaude(lines, id, turn, stderr, ts);
-  if (harness === "gemini") return parseGemini(lines, id, turn, stderr, ts);
-  if (harness === "pi") return parsePi(lines, id, turn, stderr, ts);
-  return {
-    sessionId: null,
-    assistantText: stdout.trim(),
-    events: [
-      event(ts, id, turn, { type: "turn.started" }),
-      event(ts, id, turn, { type: "assistant.completed", text: stdout.trim() }),
-      event(ts, id, turn, { type: "turn.completed", status: "completed" })
-    ]
-  };
-}
-function parseClaude(lines, id, turn, stderr, ts) {
-  const events = [];
-  let sessionId = null;
-  let assistantText = "";
-  let usage;
-  let timing;
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (parsed.type === "system" && parsed.subtype === "init") {
-      sessionId = parsed.session_id ?? sessionId;
-      events.push(event(ts, id, turn, { type: "turn.started" }));
-      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
-    }
-    if (parsed.type === "assistant") {
-      const text = (parsed.message?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("");
-      if (text) assistantText = text;
-      if (text) events.push(event(ts, id, turn, { type: "assistant.completed", text }));
-    }
-    if (parsed.type === "result") {
-      sessionId = parsed.session_id ?? sessionId;
-      usage = {
-        inputTokens: parsed.usage?.input_tokens,
-        outputTokens: parsed.usage?.output_tokens,
-        cachedTokens: parsed.usage?.cache_read_input_tokens
-      };
-      timing = { durationMs: parsed.duration_ms };
-      events.push(event(ts, id, turn, { type: "turn.completed", status: parsed.is_error ? "failed" : "completed" }));
-    }
+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();
   }
-  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
-  return { sessionId, assistantText, events, usage, timing };
-}
-function parseGemini(lines, id, turn, stderr, ts) {
-  const events = [];
-  let sessionId = null;
-  let assistantText = "";
-  let usage;
-  let timing;
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (parsed.type === "init") {
-      sessionId = parsed.session_id ?? sessionId;
-      events.push(event(ts, id, turn, { type: "turn.started" }));
-      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
-    }
-    if (parsed.type === "message" && parsed.role === "assistant" && parsed.delta === true && typeof parsed.content === "string") {
-      assistantText += parsed.content;
-      events.push(event(ts, id, turn, { type: "assistant.delta", text: parsed.content }));
-    }
-    if (parsed.type === "result") {
-      usage = {
-        inputTokens: parsed.stats?.input_tokens,
-        outputTokens: parsed.stats?.output_tokens,
-        cachedTokens: parsed.stats?.cached,
-        totalTokens: parsed.stats?.total_tokens
-      };
-      timing = { durationMs: parsed.stats?.duration_ms };
-      events.push(event(ts, id, turn, { type: "assistant.completed", text: assistantText }));
-      events.push(event(ts, id, turn, { type: "turn.completed", status: parsed.status === "success" ? "completed" : "failed" }));
+  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;
   }
-  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
-  return { sessionId, assistantText, events, usage, timing };
-}
-function parsePi(lines, id, turn, stderr, ts) {
-  const events = [];
-  let sessionId = null;
-  let assistantText = "";
-  for (const line of lines) {
-    if (!line.trim()) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (parsed.type === "session") {
-      sessionId = parsed.id ?? sessionId;
-      events.push(event(ts, id, turn, { type: "turn.started" }));
-      events.push(event(ts, id, turn, { type: "state.changed", state: "starting" }));
-    }
-    if (parsed.type === "turn_start") events.push(event(ts, id, turn, { type: "state.changed", state: "running" }));
-    if (parsed.type === "message_update" && parsed.assistantMessageEvent?.type === "thinking_start") {
-      events.push(event(ts, id, turn, { type: "state.changed", state: "thinking" }));
-    }
-    if (parsed.type === "message_update" && parsed.assistantMessageEvent?.type === "text_delta") {
-      const delta = parsed.assistantMessageEvent.delta ?? "";
-      assistantText += delta;
-      if (delta) events.push(event(ts, id, turn, { type: "assistant.delta", text: delta }));
-    }
-    if (parsed.type === "turn_end") {
-      const text = (parsed.message?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("");
-      if (text) assistantText = text;
-      events.push(event(ts, id, turn, { type: "assistant.completed", text: assistantText }));
-      events.push(event(ts, id, turn, { type: "turn.completed", status: "completed" }));
-    }
+  const match = matchRoute(manifest, parsed.segments, parsed.method);
+  if (!match) {
+    reportNoMatch(ctx);
+    process.exit(EXIT_CODES.notFound);
   }
-  for (const line of stderr.split(/\r?\n/).filter(Boolean)) events.push(event(ts, id, turn, { type: "warning", message: line }));
-  return { sessionId, assistantText, events };
-}
-var GODMODE_HOME2 = process.platform === "linux" && process.env.XDG_CONFIG_HOME ? resolve4(process.env.XDG_CONFIG_HOME, "godmode") : resolve4(homedir(), ".godmode");
-var CODING_AGENTS_HOME = resolve4(GODMODE_HOME2, "coding-agents");
-var RUNS_DIR = resolve4(CODING_AGENTS_HOME, "runs");
-var ACTIVE_RUNS_PATH = resolve4(CODING_AGENTS_HOME, "active-runs.json");
-function timestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function ensureDirs() {
-  mkdirSync(RUNS_DIR, { recursive: true });
-}
-function shellEscape(value) {
-  return `'${value.replace(/'/g, `"'"'`)}'`;
-}
-function writeJson(path, value) {
-  mkdirSync(resolve4(path, ".."), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+  const check = checkPermission({
+    extension: extensionName,
+    resource: resourceFromSegments(match.route.segments),
+    method: parsed.method
+  });
+  if (!check.allowed) {
+    process.stderr.write(`Blocked: ${check.reason}
 `);
-}
-function readJson(path) {
-  try {
-    return JSON.parse(readFileSync4(path, "utf-8"));
-  } catch {
-    return null;
+    process.stderr.write(`Suggested allow rule:
+${suggestedAllowRule({ extension: extensionName, resource: resourceFromSegments(match.route.segments), method: parsed.method })}
+`);
+    process.exit(EXIT_CODES.permissionDenied);
   }
-}
-function readSettingsFile(path) {
-  return readJson(path) ?? {};
-}
-function loadSettings(cwd = process.cwd()) {
-  const globalSettings = readSettingsFile(resolve4(GODMODE_HOME2, "settings.json"));
-  const projectSettings = readSettingsFile(resolve4(cwd, ".godmode", "settings.json"));
-  return {
-    ...globalSettings,
-    ...projectSettings,
-    plugins: {
-      ...globalSettings.plugins ?? {},
-      ...projectSettings.plugins ?? {},
-      "coding-agents": {
-        ...globalSettings.plugins?.["coding-agents"] ?? {},
-        ...projectSettings.plugins?.["coding-agents"] ?? {}
-      }
-    }
-  };
-}
-function loadActiveRuns() {
-  return readJson(ACTIVE_RUNS_PATH) ?? {};
-}
-function saveActiveRun(cwd, id) {
-  const current = loadActiveRuns();
-  current[cwd] = id;
-  writeJson(ACTIVE_RUNS_PATH, current);
-}
-function activeRunIdForCwd(cwd) {
-  return loadActiveRuns()[cwd] ?? null;
-}
-function runDir(id) {
-  return resolve4(RUNS_DIR, id);
-}
-function runPath(id) {
-  return resolve4(runDir(id), "run.json");
-}
-function turnDir(id, turn) {
-  return resolve4(runDir(id), "turns", String(turn).padStart(4, "0"));
-}
-function loadRun(id) {
-  const run = readJson(runPath(id));
-  if (!run) throw new Error(`Run not found: ${id}`);
-  return run;
-}
-function saveRun(run) {
-  run.updatedAt = timestamp();
-  writeJson(runPath(run.id), run);
-}
-function listRuns() {
-  ensureDirs();
-  return readdirSync(RUNS_DIR, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => readJson(runPath(entry.name))).filter((value) => !!value).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}
-function createRun(cwd, harness, model, effort) {
-  ensureDirs();
-  const id = `run-${Date.now()}-${randomUUID().slice(0, 8)}`;
-  const run = {
-    id,
-    cwd,
-    harness: harness.id,
-    harnessName: harness.displayName,
-    sessions: {
-      zmx: `godmode-agent-${harness.id}-${id.replace(/^run-/, "")}`
-    },
-    model: model ?? null,
-    effort: effort ?? null,
-    status: "idle",
-    createdAt: timestamp(),
-    updatedAt: timestamp(),
-    lastTurn: 0
-  };
-  mkdirSync(runDir(id), { recursive: true });
-  mkdirSync(resolve4(runDir(id), "turns"), { recursive: true });
-  saveRun(run);
-  saveActiveRun(cwd, id);
-  return run;
-}
-function buildShellCommand(harness, run, turn, prompt, passthroughArgs) {
-  const dir = turnDir(run.id, turn);
-  mkdirSync(dir, { recursive: true });
-  const stdoutPath = resolve4(dir, "stdout.log");
-  const stderrPath = resolve4(dir, "stderr.log");
-  const exitCodePath = resolve4(dir, "exit-code.txt");
-  const sessionDir = resolve4(runDir(run.id), "pi-session");
-  mkdirSync(sessionDir, { recursive: true });
-  const args = harness.buildTurnArgs({
-    prompt,
-    model: run.model ?? void 0,
-    effort: run.effort ?? void 0,
-    passthroughArgs,
-    resumeToken: run.sessions[run.harness] ?? void 0,
-    sessionDir
+  await execute(manifest, match, {
+    headers: parsed.headers,
+    query,
+    body,
+    debug: parsed.debug,
+    dryRun: parsed.dryRun
   });
-  const command = `${[harness.command, ...args].map(shellEscape).join(" ")} > ${shellEscape(stdoutPath)} 2> ${shellEscape(stderrPath)}`;
-  const shell = `${command}; code=$?; printf '%s' "$code" > ${shellEscape(exitCodePath)}; exit "$code"`;
-  return { shell, stdoutPath, stderrPath, exitCodePath };
-}
-function waitForFile(path, timeoutMs = 3e5) {
-  const started = Date.now();
-  while (!existsSync(path)) {
-    if (Date.now() - started > timeoutMs) throw new Error(`Timed out waiting for ${path}`);
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
-  }
-}
-function latestTurn(run) {
-  if (run.lastTurn < 1) throw new Error(`Run ${run.id} has no turns yet.`);
-  const turn = readJson(resolve4(turnDir(run.id, run.lastTurn), "normalized.json"));
-  if (!turn) throw new Error(`Turn ${run.lastTurn} not found for ${run.id}`);
-  return turn;
 }
-function resolveRunId(cwd, explicit) {
-  if (explicit) return explicit;
-  const active = activeRunIdForCwd(cwd);
-  if (!active) throw new Error(`No active coding-agent run for ${cwd}`);
-  return active;
-}
-function renderTurn(turn, outputMode) {
-  if (outputMode === "assistant-text") return turn.assistant.text;
-  if (outputMode === "raw") {
-    const stdout = existsSync2(turn.paths.stdout) ? readFileSync2(turn.paths.stdout, "utf-8") : "";
-    const stderr = existsSync2(turn.paths.stderr) ? readFileSync2(turn.paths.stderr, "utf-8") : "";
-    return JSON.stringify({ stdout, stderr }, null, 2);
-  }
-  if (outputMode === "events") {
-    return existsSync2(turn.paths.events) ? readFileSync2(turn.paths.events, "utf-8").trimEnd() : "";
-  }
-  return JSON.stringify(turn, null, 2);
-}
-function renderStatus(run) {
-  return JSON.stringify(run, null, 2);
-}
-function writeEvents(path, events) {
-  writeFileSyncSafe(path, `${events.map((event2) => JSON.stringify(event2)).join("\n")}
+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(" ")}
 `);
-}
-function writeFileSyncSafe(path, content) {
-  writeFileSync2(path, content);
-}
-function attachHelp() {
-  return [
-    "Usage: godmode agent attach run <id>",
-    "   or: godmode agent attach session <zmx-session-id>"
-  ].join("\n");
-}
-var AgentHelp = class extends HelpPage {
-  usage() {
-    return [
-      "godmode agent start [--harness <name>] [--model <id>] <prompt>",
-      "godmode agent send  [--harness <name>] [--model <id>] <prompt>",
-      "godmode agent attach run <id>",
-      "godmode agent attach session <session-id>",
-      "godmode agent output [id] [--json|--assistant-text|--events|--raw]",
-      "godmode agent status [id]",
-      "godmode agent list"
-    ];
-  }
-  sections() {
-    return [
-      { title: "Options:", rows: [
-        ["    --harness <name>", "coding agent harness (claude, codex, gemini, etc.)"],
-        ["    --model <id>", "model identifier passed to the harness"],
-        ["    --effort <level>", "effort level passed to the harness"],
-        ["    --json", "output machine-readable events"],
-        ["    --follow", "stream output until the run completes"]
-      ] },
-      { title: "Shortcuts:", rows: [
-        ["godmode agent <prompt>", "send prompt to active run, or start a new run"]
-      ] }
-    ];
-  }
-};
-function agentHelp() {
-  const lines = [];
-  const origLog = console.log;
-  console.log = (...args) => {
-    lines.push(args.join(" "));
-  };
-  try {
-    new AgentHelp().render();
-  } finally {
-    console.log = origLog;
+    process.stderr.write(`Method goes first: try 'godmode ${extensionName} ${iface} ${trailingVerb} ${rest.join(" ")}'
+`);
+    return;
   }
-  return lines.join("\n");
-}
-function followOutput(run, turn, outputMode, writer) {
-  const dir = turnDir(run.id, turn);
-  const stdoutPath = resolve22(dir, "stdout.log");
-  const stderrPath = resolve22(dir, "stderr.log");
-  const statePath = runPath(run.id);
-  let assistant = "";
-  const emit = (event2) => {
-    if (outputMode === "events") writer.write(`${JSON.stringify(event2)}
+  process.stderr.write(`No ${parsed.method.toUpperCase()} route matching: ${parsed.segments.join(" ")}
 `);
-    if (outputMode === "assistant-text") {
-      if (event2.type === "assistant.delta" && event2.text) writer.write(event2.text);
-      if (event2.type === "assistant.completed" && !assistant && event2.text) writer.write(event2.text);
-    }
-  };
-  streamFile(stdoutPath, (line) => {
-    const normalized = normalizeTurn(run.harness, run.id, turn, `${line}
-`, "", timestamp());
-    for (const event2 of normalized.events) {
-      if (event2.type === "assistant.delta" && event2.text) assistant += event2.text;
-      emit(event2);
-    }
-  }, () => (readJson2(statePath)?.status ?? "completed") === "running");
-  if (outputMode === "assistant-text") writer.write("\n");
-  if (outputMode === "events" && existsSync2(stderrPath)) {
-    for (const line of readFileSync2(stderrPath, "utf-8").split(/\r?\n/).filter(Boolean)) {
-      writer.write(`${JSON.stringify({ ts: timestamp(), id: run.id, turn, type: "warning", message: line })}
+  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(" ")}
 `);
     }
   }
-}
-function streamFile(path, onLine, until) {
-  let offset = 0;
-  let pending = "";
-  while (true) {
-    if (existsSync2(path)) {
-      const size = statSync(path).size;
-      if (size > offset) {
-        const fd = openSync(path, "r");
-        const buffer = Buffer.alloc(size - offset);
-        try {
-          const bytes = buffer.length ? readSync(fd, buffer, 0, buffer.length, offset) : 0;
-          offset += bytes;
-          pending += buffer.toString("utf-8", 0, bytes);
-          const lines = pending.split(/\r?\n/);
-          pending = lines.pop() ?? "";
-          for (const line of lines) if (line) onLine(line);
-        } finally {
-          closeSync(fd);
-        }
-      }
-    }
-    if (!until()) {
-      if (pending) onLine(pending);
-      return;
-    }
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
-  }
-}
-function readJson2(path) {
-  try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function defaultExecutor(command, args, stdio = "pipe") {
-  const spawnStdio = stdio === "inherit" ? "inherit" : "pipe";
-  const result = spawnSync(command, args, { encoding: "utf-8", stdio: spawnStdio });
-  return {
-    status: result.status,
-    stdout: stdio === "pipe" && typeof result.stdout === "string" ? result.stdout : "",
-    stderr: stdio === "pipe" && typeof result.stderr === "string" ? result.stderr : "",
-    error: result.error ?? void 0
-  };
-}
-function parseOutputMode(args) {
-  let outputMode = "json";
-  let follow = false;
-  const remaining = [];
-  for (const arg of args) {
-    if (arg === "--json") outputMode = "json";
-    else if (arg === "--assistant-text") outputMode = "assistant-text";
-    else if (arg === "--events") outputMode = "events";
-    else if (arg === "--raw") outputMode = "raw";
-    else if (arg === "--follow") follow = true;
-    else remaining.push(arg);
-  }
-  return { outputMode, follow, remaining };
-}
-function parseStartSendArgs(action, argv) {
-  const { outputMode, remaining } = parseOutputMode(argv);
-  let harness;
-  let model;
-  let effort;
-  let passthroughArgs = [];
-  const promptParts = [];
-  for (let i = 0; i < remaining.length; i++) {
-    const arg = remaining[i];
-    if (arg === "--") {
-      passthroughArgs = remaining.slice(i + 1);
-      break;
-    }
-    if (arg === "--harness") {
-      const value = remaining[++i];
-      if (!value || !(value in HARNESSES)) throw new Error("Missing or invalid value for --harness");
-      harness = value;
-      continue;
-    }
-    if (arg === "--model") {
-      model = remaining[++i];
-      if (!model) throw new Error("Missing value for --model");
-      continue;
-    }
-    if (arg === "--effort") {
-      effort = remaining[++i];
-      if (!effort) throw new Error("Missing value for --effort");
-      continue;
+  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}
+`);
     }
-    if (arg === "--help" || arg === "-h") throw new Error(agentHelp());
-    if (arg.startsWith("-")) throw new Error(`Unknown flag: ${arg}. Use -- to pass flags through to the native harness.`);
-    promptParts.push(arg);
   }
-  return { action, prompt: promptParts.join(" ").trim(), harness, model, effort, passthroughArgs, outputMode };
-}
-function parseOutputArgs(argv) {
-  const { outputMode, follow, remaining } = parseOutputMode(argv);
-  return { outputMode, follow, id: remaining.find((arg) => !arg.startsWith("-")) };
 }
-function classifyStatus(exitCode, stdout, stderr) {
-  const text = `${stdout}
-${stderr}`.toLowerCase();
-  if (exitCode === 0) return "completed";
-  if (text.includes("auth") || text.includes("api key") || text.includes("permission") || text.includes("may not exist")) return "blocked";
-  return "failed";
-}
-function resolveRunAndHarness(parsed, executor, cwd, options) {
-  const settings = options.settings ?? loadSettings(cwd);
-  const plugin = settings.plugins?.["coding-agents"];
-  const requestedHarnessId = parsed.harness ?? plugin?.harness;
-  let model = parsed.model ?? plugin?.model;
-  let effort = parsed.effort ?? plugin?.effort;
-  let run;
-  let harness;
-  if (parsed.action === "start") {
-    harness = detectHarness(executor, requestedHarnessId);
-    if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
-    run = createRun(cwd, harness, model, effort);
-  } else {
-    const active = activeRunIdForCwd(cwd);
-    if (active) {
-      run = loadRun(active);
-      if (parsed.harness && parsed.harness !== run.harness) throw new Error(`Active run uses harness ${run.harness}; start a new run for ${parsed.harness}.`);
-      harness = detectHarness(executor, run.harness);
-      model = parsed.model ?? run.model ?? plugin?.model ?? void 0;
-      effort = parsed.effort ?? run.effort ?? plugin?.effort ?? void 0;
-      if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
-      run.model = model ?? run.model;
-      run.effort = effort ?? run.effort;
-    } else {
-      harness = detectHarness(executor, requestedHarnessId);
-      if (effort && harness.effortFlags.length === 0) throw new Error(`Harness "${harness.id}" does not support --effort.`);
-      run = createRun(cwd, harness, model, effort);
+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.`;
     }
+    return null;
   }
-  run.status = "running";
-  run.model = model ?? run.model;
-  run.effort = effort ?? run.effort;
-  run.lastTurn += 1;
-  saveRun(run);
-  saveActiveRun(cwd, run.id);
-  return { run, harness };
-}
-function executeTurn(parsed, options) {
-  const executor = options.executor ?? defaultExecutor;
-  const writer = options.writer ?? process.stdout;
-  const errorWriter = options.errorWriter ?? process.stderr;
-  const cwd = options.cwd ?? process.cwd();
-  const zmxCheck = executor("zmx", ["--help"]);
-  if (zmxCheck.error || zmxCheck.status !== 0) {
-    errorWriter.write("zmx not found. Install zmx to use coding agents.\n");
-    return 2;
-  }
-  const { run, harness } = resolveRunAndHarness(parsed, executor, cwd, options);
-  const { shell, stdoutPath, stderrPath, exitCodePath } = buildShellCommand(harness, run, run.lastTurn, parsed.prompt, parsed.passthroughArgs);
-  const launch = executor("zmx", ["run", run.sessions.zmx, "sh", "-lc", shell], "ignore");
-  if (launch.error || launch.status !== 0) {
-    run.status = "failed";
-    saveRun(run);
-    errorWriter.write(`Failed to queue turn in zmx session ${run.sessions.zmx}.
-`);
-    return 3;
+  execute() {
+    return executeRoute(this.ctx);
   }
-  waitForFile(exitCodePath);
-  const exitCode = Number(readFileSync3(exitCodePath, "utf-8").trim() || "1");
-  const stdout = existsSync3(stdoutPath) ? readFileSync3(stdoutPath, "utf-8") : "";
-  const stderr = existsSync3(stderrPath) ? readFileSync3(stderrPath, "utf-8") : "";
-  const normalized = normalizeTurn(run.harness, run.id, run.lastTurn, stdout, stderr, (/* @__PURE__ */ new Date()).toISOString());
-  const turnStatus = classifyStatus(exitCode, stdout, stderr);
-  const turn = {
-    id: run.id,
-    turn: run.lastTurn,
-    status: turnStatus,
-    prompt: parsed.prompt,
-    harness: run.harness,
-    sessions: {
-      zmx: run.sessions.zmx,
-      ...normalized.sessionId || run.sessions[run.harness] ? { [run.harness]: normalized.sessionId ?? run.sessions[run.harness] } : {}
-    },
-    assistant: { text: normalized.assistantText },
-    usage: normalized.usage,
-    timing: normalized.timing,
-    paths: {
-      stdout: stdoutPath,
-      stderr: stderrPath,
-      events: resolve3(turnDir(run.id, run.lastTurn), "events.jsonl")
-    },
-    completedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeEvents(turn.paths.events, normalized.events);
-  writeJson(resolve3(turnDir(run.id, run.lastTurn), "normalized.json"), turn);
-  if (turn.sessions[run.harness]) run.sessions[run.harness] = turn.sessions[run.harness];
-  run.status = turnStatus;
-  saveRun(run);
-  writer.write(`${renderTurn(turn, parsed.outputMode)}
-`);
-  return turnStatus === "completed" ? 0 : 1;
-}
-function attachToTarget(argv, options) {
-  const executor = options.executor ?? defaultExecutor;
-  const errorWriter = options.errorWriter ?? process.stderr;
-  if (argv.length < 2) {
-    errorWriter.write(`${attachHelp()}
-`);
-    return 1;
+};
+var GraphqlInterface = class extends Interface {
+  validate() {
+    const { parsed, extensionName } = this.ctx;
+    return validateGraphQLFlags(parsed.method, parsed.query, parsed.body, extensionName);
   }
-  const session = argv[0] === "run" ? loadRun(argv[1]).sessions.zmx : argv[0] === "session" ? argv[1] : null;
-  if (!session) {
-    errorWriter.write(`${attachHelp()}
-`);
-    return 1;
+  execute() {
+    return executeRoute(this.ctx);
   }
-  return executor("zmx", ["attach", session], "inherit").status ?? 1;
-}
-function outputCommand(argv, options) {
-  const writer = options.writer ?? process.stdout;
-  const cwd = options.cwd ?? process.cwd();
-  const parsed = parseOutputArgs(argv);
-  const run = loadRun(resolveRunId(cwd, parsed.id));
-  if (parsed.follow && run.status === "running") {
-    followOutput(run, run.lastTurn, parsed.outputMode, writer);
-    return 0;
+};
+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]
+    );
   }
-  writer.write(`${renderTurn(latestTurn(run), parsed.outputMode)}
-`);
-  return 0;
-}
-function statusCommand(argv, options) {
-  const writer = options.writer ?? process.stdout;
-  const cwd = options.cwd ?? process.cwd();
-  writer.write(`${renderStatus(loadRun(resolveRunId(cwd, argv.find((arg) => !arg.startsWith("-")))))}
-`);
-  return 0;
-}
-function listCommand(options) {
-  const writer = options.writer ?? process.stdout;
-  writer.write(`${JSON.stringify(listRuns(), null, 2)}
-`);
-  return 0;
-}
-async function runAgentCommand(argv, options = {}) {
-  ensureDirs();
-  const writer = options.writer ?? process.stdout;
-  const errorWriter = options.errorWriter ?? process.stderr;
-  if (!argv.length) {
-    writer.write(`${agentHelp()}
+  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}
 `);
-    return 0;
-  }
-  try {
-    const [cmd, ...rest] = argv;
-    if (cmd === "--help" || cmd === "-h" || cmd === "help") {
-      writer.write(`${agentHelp()}
+      process.stderr.write(`Suggested allow rule:
+${suggestedAllowRule({ extension: extensionName, resource: resourceFromTool(tool), method: "mcp" })}
 `);
-      return 0;
+      process.exit(EXIT_CODES.permissionDenied);
     }
-    if (cmd === "start") return executeTurn(parseStartSendArgs("start", rest), options);
-    if (cmd === "send") return executeTurn(parseStartSendArgs("send", rest), options);
-    if (cmd === "attach") return attachToTarget(rest, options);
-    if (cmd === "output") return outputCommand(rest, options);
-    if (cmd === "status") return statusCommand(rest, options);
-    if (cmd === "list") return listCommand(options);
-    return executeTurn(parseStartSendArgs("send", argv), options);
-  } catch (error) {
-    errorWriter.write(`${error.message || error}
-`);
-    return 1;
+    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"]);
-var RESERVED_SLUGS = /* @__PURE__ */ new Set(["ext", "agent"]);
 async function main() {
   const args = process.argv.slice(2);
   if (!args.length || args.length === 1 && (args[0] === "-h" || args[0] === "--help")) {
+    warnSettingsErrors();
     showHelp();
     return;
   }
@@ -1487,15 +394,12 @@ async function main() {
   }
   const extensionSlug = args[0];
   const rest = args.slice(1);
-  if (extensionSlug === "ext") {
-    await runExt(rest);
+  const builtin = BUILTINS.get(extensionSlug);
+  if (builtin) {
+    await builtin.run(rest);
     return;
   }
-  if (extensionSlug === "agent") {
-    await runAgent(rest);
-    return;
-  }
-  const multi = installedExtension(extensionSlug);
+  const multi = findInstalledManifestSync(extensionSlug);
   if (!multi) {
     process.stderr.write(`'${extensionSlug}' is not an installed extension.
 `);
@@ -1503,9 +407,9 @@ async function main() {
 `);
     process.stderr.write(`Try 'godmode --help' for more information.
 `);
-    process.exit(1);
+    process.exit(EXIT_CODES.notFound);
   }
-  const declared = declaredInterfaces(multi);
+  const declared = Object.keys(multi.interfaces);
   const first = rest[0];
   if (!first || first === "--help" || first === "-h") {
     showExtensionOverview(multi);
@@ -1522,7 +426,7 @@ async function main() {
 `);
     process.stderr.write(`Try 'godmode ${extensionSlug} ${declared[0]} ${first}' or 'godmode ${extensionSlug} --help'.
 `);
-    process.exit(1);
+    process.exit(EXIT_CODES.usage);
   }
   if (!declared.includes(first)) {
     process.stderr.write(`'${extensionSlug}' does not declare a '${first}' interface.
@@ -1531,229 +435,47 @@ async function main() {
 `);
     process.stderr.write(`Try 'godmode ${extensionSlug} --help' for more information.
 `);
-    process.exit(1);
+    process.exit(EXIT_CODES.usage);
   }
   await runInterface(first, extensionSlug, rest.slice(1));
 }
-function installedExtension(name) {
-  const extPath = resolve5(GODMODE_EXTENSIONS_DIR, `${name}.json`);
-  if (!existsSync4(extPath)) return null;
-  try {
-    return JSON.parse(readFileSync5(extPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function declaredInterfaces(m) {
-  return Object.keys(m.interfaces);
-}
-function showExtHelp() {
-  console.log(`Install, inspect, and manage godmode extensions.
-
-Usage: godmode ext <command> [args]
-
-Commands:
-  install <name|folder>    Install an extension
-  uninstall <name>         Uninstall an extension
-  update <name>            Re-fetch spec, rebuild routes
-  list                     Show installed extensions
-  create                   Interactive manifest wizard`);
-}
-async function runExt(rest) {
-  const cmd = rest[0];
-  if (!cmd || cmd === "--help" || cmd === "-h") {
-    showExtHelp();
-    return;
-  }
-  if (cmd === "install") {
-    const target = rest[1];
-    if (!target) {
-      console.error("Usage: godmode ext install <name|folder>");
-      process.exit(1);
-    }
-    if (RESERVED_SLUGS.has(target)) {
-      process.stderr.write(`'${target}' is a reserved extension slug and cannot be installed.
-`);
-      process.stderr.write(`Reserved: ${[...RESERVED_SLUGS].join(", ")}.
-`);
-      process.exit(1);
-    }
-    const { runAdd } = await import("./add-AJERMPEA.js");
-    await runAdd(rest.slice(1));
-    return;
-  }
-  if (cmd === "uninstall") {
-    if (!rest[1]) {
-      console.error("Usage: godmode ext uninstall <name>");
-      process.exit(1);
-    }
-    await removeApi(rest[1]);
-    return;
-  }
-  if (cmd === "update") {
-    if (!rest[1]) {
-      console.error("Usage: godmode ext update <name>");
-      process.exit(1);
-    }
-    await updateApi(rest[1]);
-    return;
-  }
-  if (cmd === "list") {
-    await listApis();
-    return;
-  }
-  if (cmd === "create") {
-    const { configWizard } = await import("./prompt-SWOWWAOH.js");
-    await configWizard();
-    return;
-  }
-  if (installedExtension(cmd)) {
-    const multi = installedExtension(cmd);
-    const ifaces = declaredInterfaces(multi);
-    process.stderr.write(`'${cmd}' is an installed extension, not an ext command.
-
-`);
-    process.stderr.write(`Did you mean:
-`);
-    process.stderr.write(`  godmode ${cmd} --help
-`);
-    for (const i of ifaces) {
-      process.stderr.write(`  godmode ${cmd} ${i} --help
-`);
-    }
-    process.stderr.write(`
-Try 'godmode ext --help' for more information.
-`);
-    process.exit(1);
-  }
-  process.stderr.write(`Unknown ext command '${cmd}'.
-`);
-  process.stderr.write(`Try 'godmode ext --help' for more information.
-`);
-  process.exit(1);
-}
-async function runAgent(rest) {
-  const code = await runAgentCommand(rest);
-  if (code !== 0) process.exit(code);
-}
 async function runInterface(iface, extensionName, rest) {
   if (iface === "skill") {
     process.stderr.write(`Skill interface not yet implemented.
 `);
-    process.exit(1);
+    process.exit(EXIT_CODES.usage);
   }
   if (rest.includes("--version") || rest.includes("-v")) {
     const multi2 = await loadMultiManifest(extensionName);
     showExtensionVersion(multi2);
     return;
   }
-  const parsed = parseArgs(rest);
   const ifaceKey = iface;
+  const parsed = parseArgs(rest);
   const multi = await loadMultiManifest(extensionName);
   const manifest = await loadManifest(extensionName, ifaceKey);
-  const implicitMethodFilter = parsed.methodFilter || (parsed.explicitMethod ? parsed.method : void 0);
+  const handler = getInterface({
+    iface: ifaceKey,
+    extensionName,
+    manifest,
+    multi,
+    parsed,
+    rawRest: rest
+  });
   if (parsed.help) {
-    showApiHelp(manifest, extensionName, parsed.segments, parsed.filter, implicitMethodFilter, parsed.all, multi);
-    return;
-  }
-  if (iface === "mcp" && !parsed.segments.length) {
-    await runMcp(
-      { godmodeHome: GODMODE_HOME, loadManifest: (n) => loadManifest(n, "mcp") },
-      [extensionName, ...rest]
-    );
+    handler.showHelp();
     return;
   }
   if (!parsed.segments.length) {
-    showApiHelp(manifest, extensionName, parsed.segments, parsed.filter, implicitMethodFilter, parsed.all, multi);
+    await handler.handleEmpty();
     return;
   }
-  if (iface === "api" && !parsed.explicitMethod) {
-    process.stderr.write(`Missing HTTP method. Try: godmode ${extensionName} api GET ${parsed.segments.join(" ")}
-`);
-    process.stderr.write(`Valid methods: GET, POST, PUT, PATCH, DELETE, HEAD.
-`);
-    process.exit(1);
+  const err = handler.validate();
+  if (err) {
+    process.stderr.write(err + "\n");
+    process.exit(EXIT_CODES.usage);
   }
-  if (iface === "graphql") {
-    const err = validateGraphQLFlags(parsed.method, parsed.query, parsed.body, extensionName);
-    if (err) {
-      process.stderr.write(err + "\n");
-      process.exit(1);
-    }
-  }
-  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");
-    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,
-      verbose: parsed.verbose,
-      dryRun: parsed.dryRun
-    });
-    return;
-  }
-  const match = matchRoute(manifest, parsed.segments, parsed.method);
-  if (!match) {
-    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 rest2 = parsed.segments.filter((s) => s.toUpperCase() !== trailingVerb);
-      process.stderr.write(`No route matching: ${parsed.segments.join(" ")}
-`);
-      process.stderr.write(`Method goes first: try 'godmode ${extensionName} ${iface} ${trailingVerb} ${rest2.join(" ")}'
-`);
-      process.exit(1);
-    }
-    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) {
-        process.stderr.write(`  try: godmode ${extensionName} api ${m.toUpperCase()} ${parsed.segments.join(" ")}
-`);
-      }
-    }
-    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);
-  }
-  await execute(manifest, match, {
-    headers: parsed.headers,
-    query,
-    body,
-    token: parsed.token,
-    verbose: parsed.verbose,
-    dryRun: parsed.dryRun
-  });
+  await handler.execute();
 }
 main().catch((err) => {
   process.stderr.write(`${err.message || err}