Add AWS deployment setup with GitHub Actions auto-deploy

- Add GitHub Actions workflow for automatic EC2 deployment
- Add disposable mode for OpenCode (auto-reset after 20 messages)
- Add anonymous mode (no credentials stored)
- Add AWS deployment scripts
- Add disposable mode status bar to admin portal
- Add API endpoints for manual reset and status checking
- Update documentation for AWS deployment

This enables:
- Automatic deployment from GitHub to AWS EC2 on every push
- OpenCode runs anonymously without login
- Auto-resets after 20 messages with fresh device identity
- Complete cleanup of all traces between sessions

.github/workflows/deploy.yml

@@ -0,0 +1,82 @@
+name: Deploy to AWS EC2
+
+on:
+  push:
+    branches: [ main, master ]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v3
+    
+    - name: Deploy to EC2
+      env:
+        PRIVATE_KEY: ${{ secrets.EC2_SSH_KEY }}
+        HOST: ${{ secrets.EC2_HOST }}
+        USER: ${{ secrets.EC2_USER }}
+      run: |
+        echo "$PRIVATE_KEY" > private_key.pem
+        chmod 600 private_key.pem
+        
+        # Create deployment script
+        cat > deploy.sh << 'EOF'
+        #!/bin/bash
+        set -e
+        
+        cd ~/kai-api
+        
+        # Backup current state
+        echo "Creating backup..."
+        cp -r . ../kai-api-backup-$(date +%Y%m%d-%H%M%S) 2>/dev/null || true
+        
+        # Pull latest code
+        echo "Pulling latest code..."
+        git fetch origin
+        git reset --hard origin/main
+        
+        # Activate virtual environment
+        source venv/bin/activate
+        
+        # Install any new dependencies
+        echo "Installing dependencies..."
+        pip install -r requirements.txt
+        
+        # Restart the server
+        echo "Restarting server..."
+        pkill -f uvicorn 2>/dev/null || true
+        sleep 2
+        
+        # Start server in background
+        nohup ./venv/bin/uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1 > /tmp/kai-api.log 2>&1 &
+        
+        echo "✅ Deployment complete!"
+        echo "🌐 API: http://$(curl -s ifconfig.me):8000"
+        EOF
+        
+        chmod +x deploy.sh
+        
+        # Copy and execute deployment script on EC2
+        scp -i private_key.pem -o StrictHostKeyChecking=no deploy.sh $USER@$HOST:/tmp/
+        ssh -i private_key.pem -o StrictHostKeyChecking=no $USER@$HOST 'bash /tmp/deploy.sh'
+        
+        rm -f private_key.pem deploy.sh
+    
+    - name: Verify deployment
+      env:
+        HOST: ${{ secrets.EC2_HOST }}
+      run: |
+        echo "Waiting for server to start..."
+        sleep 5
+        
+        # Check if server is responding
+        if curl -s http://$HOST:8000/health > /dev/null 2>&1; then
+          echo "✅ Deployment successful! Server is running."
+          echo "🌐 API: http://$HOST:8000"
+          echo "🔧 Admin: http://$HOST:8000/qazmlp"
+        else
+          echo "⚠️  Server might still be starting. Check manually in a minute."
+          echo "🌐 API: http://$HOST:8000"
+        fi

AWS_DEPLOYMENT.md

