@owncast/plugin-sdk 0.5.0 → 0.10.1

package/index.js

@@ -3,15 +3,18 @@
 // Authors define typed handlers (onChatMessage, filterChatMessage, ...) plus
 // an `on: { [customEvent]: handler }` object for plugin-emitted events. The
 // SDK derives the manifest's subscriptions from which handlers are present
-// and returns them via register(); authors don't maintain a duplicate list.
+// and returns them via register(). Authors don't maintain a duplicate list.
 
 let registered = null;
 
+// Command registrations used for matching, dispatch, and the unified `!help`.
+const commandManifest = [];
+
 // Host-driven timers. The sandbox has no setTimeout, so owncast.timer.* asks
 // the host to schedule a callback and call back via the internal "timer.fire"
 // event. The author's callback stays here in the long-lived instance, keyed by
 // a guest-allocated id the host echoes back. State persists across calls
-// because the plugin instance is reused; timers are dropped on reload.
+// because the plugin instance is reused. Timers are dropped on reload.
 let nextTimerId = 1;
 const timerCallbacks = new Map(); // id -> { fn, repeat }
 
@@ -38,13 +41,22 @@ const Events = Object.freeze({
   // Once-a-second tick for periodic work (opt in by defining onTick)
   Tick: "tick",
   // Fediverse, engagement (metadata only) + inbound posts (with content)
+  FediverseActivity: "fediverse.activity",
   FediverseFollow: "fediverse.follow",
   FediverseLike: "fediverse.like",
   FediverseRepost: "fediverse.repost",
+  FediverseQuote: "fediverse.quote",
   FediverseMention: "fediverse.mention",
   FediverseReply: "fediverse.reply",
 });
 
