@stackmeter/cli 0.1.4 → 0.2.1

package/bin/stackmeter.mjs

@@ -4,7 +4,7 @@ import { createInterface } from "node:readline/promises";
 import { exec, execSync } from "node:child_process";
 import {
   readFileSync, writeFileSync, existsSync, mkdirSync,
-  unlinkSync, chmodSync, copyFileSync,
+  unlinkSync, chmodSync, copyFileSync, readdirSync,
 } from "node:fs";
 import { homedir, platform } from "node:os";
 import { join, dirname, resolve } from "node:path";
@@ -18,6 +18,12 @@ const args = process.argv.slice(2);
 const command = args[0];
 const target = args[1];
 
+function getFlag(name) {
+  const idx = args.indexOf(name);
+  if (idx === -1 || idx + 1 >= args.length) return null;
+  return args[idx + 1];
+}
+
 // ── Constants ────────────────────────────────────────────
 
 const DEFAULT_BASE_URL = "https://stackmeter.app";
@@ -174,9 +180,12 @@ async function connectOpenClaw() {
   console.log("");
 
   // ── Step 1: Get StackMeter base URL ────────────────
-  let baseUrl = process.env.STACKMETER_URL
-    ? process.env.STACKMETER_URL.replace(/\/api\/usage-events\/?$/, "")
-    : "";
+  const flagUrl = getFlag("--url");
+  let baseUrl = flagUrl
+    ? flagUrl.replace(/\/api\/usage-events\/?$/, "")
+    : process.env.STACKMETER_URL
+      ? process.env.STACKMETER_URL.replace(/\/api\/usage-events\/?$/, "")
+      : "";
 
   if (!baseUrl) {
     baseUrl = await rl.question(
@@ -184,17 +193,17 @@ async function connectOpenClaw() {
     );
     if (!baseUrl.trim()) baseUrl = DEFAULT_BASE_URL;
   } else {
-    console.log(`  Using STACKMETER_URL: ${baseUrl}`);
+    console.log(`  Using URL: ${baseUrl}`);
   }
   baseUrl = baseUrl.replace(/\/+$/, "");
   const apiUrl = `${baseUrl}/api/usage-events`;
 
   // ── Step 2: Get or create tracking token ───────────
-  let token = process.env.STACKMETER_TOKEN || "";
+  let token = getFlag("--token") || process.env.STACKMETER_TOKEN || "";
 
   if (token) {
     console.log(
-      `  Existing STACKMETER_TOKEN found (sm_...${token.slice(-4)})`
+      `  Using token (sm_...${token.slice(-4)})`
     );
   } else {
     console.log("");
@@ -298,7 +307,7 @@ async function connectOpenClaw() {
     console.log(
       "  \u26A0\uFE0F  OpenClaw config not found at ~/.openclaw/openclaw.json"
     );
-    console.log("     The log watcher will start anyway and wait for OpenClaw logs.");
+    console.log("     The watcher will start anyway and wait for OpenClaw session files.");
     console.log("");
   }
 
@@ -359,7 +368,7 @@ async function connectOpenClaw() {
     console.log(
       "  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("  The watcher reads session files from ~/.openclaw/agents/");
     console.log(`  View your usage at ${baseUrl}/app/ai-usage`);
     console.log("");
     rl.close();
@@ -483,16 +492,30 @@ async function selfTest() {
     console.log(`  \u274C Could not reach StackMeter: ${e.message}`);
   }
 
-  // 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`;
+  // 2/2 — Check OpenClaw session files
+  console.log("  2/2 Checking OpenClaw sessions...");
+  const ocHome = process.env.OPENCLAW_STATE_DIR || process.env.CLAWDBOT_STATE_DIR || process.env.OPENCLAW_HOME || join(homedir(), ".openclaw");
+  const agentsDir = join(ocHome, "agents");
 
-  if (existsSync(logPath)) {
-    console.log(`  \u2705 OpenClaw log found: ${logPath}`);
+  if (existsSync(agentsDir)) {
+    const agents = readdirSync(agentsDir).filter(d =>
+      existsSync(join(agentsDir, d, "sessions"))
+    );
+    if (agents.length > 0) {
+      console.log(`  \u2705 Found ${agents.length} agent(s): ${agents.join(", ")}`);
+      let totalSessions = 0;
+      for (const agent of agents) {
+        const sessDir = join(agentsDir, agent, "sessions");
+        const files = readdirSync(sessDir).filter(f => f.endsWith(".jsonl"));
+        totalSessions += files.length;
+      }
+      console.log(`     ${totalSessions} session file(s) total`);
+    } else {
+      console.log(`  \u26A0\uFE0F  ${agentsDir} exists but no agents with sessions found`);
+      console.log("     Start OpenClaw first, then re-run this test.");
+    }
   } else {
-    console.log(`  \u26A0\uFE0F  No log found at ${logPath}`);
+    console.log(`  \u26A0\uFE0F  No agents directory at ${agentsDir}`);
     console.log("     Start OpenClaw first, then re-run this test.");
   }
 

package/package.json

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

package/src/gateway/log-watcher.mjs

@@ -1,81 +1,11 @@
-// 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.
+// StackMeter Session Watcher — Reads OpenClaw session JSONL files for exact usage data.
+// Watches ~/.openclaw/agents/*/sessions/*.jsonl for assistant messages with token usage.
 
-import { readFileSync, existsSync, statSync, watchFile, unwatchFile } from "node:fs";
+import { readFileSync, existsSync, statSync, watchFile, unwatchFile, readdirSync } from "node:fs";
+import { watch } 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() {
@@ -85,6 +15,16 @@ function readStackMeterConfig() {
   catch { return {}; }
 }
 
+function getOpenClawHome(smConfig = {}) {
+  return (
+    process.env.OPENCLAW_STATE_DIR ||
+    process.env.CLAWDBOT_STATE_DIR ||
+    process.env.OPENCLAW_HOME ||
+    smConfig.openclawHome ||
+    join(homedir(), ".openclaw")
+  );
+}
+
 /* ── Emit usage event to StackMeter ──────────────────────── */
 
 async function emitUsageEvent(event, smUrl, smToken) {
@@ -100,8 +40,8 @@ async function emitUsageEvent(event, smUrl, smToken) {
 
     if (res.ok) {
       console.log(
-        `  [watcher] ${event.provider}/${event.model} ~${event.inputTokens}+${event.outputTokens} tokens` +
-        ` \u2192 ${event.costCents}\u00A2 (${res.status})`
+        `  [watcher] ${event.provider}/${event.model} ${event.inputTokens}+${event.outputTokens} tokens` +
+        ` \u2192 ${event.costCents.toFixed(4)}\u00A2 (${res.status})`
       );
     } else {
       const err = await res.text().catch(() => "");
@@ -114,21 +54,64 @@ async function emitUsageEvent(event, smUrl, smToken) {
   }
 }
 
-/* ── Log parser ──────────────────────────────────────────── */
+/* ── JSONL line parser ───────────────────────────────────── */
 
-function parseLogLine(line) {
+function parseSessionLine(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 };
+
+    // Only process assistant messages with usage data
+    if (obj.type !== "message") return null;
+    const msg = obj.message;
+    if (!msg || msg.role !== "assistant" || !msg.usage) return null;
+
+    const usage = msg.usage;
+    const cost = usage.cost || {};
+
+    return {
+      messageId: obj.id,
+      timestamp: obj.timestamp || new Date().toISOString(),
+      provider: msg.provider || "unknown",
+      model: msg.model || "unknown",
+      inputTokens: (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0),
+      outputTokens: usage.output || 0,
+      costCents: (cost.total || 0) * 100, // dollars → cents
+    };
   } catch {
     return null;
   }
 }
 
-/* ── Log watcher ─────────────────────────────────────────── */
+/* ── Directory discovery ─────────────────────────────────── */
+
+function discoverAgentDirs(ocHome) {
+  const agentsDir = join(ocHome, "agents");
+  if (!existsSync(agentsDir)) return [];
+
+  try {
+    return readdirSync(agentsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => ({
+        agentName: d.name,
+        sessionsDir: join(agentsDir, d.name, "sessions"),
+      }))
+      .filter(a => existsSync(a.sessionsDir));
+  } catch {
+    return [];
+  }
+}
+
+function listSessionFiles(sessionsDir) {
+  try {
+    return readdirSync(sessionsDir)
+      .filter(f => f.endsWith(".jsonl"))
+      .map(f => join(sessionsDir, f));
+  } catch {
+    return [];
+  }
+}
+
+/* ── Session watcher ─────────────────────────────────────── */
 
 export function startLogWatcher(opts = {}) {
   const smConfig = readStackMeterConfig();
@@ -147,157 +130,162 @@ export function startLogWatcher(opts = {}) {
     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();
+  const ocHome = getOpenClawHome(smConfig);
+  const emittedKeys = new Set();
 
-  let currentLogPath = null;
-  let fileOffset = 0;
+  // Track watched files: filePath -> { offset, partialLine }
+  const watchedFiles = new Map();
+  // Track watched directories
+  const watchedDirs = new Set();
+  // fs.watch handles for cleanup
+  const dirWatchers = [];
 
-  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 extractSessionId(filePath) {
+    // /path/to/sessions/136ae359-fceb-4464-9d5a-9e7c2a15cdf7.jsonl → 136ae359
+    const base = filePath.split("/").pop().replace(".jsonl", "");
+    return base.split("-")[0] || base;
   }
 
-  function processLine(line) {
-    if (!line.trim()) return;
-    const parsed = parseLogLine(line);
-    if (!parsed) return;
+  function processNewBytes(filePath, agentName) {
+    if (!existsSync(filePath)) return;
 
-    const { msg, data, ts } = parsed;
+    const state = watchedFiles.get(filePath);
+    if (!state) return;
 
-    // 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;
-    }
+    const stat = statSync(filePath);
+    if (stat.size <= state.offset) 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");
+    // Read only new bytes
+    const content = readFileSync(filePath, "utf-8");
+    const newContent = (state.partialLine || "") + content.slice(state.offset);
+    state.offset = content.length;
+
+    const lines = newContent.split("\n");
 
-      if (!runId || aborted) return;
-      if (emittedRuns.has(runId)) return;
+    // Last element might be a partial line (incomplete write)
+    state.partialLine = lines.pop() || "";
 
-      const run = activeRuns.get(runId);
-      if (!run) return;
+    const sessionId = extractSessionId(filePath);
 
-      activeRuns.delete(runId);
-      emittedRuns.add(runId);
+    for (const line of lines) {
+      if (!line.trim()) continue;
 
-      // Estimate tokens from duration
-      const { inputTokens, outputTokens } = estimateFromDuration(run.model, durationMs);
-      const costCents = estimateCostCents(run.model, inputTokens, outputTokens);
+      const parsed = parseSessionLine(line);
+      if (!parsed) continue;
+
+      const dedupKey = `oc-${agentName}-${sessionId}-${parsed.messageId}`;
+      if (emittedKeys.has(dedupKey)) continue;
+      emittedKeys.add(dedupKey);
 
       const event = {
-        provider: run.provider,
-        model: run.model,
-        inputTokens,
-        outputTokens,
-        costCents,
+        provider: parsed.provider,
+        model: parsed.model,
+        inputTokens: parsed.inputTokens,
+        outputTokens: parsed.outputTokens,
+        costCents: parsed.costCents,
         sourceType: "openclaw",
-        sourceId: "log-watcher",
-        ts: run.startTime || new Date().toISOString(),
-        dedupKey: `oc-${runId}`,
+        sourceId: `agent/${agentName}`,
+        ts: parsed.timestamp,
+        dedupKey,
       };
 
       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;
+    // Prune emittedKeys if it gets too large
+    if (emittedKeys.size > 100_000) {
+      emittedKeys.clear();
+    }
+  }
 
-      // If file already exists, start from the end (don't replay old events)
-      if (existsSync(logPath)) {
-        const stat = statSync(logPath);
-        fileOffset = stat.size;
-      }
+  function startWatchingFile(filePath, agentName) {
+    if (watchedFiles.has(filePath)) return;
 
-      watchLogFile(logPath);
-      return;
+    // Start from end of file (skip historical data)
+    let offset = 0;
+    if (existsSync(filePath)) {
+      offset = statSync(filePath).size;
     }
 
-    if (!existsSync(logPath)) return;
+    watchedFiles.set(filePath, { offset, partialLine: "" });
 
-    const stat = statSync(logPath);
-    if (stat.size <= fileOffset) return;
+    watchFile(filePath, { interval: 2000 }, () => {
+      processNewBytes(filePath, agentName);
+    });
+  }
 
-    // Read only new bytes
-    const fd = readFileSync(logPath, "utf-8");
-    const newContent = fd.slice(fileOffset);
-    fileOffset = fd.length;
+  function startWatchingDir(agentName, sessionsDir) {
+    if (watchedDirs.has(sessionsDir)) return;
+    watchedDirs.add(sessionsDir);
 
-    const lines = newContent.split("\n");
-    for (const line of lines) {
-      processLine(line);
+    // Watch existing session files
+    for (const filePath of listSessionFiles(sessionsDir)) {
+      startWatchingFile(filePath, agentName);
     }
-  }
 
-  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);
+    // Watch for new session files
+    try {
+      const watcher = watch(sessionsDir, (eventType, filename) => {
+        if (!filename || !filename.endsWith(".jsonl")) return;
+        const filePath = join(sessionsDir, filename);
+        if (existsSync(filePath)) {
+          startWatchingFile(filePath, agentName);
         }
-      }, 5000);
-      return;
+      });
+      dirWatchers.push(watcher);
+    } catch {
+      // fs.watch not available — rely on periodic scan below
     }
+  }
 
-    watchFile(logPath, { interval: 1000 }, () => {
-      readNewLines();
-    });
+  function scanForAgents() {
+    const agents = discoverAgentDirs(ocHome);
+    for (const { agentName, sessionsDir } of agents) {
+      startWatchingDir(agentName, sessionsDir);
+    }
   }
 
-  // Check for date rollover every 60s
-  setInterval(() => {
-    const newPath = getLogPath();
-    if (newPath !== currentLogPath) {
-      readNewLines(); // triggers switchover
+  function scanForNewFiles() {
+    for (const sessionsDir of watchedDirs) {
+      const agentName = sessionsDir.split("/").at(-2) || "unknown";
+      for (const filePath of listSessionFiles(sessionsDir)) {
+        startWatchingFile(filePath, agentName);
+      }
     }
-  }, 60_000);
+  }
 
-  // Start watching
-  currentLogPath = getLogPath();
+  // Initial scan
+  scanForAgents();
 
-  if (existsSync(currentLogPath)) {
-    const stat = statSync(currentLogPath);
-    fileOffset = stat.size; // start from end
-  }
+  // Periodic scans: new agents every 30s, new session files every 10s
+  const agentScanInterval = setInterval(scanForAgents, 30_000);
+  const fileScanInterval = setInterval(scanForNewFiles, 10_000);
 
-  watchLogFile(currentLogPath);
+  const agentDirs = discoverAgentDirs(ocHome);
+  const agentNames = agentDirs.map(a => a.agentName);
 
   console.log("");
-  console.log("  StackMeter Log Watcher");
-  console.log(`  Watching:   ${OC_LOG_DIR}/openclaw-*.log`);
+  console.log("  StackMeter Session Watcher");
+  console.log(`  Watching:   ${ocHome}/agents/*/sessions/*.jsonl`);
+  if (agentNames.length > 0) {
+    console.log(`  Agents:     ${agentNames.join(", ")}`);
+  } else {
+    console.log("  Agents:     (none found yet — waiting for OpenClaw sessions)");
+  }
   console.log(`  Reporting:  ${smUrl}`);
   console.log("");
 
-  // Return a cleanup function
   return {
     stop() {
-      if (currentLogPath) unwatchFile(currentLogPath);
+      clearInterval(agentScanInterval);
+      clearInterval(fileScanInterval);
+      for (const [filePath] of watchedFiles) {
+        unwatchFile(filePath);
+      }
+      for (const watcher of dirWatchers) {
+        watcher.close();
+      }
     }
   };
 }