@zyycn/claudex 1.0.3-fork.63859d8

package/dist/chunk-q5981tda.js

@@ -0,0 +1,184 @@
+// @bun
+import {
+  Select,
+  init_CustomSelect
+} from "./chunk-2ssrm349.js";
+import {
+  Dialog,
+  init_Dialog
+} from "./chunk-41x5pfyr.js";
+import {
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-e65m636c.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import {
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-kh4zk8k3.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/ApproveApiKey.tsx
+init_ink();
+init_config();
+init_CustomSelect();
+init_Dialog();
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function ApproveApiKey(t0) {
+  const $ = import_compiler_runtime.c(17);
+  const {
+    customApiKeyTruncated,
+    onDone
+  } = t0;
+  let t1;
+  if ($[0] !== customApiKeyTruncated || $[1] !== onDone) {
+    t1 = function onChange2(value) {
+      bb2:
+        switch (value) {
+          case "yes": {
+            saveGlobalConfig((current_0) => ({
+              ...current_0,
+              customApiKeyResponses: {
+                ...current_0.customApiKeyResponses,
+                approved: [...current_0.customApiKeyResponses?.approved ?? [], customApiKeyTruncated]
+              }
+            }));
+            onDone(true);
+            break bb2;
+          }
+          case "no": {
+            saveGlobalConfig((current) => ({
+              ...current,
+              customApiKeyResponses: {
+                ...current.customApiKeyResponses,
+                rejected: [...current.customApiKeyResponses?.rejected ?? [], customApiKeyTruncated]
+              }
+            }));
+            onDone(false);
+          }
+        }
+    };
+    $[0] = customApiKeyTruncated;
+    $[1] = onDone;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const onChange = t1;
+  let t2;
+  if ($[3] !== onChange) {
+    t2 = () => onChange("no");
+    $[3] = onChange;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      bold: true,
+      children: "ANTHROPIC_API_KEY"
+    }, undefined, false, undefined, this);
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== customApiKeyTruncated) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: [
+        t3,
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          children: [
+            ": sk-ant-...",
+            customApiKeyTruncated
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+    $[6] = customApiKeyTruncated;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  let t5;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: "Do you want to use this API key?"
+    }, undefined, false, undefined, this);
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  let t6;
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = {
+      label: "Yes",
+      value: "yes"
+    };
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  let t7;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = [t6, {
+      label: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: [
+          "No (",
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            bold: true,
+            children: "recommended"
+          }, undefined, false, undefined, this),
+          ")"
+        ]
+      }, undefined, true, undefined, this),
+      value: "no"
+    }];
+    $[10] = t7;
+  } else {
+    t7 = $[10];
+  }
+  let t8;
+  if ($[11] !== onChange) {
+    t8 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+      defaultValue: "no",
+      defaultFocusValue: "no",
+      options: t7,
+      onChange: (value_0) => onChange(value_0),
+      onCancel: () => onChange("no")
+    }, undefined, false, undefined, this);
+    $[11] = onChange;
+    $[12] = t8;
+  } else {
+    t8 = $[12];
+  }
+  let t9;
+  if ($[13] !== t2 || $[14] !== t4 || $[15] !== t8) {
+    t9 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+      title: "Detected a custom API key in your environment",
+      color: "warning",
+      onCancel: t2,
+      children: [
+        t4,
+        t5,
+        t8
+      ]
+    }, undefined, true, undefined, this);
+    $[13] = t2;
+    $[14] = t4;
+    $[15] = t8;
+    $[16] = t9;
+  } else {
+    t9 = $[16];
+  }
+  return t9;
+}
+
+export { ApproveApiKey };

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-qhfhd3vp.js