+const InternalEvents = Object.freeze({
+  ChatCommand: "chat.command",
+  TimerFire: "timer.fire",
+});
+
+const DefaultCommandPrefix = "!";
+
 const Permissions = Object.freeze({
   ChatSend: "chat.send",
   ChatHistory: "chat.history",
@@ -60,7 +72,10 @@ const Permissions = Object.freeze({
   NotificationsSend: "notifications.send",
   UsersRead: "users.read",
   UsersModerate: "users.moderate",
+  UsersRegister: "users.register",
+  AuthGate: "auth.gate",
   FediversePost: "fediverse.post",
+  FediverseInbound: "fediverse.inbound",
   HttpSSE: "http.sse",
   VideoConfigRead: "videoconfig.read",
   VideoConfigWrite: "videoconfig.write",
@@ -79,6 +94,30 @@ const filter = Object.freeze({
   },
 });
 
+// Verdict helpers for onAuthCheck (the optional re-validation hook the host runs
+// on a viewer's page load). `ok` keeps the session, `refresh` keeps it and
+// extends the cookie (optional `ttl` seconds), and `deny` ends it and bounces
+// the viewer back to the login screen.
+const authCheck = Object.freeze({
+  ok() {
+    return { action: "ok" };
+  },
+  refresh(opts) {
+    return { action: "refresh", ...(opts || {}) };
+  },
+  deny(reason) {
+    return { action: "deny", reason: reason || "" };
+  },
+});
+
+// dispatchAuthCheck routes the host's re-validation call to the author's
+// onAuthCheck handler. No handler → always "ok" (the hook is optional, and a
+// plugin that doesn't implement it simply never revokes mid-session).
+function dispatchAuthCheck(req) {
+  if (!registered || !isFn(registered.onAuthCheck)) return { action: "ok" };
+  return registered.onAuthCheck(req) || { action: "ok" };
+}
+
 // Distinguishes notification handlers from filter handlers in the HANDLERS
 // map below. Internal, not part of the public API.
 const HandlerKind = Object.freeze({
@@ -121,6 +160,11 @@ const HANDLERS = Object.freeze({
   onSseDisconnect: { event: Events.SseDisconnect, kind: HandlerKind.Notify },
   // Once-a-second tick
   onTick: { event: Events.Tick, kind: HandlerKind.Notify },
+  // Verified inbound ActivityPub activity (raw JSON object)
+  onFediverse: {
+    event: Events.FediverseActivity,
+    kind: HandlerKind.Notify,
+  },
   // Fediverse engagement (actor + target metadata)
   onFediverseFollow: {
     event: Events.FediverseFollow,
@@ -131,6 +175,10 @@ const HANDLERS = Object.freeze({
     event: Events.FediverseRepost,
     kind: HandlerKind.Notify,
   },
+  onFediverseQuote: {
+    event: Events.FediverseQuote,
+    kind: HandlerKind.Notify,
+  },
   // Fediverse inbound posts (with content)
   onFediverseMention: {
     event: Events.FediverseMention,
@@ -139,123 +187,70 @@ const HANDLERS = Object.freeze({
   onFediverseReply: { event: Events.FediverseReply, kind: HandlerKind.Notify },
 });
 
-// typeof comparisons in well-known categories. JS guarantees these strings,
-// but we go through named constants so a stray typo can't pass silently.
-const JsType = Object.freeze({
-  Function: "function",
-  Object: "object",
-});
-const isFn = (x) => typeof x === JsType.Function;
-const isObj = (x) => x !== null && typeof x === JsType.Object;
+const isFn = (x) => typeof x === "function";
+const isObj = (x) => x !== null && typeof x === "object";
 
 function definePlugin(def) {
   registered = def;
-  return def;
-}
+  commandManifest.length = 0;
+  if (!def || !isObj(def.commands)) return def;
 
-// defineCommands builds a chat-command router so plugins stop reimplementing
-// prefix parsing, aliases, per-user cooldowns, and moderator gating. It returns
-// a function you feed a ChatMessage (from onChatMessage or filterChatMessage);
-// it parses the command and invokes the matching handler's run(ctx). The return
-// value is true when the message was a command (even if gated), false when it
-// wasn't — so a filter can drop command messages from chat:
-//
-//   const commands = defineCommands({
-//     prefix: "!",
-//     commands: {
-//       uptime: { run: (ctx) => ctx.reply("up!") },
-//       ban: { modOnly: true, cooldownMs: 5000, run: (ctx) => ctx.reply(`bye ${ctx.args[0]}`) },
-//     },
-//   });
-//   module.exports = definePlugin({
-//     onChatMessage: commands,
-//     // or, to hide command messages from chat:
-//     // filterChatMessage: (msg) => (commands(msg) ? filter.drop("command") : filter.pass()),
-//   });
-//
-// run(ctx) receives { msg, user, command, args, argString, reply, replyPrivately }.
-// reply posts publicly; replyPrivately whispers to the sender (falling back to a
-// public post if their connection is unknown). Optional hooks: per-command or
-// top-level onCooldown(ctx) / onDenied(ctx), and a top-level onUnknown(ctx).
-function defineCommands(config) {
-  config = config || {};
-  const prefix = config.prefix || "!";
-  const caseSensitive = !!config.caseSensitive;
-  const norm = (s) => (caseSensitive ? s : s.toLowerCase());
-
-  // Resolve every name and alias to its canonical command definition.
-  const table = new Map();
-  const defs = config.commands || {};
-  for (const name of Object.keys(defs)) {
-    const def = defs[name];
-    table.set(norm(name), { name, def });
-    for (const alias of def.aliases || []) table.set(norm(alias), { name, def });
+  const prefix =
+    def.commandPrefix == null ? DefaultCommandPrefix : def.commandPrefix;
+  if (typeof prefix !== "string" || prefix.length === 0) {
+    throw new TypeError("commandPrefix must be a non-empty string");
   }
-
-  // Per-(command,user) cooldown clock, in memory for the plugin's lifetime.
-  const lastRun = new Map();
-
-  return function handle(msg) {
-    const body = (msg && msg.body) || "";
-    if (!body.startsWith(prefix)) return false;
-    const rest = body.slice(prefix.length);
-    const parts = rest.split(/\s+/).filter(Boolean);
-    if (parts.length === 0) return false;
-    const called = parts[0];
-    const args = parts.slice(1);
-    const argString = rest.slice(called.length).trim();
-
-    const ctx = {
-      msg,
-      user: msg && msg.user,
-      command: norm(called),
-      args,
-      argString,
-      reply: (text) => owncast.chat.send(text),
-      replyPrivately: (text) => {
-        if (!owncast.chat.replyTo(msg, text)) owncast.chat.send(text);
-      },
-    };
-
-    const entry = table.get(norm(called));
-    if (!entry) {
-      if (isFn(config.onUnknown)) config.onUnknown(ctx);
-      return false;
+  const caseSensitive = !!def.commandsCaseSensitive;
+  for (const name of Object.keys(def.commands)) {
+    const command = def.commands[name];
+    if (!isObj(command)) {
+      throw new TypeError(`command "${name}" must be an object`);
     }
-    const { name, def } = entry;
-    ctx.command = name;
-
-    // Moderator gating: the sender's scopes must include MODERATOR.
-    if (def.modOnly) {
-      const scopes = (msg.user && msg.user.scopes) || [];
-      if (!scopes.includes("MODERATOR")) {
-        if (isFn(def.onDenied)) def.onDenied(ctx);
-        else if (isFn(config.onDenied)) config.onDenied(ctx);
-        return true; // matched a command, but the caller wasn't allowed
-      }
+    const aliases = command.aliases == null ? [] : command.aliases;
+    if (
+      !Array.isArray(aliases) ||
+      !aliases.every((alias) => typeof alias === "string")
+    ) {
+      throw new TypeError(`command "${name}" aliases must be an array of strings`);
     }
-
-    // Per-user cooldown, clocked off msg.timestamp so it's deterministic in
-    // tests and independent of any sandbox clock quirks.
-    const cooldownMs = def.cooldownMs || 0;
-    if (cooldownMs > 0) {
-      const userId =
-        (msg.user && msg.user.id) ||
-        (msg.clientId != null ? `c${msg.clientId}` : "anon");
-      const key = `${name}${userId}`;
-      const now = msg.timestamp ? new Date(msg.timestamp).getTime() : 0;
-      const prev = lastRun.get(key);
-      if (now && prev && now - prev < cooldownMs) {
-        if (isFn(def.onCooldown)) def.onCooldown(ctx);
-        else if (isFn(config.onCooldown)) config.onCooldown(ctx);
-        return true;
-      }
-      if (now) lastRun.set(key, now);
+    const cooldownMs =
+      command.cooldownMs == null ? 0 : command.cooldownMs;
+    if (!Number.isSafeInteger(cooldownMs) || cooldownMs < 0) {
+      throw new TypeError(`command "${name}" cooldownMs must be a non-negative integer`);
     }
+    commandManifest.push({
+      name,
+      prefix,
+      description: command.description || "",
+      usage: command.usage || "",
+      aliases,
+      modOnly: !!command.modOnly,
+      caseSensitive,
+      cooldownMs,
+    });
+  }
+  return def;
+}
 
-    if (isFn(def.run)) def.run(ctx);
-    return true;
-  };
+function dispatchCommand(event) {
+  if (!isObj(event)) return;
+  if (!registered || !isObj(registered.commands)) return;
+  const command = registered.commands[event.command];
+  if (!command || !isFn(command.run)) return;
+
+  const msg = event.message;
+  command.run({
+    msg,
+    user: msg && msg.user,
+    command: event.command,
+    invokedAs: event.invokedAs || event.command,
+    args: event.args || [],
+    argString: event.argString || "",
+    reply: (text) => owncast.chat.send(text),
+    replyPrivately: (text) => {
+      if (!owncast.chat.replyTo(msg, text)) owncast.chat.send(text);
+    },
+  });
 }
 
 // Used by the build-generated entry to compute subscriptions for register().
@@ -286,12 +281,18 @@ function describeSubscriptions() {
   return { notify, filter: filterSubs };
 }
 
+// Used by the build-generated entry to report command registrations to the
+// host for matching, dispatch, and the unified `!help`.
+function describeCommands() {
+  return commandManifest;
+}
+
 function dispatchEvent(envelope) {
   const { eventType, payload } = envelope;
   // Internal: a host-scheduled timer elapsed. Run the author's callback,
   // dropping one-shot entries first so a throw still cleans up. Not routed to
   // user handlers or the `on` map.
-  if (eventType === "timer.fire") {
+  if (eventType === InternalEvents.TimerFire) {
     const id = payload && payload.id;
     const entry = timerCallbacks.get(id);
     if (entry) {
@@ -300,6 +301,10 @@ function dispatchEvent(envelope) {
     }
     return;
   }
+  if (eventType === InternalEvents.ChatCommand) {
+    dispatchCommand(payload);
+    return;
+  }
   if (!registered) return;
   for (const [method, info] of Object.entries(HANDLERS)) {
     if (
@@ -350,7 +355,7 @@ function dispatchHttp(request) {
 // host runtime captures), so a plugin author running `owncast-plugin
 // serve` or hitting the host's logs sees exactly which permission to
 // add to their manifest. apiName is the SDK call the author wrote
-// (e.g. "owncast.actions.set"); perm is the manifest permission string.
+// (e.g. "owncast.actions.set"). perm is the manifest permission string.
 function permError(apiName, perm) {
   const msg = `${apiName} requires the '${perm}' permission. Add it to your plugin.manifest.json's "permissions" array.`;
   console.error(`[owncast-plugin] ${msg}`);
@@ -378,50 +383,45 @@ function scheduleTimer(fn, ms, repeat) {
   return id;
 }
 
+// hostFns returns the host import table, throwing an actionable error if the
+// named function wasn't granted (the plugin's manifest is missing its
+// permission). This is the per-call guard every owncast.* method used to inline.
+function hostFns(name, perm) {
+  const fns = Host.getFunctions();
+  if (!fns[name]) throw new Error(`permission '${perm}' not granted`);
+  return fns;
+}
+
 const owncast = {
   chat: {
     send(text) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_send_chat)
-        throw new Error(`permission '${Permissions.ChatSend}' not granted`);
+      const fns = hostFns("owncast_send_chat", Permissions.ChatSend);
       fns.owncast_send_chat(Memory.fromString(text).offset);
     },
     sendAction(text) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_send_chat_action)
-        throw new Error(`permission '${Permissions.ChatSend}' not granted`);
+      const fns = hostFns("owncast_send_chat_action", Permissions.ChatSend);
       fns.owncast_send_chat_action(Memory.fromString(text).offset);
     },
     system(body) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_send_chat_system)
-        throw new Error(`permission '${Permissions.ChatSend}' not granted`);
+      const fns = hostFns("owncast_send_chat_system", Permissions.ChatSend);
       fns.owncast_send_chat_system(Memory.fromString(body).offset);
     },
     history(limit) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_chat_history)
-        throw new Error(`permission '${Permissions.ChatHistory}' not granted`);
+      const fns = hostFns("owncast_chat_history", Permissions.ChatHistory);
       const offset = fns.owncast_chat_history(limit || 0);
       if (offset == 0) return [];
       return JSON.parse(Memory.find(offset).readString());
     },
     deleteMessage(messageId) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_delete_message)
-        throw new Error(`permission '${Permissions.ChatModerate}' not granted`);
+      const fns = hostFns("owncast_delete_message", Permissions.ChatModerate);
       fns.owncast_delete_message(Memory.fromString(String(messageId)).offset);
     },
     kick(clientId) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_kick_client)
-        throw new Error(`permission '${Permissions.ChatModerate}' not granted`);
+      const fns = hostFns("owncast_kick_client", Permissions.ChatModerate);
       fns.owncast_kick_client(BigInt(clientId));
     },
     sendTo(clientId, text) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_send_chat_to)
-        throw new Error(`permission '${Permissions.ChatSend}' not granted`);
+      const fns = hostFns("owncast_send_chat_to", Permissions.ChatSend);
       fns.owncast_send_chat_to(
         BigInt(clientId),
         Memory.fromString(text).offset,
@@ -442,9 +442,7 @@ const owncast = {
       return true;
     },
     clients() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_chat_clients)
-        throw new Error(`permission '${Permissions.ChatHistory}' not granted`);
+      const fns = hostFns("owncast_chat_clients", Permissions.ChatHistory);
       const offset = fns.owncast_chat_clients();
       if (offset == 0) return [];
       return JSON.parse(Memory.find(offset).readString());
@@ -452,27 +450,19 @@ const owncast = {
   },
   users: {
     list() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_users_list)
-        throw new Error(`permission '${Permissions.UsersRead}' not granted`);
+      const fns = hostFns("owncast_users_list", Permissions.UsersRead);
       const offset = fns.owncast_users_list();
       if (offset == 0) return [];
       return JSON.parse(Memory.find(offset).readString());
     },
     get(id) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_user_get)
-        throw new Error(`permission '${Permissions.UsersRead}' not granted`);
+      const fns = hostFns("owncast_user_get", Permissions.UsersRead);
       const offset = fns.owncast_user_get(Memory.fromString(id).offset);
       if (offset == 0) return null;
       return JSON.parse(Memory.find(offset).readString());
     },
     setEnabled(id, enabled, reason) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_user_set_enabled)
-        throw new Error(
-          `permission '${Permissions.UsersModerate}' not granted`,
-        );
+      const fns = hostFns("owncast_user_set_enabled", Permissions.UsersModerate);
       fns.owncast_user_set_enabled(
         Memory.fromString(id).offset,
         enabled ? 1 : 0,
@@ -480,21 +470,54 @@ const owncast = {
       );
     },
     banIP(ip) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_ban_ip)
-        throw new Error(
-          `permission '${Permissions.UsersModerate}' not granted`,
-        );
+      const fns = hostFns("owncast_ban_ip", Permissions.UsersModerate);
       fns.owncast_ban_ip(Memory.fromString(ip).offset);
     },
+    // Find-or-create an authenticated Owncast user for an external identity
+    // (e.g. a provider account). `authId` is the stable provider-scoped id. The
+    // host namespaces it by this plugin's slug so it can't collide with or spoof
+    // another plugin's users. Optionally seeds displayName and scopes. Returns
+    // { userId }. Throws on host error. Requires `users.register`.
+    register(opts) {
+      const fns = hostFns("owncast_users_register", Permissions.UsersRegister);
+      const req =
+        typeof opts === "string" ? { authId: opts } : opts || {};
+      const offset = fns.owncast_users_register(
+        Memory.fromString(JSON.stringify(req)).offset,
+      );
+      if (offset == 0) throw new Error("users.register failed");
+      const result = JSON.parse(Memory.find(offset).readString());
+      if (result.error) throw new Error(result.error);
+      return result; // { userId }
+    },
+  },
+  // Viewer-authentication gate. Only a plugin holding `auth.gate` (and enabled by
+  // an admin) can issue sessions, and these are valid only inside onHttpRequest,
+  // where the host attaches/clears the signed session cookie on the response.
+  auth: {
+    // Issue a gate session for an already-registered user (see users.register).
+    // `ttl` is optional seconds, and 0/omitted uses the host default. Throws on
+    // host error. Requires `auth.gate`.
+    grantSession(opts) {
+      const fns = hostFns("owncast_auth_grant_session", Permissions.AuthGate);
+      const req = typeof opts === "string" ? { userId: opts } : opts || {};
+      const offset = fns.owncast_auth_grant_session(
+        Memory.fromString(JSON.stringify(req)).offset,
+      );
+      if (offset == 0) throw new Error("auth.grantSession failed");
+      const result = JSON.parse(Memory.find(offset).readString());
+      if (result.error) throw new Error(result.error);
+    },
+    // Clear the current viewer's gate session (logout). The plugin still owns the
+    // response/redirect. Requires `auth.gate`.
+    endSession() {
+      const fns = hostFns("owncast_auth_end_session", Permissions.AuthGate);
+      fns.owncast_auth_end_session();
+    },
   },
   storage: {
     upload(name, data) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_storage_upload)
-        throw new Error(
-          `permission '${Permissions.StorageUpload}' not granted`,
-        );
+      const fns = hostFns("owncast_storage_upload", Permissions.StorageUpload);
       const dataMem =
         data instanceof Uint8Array
           ? Memory.fromBuffer(
@@ -520,9 +543,7 @@ const owncast = {
     // Read a file's raw bytes. Returns a Uint8Array, or null if the file
     // doesn't exist (or can't be read).
     read(path) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_fs_read)
-        throw new Error(`permission '${Permissions.StorageFS}' not granted`);
+      const fns = hostFns("owncast_fs_read", Permissions.StorageFS);
       const offset = fns.owncast_fs_read(Memory.fromString(path).offset);
       if (offset == 0) return null;
       return new Uint8Array(Memory.find(offset).readBytes());
@@ -530,9 +551,7 @@ const owncast = {
     // Read a file as UTF-8 text. Returns a string, or null if the file
     // doesn't exist. (The Extism boundary decodes the bytes as UTF-8.)
     readText(path) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_fs_read)
-        throw new Error(`permission '${Permissions.StorageFS}' not granted`);
+      const fns = hostFns("owncast_fs_read", Permissions.StorageFS);
       const offset = fns.owncast_fs_read(Memory.fromString(path).offset);
       if (offset == 0) return null;
       return Memory.find(offset).readString();
@@ -540,9 +559,7 @@ const owncast = {
     // Write bytes (Uint8Array) or a string to a file, creating parent
     // directories as needed. Returns { ok, error? }.
     write(path, data) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_fs_write)
-        throw new Error(`permission '${Permissions.StorageFS}' not granted`);
+      const fns = hostFns("owncast_fs_write", Permissions.StorageFS);
       const dataMem =
         data instanceof Uint8Array
           ? Memory.fromBuffer(
@@ -562,27 +579,21 @@ const owncast = {
     // List the entry names (files and subdirectories) directly inside dir.
     // A missing directory lists as empty. Returns string[].
     list(dir) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_fs_list)
-        throw new Error(`permission '${Permissions.StorageFS}' not granted`);
+      const fns = hostFns("owncast_fs_list", Permissions.StorageFS);
       const offset = fns.owncast_fs_list(Memory.fromString(dir || "").offset);
       if (offset == 0) return [];
       return JSON.parse(Memory.find(offset).readString());
     },
     // Remove a single file or empty directory. Returns { ok, error? }.
     delete(path) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_fs_delete)
-        throw new Error(`permission '${Permissions.StorageFS}' not granted`);
+      const fns = hostFns("owncast_fs_delete", Permissions.StorageFS);
       const offset = fns.owncast_fs_delete(Memory.fromString(path).offset);
       if (offset == 0) return { ok: false, error: "delete failed" };
       return JSON.parse(Memory.find(offset).readString());
     },
     // Report whether a path exists inside the sandbox. Returns boolean.
     exists(path) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_fs_exists)
-        throw new Error(`permission '${Permissions.StorageFS}' not granted`);
+      const fns = hostFns("owncast_fs_exists", Permissions.StorageFS);
       return fns.owncast_fs_exists(Memory.fromString(path).offset) === 1;
     },
   },
