claude-code-infinite 1.0.36 → 1.0.37

package/dist/proxy.js

@@ -40,6 +40,7 @@
  */
 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";
@@ -68,7 +69,7 @@ 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";
@@ -427,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}`);
             }
@@ -448,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;
@@ -470,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.
@@ -498,6 +517,7 @@ export function startProxy(opts) {
         shutdownAbort.abort();
         for (const accepted of acceptedRequests)
             cancelAcceptedRequest(accepted);
+        closeTunnels.all();
         await quiesced;
         sendDeferredAgentIndexes(state);
         return false;
@@ -532,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" }));
@@ -578,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"]);
 /**
@@ -1383,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) {
@@ -1449,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;
@@ -1495,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))
@@ -1518,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,
@@ -1540,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
@@ -1556,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) {
@@ -1617,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,
@@ -1626,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) {
@@ -1803,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
@@ -6761,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