@@ -0,0 +1,155 @@
+// @bun
+import {
+  init_pluginOperations,
+  updatePluginOp
+} from "./chunk-eegrp4q3.js";
+import {
+  getDeclaredMarketplaces,
+  init_installedPluginsManager,
+  init_marketplaceManager,
+  init_pluginIdentifier,
+  isInstallationRelevantToCurrentProject,
+  loadInstalledPluginsFromDisk,
+  loadKnownMarketplacesConfig,
+  parsePluginIdentifier,
+  refreshMarketplace
+} from "./chunk-2ssrm349.js";
+import {
+  init_config1 as init_config,
+  init_schemas,
+  isMarketplaceAutoUpdate,
+  shouldSkipPluginAutoupdate
+} from "./chunk-kh4zk8k3.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/plugins/pluginAutoupdate.ts
+function onPluginsAutoUpdated(callback) {
+  pluginUpdateCallback = callback;
+  if (pendingNotification !== null && pendingNotification.length > 0) {
+    callback(pendingNotification);
+    pendingNotification = null;
+  }
+  return () => {
+    pluginUpdateCallback = null;
+  };
+}
+async function getAutoUpdateEnabledMarketplaces() {
+  const config = await loadKnownMarketplacesConfig();
+  const declared = getDeclaredMarketplaces();
+  const enabled = new Set;
+  for (const [name, entry] of Object.entries(config)) {
+    const declaredAutoUpdate = declared[name]?.autoUpdate;
+    const autoUpdate = declaredAutoUpdate !== undefined ? declaredAutoUpdate : isMarketplaceAutoUpdate(name, entry);
+    if (autoUpdate) {
+      enabled.add(name.toLowerCase());
+    }
+  }
+  return enabled;
+}
+async function updatePlugin(pluginId, installations) {
+  let wasUpdated = false;
+  for (const { scope } of installations) {
+    try {
+      const result = await updatePluginOp(pluginId, scope);
+      if (result.success && !result.alreadyUpToDate) {
+        wasUpdated = true;
+        logForDebugging(`Plugin autoupdate: updated ${pluginId} from ${result.oldVersion} to ${result.newVersion}`);
+      } else if (!result.alreadyUpToDate) {
+        logForDebugging(`Plugin autoupdate: failed to update ${pluginId}: ${result.message}`, { level: "warn" });
+      }
+    } catch (error) {
+      logForDebugging(`Plugin autoupdate: error updating ${pluginId}: ${errorMessage(error)}`, { level: "warn" });
+    }
+  }
+  return wasUpdated ? pluginId : null;
+}
+async function updatePluginsForMarketplaces(marketplaceNames) {
+  const installedPlugins = loadInstalledPluginsFromDisk();
+  const pluginIds = Object.keys(installedPlugins.plugins);
+  if (pluginIds.length === 0) {
+    return [];
+  }
+  const results = await Promise.allSettled(pluginIds.map(async (pluginId) => {
+    const { marketplace } = parsePluginIdentifier(pluginId);
+    if (!marketplace || !marketplaceNames.has(marketplace.toLowerCase())) {
+      return null;
+    }
+    const allInstallations = installedPlugins.plugins[pluginId];
+    if (!allInstallations || allInstallations.length === 0) {
+      return null;
+    }
+    const relevantInstallations = allInstallations.filter(isInstallationRelevantToCurrentProject);
+    if (relevantInstallations.length === 0) {
+      return null;
+    }
+    return updatePlugin(pluginId, relevantInstallations);
+  }));
+  return results.filter((r) => r.status === "fulfilled" && r.value !== null).map((r) => r.value);
+}
+async function updatePlugins(autoUpdateEnabledMarketplaces) {
+  return updatePluginsForMarketplaces(autoUpdateEnabledMarketplaces);
+}
+function autoUpdateMarketplacesAndPluginsInBackground() {
+  (async () => {
+    if (shouldSkipPluginAutoupdate()) {
+      logForDebugging("Plugin autoupdate: skipped (auto-updater disabled)");
+      return;
+    }
+    try {
+      const autoUpdateEnabledMarketplaces = await getAutoUpdateEnabledMarketplaces();
+      if (autoUpdateEnabledMarketplaces.size === 0) {
+        return;
+      }
+      const refreshResults = await Promise.allSettled(Array.from(autoUpdateEnabledMarketplaces).map(async (name) => {
+        try {
+          await refreshMarketplace(name, undefined, {
+            disableCredentialHelper: true
+          });
+        } catch (error) {
+          logForDebugging(`Plugin autoupdate: failed to refresh marketplace ${name}: ${errorMessage(error)}`, { level: "warn" });
+        }
+      }));
+      const failures = refreshResults.filter((r) => r.status === "rejected");
+      if (failures.length > 0) {
+        logForDebugging(`Plugin autoupdate: ${failures.length} marketplace refresh(es) failed`, { level: "warn" });
+      }
+      logForDebugging("Plugin autoupdate: checking installed plugins");
+      const updatedPlugins = await updatePlugins(autoUpdateEnabledMarketplaces);
+      if (updatedPlugins.length > 0) {
+        if (pluginUpdateCallback) {
+          pluginUpdateCallback(updatedPlugins);
+        } else {
+          pendingNotification = updatedPlugins;
+        }
+      }
+    } catch (error) {
+      logError(error);
+    }
+  })();
+}
+var pluginUpdateCallback = null, pendingNotification = null;
+var init_pluginAutoupdate = __esm(() => {
+  init_pluginOperations();
+  init_config();
+  init_debug();
+  init_errors();
+  init_log();
+  init_installedPluginsManager();
+  init_marketplaceManager();
+  init_pluginIdentifier();
+  init_schemas();
+});
+
+export { onPluginsAutoUpdated, updatePluginsForMarketplaces, autoUpdateMarketplacesAndPluginsInBackground, init_pluginAutoupdate };

