@stackmeter/cli 0.1.3 → 0.2.0

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";
@@ -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,95 +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 watcher will start anyway and wait for OpenClaw session files.");
+    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`;
-    // 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)) {
-      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 (env vars for SDK routing) ─
-    if (ocConfig) {
-      // 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(
-        `     env.OPENAI_BASE_URL    = "${gatewayBaseUrl}"`
-      );
-      console.log(
-        `     env.ANTHROPIC_BASE_URL = "${gatewayBase}"`
-      );
-    } 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")
       );
@@ -395,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;
     }
 
@@ -416,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 watcher reads session files from ~/.openclaw/agents/");
     console.log(`  View your usage at ${baseUrl}/app/ai-usage`);
     console.log("");
     rl.close();
@@ -425,30 +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(
-      '     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:");
+    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();
@@ -468,30 +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 env vars we set
-    const { config: ocConfig } = readOpenClawConfig();
-    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 env vars from ${OC_CONFIG_PATH}`);
-    }
+    console.log("  \u2705 Log watcher service stopped and removed");
   }
 
   // ── Remove StackMeter config ───────────────────────
@@ -511,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 ──────────────────────────────────
@@ -525,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) {
@@ -549,89 +448,70 @@ 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 session files
+  console.log("  2/2 Checking OpenClaw sessions...");
+  const ocHome = process.env.OPENCLAW_HOME || join(homedir(), ".openclaw");
+  const agentsDir = join(ocHome, "agents");
 
-  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(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  Could not confirm StackMeter ingestion");
+    console.log(`  \u26A0\uFE0F  No agents directory at ${agentsDir}`);
+    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.3",
+  "version": "0.2.0",
   "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,285 @@
+// 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, readdirSync } from "node:fs";
+import { watch } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+/* ── Config ──────────────────────────────────────────────── */
+
+function readStackMeterConfig() {
+  const p = join(homedir(), ".stackmeter", "config.json");
+  if (!existsSync(p)) return {};
+  try { return JSON.parse(readFileSync(p, "utf-8")); }
+  catch { return {}; }
+}
+
+function getOpenClawHome(smConfig = {}) {
+  return process.env.OPENCLAW_HOME || smConfig.openclawHome || join(homedir(), ".openclaw");
+}
+
+/* ── 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.toFixed(4)}\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;
+  }
+}
+
+/* ── JSONL line parser ───────────────────────────────────── */
+
+function parseSessionLine(line) {
+  try {
+    const obj = JSON.parse(line);
+
+    // 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;
+  }
+}
+
+/* ── 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();
+  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);
+  }
+
+  const ocHome = getOpenClawHome(smConfig);
+  const emittedKeys = new Set();
+
+  // 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 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 processNewBytes(filePath, agentName) {
+    if (!existsSync(filePath)) return;
+
+    const state = watchedFiles.get(filePath);
+    if (!state) return;
+
+    const stat = statSync(filePath);
+    if (stat.size <= state.offset) return;
+
+    // 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");
+
+    // Last element might be a partial line (incomplete write)
+    state.partialLine = lines.pop() || "";
+
+    const sessionId = extractSessionId(filePath);
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      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: parsed.provider,
+        model: parsed.model,
+        inputTokens: parsed.inputTokens,
+        outputTokens: parsed.outputTokens,
+        costCents: parsed.costCents,
+        sourceType: "openclaw",
+        sourceId: `agent/${agentName}`,
+        ts: parsed.timestamp,
+        dedupKey,
+      };
+
+      const p = emitUsageEvent(event, smUrl, smToken);
+      if (onEmit) p.then(onEmit);
+    }
+
+    // Prune emittedKeys if it gets too large
+    if (emittedKeys.size > 100_000) {
+      emittedKeys.clear();
+    }
+  }
+
+  function startWatchingFile(filePath, agentName) {
+    if (watchedFiles.has(filePath)) return;
+
+    // Start from end of file (skip historical data)
+    let offset = 0;
+    if (existsSync(filePath)) {
+      offset = statSync(filePath).size;
+    }
+
+    watchedFiles.set(filePath, { offset, partialLine: "" });
+
+    watchFile(filePath, { interval: 2000 }, () => {
+      processNewBytes(filePath, agentName);
+    });
+  }
+
+  function startWatchingDir(agentName, sessionsDir) {
+    if (watchedDirs.has(sessionsDir)) return;
+    watchedDirs.add(sessionsDir);
+
+    // Watch existing session files
+    for (const filePath of listSessionFiles(sessionsDir)) {
+      startWatchingFile(filePath, agentName);
+    }
+
+    // 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);
+        }
+      });
+      dirWatchers.push(watcher);
+    } catch {
+      // fs.watch not available — rely on periodic scan below
+    }
+  }
+
+  function scanForAgents() {
+    const agents = discoverAgentDirs(ocHome);
+    for (const { agentName, sessionsDir } of agents) {
+      startWatchingDir(agentName, sessionsDir);
+    }
+  }
+
+  function scanForNewFiles() {
+    for (const sessionsDir of watchedDirs) {
+      const agentName = sessionsDir.split("/").at(-2) || "unknown";
+      for (const filePath of listSessionFiles(sessionsDir)) {
+        startWatchingFile(filePath, agentName);
+      }
+    }
+  }
+
+  // Initial scan
+  scanForAgents();
+
+  // Periodic scans: new agents every 30s, new session files every 10s
+  const agentScanInterval = setInterval(scanForAgents, 30_000);
+  const fileScanInterval = setInterval(scanForNewFiles, 10_000);
+
+  const agentDirs = discoverAgentDirs(ocHome);
+  const agentNames = agentDirs.map(a => a.agentName);
+
+  console.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 {
+    stop() {
+      clearInterval(agentScanInterval);
+      clearInterval(fileScanInterval);
+      for (const [filePath] of watchedFiles) {
+        unwatchFile(filePath);
+      }
+      for (const watcher of dirWatchers) {
+        watcher.close();
+      }
+    }
+  };
+}

package/src/gateway/server.mjs

@@ -214,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" });
@@ -222,12 +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 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);
@@ -252,6 +256,7 @@ 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;