@ashdev/codex-plugin-release-tsundoku 1.36.1

package/dist/index.js

@@ -0,0 +1,1161 @@
+#!/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",
+  /**
+   * Count tracked series scoped to the plugin's `requiresExternalIds`.
+   *
+   * Plugins call this once at the start of a poll to learn the total
+   * denominator before iterating, so subsequent `REPORT_PROGRESS` calls
+   * carry a stable `current/total` ratio. Cheap (one batched DB lookup);
+   * safe to call from `poll`.
+   */
+  COUNT_TRACKED: "releases/count_tracked",
+  /**
+   * Report intra-poll progress to the host. The host translates this into
+   * a `TaskProgressEvent` on the active task's broadcaster; the inbox
+   * progress bar updates live. Best-effort — calls outside an active
+   * task scope are silently dropped, and rapid back-to-back calls are
+   * rate-limited (~10/sec) by the host. Plugins SHOULD call this after
+   * each unit of work (e.g. after each polled series) with `current` set
+   * to the count of completed units and `total` from `COUNT_TRACKED`.
+   */
+  REPORT_PROGRESS: "releases/report_progress",
+  /** 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/candidate.ts
+function toSpans(coverage) {
+  if (coverage.length === 0) return null;
+  return coverage.map((s) => ({ start: s.start, end: s.end }));
+}
+function fmtHighwater(value) {
+  return value === null ? "-" : String(value);
+}
+function externalReleaseId(item) {
+  return `tsundoku:${item.seriesId}:v${fmtHighwater(item.highestVolume)}:c${fmtHighwater(item.highestChapter)}`;
+}
+function feedItemToCandidate(item, match, opts) {
+  const base = opts.baseUrl.replace(/\/+$/, "");
+  return {
+    seriesMatch: {
+      codexSeriesId: match.codexSeriesId,
+      confidence: match.confidence,
+      reason: `tsundoku:vote:${match.agreeingProviders.join("+")}`
+    },
+    externalReleaseId: externalReleaseId(item),
+    volumes: toSpans(item.volumeCoverage),
+    chapters: toSpans(item.chapterCoverage),
+    language: opts.language,
+    groupOrUploader: null,
+    payloadUrl: `${base}/series/${item.seriesId}`,
+    observedAt: opts.observedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    // Tsundoku's `updatedAt` is epoch seconds; a coverage change is the closest
+    // thing the feed has to a publish date. Not skew-checked host-side.
+    releasedAt: new Date(item.updatedAt * 1e3).toISOString(),
+    metadata: {
+      tsundokuSeriesId: item.seriesId,
+      canonicalTitle: item.canonicalTitle,
+      highestVolume: item.highestVolume,
+      highestChapter: item.highestChapter
+    }
+  };
+}
+
+// src/fetcher.ts
+var FEED_PATH = "/api/v1/series/feed";
+var DEFAULT_TIMEOUT_MS = 1e4;
+function feedUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}${FEED_PATH}`;
+}
+async function fetchFeedPage(baseUrl, req, opts = {}) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const url = feedUrl(baseUrl);
+  const headers = {
+    Accept: "application/json",
+    "Content-Type": "application/json",
+    "User-Agent": "Codex-ReleaseTracker/1.0 (+https://github.com/AshDevFr/codex)"
+  };
+  const body = JSON.stringify({
+    externalIds: req.externalIds,
+    cursor: req.cursor,
+    limit: req.limit
+  });
+  const signal = AbortSignal.timeout(timeoutMs);
+  let resp;
+  try {
+    resp = await fetchImpl(url, { method: "POST", headers, body, signal });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown fetch error";
+    return { kind: "error", status: 0, message: msg };
+  }
+  if (resp.status !== 200) {
+    return {
+      kind: "error",
+      status: resp.status,
+      message: `upstream returned ${resp.status} ${resp.statusText}`.trim()
+    };
+  }
+  let parsed;
+  try {
+    parsed = await resp.json();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "invalid JSON";
+    return { kind: "error", status: 200, message: `failed to parse feed JSON: ${msg}` };
+  }
+  if (!isFeedResponse(parsed)) {
+    return { kind: "error", status: 200, message: "malformed feed response: missing items[]" };
+  }
+  return { kind: "ok", data: parsed, status: 200 };
+}
+function isFeedResponse(value) {
+  if (value === null || typeof value !== "object") return false;
+  const obj = value;
+  return Array.isArray(obj.items) && typeof obj.hasMore === "boolean";
+}
+
+// package.json
+var package_default = {
+  name: "@ashdev/codex-plugin-release-tsundoku",
+  version: "1.36.1",
+  description: "Tsundoku release-source plugin for Codex - announces new volume/chapter coverage for tracked series via the Tsundoku incremental series feed, matched by exact external IDs",
+  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-tsundoku"
+  },
+  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",
+    "tsundoku",
+    "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 CODEX_TO_TSUNDOKU_PROVIDER = {
+  mangabaka: "mangabaka",
+  anilist: "anilist",
+  myanimelist: "mal",
+  mangaupdates: "mangaupdates",
+  kitsu: "kitsu",
+  shikimori: "shikimori",
+  animeplanet: "anime_planet",
+  animenewsnetwork: "anime_news_network"
+};
+var CODEX_EXTERNAL_ID_SOURCES = Object.keys(CODEX_TO_TSUNDOKU_PROVIDER);
+var manifest = {
+  name: "release-tsundoku",
+  displayName: "Tsundoku Releases",
+  version: package_default.version,
+  description: "Announces new volume/chapter coverage for tracked series via a Tsundoku instance's incremental series feed. Matches series by exact external IDs (no fuzzy matching) and walks the feed by cursor, persisting its position between polls.",
+  author: "Codex",
+  homepage: "https://github.com/AshDevFr/codex",
+  protocolVersion: "1.1",
+  capabilities: {
+    releaseSource: {
+      kinds: ["api-feed"],
+      requiresAliases: false,
+      requiresExternalIds: [...CODEX_EXTERNAL_ID_SOURCES],
+      canAnnounceChapters: true,
+      canAnnounceVolumes: true
+    }
+  },
+  configSchema: {
+    description: "Tsundoku plugin configuration. Point `baseUrl` at your Tsundoku instance; the plugin polls its public `/api/v1/series/feed` endpoint and matches results to your tracked series by external ID.",
+    fields: [
+      {
+        key: "baseUrl",
+        label: "Tsundoku Base URL",
+        description: "Base URL of the Tsundoku instance, e.g. `https://tsundoku.example.com`. The plugin appends `/api/v1/series/feed`. No trailing slash required.",
+        type: "string",
+        required: true,
+        example: "https://tsundoku.example.com"
+      },
+      {
+        key: "defaultLanguage",
+        label: "Default Language",
+        description: "ISO 639-1 language tag stamped on every announcement. The Tsundoku feed tracks official release coverage and carries no language of its own, so a default is required. Per-series language preferences on each series' tracking config still gate the high-water mark host-side.",
+        type: "string",
+        required: false,
+        default: "en",
+        example: "en"
+      },
+      {
+        key: "pageLimit",
+        label: "Feed Page Size",
+        description: "Items requested per feed page (1\u2013500). Larger pages mean fewer round-trips when walking a long backlog. Defaults to 100.",
+        type: "number",
+        required: false,
+        default: 100
+      },
+      {
+        key: "requestTimeoutMs",
+        label: "Request Timeout (ms)",
+        description: "How long to wait for a single feed page before giving up. Defaults to 10000 (10 seconds).",
+        type: "number",
+        required: false,
+        default: 1e4
+      }
+    ]
+  },
+  userDescription: "Announces new volumes and chapters for series you've tracked, using a Tsundoku instance as the source. Matches your series by external ID (MangaBaka, AniList, MAL, and more). Notification-only \u2014 Codex does not download anything.",
+  adminSetupInstructions: "1. Set `baseUrl` to your Tsundoku instance URL (e.g. `https://tsundoku.example.com`) and save. The plugin auto-registers a single source row (`Tsundoku Releases`) in **Settings \u2192 Release tracking**, where you can disable it, change the poll interval, or hit *Poll now*. 2. To get announcements for a series, make sure it has at least one external ID Tsundoku also knows (MangaBaka, AniList, MAL, MangaUpdates, Kitsu, Shikimori, Anime-Planet, or Anime News Network) \u2014 populate these via a metadata refresh or by pasting them in the series tracking panel. 3. Optional: adjust `defaultLanguage` (default `en`), `pageLimit`, and `requestTimeoutMs`. The Tsundoku feed endpoint is public; no credentials are needed. Note: the feed is incremental, so newly tracked series only announce on their *next* Tsundoku coverage change."
+};
+
+// src/matcher.ts
+var PROVIDER_WEIGHTS = {
+  mangabaka: 3,
+  anilist: 2
+};
+var DEFAULT_WEIGHT = 1;
+function weightOf(provider) {
+  return PROVIDER_WEIGHTS[provider] ?? DEFAULT_WEIGHT;
+}
+function indexKey(provider, externalId) {
+  return `${provider}:${externalId}`;
+}
+function buildMatchContext(entries) {
+  const byKey = /* @__PURE__ */ new Map();
+  const series = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const ids = entry.externalIds;
+    if (!ids) continue;
+    const map = /* @__PURE__ */ new Map();
+    for (const [codexProvider, externalId] of Object.entries(ids)) {
+      if (!externalId) continue;
+      const provider = CODEX_TO_TSUNDOKU_PROVIDER[codexProvider] ?? codexProvider;
+      map.set(provider, externalId);
+      const key = indexKey(provider, externalId);
+      const arr = byKey.get(key);
+      if (arr) {
+        arr.push(entry.seriesId);
+      } else {
+        byKey.set(key, [entry.seriesId]);
+      }
+    }
+    if (map.size > 0) {
+      series.set(entry.seriesId, map);
+    }
+  }
+  return { byKey, series };
+}
+function externalIdFilter(ctx) {
+  return [...ctx.byKey.keys()];
+}
+function confidenceForScore(score) {
+  return Math.min(1, Math.max(0.7, 0.7 + 0.1 * score));
+}
+function matchItem(item, ctx) {
+  const itemMap = /* @__PURE__ */ new Map();
+  for (const ext of item.externalIds) {
+    if (ext.externalId) {
+      itemMap.set(ext.provider, ext.externalId);
+    }
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  for (const [provider, id] of itemMap) {
+    const arr = ctx.byKey.get(indexKey(provider, id));
+    if (arr) {
+      for (const sid of arr) candidates.add(sid);
+    }
+  }
+  if (candidates.size === 0) return null;
+  let best = null;
+  let tiedAtBest = false;
+  for (const cid of candidates) {
+    const cSeries = ctx.series.get(cid);
+    if (!cSeries) continue;
+    let agree = 0;
+    let disagree = 0;
+    const agreeing = [];
+    for (const [provider, idVal] of itemMap) {
+      const cVal = cSeries.get(provider);
+      if (cVal === void 0) continue;
+      const w = weightOf(provider);
+      if (cVal === idVal) {
+        agree += w;
+        agreeing.push({ provider, weight: w });
+      } else {
+        disagree += w;
+      }
+    }
+    const score = agree - disagree;
+    if (score <= 0) continue;
+    if (!best || score > best.score) {
+      agreeing.sort((a, b) => b.weight - a.weight || a.provider.localeCompare(b.provider));
+      best = {
+        codexSeriesId: cid,
+        score,
+        confidence: confidenceForScore(score),
+        agreeingProviders: agreeing.map((a) => a.provider)
+      };
+      tiedAtBest = false;
+    } else if (score === best.score) {
+      tiedAtBest = true;
+    }
+  }
+  if (!best || tiedAtBest) return null;
+  return best;
+}
+
+// src/index.ts
+var logger = createLogger({ name: manifest.name, level: "info" });
+var DEFAULT_PAGE_LIMIT = 100;
+var MAX_PAGE_LIMIT = 500;
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+var MIN_TIMEOUT_MS = 1e3;
+var MAX_TIMEOUT_MS = 6e4;
+var DEFAULT_LANGUAGE = "en";
+var state = {
+  hostRpc: null,
+  baseUrl: "",
+  defaultLanguage: DEFAULT_LANGUAGE,
+  pageLimit: DEFAULT_PAGE_LIMIT,
+  requestTimeoutMs: DEFAULT_TIMEOUT_MS2
+};
+function _resetState() {
+  state.hostRpc = null;
+  state.baseUrl = "";
+  state.defaultLanguage = DEFAULT_LANGUAGE;
+  state.pageLimit = DEFAULT_PAGE_LIMIT;
+  state.requestTimeoutMs = DEFAULT_TIMEOUT_MS2;
+}
+function normalizeBaseUrl(raw) {
+  return raw.trim().replace(/\/+$/, "");
+}
+async function registerSources(rpc) {
+  const sources = [
+    {
+      sourceKey: "default",
+      displayName: "Tsundoku Releases",
+      kind: "api-feed",
+      config: null
+    }
+  ];
+  try {
+    return await rpc.call(
+      RELEASES_METHODS.REGISTER_SOURCES,
+      { sources }
+    );
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    logger.error(`register_sources failed: ${reason}`);
+    return null;
+  }
+}
+var TRACKED_PAGE_SIZE = 200;
+async function* iterateTrackedSeries(rpc, sourceId) {
+  let offset = 0;
+  while (true) {
+    const page = await rpc.call(RELEASES_METHODS.LIST_TRACKED, {
+      sourceId,
+      offset,
+      limit: TRACKED_PAGE_SIZE
+    });
+    for (const entry of page.tracked) {
+      yield entry;
+    }
+    if (page.nextOffset === void 0 || page.tracked.length === 0) return;
+    offset = page.nextOffset;
+  }
+}
+async function recordCandidate(rpc, sourceId, candidate) {
+  try {
+    return await rpc.call(RELEASES_METHODS.RECORD, { sourceId, candidate });
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    const code = err instanceof HostRpcError ? ` (code ${err.code})` : "";
+    logger.warn(`record failed for ${candidate.externalReleaseId}: ${reason}${code}`);
+    return null;
+  }
+}
+async function reportProgress(rpc, current, total, message) {
+  try {
+    await rpc.call(RELEASES_METHODS.REPORT_PROGRESS, { current, total, message });
+  } catch (err) {
+    if (err instanceof HostRpcError && err.code === -32601) return;
+    const reason = err instanceof Error ? err.message : String(err);
+    logger.debug(`report_progress dropped: ${reason}`);
+  }
+}
+async function poll(params, rpc, deps) {
+  const sourceId = params.sourceId;
+  const trackedEntries = [];
+  for await (const entry of iterateTrackedSeries(rpc, sourceId)) {
+    trackedEntries.push(entry);
+  }
+  const ctx = buildMatchContext(trackedEntries);
+  const externalIds = externalIdFilter(ctx);
+  if (externalIds.length === 0) {
+    logger.info(
+      `poll: no tracked series carry a Tsundoku-known external ID (source=${sourceId}); nothing to fetch`
+    );
+    return {
+      notModified: false,
+      upstreamStatus: 200,
+      parsed: 0,
+      matched: 0,
+      recorded: 0,
+      deduped: 0
+    };
+  }
+  let cursor = null;
+  let parsed = 0;
+  let worstStatus = 200;
+  let pagesFetched = 0;
+  const hits = [];
+  while (true) {
+    const result = await fetchFeedPage(
+      deps.baseUrl,
+      { externalIds, cursor, limit: deps.pageLimit },
+      { timeoutMs: deps.timeoutMs, fetchImpl: deps.fetchImpl }
+    );
+    if (result.kind === "error") {
+      worstStatus = Math.max(worstStatus, result.status);
+      if (pagesFetched === 0) {
+        throw new Error(`feed fetch failed (status ${result.status}): ${result.message}`);
+      }
+      logger.warn(`feed fetch failed (status ${result.status}): ${result.message}; stopping walk`);
+      break;
+    }
+    pagesFetched++;
+    const page = result.data;
+    for (const item of page.items) {
+      parsed++;
+      const match = matchItem(item, ctx);
+      if (match) {
+        hits.push({ item, match });
+      }
+    }
+    await reportProgress(rpc, parsed, parsed, `Processed ${parsed} feed items`);
+    const next = page.nextCursor ?? null;
+    if (!page.hasMore) break;
+    if (!next) {
+      logger.warn("feed reported hasMore but no nextCursor; stopping walk");
+      break;
+    }
+    if (page.items.length === 0) break;
+    cursor = next;
+  }
+  const byCodex = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const arr = byCodex.get(hit.match.codexSeriesId);
+    if (arr) {
+      arr.push(hit);
+    } else {
+      byCodex.set(hit.match.codexSeriesId, [hit]);
+    }
+  }
+  let matched = 0;
+  let recorded = 0;
+  let deduped = 0;
+  let ambiguous = 0;
+  let superseded = 0;
+  for (const [codexSeriesId, group] of byCodex) {
+    group.sort((a, b) => b.match.score - a.match.score || b.item.updatedAt - a.item.updatedAt);
+    if (group.length > 1 && group[0].match.score === group[1].match.score && group[0].item.seriesId !== group[1].item.seriesId) {
+      ambiguous += group.length;
+      logger.warn(
+        `ambiguous: feed entries from different Tsundoku series match Codex series ${codexSeriesId} at score ${group[0].match.score}; skipping`
+      );
+      continue;
+    }
+    superseded += group.length - 1;
+    const { item, match } = group[0];
+    matched++;
+    const candidate = feedItemToCandidate(item, match, {
+      baseUrl: deps.baseUrl,
+      language: deps.language
+    });
+    const outcome = await recordCandidate(rpc, sourceId, candidate);
+    if (!outcome) continue;
+    if (outcome.deduped) {
+      deduped++;
+    } else {
+      recorded++;
+    }
+  }
+  logger.info(
+    `poll complete: source=${sourceId} tracked=${trackedEntries.length} parsed=${parsed} matched=${matched} recorded=${recorded} deduped=${deduped} ambiguous=${ambiguous} superseded=${superseded} worst_status=${worstStatus}`
+  );
+  return {
+    notModified: false,
+    upstreamStatus: worstStatus,
+    parsed,
+    matched,
+    recorded,
+    deduped
+  };
+}
+createReleaseSourcePlugin({
+  manifest,
+  provider: {
+    async poll(params) {
+      if (!state.hostRpc) {
+        throw new Error("Plugin not initialized: host RPC client missing");
+      }
+      if (!state.baseUrl) {
+        throw new Error("Plugin not configured: baseUrl is required");
+      }
+      return poll(params, state.hostRpc, {
+        baseUrl: state.baseUrl,
+        language: state.defaultLanguage,
+        pageLimit: state.pageLimit,
+        timeoutMs: state.requestTimeoutMs
+      });
+    }
+  },
+  logLevel: "info",
+  async onInitialize(params) {
+    state.hostRpc = params.hostRpc;
+    const ac = params.adminConfig ?? {};
+    if (typeof ac.baseUrl === "string") {
+      state.baseUrl = normalizeBaseUrl(ac.baseUrl);
+    }
+    if (typeof ac.defaultLanguage === "string" && ac.defaultLanguage.trim().length > 0) {
+      state.defaultLanguage = ac.defaultLanguage.trim().toLowerCase();
+    }
+    if (typeof ac.pageLimit === "number" && Number.isFinite(ac.pageLimit)) {
+      state.pageLimit = Math.max(1, Math.min(Math.trunc(ac.pageLimit), MAX_PAGE_LIMIT));
+    }
+    if (typeof ac.requestTimeoutMs === "number" && Number.isFinite(ac.requestTimeoutMs)) {
+      state.requestTimeoutMs = Math.max(
+        MIN_TIMEOUT_MS,
+        Math.min(ac.requestTimeoutMs, MAX_TIMEOUT_MS)
+      );
+    }
+    if (!state.baseUrl) {
+      logger.warn(
+        "initialized without a baseUrl \u2014 set it in the plugin config; polls will error until then"
+      );
+    }
+    logger.info(
+      `initialized: baseUrl=${state.baseUrl || "(unset)"} defaultLanguage=${state.defaultLanguage} pageLimit=${state.pageLimit} timeoutMs=${state.requestTimeoutMs}`
+    );
+    queueMicrotask(() => {
+      void registerSources(params.hostRpc).then((result) => {
+        if (result) {
+          logger.info(`register_sources: registered=${result.registered} pruned=${result.pruned}`);
+        }
+      });
+    });
+  }
+});
+logger.info("Tsundoku release-source plugin started");
+export {
+  _resetState,
+  normalizeBaseUrl,
+  poll,
+  registerSources
+};
+//# sourceMappingURL=index.js.map