"""CodeGPT Web App — Flask + HTML/JS. Works on phone via Chrome."""
import json
import os
import time
from pathlib import Path
from flask import Flask, request, jsonify, Response, stream_with_context, render_template_string
import requests as http_requests
try:
from groq import Groq
HAS_GROQ = True
except ImportError:
HAS_GROQ = False
app = Flask(__name__)
GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "")
OLLAMA_URL = os.environ.get("OLLAMA_URL", "http://localhost:11434")
DEFAULT_MODEL = "llama-3.2-3b-preview"
OLLAMA_MODEL = "llama3.2"
PROVIDER = "groq" if (GROQ_API_KEY and HAS_GROQ) else "ollama"
THESYS_API_KEY = os.environ.get("THESYS_API_KEY", "")
THESYS_BASE_URL = os.environ.get("THESYS_BASE_URL", "https://api.thesys.dev/v1/embed")
THESYS_MODEL = os.environ.get("THESYS_MODEL", "c1/anthropic/claude-sonnet-4/v-20250815")
THESYS_TIMEOUT = 60
if THESYS_API_KEY:
from urllib.parse import urlparse as _urlparse
_parsed = _urlparse(THESYS_BASE_URL)
if _parsed.scheme != "https" or not _parsed.netloc:
print(f" [security] THESYS_BASE_URL must be https:// (got {_parsed.scheme!r}). GenUI disabled.")
THESYS_API_KEY = ""
SYSTEM_PROMPT = """You are an AI modeled after a highly technical, system-focused developer mindset.
Be direct, concise, and dense with information. No fluff, no filler, no emojis.
Give conclusions first, then minimal necessary explanation.
Blunt but intelligent. Slightly dark tone is acceptable.
Keep responses concise."""
PERSONAS = {
"Default": SYSTEM_PROMPT,
"Hacker": "You are a cybersecurity expert. Technical jargon, CVEs, attack vectors. Defensive security only. Concise.",
"Teacher": "You are a patient programming teacher. Step by step, analogies, examples. Concise.",
"Roast": "You are a brutally sarcastic code reviewer. Roast then fix. Dark humor. Concise.",
"Minimal": "Shortest possible answer. One line if possible. Code only.",
}
HTML = """
CodeGPT
CodeGPT
Ready
Settings
Checking server...
"""
SW_JS = """self.addEventListener('install', e => self.skipWaiting());
self.addEventListener('activate', e => e.waitUntil(clients.claim()));
self.addEventListener('fetch', e => e.respondWith(fetch(e.request).catch(() => new Response('Offline'))));"""
MANIFEST = """{
"name": "CodeGPT",
"short_name": "CodeGPT",
"description": "Local AI coding assistant",
"start_url": "/",
"display": "standalone",
"orientation": "portrait",
"background_color": "#0d1117",
"theme_color": "#0d1117",
"categories": ["productivity", "utilities"],
"icons": [
{"src": "/icon", "sizes": "192x192", "type": "image/svg+xml", "purpose": "any maskable"},
{"src": "/icon-512", "sizes": "512x512", "type": "image/svg+xml", "purpose": "any maskable"}
]
}"""
# --- Routes ---
@app.route("/")
def index():
return render_template_string(HTML)
@app.route("/sw.js")
def service_worker():
return Response(SW_JS, content_type="application/javascript")
@app.route("/manifest.json")
def manifest():
return Response(MANIFEST, content_type="application/json")
@app.route("/icon")
def icon():
svg = ''''''
return Response(svg, content_type="image/svg+xml")
@app.route("/icon-512")
def icon_512():
svg = ''''''
return Response(svg, content_type="image/svg+xml")
@app.route("/chat", methods=["POST"])
def chat_stream():
data = request.get_json()
msgs = data.get("messages", [])
persona = data.get("persona", "Default")
system = PERSONAS.get(persona, SYSTEM_PROMPT)
if not msgs:
return jsonify({"error": "No messages"}), 400
try:
if PROVIDER == "groq":
gen = _stream_groq(msgs, system)
else:
gen = _stream_ollama(msgs, system)
return Response(stream_with_context(gen), content_type="application/x-ndjson")
except Exception as e:
return jsonify({"error": str(e)}), 500
def _stream_groq(messages, system):
client = Groq(api_key=GROQ_API_KEY)
full_messages = [{"role": "system", "content": system}] + messages
completion = client.chat.completions.create(
model=DEFAULT_MODEL, messages=full_messages, stream=True, max_tokens=4096,
)
for chunk in completion:
delta = chunk.choices[0].delta
if delta and delta.content:
yield json.dumps({"content": delta.content, "done": False}) + "\n"
yield json.dumps({"content": "", "done": True, "provider": "groq", "stats": "groq cloud"}) + "\n"
def _stream_ollama(messages, system):
full_messages = [{"role": "system", "content": system}] + messages
response = http_requests.post(
f"{OLLAMA_URL}/api/chat",
json={"model": OLLAMA_MODEL, "messages": full_messages, "stream": True},
stream=True, timeout=120,
)
response.raise_for_status()
for line in response.iter_lines():
if not line:
continue
try:
chunk = json.loads(line)
except json.JSONDecodeError:
continue
content = chunk.get("message", {}).get("content", "")
done = chunk.get("done", False)
out = {"content": content, "done": done}
if done:
ec = chunk.get("eval_count", 0)
td = chunk.get("total_duration", 0)
ds = td / 1e9 if td else 0
tps = ec / ds if ds > 0 else 0
out["stats"] = f"{ec} tok | {ds:.1f}s | {tps:.0f} tok/s"
out["provider"] = "ollama"
yield json.dumps(out) + "\n"
@app.route("/health")
def health():
return jsonify({"status": "ok", "provider": PROVIDER})
@app.route("/genui-status")
def genui_status():
return jsonify({"configured": bool(THESYS_API_KEY)})
@app.route("/chat-genui", methods=["POST"])
def chat_genui():
if not THESYS_API_KEY:
return jsonify({"error": "THESYS_API_KEY not configured on server"}), 503
data = request.get_json() or {}
msgs = data.get("messages", [])
persona = data.get("persona", "Default")
if not msgs:
return jsonify({"error": "No messages"}), 400
system = PERSONAS.get(persona, SYSTEM_PROMPT)
full_messages = [{"role": "system", "content": system}] + msgs
try:
r = http_requests.post(
f"{THESYS_BASE_URL}/chat/completions",
headers={
"Authorization": f"Bearer {THESYS_API_KEY}",
"Content-Type": "application/json",
},
json={"model": THESYS_MODEL, "messages": full_messages, "stream": False},
timeout=THESYS_TIMEOUT,
)
r.raise_for_status()
payload = r.json()
choices = payload.get("choices")
if not isinstance(choices, list) or not choices or not isinstance(choices[0], dict):
print(" [genui] malformed Thesys response: missing/invalid choices")
return jsonify({"error": "Malformed upstream response"}), 502
message = choices[0].get("message") or {}
content = message.get("content", "") if isinstance(message, dict) else ""
return jsonify({"content": content, "provider": "thesys"})
except http_requests.HTTPError as e:
status = e.response.status_code if e.response is not None else 502
print(f" [genui] upstream HTTPError: {e}")
return jsonify({"error": "Upstream request failed"}), status
except http_requests.RequestException as e:
print(f" [genui] upstream RequestException: {e}")
return jsonify({"error": "Upstream request failed"}), 502
except ValueError as e:
print(f" [genui] JSON decode failure: {e}")
return jsonify({"error": "Malformed upstream response"}), 502
def generate_ssl_cert():
"""Generate self-signed SSL cert for HTTPS (required for PWA install)."""
cert_dir = Path.home() / ".codegpt" / "ssl"
cert_file = cert_dir / "cert.pem"
key_file = cert_dir / "key.pem"
if cert_file.exists() and key_file.exists():
return str(cert_file), str(key_file)
cert_dir.mkdir(parents=True, exist_ok=True)
try:
from OpenSSL import crypto
k = crypto.PKey()
k.generate_key(crypto.TYPE_RSA, 2048)
cert = crypto.X509()
cert.get_subject().CN = "CodeGPT"
cert.set_serial_number(1000)
cert.gmtime_adj_notBefore(0)
cert.gmtime_adj_notAfter(365 * 24 * 60 * 60) # 1 year
cert.set_issuer(cert.get_subject())
cert.set_pubkey(k)
cert.sign(k, "sha256")
cert_file.write_bytes(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))
key_file.write_bytes(crypto.dump_privatekey(crypto.FILETYPE_PEM, k))
return str(cert_file), str(key_file)
except ImportError:
print(" pyopenssl not installed. Running HTTP only (PWA install won't work).")
return None, None
if __name__ == "__main__":
import ssl
PORT = int(os.environ.get("PORT", 5050))
cert, key = generate_ssl_cert()
print(f"\n CodeGPT Web App")
print(f" Provider: {PROVIDER}")
if cert:
print(f" https://localhost:{PORT}")
print(f" https://192.168.1.237:{PORT} (open on phone)")
print(f" HTTPS enabled - PWA install ready")
else:
print(f" http://localhost:{PORT}")
print(f" http://192.168.1.237:{PORT} (open on phone)")
print()
if cert:
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.load_cert_chain(cert, key)
app.run(host="0.0.0.0", port=PORT, debug=False, ssl_context=context)
else:
app.run(host="0.0.0.0", port=PORT, debug=False)