ah yes a big reorganization again

woohoo let's go boys.

Also handles messaging on violations, off for right now #97

src/auth/index.ts

···
 import { drizzle, DrizzleD1Database } from "drizzle-orm/d1";
 import { schema } from "../db";
 import { BSKY_MAX_USERNAME_LENGTH, BSKY_MIN_USERNAME_LENGTH } from "../limits";
-import { APP_NAME, SITE_URL } from "../siteinfo";
+import { APP_NAME } from "../siteinfo";
 import { Bindings } from "../types";
-import { lookupBskyHandle } from "../utils/bskyApi";
-import { createDMWithUser } from "../utils/bskyMsg";
-
-function createPasswordResetMessage(url: string, token: string) {
-  return `Your ${APP_NAME} password reset url is:
-${SITE_URL}/reset-password/${token}
-
-This URL will expire in about an hour.
-
-If you did not request a password reset, please ignore this message.`;
-}
+import { lookupBskyHandle } from "../utils/bsky/bskyApi";
+import { createDMWithUser } from "../utils/bsky/bskyMessage";
+import { createPasswordResetMessage } from "../utils/messages/accountReset";
 
 // Single auth configuration that handles both CLI and runtime scenarios
 function createAuth(env?: Bindings, cf?: IncomingRequestCfProperties) {

src/classes/bskyLogin.ts

···
   pds: string;
   username: string;
   password: string;
-  valid: boolean;
   constructor(data: any) {
     if (isEmpty(data)) {
       this.password = this.username = this.pds = "";
···
       this.username = data.user;
       this.password = data.pass;
     }
-    this.valid = !isEmpty(data.user) && !isEmpty(data.pass);
+  }
+  get valid(): boolean {
+    return !isEmpty(this.username) && !isEmpty(this.password);
   }
 };

src/endpoints/account.tsx

···
 import { rateLimit } from "../middleware/rateLimit";
 import { verifyTurnstile } from "../middleware/turnstile";
 import { Bindings, LooseObj } from "../types";
-import { lookupBskyHandle, lookupBskyPDS } from "../utils/bskyApi";
-import { checkIfCanDMUser } from "../utils/bskyMsg";
+import { lookupBskyHandle, lookupBskyPDS } from "../utils/bsky/bskyApi";
+import { checkIfCanDMUser } from "../utils/bsky/bskyMessage";
 import { getAllMediaOfUser } from "../utils/db/file";
 import { doesUserExist, getUserEmailForHandle, getUsernameForUser } from "../utils/db/userinfo";
 import { userHasBan } from "../utils/db/violations";

src/index.tsx

···
 import { SITE_URL } from "./siteinfo";
 import { Bindings, QueueTaskData } from "./types";
 import { makeConstScript } from "./utils/constScriptGen";
-import { processQueue } from "./utils/queueHandler";
+import { processQueue } from "./utils/queues/queueHandler";
 import { cleanUpPostsTask, schedulePostTask } from "./utils/scheduler";
 import { setupAccounts } from "./utils/setup";
 

src/utils/bsky/bskyAgents.ts

