decharge-scout 1.0.1 → 1.2.0

package/dashboard/README.md

@@ -0,0 +1,176 @@
+# DeCharge Scout Dashboard
+
+Real-time analytics dashboard for tracking DeCharge Scout agents worldwide.
+
+## Features
+
+- **Real-time Agent Tracking** - See how many agents are currently running
+- **Location Analytics** - View agent distribution across different locations
+- **Submission History** - Track all oracle submissions with prices and savings
+- **Live Updates** - Dashboard auto-refreshes every 30 seconds
+
+## Deployment to Vercel
+
+### Prerequisites
+
+1. [Vercel Account](https://vercel.com/signup)
+2. [Vercel CLI](https://vercel.com/cli) installed: `npm i -g vercel`
+
+### Step 1: Set Up Vercel Postgres Database
+
+1. Go to [Vercel Dashboard](https://vercel.com/dashboard)
+2. Create a new project or select existing one
+3. Go to "Storage" tab
+4. Click "Create Database" → Select "Postgres"
+5. Name it (e.g., `decharge-scout-db`)
+6. Wait for provisioning to complete
+
+### Step 2: Initialize Database Schema
+
+1. In your Vercel Postgres dashboard, click "Query" tab
+2. Copy and paste the contents of `lib/schema.sql`
+3. Click "Run Query" to create tables and views
+
+### Step 3: Deploy Dashboard
+
+```bash
+cd dashboard
+npm install
+vercel
+```
+
+Follow the prompts:
+- **Set up and deploy?** → Yes
+- **Which scope?** → Your account
+- **Link to existing project?** → No (unless you already created one)
+- **What's your project's name?** → `decharge-scout-dashboard`
+- **In which directory is your code located?** → `./`
+
+### Step 4: Link Postgres to Project
+
+```bash
+vercel env pull
+```
+
+This will create a `.env.local` file with your `POSTGRES_URL` automatically.
+
+### Step 5: Deploy to Production
+
+```bash
+vercel --prod
+```
+
+Your dashboard will be live at: `https://decharge-scout-dashboard.vercel.app`
+
+## Update CLI to Use Dashboard
+
+After deploying, update your `.env` file in the CLI project:
+
+```bash
+DASHBOARD_API_URL=https://your-dashboard-url.vercel.app/api/submit
+```
+
+## API Endpoints
+
+### POST `/api/submit`
+
+Submit agent data to the dashboard.
+
+**Request Body:**
+```json
+{
+  "agent_name": "Agent-ABC123",
+  "location": "Austin, TX, US",
+  "timestamp": 1234567890000,
+  "results": {
+    "cheapest_window": "5AM-6AM",
+    "price": 0.0338,
+    "savings": 71.7,
+    "data_points": 24
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Data submitted successfully"
+}
+```
+
+### GET `/api/stats`
+
+Get real-time statistics about agents.
+
+**Response:**
+```json
+{
+  "activeAgents": 5,
+  "totalSubmissions": 127,
+  "locations": [
+    {
+      "location": "Austin, TX, US",
+      "submissions": 45
+    }
+  ],
+  "recentSubmissions": [...],
+  "timestamp": "2024-01-15T10:30:00Z"
+}
+```
+
+## Local Development
+
+```bash
+npm install
+npm run dev
+```
+
+Visit http://localhost:3000 to see the dashboard.
+
+## Database Schema
+
+### Tables
+
+- **agent_heartbeat** - Tracks active agents (updated every submission)
+- **agent_submissions** - Stores all oracle submissions with full data
+
+### Views
+
+- **active_agents_hourly** - Agents active in the last hour
+- **submissions_by_location** - Aggregated stats by location
+- **hourly_submission_counts** - Time series of submissions
+
+## Troubleshooting
+
+**Error: "Internal server error"**
+- Check that `POSTGRES_URL` is configured in Vercel environment variables
+- Verify database tables are created using `lib/schema.sql`
+
+**No data showing**
+- Ensure CLI is configured with `DASHBOARD_API_URL` in `.env`
+- Check API endpoint is accessible: `curl https://your-url.vercel.app/api/stats`
+- Verify agents are running and submitting data
+
+**CORS errors**
+- API endpoints include `Access-Control-Allow-Origin: *` headers
+- If issues persist, check Vercel logs: `vercel logs`
+
+## Architecture
+
+```
+┌─────────────┐
+│ CLI Agents  │ → POST /api/submit → ┌──────────────┐
+│  (Multiple) │                      │  Vercel Edge │
+└─────────────┘                      │   Functions  │
+                                     └───────┬──────┘
+                                             ↓
+┌─────────────┐                      ┌──────────────┐
+│  Dashboard  │ ← GET /api/stats ←   │   Postgres   │
+│   (Admin)   │                      │   Database   │
+└─────────────┘                      └──────────────┘
+```
+
+## License
+
+MIT

package/dashboard/api/stats.js

@@ -0,0 +1,109 @@
+/**
+ * Vercel API Endpoint - Agent Statistics
+ *
+ * GET /api/stats
+ * Returns real-time statistics about active agents from 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': 'GET, 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 GET
+  if (req.method !== 'GET') {
+    return new Response(
+      JSON.stringify({ error: 'Method not allowed' }),
+      { status: 405, headers }
+    );
+  }
+
+  try {
+    // Initialize Supabase client
+    const supabase = createClient(
+      process.env.SUPABASE_URL,
+      process.env.SUPABASE_ANON_KEY
+    );
+
+    // Calculate time thresholds
+    const thirtyMinutesAgo = new Date(Date.now() - 30 * 60 * 1000).toISOString();
+    const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+
+    // Get active agents (last seen within 30 minutes)
+    const { data: activeAgents, error: activeError } = await supabase
+      .from('agent_heartbeat')
+      .select('agent_name', { count: 'exact', head: false })
+      .gt('last_seen', thirtyMinutesAgo);
+
+    if (activeError) throw activeError;
+
+    // Get total submissions in last 24 hours
+    const { count: submissionCount, error: submissionError } = await supabase
+      .from('agent_submissions')
+      .select('*', { count: 'exact', head: true })
+      .gt('created_at', twentyFourHoursAgo);
+
+    if (submissionError) throw submissionError;
+
+    // Get unique locations with submission counts
+    const { data: locationsData, error: locationsError } = await supabase
+      .from('agent_submissions')
+      .select('location')
+      .gt('created_at', twentyFourHoursAgo);
+
+    if (locationsError) throw locationsError;
+
+    // Aggregate locations manually
+    const locationMap = {};
+    locationsData.forEach(row => {
+      locationMap[row.location] = (locationMap[row.location] || 0) + 1;
+    });
+    const locations = Object.entries(locationMap)
+      .map(([location, submissions]) => ({ location, submissions }))
+      .sort((a, b) => b.submissions - a.submissions);
+
+    // Get recent submissions
+    const { data: recentSubmissions, error: recentError } = await supabase
+      .from('agent_submissions')
+      .select('agent_name, location, timestamp, cheapest_window, price, savings, created_at')
+      .order('created_at', { ascending: false })
+      .limit(20);
+
+    if (recentError) throw recentError;
+
+    return new Response(
+      JSON.stringify({
+        activeAgents: new Set(activeAgents.map(a => a.agent_name)).size,
+        totalSubmissions: submissionCount || 0,
+        locations: locations,
+        recentSubmissions: recentSubmissions,
+        timestamp: new Date().toISOString(),
+      }),
+      { status: 200, headers }
+    );
+  } catch (error) {
+    console.error('Stats error:', error);
+    return new Response(
+      JSON.stringify({
+        error: 'Internal server error',
+        message: error.message,
+      }),
+      { status: 500, headers }
+    );
+  }
+}

package/dashboard/api/submit.js

@@ -0,0 +1,99 @@
+/**
+ * Vercel API Endpoint - Agent Data Submission
+ *
+ * POST /api/submit
+ * Receives agent data submissions and stores them 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
+    if (!data.agent_name || !data.location || !data.timestamp || !data.results) {
+      return new Response(
+        JSON.stringify({ error: 'Missing required fields' }),
+        { status: 400, headers }
+      );
+    }
+
+    // Initialize Supabase client
+    const supabase = createClient(
+      process.env.SUPABASE_URL,
+      process.env.SUPABASE_ANON_KEY
+    );
+
+    // Insert submission
+    const { error: submissionError } = await supabase
+      .from('agent_submissions')
+      .insert({
+        agent_name: data.agent_name,
+        location: data.location,
+        timestamp: new Date(data.timestamp).toISOString(),
+        cheapest_window: data.results.cheapest_window,
+        price: data.results.price,
+        savings: data.results.savings,
+        data_points: data.results.data_points,
+      });
+
+    if (submissionError) throw submissionError;
+
+    // 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: 'Data submitted successfully',
+      }),
+      { status: 200, headers }
+    );
+  } catch (error) {
+    console.error('Submission error:', error);
+    return new Response(
+      JSON.stringify({
+        error: 'Internal server error',
+        message: error.message,
+      }),
+      { status: 500, headers }
+    );
+  }
+}

package/dashboard/lib/schema.sql

@@ -0,0 +1,67 @@
+-- DeCharge Scout Dashboard Database Schema
+-- Use this to initialize your Supabase Postgres database
+
+-- Table: agent_heartbeat
+-- Tracks which agents are currently active
+CREATE TABLE IF NOT EXISTS agent_heartbeat (
+  agent_name VARCHAR(255) PRIMARY KEY,
+  location VARCHAR(255) NOT NULL,
+  last_seen TIMESTAMP NOT NULL,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Index for querying active agents
+CREATE INDEX idx_heartbeat_last_seen ON agent_heartbeat(last_seen DESC);
+
+-- Table: agent_submissions
+-- Stores all data submissions from agents
+CREATE TABLE IF NOT EXISTS agent_submissions (
+  id SERIAL PRIMARY KEY,
+  agent_name VARCHAR(255) NOT NULL,
+  location VARCHAR(255) NOT NULL,
+  timestamp TIMESTAMP NOT NULL,
+  cheapest_window VARCHAR(50) NOT NULL,
+  price DECIMAL(10, 6) NOT NULL,
+  savings DECIMAL(5, 2) NOT NULL,
+  data_points INTEGER NOT NULL,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Indexes for analytics queries
+CREATE INDEX idx_submissions_created_at ON agent_submissions(created_at DESC);
+CREATE INDEX idx_submissions_agent ON agent_submissions(agent_name);
+CREATE INDEX idx_submissions_location ON agent_submissions(location);
+
+-- View: Active agents in the last hour
+CREATE OR REPLACE VIEW active_agents_hourly AS
+SELECT
+  agent_name,
+  location,
+  last_seen,
+  EXTRACT(EPOCH FROM (NOW() - last_seen)) / 60 as minutes_ago
+FROM agent_heartbeat
+WHERE last_seen > NOW() - INTERVAL '1 hour'
+ORDER BY last_seen DESC;
+
+-- View: Submissions summary by location (last 24h)
+CREATE OR REPLACE VIEW submissions_by_location AS
+SELECT
+  location,
+  COUNT(*) as total_submissions,
+  AVG(price) as avg_price,
+  AVG(savings) as avg_savings,
+  MAX(created_at) as latest_submission
+FROM agent_submissions
+WHERE created_at > NOW() - INTERVAL '24 hours'
+GROUP BY location
+ORDER BY total_submissions DESC;
+
+-- View: Hourly submission counts (last 24h)
+CREATE OR REPLACE VIEW hourly_submission_counts AS
+SELECT
+  DATE_TRUNC('hour', created_at) as hour,
+  COUNT(*) as submissions
+FROM agent_submissions
+WHERE created_at > NOW() - INTERVAL '24 hours'
+GROUP BY DATE_TRUNC('hour', created_at)
+ORDER BY hour DESC;

package/dashboard/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "dechargescout",
+  "version": "1.0.0",
+  "description": "Real-time analytics dashboard for DeCharge Scout agents",
+  "type": "module",
+  "scripts": {
+    "dev": "vercel dev",
+    "deploy": "vercel --prod"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.39.0"
+  },
+  "devDependencies": {
+    "vercel": "^33.0.0"
+  }
+}

package/dashboard/public/index.html

@@ -0,0 +1,377 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>DeCharge Scout - Admin Dashboard</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      min-height: 100vh;
+      padding: 20px;
+    }
+
+    .container {
+      max-width: 1400px;
+      margin: 0 auto;
+    }
+
+    .header {
+      text-align: center;
+      color: white;
+      margin-bottom: 40px;
+    }
+
+    .header h1 {
+      font-size: 3em;
+      margin-bottom: 10px;
+    }
+
+    .header p {
+      font-size: 1.2em;
+      opacity: 0.9;
+    }
+
+    .stats-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+      gap: 20px;
+      margin-bottom: 40px;
+    }
+
+    .stat-card {
+      background: white;
+      border-radius: 12px;
+      padding: 30px;
+      box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
+      transition: transform 0.3s ease;
+    }
+
+    .stat-card:hover {
+      transform: translateY(-5px);
+    }
+
+    .stat-card h3 {
+      color: #666;
+      font-size: 0.9em;
+      text-transform: uppercase;
+      letter-spacing: 1px;
+      margin-bottom: 10px;
+    }
+
+    .stat-card .value {
+      font-size: 3em;
+      font-weight: bold;
+      color: #667eea;
+    }
+
+    .stat-card .label {
+      color: #999;
+      margin-top: 5px;
+    }
+
+    .pulse {
+      animation: pulse 2s infinite;
+    }
+
+    @keyframes pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.7; }
+    }
+
+    .section {
+      background: white;
+      border-radius: 12px;
+      padding: 30px;
+      margin-bottom: 30px;
+      box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
+    }
+
+    .section h2 {
+      color: #333;
+      margin-bottom: 20px;
+      font-size: 1.8em;
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+    }
+
+    th, td {
+      text-align: left;
+      padding: 12px;
+      border-bottom: 1px solid #eee;
+    }
+
+    th {
+      background: #f8f9fa;
+      color: #666;
+      font-weight: 600;
+      text-transform: uppercase;
+      font-size: 0.85em;
+      letter-spacing: 0.5px;
+    }
+
+    tr:hover {
+      background: #f8f9fa;
+    }
+
+    .location-badge {
+      display: inline-block;
+      padding: 4px 12px;
+      background: #e3f2fd;
+      color: #1976d2;
+      border-radius: 12px;
+      font-size: 0.85em;
+      font-weight: 500;
+    }
+
+    .price {
+      color: #4caf50;
+      font-weight: 600;
+    }
+
+    .savings {
+      color: #ff9800;
+      font-weight: 600;
+    }
+
+    .loading {
+      text-align: center;
+      padding: 40px;
+      color: #999;
+    }
+
+    .error {
+      background: #ffebee;
+      color: #c62828;
+      padding: 20px;
+      border-radius: 8px;
+      margin-bottom: 20px;
+    }
+
+    .refresh-btn {
+      background: #667eea;
+      color: white;
+      border: none;
+      padding: 12px 24px;
+      border-radius: 8px;
+      font-size: 1em;
+      cursor: pointer;
+      transition: background 0.3s;
+    }
+
+    .refresh-btn:hover {
+      background: #764ba2;
+    }
+
+    .last-updated {
+      color: #999;
+      font-size: 0.9em;
+      margin-top: 10px;
+    }
+
+    .live-indicator {
+      display: inline-block;
+      width: 12px;
+      height: 12px;
+      background: #4caf50;
+      border-radius: 50%;
+      margin-right: 8px;
+      animation: pulse 2s infinite;
+    }
+
+    .map-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+      gap: 15px;
+      margin-top: 20px;
+    }
+
+    .location-card {
+      background: #f8f9fa;
+      padding: 15px;
+      border-radius: 8px;
+      border-left: 4px solid #667eea;
+    }
+
+    .location-card h4 {
+      color: #333;
+      margin-bottom: 8px;
+    }
+
+    .location-card .count {
+      font-size: 2em;
+      font-weight: bold;
+      color: #667eea;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h1>🔋 DeCharge Scout</h1>
+      <p>Real-Time Agent Analytics Dashboard</p>
+    </div>
+
+    <div id="error-container"></div>
+
+    <div class="stats-grid">
+      <div class="stat-card">
+        <h3>Active Agents</h3>
+        <div class="value pulse" id="active-agents">-</div>
+        <div class="label"><span class="live-indicator"></span>Live Now</div>
+      </div>
+
+      <div class="stat-card">
+        <h3>Total Submissions</h3>
+        <div class="value" id="total-submissions">-</div>
+        <div class="label">Last 24 Hours</div>
+      </div>
+
+      <div class="stat-card">
+        <h3>Unique Locations</h3>
+        <div class="value" id="unique-locations">-</div>
+        <div class="label">Worldwide Coverage</div>
+      </div>
+
+      <div class="stat-card">
+        <h3>Avg Savings</h3>
+        <div class="value" id="avg-savings">-</div>
+        <div class="label">Cost Reduction</div>
+      </div>
+    </div>
+
+    <div class="section">
+      <h2>📍 Agents by Location</h2>
+      <div id="locations-map" class="map-grid"></div>
+    </div>
+
+    <div class="section">
+      <h2>📊 Recent Submissions</h2>
+      <button class="refresh-btn" onclick="loadData()">Refresh Data</button>
+      <div class="last-updated" id="last-updated"></div>
+      <div id="submissions-container"></div>
+    </div>
+  </div>
+
+  <script>
+    const API_BASE = window.location.hostname === 'localhost'
+      ? 'http://localhost:3000'
+      : '';
+
+    async function loadData() {
+      try {
+        const response = await fetch(`${API_BASE}/api/stats`);
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const data = await response.json();
+
+        // Update stats
+        document.getElementById('active-agents').textContent = data.activeAgents || 0;
+        document.getElementById('total-submissions').textContent = data.totalSubmissions || 0;
+        document.getElementById('unique-locations').textContent = data.locations?.length || 0;
+
+        // Calculate average savings
+        const avgSavings = data.recentSubmissions?.length
+          ? (data.recentSubmissions.reduce((sum, s) => sum + parseFloat(s.savings), 0) / data.recentSubmissions.length).toFixed(1)
+          : 0;
+        document.getElementById('avg-savings').textContent = `${avgSavings}%`;
+
+        // Render locations map
+        renderLocationsMap(data.locations || []);
+
+        // Render submissions table
+        renderSubmissionsTable(data.recentSubmissions || []);
+
+        // Update timestamp
+        document.getElementById('last-updated').textContent =
+          `Last updated: ${new Date().toLocaleTimeString()}`;
+
+        // Clear errors
+        document.getElementById('error-container').innerHTML = '';
+      } catch (error) {
+        console.error('Error loading data:', error);
+        document.getElementById('error-container').innerHTML =
+          `<div class="error">⚠️ Error loading data: ${error.message}. Make sure the API is deployed and POSTGRES_URL is configured.</div>`;
+      }
+    }
+
+    function renderLocationsMap(locations) {
+      const container = document.getElementById('locations-map');
+
+      if (locations.length === 0) {
+        container.innerHTML = '<div class="loading">No location data available</div>';
+        return;
+      }
+
+      container.innerHTML = locations.map(loc => `
+        <div class="location-card">
+          <h4>${escapeHtml(loc.location)}</h4>
+          <div class="count">${loc.submissions}</div>
+          <div class="label">submissions</div>
+        </div>
+      `).join('');
+    }
+
+    function renderSubmissionsTable(submissions) {
+      const container = document.getElementById('submissions-container');
+
+      if (submissions.length === 0) {
+        container.innerHTML = '<div class="loading">No submissions yet</div>';
+        return;
+      }
+
+      container.innerHTML = `
+        <table>
+          <thead>
+            <tr>
+              <th>Agent</th>
+              <th>Location</th>
+              <th>Cheapest Window</th>
+              <th>Price</th>
+              <th>Savings</th>
+              <th>Time</th>
+            </tr>
+          </thead>
+          <tbody>
+            ${submissions.map(s => `
+              <tr>
+                <td><strong>${escapeHtml(s.agent_name)}</strong></td>
+                <td><span class="location-badge">${escapeHtml(s.location)}</span></td>
+                <td>${escapeHtml(s.cheapest_window)}</td>
+                <td class="price">$${parseFloat(s.price).toFixed(4)}/kWh</td>
+                <td class="savings">${parseFloat(s.savings).toFixed(1)}%</td>
+                <td>${new Date(s.created_at).toLocaleString()}</td>
+              </tr>
+            `).join('')}
+          </tbody>
+        </table>
+      `;
+    }
+
+    function escapeHtml(text) {
+      const div = document.createElement('div');
+      div.textContent = text;
+      return div.innerHTML;
+    }
+
+    // Initial load
+    loadData();
+
+    // Auto-refresh every 30 seconds
+    setInterval(loadData, 30000);
+  </script>
+</body>
+</html>

package/dashboard/vercel.json

@@ -0,0 +1,18 @@
+{
+  "version": 2,
+  "buildCommand": "echo 'No build needed'",
+  "routes": [
+    {
+      "src": "/api/submit",
+      "dest": "/api/submit.js"
+    },
+    {
+      "src": "/api/stats",
+      "dest": "/api/stats.js"
+    },
+    {
+      "src": "/(.*)",
+      "dest": "/public/index.html"
+    }
+  ]
+}

package/index.js

@@ -168,12 +168,42 @@ async function main(options) {
     console.log(chalk.blue(`🤖 Agent Name: ${agentName}`));
 
     // Get location
-    const locationSpinner = ora('Detecting location...').start();
     let location = options.location;
     if (!location) {
-      location = await getLocation();
+      const locationSpinner = ora('Detecting location via IP...').start();
+      const detectedLocation = await getLocation();
+      locationSpinner.succeed(chalk.green(`📍 Detected Location: ${detectedLocation}`));
+
+      // Ask user to confirm or override (with timeout)
+      console.log(chalk.blue('\nYou can use this location or enter a custom one.'));
+      console.log(chalk.gray('(Press Enter to use detected location, or type custom location)'));
+
+      try {
+        // Create a promise that auto-resolves after 10 seconds
+        const timeoutPromise = new Promise((resolve) => {
+          setTimeout(() => {
+            console.log(chalk.yellow('\n⏱️  No input received, using detected location...'));
+            resolve('');
+          }, 10000);
+        });
+
+        const questionPromise = question('Enter custom location (or press Enter): ');
+
+        const customLocation = await Promise.race([questionPromise, timeoutPromise]);
+        location = customLocation.trim() || detectedLocation;
+
+        if (customLocation.trim()) {
+          console.log(chalk.green(`✓ Using custom location: ${location}`));
+        } else {
+          console.log(chalk.green(`✓ Using detected location: ${location}`));
+        }
+      } catch (error) {
+        console.log(chalk.yellow(`\n⚠️  Prompt error, using detected location: ${detectedLocation}`));
+        location = detectedLocation;
+      }
+    } else {
+      console.log(chalk.green(`📍 Location: ${location}`));
     }
-    locationSpinner.succeed(chalk.green(`📍 Location: ${location}`));
 
     // Initialize points system
     initializePoints(wallet.publicKey.toBase58());
@@ -291,21 +321,36 @@ async function runQueryCycle(wallet, agentName, location, options) {
       if (process.env.DASHBOARD_API_URL) {
         try {
           const dashboardSpinner = ora('Submitting to dashboard API...').start();
-          const response = await fetch(process.env.DASHBOARD_API_URL, {
+          const apiUrl = process.env.DASHBOARD_API_URL;
+
+          console.log(chalk.blue(`\n🌐 Dashboard API URL: ${apiUrl}`));
+          console.log(chalk.gray(`📤 Submitting data: ${JSON.stringify(submissionData, null, 2)}`));
+
+          const response = await fetch(apiUrl, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(submissionData)
           });
 
+          const responseText = await response.text();
+          console.log(chalk.blue(`📥 API Response Status: ${response.status}`));
+          console.log(chalk.gray(`📥 API Response Body: ${responseText}`));
+
           if (response.ok) {
-            dashboardSpinner.succeed(chalk.green('Dashboard submission successful'));
+            dashboardSpinner.succeed(chalk.green('✅ Dashboard submission successful!'));
+            console.log(chalk.green(`🎉 Data should now appear at: https://decharge-scout.vercel.app/agentone`));
           } else {
-            dashboardSpinner.warn(chalk.yellow(`Dashboard API returned: ${response.status}`));
+            dashboardSpinner.warn(chalk.yellow(`⚠️  Dashboard API returned: ${response.status}`));
+            console.log(chalk.yellow(`Response: ${responseText}`));
           }
         } catch (error) {
           // Silent fail for dashboard - it's optional
-          console.log(chalk.gray(`ℹ️  Dashboard API not available (${error.message})`));
+          console.log(chalk.red(`❌ Dashboard API error: ${error.message}`));
+          console.log(chalk.gray(`Stack: ${error.stack}`));
         }
+      } else {
+        console.log(chalk.yellow(`\n⚠️  DASHBOARD_API_URL not set - skipping dashboard submission`));
+        console.log(chalk.gray(`   To enable: Set DASHBOARD_API_URL in .env file`));
       }
 
       // Award points

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decharge-scout",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "AI-powered energy grid data scout with Solana integration",
   "main": "index.js",
   "type": "module",

package/src/energy-data.js

@@ -16,7 +16,9 @@ const EIA_BASE_URL = 'https://api.eia.gov/v2';
  * Fetch energy data from EIA API (ERCOT)
  */
 export async function fetchEnergyData() {
-  if (!EIA_API_KEY || EIA_API_KEY === 'your_eia_api_key_here') {
+  if (!EIA_API_KEY || EIA_API_KEY === 'your_eia_api_key_here' || EIA_API_KEY.length < 20) {
+    console.warn('⚠️  EIA_API_KEY not configured or invalid');
+    console.warn('   Get a free key: https://www.eia.gov/opendata/register.php');
     throw new Error('EIA_API_KEY not configured');
   }
 

package/src/oracle.js

@@ -21,6 +21,25 @@ export async function submitToOracle(wallet, submissionData) {
   try {
     const connection = getConnection();
 
+    // Check wallet balance first
+    const balance = await connection.getBalance(wallet.publicKey);
+    const balanceSOL = balance / 1000000000; // Convert lamports to SOL
+
+    // Minimum balance needed: 0.01 SOL for transaction + fees
+    const minRequired = 0.01;
+
+    if (balanceSOL < minRequired) {
+      console.warn(`\n⚠️  Insufficient funds for oracle submission`);
+      console.warn(`   Current balance: ${balanceSOL.toFixed(4)} SOL`);
+      console.warn(`   Required: ${minRequired} SOL`);
+      console.warn(`   Wallet: ${wallet.publicKey.toBase58()}`);
+      console.warn(`\n💡 To get devnet SOL:`);
+      console.warn(`   1. solana airdrop 1 ${wallet.publicKey.toBase58()} --url devnet`);
+      console.warn(`   2. Or visit: https://faucet.solana.com/`);
+      console.warn(`\n📝 Using mock signature for demo purposes...\n`);
+      return 'MOCK_ORACLE_TX_' + Date.now() + '_' + crypto.randomBytes(16).toString('hex');
+    }
+
     // Anonymize data
     const anonymizedData = anonymizeData(submissionData);
 
@@ -28,35 +47,12 @@ export async function submitToOracle(wallet, submissionData) {
     const dataJSON = JSON.stringify(anonymizedData);
     const dataBuffer = Buffer.from(dataJSON);
 
-    // For demo, we'll send a memo transaction with the data
+    // For demo, we'll send just a memo transaction (no transfer needed)
     // In production, this would call a custom Solana program
 
-    // Create oracle program ID (mock - using a valid pubkey format)
-    const oracleProgramId = new PublicKey('DeCh4rG3orac1e111111111111111111111111111111');
-
-    // Create PDA for storing oracle data (simplified for demo)
-    const [oraclePDA] = await PublicKey.findProgramAddress(
-      [
-        Buffer.from('oracle'),
-        wallet.publicKey.toBuffer(),
-        Buffer.from(Date.now().toString())
-      ],
-      oracleProgramId
-    );
-
     // Create transaction with memo containing our data
     const transaction = new Transaction();
 
-    // Add a small transfer to make it a valid transaction
-    // (In production, this would be a custom program instruction)
-    transaction.add(
-      SystemProgram.transfer({
-        fromPubkey: wallet.publicKey,
-        toPubkey: oraclePDA,
-        lamports: 1000 // Minimal amount for demo
-      })
-    );
-
     // Add memo instruction with our data (truncate if needed for tx size limits)
     const MAX_MEMO_SIZE = 566; // Solana memo size limit
     const memoData = dataBuffer.length > MAX_MEMO_SIZE
@@ -89,7 +85,7 @@ export async function submitToOracle(wallet, submissionData) {
     return signature;
   } catch (error) {
     // If transaction fails (e.g., insufficient funds), create mock signature
-    if (error.message.includes('insufficient')) {
+    if (error.message.includes('insufficient') || error.message.includes('balance')) {
       console.warn('Insufficient funds for oracle submission, creating mock signature');
       return 'MOCK_ORACLE_TX_' + Date.now() + '_' + crypto.randomBytes(16).toString('hex');
     }

package/test-api.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+/**
+ * Test Script - Direct API Submission
+ *
+ * This script tests the dashboard API by submitting sample data
+ * Use this to verify your Supabase database connection
+ */
+
+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';
+
+// Sample test data
+const testData = {
+  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
+  }
+};
+
+console.log(chalk.cyan.bold('\n🧪 Testing DeCharge Dashboard API\n'));
+console.log(chalk.gray('=' .repeat(50)));
+
+async function testSubmission() {
+  console.log(chalk.blue('\n1️⃣  Testing Submission Endpoint'));
+  console.log(chalk.gray(`   URL: ${DASHBOARD_API_URL}`));
+  console.log(chalk.gray(`   Data: ${JSON.stringify(testData, null, 2)}`));
+
+  try {
+    const response = await fetch(DASHBOARD_API_URL, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(testData)
+    });
+
+    const responseText = await response.text();
+
+    console.log(chalk.blue(`\n📥 Response Status: ${response.status}`));
+    console.log(chalk.blue(`📥 Response Body:`));
+    console.log(chalk.gray(responseText));
+
+    if (response.ok) {
+      console.log(chalk.green('\n✅ Submission successful!'));
+      return true;
+    } else {
+      console.log(chalk.red('\n❌ Submission failed!'));
+      return false;
+    }
+  } catch (error) {
+    console.log(chalk.red(`\n❌ Error: ${error.message}`));
+    console.log(chalk.gray(error.stack));
+    return false;
+  }
+}
+
+async function testStats() {
+  console.log(chalk.blue('\n2️⃣  Testing 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📥 Response Status: ${response.status}`));
+    console.log(chalk.blue(`📊 Stats Data:`));
+    console.log(chalk.gray(JSON.stringify(data, null, 2)));
+
+    if (response.ok) {
+      console.log(chalk.green('\n✅ Stats endpoint working!'));
+      console.log(chalk.magenta(`📊 Active Agents: ${data.activeAgents}`));
+      console.log(chalk.magenta(`📊 Total Submissions: ${data.totalSubmissions}`));
+      return true;
+    } else {
+      console.log(chalk.red('\n❌ Stats endpoint failed!'));
+      return false;
+    }
+  } catch (error) {
+    console.log(chalk.red(`\n❌ Error: ${error.message}`));
+    console.log(chalk.gray(error.stack));
+    return false;
+  }
+}
+
+async function checkDatabase() {
+  console.log(chalk.blue('\n3️⃣  Checking Database Connection'));
+
+  console.log(chalk.yellow('\nPlease verify in Supabase:'));
+  console.log(chalk.gray('   1. Go to https://supabase.com'));
+  console.log(chalk.gray('   2. Open your project'));
+  console.log(chalk.gray('   3. Go to Table Editor'));
+  console.log(chalk.gray('   4. Check tables: agent_submissions, agent_heartbeat'));
+  console.log(chalk.gray(`   5. Look for agent: ${testData.agent_name}`));
+}
+
+async function main() {
+  console.log(chalk.yellow('🚀 Starting API tests...\n'));
+
+  const submissionOk = await testSubmission();
+
+  console.log(chalk.gray('\n' + '=' .repeat(50)));
+
+  await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds
+
+  const statsOk = await testStats();
+
+  console.log(chalk.gray('\n' + '=' .repeat(50)));
+
+  await checkDatabase();
+
+  console.log(chalk.gray('\n' + '=' .repeat(50)));
+  console.log(chalk.cyan.bold('\n📋 Test Summary:'));
+  console.log(submissionOk
+    ? chalk.green('✅ Submission endpoint: PASS')
+    : chalk.red('❌ Submission endpoint: FAIL'));
+  console.log(statsOk
+    ? chalk.green('✅ Stats endpoint: PASS')
+    : chalk.red('❌ Stats endpoint: FAIL'));
+
+  if (submissionOk && statsOk) {
+    console.log(chalk.green.bold('\n🎉 All tests passed! Your dashboard is working!'));
+    console.log(chalk.blue(`\n🌐 View dashboard at: https://decharge-scout.vercel.app/agentone\n`));
+  } else {
+    console.log(chalk.red.bold('\n⚠️  Some tests failed. Check the errors above.'));
+    console.log(chalk.yellow('\nTroubleshooting:'));
+    console.log(chalk.gray('1. Make sure Supabase tables are created (run schema.sql)'));
+    console.log(chalk.gray('2. Check Vercel environment variables:'));
+    console.log(chalk.gray('   - SUPABASE_URL'));
+    console.log(chalk.gray('   - SUPABASE_ANON_KEY'));
+    console.log(chalk.gray('3. Redeploy Vercel after adding env vars'));
+    console.log(chalk.gray('4. Check Vercel function logs: vercel logs\n'));
+  }
+}
+
+main().catch(error => {
+  console.error(chalk.red('Fatal error:'), error);
+  process.exit(1);
+});