decharge-scout 4.5.0 → 4.7.0

package/dashboard/api/agentone/fleet-submit.js

@@ -0,0 +1,112 @@
+/**
+ * Vercel API Endpoint - Fleet Data Submission
+ *
+ * POST /api/agentone/fleet-submit
+ * Receives fleet optimization data and stores it in Supabase
+ */
+
+import { createClient } from '@supabase/supabase-js';
+
+export const config = {
+  runtime: 'edge',
+};
+
+export default async function handler(req) {
+  // CORS headers
+  const headers = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type',
+    'Content-Type': 'application/json',
+  };
+
+  // Handle OPTIONS request for CORS
+  if (req.method === 'OPTIONS') {
+    return new Response(null, { status: 200, headers });
+  }
+
+  // Only allow POST
+  if (req.method !== 'POST') {
+    return new Response(
+      JSON.stringify({ error: 'Method not allowed' }),
+      { status: 405, headers }
+    );
+  }
+
+  try {
+    const data = await req.json();
+
+    // Validate required fields for fleet submissions
+    if (!data.type || data.type !== 'fleet') {
+      return new Response(
+        JSON.stringify({ error: 'Invalid submission type. Expected "fleet"' }),
+        { status: 400, headers }
+      );
+    }
+
+    if (!data.agent_name || !data.location || !data.timestamp || !data.fleet_size || !data.summary) {
+      return new Response(
+        JSON.stringify({ error: 'Missing required fields for fleet submission' }),
+        { status: 400, headers }
+      );
+    }
+
+    // Initialize Supabase client
+    const supabase = createClient(
+      process.env.SUPABASE_URL,
+      process.env.SUPABASE_ANON_KEY
+    );
+
+    // Insert fleet submission
+    const { error: fleetError } = await supabase
+      .from('fleet_submissions')
+      .insert({
+        agent_name: data.agent_name,
+        wallet: data.wallet,
+        location: data.location,
+        timestamp: new Date(data.timestamp).toISOString(),
+        fleet_size: data.fleet_size,
+        total_distance_km: data.summary.total_distance_km,
+        total_cost_usd: data.summary.total_cost_usd,
+        savings_percent: data.summary.savings_percent,
+        co2_saved_kg: data.summary.co2_saved_kg,
+        duration_hours: data.summary.duration_hours,
+        route_geojson: data.route,
+        stops: data.stops,
+        simulation_basis: data.simulation_basis || 'weather-based simulation',
+      });
+
+    if (fleetError) throw fleetError;
+
+    // Update agent heartbeat (upsert)
+    const { error: heartbeatError } = await supabase
+      .from('agent_heartbeat')
+      .upsert(
+        {
+          agent_name: data.agent_name,
+          location: data.location,
+          last_seen: new Date().toISOString(),
+        },
+        { onConflict: 'agent_name' }
+      );
+
+    if (heartbeatError) throw heartbeatError;
+
+    return new Response(
+      JSON.stringify({
+        success: true,
+        message: 'Fleet data submitted successfully',
+      }),
+      { status: 200, headers }
+    );
+  } catch (error) {
+    console.error('Fleet submission error:', error);
+    return new Response(
+      JSON.stringify({
+        error: 'Internal server error',
+        message: error.message,
+      }),
+      { status: 500, headers }
+    );
+  }
+}

package/dashboard/lib/schema.sql

@@ -65,3 +65,39 @@ FROM agent_submissions
 WHERE created_at > NOW() - INTERVAL '24 hours'
 GROUP BY DATE_TRUNC('hour', created_at)
 ORDER BY hour DESC;
