switch frontend to sqlite storage adapter instead of kv

frontend/Dockerfile

···
 FROM denoland/deno:2.3.3
 
+# Install sqlite3
+RUN apt-get update && apt-get install -y sqlite3 && rm -rf /var/lib/apt/lists/*
+
 WORKDIR /app
 
 COPY . .
···
 
 EXPOSE 8080
 
-CMD ["run", "-A", "--unstable-kv", "src/main.ts"]
+CMD ["run", "-A", "src/main.ts"]

frontend/deno.lock

···
     "jsr:@std/streams@^1.0.10": "1.0.11",
     "npm:@shikijs/core@^3.7.0": "3.11.0",
     "npm:@shikijs/engine-oniguruma@^3.7.0": "3.11.0",
+    "npm:@types/node@*": "22.15.15",
     "npm:preact-render-to-string@^6.5.13": "6.5.13_preact@10.27.1",
     "npm:preact@^10.27.1": "10.27.1",
     "npm:shiki@^3.7.0": "3.11.0",
···
       "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
       "dependencies": [
         "@types/unist"
+      ]
+    },
+    "@types/node@22.15.15": {
+      "integrity": "sha512-R5muMcZob3/Jjchn5LcO8jdKwSCbzqmPB6ruBxMcf9kbxtniZHP327s6C37iOfuw8mbKK3cAQa7sEl7afLrQ8A==",
+      "dependencies": [
+        "undici-types"
       ]
     },
     "@types/unist@3.0.3": {
···
       "dependencies": [
         "typed-html"
       ]
+    },
+    "undici-types@6.21.0": {
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="
     },
     "unist-util-is@6.0.0": {
       "integrity": "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==",

frontend/flake.nix

···
               WorkingDir = "/";
               Env = [
                 "PORT=8080"
-                "KV_PATH=/data/kv.db"
+                "DATABASE_URL=sqlite:///data/slices.db"
               ];
             };
           };

frontend/fly.toml

···
 [env]
   PORT = '8080'
   API_URL = 'https://slices-api.fly.dev'
+  DATABASE_URL = '/data/slices.db'
   SLICE_URI = 'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lwzmbjpqxk2q'
 
 [http_service]

frontend/src/client.ts

···
         httpMethod !== "GET"
       ) {
         try {
-          console.log("🔄 Got 401, invalidating token and attempting refresh...");
           // Mark current token as invalid to force refresh
           this.oauthClient.invalidateCurrentToken();
           // Force token refresh by calling ensureValidToken again
           await this.oauthClient.ensureValidToken();
-          console.log("✅ Token refresh successful, retrying request...");
           // Retry the request once with refreshed tokens
           return this.makeRequestWithRetry(endpoint, method, params, true);
         } catch (_refreshError) {
-          console.error("❌ Token refresh failed:", _refreshError);
           throw new Error(
             `Authentication required: OAuth tokens are invalid or expired. Please log in again.`
           );

frontend/src/config.ts

···
 import { AtProtoClient } from "./client.ts";
-import { OAuthClient, DenoKVOAuthStorage } from "@slices/oauth";
-import { getKv } from "./lib/kv.ts";
+import { OAuthClient, SQLiteOAuthStorage } from "@slices/oauth";
 
 const OAUTH_CLIENT_ID = Deno.env.get("OAUTH_CLIENT_ID");
 const OAUTH_CLIENT_SECRET = Deno.env.get("OAUTH_CLIENT_SECRET");
···
   );
 }
 
-const kv = await getKv();
-const oauthStorage = new DenoKVOAuthStorage(kv);
+const DATABASE_URL = Deno.env.get("DATABASE_URL") || "slices.db";
+const oauthStorage = new SQLiteOAuthStorage(DATABASE_URL);
 
 const oauthClient = new OAuthClient(
   {
···
     clientSecret: OAUTH_CLIENT_SECRET,
     authBaseUrl: OAUTH_AIP_BASE_URL,
     redirectUri: OAUTH_REDIRECT_URI,
-    scopes: ["openid", "profile", "email", "atproto:atproto", "atproto:transition:generic"],
+    scopes: [
+      "openid",
+      "profile",
+      "email",
+      "atproto:atproto",
+      "atproto:transition:generic",
+    ],
   },
   oauthStorage
 );

frontend/src/lib/kv.ts

···
-// Shared Deno KV instance
-let kvInstance: Deno.Kv | null = null;
-
-export async function getKv(): Promise<Deno.Kv> {
-  if (!kvInstance) {
-    try {
-      // Use persistent file-based KV store
-      const kvPath = Deno.env.get("KV_PATH") || "./kv.db";
-      kvInstance = await Deno.openKv(kvPath);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `Failed to initialize Deno KV: ${message}. Make sure to run with --unstable-kv flag.`
-      );
-    }
-  }
-  return kvInstance;
-}

frontend/src/lib/session-store.ts

···
-// Deno KV-based session storage for user authentication
+// SQLite-based session storage for user authentication
 import { atprotoClient } from "../config.ts";
+import { DatabaseSync } from "node:sqlite";
 
 export interface SessionData {
   userDid: string;
···
 }
 
 export class SessionStore {
-  constructor(private kv: Deno.Kv) {}
+  private db: DatabaseSync;
+
+  constructor(databaseUrl: string) {
+    // Extract path from sqlite:// URL or use as-is
+    const dbPath = databaseUrl.startsWith("sqlite://")
+      ? databaseUrl.slice(9)
+      : databaseUrl;
+
+    this.db = new DatabaseSync(dbPath);
+    this.initializeDatabase();
+  }
+
+  private initializeDatabase() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        user_did TEXT NOT NULL,
+        handle TEXT,
+        is_authenticated INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL
+      )
+    `);
+
+    // Create index for faster cleanup of expired sessions
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_sessions_expires_at
+      ON sessions(expires_at)
+    `);
+  }
 
   // Create a new session
-  async createSession(userDid: string, handle?: string): Promise<string> {
+  createSession(userDid: string, handle?: string): string {
     const sessionId = crypto.randomUUID();
-    const expirationMs = 30 * 24 * 60 * 60 * 1000; // 30 days
+    const createdAt = Date.now();
+    const expiresAt = createdAt + 30 * 24 * 60 * 60 * 1000; // 30 days
 
-    const sessionData: SessionData = {
-      userDid,
-      handle,
-      isAuthenticated: true,
-      createdAt: Date.now(),
-    };
+    const stmt = this.db.prepare(`
+      INSERT INTO sessions (session_id, user_did, handle, is_authenticated, created_at, expires_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
 
-    await this.kv.set(["sessions", sessionId], sessionData, {
-      expireIn: expirationMs,
-    });
+    stmt.run(sessionId, userDid, handle || null, 1, createdAt, expiresAt);
 
     return sessionId;
   }
 
   // Get session data
-  async getSession(sessionId: string): Promise<SessionData | null> {
-    const result = await this.kv.get<SessionData>(["sessions", sessionId]);
-    return result.value;
+  getSession(sessionId: string): SessionData | null {
+    // Clean up expired sessions first
+    const cleanupStmt = this.db.prepare(
+      `DELETE FROM sessions WHERE expires_at < ?`
+    );
+    cleanupStmt.run(Date.now());
+
+    const stmt = this.db.prepare(`
+      SELECT user_did, handle, is_authenticated, created_at
+      FROM sessions
+      WHERE session_id = ? AND expires_at > ?
+    `);
+
+    const row = stmt.get(sessionId, Date.now()) as
+      | {
+          user_did: string;
+          handle: string | null;
+          is_authenticated: number;
+          created_at: number;
+        }
+      | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return {
+      userDid: row.user_did,
+      handle: row.handle || undefined,
+      isAuthenticated: Boolean(row.is_authenticated),
+      createdAt: row.created_at,
+    };
   }
 
   // Update session data
-  async updateSession(
+  updateSession(
     sessionId: string,
     updates: { handle?: string; isAuthenticated?: boolean }
-  ): Promise<boolean> {
-    const existing = await this.kv.get<SessionData>(["sessions", sessionId]);
+  ): boolean {
+    const parts = [];
+    const values = [];
+
+    if (updates.handle !== undefined) {
+      parts.push("handle = ?");
+      values.push(updates.handle);
+    }
+
+    if (updates.isAuthenticated !== undefined) {
+      parts.push("is_authenticated = ?");
+      values.push(updates.isAuthenticated ? 1 : 0);
+    }
 
-    if (!existing.value) {
+    if (parts.length === 0) {
       return false;
     }
 
-    const updated = {
-      ...existing.value,
-      ...updates,
-    };
+    // Extend expiration on update
+    parts.push("expires_at = ?");
+    values.push(Date.now() + 30 * 24 * 60 * 60 * 1000);
 
-    const expirationMs = 30 * 24 * 60 * 60 * 1000; // 30 days
-    await this.kv.set(["sessions", sessionId], updated, {
-      expireIn: expirationMs,
-    });
+    values.push(sessionId);
+    values.push(Date.now()); // Only update non-expired sessions
+
+    const stmt = this.db.prepare(`
+      UPDATE sessions
+      SET ${parts.join(", ")}
+      WHERE session_id = ? AND expires_at > ?
+    `);
 
-    return true;
+    const result = stmt.run(...values);
+    return result.changes > 0;
   }
 
   // Delete a session (logout)
-  async deleteSession(sessionId: string): Promise<void> {
-    await this.kv.delete(["sessions", sessionId]);
+  deleteSession(sessionId: string): void {
+    const stmt = this.db.prepare("DELETE FROM sessions WHERE session_id = ?");
+    stmt.run(sessionId);
   }
 
   // Get user info from OAuth client
   async getUserInfo(): Promise<UserData> {
-    const tokens = await atprotoClient.oauth?.getTokens();
-    console.log("Current access token:", tokens?.accessToken);
-    console.log("Token type:", tokens?.tokenType);
-
     const userInfo = await atprotoClient.oauth?.getUserInfo();
     console.log("Fetched user info:", userInfo);
     const isAuthenticated =
···
     }
 
     try {
-      const sessionData = await this.getSession(sessionId);
+      const sessionData = this.getSession(sessionId);
 
-      if (!sessionData || !sessionData.isAuthenticated) {
+      if (!sessionData) {
+        return { isAuthenticated: false };
+      }
+
+      if (!sessionData.isAuthenticated) {
         return { isAuthenticated: false };
       }
 
       // Try to ensure valid tokens (this will refresh if needed)
       try {
         await atprotoClient.oauth?.ensureValidToken();
+
         const oauthAuthenticated =
           (await atprotoClient.oauth?.isAuthenticated()) || false;
 
         if (!oauthAuthenticated) {
           // Mark session as unauthenticated if OAuth tokens are invalid
-          await this.updateSession(sessionId, { isAuthenticated: false });
+          this.updateSession(sessionId, { isAuthenticated: false });
           return { isAuthenticated: false };
         }
-      } catch (tokenError) {
-        console.error("Token validation/refresh failed:", tokenError);
+      } catch (_tokenError) {
         // Mark session as unauthenticated if token refresh fails
-        await this.updateSession(sessionId, { isAuthenticated: false });
+        this.updateSession(sessionId, { isAuthenticated: false });
         return { isAuthenticated: false };
       }
 
···
   }
 
   // Create session from user data
-  async createSessionFromUserData(userData: UserData): Promise<string> {
+  createSessionFromUserData(userData: UserData): string {
     if (!userData.sub) {
       throw new Error("User DID (sub) is required for session creation");
     }
 
-    return await this.createSession(userData.sub, userData.handle);
+    return this.createSession(userData.sub, userData.handle);
   }
 
   // Delete session from request
-  async deleteSessionFromRequest(req: Request): Promise<void> {
+  deleteSessionFromRequest(req: Request): void {
     const sessionId = getSessionIdFromRequest(req);
     if (sessionId) {
-      await this.deleteSession(sessionId);
+      this.deleteSession(sessionId);
     }
   }
 }

frontend/src/lib/stores.ts

···
-// Initialize all stores with shared KV instance
-import { getKv } from "./kv.ts";
+// Initialize all stores with shared database
 import { SessionStore } from "./session-store.ts";
 
-const kv = await getKv();
+const DATABASE_URL = Deno.env.get("DATABASE_URL") || "sqlite://slices.db";
 
-export const sessionStore = new SessionStore(kv);
+export const sessionStore = new SessionStore(DATABASE_URL);

frontend/src/routes/pages.tsx

···
 import type { Route } from "@std/http/unstable-route";
 import { render } from "preact-render-to-string";
-import { withAuth, requireAuth } from "./middleware.ts";
+import { withAuth } from "./middleware.ts";
 import { atprotoClient } from "../config.ts";
 import { buildAtUri } from "../utils/at-uri.ts";
 import { IndexPage } from "../pages/IndexPage.tsx";
···
 
 async function handleIndexPage(req: Request): Promise<Response> {
   const context = await withAuth(req);
-  const authResponse = requireAuth(context);
-  if (authResponse) return authResponse;
-
+  
   // Slice list page - get real slices from AT Protocol
   let slices: Array<{ id: string; name: string; createdAt: string }> = [];