@stackmeter/cli 0.1.1 → 0.1.3

package/bin/stackmeter.mjs

@@ -322,6 +322,8 @@ async function connectOpenClaw() {
       10
     );
     const gatewayBaseUrl = `http://127.0.0.1:${gatewayPort}/v1`;
+    // Anthropic baseUrl doesn't include /v1 (SDK adds it)
+    const gatewayBase = `http://127.0.0.1:${gatewayPort}`;
 
     // ── Backup openclaw.json (first run only) ────────
     if (ocConfig && !existsSync(OC_BACKUP_PATH)) {
@@ -331,17 +333,22 @@ async function connectOpenClaw() {
       console.log("");
     }
 
-    // ── Patch openclaw.json ──────────────────────────
+    // ── Patch openclaw.json (env vars for SDK routing) ─
     if (ocConfig) {
-      if (!ocConfig.models) ocConfig.models = {};
-      if (!ocConfig.models.providers) ocConfig.models.providers = {};
-      if (!ocConfig.models.providers.openai)
-        ocConfig.models.providers.openai = {};
-      ocConfig.models.providers.openai.baseUrl = gatewayBaseUrl;
+      // Patch the env section with SDK-recognized base URL env vars.
+      // The OpenAI and Anthropic SDKs respect OPENAI_BASE_URL and
+      // ANTHROPIC_BASE_URL, which OpenClaw injects at runtime.
+      if (!ocConfig.env) ocConfig.env = {};
+      ocConfig.env.OPENAI_BASE_URL = gatewayBaseUrl;
+      ocConfig.env.ANTHROPIC_BASE_URL = gatewayBase;
+
       writeFileSync(OC_CONFIG_PATH, JSON.stringify(ocConfig, null, 2) + "\n");
       console.log(`  \u2705 Patched ${OC_CONFIG_PATH}`);
       console.log(
-        `     models.providers.openai.baseUrl = "${gatewayBaseUrl}"`
+        `     env.OPENAI_BASE_URL    = "${gatewayBaseUrl}"`
+      );
+      console.log(
+        `     env.ANTHROPIC_BASE_URL = "${gatewayBase}"`
       );
     } else {
       console.log(
@@ -420,7 +427,10 @@ async function connectOpenClaw() {
     console.log("");
     console.log(`  1. Edit ${OC_CONFIG_PATH}`);
     console.log(
-      '     Set models.providers.openai.baseUrl to "http://127.0.0.1:8787/v1"'
+      '     Add to the "env" section: "OPENAI_BASE_URL": "http://127.0.0.1:8787/v1"'
+    );
+    console.log(
+      '                                "ANTHROPIC_BASE_URL": "http://127.0.0.1:8787"'
     );
     console.log("");
     console.log("  2. Set env vars:");
@@ -467,12 +477,20 @@ async function disconnectOpenClaw() {
     unlinkSync(OC_BACKUP_PATH);
     console.log(`  \u2705 Restored ${OC_CONFIG_PATH} from backup`);
   } else {
-    // No backup — just remove the baseUrl we set
+    // No backup — just remove the env vars we set
     const { config: ocConfig } = readOpenClawConfig();
-    if (ocConfig?.models?.providers?.openai?.baseUrl?.includes("127.0.0.1")) {
-      delete ocConfig.models.providers.openai.baseUrl;
+    let changed = false;
+    if (ocConfig?.env?.OPENAI_BASE_URL?.includes("127.0.0.1")) {
+      delete ocConfig.env.OPENAI_BASE_URL;
+      changed = true;
+    }
+    if (ocConfig?.env?.ANTHROPIC_BASE_URL?.includes("127.0.0.1")) {
+      delete ocConfig.env.ANTHROPIC_BASE_URL;
+      changed = true;
+    }
+    if (changed) {
       writeFileSync(OC_CONFIG_PATH, JSON.stringify(ocConfig, null, 2) + "\n");
-      console.log(`  \u2705 Removed gateway baseUrl from ${OC_CONFIG_PATH}`);
+      console.log(`  \u2705 Removed gateway env vars from ${OC_CONFIG_PATH}`);
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmeter/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Track your SaaS AI costs from the terminal. One-command OpenClaw setup.",
   "type": "module",
   "bin": {

package/src/gateway/server.mjs

@@ -1,4 +1,4 @@
-// StackMeter Gateway — OpenAI-compatible proxy with usage tracking.
+// StackMeter Gateway — OpenAI + Anthropic proxy with usage tracking.
 // Does NOT store prompts or responses. Only token counts + metadata.
 
 import { createServer } from "node:http";
@@ -7,11 +7,16 @@ import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
-const OPENAI_BASE_URL = "https://api.openai.com";
 const DEFAULT_PORT = 8787;
 
+const UPSTREAM = {
+  openai: "api.openai.com",
+  anthropic: "api.anthropic.com",
+};
+
 // Cost per 1M tokens in cents (best-effort estimates)
 const MODEL_PRICING = {
+  // OpenAI
   "gpt-4o":        { input: 250,  output: 1000 },
   "gpt-4o-mini":   { input: 15,   output: 60 },
   "gpt-4-turbo":   { input: 1000, output: 3000 },
@@ -20,6 +25,15 @@ const MODEL_PRICING = {
   "o1":            { input: 1500, output: 6000 },
   "o1-mini":       { input: 300,  output: 1200 },
   "o3-mini":       { input: 110,  output: 440 },
+  // Anthropic
+  "claude-opus-4-6":    { input: 1500, output: 7500 },
+  "claude-opus-4-5":    { input: 1500, output: 7500 },
+  "claude-sonnet-4-5":  { input: 300,  output: 1500 },
+  "claude-haiku-4-5":   { input: 80,   output: 400 },
+  "claude-3-opus":      { input: 1500, output: 7500 },
+  "claude-3-5-sonnet":  { input: 300,  output: 1500 },
+  "claude-3-5-haiku":   { input: 80,   output: 400 },
+  "claude-3-haiku":     { input: 25,   output: 125 },
 };
 
 /* ── Config file readers (fallback when env vars not set) ── */
@@ -40,6 +54,15 @@ function readOpenClawApiKey() {
   } catch { return null; }
 }
 
+/* ── Provider detection ───────────────────────────────────── */
+
+function detectProvider(method, url) {
+  if (method !== "POST") return null;
+  if (url === "/v1/chat/completions" || url === "/v1/responses") return "openai";
+  if (url === "/v1/messages") return "anthropic";
+  return null;
+}
+
 /* ── Pricing + usage helpers ──────────────────────────────── */
 
 function estimateCostCents(model, inputTokens, outputTokens) {
@@ -56,8 +79,8 @@ function estimateCostCents(model, inputTokens, outputTokens) {
   );
 }
 
-async function emitUsageEvent(usage, model, smUrl, smToken) {
-  // Handle both Chat Completions (prompt_tokens) and Responses API (input_tokens)
+async function emitUsageEvent(usage, model, provider, smUrl, smToken) {
+  // Handle both Chat Completions (prompt_tokens) and Anthropic/Responses API (input_tokens)
   const {
     prompt_tokens = 0, completion_tokens = 0,
     input_tokens = 0, output_tokens = 0,
@@ -67,7 +90,7 @@ async function emitUsageEvent(usage, model, smUrl, smToken) {
   const costCents = estimateCostCents(model, inTok, outTok);
 
   const event = {
-    provider: "openai",
+    provider,
     model,
     inputTokens: inTok,
     outputTokens: outTok,
@@ -90,7 +113,7 @@ async function emitUsageEvent(usage, model, smUrl, smToken) {
 
     if (res.ok) {
       console.log(
-        `  [stackmeter] ${model} ${inTok}+${outTok} tokens \u2192 ${costCents}\u00A2 (${res.status})`
+        `  [stackmeter] ${provider}/${model} ${inTok}+${outTok} tokens \u2192 ${costCents}\u00A2 (${res.status})`
       );
     } else {
       const err = await res.text().catch(() => "");
@@ -103,7 +126,9 @@ async function emitUsageEvent(usage, model, smUrl, smToken) {
   }
 }
 
-function extractUsageFromSSE(sseBuffer, smUrl, smToken) {
+/* ── OpenAI SSE usage extraction ──────────────────────────── */
+
+function extractUsageFromOpenAISSE(sseBuffer, smUrl, smToken) {
   const lines = sseBuffer.split("\n");
   let lastModel = "unknown";
   let lastUsage = null;
@@ -113,16 +138,46 @@ function extractUsageFromSSE(sseBuffer, smUrl, smToken) {
     try {
       const data = JSON.parse(line.slice(6));
       if (data.model) lastModel = data.model;
-      // Chat Completions format
       if (data.usage) lastUsage = data.usage;
-      // Responses API streaming format (usage inside response object)
+      // Responses API streaming (usage inside response object)
       if (data.response?.usage) lastUsage = data.response.usage;
       if (data.response?.model) lastModel = data.response.model;
     } catch {}
   }
 
   if (lastUsage) {
-    return emitUsageEvent(lastUsage, lastModel, smUrl, smToken);
+    return emitUsageEvent(lastUsage, lastModel, "openai", smUrl, smToken);
+  }
+  return null;
+}
+
+/* ── Anthropic SSE usage extraction ───────────────────────── */
+
+function extractUsageFromAnthropicSSE(sseBuffer, smUrl, smToken) {
+  const lines = sseBuffer.split("\n");
+  let model = "unknown";
+  let inputTokens = 0;
+  let outputTokens = 0;
+
+  for (const line of lines) {
+    if (!line.startsWith("data: ")) continue;
+    try {
+      const data = JSON.parse(line.slice(6));
+      // message_start contains the model and input token count
+      if (data.type === "message_start" && data.message) {
+        model = data.message.model || model;
+        inputTokens = data.message.usage?.input_tokens || 0;
+      }
+      // message_delta contains the output token count
+      if (data.type === "message_delta" && data.usage) {
+        outputTokens = data.usage.output_tokens || 0;
+      }
+    } catch {}
+  }
+
+  if (inputTokens > 0 || outputTokens > 0) {
+    const usage = { input_tokens: inputTokens, output_tokens: outputTokens };
+    return emitUsageEvent(usage, model, "anthropic", smUrl, smToken);
   }
   return null;
 }
@@ -145,12 +200,6 @@ export function startGateway(opts = {}) {
   const smToken = process.env.STACKMETER_TOKEN || smConfig.token;
   const onEmit = opts.onEmit;
 
-  if (!openaiKey) {
-    console.error("  Error: OPENAI_API_KEY is required.");
-    console.error("  Set it in ~/.openclaw/openclaw.json (models.providers.openai.apiKey)");
-    console.error("  or: export OPENAI_API_KEY=sk-...");
-    process.exit(1);
-  }
   if (!smUrl) {
     console.error("  Error: STACKMETER_URL is required.");
     console.error("  Run: npx @stackmeter/cli connect openclaw --auto");
@@ -177,9 +226,8 @@ export function startGateway(opts = {}) {
       return res.end('{"error":"Not found"}');
     }
 
-    const isTracked =
-      req.method === "POST" &&
-      (req.url === "/v1/chat/completions" || req.url === "/v1/responses");
+    const provider = detectProvider(req.method, req.url);
+    const isTracked = provider !== null;
 
     // Read body for methods that have one
     let body = Buffer.alloc(0);
@@ -189,13 +237,13 @@ export function startGateway(opts = {}) {
       body = Buffer.concat(chunks);
     }
 
-    // If tracked + streaming Chat Completions, inject stream_options.include_usage
+    // If tracked OpenAI streaming, inject stream_options.include_usage
     let isStreaming = false;
     if (isTracked && body.length > 0) {
       try {
         const parsed = JSON.parse(body.toString());
         isStreaming = parsed.stream === true;
-        if (isStreaming && req.url === "/v1/chat/completions") {
+        if (isStreaming && provider === "openai" && req.url === "/v1/chat/completions") {
           parsed.stream_options = {
             ...(parsed.stream_options || {}),
             include_usage: true,
@@ -205,9 +253,38 @@ export function startGateway(opts = {}) {
       } catch {}
     }
 
-    // Build upstream request
-    const targetUrl = new URL(req.url, OPENAI_BASE_URL);
-    const upHeaders = { Authorization: `Bearer ${openaiKey}` };
+    // Determine upstream host and build auth headers
+    const upstreamHost = provider ? UPSTREAM[provider] : UPSTREAM.openai;
+    const targetUrl = new URL(req.url, `https://${upstreamHost}`);
+    const upHeaders = {};
+
+    if (provider === "anthropic") {
+      // Forward Anthropic auth headers from client
+      const clientApiKey = req.headers["x-api-key"] || process.env.ANTHROPIC_API_KEY;
+      if (!clientApiKey) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        return res.end('{"error":"Missing Anthropic API key (x-api-key header or ANTHROPIC_API_KEY env)"}');
+      }
+      upHeaders["x-api-key"] = clientApiKey;
+      // Forward anthropic-version header
+      if (req.headers["anthropic-version"]) {
+        upHeaders["anthropic-version"] = req.headers["anthropic-version"];
+      } else {
+        upHeaders["anthropic-version"] = "2023-06-01";
+      }
+      // Forward anthropic-beta if present
+      if (req.headers["anthropic-beta"]) {
+        upHeaders["anthropic-beta"] = req.headers["anthropic-beta"];
+      }
+    } else {
+      // OpenAI: use stored key
+      if (!openaiKey) {
+        res.writeHead(401, { "Content-Type": "application/json" });
+        return res.end('{"error":"Missing OpenAI API key (OPENAI_API_KEY env or ~/.openclaw/openclaw.json)"}');
+      }
+      upHeaders["Authorization"] = `Bearer ${openaiKey}`;
+    }
+
     if (body.length > 0) {
       upHeaders["Content-Type"] =
         req.headers["content-type"] || "application/json";
@@ -242,7 +319,10 @@ export function startGateway(opts = {}) {
           });
           upRes.on("end", () => {
             res.end();
-            const p = extractUsageFromSSE(buf, smUrl, smToken);
+            const extractFn = provider === "anthropic"
+              ? extractUsageFromAnthropicSSE
+              : extractUsageFromOpenAISSE;
+            const p = extractFn(buf, smUrl, smToken);
             if (p && onEmit) p.then(onEmit);
           });
         } else {
@@ -256,11 +336,19 @@ export function startGateway(opts = {}) {
             res.end();
             try {
               const data = JSON.parse(Buffer.concat(parts).toString());
-              // Handle both Chat Completions and Responses API formats
-              const usage = data.usage || data.response?.usage;
-              const model = data.model || data.response?.model || "unknown";
+              let usage, model;
+
+              if (provider === "anthropic") {
+                usage = data.usage;
+                model = data.model || "unknown";
+              } else {
+                // OpenAI Chat Completions or Responses API
+                usage = data.usage || data.response?.usage;
+                model = data.model || data.response?.model || "unknown";
+              }
+
               if (usage) {
-                const p = emitUsageEvent(usage, model, smUrl, smToken);
+                const p = emitUsageEvent(usage, model, provider, smUrl, smToken);
                 if (onEmit) p.then(onEmit);
               }
             } catch {}
@@ -288,9 +376,9 @@ export function startGateway(opts = {}) {
       console.log("");
       console.log("  StackMeter Gateway");
       console.log(`  Listening:  http://127.0.0.1:${addr.port}`);
-      console.log(`  Proxying:   ${OPENAI_BASE_URL}`);
+      console.log(`  Proxying:   OpenAI + Anthropic`);
       console.log(`  Reporting:  ${smUrl}`);
-      console.log(`  API key:    ...${openaiKey.slice(-4)}`);
+      if (openaiKey) console.log(`  OpenAI key: ...${openaiKey.slice(-4)}`);
       console.log("");
       resolve(server);
     });