@askalf/dario 4.8.72 → 4.8.74

package/dist/cc-template.d.ts

@@ -39,10 +39,13 @@ export declare const CC_TOOL_DEFINITIONS: {
     description: string;
     input_schema: Record<string, unknown>;
 }[];
-/** Lowercased CC tool name → canonical name, for identity-matching a CC client's
- *  own tools (so newer built-ins not yet in TOOL_MAP map to themselves rather
- *  than being treated as foreign and round-robined). Tracks the live bundle. */
-export declare const CC_NATIVE_LOWER: Map<string, string>;
+/** CC's own tool names, EXACT case ("Read", "Bash", "Agent", …). A CC client's
+ *  tools identity-map to themselves and OVERRIDE TOOL_MAP — whose lowercase
+ *  cross-client aliases ('read' → {path}/{filePath}) would otherwise mistranslate
+ *  a CC tool (Read's file_path → path). Exact case is the discriminator: CC sends
+ *  PascalCase, the {path}-style clients send lowercase/snake, so a non-CC `read`
+ *  still routes through TOOL_MAP. Tracks the live bundle (refreshed each bake). */
+export declare const CC_NATIVE_NAMES: Set<string>;
 /** CC's static system prompt (~25KB). */
 export declare const CC_SYSTEM_PROMPT: string;
 /** CC's agent identity string. */

package/dist/cc-template.js

@@ -45,10 +45,13 @@ export function filterToolsForPlatform(tools, platform) {
 }
 /** CC's exact tool definitions for the current platform — filtered from the bundled union. */
 export const CC_TOOL_DEFINITIONS = filterToolsForPlatform(TEMPLATE.tools, process.platform);
-/** Lowercased CC tool name → canonical name, for identity-matching a CC client's
- *  own tools (so newer built-ins not yet in TOOL_MAP map to themselves rather
- *  than being treated as foreign and round-robined). Tracks the live bundle. */
-export const CC_NATIVE_LOWER = new Map(CC_TOOL_DEFINITIONS.map((t) => [String(t.name).toLowerCase(), String(t.name)]));
+/** CC's own tool names, EXACT case ("Read", "Bash", "Agent", …). A CC client's
+ *  tools identity-map to themselves and OVERRIDE TOOL_MAP — whose lowercase
+ *  cross-client aliases ('read' → {path}/{filePath}) would otherwise mistranslate
+ *  a CC tool (Read's file_path → path). Exact case is the discriminator: CC sends
+ *  PascalCase, the {path}-style clients send lowercase/snake, so a non-CC `read`
+ *  still routes through TOOL_MAP. Tracks the live bundle (refreshed each bake). */
+export const CC_NATIVE_NAMES = new Set(CC_TOOL_DEFINITIONS.map((t) => String(t.name)));
 /** CC's static system prompt (~25KB). */
 export const CC_SYSTEM_PROMPT = TEMPLATE.system_prompt;
 /** CC's agent identity string. */
