godmode 0.0.1 → 0.0.3

package/dist/chunk-KHFZI7IA.js

@@ -0,0 +1,745 @@
+#!/usr/bin/env node
+import {
+  parseMcp
+} from "./chunk-3AQ2CZKC.js";
+import {
+  AuthStrategy
+} from "./chunk-YDXTIN53.js";
+
+// src/builtins.ts
+var BUILTINS = /* @__PURE__ */ new Map([
+  ["ext", {
+    description: "Install and manage godmode extensions",
+    run: async (rest) => (await import("./ext-K4XEAZGS.js")).runExt(rest)
+  }],
+  ["agent", {
+    description: "Coding-agent workflows",
+    run: async (rest) => {
+      const { runAgentCommand } = await import("./dist-I5CEQ4AC.js");
+      const code = await runAgentCommand(rest);
+      if (code !== 0) process.exit(code);
+    }
+  }],
+  ["permissions", {
+    description: "Inspect godmode permission policy",
+    run: async (rest) => (await import("./permissions-E4G66OUZ.js")).runPermissions(rest)
+  }]
+]);
+
+// src/config.ts
+import { resolve as resolve2, basename, dirname, extname, isAbsolute as isAbsolute2, parse as parsePath, relative } from "path";
+import { homedir } from "os";
+import { existsSync, readFileSync } from "fs";
+import { mkdir, readFile as readFile2, writeFile, readdir, unlink, access, rename, rm } from "fs/promises";
+import { execFileSync } from "child_process";
+import { parse as parseYaml2 } from "yaml";
+
+// ../../interfaces/api/src/index.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: "" }];
+}
+
+// ../../interfaces/graphql/src/index.ts
+import { readFile } from "fs/promises";
+import { isAbsolute, resolve } from "path";
+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) {
+    const isRemote = /^https?:\/\//.test(config.spec);
+    if (isRemote) {
+      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 {
+      const specPath = isAbsolute(config.spec) ? config.spec : resolve(process.cwd(), config.spec);
+      process.stderr.write(`Loading ${specPath}...
+`);
+      types = parseSdl(await readFile(specPath, "utf-8"));
+    }
+  } 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) {
+      AuthStrategy.for(config.auth).apply(headers, 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/spec.ts
+function projectManifest(multi, iface) {
+  const data = multi.interfaces[iface];
+  if (!data) {
+    throw new Error(
+      `extension '${multi.slug}' does not declare an '${iface}' interface (declared: ${Object.keys(multi.interfaces).join(", ")})`
+    );
+  }
+  const config = {
+    slug: multi.slug,
+    name: multi.name,
+    description: multi.description,
+    type: iface,
+    auth: multi.auth,
+    headers: multi.headers,
+    ..."spec" in data ? { spec: data.spec } : {},
+    ..."url" in data && data.url ? { url: data.url } : {},
+    ..."prefix" in data && data.prefix ? { prefix: data.prefix } : {},
+    versions: data.versions,
+    ...iface === "mcp" && data._mcpTools ? { _mcpTools: data._mcpTools } : {}
+  };
+  return {
+    name: multi.name,
+    description: multi.description,
+    specVersion: data.specVersion,
+    config,
+    versions: data.versions,
+    resourceDescriptions: data.resourceDescriptions,
+    routes: data.routes
+  };
+}
+var parsers = {
+  api: parseOpenApi,
+  graphql: parseGraphQL,
+  mcp: parseMcp
+};
+async function compileInterface(iface, name, source) {
+  const parser = parsers[iface];
+  if (!parser) throw new Error(`Unknown interface '${iface}'`);
+  const ifaceSource = source.interfaces[iface];
+  if (!ifaceSource) throw new Error(`Interface '${iface}' not declared on '${name}'`);
+  const legacyConfig = {
+    slug: source.slug || name,
+    name: source.name,
+    description: source.description,
+    type: iface,
+    auth: source.auth,
+    headers: source.headers,
+    ..."spec" in ifaceSource && ifaceSource.spec ? { spec: ifaceSource.spec } : {},
+    ..."url" in ifaceSource && ifaceSource.url ? { url: ifaceSource.url } : {},
+    ..."prefix" in ifaceSource && ifaceSource.prefix ? { prefix: ifaceSource.prefix } : {},
+    versions: ifaceSource.versions
+  };
+  const flat = await parser(name, legacyConfig);
+  const base = {
+    type: iface,
+    specVersion: flat.specVersion,
+    versions: flat.versions,
+    resourceDescriptions: flat.resourceDescriptions,
+    routes: flat.routes
+  };
+  if (iface === "api") {
+    const s2 = ifaceSource;
+    return {
+      ...base,
+      type: "api",
+      spec: s2.spec,
+      url: flat.config.url,
+      prefix: s2.prefix
+    };
+  }
+  if (iface === "graphql") {
+    const s2 = ifaceSource;
+    return {
+      ...base,
+      type: "graphql",
+      spec: s2.spec,
+      url: flat.config.url
+    };
+  }
+  const s = ifaceSource;
+  return {
+    ...base,
+    type: "mcp",
+    url: s.url,
+    _mcpTools: flat.config._mcpTools
+  };
+}
+
+// src/config.ts
+var GODMODE_HOME = resolve2(homedir(), ".godmode");
+var INTERFACE_KEYS = ["api", "graphql", "mcp"];
+function assertSlugFree(slug, scope, packageName) {
+  if (BUILTINS.has(slug)) {
+    throw new Error(`'${slug}' is a built-in godmode extension; its slug is always in use.`);
+  }
+  const dir = scopeExtensionsDirSync(scope);
+  if (!dir) return;
+  const manifestPath = resolve2(dir, `${slug}.json`);
+  if (!existsSync(manifestPath)) return;
+  let existing;
+  try {
+    existing = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return;
+  }
+  if (existing.packageName === packageName) return;
+  throw new Error(
+    `'${slug}' is already in use by ${existing.packageName || "an installed extension"}.
+Run 'godmode ext uninstall ${slug}' first.`
+  );
+}
+function isValidNpmPackageName(packageName) {
+  return /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/.test(packageName);
+}
+function assertContained(parent, child, label) {
+  const root = resolve2(parent);
+  const target = resolve2(child);
+  const rel = relative(root, target);
+  if (rel === "" || !rel.startsWith("..") && !isAbsolute2(rel)) return target;
+  throw new Error(`${label} resolves outside ${root}`);
+}
+function packageInstallDir(scopeRoot, packageName) {
+  if (!isValidNpmPackageName(packageName)) {
+    throw new Error(`Invalid npm package name in installed manifest: ${packageName}`);
+  }
+  return assertContained(
+    resolve2(scopeRoot, "node_modules"),
+    resolve2(scopeRoot, "node_modules", packageName),
+    `Package path for ${packageName}`
+  );
+}
+var GITIGNORE_CONTENT = `# godmode \u2014 runtime artifacts, do not commit
+node_modules/
+coding-agents/
+package-lock.json
+`;
+function findProjectGodmode(start = process.cwd()) {
+  let dir = resolve2(start);
+  const root = parsePath(dir).root;
+  while (true) {
+    const candidate = resolve2(dir, ".godmode");
+    if (existsSync(candidate)) return candidate;
+    if (dir === root) return null;
+    dir = dirname(dir);
+  }
+}
+async function ensureScopeDir(scope) {
+  if (scope === "global") {
+    await mkdir(GODMODE_HOME, { recursive: true });
+    const legacy = resolve2(GODMODE_HOME, "apis");
+    const target2 = resolve2(GODMODE_HOME, "extensions");
+    if (await exists(legacy) && !await exists(target2)) {
+      await rename(legacy, target2);
+      process.stderr.write(`Migrated ${legacy} -> ${target2}
+`);
+    }
+    await mkdir(target2, { recursive: true });
+    return target2;
+  }
+  let projectRoot = findProjectGodmode();
+  if (!projectRoot) {
+    projectRoot = resolve2(process.cwd(), ".godmode");
+    await mkdir(projectRoot, { recursive: true });
+    await writeFile(resolve2(projectRoot, ".gitignore"), GITIGNORE_CONTENT);
+  }
+  const target = resolve2(projectRoot, "extensions");
+  await mkdir(target, { recursive: true });
+  return target;
+}
+function scopeExtensionsDirSync(scope) {
+  if (scope === "global") {
+    const d2 = resolve2(GODMODE_HOME, "extensions");
+    return existsSync(d2) ? d2 : null;
+  }
+  const project = findProjectGodmode();
+  if (!project) return null;
+  const d = resolve2(project, "extensions");
+  return existsSync(d) ? d : null;
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateSource(raw, origin) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`${origin}: not a valid object`);
+  }
+  const m = raw;
+  if (!m.name || typeof m.name !== "string") {
+    throw new Error(`${origin}: missing or invalid 'name'`);
+  }
+  if (!m.interfaces || typeof m.interfaces !== "object" || Object.keys(m.interfaces).length === 0) {
+    throw new Error(`${origin}: 'interfaces' must be an object with at least one key`);
+  }
+  for (const key of Object.keys(m.interfaces)) {
+    if (!INTERFACE_KEYS.includes(key)) {
+      throw new Error(
+        `${origin}: unknown interface '${key}' (valid: ${INTERFACE_KEYS.join(", ")})`
+      );
+    }
+  }
+  return m;
+}
+async function loadSourceFromDir(dir) {
+  for (const ext of [".yaml", ".yml", ".json"]) {
+    const filePath = resolve2(dir, `manifest${ext}`);
+    if (await exists(filePath)) {
+      const text = await readFile2(filePath, "utf-8");
+      const raw = ext === ".json" ? JSON.parse(text) : parseYaml2(text);
+      return absolutizeSource(validateSource(raw, filePath), dir);
+    }
+  }
+  return null;
+}
+async function loadSourceFromFile(filePath) {
+  if (!await exists(filePath)) return null;
+  const ext = extname(filePath);
+  if (![".yaml", ".yml", ".json"].includes(ext)) return null;
+  const text = await readFile2(filePath, "utf-8");
+  const raw = ext === ".json" ? JSON.parse(text) : parseYaml2(text);
+  const dir = dirname(filePath);
+  return { source: absolutizeSource(validateSource(raw, filePath), dir), dir };
+}
+function absolutizeSource(source, dir) {
+  const interfaces = {};
+  if (source.interfaces.api) interfaces.api = { ...source.interfaces.api };
+  if (source.interfaces.graphql) interfaces.graphql = { ...source.interfaces.graphql };
+  if (source.interfaces.mcp) interfaces.mcp = { ...source.interfaces.mcp };
+  const next = {
+    ...source,
+    interfaces
+  };
+  for (const iface of ["api", "graphql"]) {
+    const spec = next.interfaces[iface]?.spec;
+    if (spec && !/^[a-z][a-z0-9+.-]*:/i.test(spec) && !isAbsolute2(spec)) {
+      next.interfaces[iface].spec = resolve2(dir, spec);
+    }
+  }
+  return next;
+}
+async function loadSourceFromPackageDir(pkgDir) {
+  const pkgPath = resolve2(pkgDir, "package.json");
+  if (!await exists(pkgPath)) return null;
+  const pkg = JSON.parse(await readFile2(pkgPath, "utf-8"));
+  const manifestExport = pkg.exports?.["./manifest"];
+  const manifestPath = typeof manifestExport === "string" ? manifestExport : manifestExport?.default;
+  if (!manifestPath) {
+    throw new Error(`${pkgPath}: missing exports["./manifest"]`);
+  }
+  const loaded = await loadSourceFromFile(assertContained(pkgDir, resolve2(pkgDir, manifestPath), "Manifest export"));
+  if (!loaded) {
+    throw new Error(`${pkgPath}: exports["./manifest"] does not point to a readable manifest`);
+  }
+  return loaded.source;
+}
+async function resolveSource(input) {
+  const asPath = resolve2(process.cwd(), input);
+  const fromFile = await loadSourceFromFile(asPath);
+  if (fromFile) {
+    const name = fromFile.source.slug || fromFile.source.name || basename(fromFile.dir);
+    return { name, source: fromFile.source, dir: fromFile.dir };
+  }
+  const fromDir = await loadSourceFromDir(asPath);
+  if (fromDir) {
+    const name = fromDir.slug || fromDir.name || basename(asPath);
+    return { name, source: fromDir, dir: asPath };
+  }
+  try {
+    const pkgDir = resolve2(import.meta.dirname, "..", "..", "..", "extensions", input);
+    const fromPkg = await loadSourceFromDir(pkgDir);
+    if (fromPkg) {
+      const name = fromPkg.slug || fromPkg.name || input;
+      return { name, source: fromPkg, dir: pkgDir };
+    }
+  } catch {
+  }
+  throw new Error(
+    `No manifest found: ${input} (expected manifest file, folder containing manifest.yaml, or @godmode-cli/${input})`
+  );
+}
+async function addApi(input, scope = "project") {
+  const extensionsDir = await ensureScopeDir(scope);
+  const resolved = await resolveSource(input).catch(() => null);
+  if (resolved) {
+    const { name: name2, source } = resolved;
+    assertSlugFree(source.slug || name2, scope);
+    const ifaceKeys = Object.keys(source.interfaces).filter(
+      (k) => INTERFACE_KEYS.includes(k)
+    );
+    if (ifaceKeys.length > 0) {
+      const multi = {
+        name: source.name,
+        slug: source.slug || name2,
+        description: source.description || "",
+        source: "local",
+        auth: source.auth,
+        headers: source.headers,
+        interfaces: {}
+      };
+      for (const iface of ifaceKeys) {
+        const data = await compileInterface(iface, name2, source);
+        multi.interfaces[iface] = data;
+      }
+      await writeFile(resolve2(extensionsDir, `${name2}.json`), JSON.stringify(multi, null, 2));
+      const ifaceSummary = ifaceKeys.map((k) => {
+        const d = multi.interfaces[k];
+        return d ? `${k}=${d.routes.length}` : k;
+      }).join(", ");
+      process.stderr.write(`Registered "${name2}" [${scope}] - interfaces: ${ifaceSummary}
+`);
+      return;
+    }
+  }
+  const scopeRoot = scope === "global" ? GODMODE_HOME : dirname(extensionsDir);
+  const asPath = resolve2(process.cwd(), input);
+  const inputPackageJson = await exists(resolve2(asPath, "package.json")) ? JSON.parse(await readFile2(resolve2(asPath, "package.json"), "utf-8")) : null;
+  const packageName = inputPackageJson?.name || (input.startsWith("@") ? input : `@godmode-cli/${input}`);
+  const name = resolved?.name || (input.startsWith("@") ? basename(input) : input);
+  assertSlugFree(name, scope, packageName);
+  const installTarget = resolved?.dir && await exists(resolve2(resolved.dir, "package.json")) ? resolved.dir : inputPackageJson ? asPath : packageName;
+  process.stderr.write(`Installing ${name} [${scope}]...
+`);
+  try {
+    execFileSync("npm", ["install", installTarget, "--prefix", scopeRoot], { stdio: "pipe" });
+  } catch (e) {
+    const err = e;
+    throw new Error(`Failed to install ${name}: ${err.stderr?.toString().trim() || err.message}`);
+  }
+  const pkgDir = packageInstallDir(scopeRoot, packageName);
+  const packageSource = await loadSourceFromPackageDir(pkgDir).catch((error) => {
+    const mcpConfigPath = resolve2(pkgDir, ".mcp.json");
+    if (existsSync(mcpConfigPath)) return null;
+    throw error;
+  });
+  if (packageSource) {
+    const slug = packageSource.slug || name;
+    if (slug !== name) assertSlugFree(slug, scope, packageName);
+    const ifaceKeys = Object.keys(packageSource.interfaces).filter(
+      (k) => INTERFACE_KEYS.includes(k)
+    );
+    const multi = {
+      name: packageSource.name,
+      slug,
+      description: packageSource.description || "",
+      source: "npm",
+      packageName,
+      auth: packageSource.auth,
+      headers: packageSource.headers,
+      interfaces: {}
+    };
+    for (const iface of ifaceKeys) {
+      const data = await compileInterface(iface, slug, packageSource);
+      multi.interfaces[iface] = data;
+    }
+    await writeFile(resolve2(extensionsDir, `${slug}.json`), JSON.stringify(multi, null, 2));
+    process.stderr.write(`Registered "${slug}" [${scope}] from ${packageName}
+`);
+  } else if (await exists(resolve2(pkgDir, ".mcp.json"))) {
+    process.stderr.write(`Installed "${name}" (MCP server extension)
+`);
+  } else {
+    process.stderr.write(`Installed "${name}"
+`);
+  }
+}
+async function updateApi(name, scope) {
+  const resolvedScope = scope ?? findInstalledScope(name);
+  if (!resolvedScope) {
+    process.stderr.write(`Extension "${name}" not found
+`);
+    process.exit(1);
+  }
+  const existing = findInstalledManifestSync(name);
+  await addApi(existing?.packageName ?? name, resolvedScope);
+}
+async function removeApi(name, scope) {
+  const resolvedScope = scope ?? findInstalledScope(name);
+  if (!resolvedScope) {
+    process.stderr.write(`Extension "${name}" not found
+`);
+    process.exit(1);
+  }
+  const dir = scopeExtensionsDirSync(resolvedScope);
+  if (!dir) {
+    process.stderr.write(`Extension "${name}" not found
+`);
+    process.exit(1);
+  }
+  const manifestPath = resolve2(dir, `${name}.json`);
+  let manifestText;
+  try {
+    manifestText = await readFile2(manifestPath, "utf-8");
+  } catch {
+    process.stderr.write(`Extension "${name}" not found
+`);
+    process.exit(1);
+  }
+  let packageName;
+  try {
+    const multi = JSON.parse(manifestText);
+    packageName = multi.packageName;
+  } catch {
+  }
+  const packageDir = packageName ? packageInstallDir(resolvedScope === "global" ? GODMODE_HOME : dirname(dir), packageName) : null;
+  try {
+    await unlink(manifestPath);
+  } catch {
+    process.stderr.write(`Extension "${name}" not found
+`);
+    process.exit(1);
+  }
+  if (packageDir) await rm(packageDir, { recursive: true, force: true });
+  process.stderr.write(`Removed "${name}" [${resolvedScope}]
+`);
+}
+function findInstalledScope(name) {
+  for (const scope of ["project", "global"]) {
+    const dir = scopeExtensionsDirSync(scope);
+    if (dir && existsSync(resolve2(dir, `${name}.json`))) return scope;
+  }
+  return null;
+}
+async function listApis() {
+  const rows = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const scope of ["project", "global"]) {
+    const dir = scopeExtensionsDirSync(scope);
+    if (!dir) continue;
+    const files = (await readdir(dir)).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      const m = JSON.parse(await readFile2(resolve2(dir, file), "utf-8"));
+      const shadowed = scope === "global" && seen.has(m.slug);
+      seen.add(m.slug);
+      rows.push({
+        scope,
+        source: m.source || "local",
+        slug: m.slug,
+        ifaces: Object.keys(m.interfaces).join(", "),
+        routeTotal: Object.values(m.interfaces).reduce((n, d) => n + (d?.routes.length ?? 0), 0),
+        description: m.description || "",
+        shadowed
+      });
+    }
+  }
+  if (!rows.length) {
+    console.log("No extensions installed. Run: godmode ext install <name>");
+    return;
+  }
+  for (const r of rows) {
+    const tag = `[${r.scope}${r.shadowed ? ", shadowed" : ""}]`;
+    const desc = r.description ? `  ${r.description}` : "";
+    console.log(`  ${r.slug}	${tag}	${r.source}	[${r.ifaces}]	${r.routeTotal} routes${desc}`);
+  }
+}
+async function loadMultiManifest(name) {
+  for (const scope of ["project", "global"]) {
+    const dir = scopeExtensionsDirSync(scope);
+    if (!dir) continue;
+    const path = resolve2(dir, `${name}.json`);
+    if (!existsSync(path)) continue;
+    return JSON.parse(await readFile2(path, "utf-8"));
+  }
+  process.stderr.write(`Extension "${name}" not found. Run: godmode ext install ${name}
+`);
+  process.exit(1);
+}
+async function loadManifest(name, iface) {
+  const multi = await loadMultiManifest(name);
+  const declared = Object.keys(multi.interfaces);
+  if (declared.length === 0) {
+    process.stderr.write(`Extension "${name}" has no interfaces declared
+`);
+    process.exit(1);
+  }
+  const target = iface ?? declared[0];
+  if (!multi.interfaces[target]) {
+    process.stderr.write(
+      `Extension "${name}" does not declare a '${target}' interface (declared: ${declared.join(", ")}).
+`
+    );
+    process.stderr.write(`Try: godmode ${declared[0]} ${name} --help
+`);
+    process.exit(1);
+  }
+  return projectManifest(multi, target);
+}
+function findInstalledManifestSync(name) {
+  for (const scope of ["project", "global"]) {
+    const dir = scopeExtensionsDirSync(scope);
+    if (!dir) continue;
+    const path = resolve2(dir, `${name}.json`);
+    if (!existsSync(path)) continue;
+    try {
+      return JSON.parse(readFileSync(path, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+export {
+  validateGraphQLFlags,
+  BUILTINS,
+  GODMODE_HOME,
+  addApi,
+  updateApi,
+  removeApi,
+  listApis,
+  loadMultiManifest,
+  loadManifest,
+  findInstalledManifestSync
+};