fixing session related stuff

Dockerfile

···
 ARG BUILD_DATE
 ARG SHA
 ARG VERSION
+ARG ATPROTO_HANDLE
 
 FROM base AS build
 COPY --chown=1000:1000 apps/bot /app
···
 EXPOSE 8002
 CMD ["node", "dist/index.js"]
 LABEL org.opencontainers.image.authors="Dane Miller '[e-mail]'" \
-      org.opencontainers.image.source="https://tangled.org/dane.is.extraordinarily.cool/tealfmbot" \
+      org.opencontainers.image.source="https://tangled.org/${ATPROTO_HANDLE}/tealfmbot" \
       org.opencontainers.image.title="discostuweb" \
       org.opencontainers.image.description="The web service for authentication for the disco stu discord bot" \
       org.opencontainers.image.version=$VERSION \
···
 WORKDIR /prod/bot
 CMD ["node", "dist/main.js"]
 LABEL org.opencontainers.image.authors="Dane Miller '[e-mail]'" \
-      org.opencontainers.image.source="https://tangled.org/dane.is.extraordinarily.cool/tealfmbot" \
+      org.opencontainers.image.source="https://tangled.org/${ATPROTO_HANDLE}/tealfmbot" \
       org.opencontainers.image.title="discostubot" \
       org.opencontainers.image.description="A discord bot that displays your music listens based on your teal.fm records" \
       org.opencontainers.image.version=$VERSION \

apps/bot/commands/auth.ts

···
 import { logger } from "@tealfmbot/common/logger";
 import { ChatInputCommandInteraction, SlashCommandBuilder } from "discord.js";
 
+const LOGIN_URL =
+  process.env.NODE_ENV === "development" ? `127.0.0.1:${env.WEB_SERVICE_PORT}` : env.PUBLIC_URL;
+
 export default {
   data: new SlashCommandBuilder()
     .setName("login")
···
       "Authenticate with your Atmosphere account and request your listens to be tracked",
     ),
   async execute(interaction: ChatInputCommandInteraction) {
-    await interaction.reply(`Log in here and request to be tracked: ${env.WEB_SERVICE_URL}:${env.WEB_SERVICE_PORT}/login`);
-    logger.info(`starting authentication process for ${interaction.user.globalName} at ${new Date().toJSON()}`);
+    await interaction.reply(`Log in here and request to be tracked: ${LOGIN_URL}/login`);
+    logger.info(
+      `starting authentication process for ${interaction.user.username} in guild ${interaction.guildId} at ${new Date().toJSON()}`,
+    );
   },
 };

apps/bot/deploy-commands.ts

···
-import {
-  env
-} from "@tealfmbot/common/constants";
+import { env } from "@tealfmbot/common/constants";
 import { REST, Routes } from "discord.js";
 import fs from "node:fs";
 import path from "node:path";

apps/bot/package.json

