@stackmeter/cli 0.1.2 → 0.1.4

package/bin/stackmeter.mjs

@@ -21,7 +21,6 @@ const target = args[1];
 // ── Constants ────────────────────────────────────────────
 
 const DEFAULT_BASE_URL = "https://stackmeter.app";
-const DEFAULT_GATEWAY_PORT = 8787;
 const LAUNCH_AGENT_LABEL = "com.stackmeter.gateway";
 const PLIST_PATH = join(
   homedir(), "Library", "LaunchAgents", `${LAUNCH_AGENT_LABEL}.plist`
@@ -33,7 +32,6 @@ const SM_LAUNCHER_PATH = join(SM_CONFIG_DIR, "start-gateway.mjs");
 const SM_GATEWAY_LOG = join(SM_CONFIG_DIR, "gateway.log");
 const SM_GATEWAY_ERR_LOG = join(SM_CONFIG_DIR, "gateway.err.log");
 const OC_CONFIG_PATH = join(homedir(), ".openclaw", "openclaw.json");
-const OC_BACKUP_PATH = join(homedir(), ".openclaw", "openclaw.json.stackmeter.bak");
 
 // ── Command routing ──────────────────────────────────────
 
@@ -86,11 +84,6 @@ function openBrowser(url) {
   exec(`${cmd} "${url}"`, () => {});
 }
 
-function redactKey(key) {
-  if (!key || key.length < 8) return "****";
-  return `...${key.slice(-4)}`;
-}
-
 // ── Config readers / writers ─────────────────────────────
 
 function readOpenClawConfig() {
@@ -299,88 +292,46 @@ async function connectOpenClaw() {
   console.log("  \u2705 Token verified!");
   console.log("");
 
-  // ── Step 4: Read OpenClaw config ───────────────────
+  // ── Step 4: Verify OpenClaw is installed ─────────────
   const { config: ocConfig } = readOpenClawConfig();
-  const existingApiKey =
-    ocConfig?.models?.providers?.openai?.apiKey ||
-    process.env.OPENAI_API_KEY ||
-    "";
-
-  if (!existingApiKey) {
-    console.log("  \u274C OpenAI API key not found.");
+  if (!ocConfig) {
     console.log(
-      "     Set models.providers.openai.apiKey in ~/.openclaw/openclaw.json"
+      "  \u26A0\uFE0F  OpenClaw config not found at ~/.openclaw/openclaw.json"
     );
-    console.log("     or: export OPENAI_API_KEY=sk-...");
-    rl.close();
-    process.exit(1);
+    console.log("     The log watcher will start anyway and wait for OpenClaw logs.");
+    console.log("");
   }
 
   if (autoFlag) {
-    const gatewayPort = parseInt(
-      process.env.STACKMETER_GATEWAY_PORT || String(DEFAULT_GATEWAY_PORT),
-      10
-    );
-    const gatewayBaseUrl = `http://127.0.0.1:${gatewayPort}/v1`;
-
-    // ── Backup openclaw.json (first run only) ────────
-    if (ocConfig && !existsSync(OC_BACKUP_PATH)) {
-      copyFileSync(OC_CONFIG_PATH, OC_BACKUP_PATH);
-      console.log(`  \u{1F4CB} Backed up ${OC_CONFIG_PATH}`);
-      console.log(`     \u2192 ${OC_BACKUP_PATH}`);
-      console.log("");
-    }
-
-    // ── Patch openclaw.json ──────────────────────────
-    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;
-      writeFileSync(OC_CONFIG_PATH, JSON.stringify(ocConfig, null, 2) + "\n");
-      console.log(`  \u2705 Patched ${OC_CONFIG_PATH}`);
-      console.log(
-        `     models.providers.openai.baseUrl = "${gatewayBaseUrl}"`
-      );
-    } else {
-      console.log(
-        "  \u274C OpenClaw config not found at ~/.openclaw/openclaw.json"
-      );
-      console.log("     Install OpenClaw first: https://openclaw.dev");
-      rl.close();
-      process.exit(1);
-    }
-    console.log("");
-
     // ── Write ~/.stackmeter/config.json ──────────────
     writeStackMeterConfig({
       token,
       url: apiUrl,
-      gatewayPort,
     });
     console.log(`  \u2705 Saved config to ${SM_CONFIG_PATH}`);
     console.log("");
 
-    // ── Install gateway as persistent service ────────
+    // ── Install log watcher as persistent service ────
     if (isMac) {
-      // Copy gateway to stable path so LaunchAgent survives npx cache eviction
-      const gatewaySource = resolve(
-        __dirname, "..", "src", "gateway", "server.mjs"
+      // Copy log watcher to stable path so LaunchAgent survives npx cache eviction
+      const watcherSource = resolve(
+        __dirname, "..", "src", "gateway", "log-watcher.mjs"
       );
-      if (!existsSync(gatewaySource)) {
-        console.log(`  \u274C Gateway script not found at ${gatewaySource}`);
+      if (!existsSync(watcherSource)) {
+        console.log(`  \u274C Log watcher script not found at ${watcherSource}`);
         rl.close();
         process.exit(1);
       }
 
-      copyFileSync(gatewaySource, SM_GATEWAY_PATH);
+      copyFileSync(watcherSource, SM_GATEWAY_PATH);
       writeFileSync(
         SM_LAUNCHER_PATH,
         [
           "#!/usr/bin/env node",
-          'import { startGateway } from "./gateway.mjs";',
-          "startGateway();",
+          'import { startLogWatcher } from "./gateway.mjs";',
+          "startLogWatcher();",
+          // Keep process alive
+          "setInterval(() => {}, 60_000);",
           "",
         ].join("\n")
       );
@@ -388,20 +339,17 @@ async function connectOpenClaw() {
       installLaunchAgent(process.execPath, SM_LAUNCHER_PATH);
       loadLaunchAgent();
 
-      console.log("  \u2705 Gateway installed as background service");
+      console.log("  \u2705 Log watcher installed as background service");
       console.log(`     LaunchAgent: ${PLIST_PATH}`);
       console.log(`     Logs:        ${SM_GATEWAY_LOG}`);
     } else {
-      // Non-macOS: start gateway in foreground
-      console.log("  Starting gateway in foreground...");
-      process.env.STACKMETER_URL = apiUrl;
-      process.env.STACKMETER_TOKEN = token;
-      if (!process.env.OPENAI_API_KEY)
-        process.env.OPENAI_API_KEY = existingApiKey;
-
+      // Non-macOS: start log watcher in foreground
+      console.log("  Starting log watcher in foreground...");
       rl.close();
-      const { startGateway } = await import("../src/gateway/server.mjs");
-      await startGateway();
+      const { startLogWatcher } = await import("../src/gateway/log-watcher.mjs");
+      startLogWatcher({ smUrl: apiUrl, smToken: token });
+      // Keep process alive
+      setInterval(() => {}, 60_000);
       return;
     }
 
@@ -409,8 +357,9 @@ async function connectOpenClaw() {
     console.log("  \u2705 Done! OpenClaw is connected to StackMeter.");
     console.log("");
     console.log(
-      "  Just run OpenClaw normally \u2014 no extra flags needed."
+      "  No changes to OpenClaw config needed \u2014 just run OpenClaw normally."
     );
+    console.log("  The log watcher reads OpenClaw's logs in /tmp/openclaw/");
     console.log(`  View your usage at ${baseUrl}/app/ai-usage`);
     console.log("");
     rl.close();
@@ -418,27 +367,15 @@ async function connectOpenClaw() {
     // ── No --auto: Print manual steps ────────────────
     console.log("  \u2705 Token is valid. Follow these steps to complete setup:");
     console.log("");
-    console.log(`  1. Edit ${OC_CONFIG_PATH}`);
-    console.log(
-      '     Set models.providers.openai.baseUrl to "http://127.0.0.1:8787/v1"'
-    );
-    console.log("");
-    console.log("  2. Set env vars:");
+    console.log("  1. Set env vars:");
     console.log(`     export STACKMETER_URL="${apiUrl}"`);
     console.log(`     export STACKMETER_TOKEN="${token}"`);
-    if (existingApiKey) {
-      console.log(
-        `     export OPENAI_API_KEY="${redactKey(existingApiKey)}"`
-      );
-    } else {
-      console.log('     export OPENAI_API_KEY="sk-..."  # your OpenAI key');
-    }
     console.log("");
-    console.log("  3. Start the gateway:");
+    console.log("  2. Start the log watcher:");
     console.log("     npx @stackmeter/cli gateway");
     console.log("");
     console.log(
-      "  4. Start OpenClaw \u2014 traffic will flow through the gateway."
+      "  3. Run OpenClaw normally \u2014 the watcher reads its logs automatically."
     );
     console.log("");
     rl.close();
@@ -458,22 +395,7 @@ async function disconnectOpenClaw() {
   // ── Stop and remove LaunchAgent ────────────────────
   if (isMac) {
     unloadLaunchAgent();
-    console.log("  \u2705 Gateway service stopped and removed");
-  }
-
-  // ── Restore openclaw.json from backup ──────────────
-  if (existsSync(OC_BACKUP_PATH)) {
-    copyFileSync(OC_BACKUP_PATH, OC_CONFIG_PATH);
-    unlinkSync(OC_BACKUP_PATH);
-    console.log(`  \u2705 Restored ${OC_CONFIG_PATH} from backup`);
-  } else {
-    // No backup — just remove the baseUrl we set
-    const { config: ocConfig } = readOpenClawConfig();
-    if (ocConfig?.models?.providers?.openai?.baseUrl?.includes("127.0.0.1")) {
-      delete ocConfig.models.providers.openai.baseUrl;
-      writeFileSync(OC_CONFIG_PATH, JSON.stringify(ocConfig, null, 2) + "\n");
-      console.log(`  \u2705 Removed gateway baseUrl from ${OC_CONFIG_PATH}`);
-    }
+    console.log("  \u2705 Log watcher service stopped and removed");
   }
 
   // ── Remove StackMeter config ───────────────────────
@@ -493,11 +415,13 @@ async function disconnectOpenClaw() {
   console.log("");
 }
 
-// ── gateway ──────────────────────────────────────────────
+// ── gateway (now runs log watcher) ───────────────────────
 
 async function startGatewayCommand() {
-  const { startGateway } = await import("../src/gateway/server.mjs");
-  await startGateway();
+  const { startLogWatcher } = await import("../src/gateway/log-watcher.mjs");
+  startLogWatcher();
+  // Keep process alive
+  setInterval(() => {}, 60_000);
 }
 
 // ── gateway --self-test ──────────────────────────────────
@@ -507,17 +431,10 @@ async function selfTest() {
 
   // Read config from file or env
   const smConfig = readStackMeterConfig();
-  const openaiKey =
-    process.env.OPENAI_API_KEY ||
-    (() => {
-      const { config } = readOpenClawConfig();
-      return config?.models?.providers?.openai?.apiKey;
-    })();
   const smUrl = process.env.STACKMETER_URL || smConfig.url;
   const smToken = process.env.STACKMETER_TOKEN || smConfig.token;
 
   const missing = [];
-  if (!openaiKey) missing.push("OPENAI_API_KEY");
   if (!smUrl) missing.push("STACKMETER_URL");
   if (!smToken) missing.push("STACKMETER_TOKEN");
   if (missing.length) {
@@ -531,89 +448,56 @@ async function selfTest() {
     process.exit(1);
   }
 
-  // Set env vars so gateway picks them up
-  if (!process.env.OPENAI_API_KEY) process.env.OPENAI_API_KEY = openaiKey;
-  if (!process.env.STACKMETER_URL) process.env.STACKMETER_URL = smUrl;
-  if (!process.env.STACKMETER_TOKEN) process.env.STACKMETER_TOKEN = smToken;
-
   console.log("");
-  console.log("  \u{1F9EA} StackMeter Gateway \u2014 Self-test");
+  console.log("  \u{1F9EA} StackMeter \u2014 Self-test");
   console.log("");
 
-  const { startGateway } = await import("../src/gateway/server.mjs");
-
-  let emitStatus = 0;
-  const server = await startGateway({
-    port: 0, // OS-assigned port
-    onEmit: (status) => {
-      emitStatus = status;
-    },
-  });
-
-  const addr = server.address();
-  const gwUrl = `http://127.0.0.1:${addr.port}`;
-
-  // 1/3 — Health check
-  console.log("  1/3 Health check...");
-  const healthRes = await fetch(`${gwUrl}/health`);
-  if (!healthRes.ok) {
-    console.log("  \u274C Health check failed");
-    server.close();
-    process.exit(1);
-  }
-  console.log("  \u2705 Gateway healthy");
-
-  // 2/3 — Send minimal completion through gateway
-  console.log(
-    "  2/3 Sending test completion (gpt-4o-mini, max_tokens=1)..."
-  );
+  // 1/2 — Test StackMeter API connectivity
+  console.log("  1/2 Testing StackMeter API...");
   try {
-    const compRes = await fetch(`${gwUrl}/v1/chat/completions`, {
+    const res = await fetch(smUrl, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: {
+        Authorization: `Bearer ${smToken}`,
+        "Content-Type": "application/json",
+      },
       body: JSON.stringify({
-        model: "gpt-4o-mini",
-        messages: [{ role: "user", content: "Hi" }],
-        max_tokens: 1,
+        provider: "stackmeter",
+        model: "self-test",
+        inputTokens: 0,
+        outputTokens: 0,
+        costCents: 0,
+        sourceType: "openclaw",
+        sourceId: "cli-self-test",
+        dedupKey: `self-test-${Date.now()}`,
       }),
     });
 
-    if (!compRes.ok) {
-      const err = await compRes.text().catch(() => "");
-      console.log(
-        `  \u274C OpenAI returned ${compRes.status}: ${err.slice(0, 200)}`
-      );
-      server.close();
-      process.exit(1);
+    if (res.ok) {
+      console.log(`  \u2705 StackMeter API responded (${res.status})`);
+    } else {
+      const err = await res.text().catch(() => "");
+      console.log(`  \u274C StackMeter API returned ${res.status}: ${err.slice(0, 200)}`);
     }
-
-    const result = await compRes.json();
-    console.log(
-      `  \u2705 OpenAI response: ${result.usage?.total_tokens ?? "?"} tokens`
-    );
   } catch (e) {
-    console.log(`  \u274C Request failed: ${e.message}`);
-    server.close();
-    process.exit(1);
+    console.log(`  \u274C Could not reach StackMeter: ${e.message}`);
   }
 
-  // 3/3 — Wait for async StackMeter emit
-  console.log("  3/3 Waiting for StackMeter ingestion...");
-  await new Promise((r) => setTimeout(r, 2000));
+  // 2/2 — Check OpenClaw log file exists
+  console.log("  2/2 Checking OpenClaw logs...");
+  const d = new Date();
+  const ymd = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+  const logPath = `/tmp/openclaw/openclaw-${ymd}.log`;
 
-  if (emitStatus >= 200 && emitStatus < 300) {
-    console.log(`  \u2705 StackMeter ingestion returned ${emitStatus}`);
-  } else if (emitStatus > 0) {
-    console.log(
-      `  \u26A0\uFE0F  StackMeter ingestion returned ${emitStatus}`
-    );
+  if (existsSync(logPath)) {
+    console.log(`  \u2705 OpenClaw log found: ${logPath}`);
   } else {
-    console.log("  \u26A0\uFE0F  Could not confirm StackMeter ingestion");
+    console.log(`  \u26A0\uFE0F  No log found at ${logPath}`);
+    console.log("     Start OpenClaw first, then re-run this test.");
   }
 
   console.log("");
   console.log("  Self-test complete.");
   console.log("");
-  server.close();
   process.exit(0);
 }

package/package.json

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

package/src/gateway/log-watcher.mjs

@@ -0,0 +1,303 @@
+// StackMeter Log Watcher — Tails OpenClaw logs and emits usage events.
+// Replaces the proxy gateway approach since OpenClaw doesn't support
+// base URL overrides for its HTTP client.
+
+import { readFileSync, existsSync, statSync, watchFile, unwatchFile } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const OC_LOG_DIR = "/tmp/openclaw";
+
+// 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 },
+  "gpt-4":         { input: 3000, output: 6000 },
+  "gpt-3.5-turbo": { input: 50,   output: 150 },
+  "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 },
+};
+
+// Rough tokens/second estimates by model class for duration-based estimation
+const TOKENS_PER_SEC = {
+  "gpt-4o":        80,
+  "gpt-4o-mini":   120,
+  "gpt-4-turbo":   40,
+  "gpt-4":         30,
+  "gpt-3.5-turbo": 100,
+  "o1":            20,
+  "o1-mini":       40,
+  "o3-mini":       60,
+  "claude-opus-4-6":    30,
+  "claude-opus-4-5":    30,
+  "claude-sonnet-4-5":  60,
+  "claude-haiku-4-5":   120,
+  "claude-3-opus":      30,
+  "claude-3-5-sonnet":  60,
+  "claude-3-5-haiku":   120,
+  "claude-3-haiku":     150,
+};
+
+function matchModel(model) {
+  for (const key of Object.keys(MODEL_PRICING)) {
+    if (model === key || model.startsWith(key + "-")) return key;
+  }
+  return null;
+}
+
+function estimateFromDuration(model, durationMs) {
+  const matched = matchModel(model);
+  const tps = matched ? (TOKENS_PER_SEC[matched] || 60) : 60;
+  const secs = durationMs / 1000;
+  // Rough split: ~30% input time, ~70% output time
+  const outputTokens = Math.round(secs * 0.7 * tps);
+  const inputTokens = Math.round(secs * 0.3 * tps * 0.5); // input is faster
+  return { inputTokens, outputTokens };
+}
+
+function estimateCostCents(model, inputTokens, outputTokens) {
+  const matched = matchModel(model);
+  if (!matched) return 0;
+  const pricing = MODEL_PRICING[matched];
+  return Math.round(
+    (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000
+  );
+}
+
+/* ── Config ──────────────────────────────────────────────── */
+
+function readStackMeterConfig() {
+  const p = join(homedir(), ".stackmeter", "config.json");
+  if (!existsSync(p)) return {};
+  try { return JSON.parse(readFileSync(p, "utf-8")); }
+  catch { return {}; }
+}
+
+/* ── Emit usage event to StackMeter ──────────────────────── */
+
+async function emitUsageEvent(event, smUrl, smToken) {
+  try {
+    const res = await fetch(smUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${smToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(event),
+    });
+
+    if (res.ok) {
+      console.log(
+        `  [watcher] ${event.provider}/${event.model} ~${event.inputTokens}+${event.outputTokens} tokens` +
+        ` \u2192 ${event.costCents}\u00A2 (${res.status})`
+      );
+    } else {
+      const err = await res.text().catch(() => "");
+      console.error(`  [watcher] emit failed (${res.status}): ${err}`);
+    }
+    return res.status;
+  } catch (err) {
+    console.error(`  [watcher] emit error: ${err.message}`);
+    return 0;
+  }
+}
+
+/* ── Log parser ──────────────────────────────────────────── */
+
+function parseLogLine(line) {
+  try {
+    const obj = JSON.parse(line);
+    const subsystem = obj["0"] || "";
+    const msg = typeof obj["1"] === "string" ? obj["1"] : "";
+    const ts = obj.time || obj._meta?.date;
+    return { subsystem, msg, data: obj["1"], ts };
+  } catch {
+    return null;
+  }
+}
+
+/* ── Log watcher ─────────────────────────────────────────── */
+
+export function startLogWatcher(opts = {}) {
+  const smConfig = readStackMeterConfig();
+  const smUrl = opts.smUrl || process.env.STACKMETER_URL || smConfig.url;
+  const smToken = opts.smToken || process.env.STACKMETER_TOKEN || smConfig.token;
+  const onEmit = opts.onEmit;
+
+  if (!smUrl) {
+    console.error("  Error: STACKMETER_URL is required.");
+    console.error("  Run: npx @stackmeter/cli connect openclaw --auto");
+    process.exit(1);
+  }
+  if (!smToken) {
+    console.error("  Error: STACKMETER_TOKEN is required.");
+    console.error("  Run: npx @stackmeter/cli connect openclaw --auto");
+    process.exit(1);
+  }
+
+  // Track active runs: runId -> { provider, model, startTime }
+  const activeRuns = new Map();
+  // Track emitted dedupKeys to avoid re-emitting on file re-read
+  const emittedRuns = new Set();
+
+  let currentLogPath = null;
+  let fileOffset = 0;
+
+  function getLogPath() {
+    const d = new Date();
+    const ymd = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+    return join(OC_LOG_DIR, `openclaw-${ymd}.log`);
+  }
+
+  function processLine(line) {
+    if (!line.trim()) return;
+    const parsed = parseLogLine(line);
+    if (!parsed) return;
+
+    const { msg, data, ts } = parsed;
+
+    // Match: "embedded run start: runId=xxx ... provider=yyy model=zzz"
+    if (typeof msg === "string" && msg.includes("embedded run start:")) {
+      const runId = msg.match(/runId=(\S+)/)?.[1];
+      const provider = msg.match(/provider=(\S+)/)?.[1];
+      const model = msg.match(/model=(\S+)/)?.[1];
+      if (runId && provider && model) {
+        activeRuns.set(runId, { provider, model, startTime: ts });
+      }
+      return;
+    }
+
+    // Match: "embedded run done: runId=xxx ... durationMs=NNN"
+    if (typeof msg === "string" && msg.includes("embedded run done:")) {
+      const runId = msg.match(/runId=(\S+)/)?.[1];
+      const durationMs = parseInt(msg.match(/durationMs=(\d+)/)?.[1] || "0", 10);
+      const aborted = msg.includes("aborted=true");
+
+      if (!runId || aborted) return;
+      if (emittedRuns.has(runId)) return;
+
+      const run = activeRuns.get(runId);
+      if (!run) return;
+
+      activeRuns.delete(runId);
+      emittedRuns.add(runId);
+
+      // Estimate tokens from duration
+      const { inputTokens, outputTokens } = estimateFromDuration(run.model, durationMs);
+      const costCents = estimateCostCents(run.model, inputTokens, outputTokens);
+
+      const event = {
+        provider: run.provider,
+        model: run.model,
+        inputTokens,
+        outputTokens,
+        costCents,
+        sourceType: "openclaw",
+        sourceId: "log-watcher",
+        ts: run.startTime || new Date().toISOString(),
+        dedupKey: `oc-${runId}`,
+      };
+
+      const p = emitUsageEvent(event, smUrl, smToken);
+      if (onEmit) p.then(onEmit);
+      return;
+    }
+  }
+
+  function readNewLines() {
+    const logPath = getLogPath();
+
+    // Date rolled over — switch to new file
+    if (logPath !== currentLogPath) {
+      if (currentLogPath) {
+        unwatchFile(currentLogPath);
+      }
+      currentLogPath = logPath;
+      fileOffset = 0;
+
+      // If file already exists, start from the end (don't replay old events)
+      if (existsSync(logPath)) {
+        const stat = statSync(logPath);
+        fileOffset = stat.size;
+      }
+
+      watchLogFile(logPath);
+      return;
+    }
+
+    if (!existsSync(logPath)) return;
+
+    const stat = statSync(logPath);
+    if (stat.size <= fileOffset) return;
+
+    // Read only new bytes
+    const fd = readFileSync(logPath, "utf-8");
+    const newContent = fd.slice(fileOffset);
+    fileOffset = fd.length;
+
+    const lines = newContent.split("\n");
+    for (const line of lines) {
+      processLine(line);
+    }
+  }
+
+  function watchLogFile(logPath) {
+    if (!existsSync(logPath)) {
+      // File doesn't exist yet — poll until it does
+      const check = setInterval(() => {
+        if (existsSync(logPath)) {
+          clearInterval(check);
+          watchLogFile(logPath);
+        }
+      }, 5000);
+      return;
+    }
+
+    watchFile(logPath, { interval: 1000 }, () => {
+      readNewLines();
+    });
+  }
+
+  // Check for date rollover every 60s
+  setInterval(() => {
+    const newPath = getLogPath();
+    if (newPath !== currentLogPath) {
+      readNewLines(); // triggers switchover
+    }
+  }, 60_000);
+
+  // Start watching
+  currentLogPath = getLogPath();
+
+  if (existsSync(currentLogPath)) {
+    const stat = statSync(currentLogPath);
+    fileOffset = stat.size; // start from end
+  }
+
+  watchLogFile(currentLogPath);
+
+  console.log("");
+  console.log("  StackMeter Log Watcher");
+  console.log(`  Watching:   ${OC_LOG_DIR}/openclaw-*.log`);
+  console.log(`  Reporting:  ${smUrl}`);
+  console.log("");
+
+  // Return a cleanup function
+  return {
+    stop() {
+      if (currentLogPath) unwatchFile(currentLogPath);
+    }
+  };
+}

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");
@@ -165,6 +214,8 @@ export function startGateway(opts = {}) {
   }
 
   const server = createServer(async (req, res) => {
+    console.log(`  [gw] ${req.method} ${req.url}`);
+
     // Health check
     if (req.method === "GET" && req.url === "/health") {
       res.writeHead(200, { "Content-Type": "application/json" });
@@ -173,13 +224,14 @@ export function startGateway(opts = {}) {
 
     // Only proxy /v1/* paths
     if (!req.url?.startsWith("/v1/")) {
+      console.log(`  [gw] 404 — not a /v1/ path`);
       res.writeHead(404, { "Content-Type": "application/json" });
       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;
+    console.log(`  [gw] provider=${provider} tracked=${isTracked}`);
 
     // Read body for methods that have one
     let body = Buffer.alloc(0);
@@ -189,13 +241,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,
@@ -204,10 +256,40 @@ export function startGateway(opts = {}) {
         }
       } catch {}
     }
+    if (isTracked) console.log(`  [gw] streaming=${isStreaming} bodyLen=${body.length}`);
+
+    // 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}`;
+    }
 
-    // Build upstream request
-    const targetUrl = new URL(req.url, OPENAI_BASE_URL);
-    const upHeaders = { Authorization: `Bearer ${openaiKey}` };
     if (body.length > 0) {
       upHeaders["Content-Type"] =
         req.headers["content-type"] || "application/json";
@@ -242,7 +324,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 +341,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 +381,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);
     });