@@ -591,11 +602,7 @@ const owncast = {
      *  behalf. Returns { url } on success, null on failure (rate-limited,
      *  disabled by admin, etc.). Requires `fediverse.post`. */
     post(text) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_fediverse_post)
-        throw new Error(
-          `permission '${Permissions.FediversePost}' not granted`,
-        );
+      const fns = hostFns("owncast_fediverse_post", Permissions.FediversePost);
       const offset = fns.owncast_fediverse_post(Memory.fromString(text).offset);
       if (offset == 0) return null;
       return JSON.parse(Memory.find(offset).readString());
@@ -603,30 +610,18 @@ const owncast = {
   },
   notifications: {
     discord(text) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_notify_discord)
-        throw new Error(
-          `permission '${Permissions.NotificationsSend}' not granted`,
-        );
+      const fns = hostFns("owncast_notify_discord", Permissions.NotificationsSend);
       fns.owncast_notify_discord(Memory.fromString(text).offset);
     },
     browserPush(payload) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_notify_browser_push)
-        throw new Error(
-          `permission '${Permissions.NotificationsSend}' not granted`,
-        );
+      const fns = hostFns("owncast_notify_browser_push", Permissions.NotificationsSend);
       const obj = typeof payload === "string" ? { title: payload } : payload;
       fns.owncast_notify_browser_push(
         Memory.fromString(JSON.stringify(obj)).offset,
       );
     },
     fediverse(payload) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_notify_fediverse)
