anthropic-gateway 1.0.0

package/vendor/dist/utils/config.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.ensureProxyAuthToken = ensureProxyAuthToken;
+exports.preserveProxyAuthToken = preserveProxyAuthToken;
+exports.configExists = configExists;
+exports.getConfigDir = getConfigDir;
+exports.updateClaudeJson = updateClaudeJson;
+exports.updateClaudeSettings = updateClaudeSettings;
+exports.getClaudePaths = getClaudePaths;
+// Configuration file management utilities
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto_1 = require("crypto");
+const fileStorage_1 = require("./fileStorage");
+const CONFIG_DIR = path.join(os.homedir(), '.claude-adapter');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+/**
+ * Load configuration from ~/.claude-adapter/config.json
+ */
+function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_FILE)) {
+            return null;
+        }
+        (0, fileStorage_1.ensureDirExists)(CONFIG_DIR);
+        (0, fileStorage_1.hardenPrivateFile)(CONFIG_FILE);
+        const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save configuration to ~/.claude-adapter/config.json
+ */
+function saveConfig(config) {
+    (0, fileStorage_1.ensureDirExists)(CONFIG_DIR);
+    (0, fileStorage_1.writePrivateJsonFile)(CONFIG_FILE, config);
+}
+/**
+ * Add the proxy credential required by current versions to a legacy config.
+ * The value is generated once and then preserved through reconfiguration.
+ */
+function ensureProxyAuthToken(config) {
+    if (typeof config.proxyAuthToken === 'string' && config.proxyAuthToken.trim().length > 0) {
+        return config;
+    }
+    const migratedConfig = {
+        ...config,
+        proxyAuthToken: (0, crypto_1.randomBytes)(32).toString('base64url'),
+    };
+    saveConfig(migratedConfig);
+    return migratedConfig;
+}
+/** Preserve the existing proxy token when the provider configuration changes. */
+function preserveProxyAuthToken(nextConfig, previousConfig) {
+    return previousConfig?.proxyAuthToken
+        ? { ...nextConfig, proxyAuthToken: previousConfig.proxyAuthToken }
+        : nextConfig;
+}
+/**
+ * Check if configuration exists
+ */
+function configExists() {
+    return fs.existsSync(CONFIG_FILE);
+}
+/**
+ * Get the config directory path
+ */
+function getConfigDir() {
+    return CONFIG_DIR;
+}
+// Claude settings file paths
+const CLAUDE_JSON_PATH = path.join(os.homedir(), '.claude.json');
+const CLAUDE_SETTINGS_DIR = path.join(os.homedir(), '.claude');
+const CLAUDE_SETTINGS_PATH = path.join(CLAUDE_SETTINGS_DIR, 'settings.json');
+/**
+ * Update ~/.claude.json to set hasCompletedOnboarding
+ */
+function updateClaudeJson() {
+    let claudeJson = {};
+    try {
+        if (fs.existsSync(CLAUDE_JSON_PATH)) {
+            const content = fs.readFileSync(CLAUDE_JSON_PATH, 'utf-8');
+            claudeJson = JSON.parse(content);
+        }
+    }
+    catch {
+        // Start fresh if file is corrupted
+        claudeJson = {};
+    }
+    claudeJson.hasCompletedOnboarding = true;
+    // Do not change permissions on the user's entire home directory.
+    (0, fileStorage_1.writePrivateJsonFile)(CLAUDE_JSON_PATH, claudeJson, false);
+}
+/**
+ * Update ~/.claude/settings.json with proxy environment variables
+ */
+function updateClaudeSettings(proxyUrl, models, proxyAuthToken) {
+    (0, fileStorage_1.ensureDirExists)(CLAUDE_SETTINGS_DIR);
+    let settings = {};
+    try {
+        if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+            const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf-8');
+            settings = JSON.parse(content);
+        }
+    }
+    catch {
+        // Start fresh if file is corrupted
+        settings = {};
+    }
+    // Merge env settings
+    settings.env = {
+        ...(settings.env || {}),
+        ANTHROPIC_BASE_URL: proxyUrl,
+        ANTHROPIC_AUTH_TOKEN: proxyAuthToken,
+        ANTHROPIC_DEFAULT_OPUS_MODEL: models.opus,
+        ANTHROPIC_DEFAULT_SONNET_MODEL: models.sonnet,
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: models.haiku,
+    };
+    (0, fileStorage_1.writePrivateJsonFile)(CLAUDE_SETTINGS_PATH, settings);
+}
+/**
+ * Get paths for display purposes
+ */
+function getClaudePaths() {
+    return {
+        claudeJson: CLAUDE_JSON_PATH,
+        claudeSettings: CLAUDE_SETTINGS_PATH,
+    };
+}
+//# sourceMappingURL=config.js.map

