godmode 0.0.1 → 0.0.3

package/dist/permissions-E4G66OUZ.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import {
+  explainPermission,
+  matchRoute,
+  resourceFromRawPath,
+  resourceFromSegments,
+  suggestedAllowRule
+} from "./chunk-4EU5JX6C.js";
+import {
+  EXIT_CODES
+} from "./chunk-XFFBFBN6.js";
+import {
+  warnSettingsErrors
+} from "./chunk-SMQBMG24.js";
+import {
+  loadManifest
+} from "./chunk-KHFZI7IA.js";
+import "./chunk-3AQ2CZKC.js";
+import "./chunk-YDXTIN53.js";
+
+// src/commands/permissions.ts
+function showPermissionsHelp() {
+  console.log(`Inspect godmode permission policy.
+
+Usage:
+  godmode permissions list
+  godmode permissions explain <extension> <interface> <target> [method]
+
+Exit codes:
+  0   success / allowed
+  2   usage or parse error
+  3   extension or route not found
+  4   permission denied
+  10  upstream HTTP 4xx
+  11  upstream HTTP 5xx
+  12  upstream failure`);
+}
+async function runPermissions(rest) {
+  const cmd = rest[0];
+  if (!cmd || cmd === "--help" || cmd === "-h") {
+    warnSettingsErrors();
+    showPermissionsHelp();
+    return;
+  }
+  if (cmd === "list") {
+    const { loadSettingsDetailed } = await import("./settings-3FF5WWEY.js");
+    const loaded = loadSettingsDetailed();
+    for (const error of loaded.errors) {
+      process.stderr.write(`Warning: cannot parse ${error.path}: ${error.message}
+`);
+    }
+    const sources = loaded.sources.flatMap((source) => {
+      const extensions = source.settings.extensions ?? {};
+      return Object.entries(extensions).flatMap(([slug, settings]) => {
+        const permissions = settings.permissions;
+        if (!permissions?.allow?.length && !permissions?.deny?.length) return [];
+        return [{ slug, permissions, origin: `${source.scope}:${source.path}` }];
+      });
+    });
+    if (!sources.length) {
+      console.log("No permissions configured.");
+      return;
+    }
+    for (const { slug, permissions, origin } of sources) {
+      console.log(`${slug}:`);
+      for (const effect of ["allow", "deny"]) {
+        for (const rule of permissions[effect] ?? []) {
+          const resources = rule.resources?.join(", ") || "*";
+          const methods = rule.methods?.join(", ") || "*";
+          console.log(`  ${effect} resources=[${resources}] methods=[${methods}] origin=${origin}`);
+        }
+      }
+    }
+    return;
+  }
+  if (cmd === "explain") {
+    const [extension, iface, target, maybeMethod] = rest.slice(1);
+    if (!extension || !iface || !target) {
+      process.stderr.write("Usage: godmode permissions explain <extension> <interface> <target> [method]\n");
+      process.exit(EXIT_CODES.usage);
+    }
+    const method = iface === "mcp" ? "mcp" : maybeMethod || "GET";
+    const resource = await explainResource(extension, iface, target, method);
+    const decision = explainPermission({ extension, resource, method });
+    console.log(`${decision.allowed ? "allow" : "deny"} ${extension} ${iface} ${target} ${method.toUpperCase()}`);
+    if (decision.reason) console.log(decision.reason);
+    if (decision.rule) {
+      console.log(`winning rule: resources=[${decision.rule.resources?.join(", ") || "*"}] methods=[${decision.rule.methods?.join(", ") || "*"}] origin=${decision.origin || "settings.yaml"}`);
+    }
+    if (!decision.allowed) {
+      console.log(`suggested allow rule:
+${suggestedAllowRule({ extension, resource, method })}`);
+      process.exit(EXIT_CODES.permissionDenied);
+    }
+    return;
+  }
+  process.stderr.write(`Unknown permissions command '${cmd}'.
+`);
+  process.stderr.write(`Try 'godmode permissions --help' for more information.
+`);
+  process.exit(EXIT_CODES.usage);
+}
+async function explainResource(extension, iface, target, method) {
+  if (iface === "mcp") return target;
+  if (iface === "api" || iface === "graphql") {
+    try {
+      const manifest = await loadManifest(extension, iface);
+      const normalizedMethod = method.toLowerCase();
+      if (target.startsWith("/")) {
+        const exact = manifest.routes.find((route) => route.method === normalizedMethod && route.path === target);
+        if (exact) return resourceFromSegments(exact.segments);
+      }
+      const segments = target.replace(/^\/+/, "").split(/[/.]/).filter(Boolean);
+      const match = matchRoute(manifest, segments, normalizedMethod);
+      if (match) return resourceFromSegments(match.route.segments);
+      return resourceFromRawPath(target);
+    } catch {
+      return target.replace(/^\/+/, "").replace(/\//g, ".").replace(/^v\d+\./i, "") || "*";
+    }
+  }
+  return target.replace(/^\/+/, "").replace(/\//g, ".").replace(/^v\d+\./i, "") || "*";
+}
+export {
+  runPermissions
+};

package/dist/{prompt-DCFFOQ7K.js → prompt-YPAZ5433.js}

@@ -2,7 +2,7 @@
 
 // src/prompt.ts
 import prompts from "prompts";
-import { writeFileSync } from "fs";
+import { mkdirSync, writeFileSync } from "fs";
 import { resolve } from "path";
 import { stringify } from "yaml";
 async function configWizard() {
@@ -60,11 +60,15 @@ async function configWizard() {
   } });
   const config = {
     name: response.name.charAt(0).toUpperCase() + response.name.slice(1),
-    type: "api",
-    spec: response.spec
+    slug: response.name.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
+    interfaces: {
+      api: {
+        spec: response.spec
+      }
+    }
   };
   if (response.description) config.description = response.description;
-  if (response.url) config.url = response.url;
+  if (response.url) config.interfaces.api.url = response.url;
   if (response.envVar) {
     config.auth = { env: response.envVar };
     if (response.authType && response.authType !== "bearer") {
@@ -72,7 +76,8 @@ async function configWizard() {
     }
   }
   const yaml = stringify(config);
-  const filename = `${response.name.toLowerCase().replace(/[^a-z0-9]/g, "-")}.yaml`;
+  const dirname = response.name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const filename = `${dirname}/manifest.yaml`;
   console.log(`
 \x1B[2m${yaml}\x1B[0m`);
   const { write } = await prompts({
@@ -86,10 +91,11 @@ async function configWizard() {
     return;
   }
   const filepath = resolve(process.cwd(), filename);
+  mkdirSync(resolve(process.cwd(), dirname), { recursive: true });
   writeFileSync(filepath, yaml);
   console.log(`
 Saved ${filepath}`);
-  console.log(`Run \x1B[1mgodmode add ${response.name.toLowerCase()}\x1B[0m to register it.`);
+  console.log(`Run \x1B[1mgodmode ext install ./${dirname}\x1B[0m to register it.`);
 }
 export {
   configWizard

package/dist/{mcp-server.js → server-L3L4TKK3.js}

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
   executeToString
-} from "./chunk-I4WS4MMI.js";
+} from "./chunk-AWGLXW3B.js";
 import {
   executeMcpTool
-} from "./chunk-EHS56XXY.js";
+} from "./chunk-3AQ2CZKC.js";
+import "./chunk-YDXTIN53.js";
 
-// src/mcp-server.ts
+// ../../interfaces/mcp/src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
@@ -98,6 +99,15 @@ async function serveMcp(manifest, options = {}) {
     }
     try {
       let result;
+      const extension = manifest.config.slug || manifest.name;
+      const resource = type === "mcp" ? resourceFromTool(toolName) : resourceFromSegments(tool.route.segments);
+      const method = type === "mcp" ? "mcp" : tool.route.method;
+      if (options.checkPermission) {
+        const check = options.checkPermission({ extension, resource, method });
+        if (!check.allowed) {
+          return { content: [{ type: "text", text: `Blocked: ${check.reason}` }], isError: true };
+        }
+      }
       if (type === "mcp") {
         result = await executeMcpTool(manifest.config, toolName, args, {});
       } else if (type === "graphql") {
@@ -124,6 +134,13 @@ async function serveMcp(manifest, options = {}) {
   });
   await server.connect(new StdioServerTransport());
 }
+function resourceFromSegments(segments) {
+  const parts = segments.filter((s) => !s.isParam).map((s) => s.value).filter((v) => !/^v\d+$/i.test(v));
+  return parts.join(".") || "*";
+}
+function resourceFromTool(toolName) {
+  return toolName;
+}
 export {
   serveMcp
 };

package/dist/settings-3FF5WWEY.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  extensionSettings,
+  loadSettings,
+  loadSettingsDetailed,
+  resetSettingsCache,
+  settingsErrorMessage,
+  warnSettingsErrors
+} from "./chunk-SMQBMG24.js";
+export {
+  extensionSettings,
+  loadSettings,
+  loadSettingsDetailed,
+  resetSettingsCache,
+  settingsErrorMessage,
+  warnSettingsErrors
+};

