@stackmeter/cli 0.1.0

package/bin/stackmeter-gateway.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { startGateway } from "../src/gateway/server.mjs";
+
+startGateway();

package/bin/stackmeter.mjs

@@ -0,0 +1,619 @@
+#!/usr/bin/env node
+
+import { createInterface } from "node:readline/promises";
+import { exec, execSync } from "node:child_process";
+import {
+  readFileSync, writeFileSync, existsSync, mkdirSync,
+  unlinkSync, chmodSync, copyFileSync,
+} from "node:fs";
+import { homedir, platform } from "node:os";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+const args = process.argv.slice(2);
+const command = args[0];
+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`
+);
+const SM_CONFIG_DIR = join(homedir(), ".stackmeter");
+const SM_CONFIG_PATH = join(SM_CONFIG_DIR, "config.json");
+const SM_GATEWAY_PATH = join(SM_CONFIG_DIR, "gateway.mjs");
+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 ──────────────────────────────────────
+
+if (command === "connect" && target === "openclaw") {
+  connectOpenClaw().catch(fatal);
+} else if (command === "disconnect" && target === "openclaw") {
+  disconnectOpenClaw().catch(fatal);
+} else if (command === "gateway") {
+  if (args.includes("--self-test")) {
+    selfTest().catch(fatal);
+  } else {
+    rl.close();
+    startGatewayCommand().catch(fatal);
+  }
+} else {
+  printUsage();
+  rl.close();
+  process.exit(1);
+}
+
+// ── Helpers ──────────────────────────────────────────────
+
+function printUsage() {
+  console.log("");
+  console.log("  Usage:");
+  console.log(
+    "    stackmeter connect openclaw [--auto]   Connect OpenClaw to StackMeter"
+  );
+  console.log(
+    "    stackmeter disconnect openclaw          Disconnect and restore config"
+  );
+  console.log(
+    "    stackmeter gateway                      Start the StackMeter gateway"
+  );
+  console.log(
+    "    stackmeter gateway --self-test           Test the full pipeline"
+  );
+  console.log("");
+}
+
+function fatal(e) {
+  console.error(e);
+  rl.close();
+  process.exit(1);
+}
+
+function openBrowser(url) {
+  const p = platform();
+  const cmd = p === "darwin" ? "open" : p === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`, () => {});
+}
+
+function redactKey(key) {
+  if (!key || key.length < 8) return "****";
+  return `...${key.slice(-4)}`;
+}
+
+// ── Config readers / writers ─────────────────────────────
+
+function readOpenClawConfig() {
+  if (!existsSync(OC_CONFIG_PATH))
+    return { path: OC_CONFIG_PATH, config: null };
+  try {
+    return {
+      path: OC_CONFIG_PATH,
+      config: JSON.parse(readFileSync(OC_CONFIG_PATH, "utf-8")),
+    };
+  } catch {
+    return { path: OC_CONFIG_PATH, config: null };
+  }
+}
+
+function readStackMeterConfig() {
+  if (!existsSync(SM_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(SM_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeStackMeterConfig(data) {
+  if (!existsSync(SM_CONFIG_DIR))
+    mkdirSync(SM_CONFIG_DIR, { recursive: true });
+  writeFileSync(SM_CONFIG_PATH, JSON.stringify(data, null, 2) + "\n");
+  chmodSync(SM_CONFIG_PATH, 0o600);
+}
+
+// ── LaunchAgent helpers (macOS) ──────────────────────────
+
+function installLaunchAgent(nodePath, gatewayScript) {
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${LAUNCH_AGENT_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${gatewayScript}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${SM_GATEWAY_LOG}</string>
+    <key>StandardErrorPath</key>
+    <string>${SM_GATEWAY_ERR_LOG}</string>
+    <key>ThrottleInterval</key>
+    <integer>10</integer>
+</dict>
+</plist>`;
+
+  const laDir = dirname(PLIST_PATH);
+  if (!existsSync(laDir)) mkdirSync(laDir, { recursive: true });
+  writeFileSync(PLIST_PATH, plist);
+}
+
+function loadLaunchAgent() {
+  try {
+    execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`, {
+      stdio: "ignore",
+    });
+  } catch {}
+  execSync(`launchctl load "${PLIST_PATH}"`);
+}
+
+function unloadLaunchAgent() {
+  try {
+    execSync(`launchctl unload "${PLIST_PATH}"`, { stdio: "ignore" });
+  } catch {}
+  if (existsSync(PLIST_PATH)) unlinkSync(PLIST_PATH);
+}
+
+// ── connect openclaw ─────────────────────────────────────
+
+async function connectOpenClaw() {
+  const autoFlag = args.includes("--auto");
+  const isMac = platform() === "darwin";
+
+  console.log("");
+  console.log("  \u{1F517} StackMeter \u2014 Connect OpenClaw");
+  console.log("");
+
+  // ── Step 1: Get StackMeter base URL ────────────────
+  let baseUrl = process.env.STACKMETER_URL
+    ? process.env.STACKMETER_URL.replace(/\/api\/usage-events\/?$/, "")
+    : "";
+
+  if (!baseUrl) {
+    baseUrl = await rl.question(
+      `  StackMeter URL (default: ${DEFAULT_BASE_URL}): `
+    );
+    if (!baseUrl.trim()) baseUrl = DEFAULT_BASE_URL;
+  } else {
+    console.log(`  Using STACKMETER_URL: ${baseUrl}`);
+  }
+  baseUrl = baseUrl.replace(/\/+$/, "");
+  const apiUrl = `${baseUrl}/api/usage-events`;
+
+  // ── Step 2: Get or create tracking token ───────────
+  let token = process.env.STACKMETER_TOKEN || "";
+
+  if (token) {
+    console.log(
+      `  Existing STACKMETER_TOKEN found (sm_...${token.slice(-4)})`
+    );
+  } else {
+    console.log("");
+    console.log("  Opening StackMeter to generate a tracking token...");
+    openBrowser(`${baseUrl}/app/ai-usage`);
+    console.log(
+      `  If the browser didn't open, visit: ${baseUrl}/app/ai-usage`
+    );
+    console.log(
+      '  Click "Track OpenClaw usage" \u2192 "Generate tracking token" \u2192 copy the token.'
+    );
+    console.log("");
+
+    token = await rl.question("  Paste your tracking token (sm_...): ");
+    token = token.trim();
+  }
+
+  if (!token.startsWith("sm_")) {
+    console.log("  \u274C Invalid token format. Tokens start with sm_");
+    rl.close();
+    process.exit(1);
+  }
+
+  // ── Step 3: Verify token ───────────────────────────
+  console.log("");
+  console.log("  Verifying token...");
+
+  try {
+    const res = await fetch(apiUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        provider: "stackmeter",
+        model: "connection-test",
+        inputTokens: 0,
+        outputTokens: 0,
+        costCents: 0,
+        sourceType: "openclaw",
+        sourceId: "cli-connect",
+        dedupKey: `connect-test-${token.slice(-8)}`,
+      }),
+    });
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      const msg = err.error || res.statusText;
+
+      if (
+        /dedup_key.*(schema cache|does not exist|could not find)/i.test(msg)
+      ) {
+        console.log("");
+        console.log(
+          "  \u26A0\uFE0F  The 'dedup_key' column is missing from usage_events."
+        );
+        console.log("  Run this SQL in the Supabase SQL Editor:");
+        console.log("");
+        console.log(
+          "    alter table usage_events add column if not exists dedup_key text;"
+        );
+        console.log(
+          "    create unique index if not exists idx_usage_events_dedup"
+        );
+        console.log(
+          "      on usage_events(dedup_key) where dedup_key is not null;"
+        );
+        console.log("");
+        rl.close();
+        process.exit(1);
+      }
+
+      if (res.status === 401) {
+        console.log(
+          `  \u274C Invalid or revoked token. Generate a new one at ${baseUrl}/app/ai-usage`
+        );
+      } else {
+        console.log(`  \u274C Token verification failed: ${msg}`);
+      }
+      rl.close();
+      process.exit(1);
+    }
+  } catch (e) {
+    console.log(`  \u274C Could not reach ${apiUrl}`);
+    console.log(`     ${e.message}`);
+    console.log("");
+    console.log(
+      "  Check your internet connection or override with STACKMETER_URL."
+    );
+    rl.close();
+    process.exit(1);
+  }
+
+  console.log("  \u2705 Token verified!");
+  console.log("");
+
+  // ── Step 4: Read OpenClaw config ───────────────────
+  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.");
+    console.log(
+      "     Set models.providers.openai.apiKey in ~/.openclaw/openclaw.json"
+    );
+    console.log("     or: export OPENAI_API_KEY=sk-...");
+    rl.close();
+    process.exit(1);
+  }
+
+  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 ────────
+    if (isMac) {
+      // Copy gateway to stable path so LaunchAgent survives npx cache eviction
+      const gatewaySource = resolve(
+        __dirname, "..", "src", "gateway", "server.mjs"
+      );
+      if (!existsSync(gatewaySource)) {
+        console.log(`  \u274C Gateway script not found at ${gatewaySource}`);
+        rl.close();
+        process.exit(1);
+      }
+
+      copyFileSync(gatewaySource, SM_GATEWAY_PATH);
+      writeFileSync(
+        SM_LAUNCHER_PATH,
+        [
+          "#!/usr/bin/env node",
+          'import { startGateway } from "./gateway.mjs";',
+          "startGateway();",
+          "",
+        ].join("\n")
+      );
+
+      installLaunchAgent(process.execPath, SM_LAUNCHER_PATH);
+      loadLaunchAgent();
+
+      console.log("  \u2705 Gateway 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;
+
+      rl.close();
+      const { startGateway } = await import("../src/gateway/server.mjs");
+      await startGateway();
+      return;
+    }
+
+    console.log("");
+    console.log("  \u2705 Done! OpenClaw is connected to StackMeter.");
+    console.log("");
+    console.log(
+      "  Just run OpenClaw normally \u2014 no extra flags needed."
+    );
+    console.log(`  View your usage at ${baseUrl}/app/ai-usage`);
+    console.log("");
+    rl.close();
+  } else {
+    // ── 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(`     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("     npx @stackmeter/cli gateway");
+    console.log("");
+    console.log(
+      "  4. Start OpenClaw \u2014 traffic will flow through the gateway."
+    );
+    console.log("");
+    rl.close();
+  }
+}
+
+// ── disconnect openclaw ──────────────────────────────────
+
+async function disconnectOpenClaw() {
+  rl.close();
+  const isMac = platform() === "darwin";
+
+  console.log("");
+  console.log("  \u{1F50C} StackMeter \u2014 Disconnect OpenClaw");
+  console.log("");
+
+  // ── 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}`);
+    }
+  }
+
+  // ── Remove StackMeter config ───────────────────────
+  if (existsSync(SM_CONFIG_PATH)) {
+    unlinkSync(SM_CONFIG_PATH);
+    console.log(`  \u2705 Removed ${SM_CONFIG_PATH}`);
+  }
+
+  // ── Clean up gateway files ─────────────────────────
+  for (const f of [SM_GATEWAY_PATH, SM_LAUNCHER_PATH]) {
+    if (existsSync(f)) unlinkSync(f);
+  }
+
+  console.log("");
+  console.log("  \u2705 OpenClaw disconnected from StackMeter.");
+  console.log("     OpenClaw will now talk directly to OpenAI.");
+  console.log("");
+}
+
+// ── gateway ──────────────────────────────────────────────
+
+async function startGatewayCommand() {
+  const { startGateway } = await import("../src/gateway/server.mjs");
+  await startGateway();
+}
+
+// ── gateway --self-test ──────────────────────────────────
+
+async function selfTest() {
+  rl.close();
+
+  // 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) {
+    console.log("");
+    console.log(`  \u274C Missing: ${missing.join(", ")}`);
+    console.log("  Run: npx @stackmeter/cli connect openclaw --auto");
+    console.log(
+      "  or set them via env vars / ~/.stackmeter/config.json"
+    );
+    console.log("");
+    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("");
+
+  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)..."
+  );
+  try {
+    const compRes = await fetch(`${gwUrl}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "gpt-4o-mini",
+        messages: [{ role: "user", content: "Hi" }],
+        max_tokens: 1,
+      }),
+    });
+
+    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);
+    }
+
+    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);
+  }
+
+  // 3/3 — Wait for async StackMeter emit
+  console.log("  3/3 Waiting for StackMeter ingestion...");
+  await new Promise((r) => setTimeout(r, 2000));
+
+  if (emitStatus >= 200 && emitStatus < 300) {
+    console.log(`  \u2705 StackMeter ingestion returned ${emitStatus}`);
+  } else if (emitStatus > 0) {
+    console.log(
+      `  \u26A0\uFE0F  StackMeter ingestion returned ${emitStatus}`
+    );
+  } else {
+    console.log("  \u26A0\uFE0F  Could not confirm StackMeter ingestion");
+  }
+
+  console.log("");
+  console.log("  Self-test complete.");
+  console.log("");
+  server.close();
+  process.exit(0);
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@stackmeter/cli",
+  "version": "0.1.0",
+  "description": "Track your SaaS AI costs from the terminal. One-command OpenClaw setup.",
+  "type": "module",
+  "bin": {
+    "stackmeter": "./bin/stackmeter.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/gateway/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stackmeter/stackmeter"
+  },
+  "keywords": [
+    "ai",
+    "usage",
+    "tracking",
+    "openai",
+    "openclaw",
+    "saas",
+    "cost",
+    "llm"
+  ],
+  "license": "MIT",
+  "homepage": "https://stackmeter.app"
+}

package/src/gateway/server.mjs

@@ -0,0 +1,298 @@
+// StackMeter Gateway — OpenAI-compatible proxy with usage tracking.
+// Does NOT store prompts or responses. Only token counts + metadata.
+
+import { createServer } from "node:http";
+import { request as httpsRequest } from "node:https";
+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;
+
+// Cost per 1M tokens in cents (best-effort estimates)
+const MODEL_PRICING = {
+  "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 },
+};
+
+/* ── Config file readers (fallback when env vars not set) ── */
+
+function readStackMeterConfig() {
+  const p = join(homedir(), ".stackmeter", "config.json");
+  if (!existsSync(p)) return {};
+  try { return JSON.parse(readFileSync(p, "utf-8")); }
+  catch { return {}; }
+}
+
+function readOpenClawApiKey() {
+  const p = join(homedir(), ".openclaw", "openclaw.json");
+  if (!existsSync(p)) return null;
+  try {
+    const c = JSON.parse(readFileSync(p, "utf-8"));
+    return c?.models?.providers?.openai?.apiKey || null;
+  } catch { return null; }
+}
+
+/* ── Pricing + usage helpers ──────────────────────────────── */
+
+function estimateCostCents(model, inputTokens, outputTokens) {
+  let pricing = null;
+  for (const [key, val] of Object.entries(MODEL_PRICING)) {
+    if (model === key || model.startsWith(key + "-")) {
+      pricing = val;
+      break;
+    }
+  }
+  if (!pricing) return 0;
+  return Math.round(
+    (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000
+  );
+}
+
+async function emitUsageEvent(usage, model, smUrl, smToken) {
+  // Handle both Chat Completions (prompt_tokens) and Responses API (input_tokens)
+  const {
+    prompt_tokens = 0, completion_tokens = 0,
+    input_tokens = 0, output_tokens = 0,
+  } = usage;
+  const inTok = prompt_tokens || input_tokens;
+  const outTok = completion_tokens || output_tokens;
+  const costCents = estimateCostCents(model, inTok, outTok);
+
+  const event = {
+    provider: "openai",
+    model,
+    inputTokens: inTok,
+    outputTokens: outTok,
+    costCents,
+    sourceType: "openclaw",
+    sourceId: "openclaw",
+    ts: new Date().toISOString(),
+    dedupKey: `gw-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+  };
+
+  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(
+        `  [stackmeter] ${model} ${inTok}+${outTok} tokens \u2192 ${costCents}\u00A2 (${res.status})`
+      );
+    } else {
+      const err = await res.text().catch(() => "");
+      console.error(`  [stackmeter] emit failed (${res.status}): ${err}`);
+    }
+    return res.status;
+  } catch (err) {
+    console.error(`  [stackmeter] emit error: ${err.message}`);
+    return 0;
+  }
+}
+
+function extractUsageFromSSE(sseBuffer, smUrl, smToken) {
+  const lines = sseBuffer.split("\n");
+  let lastModel = "unknown";
+  let lastUsage = null;
+
+  for (const line of lines) {
+    if (!line.startsWith("data: ") || line === "data: [DONE]") continue;
+    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)
+      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 null;
+}
+
+/* ── Gateway server ───────────────────────────────────────── */
+
+export function startGateway(opts = {}) {
+  const smConfig = readStackMeterConfig();
+
+  const port =
+    opts.port ??
+    parseInt(
+      process.env.STACKMETER_GATEWAY_PORT ||
+      String(smConfig.gatewayPort || DEFAULT_PORT),
+      10
+    );
+
+  const openaiKey = process.env.OPENAI_API_KEY || readOpenClawApiKey();
+  const smUrl = process.env.STACKMETER_URL || smConfig.url;
+  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");
+    console.error("  or set it in ~/.stackmeter/config.json");
+    process.exit(1);
+  }
+  if (!smToken) {
+    console.error("  Error: STACKMETER_TOKEN is required.");
+    console.error("  Run: npx @stackmeter/cli connect openclaw --auto");
+    console.error("  or set it in ~/.stackmeter/config.json");
+    process.exit(1);
+  }
+
+  const server = createServer(async (req, res) => {
+    // Health check
+    if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      return res.end('{"ok":true}');
+    }
+
+    // Only proxy /v1/* paths
+    if (!req.url?.startsWith("/v1/")) {
+      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");
+
+    // Read body for methods that have one
+    let body = Buffer.alloc(0);
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      const chunks = [];
+      for await (const chunk of req) chunks.push(chunk);
+      body = Buffer.concat(chunks);
+    }
+
+    // If tracked + streaming Chat Completions, 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") {
+          parsed.stream_options = {
+            ...(parsed.stream_options || {}),
+            include_usage: true,
+          };
+          body = Buffer.from(JSON.stringify(parsed));
+        }
+      } catch {}
+    }
+
+    // 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";
+      upHeaders["Content-Length"] = String(body.length);
+    }
+
+    const upReq = httpsRequest(
+      targetUrl,
+      { method: req.method, headers: upHeaders },
+      (upRes) => {
+        // Forward response headers (skip hop-by-hop)
+        const fwd = {};
+        for (const [k, v] of Object.entries(upRes.headers)) {
+          if (!["transfer-encoding", "connection", "keep-alive"].includes(k)) {
+            fwd[k] = v;
+          }
+        }
+        res.writeHead(upRes.statusCode, fwd);
+
+        // Non-tracked or error: pipe through
+        if (!isTracked || upRes.statusCode >= 400) {
+          upRes.pipe(res);
+          return;
+        }
+
+        if (isStreaming) {
+          // Stream through, buffer SSE to extract usage from final chunk
+          let buf = "";
+          upRes.on("data", (c) => {
+            res.write(c);
+            buf += c.toString();
+          });
+          upRes.on("end", () => {
+            res.end();
+            const p = extractUsageFromSSE(buf, smUrl, smToken);
+            if (p && onEmit) p.then(onEmit);
+          });
+        } else {
+          // Buffer full response for usage extraction
+          const parts = [];
+          upRes.on("data", (c) => {
+            parts.push(c);
+            res.write(c);
+          });
+          upRes.on("end", () => {
+            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";
+              if (usage) {
+                const p = emitUsageEvent(usage, model, smUrl, smToken);
+                if (onEmit) p.then(onEmit);
+              }
+            } catch {}
+          });
+        }
+      }
+    );
+
+    upReq.on("error", (err) => {
+      if (!res.headersSent) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({ error: "Gateway error", detail: err.message })
+        );
+      }
+    });
+
+    if (body.length > 0) upReq.write(body);
+    upReq.end();
+  });
+
+  return new Promise((resolve) => {
+    server.listen(port, "127.0.0.1", () => {
+      const addr = server.address();
+      console.log("");
+      console.log("  StackMeter Gateway");
+      console.log(`  Listening:  http://127.0.0.1:${addr.port}`);
+      console.log(`  Proxying:   ${OPENAI_BASE_URL}`);
+      console.log(`  Reporting:  ${smUrl}`);
+      console.log(`  API key:    ...${openaiKey.slice(-4)}`);
+      console.log("");
+      resolve(server);
+    });
+  });
+}