@allocator-one/harness-cli 1.15.1 → 1.17.0

package/dist/infraone-V3IKKVBG.js

@@ -0,0 +1,593 @@
+#!/usr/bin/env node
+import {
+  InfraoneClient,
+  collectFiles,
+  commandSpecs,
+  describeSession,
+  loadSpec,
+  refreshSpec,
+  resolveConfig,
+  transferFor
+} from "./chunk-W7BVOQQG.js";
+import "./chunk-WSDFLMO6.js";
+import {
+  CommandError,
+  HttpError,
+  LocalError,
+  TransportError,
+  UsageError
+} from "./chunk-BHBEIT5I.js";
+import {
+  CLI_VERSION
+} from "./chunk-5THYIKLW.js";
+
+// src/mcp/infraone.ts
+import { randomUUID } from "crypto";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { isAbsolute } from "path";
+
+// src/mcp/infraone-tools.ts
+var PATHS = "paths";
+var ON_CONFLICT = "on_conflict";
+var OUTPUT_PATH = "output_path";
+var OVERWRITE = "overwrite";
+var PATHS_PROPERTY = {
+  type: "array",
+  minItems: 1,
+  items: { type: "string", minLength: 1 },
+  description: "Absolute paths of files and folders on this machine to upload. A folder keeps its tree; hidden and empty files are left out."
+};
+var ON_CONFLICT_PROPERTY = {
+  type: "string",
+  enum: ["keep", "replace", "skip"],
+  default: "keep",
+  description: "For a name that already exists: keep both, skip the new file, or replace the existing one, which a person approves first."
+};
+var OUTPUT_PATH_PROPERTY = {
+  type: "string",
+  minLength: 1,
+  description: "Absolute path on this machine to save the file to, or an existing folder to save it in under its own name."
+};
+var OVERWRITE_PROPERTY = { type: "boolean", default: false, description: "Replace a file already at output_path." };
+var IDEMPOTENCY_KEY = "idempotency_key";
+var METHODS = ["get", "post", "put", "patch", "delete"];
+var RISKS = ["read", "write", "destructive", "outward"];
+var TOOL_NAME = /^[A-Za-z0-9_-]{1,64}$/;
+var PATH_PARAM = /\{([a-z][a-z0-9_]*)\}/g;
+var MAX_REF_DEPTH = 16;
+var SUBSCHEMA_KEYS = /* @__PURE__ */ new Set(["items", "additionalProperties", "not"]);
+var SUBSCHEMA_LIST_KEYS = /* @__PURE__ */ new Set(["allOf", "anyOf", "oneOf"]);
+var IDEMPOTENCY_PROPERTY = {
+  type: "string",
+  minLength: 1,
+  maxLength: 255,
+  description: "Optional. A fresh value for each write; send the same value again when retrying it, so the retry returns the first result instead of writing twice."
+};
+function toolOperations(spec, options = {}) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const [path, item] of Object.entries(spec.paths)) {
+    if (!isRecord(item)) continue;
+    for (const method of METHODS) {
+      const operation = item[method];
+      if (!isRecord(operation)) continue;
+      const built = toolOperation(spec, path, method.toUpperCase(), operation, options.local === true);
+      if (built !== null && !byName.has(built.name)) byName.set(built.name, built);
+    }
+  }
+  return [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function toolDefinitions(spec, scopes, options = {}) {
+  return toolOperations(spec, options).filter((operation) => scopes.includes(operation.scope)).map((operation) => operation.definition);
+}
+function toolRequest(operation, args) {
+  const { [IDEMPOTENCY_KEY]: idempotencyKey, ...rest } = args;
+  const invalid = [];
+  for (const name of [...operation.pathNames, ...operation.queryNames]) {
+    const value = rest[name];
+    if (value !== void 0 && !isScalar(value)) invalid.push(name);
+  }
+  for (const name of operation.pathNames) {
+    const value = rest[name];
+    if (value === void 0 || value === "" || value === "." || value === "..") {
+      if (!invalid.includes(name)) invalid.push(name);
+    }
+  }
+  if (idempotencyKey !== void 0 && (operation.risk === "read" || typeof idempotencyKey !== "string" || idempotencyKey === "")) {
+    invalid.push(IDEMPOTENCY_KEY);
+  }
+  if (invalid.length > 0) return { invalid };
+  const path = operation.path.replace(PATH_PARAM, (_, name) => encodeURIComponent(String(rest[name])));
+  const query = {};
+  const body = {};
+  for (const [name, value] of Object.entries(rest)) {
+    if (operation.pathNames.includes(name)) continue;
+    if (operation.queryNames.includes(name)) query[name] = value;
+    else body[name] = value;
+  }
+  return {
+    method: operation.method,
+    path,
+    query,
+    body: operation.method === "GET" || Object.keys(body).length === 0 ? void 0 : body,
+    idempotencyKey
+  };
+}
+function toolOperation(spec, path, method, operation, local) {
+  const name = operation["x-infraone-tool"];
+  const scope = operation["x-infraone-scope"];
+  if (typeof name !== "string" || !TOOL_NAME.test(name) || typeof scope !== "string" || scope === "") return null;
+  const rawRisk = operation["x-infraone-risk"];
+  const risk = typeof rawRisk === "string" && RISKS.includes(rawRisk) ? rawRisk : "destructive";
+  const parameters = (operation.parameters ?? []).map((parameter) => resolveParameter(spec, parameter)).filter((parameter) => parameter !== null && (parameter.in === "path" || parameter.in === "query"));
+  const pathNames = [...path.matchAll(PATH_PARAM)].map((match) => match[1]);
+  const queryNames = parameters.filter((parameter) => parameter.in === "query").map((parameter) => parameter.name);
+  const properties = {};
+  const required = [];
+  for (const parameter of parameters) {
+    const schema = inline(spec, parameter.schema ?? { type: "string" }, 0);
+    properties[parameter.name] = typeof parameter.description === "string" ? { ...schema, description: parameter.description } : schema;
+    if (parameter.required === true || parameter.in === "path") required.push(parameter.name);
+  }
+  for (const name2 of pathNames) {
+    if (!(name2 in properties)) properties[name2] = { type: "string" };
+    if (!required.includes(name2)) required.push(name2);
+  }
+  const bodySchema = inline(spec, operation.requestBody?.content?.["application/json"]?.schema, 0);
+  const hasBody = isRecord(operation.requestBody?.content?.["application/json"]?.schema);
+  const kind = operation["x-infraone-transfer"];
+  if (local && kind === "upload" && !hasBody) return null;
+  const transfer = local && kind === "upload" && method === "POST" && isRecord(bodySchema.properties?.["files"]) ? "upload" : local && kind === "download" && method === "GET" ? "download" : null;
+  for (const [property, schema] of Object.entries(bodySchema.properties ?? {})) {
+    if (transfer === "upload" && property === "files") continue;
+    properties[property] = schema;
+  }
+  for (const property of bodySchema.required ?? []) {
+    if (transfer === "upload" && property === "files") continue;
+    if (!required.includes(property)) required.push(property);
+  }
+  if (transfer === "upload") {
+    properties[PATHS] = PATHS_PROPERTY;
+    properties[ON_CONFLICT] = ON_CONFLICT_PROPERTY;
+    required.push(PATHS);
+  } else if (transfer === "download") {
+    properties[OUTPUT_PATH] = OUTPUT_PATH_PROPERTY;
+    properties[OVERWRITE] = OVERWRITE_PROPERTY;
+    required.push(OUTPUT_PATH);
+  } else if (risk !== "read") {
+    properties[IDEMPOTENCY_KEY] = IDEMPOTENCY_PROPERTY;
+  }
+  const description = operation.description ?? operation.summary ?? "";
+  const localNote = transfer === "upload" ? " Here, on this machine: `paths` names local files and folders, and this tool sends their bytes and finalizes the upload itself." : transfer === "download" ? " Here, on this machine: the file is saved to `output_path` instead of returning its URL." : "";
+  return {
+    name,
+    method,
+    path,
+    risk,
+    scope,
+    pathNames,
+    queryNames,
+    hasBody,
+    transfer,
+    definition: {
+      name,
+      title: operation.summary ?? name,
+      description: description + localNote,
+      inputSchema: { type: "object", properties, required, additionalProperties: false },
+      annotations: {
+        // A download saved to disk changes this machine.
+        readOnlyHint: risk === "read" && transfer === null,
+        // A local download writes a file, and with `overwrite` replaces one.
+        destructiveHint: risk === "destructive" || transfer === "download",
+        idempotentHint: risk === "read" && transfer === null,
+        openWorldHint: risk === "outward"
+      }
+    }
+  };
+}
+function inline(spec, schema, depth) {
+  if (!isRecord(schema)) return {};
+  if (typeof schema["$ref"] === "string") {
+    if (depth >= MAX_REF_DEPTH) return {};
+    const name = schema["$ref"].replace(/^#\/components\/schemas\//, "");
+    return inline(spec, spec.components?.schemas?.[name], depth + 1);
+  }
+  const copy = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "properties" && isRecord(value)) {
+      copy[key] = Object.fromEntries(Object.entries(value).map(([name, property]) => [name, inline(spec, property, depth + 1)]));
+    } else if (SUBSCHEMA_KEYS.has(key) && isRecord(value)) {
+      copy[key] = inline(spec, value, depth + 1);
+    } else if (SUBSCHEMA_LIST_KEYS.has(key) && Array.isArray(value)) {
+      copy[key] = value.map((item) => inline(spec, item, depth + 1));
+    } else {
+      copy[key] = value;
+    }
+  }
+  return copy;
+}
+function resolveParameter(spec, parameter) {
+  if ("$ref" in parameter) {
+    const name = parameter.$ref.replace(/^#\/components\/parameters\//, "");
+    return spec.components?.parameters?.[name] ?? null;
+  }
+  return typeof parameter.name === "string" && typeof parameter.in === "string" ? parameter : null;
+}
+function isScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/mcp/infraone.ts
+var MCP_CLIENT = "mcp-local";
+var POLL_INTERVAL_MS = 2e3;
+var POLL_ATTEMPTS = 60;
+var MAX_ELICITATION_MS = 10 * 6e4;
+var FILES_PER_SESSION = 20;
+var FOLDER_FILES_PER_SESSION = 100;
+var NEVER_SENT = /* @__PURE__ */ new Set(["ECONNREFUSED", "ENOTFOUND", "EAI_AGAIN", "EHOSTUNREACH", "ENETUNREACH", "CERT_HAS_EXPIRED", "DEPTH_ZERO_SELF_SIGNED_CERT", "SELF_SIGNED_CERT_IN_CHAIN", "UNABLE_TO_VERIFY_LEAF_SIGNATURE", "ERR_TLS_CERT_ALTNAME_INVALID"]);
+var NotSignedIn = class extends Error {
+};
+function buildInfraoneServer(options = {}) {
+  const env = options.env ?? process.env;
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const server = new Server({ name: "infraone", version: CLI_VERSION }, { capabilities: { tools: { listChanged: true } } });
+  let loaded = null;
+  const pending = /* @__PURE__ */ new Map();
+  const config = () => {
+    const resolved = resolveConfig(env);
+    if (!resolved.ok) throw new NotSignedIn(resolved.message);
+    return resolved.config;
+  };
+  const client = (current, headers = {}, seen) => new InfraoneClient(current.apiUrl, current.token, localFetch(options.fetchImpl ?? globalThis.fetch, headers, seen));
+  const spec = async (current, fresh = false) => {
+    if (fresh || loaded === null || loaded.source !== "server") {
+      const refreshed = await refreshSpec(current, client(current));
+      if (refreshed !== null) loaded = refreshed;
+      else loaded ??= await loadSpec(current);
+    }
+    return loaded;
+  };
+  const observe = async (current, answer) => {
+    if (answer.fingerprint === null || loaded === null || answer.fingerprint === loaded.fingerprint) return;
+    const before = JSON.stringify(toolOperations(loaded.spec, LOCAL).map((operation) => operation.definition));
+    const after = await spec(current, true);
+    if (JSON.stringify(toolOperations(after.spec, LOCAL).map((operation) => operation.definition)) !== before) await server.sendToolListChanged().catch(() => void 0);
+  };
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const current = config();
+    if (current.token === null) throw new McpError(ErrorCode.InvalidRequest, notSignedIn(current));
+    const { spec: served } = await spec(current);
+    let scopes;
+    try {
+      scopes = (await describeSession(client(current)))?.scopes ?? null;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new McpError(ErrorCode.InternalError, `Cannot read the credential's scopes from ${current.apiUrl} (${reason}), so no tools are listed.`);
+    }
+    if (scopes === null) throw new McpError(ErrorCode.InternalError, `${current.apiUrl} did not describe the credential's scopes, so no tools are listed.`);
+    return { tools: toolDefinitions(served, scopes, LOCAL) };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    const name = request.params.name;
+    const args = request.params.arguments ?? {};
+    let current;
+    try {
+      current = config();
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+    let operation = find((await spec(current)).spec, name);
+    if (operation === null) operation = find((await spec(current, true)).spec, name);
+    if (operation === null) return failure(`Unknown tool: ${name}`);
+    const tool = operation;
+    if (current.token === null) {
+      return failure(notSignedIn(current));
+    }
+    if (operation.transfer !== null) return transfer(operation, (await spec(current)).spec);
+    const built = toolRequest(operation, args);
+    if ("invalid" in built) return failure(JSON.stringify({ error: "invalid_arguments", message: `Invalid arguments: ${built.invalid.join(", ")}` }));
+    const key = pendingKey(name, args);
+    const remembered = live(pending, key);
+    const call = {
+      ...built,
+      idempotencyKey: built.idempotencyKey ?? remembered?.idempotencyKey ?? (operation.risk === "read" ? void 0 : randomUUID())
+    };
+    const send = async (confirmation) => {
+      const answer = await client(current, confirmation === null ? {} : { "infraone-confirmation": confirmation }).request(call.method, call.path, {
+        query: call.query,
+        body: call.body,
+        ...call.idempotencyKey === void 0 ? {} : { idempotencyKey: call.idempotencyKey }
+      });
+      await observe(current, answer);
+      return answer;
+    };
+    try {
+      const answer = await send(remembered?.id ?? null);
+      pending.delete(key);
+      return success(answer);
+    } catch (error) {
+      const confirmation = pendingConfirmation(error);
+      if (confirmation !== null) {
+        pending.set(key, { ...confirmation, idempotencyKey: call.idempotencyKey });
+        return confirm(confirmation);
+      }
+      if (remembered !== void 0 && isInvalidConfirmation(error)) return awaitingApproval(remembered, error);
+      return failed(error, tool, call.idempotencyKey);
+    }
+    function confirm(confirmation) {
+      return confirmThen(confirmation, key, send, tool, call.idempotencyKey);
+    }
+    async function transfer(transferTool, served) {
+      const { [PATHS]: paths, [ON_CONFLICT]: onConflict, [OUTPUT_PATH]: outputPath, [OVERWRITE]: overwrite, ...apiArgs } = args;
+      const invalid = [];
+      if (transferTool.transfer === "upload") {
+        if (!Array.isArray(paths) || paths.length === 0 || !paths.every((path) => typeof path === "string" && isAbsolute(path))) invalid.push(PATHS);
+        if (onConflict !== void 0 && !["keep", "replace", "skip"].includes(onConflict)) invalid.push(ON_CONFLICT);
+      } else {
+        if (typeof outputPath !== "string" || !isAbsolute(outputPath)) invalid.push(OUTPUT_PATH);
+        if (overwrite !== void 0 && typeof overwrite !== "boolean") invalid.push(OVERWRITE);
+      }
+      const built2 = toolRequest(transferTool, apiArgs);
+      if ("invalid" in built2) invalid.push(...built2.invalid);
+      if (invalid.length > 0 || "invalid" in built2) {
+        return failure(JSON.stringify({ error: "invalid_arguments", message: `Invalid arguments: ${invalid.join(", ")}` }));
+      }
+      const operations = commandSpecs(served);
+      const command = operations.find((candidate) => candidate.tool === transferTool.name);
+      const kind = command === void 0 ? null : transferFor(command);
+      if (command === void 0 || kind === null) return failure(`${transferTool.name} can't move files on this machine.`);
+      const replace = onConflict === "replace";
+      if (replace) {
+        const { files } = await collectFiles(paths).catch((error) => ({ files: null, error }));
+        if (files !== null) {
+          const loose = files.filter((file) => file.relativePath === null).length;
+          const folder = files.length - loose;
+          if (loose > 0 && folder > 0 || loose > FILES_PER_SESSION || folder > FOLDER_FILES_PER_SESSION) {
+            return failure(
+              `Replacing needs a person's approval for each upload, so on_conflict "replace" takes at most ${FILES_PER_SESSION} files, or ${FOLDER_FILES_PER_SESSION} from folders, and not both at once. Split the upload; nothing was sent.`
+            );
+          }
+        }
+      }
+      let session = null;
+      const sessionUrl = apiUrlOf(current, built2.path);
+      const watch = async (url, answer) => {
+        if (url.origin + url.pathname !== sessionUrl || !answer.ok) return;
+        const body = await answer.clone().json().catch(() => null);
+        const id = body?.data?.id;
+        if (typeof id === "string") session = id;
+      };
+      const invocation = {
+        pathValues: {},
+        query: built2.query,
+        body: built2.body ?? {},
+        json: true,
+        all: false,
+        // The API asks a person for a replace (428): this server never confirms by itself.
+        yes: replace,
+        extra: Array.isArray(paths) ? paths : [],
+        options: { onConflict: onConflict ?? "keep", output: outputPath, force: overwrite === true }
+      };
+      const context = {
+        client: client(current, {}, watch),
+        command,
+        invocation,
+        path: built2.path,
+        operations,
+        confirmed: false,
+        interactive: false,
+        prompt: async () => "",
+        target: async () => new URL(current.apiUrl).host,
+        stderr: () => void 0
+      };
+      try {
+        return { content: [{ type: "text", text: JSON.stringify({ data: await kind.run(context) }) }] };
+      } catch (error) {
+        const confirmation = pendingConfirmation(error);
+        if (confirmation !== null && replace && session !== null) return finalizeLater(confirmation, session, served, built2.path, apiArgs);
+        if (error instanceof UsageError || error instanceof LocalError || error instanceof CommandError) return failure(error.message);
+        return failed(error, transferTool, void 0);
+      }
+    }
+    async function finalizeLater(confirmation, session, served, createPath, createArgs) {
+      const finalize = toolOperations(served, LOCAL).find((candidate) => {
+        const last = candidate.pathNames.at(-1);
+        return candidate.method === "POST" && candidate.pathNames.length === tool.pathNames.length + 1 && candidate.path === `${tool.path}/{${last}}/finalize`;
+      });
+      if (finalize === void 0) return failure(`The files were uploaded (session ${session}), but this API has no finalize tool to approve.`);
+      const finalizeArgs = { [ON_CONFLICT]: "replace" };
+      tool.pathNames.forEach((name2, index) => {
+        finalizeArgs[finalize.pathNames[index]] = createArgs[name2];
+      });
+      finalizeArgs[finalize.pathNames.at(-1)] = session;
+      const finalizeKey = pendingKey(finalize.name, finalizeArgs);
+      const idempotencyKey = randomUUID();
+      pending.set(finalizeKey, { ...confirmation, idempotencyKey });
+      const path = `${createPath}/${encodeURIComponent(session)}/finalize`;
+      const sendFinalize = async (id) => {
+        const answer = await client(current, id === null ? {} : { "infraone-confirmation": id }).request("POST", path, {
+          body: { [ON_CONFLICT]: "replace" },
+          idempotencyKey
+        });
+        await observe(current, answer);
+        const status = await filed(`${createPath}/${encodeURIComponent(session)}`);
+        const data = answer.body["data"];
+        return status === null ? answer : { ...answer, body: { ...answer.body, data: { ...isRecord2(data) ? data : {}, ...status } } };
+      };
+      async function filed(sessionPath) {
+        const deadline = Date.now() + MAX_ELICITATION_MS;
+        let wait = 500;
+        for (; ; ) {
+          let data;
+          try {
+            data = (await client(current).request("GET", sessionPath)).body["data"];
+          } catch {
+            return null;
+          }
+          const status = isRecord2(data) ? data["status"] : void 0;
+          if (status === "completed") return { status, result: isRecord2(data) ? data["result"] ?? null : null };
+          if (status === "failed") throw new CommandError(`The files were uploaded but could not be filed (session ${session}).`);
+          if (Date.now() > deadline) return { status };
+          await sleep(wait);
+          wait = Math.min(5e3, wait * 2);
+        }
+      }
+      return confirmThen(confirmation, finalizeKey, sendFinalize, finalize, idempotencyKey, { tool: finalize.name, arguments: finalizeArgs });
+    }
+    async function confirmThen(confirmation, key2, send2, tool2, idempotencyKey, next) {
+      const elicitation = server.getClientCapabilities()?.elicitation;
+      if (elicitation === void 0) return approvalLink(confirmation, next);
+      const url = elicitation.url !== void 0;
+      const message = `Approve or deny this in Infra One${describe(confirmation.summary)}. ` + (url ? "" : `Open ${confirmation.approvalUrl}, decide there, then continue here. `) + "It runs only once you approve it there.";
+      const wait = Math.min(Math.max(confirmation.expiresAt - Date.now(), 1e3), MAX_ELICITATION_MS);
+      let action;
+      try {
+        const result = await server.elicitInput(
+          url ? { mode: "url", message, url: confirmation.approvalUrl, elicitationId: confirmation.id } : { message, requestedSchema: { type: "object", properties: {} } },
+          { timeout: wait, signal: extra.signal }
+        );
+        action = result.action;
+      } catch {
+        return approvalLink(confirmation, next);
+      }
+      if (action !== "accept") {
+        pending.delete(key2);
+        return failure(next === void 0 ? "Not confirmed, so nothing was done." : "Not confirmed: the files were uploaded but not filed, and nothing was replaced.");
+      }
+      for (let attempt = 0; attempt < POLL_ATTEMPTS && !extra.signal.aborted; attempt++) {
+        try {
+          const answer = await send2(confirmation.id);
+          pending.delete(key2);
+          if (url) await server.createElicitationCompletionNotifier(confirmation.id)().catch(() => void 0);
+          return success(answer);
+        } catch (error) {
+          if (!isInvalidConfirmation(error)) return failed(error, tool2, idempotencyKey);
+          if (Date.now() >= confirmation.expiresAt) break;
+          await sleep(POLL_INTERVAL_MS);
+        }
+      }
+      return approvalLink(confirmation, next);
+    }
+  });
+  return server;
+}
+async function startInfraoneMcp(options = {}) {
+  const server = buildInfraoneServer(options);
+  const closed = new Promise((resolve) => {
+    server.onclose = () => resolve();
+    process.stdin.once("end", () => resolve());
+  });
+  await server.connect(new StdioServerTransport());
+  await closed;
+}
+function notSignedIn(current) {
+  return `Not signed in to ${current.apiUrl}. Run \`infraone login\` in a terminal (or set INFRAONE_TOKEN for headless use) \u2014 the MCP server never opens a browser itself.`;
+}
+var LOCAL = { local: true };
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function find(spec, name) {
+  return toolOperations(spec, LOCAL).find((operation) => operation.name === name) ?? null;
+}
+function apiUrlOf(current, path) {
+  const base = current.apiUrl.replace(/\/+$/, "");
+  return new URL(/\/v\d+$/.test(base) ? base + path.replace(/^\/v\d+(?=\/|$)/, "") : base + path).href;
+}
+function localFetch(fetchImpl, headers, seen) {
+  return (async (input, init) => {
+    const merged = new Headers(init?.headers);
+    merged.set("infraone-client", MCP_CLIENT);
+    merged.delete("infraone-confirm");
+    for (const [name, value] of Object.entries(headers)) merged.set(name, value);
+    const answer = await fetchImpl(input, { ...init, headers: Object.fromEntries(merged) });
+    await seen?.(new URL(String(input instanceof Request ? input.url : input)), answer);
+    return answer;
+  });
+}
+function pendingKey(name, args) {
+  const { idempotency_key: _key, ...rest } = args;
+  return `${name}\0${canonical(rest)}`;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function live(pending, key) {
+  const found = pending.get(key);
+  if (found !== void 0 && found.expiresAt <= Date.now()) {
+    pending.delete(key);
+    return void 0;
+  }
+  return found;
+}
+function pendingConfirmation(error) {
+  if (!(error instanceof HttpError) || error.status !== 428) return null;
+  const confirmation = error.body["confirmation"];
+  if (typeof confirmation !== "object" || confirmation === null) return null;
+  const { id, approval_url: approvalUrl, expires_at: expiresAt, summary } = confirmation;
+  if (typeof id !== "string" || id === "" || typeof approvalUrl !== "string" || approvalUrl === "") return null;
+  const expiry = typeof expiresAt === "string" ? Date.parse(expiresAt) : Number.NaN;
+  return { id, approvalUrl, expiresAt: Number.isNaN(expiry) ? Date.now() + 10 * 6e4 : expiry, summary };
+}
+function isInvalidConfirmation(error) {
+  return error instanceof HttpError && error.status === 409 && error.body["error"] === "confirmation_invalid";
+}
+function approvalLink(confirmation, next) {
+  return failure(
+    JSON.stringify({
+      error: "confirmation_required",
+      message: next === void 0 ? "A person must approve this in Infra One first; nothing was done yet. Give them approval_url to open, and once they approved it, call this tool again with the same arguments." : `The files were uploaded, but replacing existing files needs a person's approval, so nothing is filed yet. Give them approval_url to open, and once they approved it, call ${next.tool} with then_call.arguments (not this tool again).`,
+      approval_url: confirmation.approvalUrl,
+      expires_at: new Date(confirmation.expiresAt).toISOString(),
+      summary: confirmation.summary ?? null,
+      ...next === void 0 ? {} : { then_call: next }
+    })
+  );
+}
+function awaitingApproval(confirmation, error) {
+  return failure(
+    JSON.stringify({
+      error: "confirmation_invalid",
+      message: "Not approved yet, so nothing was done. Once the person approved it at approval_url, call this tool again with the same arguments. A denied approval, or one whose target changed, stops matching; after it expires, calling again asks anew.",
+      approval_url: confirmation.approvalUrl,
+      expires_at: new Date(confirmation.expiresAt).toISOString(),
+      request_id: error.body["request_id"] ?? null
+    })
+  );
+}
+function describe(summary) {
+  if (typeof summary !== "object" || summary === null || Object.keys(summary).length === 0) return "";
+  return `: ${JSON.stringify(summary)}`;
+}
+function success(answer) {
+  return { content: [{ type: "text", text: JSON.stringify(answer.body) }] };
+}
+function failed(error, operation, idempotencyKey) {
+  if (error instanceof HttpError) return failure(JSON.stringify({ status: error.status, ...error.body, message: error.message }));
+  if (error instanceof TransportError) {
+    if (operation.risk !== "read" && !NEVER_SENT.has(error.code ?? "")) {
+      return failure(
+        `Outcome unknown: the write may have reached the API (${error.message}). Check before calling again, or call again ` + (idempotencyKey === void 0 ? "with the same idempotency_key." : `with idempotency_key: ${idempotencyKey}`)
+      );
+    }
+    return failure(`Cannot reach the API: ${error.message}`);
+  }
+  return failure(error instanceof Error ? error.message : String(error));
+}
+function failure(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+export {
+  MCP_CLIENT,
+  buildInfraoneServer,
+  startInfraoneMcp
+};