strapi-plugin-radiocult-uploader 1.0.0

package/dist/server/index.js

@@ -0,0 +1,1193 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const crypto = require("node:crypto");
+const promises = require("node:stream/promises");
+const NodeID3 = require("node-id3");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const fs__default = /* @__PURE__ */ _interopDefault(fs);
+const path__default = /* @__PURE__ */ _interopDefault(path);
+const os__default = /* @__PURE__ */ _interopDefault(os);
+const crypto__default = /* @__PURE__ */ _interopDefault(crypto);
+const NodeID3__default = /* @__PURE__ */ _interopDefault(NodeID3);
+const PLUGIN_ID = "radiocult-uploader";
+const TRACK_RECORD_UID = "plugin::radiocult-uploader.track-record";
+const PLATFORMS = ["mixcloud", "soundcloud"];
+const LINK_SYNC_RULE = "*/10 * * * *";
+const bootstrap = async ({ strapi: strapi2 }) => {
+  const plugin = () => strapi2.plugin(PLUGIN_ID);
+  await strapi2.admin.services.permission.actionProvider.registerMany([
+    {
+      section: "plugins",
+      displayName: "Access the Radio Cult Uploader settings",
+      uid: "settings",
+      pluginName: PLUGIN_ID
+    }
+  ]);
+  strapi2.cron.add({
+    "radiocult-uploader.link-sync": {
+      options: { rule: LINK_SYNC_RULE },
+      task: async () => {
+        try {
+          const { updated, pending } = await plugin().service("radiocult").syncLinks();
+          if (pending > 0) {
+            strapi2.log.info(
+              `radiocult-uploader link sync: ${updated} updated, ${pending} pending`
+            );
+          }
+        } catch (error) {
+          strapi2.log.warn(`radiocult-uploader link sync failed: ${error}`);
+        }
+      }
+    }
+  });
+  strapi2.db.lifecycles.subscribe(async (event) => {
+    try {
+      if (event.action !== "beforeUpdate" && event.action !== "afterUpdate") return;
+      const mapping2 = await plugin().service("mapping").mapping();
+      if (!mapping2.contentType || !mapping2.title) return;
+      if (event.model?.uid !== mapping2.contentType) return;
+      if (event.action === "beforeUpdate") {
+        if (typeof event.params?.data?.[mapping2.title] !== "string") return;
+        const row = await strapi2.db.query(mapping2.contentType).findOne({ where: event.params.where });
+        event.state.radiocultPreviousTitle = row?.[mapping2.title] ?? null;
+      }
+      if (event.action === "afterUpdate") {
+        await plugin().service("radiocult").maybeSyncTitle(event);
+      }
+    } catch (error) {
+      strapi2.log.warn(`radiocult-uploader title sync failed: ${error}`);
+    }
+  });
+};
+const destroy = ({ strapi: strapi2 }) => {
+};
+const register = ({ strapi: strapi2 }) => {
+  if (typeof fs__default.default.openAsBlob !== "function") {
+    strapi2.log.warn(
+      "radiocult-uploader: this Node version has no fs.openAsBlob — uploads need Node 20 or newer"
+    );
+  }
+};
+const config = {
+  default: ({ env }) => ({
+    apiKey: env("RADIOCULT_API_KEY"),
+    stationId: env("RADIOCULT_STATION_ID"),
+    enabled: env("RADIOCULT_ENABLED")
+  }),
+  validator() {
+  }
+};
+const kind = "collectionType";
+const collectionName = "radiocult_track_records";
+const info = { "singularName": "track-record", "pluralName": "track-records", "displayName": "Radio Cult Track Record", "description": "Bookkeeping for tracks uploaded to Radio Cult (managed by the Radio Cult Uploader plugin)" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
+const attributes = { "contentTypeUid": { "type": "string", "required": true }, "entryDocumentId": { "type": "string", "required": true }, "trackId": { "type": "string" }, "uploadedAt": { "type": "datetime" }, "mixcloudRequestedAt": { "type": "datetime" }, "soundcloudRequestedAt": { "type": "datetime" }, "lastSyncedAt": { "type": "datetime" } };
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  "track-record": { schema }
+};
+class RcHttpError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+const respond = (fn) => async (ctx) => {
+  try {
+    ctx.body = await fn(ctx);
+  } catch (error) {
+    const status = error instanceof RcHttpError ? error.status : 500;
+    const admin2 = ctx.state?.user?.email ?? ctx.state?.user?.id ?? "unknown admin";
+    const line = `radiocult-uploader ${ctx.method} ${ctx.path} (${admin2}) → ${status}: ${error?.message ?? error}`;
+    if (status >= 500) strapi.log.error(`${line}
+${error?.stack ?? ""}`);
+    else strapi.log.warn(line);
+    ctx.status = status;
+    ctx.body = { error: error?.message ?? "Unexpected error" };
+  }
+};
+const metaFrom = (body) => {
+  let tags = body?.tags;
+  if (typeof tags === "string") {
+    try {
+      tags = JSON.parse(tags);
+    } catch {
+      tags = tags.split(",");
+    }
+  }
+  return {
+    title: body?.title,
+    artist: body?.artist,
+    album: body?.album,
+    description: body?.description,
+    tags
+  };
+};
+const uploader = ({ strapi: strapi2 }) => {
+  const service = () => strapi2.plugin(PLUGIN_ID).service("radiocult");
+  return {
+    upload: respond(async (ctx) => {
+      const filesField = ctx.request.files?.files;
+      const file = Array.isArray(filesField) ? filesField[0] : filesField;
+      return service().uploadTrack({
+        documentId: ctx.params.documentId,
+        file,
+        force: ctx.query.force === "true",
+        meta: metaFrom(ctx.request.body)
+      });
+    }),
+    publish: respond(
+      async (ctx) => service().publish({
+        documentId: ctx.params.documentId,
+        platform: ctx.params.platform,
+        force: ctx.query.force === "true",
+        meta: metaFrom(ctx.request.body)
+      })
+    ),
+    updateTrack: respond(
+      async (ctx) => service().updateTrackMetadata({
+        documentId: ctx.params.documentId,
+        meta: metaFrom(ctx.request.body)
+      })
+    ),
+    status: respond(
+      async (ctx) => service().getStatus(ctx.params.documentId, { refresh: ctx.query.refresh === "true" })
+    )
+  };
+};
+const bodyMaxFileSize = (strapi2) => {
+  try {
+    const middlewares2 = strapi2.config.get("middlewares", []);
+    const entry = middlewares2.find(
+      (m) => m === "strapi::body" || m && typeof m === "object" && m.name === "strapi::body"
+    );
+    if (!entry || typeof entry === "string") return 200 * 1024 * 1024;
+    return entry.config?.formidable?.maxFileSize ?? 200 * 1024 * 1024;
+  } catch {
+    return null;
+  }
+};
+const settings$1 = ({ strapi: strapi2 }) => {
+  const settings2 = () => strapi2.plugin(PLUGIN_ID).service("settings");
+  const mapping2 = () => strapi2.plugin(PLUGIN_ID).service("mapping");
+  return {
+    get: respond(async () => {
+      const value = await settings2().get();
+      const { apiKey, ...credentials } = value.credentials;
+      const effective = await settings2().credentials();
+      return {
+        ...value,
+        credentials: { ...credentials, apiKeySet: !!effective.apiKey },
+        envLocks: settings2().envLocks()
+      };
+    }),
+    update: respond(async (ctx) => {
+      const patch = ctx.request.body ?? {};
+      if (patch.credentials && !patch.credentials.apiKey) delete patch.credentials.apiKey;
+      const value = await settings2().update(patch);
+      const { apiKey, ...credentials } = value.credentials;
+      const effective = await settings2().credentials();
+      return {
+        ...value,
+        credentials: { ...credentials, apiKeySet: !!effective.apiKey },
+        envLocks: settings2().envLocks()
+      };
+    }),
+    testConnection: respond(async () => settings2().testConnection()),
+    /**
+     * Theme + mapped content type — readable by any admin (the uploader page
+     * needs the theme, the edit-view side panel needs the content type).
+     */
+    uiConfig: respond(async () => {
+      const value = await settings2().get();
+      return { theme: value.theme, contentType: value.mapping.contentType };
+    }),
+    contentTypes: respond(async () => ({ contentTypes: mapping2().listContentTypes() })),
+    diagnostics: respond(async () => {
+      const fs2 = await import("node:fs");
+      const maxFileSize = bodyMaxFileSize(strapi2);
+      return {
+        nodeVersion: process.version,
+        openAsBlob: typeof fs2.openAsBlob === "function",
+        bodyMaxFileSize: maxFileSize,
+        // Radio Cult accepts files up to 750MB; the app's body middleware has
+        // to allow at least that or big uploads die at the Strapi door.
+        bodyLimitOk: maxFileSize === null ? null : maxFileSize >= 750 * 1024 * 1024,
+        cronEnabled: strapi2.config.get("server.cron.enabled", true)
+      };
+    })
+  };
+};
+const controllers = {
+  uploader,
+  settings: settings$1
+};
+const middlewares = {};
+const policies = {};
+const settingsPolicy = [
+  {
+    name: "admin::hasPermissions",
+    config: { actions: ["plugin::radiocult-uploader.settings"] }
+  }
+];
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "POST",
+      path: "/entries/:documentId/upload",
+      handler: "uploader.upload",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/entries/:documentId/publish/:platform",
+      handler: "uploader.publish",
+      config: { policies: [] }
+    },
+    {
+      method: "PUT",
+      path: "/entries/:documentId/track",
+      handler: "uploader.updateTrack",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/entries/:documentId/status",
+      handler: "uploader.status",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "settings.get",
+      config: { policies: settingsPolicy }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "settings.update",
+      config: { policies: settingsPolicy }
+    },
+    {
+      method: "POST",
+      path: "/settings/test-connection",
+      handler: "settings.testConnection",
+      config: { policies: settingsPolicy }
+    },
+    {
+      method: "GET",
+      path: "/content-types",
+      handler: "settings.contentTypes",
+      config: { policies: settingsPolicy }
+    },
+    {
+      method: "GET",
+      path: "/diagnostics",
+      handler: "settings.diagnostics",
+      config: { policies: settingsPolicy }
+    },
+    {
+      method: "GET",
+      path: "/ui-config",
+      handler: "settings.uiConfig",
+      config: { policies: [] }
+    }
+  ]
+};
+const routes = {
+  admin
+};
+const DEFAULT_SETTINGS = {
+  credentials: { apiKey: "", stationId: "", enabled: true },
+  mapping: {
+    contentType: null,
+    title: null,
+    image: null,
+    broadcastDate: null,
+    soundcloudLink: null,
+    mixcloudLink: null,
+    tagsRelation: null,
+    tagsLabelField: null,
+    showRelation: null,
+    showLabelField: null
+  },
+  defaults: { artist: "", description: "" },
+  theme: { preset: "paper", overrides: {}, fontFamily: "system", logoUrl: null, stationName: "" }
+};
+const deepMerge = (base, patch) => {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(patch ?? {})) {
+    if (value && typeof value === "object" && !Array.isArray(value) && typeof base[key] === "object" && base[key] !== null) {
+      out[key] = deepMerge(base[key], value);
+    } else if (value !== void 0) {
+      out[key] = value;
+    }
+  }
+  return out;
+};
+const STRING_TYPES = ["string", "text"];
+const settings = ({ strapi: strapi2 }) => ({
+  store() {
+    return strapi2.store({ type: "plugin", name: PLUGIN_ID });
+  },
+  /** Full settings object, stored values merged over defaults. */
+  async get() {
+    const stored = await this.store().get({ key: "settings" });
+    return deepMerge(DEFAULT_SETTINGS, stored ?? {});
+  },
+  /**
+   * Which credential fields are locked by plugin config / env vars. The
+   * settings page greys those inputs out and says where the value comes from.
+   */
+  envLocks() {
+    const config2 = strapi2.config.get(`plugin::${PLUGIN_ID}`, {});
+    return {
+      apiKey: !!config2.apiKey,
+      stationId: !!config2.stationId,
+      enabled: config2.enabled !== void 0 && config2.enabled !== null
+    };
+  },
+  /** Effective credentials: plugin config (env-backed) wins over the store. */
+  async credentials() {
+    const config2 = strapi2.config.get(`plugin::${PLUGIN_ID}`, {});
+    const stored = (await this.get()).credentials;
+    return {
+      apiKey: config2.apiKey || stored.apiKey,
+      stationId: config2.stationId || stored.stationId,
+      enabled: config2.enabled !== void 0 && config2.enabled !== null ? config2.enabled !== false && config2.enabled !== "false" : stored.enabled
+    };
+  },
+  /** Validates a mapping against the live content types. Throws RcHttpError(400). */
+  validateMapping(mapping2) {
+    if (!mapping2.contentType) return;
+    const model = strapi2.contentTypes[mapping2.contentType];
+    if (!model) throw new RcHttpError(400, `Unknown content type "${mapping2.contentType}"`);
+    const attrs = model.attributes ?? {};
+    const expect = (field, kinds, label, required = false) => {
+      if (!field) {
+        if (required) throw new RcHttpError(400, `The ${label} field must be mapped`);
+        return;
+      }
+      const attr = attrs[field];
+      if (!attr) {
+        throw new RcHttpError(400, `"${field}" (${label}) does not exist on ${mapping2.contentType}`);
+      }
+      if (!kinds.includes(attr.type)) {
+        throw new RcHttpError(
+          400,
+          `"${field}" (${label}) must be a ${kinds.join("/")} field, not ${attr.type}`
+        );
+      }
+    };
+    expect(mapping2.title, STRING_TYPES, "title", true);
+    expect(mapping2.image, ["media"], "image");
+    expect(mapping2.broadcastDate, ["date", "datetime"], "broadcast date");
+    expect(mapping2.soundcloudLink, STRING_TYPES, "SoundCloud link");
+    expect(mapping2.mixcloudLink, STRING_TYPES, "Mixcloud link");
+    expect(mapping2.tagsRelation, ["relation"], "tags relation");
+    expect(mapping2.showRelation, ["relation"], "show relation");
+    const expectTargetField = (relationField, labelField, label) => {
+      if (!relationField || !labelField) return;
+      const target = attrs[relationField]?.target;
+      const targetModel = target ? strapi2.contentTypes[target] : null;
+      const targetAttr = targetModel?.attributes?.[labelField];
+      if (!targetAttr || !STRING_TYPES.includes(targetAttr.type)) {
+        throw new RcHttpError(
+          400,
+          `"${labelField}" (${label}) must be a string field on ${target ?? "the related type"}`
+        );
+      }
+    };
+    expectTargetField(mapping2.tagsRelation, mapping2.tagsLabelField, "tag label");
+    expectTargetField(mapping2.showRelation, mapping2.showLabelField, "show name");
+  },
+  /** Merge-updates the stored settings. Returns the new effective settings. */
+  async update(patch) {
+    const current = await this.get();
+    const next = deepMerge(current, patch ?? {});
+    if (patch?.theme?.overrides) next.theme.overrides = patch.theme.overrides;
+    this.validateMapping(next.mapping);
+    await this.store().set({ key: "settings", value: next });
+    return next;
+  },
+  /** Cheap authenticated Radio Cult call to prove the key + station work. */
+  async testConnection() {
+    const { apiKey, stationId } = await this.credentials();
+    if (!apiKey || !stationId) {
+      return { ok: false, message: "Enter an API key and station ID first" };
+    }
+    let res;
+    try {
+      res = await fetch(`https://api.radiocult.fm/api/station/${stationId}/media/track`, {
+        headers: { "x-api-key": apiKey },
+        signal: AbortSignal.timeout(15e3)
+      });
+    } catch (error) {
+      return { ok: false, message: `Could not reach Radio Cult: ${error?.message ?? error}` };
+    }
+    if (res.status === 401 || res.status === 403) {
+      return { ok: false, message: "Radio Cult rejected the API key" };
+    }
+    if (res.status === 404) {
+      return { ok: false, message: "Station not found — check the station ID" };
+    }
+    if (!res.ok) {
+      return { ok: false, message: `Radio Cult responded ${res.status}` };
+    }
+    return { ok: true, message: "Connected to Radio Cult ✓" };
+  }
+});
+const LINK_KEY = {
+  soundcloud: "soundcloudLink",
+  mixcloud: "mixcloudLink"
+};
+const mapping = ({ strapi: strapi2 }) => ({
+  settings() {
+    return strapi2.plugin(PLUGIN_ID).service("settings");
+  },
+  async mapping() {
+    return (await this.settings().get()).mapping;
+  },
+  /** Throws 503 until a content type + title field have been mapped. */
+  async requireMapping() {
+    const mapping2 = await this.mapping();
+    if (!mapping2.contentType || !mapping2.title) {
+      throw new RcHttpError(
+        503,
+        "The uploader is not set up yet — map your episode content type in Settings → Radio Cult Uploader"
+      );
+    }
+    if (!strapi2.contentTypes[mapping2.contentType]) {
+      throw new RcHttpError(
+        503,
+        `The mapped content type "${mapping2.contentType}" no longer exists — update the plugin settings`
+      );
+    }
+    return mapping2;
+  },
+  /** Populate object covering every mapped relation/media field. */
+  populateFor(mapping2) {
+    const populate = {};
+    for (const field of [mapping2.image, mapping2.tagsRelation, mapping2.showRelation]) {
+      if (field) populate[field] = true;
+    }
+    return populate;
+  },
+  normalise(mapping2, entry) {
+    const tagsRaw = mapping2.tagsRelation ? entry[mapping2.tagsRelation] : null;
+    const tagEntries = Array.isArray(tagsRaw) ? tagsRaw : tagsRaw ? [tagsRaw] : [];
+    const tags = mapping2.tagsLabelField ? tagEntries.map((tag) => tag?.[mapping2.tagsLabelField]).filter(Boolean) : [];
+    const showRaw = mapping2.showRelation ? entry[mapping2.showRelation] : null;
+    const show = Array.isArray(showRaw) ? showRaw[0] : showRaw;
+    return {
+      documentId: entry.documentId,
+      title: mapping2.title && entry[mapping2.title] || "",
+      image: mapping2.image && entry[mapping2.image] || null,
+      broadcastDate: mapping2.broadcastDate && entry[mapping2.broadcastDate] || null,
+      tags,
+      showName: mapping2.showLabelField && show?.[mapping2.showLabelField] || "",
+      links: {
+        soundcloud: mapping2.soundcloudLink && entry[mapping2.soundcloudLink] || null,
+        mixcloud: mapping2.mixcloudLink && entry[mapping2.mixcloudLink] || null
+      },
+      raw: entry
+    };
+  },
+  /** Loads one mapped entry (with relations populated) or throws 404. */
+  async loadEntry(documentId) {
+    const mapping2 = await this.requireMapping();
+    const entry = await strapi2.documents(mapping2.contentType).findOne({
+      documentId,
+      populate: this.populateFor(mapping2)
+    });
+    if (!entry) throw new RcHttpError(404, "Entry not found");
+    return this.normalise(mapping2, entry);
+  },
+  /**
+   * Writes platform links back onto the user's entry. Only the mapped link
+   * fields are touched. Uses the db layer (like the pre-plugin code) so the
+   * write lands directly on the stored row without a draft/publish cycle.
+   */
+  async writeLinks(documentId, links) {
+    const mapping2 = await this.requireMapping();
+    const data = {};
+    for (const platform of PLATFORMS) {
+      const url = links[platform];
+      const field = mapping2[LINK_KEY[platform]];
+      if (url && field) data[field] = url;
+    }
+    if (Object.keys(data).length === 0) return [];
+    await strapi2.db.query(mapping2.contentType).update({ where: { documentId }, data });
+    return Object.keys(data);
+  },
+  /**
+   * Content types + attributes for the settings page's mapping selects.
+   * Only user-created (api::) types; attributes reduced to what the UI needs.
+   */
+  listContentTypes() {
+    return Object.entries(strapi2.contentTypes).filter(([uid]) => uid.startsWith("api::")).map(([uid, model]) => ({
+      uid,
+      displayName: model.info?.displayName ?? uid,
+      attributes: Object.entries(model.attributes ?? {}).map(([name, attr]) => ({
+        name,
+        type: attr.type,
+        target: attr.target ?? null,
+        targetAttributes: attr.type === "relation" && attr.target ? Object.entries(
+          strapi2.contentTypes[attr.target]?.attributes ?? {}
+        ).filter(
+          ([, targetAttr]) => ["string", "text"].includes(targetAttr.type)
+        ).map(([targetName]) => targetName) : null
+      }))
+    }));
+  }
+});
+const REQUESTED_AT = {
+  mixcloud: "mixcloudRequestedAt",
+  soundcloud: "soundcloudRequestedAt"
+};
+const records = ({ strapi: strapi2 }) => ({
+  /** The record for one entry, or null. */
+  async find(contentTypeUid, entryDocumentId) {
+    return await strapi2.db.query(TRACK_RECORD_UID).findOne({ where: { contentTypeUid, entryDocumentId } });
+  },
+  /** Creates or updates the record for one entry (service-level uniqueness). */
+  async upsert(contentTypeUid, entryDocumentId, data) {
+    const existing = await this.find(contentTypeUid, entryDocumentId);
+    if (existing) {
+      return await strapi2.db.query(TRACK_RECORD_UID).update({ where: { id: existing.id }, data });
+    }
+    return await strapi2.db.query(TRACK_RECORD_UID).create({ data: { contentTypeUid, entryDocumentId, ...data } });
+  },
+  /** All records with an uploaded track for the given content type. */
+  async findUploaded(contentTypeUid, entryDocumentIds) {
+    return await strapi2.db.query(TRACK_RECORD_UID).findMany({
+      where: {
+        contentTypeUid,
+        trackId: { $notNull: true },
+        ...entryDocumentIds ? { entryDocumentId: { $in: entryDocumentIds } } : {}
+      }
+    });
+  }
+});
+async function existingTagLength(filePath) {
+  const handle = await fs__default.default.promises.open(filePath, "r");
+  try {
+    const header = Buffer.alloc(10);
+    const { bytesRead } = await handle.read(header, 0, 10, 0);
+    if (bytesRead < 10 || header.toString("latin1", 0, 3) !== "ID3") return 0;
+    const size = (header[6] & 127) << 21 | (header[7] & 127) << 14 | (header[8] & 127) << 7 | header[9] & 127;
+    const hasFooter = (header[5] & 16) !== 0;
+    return 10 + size + (hasFooter ? 10 : 0);
+  } finally {
+    await handle.close();
+  }
+}
+async function embedArtworkMp3(srcPath, opts) {
+  const tagBuffer = NodeID3__default.default.create({
+    title: opts.title,
+    artist: opts.artist,
+    album: opts.album,
+    image: {
+      mime: opts.imageMime,
+      type: { id: 3, name: "front cover" },
+      description: "cover",
+      imageBuffer: opts.imageBuffer
+    }
+  });
+  const audioStart = await existingTagLength(srcPath);
+  const outPath = path__default.default.join(
+    os__default.default.tmpdir(),
+    `radiocult-${Date.now()}-${crypto__default.default.randomBytes(4).toString("hex")}.mp3`
+  );
+  await fs__default.default.promises.writeFile(outPath, tagBuffer);
+  await promises.pipeline(
+    fs__default.default.createReadStream(srcPath, { start: audioStart }),
+    fs__default.default.createWriteStream(outPath, { flags: "a" })
+  );
+  return outPath;
+}
+const RC_BASE = "https://api.radiocult.fm";
+const MAX_TRACK_BYTES = 750 * 1024 * 1024;
+const MAX_PUBLISH_ARTWORK_BYTES = 2 * 1024 * 1024;
+const MAX_EMBED_ARTWORK_BYTES = 10 * 1024 * 1024;
+const PUBLISH_RETRY_GUARD_MS = 10 * 60 * 1e3;
+const STALLED_AFTER_MS = 7 * 24 * 60 * 60 * 1e3;
+const TRACK_LIST_CACHE_MS = 20 * 1e3;
+const RC_URL_FIELD = {
+  mixcloud: "mixcloudUrl",
+  soundcloud: "soundcloudUrl"
+};
+const albumFor = (broadcastDate) => new Date(broadcastDate ?? Date.now()).toLocaleDateString("en-GB", {
+  month: "long",
+  year: "numeric"
+});
+let rateLimitedUntil = 0;
+let trackListCache = null;
+const cleanString = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+function platformState(entry, record, platform) {
+  const link = entry.links[platform];
+  const requestedAt = record?.[REQUESTED_AT[platform]] ?? null;
+  let state = "not_published";
+  if (link) state = "linked";
+  else if (requestedAt) {
+    state = Date.now() - new Date(requestedAt).getTime() > STALLED_AFTER_MS ? "stalled" : "publishing";
+  }
+  return { state, requestedAt, link: link ?? null };
+}
+function awaitingLink(entry, record, platform) {
+  if (entry.links[platform]) return false;
+  const { state } = platformState(entry, record, platform);
+  if (state === "publishing") return true;
+  if (state !== "not_published") return false;
+  const uploadedAt = record?.uploadedAt;
+  return !!uploadedAt && Date.now() - new Date(uploadedAt).getTime() < STALLED_AFTER_MS;
+}
+const radiocult = ({ strapi: strapi2 }) => {
+  const settings2 = () => strapi2.plugin(PLUGIN_ID).service("settings");
+  const mapping2 = () => strapi2.plugin(PLUGIN_ID).service("mapping");
+  const records2 = () => strapi2.plugin(PLUGIN_ID).service("records");
+  const assertConfigured = async () => {
+    const { apiKey, stationId, enabled } = await settings2().credentials();
+    if (!enabled) {
+      throw new RcHttpError(503, "Radio Cult uploads are switched off in the plugin settings");
+    }
+    if (!apiKey || !stationId) {
+      throw new RcHttpError(
+        503,
+        "Radio Cult is not configured — set the API key and station ID in Settings → Radio Cult Uploader"
+      );
+    }
+    return { apiKey, stationId };
+  };
+  const isUsable = async () => {
+    const { apiKey, stationId, enabled } = await settings2().credentials();
+    return enabled && !!apiKey && !!stationId;
+  };
+  async function rcFetch(pathname, init = {}, timeoutMs) {
+    const { apiKey, stationId } = await assertConfigured();
+    const method = init.method ?? "GET";
+    if (Date.now() < rateLimitedUntil) {
+      strapi2.log.warn(
+        `radiocult api: ${method} ${pathname} skipped — rate limited until ${new Date(rateLimitedUntil).toISOString()}`
+      );
+      throw new RcHttpError(
+        429,
+        `Radio Cult rate limit hit — try again after ${new Date(rateLimitedUntil).toLocaleTimeString("en-GB")}`
+      );
+    }
+    let res;
+    try {
+      res = await fetch(`${RC_BASE}/api/station/${stationId}${pathname}`, {
+        ...init,
+        headers: { "x-api-key": apiKey, ...init.headers ?? {} },
+        signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : void 0
+      });
+    } catch (error) {
+      strapi2.log.error(
+        `radiocult api: ${method} ${pathname} network failure: ${error?.stack ?? error}`
+      );
+      throw new RcHttpError(502, `Could not reach Radio Cult: ${error?.message ?? error}`);
+    }
+    if (res.status === 429) {
+      const retryAfter = Number(res.headers.get("retry-after")) || 60;
+      rateLimitedUntil = Date.now() + retryAfter * 1e3;
+      strapi2.log.warn(
+        `radiocult api: ${method} ${pathname} → 429, backing off ${retryAfter}s (until ${new Date(rateLimitedUntil).toISOString()})`
+      );
+      throw new RcHttpError(
+        429,
+        `Radio Cult rate limit hit — try again after ${new Date(rateLimitedUntil).toLocaleTimeString("en-GB")}`
+      );
+    }
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      strapi2.log.error(
+        `radiocult api: ${method} ${pathname} → ${res.status}: ${body.slice(0, 1e3)}`
+      );
+      if (res.status === 402) {
+        const isMixcloudPublish = pathname.endsWith("/upload/mixcloud");
+        throw new RcHttpError(
+          402,
+          isMixcloudPublish ? `Radio Cult refused the Mixcloud publish with 402: ${body.slice(0, 200)}. If your plan covers third-party publishing, this is a known fault on Radio Cult's side — publish this one by hand in the Radio Cult dashboard (Media → the track → Actions → Upload to Mixcloud); the link will still be saved to the entry automatically. Otherwise, third-party publishing needs Radio Cult Premium/Business or the Connect add-on.` : `Radio Cult refused with 402: ${body.slice(0, 200)}. Per Radio Cult's docs this means the station's plan doesn't cover this endpoint — third-party publishing needs Premium/Business or the Connect add-on.`
+        );
+      }
+      throw new RcHttpError(
+        res.status >= 500 ? 502 : res.status,
+        `Radio Cult responded ${res.status}: ${body.slice(0, 300)}`
+      );
+    }
+    strapi2.log.debug(`radiocult api: ${method} ${pathname} → ${res.status}`);
+    return res;
+  }
+  async function resolveArtwork(image, maxBytes) {
+    if (!image?.url) return null;
+    const candidates = [image.formats?.large, image.formats?.medium, image].filter(Boolean);
+    for (const candidate of candidates) {
+      const mime = candidate.mime ?? image.mime;
+      if (mime !== "image/jpeg" && mime !== "image/png") continue;
+      if (candidate.size && candidate.size * 1024 > maxBytes) continue;
+      try {
+        let buffer;
+        if (candidate.url.startsWith("http")) {
+          const res = await fetch(candidate.url, { signal: AbortSignal.timeout(3e4) });
+          if (!res.ok) continue;
+          buffer = Buffer.from(await res.arrayBuffer());
+        } else {
+          const diskPath = path__default.default.join(strapi2.dirs.static.public, candidate.url);
+          try {
+            buffer = await fs__default.default.promises.readFile(diskPath);
+          } catch {
+            const serverUrl = strapi2.config.get("server.url", "http://localhost:1337");
+            const res = await fetch(`${serverUrl}${candidate.url}`, {
+              signal: AbortSignal.timeout(3e4)
+            });
+            if (!res.ok) continue;
+            buffer = Buffer.from(await res.arrayBuffer());
+          }
+        }
+        if (buffer.length > maxBytes) continue;
+        return { buffer, mime, name: candidate.name ?? image.name ?? "artwork" };
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  function describeImage(image) {
+    if (!image?.url) return null;
+    const usable = [image.formats?.large, image.formats?.medium, image].filter(Boolean).some((candidate) => {
+      const mime = candidate.mime ?? image.mime;
+      if (mime !== "image/jpeg" && mime !== "image/png") return false;
+      return !candidate.size || candidate.size * 1024 <= MAX_PUBLISH_ARTWORK_BYTES;
+    });
+    return {
+      name: image.name ?? "entry image",
+      previewUrl: image.formats?.small?.url ?? image.formats?.thumbnail?.url ?? image.url,
+      usable
+    };
+  }
+  return {
+    /**
+     * Receives the browser upload (a formidable temp file), embeds artwork
+     * for mp3s, forwards the file to Radio Cult and stores the returned track
+     * id in the plugin's track-record. `meta` carries the (possibly edited)
+     * details from the uploader page; anything missing falls back to the
+     * entry's own values.
+     */
+    async uploadTrack({
+      documentId,
+      file,
+      force,
+      meta = {}
+    }) {
+      await assertConfigured();
+      if (typeof fs__default.default.openAsBlob !== "function") {
+        throw new RcHttpError(501, "Server Node version too old for uploads (needs Node 20+)");
+      }
+      if (!file?.filepath) {
+        throw new RcHttpError(400, 'No audio file received — send it as the "files" field');
+      }
+      const filename = file.originalFilename ?? "episode-audio";
+      const ext = path__default.default.extname(filename).toLowerCase();
+      if (ext !== ".mp3" && ext !== ".m4a") {
+        throw new RcHttpError(
+          400,
+          `Radio Cult only accepts .mp3 or .m4a files (got "${ext || "no extension"}")`
+        );
+      }
+      if (file.size > MAX_TRACK_BYTES) {
+        throw new RcHttpError(413, "File is over Radio Cult’s 750MB limit");
+      }
+      const map = await mapping2().requireMapping();
+      const entry = await mapping2().loadEntry(documentId);
+      const record = await records2().find(map.contentType, documentId);
+      if (record?.trackId && !force) {
+        throw new RcHttpError(
+          409,
+          `This entry already has a Radio Cult track (${record.trackId})`
+        );
+      }
+      const defaults = (await settings2().get()).defaults;
+      const title = cleanString(meta.title) ?? entry.title;
+      const artist = cleanString(meta.artist) ?? defaults.artist;
+      const album = cleanString(meta.album) ?? albumFor(entry.broadcastDate);
+      strapi2.log.info(
+        `radiocult: uploading "${filename}" (${Math.round(file.size / 1024 / 1024)}MB) for entry ${documentId} — title "${title}", artist "${artist}", album "${album}"${force ? " (replacing existing track)" : ""}`
+      );
+      const warnings = [];
+      let uploadPath = file.filepath;
+      let embeddedTmpPath = null;
+      if (ext === ".mp3") {
+        const artwork = await resolveArtwork(entry.image, MAX_EMBED_ARTWORK_BYTES);
+        if (artwork) {
+          try {
+            embeddedTmpPath = await embedArtworkMp3(file.filepath, {
+              title,
+              artist,
+              album,
+              imageBuffer: artwork.buffer,
+              imageMime: artwork.mime
+            });
+            uploadPath = embeddedTmpPath;
+          } catch (error) {
+            warnings.push("Could not embed the entry image into the mp3 — uploaded without artwork");
+            strapi2.log.warn(`radiocult: artwork embed failed for ${documentId}: ${error}`);
+          }
+        } else {
+          warnings.push(
+            entry.image ? "Entry image could not be used as artwork (needs to be a jpeg/png under 10MB)" : "No image set on the entry — track uploaded without artwork"
+          );
+        }
+      } else {
+        warnings.push("m4a file: artwork cannot be embedded, so the Radio Cult track will have no image");
+      }
+      try {
+        const formData = new FormData();
+        const mime = ext === ".mp3" ? "audio/mpeg" : "audio/mp4";
+        formData.append(
+          "stationMedia",
+          await fs__default.default.openAsBlob(uploadPath, { type: mime }),
+          filename
+        );
+        formData.append("metadata", JSON.stringify({ title, filename, artist, album }));
+        const res = await rcFetch("/media/track", { method: "POST", body: formData });
+        const body = await res.json().catch(() => ({}));
+        const trackId = body?.track?.id;
+        if (!body?.success || !trackId) {
+          throw new RcHttpError(
+            502,
+            `Unexpected Radio Cult response: ${JSON.stringify(body).slice(0, 300)}`
+          );
+        }
+        try {
+          await records2().upsert(map.contentType, documentId, {
+            trackId,
+            uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            mixcloudRequestedAt: null,
+            soundcloudRequestedAt: null
+          });
+        } catch (error) {
+          strapi2.log.error(
+            `radiocult: track ${trackId} uploaded but saving it for entry ${documentId} failed: ${error}`
+          );
+          throw new RcHttpError(
+            500,
+            `The track reached Radio Cult (id ${trackId}) but saving the id failed — note the id down, then delete the track in the Radio Cult dashboard and re-upload`
+          );
+        }
+        strapi2.log.info(`radiocult: uploaded track ${trackId} for entry ${documentId}`);
+        return { trackId, warnings };
+      } finally {
+        if (embeddedTmpPath) await fs__default.default.promises.unlink(embeddedTmpPath).catch(() => {
+        });
+      }
+    },
+    /**
+     * Asks Radio Cult to publish the entry's track to Mixcloud or SoundCloud.
+     * Radio Cult transfers asynchronously; syncLinks picks up the URL later.
+     * `meta` carries the (possibly edited) details from the uploader page.
+     */
+    async publish({
+      documentId,
+      platform,
+      force,
+      meta = {}
+    }) {
+      await assertConfigured();
+      if (!PLATFORMS.includes(platform)) {
+        throw new RcHttpError(400, `Unknown platform "${platform}"`);
+      }
+      const target = platform;
+      const map = await mapping2().requireMapping();
+      const entry = await mapping2().loadEntry(documentId);
+      const record = await records2().find(map.contentType, documentId);
+      const trackId = record?.trackId;
+      if (!trackId) throw new RcHttpError(409, "Upload the entry to Radio Cult first");
+      const existingLink = entry.links[target];
+      if (existingLink && !force) {
+        throw new RcHttpError(409, `Already published — link saved: ${existingLink}`);
+      }
+      const requestedAt = record?.[REQUESTED_AT[target]];
+      if (requestedAt && !existingLink && Date.now() - new Date(requestedAt).getTime() < PUBLISH_RETRY_GUARD_MS && !force) {
+        throw new RcHttpError(
+          409,
+          `A ${target} publish was requested less than 10 minutes ago — Radio Cult is probably still transferring`
+        );
+      }
+      const defaults = (await settings2().get()).defaults;
+      const title = cleanString(meta.title) ?? entry.title;
+      const description = cleanString(meta.description) ?? defaults.description;
+      const tags = Array.isArray(meta.tags) ? meta.tags.map((tag) => cleanString(tag)).filter((tag) => !!tag) : entry.tags;
+      const artwork = await resolveArtwork(entry.image, MAX_PUBLISH_ARTWORK_BYTES);
+      strapi2.log.info(
+        `radiocult: requesting ${target} publish of track ${trackId} (entry ${documentId}) — title "${title}", tags [${tags.join(", ")}], artwork ${artwork ? artwork.name : "none"}${force ? ", forced" : ""}`
+      );
+      const json = (value) => JSON.stringify(value);
+      const formData = new FormData();
+      if (target === "mixcloud") {
+        formData.append("name", json(title));
+        formData.append("tags", json(tags.slice(0, 5)));
+        formData.append("unlisted", json(false));
+        formData.append("description", json(description));
+        if (artwork) {
+          formData.append(
+            "artwork",
+            new Blob([new Uint8Array(artwork.buffer)], { type: artwork.mime }),
+            artwork.name
+          );
+        }
+      } else {
+        formData.append("title", json(title));
+        formData.append("tags", json(tags));
+        formData.append("description", json(description));
+        formData.append("sharing", json("public"));
+        formData.append("downloadable", "false");
+        formData.append("commentable", "true");
+        formData.append("embeddableBy", json("all"));
+        if (artwork) {
+          formData.append(
+            "artworkData",
+            new Blob([new Uint8Array(artwork.buffer)], { type: artwork.mime }),
+            artwork.name
+          );
+        }
+      }
+      const res = await rcFetch(
+        `/media/track/${trackId}/upload/${target}`,
+        { method: "POST", body: formData },
+        12e4
+      );
+      const body = await res.json().catch(() => ({}));
+      if (body?.success === false) {
+        throw new RcHttpError(502, `Radio Cult rejected the ${target} publish request`);
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await records2().upsert(map.contentType, documentId, { [REQUESTED_AT[target]]: now });
+      strapi2.log.info(`radiocult: requested ${target} publish of track ${trackId} (${documentId})`);
+      return { requestedAt: now };
+    },
+    /**
+     * Finds entries whose publish was requested but whose link hasn't
+     * arrived, fetches Radio Cult's track list ONCE, and writes any links
+     * that appeared back onto the mapped fields. Called by the cron sweep,
+     * the status endpoint and the "check now" button.
+     */
+    async syncLinks({
+      documentIds,
+      bypassCache
+    } = {}) {
+      if (!await isUsable()) return { updated: 0, pending: 0 };
+      const map = await mapping2().mapping();
+      if (!map.contentType || !map.title) return { updated: 0, pending: 0 };
+      if (!map.soundcloudLink && !map.mixcloudLink) return { updated: 0, pending: 0 };
+      const allRecords = await records2().findUploaded(map.contentType, documentIds);
+      const pending = [];
+      for (const record of allRecords) {
+        const raw = await strapi2.documents(map.contentType).findOne({
+          documentId: record.entryDocumentId,
+          populate: mapping2().populateFor(map)
+        });
+        if (!raw) continue;
+        const entry = mapping2().normalise(map, raw);
+        if (PLATFORMS.some((p) => awaitingLink(entry, record, p))) pending.push({ record, entry });
+      }
+      if (pending.length === 0) return { updated: 0, pending: 0 };
+      if (!trackListCache || bypassCache || Date.now() - trackListCache.fetchedAt > TRACK_LIST_CACHE_MS) {
+        const res = await rcFetch("/media/track", { method: "GET" }, 6e4);
+        const body = await res.json().catch(() => ({}));
+        const tracks = Array.isArray(body) ? body : body.tracks ?? body.results ?? body.data ?? [];
+        trackListCache = {
+          fetchedAt: Date.now(),
+          byId: new Map(tracks.map((track) => [track.id, track]))
+        };
+      }
+      let updated = 0;
+      for (const { record, entry } of pending) {
+        const track = trackListCache.byId.get(record.trackId);
+        if (!track) continue;
+        const links = {};
+        for (const platform of PLATFORMS) {
+          const url = track[RC_URL_FIELD[platform]];
+          if (url && awaitingLink(entry, record, platform)) links[platform] = url;
+        }
+        const written = await mapping2().writeLinks(record.entryDocumentId, links);
+        if (written.length > 0) {
+          await records2().upsert(map.contentType, record.entryDocumentId, {
+            lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          updated += 1;
+          strapi2.log.info(
+            `radiocult: saved ${written.join(", ")} for entry ${record.entryDocumentId}`
+          );
+        }
+      }
+      return { updated, pending: pending.length };
+    },
+    /**
+     * Per-entry state for the panel and the uploader page. Includes the
+     * entry details the uploader page prefills its editable form with.
+     */
+    async getStatus(documentId, { refresh } = {}) {
+      const map = await mapping2().requireMapping();
+      let entry = await mapping2().loadEntry(documentId);
+      let record = await records2().find(map.contentType, documentId);
+      let rateLimitMessage = null;
+      const hasPending = PLATFORMS.some((p) => awaitingLink(entry, record, p));
+      if (record?.trackId && (hasPending || refresh)) {
+        try {
+          await this.syncLinks({ documentIds: [documentId], bypassCache: refresh });
+          entry = await mapping2().loadEntry(documentId);
+          record = await records2().find(map.contentType, documentId);
+        } catch (error) {
+          if (error instanceof RcHttpError && error.status === 429) {
+            rateLimitMessage = error.message;
+          } else {
+            throw error;
+          }
+        }
+      }
+      const pluginSettings = await settings2().get();
+      return {
+        enabled: await isUsable(),
+        trackId: record?.trackId ?? null,
+        uploadedAt: record?.uploadedAt ?? null,
+        platforms: {
+          mixcloud: platformState(entry, record, "mixcloud"),
+          soundcloud: platformState(entry, record, "soundcloud")
+        },
+        rateLimitMessage,
+        // Prefill values for the uploader page's editable form.
+        details: {
+          title: entry.title,
+          // The show this entry belongs to — the uploader page uses it as the
+          // browser tab title so several open tabs stay tellable apart.
+          showName: entry.showName,
+          artist: pluginSettings.defaults.artist,
+          album: albumFor(entry.broadcastDate),
+          description: pluginSettings.defaults.description,
+          genres: entry.tags,
+          image: describeImage(entry.image)
+        }
+      };
+    },
+    /**
+     * Pushes edited title/artist/album to an already-uploaded Radio Cult
+     * track (the uploader page's "Save details to Radio Cult" button).
+     */
+    async updateTrackMetadata({
+      documentId,
+      meta
+    }) {
+      const map = await mapping2().requireMapping();
+      const record = await records2().find(map.contentType, documentId);
+      if (!record?.trackId) {
+        throw new RcHttpError(409, "Upload the entry to Radio Cult first");
+      }
+      const data = {};
+      if (cleanString(meta.title)) data.title = cleanString(meta.title);
+      if (cleanString(meta.artist)) data.artist = cleanString(meta.artist);
+      if (cleanString(meta.album)) data.album = cleanString(meta.album);
+      if (Object.keys(data).length === 0) {
+        throw new RcHttpError(400, "Nothing to update — title, artist and album are all empty");
+      }
+      await rcFetch(
+        `/media/track/${record.trackId}`,
+        {
+          method: "PUT",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(data)
+        },
+        6e4
+      );
+      strapi2.log.info(
+        `radiocult: updated track ${record.trackId} details for entry ${documentId} (${Object.keys(data).join(", ")})`
+      );
+      return { updated: Object.keys(data) };
+    },
+    /**
+     * Lifecycle hook body: pushes a changed title to the Radio Cult track.
+     * Only fires when the mapped title field actually changed (beforeUpdate
+     * stashes the previous value) — the track title can be customised on the
+     * uploader page, and an unrelated save must not overwrite it.
+     */
+    async maybeSyncTitle(event) {
+      if (!await isUsable()) return;
+      const map = await mapping2().mapping();
+      if (!map.contentType || !map.title) return;
+      if (event.model?.uid !== map.contentType) return;
+      const title = event.params?.data?.[map.title];
+      if (typeof title !== "string" || !title.trim()) return;
+      const previousTitle = event.state?.radiocultPreviousTitle;
+      if (typeof previousTitle === "string" && previousTitle === title) return;
+      const documentId = event.result?.documentId;
+      if (!documentId) return;
+      const record = await records2().find(map.contentType, documentId);
+      if (!record?.trackId) return;
+      await rcFetch(
+        `/media/track/${record.trackId}`,
+        {
+          method: "PUT",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ title })
+        },
+        6e4
+      );
+      strapi2.log.info(
+        `radiocult: synced title of track ${record.trackId} for entry ${documentId}`
+      );
+    }
+  };
+};
+const services = {
+  settings,
+  mapping,
+  records,
+  radiocult
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+exports.default = index;