···
+// this file is used to handle atpagents and their reuse during cron/queues
+// this is done because logging into PDSes across tasks can be extremely
+// expensive time wise.
+import AtpAgent from "@atproto/api";
+import { Post } from "../../classes/post";
+import { Repost } from "../../classes/repost";
+import {
+  AccountStatus, AgentConfigSettings,
+  AllContext, TaskType
+} from "../../types";
+import { getBskyUserPassForId } from "../db/userinfo";
+import { createViolationForUser } from "../db/violations";
+import { resetAppPasswordMessage } from "../messages/resetAppPassword";
+import { loginToBsky } from "./bskyLogin";
+import { createDMWithUser } from "./bskyMessage";
+
+type AgentLoginResponse = {
+  agent: AtpAgent|null;
+  violation: boolean;
+  wasNewViolation?: boolean;
+  violationType?: AccountStatus;
+}
+
+export class AgentMap {
+  #forPosts: boolean;
+  #forReposts: boolean;
+  #map: Map<string, AtpAgent|null>;
+  constructor(config: AgentConfigSettings) {
+    this.#forPosts = config.use_posts;
+    this.#forReposts = config.use_reposts;
+    this.#map = new Map();
+  }
+  async getOrAddAgent(c: AllContext, userId: string, type: TaskType): Promise<AtpAgent|null> {
+    const usesAgent: boolean = this.usesAgentForType(type);
+    let mappedAgent = (usesAgent) ? this.#map.get(userId) : null;
+    if (mappedAgent === undefined) {
+      const {agent, violation} = await AgentMap.getAgentDirect(c, userId, false);
+      mappedAgent = agent;
+      if (usesAgent) {
+        // only add this agent if it's not null
+        // but if we have a violation, we should absolutely add it in.
+        if (agent !== null || violation) {
+          this.#map.set(userId, agent);
+        }
+      }
+    }
+    return mappedAgent;
+  };
+  async getOrAddAgentFromObj(c: AllContext, data: Post|Repost, type: TaskType): Promise<AtpAgent|null> {
+    const userId: string = (type === TaskType.Post) ? (data as Post).user : (data as Repost).userId;
+    return await this.getOrAddAgent(c, userId, type);
+  };
+  static async getAgentDirect(c: AllContext, userId: string, messageOnViolation: boolean): Promise<AgentLoginResponse> {
+    const loginCreds = await getBskyUserPassForId(c, userId);
+    if (loginCreds.valid === false) {
+      console.error(`credentials for user ${userId} were invalid`);
+      return {agent: null, violation: false};
+    }
+    const {username, password, pds} = loginCreds;
+    // Login to bsky
+    const agent = new AtpAgent({ service: new URL(pds) });
+
+    const loginResponse: AccountStatus = await loginToBsky(agent, username, password);
+    if (loginResponse != AccountStatus.Ok) {
+      const addViolation: boolean = await createViolationForUser(c, userId, loginResponse);
+      if (addViolation) {
+        console.error(`Unable to login for ${userId} with violation ${loginResponse}`);
+        if (messageOnViolation && loginResponse == AccountStatus.InvalidAccount) {
+          await createDMWithUser(c.env, username, resetAppPasswordMessage());
+        }
+      } else {
+        console.error(`Unable to login ${userId}, no new violation made, got ${loginResponse}`);
+      }
+      return {agent: null, violation: true, wasNewViolation: addViolation, violationType: loginResponse};
+    }
+    return {agent: agent, violation: false};
+  };
+  usesAgentForType(type: TaskType) {
+    switch(type) {
+      case TaskType.Post:
+        return this.#forPosts;
+      case TaskType.Repost:
+        return this.#forReposts;
+    }
+    return false;
+  }
+};

src/utils/bsky/bskyLogin.ts

···
+// handles general login for agents.
+// most cases should not be interfacing directly with this function, but instead
+// use bskyAgents or bskyMsg to talk to the network
+import AtpAgent from "@atproto/api";
+import { AccountStatus, LooseObj } from "../../types";
+
+export const loginToBsky = async (agent: AtpAgent, user: string, pass: string) => {
+  try {
+    const loginResponse = await agent.login({
+      identifier: user,
+      password: pass,
+      allowTakendown: true
+    });
+    if (!loginResponse.success) {
+      if (loginResponse.data.active == false) {
+        switch (loginResponse.data.status) {
+          case "deactivated":
+            return AccountStatus.Deactivated;
+          case "suspended":
+            return AccountStatus.Suspended;
+          case "takendown":
+            return AccountStatus.TakenDown;
+        }
+        return AccountStatus.InvalidAccount;
+      }
+      return AccountStatus.PlatformOutage;
+    }
+    return AccountStatus.Ok;
+  } catch (err) {
+    // Apparently login can rethrow as an XRPCError and completely eat the original throw.
+    // so errors don't get handled gracefully.
+    const errWrap: LooseObj = err as LooseObj;
+    const errorName = errWrap.constructor.name;
+    if (errorName === "XRPCError") {
+      const errCode = errWrap.status;
+      if (errCode == 401) {
+        // app password is bad
+        return AccountStatus.InvalidAccount;
+      } else if (errCode >= 500) {
+        return AccountStatus.PlatformOutage;
+      }
+    } else if (errorName === "XRPCNotSupported") {
+      // handle is bad
+      return AccountStatus.InvalidAccount;
+    }
+    console.error(`encountered exception on login for user ${user}, err ${err}`);
+  }
+  return AccountStatus.UnhandledError;
+};

src/utils/bskyAgents.ts