package/vendor/dist/utils/errorLog.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordError = recordError;
+// Error logging utility
+const path_1 = require("path");
+const fileStorage_1 = require("./fileStorage");
+const ERROR_DIR = (0, path_1.join)((0, fileStorage_1.getBaseDir)(), 'error_logs');
+/**
+ * Get the file path for a given date
+ */
+function getErrorFilePath(dateStr) {
+    return (0, path_1.join)(ERROR_DIR, `${dateStr}.jsonl`);
+}
+/**
+ * Extract error details from various error types
+ */
+function extractErrorDetails(error) {
+    const details = {
+        message: error.message,
+    };
+    // Extract OpenAI SDK error properties
+    if ('status' in error) {
+        details.status = error.status;
+    }
+    if ('code' in error) {
+        details.code = error.code;
+    }
+    if ('type' in error) {
+        details.type = error.type;
+    }
+    return details;
+}
+/**
+ * Error codes that should not be logged (user errors, not API issues)
+ */
+const SKIP_ERROR_CODES = [401, 402, 404, 429];
+/**
+ * Record error to the daily file
+ * Non-blocking, fails silently on errors
+ * Skips common user errors like auth failures and rate limits
+ */
+function recordError(error, context) {
+    try {
+        // Skip logging for common user-related errors
+        if ('status' in error && SKIP_ERROR_CODES.includes(error.status)) {
+            return;
+        }
+        (0, fileStorage_1.ensureDirExists)(ERROR_DIR);
+        const record = {
+            timestamp: new Date().toISOString(),
+            ...context,
+            error: extractErrorDetails(error),
+        };
+        const filePath = getErrorFilePath((0, fileStorage_1.getTodayDateString)());
+        (0, fileStorage_1.appendJsonLine)(filePath, record);
+    }
+    catch {
+        // Fail silently - don't interrupt API flow for error logging
+    }
+}
+//# sourceMappingURL=errorLog.js.map

