Reply to unread chats automatically

const API_BASE = "https://api.fanvue.com";
const API_VERSION = "2025-06-26"; // pins the API version so behaviour is stable

export class FanvueClient {
  constructor(private token: string) {}

  private async request(
    path: string,
    init: RequestInit = {},
  ): Promise<any> {
    const res = await fetch(`${API_BASE}${path}`, {
      ...init,
      headers: {
        Authorization: `Bearer ${this.token}`,
        "X-Fanvue-API-Version": API_VERSION,
        "Content-Type": "application/json",
        ...init.headers,
      },
    });
    if (!res.ok) {
      throw new Error(`${res.status} ${res.statusText} on ${path}`);
    }
    return res.json();
  }

  // GET /users/me -> your own account, including your uuid
  getMe() {
    return this.request("/users/me");
  }

  // GET /chats?filter=unread -> one entry per unread conversation
  getUnreadChats(page = 1, size = 50) {
    const q = new URLSearchParams({
      filter: "unread",
      page: String(page),
      size: String(size),
    });
    return this.request(`/chats?${q}`);
  }

  // GET /chats/{userUuid}/messages -> recent messages, newest first.
  // markAsRead=false so we don't clear the unread flag before we reply.
  getMessages(userUuid: string, markAsRead = false) {
    const q = new URLSearchParams({
      size: "15",
      markAsRead: markAsRead ? "true" : "false",
    });
    return this.request(`/chats/${userUuid}/messages?${q}`);
  }

  // POST /chats/{userUuid}/message -> { messageUuid }
  sendMessage(userUuid: string, text: string) {
    return this.request(`/chats/${userUuid}/message`, {
      method: "POST",
      body: JSON.stringify({ text }),
    });
  }
}

interface Message {
  text: string | null;
  sender: { uuid: string; handle: string };
}

// messages are newest-first, as returned by GET /chats/{userUuid}/messages.
export function draftReply(fanName: string, messages: Message[]): string {
  const latest = messages[0]?.text ?? "";

  // Replace this template with your own reply logic. Feed it the recent
  // `messages` as context and the creator's tone, and return the text.
  // The API does not write the reply: the text is whatever you send.
  return (
    `Hey ${fanName}, thanks for your message ` +
    `("${(latest ?? "").slice(0, 60)}"). I will get back to you properly soon.`
  );
}

import { FanvueClient } from "./fanvue";
import { draftReply } from "./draft";

async function run(): Promise<void> {
  const token = process.env.FANVUE_TOKEN;
  if (!token) throw new Error("Set FANVUE_TOKEN");
  const client = new FanvueClient(token);

  // Who am I? Needed to tell my own messages apart from the fan's.
  const me = await client.getMe();
  const myUuid = me.uuid;
  console.log(`Running as @${me.handle} (${myUuid})`);

  // Find unread conversations.
  const unread = await client.getUnreadChats();
  const chats = unread.data;
  console.log(`Found ${chats.length} unread chat(s)`);

  for (const chat of chats) {
    const fan = chat.user;
    const userUuid = fan.uuid;
    const fanName = fan.displayName || fan.handle;

    // Read recent history. markAsRead=false keeps the chat unread until
    // we have actually replied.
    const history = await client.getMessages(userUuid, false);
    const messages = history.data.filter((m: any) => m.type !== "BROADCAST");

    // Skip if the most recent message is one we sent: nothing to reply to.
    if (messages.length && messages[0].sender.uuid === myUuid) {
      console.log(`  ${fanName}: latest message is mine, skipping`);
      continue;
    }

    const reply = draftReply(fanName, messages);

    try {
      const result = await client.sendMessage(userUuid, reply);
      console.log(`  ${fanName}: sent ${result.messageUuid}`);
    } catch (err) {
      // e.g. 400 contactability error
      console.log(`  ${fanName}: could not send (${err})`);
    }
  }
}

run().catch(console.error);