godmode 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tomas Sivicki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/add-ZRNIX6DM.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import {
+  addApi
+} from "./chunk-FBMQ3AC4.js";
+import "./chunk-EHS56XXY.js";
+
+// src/commands/add.ts
+async function runAdd(args) {
+  if (!args[0] || args[0] === "--help" || args[0] === "-h") {
+    console.log(`Add an adapter from a folder, built-in name, or manifest.
+
+Usage:
+  godmode add <name>          Built-in adapter (e.g. stripe, github)
+  godmode add <folder>        Folder containing manifest.yaml
+
+Manifest format (manifest.yaml):
+  slug:    stripe             CLI name (used as "godmode <slug>")
+  name:    Stripe             Display name
+  description: Payments API   Short description
+  type:    api                api | graphql | mcp
+  spec:    <url>              OpenAPI spec URL or local file (api, graphql)
+  url:     <base-url>         API base URL (api, graphql) or MCP endpoint (mcp)
+  auth:
+    env:   STRIPE_API_KEY     Environment variable for auth token
+    type:  bearer             Auth type (bearer, api-key, basic)
+  headers:
+    X-Custom: value           Default headers for every request
+
+Types:
+  api                         OpenAPI spec  (requires spec + url)
+  graphql                     GraphQL       (requires spec or url)
+  mcp                         MCP endpoint  (requires url)
+
+Examples:
+  $ godmode add stripe
+  $ godmode add ./my-adapter
+  $ godmode add openai`);
+    process.exit(args[0] ? 0 : 1);
+  }
+  await addApi(args[0]);
+}
+export {
+  runAdd
+};

package/dist/chunk-EHS56XXY.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+// src/protocols/mcp.ts
+var requestId = 0;
+async function mcpRequest(url, method, params, headers, sessionId) {
+  const body = {
+    jsonrpc: "2.0",
+    id: ++requestId,
+    method,
+    params
+  };
+  const reqHeaders = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+    "MCP-Protocol-Version": "2025-03-26",
+    ...headers
+  };
+  if (sessionId) reqHeaders["Mcp-Session-Id"] = sessionId;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: reqHeaders,
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`MCP request failed: ${res.status} ${text.slice(0, 200)}`);
+  }
+  const newSessionId = res.headers.get("Mcp-Session-Id") || sessionId;
+  const contentType = res.headers.get("content-type") || "";
+  if (contentType.includes("text/event-stream")) {
+    const text = await res.text();
+    const lines = text.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        try {
+          const data = JSON.parse(line.slice(6));
+          if (data.id === body.id) {
+            if (data.error) throw new Error(`MCP error: ${data.error.message}`);
+            return { result: data.result, sessionId: newSessionId };
+          }
+        } catch (e) {
+          if (e.message?.startsWith("MCP error")) throw e;
+        }
+      }
+    }
+    throw new Error("No response found in SSE stream");
+  }
+  const json = await res.json();
+  if (json.error) throw new Error(`MCP error: ${json.error.message}`);
+  return { result: json.result, sessionId: newSessionId };
+}
+function buildAuthHeaders(config) {
+  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;
+  }
+  return headers;
+}
+async function parseMcp(name, config) {
+  if (!config.url) throw new Error('MCP config needs "url" (MCP endpoint)');
+  const headers = buildAuthHeaders(config);
+  process.stderr.write(`Connecting to ${config.url}...
+`);
+  const init = await mcpRequest(config.url, "initialize", {
+    protocolVersion: "2025-03-26",
+    capabilities: {},
+    clientInfo: { name: "godmode", version: "0.0.1" }
+  }, headers);
+  const sessionId = init.sessionId;
+  await fetch(config.url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "MCP-Protocol-Version": "2025-03-26",
+      ...headers,
+      ...sessionId ? { "Mcp-Session-Id": sessionId } : {}
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })
+  });
+  process.stderr.write(`Discovering tools...
+`);
+  const toolsResult = await mcpRequest(config.url, "tools/list", {}, headers, sessionId);
+  const tools = toolsResult.result?.tools || [];
+  const routes = tools.map((tool) => ({
+    path: tool.name,
+    method: "post",
+    // MCP tools are always invocations
+    summary: tool.description || "",
+    version: "",
+    segments: [{ value: tool.name, isParam: false }]
+  }));
+  routes.sort((a, b) => a.path.localeCompare(b.path));
+  process.stderr.write(`Discovered ${routes.length} tools
+`);
+  const resourceDescriptions = {};
+  for (const tool of tools) {
+    if (tool.description) resourceDescriptions[tool.name] = tool.description;
+  }
+  return {
+    name,
+    description: config.description || init.result?.serverInfo?.name || "",
+    specVersion: init.result?.protocolVersion || "",
+    config: { ...config, _mcpTools: tools },
+    versions: [],
+    resourceDescriptions,
+    routes
+  };
+}
+function validateMcpFlags(method, query) {
+  if (["put", "patch", "delete", "head"].includes(method)) {
+    return `MCP tools are invoked via POST. ${method.toUpperCase()} is not valid.`;
+  }
+  if (Object.keys(query).length) {
+    return "MCP tools use key=value params (body), not key==value (query).";
+  }
+  return null;
+}
+async function executeMcpTool(config, toolName, args, options) {
+  const headers = buildAuthHeaders(config);
+  if (options.dryRun || options.verbose) {
+    process.stderr.write(`CALL ${config.url} \u2192 ${toolName}
+`);
+    if (Object.keys(args).length) {
+      process.stderr.write(`  Args: ${JSON.stringify(args)}
+`);
+    }
+    if (options.dryRun) return "";
+  }
+  const init = await mcpRequest(config.url, "initialize", {
+    protocolVersion: "2025-03-26",
+    capabilities: {},
+    clientInfo: { name: "godmode", version: "0.0.1" }
+  }, headers);
+  const sessionId = init.sessionId;
+  await fetch(config.url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "MCP-Protocol-Version": "2025-03-26",
+      ...headers,
+      ...sessionId ? { "Mcp-Session-Id": sessionId } : {}
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })
+  });
+  const result = await mcpRequest(config.url, "tools/call", {
+    name: toolName,
+    arguments: args
+  }, headers, sessionId);
+  const content = result.result?.content;
+  if (Array.isArray(content)) {
+    return content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+  }
+  return JSON.stringify(result.result, null, 2);
+}
+
+export {
+  parseMcp,
+  validateMcpFlags,
+  executeMcpTool
+};

