@zyycn/claudex 1.0.3-fork.1453470

package/dist/chunk-q2rb0hsc.js

@@ -0,0 +1,192 @@
+// @bun
+import {
+  formatGrantAmount,
+  getCachedOverageCreditGrant,
+  init_overageCreditGrant,
+  refreshOverageCreditGrantCache
+} from "./chunk-rwbhn5vg.js";
+import {
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-zp37prdd.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-3tqnjgfx.js";
+import {
+  init_format,
+  truncate
+} from "./chunk-wgcssf6v.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/LogoV2/OverageCreditUpsell.tsx
+function isEligibleForOverageCreditGrant() {
+  const info = getCachedOverageCreditGrant();
+  if (!info || !info.available || info.granted)
+    return false;
+  return formatGrantAmount(info) !== null;
+}
+function shouldShowOverageCreditUpsell() {
+  if (!isEligibleForOverageCreditGrant())
+    return false;
+  const config = getGlobalConfig();
+  if (config.hasVisitedExtraUsage)
+    return false;
+  if ((config.overageCreditUpsellSeenCount ?? 0) >= MAX_IMPRESSIONS)
+    return false;
+  return true;
+}
+function maybeRefreshOverageCreditCache() {
+  if (getCachedOverageCreditGrant() !== null)
+    return;
+  refreshOverageCreditGrantCache();
+}
+function useShowOverageCreditUpsell() {
+  const [show] = import_react.useState(_temp);
+  return show;
+}
+function _temp() {
+  maybeRefreshOverageCreditCache();
+  return shouldShowOverageCreditUpsell();
+}
+function incrementOverageCreditUpsellSeenCount() {
+  let newCount = 0;
+  saveGlobalConfig((prev) => {
+    newCount = (prev.overageCreditUpsellSeenCount ?? 0) + 1;
+    return {
+      ...prev,
+      overageCreditUpsellSeenCount: newCount
+    };
+  });
+  logEvent("tengu_overage_credit_upsell_shown", {
+    seen_count: newCount
+  });
+}
+function getUsageText(amount) {
+  return `${amount} in extra usage for third-party apps \xB7 /extra-usage`;
+}
+function getFeedTitle(amount) {
+  return `${amount} in extra usage`;
+}
+function OverageCreditUpsell(t0) {
+  const $ = import_compiler_runtime.c(8);
+  const {
+    maxWidth,
+    twoLine
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== maxWidth || $[1] !== twoLine) {
+    t2 = Symbol.for("react.early_return_sentinel");
+    bb0: {
+      const info = getCachedOverageCreditGrant();
+      if (!info) {
+        t2 = null;
+        break bb0;
+      }
+      const amount = formatGrantAmount(info);
+      if (!amount) {
+        t2 = null;
+        break bb0;
+      }
+      if (twoLine) {
+        const title = getFeedTitle(amount);
+        let t3;
+        if ($[4] !== maxWidth) {
+          t3 = maxWidth ? truncate(FEED_SUBTITLE, maxWidth) : FEED_SUBTITLE;
+          $[4] = maxWidth;
+          $[5] = t3;
+        } else {
+          t3 = $[5];
+        }
+        let t4;
+        if ($[6] !== t3) {
+          t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: t3
+          }, undefined, false, undefined, this);
+          $[6] = t3;
+          $[7] = t4;
+        } else {
+          t4 = $[7];
+        }
+        t2 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              color: "claude",
+              children: maxWidth ? truncate(title, maxWidth) : title
+            }, undefined, false, undefined, this),
+            t4
+          ]
+        }, undefined, true, undefined, this);
+        break bb0;
+      }
+      const text = getUsageText(amount);
+      const display = maxWidth ? truncate(text, maxWidth) : text;
+      const highlightLen = Math.min(getFeedTitle(amount).length, display.length);
+      t1 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        dimColor: true,
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            color: "claude",
+            children: display.slice(0, highlightLen)
+          }, undefined, false, undefined, this),
+          display.slice(highlightLen)
+        ]
+      }, undefined, true, undefined, this);
+    }
+    $[0] = maxWidth;
+    $[1] = twoLine;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t1 = $[2];
+    t2 = $[3];
+  }
+  if (t2 !== Symbol.for("react.early_return_sentinel")) {
+    return t2;
+  }
+  return t1;
+}
+function createOverageCreditFeed() {
+  const info = getCachedOverageCreditGrant();
+  const amount = info ? formatGrantAmount(info) : null;
+  const title = amount ? getFeedTitle(amount) : "extra usage credit";
+  return {
+    title,
+    lines: [],
+    customContent: {
+      content: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        dimColor: true,
+        children: FEED_SUBTITLE
+      }, undefined, false, undefined, this),
+      width: Math.max(title.length, FEED_SUBTITLE.length)
+    }
+  };
+}
+var import_compiler_runtime, import_react, jsx_dev_runtime, MAX_IMPRESSIONS = 3, FEED_SUBTITLE = "On us. Works on third-party apps \xB7 /extra-usage";
+var init_OverageCreditUpsell = __esm(() => {
+  init_ink();
+  init_analytics();
+  init_overageCreditGrant();
+  init_config();
+  init_format();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { isEligibleForOverageCreditGrant, shouldShowOverageCreditUpsell, useShowOverageCreditUpsell, incrementOverageCreditUpsellSeenCount, OverageCreditUpsell, createOverageCreditFeed, init_OverageCreditUpsell };

package/dist/chunk-q7bxdsfd.js

@@ -0,0 +1,22 @@
+// @bun
+import {
+  require_sts
+} from "./chunk-ds5nkfg0.js";
+import"./chunk-h0qngp9w.js";
+import"./chunk-jpp9dqv4.js";
+import"./chunk-n7ttdtk0.js";
+import"./chunk-wzpdet3m.js";
+import"./chunk-p2d5nh3g.js";
+import"./chunk-jzmz18nn.js";
+import"./chunk-n0qaeaa5.js";
+import"./chunk-2k995y2x.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";
+export default require_sts();

package/dist/chunk-qbt1tq74.js

@@ -0,0 +1,145 @@
+// @bun
+import {
+  getProjectsDir,
+  getWorktreePathsPortable,
+  init_getWorktreePathsPortable,
+  init_sessionStoragePortable,
+  sanitizePath
+} from "./chunk-4qz9vbs1.js";
+import {
+  init_v4
+} from "./chunk-g0j0t6qk.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import"./chunk-8tnsngw2.js";
+import {
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  isENOENT,
+  jsonParse,
+  jsonStringify,
+  logForDebugging
+} from "./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-qp2qdcda.js";
+
+// src/bridge/bridgePointer.ts
+init_v4();
+init_debug();
+init_errors();
+init_getWorktreePathsPortable();
+init_lazySchema();
+init_sessionStoragePortable();
+init_slowOperations();
+import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var MAX_WORKTREE_FANOUT = 50;
+var BRIDGE_POINTER_TTL_MS = 4 * 60 * 60 * 1000;
+var BridgePointerSchema = lazySchema(() => exports_external.object({
+  sessionId: exports_external.string(),
+  environmentId: exports_external.string(),
+  source: exports_external.enum(["standalone", "repl"])
+}));
+function getBridgePointerPath(dir) {
+  return join(getProjectsDir(), sanitizePath(dir), "bridge-pointer.json");
+}
+async function writeBridgePointer(dir, pointer) {
+  const path = getBridgePointerPath(dir);
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, jsonStringify(pointer), "utf8");
+    logForDebugging(`[bridge:pointer] wrote ${path}`);
+  } catch (err) {
+    logForDebugging(`[bridge:pointer] write failed: ${err}`, { level: "warn" });
+  }
+}
+async function readBridgePointer(dir) {
+  const path = getBridgePointerPath(dir);
+  let raw;
+  let mtimeMs;
+  try {
+    mtimeMs = (await stat(path)).mtimeMs;
+    raw = await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+  const parsed = BridgePointerSchema().safeParse(safeJsonParse(raw));
+  if (!parsed.success) {
+    logForDebugging(`[bridge:pointer] invalid schema, clearing: ${path}`);
+    await clearBridgePointer(dir);
+    return null;
+  }
+  const ageMs = Math.max(0, Date.now() - mtimeMs);
+  if (ageMs > BRIDGE_POINTER_TTL_MS) {
+    logForDebugging(`[bridge:pointer] stale (>4h mtime), clearing: ${path}`);
+    await clearBridgePointer(dir);
+    return null;
+  }
+  return { ...parsed.data, ageMs };
+}
+async function readBridgePointerAcrossWorktrees(dir) {
+  const here = await readBridgePointer(dir);
+  if (here) {
+    return { pointer: here, dir };
+  }
+  const worktrees = await getWorktreePathsPortable(dir);
+  if (worktrees.length <= 1)
+    return null;
+  if (worktrees.length > MAX_WORKTREE_FANOUT) {
+    logForDebugging(`[bridge:pointer] ${worktrees.length} worktrees exceeds fanout cap ${MAX_WORKTREE_FANOUT}, skipping`);
+    return null;
+  }
+  const dirKey = sanitizePath(dir);
+  const candidates = worktrees.filter((wt) => sanitizePath(wt) !== dirKey);
+  const results = await Promise.all(candidates.map(async (wt) => {
+    const p = await readBridgePointer(wt);
+    return p ? { pointer: p, dir: wt } : null;
+  }));
+  let freshest = null;
+  for (const r of results) {
+    if (r && (!freshest || r.pointer.ageMs < freshest.pointer.ageMs)) {
+      freshest = r;
+    }
+  }
+  if (freshest) {
+    logForDebugging(`[bridge:pointer] fanout found pointer in worktree ${freshest.dir} (ageMs=${freshest.pointer.ageMs})`);
+  }
+  return freshest;
+}
+async function clearBridgePointer(dir) {
+  const path = getBridgePointerPath(dir);
+  try {
+    await unlink(path);
+    logForDebugging(`[bridge:pointer] cleared ${path}`);
+  } catch (err) {
+    if (!isENOENT(err)) {
+      logForDebugging(`[bridge:pointer] clear failed: ${err}`, {
+        level: "warn"
+      });
+    }
+  }
+}
+function safeJsonParse(raw) {
+  try {
+    return jsonParse(raw);
+  } catch {
+    return null;
+  }
+}
+export {
+  writeBridgePointer,
+  readBridgePointerAcrossWorktrees,
+  readBridgePointer,
+  getBridgePointerPath,
+  clearBridgePointer,
+  BRIDGE_POINTER_TTL_MS
+};

package/dist/chunk-qhqhf88n.js

@@ -0,0 +1,130 @@
+// @bun
+import {
+  ExitFlow,
+  init_ExitFlow
+} from "./chunk-wsswrgqp.js";
+import {
+  getCurrentWorktreeSession,
+  gracefulShutdown,
+  init_concurrentSessions,
+  init_gracefulShutdown,
+  init_sample,
+  init_worktree,
+  sample_default
+} from "./chunk-730qrdey.js";
+import"./chunk-cfmxfyg6.js";
+import"./chunk-vwtd8nde.js";
+import"./chunk-nsw7n8c5.js";
+import"./chunk-v7n7nnwc.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-tggpkxkz.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-xfxyj6qk.js";
+import"./chunk-n8326eqb.js";
+import"./chunk-vhjx5fag.js";
+import"./chunk-ps540063.js";
+import"./chunk-fz0qs5hv.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-re8evv5h.js";
+import"./chunk-g3jde8ef.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-6p1yy212.js";
+import"./chunk-gv0tqhg0.js";
+import"./chunk-gdr19kp1.js";
+import"./chunk-zp37prdd.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import"./chunk-ya2a18ws.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-14as9yqj.js";
+import"./chunk-7e6ahfxz.js";
+import"./chunk-vn4hnzzj.js";
+import"./chunk-3tqnjgfx.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.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-res15ktd.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/exit/exit.tsx
+function getRandomGoodbyeMessage() {
+  return sample_default(GOODBYE_MESSAGES) ?? "Goodbye!";
+}
+async function call(onDone) {
+  if (false) {}
+  const showWorktree = getCurrentWorktreeSession() !== null;
+  if (showWorktree) {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ExitFlow, {
+      showWorktree,
+      onDone,
+      onCancel: () => onDone()
+    }, undefined, false, undefined, this);
+  }
+  onDone(getRandomGoodbyeMessage());
+  await gracefulShutdown(0, "prompt_input_exit");
+  return null;
+}
+var jsx_dev_runtime, GOODBYE_MESSAGES;
+var init_exit = __esm(() => {
+  init_sample();
+  init_ExitFlow();
+  init_concurrentSessions();
+  init_gracefulShutdown();
+  init_worktree();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  GOODBYE_MESSAGES = ["Goodbye!", "See ya!", "Bye!", "Catch you later!"];
+});
+init_exit();
+
+export {
+  call
+};