kol.js 0.3.0 → 0.4.0

package/src/Client.ts

@@ -1,10 +1,11 @@
 import { Mutex } from "async-mutex";
-import { EventEmitter } from "node:events";
-import TypedEventEmitter, { type EventMap } from "typed-emitter";
+import Emittery from "emittery";
+import makeFetchCookie from "fetch-cookie";
+import { ofetch } from "ofetch";
+import { CookieJar } from "tough-cookie";
 
-import { sanitiseBlueText, wait } from "./utils/utils.js";
 import { Player } from "./Player.js";
-import { parseLeaderboard } from "./utils/leaderboard.js";
+import { Players } from "./domains/Players.js";
 import {
   type ChatMessage,
   type KmailMessage,
@@ -14,14 +15,8 @@ import {
   isValidMessage,
   parseKmailMessage,
 } from "./utils/kmail.js";
-import { PlayerCache } from "./Cache.js";
-import { CookieJar } from "tough-cookie";
-import got, {
-  type OptionsOfJSONResponseBody,
-  type OptionsOfTextResponseBody,
-} from "got";
-
-type TypedEmitter<T extends EventMap> = TypedEventEmitter.default<T>;
+import pkg from "../package.json" with { type: "json" };
+import { sanitiseBlueText, wait } from "./utils/utils.js";
 
 export type MallPrice = {
   formattedMallPrice: string;
@@ -32,12 +27,42 @@ export type MallPrice = {
   minPrice: number | null;
 };
 
+class LoginRedirectError extends Error {}
+
+export class RolloverError extends Error {
+  constructor() {
+    super("Kingdom of Loathing is currently down for rollover");
+    this.name = "RolloverError";
+  }
+}
+
+export class AuthError extends Error {
+  constructor() {
+    super("Unable to log in to Kingdom of Loathing");
+    this.name = "AuthError";
+  }
+}
+
+type FormData = Record<string, string | number | boolean>;
+
+type RequestOptions = {
+  method?: string;
+  query?: Record<string, unknown>;
+  form?: FormData;
+};
+
+function formToBody(form: FormData): URLSearchParams {
+  return new URLSearchParams(
+    Object.entries(form).map(([k, v]) => [k, String(v)]),
+  );
+}
+
 type Events = {
-  kmail: (message: KmailMessage) => void;
-  whisper: (message: KoLMessage) => void;
-  system: (message: KoLMessage) => void;
-  public: (message: KoLMessage) => void;
-  rollover: () => void;
+  kmail: KmailMessage;
+  whisper: KoLMessage;
+  system: KoLMessage;
+  public: KoLMessage;
+  rollover: Date;
 };
 
 type Familiar = {
@@ -53,41 +78,52 @@ type ApiStatus = {
   turnsplayed: string;
   /** kol game day number */
   daynumber: string;
+  /** player level */
+  level: string;
   /** session password */
   pwd: string;
 };
 
-export class Client extends (EventEmitter as unknown as new () => TypedEmitter<Events>) {
+export class Client extends Emittery<Events> {
   actionMutex = new Mutex();
-  session = got.extend({
-    cookieJar: new CookieJar(),
-    prefixUrl: "https://www.kingdomofloathing.com",
-    handlers: [
-      (options, next) => {
-        if (options.form) {
-          if (options.form.pwd !== false) options.form.pwd = this.#pwd;
+  #cookieJar = new CookieJar();
+  session = ofetch.create(
+    {
+      baseURL: "https://www.kingdomofloathing.com",
+      retry: 0,
+      headers: { "user-agent": `kol.js/${pkg.version}` },
+      onRequest: ({ options }) => {
+        if (options.query) {
+          const { pwd: _, ...rest } = options.query;
+          options.query = { ...rest, pwd: this.#pwd };
         }
-
-        if (options.searchParams) {
-          const searchParams = options.searchParams as URLSearchParams;
-          if (searchParams.get("pwd") !== "false")
-            searchParams.set("pwd", this.#pwd);
+        if (options.body instanceof URLSearchParams) {
+          options.body.set("pwd", this.#pwd);
         }
-
-        return next(options);
       },
-    ],
-  });
-  players = new PlayerCache(this);
+      onResponse: ({ request, response }) => {
+        const requestUrl = typeof request === "string" ? request : request.url;
+        if (
+          !requestUrl.includes("login.php") &&
+          response.url.includes("/login.php")
+        ) {
+          throw new LoginRedirectError();
+        }
+      },
+    },
+    { fetch: makeFetchCookie(fetch, this.#cookieJar) },
+  );
+  players = new Players(this);
 
   #username: string;
   #password: string;
   #isRollover = false;
+  #rolloverCheckScheduled = false;
   #chatBotStarted = false;
   #pwd = "";
 
   private lastFetchedMessages = "0";
-  private postRolloverLatch = false;
+  #postRolloverLatch = false;
 
   constructor(username: string, password: string) {
     super();
@@ -99,84 +135,91 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
     return this.#username;
   }
 
-  async fetchText(
-    path: string,
-    options: OptionsOfTextResponseBody = {},
-    fallback?: string,
-  ): Promise<string> {
-    // With no pwd, try to log in
-    if (!this.#pwd && !(await this.login())) return fallback ?? "";
-
-    // Make the request
-    const response = await this.session(path, {
-      method: "POST",
-      ...options,
-      responseType: "text",
-    });
+  async #withReauth<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.#isRollover) throw new RolloverError();
+    if (!this.#pwd && !(await this.login())) {
+      if (this.#isRollover) throw new RolloverError();
+      throw new AuthError();
+    }
 
-    // If we've been redirected to the login page, clear the pwd and try again
-    if (response.url.includes("/login.php")) {
-      this.#pwd = "";
-      return this.fetchText(path, options);
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        if (error instanceof RolloverError) throw error;
+        if (error instanceof LoginRedirectError && attempt === 0) {
+          this.#pwd = "";
+          if (!(await this.login())) {
+            if (this.#isRollover) throw new RolloverError();
+            throw new AuthError();
+          }
+          continue;
+        }
+        throw error;
+      }
     }
 
-    return response.body;
+    throw new AuthError();
+  }
+
+  async fetchText(path: string, options: RequestOptions = {}): Promise<string> {
+    const { form, ...rest } = options;
+    return this.#withReauth(() =>
+      this.session(path, {
+        method: "POST",
+        ...rest,
+        body: form ? formToBody(form) : undefined,
+        responseType: "text",
+      }),
+    );
   }
 
   async fetchJson<Result>(
     path: string,
-    options: OptionsOfJSONResponseBody = {},
-    fallback?: Result,
-  ): Promise<Result | null> {
-    if (!(await this.login())) return fallback ?? null;
-
-    let failed = false;
-
-    // Make the request
-    try {
-      const response = await this.session(path, {
-        ...options,
+    options: RequestOptions = {},
+  ): Promise<Result> {
+    const { form, ...rest } = options;
+    return this.#withReauth(() =>
+      this.session<Result>(path, {
+        ...rest,
+        body: form ? formToBody(form) : undefined,
         responseType: "json",
-      });
-      if (!response.url.includes("/login.php")) return response.body as Result;
-    } catch (error) {}
-
-    // If we've not been successful, clear the pwd and try again
-    this.#pwd = "";
-    return this.fetchJson(path, options);
+      }),
+    );
   }
 
   async login(): Promise<boolean> {
     if (await this.checkLoggedIn()) return true;
     if (this.#isRollover) return false;
     try {
-      const result = await this.session
-        .post("login.php", {
-          form: {
-            loggingin: "Yup.",
-            loginname: this.#username,
-            password: this.#password,
-            secure: "0",
-            submitbutton: "Log In",
-          },
-        })
-        .text();
+      const result = await this.session("login.php", {
+        method: "POST",
+        responseType: "text",
+        body: formToBody({
+          loggingin: "Yup.",
+          loginname: this.#username,
+          password: this.#password,
+          secure: "0",
+          submitbutton: "Log In",
+        }),
+      });
 
       if (Client.#rolloverPattern.test(result)) {
-        throw new Error("It's rollover!");
+        throw new RolloverError();
       }
 
       if (!(await this.checkLoggedIn())) return false;
 
-      if (this.postRolloverLatch) {
-        this.postRolloverLatch = false;
-        this.emit("rollover");
+      if (this.#postRolloverLatch) {
+        this.#postRolloverLatch = false;
+        this.emit("rollover", new Date());
       }
 
       return true;
     } catch (error) {
-      console.log("error", error);
-      // Login failed, let's check if it is due to rollover
+      if (!(error instanceof RolloverError)) {
+        console.error("Login failed:", error);
+      }
       await this.#checkForRollover();
       return false;
     }
@@ -188,14 +231,13 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
 
   async checkLoggedIn(): Promise<boolean> {
     try {
-      const api = await this.session
-        .get("api.php", {
-          searchParams: { what: "status", for: `${this.#username} bot` },
-        })
-        .json<{ pwd: string }>();
+      const api = await this.session<{ pwd: string }>("api.php", {
+        query: { what: "status", for: `${this.#username} bot` },
+      });
+      if (!api || typeof api !== "object" || !api.pwd) return false;
       this.#pwd = api.pwd;
       return true;
-    } catch (error) {
+    } catch {
       return false;
     }
   }
@@ -203,33 +245,62 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
   static #rolloverPattern =
     /The system is currently down for nightly maintenance/;
 
+  // Uses this.session directly to avoid recursion through fetchText → login
   async #checkForRollover() {
-    const isRollover = Client.#rolloverPattern.test(await this.fetchText(""));
+    try {
+      const html = await this.session("login.php", { responseType: "text" });
+      const isRollover = Client.#rolloverPattern.test(html);
 
-    if (this.#isRollover && !isRollover) {
-      // Set the post-rollover latch so the bot can react on next log in.
-      this.postRolloverLatch = true;
-    }
+      if (this.#isRollover && !isRollover) {
+        this.#postRolloverLatch = true;
+      }
 
-    this.#isRollover = isRollover;
+      this.#isRollover = isRollover;
+    } catch {
+      // Can't reach server — don't change rollover state
+    }
 
-    if (this.#isRollover) {
-      // Rollover appears to be in progress. Check again in one minute.
-      setTimeout(() => this.#checkForRollover(), 60_000);
+    if (this.#isRollover && !this.#rolloverCheckScheduled) {
+      this.#rolloverCheckScheduled = true;
+      setTimeout(() => {
+        this.#rolloverCheckScheduled = false;
+        void this.#checkForRollover();
+      }, 60_000);
     }
   }
 
   async startChatBot() {
     if (this.#chatBotStarted) return;
-    await this.useChatMacro("/join talkie");
-    this.loopChatBot();
     this.#chatBotStarted = true;
+    this.on("rollover", () => void this.#joinChat());
+    await this.#joinChat();
+    this.loopChatBot().catch((error) => {
+      console.error("Chat bot stopped:", error);
+    });
+  }
+
+  async #joinChat() {
+    try {
+      await this.useChatMacro("/join talkie");
+    } catch (error) {
+      if (!(error instanceof RolloverError)) {
+        console.error("Failed to join chat:", error);
+      }
+    }
   }
 
   private async loopChatBot() {
-    await Promise.all([this.checkMessages(), this.checkKmails()]);
-    await wait(3000);
-    await this.loopChatBot();
+    while (true) {
+      try {
+        await Promise.all([this.checkMessages(), this.checkKmails()]);
+      } catch (error) {
+        if (error instanceof AuthError) throw error;
+        if (!(error instanceof RolloverError)) {
+          console.error("Chat bot loop error:", error);
+        }
+      }
+      await wait(this.#isRollover ? 60_000 : 3000);
+    }
   }
 
   async checkMessages() {
@@ -237,15 +308,12 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
       last: string;
       msgs: KoLChatMessage[];
     }>("newchatmessages.php", {
-      searchParams: {
+      query: {
         j: 1,
         lasttime: this.lastFetchedMessages,
       },
     });
 
-    if (!newChatMessagesResponse || typeof newChatMessagesResponse !== "object")
-      return;
-
     this.lastFetchedMessages = newChatMessagesResponse["last"];
 
     newChatMessagesResponse["msgs"]
@@ -270,23 +338,21 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
       });
   }
 
-  async fetchStatus(): Promise<ApiStatus | null> {
-    const api = await this.fetchJson<ApiStatus>("api.php", {
-      searchParams: { what: "status", for: `${this.#username} bot` },
+  async fetchStatus(): Promise<ApiStatus> {
+    return this.fetchJson<ApiStatus>("api.php", {
+      query: { what: "status", for: `${this.#username} bot` },
     });
-
-    return api;
   }
 
   async fetchKmails(): Promise<KmailMessage[]> {
     const kmails = await this.fetchJson<KoLKmail[]>("api.php", {
-      searchParams: {
+      query: {
         what: "kmail",
         for: `${this.#username} bot`,
       },
     });
 
-    if (!Array.isArray(kmails) || kmails.length === 0) return [];
+    if (kmails.length === 0) return [];
 
     return kmails.map((msg: KoLKmail) => ({
       id: Number(msg.id),
@@ -305,7 +371,6 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
         the_action: "delete",
         box: "Inbox",
         ...Object.fromEntries(ids.map((id) => [`sel${id}`, "on"])),
-        pwd: true,
       },
     });
 
@@ -324,7 +389,7 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
     return await this.fetchJson<{ output: string; msgs: string[] }>(
       "submitnewchat.php",
       {
-        searchParams: {
+        query: {
           graf: message,
           j: 1,
         },
@@ -335,9 +400,9 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
   async getUpdates() {
     const result = await this.sendChat("/updates");
     return [
-      ...(result?.output.matchAll(
+      ...result.output.matchAll(
         /<p><b>[A-za-z]+ \d+<\/b> - (.*?)(?=<p>(?:<b>|<hr>))/g,
-      ) ?? []),
+      ),
     ].map((m) => m[1]);
   }
 
@@ -351,7 +416,7 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
 
   async kmail(recipientId: number, message: string) {
     await this.fetchText("sendmessage.php", {
-      searchParams: {
+      query: {
         action: "send",
         j: 1,
         towho: recipientId,
@@ -366,9 +431,8 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
 
   async getMallPrice(itemId: number): Promise<MallPrice> {
     const prices = await this.fetchText("backoffice.php", {
-      searchParams: {
+      query: {
         action: "prices",
-        pwd: true,
         ajax: 1,
         iid: itemId,
       },
@@ -417,9 +481,7 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
     };
   }> {
     const description = await this.fetchText("desc_item.php", {
-      searchParams: {
-        whichitem: descId,
-      },
+      query: { whichitem: descId },
     });
     const blueText = description.match(
       /<center>\s*<b>\s*<font color="?[\w]+"?>(?<description>[\s\S]+)<\/center>/i,
@@ -440,7 +502,7 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
       blueText: sanitiseBlueText(blueText?.groups?.description),
       effect: effect?.groups
         ? {
-            name: effect.groups?.name,
+            name: effect.groups?.effect,
             duration: Number(effect.groups?.duration) || 0,
             descid: effect.groups?.descid,
           }
@@ -450,9 +512,7 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
 
   async getEffectDescription(descId: string): Promise<{ blueText: string }> {
     const description = await this.fetchText("desc_effect.php", {
-      searchParams: {
-        whicheffect: descId,
-      },
+      query: { whicheffect: descId },
     });
     const blueText = description.match(
       /<center><font color="?[\w]+"?>(?<description>[\s\S]+)<\/div>/m,
@@ -462,9 +522,7 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
 
   async getSkillDescription(id: number): Promise<{ blueText: string }> {
     const description = await this.fetchText("desc_skill.php", {
-      searchParams: {
-        whichskill: String(id),
-      },
+      query: { whichskill: String(id) },
     });
 
     const blueText = description.match(
@@ -475,11 +533,10 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
 
   async joinClan(id: number): Promise<boolean> {
     const result = await this.fetchText("showclan.php", {
-      searchParams: {
+      query: {
         whichclan: id,
         action: "joinclan",
         confirm: "on",
-        pwd: true,
       },
     });
     return (
@@ -492,7 +549,7 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
     return await this.actionMutex.runExclusive(async () => {
       if (!(await this.joinClan(clanId))) return false;
       await this.fetchText("clan_whitelist.php", {
-        searchParams: {
+        query: {
           addwho: playerId,
           level: 2,
           title: "",
@@ -503,21 +560,9 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
     });
   }
 
-  async getLeaderboard(leaderboardId: number) {
-    const page = await this.fetchText("museum.php", {
-      searchParams: {
-        floor: 1,
-        place: "leaderboards",
-        whichboard: leaderboardId,
-      },
-    });
-
-    return parseLeaderboard(page);
-  }
-
   async useFamiliar(familiarId: number): Promise<boolean> {
     const result = await this.fetchText("familiar.php", {
-      searchParams: {
+      query: {
         action: "newfam",
         newfam: familiarId.toFixed(0),
       },
@@ -554,48 +599,13 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
     if (Client.#descIdToIdCache.has(descId))
       return Client.#descIdToIdCache.get(descId)!;
     const page = await this.fetchText("desc_item.php", {
-      searchParams: {
-        whichitem: descId,
-      },
+      query: { whichitem: descId },
     });
     const id = Number(page.match(/<!-- itemid: (\d+) -->/)?.[1] ?? -1);
     Client.#descIdToIdCache.set(descId, id);
     return id;
   }
 
-  async getRaffle() {
-    const page = await this.fetchText("raffle.php");
-    const today = page.matchAll(
-      /<tr><td align=right>(?:First|Second) Prize:<\/td>.*?descitem\((\d+)\)/g,
-    );
-    const [first, second] = await Promise.all(
-      today
-        ? [...today].map(async (p) => await this.descIdToId(Number(p[1])))
-        : [null, null],
-    );
-    const winners = page.matchAll(
-      /<tr><td class=small><a href='showplayer\.php\?who=\d+'>(.*?) \(#(\d+)\).*?descitem\((\d+)\).*?([\d,]+)<\/td><\/tr>/g,
-    );
-    const yesterday = await Promise.all(
-      winners
-        ? [...winners].map(async (w, i) => ({
-            player: new Player(this, Number(w[2]), w[1]),
-            item: await this.descIdToId(Number(w[3])),
-            tickets: Number(w[4].replace(",", "")),
-            place: Math.min(i + 1, 2),
-          }))
-        : [],
-    );
-
-    const { daynumber } = (await this.fetchStatus()) ?? { daynumber: "0" };
-
-    return {
-      today: { first, second },
-      yesterday,
-      gameday: Number(daynumber),
-    };
-  }
-
   async getStandard(date?: Date) {
     if (!date) {
       date = new Date();
@@ -607,7 +617,7 @@ export class Client extends (EventEmitter as unknown as new () => TypedEmitter<E
     const formattedDate = date.toISOString().split("T")[0];
 
     return await this.fetchText("standard.php", {
-      searchParams: { date: formattedDate },
+      query: { date: formattedDate },
     });
   }
 }