@revenium/claude-code-metering 0.1.4 → 0.1.6

package/tests/unit/client.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  createTestPayload,
+  generateTestSessionId,
+  sendOtlpLogs,
+  checkEndpointHealth,
+} from "../../src/core/api/client.js";
+
+global.fetch = vi.fn();
+
+describe("generateTestSessionId", () => {
+  it("should generate unique session IDs", () => {
+    const id1 = generateTestSessionId();
+    const id2 = generateTestSessionId();
+    expect(id1).not.toBe(id2);
+  });
+
+  it("should start with test- prefix", () => {
+    const id = generateTestSessionId();
+    expect(id.startsWith("test-")).toBe(true);
+  });
+});
+
+describe("createTestPayload", () => {
+  it("should create valid OTLP payload structure", () => {
+    const sessionId = "test-session-123";
+    const payload = createTestPayload(sessionId);
+
+    expect(payload.resourceLogs).toHaveLength(1);
+    expect(payload.resourceLogs[0].scopeLogs).toHaveLength(1);
+    expect(payload.resourceLogs[0].scopeLogs[0].logRecords).toHaveLength(1);
+  });
+
+  it("should include correct session ID in payload", () => {
+    const sessionId = "test-session-456";
+    const payload = createTestPayload(sessionId);
+
+    const attrs = payload.resourceLogs[0].scopeLogs[0].logRecords[0].attributes;
+    const sessionAttr = attrs.find((a) => a.key === "session.id");
+    expect(sessionAttr?.value.stringValue).toBe(sessionId);
+  });
+
+  it("should include claude_code.api_request body", () => {
+    const payload = createTestPayload("test");
+    const body = payload.resourceLogs[0].scopeLogs[0].logRecords[0].body;
+    expect(body.stringValue).toBe("claude_code.api_request");
+  });
+
+  it("should include all required attributes", () => {
+    const payload = createTestPayload("test");
+    const attrs = payload.resourceLogs[0].scopeLogs[0].logRecords[0].attributes;
+    const attrKeys = attrs.map((a) => a.key);
+
+    expect(attrKeys).toContain("session.id");
+    expect(attrKeys).toContain("model");
+    expect(attrKeys).toContain("input_tokens");
+    expect(attrKeys).toContain("output_tokens");
+    expect(attrKeys).toContain("cost_usd");
+    expect(attrKeys).toContain("duration_ms");
+  });
+});
+
+describe("sendOtlpLogs", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should send POST request to correct endpoint", async () => {
+    const mockResponse = {
+      ok: true,
+      status: 200,
+      json: vi.fn().mockResolvedValue({ processedEvents: 1 }),
+    };
+    vi.mocked(global.fetch).mockResolvedValue(mockResponse as any);
+
+    const payload = createTestPayload("test-session");
+    await sendOtlpLogs("https://api.revenium.ai", "hak_test123", payload);
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.revenium.ai/meter/v2/otlp/v1/logs",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "x-api-key": "hak_test123",
+        }),
+      }),
+    );
+  });
+
+  it("should throw error on non-ok response", async () => {
+    const mockResponse = {
+      ok: false,
+      status: 401,
+      statusText: "Unauthorized",
+      text: vi.fn().mockResolvedValue("Invalid API key"),
+    };
+    vi.mocked(global.fetch).mockResolvedValue(mockResponse as any);
+
+    const payload = createTestPayload("test-session");
+
+    await expect(
+      sendOtlpLogs("https://api.revenium.ai", "hak_invalid", payload),
+    ).rejects.toThrow("OTLP request failed: 401 Unauthorized");
+  });
+
+  it("should throw error on network failure", async () => {
+    vi.mocked(global.fetch).mockRejectedValue(new Error("Network error"));
+
+    const payload = createTestPayload("test-session");
+
+    await expect(
+      sendOtlpLogs("https://api.revenium.ai", "hak_test123", payload),
+    ).rejects.toThrow("Network error");
+  });
+});
+
+describe("checkEndpointHealth", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should return healthy status on 200 response", async () => {
+    const mockResponse = {
+      ok: true,
+      status: 200,
+      json: vi.fn().mockResolvedValue({ processedEvents: 1 }),
+    };
+    vi.mocked(global.fetch).mockResolvedValue(mockResponse as any);
+
+    const result = await checkEndpointHealth(
+      "https://api.revenium.ai",
+      "hak_test123",
+    );
+
+    expect(result.healthy).toBe(true);
+    expect(result.statusCode).toBe(200);
+    expect(result.message).toContain("Endpoint healthy");
+  });
+
+  it("should return unhealthy status on 401 response", async () => {
+    const mockResponse = {
+      ok: false,
+      status: 401,
+      statusText: "Unauthorized",
+      text: vi.fn().mockResolvedValue("Invalid API key"),
+    };
+    vi.mocked(global.fetch).mockResolvedValue(mockResponse as any);
+
+    const result = await checkEndpointHealth(
+      "https://api.revenium.ai",
+      "hak_invalid",
+    );
+
+    expect(result.healthy).toBe(false);
+    expect(result.statusCode).toBe(401);
+    expect(result.message).toContain("401");
+  });
+
+  it("should return unhealthy status on network error", async () => {
+    vi.mocked(global.fetch).mockRejectedValue(new Error("Network timeout"));
+
+    const result = await checkEndpointHealth(
+      "https://api.revenium.ai",
+      "hak_test123",
+    );
+
+    expect(result.healthy).toBe(false);
+    expect(result.message).toContain("Network timeout");
+  });
+
+  it("should measure latency", async () => {
+    const mockResponse = {
+      ok: true,
+      status: 200,
+      json: vi.fn().mockResolvedValue({ id: "test-123" }),
+    };
+    vi.mocked(global.fetch).mockResolvedValue(mockResponse as any);
+
+    const result = await checkEndpointHealth(
+      "https://api.revenium.ai",
+      "hak_test123",
+    );
+
+    expect(result.latencyMs).toBeGreaterThanOrEqual(0);
+  });
+});

