@zyycn/claudex 1.0.3-fork.63859d8

package/dist/chunk-9bh231gs.js

@@ -0,0 +1,333 @@
+// @bun
+import {
+  CCRClient,
+  SSETransport
+} from "./chunk-5x0qecy1.js";
+import {
+  init_bridgeEnabled
+} from "./chunk-d1gtryh9.js";
+import {
+  init_sessionIngressAuth,
+  updateSessionIngressAuthToken
+} from "./chunk-bftwqs59.js";
+import {
+  init_semver,
+  lt
+} from "./chunk-ps49ymvj.js";
+import {
+  getFeatureValue_DEPRECATED,
+  init_growthbook
+} from "./chunk-kh4zk8k3.js";
+import {
+  init_v4
+} from "./chunk-g0j0t6qk.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonParse,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+
+// src/bridge/envLessBridgeConfig.ts
+init_v4();
+init_growthbook();
+init_lazySchema();
+init_semver();
+init_bridgeEnabled();
+var DEFAULT_ENV_LESS_BRIDGE_CONFIG = {
+  init_retry_max_attempts: 3,
+  init_retry_base_delay_ms: 500,
+  init_retry_jitter_fraction: 0.25,
+  init_retry_max_delay_ms: 4000,
+  http_timeout_ms: 1e4,
+  uuid_dedup_buffer_size: 2000,
+  heartbeat_interval_ms: 20000,
+  heartbeat_jitter_fraction: 0.1,
+  token_refresh_buffer_ms: 300000,
+  teardown_archive_timeout_ms: 1500,
+  connect_timeout_ms: 15000,
+  min_version: "0.0.0",
+  should_show_app_upgrade_message: false
+};
+var envLessBridgeConfigSchema = lazySchema(() => exports_external.object({
+  init_retry_max_attempts: exports_external.number().int().min(1).max(10).default(3),
+  init_retry_base_delay_ms: exports_external.number().int().min(100).default(500),
+  init_retry_jitter_fraction: exports_external.number().min(0).max(1).default(0.25),
+  init_retry_max_delay_ms: exports_external.number().int().min(500).default(4000),
+  http_timeout_ms: exports_external.number().int().min(2000).default(1e4),
+  uuid_dedup_buffer_size: exports_external.number().int().min(100).max(50000).default(2000),
+  heartbeat_interval_ms: exports_external.number().int().min(5000).max(30000).default(20000),
+  heartbeat_jitter_fraction: exports_external.number().min(0).max(0.5).default(0.1),
+  token_refresh_buffer_ms: exports_external.number().int().min(30000).max(1800000).default(300000),
+  teardown_archive_timeout_ms: exports_external.number().int().min(500).max(2000).default(1500),
+  connect_timeout_ms: exports_external.number().int().min(5000).max(60000).default(15000),
+  min_version: exports_external.string().refine((v) => {
+    try {
+      lt(v, "0.0.0");
+      return true;
+    } catch {
+      return false;
+    }
+  }).default("0.0.0"),
+  should_show_app_upgrade_message: exports_external.boolean().default(false)
+}));
+async function getEnvLessBridgeConfig() {
+  const raw = await getFeatureValue_DEPRECATED("tengu_bridge_repl_v2_config", DEFAULT_ENV_LESS_BRIDGE_CONFIG);
+  const parsed = envLessBridgeConfigSchema().safeParse(raw);
+  return parsed.success ? parsed.data : DEFAULT_ENV_LESS_BRIDGE_CONFIG;
+}
+async function checkEnvLessBridgeMinVersion() {
+  const cfg = await getEnvLessBridgeConfig();
+  if (cfg.min_version && lt("1.0.3-fork.63859d8", cfg.min_version)) {
+    return `Your version of Claude Code (${"1.0.3-fork.63859d8"}) is too old for Remote Control.
+Version ${cfg.min_version} or higher is required. Run \`claude update\` to update.`;
+  }
+  return null;
+}
+
+// src/bridge/workSecret.ts
+init_axios();
+init_slowOperations();
+function decodeWorkSecret(secret) {
+  const json = Buffer.from(secret, "base64url").toString("utf-8");
+  const parsed = jsonParse(json);
+  if (!parsed || typeof parsed !== "object" || !("version" in parsed) || parsed.version !== 1) {
+    throw new Error(`Unsupported work secret version: ${parsed && typeof parsed === "object" && "version" in parsed ? parsed.version : "unknown"}`);
+  }
+  const obj = parsed;
+  if (typeof obj.session_ingress_token !== "string" || obj.session_ingress_token.length === 0) {
+    throw new Error("Invalid work secret: missing or empty session_ingress_token");
+  }
+  if (typeof obj.api_base_url !== "string") {
+    throw new Error("Invalid work secret: missing api_base_url");
+  }
+  return parsed;
+}
+function buildSdkUrl(apiBaseUrl, sessionId) {
+  const isLocalhost = apiBaseUrl.includes("localhost") || apiBaseUrl.includes("127.0.0.1");
+  const protocol = isLocalhost ? "ws" : "wss";
+  const version = isLocalhost ? "v2" : "v1";
+  const host = apiBaseUrl.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  return `${protocol}://${host}/${version}/session_ingress/ws/${sessionId}`;
+}
+function sameSessionId(a, b) {
+  if (a === b)
+    return true;
+  const aBody = a.slice(a.lastIndexOf("_") + 1);
+  const bBody = b.slice(b.lastIndexOf("_") + 1);
+  return aBody.length >= 4 && aBody === bBody;
+}
+function buildCCRv2SdkUrl(apiBaseUrl, sessionId) {
+  const base = apiBaseUrl.replace(/\/+$/, "");
+  return `${base}/v1/code/sessions/${sessionId}`;
+}
+async function registerWorker(sessionUrl, accessToken) {
+  const response = await axios_default.post(`${sessionUrl}/worker/register`, {}, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01"
+    },
+    timeout: 1e4
+  });
+  const raw = response.data?.worker_epoch;
+  const epoch = typeof raw === "string" ? Number(raw) : raw;
+  if (typeof epoch !== "number" || !Number.isFinite(epoch) || !Number.isSafeInteger(epoch)) {
+    throw new Error(`registerWorker: invalid worker_epoch in response: ${jsonStringify(response.data)}`);
+  }
+  return epoch;
+}
+
+// src/bridge/replBridgeTransport.ts
+init_debug();
+init_errors();
+init_sessionIngressAuth();
+function createV1ReplTransport(hybrid) {
+  return {
+    write: (msg) => hybrid.write(msg),
+    writeBatch: (msgs) => hybrid.writeBatch(msgs),
+    close: () => hybrid.close(),
+    isConnectedStatus: () => hybrid.isConnectedStatus(),
+    getStateLabel: () => hybrid.getStateLabel(),
+    setOnData: (cb) => hybrid.setOnData(cb),
+    setOnClose: (cb) => hybrid.setOnClose(cb),
+    setOnConnect: (cb) => hybrid.setOnConnect(cb),
+    connect: () => void hybrid.connect(),
+    getLastSequenceNum: () => 0,
+    get droppedBatchCount() {
+      return hybrid.droppedBatchCount;
+    },
+    reportState: () => {},
+    reportMetadata: () => {},
+    reportDelivery: () => {},
+    flush: () => Promise.resolve()
+  };
+}
+async function createV2ReplTransport(opts) {
+  const {
+    sessionUrl,
+    ingressToken,
+    sessionId,
+    initialSequenceNum,
+    getAuthToken
+  } = opts;
+  let getAuthHeaders;
+  if (getAuthToken) {
+    getAuthHeaders = () => {
+      const token = getAuthToken();
+      if (!token)
+        return {};
+      return { Authorization: `Bearer ${token}` };
+    };
+  } else {
+    updateSessionIngressAuthToken(ingressToken);
+  }
+  const epoch = opts.epoch ?? await registerWorker(sessionUrl, ingressToken);
+  logForDebugging(`[bridge:repl] CCR v2: worker sessionId=${sessionId} epoch=${epoch}${opts.epoch !== undefined ? " (from /bridge)" : " (via registerWorker)"}`);
+  const sseUrl = new URL(sessionUrl);
+  sseUrl.pathname = sseUrl.pathname.replace(/\/$/, "") + "/worker/events/stream";
+  const sse = new SSETransport(sseUrl, {}, sessionId, undefined, initialSequenceNum, getAuthHeaders);
+  let onCloseCb;
+  const ccr = new CCRClient(sse, new URL(sessionUrl), {
+    getAuthHeaders,
+    heartbeatIntervalMs: opts.heartbeatIntervalMs,
+    heartbeatJitterFraction: opts.heartbeatJitterFraction,
+    onEpochMismatch: () => {
+      logForDebugging("[bridge:repl] CCR v2: epoch superseded (409) \u2014 closing for poll-loop recovery");
+      try {
+        ccr.close();
+        sse.close();
+        onCloseCb?.(4090);
+      } catch (closeErr) {
+        logForDebugging(`[bridge:repl] CCR v2: error during epoch-mismatch cleanup: ${errorMessage(closeErr)}`, { level: "error" });
+      }
+      throw new Error("epoch superseded");
+    }
+  });
+  sse.setOnEvent((event) => {
+    ccr.reportDelivery(event.event_id, "received");
+    ccr.reportDelivery(event.event_id, "processed");
+  });
+  let onConnectCb;
+  let ccrInitialized = false;
+  let closed = false;
+  return {
+    write(msg) {
+      return ccr.writeEvent(msg);
+    },
+    async writeBatch(msgs) {
+      for (const m of msgs) {
+        if (closed)
+          break;
+        await ccr.writeEvent(m);
+      }
+    },
+    close() {
+      closed = true;
+      ccr.close();
+      sse.close();
+    },
+    isConnectedStatus() {
+      return ccrInitialized;
+    },
+    getStateLabel() {
+      if (sse.isClosedStatus())
+        return "closed";
+      if (sse.isConnectedStatus())
+        return ccrInitialized ? "connected" : "init";
+      return "connecting";
+    },
+    setOnData(cb) {
+      sse.setOnData(cb);
+    },
+    setOnClose(cb) {
+      onCloseCb = cb;
+      sse.setOnClose((code) => {
+        ccr.close();
+        cb(code ?? 4092);
+      });
+    },
+    setOnConnect(cb) {
+      onConnectCb = cb;
+    },
+    getLastSequenceNum() {
+      return sse.getLastSequenceNum();
+    },
+    droppedBatchCount: 0,
+    reportState(state) {
+      ccr.reportState(state);
+    },
+    reportMetadata(metadata) {
+      ccr.reportMetadata(metadata);
+    },
+    reportDelivery(eventId, status) {
+      ccr.reportDelivery(eventId, status);
+    },
+    flush() {
+      return ccr.flush();
+    },
+    connect() {
+      if (!opts.outboundOnly) {
+        sse.connect();
+      }
+      ccr.initialize(epoch).then(() => {
+        ccrInitialized = true;
+        logForDebugging(`[bridge:repl] v2 transport ready for writes (epoch=${epoch}, sse=${sse.isConnectedStatus() ? "open" : "opening"})`);
+        onConnectCb?.();
+      }, (err) => {
+        logForDebugging(`[bridge:repl] CCR v2 initialize failed: ${errorMessage(err)}`, { level: "error" });
+        ccr.close();
+        sse.close();
+        onCloseCb?.(4091);
+      });
+    }
+  };
+}
+
+// src/bridge/flushGate.ts
+class FlushGate {
+  _active = false;
+  _pending = [];
+  get active() {
+    return this._active;
+  }
+  get pendingCount() {
+    return this._pending.length;
+  }
+  start() {
+    this._active = true;
+  }
+  end() {
+    this._active = false;
+    return this._pending.splice(0);
+  }
+  enqueue(...items) {
+    if (!this._active)
+      return false;
+    this._pending.push(...items);
+    return true;
+  }
+  drop() {
+    this._active = false;
+    const count = this._pending.length;
+    this._pending.length = 0;
+    return count;
+  }
+  deactivate() {
+    this._active = false;
+  }
+}
+
+export { getEnvLessBridgeConfig, checkEnvLessBridgeMinVersion, decodeWorkSecret, buildSdkUrl, sameSessionId, buildCCRv2SdkUrl, createV1ReplTransport, createV2ReplTransport, FlushGate };