@@ -1234,19 +1237,20 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
         const claimedCC = new Set();
         for (const tool of clientTools) {
             const name = (tool.name || '').toLowerCase();
-            // A CC client's OWN tools map to THEMSELVES (identity). TOOL_MAP only
-            // carries the legacy core surface + cross-client aliases, so it lags CC's
-            // newer built-ins (Agent, AskUserQuestion, Cron*, Task*, NotebookEdit,
-            // Enter/ExitPlanMode, Workflow, …). Without this, those land "unmapped",
-            // get round-robined onto Read/Bash/etc., and the collision corrupts the
-            // calls of the tools that DID map (the dock saw Read's `file_path` arrive
-            // as `path`/`filePath`). Identity-matching against the live CC tool set
-            // (CC_NATIVE_LOWER, refreshed by every capture-and-bake) fixes it for
-            // every current-and-future CC client and keeps the canonical CC fingerprint.
-            const mapping = TOOL_MAP[name]
-                ?? (CC_NATIVE_LOWER.get(name)
-                    ? { ccTool: CC_NATIVE_LOWER.get(name), translateArgs: (a) => a, translateBack: (a) => a }
-                    : undefined);
+            // A CC client's OWN tools map to THEMSELVES (identity), and this OVERRIDES
+            // TOOL_MAP. Two failure modes it fixes, both seen via the dock:
+            //  1. TOOL_MAP's lowercase cross-client aliases mistranslate a CC tool —
+            //     `Read` → TOOL_MAP['read'] whose translateBack emits {path, filePath}
+            //     instead of {file_path}, so every Read failed validation client-side.
+            //  2. CC's newer built-ins (Agent, AskUserQuestion, Cron*, Task*, Workflow,
+            //     NotebookEdit, Enter/ExitPlanMode, …) aren't in TOOL_MAP at all, so
+            //     they were round-robined onto Read/Bash/etc. and collided.
+            // Exact case is the discriminator (CC sends PascalCase; {path}-style clients
+            // send lowercase/snake) so a genuine non-CC `read` still routes via TOOL_MAP.
+            // Tracks the live bundle, so future CC tools are covered after the next bake.
+            const mapping = CC_NATIVE_NAMES.has(tool.name)
+                ? { ccTool: tool.name, translateArgs: (a) => a, translateBack: (a) => a }
+                : TOOL_MAP[name];
             if (mapping) {
                 // In hybrid mode, clone the shared mapping and attach the
                 // client-declared top-level field names from input_schema.
@@ -1282,8 +1286,8 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
         const CC_FALLBACK_TOOLS = ['Bash', 'Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'];
         for (const tool of clientTools) {
             const name = (tool.name || '').toLowerCase();
-            if (TOOL_MAP[name] || CC_NATIVE_LOWER.has(name))
-                continue; // mapped, or a CC-native tool (identity in pass 1)
+            if (CC_NATIVE_NAMES.has(tool.name) || TOOL_MAP[name])
+                continue; // CC-native (identity in pass 1) or mapped
             unmappedTools.push(tool.name);
             if (opts.hybridTools)
                 continue; // dropped — see comment above

package/dist/health-response.d.ts

@@ -0,0 +1,28 @@
+/**
+ * /health response builder — extracted so the public-vs-internal disclosure rule
+ * is unit-testable without spinning a proxy.
+ *
+ * dario's /health is auth-free (docker healthchecks + `depends_on: service_healthy`
+ * need it before any secret is configured). When dario sits behind a Cloudflare
+ * tunnel with a public /health bypass (uptime monitoring), that endpoint is
+ * world-readable — so it must not leak OAuth internals (token countdown, request
+ * volume, refresh errors). The Cloudflare edge stamps `cf-ray` on every request it
+ * proxies, so its presence marks a request as having come from the public internet.
+ * Internal callers (the docker healthcheck, `dario doctor`, the self-probe) hit
+ * dario directly on loopback with no CF headers and still get the full detail.
+ *
+ * The HTTP status (200 healthy / 503 degraded) is identical either way, so external
+ * uptime monitoring that keys on the status code is unaffected.
+ */
+export interface HealthStatusLike {
+    status: string;
+    canRefresh?: boolean;
+    expiresIn?: string;
+    refreshFailures?: number;
+    lastRefreshError?: string;
+}
+export interface HealthResponse {
+    httpStatus: number;
+    body: Record<string, unknown>;
+}
+export declare function buildHealthResponse(s: HealthStatusLike, requestCount: number, viaPublicTunnel: boolean): HealthResponse;

package/dist/health-response.js

@@ -0,0 +1,34 @@
+/**
+ * /health response builder — extracted so the public-vs-internal disclosure rule
+ * is unit-testable without spinning a proxy.
+ *
+ * dario's /health is auth-free (docker healthchecks + `depends_on: service_healthy`
+ * need it before any secret is configured). When dario sits behind a Cloudflare
+ * tunnel with a public /health bypass (uptime monitoring), that endpoint is
+ * world-readable — so it must not leak OAuth internals (token countdown, request
+ * volume, refresh errors). The Cloudflare edge stamps `cf-ray` on every request it
+ * proxies, so its presence marks a request as having come from the public internet.
+ * Internal callers (the docker healthcheck, `dario doctor`, the self-probe) hit
+ * dario directly on loopback with no CF headers and still get the full detail.
+ *
+ * The HTTP status (200 healthy / 503 degraded) is identical either way, so external
+ * uptime monitoring that keys on the status code is unaffected.
+ */
+export function buildHealthResponse(s, requestCount, viaPublicTunnel) {
+    const dead = s.status === 'broken' ||
+        s.status === 'none' ||
+        (s.status === 'expired' && s.canRefresh === false);
+    const httpStatus = dead ? 503 : 200;
+    const liveness = { status: dead ? 'degraded' : 'ok' };
+    const body = viaPublicTunnel
+        ? liveness
+        : {
+            ...liveness,
+            oauth: s.status,
+            expiresIn: s.expiresIn,
+            requests: requestCount,
+            ...(s.refreshFailures ? { refreshFailures: s.refreshFailures } : {}),
+            ...(s.lastRefreshError ? { lastRefreshError: s.lastRefreshError } : {}),
+        };
+    return { httpStatus, body };
+}

package/dist/proxy.js

@@ -7,6 +7,7 @@ import { homedir } from 'node:os';
 import { setDefaultResultOrder } from 'node:dns';
 import { arch, platform } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
+import { buildHealthResponse } from './health-response.js';
 import { buildCCRequest, applyCcPromptCaching, parseEffortSuffix, reverseMapResponse, createStreamingReverseMapper, orderHeadersForOutbound, CC_TEMPLATE } from './cc-template.js';
 import { describeTemplate, detectDrift, checkCCCompat } from './live-fingerprint.js';
 import { AccountPool, computeStickyKey, parseRateLimits, modelFamily, isInAuthCooldown, authCooldownMs } from './pool.js';
@@ -1110,18 +1111,12 @@ export async function startProxy(opts = {}) {
         // react instead of cheerfully passing while every /v1/messages 401s.
         if (urlPath === '/health' || urlPath === '/') {
             const s = await getStatus();
-            const dead = s.status === 'broken' || s.status === 'none' ||
-                (s.status === 'expired' && s.canRefresh === false);
-            const httpStatus = dead ? 503 : 200;
+            // Public requests arrive through the Cloudflare tunnel (the edge stamps
+            // `cf-ray`); they get only the liveness verdict, never the OAuth internals.
+            // See buildHealthResponse for the full rationale.
+            const { httpStatus, body } = buildHealthResponse(s, requestCount, req.headers['cf-ray'] !== undefined);
             res.writeHead(httpStatus, JSON_HEADERS);
-            res.end(JSON.stringify({
-                status: dead ? 'degraded' : 'ok',
-                oauth: s.status,
-                expiresIn: s.expiresIn,
-                requests: requestCount,
-                ...(s.refreshFailures ? { refreshFailures: s.refreshFailures } : {}),
-                ...(s.lastRefreshError ? { lastRefreshError: s.lastRefreshError } : {}),
-            }));
+            res.end(JSON.stringify(body));
             return;
         }
         if (!checkAuth(req)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "4.8.72",
+  "version": "4.8.74",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {