@zyycn/claudex 1.0.3-fork.0cb3e59

package/dist/chunk-czensfac.js

@@ -0,0 +1,476 @@
+// @bun
+import {
+  getWebSocketProxyAgent,
+  getWebSocketProxyUrl,
+  getWebSocketTLSOptions,
+  init_mtls,
+  init_proxy
+} from "./chunk-gmaybtrd.js";
+import {
+  init_cleanupRegistry,
+  init_debug,
+  init_errors,
+  isENOENT,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-raqgs410.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/upstreamproxy/upstreamproxy.ts
+init_cleanupRegistry();
+init_debug();
+init_envUtils();
+init_errors();
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/upstreamproxy/relay.ts
+init_debug();
+init_mtls();
+init_proxy();
+import { createServer } from "net";
+var nodeWSCtor;
+var MAX_CHUNK_BYTES = 512 * 1024;
+var PING_INTERVAL_MS = 30000;
+function encodeChunk(data) {
+  const len = data.length;
+  const varint = [];
+  let n = len;
+  while (n > 127) {
+    varint.push(n & 127 | 128);
+    n >>>= 7;
+  }
+  varint.push(n);
+  const out = new Uint8Array(1 + varint.length + len);
+  out[0] = 10;
+  out.set(varint, 1);
+  out.set(data, 1 + varint.length);
+  return out;
+}
+function decodeChunk(buf) {
+  if (buf.length === 0)
+    return new Uint8Array(0);
+  if (buf[0] !== 10)
+    return null;
+  let len = 0;
+  let shift = 0;
+  let i = 1;
+  while (i < buf.length) {
+    const b = buf[i];
+    len |= (b & 127) << shift;
+    i++;
+    if ((b & 128) === 0)
+      break;
+    shift += 7;
+    if (shift > 28)
+      return null;
+  }
+  if (i + len > buf.length)
+    return null;
+  return buf.subarray(i, i + len);
+}
+function newConnState() {
+  return {
+    connectBuf: Buffer.alloc(0),
+    pending: [],
+    wsOpen: false,
+    established: false,
+    closed: false
+  };
+}
+async function startUpstreamProxyRelay(opts) {
+  const authHeader = "Basic " + Buffer.from(`${opts.sessionId}:${opts.token}`).toString("base64");
+  const wsAuthHeader = `Bearer ${opts.token}`;
+  const relay = typeof Bun !== "undefined" ? startBunRelay(opts.wsUrl, authHeader, wsAuthHeader) : await startNodeRelay(opts.wsUrl, authHeader, wsAuthHeader);
+  logForDebugging(`[upstreamproxy] relay listening on 127.0.0.1:${relay.port}`);
+  return relay;
+}
+function startBunRelay(wsUrl, authHeader, wsAuthHeader) {
+  const server = Bun.listen({
+    hostname: "127.0.0.1",
+    port: 0,
+    socket: {
+      open(sock) {
+        sock.data = { ...newConnState(), writeBuf: [] };
+      },
+      data(sock, data) {
+        const st = sock.data;
+        const adapter = {
+          write: (payload) => {
+            const bytes = typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
+            if (st.writeBuf.length > 0) {
+              st.writeBuf.push(bytes);
+              return;
+            }
+            const n = sock.write(bytes);
+            if (n < bytes.length)
+              st.writeBuf.push(bytes.subarray(n));
+          },
+          end: () => sock.end()
+        };
+        handleData(adapter, st, data, wsUrl, authHeader, wsAuthHeader);
+      },
+      drain(sock) {
+        const st = sock.data;
+        while (st.writeBuf.length > 0) {
+          const chunk = st.writeBuf[0];
+          const n = sock.write(chunk);
+          if (n < chunk.length) {
+            st.writeBuf[0] = chunk.subarray(n);
+            return;
+          }
+          st.writeBuf.shift();
+        }
+      },
+      close(sock) {
+        cleanupConn(sock.data);
+      },
+      error(sock, err) {
+        logForDebugging(`[upstreamproxy] client socket error: ${err.message}`);
+        cleanupConn(sock.data);
+      }
+    }
+  });
+  return {
+    port: server.port,
+    stop: () => server.stop(true)
+  };
+}
+async function startNodeRelay(wsUrl, authHeader, wsAuthHeader) {
+  nodeWSCtor = (await import("ws")).default;
+  const states = new WeakMap;
+  const server = createServer((sock) => {
+    const st = newConnState();
+    states.set(sock, st);
+    const adapter = {
+      write: (payload) => {
+        sock.write(typeof payload === "string" ? payload : Buffer.from(payload));
+      },
+      end: () => sock.end()
+    };
+    sock.on("data", (data) => handleData(adapter, st, data, wsUrl, authHeader, wsAuthHeader));
+    sock.on("close", () => cleanupConn(states.get(sock)));
+    sock.on("error", (err) => {
+      logForDebugging(`[upstreamproxy] client socket error: ${err.message}`);
+      cleanupConn(states.get(sock));
+    });
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (addr === null || typeof addr === "string") {
+        reject(new Error("upstreamproxy: server has no TCP address"));
+        return;
+      }
+      resolve({
+        port: addr.port,
+        stop: () => server.close()
+      });
+    });
+  });
+}
+function handleData(sock, st, data, wsUrl, authHeader, wsAuthHeader) {
+  if (!st.ws) {
+    st.connectBuf = Buffer.concat([st.connectBuf, data]);
+    const headerEnd = st.connectBuf.indexOf(`\r
+\r
+`);
+    if (headerEnd === -1) {
+      if (st.connectBuf.length > 8192) {
+        sock.write(`HTTP/1.1 400 Bad Request\r
+\r
+`);
+        sock.end();
+      }
+      return;
+    }
+    const reqHead = st.connectBuf.subarray(0, headerEnd).toString("utf8");
+    const firstLine = reqHead.split(`\r
+`)[0] ?? "";
+    const m = firstLine.match(/^CONNECT\s+(\S+)\s+HTTP\/1\.[01]$/i);
+    if (!m) {
+      sock.write(`HTTP/1.1 405 Method Not Allowed\r
+\r
+`);
+      sock.end();
+      return;
+    }
+    const trailing = st.connectBuf.subarray(headerEnd + 4);
+    if (trailing.length > 0) {
+      st.pending.push(Buffer.from(trailing));
+    }
+    st.connectBuf = Buffer.alloc(0);
+    openTunnel(sock, st, firstLine, wsUrl, authHeader, wsAuthHeader);
+    return;
+  }
+  if (!st.wsOpen) {
+    st.pending.push(Buffer.from(data));
+    return;
+  }
+  forwardToWs(st.ws, data);
+}
+function openTunnel(sock, st, connectLine, wsUrl, authHeader, wsAuthHeader) {
+  const headers = {
+    "Content-Type": "application/proto",
+    Authorization: wsAuthHeader
+  };
+  let ws;
+  if (nodeWSCtor) {
+    ws = new nodeWSCtor(wsUrl, {
+      headers,
+      agent: getWebSocketProxyAgent(wsUrl),
+      ...getWebSocketTLSOptions()
+    });
+  } else {
+    ws = new globalThis.WebSocket(wsUrl, {
+      headers,
+      proxy: getWebSocketProxyUrl(wsUrl),
+      tls: getWebSocketTLSOptions() || undefined
+    });
+  }
+  ws.binaryType = "arraybuffer";
+  st.ws = ws;
+  ws.onopen = () => {
+    const head = `${connectLine}\r
+Proxy-Authorization: ${authHeader}\r
+\r
+`;
+    ws.send(encodeChunk(new Uint8Array(Buffer.from(head, "utf8"))));
+    st.wsOpen = true;
+    for (const buf of st.pending) {
+      forwardToWs(ws, buf);
+    }
+    st.pending = [];
+    st.pinger = setInterval(sendKeepalive, PING_INTERVAL_MS, ws);
+  };
+  ws.onmessage = (ev) => {
+    const raw = ev.data instanceof ArrayBuffer ? new Uint8Array(ev.data) : new Uint8Array(Buffer.from(ev.data));
+    const payload = decodeChunk(raw);
+    if (payload && payload.length > 0) {
+      st.established = true;
+      sock.write(payload);
+    }
+  };
+  ws.onerror = (ev) => {
+    const msg = "message" in ev ? String(ev.message) : "websocket error";
+    logForDebugging(`[upstreamproxy] ws error: ${msg}`);
+    if (st.closed)
+      return;
+    st.closed = true;
+    if (!st.established) {
+      sock.write(`HTTP/1.1 502 Bad Gateway\r
+\r
+`);
+    }
+    sock.end();
+    cleanupConn(st);
+  };
+  ws.onclose = () => {
+    if (st.closed)
+      return;
+    st.closed = true;
+    sock.end();
+    cleanupConn(st);
+  };
+}
+function sendKeepalive(ws) {
+  if (ws.readyState === WebSocket.OPEN) {
+    ws.send(encodeChunk(new Uint8Array(0)));
+  }
+}
+function forwardToWs(ws, data) {
+  if (ws.readyState !== WebSocket.OPEN)
+    return;
+  for (let off = 0;off < data.length; off += MAX_CHUNK_BYTES) {
+    const slice = new Uint8Array(data.subarray(off, off + MAX_CHUNK_BYTES));
+    ws.send(encodeChunk(slice));
+  }
+}
+function cleanupConn(st) {
+  if (!st)
+    return;
+  if (st.pinger)
+    clearInterval(st.pinger);
+  if (st.ws && st.ws.readyState <= WebSocket.OPEN) {
+    try {
+      st.ws.close();
+    } catch {}
+  }
+  st.ws = undefined;
+}
+
+// src/upstreamproxy/upstreamproxy.ts
+var SESSION_TOKEN_PATH = "/run/ccr/session_token";
+var SYSTEM_CA_BUNDLE = "/etc/ssl/certs/ca-certificates.crt";
+var NO_PROXY_LIST = [
+  "localhost",
+  "127.0.0.1",
+  "::1",
+  "169.254.0.0/16",
+  "10.0.0.0/8",
+  "172.16.0.0/12",
+  "192.168.0.0/16",
+  "anthropic.com",
+  ".anthropic.com",
+  "*.anthropic.com",
+  "github.com",
+  "api.github.com",
+  "*.github.com",
+  "*.githubusercontent.com",
+  "registry.npmjs.org",
+  "pypi.org",
+  "files.pythonhosted.org",
+  "index.crates.io",
+  "proxy.golang.org"
+].join(",");
+var state = { enabled: false };
+async function initUpstreamProxy(opts) {
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {
+    return state;
+  }
+  if (!isEnvTruthy(process.env.CCR_UPSTREAM_PROXY_ENABLED)) {
+    return state;
+  }
+  const sessionId = process.env.CLAUDE_CODE_REMOTE_SESSION_ID;
+  if (!sessionId) {
+    logForDebugging("[upstreamproxy] CLAUDE_CODE_REMOTE_SESSION_ID unset; proxy disabled", { level: "warn" });
+    return state;
+  }
+  const tokenPath = opts?.tokenPath ?? SESSION_TOKEN_PATH;
+  const token = await readToken(tokenPath);
+  if (!token) {
+    logForDebugging("[upstreamproxy] no session token file; proxy disabled");
+    return state;
+  }
+  setNonDumpable();
+  const baseUrl = opts?.ccrBaseUrl ?? process.env.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com";
+  const caBundlePath = opts?.caBundlePath ?? join(homedir(), ".ccr", "ca-bundle.crt");
+  const caOk = await downloadCaBundle(baseUrl, opts?.systemCaPath ?? SYSTEM_CA_BUNDLE, caBundlePath);
+  if (!caOk)
+    return state;
+  try {
+    const wsUrl = baseUrl.replace(/^http/, "ws") + "/v1/code/upstreamproxy/ws";
+    const relay = await startUpstreamProxyRelay({ wsUrl, sessionId, token });
+    registerCleanup(async () => relay.stop());
+    state = { enabled: true, port: relay.port, caBundlePath };
+    logForDebugging(`[upstreamproxy] enabled on 127.0.0.1:${relay.port}`);
+    await unlink(tokenPath).catch(() => {
+      logForDebugging("[upstreamproxy] token file unlink failed", {
+        level: "warn"
+      });
+    });
+  } catch (err) {
+    logForDebugging(`[upstreamproxy] relay start failed: ${err instanceof Error ? err.message : String(err)}; proxy disabled`, { level: "warn" });
+  }
+  return state;
+}
+function getUpstreamProxyEnv() {
+  if (!state.enabled || !state.port || !state.caBundlePath) {
+    if (process.env.HTTPS_PROXY && process.env.SSL_CERT_FILE) {
+      const inherited = {};
+      for (const key of [
+        "HTTPS_PROXY",
+        "https_proxy",
+        "NO_PROXY",
+        "no_proxy",
+        "SSL_CERT_FILE",
+        "NODE_EXTRA_CA_CERTS",
+        "REQUESTS_CA_BUNDLE",
+        "CURL_CA_BUNDLE"
+      ]) {
+        if (process.env[key])
+          inherited[key] = process.env[key];
+      }
+      return inherited;
+    }
+    return {};
+  }
+  const proxyUrl = `http://127.0.0.1:${state.port}`;
+  return {
+    HTTPS_PROXY: proxyUrl,
+    https_proxy: proxyUrl,
+    NO_PROXY: NO_PROXY_LIST,
+    no_proxy: NO_PROXY_LIST,
+    SSL_CERT_FILE: state.caBundlePath,
+    NODE_EXTRA_CA_CERTS: state.caBundlePath,
+    REQUESTS_CA_BUNDLE: state.caBundlePath,
+    CURL_CA_BUNDLE: state.caBundlePath
+  };
+}
+function resetUpstreamProxyForTests() {
+  state = { enabled: false };
+}
+async function readToken(path) {
+  try {
+    const raw = await readFile(path, "utf8");
+    return raw.trim() || null;
+  } catch (err) {
+    if (isENOENT(err))
+      return null;
+    logForDebugging(`[upstreamproxy] token read failed: ${err instanceof Error ? err.message : String(err)}`, { level: "warn" });
+    return null;
+  }
+}
+function setNonDumpable() {
+  if (process.platform !== "linux" || typeof Bun === "undefined")
+    return;
+  try {
+    const ffi = __require("bun:ffi");
+    const lib = ffi.dlopen("libc.so.6", {
+      prctl: {
+        args: ["int", "u64", "u64", "u64", "u64"],
+        returns: "int"
+      }
+    });
+    const PR_SET_DUMPABLE = 4;
+    const rc = lib.symbols.prctl(PR_SET_DUMPABLE, 0n, 0n, 0n, 0n);
+    if (rc !== 0) {
+      logForDebugging("[upstreamproxy] prctl(PR_SET_DUMPABLE,0) returned nonzero", {
+        level: "warn"
+      });
+    }
+  } catch (err) {
+    logForDebugging(`[upstreamproxy] prctl unavailable: ${err instanceof Error ? err.message : String(err)}`, { level: "warn" });
+  }
+}
+async function downloadCaBundle(baseUrl, systemCaPath, outPath) {
+  try {
+    const resp = await fetch(`${baseUrl}/v1/code/upstreamproxy/ca-cert`, {
+      signal: AbortSignal.timeout(5000)
+    });
+    if (!resp.ok) {
+      logForDebugging(`[upstreamproxy] ca-cert fetch ${resp.status}; proxy disabled`, { level: "warn" });
+      return false;
+    }
+    const ccrCa = await resp.text();
+    const systemCa = await readFile(systemCaPath, "utf8").catch(() => "");
+    await mkdir(join(outPath, ".."), { recursive: true });
+    await writeFile(outPath, systemCa + `
+` + ccrCa, "utf8");
+    return true;
+  } catch (err) {
+    logForDebugging(`[upstreamproxy] ca-cert download failed: ${err instanceof Error ? err.message : String(err)}; proxy disabled`, { level: "warn" });
+    return false;
+  }
+}
+export {
+  resetUpstreamProxyForTests,
+  initUpstreamProxy,
+  getUpstreamProxyEnv,
+  SESSION_TOKEN_PATH
+};

