claude-code-infinite 1.0.35 → 1.0.37

package/dist/proxy.js

@@ -40,9 +40,11 @@
  */
 import { UNKNOWN_INDEX_WAIT_SECONDS } from "./index-wait-413.js";
 import { capCacheBreakpoints } from "./route-cache.js";
+import { attachHttpsProxyMode, } from "./https-proxy-mode.js";
 import { PromptAccounting } from "./prompt-accounting.js";
 import { INDEX_WAIT_RETRY_AFTER_SECONDS, RefusalStreaks, RouteFallbackFailures, pausedRefusal, unreachableRefusal } from "./route-fallback.js";
 import { refusalCause, refusalMessage } from "./refusal-reason.js";
+import { AGENT_RESULT_WAITING_LINE, LaneActivity, heavyRequestNoticeText } from "./lane-activity.js";
 import { SlowUploads } from "./slow-upload.js";
 import { freshFailure, networkFailureOf, unreachableMessage, } from "./network-failure.js";
 import { createCountTokensSession, CountTokensCooldowns, plausibleSample, } from "./count-tokens.js";
@@ -67,12 +69,13 @@ import { keyInvalidNoticeText, keyInvalidRefusalMessage } from "./key-status.js"
 import { KEY_INVALID_KIND, ModelContextNotices, PAUSED_KIND, keyInvalidModelContext, lastToldKindInFile, pausedModelContext } from "./model-context.js";
 import { PaymentNoticeThrottle, pausedCompactionText, pausedRefusalMessage, paymentNoticeText, subscribeUrlFromDetail } from "./payment-notice.js";
 import { MEMTREE_LINKS_MAX_SESSIONS } from "./memtree-links.js";
-import { describeClaudeCodeRequest, inspectMonitorTranscript, knownSideRequestKind, transcriptWarning, isClaudeCodeSideRequest, memtreeClientMeta, sessionTag, } from "./cc-request.js";
+import { describeClaudeCodeRequest, inspectMonitorTranscript, knownSideRequestKind, transcriptWarning, isClaudeCodeSideRequest, memtreeClientMeta, notSessionConversation, sessionTag, } from "./cc-request.js";
 import { isResumableSessionId } from "./resume-hint.js";
 import { isSubagentCall, postToolUseOutput, SUBAGENT_RESULT_HINT, subagentMemoryHintText, subagentStartOutput, } from "./subagent-hint.js";
 import { PROJECT_TREES_HOOK_SUFFIX, RESUME_GUIDANCE_HOOK_SUFFIX, SUBAGENT_RESULT_HOOK_SUFFIX, } from "./hooks.js";
 import { conservativeBodyTokens } from "./token-estimate.js";
 import { bodyImages } from "./image-tokens.js";
+import { bodyShape, prefixDigest } from "./body-shape.js";
 import { claudeAuthFromHeaders, upstreamErrorCode } from "./claude-auth.js";
 import { rateLimitFromResponse } from "./rate-limit.js";
 import { approxTokensFromBytes, mergeUsageFromJsonBody, mergeUsageFromSseEvent, } from "./reqlog.js";
@@ -382,6 +385,7 @@ export function startProxy(opts) {
         fallbackFailures: new RouteFallbackFailures(undefined, opts.indexWaitDeadlineMs, opts.indexWaitMaxMs),
         refusalStreaks: new RefusalStreaks(),
         activeSubagents: new Set(),
+        laneActivity: new LaneActivity(),
         deferredAgentIndexes: new Map(),
         adoptingPrepared: new Map(),
         memoryRoutes: new Map(),
@@ -424,10 +428,12 @@ export function startProxy(opts) {
     // A newer tree from the background lookup reaches the status line without a turn ending.
     opts.newestTrees?.onTree((sessionId) => publishStatusLink(state, sessionId));
     state.notices.setFirstTreeIntro(opts.firstTreeIntro ?? null);
-    const server = http.createServer((req, res) => {
+    // One handler for the loopback server and, in HTTPS-proxy mode, for the decrypted
+    // api.anthropic.com streams (`intercepted`): both are tracked, drained and cancelled alike.
+    const onRequest = (intercepted) => (req, res) => {
         const accepted = { req, res };
         acceptedRequests.add(accepted);
-        const task = handleRequest(req, res, opts, upstream, state, hookPath).catch((err) => {
+        const task = handleRequest(req, res, opts, upstream, state, hookPath, intercepted).catch((err) => {
             try {
                 sendAnthropicError(res, `local proxy error: ${err?.message ?? err}`);
             }
@@ -445,7 +451,20 @@ export function startProxy(opts) {
         });
         if (shutdownAbort.signal.aborted)
             cancelAcceptedRequest(accepted);
-    });
+    };
+    const server = http.createServer(opts.innerToken === undefined ? onRequest(false)
+        : (req, res) => {
+            const inner = acceptInnerRequest(req, opts.innerToken);
+            if (inner === undefined) {
+                res.writeHead(403, { "content-type": "application/json" });
+                res.end(JSON.stringify({ detail: "ccc inner proxy: not for direct use" }));
+                return;
+            }
+            onRequest(inner.intercepted)(req, res);
+        });
+    const closeTunnels = opts.httpsProxyMode
+        ? attachHttpsProxyMode(server, onRequest(true), interceptUpstream(upstream), opts.httpsProxyMode)
+        : { blind: () => { }, all: () => { } };
     // Long-running SSE responses must not be cut by idle timeouts.
     server.requestTimeout = 0;
     server.headersTimeout = 60_000;
@@ -467,6 +486,9 @@ export function startProxy(opts) {
             ? Math.floor(timeoutMs)
             : 5_000;
         backgroundAbort.abort();
+        // CONNECT tunnels are raw sockets that keep server.close() waiting: the blind ones
+        // (and idle decrypted streams) carry no ccc work, so they go now.
+        closeTunnels.blind();
         const quiesced = (async () => {
             // Once close completes, every accepted request has entered the tracked
             // set.
@@ -495,6 +517,7 @@ export function startProxy(opts) {
         shutdownAbort.abort();
         for (const accepted of acceptedRequests)
             cancelAcceptedRequest(accepted);
+        closeTunnels.all();
         await quiesced;
         sendDeferredAgentIndexes(state);
         return false;
@@ -529,8 +552,10 @@ function cancelAcceptedRequest(accepted) {
     if (!res.destroyed && !res.writableEnded)
         res.destroy();
 }
-async function handleRequest(req, res, opts, upstream, state, hookPath) {
+async function handleRequest(req, res, opts, upstream, state, hookPath, intercepted) {
     const url = new URL(req.url ?? "/", `http://127.0.0.1`);
+    if (intercepted)
+        return handleInterceptedRequest(req, res, url, opts, upstream, state);
     if (!isLocalCaller(req)) {
         res.writeHead(403, { "content-type": "application/json" });
         res.end(JSON.stringify({ detail: "The ccc proxy only serves programs on this machine" }));
@@ -575,6 +600,32 @@ async function handleRequest(req, res, opts, upstream, state, hookPath) {
     }
     return passThroughStreaming(req, res, upstream, state.shutdownSignal);
 }
+/**
+ * Claude Code's own api.anthropic.com traffic, decrypted (HTTPS-proxy mode): model calls
+ * get MemTree exactly as through the base URL; everything else (Remote Control's bridge,
+ * sessions, files, OAuth, telemetry) goes verbatim to api.anthropic.com. ccc's
+ * loopback-only routes (hooks, /memtree/*) are never answered here: such a path is
+ * Anthropic's.
+ */
+function handleInterceptedRequest(req, res, url, opts, upstream, state) {
+    if (req.method === "POST" && url.pathname === "/v1/messages") {
+        try {
+            opts.httpsProxyMode?.onModelCall?.();
+        }
+        catch {
+            // A notice hook must never fail a model call.
+        }
+        return handleMessages(req, res, opts, upstream, state);
+    }
+    if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
+        return handleCountTokens(req, res, opts, upstream, state);
+    }
+    return passThroughStreaming(req, res, upstream, state.shutdownSignal);
+}
+/** Where a WebSocket upgrade on a decrypted stream is replayed: the same upstream. */
+function interceptUpstream(upstream) {
+    return { host: upstream.host, port: upstream.port, secure: upstream.module === https };
+}
 const LOOPBACK_HOSTNAMES = new Set(["127.0.0.1", "localhost", "[::1]"]);
 const BROWSER_SAME_SITE = new Set(["same-origin", "none"]);
 /**
@@ -1256,6 +1307,7 @@ async function handleMessages(req, res, opts, upstream, state) {
         finally {
             if (rec.totalMs === undefined)
                 rec.totalMs = Date.now() - received;
+            noteForwardedSize(state, rec, requestSessionId(req));
             opts.reqlog?.log(rec);
         }
     };
@@ -1379,6 +1431,12 @@ async function handleMessages(req, res, opts, upstream, state) {
     const { lane: requestRouteLane, key: requestRouteKey } = routeIdentity(req, isAwaySummary);
     const isSubagentRequest = requestRouteLane === "agent";
     const isMainRequest = requestRouteLane === "main";
+    // A side request or a thread continuation carries a fragment, not the conversation:
+    // it is forwarded as sent, with no compress, route, recovery or MemTree upload.
+    // The away summary keeps its own lane and handling.
+    const notConversation = isAwaySummary ? undefined : notSessionConversation(body, clientInfo);
+    if (notConversation)
+        rec.notConversation = notConversation;
     const requestSizeKey = laneSizeKey(req, requestRouteKey, body.model);
     const hold = indexHolds.get(rec);
     if (hold) {
@@ -1431,6 +1489,7 @@ async function handleMessages(req, res, opts, upstream, state) {
         }
     }
     rec.routeLane = requestRouteLane;
+    noteLaneActivity(state, rec, requestSessionId(req));
     // Stored by the server on the usage row (client_meta): which Claude Code,
     // lane, agent and model produced this request.
     const clientMeta = memtreeClientMeta({
@@ -1444,7 +1503,9 @@ async function handleMessages(req, res, opts, upstream, state) {
     // API identity and validated history alone govern route eligibility.
     const rideableCandidate = getMemoryRoute(state, requestRouteKey);
     const existingRide = rideableCandidate && memoryRoutedToolBody(body, messages, rideableCandidate, state.mainRouteEpoch, requestSessionId(req));
-    const isFollowupUserTurn = isUserTurn && hasEarlierNonToolUserMessage(messages);
+    // A fragment is never a follow-up: it must not reserve a route decision (it would never
+    // release it, and an in-flight main compression could not install its route).
+    const isFollowupUserTurn = !notConversation && isUserTurn && hasEarlierNonToolUserMessage(messages);
     const routeEpoch = state.mainRouteEpoch;
     let routeDecisionGeneration = state.mainRouteDecisionGeneration;
     let routeDecisionSettled = false;
@@ -1490,7 +1551,7 @@ async function handleMessages(req, res, opts, upstream, state) {
         // ORIGINAL conversation (the one MemTree indexed), never the ride itself.
         recoverLate: async (_ride, rideTokens, target) => {
             // A compression already made may be redone only to a smaller target.
-            if ((rec.compress && target === undefined) ||
+            if (notConversation || (rec.compress && target === undefined) ||
                 compactionMode(opts, state, requestSessionKey).mode === "off" ||
                 !hasEarlierNonToolUserMessage(messages) ||
                 (rec.turnType.startsWith("tool") && opts.toolRouteRecovery === false))
@@ -1513,9 +1574,14 @@ async function handleMessages(req, res, opts, upstream, state) {
     // The main lane's latest conversation: what its final index sends, plus the
     // reply the session ends with (scheduleFinalIndex, on Stop).
     const mainSessionId = isMainRequest ? requestSessionId(req) : undefined;
-    if (mainSessionId !== undefined) {
-        if (isResumableSessionId(mainSessionId))
-            state.resumableMainSession = mainSessionId;
+    if (mainSessionId !== undefined && isResumableSessionId(mainSessionId)) {
+        state.resumableMainSession = mainSessionId;
+    }
+    // A continuation is the session at work (a side request, e.g. a status summary, is not).
+    if (mainSessionId !== undefined && notConversation === "thread-continue") {
+        opts.memtree.noteMainActivity(mainSessionId);
+    }
+    if (mainSessionId !== undefined && !notConversation) {
         opts.memtree.noteMainConversation(mainSessionId, {
             messages: msgsForMemtree,
             modelContextLimit,
@@ -1535,7 +1601,7 @@ async function handleMessages(req, res, opts, upstream, state) {
     // Observation only: which requests carry Claude Code's turn origin.
     if (clientInfo)
         rec.client = clientInfo;
-    if (!isFollowupUserTurn) {
+    if (!isFollowupUserTurn || notConversation) {
         // Tool turn or FIRST user turn: keep the index fed off the response path
         // and forward as-is (on the lane's memory route or the session's stable
         // prefix when one applies) — except a tool turn whose estimated size
@@ -1551,7 +1617,7 @@ async function handleMessages(req, res, opts, upstream, state) {
         let routedTool = false;
         let routedCandidate;
         let routeMiss;
-        if (isToolResultTurn || isContinuationTurn || isUserTurn) {
+        if (!notConversation && (isToolResultTurn || isContinuationTurn || isUserTurn)) {
             // Reuse only this API session/lane's independently validated prefix.
             const activeRoute = rideableCandidate;
             if (activeRoute) {
@@ -1612,7 +1678,7 @@ async function handleMessages(req, res, opts, upstream, state) {
             rec.continuation = true;
         // Cheap shape check: without an earlier real user message there is
         // nothing MemTree could compress, so no attempt is worth making.
-        const canCompress = hasEarlierNonToolUserMessage(messages);
+        const canCompress = !notConversation && hasEarlierNonToolUserMessage(messages);
         let toolRide = routedTool
             ? {
                 raw: routedBody,
@@ -1621,7 +1687,10 @@ async function handleMessages(req, res, opts, upstream, state) {
             }
             : undefined;
         let toolNeedsOriginal = false;
-        if (opts.toolRouteRecovery === false) {
+        if (notConversation) {
+            // A fragment: forwarded as sent (no route, no stable prefix, no compaction).
+        }
+        else if (opts.toolRouteRecovery === false) {
             // Kill switch: no size check and no compress call on any tool turn.
             // A route still rides; a miss forwards whole and records "disabled".
             if ((routeMiss === "missing" || routeMiss === "rejected") && canCompress) {
@@ -1798,8 +1867,10 @@ async function handleMessages(req, res, opts, upstream, state) {
             requestSendPolicies.get(req)?.allowed.add(toolRide.raw);
         const sendBody = toolRide?.raw ?? (toolNeedsOriginal ? rawBody : forwardBody);
         recordTurn(rec, toolRide ? toolRide.turnType : isUserTurn ? "first-user" : "tool", sendBody);
-        indexTurn({ opts, state, req, rec, hash, msgsForMemtree, modelContextLimit,
-            sessionId: toolSessionId, clientMeta });
+        if (!notConversation) {
+            indexTurn({ opts, state, req, rec, hash, msgsForMemtree, modelContextLimit,
+                sessionId: toolSessionId, clientMeta });
+        }
         capture(opts, toolRide ? "anthropic-request-memory-tool" : "anthropic-request", sendBody);
         // The size Anthropic reports is the next budget check's anchor: a ride
         // reports to its prefix (or route), a whole request to the session's (or
@@ -3326,8 +3397,16 @@ function reportedSample(rec, sent) {
 }
 /** A size sample of `sent` carrying its inline images (estimateRequestTokens). */
 function sizeSampleOf(sent, tokens, model) {
-    const { imageBytes, imageTokens } = bodyImages(sent, typeof model === "string" ? model : undefined);
-    return { tokens, forwardedBytes: sent.length, imageBytes, imageTokens };
+    const id = typeof model === "string" ? model : undefined;
+    const { imageBytes, imageTokens } = bodyImages(sent, id);
+    return { tokens, forwardedBytes: sent.length, imageBytes, imageTokens, ...sampleLineage(sent, id) };
+}
+/** The sampled body's lineage (body-shape.ts) for anchoredBound; none for a small body. */
+function sampleLineage(sent, model) {
+    const shape = bodyShape(sent);
+    const digest = shape && prefixDigest(shape, shape.messages.length);
+    return shape && digest && model
+        ? { model, messageCount: shape.messages.length, prefixDigest: digest } : {};
 }
 /**
  * Anthropic's input tokens for the body this request forwarded, when its usage
@@ -4112,6 +4191,8 @@ const exactSizedRecords = new WeakSet();
  * it is over the window for planning and takes the normal gated compression.
  */
 function noteUncountedBound(record, sizing, candidate, body, modelContextLimit) {
+    if (candidate.anchored)
+        record.anchoredBound = true;
     if (sizing.isExact(candidate)) {
         exactSizedRecords.add(record);
         return;
@@ -5227,7 +5308,23 @@ async function recoverToolRouteMiss(args) {
 function recordTurn(rec, turnType, forwardBody) {
     rec.turnType = turnType;
     rec.forwardedBytes = forwardBody.length;
-    rec.approxInputTokens = approxTokensFromBytes(forwardBody.length);
+    rec.approxInputTokens = approxBodyTokens(forwardBody, rec.model);
+    forwardedImageBytes.set(rec, bodyImages(forwardBody, typeof rec.model === "string" ? rec.model : undefined).imageBytes);
+}
+/** The forwarded body's inline image bytes (recordTurn), for the heavy-request notice. */
+const forwardedImageBytes = new WeakMap();
+/** What this request uploaded to Anthropic, for the session's heavy-request notice. */
+function noteForwardedSize(state, rec, sessionId) {
+    const bytes = rec.forwardedBytes ?? 0;
+    if (bytes > 0) {
+        state.laneActivity.sent(sessionId, { bytes, imageBytes: forwardedImageBytes.get(rec) ?? 0 });
+    }
+}
+/** A body's text at bytes/4 plus its inline images at their visual tokens (log only):
+ * bytes/4 alone logged a 22 MB contact-sheet lane at 5.5M tokens (Anthropic: 491k). */
+function approxBodyTokens(body, model) {
+    const images = bodyImages(body, typeof model === "string" ? model : undefined);
+    return approxTokensFromBytes(body.length - images.imageBytes) + images.imageTokens;
 }
 function headerText(headers, name) {
     const value = headers[name];
@@ -5707,7 +5804,7 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
             : offline ? unreachableRefusal(offline.message)
                 : args.state.fallbackFailures.fail(args.routeKey, { awaitingIndex: args.rec.indexBehind === true,
                     indexSecondsLeft: activeIndexWaits.get(args.rec),
-                    refusalMessage: refusalMessage(cause, currentSessionLink(args.state, requestSessionId(args.req))) });
+                    refusalMessage: refusalMessage(cause, currentSessionLink(args.state, requestSessionId(args.req)), agentResultNote(args)) });
     args.rec.forwardedBytes = 0;
     args.rec.approxInputTokens = 0;
     // Nothing went out uncompressed: Claude Code retries it (2026-10-28).
@@ -5750,6 +5847,17 @@ function refuseWholeRequest(args, inputTokens, budgetTokens) {
         args.state.keyNotice.markShown();
     return false;
 }
+/**
+ * A main-lane refusal while an agent lane of this session was recently active: a
+ * background agent's finished result reaches the main session only as part of its
+ * next turn, so say it may be waiting (2026-11-13: a refused main lane held one back).
+ */
+function agentResultNote(args) {
+    // This session's own agent traffic only: activeSubagents is process-wide (review r1 P3).
+    return args.rec.routeLane === "main" &&
+        args.state.laneActivity.agentRecent(requestSessionId(args.req))
+        ? AGENT_RESULT_WAITING_LINE : undefined;
+}
 /** Requests held back by a lane backoff whose attempt MemTree answered (unreachableNow). */
 const answeredBackoffs = new WeakSet();
 /**
@@ -5781,6 +5889,25 @@ function unreachableNow(state, rec) {
     return { message: unreachableMessage(memtree, anthropic),
         what: anthropic ? "internet" : "memtree" };
 }
+/**
+ * Note this request's lane (lane-activity.ts) and, on a main-lane request of the current
+ * prompt, queue the session's one heavy-request warning when an earlier upload passed the
+ * size and no other notice waits. It is the lowest priority (otherNoticePending): any
+ * other notice may replace it, which leaves it due for a later turn.
+ */
+function noteLaneActivity(state, rec, sessionId) {
+    state.laneActivity.seen(sessionId, rec.routeLane);
+    const heavy = state.laneActivity.heavyDue(sessionId);
+    const prompt = noticeContexts.get(rec);
+    if (!heavy || sessionId === undefined || rec.routeLane !== "main" || prompt === undefined ||
+        prompt.generation !== state.mainPromptGeneration || state.notices.hasPending())
+        return;
+    state.heavyNotice = state.notices.queueSuffix(heavyRequestNoticeText(heavy), () => state.laneActivity.markWarned(sessionId), prompt.promptId);
+}
+/** Whether a notice other than the heavy-request one (the lowest priority) waits. */
+function otherNoticePending(state, promptId) {
+    return state.notices.hasPending(promptId) && !state.notices.pendingIs(state.heavyNotice);
+}
 /**
  * A repeated retryable refusal on the main thread: say once per streak that
  * MemTree is slow and Claude Code is retrying, unless another notice waits.
@@ -5793,7 +5920,7 @@ function noteSlowRetry(args, failure) {
     const canShow = failure.status === 503 && rec.routeLane === "main" &&
         rec.indexBehind !== true && prompt !== undefined &&
         prompt.generation === state.mainPromptGeneration && !args.res.destroyed &&
-        !state.notices.hasPending();
+        !otherNoticePending(state);
     if (!state.refusalStreaks.refused(args.routeKey, Date.now(), canShow))
         return;
     state.notices.queueSuffix(SLOW_RETRY_NOTICE, undefined, prompt.promptId);
@@ -5844,7 +5971,7 @@ function warnPausedNearWindow(state, rec, sessionId) {
     // Never replace another queued notice (or this one again): a later request tries.
     if (detail === null || rec.routeLane !== "main" || sessionId === undefined ||
         pausedNotices.has(rec) || nearWindowWarned(state, sessionId) ||
-        state.notices.hasPending(state.mainPromptId))
+        otherNoticePending(state, state.mainPromptId))
         return;
     state.nearWindowNotice = state.notices.queueSuffix(paymentNoticeText(detail, undefined, { overBudget: true }), () => {
         state.paymentNotice.markShown();
@@ -6700,4 +6827,23 @@ function transcriptTimesFor(opts, sessionId, agentId) {
     return (messages) => source.timesFor(sessionId, messages, agentId);
 }
 export const __testHoldingLane = holdingLane;
+/**
+ * The inner-proxy headers (ProxyOptions.innerToken): checked, then stripped so nothing
+ * forwards them. undefined: not the service.
+ */
+function acceptInnerRequest(req, token) {
+    if (!sameSecret(req.headers[INNER_TOKEN_HEADER], token))
+        return undefined;
+    const intercepted = req.headers[INNER_INTERCEPTED_HEADER] === "1";
+    delete req.headers[INNER_TOKEN_HEADER];
+    delete req.headers[INNER_INTERCEPTED_HEADER];
+    for (let i = req.rawHeaders.length - 2; i >= 0; i -= 2) {
+        const name = req.rawHeaders[i].toLowerCase();
+        if (name === INNER_TOKEN_HEADER || name === INNER_INTERCEPTED_HEADER)
+            req.rawHeaders.splice(i, 2);
+    }
+    return { intercepted };
+}
+export const INNER_TOKEN_HEADER = "x-ccc-inner";
+export const INNER_INTERCEPTED_HEADER = "x-ccc-intercepted";
 //# sourceMappingURL=proxy.js.map