@ashdev/codex-plugin-sync-anilist 1.10.0

package/dist/index.js

@@ -0,0 +1,1095 @@
+#!/usr/bin/env node
+
+// node_modules/@ashdev/codex-plugin-sdk/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
+};
+var PLUGIN_ERROR_CODES = {
+  /** Rate limited by external API */
+  RATE_LIMITED: -32001,
+  /** Resource not found (e.g., series ID doesn't exist) */
+  NOT_FOUND: -32002,
+  /** Authentication failed (invalid credentials) */
+  AUTH_FAILED: -32003,
+  /** External API error */
+  API_ERROR: -32004,
+  /** Plugin configuration error */
+  CONFIG_ERROR: -32005
+};
+
+// node_modules/@ashdev/codex-plugin-sdk/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
+    };
+  }
+};
+var RateLimitError = class extends PluginError {
+  code = PLUGIN_ERROR_CODES.RATE_LIMITED;
+  /** Seconds to wait before retrying */
+  retryAfterSeconds;
+  constructor(retryAfterSeconds, message) {
+    super(message ?? `Rate limited, retry after ${retryAfterSeconds}s`, {
+      retryAfterSeconds
+    });
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+var AuthError = class extends PluginError {
+  code = PLUGIN_ERROR_CODES.AUTH_FAILED;
+  constructor(message) {
+    super(message ?? "Authentication failed");
+  }
+};
+var ApiError = class extends PluginError {
+  code = PLUGIN_ERROR_CODES.API_ERROR;
+  statusCode;
+  constructor(message, statusCode) {
+    super(message, statusCode !== void 0 ? { statusCode } : void 0);
+    this.statusCode = statusCode;
+  }
+};
+
+// node_modules/@ashdev/codex-plugin-sdk/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);
+}
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/server.js
+import { createInterface } from "node:readline";
+
+// node_modules/@ashdev/codex-plugin-sdk/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));
+      }
+    });
+  }
+};
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/server.js
+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();
+  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);
+  });
+  rl.on("close", () => {
+    logger2.info("stdin closed, shutting down");
+    storage.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) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+  }
+  if (parsed && isJsonRpcResponse(parsed)) {
+    logger2.debug("Routing storage response", { id: parsed.id });
+    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 handleRequest(request, manifest2, onInitialize, router, logger2, storage);
+    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) {
+  const { method, params, id } = request;
+  switch (method) {
+    case "initialize": {
+      const initParams = params ?? {};
+      initParams.storage = storage;
+      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();
+      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 methodNotFound(id, message) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+      message
+    }
+  };
+}
+function success(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function createSyncPlugin(options) {
+  const { manifest: manifest2, provider: provider2, onInitialize, logLevel } = options;
+  const router = async (method, params, id) => {
+    switch (method) {
+      case "sync/getUserInfo":
+        return success(id, await provider2.getUserInfo());
+      case "sync/pushProgress":
+        return success(id, await provider2.pushProgress(params));
+      case "sync/pullProgress":
+        return success(id, await provider2.pullProgress(params));
+      case "sync/status": {
+        if (!provider2.status)
+          return methodNotFound(id, "This plugin does not support sync/status");
+        return success(id, await provider2.status());
+      }
+      default:
+        return null;
+    }
+  };
+  createPluginServer({ manifest: manifest2, onInitialize, logLevel, label: "sync", router });
+}
+
+// node_modules/@ashdev/codex-plugin-sdk/dist/types/manifest.js
+var EXTERNAL_ID_SOURCE_ANILIST = "api:anilist";
+
+// src/anilist.ts
+var ANILIST_API_URL = "https://graphql.anilist.co";
+var VIEWER_QUERY = `
+  query {
+    Viewer {
+      id
+      name
+      avatar {
+        large
+        medium
+      }
+      siteUrl
+      options {
+        displayAdultContent
+      }
+      mediaListOptions {
+        scoreFormat
+      }
+    }
+  }
+`;
+var MANGA_LIST_QUERY = `
+  query ($userId: Int!, $page: Int, $perPage: Int) {
+    Page(page: $page, perPage: $perPage) {
+      pageInfo {
+        total
+        currentPage
+        lastPage
+        hasNextPage
+      }
+      mediaList(userId: $userId, type: MANGA, sort: UPDATED_TIME_DESC) {
+        id
+        mediaId
+        status
+        score
+        progress
+        progressVolumes
+        startedAt {
+          year
+          month
+          day
+        }
+        completedAt {
+          year
+          month
+          day
+        }
+        notes
+        updatedAt
+        media {
+          id
+          title {
+            romaji
+            english
+            native
+          }
+          siteUrl
+        }
+      }
+    }
+  }
+`;
+var SEARCH_MANGA_QUERY = `
+  query ($search: String!) {
+    Media(search: $search, type: MANGA) {
+      id
+      title {
+        romaji
+        english
+      }
+    }
+  }
+`;
+var UPDATE_ENTRY_MUTATION = `
+  mutation (
+    $mediaId: Int!,
+    $status: MediaListStatus,
+    $score: Float,
+    $progress: Int,
+    $progressVolumes: Int,
+    $startedAt: FuzzyDateInput,
+    $completedAt: FuzzyDateInput,
+    $notes: String
+  ) {
+    SaveMediaListEntry(
+      mediaId: $mediaId,
+      status: $status,
+      score: $score,
+      progress: $progress,
+      progressVolumes: $progressVolumes,
+      startedAt: $startedAt,
+      completedAt: $completedAt,
+      notes: $notes
+    ) {
+      id
+      mediaId
+      status
+      score
+      progress
+      progressVolumes
+    }
+  }
+`;
+var AniListClient = class {
+  accessToken;
+  constructor(accessToken) {
+    this.accessToken = accessToken;
+  }
+  /**
+   * Execute a GraphQL query against the AniList API.
+   * On rate limit (429), waits the requested duration and retries once.
+   */
+  async query(queryStr, variables) {
+    return this.executeQuery(queryStr, variables, true);
+  }
+  async executeQuery(queryStr, variables, allowRetry) {
+    let response;
+    try {
+      response = await fetch(ANILIST_API_URL, {
+        method: "POST",
+        signal: AbortSignal.timeout(3e4),
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          Authorization: `Bearer ${this.accessToken}`
+        },
+        body: JSON.stringify({ query: queryStr, variables })
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "TimeoutError") {
+        throw new ApiError("AniList API request timed out after 30 seconds");
+      }
+      throw error;
+    }
+    if (response.status === 401) {
+      throw new AuthError("AniList access token is invalid or expired");
+    }
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      const retrySeconds = retryAfter ? Number.parseInt(retryAfter, 10) : 60;
+      const waitSeconds = Number.isNaN(retrySeconds) ? 60 : retrySeconds;
+      if (allowRetry) {
+        await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1e3));
+        return this.executeQuery(queryStr, variables, false);
+      }
+      throw new RateLimitError(waitSeconds, "AniList rate limit exceeded");
+    }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new ApiError(
+        `AniList API error: ${response.status} ${response.statusText}${body ? ` - ${body}` : ""}`
+      );
+    }
+    const json = await response.json();
+    if (json.errors?.length) {
+      const message = json.errors.map((e) => e.message).join("; ");
+      throw new ApiError(`AniList GraphQL error: ${message}`);
+    }
+    if (!json.data) {
+      throw new ApiError("AniList returned empty data");
+    }
+    return json.data;
+  }
+  /**
+   * Get the authenticated user's info
+   */
+  async getViewer() {
+    const data = await this.query(VIEWER_QUERY);
+    return data.Viewer;
+  }
+  /**
+   * Get the user's manga list (paginated)
+   */
+  async getMangaList(userId, page = 1, perPage = 50) {
+    const variables = { userId, page, perPage };
+    const data = await this.query(MANGA_LIST_QUERY, variables);
+    return {
+      pageInfo: data.Page.pageInfo,
+      entries: data.Page.mediaList
+    };
+  }
+  /**
+   * Update or create a manga list entry
+   */
+  async saveEntry(variables) {
+    const data = await this.query(
+      UPDATE_ENTRY_MUTATION,
+      variables
+    );
+    return data.SaveMediaListEntry;
+  }
+  /**
+   * Search for a manga by title and return its AniList ID.
+   * Returns null if no result found or an error occurs.
+   */
+  async searchManga(title) {
+    try {
+      const data = await this.query(SEARCH_MANGA_QUERY, {
+        search: title
+      });
+      return data.Media;
+    } catch {
+      return null;
+    }
+  }
+};
+function anilistStatusToSync(status) {
+  switch (status) {
+    case "CURRENT":
+    case "REPEATING":
+      return "reading";
+    case "COMPLETED":
+      return "completed";
+    case "PAUSED":
+      return "on_hold";
+    case "DROPPED":
+      return "dropped";
+    case "PLANNING":
+      return "plan_to_read";
+    default:
+      return "reading";
+  }
+}
+function syncStatusToAnilist(status) {
+  switch (status) {
+    case "reading":
+      return "CURRENT";
+    case "completed":
+      return "COMPLETED";
+    case "on_hold":
+      return "PAUSED";
+    case "dropped":
+      return "DROPPED";
+    case "plan_to_read":
+      return "PLANNING";
+    default:
+      return "CURRENT";
+  }
+}
+function fuzzyDateToIso(date) {
+  if (!date?.year) return void 0;
+  const month = date.month ? String(date.month).padStart(2, "0") : "01";
+  const day = date.day ? String(date.day).padStart(2, "0") : "01";
+  return `${date.year}-${month}-${day}T00:00:00Z`;
+}
+function isoToFuzzyDate(iso) {
+  if (!iso) return void 0;
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return void 0;
+  return {
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate()
+  };
+}
+function convertScoreToAnilist(score, format) {
+  switch (format) {
+    case "POINT_100":
+      return Math.round(score);
+    case "POINT_10_DECIMAL":
+      return score / 10;
+    case "POINT_10":
+      return Math.round(score / 10);
+    case "POINT_5":
+      return Math.round(score / 20);
+    case "POINT_3":
+      if (score >= 70) return 3;
+      if (score >= 40) return 2;
+      return 1;
+    default:
+      return Math.round(score / 10);
+  }
+}
+function convertScoreFromAnilist(score, format) {
+  switch (format) {
+    case "POINT_100":
+      return score;
+    case "POINT_10_DECIMAL":
+      return score * 10;
+    case "POINT_10":
+      return score * 10;
+    case "POINT_5":
+      return score * 20;
+    case "POINT_3":
+      return Math.round(score * 33.3);
+    default:
+      return score * 10;
+  }
+}
+
+// package.json
+var package_default = {
+  name: "@ashdev/codex-plugin-sync-anilist",
+  version: "1.10.0",
+  description: "AniList reading progress sync plugin for Codex",
+  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/sync-anilist"
+  },
+  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",
+    "anilist",
+    "sync",
+    "manga",
+    "reading-progress"
+  ],
+  author: "Codex",
+  license: "MIT",
+  engines: {
+    node: ">=22.0.0"
+  },
+  dependencies: {
+    "@ashdev/codex-plugin-sdk": "^1.10.0"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.3.13",
+    "@types/node": "^22.0.0",
+    esbuild: "^0.24.0",
+    typescript: "^5.7.0",
+    vitest: "^3.0.0"
+  }
+};
+
+// src/manifest.ts
+var manifest = {
+  name: "sync-anilist",
+  displayName: "AniList Sync",
+  version: package_default.version,
+  description: "Sync manga reading progress between Codex and AniList. Supports push/pull of reading status, chapters read, scores, and dates.",
+  author: "Codex",
+  homepage: "https://github.com/AshDevFr/codex",
+  protocolVersion: "1.0",
+  capabilities: {
+    userReadSync: true,
+    externalIdSource: EXTERNAL_ID_SOURCE_ANILIST
+  },
+  requiredCredentials: [
+    {
+      key: "access_token",
+      label: "AniList Access Token",
+      description: "OAuth access token for AniList API",
+      type: "password",
+      required: true,
+      sensitive: true
+    }
+  ],
+  userConfigSchema: {
+    description: "AniList-specific sync settings",
+    fields: [
+      {
+        key: "progressUnit",
+        label: "Progress Unit",
+        description: "What each book in Codex represents in AniList. Use 'volumes' for manga volumes, 'chapters' for individual chapters",
+        type: "string",
+        required: false,
+        default: "volumes"
+      },
+      {
+        key: "pauseAfterDays",
+        label: "Auto-Pause After Days",
+        description: "Automatically set in-progress series to Paused on AniList if no reading activity in this many days. Set to 0 to disable.",
+        type: "number",
+        required: false,
+        default: 0
+      },
+      {
+        key: "dropAfterDays",
+        label: "Auto-Drop After Days",
+        description: "Automatically set in-progress series to Dropped on AniList if no reading activity in this many days. Set to 0 to disable. When both pause and drop are set, the shorter threshold fires first.",
+        type: "number",
+        required: false,
+        default: 0
+      },
+      {
+        key: "searchFallback",
+        label: "Search Fallback",
+        description: "When a series has no AniList ID, search by title to find a match and sync progress. Disable for strict matching only.",
+        type: "boolean",
+        required: false,
+        default: false
+      }
+    ]
+  },
+  oauth: {
+    authorizationUrl: "https://anilist.co/api/v2/oauth/authorize",
+    tokenUrl: "https://anilist.co/api/v2/oauth/token",
+    scopes: [],
+    pkce: false
+  },
+  userDescription: "Sync manga reading progress between Codex and AniList",
+  adminSetupInstructions: "To enable OAuth login, create an AniList API client at https://anilist.co/settings/developer. Set the redirect URL to {your-codex-url}/api/v1/user/plugins/oauth/callback. Enter the Client ID below. Without OAuth configured, users can still connect by pasting a personal access token.",
+  userSetupInstructions: "Connect your AniList account via OAuth, or paste a personal access token. To generate a token, visit https://anilist.co/settings/developer, create a client with redirect URL https://anilist.co/api/v2/oauth/pin, then authorize it to receive your token."
+};
+
+// src/index.ts
+var logger = createLogger({ name: "sync-anilist", level: "debug" });
+var client = null;
+var viewerId = null;
+var scoreFormat = "POINT_10";
+var progressUnit = "volumes";
+var pauseAfterDays = 0;
+var dropAfterDays = 0;
+var searchFallback = false;
+function setClient(c) {
+  client = c;
+}
+function setViewerId(id) {
+  viewerId = id;
+}
+function setSearchFallback(enabled) {
+  searchFallback = enabled;
+}
+function applyStaleness(status, latestUpdatedAt, pauseDays, dropDays, now) {
+  if (status !== "reading") return status;
+  if (pauseDays === 0 && dropDays === 0) return status;
+  if (!latestUpdatedAt) return status;
+  const lastActivity = new Date(latestUpdatedAt).getTime();
+  if (Number.isNaN(lastActivity)) return status;
+  const currentTime = now ?? Date.now();
+  const daysInactive = Math.max(0, (currentTime - lastActivity) / (1e3 * 60 * 60 * 24));
+  if (dropDays > 0 && daysInactive >= dropDays) {
+    return "dropped";
+  }
+  if (pauseDays > 0 && daysInactive >= pauseDays) {
+    return "on_hold";
+  }
+  return status;
+}
+var provider = {
+  async getUserInfo() {
+    if (!client) {
+      throw new Error("Plugin not initialized - no AniList client");
+    }
+    const viewer = await client.getViewer();
+    viewerId = viewer.id;
+    scoreFormat = viewer.mediaListOptions.scoreFormat;
+    logger.info(`Authenticated as ${viewer.name} (id: ${viewer.id}, scoreFormat: ${scoreFormat})`);
+    return {
+      externalId: String(viewer.id),
+      username: viewer.name,
+      avatarUrl: viewer.avatar.large || viewer.avatar.medium,
+      profileUrl: viewer.siteUrl
+    };
+  },
+  async pushProgress(params) {
+    if (!client || viewerId === null) {
+      throw new Error("Plugin not initialized - call getUserInfo first");
+    }
+    const existingMediaIds = /* @__PURE__ */ new Set();
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const result = await client.getMangaList(viewerId, page, 50);
+      for (const entry of result.entries) {
+        existingMediaIds.add(entry.mediaId);
+      }
+      hasMore = result.pageInfo.hasNextPage;
+      page++;
+    }
+    const success2 = [];
+    const failed = [];
+    for (const entry of params.entries) {
+      try {
+        let mediaId = Number.parseInt(entry.externalId, 10);
+        if (Number.isNaN(mediaId)) {
+          if (searchFallback && entry.title) {
+            const result2 = await client.searchManga(entry.title);
+            if (result2) {
+              mediaId = result2.id;
+              logger.info(`Search fallback resolved "${entry.title}" \u2192 AniList ID ${mediaId}`);
+            }
+          }
+          if (Number.isNaN(mediaId)) {
+            failed.push({
+              externalId: entry.externalId,
+              status: "failed",
+              error: searchFallback ? `No AniList match found for "${entry.title || entry.externalId}"` : `Invalid media ID: ${entry.externalId}`
+            });
+            continue;
+          }
+        }
+        const effectiveStatus = applyStaleness(
+          entry.status,
+          entry.latestUpdatedAt,
+          pauseAfterDays,
+          dropAfterDays
+        );
+        if (effectiveStatus !== entry.status) {
+          logger.debug(
+            `Entry ${entry.externalId}: auto-${effectiveStatus === "dropped" ? "dropped" : "paused"} (was ${entry.status})`
+          );
+        }
+        const saveParams = {
+          mediaId,
+          status: syncStatusToAnilist(effectiveStatus)
+        };
+        const count = entry.progress?.volumes ?? entry.progress?.chapters;
+        if (count !== void 0) {
+          if (progressUnit === "chapters") {
+            saveParams.progress = count;
+          } else {
+            saveParams.progressVolumes = count;
+          }
+        }
+        if (entry.score !== void 0) {
+          saveParams.score = convertScoreToAnilist(entry.score, scoreFormat);
+        }
+        if (entry.startedAt) {
+          saveParams.startedAt = isoToFuzzyDate(entry.startedAt);
+        }
+        if (entry.completedAt) {
+          saveParams.completedAt = isoToFuzzyDate(entry.completedAt);
+        }
+        if (entry.notes !== void 0) {
+          saveParams.notes = entry.notes;
+        }
+        const resolvedExternalId = String(mediaId);
+        const existed = existingMediaIds.has(mediaId);
+        const result = await client.saveEntry(saveParams);
+        logger.debug(`Pushed entry ${resolvedExternalId}: status=${result.status}`);
+        existingMediaIds.add(mediaId);
+        success2.push({
+          externalId: resolvedExternalId,
+          status: existed ? "updated" : "created"
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        logger.error(`Failed to push entry ${entry.externalId}: ${message}`);
+        failed.push({
+          externalId: entry.externalId,
+          status: "failed",
+          error: message
+        });
+      }
+    }
+    return { success: success2, failed };
+  },
+  async pullProgress(params) {
+    if (!client || viewerId === null) {
+      throw new Error("Plugin not initialized - call getUserInfo first");
+    }
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 1;
+    const perPage = params.limit ? Math.min(params.limit, 50) : 50;
+    const result = await client.getMangaList(viewerId, page, perPage);
+    const entries = result.entries.map((entry) => ({
+      externalId: String(entry.mediaId),
+      status: anilistStatusToSync(entry.status),
+      progress: {
+        chapters: entry.progress || void 0,
+        volumes: entry.progressVolumes || void 0
+      },
+      score: entry.score > 0 ? convertScoreFromAnilist(entry.score, scoreFormat) : void 0,
+      startedAt: fuzzyDateToIso(entry.startedAt),
+      completedAt: fuzzyDateToIso(entry.completedAt),
+      notes: entry.notes || void 0
+    }));
+    logger.info(
+      `Pulled ${entries.length} entries (page ${result.pageInfo.currentPage}/${result.pageInfo.lastPage})`
+    );
+    return {
+      entries,
+      nextCursor: result.pageInfo.hasNextPage ? String(result.pageInfo.currentPage + 1) : void 0,
+      hasMore: result.pageInfo.hasNextPage
+    };
+  },
+  async status() {
+    if (!client || viewerId === null) {
+      return {
+        pendingPush: 0,
+        pendingPull: 0,
+        conflicts: 0
+      };
+    }
+    const result = await client.getMangaList(viewerId, 1, 1);
+    return {
+      externalCount: result.pageInfo.total,
+      pendingPush: 0,
+      pendingPull: 0,
+      conflicts: 0
+    };
+  }
+};
+createSyncPlugin({
+  manifest,
+  provider,
+  logLevel: "debug",
+  onInitialize(params) {
+    const accessToken = params.credentials?.access_token;
+    if (accessToken) {
+      client = new AniListClient(accessToken);
+      logger.info("AniList client initialized with access token");
+    } else {
+      logger.warn("No access token provided - sync operations will fail");
+    }
+    const uc = params.userConfig;
+    if (uc) {
+      const unit = uc.progressUnit;
+      if (unit === "chapters" || unit === "volumes") {
+        progressUnit = unit;
+      }
+      if (typeof uc.pauseAfterDays === "number" && uc.pauseAfterDays >= 0) {
+        pauseAfterDays = uc.pauseAfterDays;
+      }
+      if (typeof uc.dropAfterDays === "number" && uc.dropAfterDays >= 0) {
+        dropAfterDays = uc.dropAfterDays;
+      }
+      if (typeof uc.searchFallback === "boolean") {
+        searchFallback = uc.searchFallback;
+      }
+      logger.info(
+        `Plugin config: progressUnit=${progressUnit}, pauseAfterDays=${pauseAfterDays}, dropAfterDays=${dropAfterDays}, searchFallback=${searchFallback}`
+      );
+    }
+  }
+});
+logger.info("AniList sync plugin started");
+export {
+  applyStaleness,
+  provider,
+  setClient,
+  setSearchFallback,
+  setViewerId
+};
+//# sourceMappingURL=index.js.map