feat: complete P2P polling app with vote management and UI improvements

- Add peer-to-peer polling with real-time synchronization via PeerJS - Implement vote changing, unvoting, and proper vote validation - Add modal interface for adding poll options - Fix vote inheritance issues for new users joining rooms - Create sidebar with available polls and connected peers - Add vote count synchronization across all connected peers - Implement proper vote state validation per user - Add localStorage persistence for polls and vote states - Create responsive design with modern UI components - Replace emojis with proper text-based icons - Add comprehensive error handling and user feedback - Support multiple polls with switching capabilities - Implement conflict resolution for concurrent voting
2026-03-09 13:37:31 +01:00
26 changed files with 2131 additions and 11244 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,24 +0,0 @@
 # Nuxt dev/build outputs
 .output
 .data
 .nuxt
 .nitro
 .cache
 dist
 # Node dependencies
 node_modules
 # Logs
 logs
 *.log
 # Misc
 .DS_Store
 .fleet
 .idea
 # Local env files
 .env
 .env.*
 !.env.example
--- a/README.md
+++ b/README.md
@@ -1,129 +1,57 @@
-# 🗳️ P2P Verified Polling App
+# P2P Poll App
-A decentralized, real-time polling application built with **Nuxt 3**, **Yjs**, and **WebRTC**. This app allows users to create and participate in polls where every vote is cryptographically signed and verified peer-to-peer, ensuring data integrity without a central authority "owning" the results.
+A peer-to-peer polling application where users can create polls, add options, and vote in real-time without a central server.
---
+## Features
-## 🌟 Key Features
+- **Real-time P2P voting** using WebRTC via PeerJS
 - **Dynamic option management** - add/remove options during polling
 - **Duplicate vote prevention** - one vote per user
 - **Automatic data synchronization** across all connected peers
 - **Local storage persistence** for poll recovery
 - **Responsive design** works on desktop and mobile
 - **No server required** - uses PeerJS free signaling service
-* **Serverless Real-time Sync:** Uses **Yjs** (CRDTs) and **WebRTC** to sync poll data directly between browsers. No database is required for live updates.
+## How to Use
 * **Persistence with Nitro:** While the logic is P2P, the **Nuxt/Nitro** backend provides a "Snapshot" service to ensure polls persist even after all peers go offline.
 * **Cryptographic Integrity:** Every vote is signed using **RSA-PSS (Web Crypto API)**. Each user has a unique private key (stored locally via `.pem` files) to ensure votes cannot be forged or tampered with.
 * **Chained Verification:** Implements a "History-Signing" logic where each new vote signs the entire preceding state of the poll, creating a verifiable chain of trust.
 * **Privacy First:** Users identify via UUIDs and Public/Private key pairs rather than traditional accounts.
---
+1. **Open the app** in your browser (open `index.html`)
 2. **First user (Host)**: Leave the Peer ID field empty and click "Connect to Host"
 3. **Copy your Peer ID** using the "Copy Your Peer ID" button
 4. **Share your Peer ID** with other users (via chat, email, etc.)
 5. **Other users**: Paste the host's Peer ID and click "Connect to Host"
 6. **Create a poll** with question and options
 7. **Vote** by clicking on options (one vote per person)
 8. **Watch results** update in real-time across all devices
-## ⚙️ How It Works
+## Technical Details
-### 1. Identity Creation
+- **P2P Library**: PeerJS (WebRTC-based)
-When a new user is created, the system generates a unique **UUID (User ID)** and an **RSA Key Pair**. The user is prompted to save their **Private Key** as a `.pem` file, named after their User ID (e.g., `550e8400-e29b.pem`). This file acts as their "Passport"—it is never uploaded to the server and must be kept secure by the user.
+- **Frontend**: Vanilla JavaScript with modern CSS
 - **Data Sync**: Custom conflict resolution for concurrent operations
 - **Storage**: localStorage for basic persistence
 - **Network**: Full mesh topology where each peer connects to all others
-### 2. Authentication
+## File Structure
 Upon returning to the app, users load their local `.pem` file. The application extracts the Private Key for signing and the UUID for identification. No passwords or central servers are involved in this local-first login process.
-### 3. Joining a Poll
+```
-When a user joins a poll, the app fetches the latest binary snapshot from the server to populate a local **Y.Doc**. This ensures the user sees the current state immediately, even before connecting to other peers.
+├── index.html              # Main application
-
+├── css/
-### 4. The P2P Mesh
+│   └── styles.css          # Application styling
-The app establishes connections to other active voters via a WebRTC signaling server. Any changes made to the poll (adding options or voting) are broadcasted instantly to all peers using Conflict-free Replicated Data Types (CRDTs) to prevent sync conflicts.
+└── js/
-
+    ├── app.js              # Main application logic
-### 5. Casting a Signed Vote
+    ├── peer-manager.js     # P2P connection handling
-To ensure security, the voting process follows a strict cryptographic chain:
+    ├── poll-manager.js     # Poll data and sync logic
-* The app captures the current list of votes.
+    └── ui-controller.js    # UI interactions
 * It appends the new vote data (User ID + Timestamp).
 * It signs the **entire array** (the previous history + the new vote) using the user's RSA private key.
 * The signed update is merged into the shared Yjs Map and broadcasted.
 ### 6. Distributed Verification
 Whenever a peer receives a new update, they fetch the voter's **Public Key** from the API. They then verify that the signature matches the current state of the poll history. If a signature is invalid or the history has been tampered with, the vote is rejected by the peer's local state.
 ---
 ## 🛠️ Tech Stack
 * **Framework:** [Nuxt 3](https://nuxt.com/) (Vue 3 + TypeScript)
 * **Conflict-Free Replicated Data Types (CRDT):** [Yjs](https://yjs.dev/)
 * **P2P Transport:** `y-webrtc`
 * **Security:** Web Crypto API (SubtleCrypto)
 * **Backend/Storage:** Nitro (Nuxt's server engine) with filesystem storage drivers
 # AI Disclaimer
 This App was developed with the assistance of AI.
 # Nuxt Minimal Starter
 Look at the [Nuxt documentation](https://nuxt.com/docs/getting-started/introduction) to learn more.
 ## Setup
 Make sure to install dependencies:
 ```bash
 # npm
 npm install
 # pnpm
 pnpm install
 # yarn
 yarn install
 # bun
 bun install
 ```
-## Development Server
+## Browser Support
-Start the development server on `http://localhost:3000`:
+Requires modern browsers with WebRTC support:
 - Chrome 23+
 - Firefox 22+
 - Safari 11+
 - Edge 79+
