Update server.js

server.js

@@ -1,13 +1,11 @@
 import express from 'express';
 import cors from 'cors';
-import { GoogleGenAI } from '@google/genai';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import sqlite3 from 'sqlite3';
 import bcrypt from 'bcryptjs';
 
 const app = express();
-// Hugging Face Spaces require port 7860
 const port = process.env.PORT || 7860;
 
 // --- Database Initialization ---
@@ -17,7 +15,6 @@ const dbPath = path.join(__dirname, 'database.db');
 const db = new sqlite3.Database(dbPath);
 
 db.serialize(() => {
-  // Users table
   db.run(`
     CREATE TABLE IF NOT EXISTS users (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -27,8 +24,6 @@ db.serialize(() => {
       created_at DATETIME DEFAULT CURRENT_TIMESTAMP
     )
   `);
-
-  // Messages table for Neural Memory
   db.run(`
     CREATE TABLE IF NOT EXISTS messages (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -41,188 +36,103 @@ db.serialize(() => {
   `);
 });
 
-// --- Simulated In-Memory Session Storage ---
 let activeSession = null;
 
-// --- Mock Citi Financial Data ---
+// Mock Citi Data
 const CITI_ACCOUNTS = {
-  accountGroupDetails: [
-    {
-      accountGroup: "CHECKING",
-      checkingAccountsDetails: [
-        {
-          productName: "Corporate Mastery Checking",
-          accountNickname: "Main Ops Node",
-          accountDescription: "Corporate Mastery Checking - 9594",
-          balanceType: "ASSET",
-          displayAccountNumber: "XXXXXX9594",
-          accountId: "citi_acc_99201",
-          currencyCode: "USD",
-          accountStatus: "ACTIVE",
-          currentBalance: 1245000.50,
-          availableBalance: 1240000.00
-        }
-      ],
-      totalCurrentBalance: { localCurrencyCode: "USD", localCurrencyBalanceAmount: 1245000.50 },
-      totalAvailableBalance: { localCurrencyCode: "USD", localCurrencyBalanceAmount: 1240000.00 }
-    }
-  ],
-  customer: {
-    customerId: "citi_cust_884102"
-  }
-};
-
-const CITI_TRANSACTIONS = {
-  "citi_acc_99201": {
-    checkingAccountTransactions: [
-      {
-        accountId: "citi_acc_99201",
-        currencyCode: "USD",
-        transactionAmount: -25000.00,
-        transactionDate: "2024-03-31",
-        transactionDescription: "NEURAL_NETWORK_COMPUTE_Q1_ALLOCATION",
-        transactionId: "TXN_C_884102",
-        transactionStatus: "POSTED",
-        transactionType: "PAYMENT",
-        displayAccountNumber: "XXXXXX9594"
-      }
-    ]
-  }
+  accountGroupDetails: [{
+    accountGroup: "CHECKING",
+    checkingAccountsDetails: [{
+      productName: "Corporate Mastery Checking",
+      accountNickname: "Main Ops Node",
+      accountDescription: "Corporate Mastery Checking - 9594",
+      balanceType: "ASSET",
+      displayAccountNumber: "XXXXXX9594",
+      accountId: "citi_acc_99201",
+      currencyCode: "USD",
+      accountStatus: "ACTIVE",
+      currentBalance: 1245000.50,
+      availableBalance: 1240000.00
+    }],
+    totalCurrentBalance: { localCurrencyCode: "USD", localCurrencyBalanceAmount: 1245000.50 },
+    totalAvailableBalance: { localCurrencyCode: "USD", localCurrencyBalanceAmount: 1240000.00 }
+  }],
+  customer: { customerId: "citi_cust_884102" }
 };
 
 app.use(cors());
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 
-// --- Authentication Endpoints ---
-
-app.get('/api/auth/me', (req, res) => {
-  if (activeSession) {
-    res.json({ isAuthenticated: true, user: activeSession });
-  } else {
-    res.status(401).json({ isAuthenticated: false, user: null });
-  }
-});
-
-app.post('/api/auth/register', async (req, res) => {
-  const { username, password } = req.body;
-  if (!username || !password) return res.status(400).json({ error: 'Identity credentials missing.' });
-
-  try {
-    const hash = await bcrypt.hash(password, 10);
-    db.run(
-      'INSERT INTO users (username, password_hash, role) VALUES (?, ?, ?)',
-      [username, hash, 'Root Admin'],
-      function(err) {
-        if (err) {
-          if (err.message.includes('UNIQUE')) {
-            return res.status(409).json({ error: 'Identity node already registered.' });
-          }
-          return res.status(500).json({ error: 'Registry write failure.' });
-        }
-        res.status(201).json({ success: true, userId: this.lastID });
-      }
-    );
-  } catch (error) {
-    res.status(500).json({ error: 'Encryption engine failure.' });
-  }
-});
-
+// Auth API
+app.get('/api/auth/me', (req, res) => res.json({ isAuthenticated: !!activeSession, user: activeSession }));
 app.post('/api/auth/login', (req, res) => {
   const { username, password } = req.body;
-  
   db.get('SELECT * FROM users WHERE username = ?', [username], async (err, user) => {
-    if (err || !user) {
-      return res.status(401).json({ success: false, message: 'Identity node rejected credentials.' });
-    }
-
+    if (err || !user) return res.status(401).json({ success: false, message: 'Invalid node' });
     const match = await bcrypt.compare(password, user.password_hash);
     if (match) {
-      activeSession = {
-        id: `USR-${user.id}`,
-        dbId: user.id, // Internal database ID for relations
-        name: user.username,
-        role: user.role,
-        lastLogin: new Date().toISOString()
-      };
+      activeSession = { id: `USR-${user.id}`, dbId: user.id, name: user.username, role: user.role, lastLogin: new Date().toISOString() };
       res.json({ success: true, user: activeSession });
     } else {
-      res.status(401).json({ success: false, message: 'Identity node rejected credentials.' });
+      res.status(401).json({ success: false });
     }
   });
 });