+
+-- Table: fleet_submissions
+-- Stores fleet optimization submissions
+CREATE TABLE IF NOT EXISTS fleet_submissions (
+  id SERIAL PRIMARY KEY,
+  agent_name VARCHAR(255) NOT NULL,
+  wallet VARCHAR(255),
+  location VARCHAR(255) NOT NULL,
+  timestamp TIMESTAMP NOT NULL,
+  fleet_size INTEGER NOT NULL,
+  total_distance_km INTEGER NOT NULL,
+  total_cost_usd DECIMAL(10, 2) NOT NULL,
+  savings_percent INTEGER NOT NULL,
+  co2_saved_kg INTEGER NOT NULL,
+  duration_hours INTEGER NOT NULL,
+  route_geojson JSONB,
+  stops JSONB,
+  simulation_basis VARCHAR(255),
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Indexes for fleet queries
+CREATE INDEX idx_fleet_created_at ON fleet_submissions(created_at DESC);
+CREATE INDEX idx_fleet_agent ON fleet_submissions(agent_name);
+CREATE INDEX idx_fleet_location ON fleet_submissions(location);
+
+-- View: Fleet stats (last 24h)
+CREATE OR REPLACE VIEW fleet_stats_daily AS
+SELECT
+  COUNT(*) as total_fleets,
+  SUM(fleet_size) as total_vehicles,
+  SUM(total_distance_km) as total_distance,
+  AVG(savings_percent) as avg_savings,
+  SUM(co2_saved_kg) as total_co2_saved
+FROM fleet_submissions
+WHERE created_at > NOW() - INTERVAL '24 hours';

package/dashboard/vercel.json

@@ -10,6 +10,10 @@
       "src": "/api/stats",
       "dest": "/api/stats.js"
     },
