@zyycn/claudex 1.0.3-fork.3767904

package/dist/chunk-8mtb0zzs.js

@@ -0,0 +1,40 @@
+// @bun
+import {
+  init_toolPool,
+  mergeAndFilterTools
+} from "./chunk-v2pc6h28.js";
+import {
+  assembleToolPool,
+  init_tools1 as init_tools
+} from "./chunk-njmw3yt4.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/hooks/useMergedTools.ts
+function useMergedTools(initialTools, mcpTools, toolPermissionContext) {
+  let replBridgeEnabled = false;
+  let replBridgeOutboundOnly = false;
+  return import_react.useMemo(() => {
+    const assembled = assembleToolPool(toolPermissionContext, mcpTools);
+    return mergeAndFilterTools(initialTools, assembled, toolPermissionContext.mode);
+  }, [
+    initialTools,
+    mcpTools,
+    toolPermissionContext,
+    replBridgeEnabled,
+    replBridgeOutboundOnly
+  ]);
+}
+var import_react;
+var init_useMergedTools = __esm(() => {
+  init_tools();
+  init_toolPool();
+  import_react = __toESM(require_react(), 1);
+});
+
+export { useMergedTools, init_useMergedTools };

package/dist/chunk-8qm7hxn7.js

@@ -0,0 +1,27 @@
+// @bun
+import {
+  fromSSO,
+  init_dist_es,
+  isSsoProfile,
+  validateSsoProfile
+} from "./chunk-h5f90qy3.js";
+import"./chunk-nx4e896a.js";
+import"./chunk-wzpdet3m.js";
+import"./chunk-p2d5nh3g.js";
+import"./chunk-n0qaeaa5.js";
+import"./chunk-wfz0qffj.js";
+import"./chunk-b4wg70y1.js";
+import"./chunk-nka1g8f4.js";
+import"./chunk-30rst83v.js";
+import"./chunk-j2k4p94p.js";
+import"./chunk-hk9xz7gk.js";
+import"./chunk-xsq9ae7x.js";
+import"./chunk-2nayx6q1.js";
+import"./chunk-qp2qdcda.js";
+init_dist_es();
+
+export {
+  validateSsoProfile,
+  isSsoProfile,
+  fromSSO
+};

package/dist/chunk-8tnsngw2.js

@@ -0,0 +1,31 @@
+// @bun
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/hash.ts
+function djb2Hash(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i) | 0;
+  }
+  return hash;
+}
+function hashContent(content) {
+  if (typeof Bun !== "undefined") {
+    return Bun.hash(content).toString();
+  }
+  const crypto = __require("crypto");
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+function hashPair(a, b) {
+  if (typeof Bun !== "undefined") {
+    return Bun.hash(b, Bun.hash(a)).toString();
+  }
+  const crypto = __require("crypto");
+  return crypto.createHash("sha256").update(a).update("\x00").update(b).digest("hex");
+}
+var init_hash = () => {};
+
+export { djb2Hash, hashContent, hashPair, init_hash };

package/dist/chunk-8y0qvap3.js

@@ -0,0 +1,333 @@
+// @bun
+import {
+  CCRClient,
+  SSETransport
+} from "./chunk-0b8kwsg7.js";
+import {
+  init_bridgeEnabled
+} from "./chunk-2r6p51j7.js";
+import {
+  init_sessionIngressAuth,
+  updateSessionIngressAuthToken
+} from "./chunk-a8fvd2bk.js";
+import {
+  init_semver,
+  lt
+} from "./chunk-ps49ymvj.js";
+import {
+  getFeatureValue_DEPRECATED,
+  init_growthbook
+} from "./chunk-z06751ss.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.3767904", cfg.min_version)) {
+    return `Your version of Claude Code (${"1.0.3-fork.3767904"}) 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-8y12jxg8.js

@@ -0,0 +1,10 @@
+// @bun
+import {
+  require_src
+} from "./chunk-6tq2v3rk.js";
+import"./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-qp2qdcda.js";
+export default require_src();

package/dist/chunk-8ymf4e6z.js

@@ -0,0 +1,48 @@
+// @bun
+import {
+  require_index_node_http,
+  require_src,
+  require_src1 as require_src2
+} from "./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-proto@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-proto/build/esm/platform/node/OTLPTraceExporter.js
+var import_otlp_exporter_base, import_otlp_transformer, import_node_http, OTLPTraceExporter;
+var init_OTLPTraceExporter = __esm(() => {
+  import_otlp_exporter_base = __toESM(require_src(), 1);
+  import_otlp_transformer = __toESM(require_src2(), 1);
+  import_node_http = __toESM(require_index_node_http(), 1);
+  OTLPTraceExporter = class OTLPTraceExporter extends import_otlp_exporter_base.OTLPExporterBase {
+    constructor(config = {}) {
+      super(import_node_http.createOtlpHttpExportDelegate(import_node_http.convertLegacyHttpOptions(config, "TRACES", "v1/traces", {
+        "Content-Type": "application/x-protobuf"
+      }), import_otlp_transformer.ProtobufTraceSerializer));
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-proto@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-proto/build/esm/platform/node/index.js
+var init_node = __esm(() => {
+  init_OTLPTraceExporter();
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-proto@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-proto/build/esm/platform/index.js
+var init_platform = __esm(() => {
+  init_node();
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-proto@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-proto/build/esm/index.js
+var init_esm = __esm(() => {
+  init_platform();
+});
+init_esm();
+
+export {
+  OTLPTraceExporter
+};