package/vendor/dist/utils/fileStorage.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTodayDateString = getTodayDateString;
+exports.ensureDirExists = ensureDirExists;
+exports.getBaseDir = getBaseDir;
+exports.repairPrivateStoragePermissions = repairPrivateStoragePermissions;
+exports.hardenPrivateFile = hardenPrivateFile;
+exports.appendJsonLine = appendJsonLine;
+exports.writePrivateJsonFile = writePrivateJsonFile;
+// Shared file storage utilities for daily JSON files
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const os_1 = require("os");
+const path_1 = require("path");
+// Base directory for all claude-adapter data
+const BASE_DIR = (0, path_1.join)((0, os_1.homedir)(), '.claude-adapter');
+/**
+ * Get today's date as YYYY-MM-DD
+ */
+function getTodayDateString() {
+    return new Date().toISOString().split('T')[0];
+}
+/**
+ * Ensure a directory exists, creating it if necessary
+ */
+function ensureDirExists(dirPath) {
+    if (!(0, fs_1.existsSync)(dirPath)) {
+        (0, fs_1.mkdirSync)(dirPath, { recursive: true, mode: 0o700 });
+    }
+    // Windows relies on the current user's profile ACL. POSIX modes protect
+    // configuration, metadata, usage, and error logs from other local users.
+    if (process.platform !== 'win32') {
+        (0, fs_1.chmodSync)(dirPath, 0o700);
+    }
+}
+/**
+ * Get the base storage directory
+ */
+function getBaseDir() {
+    return BASE_DIR;
+}
+/** Repair all existing adapter-owned storage permissions during startup. */
+function repairPrivateStoragePermissions(baseDir = BASE_DIR) {
+    if (process.platform === 'win32') {
+        return;
+    }
+    ensureDirExists(baseDir);
+    for (const entry of (0, fs_1.readdirSync)(baseDir, { withFileTypes: true })) {
+        const entryPath = (0, path_1.join)(baseDir, entry.name);
+        const stats = (0, fs_1.lstatSync)(entryPath);
+        // Never follow symlinks from the private storage tree.
+        if (stats.isSymbolicLink()) {
+            continue;
+        }
+        if (stats.isDirectory()) {
+            repairPrivateStoragePermissions(entryPath);
+        }
+        else if (stats.isFile()) {
+            (0, fs_1.chmodSync)(entryPath, 0o600);
+        }
+    }
+}
+/** Repair permissions on an existing private file. */
+function hardenPrivateFile(filePath) {
+    if (process.platform !== 'win32' && (0, fs_1.existsSync)(filePath)) {
+        (0, fs_1.chmodSync)(filePath, 0o600);
+    }
+}
+/**
+ * Append a JSON record to a file (one JSON object per line)
+ * This is atomic on most filesystems and avoids race conditions
+ */
+function appendJsonLine(filePath, record) {
+    ensureDirExists((0, path_1.dirname)(filePath));
+    const line = JSON.stringify(record) + '\n';
+    (0, fs_1.appendFileSync)(filePath, line, { encoding: 'utf-8', mode: 0o600 });
+    hardenPrivateFile(filePath);
+}
+/**
+ * Atomically replace a JSON file with a private file in the same directory.
+ * Keeping the temporary file adjacent to the destination makes rename atomic
+ * on the filesystems supported by this CLI.
+ */
+function writePrivateJsonFile(filePath, data, secureParentDirectory = true) {
+    const parentDirectory = (0, path_1.dirname)(filePath);
+    if (secureParentDirectory) {
+        ensureDirExists(parentDirectory);
+    }
+    else if (!(0, fs_1.existsSync)(parentDirectory)) {
+        (0, fs_1.mkdirSync)(parentDirectory, { recursive: true });
+    }
+    const tempPath = `${filePath}.${process.pid}.${(0, crypto_1.randomBytes)(8).toString('hex')}.tmp`;
+    let descriptor;
+    try {
+        descriptor = (0, fs_1.openSync)(tempPath, 'w', 0o600);
+        (0, fs_1.writeFileSync)(descriptor, JSON.stringify(data, null, 2), 'utf-8');
+        (0, fs_1.closeSync)(descriptor);
+        descriptor = undefined;
+        if (process.platform !== 'win32') {
+            (0, fs_1.chmodSync)(tempPath, 0o600);
+        }
+        (0, fs_1.renameSync)(tempPath, filePath);
+        hardenPrivateFile(filePath);
+    }
+    finally {
+        if (descriptor !== undefined) {
+            (0, fs_1.closeSync)(descriptor);
+        }
+        if ((0, fs_1.existsSync)(tempPath)) {
+            (0, fs_1.unlinkSync)(tempPath);
+        }
+    }
+}
+//# sourceMappingURL=fileStorage.js.map

package/vendor/dist/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Utility exports
+__exportStar(require("./config"), exports);
+//# sourceMappingURL=index.js.map