@@ -0,0 +1,299 @@
+# AWS Deployment Guide for K-AI API
+
+This guide will help you deploy the K-AI API to AWS EC2 with OpenCode in **Anonymous + Disposable Mode**.
+
+## Overview
+
+- **Platform**: AWS EC2 (Ubuntu 22.04 LTS)
+- **Instance Type**: t3.medium minimum (2 vCPU, 4GB RAM)
+- **Port**: 8000 (HTTP)
+- **Mode**: Anonymous + Disposable (auto-reset after 20 messages)
+
+## Key Features
+
+### 🔒 Anonymous Mode
+- No login required
+- No credentials stored anywhere
+- Fresh device identity for each session
+- Random device/session IDs generated on startup
+
+### 🗑️ Disposable Mode
+- **Auto-reset after 20 messages** - Complete wipe and fresh start
+- **New chat between each message** - No context carryover
+- **Aggressive cleanup** - Removes ALL traces (config files, cache, temp files)
+- **Appears as new device** - OpenCode sees a completely different device
+
+### 🧹 What Gets Cleaned
+- All config directories
+- All cache and temp files
+- NPM/npx cache
+- Session directories
+- Any stored identifiers
+
+## Prerequisites
+
+1. **AWS Account** with EC2 access
+2. **SSH Key Pair** created in AWS
+3. **Local terminal** with SSH access
+
+## Step 1: Create EC2 Instance
+
+1. Go to AWS Console → EC2 → Launch Instance
+2. **Name**: `kai-api-server`
+3. **AMI**: Ubuntu 22.04 LTS (64-bit)
+4. **Instance Type**: t3.medium or larger
+5. **Key Pair**: Select your existing key pair or create new
+6. **Network Settings**:
+   - Create security group
+   - Allow SSH (port 22) from your IP
+   - Allow HTTP (port 80) from anywhere
+   - Allow Custom TCP (port 8000) from anywhere
+
+7. **Storage**: 20 GB gp3 (minimum)
+8. Click **Launch Instance**
+
+## Step 2: Get Your EC2 Details
+
+Once the instance is running, note down:
+- **Public IPv4 address** (e.g., `54.123.456.789`)
+- **Key pair file path** on your local machine (e.g., `~/Downloads/kai-api-key.pem`)
+
+## Step 3: Deploy to AWS (Easy Method)
+
+We provide a simple deployment script. Run this from your local machine:
+
+```bash
+# Make scripts executable
+chmod +x deploy-to-aws.sh aws-setup.sh start-production.sh run-daemon.sh
+
+# Run deployment
+./deploy-to-aws.sh -i ~/Downloads/kai-api-key.pem -h 54.123.456.789 -u ubuntu
+```
+
+This will:
+1. Upload all files to your EC2 instance
+2. Run the setup automatically
+3. Install all dependencies
+4. Start the server
+
+## Step 4: Access Your API
+
+Once deployed:
+- **API**: http://YOUR_EC2_IP:8000
+- **Admin Portal**: http://YOUR_EC2_IP:8000/qazmlp
+- **API Docs**: http://YOUR_EC2_IP:8000/docs
+
+## Managing the Server
+
+SSH into your EC2 instance:
+```bash
+ssh -i ~/Downloads/kai-api-key.pem ubuntu@54.123.456.789
+```
+
+### Server Commands
+
+```bash
+cd ~/kai-api
+
+# Start in foreground (good for testing)
+./start-production.sh
+
+# Run as background daemon
+./run-daemon.sh start
+
+# Check status
+./run-daemon.sh status
+
+# View logs
+./run-daemon.sh logs
+
+# Stop server
+./run-daemon.sh stop
+
+# Restart server
+./run-daemon.sh restart
+```
+
+## Using OpenCode in Disposable Mode
+
+### From the Admin Portal (/qazmlp):
+
+1. Go to **Browser Portal** section
+2. Select **"🖥️ OpenCode (Kimi K2.5 Free)"** from dropdown
+3. Click **Connect**
+4. You'll see the **Disposable Mode Status Bar** showing:
+   - Message count (0/20)
+   - Progress bar
+   - Reset timer
+   - Manual reset button
+
+### Disposable Mode Features:
+
+✅ **Automatic**:
+- New chat starts before EVERY message (no context carryover)
+- After 20 messages: Complete reset automatically
+- Fresh device identity generated
+- All traces wiped clean
+
+✅ **Manual Control**:
+- Click **"🔄 Reset Now"** anytime to force a reset
+- Status bar shows messages remaining
+- Visual warning when approaching reset (last 5 messages)
+
+### What Happens During Reset:
+
+1. Current session closed
+2. ALL files cleaned up:
+   - Config files
+   - Cache files
+   - Temp files
+   - Session directories
+   - NPM cache
+3. Fresh identity generated
+4. New session started
+5. OpenCode sees a **completely new device**
+
+### API Endpoints for Disposable Mode:
+
+```bash
+# Check disposable status
+curl "http://YOUR_EC2_IP:8000/qaz/terminal/status?model=kimi-k2.5-free"
+
+# Response:
+# {
+#   "status": "success",
+#   "data": {
+#     "message_count": 5,
+#     "max_messages": 20,
+#     "messages_remaining": 15,
+#     "auto_reset_enabled": true,
+#     "new_chat_between_messages": true,
+#     "is_running": true,
+#     "anonymous_mode": true
+#   }
+# }
+
+# Manual reset (wipe everything and start fresh)
+curl -X POST http://YOUR_EC2_IP:8000/qaz/terminal/reset \
+  -H "Content-Type: application/json" \
+  -d '{"model": "kimi-k2.5-free"}'
+
+# Response:
+# {
+#   "status": "success",
+#   "message": "Full disposable reset completed - OpenCode sees a brand new device!",
+#   "model": "kimi-k2.5-free"
+# }
+```
+
+## How It Works
+
+### Message Flow:
+1. User sends message
+2. System starts **new chat** (clears context)
+3. Message sent to OpenCode
+4. Response received
+5. Message counter incremented
+6. If counter >= 20 → **Full reset triggered**
+
+### Reset Process:
+```
+[20 messages reached]
+    ↓
+[Close session]
+    ↓
+[Delete ALL files]
+    ↓
+[Clear ALL caches]
+    ↓
+[Generate new identity]
+    ↓
+[Start fresh session]
+    ↓
+[OpenCode sees new device]
+```
+
+## Security & Privacy
+
+🔒 **Anonymous Mode Guarantees**:
+- No credentials stored
+- No login required
+- No persistent identifiers
+- Fresh identity each session
+
+🗑️ **Disposable Mode Guarantees**:
+- All traces removed after reset
+- No tracking possible between sessions
+- Context never carries over
+- Appears as completely different device
+
+## Available Free Models
+
+All models work in disposable mode:
+
+- **kimi-k2.5-free** (Kimi K2.5 Free)
+- **minimax-m2.5-free** (MiniMax M2.5 Free)
+- **big-pickle** (Big Pickle)
+- **glm-4.7** (GLM 4.7)
+
+## Troubleshooting
+
+### Can't connect to EC2:
+```bash
+chmod 600 ~/Downloads/kai-api-key.pem
+```
+
+### Server not starting:
+```bash
+./run-daemon.sh logs
+# Or run in foreground
+./start-production.sh
+```
+
+### OpenCode not resetting:
+- Check status: `curl "http://IP:8000/qaz/terminal/status"`
+- Manual reset: Use the "🔄 Reset Now" button
+- Check logs: `./run-daemon.sh logs`
+
+### Too many resets happening?
+- Default is 20 messages per reset
+- You can change this in `opencode_terminal.py`:
+```python
+MAX_MESSAGES_BEFORE_RESET = 20  # Change this number
+```
+
+## Cost Estimation
+
+- **t3.medium**: ~$30/month (on-demand)
+- **t3.large**: ~$60/month (on-demand)
+- **Data transfer**: Variable
+
+Use Reserved Instances for 30-60% savings.
+
+## Files You Can Modify
+
+- `opencode_terminal.py` - Change disposable mode settings
+- `aws-setup.sh` - Change EC2 setup
+- `start-production.sh` - Change how server starts
+- `run-daemon.sh` - Change daemon behavior
+
+## Need Help?
+
+1. Check logs: `./run-daemon.sh logs`
+2. Verify EC2 security group allows port 8000
+3. Ensure Node.js 18+ is installed
+4. Check disposable status endpoint
+
+---
+
+## Summary
+
+Your OpenCode integration now:
+✅ Requires NO login
+✅ Stores NO credentials  
+✅ Auto-resets every 20 messages
+✅ Starts new chat between messages
+✅ Wipes ALL traces on reset
+✅ Appears as new device to OpenCode
+
+**You get fresh free tokens automatically with each reset!**

admin_router.py

