squidgems 0.1.0

package/README.md

@@ -0,0 +1,62 @@
+# squidgems
+
+Track your [Claude Code](https://docs.anthropic.com/en/docs/claude-code) costs, tokens, and sessions in real time.
+
+SquidGems connects to Claude Code via OpenTelemetry and gives you a live dashboard showing per-session cost breakdowns, token usage, and tool invocations.
+
+## Install
+
+```bash
+npm install -g squidgems
+```
+
+## Quick Start
+
+**1. Register your machine**
+
+```bash
+squidgems
+```
+
+Generates a stable local identity and registers it with the SquidGems API.
+
+**2. Connect Claude Code**
+
+```bash
+squidgems init --claude
+```
+
+Configures Claude Code to emit OpenTelemetry data to SquidGems. Opens your dashboard automatically.
+
+**3. Use Claude Code as normal**
+
+Sessions appear in real time at your dashboard on [squidgems.ink](https://squidgems.ink).
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `squidgems` | Register your machine (run once) |
+| `squidgems init --claude` | Connect Claude Code to SquidGems |
+| `squidgems disable --claude` | Disconnect Claude Code from SquidGems |
+| `squidgems uninstall` | Remove all SquidGems config from your machine |
+
+## What gets tracked
+
+- Session start/end times
+- Token usage (input, output, cache)
+- Cost per session (calculated from token counts)
+- Tool invocations and durations
+- Errors and retries
+
+All data is tied to an anonymous machine identity. No source code or prompt content is collected.
+
+## Requirements
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) installed
+- Node.js 18+
+
+## Links
+
+- [Dashboard](https://squidgems.ink)
+- [Report issues](mailto:hello@squidgems.ink)

package/bin/squidgems

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("../dist/index.js");

package/dist/index.js

@@ -0,0 +1,447 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  __mainPromise: () => __mainPromise
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/settings-merge.ts
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+function claudeDirExists() {
+  return import_fs.default.existsSync(import_path.default.join(import_os.default.homedir(), ".claude"));
+}
+function getSettingsPath() {
+  return import_path.default.join(import_os.default.homedir(), ".claude", "settings.json");
+}
+function readSettings() {
+  const settingsPath = getSettingsPath();
+  if (!import_fs.default.existsSync(settingsPath)) {
+    return {};
+  }
+  const raw = import_fs.default.readFileSync(settingsPath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    console.warn("Warning: settings.json is malformed. Creating backup and starting fresh.");
+    import_fs.default.writeFileSync(`${settingsPath}.bak`, raw);
+    return {};
+  }
+}
+function buildOtelEnv(userId) {
+  return {
+    CLAUDE_CODE_ENABLE_TELEMETRY: "1",
+    OTEL_LOGS_EXPORTER: "otlp",
+    OTEL_EXPORTER_OTLP_PROTOCOL: "http/protobuf",
+    OTEL_EXPORTER_OTLP_ENDPOINT: process.env.SQUIDGEMS_OTEL_ENDPOINT ?? "https://claude.otel.squidgems.ink",
+    OTEL_LOG_TOOL_DETAILS: "1",
+    OTEL_RESOURCE_ATTRIBUTES: `X_Squid_User_Id=${userId}`
+  };
+}
+function mergeOtelEnv(userId) {
+  const settingsPath = getSettingsPath();
+  const existing = readSettings();
+  const otelEnv = buildOtelEnv(userId);
+  const {
+    OTEL_EXPORTER_OTLP_HEADERS: _h,
+    OTEL_RESOURCE_ATTRIBUTES: _r,
+    ...restEnv
+  } = existing.env ?? {};
+  const updated = {
+    ...existing,
+    otelHeadersHelper: "squidgems token",
+    env: {
+      ...restEnv,
+      ...otelEnv
+    }
+  };
+  import_fs.default.mkdirSync(import_path.default.dirname(settingsPath), { recursive: true });
+  import_fs.default.writeFileSync(settingsPath, JSON.stringify(updated, null, 2), "utf8");
+}
+function disableOtel() {
+  const settingsPath = getSettingsPath();
+  const existing = readSettings();
+  const { otelHeadersHelper: _, ...rest } = existing;
+  const updated = {
+    ...rest,
+    env: {
+      ...existing.env,
+      CLAUDE_CODE_ENABLE_TELEMETRY: "0"
+    }
+  };
+  import_fs.default.mkdirSync(import_path.default.dirname(settingsPath), { recursive: true });
+  import_fs.default.writeFileSync(settingsPath, JSON.stringify(updated, null, 2), "utf8");
+}
+
+// src/disable-claude.ts
+function runDisableClaude() {
+  if (!claudeDirExists()) {
+    console.log("Claude Code is not installed — nothing to disable.");
+    return;
+  }
+  disableOtel();
+  console.log("✓ Telemetry disabled in ~/.claude/settings.json");
+  console.log("Run `squidgems init --claude` to re-enable.");
+}
+
+// src/api-client.ts
+var API_BASE = process.env.SQUIDGEMS_API_URL ?? "https://api.squidgems.ink";
+async function lookupMachineId(machineId) {
+  const url = `${API_BASE}/api/squid/install?machine_id=${encodeURIComponent(machineId)}`;
+  const res = await fetch(url);
+  if (res.status === 200) {
+    const data = await res.json();
+    return data.user_id_squid;
+  }
+  if (res.status === 204)
+    return null;
+  throw new Error(`Unexpected status: ${res.status}`);
+}
+async function registerInstall(userId, machineId) {
+  const res = await fetch(`${API_BASE}/api/squid/install`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ user_id_squid: userId, machine_id: machineId })
+  });
+  if (!res.ok)
+    throw new Error(`Registration failed: ${res.status}`);
+}
+async function requestToken(squidId) {
+  const res = await fetch(`${API_BASE}/api/squid/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ squid_id: squidId })
+  });
+  if (res.status === 403 || res.status === 404)
+    return null;
+  if (!res.ok)
+    throw new Error(`Token request failed: ${res.status}`);
+  const data = await res.json();
+  return data.token;
+}
+async function refreshToken(squidId, token) {
+  const res = await fetch(`${API_BASE}/api/squid/token/refresh`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ token })
+  });
+  if (res.status === 401 || res.status === 403)
+    return null;
+  if (!res.ok)
+    throw new Error(`Token refresh failed: ${res.status}`);
+  const data = await res.json();
+  return data.token;
+}
+
+// src/config-file.ts
+var import_crypto = __toESM(require("crypto"));
+var import_fs2 = __toESM(require("fs"));
+var import_os2 = __toESM(require("os"));
+var import_path2 = __toESM(require("path"));
+function generateUserId() {
+  return `squid_${import_crypto.default.randomBytes(16).toString("hex")}`;
+}
+function getConfigPath() {
+  return import_path2.default.join(import_os2.default.homedir(), ".squidgems", "config.json");
+}
+function readConfig() {
+  const configPath = getConfigPath();
+  try {
+    const raw = import_fs2.default.readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.userId === "string") {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeConfig(config) {
+  const configPath = getConfigPath();
+  import_fs2.default.mkdirSync(import_path2.default.dirname(configPath), { recursive: true });
+  import_fs2.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+}
+function updateConfigToken(token) {
+  const config = readConfig();
+  if (!config)
+    return;
+  if (token) {
+    writeConfig({ ...config, token });
+  } else {
+    const { token: _, ...rest } = config;
+    writeConfig(rest);
+  }
+}
+async function getOrCreateUserId() {
+  const cached = readConfig();
+  if (cached)
+    return cached.userId;
+  const userId = generateUserId();
+  writeConfig({ userId });
+  return userId;
+}
+
+// src/open-browser.ts
+var import_child_process = require("child_process");
+function openBrowser(url) {
+  let cmd;
+  let args;
+  switch (process.platform) {
+    case "darwin":
+      cmd = "open";
+      args = [url];
+      break;
+    case "win32":
+      cmd = "cmd";
+      args = ["/c", "start", url];
+      break;
+    default:
+      cmd = "xdg-open";
+      args = [url];
+  }
+  try {
+    const child = import_child_process.spawn(cmd, args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  } catch {}
+}
+
+// src/init-claude.ts
+async function runInitClaude() {
+  console.log("\uD83D\uDD0D Checking for Claude Code...");
+  if (!claudeDirExists()) {
+    console.error("Claude Code is not installed. Install it from: https://claude.ai/code");
+    process.exit(1);
+  }
+  const userId = await getOrCreateUserId();
+  console.log("\uD83D\uDD27 Configuring OpenTelemetry...");
+  mergeOtelEnv(userId);
+  console.log("✓ Modified ~/.claude/settings.json");
+  try {
+    const token = await requestToken(userId);
+    if (token) {
+      updateConfigToken(token);
+      console.log("✓ Token cached");
+    } else {
+      console.warn("Warning: Could not obtain token. Run `squidgems` first to register.");
+    }
+  } catch {
+    console.warn("Warning: Token request failed. Will retry on next session.");
+  }
+  console.log("\uD83C\uDD94 Generating your tracking ID...");
+  console.log(`✓ User ID: ${userId}`);
+  const baseUrl = process.env.SQUIDGEMS_WEB_URL ?? "https://squidgems.ink";
+  let dashboardUrl = `${baseUrl}/sessions/${userId}?provider=claude`;
+  const config = readConfig();
+  if (config?.token) {
+    dashboardUrl += `&token=${encodeURIComponent(config.token)}`;
+  }
+  console.log("\uD83D\uDE80 Opening dashboard...");
+  openBrowser(dashboardUrl);
+  console.log(`✓ Browser opened at: ${dashboardUrl}`);
+  console.log("\uD83C\uDF89 You're all set!");
+  console.log("Claude Code is now configured to send telemetry to your SquidGems dashboard.");
+  console.log(`View your sessions at: ${dashboardUrl}`);
+}
+
+// src/machine-id.ts
+var import_child_process2 = require("child_process");
+var import_crypto2 = __toESM(require("crypto"));
+var import_fs3 = __toESM(require("fs"));
+function getRawSources() {
+  switch (process.platform) {
+    case "darwin": {
+      const out = import_child_process2.execSync("ioreg -rd1 -c IOPlatformExpertDevice", { encoding: "utf8" });
+      const uuidMatch = out.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (!uuidMatch)
+        throw new Error("IOPlatformUUID not found in ioreg output");
+      const serialMatch = out.match(/"IOPlatformSerialNumber"\s*=\s*"([^"]+)"/);
+      return [uuidMatch[1], serialMatch ? serialMatch[1] : ""];
+    }
+    case "linux": {
+      const machineId = import_fs3.default.readFileSync("/etc/machine-id", "utf8").trim();
+      let productUuid = "";
+      try {
+        productUuid = import_fs3.default.readFileSync("/sys/class/dmi/id/product_uuid", "utf8").trim();
+      } catch {}
+      return [machineId, productUuid];
+    }
+    case "win32": {
+      const regOut = import_child_process2.execSync("reg query HKLM\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid", {
+        encoding: "utf8"
+      });
+      const guidMatch = regOut.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
+      if (!guidMatch)
+        throw new Error("MachineGuid not found in registry output");
+      const biosOut = import_child_process2.execSync("wmic bios get serialnumber", { encoding: "utf8" });
+      const biosMatch = biosOut.match(/SerialNumber\s+(\S+)/i);
+      return [guidMatch[1], biosMatch ? biosMatch[1] : ""];
+    }
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+function getMachineId() {
+  try {
+    const [src1, src2] = getRawSources();
+    return import_crypto2.default.createHash("sha256").update(`${src1}:${src2}`).digest("hex");
+  } catch {
+    return null;
+  }
+}
+
+// src/installer.ts
+async function runInstaller() {
+  try {} catch {
+    console.error("Failed to install squidgems globally.");
+    console.error("Try running with sudo: sudo npm install -g squidgems");
+    process.exit(1);
+  }
+  const userId = await getOrCreateUserId();
+  const registeredId = await syncInstall(userId);
+  console.log(`Your autogenerated id: ${registeredId}`);
+  console.log("Installation is done \uD83E\uDD91");
+  console.log("Enable cost tracking: `squidgems init --claude`");
+}
+async function syncInstall(localId) {
+  const machineId = getMachineId();
+  if (!machineId)
+    return localId;
+  try {
+    const existing = await lookupMachineId(machineId);
+    if (existing) {
+      if (existing !== localId)
+        writeConfig({ userId: existing });
+      return existing;
+    }
+    await registerInstall(localId, machineId);
+  } catch (err) {
+    console.error(`[squidgems] sync failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return localId;
+}
+
+// src/token.ts
+function output(headers) {
+  process.stdout.write(JSON.stringify(headers));
+}
+async function runToken() {
+  const config = readConfig();
+  if (!config) {
+    output({});
+    return;
+  }
+  const { userId, token: cachedToken } = config;
+  if (cachedToken) {
+    try {
+      const newToken = await refreshToken(userId, cachedToken);
+      if (newToken) {
+        updateConfigToken(newToken);
+        output({ X_Squid_Token: newToken, X_Squid_User_Id: userId });
+      } else {
+        updateConfigToken(null);
+        output({});
+      }
+    } catch {
+      output({ X_Squid_Token: cachedToken, X_Squid_User_Id: userId });
+    }
+    return;
+  }
+  try {
+    const token = await requestToken(userId);
+    if (token) {
+      updateConfigToken(token);
+      output({ X_Squid_Token: token, X_Squid_User_Id: userId });
+    } else {
+      output({});
+    }
+  } catch {
+    output({});
+  }
+}
+
+// src/uninstall.ts
+var import_fs4 = __toESM(require("fs"));
+var import_os3 = __toESM(require("os"));
+var import_path3 = __toESM(require("path"));
+function runUninstall() {
+  if (!claudeDirExists()) {
+    console.log("Claude Code is not installed — skipping telemetry disable.");
+  } else {
+    disableOtel();
+    console.log("✓ Telemetry disabled in ~/.claude/settings.json");
+  }
+  const squidDir = import_path3.default.join(import_os3.default.homedir(), ".squidgems");
+  if (import_fs4.default.existsSync(squidDir)) {
+    import_fs4.default.rmSync(squidDir, { recursive: true, force: true });
+    console.log("✓ Removed ~/.squidgems");
+  } else {
+    console.log("~/.squidgems not found — nothing to remove.");
+  }
+  console.log("Done. To remove the CLI: npm uninstall -g squidgems");
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var __mainPromise = (async () => {
+  if (args[0] === "init" && args[1] === "--claude") {
+    await runInitClaude();
+  } else if (args[0] === "disable" && args[1] === "--claude") {
+    runDisableClaude();
+  } else if (args[0] === "token") {
+    await runToken();
+  } else if (args[0] === "uninstall") {
+    runUninstall();
+  } else if (args.length === 0) {
+    await runInstaller();
+  } else {
+    console.error(`Unknown command: ${args.join(" ")}`);
+    console.error("Usage: squidgems [init --claude | disable --claude | uninstall]");
+    process.exit(1);
+  }
+})();

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "squidgems",
+  "version": "0.1.0",
+  "description": "Track Claude Code costs, tokens, and sessions in real time",
+  "private": false,
+  "type": "commonjs",
+  "license": "UNLICENSED",
+  "author": "SquidGems",
+  "homepage": "https://squidgems.ink",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "opentelemetry",
+    "telemetry",
+    "cost-tracking",
+    "ai",
+    "anthropic"
+  ],
+  "bin": {
+    "squidgems": "bin/squidgems"
+  },
+  "files": [
+    "bin/squidgems",
+    "dist/index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "node dist/index.js",
+    "build": "bun build src/index.ts --outdir dist --target node --format cjs",
+    "start": "node dist/index.js",
+    "lint": "eslint",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "clean": "rm -rf node_modules dist"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@vitest/coverage-v8": "^3.0.0",
+    "typescript": "^5",
+    "vitest": "^3.0.0"
+  }
+}