anthropic-gateway 1.0.0

package/vendor/dist/utils/ui.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UI = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("./logger");
+// Claude Code Inspired Palette
+const Palette = {
+    Brand: '#D97757', // Warm Terracotta (Main Brand)
+    Error: '#D95858', // Soft Red
+    Warning: '#D9A458', // Mustard Yellow
+    Dim: '#6B6B6B', // Dark Gray
+    Text: '#E6E6E6', // Off-White
+    Border: '#3F3F3F', // Subtle Border
+    Highlight: '#A78BFA', // Soft Purple (Files/Links)
+};
+class UI {
+    static log(message) {
+        logger_1.logger.print(message);
+    }
+    static info(message) {
+        this.log(`${chalk_1.default.hex(Palette.Dim).bold('•')} ${chalk_1.default.hex(Palette.Text)(message)}`);
+    }
+    static success(message) {
+        this.log(`${chalk_1.default.hex(Palette.Brand)('✔')} ${chalk_1.default.hex(Palette.Brand)(message)}`);
+    }
+    static warning(message) {
+        this.log(`${chalk_1.default.hex(Palette.Dim)('⚠')} ${message}`);
+    }
+    static error(message, error) {
+        this.log(`${chalk_1.default.hex(Palette.Dim)('✖')} ${message}`);
+        if (error && error.message) {
+            this.log(chalk_1.default.hex(Palette.Error)(`  ${error.message}`));
+        }
+    }
+    static header(subtitle) {
+        this.log('');
+        this.log(chalk_1.default.hex(Palette.Dim)(`  ${subtitle}`));
+        this.log('');
+    }
+    static status(text) {
+        this.log(`${chalk_1.default.hex(Palette.Dim)('•')} ${chalk_1.default.hex(Palette.Text)(text)}`);
+    }
+    static statusDone(success = true, text) {
+        if (success) {
+            this.log(`${chalk_1.default.hex(Palette.Dim)('✔')} ${text || ''}`);
+        }
+        else {
+            this.log(`${chalk_1.default.hex(Palette.Dim)('✖')} ${text || ''}`);
+        }
+    }
+    static box(title, content) {
+        const border = chalk_1.default.hex(Palette.Border)('──────────────────────────────────────────────────');
+        this.log('');
+        this.log(border);
+        this.log(chalk_1.default.hex(Palette.Brand).bold(`  ${title}`));
+        this.log(border);
+        content.forEach((line) => this.log(`  ${line}`));
+        this.log(border);
+        this.log('');
+    }
+    static newUrl(url) {
+        return chalk_1.default.hex(Palette.Highlight).bold.underline(url);
+    }
+    static dim(text) {
+        return chalk_1.default.hex(Palette.Dim)(text);
+    }
+    static highlight(text) {
+        return chalk_1.default.hex(Palette.Highlight)(text);
+    }
+    static hint(text) {
+        this.log(`  ${chalk_1.default.hex(Palette.Dim)(text)}`);
+    }
+    static banner() {
+        const brand = chalk_1.default.hex(Palette.Brand);
+        const dim = chalk_1.default.hex(Palette.Dim);
+        // USB adapter with CLAUDE text inside
+        const art = [
+            '',
+            dim('     ┌────────────────────┐'),
+            dim('     │ ') + brand('┌─┐┬  ┌─┐┬ ┬┌┬┐┌─┐') + dim(' ├──┐'),
+            dim('     │ ') + brand('│  │  ├─┤│ │ ││├┤ ') + dim(' │▓▓│'),
+            dim('     │ ') + brand('└─┘┴─┘┴ ┴└─┘─┴┘└─┘') + dim(' ├──┘'),
+            dim('     └──────•ADAPTER──────┘'),
+            '',
+        ];
+        art.forEach((line) => this.log(line));
+    }
+    static table(rows) {
+        const maxLabelWidth = Math.max(...rows.map((r) => r.label.length));
+        this.log('');
+        rows.forEach((row) => {
+            const paddedLabel = row.label.padEnd(maxLabelWidth);
+            this.log(`  ${chalk_1.default.hex(Palette.Dim)(paddedLabel)}  ${chalk_1.default.hex(Palette.Highlight)(row.value)}`);
+        });
+        this.log('');
+    }
+    static updateNotify(current, latest) {
+        this.log('');
+        this.log(`${chalk_1.default.hex(Palette.Dim)('•')} ${chalk_1.default.hex(Palette.Text)('Update available:')} ${chalk_1.default.hex(Palette.Dim)(current)} ${chalk_1.default.hex(Palette.Dim)('→')} ${chalk_1.default.hex(Palette.Highlight)(latest)}`);
+        this.hint('Run "npm i -g claude-adapter" to update');
+    }
+}
+exports.UI = UI;
+//# sourceMappingURL=ui.js.map

