openclaw-smartmeter 0.2.2 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-smartmeter",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "AI cost optimization for OpenClaw - analyze usage and reduce costs by 48%",
   "main": "src/cli/index.js",
   "bin": {
@@ -18,8 +18,24 @@
     "dashboard": "node src/cli/index.js dashboard",
     "dashboard:preview": "python3 canvas-template/preview-server.py"
   },
-  "keywords": ["openclaw", "ai-cost-optimization", "token-monitoring", "llm-costs", "cost-reduction"],
-  "author": "",
+  "keywords": [
+    "openclaw",
+    "openclaw-skill",
+    "ai-cost-optimization",
+    "token-monitoring",
+    "llm-costs",
+    "cost-reduction",
+    "budget-management",
+    "config-optimization"
+  ],
+  "openclaw": {
+    "skill": true,
+    "name": "smartmeter",
+    "category": "productivity",
+    "emoji": "💰",
+    "manifest": "SKILL.md"
+  },
+  "author": "vajihkhan <vajihkhan@gmail.com>",
   "license": "Apache-2.0",
   "type": "module",
   "repository": {

package/src/analyzer/config-manager.js

@@ -0,0 +1,92 @@
+/**
+ * Configuration Manager
+ * Handles secure storage of OpenRouter API key and other config
+ */
+
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CONFIG_DIR = join(homedir(), '.openclaw', 'smartmeter');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+/**
+ * Get configuration including OpenRouter API key
+ * @returns {Promise<Object>} Configuration object
+ */
+export async function getConfig() {
+  try {
+    if (!existsSync(CONFIG_FILE)) {
+      return getDefaultConfig();
+    }
+
+    const content = await readFile(CONFIG_FILE, 'utf-8');
+    const config = JSON.parse(content);
+    
+    return {
+      ...getDefaultConfig(),
+      ...config
+    };
+  } catch (error) {
+    console.warn('Failed to read config, using defaults:', error.message);
+    return getDefaultConfig();
+  }
+}
+
+/**
+ * Save configuration
+ * @param {Object} config - Configuration object to save
+ */
+export async function saveConfig(config) {
+  try {
+    // Ensure directory exists
+    if (!existsSync(CONFIG_DIR)) {
+      await mkdir(CONFIG_DIR, { recursive: true });
+    }
+
+    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+  } catch (error) {
+    throw new Error(`Failed to save config: ${error.message}`);
+  }
+}
+
+/**
+ * Set OpenRouter API key
+ * @param {string} apiKey - OpenRouter API key
+ */
+export async function setOpenRouterApiKey(apiKey) {
+  const config = await getConfig();
+  config.openRouterApiKey = apiKey;
+  await saveConfig(config);
+}
+
+/**
+ * Get OpenRouter API key
+ * @returns {Promise<string|null>} API key or null if not set
+ */
+export async function getOpenRouterApiKey() {
+  const config = await getConfig();
+  return config.openRouterApiKey || null;
+}
+
+/**
+ * Remove OpenRouter API key
+ */
+export async function removeOpenRouterApiKey() {
+  const config = await getConfig();
+  delete config.openRouterApiKey;
+  await saveConfig(config);
+}
+
+/**
+ * Get default configuration
+ * @returns {Object} Default config
+ */
+function getDefaultConfig() {
+  return {
+    openRouterApiKey: null,
+    enableOpenRouterIntegration: true,
+    lastUpdated: null
+  };
+}

package/src/analyzer/openrouter-client.js

@@ -0,0 +1,112 @@
+/**
+ * OpenRouter API Client
+ * Fetches live usage data from OpenRouter to compare with analyzed session data
+ */
+
+import https from 'https';
+
+const OPENROUTER_API_BASE = 'https://openrouter.ai/api/v1';
+
+/**
+ * Fetch account credits and usage from OpenRouter
+ * @param {string} apiKey - OpenRouter API key
+ * @returns {Promise<Object>} Usage data including credits, generations, and costs
+ */
+export async function fetchOpenRouterUsage(apiKey) {
+  if (!apiKey || !apiKey.startsWith('sk-or-')) {
+    throw new Error('Invalid OpenRouter API key format (should start with "sk-or-")');
+  }
+
+  try {
+    // Fetch credits/balance
+    const creditsData = await makeRequest('/auth/key', apiKey);
+    
+    // Calculate usage based on available data
+    const usage = {
+      success: true,
+      timestamp: new Date().toISOString(),
+      account: {
+        label: creditsData.data?.label || 'Unknown',
+        limit: creditsData.data?.limit || null,
+        usageBalance: creditsData.data?.usage || null,
+        limitRemaining: creditsData.data?.limit_remaining || null,
+        isFreeTier: creditsData.data?.is_free_tier || false,
+      },
+      // OpenRouter returns usage in USD cents typically
+      totalSpent: creditsData.data?.usage ? (creditsData.data.usage / 100) : null,
+      note: 'OpenRouter API integration active'
+    };
+
+    return usage;
+  } catch (error) {
+    if (error.statusCode === 401) {
+      throw new Error('Invalid OpenRouter API key - authentication failed');
+    }
+    throw new Error(`OpenRouter API error: ${error.message}`);
+  }
+}
+
+/**
+ * Make HTTPS request to OpenRouter API
+ * @param {string} endpoint - API endpoint path
+ * @param {string} apiKey - OpenRouter API key
+ * @returns {Promise<Object>} Response data
+ */
+function makeRequest(endpoint, apiKey) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'openrouter.ai',
+      path: `/api/v1${endpoint}`,
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(data);
+          
+          if (res.statusCode === 200) {
+            resolve(parsed);
+          } else {
+            const error = new Error(parsed.error?.message || 'OpenRouter API error');
+            error.statusCode = res.statusCode;
+            error.response = parsed;
+            reject(error);
+          }
+        } catch (e) {
+          reject(new Error(`Failed to parse OpenRouter response: ${e.message}`));
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(new Error(`Network error: ${error.message}`));
+    });
+
+    req.setTimeout(10000, () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    req.end();
+  });
+}
+
+/**
+ * Validate OpenRouter API key format
+ * @param {string} apiKey - API key to validate
+ * @returns {boolean} True if format is valid
+ */
+export function isValidApiKeyFormat(apiKey) {
+  return typeof apiKey === 'string' && apiKey.startsWith('sk-or-') && apiKey.length > 20;
+}

