@revenium/claude-code-metering 0.1.3 → 0.1.5

package/tests/unit/test.test.ts

@@ -0,0 +1,165 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { testCommand } from "../../src/cli/commands/test.js";
+import * as loader from "../../src/core/config/loader.js";
+import * as client from "../../src/core/api/client.js";
+
+vi.mock("../../src/core/config/loader.js");
+vi.mock("../../src/core/api/client.js");
+vi.mock("chalk", () => ({
+  default: {
+    bold: (str: string) => str,
+    green: {
+      bold: (str: string) => str,
+    },
+    red: (str: string) => str,
+    yellow: (str: string) => str,
+    dim: (str: string) => str,
+  },
+}));
+vi.mock("ora", () => ({
+  default: () => ({
+    start: () => ({
+      succeed: vi.fn(),
+      fail: vi.fn(),
+    }),
+  }),
+}));
+
+describe("testCommand", () => {
+  const mockExit = vi
+    .spyOn(process, "exit")
+    .mockImplementation((code?: number) => {
+      throw new Error(`process.exit unexpectedly called with "${code}"`);
+    });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should exit with error when config does not exist", async () => {
+    vi.mocked(loader.configExists).mockReturnValue(false);
+
+    await expect(testCommand()).rejects.toThrow(
+      'process.exit unexpectedly called with "1"',
+    );
+  });
+
+  it("should exit with error when config cannot be loaded", async () => {
+    vi.mocked(loader.configExists).mockReturnValue(true);
+    vi.mocked(loader.loadConfig).mockResolvedValue(null);
+
+    await expect(testCommand()).rejects.toThrow(
+      'process.exit unexpectedly called with "1"',
+    );
+  });
+
+  it("should send test metric successfully", async () => {
+    vi.mocked(loader.configExists).mockReturnValue(true);
+    vi.mocked(loader.loadConfig).mockResolvedValue({
+      apiKey: "hak_test123",
+      endpoint: "https://api.revenium.ai",
+      email: "test@example.com",
+    });
+    vi.mocked(client.generateTestSessionId).mockReturnValue("test-session-123");
+    vi.mocked(client.createTestPayload).mockReturnValue({
+      resourceLogs: [],
+    });
+    vi.mocked(client.sendOtlpLogs).mockResolvedValue({
+      id: "metric-123",
+      resourceType: "claude-code-metering",
+      processedEvents: 1,
+      created: "2024-01-01T00:00:00Z",
+    });
+
+    await testCommand();
+
+    expect(client.generateTestSessionId).toHaveBeenCalled();
+    expect(client.createTestPayload).toHaveBeenCalledWith(
+      "test-session-123",
+      expect.objectContaining({
+        email: "test@example.com",
+      }),
+    );
+    expect(client.sendOtlpLogs).toHaveBeenCalledWith(
+      "https://api.revenium.ai",
+      "hak_test123",
+      expect.any(Object),
+    );
+  });
+
+  it("should include organizationId and productId in payload", async () => {
+    vi.mocked(loader.configExists).mockReturnValue(true);
+    vi.mocked(loader.loadConfig).mockResolvedValue({
+      apiKey: "hak_test123",
+      endpoint: "https://api.revenium.ai",
+      organizationId: "org-123",
+      productId: "prod-456",
+    });
+    vi.mocked(client.generateTestSessionId).mockReturnValue("test-session-123");
+    vi.mocked(client.createTestPayload).mockReturnValue({
+      resourceLogs: [],
+    });
+    vi.mocked(client.sendOtlpLogs).mockResolvedValue({
+      id: "metric-123",
+      resourceType: "claude-code-metering",
+      processedEvents: 1,
+      created: "2024-01-01T00:00:00Z",
+    });
+
+    await testCommand();
+
+    expect(client.createTestPayload).toHaveBeenCalledWith(
+      "test-session-123",
+      expect.objectContaining({
+        organizationId: "org-123",
+        productId: "prod-456",
+      }),
+    );
+  });
+
+  it("should handle verbose option", async () => {
+    vi.mocked(loader.configExists).mockReturnValue(true);
+    vi.mocked(loader.loadConfig).mockResolvedValue({
+      apiKey: "hak_test123",
+      endpoint: "https://api.revenium.ai",
+    });
+    vi.mocked(client.generateTestSessionId).mockReturnValue("test-session-123");
+    vi.mocked(client.createTestPayload).mockReturnValue({
+      resourceLogs: [],
+    });
+    vi.mocked(client.sendOtlpLogs).mockResolvedValue({
+      id: "metric-123",
+      resourceType: "claude-code-metering",
+      processedEvents: 1,
+      created: "2024-01-01T00:00:00Z",
+    });
+
+    await testCommand({ verbose: true });
+
+    expect(client.sendOtlpLogs).toHaveBeenCalled();
+  });
+
+  it("should exit with error when sendOtlpLogs fails", async () => {
+    vi.mocked(loader.configExists).mockReturnValue(true);
+    vi.mocked(loader.loadConfig).mockResolvedValue({
+      apiKey: "hak_test123",
+      endpoint: "https://api.revenium.ai",
+    });
+    vi.mocked(client.generateTestSessionId).mockReturnValue("test-session-123");
+    vi.mocked(client.createTestPayload).mockReturnValue({
+      resourceLogs: [],
+    });
+    vi.mocked(client.sendOtlpLogs).mockRejectedValue(
+      new Error("Network error"),
+    );
+
+    await expect(testCommand()).rejects.toThrow(
+      'process.exit unexpectedly called with "1"',
+    );
+  });
+});
+