···
-// this file is used to handle atpagents and their reuse during cron/queues
-// this is done because logging into PDSes across tasks can be extremely
-// expensive time wise.
-//
-// Also just handles general login.
-import AtpAgent from "@atproto/api";
-import { Post } from "../classes/post";
-import { Repost } from "../classes/repost";
-import {
-  AccountStatus, AgentConfigSettings,
-  AllContext, LooseObj, TaskType
-} from "../types";
-import { getBskyUserPassForId } from "./db/userinfo";
-import { createViolationForUser } from "./db/violations";
-
-export const makeAgentForUser = async (c: AllContext, userId: string) => {
-  const loginCreds = await getBskyUserPassForId(c, userId);
-  if (loginCreds.valid === false) {
-    console.error(`credentials for user ${userId} were invalid`);
-    return null;
-  }
-  const {username, password, pds} = loginCreds;
-  // Login to bsky
-  const agent = new AtpAgent({ service: new URL(pds) });
-
-  const loginResponse: AccountStatus = await loginToBsky(agent, username, password);
-  if (loginResponse != AccountStatus.Ok) {
-    const addViolation: boolean = await createViolationForUser(c, userId, loginResponse);
-    if (addViolation)
-      console.error(`Unable to login for ${userId} with violation ${loginResponse}`);
-    else
-      console.error(`Unable to login ${userId}, no violation made, got ${loginResponse}`);
-    return null;
-  }
-  return agent;
-};
-
-export const loginToBsky = async (agent: AtpAgent, user: string, pass: string) => {
-  try {
-    const loginResponse = await agent.login({
-      identifier: user,
-      password: pass,
-      allowTakendown: true
-    });
-    if (!loginResponse.success) {
-      if (loginResponse.data.active == false) {
-        switch (loginResponse.data.status) {
-          case "deactivated":
-            return AccountStatus.Deactivated;
-          case "suspended":
-            return AccountStatus.Suspended;
-          case "takendown":
-            return AccountStatus.TakenDown;
-        }
-        return AccountStatus.InvalidAccount;
-      }
-      return AccountStatus.PlatformOutage;
-    }
-    return AccountStatus.Ok;
-  } catch (err) {
-    // Apparently login can rethrow as an XRPCError and completely eat the original throw.
-    // so errors don't get handled gracefully.
-    const errWrap: LooseObj = err as LooseObj;
-    const errorName = errWrap.constructor.name;
-    if (errorName === "XRPCError") {
-      const errCode = errWrap.status;
-      if (errCode == 401) {
-        // app password is bad
-        return AccountStatus.InvalidAccount;
-      } else if (errCode >= 500) {
-        return AccountStatus.PlatformOutage;
-      }
-    } else if (errorName === "XRPCNotSupported") {
-      // handle is bad
-      return AccountStatus.InvalidAccount;
-    }
-    console.error(`encountered exception on login for user ${user}, err ${err}`);
-  }
-  return AccountStatus.UnhandledError;
-};
-
-export class AgentMap {
-  #forPosts: boolean;
-  #forReposts: boolean;
-  #map: Map<string, AtpAgent>;
-  constructor(config: AgentConfigSettings) {
-    this.#forPosts = config.use_posts;
-    this.#forReposts = config.use_reposts;
-    this.#map = new Map();
-  }
-  async getOrAddAgent(c: AllContext, userId: string, type: TaskType): Promise<AtpAgent|null> {
-    const usesAgent: boolean = this.usesAgentForType(type);
-    let agent = (usesAgent) ? this.#map.get(userId) || null : null;
-    if (agent === null) {
-      agent = await AgentMap.getAgentDirect(c, userId);
-      if (usesAgent && agent !== null)
-        this.#map.set(userId, agent);
-    }
-    return agent;
-  };
-  async getOrAddAgentFromObj(c: AllContext, data: Post|Repost, type: TaskType): Promise<AtpAgent|null> {
-    const userId: string = (type === TaskType.Post) ? (data as Post).user : (data as Repost).userId;
-    return await this.getOrAddAgent(c, userId, type);
-  };
-  static async getAgentDirect(c: AllContext, userId: string) {
-    return await makeAgentForUser(c, userId);
-  };
-  usesAgentForType(type: TaskType) {
-    switch(type) {
-      case TaskType.Post:
-        return this.#forPosts;
-      case TaskType.Repost:
-        return this.#forReposts;
-    }
-    return false;
-  }
-};