package/dist/chunk-9gbamk79.js

@@ -0,0 +1,93 @@
+// @bun
+import {
+  L,
+  init_index_min
+} from "./chunk-qnfx3qtx.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/fileStateCache.ts
+import { normalize } from "path";
+
+class FileStateCache {
+  cache;
+  constructor(maxEntries, maxSizeBytes) {
+    this.cache = new L({
+      max: maxEntries,
+      maxSize: maxSizeBytes,
+      sizeCalculation: (value) => Math.max(1, Buffer.byteLength(value.content))
+    });
+  }
+  get(key) {
+    return this.cache.get(normalize(key));
+  }
+  set(key, value) {
+    this.cache.set(normalize(key), value);
+    return this;
+  }
+  has(key) {
+    return this.cache.has(normalize(key));
+  }
+  delete(key) {
+    return this.cache.delete(normalize(key));
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+  get max() {
+    return this.cache.max;
+  }
+  get maxSize() {
+    return this.cache.maxSize;
+  }
+  get calculatedSize() {
+    return this.cache.calculatedSize;
+  }
+  keys() {
+    return this.cache.keys();
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  dump() {
+    return this.cache.dump();
+  }
+  load(entries) {
+    this.cache.load(entries);
+  }
+}
+function createFileStateCacheWithSizeLimit(maxEntries, maxSizeBytes = DEFAULT_MAX_CACHE_SIZE_BYTES) {
+  return new FileStateCache(maxEntries, maxSizeBytes);
+}
+function cacheToObject(cache) {
+  return Object.fromEntries(cache.entries());
+}
+function cacheKeys(cache) {
+  return Array.from(cache.keys());
+}
+function cloneFileStateCache(cache) {
+  const cloned = createFileStateCacheWithSizeLimit(cache.max, cache.maxSize);
+  cloned.load(cache.dump());
+  return cloned;
+}
+function mergeFileStateCaches(first, second) {
+  const merged = cloneFileStateCache(first);
+  for (const [filePath, fileState] of second.entries()) {
+    const existing = merged.get(filePath);
+    if (!existing || fileState.timestamp > existing.timestamp) {
+      merged.set(filePath, fileState);
+    }
+  }
+  return merged;
+}
+var READ_FILE_STATE_CACHE_SIZE = 100, DEFAULT_MAX_CACHE_SIZE_BYTES;
+var init_fileStateCache = __esm(() => {
+  init_index_min();
+  DEFAULT_MAX_CACHE_SIZE_BYTES = 25 * 1024 * 1024;
+});
+
+export { READ_FILE_STATE_CACHE_SIZE, createFileStateCacheWithSizeLimit, cacheToObject, cacheKeys, cloneFileStateCache, mergeFileStateCaches, init_fileStateCache };

package/dist/chunk-9jetfeq0.js

@@ -0,0 +1,114 @@
+// @bun
+import {
+  Settings,
+  init_Settings
+} from "./chunk-n04af68e.js";
+import"./chunk-2m3nn9wn.js";
+import"./chunk-d1gtryh9.js";
+import"./chunk-41bv0qr9.js";
+import"./chunk-harq79ch.js";
+import"./chunk-bx3fzqtt.js";
+import"./chunk-68k646wc.js";
+import"./chunk-zpwh305r.js";
+import"./chunk-gnves4xd.js";
+import"./chunk-b5fkptr7.js";
+import"./chunk-ycbkq0vg.js";
+import"./chunk-2ssrm349.js";
+import"./chunk-0hgm34fp.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-bftwqs59.js";
+import"./chunk-zkpjxvnd.js";
+import"./chunk-cyp8x61z.js";
+import"./chunk-cgeewb6e.js";
+import"./chunk-41x5pfyr.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-smfnjta6.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-pa86j0bt.js";
+import"./chunk-cgqxb74c.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-pn0gryjm.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-n9n0mrjy.js";
+import"./chunk-e65m636c.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import"./chunk-pfz2eecq.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-png9e5ck.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-4bt4tycr.js";
+import"./chunk-kh4zk8k3.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-9nta4x35.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-vqk1n5qr.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-d9kz373t.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-w8yw30sd.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-dstxhxsx.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import"./chunk-yysj6sxt.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./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 {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/usage/usage.tsx
+var jsx_dev_runtime, call = async (onDone, context) => {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Settings, {
+    onClose: onDone,
+    context,
+    defaultTab: "Usage"
+  }, undefined, false, undefined, this);
+};
+var init_usage = __esm(() => {
+  init_Settings();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_usage();
+
+export {
+  call
+};

package/dist/chunk-9k2drwej.js

@@ -0,0 +1,106 @@
+// @bun
+import {
+  L,
+  init_index_min
+} from "./chunk-qnfx3qtx.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  init_slowOperations,
+  jsonStringify
+} from "./chunk-sbbj6ta3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/memoize.ts
+function memoizeWithTTLAsync(f, cacheLifetimeMs = 5 * 60 * 1000) {
+  const cache = new Map;
+  const inFlight = new Map;
+  const memoized = async (...args) => {
+    const key = jsonStringify(args);
+    const cached = cache.get(key);
+    const now = Date.now();
+    if (!cached) {
+      const pending = inFlight.get(key);
+      if (pending)
+        return pending;
+      const promise = f(...args);
+      inFlight.set(key, promise);
+      try {
+        const result = await promise;
+        if (inFlight.get(key) === promise) {
+          cache.set(key, {
+            value: result,
+            timestamp: now,
+            refreshing: false
+          });
+        }
+        return result;
+      } finally {
+        if (inFlight.get(key) === promise) {
+          inFlight.delete(key);
+        }
+      }
+    }
+    if (cached && now - cached.timestamp > cacheLifetimeMs && !cached.refreshing) {
+      cached.refreshing = true;
+      const staleEntry = cached;
+      f(...args).then((newValue) => {
+        if (cache.get(key) === staleEntry) {
+          cache.set(key, {
+            value: newValue,
+            timestamp: Date.now(),
+            refreshing: false
+          });
+        }
+      }).catch((e) => {
+        logError(e);
+        if (cache.get(key) === staleEntry) {
+          cache.delete(key);
+        }
+      });
+      return cached.value;
+    }
+    return cache.get(key).value;
+  };
+  memoized.cache = {
+    clear: () => {
+      cache.clear();
+      inFlight.clear();
+    }
+  };
+  return memoized;
+}
+function memoizeWithLRU(f, cacheFn, maxCacheSize = 100) {
+  const cache = new L({
+    max: maxCacheSize
+  });
+  const memoized = (...args) => {
+    const key = cacheFn(...args);
+    const cached = cache.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const result = f(...args);
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = {
+    clear: () => cache.clear(),
+    size: () => cache.size,
+    delete: (key) => cache.delete(key),
+    get: (key) => cache.peek(key),
+    has: (key) => cache.has(key)
+  };
+  return memoized;
+}
+var init_memoize = __esm(() => {
+  init_index_min();
+  init_log();
+  init_slowOperations();
+});
+
+export { memoizeWithTTLAsync, memoizeWithLRU, init_memoize };