+app.post('/api/auth/logout', (req, res) => { activeSession = null; res.json({ success: true }); });
 
-app.post('/api/auth/logout', (req, res) => {
-  activeSession = null;
-  res.json({ success: true });
-});
-
-// --- Chat History Endpoints ---
-
-app.get('/api/chat/history', (req, res) => {
-  if (!activeSession) return res.status(401).json({ error: 'Session parity lost.' });
-  
-  db.all(
-    'SELECT * FROM messages WHERE user_id = ? ORDER BY timestamp ASC',
-    [activeSession.dbId],
-    (err, rows) => {
-      if (err) return res.status(500).json({ error: 'Neural memory retrieval failure.' });
-      res.json(rows);
-    }
-  );
-});
-
-// --- Gemini Proxy ---
+// Gemini REST Proxy (Using corsproxy.io and gemini-2.5-flash as requested)
 app.post('/api/gemini/generate', async (req, res) => {
   try {
-    const apiKey = process.env.GEMINI_API_KEY;
-    if (!apiKey) return res.status(500).json({ error: 'API Key missing' });
+    const apiKey = process.env.GEMINI_API_KEY || process.env.API_KEY;
     
-    const { model, contents, config, saveToMemory } = req.body;
-    const ai = new GoogleGenAI({ apiKey });
-    const response = await ai.models.generateContent({ 
-      model: model || 'gemini-3-flash-preview', 
-      contents, 
-      config: config || {}
+    if (!apiKey) {
+      console.error("GEMINI_API_KEY is missing");
+      return res.status(500).json({ error: 'GEMINI_API_KEY missing' });
+    }
+    
+    const { model, contents, config } = req.body;
+    const modelId = model || 'gemini-2.5-flash';
+    
+    const targetUrl = `https://generativelanguage.googleapis.com/v1beta/models/${modelId}:generateContent`;
+    const proxyUrl = `https://corsproxy.io/?url=${encodeURIComponent(targetUrl)}`;
+    
+    const response = await fetch(proxyUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-goog-api-key': apiKey
+      },
+      body: JSON.stringify({
+        contents: contents,
+        generationConfig: config || {}
+      })
     });
 
-    const aiText = response.text;
-
-    // Persist to memory if requested and authenticated
-    if (activeSession && saveToMemory && contents[0]?.parts[0]?.text) {
-      const userPrompt = contents[0].parts[0].text;
-      
-      // Save user prompt
-      db.run('INSERT INTO messages (user_id, role, content) VALUES (?, ?, ?)', [activeSession.dbId, 'user', userPrompt]);
-      // Save AI response
-      db.run('INSERT INTO messages (user_id, role, content) VALUES (?, ?, ?)', [activeSession.dbId, 'assistant', aiText]);
+    const data = await response.json();
+    
+    if (data.error) {
+      return res.status(response.status || 500).json({ error: data.error.message || 'Upstream Error' });
     }
 
-    res.json({ text: aiText, candidates: response.candidates });
+    const text = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    res.json({ text, candidates: data.candidates });
   } catch (error) {
-    res.status(500).json({ error: 'AI communication failure', details: error.message });
+    res.status(500).json({ error: error.message });
   }
 });
 
-const CITI_BASE = '/api/accounts/account-transactions/partner/v1';
-app.get(`${CITI_BASE}/accounts/details`, (req, res) => res.json(CITI_ACCOUNTS));
-app.get(`${CITI_BASE}/accounts/:accountId/transactions`, (req, res) => {
-  const { accountId } = req.params;
-  res.json(CITI_TRANSACTIONS[accountId] || { checkingAccountTransactions: [] });
-});
+// Citi Proxy
+app.get('/api/accounts/account-transactions/partner/v1/accounts/details', (req, res) => res.json(CITI_ACCOUNTS));
 
-// Serve frontend files from the dist directory
-app.use(express.static(path.join(__dirname, 'dist')));
+// Serve Frontend
+const __dist = path.join(__dirname, 'dist');
+app.use(express.static(__dist));
 
-// SPA Fallback: Catch any request that didn't match an API route or a static file.
-// In Express 5, using a middleware function without a path is the safest way 
-// to implement a catch-all fallback for Single Page Applications.
+// SPA Fallback
 app.use((req, res) => {
-  // Safeguard: Do not serve index.html for missing API routes
-  if (req.path.startsWith('/api')) {
-    return res.status(404).json({ error: 'API endpoint not found' });
-  }
-  res.sendFile(path.join(__dirname, 'dist', 'index.html'));
+  if (req.path.startsWith('/api')) return res.status(404).json({ error: 'Not found' });
+  res.sendFile(path.join(__dist, 'index.html'));
 });
 
-app.listen(port, '0.0.0.0', () => console.log(`Financial Node Proxy Operational on port ${port}`));
+app.listen(port, '0.0.0.0', () => console.log(`Operational on ${port}`));