+    {
+      "src": "/api/agentone/fleet-submit",
+      "dest": "/api/agentone/fleet-submit.js"
+    },
     {
       "src": "/(.*)",
       "dest": "/public/index.html"

package/index.js

@@ -511,7 +511,7 @@ async function runQueryCycle(wallet, agentName, location, options) {
       // Submit to DeCharge Scout dashboard
       try {
         const dashboardSpinner = ora('Submitting to DeCharge Scout dashboard...').start();
-        const apiUrl = 'https://decharge-scout.vercel.app/api/agentone/submit';
+        const apiUrl = 'https://decharge-scout.vercel.app/api/submit';
 
         console.log(chalk.blue(`\n🌐 Dashboard API URL: ${apiUrl}`));
         console.log(chalk.gray(`📤 Submitting data...`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decharge-scout",
-  "version": "4.5.0",
+  "version": "4.7.0",
   "description": "Global Energy Scout - Weather-powered intelligent energy price forecasting with Solana integration",
   "main": "index.js",
   "type": "module",

package/src/oracle.js

@@ -123,7 +123,26 @@ export async function submitToOracle(wallet, submissionData) {
  * Anonymize submission data
  */
 function anonymizeData(data) {
-  // Create anonymized version
+  // Check if this is a fleet submission or regular submission
+  if (data.type === 'fleet') {
+    // Fleet submission - different structure
+    return {
+      agent_id: hashString(data.agent_name),
+      location_region: generalizeLocation(data.location),
+      timestamp: data.timestamp,
+      type: 'fleet',
+      fleet_size: data.fleet_size,
+      summary: {
+        ...data.summary,
+        // Round values to reduce precision
+        total_cost_usd: parseFloat(data.summary.total_cost_usd.toFixed(2)),
+        savings_percent: Math.round(data.summary.savings_percent)
+      },
+      stops_count: data.stops?.length || 0
+    };
+  }
+
+  // Regular scout submission
   const anonymized = {
     agent_id: hashString(data.agent_name), // Hash the agent name
     location_region: generalizeLocation(data.location), // Generalize location

package/src/weather-data.js

@@ -136,11 +136,39 @@ const KNOWN_CITIES = {
   'dallas': { latitude: 32.776, longitude: -96.797, name: 'Dallas', country: 'United States', timezone: 'America/Chicago' },
 };
 
+/**
+ * Get weather data for coordinates directly
+ * Used by fleet module for intermediate route points
+ */
+export async function getWeatherForCoordinates(latitude, longitude) {
+  // Get weather forecast directly without geocoding
+  const forecast = await fetchWeatherForecast(latitude, longitude, 'auto');
+
+  return {
+    location: {
+      latitude,
+      longitude,
+      name: `${latitude.toFixed(2)},${longitude.toFixed(2)}`,
+      country: 'ROUTE',
+      timezone: 'auto'
+    },
+    forecast
+  };
+}
+
 /**
  * Get weather data for a location
  * Throws error if geocoding fails - caller should handle user interaction
  */
 export async function getWeatherForLocation(location) {
+  // Check if location is already in coordinate format (lat,lon)
+  const coordMatch = location.match(/^(-?\d+\.?\d*),\s*(-?\d+\.?\d*)$/);
+  if (coordMatch) {
+    const lat = parseFloat(coordMatch[1]);
+    const lon = parseFloat(coordMatch[2]);
+    return getWeatherForCoordinates(lat, lon);
+  }
+
   // Try geocoding - throw error if fails
   const coords = await getCoordinatesFromLocation(location);
   console.log(`📍 Location: ${coords.name}, ${coords.country} (${coords.latitude}, ${coords.longitude})`);

package/test-api.js

@@ -10,8 +10,8 @@
 import fetch from 'node-fetch';
 import chalk from 'chalk';
 
-const DASHBOARD_API_URL = 'https://decharge-scout.vercel.app/agentone/api/submit';
-const STATS_API_URL = 'https://decharge-scout.vercel.app/agentone/api/stats';
+const DASHBOARD_API_URL = 'https://decharge-scout.vercel.app/api/submit';
+const STATS_API_URL = 'https://decharge-scout.vercel.app/api/stats';
 
 // Sample test data
 const testData = {

package/test-both-apis.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+
+/**
+ * Comprehensive API Test Script
+ *
+ * Tests both regular submit and fleet-submit endpoints
+ */
+
+import fetch from 'node-fetch';
+import chalk from 'chalk';
+
+const SUBMIT_API_URL = 'https://decharge-scout.vercel.app/api/submit';
+const FLEET_SUBMIT_API_URL = 'https://decharge-scout.vercel.app/api/agentone/fleet-submit';
+const STATS_API_URL = 'https://decharge-scout.vercel.app/api/stats';
+
+// Sample regular submission data
+const regularSubmissionData = {
+  agent_name: `TestAgent-${Math.random().toString(36).substring(7).toUpperCase()}`,
+  location: 'Test City, TX, US',
+  timestamp: Date.now(),
+  results: {
+    cheapest_window: '2AM-3AM',
+    price: 0.0299,
+    savings: 75.5,
+    data_points: 24
+  }
+};
+
+// Sample fleet submission data
+const fleetSubmissionData = {
+  type: 'fleet',
+  agent_name: `FleetAgent-${Math.random().toString(36).substring(7).toUpperCase()}`,
+  wallet: 'TestWallet123',
+  location: 'New York → Boston',
+  timestamp: Date.now(),
+  fleet_size: 10,
+  route: {
+    type: 'LineString',
+    coordinates: [
+      [-74.0060, 40.7128], // New York
+      [-71.0589, 42.3601]  // Boston
+    ]
+  },
+  stops: [
+    {
+      lat: 41.5,
+      lon: -72.5,
+      time: '3AM-4AM',
+      price: 0.025,
+      savings: 80,
+      location: 'Hartford, CT',
+      segmentId: 1
+    }
+  ],
+  summary: {
+    total_distance_km: 350,
+    total_cost_usd: 150.00,
+    savings_percent: 78,
+    co2_saved_kg: 45,
+    duration_hours: 4
+  },
+  simulation_basis: 'Test simulation'
+};
+
+console.log(chalk.cyan.bold('\n🧪 Comprehensive API Test Suite\n'));
+console.log(chalk.gray('=' .repeat(60)));
+
+/**
+ * Test 1: Regular Submit Endpoint
+ */
+async function testRegularSubmit() {
+  console.log(chalk.blue('\n📝 TEST 1: Regular Submit Endpoint'));
+  console.log(chalk.gray(`   URL: ${SUBMIT_API_URL}`));
+  console.log(chalk.gray(`   Agent: ${regularSubmissionData.agent_name}`));
+
+  try {
+    const response = await fetch(SUBMIT_API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(regularSubmissionData)
+    });
+
+    const responseText = await response.text();
+
+    console.log(chalk.blue(`\n   📥 Status: ${response.status}`));
+    console.log(chalk.blue(`   📥 Response: ${responseText}`));
+
+    if (response.ok) {
+      console.log(chalk.green('\n   ✅ Regular submit: PASS'));
+      return { success: true, agent: regularSubmissionData.agent_name };
+    } else {
+      console.log(chalk.red('\n   ❌ Regular submit: FAIL'));
+      return { success: false, error: responseText };
+    }
+  } catch (error) {
+    console.log(chalk.red(`\n   ❌ Error: ${error.message}`));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Test 2: Fleet Submit Endpoint
+ */
+async function testFleetSubmit() {
+  console.log(chalk.blue('\n\n🚛 TEST 2: Fleet Submit Endpoint'));
+  console.log(chalk.gray(`   URL: ${FLEET_SUBMIT_API_URL}`));
+  console.log(chalk.gray(`   Agent: ${fleetSubmissionData.agent_name}`));
+  console.log(chalk.gray(`   Fleet size: ${fleetSubmissionData.fleet_size} EVs`));
+
+  try {
+    const response = await fetch(FLEET_SUBMIT_API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(fleetSubmissionData)
+    });
+
+    const responseText = await response.text();
+
+    console.log(chalk.blue(`\n   📥 Status: ${response.status}`));
+    console.log(chalk.blue(`   📥 Response: ${responseText}`));
+
+    if (response.ok) {
+      console.log(chalk.green('\n   ✅ Fleet submit: PASS'));
+      return { success: true, agent: fleetSubmissionData.agent_name };
+    } else {
+      console.log(chalk.red('\n   ❌ Fleet submit: FAIL'));
+      return { success: false, error: responseText };
+    }
+  } catch (error) {
+    console.log(chalk.red(`\n   ❌ Error: ${error.message}`));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Test 3: Stats Endpoint
+ */
+async function testStats() {
+  console.log(chalk.blue('\n\n📊 TEST 3: Stats Endpoint'));
+  console.log(chalk.gray(`   URL: ${STATS_API_URL}`));
+
+  try {
+    const response = await fetch(STATS_API_URL);
+    const data = await response.json();
+
+    console.log(chalk.blue(`\n   📥 Status: ${response.status}`));
+
+    if (response.ok) {
+      console.log(chalk.green('\n   ✅ Stats endpoint: PASS'));
+      console.log(chalk.magenta(`   📊 Active Agents: ${data.activeAgents}`));
+      console.log(chalk.magenta(`   📊 Total Submissions: ${data.totalSubmissions}`));
+      console.log(chalk.magenta(`   📊 Locations tracked: ${data.locations?.length || 0}`));
+      return { success: true, data };
+    } else {
+      console.log(chalk.red('\n   ❌ Stats endpoint: FAIL'));
+      return { success: false, error: await response.text() };
+    }
+  } catch (error) {
+    console.log(chalk.red(`\n   ❌ Error: ${error.message}`));
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Main test runner
+ */
+async function main() {
+  console.log(chalk.yellow('\n🚀 Starting comprehensive API tests...\n'));
+
+  // Run all tests
+  const regularResult = await testRegularSubmit();
+  await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds
+
+  const fleetResult = await testFleetSubmit();
+  await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds
+
+  const statsResult = await testStats();
+
+  // Summary
+  console.log(chalk.gray('\n' + '=' .repeat(60)));
+  console.log(chalk.cyan.bold('\n📋 Test Summary:\n'));
+
+  console.log(regularResult.success
+    ? chalk.green('   ✅ Regular submit endpoint: PASS')
+    : chalk.red('   ❌ Regular submit endpoint: FAIL'));
+
+  console.log(fleetResult.success
+    ? chalk.green('   ✅ Fleet submit endpoint: PASS')
+    : chalk.red('   ❌ Fleet submit endpoint: FAIL'));
+
+  console.log(statsResult.success
+    ? chalk.green('   ✅ Stats endpoint: PASS')
+    : chalk.red('   ❌ Stats endpoint: FAIL'));
+
+  const allPassed = regularResult.success && fleetResult.success && statsResult.success;
+
+  if (allPassed) {
+    console.log(chalk.green.bold('\n🎉 All tests passed! Both endpoints are working!\n'));
+    console.log(chalk.blue('   🌐 View dashboard: https://decharge-scout.vercel.app/agentone\n'));
+    console.log(chalk.yellow('   📝 Check Supabase for:'));
+    console.log(chalk.gray(`      - Regular submission: ${regularResult.agent}`));
+    console.log(chalk.gray(`      - Fleet submission: ${fleetResult.agent}\n`));
+  } else {
+    console.log(chalk.red.bold('\n⚠️  Some tests failed. Check errors above.\n'));
+
+    if (!regularResult.success || !fleetResult.success) {
+      console.log(chalk.yellow('   Common issues:'));
+      console.log(chalk.gray('   1. Supabase tables not created (run schema.sql)'));
+      console.log(chalk.gray('   2. Missing Vercel environment variables'));
+      console.log(chalk.gray('   3. Need to redeploy Vercel after changes'));
+      console.log(chalk.gray('   4. Check Vercel logs: vercel logs\n'));
+    }
+  }
+
+  console.log(chalk.gray('=' .repeat(60) + '\n'));
+}
+
+main().catch(error => {
+  console.error(chalk.red('Fatal error:'), error);
+  process.exit(1);
+});

package/test-live-apis.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+/**
+ * Simple Live API Test - Hit both endpoints
+ */
+
+import https from 'https';
+
+const SUBMIT_API = 'https://decharge-scout.vercel.app/api/submit';
+const FLEET_API = 'https://decharge-scout.vercel.app/api/agentone/fleet-submit';
+
+// Test data for regular submit
+const regularData = {
+  agent_name: `TestAgent-${Date.now()}`,
+  location: 'Test City, TX, US',
+  timestamp: Date.now(),
+  results: {
+    cheapest_window: '2AM-3AM',
+    price: 0.0299,
+    savings: 75.5,
+    data_points: 24
+  }
+};
+
+// Test data for fleet submit
+const fleetData = {
+  type: 'fleet',
+  agent_name: `FleetAgent-${Date.now()}`,
+  wallet: 'TestWallet123',
+  location: 'New York → Boston',
+  timestamp: Date.now(),
+  fleet_size: 10,
+  route: {
+    type: 'LineString',
+    coordinates: [[-74.0060, 40.7128], [-71.0589, 42.3601]]
+  },
+  stops: [{
+    lat: 41.5,
+    lon: -72.5,
+    time: '3AM-4AM',
+    price: 0.025,
+    savings: 80,
+    location: 'Hartford, CT',
+    segmentId: 1
+  }],
+  summary: {
+    total_distance_km: 350,
+    total_cost_usd: 150.00,
+    savings_percent: 78,
+    co2_saved_kg: 45,
+    duration_hours: 4
+  },
+  simulation_basis: 'Test simulation'
+};
+
+function hitAPI(url, data, name) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const postData = JSON.stringify(data);
+
+    const options = {
+      hostname: urlObj.hostname,
+      path: urlObj.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(postData)
+      }
+    };
+
+    console.log(`\n🔵 Testing ${name}...`);
+    console.log(`   URL: ${url}`);
+    console.log(`   Data: ${JSON.stringify(data, null, 2).substring(0, 200)}...`);
+
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        console.log(`\n   Status: ${res.statusCode}`);
+        console.log(`   Response: ${body}`);
+
+        if (res.statusCode === 200 || res.statusCode === 201) {
+          console.log(`   ✅ ${name} PASSED`);
+          resolve({ success: true, status: res.statusCode, body });
+        } else {
+          console.log(`   ❌ ${name} FAILED`);
+          resolve({ success: false, status: res.statusCode, body });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      console.log(`   ❌ ${name} ERROR: ${error.message}`);
+      reject(error);
+    });
+
+    req.write(postData);
+    req.end();
+  });
+}
+
+async function main() {
+  console.log('🧪 Testing Both APIs\n');
+  console.log('='.repeat(60));
+
+  try {
+    // Test 1: Regular Submit
+    const regularResult = await hitAPI(SUBMIT_API, regularData, 'Regular Submit API');
+
+    // Wait 2 seconds
+    await new Promise(r => setTimeout(r, 2000));
+
+    // Test 2: Fleet Submit
+    const fleetResult = await hitAPI(FLEET_API, fleetData, 'Fleet Submit API');
+
+    // Summary
+    console.log('\n' + '='.repeat(60));
+    console.log('\n📊 RESULTS:\n');
+    console.log(regularResult.success ? '✅ Regular Submit: WORKING' : '❌ Regular Submit: FAILED');
+    console.log(fleetResult.success ? '✅ Fleet Submit: WORKING' : '❌ Fleet Submit: FAILED');
+
+    if (regularResult.success && fleetResult.success) {
+      console.log('\n🎉 Both APIs are working correctly!\n');
+    } else {
+      console.log('\n⚠️  Some APIs failed - check errors above\n');
+    }
+
+  } catch (error) {
+    console.error('\n❌ Fatal error:', error.message);
+  }
+}
+
+main();