poe-code 3.0.191 → 3.0.192

package/dist/providers/tiny-http-mcp-server.js

@@ -0,0 +1,1471 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/templates/py-poe-spawn/env.mustache
+var require_env = __commonJS({
+  "src/templates/py-poe-spawn/env.mustache"(exports, module) {
+    module.exports = "POE_API_KEY={{apiKey}}\nPOE_BASE_URL=https://api.poe.com/v1\nMODEL={{model}}\n";
+  }
+});
+
+// src/templates/py-poe-spawn/main.py.mustache
+var require_main_py = __commonJS({
+  "src/templates/py-poe-spawn/main.py.mustache"(exports, module) {
+    module.exports = 'import os\nfrom openai import OpenAI\nfrom dotenv import load_dotenv\n\nload_dotenv()\n\nclient = OpenAI(\n    api_key=os.getenv("POE_API_KEY"),\n    base_url=os.getenv("POE_BASE_URL")\n)\n\nresponse = client.chat.completions.create(\n    model=os.getenv("MODEL", "{{model}}"),\n    messages=[{"role": "user", "content": "Tell me a joke"}]\n)\n\nprint(response.choices[0].message.content)\n';
+  }
+});
+
+// src/templates/py-poe-spawn/requirements.txt.mustache
+var require_requirements_txt = __commonJS({
+  "src/templates/py-poe-spawn/requirements.txt.mustache"(exports, module) {
+    module.exports = "openai>=1.0.0\npython-dotenv>=1.0.0\n";
+  }
+});
+
+// src/templates/codex/config.toml.mustache
+var require_config_toml = __commonJS({
+  "src/templates/codex/config.toml.mustache"(exports, module) {
+    module.exports = 'model_provider = "poe"\n\n[profiles."{{{profileName}}}"]\nmodel = "{{{model}}}"\nmodel_provider = "poe"\nmodel_reasoning_effort = "{{reasoningEffort}}"\nmodel_verbosity = "medium"\n\n[model_providers.poe]\nname = "poe"\nbase_url = "{{{baseUrl}}}"\nwire_api = "responses"\nexperimental_bearer_token = "{{apiKey}}"\nrequires_openai_auth = false\nsupports_websockets = false\n';
+  }
+});
+
+// src/templates/tiny-http-mcp-server/server.mjs.mustache
+var require_server_mjs = __commonJS({
+  "src/templates/tiny-http-mcp-server/server.mjs.mustache"(exports, module) {
+    module.exports = 'import path from "node:path";\nimport { readFile } from "node:fs/promises";\nimport { fileURLToPath, pathToFileURL } from "node:url";\nimport { createHttpServer } from "tiny-http-mcp-server";\n\nfunction isWindowsAbsolutePath(value) {\n  if (value.length < 3) {\n    return false;\n  }\n\n  const drive = value.charCodeAt(0);\n  const separator = value[2];\n  const isLetter =\n    (drive >= 65 && drive <= 90) || (drive >= 97 && drive <= 122);\n\n  return isLetter && value[1] === ":" && (separator === "\\\\" || separator === "/");\n}\n\nfunction resolveModuleSpecifier(baseDir, value) {\n  if (value.startsWith("file:")) {\n    return value;\n  }\n\n  if (value.startsWith(".") || value.startsWith("/") || isWindowsAbsolutePath(value)) {\n    const resolvedPath = path.isAbsolute(value)\n      ? value\n      : path.resolve(baseDir, value);\n    return pathToFileURL(resolvedPath).href;\n  }\n\n  return value;\n}\n\nconst directory = path.dirname(fileURLToPath(import.meta.url));\nconst config = JSON.parse(\n  await readFile(new URL("./config.json", import.meta.url), "utf8")\n);\n\nconst verifierModule = await import(\n  resolveModuleSpecifier(directory, config.oauth.verifierModule)\n);\nconst verifier = verifierModule[config.oauth.verifierExport ?? "default"];\n\nif (!verifier || typeof verifier.verify !== "function") {\n  throw new Error("Verifier module must export an object with a verify() method.");\n}\n\nconst server = createHttpServer({\n  name: config.name,\n  version: config.version,\n  oauth: {\n    resource: config.oauth.resource,\n    authorizationServers: config.oauth.authorizationServers,\n    requiredScopes: config.oauth.requiredScopes,\n    scopesSupported: config.oauth.scopesSupported,\n    bearerMethodsSupported: config.oauth.bearerMethodsSupported,\n    verifier,\n  },\n});\n\nconst handle = await server.listenHttp(config.listen);\n\nconsole.log(handle.url);\n\nconst shutdown = async () => {\n  await handle.close();\n  process.exit(0);\n};\n\nprocess.once("SIGINT", () => {\n  void shutdown();\n});\n\nprocess.once("SIGTERM", () => {\n  void shutdown();\n});\n';
+  }
+});
+
+// src/templates/tiny-http-mcp-server/verify-token.mjs.mustache
+var require_verify_token_mjs = __commonJS({
+  "src/templates/tiny-http-mcp-server/verify-token.mjs.mustache"(exports, module) {
+    module.exports = 'import { TokenVerificationError } from "tiny-http-mcp-server";\n\nexport default {\n  async verify(_input) {\n    throw new TokenVerificationError({\n      error: "invalid_token",\n      errorDescription: "Replace ~/.poe-code/tiny-http-mcp-server/verify-token.mjs with your token verifier.",\n    });\n  },\n};\n';
+  }
+});
+
+// packages/config-mutations/src/mutations/config-mutation.ts
+function merge(options) {
+  return {
+    kind: "configMerge",
+    target: options.target,
+    value: options.value,
+    format: options.format,
+    pruneByPrefix: options.pruneByPrefix,
+    label: options.label
+  };
+}
+function prune(options) {
+  return {
+    kind: "configPrune",
+    target: options.target,
+    shape: options.shape,
+    format: options.format,
+    onlyIf: options.onlyIf,
+    label: options.label
+  };
+}
+function transform(options) {
+  return {
+    kind: "configTransform",
+    target: options.target,
+    format: options.format,
+    transform: options.transform,
+    label: options.label
+  };
+}
+var configMutation = {
+  merge,
+  prune,
+  transform
+};
+
+// packages/config-mutations/src/mutations/file-mutation.ts
+function ensureDirectory(options) {
+  return {
+    kind: "ensureDirectory",
+    path: options.path,
+    label: options.label
+  };
+}
+function remove(options) {
+  return {
+    kind: "removeFile",
+    target: options.target,
+    whenEmpty: options.whenEmpty,
+    whenContentMatches: options.whenContentMatches,
+    label: options.label
+  };
+}
+function removeDirectory(options) {
+  return {
+    kind: "removeDirectory",
+    path: options.path,
+    force: options.force,
+    label: options.label
+  };
+}
+function chmod(options) {
+  return {
+    kind: "chmod",
+    target: options.target,
+    mode: options.mode,
+    label: options.label
+  };
+}
+function backup(options) {
+  return {
+    kind: "backup",
+    target: options.target,
+    label: options.label
+  };
+}
+var fileMutation = {
+  ensureDirectory,
+  remove,
+  removeDirectory,
+  chmod,
+  backup
+};
+
+// packages/config-mutations/src/mutations/template-mutation.ts
+function write(options) {
+  return {
+    kind: "templateWrite",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+function mergeToml(options) {
+  return {
+    kind: "templateMergeToml",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+function mergeJson(options) {
+  return {
+    kind: "templateMergeJson",
+    target: options.target,
+    templateId: options.templateId,
+    context: options.context,
+    label: options.label
+  };
+}
+var templateMutation = {
+  write,
+  mergeToml,
+  mergeJson
+};
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+import Mustache from "mustache";
+
+// packages/config-mutations/src/formats/json.ts
+import * as jsonc from "jsonc-parser";
+function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse2(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const errors = [];
+  const parsed = jsonc.parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    throw new Error(`JSON parse error: ${jsonc.printParseErrorCode(errors[0].error)}`);
+  }
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject(parsed)) {
+    throw new Error("Expected JSON object.");
+  }
+  return parsed;
+}
+function serialize(obj) {
+  return `${JSON.stringify(obj, null, 2)}
+`;
+}
+function merge2(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject(existing) && isConfigObject(value)) {
+      result[key] = merge2(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune2(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject(pattern) && isConfigObject(current)) {
+      const { changed: childChanged, result: childResult } = prune2(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var jsonFormat = {
+  parse: parse2,
+  serialize,
+  merge: merge2,
+  prune: prune2
+};
+
+// packages/config-mutations/src/formats/toml.ts
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+function isConfigObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse3(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseToml(content);
+  if (!isConfigObject2(parsed)) {
+    throw new Error("Expected TOML document to be a table.");
+  }
+  return parsed;
+}
+function serialize2(obj) {
+  const serialized = stringifyToml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge3(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject2(existing) && isConfigObject2(value)) {
+      result[key] = merge3(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune3(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject2(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject2(pattern) && isConfigObject2(current)) {
+      const { changed: childChanged, result: childResult } = prune3(
+        current,
+        pattern
+      );
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var tomlFormat = {
+  parse: parse3,
+  serialize: serialize2,
+  merge: merge3,
+  prune: prune3
+};
+
+// packages/config-mutations/src/formats/yaml.ts
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+function isConfigObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse4(content) {
+  if (!content || content.trim() === "") {
+    return {};
+  }
+  const parsed = parseYaml(content);
+  if (parsed === null || parsed === void 0) {
+    return {};
+  }
+  if (!isConfigObject3(parsed)) {
+    throw new Error("Expected YAML object.");
+  }
+  return parsed;
+}
+function serialize3(obj) {
+  const serialized = stringifyYaml(obj);
+  return serialized.endsWith("\n") ? serialized : `${serialized}
+`;
+}
+function merge4(base, patch) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) {
+      continue;
+    }
+    const existing = result[key];
+    if (isConfigObject3(existing) && isConfigObject3(value)) {
+      result[key] = merge4(existing, value);
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prune4(obj, shape) {
+  let changed = false;
+  const result = { ...obj };
+  for (const [key, pattern] of Object.entries(shape)) {
+    if (!(key in result)) {
+      continue;
+    }
+    const current = result[key];
+    if (isConfigObject3(pattern) && Object.keys(pattern).length === 0) {
+      delete result[key];
+      changed = true;
+      continue;
+    }
+    if (isConfigObject3(pattern) && isConfigObject3(current)) {
+      const { changed: childChanged, result: childResult } = prune4(current, pattern);
+      if (childChanged) {
+        changed = true;
+      }
+      if (Object.keys(childResult).length === 0) {
+        delete result[key];
+      } else {
+        result[key] = childResult;
+      }
+      continue;
+    }
+    delete result[key];
+    changed = true;
+  }
+  return { changed, result };
+}
+var yamlFormat = {
+  parse: parse4,
+  serialize: serialize3,
+  merge: merge4,
+  prune: prune4
+};
+
+// packages/config-mutations/src/formats/index.ts
+var formatRegistry = {
+  json: jsonFormat,
+  toml: tomlFormat,
+  yaml: yamlFormat
+};
+var extensionMap = {
+  ".json": "json",
+  ".toml": "toml",
+  ".yaml": "yaml",
+  ".yml": "yaml"
+};
+function getConfigFormat(pathOrFormat) {
+  if (pathOrFormat in formatRegistry) {
+    return formatRegistry[pathOrFormat];
+  }
+  const ext = getExtension(pathOrFormat);
+  const formatName = extensionMap[ext];
+  if (!formatName) {
+    throw new Error(
+      `Unsupported config format. Cannot detect format from "${pathOrFormat}". Supported extensions: ${Object.keys(extensionMap).join(", ")}. Supported format names: ${Object.keys(formatRegistry).join(", ")}.`
+    );
+  }
+  return formatRegistry[formatName];
+}
+function detectFormat(path2) {
+  const ext = getExtension(path2);
+  return extensionMap[ext];
+}
+function getExtension(path2) {
+  const lastDot = path2.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "";
+  }
+  return path2.slice(lastDot).toLowerCase();
+}
+
+// packages/config-mutations/src/execution/path-utils.ts
+import path from "node:path";
+function expandHome(targetPath, homeDir) {
+  if (!targetPath?.startsWith("~")) {
+    return targetPath;
+  }
+  if (targetPath.startsWith("~./")) {
+    targetPath = `~/.${targetPath.slice(3)}`;
+  }
+  let remainder = targetPath.slice(1);
+  if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+    remainder = remainder.slice(1);
+  } else if (remainder.startsWith(".")) {
+    remainder = remainder.slice(1);
+    if (remainder.startsWith("/") || remainder.startsWith("\\")) {
+      remainder = remainder.slice(1);
+    }
+  }
+  return remainder.length === 0 ? homeDir : path.join(homeDir, remainder);
+}
+function validateHomePath(targetPath) {
+  if (typeof targetPath !== "string" || targetPath.length === 0) {
+    throw new Error("Target path must be a non-empty string.");
+  }
+  if (!targetPath.startsWith("~")) {
+    throw new Error(
+      `All target paths must be home-relative (start with ~). Received: "${targetPath}"`
+    );
+  }
+}
+function resolvePath(rawPath, homeDir, pathMapper) {
+  validateHomePath(rawPath);
+  const expanded = expandHome(rawPath, homeDir);
+  if (!pathMapper) {
+    return expanded;
+  }
+  const rawDirectory = path.dirname(expanded);
+  const mappedDirectory = pathMapper.mapTargetDirectory({
+    targetDirectory: rawDirectory
+  });
+  const filename = path.basename(expanded);
+  return filename.length === 0 ? mappedDirectory : path.join(mappedDirectory, filename);
+}
+
+// packages/config-mutations/src/fs-utils.ts
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+async function readFileIfExists(fs, target) {
+  try {
+    return await fs.readFile(target, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+async function pathExists(fs, target) {
+  try {
+    await fs.stat(target);
+    return true;
+  } catch (error) {
+    if (isNotFound(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
+function createTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").replaceAll(".", "-");
+}
+
+// packages/config-mutations/src/execution/apply-mutation.ts
+function resolveValue(resolver, options) {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+}
+function createInvalidDocumentBackupPath(targetPath) {
+  const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
+  return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
+}
+async function backupInvalidDocument(fs, targetPath, content) {
+  const backupPath = createInvalidDocumentBackupPath(targetPath);
+  await fs.writeFile(backupPath, content, { encoding: "utf8" });
+}
+function describeMutation(kind, targetPath) {
+  const displayPath = targetPath ?? "target";
+  switch (kind) {
+    case "ensureDirectory":
+      return `Create ${displayPath}`;
+    case "removeDirectory":
+      return `Remove directory ${displayPath}`;
+    case "backup":
+      return `Backup ${displayPath}`;
+    case "templateWrite":
+      return `Write ${displayPath}`;
+    case "chmod":
+      return `Set permissions on ${displayPath}`;
+    case "removeFile":
+      return `Remove ${displayPath}`;
+    case "configMerge":
+    case "configPrune":
+    case "configTransform":
+    case "templateMergeToml":
+    case "templateMergeJson":
+      return `Update ${displayPath}`;
+    default:
+      return "Operation";
+  }
+}
+function pruneKeysByPrefix(table, prefix) {
+  const result = {};
+  for (const [key, value] of Object.entries(table)) {
+    if (!key.startsWith(prefix)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isConfigObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeWithPruneByPrefix(base, patch, pruneByPrefix) {
+  const result = { ...base };
+  const prefixMap = pruneByPrefix ?? {};
+  for (const [key, value] of Object.entries(patch)) {
+    const current = result[key];
+    const prefix = prefixMap[key];
+    if (isConfigObject4(current) && isConfigObject4(value)) {
+      if (prefix) {
+        const pruned = pruneKeysByPrefix(current, prefix);
+        result[key] = { ...pruned, ...value };
+      } else {
+        result[key] = mergeWithPruneByPrefix(
+          current,
+          value,
+          prefixMap
+        );
+      }
+      continue;
+    }
+    result[key] = value;
+  }
+  return result;
+}
+async function applyMutation(mutation, context, options) {
+  switch (mutation.kind) {
+    case "ensureDirectory":
+      return applyEnsureDirectory(mutation, context, options);
+    case "removeDirectory":
+      return applyRemoveDirectory(mutation, context, options);
+    case "removeFile":
+      return applyRemoveFile(mutation, context, options);
+    case "chmod":
+      return applyChmod(mutation, context, options);
+    case "backup":
+      return applyBackup(mutation, context, options);
+    case "configMerge":
+      return applyConfigMerge(mutation, context, options);
+    case "configPrune":
+      return applyConfigPrune(mutation, context, options);
+    case "configTransform":
+      return applyConfigTransform(mutation, context, options);
+    case "templateWrite":
+      return applyTemplateWrite(mutation, context, options);
+    case "templateMergeToml":
+      return applyTemplateMerge(mutation, context, options, "toml");
+    case "templateMergeJson":
+      return applyTemplateMerge(mutation, context, options, "json");
+    default: {
+      const never = mutation;
+      throw new Error(`Unknown mutation kind: ${never.kind}`);
+    }
+  }
+}
+async function applyEnsureDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.mkdir(targetPath, { recursive: true });
+  }
+  return {
+    outcome: {
+      changed: !existed,
+      effect: "mkdir",
+      detail: existed ? "noop" : "create"
+    },
+    details
+  };
+}
+async function applyRemoveDirectory(mutation, context, options) {
+  const rawPath = resolveValue(mutation.path, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const existed = await pathExists(context.fs, targetPath);
+  if (!existed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (typeof context.fs.rm !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.force) {
+    if (!context.dryRun) {
+      await context.fs.rm(targetPath, { recursive: true, force: true });
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const entries = await context.fs.readdir(targetPath);
+  if (entries.length > 0) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    await context.fs.rm(targetPath, { recursive: true, force: true });
+  }
+  return {
+    outcome: { changed: true, effect: "delete", detail: "delete" },
+    details
+  };
+}
+async function applyRemoveFile(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  try {
+    const content = await context.fs.readFile(targetPath, "utf8");
+    const trimmed = content.trim();
+    if (mutation.whenContentMatches && !mutation.whenContentMatches.test(trimmed)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (mutation.whenEmpty && trimmed.length > 0) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+async function applyChmod(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  if (typeof context.fs.chmod !== "function") {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  try {
+    const stat = await context.fs.stat(targetPath);
+    const currentMode = typeof stat.mode === "number" ? stat.mode & 511 : null;
+    if (currentMode === mutation.mode) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.chmod(targetPath, mutation.mode);
+    }
+    return {
+      outcome: { changed: true, effect: "chmod", detail: "update" },
+      details
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    throw error;
+  }
+}
+async function applyBackup(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const content = await readFileIfExists(context.fs, targetPath);
+  if (content === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (!context.dryRun) {
+    const backupPath = `${targetPath}.backup-${createTimestamp()}`;
+    await context.fs.writeFile(backupPath, content, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "copy", detail: "backup" },
+    details
+  };
+}
+async function applyConfigMerge(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const value = resolveValue(mutation.value, options);
+  let merged;
+  if (mutation.pruneByPrefix) {
+    merged = mergeWithPruneByPrefix(current, value, mutation.pruneByPrefix);
+  } else {
+    merged = format.merge(current, value);
+  }
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+async function applyConfigPrune(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  if (rawContent === null) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  let current;
+  try {
+    current = format.parse(rawContent);
+  } catch {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (mutation.onlyIf && !mutation.onlyIf(current, options)) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  const shape = resolveValue(mutation.shape, options);
+  const { changed, result } = format.prune(current, shape);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (Object.keys(result).length === 0) {
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(result);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: { changed: true, effect: "write", detail: "update" },
+    details
+  };
+}
+async function applyConfigTransform(mutation, context, options) {
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const formatName = mutation.format ?? detectFormat(rawPath);
+  if (!formatName) {
+    throw new Error(
+      `Cannot detect config format for "${rawPath}". Provide explicit format option.`
+    );
+  }
+  const format = getConfigFormat(formatName);
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const { content: transformed, changed } = mutation.transform(current, options);
+  if (!changed) {
+    return {
+      outcome: { changed: false, effect: "none", detail: "noop" },
+      details
+    };
+  }
+  if (transformed === null) {
+    if (rawContent === null) {
+      return {
+        outcome: { changed: false, effect: "none", detail: "noop" },
+        details
+      };
+    }
+    if (!context.dryRun) {
+      await context.fs.unlink(targetPath);
+    }
+    return {
+      outcome: { changed: true, effect: "delete", detail: "delete" },
+      details
+    };
+  }
+  const serialized = format.serialize(transformed);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: rawContent === null ? "create" : "update"
+    },
+    details
+  };
+}
+async function applyTemplateWrite(mutation, context, options) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  const existed = await pathExists(context.fs, targetPath);
+  if (!context.dryRun) {
+    await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed: true,
+      effect: "write",
+      detail: existed ? "update" : "create"
+    },
+    details
+  };
+}
+async function applyTemplateMerge(mutation, context, options, formatName) {
+  if (!context.templates) {
+    throw new Error(
+      "Template mutations require a templates loader. Provide templates function to runMutations context."
+    );
+  }
+  const rawPath = resolveValue(mutation.target, options);
+  const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+  const details = {
+    kind: mutation.kind,
+    label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+    targetPath
+  };
+  const format = getConfigFormat(formatName);
+  const template = await context.templates(mutation.templateId);
+  const templateContext = mutation.context ? resolveValue(mutation.context, options) : {};
+  const rendered = Mustache.render(template, templateContext);
+  let templateDoc;
+  try {
+    templateDoc = format.parse(rendered);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse rendered template "${mutation.templateId}" as ${formatName.toUpperCase()}: ${error}`,
+      { cause: error }
+    );
+  }
+  const rawContent = await readFileIfExists(context.fs, targetPath);
+  let current;
+  try {
+    current = rawContent === null ? {} : format.parse(rawContent);
+  } catch {
+    if (rawContent !== null) {
+      await backupInvalidDocument(context.fs, targetPath, rawContent);
+    }
+    current = {};
+  }
+  const merged = format.merge(current, templateDoc);
+  const serialized = format.serialize(merged);
+  const changed = serialized !== rawContent;
+  if (changed && !context.dryRun) {
+    await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+  }
+  return {
+    outcome: {
+      changed,
+      effect: changed ? "write" : "none",
+      detail: changed ? rawContent === null ? "create" : "update" : "noop"
+    },
+    details
+  };
+}
+
+// packages/config-mutations/src/execution/run-mutations.ts
+async function runMutations(mutations, context, options) {
+  const effects = [];
+  let anyChanged = false;
+  const resolverOptions = options ?? {};
+  for (const mutation of mutations) {
+    const { outcome } = await executeMutation(
+      mutation,
+      context,
+      resolverOptions
+    );
+    effects.push(outcome);
+    if (outcome.changed) {
+      anyChanged = true;
+    }
+  }
+  return {
+    changed: anyChanged,
+    effects
+  };
+}
+async function executeMutation(mutation, context, options) {
+  context.observers?.onStart?.({
+    kind: mutation.kind,
+    label: mutation.label ?? mutation.kind,
+    targetPath: void 0
+    // Will be resolved during apply
+  });
+  try {
+    const { outcome, details } = await applyMutation(mutation, context, options);
+    context.observers?.onComplete?.(details, outcome);
+    return { outcome, details };
+  } catch (error) {
+    context.observers?.onError?.(
+      {
+        kind: mutation.kind,
+        label: mutation.label ?? mutation.kind,
+        targetPath: void 0
+      },
+      error
+    );
+    throw error;
+  }
+}
+
+// packages/config-mutations/src/template/render.ts
+import Mustache2 from "mustache";
+var originalEscape = Mustache2.escape;
+
+// src/services/service-install.ts
+async function runServiceInstall(definition, context) {
+  const checkContext = {
+    isDryRun: context.isDryRun,
+    runCommand: context.runCommand
+  };
+  let needsInstall = false;
+  try {
+    await definition.check.run(checkContext);
+    context.logger(`${definition.summary} already installed.`);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    context.logger(`${definition.summary} not detected: ${detail}`);
+    needsInstall = true;
+  }
+  if (!needsInstall) {
+    return false;
+  }
+  if (context.isDryRun) {
+    logInstallDryRun(definition, context);
+    return true;
+  }
+  const platformSteps = filterStepsByPlatform(definition.steps, context.platform);
+  for (const step of platformSteps) {
+    await runInstallStep(step, context);
+  }
+  await definition.check.run(checkContext);
+  if (definition.postChecks) {
+    for (const postCheck of definition.postChecks) {
+      await postCheck.run(checkContext);
+    }
+  }
+  context.logger(
+    definition.successMessage ?? `${definition.summary} installed.`
+  );
+  return true;
+}
+function describeInstallCommand(step) {
+  return `[${step.id}] ${formatCommand(step.command, step.args)}`;
+}
+function formatCommand(command, args) {
+  return [command, ...args.map(quoteIfNeeded)].join(" ");
+}
+function quoteIfNeeded(value) {
+  if (value.length === 0) {
+    return '""';
+  }
+  if (value.includes(" ") || value.includes("	") || value.includes("\n")) {
+    return `"${value.replaceAll('"', '\\"')}"`;
+  }
+  return value;
+}
+function filterStepsByPlatform(steps, platform) {
+  return steps.filter(
+    (step) => !step.platforms || step.platforms.includes(platform)
+  );
+}
+function logInstallDryRun(definition, context) {
+  context.logger(`Dry run: would install ${definition.summary}.`);
+  const platformSteps = filterStepsByPlatform(definition.steps, context.platform);
+  for (const step of platformSteps) {
+    context.logger(`Dry run: ${describeInstallCommand(step)}`);
+  }
+}
+async function runInstallStep(step, context) {
+  context.logger(`Running ${describeInstallCommand(step)}`);
+  const result = await context.runCommand(step.command, step.args);
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.trim();
+    const suffix = stderr.length > 0 ? `: ${stderr}` : "";
+    throw new Error(
+      `${describeInstallCommand(step)} failed with exit code ${result.exitCode}${suffix}`
+    );
+  }
+}
+
+// src/providers/create-provider.ts
+var templateImports = {
+  "py-poe-spawn/env.mustache": () => Promise.resolve().then(() => __toESM(require_env(), 1)),
+  "py-poe-spawn/main.py.mustache": () => Promise.resolve().then(() => __toESM(require_main_py(), 1)),
+  "py-poe-spawn/requirements.txt.mustache": () => Promise.resolve().then(() => __toESM(require_requirements_txt(), 1)),
+  "codex/config.toml.mustache": () => Promise.resolve().then(() => __toESM(require_config_toml(), 1)),
+  "tiny-http-mcp-server/server.mjs.mustache": () => Promise.resolve().then(() => __toESM(require_server_mjs(), 1)),
+  "tiny-http-mcp-server/verify-token.mjs.mustache": () => Promise.resolve().then(() => __toESM(require_verify_token_mjs(), 1))
+};
+async function loadTemplate(templateId) {
+  const loader = templateImports[templateId];
+  if (!loader) {
+    throw new Error(`Template not found: ${templateId}`);
+  }
+  const module = await loader();
+  return module.default;
+}
+function createProvider(opts) {
+  const provider2 = {
+    id: opts.id,
+    summary: opts.summary,
+    name: opts.name,
+    aliases: opts.aliases,
+    label: opts.label,
+    branding: opts.branding,
+    disabled: opts.disabled,
+    supportsStdinPrompt: opts.supportsStdinPrompt,
+    supportsMcpSpawn: opts.supportsMcpSpawn,
+    requiresProvider: opts.requiresProvider ?? true,
+    configurePrompts: opts.configurePrompts,
+    postConfigureMessages: opts.postConfigureMessages,
+    extendConfigurePayload: opts.extendConfigurePayload,
+    isolatedEnv: opts.isolatedEnv,
+    async configure(context, runOptions) {
+      await runMutations(opts.manifest.configure, {
+        fs: context.fs,
+        homeDir: context.env.homeDir,
+        observers: runOptions?.observers,
+        templates: loadTemplate,
+        pathMapper: context.pathMapper
+      }, context.options);
+      context.command.flushDryRun({ emitIfEmpty: false });
+    },
+    async unconfigure(context, runOptions) {
+      if (!opts.manifest.unconfigure) {
+        return false;
+      }
+      const result = await runMutations(opts.manifest.unconfigure, {
+        fs: context.fs,
+        homeDir: context.env.homeDir,
+        observers: runOptions?.observers,
+        templates: loadTemplate,
+        pathMapper: context.pathMapper
+      }, context.options);
+      context.command.flushDryRun({ emitIfEmpty: false });
+      return result.changed;
+    }
+  };
+  if (opts.install) {
+    provider2.install = createInstallRunner(opts.install);
+  }
+  if (opts.test) {
+    provider2.test = opts.test;
+  }
+  if (opts.spawn) {
+    provider2.spawn = opts.spawn;
+  }
+  return provider2;
+}
+function createInstallRunner(definition) {
+  return async (context) => {
+    await runServiceInstall(definition, {
+      isDryRun: context.logger.context.dryRun,
+      runCommand: context.command.runCommand,
+      logger: (message) => context.logger.verbose(message),
+      platform: context.env.platform
+    });
+  };
+}
+
+// src/providers/tiny-http-mcp-server.ts
+var SCAFFOLD_DIRECTORY = "~/.poe-code/tiny-http-mcp-server";
+var CONFIG_FILE = `${SCAFFOLD_DIRECTORY}/config.json`;
+var SERVER_FILE = `${SCAFFOLD_DIRECTORY}/server.mjs`;
+var VERIFIER_FILE = `${SCAFFOLD_DIRECTORY}/verify-token.mjs`;
+var DEFAULT_CONFIG = {
+  name: "oauth-http-server",
+  version: "1.0.0",
+  listen: {
+    hostname: "127.0.0.1",
+    path: "/mcp",
+    port: 3e3
+  },
+  oauth: {
+    resource: "https://example.com/mcp",
+    authorizationServers: ["https://auth.example.com"],
+    scopesSupported: ["mcp.read", "mcp.write"],
+    requiredScopes: ["mcp.read"],
+    bearerMethodsSupported: ["header"],
+    verifierModule: "./verify-token.mjs",
+    verifierExport: "default"
+  }
+};
+function normalizeString(value) {
+  return value.trim();
+}
+function normalizeStringList(values) {
+  const normalized = [];
+  for (const value of values) {
+    const trimmed = normalizeString(value);
+    if (trimmed.length === 0 || normalized.includes(trimmed)) {
+      continue;
+    }
+    normalized.push(trimmed);
+  }
+  return normalized;
+}
+function splitCommaSeparated(value) {
+  return normalizeStringList(value.split(","));
+}
+function readStringOption(context, key) {
+  const value = context.commandOptions[key];
+  return typeof value === "string" && value.trim().length > 0 ? normalizeString(value) : void 0;
+}
+function readStringArrayOption(context, key) {
+  const value = context.commandOptions[key];
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const normalized = normalizeStringList(
+    value.filter((entry) => typeof entry === "string")
+  );
+  return normalized.length > 0 ? normalized : void 0;
+}
+async function promptForValue(context, input) {
+  const response = await context.prompts({
+    name: input.key,
+    message: input.message,
+    type: "text",
+    initial: input.defaultValue
+  });
+  const value = response[input.key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`Missing value for ${input.message}.`);
+  }
+  return normalizeString(value);
+}
+async function resolveStringField(context, input) {
+  const configured = readStringOption(context, input.optionKey);
+  if (configured !== void 0) {
+    return configured;
+  }
+  if (context.assumeYes) {
+    return input.defaultValue;
+  }
+  return promptForValue(context, {
+    key: input.promptKey,
+    message: input.message,
+    defaultValue: input.defaultValue
+  });
+}
+async function resolveStringListField(context, input) {
+  const configured = readStringArrayOption(context, input.optionKey);
+  if (configured !== void 0) {
+    return configured;
+  }
+  if (context.assumeYes) {
+    return [...input.defaultValue];
+  }
+  const response = await promptForValue(context, {
+    key: input.promptKey,
+    message: input.message,
+    defaultValue: input.defaultValue.join(", ")
+  });
+  return splitCommaSeparated(response);
+}
+async function resolveTinyHttpMcpServerConfig(context) {
+  return {
+    name: DEFAULT_CONFIG.name,
+    version: DEFAULT_CONFIG.version,
+    listen: { ...DEFAULT_CONFIG.listen },
+    oauth: {
+      resource: await resolveStringField(context, {
+        optionKey: "oauthResource",
+        promptKey: "oauthResource",
+        message: "OAuth protected resource URI",
+        defaultValue: DEFAULT_CONFIG.oauth.resource
+      }),
+      authorizationServers: await resolveStringListField(context, {
+        optionKey: "oauthAuthorizationServer",
+        promptKey: "oauthAuthorizationServers",
+        message: "OAuth authorization server issuers (comma-separated)",
+        defaultValue: DEFAULT_CONFIG.oauth.authorizationServers
+      }),
+      scopesSupported: await resolveStringListField(context, {
+        optionKey: "oauthSupportedScope",
+        promptKey: "oauthSupportedScopes",
+        message: "OAuth supported scopes (comma-separated)",
+        defaultValue: DEFAULT_CONFIG.oauth.scopesSupported
+      }),
+      requiredScopes: await resolveStringListField(context, {
+        optionKey: "oauthRequiredScope",
+        promptKey: "oauthRequiredScopes",
+        message: "OAuth required scopes (comma-separated)",
+        defaultValue: DEFAULT_CONFIG.oauth.requiredScopes
+      }),
+      bearerMethodsSupported: await resolveStringListField(context, {
+        optionKey: "oauthBearerMethod",
+        promptKey: "oauthBearerMethods",
+        message: "OAuth bearer methods (comma-separated)",
+        defaultValue: DEFAULT_CONFIG.oauth.bearerMethodsSupported
+      }),
+      verifierModule: await resolveStringField(context, {
+        optionKey: "oauthVerifierModule",
+        promptKey: "oauthVerifierModule",
+        message: "OAuth verifier module path or specifier",
+        defaultValue: DEFAULT_CONFIG.oauth.verifierModule
+      }),
+      verifierExport: await resolveStringField(context, {
+        optionKey: "oauthVerifierExport",
+        promptKey: "oauthVerifierExport",
+        message: "OAuth verifier export name",
+        defaultValue: DEFAULT_CONFIG.oauth.verifierExport
+      })
+    }
+  };
+}
+var tinyHttpMcpServerService = createProvider({
+  id: "tiny-http-mcp-server",
+  name: "tiny-http-mcp-server",
+  label: "tiny-http-mcp-server",
+  summary: "Scaffold an OAuth-protected tiny-http-mcp-server example.",
+  requiresProvider: false,
+  async extendConfigurePayload(context) {
+    return resolveTinyHttpMcpServerConfig(context);
+  },
+  manifest: {
+    configure: [
+      fileMutation.ensureDirectory({ path: SCAFFOLD_DIRECTORY }),
+      configMutation.merge({
+        target: CONFIG_FILE,
+        value: (ctx) => {
+          const options = ctx;
+          return {
+            name: options.name,
+            version: options.version,
+            listen: {
+              hostname: options.listen.hostname,
+              path: options.listen.path,
+              port: options.listen.port
+            },
+            oauth: {
+              resource: options.oauth.resource,
+              authorizationServers: options.oauth.authorizationServers,
+              scopesSupported: options.oauth.scopesSupported,
+              requiredScopes: options.oauth.requiredScopes,
+              bearerMethodsSupported: options.oauth.bearerMethodsSupported,
+              verifierModule: options.oauth.verifierModule,
+              verifierExport: options.oauth.verifierExport
+            }
+          };
+        }
+      }),
+      fileMutation.backup({ target: SERVER_FILE }),
+      templateMutation.write({
+        target: SERVER_FILE,
+        templateId: "tiny-http-mcp-server/server.mjs.mustache"
+      }),
+      fileMutation.backup({ target: VERIFIER_FILE }),
+      templateMutation.write({
+        target: VERIFIER_FILE,
+        templateId: "tiny-http-mcp-server/verify-token.mjs.mustache"
+      })
+    ],
+    unconfigure: [
+      fileMutation.remove({ target: CONFIG_FILE }),
+      fileMutation.remove({ target: SERVER_FILE }),
+      fileMutation.remove({ target: VERIFIER_FILE }),
+      fileMutation.removeDirectory({ path: SCAFFOLD_DIRECTORY })
+    ]
+  }
+});
+var provider = tinyHttpMcpServerService;
+export {
+  provider,
+  tinyHttpMcpServerService
+};
+//# sourceMappingURL=tiny-http-mcp-server.js.map