package/dist/chunk-qm3nkwce.js

@@ -0,0 +1,71 @@
+// @bun
+import {
+  Login,
+  init_login
+} from "./chunk-fx9bv58w.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import {
+  init_browser,
+  openBrowser
+} from "./chunk-7e6ahfxz.js";
+import {
+  getClaudeAIOAuthTokens,
+  getOauthProfileFromOauthToken,
+  init_auth,
+  init_getOauthProfile,
+  isClaudeAISubscriber
+} from "./chunk-kh4zk8k3.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/upgrade/upgrade.tsx
+async function call(onDone, context) {
+  try {
+    if (isClaudeAISubscriber()) {
+      const tokens = getClaudeAIOAuthTokens();
+      let isMax20x = false;
+      if (tokens?.subscriptionType && tokens?.rateLimitTier) {
+        isMax20x = tokens.subscriptionType === "max" && tokens.rateLimitTier === "default_claude_max_20x";
+      } else if (tokens?.accessToken) {
+        const profile = await getOauthProfileFromOauthToken(tokens.accessToken);
+        isMax20x = profile?.organization?.organization_type === "claude_max" && profile?.organization?.rate_limit_tier === "default_claude_max_20x";
+      }
+      if (isMax20x) {
+        setTimeout(onDone, 0, "You are already on the highest Max subscription plan. For additional usage, run /login to switch to an API usage-billed account.");
+        return null;
+      }
+    }
+    const url = "https://claude.ai/upgrade/max";
+    await openBrowser(url);
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Login, {
+      startingMessage: "Starting new login following /upgrade. Exit with Ctrl-C to use existing account.",
+      onDone: (success) => {
+        context.onChangeAPIKey();
+        onDone(success ? "Login successful" : "Login interrupted");
+      }
+    }, undefined, false, undefined, this);
+  } catch (error) {
+    logError(error);
+    setTimeout(onDone, 0, "Failed to open browser. Please visit https://claude.ai/upgrade/max to upgrade.");
+  }
+  return null;
+}
+var jsx_dev_runtime;
+var init_upgrade = __esm(() => {
+  init_getOauthProfile();
+  init_auth();
+  init_browser();
+  init_log();
+  init_login();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { call, init_upgrade };