package/package.json

@@ -1,15 +1,33 @@
 {
   "name": "godmode",
-  "version": "0.0.1",
-  "description": "better than mcp",
+  "version": "0.0.3",
+  "description": "any API as CLI. any API as MCP. zero code generation.",
   "type": "module",
   "license": "MIT",
   "author": "Tomas Sivicki",
+  "homepage": "https://godmode.so",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tomsiwik/godmode",
+    "directory": "packages/cli"
+  },
+  "bugs": "https://github.com/tomsiwik/godmode/issues",
+  "keywords": [
+    "cli",
+    "api",
+    "mcp",
+    "openapi",
+    "graphql",
+    "claude-code"
+  ],
   "bin": {
     "godmode": "./dist/index.js"
   },
   "exports": {
-    "./test/adapter": "./test/adapter.ts"
+    "./spec": "./src/spec.ts",
+    "./config": "./src/config.ts",
+    "./permissions": "./src/permissions.ts",
+    "./help": "./src/help.ts"
   },
   "files": [
     "dist",
@@ -17,19 +35,23 @@
     "README.md"
   ],
   "dependencies": {
-    "@hey-api/openapi-ts": "^0.94.0",
-    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@hey-api/openapi-ts": "^0.97.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "fuzzysort": "^3.1.0",
     "prompts": "^2.4.2",
-    "yaml": "^2.8.0"
+    "yaml": "^2.8.4",
+    "@godmode-cli/cli": "0.0.1",
+    "@godmode-cli/command-agent": "0.0.1",
+    "@godmode-cli/interface-api": "0.0.1",
+    "@godmode-cli/interface-graphql": "0.0.1",
+    "@godmode-cli/interface-mcp": "0.0.1"
   },
   "devDependencies": {
-    "@changesets/cli": "^2.30.0",
-    "@types/node": "^22.0.0",
+    "@types/node": "^25.6.0",
     "@types/prompts": "^2.4.9",
-    "tsup": "^8.0.0",
-    "typescript": "^5.5.0",
-    "vitest": "^4.1.0"
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "engines": {
     "node": ">=20.0.0"
@@ -38,9 +60,6 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "start": "node dist/index.js",
-    "test": "vitest run",
-    "changeset": "changeset",
-    "version": "changeset version",
-    "release": "pnpm build && changeset publish"
+    "test": "vitest run"
   }
 }

