evaldoc 1.0.0

package/docs/DEPLOYMENT_STEPS.md

@@ -0,0 +1,373 @@
+# EvalDoc Thread System - Deployment Steps
+
+## ✅ What's Been Implemented
+
+### Frontend
+- ✅ [public/chat.html](public/chat.html) - Updated with Google Sign-In modal and Firebase Auth scripts
+- ✅ [public/js/chat-threads.js](public/js/chat-threads.js) - NEW: Thread-based chat system with Google authentication
+- ✅ [public/app/inbox.html](public/app/inbox.html) - Updated with doctor reply styling
+- ✅ [public/app/inbox-threads.js](public/app/inbox-threads.js) - NEW: Thread-based inbox with manual reply feature
+
+### Backend
+- ✅ [functions/src/patient-api.js](functions/src/patient-api.js) - NEW: Patient API handlers
+- ✅ [functions/src/index.js](functions/src/index.js) - Updated with patient and doctor thread endpoints
+
+### Security
+- ✅ [firestore.rules](firestore.rules) - Updated with patients and threads collection rules
+
+### Documentation
+- ✅ [THREAD_IMPLEMENTATION_GUIDE.md](THREAD_IMPLEMENTATION_GUIDE.md) - Complete implementation guide
+- ✅ [ARCHITECTURE_SUMMARY.md](ARCHITECTURE_SUMMARY.md) - Architecture overview
+
+---
+
+## 🚀 Deployment Checklist
+
+### Step 1: Enable Google Sign-In (5 minutes)
+
+1. Go to [Firebase Console](https://console.firebase.google.com)
+2. Select your project
+3. Go to **Authentication** → **Sign-in method**
+4. Click **Google** and enable it
+5. Add authorized domains:
+   - `localhost` (for testing)
+   - Your production domain (e.g., `evaldoc.com`)
+6. Click **Save**
+
+---
+
+### Step 2: Deploy Firestore Rules (1 minute)
+
+```bash
+# From your project root
+firebase deploy --only firestore:rules
+```
+
+**Expected output:**
+```
+✔  Deploy complete!
+✔  firestore: deployed database security rules
+```
+
+---
+
+### Step 3: Deploy Firebase Functions (5 minutes)
+
+```bash
+# Make sure you're in the project root
+cd functions
+npm install  # Install any new dependencies
+cd ..
+
+# Deploy functions
+firebase deploy --only functions
+```
+
+**Expected output:**
+```
+✔  Deploy complete!
+✔  functions[api]: Successful update operation
+```
+
+**Note:** First deployment may take 5-10 minutes. Subsequent deploys are faster.
+
+---
+
+### Step 4: Deploy Hosting (1 minute)
+
+```bash
+firebase deploy --only hosting
+```
+
+**Expected output:**
+```
+✔  Deploy complete!
+✔  hosting: deployed new version
+```
+
+---
+
+### Step 5: Verify Deployment (2 minutes)
+
+#### Test Patient Flow:
+
+1. Go to your deployed URL: `https://your-domain.com/dr-john-cardiology` (replace with actual doctor handle)
+2. Should see the chat interface
+3. Try sending a message
+4. Should see "Sign in to continue" modal
+5. Click "Continue with Google"
+6. Sign in with Google account
+7. Message should send successfully
+8. AI should respond
+9. **Refresh the page** - conversation should persist!
+
+#### Test Doctor Inbox:
+
+1. Go to `https://your-domain.com/app`
+2. Sign in as doctor (provider account)
+3. Go to "Inbox" tab
+4. Should see threads instead of old conversations
+5. Click on a thread
+6. Should see patient name/email
+7. Type a reply and click "Send Reply"
+8. Message should appear in thread
+
+---
+
+## 🧪 Testing Scenarios
+
+### Scenario 1: New Patient
+```
+1. Clear browser data (to simulate new patient)
+2. Visit doctor link
+3. Send message → Should prompt for Google Sign-In
+4. Sign in with Google
+5. Message should send + AI responds
+6. Refresh page → Should see conversation history
+7. Send another message → Should continue thread
+```
+
+### Scenario 2: Returning Patient
+```
+1. Visit doctor link (already signed in)
+2. Should immediately see chat interface with history
+3. Send message → AI responds
+4. Conversation continues in same thread
+```
+
+### Scenario 3: Patient with Multiple Doctors
+```
+1. Patient chats with Dr. A
+2. Patient visits Dr. B's link
+3. New thread created for Dr. B
+4. Both conversations are separate
+5. Patient can switch between doctors
+```
+
+### Scenario 4: Doctor Manual Reply
+```
+1. Doctor logs into inbox
+2. Sees patient thread with unread indicator (green dot)
+3. Clicks on thread
+4. Types reply in text box
+5. Clicks "Send Reply"
+6. Message appears in thread
+7. Patient receives message (doctor's name shown)
+```
+
+### Scenario 5: Doctor Takes Over (Manual Mode)
+```
+1. Doctor clicks "👨‍⚕️ Take Over (Manual Mode)" button
+2. Thread marked as manual mode
+3. AI stops responding
+4. All messages from doctor are manual
+5. Doctor can toggle back to AI mode
+```
+
+---
+
+## 📋 Post-Deployment Verification
+
+### Check Firebase Console
+
+1. **Authentication:**
+   - Go to Authentication → Users
+   - Should see new users signing in via Google
+
+2. **Firestore:**
+   - Go to Firestore Database
+   - Should see new collections:
+     - `patients` - Patient profiles
+     - `threads` - Conversation threads
+     - Inside threads: `messages` subcollection
+
+3. **Functions:**
+   - Go to Functions → Dashboard
+   - Check `/api/patient/*` endpoints are deployed
+   - Check logs for any errors
+
+---
+
+## 🐛 Troubleshooting
+
+### Issue: "Unauthorized" error when sending message
+
+**Fix:**
+1. Check Firebase Auth is enabled for Google
+2. Verify token is being sent: Open browser DevTools → Network → Check request headers for `Authorization: Bearer ...`
+3. Re-deploy Firestore rules: `firebase deploy --only firestore:rules`
+
+### Issue: "Thread not found" error
+
+**Fix:**
+1. Check Firestore Database has `threads` collection
+2. Verify thread ID format: `thread_{patientId}_{doctorId}`
+3. Check Firebase console for error logs
+
+### Issue: Google Sign-In popup blocked
+
+**Fix:**
+1. Check browser isn't blocking popups
+2. Add domain to Firebase Console → Authentication → Authorized domains
+3. Clear browser cache
+
+### Issue: Messages not showing in doctor inbox
+
+**Fix:**
+1. Verify doctor is using [inbox-threads.js](public/app/inbox-threads.js) (not old inbox.js)
+2. Check API endpoint: `/api/doctor/threads` is working
+3. Check browser console for errors
+
+### Issue: Payment not working with threads
+
+**Fix:**
+1. Thread-based payment integration is in [chat-threads.js](public/js/chat-threads.js)
+2. Verify Stripe keys are configured
+3. Check `thread.isPaid` status in Firestore
+
+---
+
+## 🔄 Rollback Plan (If Needed)
+
+If something goes wrong, you can quickly rollback:
+
+### Rollback Frontend:
+```bash
+# In public/chat.html, change:
+<script src="/js/chat-threads.js?v=1"></script>
+# Back to:
+<script src="/js/chat.js?v=3"></script>
+
+# In public/app/inbox.html, change:
+<script src="/app/inbox-threads.js"></script>
+# Back to:
+<script src="/app/inbox.js"></script>
+
+# Deploy:
+firebase deploy --only hosting
+```
+
+### Rollback Functions:
+```bash
+# Comment out patient API routes in functions/src/index.js:
+// if (req.path.startsWith("/patient/")) {
+//   const user = await requireAuth(req, res);
+//   if (!user) return;
+//   await handlePatientAPI(req, res, user);
+//   return;
+// }
+
+firebase deploy --only functions
+```
+
+**Note:** Old conversations in `conversations` collection are unaffected. They'll still work with old system.
+
+---
+
+## 📊 Monitoring & Analytics
+
+### Key Metrics to Watch:
+
+1. **Patient Sign-Ups:**
+   - Firebase Console → Authentication → Users
+   - Should see growth over time
+
+2. **Thread Creation Rate:**
+   - Firestore → `threads` collection
+   - Count of new documents
+
+3. **Message Volume:**
+   - Firestore → `threads/{id}/messages`
+   - Average messages per thread
+
+4. **Doctor Response Time:**
+   - Check `lastMessageAt` timestamps
+   - Time between patient message and doctor reply
+
+5. **API Performance:**
+   - Functions → Dashboard → Metrics
+   - Check latency and error rates
+
+---
+
+## 🎯 Success Criteria
+
+You'll know deployment is successful when:
+
+- ✅ Patients can sign in with Google
+- ✅ Messages persist after browser refresh
+- ✅ Doctor inbox shows patient names (not sessionIds)
+- ✅ Doctor can send manual replies
+- ✅ Manual mode (override AI) works
+- ✅ No errors in Firebase Functions logs
+- ✅ No errors in browser console
+- ✅ Multiple patients can chat with same doctor
+- ✅ Single patient can chat with multiple doctors
+
+---
+
+## 📞 Next Steps After Deployment
+
+### Phase 3: Web Push Notifications (Future)
+
+Once everything is stable, implement push notifications:
+
+1. Add FCM (Firebase Cloud Messaging) to frontend
+2. Request notification permission from patients
+3. Save FCM token to patient profile
+4. Send push notification when doctor replies
+
+See [THREAD_IMPLEMENTATION_GUIDE.md](THREAD_IMPLEMENTATION_GUIDE.md#phase-4-web-push-notifications) for details.
+
+---
+
+## 🔐 Security Reminders
+
+- ✅ Patient data is private (only they can access)
+- ✅ Doctors can only see their own threads
+- ✅ All writes go through authenticated backend
+- ✅ Firestore rules enforce access control
+- ✅ Google Sign-In tokens are verified server-side
+
+---
+
+## 📝 Deployment Log Template
+
+Use this to track your deployment:
+
+```
+Date: _____________
+Deployed by: _____________
+
+Step 1: Google Sign-In Enabled ✅ / ❌
+Step 2: Firestore Rules Deployed ✅ / ❌
+Step 3: Functions Deployed ✅ / ❌
+Step 4: Hosting Deployed ✅ / ❌
+Step 5: Testing Complete ✅ / ❌
+
+Test Results:
+- New patient flow: ✅ / ❌
+- Returning patient: ✅ / ❌
+- Doctor inbox: ✅ / ❌
+- Manual reply: ✅ / ❌
+
+Issues Encountered:
+__________________________________________
+__________________________________________
+
+Notes:
+__________________________________________
+__________________________________________
+```
+
+---
+
+## 🎉 You're Ready!
+
+Follow the steps above and you'll have the thread-based system live in under 15 minutes!
+
+**Need help?** Check:
+1. [THREAD_IMPLEMENTATION_GUIDE.md](THREAD_IMPLEMENTATION_GUIDE.md)
+2. [ARCHITECTURE_SUMMARY.md](ARCHITECTURE_SUMMARY.md)
+3. Firebase Console logs
+4. Browser developer console

package/docs/DEPLOY_FIRESTORE_RULES.md

@@ -0,0 +1,239 @@
+# Deploy Firestore Security Rules Manually
+
+## The Issue
+Firebase CLI is broken, so we need to deploy Firestore rules manually through the Firebase Console.
+
+## Quick Fix - Update Firestore Rules in Firebase Console
+
+### Step 1: Go to Firebase Console
+1. Open https://console.firebase.google.com/
+2. Select project: **evaldocplatform**
+3. Click **Firestore Database** in the left sidebar
+4. Click the **Rules** tab
+
+### Step 2: Copy and Paste These Rules
+
+```javascript
+rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    function isSignedIn() {
+      return request.auth != null;
+    }
+
+    function isOwner(ownerUid) {
+      return isSignedIn() && request.auth.uid == ownerUid;
+    }
+
+    // Provider documents
+    match /providers/{providerId} {
+      // Public: Anyone can read published providers
+      allow read: if resource.data.status == "published";
+
+      // Providers can only be created via backend API (Admin SDK)
+      allow create: if false;
+
+      // Providers can update their own profile
+      allow update: if isOwner(resource.data.ownerUid);
+
+      // Only backend can delete
+      allow delete: if false;
+
+      // Analytics subcollection
+      match /analyticsDaily/{dayId} {
+        allow read: if isOwner(providerId);
+        allow write: if false; // Only backend can write analytics
+      }
+    }
+
+    // Handle lookup (used to check if handle is taken)
+    match /handles/{handle} {
+      allow read: if true; // Anyone can check if handle exists
+      allow write: if false; // Only backend can manage handles
+    }
+
+    // Conversations (chat data)
+    match /conversations/{conversationId} {
+      // Only backend API can manage conversations
+      allow read, write: if false;
+
+      match /messages/{messageId} {
+        allow read, write: if false;
+      }
+    }
+
+    // Safety events (for monitoring)
+    match /safetyEvents/{eventId} {
+      allow read, write: if false; // Only backend
+    }
+
+    // Platform configuration
+    match /platformConfig/{docId} {
+      allow read: if true; // Public config can be read
+      allow write: if false; // Only backend can write
+    }
+
+    // Payment-related collections
+    match /subscriptions/{subscriptionId} {
+      allow read: if isSignedIn(); // Users can read their subscriptions
+      allow write: if false; // Only backend manages subscriptions
+    }
+
+    match /transactions/{transactionId} {
+      allow read: if isSignedIn(); // Users can read their transactions
+      allow write: if false; // Only backend manages transactions
+    }
+  }
+}
+```
+
+### Step 3: Publish the Rules
+1. Click the **Publish** button in the Firebase Console
+2. Wait for confirmation that rules were published
+
+---
+
+## What These Rules Do
+
+### ✅ Provider Management
+- **Read**: Anyone can read published providers (for patient search)
+- **Create**: Blocked on client (must use backend API)
+- **Update**: Providers can update their own profile
+- **Delete**: Only backend can delete
+
+### ✅ Handles Collection
+- **Read**: Public (to check if handle is available)
+- **Write**: Backend only
+
+### ✅ Conversations & Messages
+- **All access**: Backend only (sensitive medical data)
+
+### ✅ Payment Collections
+- **Read**: Authenticated users can read their own data
+- **Write**: Backend only (Stripe webhooks)
+
+---
+
+## Security Architecture
+
+This is a **backend-first architecture**:
+
+```
+Frontend → Backend API → Firebase Admin SDK → Firestore
+                ↓
+         (bypasses security rules)
+```
+
+**Why this is secure:**
+1. ✅ All writes go through authenticated API endpoints
+2. ✅ API validates data before writing
+3. ✅ Admin SDK bypasses Firestore rules (backend has full access)
+4. ✅ Client-side direct writes are blocked
+5. ✅ Only necessary reads are allowed from client
+
+**What the frontend can do directly:**
+- ✅ Read published provider profiles
+- ✅ Check if handles are available
+- ✅ Read public platform config
+- ✅ Read their own subscriptions/transactions
+
+**What requires backend API:**
+- ✅ Create provider profiles
+- ✅ Update provider data
+- ✅ Manage conversations
+- ✅ Process payments
+- ✅ Write analytics
+
+---
+
+## Testing After Deployment
+
+### Test 1: Public Provider Read
+```javascript
+// In browser console at http://localhost:8080
+firebase.firestore()
+  .collection('providers')
+  .where('status', '==', 'published')
+  .limit(1)
+  .get()
+  .then(snap => console.log('✅ Can read published providers'))
+  .catch(err => console.error('❌ Error:', err));
+```
+
+### Test 2: Handle Availability Check
+```javascript
+// Check if handle is available
+firebase.firestore()
+  .collection('handles')
+  .doc('test-doctor')
+  .get()
+  .then(doc => console.log('✅ Can check handles'))
+  .catch(err => console.error('❌ Error:', err));
+```
+
+### Test 3: Direct Create (Should Fail)
+```javascript
+// This should be blocked
+firebase.firestore()
+  .collection('providers')
+  .add({ test: true })
+  .then(() => console.error('❌ Security rules not working!'))
+  .catch(err => console.log('✅ Direct create blocked:', err.code));
+// Expected: permission-denied
+```
+
+---
+
+## Common Issues
+
+### "Missing or insufficient permissions"
+✅ **This is expected** for operations that must go through the backend API
+- Provider creation
+- Conversation management
+- Payment processing
+
+Use the API endpoints instead:
+- `POST /api/provider` - Create provider
+- `POST /api/provider/update` - Update provider
+- `POST /api/payment/update-pricing` - Update pricing
+
+### Rules not taking effect
+1. Clear browser cache
+2. Sign out and sign back in
+3. Wait 1-2 minutes for rules to propagate
+4. Check Firebase Console shows the new rules
+
+---
+
+## Verify Rules Are Active
+
+After publishing, check the Firebase Console:
+1. Go to **Firestore Database** → **Rules**
+2. Verify the rules match what you pasted
+3. Check "Last updated" timestamp is recent
+
+---
+
+## Production Considerations
+
+### Current Rules (Development-Friendly)
+✅ Public can read published providers
+✅ Public can check handle availability
+✅ Authenticated users can read config
+
+### For Production Hardening
+Consider adding:
+- Rate limiting (via Firebase App Check)
+- Geolocation restrictions
+- More granular provider update rules
+- Audit logging for sensitive operations
+
+---
+
+## Status
+
+✅ **Rules Created**: firestore.rules file updated
+⚠️ **Rules Deployed**: Manual deployment needed
+📋 **Next Step**: Copy rules to Firebase Console and publish
+
+**Deploy now**: https://console.firebase.google.com/project/evaldocplatform/firestore/rules

package/docs/DEPLOY_STORAGE_RULES.md

@@ -0,0 +1,82 @@
+# Deploy Firebase Storage Rules Manually
+
+## The Issue
+Firebase CLI is broken, so we need to deploy storage rules manually through the Firebase Console.
+
+## Quick Fix - Update Storage Rules in Firebase Console
+
+### Step 1: Go to Firebase Console
+1. Open https://console.firebase.google.com/
+2. Select project: **evaldocplatform**
+3. Click **Storage** in the left sidebar
+4. Click the **Rules** tab
+
+### Step 2: Copy and Paste These Rules
+
+```javascript
+rules_version = '2';
+service firebase.storage {
+  match /b/{bucket}/o {
+
+    // Doctor certificates - allow authenticated users to upload their own
+    match /certificates/{userId}/{allPaths=**} {
+      // Users can only upload their own certificates
+      allow write: if request.auth != null
+                   && request.auth.uid == userId
+                   && request.resource.size < 10 * 1024 * 1024;  // 10MB max
+
+      // Authenticated users can read (for admin verification)
+      allow read: if request.auth != null;
+    }
+
+    // Fallback for development - allow authenticated users
+    match /{allPaths=**} {
+      allow read, write: if request.auth != null;
+    }
+  }
+}
+```
+
+### Step 3: Publish the Rules
+1. Click the **Publish** button in the Firebase Console
+2. Wait for confirmation that rules were published
+
+### Step 4: Test Upload Again
+1. Go back to http://localhost:8080/app
+2. Try uploading a certificate again
+3. Should work now!
+
+## What These Rules Do
+
+✅ **Allow authenticated users to upload to their own folder**
+- Path: `certificates/{userId}/filename.pdf`
+- User can only write to their own `userId` folder
+- Max file size: 10MB
+
+✅ **Allow authenticated users to read certificates**
+- Needed for admin verification
+
+✅ **Development fallback**
+- Any authenticated user can read/write anywhere
+- This is permissive for development - tighten for production
+
+## Production Rules (Future)
+
+For production, replace the fallback with explicit deny:
+
+```javascript
+match /{allPaths=**} {
+  allow read, write: if false;  // Deny all other access
+}
+```
+
+## Verify Rules Are Active
+
+After publishing, the upload error should change from:
+- ❌ `storage/unauthorized` → ✅ Upload succeeds
+
+If you still get permission errors:
+1. Make sure you're logged in (check Firebase Auth)
+2. Verify the userId in the path matches your auth.uid
+3. Check file size is under 10MB
+4. Clear browser cache and try again