hazo_chat 1.1.0 → 2.0.1

package/SETUP_CHECKLIST.md

@@ -1,4 +1,4 @@
-# hazo_chat Setup Checklist
+# hazo_chat Setup Checklist (v2.0)
 
 A comprehensive, step-by-step guide for setting up hazo_chat in a Next.js project. This checklist is designed for both AI assistants and human developers.
 
@@ -8,15 +8,12 @@ A comprehensive, step-by-step guide for setting up hazo_chat in a Next.js projec
 
 1. [Prerequisites](#1-prerequisites)
 2. [Package Installation](#2-package-installation)
-3. [Configuration Files](#3-configuration-files)
-4. [Database Setup](#4-database-setup)
-5. [Environment Variables](#5-environment-variables)
-6. [Next.js Configuration](#6-nextjs-configuration)
-7. [API Routes](#7-api-routes)
-8. [Page Routes (Optional)](#8-page-routes-optional)
-9. [Component Integration](#9-component-integration)
-10. [Verification Checklist](#10-verification-checklist)
-11. [Troubleshooting](#11-troubleshooting)
+3. [Database Setup](#3-database-setup)
+4. [API Routes](#4-api-routes)
+5. [Component Integration](#5-component-integration)
+6. [Configuration (Optional)](#6-configuration-optional)
+7. [Verification Checklist](#7-verification-checklist)
+8. [Troubleshooting](#8-troubleshooting)
 
 ---
 
@@ -39,111 +36,25 @@ A comprehensive, step-by-step guide for setting up hazo_chat in a Next.js projec
 ### Step 2.1: Install Core Packages
 
 ```bash
-npm install hazo_chat hazo_connect hazo_auth hazo_config
+npm install hazo_chat hazo_connect
 ```
 
 ### Step 2.2: Install Peer Dependencies (if not already installed)
 
 ```bash
-npm install react react-dom
-```
-
-### Step 2.3: Install Additional Dependencies
-
-```bash
-# For UUID generation (optional, if not using hazo_auth's ID generation)
-npm install uuid
-npm install -D @types/uuid
+npm install react react-dom next
 ```
 
 ### Verification
-- [ ] `package.json` contains `hazo_chat`, `hazo_connect`, `hazo_auth`
+- [ ] `package.json` contains `hazo_chat` and `hazo_connect`
 - [ ] No npm installation errors
 - [ ] `node_modules/hazo_chat` exists
 
 ---
 
-## 3. Configuration Files
-
-### Step 3.1: Create hazo_connect_config.ini
-
-Create in project root: `hazo_connect_config.ini`
-
-```ini
-[database]
-; Database type: sqlite, postgrest, supabase
-type = sqlite
-
-; For SQLite - path relative to project root
-sqlite_path = ./data/app.db
-
-; For PostgreSQL/Supabase (uncomment if using)
-; postgrest_url = http://localhost:3000
-; supabase_url = https://your-project.supabase.co
-; supabase_anon_key = your-anon-key
-```
-
-### Step 3.2: Create hazo_auth_config.ini
-
-Create in project root: `hazo_auth_config.ini`
+## 3. Database Setup
 
-```ini
-[auth]
-; JWT secret for token signing
-jwt_secret = your-secure-secret-key-here
-jwt_expiry = 7d
-
-; Cookie settings
-cookie_name = hazo_auth_token
-cookie_secure = false
-cookie_http_only = true
-cookie_same_site = lax
-
-[login]
-enable_remember_me = true
-max_login_attempts = 5
-lockout_duration = 300
-
-[registration]
-enable_registration = true
-require_email_verification = false
-default_role = user
-
-[ui]
-; Visual panel image for auth pages
-visual_panel_image = /globe.svg
-```
-
-### Step 3.3: Create hazo_chat_config.ini (Optional)
-
-Create in project root: `hazo_chat_config.ini`
-
-```ini
-[chat]
-; Polling interval in milliseconds (default: 5000)
-polling_interval = 5000
-
-; Messages to load per page (default: 20)
-messages_per_page = 20
-
-[uploads]
-; Maximum file size in MB (default: 10)
-max_file_size_mb = 10
-
-; Allowed file extensions
-allowed_types = pdf,png,jpg,jpeg,gif,txt,doc,docx
-```
-
-### Verification
-- [ ] `hazo_connect_config.ini` exists in project root
-- [ ] `hazo_auth_config.ini` exists in project root
-- [ ] Database path directory exists (create `./data/` if using SQLite)
-
----
-
-## 4. Database Setup
-
-### Step 4.1: Create hazo_chat Table
+### Step 3.1: Create hazo_chat Table
 
 Run this SQL to create the chat messages table:
 
@@ -170,21 +81,17 @@ CREATE INDEX IF NOT EXISTS idx_hazo_chat_receiver ON hazo_chat(receiver_user_id)
 CREATE INDEX IF NOT EXISTS idx_hazo_chat_created ON hazo_chat(created_at DESC);
 ```
 
-### Step 4.2: Ensure hazo_users Table Exists
+### Step 3.2: Ensure Users Table Exists
 
-hazo_auth should have created this, but verify:
+You need a users table with at least these fields:
 
 ```sql
--- hazo_users table (created by hazo_auth)
 CREATE TABLE IF NOT EXISTS hazo_users (
   id TEXT PRIMARY KEY,
   email_address TEXT UNIQUE NOT NULL,
-  password_hash TEXT NOT NULL,
   name TEXT,
   profile_picture_url TEXT,
-  profile_source TEXT DEFAULT 'default',
   is_active INTEGER DEFAULT 1,
-  email_verified INTEGER DEFAULT 0,
   created_at TEXT NOT NULL,
   changed_at TEXT NOT NULL
 );
@@ -192,313 +99,87 @@ CREATE TABLE IF NOT EXISTS hazo_users (
 
 ### Verification
 - [ ] `hazo_chat` table exists in database
-- [ ] `hazo_users` table exists with at least one user
+- [ ] Users table exists with at least one user
 - [ ] Can query: `SELECT * FROM hazo_chat LIMIT 1`
 
 ---
 
-## 5. Environment Variables
-
-### Step 5.1: Create .env.local
-
-```env
-# Database (if not using config.ini)
-HAZO_CONNECT_TYPE=sqlite
-HAZO_CONNECT_SQLITE_PATH=./data/app.db
-
-# Auth secrets
-HAZO_AUTH_JWT_SECRET=your-secure-secret-key-min-32-chars
-
-# Optional: Supabase/PostgreSQL
-# HAZO_CONNECT_POSTGREST_URL=http://localhost:3000
-# SUPABASE_URL=https://your-project.supabase.co
-# SUPABASE_ANON_KEY=your-anon-key
-```
-
-### Step 5.2: Add to .gitignore
-
-```gitignore
-# Environment files
-.env
-.env.local
-.env.*.local
-
-# Database files (if using SQLite)
-*.db
-*.sqlite
-data/
-```
-
-### Verification
-- [ ] `.env.local` exists
-- [ ] `.env.local` is in `.gitignore`
-- [ ] Secrets are not committed to git
-
----
-
-## 6. Next.js Configuration
-
-### Step 6.1: Update next.config.js
+## 4. API Routes
 
-```javascript
-/**
- * Next.js Configuration with hazo_chat support
- */
-
-const path = require('path');
-
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  // Transpile the hazo packages for ES module support
-  transpilePackages: ['hazo_chat', 'hazo_connect', 'hazo_auth'],
-
-  // Webpack configuration
-  webpack: (config, { isServer }) => {
-    // Configure module resolution
-    config.resolve.extensionAlias = {
-      '.js': ['.js', '.ts', '.tsx'],
-      '.jsx': ['.jsx', '.tsx'],
-    };
-    
-    // Enable package exports resolution
-    config.resolve.conditionNames = ['import', 'require', 'default'];
-
-    // Server-side externals
-    if (isServer) {
-      config.externals = config.externals || [];
-      if (Array.isArray(config.externals)) {
-        config.externals.push("sql.js");
-        config.externals.push("hazo_notify");
-      }
-    }
+Create the following API routes in your Next.js app:
 
-    // WebAssembly support for sql.js
-    config.experiments = {
-      ...(config.experiments ?? {}),
-      asyncWebAssembly: true,
-    };
-
-    return config;
-  },
-
-  // Experimental features
-  experimental: {
-    serverComponentsExternalPackages: [
-      "sql.js",
-      "better-sqlite3",
-      "hazo_notify",
-    ],
-  },
-};
-
-module.exports = nextConfig;
-```
-
-### Verification
-- [ ] `next.config.js` includes transpilePackages
-- [ ] Server externals configured for sql.js
-- [ ] No build errors with `npm run build`
-
----
-
-## 7. API Routes
-
-Create the following API routes in `src/app/api/`:
-
-### Step 7.1: Chat Messages API
+### Step 4.1: Messages API (Using Exportable Handler)
 
 **File: `src/app/api/hazo_chat/messages/route.ts`**
 
 ```typescript
 /**
  * API route for chat message operations
+ * Uses the exportable handler from hazo_chat
  */
 
-export const dynamic = "force-dynamic";
-
-import { NextRequest, NextResponse } from "next/server";
-import { cookies } from "next/headers";
-import { createCrudService } from "hazo_connect/server";
-import { getHazoConnectSingleton } from "hazo_connect/nextjs/setup";
-import { v4 as uuid_v4 } from "uuid";
-
-interface ChatMessageDB {
-  id: string;
-  reference_id: string;
-  reference_type: string;
-  sender_user_id: string;
-  receiver_user_id: string;
-  message_text: string | null;
-  reference_list: string | null;
-  read_at: string | null;
-  deleted_at: string | null;
-  created_at: string;
-  changed_at: string;
-  [key: string]: unknown;
-}
-
-// GET - Fetch messages
-export async function GET(request: NextRequest) {
-  try {
-    const cookieStore = cookies();
-    const current_user_id = cookieStore.get("hazo_auth_user_id")?.value;
-
-    if (!current_user_id) {
-      return NextResponse.json(
-        { success: false, error: "Not authenticated" },
-        { status: 401 }
-      );
-    }
-
-    const { searchParams } = new URL(request.url);
-    const receiver_user_id = searchParams.get("receiver_user_id");
-    const reference_id = searchParams.get("reference_id");
-    const reference_type = searchParams.get("reference_type");
-
-    if (!receiver_user_id) {
-      return NextResponse.json(
-        { success: false, error: "receiver_user_id is required" },
-        { status: 400 }
-      );
-    }
-
-    const hazoConnect = getHazoConnectSingleton();
-    const chatService = createCrudService<ChatMessageDB>(hazoConnect, "hazo_chat");
-
-    const messages = await chatService.list((query) => {
-      let filteredQuery = query.whereOr([
-        { field: "sender_user_id", operator: "eq", value: current_user_id },
-        { field: "receiver_user_id", operator: "eq", value: current_user_id },
-      ]);
-
-      if (reference_id) {
-        filteredQuery = filteredQuery.where("reference_id", "eq", reference_id);
-      }
-      if (reference_type) {
-        filteredQuery = filteredQuery.where("reference_type", "eq", reference_type);
-      }
-
-      return filteredQuery.order("created_at", "asc");
-    });
-
-    return NextResponse.json({
-      success: true,
-      messages: messages || [],
-      current_user_id,
-    });
-  } catch (error) {
-    console.error("[hazo_chat/messages GET] Error:", error);
-    return NextResponse.json(
-      { success: false, error: "Failed to fetch messages" },
-      { status: 500 }
-    );
-  }
-}
-
-// POST - Create message
-export async function POST(request: NextRequest) {
-  try {
-    const cookieStore = cookies();
-    const sender_user_id = cookieStore.get("hazo_auth_user_id")?.value;
+import { createMessagesHandler } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
 
-    if (!sender_user_id) {
-      return NextResponse.json(
-        { success: false, error: "Not authenticated" },
-        { status: 401 }
-      );
-    }
+export const dynamic = 'force-dynamic';
 
-    const body = await request.json();
-    const { receiver_user_id, message_text, reference_id, reference_type, reference_list } = body;
+const { GET, POST } = createMessagesHandler({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
 
-    if (!receiver_user_id || !message_text?.trim()) {
-      return NextResponse.json(
-        { success: false, error: "receiver_user_id and message_text are required" },
-        { status: 400 }
-      );
-    }
-
-    const hazoConnect = getHazoConnectSingleton();
-    const chatService = createCrudService<ChatMessageDB>(hazoConnect, "hazo_chat");
-
-    const message_id = uuid_v4();
-    const now = new Date().toISOString();
-
-    const message_record: ChatMessageDB = {
-      id: message_id,
-      reference_id: reference_id || message_id,
-      reference_type: reference_type || "chat",
-      sender_user_id,
-      receiver_user_id,
-      message_text: message_text.trim(),
-      reference_list: reference_list ? JSON.stringify(reference_list) : null,
-      read_at: null,
-      deleted_at: null,
-      created_at: now,
-      changed_at: now,
-    };
-
-    await chatService.insert(message_record);
-
-    return NextResponse.json({
-      success: true,
-      message: message_record,
-    });
-  } catch (error) {
-    console.error("[hazo_chat/messages POST] Error:", error);
-    return NextResponse.json(
-      { success: false, error: "Failed to send message" },
-      { status: 500 }
-    );
-  }
-}
+export { GET, POST };
 ```
 
-### Step 7.2: Auth Me API
+### Step 4.2: Auth Me API
 
 **File: `src/app/api/hazo_auth/me/route.ts`**
 
 ```typescript
 /**
  * API route to get current authenticated user
+ * Adapt this to your authentication system
  */
 
-export const dynamic = "force-dynamic";
+export const dynamic = 'force-dynamic';
 
-import { NextRequest, NextResponse } from "next/server";
-import { hazo_get_auth } from "hazo_auth/lib/auth/hazo_get_auth.server";
+import { NextRequest, NextResponse } from 'next/server';
+import { cookies } from 'next/headers';
 
 export async function GET(request: NextRequest) {
   try {
-    const auth_result = await hazo_get_auth(request);
+    const cookieStore = cookies();
+    const user_id = cookieStore.get('hazo_auth_user_id')?.value;
 
-    if (!auth_result.is_authenticated || !auth_result.user) {
+    if (!user_id) {
       return NextResponse.json({
-        is_authenticated: false,
-        user_id: null,
-        email: null,
+        authenticated: false,
+        user: null
       });
     }
 
+    // TODO: Fetch user from your database
+    // const user = await fetchUserById(user_id);
+
     return NextResponse.json({
-      is_authenticated: true,
-      user_id: auth_result.user.id,
-      email: auth_result.user.email_address,
-      name: auth_result.user.name,
-      profile_picture_url: auth_result.user.profile_picture_url,
+      authenticated: true,
+      user: {
+        id: user_id,
+        name: 'User Name', // Replace with actual user data
+        email: 'user@example.com',
+        profile_picture_url: null
+      }
     });
   } catch (error) {
-    console.error("[hazo_auth/me] Error:", error);
+    console.error('[hazo_auth/me] Error:', error);
     return NextResponse.json({
-      is_authenticated: false,
-      user_id: null,
-      email: null,
+      authenticated: false,
+      user: null
     });
   }
 }
 ```
 
-### Step 7.3: User Profiles API
+### Step 4.3: User Profiles API
 
 **File: `src/app/api/hazo_auth/profiles/route.ts`**
 
@@ -507,18 +188,11 @@ export async function GET(request: NextRequest) {
  * API route to fetch user profiles by IDs
  */
 
-export const dynamic = "force-dynamic";
+export const dynamic = 'force-dynamic';
 
-import { NextRequest, NextResponse } from "next/server";
-import { createCrudService } from "hazo_connect/server";
-import { getHazoConnectSingleton } from "hazo_connect/nextjs/setup";
-
-interface UserProfile {
-  id: string;
-  name: string;
-  email: string;
-  avatar_url?: string;
-}
+import { NextRequest, NextResponse } from 'next/server';
+import { createCrudService } from 'hazo_connect/server';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
 
 export async function POST(request: NextRequest) {
   try {
@@ -527,299 +201,238 @@ export async function POST(request: NextRequest) {
 
     if (!Array.isArray(user_ids) || user_ids.length === 0) {
       return NextResponse.json(
-        { success: false, error: "user_ids array is required" },
+        { success: false, error: 'user_ids array is required' },
         { status: 400 }
       );
     }
 
     const hazoConnect = getHazoConnectSingleton();
-    const usersService = createCrudService(hazoConnect, "hazo_users");
+    const usersService = createCrudService(hazoConnect, 'hazo_users');
 
     const users = await usersService.list((query) =>
-      query.whereIn("id", user_ids)
+      query.whereIn('id', user_ids)
     );
 
-    const profiles: UserProfile[] = users.map((user) => ({
+    const profiles = users.map((user) => ({
       id: user.id as string,
-      name: (user.name as string) || (user.email_address as string).split("@")[0],
+      name: (user.name as string) || (user.email_address as string)?.split('@')[0] || 'User',
       email: user.email_address as string,
       avatar_url: user.profile_picture_url as string | undefined,
     }));
 
     return NextResponse.json({ success: true, profiles });
   } catch (error) {
-    console.error("[hazo_auth/profiles] Error:", error);
+    console.error('[hazo_auth/profiles] Error:', error);
     return NextResponse.json(
-      { success: false, error: "Failed to fetch profiles" },
+      { success: false, error: 'Failed to fetch profiles' },
       { status: 500 }
     );
   }
 }
 ```
 
-### Step 7.4: Additional Auth API Routes (Required for full hazo_auth)
+### API Routes Summary
 
-Create these additional routes if using hazo_auth authentication pages:
+| Endpoint | Method | File | Purpose |
+|----------|--------|------|---------|
+| `/api/hazo_chat/messages` | GET, POST | `api/hazo_chat/messages/route.ts` | Message CRUD |
+| `/api/hazo_auth/me` | GET | `api/hazo_auth/me/route.ts` | Get current user |
+| `/api/hazo_auth/profiles` | POST | `api/hazo_auth/profiles/route.ts` | Get user profiles |
 
-| Route | File Path | Purpose |
-|-------|-----------|---------|
-| Login | `api/hazo_auth/login/route.ts` | User login |
-| Logout | `api/hazo_auth/logout/route.ts` | User logout |
-| Register | `api/hazo_auth/register/route.ts` | User registration |
-| Users List | `api/hazo_auth/users/route.ts` | List all users |
+### Verification
+- [ ] All API route files exist
+- [ ] `GET /api/hazo_auth/me` returns user data when logged in
+- [ ] `POST /api/hazo_auth/profiles` returns profiles for given IDs
+- [ ] `GET /api/hazo_chat/messages?receiver_user_id=xxx` works
 
-See the test-app in this repository for complete implementations.
+---
 
-### Verification Checklist
-- [ ] `api/hazo_chat/messages/route.ts` exists
-- [ ] `api/hazo_auth/me/route.ts` exists
-- [ ] `api/hazo_auth/profiles/route.ts` exists
-- [ ] API routes return 200 when tested with curl
+## 5. Component Integration
 
----
+### Step 5.1: Basic Usage
 
-## 8. Page Routes (Optional)
+**File: `src/app/chat/page.tsx`**
 
-If using hazo_auth authentication pages, create these routes:
+```typescript
+'use client';
 
-### Authentication Pages
+import { HazoChat } from 'hazo_chat';
 
-| Page | File Path | Purpose |
-|------|-----------|---------|
-| Login | `app/hazo_auth/login/page.tsx` | Login page |
-| Register | `app/hazo_auth/register/page.tsx` | Registration page |
-| Forgot Password | `app/hazo_auth/forgot_password/page.tsx` | Password reset request |
-| Reset Password | `app/hazo_auth/reset_password/page.tsx` | Password reset form |
-| Verify Email | `app/hazo_auth/verify_email/page.tsx` | Email verification |
-| My Settings | `app/hazo_auth/my_settings/page.tsx` | User settings |
+export default function ChatPage() {
+  return (
+    <div className="h-screen">
+      <HazoChat
+        receiver_user_id="recipient-uuid-here"
+        title="Chat"
+        subtitle="Direct Message"
+      />
+    </div>
+  );
+}
+```
 
-See the test-app for complete page implementations.
+### Step 5.2: With All Options
 
----
+```typescript
+'use client';
 
-## 9. Component Integration
+import { HazoChat } from 'hazo_chat';
 
-### Step 9.1: Create hazo_auth Service Wrapper
+export default function ChatPage() {
+  return (
+    <HazoChat
+      receiver_user_id="user-123"
+      reference_id="project-456"
+      reference_type="project_chat"
+      api_base_url="/api/hazo_chat"
+      timezone="Australia/Sydney"
+      title="Project Discussion"
+      subtitle="Design Review"
+      additional_references={[
+        { 
+          id: 'doc-1', 
+          type: 'document', 
+          scope: 'field',
+          name: 'Design.pdf', 
+          url: '/files/design.pdf'
+        }
+      ]}
+      on_close={() => window.history.back()}
+      className="h-[600px]"
+    />
+  );
+}
+```
 
-**File: `src/lib/hazo_auth_client.ts`**
+---
 
-```typescript
-/**
- * Client-side hazo_auth service wrapper
- */
+## 6. Configuration (Optional)
 
-import type { HazoAuthInstance, HazoUserProfile } from 'hazo_chat';
-
-export const hazo_auth_client: HazoAuthInstance = {
-  hazo_get_auth: async () => {
-    try {
-      const response = await fetch('/api/hazo_auth/me');
-      const data = await response.json();
-      
-      if (data.is_authenticated) {
-        return {
-          id: data.user_id,
-          email: data.email,
-        };
-      }
-      return null;
-    } catch (error) {
-      console.error('Failed to get auth:', error);
-      return null;
-    }
-  },
+### hazo_connect Configuration
 
-  hazo_get_user_profiles: async (user_ids: string[]): Promise<HazoUserProfile[]> => {
-    try {
-      const response = await fetch('/api/hazo_auth/profiles', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ user_ids }),
-      });
-      const data = await response.json();
-      
-      if (data.success) {
-        return data.profiles;
-      }
-      return [];
-    } catch (error) {
-      console.error('Failed to get profiles:', error);
-      return [];
-    }
-  },
-};
-```
+Create `hazo_connect_config.ini` in project root:
 
-### Step 9.2: Integrate HazoChat Component
+```ini
+[database]
+type = sqlite
+sqlite_path = ./data/app.db
+```
 
-**File: `src/app/chat/page.tsx`**
+### hazo_chat Configuration
 
-```typescript
-'use client';
+Create `hazo_chat_config.ini` in project root (optional):
 
-import { useState, useEffect } from 'react';
-import { useRouter } from 'next/navigation';
-import { HazoChat } from 'hazo_chat';
-import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
-import { hazo_auth_client } from '@/lib/hazo_auth_client';
+```ini
+[chat]
+polling_interval = 5000
+messages_per_page = 20
 
-export default function ChatPage() {
-  const router = useRouter();
-  const [is_authenticated, set_is_authenticated] = useState(false);
-  const [is_loading, set_is_loading] = useState(true);
-  const [recipient_id, set_recipient_id] = useState<string>('');
-
-  // Check authentication on mount
-  useEffect(() => {
-    async function check_auth() {
-      const user = await hazo_auth_client.hazo_get_auth();
-      if (!user) {
-        router.push('/hazo_auth/login');
-        return;
-      }
-      set_is_authenticated(true);
-      set_is_loading(false);
-    }
-    check_auth();
-  }, [router]);
+[uploads]
+max_file_size_mb = 10
+allowed_types = pdf,png,jpg,jpeg,gif
+```
 
-  if (is_loading) {
-    return <div>Loading...</div>;
-  }
+### Next.js Configuration
 
-  if (!is_authenticated || !recipient_id) {
-    return <div>Select a user to chat with</div>;
-  }
+Update `next.config.js` if needed:
 
-  const hazo_connect = getHazoConnectSingleton();
+```javascript
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: ['hazo_chat', 'hazo_connect'],
+  experimental: {
+    serverComponentsExternalPackages: ['sql.js', 'better-sqlite3'],
+  },
+};
 
-  return (
-    <div className="h-screen">
-      <HazoChat
-        hazo_connect={hazo_connect}
-        hazo_auth={hazo_auth_client}
-        receiver_user_id={recipient_id}
-        document_save_location="/uploads/chat"
-        reference_id={`chat-${recipient_id}`}
-        reference_type="direct_message"
-        title="Chat"
-        on_close={() => router.back()}
-      />
-    </div>
-  );
-}
+module.exports = nextConfig;
 ```
 
 ---
 
-## 10. Verification Checklist
+## 7. Verification Checklist
 
 ### Installation Verification
 - [ ] All packages installed without errors
 - [ ] `npm run build` completes successfully
 - [ ] No TypeScript errors
 
-### Configuration Verification
-- [ ] `hazo_connect_config.ini` exists and is readable
-- [ ] Database file/connection is accessible
-- [ ] Environment variables are set
-
 ### Database Verification
 - [ ] `hazo_chat` table exists
-- [ ] `hazo_users` table exists with test users
+- [ ] Users table exists with test users
 - [ ] Can insert and query messages
 
 ### API Verification
 
-Test with curl or browser:
+Test with curl:
 
 ```bash
-# Test auth endpoint
+# Test auth endpoint (should return user data if logged in)
 curl http://localhost:3000/api/hazo_auth/me
 
-# Test profiles endpoint (with cookie/auth)
+# Test profiles endpoint
 curl -X POST http://localhost:3000/api/hazo_auth/profiles \
   -H "Content-Type: application/json" \
   -d '{"user_ids": ["user-id-here"]}'
 
-# Test messages endpoint (with cookie/auth)
+# Test messages endpoint
 curl "http://localhost:3000/api/hazo_chat/messages?receiver_user_id=user-id"
 ```
 
-Expected responses:
-- [ ] `/api/hazo_auth/me` returns user data or `is_authenticated: false`
-- [ ] `/api/hazo_auth/profiles` returns user profiles array
-- [ ] `/api/hazo_chat/messages` returns messages array
-
 ### UI Verification
 - [ ] Chat component renders without errors
+- [ ] No "Module not found: Can't resolve 'fs'" errors
 - [ ] Messages load and display correctly
 - [ ] Can send new messages
 - [ ] Messages appear in real-time (within polling interval)
-- [ ] File upload works (if configured)
 
 ---
 
-## 11. Troubleshooting
-
-### Error: "hazo_connect.from is not a function"
-
-**Cause:** Using wrong adapter type or import.
-
-**Solution:**
-```typescript
-// Wrong
-import hazo_connect from 'hazo_connect';
-
-// Correct
-import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
-const hazo_connect = getHazoConnectSingleton();
-```
-
-### Error: "Module not found"
+## 8. Troubleshooting
 
-**Cause:** Package not transpiled by Next.js.
+### Error: "Module not found: Can't resolve 'fs'"
 
-**Solution:** Add to `next.config.js`:
-```javascript
-transpilePackages: ['hazo_chat', 'hazo_connect', 'hazo_auth'],
-```
-
-### Error: "Hydration failed"
-
-**Cause:** Server/client rendering mismatch.
+**Cause:** Server-side code imported in client component.
 
-**Solution:**
-```typescript
-const [mounted, set_mounted] = useState(false);
-useEffect(() => set_mounted(true), []);
-if (!mounted) return null;
-```
+**Solution:** This shouldn't happen with v2.0. Ensure:
+1. You're using `hazo_chat` version 2.0+
+2. You're not importing from `hazo_connect/server` in client components
+3. API routes use server-side imports only
 
-### Error: "Database not found"
+### Error: "401 Unauthorized"
 
-**Cause:** SQLite path incorrect or directory doesn't exist.
+**Cause:** User not authenticated.
 
 **Solution:**
-1. Create data directory: `mkdir -p ./data`
-2. Check path in `hazo_connect_config.ini`
-3. Ensure path is relative to project root
+1. Check `/api/hazo_auth/me` returns authenticated user
+2. Ensure `hazo_auth_user_id` cookie is set
+3. Check cookie settings (httpOnly, sameSite, secure)
 
-### Messages Not Loading
+### Error: "Messages not loading"
 
 **Checklist:**
 1. Is user authenticated? Check `/api/hazo_auth/me`
-2. Is `reference_id` provided to HazoChat?
-3. Is database accessible?
-4. Check browser console for errors
+2. Is `receiver_user_id` provided?
+3. Check browser console for errors
+4. Check network tab for API responses
 5. Check server logs for API errors
 
-### Polling Not Working
+### Error: "Profiles not loading"
+
+**Cause:** `/api/hazo_auth/profiles` not returning data.
+
+**Solution:**
+1. Check the API route exists
+2. Verify users exist in database
+3. Check API response format matches expected
+
+### Error: "Polling not working"
 
 **Checklist:**
 1. Check network tab for `/api/hazo_chat/messages` requests
-2. Verify `polling_interval` in config (default: 5000ms)
+2. Verify polling interval (default: 5000ms)
 3. Check for JavaScript errors in console
+4. Verify API returns `{ success: true, messages: [] }` format
 
 ---
 
@@ -827,32 +440,23 @@ if (!mounted) return null;
 
 ```bash
 # 1. Install packages
-npm install hazo_chat hazo_connect hazo_auth hazo_config uuid
-
-# 2. Create config files
-touch hazo_connect_config.ini hazo_auth_config.ini
+npm install hazo_chat hazo_connect
 
-# 3. Create database directory
-mkdir -p ./data
-
-# 4. Create API routes
+# 2. Create API routes
 mkdir -p src/app/api/hazo_chat/messages
 mkdir -p src/app/api/hazo_auth/me
 mkdir -p src/app/api/hazo_auth/profiles
 
-# 5. Update next.config.js with transpilePackages
-
-# 6. Run database migrations (create hazo_chat table)
+# 3. Create database table (run SQL)
 
-# 7. Start development server
+# 4. Start development server
 npm run dev
 
-# 8. Test API endpoints
+# 5. Test API endpoints
 
-# 9. Integrate HazoChat component
+# 6. Use HazoChat component
 ```
 
 ---
 
 For more information, see the [README.md](./README.md) and [test-app](./test-app) for complete working examples.
-