package/tests/unit/detector.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  validateConfigPath,
+  getSourceCommand,
+  detectShell,
+  getProfilePath,
+} from "../../src/core/shell/detector.js";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+
+vi.mock("node:fs");
+vi.mock("node:os");
+
+describe("validateConfigPath", () => {
+  it("should accept valid path with alphanumeric and safe characters", () => {
+    expect(() =>
+      validateConfigPath("/home/user/.claude/revenium.env"),
+    ).not.toThrow();
+    expect(() => validateConfigPath("~/.claude/revenium.env")).not.toThrow();
+    expect(() => validateConfigPath("/opt/config-file_v1.0.env")).not.toThrow();
+  });
+
+  it("should reject path with semicolon", () => {
+    expect(() => validateConfigPath("/path;rm -rf /")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should reject path with backticks", () => {
+    expect(() => validateConfigPath("/path/`whoami`/file")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should reject path with dollar sign", () => {
+    expect(() => validateConfigPath("/path/$(whoami)/file")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should reject path with pipe", () => {
+    expect(() => validateConfigPath("/path/file | cat")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should reject path with ampersand", () => {
+    expect(() => validateConfigPath("/path/file & echo")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should reject path with newline", () => {
+    expect(() => validateConfigPath("/path/file\nrm -rf /")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should accept path with spaces", () => {
+    expect(() => validateConfigPath("/path with spaces/file")).not.toThrow();
+    expect(() =>
+      validateConfigPath("/Users/John Doe/.claude/revenium.env"),
+    ).not.toThrow();
+  });
+
+  it("should accept path with tilde", () => {
+    expect(() => validateConfigPath("~/config.env")).not.toThrow();
+  });
+
+  it("should accept path with dots", () => {
+    expect(() =>
+      validateConfigPath("/home/user/.config/file.env"),
+    ).not.toThrow();
+  });
+
+  it("should accept path with hyphens and underscores", () => {
+    expect(() =>
+      validateConfigPath("/opt/my-app_config/file-v1_0.env"),
+    ).not.toThrow();
+  });
+});
+
+describe("getSourceCommand", () => {
+  const validPath = "/home/user/.claude/revenium.env";
+
+  it("should generate valid bash source command", () => {
+    const command = getSourceCommand("bash", validPath);
+    expect(command).toContain('if [ -f "');
+    expect(command).toContain(validPath);
+    expect(command).toContain('source "');
+    expect(command).toContain("# Source Revenium Claude Code metering config");
+  });
+
+  it("should generate valid zsh source command", () => {
+    const command = getSourceCommand("zsh", validPath);
+    expect(command).toContain('if [ -f "');
+    expect(command).toContain(validPath);
+    expect(command).toContain('source "');
+  });
+
+  it("should generate valid fish source command", () => {
+    const command = getSourceCommand("fish", validPath);
+    expect(command).toContain('if test -f "');
+    expect(command).toContain(validPath);
+    expect(command).toContain("export (cat");
+    expect(command).toContain("# Source Revenium Claude Code metering config");
+  });
+
+  it("should properly quote path in bash command", () => {
+    const command = getSourceCommand("bash", validPath);
+    expect(command).toMatch(/"[^"]+"/);
+  });
+
+  it("should properly quote path in fish command", () => {
+    const command = getSourceCommand("fish", validPath);
+    expect(command).toMatch(/"[^"]+"/);
+  });
+
+  it("should throw error for invalid path with semicolon", () => {
+    expect(() => getSourceCommand("bash", "/path;rm -rf /")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should throw error for invalid path with backticks", () => {
+    expect(() => getSourceCommand("fish", "/path/`whoami`")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should throw error for invalid path with dollar sign", () => {
+    expect(() => getSourceCommand("zsh", "/path/$(cmd)")).toThrow(
+      /Invalid config path/,
+    );
+  });
+
+  it("should handle unknown shell type with bash syntax", () => {
+    const command = getSourceCommand("unknown", validPath);
+    expect(command).toContain('if [ -f "');
+    expect(command).toContain('source "');
+  });
+});
+
+describe("detectShell", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env = { ...originalEnv };
+    vi.mocked(homedir).mockReturnValue("/home/user");
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    vi.restoreAllMocks();
+  });
+
+  it("should detect zsh from SHELL environment variable", () => {
+    process.env.SHELL = "/bin/zsh";
+    const shell = detectShell();
+    expect(shell).toBe("zsh");
+  });
+
+  it("should detect bash from SHELL environment variable", () => {
+    process.env.SHELL = "/bin/bash";
+    const shell = detectShell();
+    expect(shell).toBe("bash");
+  });
+
+  it("should detect fish from SHELL environment variable", () => {
+    process.env.SHELL = "/usr/bin/fish";
+    const shell = detectShell();
+    expect(shell).toBe("fish");
+  });
+
+  it("should fallback to detecting zsh from .zshrc file", () => {
+    process.env.SHELL = "";
+    vi.mocked(existsSync).mockImplementation(
+      (path) => path === "/home/user/.zshrc",
+    );
+    const shell = detectShell();
+    expect(shell).toBe("zsh");
+  });
+
+  it("should fallback to detecting fish from config.fish file", () => {
+    process.env.SHELL = "";
+    vi.mocked(existsSync).mockImplementation(
+      (path) => path === "/home/user/.config/fish/config.fish",
+    );
+    const shell = detectShell();
+    expect(shell).toBe("fish");
+  });
+
+  it("should fallback to detecting bash from .bashrc file", () => {
+    process.env.SHELL = "";
+    vi.mocked(existsSync).mockImplementation(
+      (path) => path === "/home/user/.bashrc",
+    );
+    const shell = detectShell();
+    expect(shell).toBe("bash");
+  });
+
+  it("should return unknown when no shell is detected", () => {
+    process.env.SHELL = "";
+    vi.mocked(existsSync).mockReturnValue(false);
+    const shell = detectShell();
+    expect(shell).toBe("unknown");
+  });
+});
+
+describe("getProfilePath", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(homedir).mockReturnValue("/home/user");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should return .zshrc path for zsh", () => {
+    const path = getProfilePath("zsh");
+    expect(path).toBe("/home/user/.zshrc");
+  });
+
+  it("should return .bashrc path for bash when it exists", () => {
+    vi.mocked(existsSync).mockReturnValue(true);
+    const path = getProfilePath("bash");
+    expect(path).toBe("/home/user/.bashrc");
+  });
+
+  it("should return .bash_profile path for bash when .bashrc does not exist", () => {
+    vi.mocked(existsSync).mockReturnValue(false);
+    const path = getProfilePath("bash");
+    expect(path).toBe("/home/user/.bash_profile");
+  });
+
+  it("should return config.fish path for fish", () => {
+    const path = getProfilePath("fish");
+    expect(path).toBe("/home/user/.config/fish/config.fish");
+  });
+
+  it("should return null for unknown shell", () => {
+    const path = getProfilePath("unknown");
+    expect(path).toBeNull();
+  });
+});

package/tests/unit/hashing.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { generateTransactionId, type TransactionIdComponents } from '../../src/utils/hashing.js';
+
+describe('generateTransactionId', () => {
+  const baseComponents: TransactionIdComponents = {
+    sessionId: '5345477c-26de-46ed-8eb1-d1deea0ee61f',
+    timestamp: '2026-01-13T15:15:09.790Z',
+    model: 'claude-opus-4-5-20251101',
+    inputTokens: 100,
+    outputTokens: 50,
+    cacheReadTokens: 1000,
+    cacheCreationTokens: 500,
+  };
+
+  it('should generate a 32-character hex string', () => {
+    const result = generateTransactionId(baseComponents);
+    expect(result).toHaveLength(32);
+    expect(result).toMatch(/^[0-9a-f]{32}$/);
+  });
+
+  it('should be deterministic (same input produces same output)', () => {
+    const result1 = generateTransactionId(baseComponents);
+    const result2 = generateTransactionId(baseComponents);
+    const result3 = generateTransactionId({ ...baseComponents });
+    expect(result1).toBe(result2);
+    expect(result1).toBe(result3);
+  });
+
+  it('should produce different outputs for different inputs', () => {
+    const result1 = generateTransactionId(baseComponents);
+    const result2 = generateTransactionId({
+      ...baseComponents,
+      inputTokens: 101,
+    });
+    expect(result1).not.toBe(result2);
+  });
+
+  it('should be sensitive to sessionId changes', () => {
+    const result1 = generateTransactionId(baseComponents);
+    const result2 = generateTransactionId({
+      ...baseComponents,
+      sessionId: 'different-session-id',
+    });
+    expect(result1).not.toBe(result2);
+  });
+
+  it('should be sensitive to timestamp changes', () => {
+    const result1 = generateTransactionId(baseComponents);
+    const result2 = generateTransactionId({
+      ...baseComponents,
+      timestamp: '2026-01-13T15:15:09.791Z',
+    });
+    expect(result1).not.toBe(result2);
+  });
+
+  it('should be sensitive to model changes', () => {
+    const result1 = generateTransactionId(baseComponents);
+    const result2 = generateTransactionId({
+      ...baseComponents,
+      model: 'claude-sonnet-4-20250514',
+    });
+    expect(result1).not.toBe(result2);
+  });
+
+  it('should handle zero token values', () => {
+    const zeroTokenComponents: TransactionIdComponents = {
+      sessionId: 'test-session',
+      timestamp: '2026-01-01T00:00:00.000Z',
+      model: 'test-model',
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+    };
+    const result = generateTransactionId(zeroTokenComponents);
+    expect(result).toHaveLength(32);
+    expect(result).toMatch(/^[0-9a-f]{32}$/);
+  });
+
+  it('should handle large token values', () => {
+    const largeTokenComponents: TransactionIdComponents = {
+      ...baseComponents,
+      inputTokens: 1000000,
+      outputTokens: 500000,
+      cacheReadTokens: 10000000,
+      cacheCreationTokens: 5000000,
+    };
+    const result = generateTransactionId(largeTokenComponents);
+    expect(result).toHaveLength(32);
+    expect(result).toMatch(/^[0-9a-f]{32}$/);
+  });
+
+  /**
+   * CROSS-IMPLEMENTATION VERIFICATION TEST
+   *
+   * This test vector must produce the same hash in both:
+   * - TypeScript (this implementation)
+   * - Kotlin (ClaudeCodeMapper.kt in the backend)
+   *
+   * If you change the hash formula, update both implementations
+   * and regenerate this expected value.
+   */
+  it('should produce known hash for test vector (cross-implementation verification)', () => {
+    const testVector: TransactionIdComponents = {
+      sessionId: '5345477c-26de-46ed-8eb1-d1deea0ee61f',
+      timestamp: '2026-01-13T15:15:09.790Z',
+      model: 'claude-opus-4-5-20251101',
+      inputTokens: 100,
+      outputTokens: 50,
+      cacheReadTokens: 1000,
+      cacheCreationTokens: 500,
+    };
+
+    const result = generateTransactionId(testVector);
+
+    // This is the expected hash for the above input.
+    // The Kotlin implementation must produce the same value.
+    // Input string: "5345477c-26de-46ed-8eb1-d1deea0ee61f|2026-01-13T15:15:09.790Z|claude-opus-4-5-20251101|100|50|1000|500"
+    expect(result).toBe('a4ae0241320cd35508c022af01424382');
+  });
+});