issues regarding the map and hunt stopping have been fixed. leaderboard page needs to be integrated and a clues should be added to be properly processed. after that the css for the application should be developed.

app/api/hunt-status/route.js

@@ -1,6 +1,4 @@
 import { queryOne, run } from "@/lib/db";
-import { cookies } from "next/headers";
-import { verifyToken } from "@/app/api/auth/[...nextauth]/route";
 
 export const dynamic = "force-dynamic"; // Disable caching
 
@@ -33,68 +31,76 @@ async function ensureHuntStatusTableExists() {
   }
 }
 
-// GET endpoint to check if the hunt is active
+// GET endpoint to check if the hunt is active - allow unauthenticated access for easier status checks
 export async function GET(request) {
   try {
     // First ensure the table exists
     await ensureHuntStatusTableExists();
 
-    // Get the token from cookies - properly awaited
-    const cookieStore = await cookies();
-    const sessionToken = cookieStore.get("next-auth.session-token")?.value;
+    // NO TOKEN CHECK - Allow anonymous status checks
+    // This is critical for the waiting page to work reliably
 
-    // Check hunt status even if user is not authenticated
-    // to prevent auth errors from interfering with status checks
-
-    // First check the hunt_status table for direct status
+    // Query all possible sources
     const huntStatus = await queryOne(
       "SELECT is_active, start_time FROM hunt_status LIMIT 1"
-    ).catch((err) => {
-      console.warn("Error querying hunt_status:", err.message);
-      return null;
-    });
+    ).catch(() => null);
+
+    const timerStatus = await queryOne(
+      "SELECT active, start_time, end_time FROM hunt_timer WHERE active = 1 ORDER BY id DESC LIMIT 1"
+    ).catch(() => null);
 
-    // Then check the settings table as a backup
     const huntActiveSetting = await queryOne(
       "SELECT value FROM settings WHERE key = 'hunt_active'"
-    ).catch((err) => {
-      console.warn("Error querying settings:", err.message);
-      return null;
-    });
+    ).catch(() => null);
 
-    // Also check the hunts table if it exists (for backward compatibility)
+    // Also check the traditional hunts table
     const oldHuntRecord = await queryOne(
       "SELECT active, start_time FROM hunts ORDER BY id DESC LIMIT 1"
-    ).catch((err) => {
-      // Ignore errors if table doesn't exist
-      return null;
-    });
+    ).catch(() => null);
 
-    // Determine active status from all available sources
+    // Determine active status from all possible sources
     let isActive = false;
     let startTime = null;
+    let endTime = null;
 