package/dist/chunk-FBMQ3AC4.js

@@ -0,0 +1,339 @@
+#!/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
+};

package/dist/chunk-I4WS4MMI.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// src/request.ts
+async function executeToString(manifest, match, options) {
+  const baseUrl = manifest.config.url;
+  if (!baseUrl) {
+    throw new Error('No base URL configured. Add "url" to your config file.');
+  }
+  let path = match.route.path;
+  for (const [key, value] of Object.entries(match.params)) {
+    path = path.replace(`{${key}}`, encodeURIComponent(value));
+  }
+  const url = new URL(baseUrl.replace(/\/$/, "") + path);
+  for (const [key, value] of Object.entries(options.query)) {
+    url.searchParams.set(key, value);
+  }
+  const headers = { ...manifest.config.headers, ...options.headers };
+  const authConfig = manifest.config.auth;
+  const token = options.token || (authConfig?.env ? process.env[authConfig.env] : void 0);
+  if (authConfig?.env && !token && !options.dryRun) {
+    throw new Error(`Missing ${authConfig.env}. Set it in .env or environment, or use --token.`);
+  }
+  if (token) {
+    const authType = authConfig?.type || "bearer";
+    if (authType === "bearer") {
+      headers["Authorization"] = `Bearer ${token}`;
+    } else if (authType === "api-key") {
+      headers[authConfig?.header || "X-API-Key"] = token;
+    } else if (authType === "basic") {
+      headers["Authorization"] = `Basic ${token}`;
+    }
+  }
+  if (options.body && !headers["Content-Type"]) {
+    headers["Content-Type"] = "application/json";
+  }
+  const method = match.route.method.toUpperCase();
+  if (options.dryRun || options.verbose) {
+    process.stderr.write(`${method} ${url.toString()}
+`);
+    for (const [k, v] of Object.entries(headers)) {
+      process.stderr.write(`  ${k}: ${v}
+`);
+    }
+    if (options.body) {
+      const preview = options.body.length > 200 ? options.body.slice(0, 200) + "..." : options.body;
+      process.stderr.write(`  Body: ${preview}
+`);
+    }
+    if (options.dryRun) return "";
+    process.stderr.write("\n");
+  }
+  const response = await fetch(url.toString(), {
+    method,
+    headers,
+    body: options.body || void 0
+  });
+  if (options.verbose) {
+    process.stderr.write(`${response.status} ${response.statusText}
+`);
+    response.headers.forEach((v, k) => process.stderr.write(`  ${k}: ${v}
+`));
+    process.stderr.write("\n");
+  }
+  const text = await response.text();
+  const contentType = response.headers.get("content-type") || "";
+  let result;
+  if (contentType.includes("json")) {
+    try {
+      result = JSON.stringify(JSON.parse(text), null, 2);
+    } catch {
+      result = text;
+    }
+  } else {
+    result = text;
+  }
+  if (!response.ok) throw new Error(result);
+  return result;
+}
+async function execute(manifest, match, options) {
+  try {
+    const result = await executeToString(manifest, match, options);
+    if (result) process.stdout.write(result + "\n");
+  } catch (err) {
+    process.stderr.write(err.message + "\n");
+    process.exit(1);
+  }
+}
+
+export {
+  executeToString,
+  execute
+};