-        throw new Error(
-          `permission '${Permissions.NotificationsSend}' not granted`,
-        );
+      const fns = hostFns("owncast_notify_fediverse", Permissions.NotificationsSend);
       fns.owncast_notify_fediverse(
         Memory.fromString(JSON.stringify(payload)).offset,
       );
@@ -634,17 +629,13 @@ const owncast = {
   },
   stream: {
     current() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_stream_current)
-        throw new Error(`permission '${Permissions.ServerRead}' not granted`);
+      const fns = hostFns("owncast_stream_current", Permissions.ServerRead);
       const offset = fns.owncast_stream_current();
       if (offset == 0) return { online: false, viewers: 0 };
       return JSON.parse(Memory.find(offset).readString());
     },
     broadcaster() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_stream_broadcaster)
-        throw new Error(`permission '${Permissions.ServerRead}' not granted`);
+      const fns = hostFns("owncast_stream_broadcaster", Permissions.ServerRead);
       const offset = fns.owncast_stream_broadcaster();
       if (offset == 0) return {};
       return JSON.parse(Memory.find(offset).readString());
@@ -652,41 +643,31 @@ const owncast = {
   },
   server: {
     info() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_server_info)
-        throw new Error(`permission '${Permissions.ServerRead}' not granted`);
+      const fns = hostFns("owncast_server_info", Permissions.ServerRead);
       const offset = fns.owncast_server_info();
       if (offset == 0) return {};
       return JSON.parse(Memory.find(offset).readString());
     },
     socials() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_server_socials)