package/src/canvas/api-server.js

@@ -9,6 +9,9 @@ import {
   cmdStatus,
 } from "../cli/commands.js";
 
+import { fetchOpenRouterUsage, isValidApiKeyFormat } from "../analyzer/openrouter-client.js";
+import { getOpenRouterApiKey, setOpenRouterApiKey, getConfig } from "../analyzer/config-manager.js";
+
 /**
  * Simple API server for SmartMeter dashboard.
  * Provides REST endpoints for the web UI to interact with CLI functions.
@@ -84,6 +87,12 @@ export class ApiServer {
       await this.handleEvaluate(req, res);
     } else if (path === "/api/export" && req.method === "GET") {
       await this.handleExport(req, res);
+    } else if (path === "/api/openrouter-usage" && req.method === "GET") {
+      await this.handleOpenRouterUsage(req, res);
+    } else if (path === "/api/config/openrouter-key" && req.method === "POST") {
+      await this.handleSetOpenRouterKey(req, res);
+    } else if (path === "/api/config/openrouter-key" && req.method === "GET") {
+      await this.handleGetOpenRouterKeyStatus(req, res);
     } else {
       this.sendError(res, 404, "Not found");
     }
@@ -255,6 +264,93 @@ ${analysis.recommendations.map((rec, i) => `${i + 1}. **${rec.title}**\n   ${rec
 `;
   }
 
+  /**
+   * GET /api/openrouter-usage - Fetch actual OpenRouter usage
+   */
+  async handleOpenRouterUsage(req, res) {
+    try {
+      const apiKey = await getOpenRouterApiKey();
+      
+      if (!apiKey) {
+        this.sendJson(res, {
+          success: false,
+          configured: false,
+          message: "OpenRouter API key not configured"
+        });
+        return;
+      }
+
+      const usage = await fetchOpenRouterUsage(apiKey);
+      this.sendJson(res, {
+        success: true,
+        configured: true,
+        ...usage
+      });
+    } catch (error) {
+      this.sendJson(res, {
+        success: false,
+        configured: true,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * POST /api/config/openrouter-key - Set OpenRouter API key
+   */
+  async handleSetOpenRouterKey(req, res) {
+    try {
+      const body = await this.parseBody(req);
+      const apiKey = body?.apiKey;
+
+      if (!apiKey) {
+        this.sendError(res, 400, "API key required");
+        return;
+      }
+
+      if (!isValidApiKeyFormat(apiKey)) {
+        this.sendError(res, 400, "Invalid API key format (should start with 'sk-or-')");
+        return;
+      }
+
+      // Test the key before saving
+      try {
+        await fetchOpenRouterUsage(apiKey);
+      } catch (error) {
+        this.sendError(res, 401, `API key validation failed: ${error.message}`);
+        return;
+      }
+
+      await setOpenRouterApiKey(apiKey);
+      
+      this.sendJson(res, {
+        success: true,
+        message: "OpenRouter API key saved and validated"
+      });
+    } catch (error) {
+      this.sendError(res, 500, error.message);
+    }
+  }
+
+  /**
+   * GET /api/config/openrouter-key - Check if OpenRouter key is configured
+   */
+  async handleGetOpenRouterKeyStatus(req, res) {
+    try {
+      const apiKey = await getOpenRouterApiKey();
+      const config = await getConfig();
+      
+      this.sendJson(res, {
+        success: true,
+        configured: !!apiKey,
+        keyPreview: apiKey ? `${apiKey.substring(0, 9)}...${apiKey.substring(apiKey.length - 4)}` : null,
+        enabledIntegration: config.enableOpenRouterIntegration !== false
+      });
+    } catch (error) {
+      this.sendError(res, 500, error.message);
+    }
+  }
+
   /**
    * Parse JSON body from request
    */
@@ -310,11 +406,14 @@ export async function startApiServer(opts = {}) {
 🚀 API Server: http://localhost:${port}
 
 📡 Available Endpoints:
-   GET  /api/status   - Current optimization status
-   GET  /api/preview  - Preview config changes
-   POST /api/apply    - Apply optimizations
-   GET  /api/evaluate - Evaluate configuration
-   GET  /api/export   - Export analysis report
+   GET  /api/status                  - Current optimization status
+   GET  /api/preview                 - Preview config changes
+   POST /api/apply                   - Apply optimizations
+   GET  /api/evaluate                - Evaluate configuration
+   GET  /api/export                  - Export analysis report
+   GET  /api/openrouter-usage        - Fetch actual OpenRouter usage
+   POST /api/config/openrouter-key   - Set OpenRouter API key
+   GET  /api/config/openrouter-key   - Check API key status
 
 Press Ctrl+C to stop
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

package/src/canvas/deployer.js

@@ -163,7 +163,7 @@ export class CanvasDeployer {
    * Return the canvas URL for the given gateway port.
    */
   getCanvasUrl(port = 8080) {
-    return `http://localhost:${port}/__openclaw__/canvas/smartmeter/`;
+    return `http://localhost:${port}`;
   }
 
   /**

package/src/cli/commands.js

@@ -143,8 +143,9 @@ Opening in your browser...
       process.on("SIGINT", shutdownHandler);
       process.on("SIGTERM", shutdownHandler);
 
-      // Store server references for cleanup
-      analysis._servers = { staticServer, apiServer };
+      // Keep process alive - wait indefinitely
+      // This prevents the CLI from exiting and killing the servers
+      await new Promise(() => {}); // Never resolves, keeps process alive
       
     } catch (err) {
       console.error(`\n⚠ Could not start dashboard: ${err.message}`);

package/src/generator/config-builder.js

@@ -68,9 +68,14 @@ export function generateConfig(analysis, currentConfig = {}) {
   }
 
   // 5. Budget controls
+  // Use minimum budget values when costs are zero or very low to ensure valid config
+  const MIN_DAILY_BUDGET = 1.00;  // $1/day minimum
+  const MIN_WEEKLY_BUDGET = 5.00; // $5/week minimum
+  
   const dailyAvg = (analysis.summary.currentMonthlyCost || 0) / 30;
-  const dailyBudget = Math.ceil(dailyAvg * 1.2 * 100) / 100;
-  const weeklyBudget = Math.ceil(dailyBudget * 7 * 100) / 100;
+  const calculatedDaily = Math.ceil(dailyAvg * 1.2 * 100) / 100;
+  const dailyBudget = Math.max(calculatedDaily, MIN_DAILY_BUDGET);
+  const weeklyBudget = Math.max(Math.ceil(dailyBudget * 7 * 100) / 100, MIN_WEEKLY_BUDGET);
 
   config.agents.defaults.budget = deepMerge(
     config.agents.defaults.budget || {},

package/src/generator/validator.js

@@ -1,4 +1,4 @@
-const ALLOWED_TOP_KEYS = new Set([
+const SMARTMETER_KEYS = new Set([
   "agents",
   "skills",
   "models",
@@ -9,6 +9,10 @@ const ALLOWED_TOP_KEYS = new Set([
 /**
  * Validate an openclaw config object.
  * Returns { valid: boolean, errors: string[] }.
+ * 
+ * Note: This validator focuses on SmartMeter-managed fields only.
+ * It allows other OpenClaw config keys (meta, wizard, auth, tools, etc.)
+ * to pass through without validation.
  */
 export function validate(config) {
   const errors = [];
@@ -17,12 +21,8 @@ export function validate(config) {
     return { valid: false, errors: ["Config must be a non-null object"] };
   }
 
-  // Check top-level keys
-  for (const key of Object.keys(config)) {
-    if (!ALLOWED_TOP_KEYS.has(key)) {
-      errors.push(`Unknown top-level key: "${key}"`);
-    }
-  }
+  // Only validate SmartMeter-managed keys, not the entire OpenClaw config
+  // This allows existing OpenClaw configs to merge without validation errors
 
   // agents.defaults.model.primary must exist and be a string
   const primary = config.agents?.defaults?.model?.primary;