@ashdev/codex-plugin-release-mangaupdates 1.18.0

package/dist/index.js

@@ -0,0 +1,1127 @@
+#!/usr/bin/env node
+
+// ../sdk-typescript/dist/types/rpc.js
+var JSON_RPC_ERROR_CODES = {
+  /** Invalid JSON was received */
+  PARSE_ERROR: -32700,
+  /** The JSON sent is not a valid Request object */
+  INVALID_REQUEST: -32600,
+  /** The method does not exist / is not available */
+  METHOD_NOT_FOUND: -32601,
+  /** Invalid method parameter(s) */
+  INVALID_PARAMS: -32602,
+  /** Internal JSON-RPC error */
+  INTERNAL_ERROR: -32603
+};
+
+// ../sdk-typescript/dist/errors.js
+var PluginError = class extends Error {
+  data;
+  constructor(message, data) {
+    super(message);
+    this.name = this.constructor.name;
+    this.data = data;
+  }
+  /**
+   * Convert to JSON-RPC error format
+   */
+  toJsonRpcError() {
+    return {
+      code: this.code,
+      message: this.message,
+      data: this.data
+    };
+  }
+};
+
+// ../sdk-typescript/dist/request-context.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var store = new AsyncLocalStorage();
+function runWithParentRequestId(forwardRequestId, fn) {
+  return store.run(forwardRequestId, fn);
+}
+function currentParentRequestId() {
+  return store.getStore();
+}
+
+// ../sdk-typescript/dist/host-rpc.js
+var HostRpcError = class extends Error {
+  code;
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "HostRpcError";
+  }
+};
+var HostRpcClient = class {
+  // Start the counter high so it can't collide with PluginStorage's id space.
+  // `Number.MAX_SAFE_INTEGER` is far above this, so we have plenty of room
+  // before wrapping (and we never expect a single plugin lifetime to issue
+  // more than ~9 quintillion calls).
+  nextId = 1e9;
+  pendingRequests = /* @__PURE__ */ new Map();
+  writeFn;
+  /**
+   * @param writeFn - Optional custom write function (defaults to
+   *   `process.stdout.write`). Useful for testing.
+   */
+  constructor(writeFn) {
+    this.writeFn = writeFn ?? ((line) => {
+      process.stdout.write(line);
+    });
+  }
+  /**
+   * Send a JSON-RPC request to the host and resolve with the result.
+   *
+   * @param method - JSON-RPC method name (e.g. `"releases/list_tracked"`).
+   * @param params - Method-specific params. Pass `undefined` when the method
+   *   takes no params.
+   */
+  async call(method, params) {
+    const id = this.nextId++;
+    const parent = currentParentRequestId();
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params,
+      ...parent !== void 0 ? { parentRequestId: parent } : {}
+    };
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, {
+        resolve: (v) => resolve(v),
+        reject
+      });
+      try {
+        this.writeFn(`${JSON.stringify(request)}
+`);
+      } catch (err) {
+        this.pendingRequests.delete(id);
+        const message = err instanceof Error ? err.message : "Unknown write error";
+        reject(new HostRpcError(`Failed to send request: ${message}`, -1));
+      }
+    });
+  }
+  /**
+   * Process an incoming JSON-RPC response line. Returns `true` if this
+   * client owned the response id and resolved it, `false` otherwise (so
+   * other clients can try).
+   *
+   * Called by the plugin server's main loop on every response.
+   */
+  handleResponse(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return false;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return false;
+    }
+    const obj = parsed;
+    if (obj.method !== void 0)
+      return false;
+    const rawId = obj.id;
+    if (typeof rawId !== "number")
+      return false;
+    if (!this.pendingRequests.has(rawId))
+      return false;
+    const pending = this.pendingRequests.get(rawId);
+    if (!pending)
+      return false;
+    this.pendingRequests.delete(rawId);
+    if ("error" in obj && obj.error) {
+      const err = obj.error;
+      pending.reject(new HostRpcError(err.message, err.code, err.data));
+    } else {
+      pending.resolve(obj.result);
+    }
+    return true;
+  }
+  /** Reject all pending requests (e.g. on shutdown). */
+  cancelAll() {
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(new HostRpcError("Host RPC client stopped", -1));
+    }
+    this.pendingRequests.clear();
+  }
+};
+
+// ../sdk-typescript/dist/logger.js
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  name;
+  minLevel;
+  timestamps;
+  constructor(options) {
+    this.name = options.name;
+    this.minLevel = LOG_LEVELS[options.level ?? "info"];
+    this.timestamps = options.timestamps ?? true;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= this.minLevel;
+  }
+  format(level, message, data) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    parts.push(`[${level.toUpperCase()}]`);
+    parts.push(`[${this.name}]`);
+    parts.push(message);
+    if (data !== void 0) {
+      if (data instanceof Error) {
+        parts.push(`- ${data.message}`);
+        if (data.stack) {
+          parts.push(`
+${data.stack}`);
+        }
+      } else if (typeof data === "object") {
+        parts.push(`- ${JSON.stringify(data)}`);
+      } else {
+        parts.push(`- ${String(data)}`);
+      }
+    }
+    return parts.join(" ");
+  }
+  log(level, message, data) {
+    if (this.shouldLog(level)) {
+      process.stderr.write(`${this.format(level, message, data)}
+`);
+    }
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+};
+function createLogger(options) {
+  return new Logger(options);
+}
+
+// ../sdk-typescript/dist/server.js
+import { createInterface } from "node:readline";
+
+// ../sdk-typescript/dist/storage.js
+var StorageError = class extends Error {
+  code;
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "StorageError";
+  }
+};
+var PluginStorage = class {
+  nextId = 1;
+  pendingRequests = /* @__PURE__ */ new Map();
+  writeFn;
+  /**
+   * Create a new storage client.
+   *
+   * @param writeFn - Optional custom write function (defaults to process.stdout.write).
+   *                  Useful for testing or custom transport layers.
+   */
+  constructor(writeFn) {
+    this.writeFn = writeFn ?? ((line) => {
+      process.stdout.write(line);
+    });
+  }
+  /**
+   * Get a value by key
+   *
+   * @param key - Storage key to retrieve
+   * @returns The stored data and optional expiration, or null data if key doesn't exist
+   */
+  async get(key) {
+    return await this.sendRequest("storage/get", { key });
+  }
+  /**
+   * Set a value by key (upsert - creates or updates)
+   *
+   * @param key - Storage key
+   * @param data - JSON-serializable data to store
+   * @param expiresAt - Optional expiration timestamp (ISO 8601)
+   * @returns Success indicator
+   */
+  async set(key, data, expiresAt) {
+    const params = { key, data };
+    if (expiresAt !== void 0) {
+      params.expiresAt = expiresAt;
+    }
+    return await this.sendRequest("storage/set", params);
+  }
+  /**
+   * Delete a value by key
+   *
+   * @param key - Storage key to delete
+   * @returns Whether the key existed and was deleted
+   */
+  async delete(key) {
+    return await this.sendRequest("storage/delete", { key });
+  }
+  /**
+   * List all keys for this plugin instance (excluding expired)
+   *
+   * @returns List of key entries with metadata
+   */
+  async list() {
+    return await this.sendRequest("storage/list", {});
+  }
+  /**
+   * Clear all data for this plugin instance
+   *
+   * @returns Number of entries deleted
+   */
+  async clear() {
+    return await this.sendRequest("storage/clear", {});
+  }
+  /**
+   * Handle an incoming JSON-RPC response line from the host.
+   *
+   * Call this method from your readline handler to deliver responses
+   * back to pending storage requests.
+   */
+  handleResponse(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    const obj = parsed;
+    if (obj.method !== void 0) {
+      return;
+    }
+    const id = obj.id;
+    if (id === void 0 || id === null)
+      return;
+    const pending = this.pendingRequests.get(id);
+    if (!pending)
+      return;
+    this.pendingRequests.delete(id);
+    if ("error" in obj && obj.error) {
+      const err = obj.error;
+      pending.reject(new StorageError(err.message, err.code, err.data));
+    } else {
+      pending.resolve(obj.result);
+    }
+  }
+  /**
+   * Cancel all pending requests (e.g. on shutdown).
+   */
+  cancelAll() {
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(new StorageError("Storage client stopped", -1));
+    }
+    this.pendingRequests.clear();
+  }
+  // ===========================================================================
+  // Internal
+  // ===========================================================================
+  sendRequest(method, params) {
+    const id = this.nextId++;
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      try {
+        this.writeFn(`${JSON.stringify(request)}
+`);
+      } catch (err) {
+        this.pendingRequests.delete(id);
+        const message = err instanceof Error ? err.message : "Unknown write error";
+        reject(new StorageError(`Failed to send request: ${message}`, -1));
+      }
+    });
+  }
+};
+
+// ../sdk-typescript/dist/server.js
+function validateStringFields(params, fields) {
+  if (params === null || params === void 0) {
+    return { field: "params", message: "params is required" };
+  }
+  if (typeof params !== "object") {
+    return { field: "params", message: "params must be an object" };
+  }
+  const obj = params;
+  for (const field of fields) {
+    const value = obj[field];
+    if (value === void 0 || value === null) {
+      return { field, message: `${field} is required` };
+    }
+    if (typeof value !== "string") {
+      return { field, message: `${field} must be a string` };
+    }
+    if (value.trim() === "") {
+      return { field, message: `${field} cannot be empty` };
+    }
+  }
+  return null;
+}
+function invalidParamsError(id, error) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+      message: `Invalid params: ${error.message}`,
+      data: { field: error.field }
+    }
+  };
+}
+function createPluginServer(options) {
+  const { manifest: manifest2, onInitialize, logLevel = "info", label, router } = options;
+  const logger2 = createLogger({ name: manifest2.name, level: logLevel });
+  const prefix = label ? `${label} plugin` : "plugin";
+  const storage = new PluginStorage();
+  const hostRpc = new HostRpcClient();
+  logger2.info(`Starting ${prefix}: ${manifest2.displayName} v${manifest2.version}`);
+  const rl = createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+  rl.on("line", (line) => {
+    void handleLine(line, manifest2, onInitialize, router, logger2, storage, hostRpc);
+  });
+  rl.on("close", () => {
+    logger2.info("stdin closed, shutting down");
+    storage.cancelAll();
+    hostRpc.cancelAll();
+    process.exit(0);
+  });
+  process.on("uncaughtException", (error) => {
+    logger2.error("Uncaught exception", error);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger2.error("Unhandled rejection", reason);
+  });
+}
+function isJsonRpcResponse(obj) {
+  if (obj.method !== void 0)
+    return false;
+  if (obj.id === void 0 || obj.id === null)
+    return false;
+  return "result" in obj || "error" in obj;
+}
+async function handleLine(line, manifest2, onInitialize, router, logger2, storage, hostRpc) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+  }
+  if (parsed && isJsonRpcResponse(parsed)) {
+    logger2.debug("Routing reverse-RPC response", { id: parsed.id });
+    if (!hostRpc.handleResponse(trimmed)) {
+      storage.handleResponse(trimmed);
+    }
+    return;
+  }
+  let id = null;
+  try {
+    const request = parsed ?? JSON.parse(trimmed);
+    id = request.id;
+    logger2.debug(`Received request: ${request.method}`, { id: request.id });
+    const response = await runWithParentRequestId(request.id, () => handleRequest(request, manifest2, onInitialize, router, logger2, storage, hostRpc));
+    if (response !== null) {
+      writeResponse(response);
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      writeResponse({
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
+          message: "Parse error: invalid JSON"
+        }
+      });
+    } else if (error instanceof PluginError) {
+      writeResponse({
+        jsonrpc: "2.0",
+        id,
+        error: error.toJsonRpcError()
+      });
+    } else {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger2.error("Request failed", error);
+      writeResponse({
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+          message
+        }
+      });
+    }
+  }
+}
+async function handleRequest(request, manifest2, onInitialize, router, logger2, storage, hostRpc) {
+  const { method, params, id } = request;
+  switch (method) {
+    case "initialize": {
+      const initParams = params ?? {};
+      initParams.storage = storage;
+      initParams.hostRpc = hostRpc;
+      if (onInitialize) {
+        await onInitialize(initParams);
+      }
+      return { jsonrpc: "2.0", id, result: manifest2 };
+    }
+    case "ping":
+      return { jsonrpc: "2.0", id, result: "pong" };
+    case "shutdown": {
+      logger2.info("Shutdown requested");
+      storage.cancelAll();
+      hostRpc.cancelAll();
+      const response2 = { jsonrpc: "2.0", id, result: null };
+      process.stdout.write(`${JSON.stringify(response2)}
+`, () => {
+        process.exit(0);
+      });
+      return null;
+    }
+  }
+  const response = await router(method, params, id);
+  if (response !== null) {
+    return response;
+  }
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+      message: `Method not found: ${method}`
+    }
+  };
+}
+function writeResponse(response) {
+  process.stdout.write(`${JSON.stringify(response)}
+`);
+}
+function success(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function validateReleasePollParams(params) {
+  return validateStringFields(params, ["sourceId"]);
+}
+function createReleaseSourcePlugin(options) {
+  const { manifest: manifest2, provider, onInitialize, logLevel } = options;
+  if (!manifest2.capabilities.releaseSource) {
+    throw new Error("manifest.capabilities.releaseSource is required for createReleaseSourcePlugin");
+  }
+  const router = async (method, params, id) => {
+    switch (method) {
+      case "releases/poll": {
+        const err = validateReleasePollParams(params);
+        if (err)
+          return invalidParamsError(id, err);
+        return success(id, await provider.poll(params));
+      }
+      default:
+        return null;
+    }
+  };
+  createPluginServer({ manifest: manifest2, onInitialize, logLevel, label: "release-source", router });
+}
+
+// ../sdk-typescript/dist/types/releases.js
+var RELEASES_METHODS = {
+  /** List tracked series, scoped to what the plugin's manifest declared. */
+  LIST_TRACKED: "releases/list_tracked",
+  /** Submit a candidate to the host's release ledger. */
+  RECORD: "releases/record",
+  /** Get persisted per-source state (etag, last_polled_at, last_error). */
+  SOURCE_STATE_GET: "releases/source_state/get",
+  /** Set persisted per-source state (etag only — other fields are host-owned). */
+  SOURCE_STATE_SET: "releases/source_state/set",
+  /**
+   * Replace the set of `release_sources` rows owned by this plugin.
+   *
+   * Plugins call this from `onInitialize` (and after any config change, which
+   * triggers a process restart that re-runs `onInitialize`). Each call carries
+   * the plugin's full desired-state list; the host upserts every entry on
+   * `(plugin_id, source_key)` and prunes rows whose `source_key` is not in
+   * the request. User-managed fields (`enabled`, `pollIntervalS`) are
+   * preserved across re-registrations so an admin's overrides aren't
+   * trampled by a plugin restart.
+   */
+  REGISTER_SOURCES: "releases/register_sources"
+};
+
+// src/fetcher.ts
+var MANGAUPDATES_RSS_BASE = "https://api.mangaupdates.com/v1/series";
+function normalizeMangaUpdatesId(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return null;
+  if (/^\d+$/.test(trimmed)) return trimmed;
+  if (!/^[0-9a-z]+$/i.test(trimmed)) return null;
+  const decoded = Number.parseInt(trimmed, 36);
+  if (!Number.isFinite(decoded) || decoded <= 0) return null;
+  return String(decoded);
+}
+function feedUrl(mangaUpdatesId) {
+  const normalized = normalizeMangaUpdatesId(mangaUpdatesId) ?? mangaUpdatesId;
+  return `${MANGAUPDATES_RSS_BASE}/${normalized}/rss`;
+}
+async function fetchSeriesFeed(mangaUpdatesId, previousEtag, opts = {}) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const timeoutMs = opts.timeoutMs ?? 1e4;
+  const url = feedUrl(mangaUpdatesId);
+  const headers = {
+    Accept: "application/rss+xml, application/xml;q=0.9, */*;q=0.5",
+    "User-Agent": "Codex-ReleaseTracker/1.0 (+https://github.com/AshDevFr/codex)"
+  };
+  if (previousEtag) {
+    headers["If-None-Match"] = previousEtag;
+  }
+  const signal = AbortSignal.timeout(timeoutMs);
+  let resp;
+  try {
+    resp = await fetchImpl(url, { method: "GET", headers, signal });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown fetch error";
+    return { kind: "error", status: 0, message: msg };
+  }
+  if (resp.status === 304) {
+    return { kind: "notModified", status: 304 };
+  }
+  if (resp.status === 200) {
+    const body = await resp.text();
+    const etag = resp.headers.get("etag");
+    return { kind: "ok", body, etag, status: 200 };
+  }
+  return {
+    kind: "error",
+    status: resp.status,
+    message: `upstream returned ${resp.status} ${resp.statusText}`
+  };
+}
+
+// src/parser.ts
+var UNKNOWN_LANGUAGE = "unknown";
+function decodeXmlText(raw) {
+  let s = raw.trim();
+  const cdataMatch = s.match(/^<!\[CDATA\[([\s\S]*?)]]>$/);
+  if (cdataMatch?.[1] !== void 0) {
+    s = cdataMatch[1];
+  }
+  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'");
+}
+function extractTagText(xml, tag) {
+  const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`, "i");
+  const m = xml.match(re);
+  if (!m?.[1]) return null;
+  return decodeXmlText(m[1]);
+}
+function splitItems(xml) {
+  const out = [];
+  const re = /<item\b[^>]*>([\s\S]*?)<\/item>/gi;
+  for (; ; ) {
+    const match = re.exec(xml);
+    if (match === null) break;
+    if (match[1] !== void 0) out.push(match[1]);
+  }
+  return out;
+}
+function parseTitle(title) {
+  const trimmed = title.trim();
+  let chapter = null;
+  const chMatch = trimmed.match(/\bc(?:h)?\.?\s*([0-9]+(?:\.[0-9]+)?)\b/i);
+  if (chMatch?.[1]) {
+    const n = Number.parseFloat(chMatch[1]);
+    if (Number.isFinite(n)) chapter = n;
+  }
+  let volume = null;
+  const volMatch = trimmed.match(/\bv(?:ol)?\.?\s*([0-9]+)\b/i);
+  if (volMatch?.[1]) {
+    const n = Number.parseInt(volMatch[1], 10);
+    if (Number.isFinite(n)) volume = n;
+  }
+  let group = null;
+  const groupMatch = trimmed.match(/\bby\s+(.+?)(?:\s*\([a-z]{2,3}\)\s*)?$/i);
+  if (groupMatch?.[1]) {
+    const candidate = groupMatch[1].trim();
+    if (candidate.length > 0) group = candidate;
+  }
+  let language = "en";
+  const langMatch = trimmed.match(/\(([a-z]{2,3})\)\s*$/i);
+  if (langMatch?.[1]) {
+    language = langMatch[1].toLowerCase();
+  }
+  return { chapter, volume, group, language };
+}
+function pubDateToIso(raw) {
+  if (raw) {
+    const d = new Date(raw);
+    if (!Number.isNaN(d.getTime())) return d.toISOString();
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function deriveExternalReleaseId(guid, link, title, pubDate) {
+  if (guid && guid.trim().length > 0) return guid.trim();
+  if (link && link.trim().length > 0) return link.trim();
+  const fallback = `${title}|${pubDate ?? ""}`;
+  let h = 5381;
+  for (let i = 0; i < fallback.length; i++) {
+    h = (h << 5) + h + fallback.charCodeAt(i) | 0;
+  }
+  return `t:${(h >>> 0).toString(36)}`;
+}
+function parseItem(itemXml) {
+  const title = extractTagText(itemXml, "title");
+  if (!title) return null;
+  const link = extractTagText(itemXml, "link");
+  const guid = extractTagText(itemXml, "guid");
+  const pubDate = extractTagText(itemXml, "pubDate");
+  const { chapter, volume, group, language } = parseTitle(title);
+  return {
+    externalReleaseId: deriveExternalReleaseId(guid, link, title, pubDate),
+    title,
+    chapter,
+    volume,
+    group,
+    language,
+    link: link ?? "",
+    observedAt: pubDateToIso(pubDate)
+  };
+}
+function parseFeed(xml) {
+  return splitItems(xml).map(parseItem).filter((i) => i !== null);
+}
+
+// src/filter.ts
+function resolveFilters(input) {
+  const languages = dedupePreserveOrder(
+    input.languages.map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0)
+  );
+  const blockedGroups = new Set(
+    input.blockedGroups.map((s) => s.trim().toLowerCase()).filter((s) => s.length > 0)
+  );
+  return {
+    languages,
+    blockedGroups,
+    includeUnknownLanguage: input.includeUnknownLanguage ?? false
+  };
+}
+function parseCommaList(raw) {
+  if (typeof raw !== "string") return [];
+  return raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function passesFilters(item, filters) {
+  if (item.language === UNKNOWN_LANGUAGE) {
+    if (!filters.includeUnknownLanguage) return false;
+  } else if (filters.languages.length > 0) {
+    if (!filters.languages.includes(item.language.toLowerCase())) return false;
+  }
+  if (item.group !== null && filters.blockedGroups.size > 0) {
+    if (filters.blockedGroups.has(item.group.trim().toLowerCase())) return false;
+  }
+  return true;
+}
+function dedupePreserveOrder(xs) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const x of xs) {
+    if (!seen.has(x)) {
+      seen.add(x);
+      out.push(x);
+    }
+  }
+  return out;
+}
+
+// package.json
+var package_default = {
+  name: "@ashdev/codex-plugin-release-mangaupdates",
+  version: "1.18.0",
+  description: "MangaUpdates RSS release-source plugin for Codex - announces new chapter releases for tracked series in user-configured languages",
+  main: "dist/index.js",
+  bin: "dist/index.js",
+  type: "module",
+  files: [
+    "dist",
+    "README.md"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/AshDevFr/codex.git",
+    directory: "plugins/release-mangaupdates"
+  },
+  scripts: {
+    build: "esbuild src/index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/index.js --sourcemap --banner:js='#!/usr/bin/env node'",
+    dev: "npm run build -- --watch",
+    clean: "rm -rf dist",
+    start: "node dist/index.js",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    typecheck: "tsc --noEmit",
+    test: "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    prepublishOnly: "npm run lint && npm run build"
+  },
+  keywords: [
+    "codex",
+    "plugin",
+    "mangaupdates",
+    "release-source",
+    "manga"
+  ],
+  author: "Codex",
+  license: "MIT",
+  engines: {
+    node: ">=22.0.0"
+  },
+  dependencies: {
+    "@ashdev/codex-plugin-sdk": "file:../sdk-typescript"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.4.4",
+    "@types/node": "^22.0.0",
+    esbuild: "^0.27.3",
+    typescript: "^5.9.3",
+    vitest: "^4.0.18"
+  }
+};
+
+// src/manifest.ts
+var EXTERNAL_ID_SOURCE_MANGAUPDATES = "mangaupdates";
+var manifest = {
+  name: "release-mangaupdates",
+  displayName: "MangaUpdates Releases",
+  version: package_default.version,
+  description: "Announces new chapter releases for tracked series via MangaUpdates per-series RSS feeds. Filters by user-configured languages.",
+  author: "Codex",
+  homepage: "https://github.com/AshDevFr/codex",
+  protocolVersion: "1.1",
+  capabilities: {
+    releaseSource: {
+      kinds: ["rss-series"],
+      requiresAliases: false,
+      requiresExternalIds: [EXTERNAL_ID_SOURCE_MANGAUPDATES],
+      canAnnounceChapters: true,
+      canAnnounceVolumes: true
+    }
+  },
+  configSchema: {
+    description: "MangaUpdates plugin configuration. Per-series language preferences live on each series' tracking config; the values here are server-wide defaults applied when a series doesn't override them.",
+    fields: [
+      {
+        key: "blockedGroups",
+        label: "Blocked Scanlation Groups",
+        description: "Comma-separated list of scanlation group names to exclude from announcements (case-insensitive, exact match). Per-series overrides may further extend this list.",
+        type: "string",
+        required: false,
+        default: "",
+        example: "LowQualityScans,MTL Group"
+      },
+      {
+        key: "requestTimeoutMs",
+        label: "Request Timeout (ms)",
+        description: "How long to wait for a single RSS fetch before giving up. Defaults to 10000 (10 seconds).",
+        type: "number",
+        required: false,
+        default: 1e4
+      }
+    ]
+  },
+  userDescription: "Announces new chapters for series you've tracked, using their MangaUpdates IDs. Filters releases to languages you can read. Notification-only \u2014 Codex does not download anything.",
+  adminSetupInstructions: "1. No config is required to get started \u2014 saving the plugin is enough. The plugin auto-registers a single source row (`MangaUpdates Releases`) in **Settings \u2192 Release tracking** on first start, where you can disable it, change the poll interval, or hit *Poll now*. 2. To get announcements for a series, edit its tracking panel and either paste a `mangaupdates` external ID or let the metadata-refresh path populate it from MangaBaka cross-references. 3. Optional: set `blockedGroups` (CSV, case-insensitive) to filter noisy scanlators server-wide; per-series language preferences live on each series' tracking config and override the server default (`release_tracking.default_languages`). No credentials are needed; MangaUpdates RSS feeds are public."
+};
+
+// src/index.ts
+var logger = createLogger({ name: manifest.name, level: "info" });
+var state = {
+  hostRpc: null,
+  blockedGroupsCsv: "",
+  requestTimeoutMs: 1e4
+};
+function _resetState() {
+  state.hostRpc = null;
+  state.blockedGroupsCsv = "";
+  state.requestTimeoutMs = 1e4;
+}
+async function listTracked(rpc, sourceId, offset, limit) {
+  return rpc.call(RELEASES_METHODS.LIST_TRACKED, {
+    sourceId,
+    offset,
+    limit
+  });
+}
+async function recordCandidate(rpc, sourceId, candidate) {
+  try {
+    return await rpc.call(RELEASES_METHODS.RECORD, {
+      sourceId,
+      candidate
+    });
+  } catch (err) {
+    if (err instanceof HostRpcError) {
+      logger.warn(
+        `record failed for ${candidate.externalReleaseId}: ${err.message} (code ${err.code})`
+      );
+    } else {
+      const msg = err instanceof Error ? err.message : "unknown error";
+      logger.warn(`record failed for ${candidate.externalReleaseId}: ${msg}`);
+    }
+    return null;
+  }
+}
+async function* iterateTrackedSeries(rpc, sourceId) {
+  const pageSize = 200;
+  let offset = 0;
+  while (true) {
+    const page = await listTracked(rpc, sourceId, offset, pageSize);
+    for (const entry of page.tracked) {
+      yield entry;
+    }
+    if (page.nextOffset === void 0 || page.tracked.length === 0) return;
+    offset = page.nextOffset;
+  }
+}
+function effectiveLanguagesForSeries(_entry) {
+  return [];
+}
+function toCandidate(entry, item) {
+  const candidate = {
+    seriesMatch: {
+      codexSeriesId: entry.seriesId,
+      confidence: 1,
+      reason: `mangaupdates_id:${entry.externalIds?.[EXTERNAL_ID_SOURCE_MANGAUPDATES] ?? ""}`
+    },
+    externalReleaseId: item.externalReleaseId,
+    chapter: item.chapter,
+    volume: item.volume,
+    language: item.language,
+    groupOrUploader: item.group,
+    payloadUrl: item.link.length > 0 ? item.link : `urn:mu:${item.externalReleaseId}`,
+    observedAt: item.observedAt
+  };
+  return candidate;
+}
+async function pollSeries(rpc, sourceId, entry, options) {
+  const muId = entry.externalIds?.[EXTERNAL_ID_SOURCE_MANGAUPDATES];
+  if (!muId) {
+    return {
+      seriesId: entry.seriesId,
+      fetched: false,
+      notModified: false,
+      parsed: 0,
+      matched: 0,
+      recorded: 0,
+      deduped: 0,
+      upstreamStatus: 0,
+      etag: null,
+      error: "missing mangaupdates external ID"
+    };
+  }
+  const result = await fetchSeriesFeed(muId, null, {
+    fetchImpl: options.fetchImpl,
+    timeoutMs: options.timeoutMs
+  });
+  if (result.kind === "notModified") {
+    return {
+      seriesId: entry.seriesId,
+      fetched: true,
+      notModified: true,
+      parsed: 0,
+      matched: 0,
+      recorded: 0,
+      deduped: 0,
+      upstreamStatus: 304,
+      etag: null,
+      error: ""
+    };
+  }
+  if (result.kind === "error") {
+    return {
+      seriesId: entry.seriesId,
+      fetched: false,
+      notModified: false,
+      parsed: 0,
+      matched: 0,
+      recorded: 0,
+      deduped: 0,
+      upstreamStatus: result.status,
+      etag: null,
+      error: result.message
+    };
+  }
+  const items = parseFeed(result.body);
+  const filters = resolveFilters({
+    languages: effectiveLanguagesForSeries(entry),
+    blockedGroups: options.blockedGroups
+  });
+  let matched = 0;
+  let recorded = 0;
+  let deduped = 0;
+  for (const item of items) {
+    if (!passesFilters(item, filters)) continue;
+    matched++;
+    const candidate = toCandidate(entry, item);
+    const outcome = await recordCandidate(rpc, sourceId, candidate);
+    if (!outcome) continue;
+    if (outcome.deduped) {
+      deduped++;
+    } else {
+      recorded++;
+    }
+  }
+  return {
+    seriesId: entry.seriesId,
+    fetched: true,
+    notModified: false,
+    parsed: items.length,
+    matched,
+    recorded,
+    deduped,
+    upstreamStatus: 200,
+    etag: result.etag,
+    error: ""
+  };
+}
+async function poll(params, rpc) {
+  const sourceId = params.sourceId;
+  const blockedGroups = parseCommaList(state.blockedGroupsCsv);
+  let parsed = 0;
+  let matched = 0;
+  let recorded = 0;
+  let deduped = 0;
+  let worstStatus = 200;
+  let lastEtag = null;
+  let seenSeries = 0;
+  let skippedNoMuId = 0;
+  for await (const entry of iterateTrackedSeries(rpc, sourceId)) {
+    seenSeries++;
+    const outcome = await pollSeries(rpc, sourceId, entry, {
+      blockedGroups,
+      timeoutMs: state.requestTimeoutMs
+    });
+    parsed += outcome.parsed;
+    matched += outcome.matched;
+    recorded += outcome.recorded;
+    deduped += outcome.deduped;
+    if (outcome.upstreamStatus > worstStatus) {
+      worstStatus = outcome.upstreamStatus;
+    }
+    if (outcome.etag) lastEtag = outcome.etag;
+    if (outcome.error === "missing mangaupdates external ID") {
+      skippedNoMuId++;
+    } else if (outcome.error) {
+      logger.warn(`series ${entry.seriesId}: ${outcome.error} (status ${outcome.upstreamStatus})`);
+    }
+  }
+  if (skippedNoMuId > 0) {
+    logger.info(
+      `skipped ${skippedNoMuId} of ${seenSeries} tracked series for source=${sourceId}: no mangaupdates external ID. Add one in the Tracking panel or run a metadata refresh.`
+    );
+  }
+  logger.info(
+    `poll complete: source=${sourceId} series=${seenSeries} skipped=${skippedNoMuId} parsed=${parsed} matched=${matched} recorded=${recorded} deduped=${deduped} worst_status=${worstStatus}`
+  );
+  return {
+    notModified: false,
+    upstreamStatus: worstStatus,
+    parsed,
+    matched,
+    recorded,
+    deduped,
+    ...lastEtag !== null ? { etag: lastEtag } : {}
+  };
+}
+async function registerSources(rpc) {
+  const sources = [
+    {
+      sourceKey: "default",
+      displayName: "MangaUpdates Releases",
+      kind: "rss-series",
+      config: null
+    }
+  ];
+  const maxAttempts = 5;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await rpc.call(
+        RELEASES_METHODS.REGISTER_SOURCES,
+        { sources }
+      );
+    } catch (err) {
+      const isMethodNotFound = err instanceof HostRpcError && err.code === -32601;
+      if (isMethodNotFound && attempt < maxAttempts) {
+        await new Promise((r) => setTimeout(r, 50 * attempt));
+        continue;
+      }
+      const reason = err instanceof Error ? err.message : String(err);
+      logger.error(`register_sources failed: ${reason}`);
+      return null;
+    }
+  }
+  return null;
+}
+createReleaseSourcePlugin({
+  manifest,
+  provider: {
+    async poll(params) {
+      if (!state.hostRpc) {
+        throw new Error("Plugin not initialized: hostRpc client missing");
+      }
+      return poll(params, state.hostRpc);
+    }
+  },
+  logLevel: "info",
+  async onInitialize(params) {
+    state.hostRpc = params.hostRpc;
+    const ac = params.adminConfig ?? {};
+    if (typeof ac.blockedGroups === "string") {
+      state.blockedGroupsCsv = ac.blockedGroups;
+    }
+    if (typeof ac.requestTimeoutMs === "number" && Number.isFinite(ac.requestTimeoutMs)) {
+      state.requestTimeoutMs = Math.max(1e3, Math.min(ac.requestTimeoutMs, 6e4));
+    }
+    logger.info(
+      `initialized: blockedGroups=${state.blockedGroupsCsv ? "set" : "empty"} timeoutMs=${state.requestTimeoutMs}`
+    );
+    queueMicrotask(() => {
+      void registerSources(params.hostRpc).then((result) => {
+        if (result) {
+          logger.info(`register_sources: registered=${result.registered} pruned=${result.pruned}`);
+        }
+      });
+    });
+  }
+});
+logger.info("MangaUpdates release-source plugin started");
+export {
+  _resetState,
+  pollSeries,
+  registerSources
+};
+//# sourceMappingURL=index.js.map