-        throw new Error(`permission '${Permissions.ServerRead}' not granted`);
+      const fns = hostFns("owncast_server_socials", Permissions.ServerRead);
       const offset = fns.owncast_server_socials();
       if (offset == 0) return [];
       return JSON.parse(Memory.find(offset).readString());
     },
     emotes() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_server_emotes)
-        throw new Error(`permission '${Permissions.ServerRead}' not granted`);
+      const fns = hostFns("owncast_server_emotes", Permissions.ServerRead);
       const offset = fns.owncast_server_emotes();
       if (offset == 0) return [];
       return JSON.parse(Memory.find(offset).readString());
     },
     federation() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_server_federation)
-        throw new Error(`permission '${Permissions.ServerRead}' not granted`);
+      const fns = hostFns("owncast_server_federation", Permissions.ServerRead);
       const offset = fns.owncast_server_federation();
       if (offset == 0) return { enabled: false };
       return JSON.parse(Memory.find(offset).readString());
     },
     tags() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_server_tags)
-        throw new Error(`permission '${Permissions.ServerRead}' not granted`);
+      const fns = hostFns("owncast_server_tags", Permissions.ServerRead);
       const offset = fns.owncast_server_tags();
       if (offset == 0) return [];
       return JSON.parse(Memory.find(offset).readString());