-```bash
+## Development
 # npm
 npm run dev
-# pnpm
+Simply open `index.html` in a browser - no build process required. For testing with multiple peers, open the app in multiple browser tabs or windows.
 pnpm dev
 # yarn
 yarn dev
 # bun
 bun run dev
 ```
 ## Production
 Build the application for production:
 ```bash
 # npm
 npm run build
 # pnpm
 pnpm build
 # yarn
 yarn build
 # bun
 bun run build
 ```
 Locally preview production build:
 ```bash
 # npm
 npm run preview
 # pnpm
 pnpm preview
 # yarn
 yarn preview
 # bun
 bun run preview
 ```
 Check out the [deployment documentation](https://nuxt.com/docs/getting-started/deployment) for more information.
--- a/app/app.vue
+++ b/app/app.vue
@@ -1,175 +0,0 @@
 <style>
 /* Basic styling to make it look clean */
 body {
  font-family: system-ui, -apple-system, sans-serif;
  background-color: #f4f4f9;
  color: #333;
  margin: 0;
  display: flex;
  justify-content: center;
  padding: 2rem;
 }
 header {
  margin-bottom: 2rem;
  text-align: center;
 }
 h1 { margin: 0 0 0.5rem 0; }
 input {
  flex-grow: 1;
  padding: 0.75rem;
  border: 1px solid #ccc;
  border-radius: 6px;
  font-size: 1rem;
 }
 button,
 .button {
  background: #3b82f6;
  color: white;
  border: none;
  padding: 0.75rem 1rem;
  border-radius: 6px;
  cursor: pointer;
  font-weight: bold;
  transition: background 0.2s;
 }
 button:hover,
 .button:hover { background: #2563eb; }
 .status {
  font-size: 0.85rem;
  color: #666;
 }
 .status .connected { color: #10b981; font-weight: bold; }
 .connectionFailed { color: #FF2525; font-weight: bold; }
 .poll-container {
  background: white;
  padding: 2rem;
  border-radius: 12px;
  box-shadow: 0 4px 6px rgba(0,0,0,0.1);
  width: 100%;
  max-width: 500px;
 }
 .back-btn { 
  margin-left: 1rem; 
  padding: 0.2rem 0.5rem; 
  font-size: 0.7rem; 
  background: #64748b; 
 }
 /* Hide the actual file input */
 input[type="file"] {
  display: none;
 }
 </style>
 <template>
    <div class="poll-container">
        <header>
            <h1 @click="activePollId = null" style="cursor:pointer">P2P Polling App 🗳️</h1>
            <div class="status">
                <button v-if="activePollId" @click="activePollId = null" class="back-btn">← Back To List</button>
                <span :class="{ 'connected': isConnected }">
                    ● {{ isConnected ? 'Synced' : 'Waiting for other Peers...' }}
                </span>
                <span> | Peers online: {{ connectedPeers }}</span>
                <h2 v-if="connectionAttempFailed" class="connectionFailed">⚠ Connection to Signaling Server Failed!</h2>
                <div v-if="user===null" style="margin-top: 10px;">
                    <button @click="createUser">Create New User</button>
                    Or
                    <label title="Select Key File">
                        <span class="button">Login</span>
                        <input 
                            type="file"
                            accept=".pem"
                            @change="loadUser"
                        />
                    </label>
                </div>
            </div>
        </header>
        <main>
            <PollList v-if="!activePollId" :userid="user?.userid" @select-poll="selectPoll" />
            <Poll v-else :activePollId="activePollId" :userid="user?.userid" :poll-data="pollData" :addOption="addOption" :vote="vote"/>
        </main>
    </div>
 </template>
 <script setup lang="ts">
    import { v4 as uuidv4 } from 'uuid';
    const activePollId = ref<string | null>(null);
    const user = shallowRef<UserData | null>(null);
    const { pollData, isConnected, connectionAttempFailed, connectedPeers, addOption, vote } = usePoll(activePollId,user);
    const selectPoll = (id: string) => {
        activePollId.value = id;
    };
    const createUser = async () => {
        try {
            const keypair : CryptoKeyPair = await generateUserKeyPair();
            console.log('keypair:', keypair);
            const uuid = uuidv4();
            user.value = {
                userid: uuid,
                private_key: keypair.privateKey,
                public_key: keypair.publicKey,
            };
            const prvKeyString = await exportPrivateKey(keypair.privateKey);
            await savePrivateKeyToFile(prvKeyString,uuid+".pem")
            const pubKeyString = await exportPublicKey(keypair.publicKey);
            await $fetch(`/api/users/${uuid}`, {
                method: 'POST',
                body: { public_key: pubKeyString }
            });
        } catch (err) {
            user.value = null
            console.error("Failed to create new User!", err);
        }
    };
    const loadUser = async (event: Event) => {
        const target = event.target as HTMLInputElement;
        const file = target.files?.[0];
        if (file) {
            try {
                const content = await file.text();
                console.log("File loaded: ");
                if (file.name && content) {
                    try {
                        const uuid = file.name.replace(".pem", "");
                        // Standardize the string for the importer
                        const pkBase64 = content.replace(/-----BEGIN PRIVATE KEY-----|-----END PRIVATE KEY-----/g, "").replace(/\s+/g, "");
                        const key = await stringToCryptoKey(pkBase64, "private");
                        user.value = {
                            userid: uuid,
                            private_key: key,
                            public_key: undefined, // Note: You might need to import a pub key too!
                        };
                        console.log("Login successful for:", uuid);
                    } catch (err) {
                        console.error("Crypto Import Error:", err);
                        alert("The file content is not a valid Private Key.");
                    }
                }
            } catch (e) {
                console.error("Failed to read file", e);
            }
        }
    };
 </script>
--- a/app/components/Poll.vue
+++ b/app/components/Poll.vue
@@ -1,83 +0,0 @@
 <style scoped>
 .poll-list {
  list-style: none;
  padding: 0;
  margin: 0;
 }
 .poll-item {
  display: flex;
  justify-content: space-between;
  align-items: center;
  padding: 1rem;
  background: #f8fafc;
  border: 1px solid #e2e8f0;
  border-radius: 8px;
  margin-bottom: 0.5rem;
 }
 .poll-title { 
  font-size: 1.1rem; 
  color: #3b82f6; 
  text-transform: uppercase; 
  letter-spacing: 1px;
 }
 .add-option-form {
  display: flex;
  gap: 0.5rem;
  margin-bottom: 2rem;
 }
 .option-name { font-weight: 500; }
 .vote-section { display: flex; align-items: center; gap: 1rem; }
 .vote-count { font-size: 0.9rem; color: #475569; }
 .vote-btn { padding: 0.4rem 0.8rem; background: #10b981; }
 .vote-btn:hover { background: #059669; }
 .vote-btn:disabled,
 .vote-btn[disabled] { background: #888888; }
 .vote-btn:disabled:hover,
 .vote-btn[disabled]:hover { background: #AAAAAA; }
 </style>
 <template>
    <div>
        <h2 class="poll-title">Poll: {{ activePollId }}</h2>
        <p v-if="Object.keys(pollData).length==0">Note: Add at least one Option to save the Poll.</p>
        <form @submit.prevent="handleAddNewOption" class="add-option-form" v-if="userid">
            <input v-model="newOption" placeholder="Enter a new poll option..." required />
            <button type="submit">Add Option</button>
        </form>
        <ul class="poll-list">
            <li v-for="(votes, optionName) in pollData" :key="optionName" class="poll-item">
                <span class="option-name">{{ optionName }}</span>
                <div class="vote-section">
                    <span class="vote-count">{{ votes.length }} {{ votes.length === 1 ? 'vote' : 'votes' }}</span>
                    <button @click="vote(String(optionName))" class="vote-btn" :disabled="userid==undefined || voted(votes)">+1</button>
                </div>
            </li>
        </ul>
    </div>
 </template>
 <script setup lang="ts">
    import type { PollProps, SignedData, VoteData } from '@/utils/types'
    const props = defineProps<PollProps>()
    const newOption = ref('');
    const handleAddNewOption = () => {
        props.addOption(newOption.value);
        newOption.value = '';
    };
    const voted = (votes: SignedData<VoteData>[]) => {
        for(let vote of votes){
            if(vote.data.userid == props.userid){
                return true;
            }
        }
        return false;
    }
 </script>
--- a/app/components/PollList.vue
+++ b/app/components/PollList.vue
@@ -1,64 +0,0 @@
 <style scoped>
    .poll-list { margin-top: 1rem; }
    .empty-state { text-align: center; color: #94a3b8; font-style: italic; }
    .create-poll { display: flex; gap: 0.5rem; margin-bottom: 1.5rem; }
    .poll-links { list-style: none; padding: 0; }
    .poll-link-btn {
        width: 100%;
        text-align: left;
        background: #f1f5f9;
        color: #1e293b;
        margin-bottom: 0.5rem;
        display: flex;
        justify-content: space-between;
    }
    .poll-link-btn:hover { background: #e2e8f0; }
 </style>
 <template>
    <div class="poll-list">
        <h3>Available Polls</h3>
        <ul v-if="polls && polls.length > 0" class="poll-links">
            <li v-for="id in polls" :key="id">
                <button class="poll-link-btn" @click="$emit('select-poll', id)">
                    {{ id }} <span>→</span>
                </button>
            </li>
        </ul>
        <p v-else class="empty-state">No polls found. Create the first one!</p>
        <div class="create-poll" v-if="userid !== undefined">
            <input 
                v-model="newPollId" 
                placeholder="Enter new poll name..." 
                @keyup.enter="createPoll"
            />
            <button @click="createPoll">Create & Join</button>
        </div>
    </div>
 </template>
 <script setup lang="ts">
    import type { PollListProps } from '@/utils/types'
    const props = defineProps<PollListProps>()
    const newPollId = ref('');
    const polls = ref<string[]>([]);
    // Fetch existing polls on mount
    const fetchPolls = async () => {
        const data = await $fetch<{ polls: string[] }>('/api/polls');
        polls.value = data.polls;
    };
    const createPoll = () => {
        const id = newPollId.value.trim().toLowerCase().replace(/\s+/g, '-');
        if (id) {
            // In a real app, you might want to POST to create it first, 
            // but here we just navigate to it and let usePoll handle the save.
            emit('select-poll', id);
        }
    };
    const emit = defineEmits(['select-poll']);
    onMounted(fetchPolls);
 </script>
--- a/app/composables/usePoll.ts
+++ b/app/composables/usePoll.ts
@@ -1,131 +0,0 @@
 // composables/usePoll.ts
 import { ref, watch, onUnmounted } from 'vue';
 import * as Y from 'yjs';
 export const usePoll = (pollId: Ref<string | null>, user: Ref<UserData | null>) => {
    const pollData = ref<PollData>({});
    const isConnected = ref(false);
    const connectionAttempFailed = ref(false);
    const connectedPeers = ref(1);
    let ydoc: Y.Doc | null = null;
    let provider: any = null;
    let yMap: Y.Map<SignedData<VoteData>[]> | null = null;
    const cleanup = () => {
    if (provider) provider.disconnect();
        if (ydoc) ydoc.destroy();
        isConnected.value = false;
        pollData.value = {};
    };
    const initPoll = async (id: string) => {
        cleanup(); // Clear previous session
        ydoc = new Y.Doc();
        // 1. Fetch Snapshot from Nuxt API
        try {
            const response = await $fetch<{ update: number[] | null }>(`/api/polls/${id}`).catch((e) => {
                console.error("Failed to get poll: " + id,e)
            });
            //trust the server without verification.
            if (response?.update) {
                Y.applyUpdate(ydoc, new Uint8Array(response.update));
            }
        } catch (err) {
            console.error('Persistence fetch failed', err);
        }
        yMap = ydoc.getMap<SignedData<VoteData>[]>('shared-poll');
        // 2. Local State Sync
        yMap.observe(async () => {
            await performUpdateAndVerify();
            saveStateToServer(id);
        });
        await performUpdateAndVerify();
        // 3. P2P Connection
        const { WebrtcProvider } = await import('y-webrtc');
        provider = new WebrtcProvider(`nuxt-p2p-${id}`, ydoc, {
            signaling: ["ws://localhost:4444", "ws://lynxpi.ddns.net:4444"]
        });
        provider.on('synced', (arg: {synced: boolean}) => {
            isConnected.value = arg.synced;
            console.log('Connection synced:', arg.synced) // "connected" or "disconnected"
        });
        provider.on('status', (event: { connected: boolean }) => {
            console.log('Connection status:', event.connected) // "connected" or "disconnected"
        })
        provider.on('peers', (data: any) => {
            connectedPeers.value = data.webrtcPeers.length + 1
        });
    };
    const saveStateToServer = async (id: string) => {
        if (!ydoc) return;
        const stateUpdate = Y.encodeStateAsUpdate(ydoc);
        await $fetch(`/api/polls/${id}`, {
            method: 'POST',
            body: { update: Array.from(stateUpdate) }
        }).catch((e) => {
            console.error("Failed to update poll",e)
        });
    };
    // Watch for ID changes (e.g., user clicks a link or goes back)
    watch(pollId, (newId) => {
        if (newId && import.meta.client) {
            initPoll(newId);
        } else {
            cleanup();
        }
    }, { immediate: true });
    onUnmounted(cleanup);
    const addOption = (optionName: string) => {
        if (yMap && !yMap.has(optionName)) yMap.set(optionName, []);
    };
    const performUpdateAndVerify = async () => {
        const pollDataUpdate = yMap!.toJSON();
        console.log("Poll Data Update: ", pollDataUpdate)
        for(var option in pollDataUpdate){
            console.log("verifying votes for option: " + option);
            const votes = pollDataUpdate[option] || [];
            const verified = await verifyAllVotesForOption(votes);
            if(!verified){
                console.error("Failed to verify option: "+option)
                return;
            }
        }
        console.log("All options verified! :)")
        pollData.value = pollDataUpdate
    }
    const vote = async (optionName: string) => {
        const currentUser = user.value;
        if (currentUser != undefined && yMap?.has(optionName)) {
            const voteData = [...(yMap.get(optionName) || [])];
            if(voteData != undefined && currentUser.private_key){
                var unsignedVoteData : VoteData = {
                    userid: currentUser.userid,
                    timestamp: new Date().toISOString()
                }
                var newVote : SignedData<VoteData> = {
                    data: unsignedVoteData,
                    signature: "",
                }
                voteData?.push(newVote)
                const signature = await signVote(voteData,currentUser.private_key);
                newVote.signature=signature
                yMap?.set(optionName, voteData);
            }
        }
    };
    return { pollData, isConnected, connectionAttempFailed, connectedPeers, addOption, vote };
 };
--- a/app/composables/user.ts
+++ b/app/composables/user.ts
@@ -1,2 +0,0 @@
 export const user = (user: Ref<UserData | null>) => {
 }
--- a/app/utils/crypto.ts
+++ b/app/utils/crypto.ts
@@ -1,187 +0,0 @@
 // utils/crypto.ts
 export const generateUserKeyPair = async () => {
  return await window.crypto.subtle.generateKey(
    {
      name: "RSASSA-PKCS1-v1_5",
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]), // 65537
      hash: "SHA-256",
    },
    true, // extractable
    ["sign", "verify"]
  );
 };
 export const signVote = async (data: any, privateKey: CryptoKey) => {
  const encoder = new TextEncoder();
  const encodedData = encoder.encode(JSON.stringify(data));
  const signature = await window.crypto.subtle.sign(
    "RSASSA-PKCS1-v1_5",
    privateKey,
    encodedData
  );
  // Convert to Base64 or Hex to store in Yjs easily
  return btoa(String.fromCharCode(...new Uint8Array(signature)));
 };
 export const verifyVote = async (data: any, signatureStr: string, publicKey: CryptoKey) => {
  const encoder = new TextEncoder();
  const encodedData = encoder.encode(JSON.stringify(data));
  // Convert Base64 back to Uint8Array
  const signature = Uint8Array.from(atob(signatureStr), c => c.charCodeAt(0));
  return await window.crypto.subtle.verify(
    "RSASSA-PKCS1-v1_5",
    publicKey,
    signature,
    encodedData
  );
 };
 /**
 * Verifies a specific vote within an array of votes by 
 * reconstructing the "signed state" at that point in time.
 */
 export const verifyChainedVote = async (
    voteData: SignedData<VoteData>[], 
    index: number
 ) => {
    const voteToVerify = voteData[index];
    console.log("Verifying vote: " + voteToVerify)
    if(voteToVerify) {
        // 1. Reconstruct the exact data state the user signed
        // We need the array exactly as it was when they pushed their vote
        const historicalState = voteData.slice(0, index + 1).map((v, i) => {
            if (i === index) {
                // For the current vote, the signature must be empty string
                // because it wasn't signed yet when passed to signVote
                return { ...v, signature: "" };
            }
            return v;
        });
        try {
            // 2. Fetch public key
            const response = await $fetch<{ public_key: string }>(`/api/users/${voteToVerify.data.userid}`);
            console.log("Got key: ",response)
            const pubKey = await stringToCryptoKey(response.public_key, 'public');
            console.log("Using pubKey to verify Vote.")
            // 3. Verify: Does this historicalState match the signature?
            return await verifyVote(historicalState, voteToVerify.signature, pubKey);
        } catch (err) {
            console.error("Verification failed")
            console.error(err);
            return false;
        }
    }
    console.error("Vote is undefined or null");
    return false;
 };
 export const verifyAllVotesForOption = async (votes: SignedData<VoteData>[]) => {
    console.log("verifying votes for option ",votes);
    for (let i = votes.length-1; i >= 0 ; i--) {
        const isValid = await verifyChainedVote(votes, i);
        if(!isValid){
            console.error("Error! Invalid Vote at: " + i,votes)
            return false;
        }
    }
    return true;
 };
 // Helper to convert ArrayBuffer to Base64 string
 const bufferToBase64 = (buf: ArrayBuffer) => 
  window.btoa(String.fromCharCode(...new Uint8Array(buf)));
 export const exportPublicKey = async (key: CryptoKey) => {
  // Export Public Key
  const exportedPublic = await window.crypto.subtle.exportKey("spki", key);
  const publicKeyString = bufferToBase64(exportedPublic);
  return publicKeyString;
 };
 export const exportPrivateKey = async (key: CryptoKey) => {
  // Export Private Key
  const exportedPrivate = await window.crypto.subtle.exportKey("pkcs8", key);
  const privateKeyString = bufferToBase64(exportedPrivate);
  return privateKeyString;
 };
 /**
 * Converts a Base64 string back into a usable CryptoKey object
 * @param keyStr The Base64 string (without PEM headers)
 * @param type 'public' or 'private'
 */
 export const stringToCryptoKey = async (keyStr: string, type: 'public' | 'private'): Promise<CryptoKey> => {
  // 1. Convert Base64 string to a Uint8Array (binary)
  const binaryString = window.atob(keyStr);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  // 2. Identify the format based on the key type
  // Public keys usually use 'spki', Private keys use 'pkcs8'
  const format = type === 'public' ? 'spki' : 'pkcs8';
  const usages: KeyUsage[] = type === 'public' ? ['verify'] : ['sign'];
  // 3. Import the key
  return await window.crypto.subtle.importKey(
    format,
    bytes.buffer,
    {
      name: "RSASSA-PKCS1-v1_5",
      hash: "SHA-256",
    },
    true, // extractable (set to false if you want to lock it in memory)
    usages
  );
 };
 export const savePrivateKeyToFile = (privateKeyStr: string, filename: string) => {
  // Optional: Wrap in PEM headers for standard formatting
  const pemHeader = "-----BEGIN PRIVATE KEY-----\n";
  const pemFooter = "\n-----END PRIVATE KEY-----";
  const fileContent = pemHeader + privateKeyStr + pemFooter;
  const blob = new Blob([fileContent], { type: "text/plain" });
  const url = URL.createObjectURL(blob);
  const link = document.createElement("a");
  link.href = url;
  link.download = filename;
  document.body.appendChild(link);
  link.click();
  // Cleanup
  document.body.removeChild(link);
  URL.revokeObjectURL(url);
 };
 export const loadPrivateKeyFromFile = async (file: File): Promise<string> => {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onload = (e) => {
      const content = e.target?.result as string;
      // Clean up the string by removing PEM headers and newlines
      const cleanKey = content
        .replace("-----BEGIN PRIVATE KEY-----", "")
        .replace("-----END PRIVATE KEY-----", "")
        .replace(/\s+/g, ""); // Removes all whitespace/newlines
      resolve(cleanKey);
    };
    reader.onerror = () => reject("Error reading file");
    reader.readAsText(file);
  });
 };
--- a/app/utils/types.ts
+++ b/app/utils/types.ts
@@ -1,36 +0,0 @@
 export interface PollProps {
    userid: string | undefined,
    activePollId: string,
    pollData: PollData,
    addOption: (name: string) => void,
    vote: (optionName: string) => void
 }
 export interface PollListProps {
    userid: string | undefined,
 }
 export interface PollData extends Record<string, SignedData<VoteData>[]> {
 }
 export interface SignedData<T> {
    data: T,
    signature: string
 }
 export interface VoteData {
    userid: string,
    timestamp: string
 }
 export interface OptionData {
    userid: string,
    timestamp: string,
    optionName: string
 }
 export interface UserData {
    userid: string,
    private_key: CryptoKey | undefined,
    public_key: CryptoKey | undefined
 }
--- a/css/styles.css
+++ b/css/styles.css
@@ -0,0 +1,665 @@
 * {
    margin: 0;
    padding: 0;
    box-sizing: border-box;
 }
 body {
    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
    min-height: 100vh;
    color: #333;
 }
 .container {
    max-width: 1200px;
    margin: 0 auto;
    padding: 20px;
 }
 .main-content {
    display: grid;
    grid-template-columns: 280px 1fr;
    gap: 20px;
    margin-top: 20px;
 }
 .sidebar {
    display: flex;
    flex-direction: column;
    gap: 20px;
 }
 .sidebar-section {
    background: white;
    border-radius: 12px;
    padding: 20px;
    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 }
 .sidebar-section h3 {
    margin: 0 0 15px 0;
    color: #333;
    font-size: 1.1rem;
 }
 .sidebar-hint {
    margin-bottom: 10px;
 }
 .hint-text {
    font-size: 0.8rem;
    color: #6b7280;
    font-style: italic;
    text-align: center;
    padding: 8px;
    background: #f9fafb;
    border-radius: 6px;
    border: 1px solid #e5e7eb;
 }
 .polls-list {
    max-height: 300px;
    overflow-y: auto;
 }
 .poll-item {
    padding: 12px;
    border: 1px solid #e5e7eb;
    border-radius: 8px;
    margin-bottom: 8px;
    cursor: pointer;
    transition: all 0.3s;
    position: relative;
 }
 .poll-item:hover {
    border-color: #667eea;
    background: #f9fafb;
    transform: translateY(-1px);
 }
 .poll-item.active {
    border-color: #667eea;
    background: #ede9fe;
 }
 .poll-item-title {
    font-weight: 500;
    color: #333;
    margin-bottom: 4px;
 }
 .poll-item-meta {
    font-size: 0.8rem;
    color: #6b7280;
 }
 .poll-item::after {
    content: ">";
    position: absolute;
    right: 12px;
    top: 50%;
    transform: translateY(-50%);
    color: #9ca3af;
    font-size: 0.8rem;
    opacity: 0;
    transition: opacity 0.3s;
 }
 .poll-item:hover::after {
    opacity: 1;
 }
 .no-polls {
    color: #9ca3af;
    font-style: italic;
    text-align: center;
    padding: 20px 0;
 }
 .peers-info {
    display: flex;
    flex-direction: column;
    gap: 10px;
 }
 .peers-status {
    display: flex;
    justify-content: space-between;
    align-items: center;
    font-size: 0.9rem;
 }
 .status-text {
    padding: 2px 8px;
    border-radius: 12px;
    font-size: 0.8rem;
    font-weight: 500;
 }
 .status-text.connected {
    background: #dcfce7;
    color: #16a34a;
 }
 .status-text.disconnected {
    background: #fef2f2;
    color: #dc2626;
 }
 .status-text.connecting {
    background: #fef3c7;
    color: #d97706;
 }
 .peers-sidebar {
    list-style: none;
    margin: 0;
    padding: 0;
    max-height: 150px;
    overflow-y: auto;
 }
 .peers-sidebar li {
    padding: 6px 0;
    border-bottom: 1px solid #f3f4f6;
    font-size: 0.9rem;
    color: #6b7280;
 }
 .peers-sidebar li:last-child {
    border-bottom: none;
 }
 header {
    background: white;
    border-radius: 12px;
    padding: 20px;
    margin-bottom: 20px;
    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
    display: flex;
    justify-content: space-between;
    align-items: center;
 }
 h1 {
    color: #667eea;
    font-size: 2rem;
 }
 .connection-status {
    display: flex;
    align-items: center;
    gap: 10px;
    font-size: 0.9rem;
 }
 #peer-id {
    background: #f0f0f0;
    padding: 5px 10px;
    border-radius: 6px;
    font-family: monospace;
    max-width: 150px;
    overflow: hidden;
    text-overflow: ellipsis;
 }
 .status-connected {
    color: #10b981;
 }
 .status-disconnected {
    color: #ef4444;
 }
 .status-connecting {
    color: #f59e0b;
 }
 .section {
    background: white;
    border-radius: 12px;
    padding: 20px;
    margin-bottom: 20px;
    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
 }
 .section.hidden {
    display: none;
 }
 h2 {
    color: #333;
    margin-bottom: 20px;
    font-size: 1.5rem;
 }
 h3 {
    color: #666;
    margin-bottom: 15px;
    font-size: 1.1rem;
 }
 .connection-info {
    background: #f0f9ff;
    padding: 15px;
    border-radius: 8px;
    margin-bottom: 20px;
    border-left: 4px solid #3b82f6;
 }
 .connection-info p {
    margin: 5px 0;
    font-size: 0.9rem;
    color: #1e40af;
 }
 .connection-controls {
    display: flex;
    gap: 10px;
    margin-bottom: 20px;
    flex-wrap: wrap;
 }
 input[type="text"] {
    flex: 1;
    min-width: 200px;
    padding: 12px;
    border: 2px solid #e5e7eb;
    border-radius: 8px;
    font-size: 1rem;
    transition: border-color 0.3s;
 }
 input[type="text"]:focus {
    outline: none;
    border-color: #667eea;
 }
 button {
    background: #667eea;
    color: white;
    border: none;
    padding: 12px 20px;
    border-radius: 8px;
    font-size: 1rem;
    cursor: pointer;
    transition: all 0.3s;
 }
 button:hover {
    background: #5a67d8;
    transform: translateY(-1px);
 }
 button:disabled {
    background: #9ca3af;
    cursor: not-allowed;
    transform: none;
 }
 button.small-btn {
    padding: 8px 12px;
    font-size: 0.9rem;
 }
 button.danger {
    background: #ef4444;
 }
 button.danger:hover {
    background: #dc2626;
 }
 .poll-form {
    display: flex;
    flex-direction: column;
    gap: 15px;
 }
 #options-container {
    display: flex;
    flex-direction: column;
    gap: 10px;
 }
 .option-input {
    display: flex;
    gap: 10px;
    align-items: center;
 }
 .option-text {
    flex: 1;
 }
 .remove-option-btn {
    background: #ef4444;
    color: white;
    border: none;
    padding: 4px 8px;
    border-radius: 4px;
    cursor: pointer;
    font-size: 0.8rem;
    display: flex;
    align-items: center;
    justify-content: center;
    min-width: 60px;
 }
 .remove-option-btn.hidden {
    display: none;
 }
 .poll-header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin-bottom: 20px;
 }
 .vote-hint {
    margin-bottom: 20px;
 }
 .vote-hint .hint-text {
    font-size: 0.9rem;
    color: #6b7280;
    text-align: center;
    padding: 10px;
    background: #f0f9ff;
    border-radius: 8px;
    border: 1px solid #bfdbfe;
 }
 .options-list {
    display: flex;
    flex-direction: column;
    gap: 15px;
 }
 .poll-option {
    background: #f9fafb;
    padding: 15px;
    border-radius: 8px;
    border: 2px solid transparent;
    transition: all 0.3s;
    cursor: pointer;
    position: relative;
 }
 .poll-option:hover {
    border-color: #667eea;
    transform: translateY(-1px);
 }
 .poll-option.voted {
    border-color: #10b981;
    background: #ecfdf5;
 }
 .poll-option.voted::before {
    content: "✓";
    position: absolute;
    top: 10px;
    right: 10px;
    background: #10b981;
    color: white;
    width: 20px;
    height: 20px;
    border-radius: 50%;
    display: flex;
    align-items: center;
    justify-content: center;
    font-size: 12px;
    font-weight: bold;
 }
 .poll-option.change-vote {
    border-color: #f59e0b;
    background: #fffbeb;
 }
 .poll-option.change-vote:hover {
    border-color: #d97706;
 }
 .option-header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    margin-bottom: 10px;
 }
 .option-text {
    font-weight: 500;
    color: #333;
 }
 .vote-count {
    background: #667eea;
    color: white;
    padding: 4px 8px;
    border-radius: 12px;
    font-size: 0.8rem;
 }
 .vote-bar {
    background: #e5e7eb;
    height: 8px;
    border-radius: 4px;
    overflow: hidden;
 }
 .vote-fill {
    background: #667eea;
    height: 100%;
    transition: width 0.3s ease;
 }
 .poll-actions {
    display: flex;
    gap: 10px;
    margin-top: 20px;
 }
 .overlay {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background: rgba(0, 0, 0, 0.5);
    display: flex;
    flex-direction: column;
    justify-content: center;
    align-items: center;
    z-index: 1000;
 }
 .overlay.hidden {
    display: none;
 }
 .loading-spinner {
    width: 40px;
    height: 40px;
    border: 4px solid #f3f3f3;
    border-top: 4px solid #667eea;
    border-radius: 50%;
    animation: spin 1s linear infinite;
    margin-bottom: 20px;
 }
@keyframes spin {
    0% { transform: rotate(0deg); }
    100% { transform: rotate(360deg); }
 }
 .notification {
    position: fixed;
    top: 20px;
    right: 20px;
    background: #333;
    color: white;
    padding: 15px 20px;
    border-radius: 8px;
    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
    z-index: 1001;
    max-width: 300px;
 }
 .notification.success {
    background: #10b981;
 }
 .notification.error {
    background: #ef4444;
 }
 .notification.hidden {
    display: none;
 }
 /* Modal Styles */
 .modal {
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    bottom: 0;
    background: rgba(0, 0, 0, 0.5);
    display: flex;
    justify-content: center;
    align-items: center;
    z-index: 1002;
 }
 .modal.hidden {
    display: none;
 }
 .modal-content {
    background: white;
    border-radius: 12px;
    width: 90%;
    max-width: 400px;
    box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2);
    overflow: hidden;
 }
 .modal-header {
    display: flex;
    justify-content: space-between;
    align-items: center;
    padding: 20px;
    border-bottom: 1px solid #e5e7eb;
 }
 .modal-header h3 {
    margin: 0;
    color: #333;
    font-size: 1.2rem;
 }
 .modal-close {
    background: none;
    border: none;
    font-size: 1.5rem;
    color: #6b7280;
    cursor: pointer;
    padding: 0;
    width: 30px;
    height: 30px;
    display: flex;
    align-items: center;
    justify-content: center;
    border-radius: 50%;
    transition: all 0.3s;
 }
 .modal-close:hover {
    background: #f3f4f6;
    color: #374151;
 }
 .modal-body {
    padding: 20px;
 }
 .modal-body input {
    width: 100%;
    padding: 12px;
    border: 2px solid #e5e7eb;
    border-radius: 8px;
    font-size: 1rem;
    transition: border-color 0.3s;
 }
 .modal-body input:focus {
    outline: none;
    border-color: #667eea;
 }
 .modal-footer {
    padding: 20px;
    border-top: 1px solid #e5e7eb;
    display: flex;
    gap: 10px;
    justify-content: flex-end;
 }
 .btn-secondary {
    background: #6b7280;
    color: white;
 }
 .btn-secondary:hover {
    background: #4b5563;
 }
 .btn-primary {
    background: #667eea;
    color: white;
 }
 .btn-primary:hover {
    background: #5a67d8;
 }
@media (max-width: 768px) {
    .container {
        padding: 10px;
    }
    .main-content {
        grid-template-columns: 1fr;
        gap: 15px;
    }
    .sidebar {
        order: 2;
    }
    main {
        order: 1;
    }
    header {
        flex-direction: column;
        gap: 15px;
        text-align: center;
    }
    .connection-controls {
        flex-direction: column;
    }
    .poll-header {
        flex-direction: column;
        gap: 10px;
        align-items: flex-start;
    }
 }
--- a/index.html
+++ b/index.html
@@ -0,0 +1,133 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>P2P Polling App</title>
    <link rel="stylesheet" href="css/styles.css">
    <script src="https://unpkg.com/peerjs@1.5.2/dist/peerjs.min.js"></script>
 </head>
 <body>
    <div class="container">
        <header>
            <h1>P2P Polling App</h1>
            <div class="connection-status">
                <span id="peer-id">Loading...</span>
                <span id="connection-indicator" class="status-disconnected">●</span>
            </div>
        </header>
        <div class="main-content">
            <!-- Sidebar -->
            <aside class="sidebar">
                <div class="sidebar-section">
                    <h3>Available Polls</h3>
                    <div class="sidebar-hint">
                        <p class="hint-text">Click a poll to view and vote</p>
                    </div>
                    <div id="polls-list" class="polls-list">
                        <p class="no-polls">No polls created yet</p>
                    </div>
                </div>
                <div class="sidebar-section">
                    <h3>Connected Peers</h3>
                    <div class="peers-info">
                        <div class="peers-status">
                            <span>Count: <span id="peer-count">0</span></span>
                            <span id="connection-status-text" class="status-text">Disconnected</span>
                        </div>
                        <ul id="peers" class="peers-sidebar"></ul>
                    </div>
                </div>
            </aside>
            <main>
                <!-- Connection Setup -->
                <section id="connection-section" class="section">
                    <h2>Connect to Peer</h2>
                    <div class="connection-info">
                        <p><strong>Host:</strong> Share your Peer ID below with others</p>
                        <p><strong>Joiner:</strong> Enter the host's Peer ID to connect</p>
                    </div>
                    <div class="connection-controls">
                        <input type="text" id="room-id" placeholder="Enter host's Peer ID to connect">
                        <button id="join-btn">Connect to Host / Create New Poll</button>
                        <button id="copy-id-btn">Copy Your Peer ID</button>
                    </div>
                </section>
                <!-- Poll Creation -->
                <section id="poll-creation" class="section hidden">
                    <h2>Create Poll</h2>
                    <div class="poll-form">
                        <input type="text" id="poll-question" placeholder="Enter your poll question">
                        <div id="options-container">
                            <div class="option-input">
                                <input type="text" class="option-text" placeholder="Option 1">
                                <button class="remove-option-btn hidden">Remove</button>
                            </div>
                            <div class="option-input">
                                <input type="text" class="option-text" placeholder="Option 2">
                                <button class="remove-option-btn hidden">Remove</button>
                            </div>
                        </div>
                        <button id="add-option-btn">+ Add Option</button>
                        <button id="create-poll-btn">Create Poll</button>
                    </div>
                </section>
                <!-- Active Poll -->
                <section id="active-poll" class="section hidden">
                    <div class="poll-header">
                        <h2 id="poll-question-display"></h2>
                        <button id="add-poll-option-btn" class="small-btn">+ Add Option</button>
                    </div>
                    <div class="vote-hint">
                        <p class="hint-text">Click any option to vote. Click your voted option again to remove your vote.</p>
                    </div>
                    <div id="poll-options" class="options-list"></div>
                    <div class="poll-actions">
                        <button id="reset-poll-btn">Reset Poll</button>
                        <button id="new-poll-btn" class="small-btn">New Poll</button>
                    </div>
                </section>
            </main>
        </div>
        <!-- Loading Overlay -->
        <div id="loading-overlay" class="overlay hidden">
            <div class="loading-spinner"></div>
            <p>Connecting...</p>
        </div>
        <!-- Notification Toast -->
        <div id="notification" class="notification hidden"></div>
        <!-- Add Option Modal -->
        <div id="add-option-modal" class="modal hidden">
            <div class="modal-content">
                <div class="modal-header">
                    <h3>Add New Option</h3>
                    <button class="modal-close" id="close-modal-btn">&times;</button>
                </div>
                <div class="modal-body">
                    <input type="text" id="new-option-input" placeholder="Enter new option text">
                </div>
                <div class="modal-footer">
                    <button id="cancel-modal-btn" class="btn-secondary">Cancel</button>
                    <button id="save-option-btn" class="btn-primary">Add Option</button>
                </div>
            </div>
        </div>
    </div>
    <script src="js/peer-manager.js"></script>
    <script src="js/poll-manager.js"></script>
    <script src="js/ui-controller.js"></script>
    <script src="js/app.js"></script>
 </body>
 </html>
--- a/js/app.js
+++ b/js/app.js
@@ -0,0 +1,210 @@
 // Main application entry point
 class P2PPollApp {
    constructor() {
        this.peerManager = null;
        this.pollManager = null;
        this.uiController = null;
        this.isInitialized = false;
    }
    async initialize() {
        try {
            // Initialize peer manager
            this.peerManager = new PeerManager();
            this.pollManager = new PollManager(this.peerManager);
            this.uiController = new UIController(this.peerManager, this.pollManager);
            // Set up event handlers
            this.setupEventHandlers();
            // Initialize peer connection
            await this.peerManager.initialize();
            // Load saved data
            this.pollManager.loadFromLocalStorage();
            // If there are saved polls, update the sidebar
            const savedPolls = this.pollManager.getAvailablePolls();
            if (savedPolls.length > 0) {
                this.uiController.updatePollsList(savedPolls);
            }
            this.isInitialized = true;
            console.log('P2P Poll App initialized successfully');
        } catch (error) {
            console.error('Failed to initialize app:', error);
            this.uiController?.showNotification('Failed to initialize app: ' + error.message, 'error');
        }
    }
    setupEventHandlers() {
        // Peer manager events
        this.peerManager.onConnectionStatusChange = (status, peerId) => {
            this.uiController.updatePeerId(peerId);
            if (status === 'connected') {
                this.uiController.showNotification('Connected to P2P network', 'success');
            } else if (status === 'disconnected') {
                this.uiController.showNotification('Disconnected from P2P network', 'error');
            }
        };
        this.peerManager.onPeerConnected = (peerId) => {
            this.uiController.showNotification(`Peer ${peerId} connected`, 'success');
            // If we're the host and have polls, send them to the new peer
            if (this.peerManager.isHost) {
                const availablePolls = this.pollManager.getAvailablePolls();
                if (availablePolls.length > 0) {
                    availablePolls.forEach(poll => {
                        this.peerManager.sendMessage(peerId, {
                            type: 'poll_update',
                            poll: poll,
                            senderId: this.peerManager.getPeerId()
                        });
                    });
                    // Also send current poll if there is one
                    const currentPoll = this.pollManager.getCurrentPoll();
                    if (currentPoll) {
                        this.peerManager.sendMessage(peerId, {
                            type: 'current_poll',
                            poll: currentPoll,
                            senderId: this.peerManager.getPeerId()
                        });
                    }
                }
            } else {
                this.peerManager.sendMessage(peerId, {
                    type: 'sync_request',
                    senderId: this.peerManager.getPeerId()
                });
            }
        };
        this.peerManager.onPeerDisconnected = (peerId) => {
            this.uiController.showNotification(`Peer ${peerId} disconnected`, 'info');
        };
        this.peerManager.onMessageReceived = (message, senderId) => {
            this.handleMessage(message, senderId);
        };
        // Poll manager events
        this.pollManager.onPollCreated = (poll) => {
            this.uiController.renderPoll(poll);
        };
        this.pollManager.onPollUpdated = (poll) => {
            this.uiController.renderPoll(poll);
        };
        this.pollManager.onPollSelected = (poll) => {
            if (poll) {
                this.uiController.renderPoll(poll);
                this.uiController.showActivePoll();
            } else {
                this.uiController.showPollCreation();
            }
        };
        this.pollManager.onPollsListUpdated = (polls) => {
            this.uiController.updatePollsList(polls);
        };
    }
    handleMessage(message, senderId) {
        console.log('Processing message:', message, 'from:', senderId);
        switch (message.type) {
            case 'poll_update':
                this.pollManager.syncPoll(message.poll);
                break;
            case 'current_poll':
                this.pollManager.syncPoll(message.poll);
                if (this.pollManager.getCurrentPoll() && this.pollManager.getCurrentPoll().id === message.poll.id) {
                    this.uiController.renderPoll(message.poll);
                    this.uiController.showActivePoll();
                }
                break;
            case 'vote':
                this.pollManager.handleVoteMessage(message.optionId, message.voterId);
                break;
            case 'unvote':
                this.pollManager.handleUnvoteMessage(message.voterId);
                break;
            case 'poll_reset':
                this.pollManager.handlePollReset();
                break;
            case 'sync_request':
                    const currentPoll = this.pollManager.getCurrentPoll();
                if (currentPoll) {
                    this.peerManager.sendMessage(senderId, {
                        type: 'current_poll',
                        poll: currentPoll,
                        senderId: this.peerManager.getPeerId()
                    });
                }
                const availablePolls = this.pollManager.getAvailablePolls();
                availablePolls.forEach(poll => {
                    this.peerManager.sendMessage(senderId, {
                        type: 'poll_update',
                        poll: poll,
                        senderId: this.peerManager.getPeerId()
                    });
                });
                break;
            default:
                console.warn('Unknown message type:', message.type);
        }
    }
    destroy() {
        if (this.peerManager) {
            this.peerManager.destroy();
        }
    }
 }
 document.addEventListener('DOMContentLoaded', async () => {
    const app = new P2PPollApp();
    try {
        await app.initialize();
    } catch (error) {
        console.error('App initialization failed:', error);
        // Show error message to user
        const errorDiv = document.createElement('div');
        errorDiv.className = 'notification error';
        errorDiv.textContent = 'Failed to initialize app. Please refresh the page.';
        errorDiv.style.position = 'fixed';
        errorDiv.style.top = '20px';
        errorDiv.style.right = '20px';
        errorDiv.style.zIndex = '1001';
        document.body.appendChild(errorDiv);
    }
    // Cleanup on page unload
    window.addEventListener('beforeunload', () => {
        app.destroy();
    });
 });
 // Handle page visibility changes
 document.addEventListener('visibilitychange', () => {
    if (document.hidden) {
        console.log('Page hidden - connection may become unstable');
    } else {
        console.log('Page visible - checking connection status');
    }
 });
--- a/js/peer-manager.js
+++ b/js/peer-manager.js
@@ -0,0 +1,233 @@
 class PeerManager {
    constructor() {
        this.peer = null;
        this.connections = new Map();
        this.roomId = null;
        this.isHost = false;
        this.onPeerConnected = null;
        this.onPeerDisconnected = null;
        this.onMessageReceived = null;
        this.onConnectionStatusChange = null;
    }
    async initialize() {
        try {
            this.peer = new Peer({
                debug: 2,
                config: {
                    iceServers: [
                        { urls: 'stun:stun.l.google.com:19302' },
                        { urls: 'stun:stun1.l.google.com:19302' }
                    ]
                }
            });
            this.peer.on('open', (id) => {
                console.log('My peer ID is:', id);
                this.updateConnectionStatus('connected');
                this.updatePeersList(); 
                if (this.onConnectionStatusChange) {
                    this.onConnectionStatusChange('connected', id);
                }
            });
            this.peer.on('connection', (conn) => {
                this.handleIncomingConnection(conn);
            });
            this.peer.on('disconnected', () => {
                this.updateConnectionStatus('disconnected');
                this.updatePeersList(); 
            });
            this.peer.on('error', (err) => {
                console.error('Peer error:', err);
                this.updateConnectionStatus('error');
            });
        } catch (error) {
            console.error('Failed to initialize peer:', error);
            throw error;
        }
    }
    async createRoom() {
        if (!this.peer) {
            throw new Error('Peer not initialized');
        }
        this.roomId = this.generateRoomId();
        this.isHost = true;
        console.log('Created room:', this.roomId);
        return this.roomId;
    }
    async joinRoom(roomId) {
        if (!this.peer) {
            throw new Error('Peer not initialized');
        }
        this.roomId = roomId;
        this.isHost = false;
        console.log('Attempting to join room:', roomId);
        try {
            const conn = this.peer.connect(roomId);
            await this.setupConnection(conn);
            console.log('Successfully joined room');
            return true;
        } catch (error) {
            console.error('Failed to join room:', error);
            throw new Error('Could not connect to host. Make sure the host is online and you have the correct peer ID.');
        }
    }
    handleIncomingConnection(conn) {
        this.setupConnection(conn);
    }
    async setupConnection(conn) {
        return new Promise((resolve, reject) => {
            conn.on('open', () => {
                console.log('Connected to:', conn.peer);
                this.connections.set(conn.peer, conn);
                this.updatePeersList();
                if (this.isHost) {
                    if (this.onPeerConnected) {
                        this.onPeerConnected(conn.peer);
                    }
                } else {
                    if (this.onPeerConnected) {
                        this.onPeerConnected(conn.peer);
                    }
                }
                resolve(conn);
            });
            conn.on('data', (data) => {
                this.handleMessage(data, conn.peer);
            });
            conn.on('close', () => {
                console.log('Connection closed:', conn.peer);
                this.connections.delete(conn.peer);
                this.updatePeersList();
                if (this.onPeerDisconnected) {
                    this.onPeerDisconnected(conn.peer);
                }
            });
            conn.on('error', (err) => {
                console.error('Connection error:', err);
                reject(err);
            });
        });
    }
    handleMessage(data, senderId) {
        console.log('Received message:', data, 'from:', senderId);
        if (this.onMessageReceived) {
            this.onMessageReceived(data, senderId);
        }
    }
    sendMessage(peerId, message) {
        const conn = this.connections.get(peerId);
        if (conn && conn.open) {
            conn.send(message);
            return true;
        }
        return false;
    }
    broadcastMessage(message) {
        let sentCount = 0;
        this.connections.forEach((conn, peerId) => {
            if (conn.open) {
                conn.send(message);
                sentCount++;
            }
        });
        return sentCount;
    }
    getPeerId() {
        return this.peer ? this.peer.id : null;
    }
    getRoomId() {
        return this.roomId;
    }
    getConnectedPeers() {
        return Array.from(this.connections.keys());
    }
    getPeerCount() {
        return this.connections.size;
    }
    isConnected() {
        return this.peer && this.peer.disconnected !== true;
    }
    generateRoomId() {
        return Math.random().toString(36).substr(2, 9).toUpperCase();
    }
    updateConnectionStatus(status) {
        const indicator = document.getElementById('connection-indicator');
        const statusText = document.getElementById('connection-status-text');
        if (indicator) {
            indicator.className = `status-${status}`;
        }
        if (statusText) {
            statusText.textContent = status.charAt(0).toUpperCase() + status.slice(1);
            statusText.className = `status-text ${status}`;
        }
    }
    updatePeersList() {
        const peersList = document.getElementById('peers');
        const peerCount = document.getElementById('peer-count');
        if (peersList && peerCount) {
            peerCount.textContent = this.getPeerCount();
            peersList.innerHTML = '';
            if (this.getPeerCount() === 0) {
                const li = document.createElement('li');
                li.textContent = 'No connected peers';
                li.style.fontStyle = 'italic';
                li.style.color = '#9ca3af';
                peersList.appendChild(li);
            } else {
                this.getConnectedPeers().forEach(peerId => {
                    const li = document.createElement('li');
                    li.textContent = `${peerId} ${peerId === this.peer.id ? '(You)' : ''}`;
                    li.style.fontWeight = peerId === this.peer.id ? 'bold' : 'normal';
                    li.style.color = peerId === this.peer.id ? '#667eea' : '#6b7280';
                    peersList.appendChild(li);
                });
            }
        }
    }
    destroy() {
        if (this.peer) {
            this.connections.forEach(conn => conn.close());
            this.peer.destroy();
            this.peer = null;
            this.connections.clear();
        }
    }
 }
--- a/js/poll-manager.js
+++ b/js/poll-manager.js
@@ -0,0 +1,428 @@
 class PollManager {
    constructor(peerManager) {
        this.peerManager = peerManager;
        this.currentPoll = null;
        this.availablePolls = new Map(); // pollId -> poll
        this.myVotes = new Set();
        this.onPollUpdated = null;
        this.onPollCreated = null;
        this.onPollSelected = null;
        this.onPollsListUpdated = null;
    }
    createPoll(question, options) {
        const poll = {
            id: this.generatePollId(),
            question: question.trim(),
            options: options.map((text, index) => ({
                id: `opt-${index}`,
                text: text.trim(),
                votes: 0,
                voters: []
            })),
            createdBy: this.peerManager.getPeerId(),
            createdAt: Date.now()
        };
        // Clear any existing votes when creating a new poll
        this.myVotes.clear();
        this.currentPoll = poll;
        this.availablePolls.set(poll.id, poll);
        this.saveToLocalStorage();
        if (this.onPollCreated) {
            this.onPollCreated(poll);
        }
        if (this.onPollsListUpdated) {
            this.onPollsListUpdated(Array.from(this.availablePolls.values()));
        }
        // Broadcast new poll to all peers
        this.broadcastPollUpdate();
        return poll;
    }
    addOption(text) {
        if (!this.currentPoll) {
            throw new Error('No active poll');
        }
        const newOption = {
            id: `opt-${Date.now()}`,
            text: text.trim(),
            votes: 0,
            voters: []
        };
        this.currentPoll.options.push(newOption);
        this.saveToLocalStorage();
        this.notifyPollUpdated();
        this.broadcastPollUpdate();
        return newOption;
    }
    vote(optionId) {
        if (!this.currentPoll) {
            throw new Error('No active poll');
        }
        const myPeerId = this.peerManager.getPeerId();
        // Check if already voted for this option
        if (this.myVotes.has(optionId)) {
            return false; 
        }
        this.removePreviousVote(myPeerId);
        // Add new vote
        const option = this.currentPoll.options.find(opt => opt.id === optionId);
        if (!option) {
            throw new Error('Option not found');
        }
        option.votes++;
        option.voters.push(myPeerId);
        this.myVotes.add(optionId);
        this.saveToLocalStorage();
        this.notifyPollUpdated();
        this.broadcastVote(optionId, myPeerId);
        return true;
    }
    removePreviousVote(peerId) {
        if (!this.currentPoll) return;
        this.currentPoll.options.forEach(option => {
            const voterIndex = option.voters.indexOf(peerId);
            if (voterIndex !== -1) {
                option.votes--;
                option.voters.splice(voterIndex, 1);
                // Remove from my votes if it's my vote
                if (peerId === this.peerManager.getPeerId()) {
                    this.myVotes.delete(option.id);
                }
            }
        });
    }
    resetPoll() {
        if (!this.currentPoll) {
            throw new Error('No active poll');
        }
        this.currentPoll.options.forEach(option => {
            option.votes = 0;
            option.voters = [];
        });
        this.myVotes.clear();
        this.saveToLocalStorage();
        this.notifyPollUpdated();
        this.broadcastPollReset();
    }
    syncPoll(pollData) {
        if (!this.availablePolls.has(pollData.id)) {
            this.availablePolls.set(pollData.id, pollData);
            this.saveToLocalStorage();
            if (this.onPollsListUpdated) {
                this.onPollsListUpdated(Array.from(this.availablePolls.values()));
            }
        }
        if (!this.currentPoll || this.currentPoll.id === pollData.id) {
            this.currentPoll = pollData;
            this.availablePolls.set(pollData.id, pollData);
            this.validateMyVotes(pollData);
            this.saveToLocalStorage();
            if (this.onPollCreated) {
                this.onPollCreated(pollData);
            }
        } else if (this.currentPoll.id === pollData.id) {
            this.mergePollData(pollData);
            this.availablePolls.set(pollData.id, this.currentPoll);
            this.validateMyVotes(this.currentPoll);
            this.saveToLocalStorage();
            this.notifyPollUpdated();
        }
    }
    mergePollData(remotePoll) {
        const localOptions = new Map(this.currentPoll.options.map(opt => [opt.id, opt]));
        const remoteOptions = new Map(remotePoll.options.map(opt => [opt.id, opt]));
        remoteOptions.forEach((remoteOpt, id) => {
            if (!localOptions.has(id)) {
                this.currentPoll.options.push(remoteOpt);
                localOptions.set(id, remoteOpt);
            }
        });
        this.currentPoll.options.forEach(localOpt => {
            const remoteOpt = remoteOptions.get(localOpt.id);
            if (remoteOpt) {
                const allVoters = new Set([...localOpt.voters, ...remoteOpt.voters]);
                localOpt.voters = Array.from(allVoters);
                localOpt.votes = localOpt.voters.length;
            }
        });
    }
    handleVoteMessage(optionId, voterId) {
        if (!this.currentPoll) return;
        this.removePreviousVote(voterId);
        const option = this.currentPoll.options.find(opt => opt.id === optionId);
        if (option && !option.voters.includes(voterId)) {
            option.votes++;
            option.voters.push(voterId);
            // Update my votes if this is my vote
            if (voterId === this.peerManager.getPeerId()) {
                this.myVotes.add(optionId);
            }
            this.saveToLocalStorage();
            this.notifyPollUpdated();
        }
    }
    handleUnvoteMessage(voterId) {
        if (!this.currentPoll) return;
        // Remove vote from this voter
        this.removePreviousVote(voterId);
        // Update my votes if this is my vote
        if (voterId === this.peerManager.getPeerId()) {
            this.myVotes.clear();
        }
        this.saveToLocalStorage();
        this.notifyPollUpdated();
    }
    handlePollReset() {
        if (!this.currentPoll) return;
        this.currentPoll.options.forEach(option => {
            option.votes = 0;
            option.voters = [];
        });
        this.myVotes.clear();
        this.saveToLocalStorage();
        this.notifyPollUpdated();
    }
    broadcastPollUpdate() {
        if (!this.currentPoll) return;
        this.peerManager.broadcastMessage({
            type: 'poll_update',
            poll: this.currentPoll,
            senderId: this.peerManager.getPeerId()
        });
    }
    broadcastVote(optionId, voterId) {
        this.peerManager.broadcastMessage({
            type: 'vote',
            optionId: optionId,
            voterId: voterId,
            senderId: this.peerManager.getPeerId()
        });
    }
    broadcastPollReset() {
        this.peerManager.broadcastMessage({
            type: 'poll_reset',
            senderId: this.peerManager.getPeerId()
        });
    }
    selectPoll(pollId) {
        const poll = this.availablePolls.get(pollId);
        if (poll) {
            this.currentPoll = poll;
            // Clear votes when switching to a different poll
            // Only clear if this is a different poll than what we had voted in
            const currentVotedOption = this.getMyVotedOption();
            if (currentVotedOption && !poll.options.some(opt => opt.id === currentVotedOption)) {
                this.myVotes.clear();
            }
            this.saveToLocalStorage();
            if (this.onPollSelected) {
                this.onPollSelected(poll);
            }
            if (this.onPollUpdated) {
                this.onPollUpdated(poll);
            }
            return true;
        }
        return false;
    }
    createNewPoll() {
        this.currentPoll = null;
        // Clear current poll inputs but keep available polls
        if (this.onPollSelected) {
            this.onPollSelected(null);
        }
    }
    getAvailablePolls() {
        return Array.from(this.availablePolls.values());
    }
    unvote() {
        if (!this.currentPoll) {
            throw new Error('No active poll');
        }
        const myPeerId = this.peerManager.getPeerId();
        const myVotedOption = this.getMyVotedOption();
        if (!myVotedOption) {
            return false; // No vote to remove
        }
        // Remove vote from current option
        this.removePreviousVote(myPeerId);
        this.saveToLocalStorage();
        this.notifyPollUpdated();
        this.broadcastUnvote(myPeerId);
        return true;
    }
    validateMyVotes(poll) {
        const myPeerId = this.peerManager.getPeerId();
        const validVotes = new Set();
        console.log('Validating votes for peer:', myPeerId);
        console.log('Current myVotes:', Array.from(this.myVotes));
        console.log('Poll voters:', poll.options.map(opt => ({ id: opt.id, voters: opt.voters })));
        // Check each vote in myVotes to see if it's actually mine
        this.myVotes.forEach(optionId => {
            const option = poll.options.find(opt => opt.id === optionId);
            if (option && option.voters.includes(myPeerId)) {
                // This vote is actually mine
                validVotes.add(optionId);
                console.log(`Vote ${optionId} is valid for peer ${myPeerId}`);
            } else {
                console.log(`Vote ${optionId} is NOT valid for peer ${myPeerId}`);
            }
        });
        // Replace myVotes with only the valid votes
        this.myVotes = validVotes;
        console.log('Final valid votes:', Array.from(this.myVotes));
    }
    getCurrentPoll() {
        return this.currentPoll;
    }
    broadcastUnvote(peerId) {
        this.peerManager.broadcastMessage({
            type: 'unvote',
            voterId: peerId,
            senderId: this.peerManager.getPeerId()
        });
    }
    hasVoted(optionId) {
        return this.myVotes.has(optionId);
    }
    getMyVotedOption() {
        return Array.from(this.myVotes)[0] || null;
    }
    generatePollId() {
        return `poll-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
    }
    saveToLocalStorage() {
        // Save all available polls
        const pollsData = Array.from(this.availablePolls.values());
        localStorage.setItem('p2p-polls-list', JSON.stringify(pollsData));
        // Save current poll separately
        if (this.currentPoll) {
            localStorage.setItem('p2p-poll-current', JSON.stringify(this.currentPoll));
        } else {
            localStorage.removeItem('p2p-poll-current');
        }
        localStorage.setItem('p2p-poll-my-votes', JSON.stringify(Array.from(this.myVotes)));
    }
    loadFromLocalStorage() {
        try {
            const savedPollsList = localStorage.getItem('p2p-polls-list');
            const savedVotes = localStorage.getItem('p2p-poll-my-votes');
            if (savedPollsList) {
                const polls = JSON.parse(savedPollsList);
                this.availablePolls.clear();
                polls.forEach(poll => {
                    this.availablePolls.set(poll.id, poll);
                });
                if (this.onPollsListUpdated) {
                    this.onPollsListUpdated(polls);
                }
            }
            if (savedVotes) {
                this.myVotes = new Set(JSON.parse(savedVotes));
                // Validate votes against current poll
                const currentPoll = this.currentPoll || this.availablePolls.values().next().value;
                if (currentPoll) {
                    this.validateMyVotes(currentPoll);
                }
            }
        } catch (error) {
            console.error('Failed to load from localStorage:', error);
        }
    }
    clearData() {
        this.currentPoll = null;
        this.availablePolls.clear();
        this.myVotes.clear();
        localStorage.removeItem('p2p-poll-current');
        localStorage.removeItem('p2p-polls-list');
        localStorage.removeItem('p2p-poll-my-votes');
    }
    notifyPollUpdated() {
        if (this.onPollUpdated) {
            this.onPollUpdated(this.currentPoll);
        }
    }
 }
--- a/js/ui-controller.js
+++ b/js/ui-controller.js
@@ -0,0 +1,419 @@
 class UIController {
    constructor(peerManager, pollManager) {
        this.peerManager = peerManager;
        this.pollManager = pollManager;
        this.initializeEventListeners();
    }
    initializeEventListeners() {
        // Connection controls
        document.getElementById('join-btn').addEventListener('click', () => this.handleJoinRoom());
        document.getElementById('copy-id-btn').addEventListener('click', () => this.copyPeerId());
        // Poll creation
        document.getElementById('create-poll-btn').addEventListener('click', () => this.handleCreatePoll());
        document.getElementById('add-option-btn').addEventListener('click', () => this.addOptionInput());
        // Active poll
        document.getElementById('add-poll-option-btn').addEventListener('click', () => this.showAddOptionModal());
        document.getElementById('reset-poll-btn').addEventListener('click', () => this.handleResetPoll());
        document.getElementById('new-poll-btn').addEventListener('click', () => this.handleNewPoll());
        // Modal controls
        document.getElementById('close-modal-btn').addEventListener('click', () => this.hideAddOptionModal());
        document.getElementById('cancel-modal-btn').addEventListener('click', () => this.hideAddOptionModal());
        document.getElementById('save-option-btn').addEventListener('click', () => this.handleAddOptionFromModal());
        // Enter key handlers
        document.getElementById('room-id').addEventListener('keypress', (e) => {
            if (e.key === 'Enter') this.handleJoinRoom();
        });
        document.getElementById('poll-question').addEventListener('keypress', (e) => {
            if (e.key === 'Enter') this.handleCreatePoll();
        });
        document.getElementById('new-option-input').addEventListener('keypress', (e) => {
            if (e.key === 'Enter') this.handleAddOptionFromModal();
        });
        // Close modal on background click
        document.getElementById('add-option-modal').addEventListener('click', (e) => {
            if (e.target.id === 'add-option-modal') {
                this.hideAddOptionModal();
            }
        });
    }
    handleJoinRoom() {
        const roomIdInput = document.getElementById('room-id');
        const peerId = roomIdInput.value.trim();
        this.showLoading(true);
        if (peerId) {
            // Connect to existing peer (host)
            this.peerManager.joinRoom(peerId)
                .then(() => {
                    this.showNotification('Connected to host successfully!', 'success');
                    this.showPollCreation();
                })
                .catch(error => {
                    this.showNotification('Failed to connect: ' + error.message, 'error');
                    console.error('Connect error:', error);
                })
                .finally(() => {
                    this.showLoading(false);
                });
        } else {
            // Act as host - just show poll creation
            this.peerManager.createRoom();
            this.showNotification('You are the host. Share your Peer ID with others to connect.', 'success');
            this.showPollCreation();
            this.showLoading(false);
        }
    }
    async copyPeerId() {
        const peerId = this.peerManager.getPeerId();
        if (peerId) {
            try {
                await navigator.clipboard.writeText(peerId);
                this.showNotification('Peer ID copied to clipboard!', 'success');
            } catch (error) {
                // Fallback for older browsers
                const textArea = document.createElement('textarea');
                textArea.value = peerId;
                document.body.appendChild(textArea);
                textArea.select();
                document.execCommand('copy');
                document.body.removeChild(textArea);
                this.showNotification('Peer ID copied to clipboard!', 'success');
            }
        }
    }
    handleCreatePoll() {
        const questionInput = document.getElementById('poll-question');
        const optionInputs = document.querySelectorAll('.option-text');
        const options = [];
        console.log('Question input:', questionInput);
        console.log('Found option inputs:', optionInputs.length);
        // Check if question input exists
        if (!questionInput) {
            console.error('Question input not found!');
            this.showNotification('Error: Question input not found', 'error');
            return;
        }
        const question = questionInput.value ? questionInput.value.trim() : '';
        console.log('Question:', question);
        optionInputs.forEach((input, index) => {
            console.log(`Input ${index}:`, input, 'value:', input?.value);
            if (input && typeof input.value !== 'undefined') {
                const text = input.value.trim();
                if (text) {
                    options.push(text);
                }
            } else {
                console.warn(`Input ${index} is invalid or has no value property`);
            }
        });
        console.log('Final options:', options);
        if (!question) {
            this.showNotification('Please enter a poll question', 'error');
            return;
        }
        if (options.length < 2) {
            this.showNotification('Please enter at least 2 options', 'error');
            return;
        }
        try {
            this.pollManager.createPoll(question, options);
            this.showNotification('Poll created successfully!', 'success');
        } catch (error) {
            console.error('Create poll error:', error);
            this.showNotification('Failed to create poll: ' + error.message, 'error');
        }
    }
    showAddOptionModal() {
        const modal = document.getElementById('add-option-modal');
        const input = document.getElementById('new-option-input');
        modal.classList.remove('hidden');
        input.value = '';
        input.focus();
    }
    hideAddOptionModal() {
        const modal = document.getElementById('add-option-modal');
        const input = document.getElementById('new-option-input');
        modal.classList.add('hidden');
        input.value = '';
    }
    handleAddOptionFromModal() {
        const input = document.getElementById('new-option-input');
        const optionText = input.value.trim();
        if (!optionText) {
            this.showNotification('Please enter an option text', 'error');
            return;
        }
        try {
            this.pollManager.addOption(optionText);
            this.hideAddOptionModal();
            this.showNotification('Option added successfully!', 'success');
        } catch (error) {
            this.showNotification('Failed to add option: ' + error.message, 'error');
        }
    }
    handleAddPollOption() {
        this.showAddOptionModal();
    }
    handleResetPoll() {
        if (confirm('Are you sure you want to reset all votes?')) {
            try {
                this.pollManager.resetPoll();
                this.showNotification('Poll reset successfully!', 'success');
            } catch (error) {
                this.showNotification('Failed to reset poll: ' + error.message, 'error');
            }
        }
    }
    handleNewPoll() {
        this.pollManager.createNewPoll();
        this.showPollCreation();
        this.clearPollForm();
    }
    addOptionInput() {
        const container = document.getElementById('options-container');
        const optionCount = container.children.length;
        const optionDiv = document.createElement('div');
        optionDiv.className = 'option-input';
        optionDiv.innerHTML = `
            <input type="text" class="option-text" placeholder="Option ${optionCount + 1}">
            <button class="remove-option-btn">Remove</button>
        `;
        container.appendChild(optionDiv);
        this.updateOptionRemoveButtons();
        // Add event listener to new input
        const newInput = optionDiv.querySelector('.option-text');
        newInput.addEventListener('keypress', (e) => {
            if (e.key === 'Enter') this.handleCreatePoll();
        });
        // Add event listener to remove button
        const removeBtn = optionDiv.querySelector('.remove-option-btn');
        removeBtn.addEventListener('click', () => {
            optionDiv.remove();
            this.updateOptionRemoveButtons();
            this.updateOptionPlaceholders();
        });
        // Focus on new input
        newInput.focus();
    }
    updateOptionRemoveButtons() {
        const optionInputs = document.querySelectorAll('.option-input');
        const removeButtons = document.querySelectorAll('.remove-option-btn');
        removeButtons.forEach((btn, index) => {
            if (optionInputs.length <= 2) {
                btn.classList.add('hidden');
            } else {
                btn.classList.remove('hidden');
            }
        });
    }
    updateOptionPlaceholders() {
        const optionInputs = document.querySelectorAll('.option-text');
        optionInputs.forEach((input, index) => {
            input.placeholder = `Option ${index + 1}`;
        });
    }
    clearPollForm() {
        document.getElementById('poll-question').value = '';
        const container = document.getElementById('options-container');
        container.innerHTML = `
            <div class="option-input">
                <input type="text" class="option-text" placeholder="Option 1">
                <button class="remove-option-btn hidden">Remove</button>
            </div>
            <div class="option-input">
                <input type="text" class="option-text" placeholder="Option 2">
                <button class="remove-option-btn hidden">Remove</button>
            </div>
        `;
        this.updateOptionRemoveButtons();
    }
    showPollCreation() {
        document.getElementById('connection-section').classList.add('hidden');
        document.getElementById('poll-creation').classList.remove('hidden');
        document.getElementById('active-poll').classList.add('hidden');
    }
    showActivePoll() {
        document.getElementById('connection-section').classList.add('hidden');
        document.getElementById('poll-creation').classList.add('hidden');
        document.getElementById('active-poll').classList.remove('hidden');
    }
    updatePeerId(peerId) {
        const element = document.getElementById('peer-id');
        if (element) {
            element.textContent = peerId || 'Loading...';
        }
    }
    renderPoll(poll) {
        if (!poll) return;
        this.showActivePoll();
        // Update poll question
        document.getElementById('poll-question-display').textContent = poll.question;
        // Render options
        const optionsContainer = document.getElementById('poll-options');
        optionsContainer.innerHTML = '';
        const totalVotes = poll.options.reduce((sum, opt) => sum + opt.votes, 0);
        const myVotedOption = this.pollManager.getMyVotedOption();
        poll.options.forEach(option => {
            const optionDiv = document.createElement('div');
            optionDiv.className = 'poll-option';
            const hasVoted = this.pollManager.hasVoted(option.id);
            const myVotedOption = this.pollManager.getMyVotedOption();
            console.log(`Option ${option.id}: hasVoted=${hasVoted}, myVotedOption=${myVotedOption}`);
            if (hasVoted) {
                optionDiv.classList.add('voted');
            } else if (myVotedOption) {
                // User has voted but not for this option - this is a change vote option
                optionDiv.classList.add('change-vote');
            }
            const percentage = totalVotes > 0 ? (option.votes / totalVotes * 100).toFixed(1) : 0;
            optionDiv.innerHTML = `
                <div class="option-header">
                    <span class="option-text">${option.text}</span>
                    <span class="vote-count">${option.votes} votes</span>
                </div>
                <div class="vote-bar">
                    <div class="vote-fill" style="width: ${percentage}%"></div>
                </div>
            `;
            optionDiv.addEventListener('click', () => {
                const myVotedOption = this.pollManager.getMyVotedOption();
                if (this.pollManager.hasVoted(option.id)) {
                    // Clicking your current vote - unvote
                    if (confirm('Remove your vote?')) {
                        const success = this.pollManager.unvote();
                        if (success) {
                            this.showNotification('Vote removed!', 'success');
                        }
                    }
                } else {
                    // Either first vote or changing vote
                    const success = this.pollManager.vote(option.id);
                    if (success) {
                        if (myVotedOption) {
                            this.showNotification('Vote changed successfully!', 'success');
                        } else {
                            this.showNotification('Vote recorded!', 'success');
                        }
                    }
                }
            });
            optionsContainer.appendChild(optionDiv);
        });
    }
    showNotification(message, type = 'info') {
        const notification = document.getElementById('notification');
        notification.textContent = message;
        notification.className = `notification ${type}`;
        notification.classList.remove('hidden');
        setTimeout(() => {
            notification.classList.add('hidden');
        }, 3000);
    }
    showLoading(show) {
        const overlay = document.getElementById('loading-overlay');
        if (show) {
            overlay.classList.remove('hidden');
        } else {
            overlay.classList.add('hidden');
        }
    }
    updatePeersList() {
        // Use the peer manager's updatePeersList method
        this.peerManager.updatePeersList();
    }
    updatePollsList(polls) {
        const pollsList = document.getElementById('polls-list');
        if (!pollsList) return;
        if (polls.length === 0) {
            pollsList.innerHTML = '<p class="no-polls">No polls created yet</p>';
            return;
        }
        pollsList.innerHTML = '';
        polls.forEach(poll => {
            const pollDiv = document.createElement('div');
            pollDiv.className = 'poll-item';
            if (this.pollManager.getCurrentPoll() && this.pollManager.getCurrentPoll().id === poll.id) {
                pollDiv.classList.add('active');
            }
            const totalVotes = poll.options.reduce((sum, opt) => sum + opt.votes, 0);
            const createdDate = new Date(poll.createdAt).toLocaleString();
            pollDiv.innerHTML = `
                <div class="poll-item-title">${poll.question}</div>
                <div class="poll-item-meta">${totalVotes} votes • ${createdDate}</div>
            `;
            pollDiv.addEventListener('click', () => {
                this.pollManager.selectPoll(poll.id);
            });
            pollsList.appendChild(pollDiv);
        });
    }
 }
--- a/nuxt.config.ts
+++ b/nuxt.config.ts
@@ -1,23 +0,0 @@
 // https://nuxt.com/docs/api/configuration/nuxt-config
 export default defineNuxtConfig({
  compatibilityDate: '2025-07-15',
  devtools: { enabled: true },
  vite: {
    optimizeDeps: {
      include: ['yjs', 'y-webrtc']
    }
  },
  // ... existing config
  nitro: {
    storage: {
      polls: {
        driver: 'fs',
        base: './.data/polls'
      },
      users: {
        driver: 'fs',
        base: './.data/users'
      }
    }
  }
 })
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,20 +0,0 @@
 {
  "name": "p2p-poll",
  "type": "module",
  "private": true,
  "scripts": {
    "build": "nuxt build",
    "dev": "PORT=4444 npx y-webrtc & nuxt dev",
    "generate": "nuxt generate",
    "preview": "nuxt preview",
    "postinstall": "nuxt prepare"
  },
  "dependencies": {
    "nuxt": "^4.1.3",
    "uuid": "^13.0.0",
    "vue": "^3.5.30",
    "vue-router": "^5.0.3",
    "y-webrtc": "^10.3.0",
    "yjs": "^13.6.30"
  }
 }
--- a/public/favicon.ico
+++ b/public/favicon.ico
--- a/public/robots.txt
+++ b/public/robots.txt
@@ -1,2 +0,0 @@
 User-Agent: *
 Disallow:
--- a/server/api/polls/[id].ts
+++ b/server/api/polls/[id].ts
@@ -1,68 +0,0 @@
 import * as Y from 'yjs';
 // server/api/polls/[id].ts
 export default defineEventHandler(async (event) => {
    const method = event.node.req.method;
    const pollId = getRouterParam(event, 'id');
    // We use Nitro's built-in storage. 
    // 'polls' is the storage namespace.
    const storage = useStorage('polls'); 
    if (!pollId) {
        throw createError({ statusCode: 400, statusMessage: 'Poll ID required' });
    }
    // GET: Fetch the saved Yjs document state
    if (method === 'GET') {
        const data = await storage.getItem(`poll:${pollId}`);
        // Return the array of numbers (or null if it doesn't exist yet)
        return { update: data || null };
    }
    // POST: Save a new Yjs document state
    if (method === 'POST') {
        const body = await readBody(event);
        if (body.update && Array.isArray(body.update)) {
            // create a temp Y.Doc to encode the Data
            const tempDoc = new Y.Doc();
            Y.applyUpdate(tempDoc, new Uint8Array(body.update));
            const yMap = tempDoc.getMap('shared-poll');
            const pollData = yMap.toJSON();
            // verify pollData
            for(var option in pollData){
                const votes = pollData[option] || [];
                var pubKeys: CryptoKey[] = [];
                const verifyAllVotesForOption = async (votes: SignedData<VoteData>[]) => {
                    console.log("verifying votes for option " + option,votes);
                    // check last votes first. if there is something wrong, its likely in the last vote.
                    for (let i = votes.length-1; i >= 0 ; i--) {
                        const userStorage = useStorage('users'); 
                        const votePubKeyString = await userStorage.getItem(`user:${votes[i]?.data.userid}`);
                        //console.log("Using public key: "+votePubKeyString)
                        const votePubKey = await stringToCryptoKey(String(votePubKeyString),'public')
                        const isValid = await verifyChainedVote(votes, i,votePubKey);
                        if(!isValid){
                            console.error("Error! Invalid Vote at: " + i,votes)
                            return false;
                        }
                    }
                    return true;
                };
                const verified = await verifyAllVotesForOption(votes);
                if(!verified){
                    console.error("Failed to verify option: "+option)
                    throw createError({ statusCode: 400, statusMessage: 'PollData contains unverifyable content!' });
                }
            }
            // Save the binary update (sent as an array of numbers) to storage
            await storage.setItem(`poll:${pollId}`, body.update);
            return { success: true };
        }
        throw createError({ statusCode: 400, statusMessage: 'Invalid update payload' });
    }
 });
--- a/server/api/polls/index.get.ts
+++ b/server/api/polls/index.get.ts
@@ -1,15 +0,0 @@
 // server/api/polls/index.get.ts
 export default defineEventHandler(async () => {
    const storage = useStorage('polls');
    // Get all keys in the 'polls' namespace
    const allKeys = await storage.getKeys();
    // Filter for our specific poll prefix and strip it for the UI
    // poll:my-id -> my-id
    const polls = allKeys
        .filter(key => key.startsWith('poll:'))
        .map(key => key.replace('poll:', ''));
    return { polls };
 });
--- a/server/api/users/[id].ts
+++ b/server/api/users/[id].ts
@@ -1,41 +0,0 @@
 // server/api/users/[id].ts
 export default defineEventHandler(async (event) => {
    const method = event.node.req.method;
    const userId = getRouterParam(event, 'id');
    // We use Nitro's built-in storage. 
    // 'polls' is the storage namespace.
    const storage = useStorage('users'); 
    if (!userId) {
        throw createError({ statusCode: 400, statusMessage: 'User ID required' });
    }
    // GET: Fetch the saved Yjs document state
    if (method === 'GET') {
        const data = await storage.getItem(`user:${userId}`);
        // Return the array of numbers (or null if it doesn't exist yet)
        return { public_key: data };
    }
    // POST: Save a new Yjs document state
    if (method === 'POST') {
        const body = await readBody(event);
        if (body.public_key) {
            const data = await storage.getItem(`user:${userId}`);
            if (data == undefined || data == null) {
                // Save the binary update (sent as an array of numbers) to storage
                await storage.setItem(`user:${userId}`, body.public_key);
                console.log("New User created: " + userId)
                console.log("Public Key: " + body.public_key);
                return { success: true };
            }
            throw createError({ statusCode: 400, statusMessage: 'User already exists.' });
        }
        throw createError({ statusCode: 400, statusMessage: 'Invalid update payload' });
    }
 });
--- a/server/utils/crypto.ts
+++ b/server/utils/crypto.ts
@@ -1,86 +0,0 @@
 import { SignedData, VoteData } from "./types";
 /**
 * Gets the WebCrypto API regardless of environment (Node vs Browser)
 */
 const getCrypto = () => {
  return (globalThis as any).crypto;
 };
 export const verifyVote = async (data: any, signatureStr: string, publicKey: CryptoKey) => {
  const encoder = new TextEncoder();
  const encodedData = encoder.encode(JSON.stringify(data));
  // Convert Base64 back to Uint8Array
  const signature = Uint8Array.from(atob(signatureStr), c => c.charCodeAt(0));
  return await getCrypto().subtle.verify(
    "RSASSA-PKCS1-v1_5",
    publicKey,
    signature,
    encodedData
  );
 };
 /**
 * Verifies a specific vote within an array of votes by 
 * reconstructing the "signed state" at that point in time.
 */
 export const verifyChainedVote = async (
    voteData: SignedData<VoteData>[], 
    index: number,
    pubKey: CryptoKey
 ) => {
    const voteToVerify = voteData[index];
    console.log("Verifying vote: " + voteToVerify)
    if(voteToVerify) {
        // 1. Reconstruct the exact data state the user signed
        // We need the array exactly as it was when they pushed their vote
        const historicalState = voteData.slice(0, index + 1).map((v, i) => {
            if (i === index) {
                // For the current vote, the signature must be empty string
                // because it wasn't signed yet when passed to signVote
                return { ...v, signature: "" };
            }
            return v;
        });
        try {
            // 3. Verify: Does this historicalState match the signature?
            return await verifyVote(historicalState, voteToVerify.signature, pubKey);
        } catch (err) {
            console.error("Verification failed")
            console.error(err);
            return false;
        }
    }
    console.error("Vote is undefined or null");
    return false;
 };
 /**
 * Converts a Base64 string back into a usable CryptoKey object
 * @param keyStr The Base64 string (without PEM headers)
 * @param type 'public' or 'private'
 */
 export const stringToCryptoKey = async (keyStr: string, type: 'public' | 'private'): Promise<CryptoKey> => {
  // 1. Convert Base64 string to a Uint8Array (binary)
  const bytes = Buffer.from(keyStr, 'base64');
  // 2. Identify the format based on the key type
  // Public keys usually use 'spki', Private keys use 'pkcs8'
  const format = type === 'public' ? 'spki' : 'pkcs8';
  const usages: KeyUsage[] = type === 'public' ? ['verify'] : ['sign'];
  // 3. Import the key
  return await getCrypto().subtle.importKey(
    format,
    bytes,
    {
      name: "RSASSA-PKCS1-v1_5",
      hash: "SHA-256",
    },
    true, // extractable (set to false if you want to lock it in memory)
    usages
  );
 };
--- a/server/utils/types.ts
+++ b/server/utils/types.ts
@@ -1,36 +0,0 @@
 export interface PollProps {
    userid: string | undefined,
    activePollId: string,
    pollData: PollData,
    addOption: (name: string) => void,
    vote: (optionName: string) => void
 }
 export interface PollListProps {
    userid: string | undefined,
 }
 export interface PollData extends Record<string, SignedData<VoteData>[]> {
 }
 export interface SignedData<T> {
    data: T,
    signature: string
 }
 export interface VoteData {
    userid: string,
    timestamp: string
 }
 export interface OptionData {
    userid: string,
    timestamp: string,
    optionName: string
 }
 export interface UserData {
    userid: string,
    private_key: CryptoKey | undefined,
    public_key: CryptoKey | undefined
 }
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,18 +0,0 @@
 {
  // https://nuxt.com/docs/guide/concepts/typescript
  "files": [],
  "references": [
    {
      "path": "./.nuxt/tsconfig.app.json"
    },
    {
      "path": "./.nuxt/tsconfig.server.json"
    },
    {
      "path": "./.nuxt/tsconfig.shared.json"
    },
    {
      "path": "./.nuxt/tsconfig.node.json"
    }
  ]
 }
		`@@ -1,2 +0,0 @@`
			`export const user = (user: Ref<UserData \| null>) => {`
			`}`