···
   "private": true,
   "type": "module",
   "scripts": {
-    "dev": "tsx --watch main.ts",
+    "dev": "NODE_ENV=development tsx --watch main.ts",
     "deploy-commands": "tsx deploy-commands.ts",
     "build": "tsc",
     "watch": "tsc --watch",

apps/web/client.ts

···
 import { env } from "@tealfmbot/common/constants";
 import { db } from "@tealfmbot/database/db";
 import assert from "node:assert";
+
 import { SessionStore, StateStore } from "./storage.js";
 
 const loadJwk = async () => {
-    const raw = env.PRIVATE_KEYS;
-    if (!raw) return undefined;
-    const json = JSON.parse(raw);
-    if (!json) return undefined;
-    const keys = await Promise.all(
-        json.map((jwk: string | Record<string, unknown>) => JoseKey.fromJWK(jwk)),
-    );
-    return new Keyset(keys);
+  const raw = env.PRIVATE_KEYS;
+  if (!raw) return undefined;
+  const json = JSON.parse(raw);
+  if (!json) return undefined;
+  const keys = await Promise.all(
+    json.map((jwk: string | Record<string, unknown>) => JoseKey.fromJWK(jwk)),
+  );
+  return new Keyset(keys);
 };
 
-const keyset =
-  env.PUBLIC_URL && env.PRIVATE_KEYS
-    ? await loadJwk()
-    : undefined;
-
-
+const keyset = env.PUBLIC_URL && env.PRIVATE_KEYS ? await loadJwk() : undefined;
 
 assert(!env.PUBLIC_URL || keyset?.size, "PRIVATE_KEYS environment variable must be set");
 

apps/web/index.ts

···
 import pinoHttpLogger from "pino-http";
 
 import { client } from "./client.js";
-import { createSession, getSessionAgent, MAX_AGE, validateIdentifier } from "./utils.js";
+import {
+  createSession,
+  getSessionAgent,
+  MAX_AGE,
+  validateIdentifier,
+  getSession,
+} from "./utils.js";
 
 type Variables = {
   logger: typeof logger;
···
 });
 
 app.get("/dashboard", async (c) => {
-  const agent = await getSessionAgent(c);
-  if (agent?.assertAuthenticated()) {
-    return c.redirect("/login");
+  const session = await getSession(c, env);
+  if (session) {
+    const agent = await getSessionAgent(c);
+    return c.html(html`
+      <h1>Dashboard</h1>
+      <p>DID: ${agent?.assertDid}</p>
+      <form method="post" action="/logout">
+          <button type="submit">Log out</button>
+      </form>
+       `);
   }
-  return c.html(html`
-    <h1>Dashboard</h1>
-    <p>DID: ${agent?.assertDid}</p>
-    <form method="post" action="/logout">
-        <button type="submit">Log out</button>
-    </form>
-     `);
+  return c.redirect("/login");
 });
 
 app.get("/health", (c) => {
···
   const params = new URLSearchParams(c.req.url.split("?")[1]);
 
   try {
-    const session = await getSignedCookie(c, env.COOKIE_SECRET, "__teal_fm_bot_session");
+    const session = await getSession(c, env);
     if (session) {
       try {
         const oauthSession = await client.restore(session);
···
   return c.redirect("/dashboard");
 });
 
-app.get("/login", (c) => {
+app.get("/login", async (c) => {
+  const session = await getSession(c, env);
+  if (session) {
+    return c.redirect("/dashboard")
+  }
+
   return c.html(
     html`
         <form action="/login" method="post">
···
         </form>
     `,
   );
+
 });
 
 app.post(
···
       });
       return c.redirect(url.href.toString());
     } catch (error) {
-      logger.error({error}, "oauth authorize failed");
+      logger.error({ error }, "oauth authorize failed");
       return c.json({ message: "oauth authorize failed" }, 500);
     }
   },
···
 
 app.post("/logout", async (c) => {
   c.header("Cache-Control", "no-store");
-  const session = await getSignedCookie(c, env.COOKIE_SECRET, "__teal_fm_bot_session");
+  const session = await getSession(c, env);
   if (session) {
     try {
       const oauthSession = await client.restore(session);

apps/web/utils.ts

···
   }
 }
 
+export async function getSession(c: Context, e: typeof env) {
+  const session = await getSignedCookie(c, e.COOKIE_SECRET, "__teal_fm_bot_session");
+  return session;
+}
+
 export function isValidUrl(url: string) {
   if (URL.canParse(url)) {
     const pdsUrl = new URL(url);

build-and-publish-images.sh

···
 BUILD_DATE=$(date -u +%Y-%m-%dT%H:%M:%SZ)
 VERSION=$(git describe --tags --abbrev=0)
 REGISTRY=atcr.io/besaid.zone
+ATPROTO_HANDLE=besaid.zone
 
 services=(
     web
···
         --target $svc \
         --build-arg VERSION=${VERSION#v} \
         --build-arg SHA=$SHA \
+        --build-arg ATPROTO_HANDLE=$ATPROTO_HANDLE \
         --build-arg BUILD_DATE=$BUILD_DATE \
         --pull \
         --no-cache \

docker-compose.dev.yml

···
 services:
-   db:
+  db:
     image: postgres:18.1
     healthcheck:
       test: ["CMD-SHELL", "pg_isready -U postgres -d tealfmbotdb"]

packages/common/constants.ts

···
   TAP_ADMIN_PASSWORD: str(),
   DATABASE_URL: str({ devDefault: "postgres://postgres:password@localhost:5432/tealfmbotdb" }),
   PUBLIC_URL: str(),
-  COOKIE_SECRET: str({ devDefault: '00000000000000000000000000000000' }),
+  COOKIE_SECRET: str({ devDefault: "00000000000000000000000000000000" }),
   PRIVATE_KEYS: str(),
-  WEB_SERVICE_URL: str({ devDefault: "http://localhost" }),
-  WEB_SERVICE_PORT: num({devDefault: 8002})
+  WEB_SERVICE_PORT: num({ devDefault: 8002 }),
 });