@askalf/dario 2.3.0 → 2.4.0

package/dist/proxy.js

@@ -1,6 +1,9 @@
 import { createServer } from 'node:http';
 import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { execSync, spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 import { arch, platform, version as nodeVersion } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
 const ANTHROPIC_API = 'https://api.anthropic.com';
@@ -45,12 +48,120 @@ function detectClaudeVersion() {
 }
 const SESSION_ID = randomUUID();
 const OS_NAME = platform === 'win32' ? 'Windows' : platform === 'darwin' ? 'MacOS' : 'Linux';
+// Claude Code device identity — required for Max plan billing classification.
+// Without metadata.user_id, Anthropic classifies requests as third-party and
+// routes them to Extra Usage billing instead of the Max plan allocation.
+function loadClaudeIdentity() {
+    const paths = [
+        join(homedir(), '.claude.json'), // Windows / Linux / macOS (live config)
+        join(homedir(), '.claude', '.claude.json'), // Alternative location
+        join(homedir(), '.claude', 'claude.json'),
+    ];
+    // Also check backup files as fallback
+    try {
+        const backupDir = join(homedir(), '.claude', 'backups');
+        const files = require('fs').readdirSync(backupDir);
+        const backups = files
+            .filter((f) => f.startsWith('.claude.json.backup.'))
+            .sort()
+            .reverse();
+        for (const b of backups)
+            paths.push(join(backupDir, b));
+    }
+    catch { /* no backups dir */ }
+    for (const p of paths) {
+        try {
+            const data = JSON.parse(readFileSync(p, 'utf-8'));
+            if (data.userID) {
+                // accountUuid lives inside oauthAccount, not at root
+                const accountUuid = data.oauthAccount?.accountUuid ?? data.accountUuid ?? '';
+                return { deviceId: data.userID, accountUuid };
+            }
+        }
+        catch { /* try next */ }
+    }
+    return { deviceId: '', accountUuid: '' };
+}
 // Model shortcuts — users can pass short names
 const MODEL_ALIASES = {
     'opus': 'claude-opus-4-6',
+    'opus1m': 'claude-opus-4-6[1m]',
     'sonnet': 'claude-sonnet-4-6',
+    'sonnet1m': 'claude-sonnet-4-6[1m]',
     'haiku': 'claude-haiku-4-5',
 };
+// Beta prefixes that trigger Extra Usage billing on Max subscriptions.
+// Stripping these prevents surprise charges while keeping caching/thinking/1M active.
+const BILLABLE_BETA_PREFIXES = [
+    'extended-cache-ttl-', // Extended cache TTLs beyond default
+    'context-management-', // Auto-compaction / context management
+    'prompt-caching-scope-', // Extended prompt caching scope
+];
+/** Filter out billable betas from client-provided beta header. */
+function filterBillableBetas(betas) {
+    return betas.split(',').map(b => b.trim()).filter(b => b.length > 0 && !BILLABLE_BETA_PREFIXES.some(p => b.startsWith(p))).join(',');
+}
+// Orchestration tags injected by agents (Aider, Cursor, OpenCode, etc.)
+// that confuse Claude when passed through. Strip before forwarding.
+const ORCHESTRATION_TAG_NAMES = [
+    'system-reminder', 'env', 'system_information', 'current_working_directory',
+    'operating_system', 'default_shell', 'home_directory', 'task_metadata',
+    'tool_exec', 'tool_output', 'skill_content', 'skill_files',
+    'directories', 'available_skills', 'thinking',
+];
+const ORCHESTRATION_PATTERNS = ORCHESTRATION_TAG_NAMES.flatMap(tag => [
+    new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?<\\/${tag}>`, 'gi'),
+    new RegExp(`<${tag}\\b[^>]*\\/>`, 'gi'),
+]);
+/** Strip orchestration wrapper tags from message content. */
+function sanitizeContent(text) {
+    let result = text;
+    for (const pattern of ORCHESTRATION_PATTERNS) {
+        pattern.lastIndex = 0;
+        result = result.replace(pattern, '');
+    }
+    return result.replace(/\n{3,}/g, '\n\n').trim();
+}
+/** Strip orchestration tags from all messages in a request body. */
+function sanitizeMessages(body) {
+    const messages = body.messages;
+    if (!messages)
+        return;
+    for (const msg of messages) {
+        if (typeof msg.content === 'string') {
+            msg.content = sanitizeContent(msg.content);
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (typeof block === 'object' && block && 'text' in block && typeof block.text === 'string') {
+                    block.text = sanitizeContent(block.text);
+                }
+            }
+        }
+    }
+}
+let lastTokenSnapshot = null;
+function checkTokenAnomalies(usage, requestId) {
+    const current = {
+        inputTokens: usage.input_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? 0,
+        cacheRead: usage.cache_read_input_tokens ?? 0,
+    };
+    if (lastTokenSnapshot && lastTokenSnapshot.inputTokens > 0) {
+        const growth = (current.inputTokens - lastTokenSnapshot.inputTokens) / lastTokenSnapshot.inputTokens;
+        if (growth > 0.6) {
+            const pct = Math.round(growth * 100);
+            console.warn(`[dario] TOKEN WARN ${requestId}: Input grew ${pct}% (${lastTokenSnapshot.inputTokens} → ${current.inputTokens}). Possible full replay.`);
+        }
+        if (current.outputTokens > lastTokenSnapshot.outputTokens * 2 && current.outputTokens > 2000) {
+            console.warn(`[dario] TOKEN WARN ${requestId}: Output explosion ${current.outputTokens} tokens (${Math.round(current.outputTokens / lastTokenSnapshot.outputTokens)}x previous).`);
+        }
+    }
+    lastTokenSnapshot = current;
+}
+// Extended context fallback — cooldown after 1M context failure
+let extendedContextUnavailableAt = 0;
+const EXTENDED_CONTEXT_COOLDOWN_MS = 60 * 60 * 1000; // 1 hour
 // OpenAI model names → Anthropic (fallback if client sends GPT names)
 const OPENAI_MODEL_MAP = {
     'gpt-5.4': 'claude-opus-4-6',
@@ -255,6 +366,14 @@ export async function startProxy(opts = {}) {
     }
     const cliVersion = detectClaudeVersion();
     const modelOverride = opts.model ? (MODEL_ALIASES[opts.model] ?? opts.model) : null;
+    const identity = loadClaudeIdentity();
+    if (identity.deviceId) {
+        console.log('  Device identity: detected');
+    }
+    else {
+        console.warn('[dario] WARNING: No Claude Code device identity found. Requests may be billed as Extra Usage.');
+        console.warn('[dario] Run Claude Code at least once to generate ~/.claude/.claude.json');
+    }
     // Pre-build static headers (only auth, version, beta, request-id change per request)
     const staticHeaders = {
         'accept': 'application/json',
@@ -352,11 +471,12 @@ export async function startProxy(opts = {}) {
         // Detect OpenAI-format requests
         const isOpenAI = urlPath === '/v1/chat/completions';
         // Allowlisted API paths — only these are proxied (prevents SSRF)
+        // ?beta=true matches native Claude Code behavior for billing classification
         const allowedPaths = {
-            '/v1/messages': `${ANTHROPIC_API}/v1/messages`,
+            '/v1/messages': `${ANTHROPIC_API}/v1/messages?beta=true`,
             '/v1/complete': `${ANTHROPIC_API}/v1/complete`,
         };
-        const targetBase = isOpenAI ? `${ANTHROPIC_API}/v1/messages` : allowedPaths[urlPath];
+        const targetBase = isOpenAI ? `${ANTHROPIC_API}/v1/messages?beta=true` : allowedPaths[urlPath];
         if (!targetBase) {
             res.writeHead(403, JSON_HEADERS);
             res.end(ERR_FORBIDDEN);
@@ -421,12 +541,28 @@ export async function startProxy(opts = {}) {
                 res.end(cliResult.body);
                 return;
             }
-            // Parse body once, apply OpenAI translation or model override
+            // Parse body once, apply OpenAI translation, model override, and sanitization
             let finalBody = body.length > 0 ? body : undefined;
-            if (body.length > 0 && (isOpenAI || modelOverride)) {
+            if (body.length > 0) {
                 try {
                     const parsed = JSON.parse(body.toString());
+                    // Strip orchestration tags from messages (Aider, Cursor, etc.)
+                    sanitizeMessages(parsed);
+                    // Handle 1M context: strip [1m] suffix if in cooldown
+                    if (modelOverride?.includes('[1m]') && extendedContextUnavailableAt > 0 && Date.now() - extendedContextUnavailableAt < EXTENDED_CONTEXT_COOLDOWN_MS) {
+                        parsed.model = modelOverride.replace('[1m]', '');
+                    }
                     const result = isOpenAI ? openaiToAnthropic(parsed, modelOverride) : (modelOverride ? { ...parsed, model: modelOverride } : parsed);
+                    // Inject device identity metadata — required for Max plan billing classification
+                    if (identity.deviceId && typeof result === 'object' && result !== null) {
+                        result.metadata = {
+                            user_id: JSON.stringify({
+                                device_id: identity.deviceId,
+                                account_uuid: identity.accountUuid,
+                                session_id: SESSION_ID,
+                            }),
+                        };
+                    }
                     finalBody = Buffer.from(JSON.stringify(result));
                 }
                 catch { /* not JSON, send as-is */ }
@@ -435,11 +571,16 @@ export async function startProxy(opts = {}) {
                 const modelInfo = modelOverride ? ` (model: ${modelOverride})` : '';
                 console.log(`[dario] #${requestCount} ${req.method} ${urlPath}${modelInfo}`);
             }
-            // Merge client beta flags with defaults
+            // Beta flags matching native Claude Code v2.1.98.
+            // context-management and prompt-caching-scope are safe when metadata.user_id
+            // is present — billing classification depends on device identity, not betas.
             const clientBeta = req.headers['anthropic-beta'];
-            let beta = 'oauth-2025-04-20,interleaved-thinking-2025-05-14,prompt-caching-scope-2026-01-05,claude-code-20250219,context-management-2025-06-27';
-            if (clientBeta)
-                beta += ',' + clientBeta.split(',').map(f => f.trim()).filter(f => f.length > 0 && f.length < 100).join(',');
+            let beta = 'oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,claude-code-20250219,advisor-tool-2026-03-01';
+            if (clientBeta) {
+                const filtered = filterBillableBetas(clientBeta);
+                if (filtered)
+                    beta += ',' + filtered;
+            }
             const headers = {
                 ...staticHeaders,
                 'Authorization': `Bearer ${accessToken}`,
@@ -516,6 +657,21 @@ export async function startProxy(opts = {}) {
             else {
                 // Buffer and forward
                 const responseBody = await upstream.text();
+                // Check for extended context failure — cooldown to avoid repeated failures
+                if (upstream.status === 400 && responseBody.includes('extra_usage') && modelOverride?.includes('[1m]')) {
+                    extendedContextUnavailableAt = Date.now();
+                    console.warn('[dario] 1M context requires Extra Usage — falling back to standard context for 1 hour');
+                }
+                // Token anomaly detection on non-streaming responses
+                if (upstream.status >= 200 && upstream.status < 300) {
+                    try {
+                        const parsed = JSON.parse(responseBody);
+                        const usage = parsed.usage;
+                        if (usage)
+                            checkTokenAnomalies(usage, responseHeaders['request-id'] ?? '');
+                    }
+                    catch { /* ignore parse errors */ }
+                }
                 if (isOpenAI && upstream.status >= 200 && upstream.status < 300) {
                     // Translate Anthropic response → OpenAI format
                     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Use your Claude subscription as an API. No API key needed. Local proxy for Claude Max/Pro subscriptions.",
   "type": "module",
   "bin": {