mcp-rule34 0.1.0

package/dist/index.js

@@ -0,0 +1,1435 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/version.ts
+var PKG_VERSION = "0.1.0";
+var REPO_URL = "https://github.com/smeet666/mcp-rule34";
+
+// src/config.ts
+var DEFAULT_USER_AGENT = `mcp-rule34/${PKG_VERSION} (+${REPO_URL})`;
+var DEFAULTS = {
+  minIntervalMs: 1e3,
+  timeoutMs: 2e4,
+  maxRetries: 3,
+  cacheTtlMs: 5 * 60 * 1e3,
+  cacheMaxEntries: 300,
+  logLevel: "error"
+};
+var MIN_ALLOWED_INTERVAL_MS = 1e3;
+var LOG_LEVELS = ["silent", "error", "info", "debug"];
+function warn(message) {
+  process.stderr.write(`[mcp-rule34] ${message}
+`);
+}
+function readNumber(name, env, range) {
+  const raw = env[name];
+  if (raw === void 0 || raw.trim() === "") {
+    return range.fallback;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    warn(`${name}="${raw}" is not a number, using ${range.fallback}`);
+    return range.fallback;
+  }
+  const clamped = Math.min(range.max, Math.max(range.min, Math.round(parsed)));
+  if (clamped !== Math.round(parsed)) {
+    warn(`${name}=${raw} is out of range, clamped to ${clamped}`);
+  }
+  return clamped;
+}
+function readInterval(env) {
+  const raw = env.RULE34_MIN_INTERVAL_MS;
+  if (raw === void 0 || raw.trim() === "") {
+    return DEFAULTS.minIntervalMs;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    warn(`RULE34_MIN_INTERVAL_MS="${raw}" is not a number, using ${DEFAULTS.minIntervalMs}ms`);
+    return DEFAULTS.minIntervalMs;
+  }
+  const rounded = Math.round(parsed);
+  if (rounded < MIN_ALLOWED_INTERVAL_MS) {
+    warn(
+      `RULE34_MIN_INTERVAL_MS=${raw} is below the ${MIN_ALLOWED_INTERVAL_MS}ms floor and was ignored; using ${DEFAULTS.minIntervalMs}ms. This floor keeps the client from hammering rule34.xxx.`
+    );
+    return DEFAULTS.minIntervalMs;
+  }
+  return Math.min(6e4, rounded);
+}
+function readCredentials(env) {
+  const userId = env.RULE34_USER_ID?.trim() ?? "";
+  const apiKey = env.RULE34_API_KEY?.trim() ?? "";
+  if (userId === "" || apiKey === "") {
+    return null;
+  }
+  return { userId, apiKey };
+}
+function loadConfig(env = process.env) {
+  const rawUserAgent = env.RULE34_USER_AGENT?.trim();
+  const rawLogLevel = env.RULE34_LOG_LEVEL?.trim().toLowerCase();
+  let logLevel = DEFAULTS.logLevel;
+  if (rawLogLevel) {
+    if (LOG_LEVELS.includes(rawLogLevel)) {
+      logLevel = rawLogLevel;
+    } else {
+      warn(`RULE34_LOG_LEVEL="${rawLogLevel}" is unknown, using "${DEFAULTS.logLevel}"`);
+    }
+  }
+  return {
+    userAgent: rawUserAgent || DEFAULT_USER_AGENT,
+    credentials: readCredentials(env),
+    minIntervalMs: readInterval(env),
+    timeoutMs: readNumber("RULE34_TIMEOUT_MS", env, {
+      min: 1e3,
+      max: 12e4,
+      fallback: DEFAULTS.timeoutMs
+    }),
+    maxRetries: readNumber("RULE34_MAX_RETRIES", env, {
+      min: 0,
+      max: 10,
+      fallback: DEFAULTS.maxRetries
+    }),
+    cacheTtlMs: readNumber("RULE34_CACHE_TTL_MS", env, {
+      min: 0,
+      max: 24 * 60 * 60 * 1e3,
+      fallback: DEFAULTS.cacheTtlMs
+    }),
+    cacheMaxEntries: readNumber("RULE34_CACHE_MAX_ENTRIES", env, {
+      min: 0,
+      max: 1e4,
+      fallback: DEFAULTS.cacheMaxEntries
+    }),
+    logLevel
+  };
+}
+var LEVEL_RANK = { silent: 0, error: 1, info: 2, debug: 3 };
+function createLogger(level) {
+  const emit = (at, message) => {
+    if (LEVEL_RANK[level] >= LEVEL_RANK[at]) {
+      process.stderr.write(`[mcp-rule34] ${message}
+`);
+    }
+  };
+  return {
+    error: (message) => emit("error", message),
+    info: (message) => emit("info", message),
+    debug: (message) => emit("debug", message)
+  };
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z5 } from "zod";
+
+// src/errors.ts
+var Rule34Error = class extends Error {
+  constructor(code, text, details = {}) {
+    super(`[${code}] ${text}`);
+    this.code = code;
+    this.details = details;
+    this.name = "Rule34Error";
+  }
+  code;
+  details;
+};
+var ISSUES_URL = "https://github.com/smeet666/mcp-rule34/issues";
+function invalidInput(message, hint) {
+  return new Rule34Error("invalid_input", message, hint ? { hint } : {});
+}
+function missingCredentials(url) {
+  return new Rule34Error(
+    "invalid_input",
+    "rule34.xxx answered that this request carries no valid API credentials.",
+    {
+      url,
+      hint: "Set RULE34_USER_ID and RULE34_API_KEY in the env block of this server's entry in your MCP client configuration. Both are shown under 'API Access Credentials' at https://rule34.xxx/index.php?page=account&s=options once you are signed in. The site issues one key per person, so use your own rather than sharing one."
+    }
+  );
+}
+function notFound(url) {
+  return new Rule34Error("not_found", "rule34.xxx has nothing at this address.", {
+    url,
+    status: 404,
+    hint: "Check the post id. Ids come from a search; they are not stable to guess by hand."
+  });
+}
+function rateLimited(url, retryAfterMs) {
+  return new Rule34Error(
+    "rate_limited",
+    "rule34.xxx is refusing requests from this client for now (HTTP 429). This does NOT mean the search found nothing.",
+    {
+      url,
+      status: 429,
+      retryAfterMs,
+      hint: "Wait before asking again. If it keeps happening, raise RULE34_MIN_INTERVAL_MS in your MCP client configuration to slow this server down."
+    }
+  );
+}
+function parseFailure(url, what) {
+  return new Rule34Error(
+    "parse_failure",
+    `The request was answered, but not with the document this route publishes (${what}).`,
+    { url, hint: `Please report this, with the query you used, at ${ISSUES_URL}` }
+  );
+}
+function upstreamFailure(url, message) {
+  return new Rule34Error("network_error", `rule34.xxx reported a failure: ${message}`, {
+    url,
+    hint: "This is the site's own message. Waiting and asking again is usually the only remedy."
+  });
+}
+
+// src/rule34/cache.ts
+var TtlLruCache = class {
+  constructor(maxEntries, ttlMs) {
+    this.maxEntries = maxEntries;
+    this.ttlMs = ttlMs;
+  }
+  maxEntries;
+  ttlMs;
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (Date.now() >= entry.expiresAt) {
+      this.store.delete(key);
+      return void 0;
+    }
+    this.store.delete(key);
+    this.store.set(key, entry);
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.maxEntries <= 0 || this.ttlMs <= 0) {
+      return;
+    }
+    this.store.delete(key);
+    this.store.set(key, { value, expiresAt: Date.now() + this.ttlMs });
+    while (this.store.size > this.maxEntries) {
+      const oldest = this.store.keys().next();
+      if (oldest.done) {
+        break;
+      }
+      this.store.delete(oldest.value);
+    }
+  }
+  /** The keys currently held, in least recently used order. */
+  keys() {
+    return [...this.store.keys()];
+  }
+  get size() {
+    return this.store.size;
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
+// src/rule34/rateLimiter.ts
+var DEFAULT_MAX_INTERVAL_MS = 3e4;
+var RateLimiter = class {
+  baseIntervalMs;
+  maxIntervalMs;
+  intervalMs;
+  /** Tail of the queue: each task chains onto the previous one. */
+  tail = Promise.resolve();
+  lastStart = 0;
+  constructor(options) {
+    this.baseIntervalMs = Math.max(0, options.minIntervalMs);
+    this.maxIntervalMs = Math.max(
+      this.baseIntervalMs,
+      options.maxIntervalMs ?? DEFAULT_MAX_INTERVAL_MS
+    );
+    this.intervalMs = this.baseIntervalMs;
+  }
+  get currentIntervalMs() {
+    return this.intervalMs;
+  }
+  /** Queue a task. Tasks run in call order, one at a time. */
+  schedule(task) {
+    const run = this.tail.then(async () => task());
+    this.tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  /**
+   * Wait for this request's slot, then claim it.
+   *
+   * Called once per upstream request rather than once per task, because a task
+   * runs a whole retry chain: stamping only its start would let the next task
+   * follow the chain's last request with no gap at all.
+   */
+  async beforeRequest() {
+    await this.waitForSlot();
+    this.lastStart = Date.now();
+  }
+  /** Called after the site answers that it is being asked too often. */
+  penalize() {
+    const next = this.intervalMs === 0 ? 500 : this.intervalMs * 2;
+    this.intervalMs = Math.min(this.maxIntervalMs, next);
+  }
+  /** Called after a success, so one push-back does not slow things down forever. */
+  relax() {
+    this.intervalMs = Math.max(this.baseIntervalMs, Math.floor(this.intervalMs * 0.75));
+  }
+  async waitForSlot() {
+    if (this.intervalMs === 0 || this.lastStart === 0) {
+      return;
+    }
+    const elapsed = Date.now() - this.lastStart;
+    const remaining = Math.min(this.intervalMs, this.intervalMs - elapsed);
+    if (remaining > 0) {
+      await sleep(remaining);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/rule34/urls.ts
+var API_URL = "https://api.rule34.xxx/index.php";
+var SITE_URL = "https://rule34.xxx/index.php";
+var MAX_LIMIT = 1e3;
+var MEDIA_TOKENS = {
+  image: ["-video", "-animated"],
+  animated: ["animated", "-video"],
+  video: ["video"],
+  any: []
+};
+var SORT_TOKENS = {
+  score: "sort:score:desc",
+  id: "sort:id:desc",
+  updated: "sort:updated:desc",
+  random: "sort:random"
+};
+var MAX_TAGS = 10;
+function normalizeTag(raw) {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    throw invalidInput(
+      "A tag is required.",
+      "Pass the tag to search for, such as 'black hair' or 'asuka langley sohryu'."
+    );
+  }
+  if (trimmed.startsWith("-")) {
+    throw invalidInput(
+      `"${trimmed}" starts with '-', which means "without this tag" on rule34.xxx.`,
+      "This tool searches for a tag. Pass the tag itself, without the leading dash."
+    );
+  }
+  if (trimmed.includes(":")) {
+    throw invalidInput(
+      `"${trimmed}" carries a ':', which rule34.xxx reads as a filter rather than as a tag.`,
+      "Filters are separate arguments here: use 'rating', 'sort' and 'media_type'."
+    );
+  }
+  return trimmed.replace(/\s+/g, "_").toLowerCase();
+}
+function normalizeList(raw, argument) {
+  const tags = (raw ?? []).map(normalizeTag);
+  if (tags.length > MAX_TAGS) {
+    throw invalidInput(
+      `'${argument}' holds ${tags.length} tags, and this tool searches at most ${MAX_TAGS} at a time.`,
+      "Search on the tags that narrow the most, then look through the results."
+    );
+  }
+  return tags;
+}
+function normalizeSearch(search) {
+  const required = normalizeList(search.tags, "tags");
+  if (required.length === 0) {
+    throw invalidInput(
+      "At least one tag is required.",
+      "Pass the tags to search for, such as ['asuka langley sohryu', 'black hair']."
+    );
+  }
+  const alternatives = normalizeList(search.anyOf, "any_of");
+  const excluded = normalizeList(search.exclude, "exclude");
+  const contradiction = required.find((tag) => excluded.includes(tag));
+  if (contradiction) {
+    throw invalidInput(
+      `'${contradiction}' is both required and excluded, so no post can match.`,
+      "Remove it from one of the two lists."
+    );
+  }
+  return { required, alternatives, excluded };
+}
+function buildSearchQuery(search) {
+  const { required, alternatives, excluded } = normalizeSearch(search);
+  const tokens = [...required];
+  if (alternatives.length === 1) {
+    tokens.push(...alternatives);
+  } else if (alternatives.length > 1) {
+    tokens.push(`( ${alternatives.join(" ~ ")} )`);
+  }
+  tokens.push(...excluded.map((tag) => `-${tag}`), ...MEDIA_TOKENS[search.mediaType ?? "any"]);
+  if (search.rating) {
+    tokens.push(`rating:${search.rating}`);
+  }
+  if (search.sort) {
+    tokens.push(SORT_TOKENS[search.sort]);
+  }
+  return tokens.join(" ");
+}
+function buildPostSearchUrl(search, credentials) {
+  if (!Number.isInteger(search.limit) || search.limit < 1 || search.limit > MAX_LIMIT) {
+    throw invalidInput(
+      `limit must be a whole number between 1 and ${MAX_LIMIT}, and ${search.limit} is not.`,
+      `rule34.xxx serves at most ${MAX_LIMIT} posts in one request.`
+    );
+  }
+  if (!Number.isInteger(search.page) || search.page < 1) {
+    throw invalidInput(`page must be a whole number from 1 upwards, and ${search.page} is not.`);
+  }
+  const query = encodeURIComponent(buildSearchQuery(search));
+  const pid = search.page - 1;
+  return `${API_URL}?page=dapi&s=post&q=index&tags=${query}&limit=${search.limit}&pid=${pid}&api_key=${encodeURIComponent(credentials.apiKey)}&user_id=${encodeURIComponent(credentials.userId)}`;
+}
+function buildTagLookupUrl(tag, credentials) {
+  return `${API_URL}?page=dapi&s=tag&q=index&name=${encodeURIComponent(normalizeTag(tag))}&api_key=${encodeURIComponent(credentials.apiKey)}&user_id=${encodeURIComponent(credentials.userId)}`;
+}
+function readPostPageUrl(raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw.trim());
+  } catch {
+    throw invalidInput(
+      `"${raw}" is not a URL.`,
+      "Pass a link to a post's page, such as https://rule34.xxx/index.php?page=post&s=view&id=2195419"
+    );
+  }
+  const host = parsed.hostname.toLowerCase();
+  if (host !== "rule34.xxx" && !host.endsWith(".rule34.xxx")) {
+    throw invalidInput(
+      `"${raw}" is not a rule34.xxx address.`,
+      "This tool reads posts on rule34.xxx. A link elsewhere names no post it holds."
+    );
+  }
+  if (parsed.searchParams.get("page") !== "post" || parsed.searchParams.get("s") !== "view") {
+    throw invalidInput(
+      `"${raw}" is a rule34.xxx address, but not a post's page.`,
+      "A post's page looks like https://rule34.xxx/index.php?page=post&s=view&id=2195419"
+    );
+  }
+  const id = Number(parsed.searchParams.get("id"));
+  if (!Number.isInteger(id) || id < 1) {
+    throw invalidInput(`"${raw}" carries no post id.`);
+  }
+  return id;
+}
+function resolvePostRef(ref) {
+  const fromUrl = ref.url === void 0 ? null : readPostPageUrl(ref.url);
+  const fromId = ref.id;
+  if (fromId !== void 0) {
+    if (!Number.isInteger(fromId) || fromId < 1) {
+      throw invalidInput(`id must be a whole number from 1 upwards, and ${fromId} is not.`);
+    }
+    if (fromUrl !== null && fromUrl !== fromId) {
+      throw invalidInput(
+        `'id' names post ${fromId} and 'url' names post ${fromUrl}, so they cannot both be read.`,
+        "Pass one of the two, or make them agree."
+      );
+    }
+    return fromId;
+  }
+  if (fromUrl !== null) {
+    return fromUrl;
+  }
+  throw invalidInput(
+    "Either 'id' or 'url' must be given.",
+    "Pass the numeric post id, or a link to the post's page on rule34.xxx."
+  );
+}
+function buildPostByIdXmlUrl(id, credentials) {
+  return `${API_URL}?page=dapi&s=post&q=index&id=${id}${credentialsQuery(credentials)}`;
+}
+function buildPostByIdJsonUrl(id, credentials) {
+  return `${API_URL}?page=dapi&s=post&q=index&id=${id}&json=1&fields=tag_info${credentialsQuery(credentials)}`;
+}
+function credentialsQuery(credentials) {
+  return `&api_key=${encodeURIComponent(credentials.apiKey)}&user_id=${encodeURIComponent(credentials.userId)}`;
+}
+function buildPostPageUrl(id) {
+  return `${SITE_URL}?page=post&s=view&id=${id}`;
+}
+function redactCredentials(url) {
+  return url.replace(/([?&]api_key=)[^&]*/gi, "$1REDACTED");
+}
+
+// src/rule34/http.ts
+var BACKOFF_BASE_MS = 2e3;
+var BACKOFF_FACTOR = 2;
+var BACKOFF_MAX_MS = 3e4;
+function backoffDelay(attempt, random = Math.random) {
+  const uncapped = BACKOFF_BASE_MS * BACKOFF_FACTOR ** attempt;
+  const capped = Math.min(BACKOFF_MAX_MS, uncapped);
+  return Math.round(capped * (0.5 + random() * 0.5));
+}
+async function fetchXml(url, deps) {
+  const { config, limiter, logger } = deps;
+  const doFetch = deps.fetchImpl ?? fetch;
+  const safeUrl = redactCredentials(url);
+  return await limiter.schedule(async () => {
+    let lastError;
+    let askedWaitMs = null;
+    for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
+      if (attempt > 0) {
+        const delay = Math.min(askedWaitMs ?? backoffDelay(attempt - 1), BACKOFF_MAX_MS);
+        askedWaitMs = null;
+        logger.info(`retry ${attempt}/${config.maxRetries} in ${delay}ms for ${safeUrl}`);
+        await sleep(delay);
+      }
+      let status;
+      let body;
+      let retryAfterMs = null;
+      try {
+        await limiter.beforeRequest();
+        const response = await doFetch(url, {
+          headers: {
+            "User-Agent": config.userAgent,
+            Accept: "application/xml,text/xml;q=0.9,*/*;q=0.8"
+          },
+          redirect: "follow",
+          signal: AbortSignal.timeout(config.timeoutMs)
+        });
+        status = response.status;
+        retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+        body = await response.text();
+      } catch (error) {
+        lastError = asTransportError(error, safeUrl);
+        logger.debug(`${lastError.code} for ${safeUrl}: ${lastError.message}`);
+        continue;
+      }
+      if (status === 429) {
+        limiter.penalize();
+        logger.info(`rate limited on ${safeUrl}, interval now ${limiter.currentIntervalMs}ms`);
+        askedWaitMs = retryAfterMs;
+        lastError = rateLimited(safeUrl, retryAfterMs ?? backoffDelay(attempt));
+        continue;
+      }
+      if (status === 404) {
+        throw notFound(safeUrl);
+      }
+      if (status >= 500) {
+        lastError = new Rule34Error("network_error", `rule34.xxx returned HTTP ${status}.`, {
+          url: safeUrl,
+          status
+        });
+        continue;
+      }
+      if (status >= 400) {
+        throw new Rule34Error("network_error", `rule34.xxx refused the request (HTTP ${status}).`, {
+          url: safeUrl,
+          status
+        });
+      }
+      limiter.relax();
+      return body;
+    }
+    throw lastError ?? new Rule34Error("network_error", `Could not fetch ${safeUrl}.`, {
+      url: safeUrl
+    });
+  });
+}
+function parseRetryAfter(raw) {
+  if (!raw) {
+    return null;
+  }
+  const seconds = Number(raw.trim());
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.round(seconds * 1e3);
+  }
+  const when = Date.parse(raw);
+  if (Number.isNaN(when)) {
+    return null;
+  }
+  return Math.max(0, when - Date.now());
+}
+function asTransportError(error, safeUrl) {
+  if (error instanceof Rule34Error) {
+    return error;
+  }
+  const name = error instanceof Error ? error.name : "";
+  if (name === "TimeoutError" || name === "AbortError") {
+    return new Rule34Error("timeout", "rule34.xxx did not answer in time.", {
+      url: safeUrl,
+      hint: "Raise RULE34_TIMEOUT_MS if this happens often on a slow connection."
+    });
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return new Rule34Error("network_error", `Could not reach rule34.xxx: ${message}`, {
+    url: safeUrl
+  });
+}
+
+// src/rule34/parsers/postDetail.ts
+var TYPES = {
+  tag: "general",
+  artist: "artist",
+  copyright: "copyright",
+  character: "character",
+  metadata: "metadata"
+};
+function parsePostDetail(body, url, id) {
+  const safeUrl = redactCredentials(url);
+  if (body.trim() === "") {
+    throw notFound(safeUrl);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw parseFailure(safeUrl, "the response is not JSON");
+  }
+  if (typeof parsed === "string") {
+    if (/authenticat/i.test(parsed)) {
+      throw missingCredentials(safeUrl);
+    }
+    throw upstreamFailure(safeUrl, parsed);
+  }
+  if (!Array.isArray(parsed)) {
+    throw parseFailure(safeUrl, "the response is not a list of posts");
+  }
+  const [raw] = parsed;
+  if (raw === void 0) {
+    throw notFound(safeUrl);
+  }
+  if (raw === null || typeof raw !== "object") {
+    throw parseFailure(safeUrl, "the first entry is not a post");
+  }
+  return readPost(raw, id);
+}
+function readPost(raw, askedFor) {
+  const id = readInteger(raw.id) ?? askedFor;
+  const tags = readString(raw.tags).split(/\s+/).filter((tag) => tag !== "");
+  return {
+    id,
+    postUrl: buildPostPageUrl(id),
+    fileUrl: readString(raw.file_url),
+    sampleUrl: readText(raw.sample_url),
+    previewUrl: readText(raw.preview_url),
+    width: readInteger(raw.width) ?? 0,
+    height: readInteger(raw.height) ?? 0,
+    md5: readString(raw.hash),
+    score: readInteger(raw.score) ?? 0,
+    rating: readString(raw.rating),
+    tags,
+    tagDetails: readTagDetails(raw.tag_info),
+    source: readText(raw.source),
+    // This route writes 0 where the XML writes an empty string, and 0 is a post
+    // id that belongs to somebody else.
+    parentId: nonZero(readInteger(raw.parent_id)),
+    owner: readText(raw.owner),
+    commentCount: readInteger(raw.comment_count),
+    status: readString(raw.status),
+    hasNotes: raw.has_notes === true,
+    changedAtUnix: readInteger(raw.change)
+  };
+}
+function readTagDetails(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    const info = entry ?? {};
+    const type = readString(info.type);
+    return {
+      name: readString(info.tag),
+      // A word this site has not documented is carried as it came: naming it
+      // something else would state a kind the site never wrote.
+      type: TYPES[type] ?? type,
+      postCount: readInteger(info.count) ?? 0
+    };
+  });
+}
+function nonZero(value) {
+  return value === null || value === 0 ? null : value;
+}
+function readString(value) {
+  return typeof value === "string" ? value : "";
+}
+function readText(value) {
+  const trimmed = readString(value).trim();
+  return trimmed === "" ? null : trimmed;
+}
+function readInteger(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  const trimmed = readString(value).trim();
+  if (trimmed === "") {
+    return null;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+// src/rule34/parsers/document.ts
+import { XMLParser } from "fast-xml-parser";
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  // Attribute values are converted one field at a time by each parser, so that
+  // an empty `parent_id` stays empty instead of becoming a number.
+  parseAttributeValue: false,
+  trimValues: true
+});
+function readDocument(xml, safeUrl) {
+  if (xml.trim() === "") {
+    throw parseFailure(safeUrl, "the response was empty");
+  }
+  let document;
+  try {
+    document = parser.parse(xml);
+  } catch (error) {
+    throw parseFailure(safeUrl, error instanceof Error ? error.message : "unreadable XML");
+  }
+  if (document === null || typeof document !== "object") {
+    throw parseFailure(safeUrl, "the response is not an XML document");
+  }
+  const parsed = document;
+  const failure = parsed.error;
+  if (failure !== void 0) {
+    const message = typeof failure === "string" ? failure : String(failure);
+    if (/authenticat/i.test(message)) {
+      throw missingCredentials(safeUrl);
+    }
+    throw upstreamFailure(safeUrl, message);
+  }
+  return parsed;
+}
+function toArray(value) {
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  return Array.isArray(value) ? value : [value];
+}
+function readText2(value) {
+  const trimmed = value?.trim() ?? "";
+  return trimmed === "" ? null : trimmed;
+}
+function readInteger2(value) {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed === "") {
+    return null;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+// src/rule34/parsers/posts.ts
+var RATINGS = {
+  e: "explicit",
+  q: "questionable",
+  s: "safe"
+};
+function parsePostList(xml, url) {
+  const safeUrl = redactCredentials(url);
+  const document = readDocument(xml, safeUrl);
+  const posts = document.posts;
+  if (posts === void 0 || posts === null || typeof posts !== "object") {
+    throw parseFailure(safeUrl, "no <posts> element");
+  }
+  const attributes = posts;
+  const total = readInteger2(attributes["@_count"]);
+  if (total === null) {
+    throw parseFailure(safeUrl, "the <posts> element carries no count");
+  }
+  return {
+    total,
+    offset: readInteger2(attributes["@_offset"]) ?? 0,
+    posts: toArray(attributes.post).map(readPost2)
+  };
+}
+function readPost2(attributes) {
+  const id = readInteger2(attributes["@_id"]) ?? 0;
+  const rating = attributes["@_rating"]?.trim() ?? "";
+  return {
+    id,
+    postUrl: buildPostPageUrl(id),
+    fileUrl: attributes["@_file_url"] ?? "",
+    sampleUrl: readText2(attributes["@_sample_url"]),
+    previewUrl: readText2(attributes["@_preview_url"]),
+    width: readInteger2(attributes["@_width"]) ?? 0,
+    height: readInteger2(attributes["@_height"]) ?? 0,
+    md5: attributes["@_md5"] ?? "",
+    score: readInteger2(attributes["@_score"]) ?? 0,
+    // An unknown letter is carried as it came: naming it would state a rating
+    // the site never wrote.
+    rating: RATINGS[rating] ?? rating,
+    tags: (attributes["@_tags"] ?? "").split(/\s+/).filter((tag) => tag !== ""),
+    source: readText2(attributes["@_source"]),
+    // The attribute is present and empty on a post with no parent, and 0 is a
+    // post id that belongs to somebody else.
+    parentId: readInteger2(attributes["@_parent_id"]),
+    creatorId: readInteger2(attributes["@_creator_id"]),
+    status: attributes["@_status"] ?? "",
+    hasChildren: attributes["@_has_children"] === "true",
+    hasComments: attributes["@_has_comments"] === "true",
+    hasNotes: attributes["@_has_notes"] === "true",
+    createdAt: readDate(attributes["@_created_at"]),
+    changedAtUnix: readInteger2(attributes["@_change"])
+  };
+}
+function readDate(value) {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed === "") {
+    return null;
+  }
+  const parsed = Date.parse(trimmed);
+  return Number.isNaN(parsed) ? null : new Date(parsed).toISOString();
+}
+
+// src/rule34/parsers/tags.ts
+var TYPES2 = {
+  0: "general",
+  1: "artist",
+  3: "copyright",
+  4: "character",
+  5: "metadata"
+};
+function parseTagList(xml, url) {
+  const safeUrl = redactCredentials(url);
+  const document = readDocument(xml, safeUrl);
+  const tags = document.tags;
+  if (tags !== void 0 && tags !== null && typeof tags === "object") {
+    return toArray(tags.tag).map(readTag);
+  }
+  const lone = document.tag;
+  if (lone !== void 0 && lone !== null && typeof lone === "object") {
+    const attributes = lone;
+    return attributes["@_name"] === void 0 ? [] : [readTag(attributes)];
+  }
+  throw parseFailure(safeUrl, "no <tags> element");
+}
+function readTag(attributes) {
+  const typeCode = readInteger2(attributes["@_type"]);
+  return {
+    id: readInteger2(attributes["@_id"]) ?? 0,
+    name: attributes["@_name"] ?? "",
+    postCount: readInteger2(attributes["@_count"]) ?? 0,
+    // A number this site has not documented is left unnamed: calling it
+    // something would state a kind the site never wrote.
+    type: (typeCode === null ? void 0 : TYPES2[typeCode]) ?? "unknown",
+    typeCode,
+    ambiguous: attributes["@_ambiguous"] === "true"
+  };
+}
+
+// src/rule34/client.ts
+var Rule34Client = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.limiter = new RateLimiter({ minIntervalMs: deps.config.minIntervalMs });
+    this.cache = new TtlLruCache(deps.config.cacheMaxEntries, deps.config.cacheTtlMs);
+  }
+  deps;
+  limiter;
+  cache;
+  /** The addresses currently held, for a diagnostic to look at. */
+  cacheKeys() {
+    return this.cache.keys();
+  }
+  async searchPosts(search) {
+    const url = buildPostSearchUrl(search, this.credentials());
+    const { body, cached } = await this.read(url);
+    return { data: parsePostList(body, url), cached };
+  }
+  /**
+   * One post, read from both formats the API publishes.
+   *
+   * Neither format carries everything: the publication date and the uploader's
+   * numeric id come from the XML, and the uploader's name, the comment count
+   * and the tag types come from the JSON. Reading one of them would leave out
+   * what the other holds, so a fiche costs two reads of the site.
+   */
+  async getPost(ref) {
+    const credentials = this.credentials();
+    const id = resolvePostRef(ref);
+    const jsonUrl = buildPostByIdJsonUrl(id, credentials);
+    const json = await this.read(jsonUrl);
+    const detail = parsePostDetail(json.body, jsonUrl, id);
+    const xmlUrl = buildPostByIdXmlUrl(id, credentials);
+    const xml = await this.read(xmlUrl);
+    const [fromXml] = parsePostList(xml.body, xmlUrl).posts;
+    return {
+      data: {
+        ...detail,
+        createdAt: fromXml?.createdAt ?? null,
+        creatorId: fromXml?.creatorId ?? null,
+        hasComments: fromXml?.hasComments ?? (detail.commentCount ?? 0) > 0,
+        hasChildren: fromXml?.hasChildren ?? false
+      },
+      cached: json.cached && xml.cached
+    };
+  }
+  /** The tag under this exact name, or nothing when the site holds no such tag. */
+  async lookupTag(name) {
+    const url = buildTagLookupUrl(name, this.credentials());
+    const { body, cached } = await this.read(url);
+    const [tag] = parseTagList(body, url);
+    return { data: tag ?? null, cached };
+  }
+  /**
+   * Which of these names the site does not hold as a tag.
+   *
+   * A search of several tags that finds nothing says nothing about which tag
+   * emptied it, and a misspelled name is indistinguishable from a combination
+   * the site genuinely has nothing for. Each distinct name costs one request,
+   * which is why this is worth spending only once a search has come back empty.
+   */
+  async findUnknownTags(names) {
+    const distinct = [...new Set(names.map(normalizeTag))];
+    const unknown = [];
+    for (const name of distinct) {
+      const { data } = await this.lookupTag(name);
+      if (data === null) {
+        unknown.push(name);
+      }
+    }
+    return unknown;
+  }
+  credentials() {
+    const credentials = this.deps.config.credentials;
+    if (!credentials) {
+      throw invalidInput(
+        "This server has no rule34.xxx API credentials, so it cannot ask the site anything.",
+        "Set RULE34_USER_ID and RULE34_API_KEY in the env block of this server's entry in your MCP client configuration. Both are shown under 'API Access Credentials' at https://rule34.xxx/index.php?page=account&s=options once you are signed in. The site issues one key per person, so use your own rather than sharing one."
+      );
+    }
+    return credentials;
+  }
+  /**
+   * Fetch one address, remembering the answer under it.
+   *
+   * The key is the address without the key in it: two searches differ by their
+   * query and never by their credentials, and holding the secret in a second
+   * place buys nothing.
+   */
+  async read(url) {
+    const key = redactCredentials(url);
+    const remembered = this.cache.get(key);
+    if (remembered !== void 0) {
+      this.deps.logger.debug(`cache hit for ${key}`);
+      return { body: remembered, cached: true };
+    }
+    const body = await fetchXml(url, {
+      config: this.deps.config,
+      limiter: this.limiter,
+      logger: this.deps.logger,
+      fetchImpl: this.deps.fetchImpl
+    });
+    this.cache.set(key, body);
+    return { body, cached: false };
+  }
+};
+
+// src/tools/getPost.ts
+import { z as z3 } from "zod";
+
+// src/tools/arguments.ts
+import { z } from "zod";
+var INVALID_INPUT = "invalid_input";
+var CODE = `[${INVALID_INPUT}]`;
+function choice(argument, options, what) {
+  const error = `${CODE} ${argument} takes one of ${options.join(", ")}. ${what}`;
+  return z.enum(options, { error });
+}
+function wholeNumber(argument, min, max) {
+  const error = `${CODE} ${argument} takes a whole number from ${min} to ${max}.`;
+  return z.number({ error }).int(error).min(min, error).max(max, error);
+}
+function tagName(argument, most) {
+  const error = `${CODE} ${argument} takes a tag name, at most ${most} characters. Written empty it narrows nothing.`;
+  return z.string({ error }).trim().min(1, error).max(most, error);
+}
+function tagNames(argument, least, most) {
+  const error = `${CODE} ${argument} takes between ${least} and ${most} tag names.`;
+  return z.array(tagName(argument, 120), { error }).min(least, error).max(most, error);
+}
+function strictInput(shape) {
+  const declared = Object.keys(shape);
+  return z.strictObject(shape, {
+    error: (issue) => issue.code === "unrecognized_keys" ? unknownArgumentMessage(issue.keys, declared) : void 0
+  });
+}
+function unknownArgumentMessage(keys, declared) {
+  const named = keys.map((key) => {
+    const near = nearestArgument(key, declared);
+    return near ? `'${key}' (did you mean '${near}'?)` : `'${key}'`;
+  }).join(", ");
+  return `[${INVALID_INPUT}] Unknown ${keys.length > 1 ? "arguments" : "argument"} ${named}. This tool takes: ${declared.join(", ")}.`;
+}
+function nearestArgument(key, declared) {
+  const flatten = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const flat = flatten(key);
+  if (flat.length === 0) {
+    return void 0;
+  }
+  const sameName = declared.find((name) => flatten(name) === flat);
+  if (sameName) {
+    return sameName;
+  }
+  const overlapping = declared.find((name) => {
+    const other = flatten(name);
+    const [shorter, longer] = other.length < flat.length ? [other, flat] : [flat, other];
+    return shorter.length >= 3 && (longer.startsWith(shorter) || longer.endsWith(shorter));
+  });
+  if (overlapping) {
+    return overlapping;
+  }
+  let closest;
+  let shortest = Number.POSITIVE_INFINITY;
+  for (const name of declared) {
+    const distance = editDistance(flat, flatten(name));
+    if (distance < shortest) {
+      shortest = distance;
+      closest = name;
+    }
+  }
+  return shortest <= Math.max(1, Math.floor(flat.length / 3)) ? closest : void 0;
+}
+function editDistance(left, right) {
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  let distance = right.length;
+  for (let row = 1; row <= left.length; row += 1) {
+    const current = [row];
+    let diagonal = row - 1;
+    let leftward = row;
+    for (const [column, above] of previous.entries()) {
+      if (column === 0) {
+        continue;
+      }
+      const substitution = diagonal + (left[row - 1] === right[column - 1] ? 0 : 1);
+      const cell = Math.min(substitution, above + 1, leftward + 1);
+      current.push(cell);
+      diagonal = above;
+      leftward = cell;
+    }
+    previous = current;
+    distance = leftward;
+  }
+  return distance;
+}
+
+// src/tools/shared.ts
+import { z as z2 } from "zod";
+var MAX_TEXT_MIRROR_CHARS = 2e3;
+var MAX_PAGE = 200;
+var TAG_PREVIEW = 12;
+var postSchema = z2.object({
+  id: z2.number().int(),
+  post_url: z2.string().describe("The rule34.xxx page for this post."),
+  file_url: z2.string().describe("The image or video itself, on the site's CDN."),
+  preview_url: z2.string().nullable().describe("Thumbnail, when the site published one."),
+  sample_url: z2.string().nullable().describe("Reduced copy, when the site published one."),
+  width: z2.number().int(),
+  height: z2.number().int(),
+  score: z2.number().int().describe("The site's own score, updated once a day."),
+  rating: z2.string().describe("As the site holds it: 'explicit' or 'questionable'."),
+  tags: z2.array(z2.string()).describe("The first tags of the post, at most 12 of them."),
+  tags_total: z2.number().int().describe("How many tags the post carries in all."),
+  source: z2.string().nullable().describe("Whatever the uploader credited, when they credited any."),
+  created_at: z2.string().nullable().describe("When the post was published, ISO 8601."),
+  has_comments: z2.boolean(),
+  parent_id: z2.number().int().nullable()
+});
+function toPostOut(post) {
+  return {
+    id: post.id,
+    post_url: post.postUrl,
+    file_url: post.fileUrl,
+    preview_url: post.previewUrl,
+    sample_url: post.sampleUrl,
+    width: post.width,
+    height: post.height,
+    score: post.score,
+    rating: post.rating,
+    tags: post.tags.slice(0, TAG_PREVIEW),
+    tags_total: post.tags.length,
+    source: post.source,
+    created_at: post.createdAt,
+    has_comments: post.hasComments,
+    parent_id: post.parentId
+  };
+}
+function indentMarkerLines(body) {
+  return body.replace(/^(Note:)/gm, " $1");
+}
+function ok(structured, text, notes = []) {
+  const trailer = notes.map((note) => `Note: ${note}`).join("\n");
+  const budget = MAX_TEXT_MIRROR_CHARS - (trailer ? trailer.length + 2 : 0);
+  const body = truncate(indentMarkerLines(text), Math.max(0, budget));
+  return {
+    content: [{ type: "text", text: trailer ? `${body}
+
+${trailer}` : body }],
+    structuredContent: structured
+  };
+}
+function toToolError(error) {
+  const known = error instanceof Rule34Error ? error : new Rule34Error("network_error", error instanceof Error ? error.message : String(error));
+  const lines = [known.message];
+  if (known.details.hint) {
+    lines.push(`Hint: ${known.details.hint}`);
+  }
+  if (known.details.url) {
+    lines.push(`URL: ${known.details.url}`);
+  }
+  return { content: [{ type: "text", text: lines.join("\n") }], isError: true };
+}
+function truncate(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, maxChars - 1).trimEnd()}\u2026`;
+}
+function renderPostList(posts) {
+  return posts.map((post, index) => {
+    const head = `${index + 1}. #${post.id} \xB7 ${post.width}\xD7${post.height} \xB7 score ${post.score} \xB7 ${post.rating}`;
+    return `${head}
+   ${post.post_url}
+   ${post.file_url}`;
+  }).join("\n");
+}
+
+// src/tools/getPost.ts
+var getPostDescription = [
+  "Read one rule34.xxx post, named by its id or by a link to its page.",
+  "Returns every tag the post carries, each with its kind (character, copyright, artist, general or",
+  "metadata) and how many posts share it, alongside the image or video, the dimensions, the score,",
+  "the rating, the uploader, the number of comments, the credited source and the publication date.",
+  "Use this after a search, whose rows show only the first few tags of each post."
+].join(" ");
+var getPostInput = strictInput({
+  id: wholeNumber("id", 1, Number.MAX_SAFE_INTEGER).optional().describe("The post's numeric id, as a search returns it."),
+  url: z3.string().max(500).optional().describe(
+    "A link to the post's page, such as https://rule34.xxx/index.php?page=post&s=view&id=2195419. The link is read rather than followed."
+  )
+});
+var getPostOutputShape = {
+  id: z3.number().int(),
+  post_url: z3.string(),
+  file_url: z3.string(),
+  preview_url: z3.string().nullable(),
+  sample_url: z3.string().nullable(),
+  width: z3.number().int(),
+  height: z3.number().int(),
+  md5: z3.string(),
+  score: z3.number().int().describe("The site's own score, updated once a day."),
+  rating: z3.string(),
+  tags: z3.array(
+    z3.object({
+      name: z3.string(),
+      type: z3.string().describe("character, copyright, artist, general or metadata."),
+      post_count: z3.number().int().describe("Posts the site credits to this tag.")
+    })
+  ),
+  source: z3.string().nullable(),
+  parent_id: z3.number().int().nullable(),
+  owner: z3.string().nullable().describe("The account that uploaded the post."),
+  comment_count: z3.number().int().nullable(),
+  created_at: z3.string().nullable().describe("When the post was published, ISO 8601."),
+  changed_at: z3.string().nullable().describe("When the post last changed, ISO 8601."),
+  status: z3.string(),
+  has_notes: z3.boolean(),
+  source_site: z3.literal("rule34.xxx"),
+  notes: z3.array(z3.string())
+};
+async function runGetPost(client, args) {
+  try {
+    const { data, cached } = await client.getPost(args);
+    const notes = cached ? ["Served from this server's short-lived in-memory cache."] : [];
+    const structured = {
+      id: data.id,
+      post_url: data.postUrl,
+      file_url: data.fileUrl,
+      preview_url: data.previewUrl,
+      sample_url: data.sampleUrl,
+      width: data.width,
+      height: data.height,
+      md5: data.md5,
+      score: data.score,
+      rating: data.rating,
+      tags: data.tagDetails.map((tag) => ({
+        name: tag.name,
+        type: tag.type,
+        post_count: tag.postCount
+      })),
+      source: data.source,
+      parent_id: data.parentId,
+      owner: data.owner,
+      comment_count: data.commentCount,
+      created_at: data.createdAt ?? null,
+      changed_at: toIso(data.changedAtUnix),
+      status: data.status,
+      has_notes: data.hasNotes,
+      source_site: "rule34.xxx",
+      notes
+    };
+    return ok(structured, render(structured), notes);
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+function toIso(unixSeconds) {
+  return unixSeconds === null ? null : new Date(unixSeconds * 1e3).toISOString();
+}
+var NAMED_FIRST = ["character", "copyright", "artist"];
+function render(post) {
+  const lines = [
+    `Post #${post.id} \xB7 ${post.width}\xD7${post.height} \xB7 score ${post.score} \xB7 ${post.rating}`,
+    `  ${post.post_url}`,
+    `  ${post.file_url}`
+  ];
+  const posted = post.created_at ? post.created_at.slice(0, 10) : "an unstated date";
+  lines.push(`  posted ${posted}${post.owner ? ` by ${post.owner}` : ""}`);
+  if (post.comment_count !== null) {
+    lines.push(`  ${post.comment_count} comment(s)`);
+  }
+  for (const kind of NAMED_FIRST) {
+    const named = post.tags.filter((tag) => tag.type === kind).map((tag) => tag.name);
+    if (named.length > 0) {
+      lines.push(`  ${kind}: ${named.join(", ")}`);
+    }
+  }
+  const rest = post.tags.filter((tag) => !NAMED_FIRST.includes(tag.type)).map((tag) => tag.name);
+  lines.push(`  ${post.tags.length} tag(s): ${rest.join(" ")}`);
+  return lines.join("\n");
+}
+
+// src/tools/searchPosts.ts
+import { z as z4 } from "zod";
+var searchPostsDescription = [
+  "Search rule34.xxx for posts carrying a tag, or several tags at once.",
+  "Tags are written as one token, so a name said as words is joined by underscores:",
+  "'asuka langley sohryu' and 'ranma 1/2' are single tags, and this tool joins them for you.",
+  "Returns each post's page, its image or video URL, dimensions, score and rating, alongside the",
+  `number of posts the whole search matches. A row shows the first ${TAG_PREVIEW} of a post's tags and`,
+  "says how many it has; call get_post for the whole list with a kind for every tag.",
+  "Use 'media_type' to ask for still images, animations or video; the site classifies these itself.",
+  "When a search finds nothing, the answer names the tags rule34.xxx does not hold, or says how many",
+  "posts the tags match once the restrictions are dropped."
+].join(" ");
+var searchPostsInput = strictInput({
+  tags: tagNames("tags", 1, MAX_TAGS).describe(
+    "Tags a post must all carry, such as ['asuka langley sohryu', 'black hair']."
+  ),
+  any_of: tagNames("any_of", 1, MAX_TAGS).optional().describe("Tags a post must carry at least one of."),
+  exclude: tagNames("exclude", 1, MAX_TAGS).optional().describe("Tags a post must not carry, such as ['monochrome'] to leave out black and white."),
+  media_type: choice(
+    "media_type",
+    ["image", "animated", "video", "any"],
+    "The site states this in its own tags."
+  ).default("any").describe(
+    "'image' for stills, 'animated' for GIFs, 'video' for MP4. The site states this in its own tags, so the classification is as good as the tagging."
+  ),
+  rating: choice(
+    "rating",
+    ["questionable", "explicit"],
+    "These are the two ratings rule34.xxx holds; any other answers zero posts and no error, which would hand back an absence the site never had."
+  ).optional().describe("The two ratings rule34.xxx holds. Leave unset to search both."),
+  sort: choice("sort", ["score", "id", "updated", "random"], "The order the site sorts by.").default("score").describe("'score' is the site's own, updated once a day. 'id' is newest first."),
+  limit: wholeNumber("limit", 1, 100).default(20),
+  page: wholeNumber("page", 1, MAX_PAGE).default(1)
+});
+var searchPostsOutputShape = {
+  tags: z4.array(z4.string()).describe("The required tags, as rule34.xxx spells them."),
+  any_of: z4.array(z4.string()).describe("The alternatives, as rule34.xxx spells them."),
+  exclude: z4.array(z4.string()).describe("The excluded tags, as rule34.xxx spells them."),
+  query: z4.string().describe("The search as it was sent, in the site's own language."),
+  total: z4.number().int().describe("Posts the whole search matches, as counted by the site."),
+  page: z4.number().int(),
+  posts: z4.array(postSchema),
+  has_more: z4.boolean(),
+  next_page: z4.number().int().nullable(),
+  source: z4.literal("rule34.xxx"),
+  notes: z4.array(z4.string())
+};
+function toSearch(args) {
+  return {
+    tags: args.tags,
+    anyOf: args.any_of,
+    exclude: args.exclude,
+    mediaType: args.media_type,
+    rating: args.rating,
+    sort: args.sort,
+    limit: args.limit,
+    page: args.page
+  };
+}
+function whatFollowsThisPage(hasMore, page) {
+  if (!hasMore) {
+    return "";
+  }
+  if (page < MAX_PAGE) {
+    return `
+
+More posts match: call again with page=${page + 1}.`;
+  }
+  return `
+
+rule34.xxx holds more, and page ${MAX_PAGE} is as far as this tool reads. Narrow the search instead.`;
+}
+var quoted = (tags) => tags.map((tag) => `'${tag}'`).join(", ");
+function restrictionsIn(args) {
+  const named = [];
+  if ((args.any_of ?? []).length > 0) {
+    named.push("any_of");
+  }
+  if ((args.exclude ?? []).length > 0) {
+    named.push("exclude");
+  }
+  if (args.media_type !== "any") {
+    named.push("media_type");
+  }
+  if (args.rating) {
+    named.push("rating");
+  }
+  return named;
+}
+async function explainEmptySearch(client, args) {
+  const alternatives = args.any_of ?? [];
+  const unknownRequired = await client.findUnknownTags(args.tags);
+  const unknownAlternatives = alternatives.length > 0 ? await client.findUnknownTags(alternatives) : [];
+  if (unknownRequired.length > 0) {
+    return [
+      `rule34.xxx holds no tag named ${quoted(unknownRequired)}. A tag a search requires and the site does not hold empties that search on its own.`
+    ];
+  }
+  if (alternatives.length > 0 && unknownAlternatives.length === alternatives.length) {
+    return [
+      `rule34.xxx holds none of the alternatives ${quoted(unknownAlternatives)}, so no post could carry one of them.`
+    ];
+  }
+  const restrictions = restrictionsIn(args);
+  if (restrictions.length > 0) {
+    const { data } = await client.searchPosts({ tags: args.tags, limit: 1, page: 1 });
+    if (data.total > 0) {
+      return [
+        `The tags alone match ${data.total.toLocaleString("en-US")} post(s). What emptied this search is the restriction on ${restrictions.join(", ")}.`
+      ];
+    }
+  }
+  return ["Every tag this search requires exists on rule34.xxx; no post carries them together."];
+}
+async function runSearchPosts(client, args) {
+  try {
+    const search = toSearch(args);
+    const spelled = normalizeSearch(search);
+    const query = buildSearchQuery(search);
+    const { data, cached } = await client.searchPosts(search);
+    const notes = [];
+    if (cached) {
+      notes.push("Served from this server's short-lived in-memory cache.");
+    }
+    const posts = data.posts.map(toPostOut);
+    const trimmed = posts.filter((post) => post.tags_total > post.tags.length).length;
+    if (trimmed > 0) {
+      notes.push(
+        `${trimmed} of these posts carry more tags than a row shows. Call get_post with an id for the whole list, with a kind and a post count for every tag.`
+      );
+    }
+    const hasMore = args.page * args.limit < data.total;
+    if (data.total === 0) {
+      notes.push(...await explainEmptySearch(client, args));
+    }
+    const structured = {
+      tags: spelled.required,
+      any_of: spelled.alternatives,
+      exclude: spelled.excluded,
+      query,
+      total: data.total,
+      page: args.page,
+      posts,
+      has_more: hasMore,
+      next_page: hasMore && args.page < MAX_PAGE ? args.page + 1 : null,
+      source: "rule34.xxx",
+      notes
+    };
+    const header = data.total === 0 ? `No post on rule34.xxx matches ${query}.` : `${data.total.toLocaleString("en-US")} post(s) match ${query}. Page ${args.page}:`;
+    const body = posts.length > 0 ? `
+${renderPostList(posts)}` : "";
+    return ok(structured, `${header}${body}${whatFollowsThisPage(hasMore, args.page)}`, notes);
+  } catch (error) {
+    return toToolError(error);
+  }
+}
+
+// src/server.ts
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
+function createServer(options = {}) {
+  const config = options.config ?? loadConfig();
+  const logger = options.logger ?? createLogger(config.logLevel);
+  const client = new Rule34Client({
+    config,
+    logger,
+    ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
+  });
+  const server = new McpServer(
+    { name: "mcp-rule34", version: PKG_VERSION },
+    {
+      instructions: "Tools for searching rule34.xxx by tag, through the site's own API. This server reads and never contributes anything back. It needs credentials: set RULE34_USER_ID and RULE34_API_KEY, both shown under 'API Access Credentials' at https://rule34.xxx/index.php?page=account&s=options once signed in, and note that the site issues one key per person. Tags are single tokens: a name said as words, such as 'asuka langley sohryu', is one tag, and the tools join it for you. The site holds two ratings, 'questionable' and 'explicit'; asking for anything else is refused rather than answered with nothing. Typical flow: search_posts to find posts by tag, then get_post with an id for one post's whole tag list, since a search row shows only its first few tags. A 'rate_limited' error means the site is refusing this client for now, not that a search found nothing. When you show a post to a user, link its rule34.xxx page."
+    }
+  );
+  server.registerTool(
+    "search_posts",
+    {
+      title: "Search posts by tag",
+      description: searchPostsDescription,
+      inputSchema: searchPostsInput,
+      outputSchema: z5.object(searchPostsOutputShape),
+      annotations: READ_ONLY
+    },
+    async (args) => runSearchPosts(client, args)
+  );
+  server.registerTool(
+    "get_post",
+    {
+      title: "Read one post",
+      description: getPostDescription,
+      inputSchema: getPostInput,
+      outputSchema: z5.object(getPostOutputShape),
+      annotations: READ_ONLY
+    },
+    async (args) => runGetPost(client, args)
+  );
+  logger.info(
+    `ready: user-agent="${config.userAgent}", min interval ${config.minIntervalMs}ms, cache ${config.cacheTtlMs}ms, credentials ${config.credentials ? "set" : "missing"}`
+  );
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const config = loadConfig();
+  const logger = createLogger(config.logLevel);
+  const server = createServer({ config, logger });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  const shutdown = () => {
+    void server.close().finally(() => process.exit(0));
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((error) => {
+  process.stderr.write(
+    `[mcp-rule34] fatal: ${error instanceof Error ? error.stack ?? error.message : String(error)}
+`
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map