package/vendor/dist/utils/logger.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLogger = exports.Logger = exports.logger = exports.LogLevel = void 0;
+// Structured logger with levels and timestamps
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+const levelNames = {
+    [LogLevel.DEBUG]: 'DEBUG',
+    [LogLevel.INFO]: 'INFO',
+    [LogLevel.WARN]: 'WARN',
+    [LogLevel.ERROR]: 'ERROR',
+};
+const levelColors = {
+    [LogLevel.DEBUG]: '\x1b[90m', // gray
+    [LogLevel.INFO]: '\x1b[36m', // cyan
+    [LogLevel.WARN]: '\x1b[33m', // yellow
+    [LogLevel.ERROR]: '\x1b[31m', // red
+};
+const RESET = '\x1b[0m';
+class Logger {
+    level;
+    prefix;
+    constructor(prefix = 'adapter') {
+        this.prefix = prefix;
+        // Default to INFO, can be overridden by LOG_LEVEL env var
+        const envLevel = process.env.LOG_LEVEL?.toUpperCase();
+        this.level = this.parseLevel(envLevel) ?? LogLevel.INFO;
+    }
+    parseLevel(level) {
+        switch (level) {
+            case 'DEBUG':
+                return LogLevel.DEBUG;
+            case 'INFO':
+                return LogLevel.INFO;
+            case 'WARN':
+                return LogLevel.WARN;
+            case 'ERROR':
+                return LogLevel.ERROR;
+            default:
+                return undefined;
+        }
+    }
+    formatTimestamp() {
+        return new Date().toISOString();
+    }
+    log(level, message, meta) {
+        if (level < this.level)
+            return;
+        let output;
+        const color = levelColors[level];
+        // Use simple format for INFO in non-debug mode
+        if (level === LogLevel.INFO && this.level > LogLevel.DEBUG) {
+            output = `${color}${message}${RESET}`;
+            if (meta && Object.keys(meta).length > 0) {
+                output += ` ${color}${JSON.stringify(meta)}${RESET}`;
+            }
+        }
+        else {
+            // Full format with timestamp for DEBUG or when in debug mode
+            const levelName = levelNames[level].padEnd(5);
+            const timestamp = this.formatTimestamp();
+            output = `${color}[${timestamp}] [${this.prefix}] ${levelName}${RESET} ${message}`;
+            if (meta && Object.keys(meta).length > 0) {
+                output += ` ${JSON.stringify(meta)}`;
+            }
+        }
+        if (level === LogLevel.ERROR) {
+            console.error(output);
+        }
+        else {
+            console.log(output);
+        }
+    }
+    debug(message, meta) {
+        this.log(LogLevel.DEBUG, message, meta);
+    }
+    info(message, meta) {
+        this.log(LogLevel.INFO, message, meta);
+    }
+    warn(message, meta) {
+        this.log(LogLevel.WARN, message, meta);
+    }
+    error(message, error, meta) {
+        const errorMeta = error ? { error: error.message, ...meta } : meta;
+        this.log(LogLevel.ERROR, message, errorMeta);
+    }
+    print(message) {
+        console.log(message);
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    /**
+     * Create a child logger with request context
+     */
+    withRequestId(requestId) {
+        return new RequestLogger(this, requestId);
+    }
+}
+exports.Logger = Logger;
+/**
+ * Logger bound to a specific request ID for tracing
+ */
+class RequestLogger {
+    parent;
+    requestId;
+    constructor(parent, requestId) {
+        this.parent = parent;
+        this.requestId = requestId;
+    }
+    addContext(meta) {
+        return { requestId: this.requestId, ...meta };
+    }
+    debug(message, meta) {
+        this.parent.debug(message, this.addContext(meta));
+    }
+    info(message, meta) {
+        this.parent.info(message, this.addContext(meta));
+    }
+    warn(message, meta) {
+        this.parent.warn(message, this.addContext(meta));
+    }
+    error(message, error, meta) {
+        this.parent.error(message, error, this.addContext(meta));
+    }
+    print(message) {
+        this.parent.print(message);
+    }
+}
+exports.RequestLogger = RequestLogger;
+// Export singleton instance
+exports.logger = new Logger();
+//# sourceMappingURL=logger.js.map

package/vendor/dist/utils/metadata.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadata = getMetadata;
+exports.updateLatestVersion = updateLatestVersion;
+exports.getCachedLatestVersion = getCachedLatestVersion;
+// Metadata storage utility
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const package_json_1 = require("../../package.json");
+const fileStorage_1 = require("./fileStorage");
+const METADATA_DIR = (0, path_1.join)((0, os_1.homedir)(), '.claude-adapter');
+const METADATA_FILE = (0, path_1.join)(METADATA_DIR, 'metadata.json');
+/**
+ * Generate a unique user ID
+ */
+function generateUserId() {
+    return (0, crypto_1.randomBytes)(16).toString('hex');
+}
+/**
+ * Get OS name
+ */
+function getOsName() {
+    return (0, os_1.platform)();
+}
+/**
+ * Ensure metadata directory exists
+ */
+function ensureMetadataDir() {
+    (0, fileStorage_1.ensureDirExists)(METADATA_DIR);
+}
+let cachedMetadata = null;
+/**
+ * Load metadata from file
+ */
+function loadMetadata() {
+    if (cachedMetadata) {
+        return cachedMetadata;
+    }
+    try {
+        if ((0, fs_1.existsSync)(METADATA_FILE)) {
+            ensureMetadataDir();
+            (0, fileStorage_1.hardenPrivateFile)(METADATA_FILE);
+            const data = (0, fs_1.readFileSync)(METADATA_FILE, 'utf-8');
+            cachedMetadata = JSON.parse(data);
+            return cachedMetadata;
+        }
+    }
+    catch {
+        // Ignore read errors
+    }
+    return null;
+}
+/**
+ * Save metadata to file
+ */
+function saveMetadata(metadata) {
+    try {
+        ensureMetadataDir();
+        (0, fileStorage_1.writePrivateJsonFile)(METADATA_FILE, metadata);
+        cachedMetadata = metadata;
+    }
+    catch {
+        // Ignore write errors
+    }
+}
+/**
+ * Get or create metadata
+ * Creates new metadata on first run, updates currentVersion on subsequent runs
+ */
+function getMetadata() {
+    let metadata = loadMetadata();
+    if (!metadata) {
+        // First run - create new metadata
+        metadata = {
+            userId: generateUserId(),
+            platform: getOsName(),
+            platformRelease: (0, os_1.release)(),
+            currentVersion: package_json_1.version,
+            createdAt: new Date().toISOString(),
+        };
+        saveMetadata(metadata);
+    }
+    else {
+        // Update current version if changed
+        if (metadata.currentVersion !== package_json_1.version) {
+            metadata.currentVersion = package_json_1.version;
+            saveMetadata(metadata);
+        }
+    }
+    return metadata;
+}
+/**
+ * Update latest version in metadata (called after npm registry check)
+ */
+function updateLatestVersion(version) {
+    try {
+        const metadata = loadMetadata();
+        if (metadata) {
+            metadata.latestVersion = version;
+            metadata.latestVersionTimestamp = Date.now();
+            saveMetadata(metadata);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}
+/**
+ * Get cached latest version info
+ */
+function getCachedLatestVersion() {
+    try {
+        const metadata = loadMetadata();
+        if (metadata?.latestVersion && metadata?.latestVersionTimestamp) {
+            return {
+                version: metadata.latestVersion,
+                timestamp: metadata.latestVersionTimestamp,
+            };
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+//# sourceMappingURL=metadata.js.map

package/vendor/dist/utils/provider.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAzureOpenAIEndpoint = isAzureOpenAIEndpoint;
+function isAzureOpenAIEndpoint(baseUrl) {
+    try {
+        const url = new URL(baseUrl);
+        const hostname = url.hostname.toLowerCase();
+        return hostname.endsWith('.openai.azure.com') || hostname.includes('.services.ai.azure.com');
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=provider.js.map

package/vendor/dist/utils/tokenUsage.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordUsage = recordUsage;
+// Token usage storage utility
+const path_1 = require("path");
+const fileStorage_1 = require("./fileStorage");
+const USAGE_DIR = (0, path_1.join)((0, fileStorage_1.getBaseDir)(), 'token_usage');
+/**
+ * Get the file path for a given date
+ */
+function getUsageFilePath(dateStr) {
+    return (0, path_1.join)(USAGE_DIR, `${dateStr}.jsonl`);
+}
+/**
+ * Record token usage to the daily file
+ * Non-blocking, fails silently on errors
+ */
+function recordUsage(data) {
+    try {
+        (0, fileStorage_1.ensureDirExists)(USAGE_DIR);
+        const record = {
+            timestamp: new Date().toISOString(),
+            ...data
+        };
+        const filePath = getUsageFilePath((0, fileStorage_1.getTodayDateString)());
+        (0, fileStorage_1.appendJsonLine)(filePath, record);
+    }
+    catch {
+        // Fail silently - don't interrupt API flow for usage tracking
+    }
+}
+//# sourceMappingURL=tokenUsage.js.map