@@ -1383,3 +1383,46 @@ async def close_terminal(req: dict):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+
+@router.post("/terminal/reset")
+async def reset_terminal(req: dict):
+    """Manually trigger a full disposable reset (wipes all traces and starts fresh)."""
+    try:
+        from opencode_terminal import get_terminal_manager
+        
+        model = req.get("model", "kimi-k2.5-free")
+        manager = get_terminal_manager()
+        portal = manager.get_portal(model)
+        
+        if not portal.is_running():
+            raise HTTPException(status_code=400, detail="Terminal not running")
+        
+        success = await portal.manual_reset()
+        
+        return {
+            "status": "success" if success else "error",
+            "message": "Full disposable reset completed - OpenCode sees a brand new device!",
+            "model": model
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/terminal/status")
+async def get_terminal_status(model: str = "kimi-k2.5-free"):
+    """Get disposable mode status and message count."""
+    try:
+        from opencode_terminal import get_terminal_manager
+        
+        manager = get_terminal_manager()
+        portal = manager.get_portal(model)
+        
+        status = portal.get_disposable_status()
+        
+        return {
+            "status": "success",
+            "data": status
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+

aws-setup.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+# AWS EC2 Deployment Script for K-AI API
+# ======================================
+# This script sets up the K-AI API on an AWS EC2 instance
+# Run this on your EC2 instance after creating it
+
+set -e  # Exit on error
+
+echo "🚀 Starting K-AI API deployment on AWS EC2..."
+
+# Update system
+echo "📦 Updating system packages..."
+sudo apt-get update && sudo apt-get upgrade -y
+
+# Install essential packages
+echo "🔧 Installing dependencies..."
+sudo apt-get install -y \
+    git \
+    curl \
+    wget \
+    build-essential \
+    python3 \
+    python3-pip \
+    python3-venv \
+    nginx \
+    certbot \
+    python3-certbot-nginx \
+    software-properties-common \
+    apt-transport-https \
+    ca-certificates \
+    gnupg \
+    lsb-release
+
+# Install Node.js 18.x (required for OpenCode)
+echo "⬇️ Installing Node.js..."
+curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+# Verify installations
+echo "✅ Checking installations..."
+python3 --version
+node --version
+npm --version
+
+# Install Docker
+echo "🐳 Installing Docker..."
+sudo apt-get install -y docker.io docker-compose
+sudo systemctl start docker
+sudo systemctl enable docker
+sudo usermod -aG docker $USER
+
+# Install Playwright dependencies (for browser portals)
+echo "🎭 Installing Playwright dependencies..."
+sudo apt-get install -y \
+    libnss3 \
+    libatk-bridge2.0-0 \
+    libxss1 \
+    libgtk-3-0 \
+    libgbm1 \
+    libasound2
+
+# Create app directory
+echo "📁 Creating app directory..."
+mkdir -p ~/kai-api
+cd ~/kai-api
+
+# Clone your repository (you'll need to replace this URL)
+echo "📥 Cloning repository..."
+# git clone https://github.com/YOUR_USERNAME/KAI_API.git .
+# OR if using SCP/SFTP to upload files:
+echo "⏳ Waiting for application files..."
+echo "Please upload your K-AI API files to ~/kai-api/"
+echo "You can use: scp -r /local/path/to/KAI_API/* ubuntu@YOUR_EC2_IP:~/kai-api/"
+
+# Create a flag file to indicate setup is complete
+touch ~/kai-api/.setup-complete
+
+echo ""
+echo "=========================================="
+echo "✅ EC2 Setup Complete!"
+echo "=========================================="
+echo ""
+echo "Next steps:"
+echo "1. Upload your K-AI API files to ~/kai-api/"
+echo "2. Run: cd ~/kai-api && ./start-production.sh"
+echo ""
+echo "Your EC2 instance is ready!"

deploy-to-aws.sh

@@ -0,0 +1,260 @@
+#!/bin/bash
+# AWS Deployment Script - Automatic Upload and Setup
+# ==================================================
+# This script uploads files to EC2 and sets everything up automatically
+
+set -e  # Exit on error
+
+# Configuration
+EC2_IP="44.201.146.74"
+EC2_USER="ubuntu"
+KEY_PATH=""  # Will be set interactively
+REMOTE_DIR="/home/ubuntu/kai-api"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+# Check if running from KAI_API directory
+if [ ! -f "main.py" ] || [ ! -d "providers" ]; then
+    print_error "Please run this script from the KAI_API directory"
+    exit 1
+fi
+
+# Get SSH key path
+read -p "Enter path to your .pem key file (e.g., ~/Downloads/kai-api-key.pem): " KEY_PATH
+KEY_PATH="${KEY_PATH/#\~/$HOME}"  # Expand ~ to home directory
+
+if [ ! -f "$KEY_PATH" ]; then
+    print_error "Key file not found: $KEY_PATH"
+    exit 1
+fi
+
+# Fix key permissions
+chmod 600 "$KEY_PATH"
+print_success "Key permissions set to 600"
+
+print_status "Starting deployment to EC2 instance: $EC2_IP"
+print_status "This will upload files and set up the server automatically..."
+
+echo ""
+read -p "Press Enter to continue..."
+
+# Step 1: Test SSH connection
+print_status "Testing SSH connection..."
+if ssh -i "$KEY_PATH" -o ConnectTimeout=10 -o StrictHostKeyChecking=no "$EC2_USER@$EC2_IP" "echo 'SSH connection successful'" 2>/dev/null; then
+    print_success "SSH connection successful"
+else
+    print_error "Cannot connect to EC2 instance. Please check:"
+    print_error "  1. Instance is running"
+    print_error "  2. Security group allows port 22 from your IP"
+    print_error "  3. Key file is correct"
+    exit 1
+fi
+
+# Step 2: Create remote directory
+print_status "Creating remote directory..."
+ssh -i "$KEY_PATH" "$EC2_USER@$EC2_IP" "mkdir -p $REMOTE_DIR"
+
+# Step 3: Upload files
+print_status "Uploading files to EC2 (this may take a few minutes)..."
+print_status "Uploading application files..."
+
+# Create a list of files to upload (excluding unnecessary files)
+cat > /tmp/upload_list.txt << 'EOF'
+main.py
+config.py
+models.py
+engine.py
+services.py
+db.py
+auth.py
+v1_router.py
+admin_router.py
+copilot_portal.py
+copilot_session.py
+browser_portal.py
+opencode_terminal.py
+proxy_manager.py
+provider_state.py
+provider_sessions.py
+search_engine.py
+error_handling.py
+utils.py
+sanitizer.py
+useragent.py
+requirements.txt
+aws-setup.sh
+start-production.sh
+run-daemon.sh
+Dockerfile
+EOF
+
+# Upload the list and files
+rsync -avz --progress \
+    -e "ssh -i $KEY_PATH" \
+    --files-from=/tmp/upload_list.txt \
+    . \
+    "$EC2_USER@$EC2_IP:$REMOTE_DIR/"
+
+print_status "Uploading providers directory..."
+rsync -avz --progress \
+    -e "ssh -i $KEY_PATH" \
+    providers/ \
+    "$EC2_USER@$EC2_IP:$REMOTE_DIR/providers/"
+
+print_status "Uploading static directory..."
+rsync -avz --progress \
+    -e "ssh -i $KEY_PATH" \
+    static/ \
+    "$EC2_USER@$EC2_IP:$REMOTE_DIR/static/"
+
+print_success "All files uploaded successfully!"
+
+# Step 4: Run setup on EC2
+print_status "Running setup on EC2 instance..."
+ssh -i "$KEY_PATH" "$EC2_USER@$EC2_IP" << 'REMOTE_SCRIPT'
+
+cd ~/kai-api
+
+echo "=========================================="
+echo "🚀 Starting K-AI API Setup"
+echo "=========================================="
+
+# Update system
+echo "📦 Updating system packages..."
+sudo apt-get update -y
+
+# Install dependencies
+echo "🔧 Installing dependencies..."
+sudo apt-get install -y \
+    git curl wget build-essential \
+    python3 python3-pip python3-venv \
+    nginx certbot python3-certbot-nginx \
+    software-properties-common \
+    apt-transport-https ca-certificates \
+    gnupg lsb-release
+
+# Install Node.js 18.x
+echo "⬇️ Installing Node.js..."
+curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
+sudo apt-get install -y nodejs
+
+echo "✅ Node.js version: $(node --version)"
+echo "✅ npm version: $(npm --version)"
+
+# Install Docker
+echo "🐳 Installing Docker..."
+sudo apt-get install -y docker.io docker-compose
+sudo systemctl start docker
+sudo systemctl enable docker
+sudo usermod -aG docker $USER
+
+# Install Playwright dependencies
+echo "🎭 Installing Playwright dependencies..."
+sudo apt-get install -y \
+    libnss3 libatk-bridge2.0-0 libxss1 \
+    libgtk-3-0 libgbm1 libasound2
+
+# Create virtual environment
+echo "🐍 Setting up Python virtual environment..."
+python3 -m venv venv
+source venv/bin/activate
+
+# Install Python dependencies
+echo "📥 Installing Python dependencies..."
+pip install --upgrade pip
+pip install -r requirements.txt
+
+# Install Playwright browsers
+echo "🎭 Installing Playwright browsers..."
+playwright install chromium
+
+echo "=========================================="
+echo "✅ Setup Complete!"
+echo "=========================================="
+echo ""
+echo "To start the server, run:"
+echo "  cd ~/kai-api && ./start-production.sh"
+echo ""
+echo "Or run as background daemon:"
+echo "  cd ~/kai-api && ./run-daemon.sh start"
+echo ""
+
+REMOTE_SCRIPT
+
+print_success "Setup completed on EC2!"
+
+# Step 5: Start the server
+print_status "Starting the server..."
+ssh -i "$KEY_PATH" "$EC2_USER@$EC2_IP" << 'REMOTE_SCRIPT'
+
+cd ~/kai-api
+
+# Kill any existing processes
+pkill -f uvicorn 2>/dev/null || true
+
+# Start the server in background
+nohup ./venv/bin/uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1 > /tmp/kai-api.log 2>&1 &
+
+# Wait a moment for startup
+sleep 5
+
+# Check if it's running
+if pgrep -f uvicorn > /dev/null; then
+    echo "✅ Server is running!"
+    echo ""
+    echo "🌐 Your API is available at:"
+    echo "   http://$(curl -s ifconfig.me):8000"
+    echo ""
+    echo "🔧 Admin Portal:"
+    echo "   http://$(curl -s ifconfig.me):8000/qazmlp"
+    echo ""
+    echo "📚 API Docs:"
+    echo "   http://$(curl -s ifconfig.me):8000/docs"
+else
+    echo "❌ Server failed to start. Check logs:"
+    echo "   cat /tmp/kai-api.log"
+fi
+
+REMOTE_SCRIPT
+
+echo ""
+echo "=========================================="
+print_success "DEPLOYMENT COMPLETE!"
+echo "=========================================="
+echo ""
+echo "🌐 Your K-AI API is now running at:"
+echo "   http://$EC2_IP:8000"
+echo ""
+echo "🔧 Admin Portal (OpenCode Terminal):"
+echo "   http://$EC2_IP:8000/qazmlp"
+echo ""
+echo "📚 API Documentation:"
+echo "   http://$EC2_IP:8000/docs"
+echo ""
+echo "📊 To check server status:"
+echo "   ssh -i $KEY_PATH $EC2_USER@$EC2_IP 'cd ~/kai-api && ./run-daemon.sh status'"
+echo ""
+echo "📝 To view logs:"
+echo "   ssh -i $KEY_PATH $EC2_USER@$EC2_IP 'tail -f /tmp/kai-api.log'"
+echo ""

opencode_terminal.py

@@ -3,6 +3,8 @@ OpenCode Terminal Portal
 -------------------------
 Manages OpenCode terminal TUI as a provider.
 Supports free models: Kimi K2.5 Free, MiniMax M2.5 Free, Big Pickle, GLM 4.7
+
+ANONYMOUS MODE: No credentials stored, fresh device identity each session
 """
 
 import asyncio
@@ -10,11 +12,14 @@ import logging
 import subprocess
 import os
 import json
+import random
+import string
 from typing import Optional, Dict, Any, Callable
 from dataclasses import dataclass
 from datetime import datetime
 import threading
 import queue
+import shutil
 
 logger = logging.getLogger("kai_api.terminal_portal")
 
@@ -28,6 +33,15 @@ class TerminalConfig:
     config_path: str = ".opencode/config.json"
 
 
+def generate_anonymous_identity():
+    """Generate random device identifiers to appear as different device each time."""
+    return {
+        "device_id": ''.join(random.choices(string.hexdigits.lower(), k=32)),
+        "session_id": ''.join(random.choices(string.hexdigits.lower(), k=16)),
+        "fingerprint": ''.join(random.choices(string.hexdigits.lower(), k=24)),
+    }
+
+
 # Free models configuration
 OPENCODE_MODELS = {
     "kimi-k2.5-free": {
@@ -54,7 +68,11 @@ OPENCODE_MODELS = {
 
 
 class OpenCodeTerminalPortal:
-    """Manages OpenCode terminal TUI session."""
+    """Manages OpenCode terminal TUI session with DISPOSABLE mode."""
+    
+    # Disposable mode settings
+    MAX_MESSAGES_BEFORE_RESET = 20  # Auto-reset after 20 messages
+    AUTO_NEW_CHAT_BETWEEN_MESSAGES = True  # Start new chat between each message
     
     def __init__(self, config: TerminalConfig):
         self.config = config
@@ -67,22 +85,49 @@ class OpenCodeTerminalPortal:
         self.screenshot_path = f"/tmp/opencode_{config.model}.png"
         self.last_activity = None
         self._keyboard_active = False
+        self.message_count = 0  # Track messages for auto-reset
+        self.current_identity = None  # Track current session identity
+        self.session_dir = None  # Track current session directory
         
     async def initialize(self):
-        """Initialize OpenCode terminal session."""
+        """Initialize OpenCode terminal session in ANONYMOUS/DISPOSABLE mode."""
         if self.is_initialized:
             return
             
         try:
-            # Restore auth from Supabase if available
-            await self.restore_auth()
-            
             logger.info(f"🚀 Starting OpenCode terminal with model: {self.config.model}")
+            logger.info("🔒 Anonymous mode: No credentials stored, fresh device identity")
+            logger.info("🗑️  Disposable mode: Auto-reset after 20 messages, new chat between messages")
+            
+            # Generate fresh anonymous identity
+            self.current_identity = generate_anonymous_identity()
+            identity = self.current_identity
             
-            # Ensure config directory exists
-            os.makedirs(".opencode", exist_ok=True)
+            # Create isolated config directory for this session
+            self.session_dir = f"/tmp/opencode_session_{identity['session_id'][:8]}"
+            config_path = f"{self.session_dir}/config.json"
+            os.makedirs(self.session_dir, exist_ok=True)
             
-            # Create config file for this model
+            # Remove any existing auth files to ensure anonymous mode
+            auth_paths = [
+                os.path.expanduser("~/.local/share/opencode/auth.json"),
+                os.path.expanduser("~/.local/share/opencode"),
+                ".opencode/auth.json",
+                "/tmp/opencode_auth.json"
+            ]
+            for path in auth_paths:
+                if os.path.exists(path):
+                    try:
+                        if os.path.isfile(path):
+                            os.remove(path)
+                            logger.info(f"🗑️ Removed auth file: {path}")
+                        elif os.path.isdir(path):
+                            shutil.rmtree(path)
+                            logger.info(f"🗑️ Removed auth directory: {path}")
+                    except Exception as e:
+                        logger.warning(f"Could not remove {path}: {e}")
+            
+            # Create anonymous config - NO login required
             config_data = {
                 "$schema": "https://opencode.ai/config.json",
                 "theme": "opencode",
@@ -100,40 +145,25 @@ class OpenCodeTerminalPortal:
                 },
                 "model": f"opencode-zen/{self.config.model}",
                 "autoshare": False,
-                "autoupdate": True
+                "autoupdate": True,
+                # Anonymous mode settings
+                "anonymous": True,
+                "deviceId": identity["device_id"],
+                "sessionId": identity["session_id"]
             }
             
-            # Create config file for this model ONLY if it doesn't exist
-            # This allows the user to run `npx opencode-ai` manually to login/auth
-            if not os.path.exists(self.config.config_path):
-                config_data = {
-                    "$schema": "https://opencode.ai/config.json",
-                    "theme": "opencode",
-                    "provider": {
-                        "opencode-zen": {
-                            "npm": "@ai-sdk/openai-compatible",
-                            "options": {
-                                "baseURL": "https://opencode.ai/zen/v1"
-                            },
-                            "models": {
-                                model: {"name": info["name"]} 
-                                for model, info in OPENCODE_MODELS.items()
-                            }
-                        }
-                    },
-                    "model": f"opencode-zen/{self.config.model}",
-                    "autoshare": False,
-                    "autoupdate": True
-                }
-                
-                with open(self.config.config_path, 'w') as f:
-                    json.dump(config_data, f, indent=2)
-            else:
-                logger.info(f"Using existing config at {self.config.config_path}")
+            with open(config_path, 'w') as f:
+                json.dump(config_data, f, indent=2)
+            
+            logger.info(f"✅ Config created at: {config_path}")
             
-            # Start OpenCode process
+            # Start OpenCode process with custom environment
             env = os.environ.copy()
-            env['OPENCODE_CONFIG'] = os.path.abspath(self.config.config_path)
+            env['OPENCODE_CONFIG'] = os.path.abspath(config_path)
+            # Set random terminal identifier
+            env['TERM_SESSION_ID'] = identity["session_id"]
+            # Prevent any auth persistence
+            env['OPENCODE_NO_AUTH'] = '1'
             
             self.process = subprocess.Popen(
                 ['npx', '-y', 'opencode-ai'],
@@ -141,7 +171,7 @@ class OpenCodeTerminalPortal:
                 env=env,
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
+                stderr=subprocess.STDOUT,  # Merge stderr into stdout for easier reading
                 text=True,
                 bufsize=1
             )
@@ -152,9 +182,31 @@ class OpenCodeTerminalPortal:
             self.output_thread.start()
             
             self.is_initialized = True
-            logger.info(f"✅ OpenCode terminal ready with {self.config.model}")
+            logger.info(f"✅ OpenCode terminal ready (Anonymous mode)")
+            logger.info(f"🆔 Session ID: {identity['session_id'][:16]}...")
+            
+            # Wait for startup and send initial commands to select free model
+            await asyncio.sleep(3)
+            
+            # Auto-select the free model (Ctrl+X then M)
+            await self.send_key('ctrl+x')
+            await asyncio.sleep(0.5)
+            await self.send_input('m')
+            await asyncio.sleep(1)
+            
+            # Select model based on config
+            model_map = {
+                "kimi-k2.5-free": "kimi",
+                "minimax-m2.5-free": "minimax",
+                "big-pickle": "big pickle",
+                "glm-4.7": "glm"
+            }
+            model_keyword = model_map.get(self.config.model, "kimi")
+            
+            # Send enter to select default (usually Kimi)
+            await self.send_key('Enter')
+            await asyncio.sleep(0.5)
             
-            await asyncio.sleep(2)  # Give it time to start
             await self.take_screenshot()
             
         except Exception as e:
@@ -181,20 +233,138 @@ class OpenCodeTerminalPortal:
         except Exception as e:
             logger.error(f"Error reading output: {e}")
     
-    async def send_input(self, text: str):
-        """Send text input to OpenCode."""
+    async def send_input(self, text: str, is_message: bool = True):
+        """Send text input to OpenCode with disposable mode handling."""
         if not self.process or not self.is_initialized:
             return False
         
         try:
+            # If this is a user message (not a command), handle disposable mode
+            if is_message and self.AUTO_NEW_CHAT_BETWEEN_MESSAGES:
+                # Start a new chat before sending the message
+                await self._start_new_chat()
+                await asyncio.sleep(0.5)
+            
+            # Send the actual message
             self.process.stdin.write(text + '\n')
             self.process.stdin.flush()
             self.last_activity = datetime.now()
+            
+            # Track message count for auto-reset
+            if is_message:
+                self.message_count += 1
+                logger.info(f"📨 Message {self.message_count}/{self.MAX_MESSAGES_BEFORE_RESET}")
+                
+                # Check if we need to auto-reset
+                if self.message_count >= self.MAX_MESSAGES_BEFORE_RESET:
+                    logger.info("🔄 Auto-reset triggered after 20 messages!")
+                    await self._full_reset()
+            
             return True
         except Exception as e:
             logger.error(f"Error sending input: {e}")
             return False
     
+    async def _start_new_chat(self):
+        """Start a new chat to avoid context carryover."""
+        try:
+            # Send Ctrl+N for new chat (or equivalent command)
+            logger.info("🆕 Starting new chat...")
+            self.process.stdin.write('\x0e')  # Ctrl+N
+            self.process.stdin.flush()
+            await asyncio.sleep(0.3)
+        except Exception as e:
+            logger.warning(f"Could not start new chat: {e}")
+    
+    async def _full_reset(self):
+        """Complete reset: wipe everything and start fresh."""
+        logger.info("🧹 PERFORMING FULL DISPOSABLE RESET...")
+        
+        # 1. Close current session
+        await self.close()
+        
+        # 2. Aggressive cleanup of ALL traces
+        await self._complete_cleanup()
+        
+        # 3. Reset counters
+        self.message_count = 0
+        self.current_identity = None
+        self.session_dir = None
+        
+        # 4. Wait a moment to ensure cleanup
+        await asyncio.sleep(2)
+        
+        # 5. Reinitialize with fresh identity
+        logger.info("🔄 Starting fresh session...")
+        await self.initialize()
+        
+        logger.info("✅ Full reset complete - OpenCode sees a completely new device!")
+    
+    async def _complete_cleanup(self):
+        """Complete cleanup of ALL OpenCode traces."""
+        cleanup_paths = [
+            # Config directories
+            "/tmp/opencode_session_*",
+            os.path.expanduser("~/.local/share/opencode"),
+            os.path.expanduser("~/.config/opencode"),
+            os.path.expanduser("~/.opencode"),
+            ".opencode",
+            
+            # Cache and temp files
+            os.path.expanduser("~/.cache/opencode"),
+            "/tmp/opencode*",
+            "/tmp/.opencode*",
+            
+            # Node/npm cache that might have identifiers
+            os.path.expanduser("~/.npm/_npx/*opencode*"),
+            os.path.expanduser("~/.npm/_logs/*opencode*"),
+            
+            # Any auth files
+            os.path.expanduser("~/.local/share/opencode/auth.json"),
+            "/tmp/opencode_auth.json",
+            "/tmp/kai-opencode-*",
+        ]
+        
+        for path_pattern in cleanup_paths:
+            try:
+                import glob
+                matching_paths = glob.glob(path_pattern)
+                for path in matching_paths:
+                    if os.path.exists(path):
+                        if os.path.isfile(path):
+                            os.remove(path)
+                            logger.info(f"🗑️ Deleted file: {path}")
+                        elif os.path.isdir(path):
+                            shutil.rmtree(path, ignore_errors=True)
+                            logger.info(f"🗑️ Deleted directory: {path}")
+            except Exception as e:
+                logger.warning(f"Cleanup warning for {path_pattern}: {e}")
+        
+        # Clear npm/npx cache
+        try:
+            subprocess.run(["npm", "cache", "clean", "--force"], 
+                         capture_output=True, timeout=10)
+            logger.info("🧹 NPM cache cleared")
+        except Exception as e:
+            logger.warning(f"Could not clear NPM cache: {e}")
+        
+        # Clear any system-level temporary identifiers
+        try:
+            # Clear /tmp of any opencode related files
+            import glob
+            for f in glob.glob("/tmp/*opencode*"):
+                try:
+                    if os.path.isfile(f):
+                        os.remove(f)
+                    elif os.path.isdir(f):
+                        shutil.rmtree(f, ignore_errors=True)
+                except:
+                    pass
+        except:
+            pass
+        
+        logger.info("🧹 Complete cleanup finished - No traces left!")
+    
     async def send_key(self, key: str):
         """Send a special key to OpenCode (e.g., 'ctrl+c', 'enter', 'tab')."""
         if not self.process or not self.is_initialized:
@@ -288,7 +458,7 @@ class OpenCodeTerminalPortal:
         return self.process.poll() is None
     
     async def close(self):
-        """Close the OpenCode terminal."""
+        """Close the OpenCode terminal and cleanup anonymous session."""
         try:
             if self.process:
                 # Send exit command
@@ -309,74 +479,47 @@ class OpenCodeTerminalPortal:
                 self.process = None
             
             self.is_initialized = False
-            logger.info("OpenCode terminal closed")
-            
-        except Exception as e:
-            logger.error(f"Error closing OpenCode: {e}")
-
-    async def restore_auth(self):
-        """Restore auth token from Supabase."""
-        try:
-            from db import get_supabase
-            supabase = get_supabase()
-            if not supabase:
-                return
-
-            # Check if we have auth data in Supabase
-            res = supabase.table("kaiapi_settings").select("value").eq("key", "opencode_auth").execute()
-            if not res.data:
-                return
-
-            auth_data = res.data[0]["value"]
             
-            # Paths to check/restore
-            paths = [
-                os.path.expanduser("~/.local/share/opencode/auth.json"),
-                # Fallback paths if needed
-            ]
+            # Cleanup session directory to remove any traces
+            if self.session_dir and os.path.exists(self.session_dir):
+                try:
+                    shutil.rmtree(self.session_dir, ignore_errors=True)
+                    logger.info(f"🧹 Cleaned up session directory: {self.session_dir}")
+                except Exception as e:
+                    logger.warning(f"Session cleanup warning: {e}")
             
-            for path in paths:
-                os.makedirs(os.path.dirname(path), exist_ok=True)
-                with open(path, 'w') as f:
-                    json.dump(auth_data, f, indent=2)
+            # Reset message counter
+            self.message_count = 0
             
-            logger.info("✅ Restored OpenCode auth from Supabase")
+            logger.info("OpenCode terminal closed (Anonymous session cleaned)")
             
         except Exception as e:
-            logger.warning(f"Failed to restore auth from Supabase: {e}")
+            logger.error(f"Error closing OpenCode: {e}")
 
     async def sync_auth(self):
-        """Sync local auth token to Supabase."""
-        try:
-            from db import get_supabase
-            supabase = get_supabase()
-            if not supabase:
-                logger.error("Supabase not configured, cannot sync auth")
-                return False
-
-            # Find auth file
-            auth_path = os.path.expanduser("~/.local/share/opencode/auth.json")
-            if not os.path.exists(auth_path):
-                logger.warning(f"Auth file not found at {auth_path}")
-                return False
-                
-            with open(auth_path, 'r') as f:
-                auth_data = json.load(f)
-                
-            # Save to Supabase
-            supabase.table("kaiapi_settings").upsert({
-                "key": "opencode_auth",
-                "value": auth_data,
-                "updated_at": datetime.now().isoformat()
-            }).execute()
-            
-            logger.info("✅ Synced OpenCode auth to Supabase")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to sync auth to Supabase: {e}")
-            return False
+        """DEPRECATED: Anonymous mode - no auth to sync."""
+        logger.warning("sync_auth() called but anonymous mode is active - no credentials stored")
+        return False
 
+    async def manual_reset(self):
+        """Manually trigger a full disposable reset."""
+        logger.info("🔄 Manual reset requested")
+        await self._full_reset()
+        return True
+    
+    def get_disposable_status(self) -> dict:
+        """Get current disposable mode status."""
+        return {
+            "message_count": self.message_count,
+            "max_messages": self.MAX_MESSAGES_BEFORE_RESET,
+            "messages_remaining": max(0, self.MAX_MESSAGES_BEFORE_RESET - self.message_count),
+            "auto_reset_enabled": True,
+            "new_chat_between_messages": self.AUTO_NEW_CHAT_BETWEEN_MESSAGES,
+            "is_running": self.is_running(),
+            "anonymous_mode": True,
+            "session_dir": self.session_dir,
+            "device_id": self.current_identity["device_id"][:16] + "..." if self.current_identity else None,
+        }
 
 
 class TerminalPortalManager:

run-daemon.sh

@@ -0,0 +1,112 @@
+#!/bin/bash
+# Run K-AI API as a Background Daemon
+# ===================================
+# This script runs the API in the background with auto-restart
+
+cd ~/kai-api
+
+APP_NAME="kai-api"
+PID_FILE="/tmp/kai-api.pid"
+LOG_FILE="/tmp/kai-api.log"
+
+start() {
+    if [ -f "$PID_FILE" ] && kill -0 $(cat "$PID_FILE") 2>/dev/null; then
+        echo "✅ $APP_NAME is already running (PID: $(cat $PID_FILE))"
+        return
+    fi
+    
+    echo "🚀 Starting $APP_NAME..."
+    
+    # Activate virtual environment
+    source venv/bin/activate
+    
+    # Set environment
+    export PYTHONUNBUFFERED=1
+    export ENVIRONMENT=production
+    
+    # Load .env if exists
+    if [ -f ".env" ]; then
+        export $(cat .env | grep -v '^#' | xargs)
+    fi
+    
+    # Start with nohup
+    nohup uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1 > "$LOG_FILE" 2>&1 &
+    
+    # Save PID
+    echo $! > "$PID_FILE"
+    
+    echo "✅ $APP_NAME started (PID: $(cat $PID_FILE))"
+    echo "📄 Logs: $LOG_FILE"
+    echo "🌐 API: http://$(curl -s ifconfig.me):8000"
+    echo "🔧 Admin: http://$(curl -s ifconfig.me):8000/qazmlp"
+}
+
+stop() {
+    if [ ! -f "$PID_FILE" ]; then
+        echo "❌ $APP_NAME is not running"
+        return
+    fi
+    
+    PID=$(cat "$PID_FILE")
+    echo "🛑 Stopping $APP_NAME (PID: $PID)..."
+    
+    kill $PID 2>/dev/null
+    sleep 2
+    
+    if kill -0 $PID 2>/dev/null; then
+        echo "💥 Force killing..."
+        kill -9 $PID 2>/dev/null
+    fi
+    
+    rm -f "$PID_FILE"
+    echo "✅ $APP_NAME stopped"
+}
+
+restart() {
+    stop
+    sleep 2
+    start
+}
+
+status() {
+    if [ -f "$PID_FILE" ] && kill -0 $(cat "$PID_FILE") 2>/dev/null; then
+        echo "✅ $APP_NAME is running (PID: $(cat $PID_FILE))"
+        echo "🌐 API: http://$(curl -s ifconfig.me):8000"
+        echo ""
+        echo "📊 Recent logs:"
+        tail -20 "$LOG_FILE"
+    else
+        echo "❌ $APP_NAME is not running"
+        rm -f "$PID_FILE"
+    fi
+}
+
+logs() {
+    if [ -f "$LOG_FILE" ]; then
+        tail -f "$LOG_FILE"
+    else
+        echo "❌ No log file found"
+    fi
+}
+
+case "${1:-start}" in
+    start)
+        start
+        ;;
+    stop)
+        stop
+        ;;
+    restart)
+        restart
+        ;;
+    status)
+        status
+        ;;
+    logs)
+        logs
+        ;;
+    *)
+        echo "Usage: $0 {start|stop|restart|status|logs}"
+        exit 1
+        ;;
+esac

start-production.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+# Production Start Script for K-AI API
+# ====================================
+# This script starts the K-AI API in production mode
+
+cd ~/kai-api
+
+echo "🚀 Starting K-AI API in production mode..."
+
+# Check if virtual environment exists
+if [ ! -d "venv" ]; then
+    echo "📦 Creating virtual environment..."
+    python3 -m venv venv
+fi
+
+# Activate virtual environment
+source venv/bin/activate
+
+# Install/update dependencies
+echo "📥 Installing dependencies..."
+pip install --upgrade pip
+pip install -r requirements.txt
+
+# Install Playwright browsers
+echo "🎭 Installing Playwright browsers..."
+playwright install chromium
+
+# Create necessary directories
+mkdir -p static
+mkdir -p /tmp/opencode_sessions
+
+# Set environment variables for production
+export PYTHONUNBUFFERED=1
+export ENVIRONMENT=production
+export PORT=8000
+export HOST=0.0.0.0
+
+# Check if .env file exists and source it
+if [ -f ".env" ]; then
+    echo "🔑 Loading environment variables from .env..."
+    export $(cat .env | grep -v '^#' | xargs)
+fi
+
+echo ""
+echo "========================================"
+echo "🌐 K-AI API is starting!"
+echo "========================================"
+echo ""
+echo "The API will be available at:"
+echo "  • Local: http://localhost:8000"
+echo "  • Admin: http://localhost:8000/qazmlp"
+echo ""
+echo "To run in background with auto-restart, use:"
+echo "  ./run-daemon.sh"
+echo ""
+echo "Starting server..."
+echo ""
+
+# Start the server
+exec uvicorn main:app --host $HOST --port $PORT --workers 1

static/qaz.html

@@ -805,6 +805,28 @@
                 </div>
             </div>
 
+            <!-- Disposable Mode Status Bar (shown only for terminal) -->
+            <div id="disposable-status-bar" style="display:none;padding:10px 16px;background:var(--surface-hover);border-bottom:1px solid var(--border);">
+                <div style="display:flex;justify-content:space-between;align-items:center;">
+                    <div style="display:flex;align-items:center;gap:12px;">
+                        <span style="font-size:0.875rem;font-weight:600;">🗑️ Disposable Mode</span>
+                        <span style="font-size:0.75rem;color:var(--text-secondary);">
+                            Messages: <span id="msg-count" style="color:var(--accent);font-weight:600;">0</span>/<span id="msg-max">20</span>
+                        </span>
+                        <div class="progress-bar" style="width:100px;height:6px;">
+                            <div id="msg-progress" class="progress-fill" style="width:0%;background:var(--success);"></div>
+                        </div>
+                    </div>
+                    <div style="display:flex;gap:8px;">
+                        <span id="next-reset-timer" style="font-size:0.75rem;color:var(--text-secondary);"></span>
+                        <button class="btn btn-secondary" style="padding:4px 12px;font-size:0.75rem;" onclick="manualReset()">🔄 Reset Now</button>
+                    </div>
+                </div>
+                <div style="margin-top:6px;font-size:0.75rem;color:var(--text-secondary);">
+                    🔒 Anonymous • 🆕 New chat between messages • 🧹 Auto-reset after 20 messages
+                </div>
+            </div>
+
             <!-- Browser Interface -->
             <div id="browser-interface" style="display:none;">
                 <!-- Toolbar -->
@@ -821,7 +843,7 @@
 
                     <div class="quality-selector">
                         <span style="font-size:0.75rem;color:var(--text-secondary);">Quality:</span>
-                        <button class="quality-btn active" onclick="setStreamQuality('low')"
+                        <button class="quality-btn active" onclick="setStreamQuality('low')
                             id="quality-low">Low</button>
                         <button class="quality-btn" onclick="setStreamQuality('medium')"
                             id="quality-medium">Med</button>
@@ -1206,9 +1228,15 @@
             // Update controls for terminal
             document.querySelector('.browser-address-bar').style.visibility = 'hidden';
             document.querySelector('.quality-selector').style.visibility = 'hidden';
-            document.getElementById('terminal-sync-btn').style.display = 'inline-block';
+            document.getElementById('terminal-sync-btn').style.display = 'none'; // Hide sync button (anonymous mode)
             document.getElementById('browser-page-title').textContent = 'OpenCode Terminal';
             document.getElementById('browser-coords').textContent = 'Type commands below';
+            
+            // Show disposable mode status bar
+            document.getElementById('disposable-status-bar').style.display = 'block';
+            
+            // Start polling disposable status
+            startDisposableStatusPolling();
         }
 
         async function syncTerminalAuth() {
@@ -1267,6 +1295,98 @@
             }, 1000);
         }
 
+        // Disposable Mode Functions
+        let disposableStatusInterval = null;
+
+        function startDisposableStatusPolling() {
+            if (disposableStatusInterval) clearInterval(disposableStatusInterval);
+            
+            // Poll status every 3 seconds
+            disposableStatusInterval = setInterval(async () => {
+                if (currentProvider !== 'opencode') return;
+                
+                try {
+                    const res = await fetch('/qaz/terminal/status?model=kimi-k2.5-free');
+                    const data = await res.json();
+                    
+                    if (data.status === 'success' && data.data) {
+                        updateDisposableStatusUI(data.data);
+                    }
+                } catch (e) {
+                    console.error('Disposable status poll error:', e);
+                }
+            }, 3000);
+            
+            // Initial poll
+            fetch('/qaz/terminal/status?model=kimi-k2.5-free')
+                .then(r => r.json())
+                .then(data => {
+                    if (data.status === 'success') updateDisposableStatusUI(data.data);
+                })
+                .catch(e => console.error(e));
+        }
+
+        function updateDisposableStatusUI(status) {
+            document.getElementById('msg-count').textContent = status.message_count;
+            document.getElementById('msg-max').textContent = status.max_messages;
+            
+            const progress = (status.message_count / status.max_messages) * 100;
+            const progressBar = document.getElementById('msg-progress');
+            progressBar.style.width = progress + '%';
+            
+            // Change color based on progress
+            if (progress >= 90) {
+                progressBar.style.background = 'var(--error)';
+            } else if (progress >= 70) {
+                progressBar.style.background = 'var(--warning)';
+            } else {
+                progressBar.style.background = 'var(--success)';
+            }
+            
+            const remaining = status.max_messages - status.message_count;
+            document.getElementById('next-reset-timer').textContent = 
+                remaining <= 5 ? `⚠️ Reset in ${remaining} messages!` : `${remaining} messages until reset`;
+        }
+
+        async function manualReset() {
+            if (!confirm('🗑️ This will completely wipe all traces and start fresh. OpenCode will see a brand new device. Continue?')) {
+                return;
+            }
+            
+            const btn = event.target;
+            const originalText = btn.textContent;
+            btn.textContent = 'Resetting...';
+            btn.disabled = true;
+            
+            try {
+                const res = await fetch('/qaz/terminal/reset', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ model: 'kimi-k2.5-free' })
+                });
+                
+                const data = await res.json();
+                
+                if (data.status === 'success') {
+                    btn.textContent = '✅ Reset Complete!';
+                    alert('🗑️ Full disposable reset completed!\n\nOpenCode now sees a completely new device with fresh tokens.');
+                    // Clear terminal view
+                    document.getElementById('terminal-view').innerHTML = '🔄 Session reset - Starting fresh...';
+                } else {
+                    alert('Reset failed: ' + data.message);
+                    btn.textContent = '❌ Error';
+                }
+            } catch (e) {
+                alert('Reset error: ' + e);
+                btn.textContent = '❌ Error';
+            } finally {
+                setTimeout(() => {
+                    btn.textContent = originalText;
+                    btn.disabled = false;
+                }, 2000);
+            }
+        }
+
         function showBrowserInterface() {
             document.getElementById('browser-interface').style.display = 'block';
 

test_prompt.py

@@ -0,0 +1,39 @@
+
+import asyncio
+import os
+import logging
+from engine import AIEngine
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+async def main():
+    print("Initializing Engine...")
+    engine = AIEngine()
+    
+    # Mocking system prompt file if it doesn't exist (it should)
+    
+    print("\n--- Testing Chat ---")
+    try:
+        # We try 'opencode' because we know we settled auth for it, 
+        # OR we try 'g4f'/pollinations if they are easier.
+        # User reported issue on 'gemini-3-flash'.
+        # Let's try to mock the provider response handling to see what PROMPT it actually gets?
+        # Actually, we can just print the prompt in engine.py by adding a log.
+        
+        # But let's run a real request if possible.
+        # If not, at least we see if it crashes.
+        
+        response = await engine.chat(
+            prompt="Hello! Are you there?",
+            model="gemini", # Friendly name for gemini-pro or similar, mapped in config
+            provider="auto"
+        )
+        print(f"\nResponse: {response['response']}")
+        print(f"Model used: {response['model']}")
+        
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())