@@ -696,24 +677,16 @@ const owncast = {
     /** Read the current video/transcoding config: { latencyLevel, codec,
      *  variants }. Requires `videoconfig.read`. */
     read() {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_video_config_read)
-        throw new Error(
-          `permission '${Permissions.VideoConfigRead}' not granted`,
-        );
+      const fns = hostFns("owncast_video_config_read", Permissions.VideoConfigRead);
       const offset = fns.owncast_video_config_read();
       if (offset == 0) return { latencyLevel: 0, codec: "", variants: [] };
       return JSON.parse(Memory.find(offset).readString());
     },
     /** Apply a partial video config change. Pass any of { latencyLevel, codec,
-     *  variants }; omitted fields are left unchanged. Throws if the host
+     *  variants }, where omitted fields are left unchanged. Throws if the host
      *  rejects the config. Requires `videoconfig.write`. */
     write(config) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_video_config_write)
-        throw new Error(
-          `permission '${Permissions.VideoConfigWrite}' not granted`,
-        );
+      const fns = hostFns("owncast_video_config_write", Permissions.VideoConfigWrite);
       const offset = fns.owncast_video_config_write(
         Memory.fromString(JSON.stringify(config || {})).offset,
       );
@@ -725,17 +698,13 @@ const owncast = {
   },
   kv: {
     get(key) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_kv_get)