-    // First priority: hunt_status.is_active
-    if (huntStatus && huntStatus.is_active !== null) {
-      isActive = Boolean(huntStatus.is_active);
+    // Check all possible active indicators in priority order
+    if (timerStatus && Number(timerStatus.active) === 1) {
+      console.log("Hunt active from timer table");
+      isActive = true;
+      startTime = timerStatus.start_time;
+      endTime = timerStatus.end_time;
+    } else if (huntStatus && huntStatus.is_active) {
+      console.log("Hunt active from hunt_status table");
+      isActive = true;
       startTime = huntStatus.start_time;
-    }
-    // Second priority: settings table
-    else if (huntActiveSetting) {
-      isActive = huntActiveSetting.value === "true";
-    }
-    // Third priority: old hunts table
-    else if (oldHuntRecord) {
-      isActive = Boolean(oldHuntRecord.active);
+    } else if (huntActiveSetting && huntActiveSetting.value === "true") {
+      console.log("Hunt active from settings table");
+      isActive = true;
+    } else if (oldHuntRecord && oldHuntRecord.active) {
+      console.log("Hunt active from hunts table");
+      isActive = true;
       startTime = oldHuntRecord.start_time;
     }
 
-    console.log("Hunt status check:", { isActive, startTime });
+    console.log("Hunt status check:", { isActive, startTime, endTime });
 
-    return Response.json({
-      active: isActive,
-      startTime: startTime || null,
-    });
+    // Set extremely aggressive cache control headers
+    return new Response(
+      JSON.stringify({
+        active: isActive,
+        startTime: startTime || null,
+        endTime: endTime || null,
+      }),
+      {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+          Pragma: "no-cache",
+          Expires: "0",
+        },
+      }
+    );
   } catch (error) {
     console.error("Error checking hunt status:", error);
     return Response.json(

app/api/hunt/timer/route.js

@@ -1,6 +1,5 @@
 import { query, queryOne, run } from "@/lib/db";
-import { cookies } from "next/headers";
-import { verifyToken } from "@/app/api/auth/[...nextauth]/route";
+import { getToken } from "next-auth/jwt";
 
 export const dynamic = "force-dynamic"; // Disable caching
 
@@ -90,17 +89,83 @@ async function ensureSettingsTableExists() {
   }
 }
 
-// Helper function to update hunt active status
+// Helper function to update hunt active status - ensure it updates all tables
 async function updateHuntActiveStatus(isActive) {
   try {
     await ensureSettingsTableExists();
 
+    // Update settings table - this is used by many endpoints to check status
     await run("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)", [
       "hunt_active",
       isActive ? "true" : "false",
     ]);
 
-    console.log("Hunt active status updated:", isActive);
+    // Update hunt_status table for consistency
+    try {
+      const now = new Date().toISOString();
+      await run(`
+        CREATE TABLE IF NOT EXISTS hunt_status (
+          id INTEGER PRIMARY KEY CHECK (id = 1),
+          is_active BOOLEAN DEFAULT 0,
+          start_time TEXT,
+          end_time TEXT,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+
+      // Check if we need to insert the initial record
+      const status = await queryOne("SELECT * FROM hunt_status LIMIT 1");
+      if (!status) {
+        await run(
+          "INSERT INTO hunt_status (id, is_active, start_time) VALUES (1, ?, ?)",
+          [isActive ? 1 : 0, isActive ? now : null]
+        );
+      } else {
+        // Update existing record
+        await run(
+          "UPDATE hunt_status SET is_active = ?, start_time = ? WHERE id = 1",
+          [isActive ? 1 : 0, isActive ? now : null]
+        );
+      }
+    } catch (err) {
+      console.error("Error updating hunt_status table:", err);
+    }
+
+    // Also try to update the traditional hunts table for backwards compatibility
+    try {
+      const now = new Date().toISOString();
+      await run(`
+        CREATE TABLE IF NOT EXISTS hunts (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          active BOOLEAN DEFAULT 0,
+          start_time DATETIME DEFAULT NULL,
+          end_time DATETIME DEFAULT NULL,
+          created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+
+      // Check if we need to insert a new record or update existing
+      const hunt = await queryOne(
+        "SELECT * FROM hunts ORDER BY id DESC LIMIT 1"
+      );
+      if (!hunt) {
+        await run("INSERT INTO hunts (active, start_time) VALUES (?, ?)", [
+          isActive ? 1 : 0,
+          isActive ? now : null,
+        ]);
+      } else {
+        // Update most recent hunt record
+        await run("UPDATE hunts SET active = ?, start_time = ? WHERE id = ?", [
+          isActive ? 1 : 0,
+          isActive ? now : null,
+          hunt.id,
+        ]);
+      }
+    } catch (err) {
+      console.error("Error updating hunts table:", err);
+    }
+
+    console.log("Hunt active status updated across ALL tables:", isActive);
     return true;
   } catch (error) {
     console.error("Failed to update hunt active status:", error);
@@ -111,19 +176,18 @@ async function updateHuntActiveStatus(isActive) {
 // GET endpoint to get current timer status
 export async function GET(request) {
   try {
-    // Verify the user is authenticated
-    const cookieStore = await cookies(); // Add await here
-    const sessionToken = cookieStore.get("next-auth.session-token")?.value;
+    // Use proper next-auth token validation
+    const token = await getToken({
+      req: request,
+      secret:
+        process.env.NEXTAUTH_SECRET ||
+        "your-fallback-secret-should-be-at-least-32-chars",
+    });
 
-    if (!sessionToken) {
+    if (!token) {
       return Response.json({ error: "Unauthorized" }, { status: 401 });
     }
 
-    const userData = verifyToken(sessionToken);
-    if (!userData) {
-      return Response.json({ error: "Invalid session" }, { status: 401 });
-    }
-
     // Ensure both tables exist
     const tableExists = await ensureTableExists();
     await ensureSettingsTableExists();
@@ -175,31 +239,21 @@ export async function GET(request) {
 // POST endpoint to start/stop timer
 export async function POST(request) {
   try {
-    // Verify the user is authenticated and is an admin
-    const cookieStore = await cookies(); // Add await here
-    const sessionToken = cookieStore.get("next-auth.session-token")?.value;
-
-    if (!sessionToken) {
+    // Use next-auth's getToken to properly decode the token
+    const token = await getToken({
+      req: request,
+      secret:
+        process.env.NEXTAUTH_SECRET ||
+        "your-fallback-secret-should-be-at-least-32-chars",
+    });
+    if (!token) {
       return Response.json({ error: "Unauthorized" }, { status: 401 });
     }
 
-    const userData = verifyToken(sessionToken);
-    if (!userData) {
-      return Response.json({ error: "Invalid session" }, { status: 401 });
-    }
-
-    console.log("User role:", userData.role);
-
     // Check if user is admin (more lenient check)
-    if (
-      !(
-        userData.role === "admin" ||
-        userData.isAdmin === true ||
-        userData.is_admin === 1
-      )
-    ) {
+    if (token.role !== "admin") {
       return Response.json(
-        { error: "Unauthorized: Admin access required" },
+        { error: "Only admin can start the timer" },
         { status: 403 }
       );
     }

app/api/teams/[teamId]/hunt-session/route.js

@@ -0,0 +1,74 @@
+import { getToken } from "next-auth/jwt";
+import { queryOne } from "@/lib/db";
+
+export async function GET(request, context) {
+  try {
+    const token = await getToken({
+      req: request,
+      secret:
+        process.env.NEXTAUTH_SECRET ||
+        "your-fallback-secret-should-be-at-least-32-chars",
+    });
+
+    if (!token) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+
+    const { teamId } = context.params;
+
+    // Validate that user belongs to this team
+    if (!token.teamId || parseInt(token.teamId, 10) !== parseInt(teamId, 10)) {
+      return Response.json(
+        { error: "You are not a member of this team" },
+        { status: 403 }
+      );
+    }
+
+    // Get the team's hunt session from the database
+    const session = await queryOne(
+      "SELECT team_id, start_time FROM team_hunt_sessions WHERE team_id = ?",
+      [teamId]
+    );
+
+    if (!session) {
+      // Try to get the global hunt start time as fallback
+      const huntStatus = await queryOne(
+        "SELECT start_time FROM hunt_status WHERE is_active = 1 LIMIT 1"
+      );
+      if (huntStatus && huntStatus.start_time) {
+        return Response.json({
+          startTime: huntStatus.start_time,
+          source: "global_hunt_status",
+        });
+      }
+
+      // Final fallback to settings table
+      const huntActive = await queryOne(
+        "SELECT value FROM settings WHERE key = 'hunt_active'"
+      );
+      if (huntActive && huntActive.value === "true") {
+        return Response.json({
+          startTime: new Date().toISOString(),
+          source: "fallback_current_time",
+        });
+      }
+
+      return Response.json(
+        { error: "No hunt session found for this team" },
+        { status: 404 }
+      );
+    }
+
+    return Response.json({
+      teamId: session.team_id,
+      startTime: session.start_time,
+      source: "team_session",
+    });
+  } catch (error) {
+    console.error("Get team hunt session error:", error);
+    return Response.json(
+      { error: "Failed to get hunt session: " + error.message },
+      { status: 500 }
+    );
+  }
+}

app/api/teams/[teamId]/route.js

@@ -14,11 +14,10 @@ export async function GET(request, context) {
     if (!token) {
       return Response.json({ error: "Unauthorized" }, { status: 401 });
     }
-    // Use token.teamId for validation
-    if (
-      !token.teamId ||
-      parseInt(token.teamId, 10) !== parseInt(context.params.teamId, 10)
-    ) {
+    // Await context.params so its properties can be safely used
+    const { teamId } = await context.params;
+    // Validate that the token's teamId matches the requested teamId
+    if (!token.teamId || parseInt(token.teamId, 10) !== parseInt(teamId, 10)) {
       return Response.json(
         { error: "Not authorized to view this team" },
         { status: 403 }

app/api/teams/[teamId]/start-team-hunt/route.js

@@ -0,0 +1,114 @@
+import { getToken } from "next-auth/jwt";
+import { query, queryOne, run } from "@/lib/db";
+
+export async function POST(request, context) {
+  try {
+    const token = await getToken({
+      req: request,
+      secret:
+        process.env.NEXTAUTH_SECRET ||
+        "your-fallback-secret-should-be-at-least-32-chars",
+    });
+
+    if (!token) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+
+    const { teamId } = context.params;
+
+    // Validate that user belongs to this team
+    if (!token.teamId || parseInt(token.teamId, 10) !== parseInt(teamId, 10)) {
+      return Response.json(
+        { error: "You are not a member of this team" },
+        { status: 403 }
+      );
+    }
+
+    // Get current time in ISO format for consistent timing across team members
+    const startTime = new Date().toISOString();
+
+    // Store the hunt start time for this team in the database
+    await run(`
+      CREATE TABLE IF NOT EXISTS team_hunt_sessions (
+        team_id INTEGER PRIMARY KEY,
+        start_time TEXT NOT NULL,
+        initiated_by INTEGER,
+        FOREIGN KEY (team_id) REFERENCES teams(id),
+        FOREIGN KEY (initiated_by) REFERENCES users(id)
+      )
+    `);
+
+    // Insert or replace the team's hunt session
+    await run(
+      "INSERT OR REPLACE INTO team_hunt_sessions (team_id, start_time, initiated_by) VALUES (?, ?, ?)",
+      [teamId, startTime, token.id]
+    );
+
+    // Update hunt_status and settings tables to activate the hunt
+    await run(`
+      CREATE TABLE IF NOT EXISTS hunt_status (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        is_active BOOLEAN DEFAULT 0,
+        start_time TEXT,
+        end_time TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+    // Check if record exists
+    const statusExists = await queryOne(
+      "SELECT 1 FROM hunt_status WHERE id = 1"
+    );
+    if (statusExists) {
+      await run(
+        "UPDATE hunt_status SET is_active = 1, start_time = ? WHERE id = 1",
+        [startTime]
+      );
+    } else {
+      await run(
+        "INSERT INTO hunt_status (id, is_active, start_time) VALUES (1, 1, ?)",
+        [startTime]
+      );
+    }
+
+    // Update settings table
+    await run(`
+      CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+    await run("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)", [
+      "hunt_active",
+      "true",
+    ]);
+
+    // Get the team members for potential notifications
+    const teamMembers = await query(
+      "SELECT id, username FROM users WHERE team_id = ?",
+      [teamId]
+    );
+
+    return Response.json(
+      {
+        success: true,
+        startTime,
+        message: "Hunt started for the entire team",
+        teamMembers: teamMembers.map((m) => m.username),
+      },
+      {
+        status: 200,
+        headers: {
+          "Cache-Control": "no-store, no-cache, must-revalidate",
+          Pragma: "no-cache",
+        },
+      }
+    );
+  } catch (error) {
+    console.error("Start team hunt error:", error);
+    return Response.json(
+      { error: "Failed to start hunt: " + error.message },
+      { status: 500 }
+    );
+  }
+}