src/utils/bskyApi.ts src/utils/bsky/bskyApi.ts

···
 import has from 'just-has';
 import isEmpty from "just-is-empty";
 import truncate from "just-truncate";
-import { Post } from "../classes/post";
-import { Repost } from "../classes/repost";
-import { BSKY_IMG_SIZE_LIMIT, MAX_ALT_TEXT, MAX_EMBEDS_PER_POST } from '../limits';
+import { Post } from "../../classes/post";
+import { Repost } from "../../classes/repost";
+import { BSKY_IMG_SIZE_LIMIT, MAX_ALT_TEXT, MAX_EMBEDS_PER_POST } from '../../limits';
 import {
   AccountStatus,
   AllContext,
   BskyEmbedWrapper, BskyRecordWrapper, EmbedData, EmbedDataType,
   LooseObj, PostLabel,
   PostRecordResponse, PostStatus
-} from '../types';
-import { atpRecordURI } from '../validation/regexCases';
-import { makeAgentForUser } from './bskyAgents';
+} from '../../types';
+import { atpRecordURI } from '../../validation/regexCases';
 import {
   bulkUpdatePostedData, getChildPostsOfThread,
   isPostAlreadyPosted, setPostNowOffForPost
-} from './db/data';
-import { getUsernameForUserId } from './db/userinfo';
-import { createViolationForUser } from './db/violations';
-import { deleteEmbedsFromR2 } from './r2Query';
+} from '../db/data';
+import { getUsernameForUserId } from '../db/userinfo';
+import { createViolationForUser } from '../db/violations';
+import { deleteEmbedsFromR2 } from '../r2Query';
 
 export const doesHandleExist = async (user: string) => {
   try {
···
 }
 
 export const makeRepost = async (c: AllContext, content: Repost, usingAgent: AtpAgent) => {
-  let bWasSuccess = true;
-  const agent: AtpAgent|null = (usingAgent === null) ? await makeAgentForUser(c, content.userId) : usingAgent;
-  if (agent === null) {
-    console.warn(`could not make agent for repost ${content.postid}`);
-    return false;
-  }
-
   try {
-    await agent.deleteRepost(content.uri);
+    await usingAgent.deleteRepost(content.uri);
   } catch {
     // This probably should not be a warning, and should silently fail.
     // the only thing that actually matters is the object below.
···
   }
 
   try {
-    await agent.repost(content.uri, content.cid);
+    await usingAgent.repost(content.uri, content.cid);
+    return true;
   } catch(err) {
     console.error(`Failed to repost ${content.uri}, got error ${err}`);
-    bWasSuccess = false;
+    return false;
   }
-
-  return bWasSuccess;
 };
 
 const makePostRaw = async (c: AllContext, content: Post, agent: AtpAgent): Promise<PostStatus|null> => {

src/utils/bskyMsg.ts src/utils/bsky/bskyMessage.ts

···
 import { AtpAgent, RichText } from '@atproto/api';
-import { AccountStatus, Bindings } from '../types';
-import { loginToBsky } from './bskyAgents';
+import { AccountStatus, Bindings } from '../../types';
+import { loginToBsky } from './bskyLogin';
 
 const chatHeaders = {headers: {
   "atproto-proxy": "did:web:api.bsky.chat#bsky_chat"

src/utils/bskyPrune.ts src/utils/bsky/bskyPrune.ts

···
 import isEmpty from 'just-is-empty';
 import split from 'just-split';
-import { AllContext } from '../types';
+import { AllContext } from '../../types';
 import { getPostRecords } from './bskyApi';
-import { getAllPostedPosts, getAllPostedPostsOfUser } from './db/data';
+import { getAllPostedPosts, getAllPostedPostsOfUser } from '../db/data';
 
 // This looks for a bunch of posts that are posted and determines if the posts
 // are still on the network or not. If they are not, then this prunes the posts from

src/utils/db/violations.ts

···
 import isEmpty from "just-is-empty";
 import { bannedUsers, violations } from "../../db/enforcement.schema";
 import { AccountStatus, AllContext, LooseObj, Violation } from "../../types";
-import { lookupBskyHandle } from "../bskyApi";
+import { lookupBskyHandle } from "../bsky/bskyApi";
 import { getUsernameForUserId } from "./userinfo";
 
 const createBanForUser = async(db: DrizzleD1Database, userName: string, reason: string) => {

src/utils/messages/accountReset.ts

···
+import { APP_NAME, SITE_URL } from "../../siteinfo";
+
+export function createPasswordResetMessage(url: string, token: string) {
+  return `Your ${APP_NAME} password reset url is:
+${SITE_URL}/reset-password/${token}
+
+This URL will expire in about an hour.
+
+If you did not request a password reset, please ignore this message.`;
+};

src/utils/messages/resetAppPassword.ts

···
+import { APP_NAME } from "../../siteinfo";
+
+export function resetAppPasswordMessage() {
+  return `Hey there! This is an automated message to let you know
+  that your ${APP_NAME} account is no longer automatically posting.
+
+  This occurs when your BSky App Password either expires or gets deleted.
+  If you did not mean to do this, log back onto ${APP_NAME} and provide
+  an updated BSky app password in the "Account Settings" section of the
+  dashboard.
+
+  This message can only be seen by you. If you no longer want to use
+  ${APP_NAME} or don't need to for awhile, no worries! This bot will
+  only send you this message once (unless you password expires again).`;
+};

src/utils/queueHandler.ts src/utils/queues/queueHandler.ts

···
 import unique from "just-unique";
-import { ScheduledContext } from "../classes/context";
-import { Post } from "../classes/post";
-import { Repost } from "../classes/repost";
-import { Bindings, QueueTaskData, TaskType } from "../types";
-import { AgentMap } from "./bskyAgents";
-import { userHasViolations } from "./db/violations";
-import { isPost } from "./helpers";
+import { ScheduledContext } from "../../classes/context";
+import { Post } from "../../classes/post";
+import { Repost } from "../../classes/repost";
+import { Bindings, QueueTaskData, TaskType } from "../../types";
+import { AgentMap } from "../bsky/bskyAgents";
+import { userHasViolations } from "../db/violations";
+import { isPost } from "../helpers";
+import { handlePostTask, handleRepostTask } from "../scheduler";
 import { enqueueEmptyWork } from "./queuePublisher";
-import { handlePostTask, handleRepostTask } from "./scheduler";
 
 type BufferBlast = {
   type: TaskType,

src/utils/queuePublisher.ts src/utils/queues/queuePublisher.ts

···
 import isEmpty from 'just-is-empty';
 import random from 'just-random';
 import get from 'just-safe-get';
-import { Post } from "../classes/post";
-import { Repost } from "../classes/repost";
-import { AllContext, Bindings, QueueTaskData, TaskType } from "../types";
+import { Post } from "../../classes/post";
+import { Repost } from "../../classes/repost";
+import { AllContext, Bindings, QueueTaskData, TaskType } from "../../types";
 
 // picks a random queue to publish data to
 const getRandomQueue = (env: Bindings, listName: string): Queue|null => {

src/utils/scheduler.ts

···
 import { Post } from "../classes/post";
 import { Repost } from "../classes/repost";
 import { AllContext, TaskType } from '../types';
-import { AgentMap } from './bskyAgents';
-import { makePost, makeRepost } from './bskyApi';
-import { pruneBskyPosts } from './bskyPrune';
+import { AgentMap } from './bsky/bskyAgents';
+import { makePost, makeRepost } from './bsky/bskyApi';
+import { pruneBskyPosts } from './bsky/bskyPrune';
 import {
   deleteAllRepostsBeforeCurrentTime, deletePosts, getAllPostsForCurrentTime,
   getAllRepostsForCurrentTime, purgePostedPosts,
···
 import {
   enqueuePost, enqueueRepost, isQueueEnabled,
   isRepostQueueEnabled, shouldPostNowQueue, shouldPostThreadQueue
-} from './queuePublisher';
+} from './queues/queuePublisher';
 import { deleteFromR2 } from './r2Query';
 
 export const handlePostTask = async(runtime: AllContext, postData: Post, agent: AtpAgent|null) => {
···
       postStatus = false;
     }
   } else {
-    const agent = await AgentMap.getAgentDirect(c, postData.user);
+    const {agent} = await AgentMap.getAgentDirect(c, postData.user, false);
     if (agent === null) {
       console.error(`unable to get agent for user ${postData.user} to post now`);
       postStatus = false;