@askalf/dario 1.0.6 → 1.0.8

package/dist/cli.js

@@ -16,7 +16,7 @@ import { homedir } from 'node:os';
 import { startOAuthFlow, exchangeCode, getStatus, refreshTokens } from './oauth.js';
 import { startProxy } from './proxy.js';
 const args = process.argv.slice(2);
-const command = args[0] ?? 'proxy';
+const command = args[0] ?? (process.stdin.isTTY ? 'proxy' : 'proxy');
 function ask(question) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     return new Promise(resolve => {
@@ -83,10 +83,18 @@ async function status() {
     console.log('  ─────────────');
     console.log('');
     if (!s.authenticated) {
-        console.log(`  Status: ${s.status === 'expired' ? 'Expired (will auto-refresh)' : 'Not authenticated'}`);
-        if (s.status === 'none') {
+        if (s.status === 'expired' && s.canRefresh) {
+            console.log('  Status: Expired (will auto-refresh when proxy starts)');
+            console.log('  Run `dario refresh` to refresh now, or `dario proxy` to start.');
+        }
+        else if (s.status === 'none') {
+            console.log('  Status: Not authenticated');
             console.log('  Run `dario login` to authenticate.');
         }
+        else {
+            console.log(`  Status: ${s.status}`);
+            console.log('  Run `dario login` to re-authenticate.');
+        }
     }
     else {
         console.log(`  Status: ${s.status}`);

package/dist/oauth.d.ts

@@ -45,4 +45,5 @@ export declare function getStatus(): Promise<{
     status: 'healthy' | 'expiring' | 'expired' | 'none';
     expiresAt?: number;
     expiresIn?: string;
+    canRefresh?: boolean;
 }>;

package/dist/oauth.js

@@ -5,7 +5,7 @@
  * Handles authorization, token exchange, storage, and auto-refresh.
  */
 import { randomBytes, createHash } from 'node:crypto';
-import { readFile, writeFile, mkdir, chmod } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, chmod, rename } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 // Claude CLI's public OAuth client (PKCE, no secret needed)
@@ -58,7 +58,6 @@ async function saveCredentials(creds) {
     // Write atomically: write to temp file, then rename
     const tmpPath = `${path}.tmp.${Date.now()}`;
     await writeFile(tmpPath, JSON.stringify(creds, null, 2), { mode: 0o600 });
-    const { rename } = await import('node:fs/promises');
     await rename(tmpPath, path);
     // Set permissions (best-effort — no-op on Windows where mode is ignored)
     try {
@@ -105,10 +104,10 @@ export async function exchangeCode(code, codeVerifier) {
             redirect_uri: OAUTH_REDIRECT_URI,
             code_verifier: codeVerifier,
         }),
+        signal: AbortSignal.timeout(30000),
     });
     if (!res.ok) {
-        const err = await res.text().catch(() => 'Unknown error');
-        throw new Error(`Token exchange failed (${res.status}): ${err}`);
+        throw new Error(`Token exchange failed (${res.status}). Check your authorization code and try again.`);
     }
     const data = await res.json();
     const tokens = {
@@ -203,7 +202,9 @@ export async function getStatus() {
     const { expiresAt } = creds.claudeAiOauth;
     const now = Date.now();
     if (expiresAt < now) {
-        return { authenticated: false, status: 'expired', expiresAt };
+        // Expired but has refresh token — can be refreshed
+        const canRefresh = !!creds.claudeAiOauth.refreshToken;
+        return { authenticated: false, status: 'expired', expiresAt, canRefresh };
     }
     const ms = expiresAt - now;
     const hours = Math.floor(ms / 3600000);

package/dist/proxy.js

@@ -8,6 +8,9 @@
  * No API key needed — your Claude subscription pays for it.
  */
 import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { execSync } from 'node:child_process';
+import { arch, platform, version as nodeVersion } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
 const ANTHROPIC_API = 'https://api.anthropic.com';
 const DEFAULT_PORT = 3456;
@@ -15,6 +18,37 @@ const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB — generous for large prompts
 const UPSTREAM_TIMEOUT_MS = 300_000; // 5 min — matches Anthropic SDK default
 const LOCALHOST = '127.0.0.1';
 const CORS_ORIGIN = 'http://localhost';
+// Detect installed Claude Code version at startup
+function detectClaudeVersion() {
+    try {
+        const out = execSync('claude --version', { timeout: 5000, stdio: 'pipe' }).toString().trim();
+        const match = out.match(/^([\d.]+)/);
+        return match?.[1] ?? '2.1.96';
+    }
+    catch {
+        return '2.1.96';
+    }
+}
+function getOsName() {
+    const p = platform;
+    if (p === 'win32')
+        return 'Windows';
+    if (p === 'darwin')
+        return 'MacOS';
+    return 'Linux';
+}
+// Persistent session ID per proxy lifetime (like Claude Code does per session)
+const SESSION_ID = randomUUID();
+// Detect @anthropic-ai/sdk version from installed package
+function detectSdkVersion() {
+    try {
+        const pkg = require('@anthropic-ai/sdk/package.json');
+        return pkg.version ?? '0.81.0';
+    }
+    catch {
+        return '0.81.0';
+    }
+}
 function sanitizeError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     // Never leak tokens in error messages
@@ -29,6 +63,8 @@ export async function startProxy(opts = {}) {
         console.error('[dario] Not authenticated. Run `dario login` first.');
         process.exit(1);
     }
+    const cliVersion = detectClaudeVersion();
+    const sdkVersion = detectSdkVersion();
     let requestCount = 0;
     let tokenCostEstimate = 0;
     const server = createServer(async (req, res) => {
@@ -84,7 +120,6 @@ export async function startProxy(opts = {}) {
         // Proxy to Anthropic
         try {
             const accessToken = await getAccessToken();
-            requestCount++;
             // Read request body with size limit
             const chunks = [];
             let totalBytes = 0;
@@ -106,7 +141,12 @@ export async function startProxy(opts = {}) {
             const targetUrl = targetBase;
             // Merge any client-provided beta flags with the required oauth flag
             const clientBeta = req.headers['anthropic-beta'];
-            const betaFlags = new Set(['oauth-2025-04-20']);
+            const betaFlags = new Set([
+                'oauth-2025-04-20',
+                'interleaved-thinking-2025-05-14',
+                'prompt-caching-scope-2026-01-05',
+                'claude-code-20250219',
+            ]);
             if (clientBeta) {
                 for (const flag of clientBeta.split(',')) {
                     const trimmed = flag.trim();
@@ -115,11 +155,24 @@ export async function startProxy(opts = {}) {
                 }
             }
             const headers = {
+                'accept': 'application/json',
                 'Authorization': `Bearer ${accessToken}`,
                 'Content-Type': 'application/json',
                 'anthropic-version': req.headers['anthropic-version'] || '2023-06-01',
                 'anthropic-beta': [...betaFlags].join(','),
+                'anthropic-dangerous-direct-browser-access': 'true',
+                'user-agent': `claude-cli/${cliVersion} (external, cli)`,
                 'x-app': 'cli',
+                'x-claude-code-session-id': SESSION_ID,
+                'x-client-request-id': randomUUID(),
+                'x-stainless-arch': arch,
+                'x-stainless-lang': 'js',
+                'x-stainless-os': getOsName(),
+                'x-stainless-package-version': sdkVersion,
+                'x-stainless-retry-count': '0',
+                'x-stainless-runtime': 'node',
+                'x-stainless-runtime-version': nodeVersion,
+                'x-stainless-timeout': '600',
             };
             const upstream = await fetch(targetUrl, {
                 method: req.method ?? 'POST',
@@ -143,6 +196,7 @@ export async function startProxy(opts = {}) {
                 if (v)
                     responseHeaders[h] = v;
             }
+            requestCount++;
             res.writeHead(upstream.status, responseHeaders);
             if (isStream && upstream.body) {
                 // Stream SSE chunks through
@@ -186,6 +240,15 @@ export async function startProxy(opts = {}) {
             res.end(JSON.stringify({ error: 'Proxy error', message: 'Failed to reach upstream API' }));
         }
     });
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.error(`[dario] Port ${port} is already in use. Is another dario proxy running?`);
+        }
+        else {
+            console.error(`[dario] Server error: ${err.message}`);
+        }
+        process.exit(1);
+    });
     server.listen(port, LOCALHOST, () => {
         const oauthLine = `OAuth: ${status.status} (expires in ${status.expiresIn})`;
         console.log('');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Use your Claude subscription as an API. Two commands, no API key. OAuth bridge for Claude Max/Pro.",
   "type": "module",
   "bin": {