server.js

const express = require('express');
const { Pool } = require('pg');
const fetch = require('node-fetch');
const { exec } = require('child_process');

const app = express();
app.use(express.json());

// Set this in your environment variables
const TIGER_DATA_URL = process.env.TIGER_DATA_URL;

const pool = new Pool({ connectionString: TIGER_DATA_URL });

// --- AGENT TOOL IMPLEMENTATIONS ---

/**
 * Tool 1: Calls any external API.
 */
async function callExternalAPI(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) throw new Error(`API returned status ${response.status}`);
    const data = await response.json();
    return { success: true, data: data };
  } catch (error) {
    return { success: false, error: error.message };
  }
}

/**
 * Tool 2: Executes a *safe* SQL query.
 */
async function executeSQL(sqlQuery) {
  const forbiddenCommands = ['DROP DATABASE', 'GRANT', 'REVOKE'];
  if (forbiddenCommands.some(cmd => sqlQuery.toUpperCase().includes(cmd))) {
    return { success: false, error: 'Forbidden SQL command.' };
  }
  try {
    const client = await pool.connect();
    const result = await client.query(sqlQuery);
    client.release();
    return { success: true, result: result.rows };
  } catch (error) {
    return { success: false, error: error.message };
  }
}

/**
 * Tool 3: Creates a Tiger Data Zero-Copy Fork.
 */
async function createZeroCopyFork(forkName, sourceService) {
  const command = `tiger service fork create --name ${forkName} --from ${sourceService}`;
  return new Promise((resolve) => {
    exec(command, (error, stdout, stderr) => {
      if (error) { resolve({ success: false, error: stderr }); } 
      else { resolve({ success: true, output: `Fork ${forkName} created.` }); }
    });
  });
}

/**
 * Tool 4: Deletes a Tiger Data Fork.
 */
async function deleteFork(forkName) {
  const command = `tiger service fork delete --name ${forkName}`;
  return new Promise((resolve) => {
    exec(command, (error, stdout, stderr) => {
      if (error) { resolve({ success: false, error: stderr }); }
      else { resolve({ success: true, output: `Fork ${forkName} deleted.` }); }
    });
  });
}

/**
 * **NEW TOOL 5: Gets schema info to power your "Schema Viewer" tab.**
 */
async function getSchemaInfo(tableName) {
  const sqlQuery = `
    SELECT column_name, data_type, is_nullable
    FROM information_schema.columns
    WHERE table_name = $1
    ORDER BY ordinal_position;
  `;
  try {
    const client = await pool.connect();
    const result = await client.query(sqlQuery, [tableName]);
    client.release();
    return { success: true, schema: result.rows };
  } catch (error) {
    return { success: false, error: error.message };
  }
}

/**
 * **NEW TOOL 6: Gets monitoring data to power your "Dashboard" tab.**
 */
async function getMonitoringData() {
  // This query gets the daily average price, perfect for a chart.
  const sqlQuery = `
    SELECT 
      DATE_TRUNC('day', timestamp) AS date,
      AVG(price) AS average_price
    FROM bitcoin_prices
    GROUP BY date
    ORDER BY date ASC;
  `;
  try {
    const client = await pool.connect();
    const result = await client.query(sqlQuery);
    client.release();
    // Formats data perfectly for react-charts
    const chartData = [
      {
        label: 'Daily Average Price',
        data: result.rows.map(row => ({
          primary: new Date(row.date),
          secondary: parseFloat(row.average_price)
        }))
      }
    ];
    return { success: true, chartData: chartData };
  } catch (error) {
    return { success: false, error: error.message };
  }
}


// --- The Single API Endpoint for All Agents ---
app.post('/api/agent-tools', async (req, res) => {
  const { action, params } = req.body;
  let result;
  console.log(`[API] Received action: ${action} with params:`, params);

  try {
    switch (action) {
      case 'call_api':
        result = await callExternalAPI(params.url);
        break;
      case 'execute_sql':
        result = await executeSQL(params.sqlQuery);
        break;
T      case 'create_zero_copy_fork':
        result = await createZeroCopyFork(params.forkName, params.sourceService);
        break;
      case 'delete_fork':
        result = await deleteFork(params.forkName);
        break;
      // **NEW ENDPOINTS**
      case 'get_schema_info':
        result = await getSchemaInfo(params.tableName);
        break;
      case 'get_monitoring_data':
        result = await getMonitoringData();
        break;
      default:
        result = { success: false, error: 'Unknown action' };
    }
    res.json(result);
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

const PORT = process.env.PORT || 3001;
app.listen(PORT, () => {
  console.log(`Agents' "Hands" API listening on http://localhost:${PORT}`);
});