package/vendor/dist/utils/update.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdates = checkForUpdates;
+exports.getCachedUpdateInfo = getCachedUpdateInfo;
+const https_1 = __importDefault(require("https"));
+const package_json_1 = require("../../package.json");
+const metadata_1 = require("./metadata");
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+/**
+ * Compare two semantic versions
+ * Returns true if latest is greater than current
+ */
+function isNewerVersion(latest, current) {
+    const parseVersion = (v) => v.split('.').map(n => parseInt(n, 10) || 0);
+    const [latestParts, currentParts] = [parseVersion(latest), parseVersion(current)];
+    for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+        const l = latestParts[i] || 0;
+        const c = currentParts[i] || 0;
+        if (l > c)
+            return true;
+        if (l < c)
+            return false;
+    }
+    return false;
+}
+/**
+ * Check if cached version is still valid (within 24 hours)
+ */
+function isCacheValid(timestamp) {
+    return Date.now() - timestamp < CACHE_TTL;
+}
+/**
+ * Fetch latest version from npm registry
+ */
+function fetchLatestVersion() {
+    return new Promise((resolve) => {
+        const timeout = setTimeout(() => resolve(null), 3000); // 3s timeout
+        https_1.default.get('https://registry.npmjs.org/claude-adapter/latest', (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                clearTimeout(timeout);
+                try {
+                    const { version } = JSON.parse(data);
+                    resolve(version);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+        }).on('error', () => {
+            clearTimeout(timeout);
+            resolve(null);
+        });
+    });
+}
+/**
+ * Check for updates with 24-hour caching
+ * Non-blocking, fails silently on errors
+ */
+async function checkForUpdates() {
+    try {
+        // Check cache first
+        const cache = (0, metadata_1.getCachedLatestVersion)();
+        if (cache && isCacheValid(cache.timestamp)) {
+            return {
+                current: package_json_1.version,
+                latest: cache.version,
+                hasUpdate: isNewerVersion(cache.version, package_json_1.version)
+            };
+        }
+        // Fetch from registry
+        const latest = await fetchLatestVersion();
+        if (!latest) {
+            return null;
+        }
+        // Update cache in metadata
+        (0, metadata_1.updateLatestVersion)(latest);
+        return {
+            current: package_json_1.version,
+            latest,
+            hasUpdate: isNewerVersion(latest, package_json_1.version)
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get cached update info synchronously (for use in request converter)
+ * Returns null if cache doesn't exist or is expired
+ */
+function getCachedUpdateInfo() {
+    try {
+        const cache = (0, metadata_1.getCachedLatestVersion)();
+        if (cache && isCacheValid(cache.timestamp)) {
+            return {
+                current: package_json_1.version,
+                latest: cache.version,
+                hasUpdate: isNewerVersion(cache.version, package_json_1.version)
+            };
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+//# sourceMappingURL=update.js.map

package/vendor/dist/utils/validation.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAnthropicRequest = validateAnthropicRequest;
+exports.formatValidationErrors = formatValidationErrors;
+/**
+ * Validate an incoming Anthropic Messages API request
+ */
+function validateAnthropicRequest(body) {
+    const errors = [];
+    // Check if body is an object
+    if (!body || typeof body !== 'object') {
+        return { valid: false, errors: [{ field: 'body', message: 'Request body must be an object' }] };
+    }
+    const request = body;
+    // Required field: model
+    if (!request.model || typeof request.model !== 'string') {
+        errors.push({ field: 'model', message: 'model is required and must be a string' });
+    }
+    // Required field: max_tokens
+    if (request.max_tokens === undefined || typeof request.max_tokens !== 'number') {
+        errors.push({ field: 'max_tokens', message: 'max_tokens is required and must be a number' });
+    }
+    else if (request.max_tokens <= 0) {
+        errors.push({ field: 'max_tokens', message: 'max_tokens must be a positive number' });
+    }
+    // Required field: messages
+    if (!request.messages) {
+        errors.push({ field: 'messages', message: 'messages is required' });
+    }
+    else if (!Array.isArray(request.messages)) {
+        errors.push({ field: 'messages', message: 'messages must be an array' });
+    }
+    else if (request.messages.length === 0) {
+        errors.push({ field: 'messages', message: 'messages array cannot be empty' });
+    }
+    else {
+        // Validate each message
+        const messageErrors = validateMessages(request.messages);
+        errors.push(...messageErrors);
+    }
+    // Optional field validations
+    if (request.temperature !== undefined) {
+        if (typeof request.temperature !== 'number' ||
+            request.temperature < 0 ||
+            request.temperature > 1) {
+            errors.push({
+                field: 'temperature',
+                message: 'temperature must be a number between 0 and 1',
+            });
+        }
+    }
+    if (request.top_p !== undefined) {
+        if (typeof request.top_p !== 'number' || request.top_p < 0 || request.top_p > 1) {
+            errors.push({ field: 'top_p', message: 'top_p must be a number between 0 and 1' });
+        }
+    }
+    if (request.stream !== undefined && typeof request.stream !== 'boolean') {
+        errors.push({ field: 'stream', message: 'stream must be a boolean' });
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Validate message array structure
+ */
+function validateMessages(messages) {
+    const errors = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg || typeof msg !== 'object') {
+            errors.push({ field: `messages[${i}]`, message: 'message must be an object' });
+            continue;
+        }
+        const message = msg;
+        // Validate role - accept any string role for forward compatibility
+        // Claude Code may introduce new roles (e.g., from session-start hooks)
+        // The converter will map unknown roles to valid OpenAI roles downstream
+        if (!message.role || typeof message.role !== 'string') {
+            errors.push({
+                field: `messages[${i}].role`,
+                message: 'role is required and must be a string',
+            });
+        }
+        // Validate content - allow missing/empty content for forward compatibility
+        // Some message types (e.g., hook attachments) may have minimal content
+        if (message.content !== undefined && message.content !== null) {
+            if (typeof message.content !== 'string' && !Array.isArray(message.content)) {
+                errors.push({
+                    field: `messages[${i}].content`,
+                    message: 'content must be a string or array',
+                });
+            }
+            else if (Array.isArray(message.content)) {
+                const contentErrors = validateContentBlocks(message.content, i);
+                errors.push(...contentErrors);
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Validate content blocks array
+ */
+function validateContentBlocks(blocks, messageIndex) {
+    const errors = [];
+    for (let j = 0; j < blocks.length; j++) {
+        const block = blocks[j];
+        if (!block || typeof block !== 'object') {
+            errors.push({
+                field: `messages[${messageIndex}].content[${j}]`,
+                message: 'content block must be an object',
+            });
+            continue;
+        }
+        const contentBlock = block;
+        if (!contentBlock.type || typeof contentBlock.type !== 'string') {
+            errors.push({
+                field: `messages[${messageIndex}].content[${j}].type`,
+                message: 'content block type is required',
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Format validation errors into a human-readable message
+ */
+function formatValidationErrors(errors) {
+    return errors.map((e) => `${e.field}: ${e.message}`).join('; ');
+}
+//# sourceMappingURL=validation.js.map

package/vendor/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "anthropic-gateway-vendor",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Vendored conversion core from claude-adapter (MIT) — see vendor/LICENSE.claude-adapter"
+}