package/tests/unit/validator.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect } from "vitest";
+import {
+  validateApiKey,
+  validateEmail,
+  validateSubscriptionTier,
+  validateConfig,
+  validateEndpointUrl,
+} from "../../src/core/config/validator.js";
+
+describe("validateApiKey", () => {
+  it("should accept valid API key format", () => {
+    const result = validateApiKey("hak_tenant_abc123xyz");
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("should reject empty API key", () => {
+    const result = validateApiKey("");
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("API key is required");
+  });
+
+  it("should reject API key without hak_ prefix", () => {
+    const result = validateApiKey("invalid_key_123");
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("hak_"))).toBe(true);
+  });
+
+  it("should reject API key with wrong format", () => {
+    const result = validateApiKey("hak_short");
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("format"))).toBe(true);
+  });
+
+  it("should reject very short API keys", () => {
+    const result = validateApiKey("hak_x_y");
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("short"))).toBe(true);
+  });
+});
+
+describe("validateEmail", () => {
+  it("should accept valid email", () => {
+    const result = validateEmail("user@example.com");
+    expect(result.valid).toBe(true);
+  });
+
+  it("should accept empty email (optional)", () => {
+    const result = validateEmail("");
+    expect(result.valid).toBe(true);
+  });
+
+  it("should reject invalid email format", () => {
+    const result = validateEmail("invalid-email");
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("Invalid email format");
+  });
+
+  it("should reject email without domain", () => {
+    const result = validateEmail("user@");
+    expect(result.valid).toBe(false);
+  });
+});
+
+describe("validateSubscriptionTier", () => {
+  it("should accept valid tiers", () => {
+    const tiers = [
+      "pro",
+      "max_5x",
+      "max_20x",
+      "team_premium",
+      "enterprise",
+      "api",
+    ];
+    for (const tier of tiers) {
+      const result = validateSubscriptionTier(tier);
+      expect(result.valid).toBe(true);
+    }
+  });
+
+  it("should accept empty tier (optional)", () => {
+    const result = validateSubscriptionTier("");
+    expect(result.valid).toBe(true);
+  });
+
+  it("should reject invalid tier", () => {
+    const result = validateSubscriptionTier("invalid");
+    expect(result.valid).toBe(false);
+    expect(
+      result.errors.some((e) => e.includes("Invalid subscription tier"))
+    ).toBe(true);
+  });
+});
+
+describe("validateConfig", () => {
+  it("should accept valid complete config", () => {
+    const result = validateConfig({
+      apiKey: "hak_tenant_abc123xyz",
+      endpoint: "https://api.revenium.ai",
+      email: "user@example.com",
+      subscriptionTier: "pro",
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("should accept valid minimal config", () => {
+    const result = validateConfig({
+      apiKey: "hak_tenant_abc123xyz",
+      endpoint: "https://api.revenium.ai",
+    });
+    expect(result.valid).toBe(true);
+  });
+
+  it("should reject invalid endpoint URL", () => {
+    const result = validateConfig({
+      apiKey: "hak_tenant_abc123xyz",
+      endpoint: "not-a-url",
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("Invalid endpoint URL"))).toBe(
+      true
+    );
+  });
+
+  it("should reject missing endpoint", () => {
+    const result = validateConfig({
+      apiKey: "hak_tenant_abc123xyz",
+      endpoint: "",
+    });
+    expect(result.valid).toBe(false);
+    expect(
+      result.errors.some((e) => e.includes("Endpoint URL is required"))
+    ).toBe(true);
+  });
+
+  it("should reject HTTP endpoint", () => {
+    const result = validateConfig({
+      apiKey: "hak_tenant_abc123xyz",
+      endpoint: "http://api.example.com",
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("HTTPS is required"))).toBe(
+      true
+    );
+  });
+});
+
+describe("validateEndpointUrl", () => {
+  it("should accept HTTPS endpoint", () => {
+    const result = validateEndpointUrl("https://api.revenium.ai");
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("should reject HTTP endpoint", () => {
+    const result = validateEndpointUrl("http://api.example.com");
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("HTTPS is required"))).toBe(
+      true
+    );
+  });
+
+  it("should reject FTP endpoint", () => {
+    const result = validateEndpointUrl("ftp://api.example.com");
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("HTTPS is required"))).toBe(
+      true
+    );
+  });
+
+  it("should reject WebSocket endpoint", () => {
+    const result = validateEndpointUrl("ws://api.example.com");
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("HTTPS is required"))).toBe(
+      true
+    );
+  });
+
+  it("should reject file:// endpoint", () => {
+    const result = validateEndpointUrl("file:///etc/passwd");
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("HTTPS is required"))).toBe(
+      true
+    );
+  });
+
+  it("should reject empty endpoint", () => {
+    const result = validateEndpointUrl("");
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("Endpoint URL is required");
+  });
+
+  it("should reject invalid URL format", () => {
+    const result = validateEndpointUrl("not-a-valid-url");
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("Invalid endpoint URL"))).toBe(
+      true
+    );
+  });
+
+  it("should accept HTTPS with port", () => {
+    const result = validateEndpointUrl("https://api.example.com:8443");
+    expect(result.valid).toBe(true);
+  });
+
+  it("should accept HTTPS with path", () => {
+    const result = validateEndpointUrl("https://api.example.com/v1/endpoint");
+    expect(result.valid).toBe(true);
+  });
+});

