Update app.js

app.js

@@ -1,84 +1,264 @@
-const express = require('express');
-const cors = require('cors');
-// require('dotenv').config();
+import express from 'express';
+import dotenv from 'dotenv';
+import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
+import { AzureOpenAI } from "openai";
 
-const { hydrateMemory, searchTools } = require('./db');
-const { runSmartScraper } = require('./scraper');
-const { formatResponse } = require('./translator');
+dotenv.config();
 
 const app = express();
+const PORT = process.env.PORT || 7860;
+
 app.use(express.json());
-app.use(cors()); // Allow requests from any frontend
-
-// 1. The Runtime Search API (Public)
-// POST /v1/search
-app.post('/v1/search', (req, res) => {
-    const { query, format, limit = 5 } = req.body;
-  
-    if (!query) {
-        return res.status(400).json({ error: "Query is required" });
+
+// --- 1. INITIALIZE AI CLIENTS ---
+
+// AWS Bedrock Client (For Claude)
+const bedrockClient = new BedrockRuntimeClient({
+    region: process.env.AWS_REGION || "us-east-1",
+    credentials: {
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
     }
+});
 
-    // A. Fast In-Memory Search
-    // We fetch a bit more than needed to filter for quality later
-    let results = searchTools(query);
-
-    // Sort by "Stars" (Rudimentary Reputation V1)
-    results.sort((a, b) => (b.stats?.stars || 0) - (a.stats?.stars || 0));
-
-    // Slice to limit
-    const topResults = results.slice(0, limit);
-
-    // B. Apply Translation
-    const formattedTools = topResults.map(tool => formatResponse(tool, format));
-
-    // C. Log Analytics (Async - don't await)
-    // TODO: Increment 'views' count in Firestore for these tool IDs
-    
-    res.json({
-        meta: {
-            query,
-            count: formattedTools.length,
-            target_format: format || 'agentq-json'
-        },
-        tools: formattedTools
-    });
+// Azure OpenAI Client (For GPT-5 Mini)
+const azureClient = new AzureOpenAI({
+    endpoint: process.env.AZURE_OPENAI_ENDPOINT,
+    apiKey: process.env.AZURE_OPENAI_API_KEY,
+    apiVersion: "2026-01-01-preview", // Current 2026 API version
+    deployment: process.env.AZURE_OPENAI_DEPLOYMENT || "gpt-5-mini"
 });
 
-// 2. The Fire-and-Forget Scraper Trigger (Admin Only)
-// POST /admin/trigger-scrape
-app.post('/admin/trigger-scrape', (req, res) => {
-    
-  /* const secret = req.headers['x-admin-secret'];
-    
-    if (secret !== 
-       // process.env.
-        ADMIN_SECRET) {
-        return res.status(401).json({ error: "Unauthorized" });
+// --- 2. AI ROUTING LOGIC ---
+
+async function callClaudeOnBedrock(prompt) {
+    try {
+        const command = new ConverseCommand({
+            // Using the standard Bedrock model ID format for Sonnet
+            modelId: "anthropic.claude-4-6-sonnet-v1:0", 
+            messages:
+                }
+            ],
+            inferenceConfig: {
+                maxTokens: 4096,
+                temperature: 0.2
+            }
+        });
+
+        const response = await bedrockClient.send(command);
+        return response.output.message.content.text;
+    } catch (error) {
+        console.error("AWS Bedrock Error:", error);
+        throw new Error(`Bedrock Error: ${error.message}`);
+    }
+}
+
+async function callGptOnAzure(prompt) {
+    try {
+        const response = await azureClient.chat.completions.create({
+            messages:,
+            temperature: 0.2,
+            max_tokens: 4096
+        });
+
+        return response.choices.message.content;
+    } catch (error) {
+        console.error("Azure OpenAI Error:", error);
+        throw new Error(`Azure Error: ${error.message}`);
+    }
+}
+
+// --- 3. API ENDPOINTS ---
+
+app.post('/api/generate', async (req, res) => {
+    const { model, prompt } = req.body;
+
+    if (!prompt) {
+        return res.status(400).json({ error: "Prompt is required." });
+    }
+
+    try {
+        let aiResponse = "";
+        const startTime = Date.now();
+
+        if (model === "claude-sonnet") {
+            aiResponse = await callClaudeOnBedrock(prompt);
+        } else if (model === "gpt-mini") {
+            aiResponse = await callGptOnAzure(prompt);
+        } else {
+            return res.status(400).json({ error: "Invalid model selected." });
+        }
+
+        const latency = Date.now() - startTime;
+
+        res.json({
+            success: true,
+            model: model,
+            response: aiResponse,
+            latencyMs: latency
+        });
+
+    } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
     }
- */
-    console.log("🔥 Manual Scrape Triggered");
-
-    // EXECUTE WITHOUT AWAITING
-    // This allows the response to return immediately
-    runSmartScraper()
-        .then(() => console.log("✅ Background Job Finished"))
-        .catch(err => console.error("❌ Background Job Failed", err));
-
-    res.json({ 
-        status: "accepted", 
-        message: "Scraping job started in background." 
-    });
 });
 
-// Start Server
-const PORT = process.env.PORT || 7860;
-app.listen(PORT, async () => {
-    console.log(`🚀 AgentQ Core running on port ${PORT}`);
-    
-    // Initial Hydration on Boot
-    await hydrateMemory();
-    
-    // Optional: Run scraper on boot if DB is empty
-    // runSmartScraper();
+// --- 4. EMBEDDED HTML FRONTEND ---
+
+app.get('/', (req, res) => {
+    const html = `
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>Hollowpad Battle Arena</title>
+        <style>
+            body {
+                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                background-color: #121212;
+                color: #e0e0e0;
+                margin: 0;
+                padding: 40px;
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+            }
+            .container {
+                width: 100%;
+                max-width: 800px;
+                background: #1e1e1e;
+                padding: 30px;
+                border-radius: 12px;
+                box-shadow: 0 8px 16px rgba(0,0,0,0.5);
+            }
+            h1 { text-align: center; color: #4facfe; }
+            label { font-weight: bold; margin-top: 15px; display: block; }
+            select, textarea {
+                width: 100%;
+                padding: 12px;
+                margin-top: 8px;
+                background: #2a2a2a;
+                border: 1px solid #444;
+                color: #fff;
+                border-radius: 6px;
+                font-size: 16px;
+                box-sizing: border-box;
+            }
+            textarea { height: 150px; resize: vertical; font-family: monospace; }
+            button {
+                width: 100%;
+                padding: 15px;
+                margin-top: 20px;
+                background: linear-gradient(to right, #4facfe 0%, #00f2fe 100%);
+                border: none;
+                color: #000;
+                font-weight: bold;
+                font-size: 16px;
+                border-radius: 6px;
+                cursor: pointer;
+                transition: opacity 0.2s;
+            }
+            button:hover { opacity: 0.8; }
+            button:disabled { background: #555; cursor: not-allowed; }
+            .output-box {
+                margin-top: 30px;
+                background: #000;
+                padding: 20px;
+                border-radius: 6px;
+                border: 1px solid #333;
+                min-height: 100px;
+                white-space: pre-wrap;
+                font-family: 'Courier New', Courier, monospace;
+            }
+            .stats {
+                font-size: 12px;
+                color: #888;
+                margin-top: 10px;
+                text-align: right;
+            }
+            .loader {
+                display: none;
+                text-align: center;
+                margin-top: 20px;
+                color: #4facfe;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <h1>Hollowpad: Model Test Arena</h1>
+            
+            <label for="modelSelect">Select AI Model:</label>
+            <select id="modelSelect">
+                <option value="gpt-mini">GPT-5 Mini (Azure - Worker)</option>
+                <option value="claude-sonnet">Claude 4.6 Sonnet (AWS - Pro)</option>
+            </select>
+
+            <label for="promptInput">Enter Prompt:</label>
+            <textarea id="promptInput" placeholder="Write a Roblox DataStore script..."></textarea>
+
+            <button id="generateBtn" onclick="generate()">Run Test</button>
+            <div id="loader" class="loader">Generating response... Please wait.</div>
+
+            <label>Output:</label>
+            <div id="outputBox" class="output-box">Response will appear here...</div>
+            <div id="stats" class="stats"></div>
+        </div>
+
+        <script>
+            async function generate() {
+                const model = document.getElementById('modelSelect').value;
+                const prompt = document.getElementById('promptInput').value;
+                const btn = document.getElementById('generateBtn');
+                const loader = document.getElementById('loader');
+                const outputBox = document.getElementById('outputBox');
+                const stats = document.getElementById('stats');
+
+                if (!prompt.trim()) {
+                    alert('Please enter a prompt.');
+                    return;
+                }
+
+                // UI Loading State
+                btn.disabled = true;
+                loader.style.display = 'block';
+                outputBox.innerText = '';
+                stats.innerText = '';
+
+                try {
+                    const response = await fetch('/api/generate', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ model, prompt })
+                    });
+
+                    const data = await response.json();
+
+                    if (data.success) {
+                        outputBox.innerText = data.response;
+                        stats.innerText = \`Latency: \${(data.latencyMs / 1000).toFixed(2)}s\`;
+                    } else {
+                        outputBox.innerText = "Error: " + data.error;
+                    }
+                } catch (err) {
+                    outputBox.innerText = "Network Error: " + err.message;
+                } finally {
+                    // Reset UI
+                    btn.disabled = false;
+                    loader.style.display = 'none';
+                }
+            }
+        </script>
+    </body>
+    </html>
+    `;
+    res.send(html);
+});
+
+// --- 5. START SERVER ---
+app.listen(PORT, () => {
+    console.log(`🚀 Hollowpad Test Arena running at http://localhost:${PORT}`);
+    console.log(`Checking AWS Region: ${process.env.AWS_REGION}`);
+    console.log(`Checking Azure Endpoint: ${process.env.AZURE_OPENAI_ENDPOINT ? "Set" : "Missing"}`);
 });