package/dist/chunk-FBMQ3AC4.js

@@ -1,339 +0,0 @@
-#!/usr/bin/env node
-import {
-  parseMcp
-} from "./chunk-EHS56XXY.js";
-
-// src/protocols/graphql.ts
-var INTROSPECTION_QUERY = `{
-  __schema {
-    queryType { name }
-    mutationType { name }
-    subscriptionType { name }
-    types {
-      name kind description
-      fields { name description args { name type { name kind ofType { name kind } } } }
-    }
-  }
-}`;
-async function introspect(url, headers) {
-  const res = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...headers },
-    body: JSON.stringify({ query: INTROSPECTION_QUERY })
-  });
-  if (!res.ok) throw new Error(`Introspection failed: ${res.status} ${res.statusText}`);
-  const json = await res.json();
-  return json.data?.__schema?.types?.filter((t) => !t.name.startsWith("__")) || [];
-}
-function parseSdl(text) {
-  const types = [];
-  const typeRegex = /type\s+(\w+)\s*\{([^}]*)}/g;
-  let match;
-  while ((match = typeRegex.exec(text)) !== null) {
-    const [, typeName, body] = match;
-    const fields = [];
-    const fieldRegex = /(\w+)(?:\(([^)]*)\))?\s*:\s*\S+/g;
-    let fm;
-    while ((fm = fieldRegex.exec(body)) !== null) {
-      const args = [];
-      if (fm[2]) {
-        const argRegex = /(\w+)\s*:\s*(\w+)/g;
-        let am;
-        while ((am = argRegex.exec(fm[2])) !== null) {
-          args.push({ name: am[1], type: { name: am[2], kind: "SCALAR" } });
-        }
-      }
-      fields.push({ name: fm[1], args: args.length ? args : void 0 });
-    }
-    types.push({ name: typeName, kind: "OBJECT", fields });
-  }
-  return types;
-}
-async function parseGraphQL(name, config) {
-  let types;
-  if (config.spec) {
-    process.stderr.write(`Fetching ${config.spec}...
-`);
-    const res = await fetch(config.spec);
-    if (!res.ok) throw new Error(`Failed to fetch spec: ${res.status}`);
-    types = parseSdl(await res.text());
-  } else {
-    if (!config.url) throw new Error('GraphQL config needs either "spec" or "url"');
-    process.stderr.write(`Introspecting ${config.url}...
-`);
-    const headers = { ...config.headers };
-    const token = config.auth?.env ? process.env[config.auth.env] : void 0;
-    if (token) {
-      const authType = config.auth?.type || "bearer";
-      if (authType === "bearer") headers["Authorization"] = `Bearer ${token}`;
-      else if (authType === "api-key") headers[config.auth?.header || "X-API-Key"] = token;
-    }
-    types = await introspect(config.url, headers);
-  }
-  const routes = [];
-  for (const type of types) {
-    if (!type.fields) continue;
-    const isQuery = type.name === "Query" || type.name === "RootQuery";
-    const isMutation = type.name === "Mutation" || type.name === "RootMutation";
-    if (!isQuery && !isMutation) continue;
-    const method = isMutation ? "post" : "get";
-    for (const field of type.fields) {
-      routes.push({
-        path: field.name,
-        method,
-        summary: field.description || "",
-        version: "",
-        segments: [{ value: field.name, isParam: false }]
-      });
-    }
-  }
-  routes.sort((a, b) => a.path.localeCompare(b.path));
-  process.stderr.write(`Parsed ${routes.length} fields (${types.length} types)
-`);
-  return { name, description: config.description || "", specVersion: "", config, versions: [], resourceDescriptions: {}, routes };
-}
-function validateGraphQLFlags(method, query, body, apiName) {
-  if (["put", "patch", "delete", "head"].includes(method)) {
-    return `GraphQL only supports POST. ${method.toUpperCase()} is not valid.`;
-  }
-  if (method === "post") {
-    process.stderr.write(`Note: POST is implicit for GraphQL, flag not needed.
-`);
-  }
-  if (Object.keys(query).length || Object.keys(body).length) {
-    return `GraphQL uses document syntax, not key=value params.
-  godmode ${apiName} '{ field { subfield } }'`;
-  }
-  return null;
-}
-
-// src/config.ts
-import { resolve, basename } from "path";
-import { homedir } from "os";
-import { mkdir, readFile, writeFile, readdir, unlink, access } from "fs/promises";
-import { execSync } from "child_process";
-import { parse as parseYaml2 } from "yaml";
-
-// src/protocols/api.ts
-import { parse as parseYaml } from "yaml";
-async function parseOpenApi(name, config) {
-  process.stderr.write(`Fetching ${config.spec}...
-`);
-  const res = await fetch(config.spec);
-  if (!res.ok) throw new Error(`Failed to fetch spec: ${res.status} ${res.statusText}`);
-  const text = await res.text();
-  const isJson = text.trimStart().startsWith("{");
-  const spec = isJson ? JSON.parse(text) : parseYaml(text);
-  if (!spec.paths) throw new Error("No paths found - is this a valid OpenAPI document?");
-  if (!config.url) {
-    if (spec.servers?.[0]?.url) {
-      config.url = spec.servers[0].url;
-    } else if (spec.host) {
-      const scheme = spec.schemes?.[0] || "https";
-      config.url = `${scheme}://${spec.host}${spec.basePath || ""}`;
-    }
-  }
-  const versions = resolveVersions(config, Object.keys(spec.paths));
-  const httpMethods = ["get", "post", "put", "patch", "delete", "head"];
-  const routes = [];
-  for (const [path, pathItem] of Object.entries(spec.paths)) {
-    for (const method of httpMethods) {
-      const op = pathItem[method];
-      if (!op) continue;
-      const ver = versions.find((v) => path.startsWith(v.prefix));
-      const version = ver?.name || "";
-      const stripped = ver ? path.slice(ver.prefix.length).replace(/^\//, "") : path.slice(1);
-      const rawSegments = stripped.split("/").filter(Boolean);
-      const segments = rawSegments.map((s) => {
-        const isParam = s.startsWith("{") && s.endsWith("}");
-        return { value: isParam ? s.slice(1, -1) : s, isParam };
-      });
-      const tag = op.tags?.[0] || "";
-      routes.push({ path, method, summary: op.summary || "", version, tag, segments });
-    }
-  }
-  routes.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
-  const resourceDescriptions = {};
-  if (spec.tags) {
-    const stripHtml = (s) => s.replace(/<[^>]+>/g, "").trim();
-    for (const t of spec.tags) {
-      if (t.name && t.description) {
-        const first = stripHtml(t.description).split(/\.\s/)[0];
-        resourceDescriptions[t.name] = first.endsWith(".") ? first : first + ".";
-      }
-    }
-  }
-  const description = config.description || spec.info?.description || "";
-  const specVersion = spec.info?.version || "";
-  const versionNames = versions.map((v) => v.name).join(", ");
-  process.stderr.write(`Parsed ${routes.length} routes (versions: ${versionNames || "none"})
-`);
-  return { name, description, specVersion, config, versions, resourceDescriptions, routes };
-}
-function resolveVersions(config, paths) {
-  if (config.versions?.length) {
-    return config.versions.map((v) => ({
-      prefix: v.prefix.endsWith("/") ? v.prefix.slice(0, -1) : v.prefix,
-      name: v.name || v.prefix.replace(/^\//, "")
-    }));
-  }
-  if (config.prefix) {
-    const prefix = config.prefix.endsWith("/") ? config.prefix.slice(0, -1) : config.prefix;
-    return [{ prefix, name: prefix.replace(/^\//, "") }];
-  }
-  const versionPattern = /^(\/(?:api\/)?v\d+)/;
-  const detected = /* @__PURE__ */ new Map();
-  for (const p of paths) {
-    const match = p.match(versionPattern);
-    if (match) detected.set(match[1], (detected.get(match[1]) || 0) + 1);
-  }
-  if (detected.size) {
-    return [...detected.entries()].sort((a, b) => b[1] - a[1]).map(([prefix]) => ({ prefix, name: prefix.replace(/^\//, "") }));
-  }
-  return [{ prefix: "", name: "" }];
-}
-
-// src/spec.ts
-var parsers = {
-  api: parseOpenApi,
-  graphql: parseGraphQL,
-  mcp: parseMcp
-};
-async function parseSpec(name, config) {
-  const parser = parsers[config.type];
-  if (!parser) throw new Error(`Unknown type "${config.type}" - supported: ${Object.keys(parsers).join(", ")}`);
-  return parser(name, config);
-}
-
-// src/config.ts
-var GODMODE_HOME = process.platform === "linux" && process.env.XDG_CONFIG_HOME ? resolve(process.env.XDG_CONFIG_HOME, "godmode") : resolve(homedir(), ".godmode");
-var APIS_DIR = resolve(GODMODE_HOME, "apis");
-async function ensureDirs() {
-  await mkdir(APIS_DIR, { recursive: true });
-}
-async function exists(path) {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function loadManifestFromDir(dir) {
-  for (const ext of [".yaml", ".yml", ".json"]) {
-    const filePath = resolve(dir, `manifest${ext}`);
-    if (await exists(filePath)) {
-      const text = await readFile(filePath, "utf-8");
-      const config = ext === ".json" ? JSON.parse(text) : parseYaml2(text);
-      return { config, ext };
-    }
-  }
-  return null;
-}
-async function resolveConfig(input) {
-  const asPath = resolve(process.cwd(), input);
-  const fromPath = await loadManifestFromDir(asPath);
-  if (fromPath) return { name: fromPath.config.slug || basename(asPath), config: fromPath.config, dir: asPath };
-  try {
-    const pkgDir = resolve(import.meta.dirname, "..", "..", "..", "adapters", input);
-    const fromPkg = await loadManifestFromDir(pkgDir);
-    if (fromPkg) return { name: fromPkg.config.slug || input, config: fromPkg.config, dir: pkgDir };
-  } catch {
-  }
-  throw new Error(`No config found: ${input}/manifest.yaml or @godmode-cli/${input}`);
-}
-async function addApi(input) {
-  await ensureDirs();
-  const resolved = await resolveConfig(input).catch(() => null);
-  if (resolved) {
-    const { name: name2, config } = resolved;
-    const type = config.type;
-    if (type && ["api", "graphql", "mcp"].includes(type)) {
-      if (type === "api" && !config.spec) throw new Error('Config missing "spec" (OpenAPI spec URL or path)');
-      if (type === "graphql" && !config.spec && !config.url) throw new Error('GraphQL config needs "spec" (SDL) or "url" (for introspection)');
-      if (type === "mcp" && !config.url) throw new Error('MCP config needs "url" (MCP endpoint)');
-      if (!config.url && type === "api") process.stderr.write('Warning: no "url" in config - will try to detect from spec\n');
-      const manifest = await parseSpec(name2, config);
-      await writeFile(resolve(APIS_DIR, `${name2}.json`), JSON.stringify(manifest, null, 2));
-      const urlNote = manifest.config.url ? ` at ${manifest.config.url}` : "";
-      process.stderr.write(`Registered "${name2}" - ${manifest.routes.length} routes${urlNote}
-`);
-      return;
-    }
-  }
-  const name = resolved?.name || input;
-  const installTarget = resolved?.dir && await exists(resolve(resolved.dir, "package.json")) ? resolved.dir : input.startsWith("@") ? input : `@godmode-cli/${input}`;
-  process.stderr.write(`Installing ${name}...
-`);
-  try {
-    execSync(`npm install ${installTarget} --prefix ${GODMODE_HOME}`, { stdio: "pipe" });
-  } catch (e) {
-    throw new Error(`Failed to install ${name}: ${e.stderr?.toString().trim() || e.message}`);
-  }
-  const pkgName = `@godmode-cli/${name}`;
-  const mcpConfigPath = resolve(GODMODE_HOME, "node_modules", pkgName, ".mcp.json");
-  if (await exists(mcpConfigPath)) {
-    process.stderr.write(`Installed "${name}" (MCP server adapter)
-`);
-  } else {
-    process.stderr.write(`Installed "${name}"
-`);
-  }
-}
-async function updateApi(name) {
-  await ensureDirs();
-  const manifest = await loadManifestFromDir(name);
-  process.stderr.write(`Updating "${name}"...
-`);
-  const updated = await parseSpec(name, manifest.config);
-  await writeFile(resolve(APIS_DIR, `${name}.json`), JSON.stringify(updated, null, 2));
-  process.stderr.write(`Updated "${name}" - ${updated.routes.length} routes
-`);
-}
-async function removeApi(name) {
-  try {
-    await unlink(resolve(APIS_DIR, `${name}.json`));
-    process.stderr.write(`Removed "${name}"
-`);
-  } catch {
-    process.stderr.write(`API "${name}" not found
-`);
-    process.exit(1);
-  }
-}
-async function listApis() {
-  await ensureDirs();
-  const files = await readdir(APIS_DIR);
-  const apis = files.filter((f) => f.endsWith(".json"));
-  if (!apis.length) {
-    console.log("No APIs registered. Create a <name>.yaml config and run: godmode add <name>");
-    return;
-  }
-  for (const file of apis) {
-    const m = JSON.parse(await readFile(resolve(APIS_DIR, file), "utf-8"));
-    const ver = m.specVersion ? ` v${m.specVersion}` : "";
-    const desc = m.description ? `  ${m.description}` : "";
-    const url = m.config.url || "(local)";
-    console.log(`  ${m.name}${ver}	${url}	${m.routes.length} routes${desc}`);
-  }
-}
-async function loadManifest(name) {
-  await ensureDirs();
-  try {
-    return JSON.parse(await readFile(resolve(APIS_DIR, `${name}.json`), "utf-8"));
-  } catch {
-    process.stderr.write(`API "${name}" not found. Create ${name}.yaml and run: godmode add ${name}
-`);
-    process.exit(1);
-  }
-}
-
-export {
-  validateGraphQLFlags,
-  GODMODE_HOME,
-  addApi,
-  updateApi,
-  removeApi,
-  listApis,
-  loadManifest
-};