package/tests/unit/writer.test.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  writeConfig,
+  getConfigFilePath,
+} from "../../src/core/config/writer.js";
+import { writeFile, mkdir, chmod } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+vi.mock("node:fs/promises");
+vi.mock("node:os");
+
+describe("writer", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(homedir).mockReturnValue("/home/user");
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("writeConfig", () => {
+    it("should create directory if it does not exist", async () => {
+      const config = {
+        apiKey: "hak_test123",
+        endpoint: "https://api.revenium.ai",
+      };
+
+      await writeConfig(config);
+
+      expect(mkdir).toHaveBeenCalledWith("/home/user/.claude", {
+        recursive: true,
+      });
+    });
+
+    it("should write config file with correct content", async () => {
+      const config = {
+        apiKey: "hak_test123",
+        endpoint: "https://api.revenium.ai",
+      };
+
+      await writeConfig(config);
+
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("export CLAUDE_CODE_ENABLE_TELEMETRY=1"),
+        { encoding: "utf-8" },
+      );
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("export OTEL_EXPORTER_OTLP_ENDPOINT="),
+        { encoding: "utf-8" },
+      );
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("x-api-key=hak_test123"),
+        { encoding: "utf-8" },
+      );
+    });
+
+    it("should set file permissions to 0600", async () => {
+      const config = {
+        apiKey: "hak_test123",
+        endpoint: "https://api.revenium.ai",
+      };
+
+      await writeConfig(config);
+
+      expect(chmod).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        0o600,
+      );
+    });
+
+    it("should include email when provided", async () => {
+      const config = {
+        apiKey: "hak_test123",
+        endpoint: "https://api.revenium.ai",
+        email: "test@example.com",
+      };
+
+      await writeConfig(config);
+
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("export REVENIUM_SUBSCRIBER_EMAIL="),
+        { encoding: "utf-8" },
+      );
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("test@example.com"),
+        { encoding: "utf-8" },
+      );
+    });
+
+    it("should include subscription tier and cost multiplier when provided", async () => {
+      const config = {
+        apiKey: "hak_test123",
+        endpoint: "https://api.revenium.ai",
+        subscriptionTier: "pro" as const,
+      };
+
+      await writeConfig(config);
+
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("export CLAUDE_CODE_SUBSCRIPTION="),
+        { encoding: "utf-8" },
+      );
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("cost_multiplier="),
+        { encoding: "utf-8" },
+      );
+    });
+
+    it("should escape special characters in API key", async () => {
+      const config = {
+        apiKey: 'hak_test"$`\\special',
+        endpoint: "https://api.revenium.ai",
+      };
+
+      await writeConfig(config);
+
+      const writeFileCall = vi.mocked(writeFile).mock.calls[0];
+      const content = writeFileCall[1] as string;
+
+      expect(content).toContain('\\"');
+      expect(content).toContain("\\$");
+      expect(content).toContain("\\`");
+      expect(content).toContain("\\\\");
+    });
+
+    it("should return the config file path", async () => {
+      const config = {
+        apiKey: "hak_test123",
+        endpoint: "https://api.revenium.ai",
+      };
+
+      const path = await writeConfig(config);
+
+      expect(path).toBe("/home/user/.claude/revenium.env");
+    });
+
+    it("should include organizationId and productId in OTEL_RESOURCE_ATTRIBUTES", async () => {
+      const config = {
+        apiKey: "hak_test123",
+        endpoint: "https://api.revenium.ai",
+        subscriptionTier: "pro" as const,
+        organizationId: "org-123",
+        productId: "prod-456",
+      };
+
+      await writeConfig(config);
+
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("organization.name=org-123"),
+        { encoding: "utf-8" },
+      );
+      expect(writeFile).toHaveBeenCalledWith(
+        "/home/user/.claude/revenium.env",
+        expect.stringContaining("product.name=prod-456"),
+        { encoding: "utf-8" },
+      );
+    });
+  });
+
+  describe("getConfigFilePath", () => {
+    it("should return correct config file path", () => {
+      const path = getConfigFilePath();
+      expect(path).toBe("/home/user/.claude/revenium.env");
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}