package/dist/chunk-czvztj44.js

@@ -0,0 +1,224 @@
+// @bun
+import {
+  CCR_SESSION_INGRESS_TOKEN_PATH,
+  init_authFileDescriptor,
+  maybePersistTokenForSubprocesses,
+  readTokenFromWellKnownFile
+} from "./chunk-hgba8zda.js";
+import {
+  init_diagLogs,
+  logForDiagnosticsNoPII
+} from "./chunk-b8x1gk3y.js";
+import {
+  errorMessage,
+  getFsImplementation,
+  init_cleanupRegistry,
+  init_debug,
+  init_errors,
+  init_fsOperations,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-sbbj6ta3.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-raqgs410.js";
+import {
+  getSessionIngressToken,
+  init_state,
+  setSessionIngressToken
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/sessionIngressAuth.ts
+function getTokenFromFileDescriptor() {
+  const cachedToken = getSessionIngressToken();
+  if (cachedToken !== undefined) {
+    return cachedToken;
+  }
+  const fdEnv = process.env.CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR;
+  if (!fdEnv) {
+    const path = process.env.CLAUDE_SESSION_INGRESS_TOKEN_FILE ?? CCR_SESSION_INGRESS_TOKEN_PATH;
+    const fromFile = readTokenFromWellKnownFile(path, "session ingress token");
+    setSessionIngressToken(fromFile);
+    return fromFile;
+  }
+  const fd = parseInt(fdEnv, 10);
+  if (Number.isNaN(fd)) {
+    logForDebugging(`CLAUDE_CODE_WEBSOCKET_AUTH_FILE_DESCRIPTOR must be a valid file descriptor number, got: ${fdEnv}`, { level: "error" });
+    setSessionIngressToken(null);
+    return null;
+  }
+  try {
+    const fsOps = getFsImplementation();
+    const fdPath = process.platform === "darwin" || process.platform === "freebsd" ? `/dev/fd/${fd}` : `/proc/self/fd/${fd}`;
+    const token = fsOps.readFileSync(fdPath, { encoding: "utf8" }).trim();
+    if (!token) {
+      logForDebugging("File descriptor contained empty token", {
+        level: "error"
+      });
+      setSessionIngressToken(null);
+      return null;
+    }
+    logForDebugging(`Successfully read token from file descriptor ${fd}`);
+    setSessionIngressToken(token);
+    maybePersistTokenForSubprocesses(CCR_SESSION_INGRESS_TOKEN_PATH, token, "session ingress token");
+    return token;
+  } catch (error) {
+    logForDebugging(`Failed to read token from file descriptor ${fd}: ${errorMessage(error)}`, { level: "error" });
+    const path = process.env.CLAUDE_SESSION_INGRESS_TOKEN_FILE ?? CCR_SESSION_INGRESS_TOKEN_PATH;
+    const fromFile = readTokenFromWellKnownFile(path, "session ingress token");
+    setSessionIngressToken(fromFile);
+    return fromFile;
+  }
+}
+function getSessionIngressAuthToken() {
+  const envToken = process.env.CLAUDE_CODE_SESSION_ACCESS_TOKEN;
+  if (envToken) {
+    return envToken;
+  }
+  return getTokenFromFileDescriptor();
+}
+function getSessionIngressAuthHeaders() {
+  const token = getSessionIngressAuthToken();
+  if (!token)
+    return {};
+  if (token.startsWith("sk-ant-sid")) {
+    const headers = {
+      Cookie: `sessionKey=${token}`
+    };
+    const orgUuid = process.env.CLAUDE_CODE_ORGANIZATION_UUID;
+    if (orgUuid) {
+      headers["X-Organization-Uuid"] = orgUuid;
+    }
+    return headers;
+  }
+  return { Authorization: `Bearer ${token}` };
+}
+function updateSessionIngressAuthToken(token) {
+  process.env.CLAUDE_CODE_SESSION_ACCESS_TOKEN = token;
+}
+var init_sessionIngressAuth = __esm(() => {
+  init_state();
+  init_authFileDescriptor();
+  init_debug();
+  init_errors();
+  init_fsOperations();
+});
+
+// src/services/api/emptyUsage.ts
+var EMPTY_USAGE;
+var init_emptyUsage = __esm(() => {
+  EMPTY_USAGE = {
+    input_tokens: 0,
+    cache_creation_input_tokens: 0,
+    cache_read_input_tokens: 0,
+    output_tokens: 0,
+    server_tool_use: { web_search_requests: 0, web_fetch_requests: 0 },
+    service_tier: "standard",
+    cache_creation: {
+      ephemeral_1h_input_tokens: 0,
+      ephemeral_5m_input_tokens: 0
+    },
+    inference_geo: "",
+    iterations: [],
+    speed: "standard"
+  };
+});
+
+// src/utils/sessionActivity.ts
+function startHeartbeatTimer() {
+  clearIdleTimer();
+  heartbeatTimer = setInterval(() => {
+    logForDiagnosticsNoPII("debug", "session_keepalive_heartbeat", {
+      refcount
+    });
+    if (isEnvTruthy(process.env.CLAUDE_CODE_REMOTE_SEND_KEEPALIVES)) {
+      activityCallback?.();
+    }
+  }, SESSION_ACTIVITY_INTERVAL_MS);
+}
+function startIdleTimer() {
+  clearIdleTimer();
+  if (activityCallback === null) {
+    return;
+  }
+  idleTimer = setTimeout(() => {
+    logForDiagnosticsNoPII("info", "session_idle_30s");
+    idleTimer = null;
+  }, SESSION_ACTIVITY_INTERVAL_MS);
+}
+function clearIdleTimer() {
+  if (idleTimer !== null) {
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  }
+}
+function registerSessionActivityCallback(cb) {
+  activityCallback = cb;
+  if (refcount > 0 && heartbeatTimer === null) {
+    startHeartbeatTimer();
+  }
+}
+function unregisterSessionActivityCallback() {
+  activityCallback = null;
+  if (heartbeatTimer !== null) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+  clearIdleTimer();
+}
+function sendSessionActivitySignal() {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_REMOTE_SEND_KEEPALIVES)) {
+    activityCallback?.();
+  }
+}
+function isSessionActivityTrackingActive() {
+  return activityCallback !== null;
+}
+function startSessionActivity(reason) {
+  refcount++;
+  activeReasons.set(reason, (activeReasons.get(reason) ?? 0) + 1);
+  if (refcount === 1) {
+    oldestActivityStartedAt = Date.now();
+    if (activityCallback !== null && heartbeatTimer === null) {
+      startHeartbeatTimer();
+    }
+  }
+  if (!cleanupRegistered) {
+    cleanupRegistered = true;
+    registerCleanup(async () => {
+      logForDiagnosticsNoPII("info", "session_activity_at_shutdown", {
+        refcount,
+        active: Object.fromEntries(activeReasons),
+        oldest_activity_ms: refcount > 0 && oldestActivityStartedAt !== null ? Date.now() - oldestActivityStartedAt : null
+      });
+    });
+  }
+}
+function stopSessionActivity(reason) {
+  if (refcount > 0) {
+    refcount--;
+  }
+  const n = (activeReasons.get(reason) ?? 0) - 1;
+  if (n > 0)
+    activeReasons.set(reason, n);
+  else
+    activeReasons.delete(reason);
+  if (refcount === 0 && heartbeatTimer !== null) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+    startIdleTimer();
+  }
+}
+var SESSION_ACTIVITY_INTERVAL_MS = 30000, activityCallback = null, refcount = 0, activeReasons, oldestActivityStartedAt = null, heartbeatTimer = null, idleTimer = null, cleanupRegistered = false;
+var init_sessionActivity = __esm(() => {
+  init_cleanupRegistry();
+  init_diagLogs();
+  init_envUtils();
+  activeReasons = new Map;
+});
+
+export { getSessionIngressAuthToken, getSessionIngressAuthHeaders, updateSessionIngressAuthToken, init_sessionIngressAuth, registerSessionActivityCallback, unregisterSessionActivityCallback, sendSessionActivitySignal, isSessionActivityTrackingActive, startSessionActivity, stopSessionActivity, init_sessionActivity, EMPTY_USAGE, init_emptyUsage };