-        throw new Error(`permission '${Permissions.StorageKV}' not granted`);
+      const fns = hostFns("owncast_kv_get", Permissions.StorageKV);
       const offset = fns.owncast_kv_get(Memory.fromString(key).offset);
       if (offset == 0) return null;
       return Memory.find(offset).readString();
     },
     set(key, value) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_kv_set)
-        throw new Error(`permission '${Permissions.StorageKV}' not granted`);
+      const fns = hostFns("owncast_kv_set", Permissions.StorageKV);
       fns.owncast_kv_set(
         Memory.fromString(key).offset,
         Memory.fromString(String(value)).offset,
@@ -792,9 +761,7 @@ const owncast = {
   },
   events: {
     emit(eventType, payload) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_emit_event)
-        throw new Error(`permission '${Permissions.EventsEmit}' not granted`);
+      const fns = hostFns("owncast_emit_event", Permissions.EventsEmit);
       fns.owncast_emit_event(
         Memory.fromString(eventType).offset,
         Memory.fromString(JSON.stringify(payload)).offset,
@@ -830,15 +797,13 @@ const owncast = {
     // send(channel, event, data) pushes one Server-Sent-Event to every
     // browser connected to this plugin's /plugins/<name>/_sse/<channel>
     // stream. `event` is the SSE event name (browser side:
-    // source.addEventListener(event, ...)); pass "" for the default
+    // source.addEventListener(event, ...)). Pass "" for the default
     // "message" event. `data` is sent as-is if it's a string, otherwise
     // JSON-stringified. Fire-and-forget: returns immediately, and frames to
     // a slow client are dropped rather than blocking the plugin. Requires
     // the 'http.sse' permission.
     send(channel, event, data) {
-      const fns = Host.getFunctions();
-      if (!fns.owncast_sse_send)
-        throw new Error(`permission '${Permissions.HttpSSE}' not granted`);
+      const fns = hostFns("owncast_sse_send", Permissions.HttpSSE);
       const payload = typeof data === "string" ? data : JSON.stringify(data);
       fns.owncast_sse_send(
         Memory.fromString(channel || "").offset,
@@ -850,7 +815,7 @@ const owncast = {
   timer: {
     // setTimeout(fn, ms) runs fn once after ~ms milliseconds. setInterval
     // repeats until clear(id). The host drives the schedule (the sandbox has
-    // no setTimeout); your callback runs in this instance when it fires.
+    // no setTimeout). Your callback runs in this instance when it fires.
     // Returns an id for clear(). Very small delays are clamped up by the host,
     // and there's a per-plugin cap on pending timers (throws past it).
     // Note: timers are in-memory and do not survive a plugin reload or a host
@@ -900,18 +865,32 @@ function dispatchPageContent(req) {
   return registered.onPageContent(req) || "";
 }
 
+function dispatchPageStyles() {
+  if (!registered || !isFn(registered.onPageStyles)) return "";
+  return registered.onPageStyles() || "";
+}
+
+function dispatchPageScripts() {
+  if (!registered || !isFn(registered.onPageScripts)) return "";
+  return registered.onPageScripts() || "";
+}
+
 module.exports = {
   definePlugin,
-  defineCommands,
   owncast,
   filter,
+  authCheck,
   FilterAction,
   Events,
   Permissions,
   describeSubscriptions,
+  describeCommands,
   dispatchEvent,
   dispatchFilter,
   dispatchHttp,
+  dispatchAuthCheck,
   dispatchTabContent,
   dispatchPageContent,
+  dispatchPageStyles,
+  dispatchPageScripts,
 };