@zyycn/claudex 1.0.3-fork.2a74621

package/dist/chunk-kq0n3myz.js

@@ -0,0 +1,71 @@
+// @bun
+import {
+  Login,
+  init_login
+} from "./chunk-8k0y8sk2.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-3zzszjst.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 };

package/dist/chunk-kwekc97v.js

@@ -0,0 +1,18 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/rewind/rewind.ts
+async function call(_args, context) {
+  if (context.openMessageSelector) {
+    context.openMessageSelector();
+  }
+  return { type: "skip" };
+}
+var init_rewind = () => {};
+init_rewind();
+
+export {
+  call
+};

package/dist/chunk-m44gmqd1.js

@@ -0,0 +1,258 @@
+// @bun
+import {
+  init_setup,
+  isChromeExtensionInstalled
+} from "./chunk-e8d2zjs1.js";
+import"./chunk-gyj242zr.js";
+import {
+  Dialog,
+  init_Dialog
+} from "./chunk-gz457zg6.js";
+import"./chunk-j5hc27hv.js";
+import"./chunk-ph936yc1.js";
+import"./chunk-z7ns4g0p.js";
+import {
+  Link,
+  Newline,
+  ThemedBox_default,
+  ThemedText,
+  init_ink,
+  require_compiler_runtime,
+  use_input_default
+} from "./chunk-adg4351g.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-3zzszjst.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-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.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 {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/ClaudeInChromeOnboarding.tsx
+init_analytics();
+init_ink();
+init_setup();
+init_config();
+init_Dialog();
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+var import_react = __toESM(require_react(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+var CHROME_EXTENSION_URL = "https://claude.ai/chrome";
+var CHROME_PERMISSIONS_URL = "https://clau.de/chrome/permissions";
+function ClaudeInChromeOnboarding(t0) {
+  const $ = import_compiler_runtime.c(20);
+  const {
+    onDone
+  } = t0;
+  const [isExtensionInstalled, setIsExtensionInstalled] = import_react.default.useState(false);
+  let t1;
+  let t2;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => {
+      logEvent("tengu_claude_in_chrome_onboarding_shown", {});
+      isChromeExtensionInstalled().then(setIsExtensionInstalled);
+      saveGlobalConfig(_temp);
+    };
+    t2 = [];
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t1 = $[0];
+    t2 = $[1];
+  }
+  import_react.default.useEffect(t1, t2);
+  let t3;
+  if ($[2] !== onDone) {
+    t3 = (_input, key) => {
+      if (key.return) {
+        onDone();
+      }
+    };
+    $[2] = onDone;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  use_input_default(t3);
+  let t4;
+  if ($[4] !== isExtensionInstalled) {
+    t4 = !isExtensionInstalled && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Newline, {}, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Newline, {}, undefined, false, undefined, this),
+        "Requires the Chrome extension. Get started at",
+        " ",
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Link, {
+          url: CHROME_EXTENSION_URL
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+    $[4] = isExtensionInstalled;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  let t5;
+  if ($[6] !== t4) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: [
+        "Claude in Chrome works with the Chrome extension to let you control your browser directly from Claude Code. You can navigate websites, fill forms, capture screenshots, record GIFs, and debug with console logs and network requests.",
+        t4
+      ]
+    }, undefined, true, undefined, this);
+    $[6] = t4;
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  let t6;
+  if ($[8] !== isExtensionInstalled) {
+    t6 = isExtensionInstalled && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
+      children: [
+        " ",
+        "(",
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Link, {
+          url: CHROME_PERMISSIONS_URL
+        }, undefined, false, undefined, this),
+        ")"
+      ]
+    }, undefined, true, undefined, this);
+    $[8] = isExtensionInstalled;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  let t7;
+  if ($[10] !== t6) {
+    t7 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: [
+        "Site-level permissions are inherited from the Chrome extension. Manage permissions in the Chrome extension settings to control which sites Claude can browse, click, and type on",
+        t6,
+        "."
+      ]
+    }, undefined, true, undefined, this);
+    $[10] = t6;
+    $[11] = t7;
+  } else {
+    t7 = $[11];
+  }
+  let t8;
+  if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      bold: true,
+      color: "chromeYellow",
+      children: "/chrome"
+    }, undefined, false, undefined, this);
+    $[12] = t8;
+  } else {
+    t8 = $[12];
+  }
+  let t9;
+  if ($[13] === Symbol.for("react.memo_cache_sentinel")) {
+    t9 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: [
+        "For more info, use",
+        " ",
+        t8,
+        " ",
+        "or visit ",
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Link, {
+          url: "https://code.claude.com/docs/en/chrome"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+    $[13] = t9;
+  } else {
+    t9 = $[13];
+  }
+  let t10;
+  if ($[14] !== t5 || $[15] !== t7) {
+    t10 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        t5,
+        t7,
+        t9
+      ]
+    }, undefined, true, undefined, this);
+    $[14] = t5;
+    $[15] = t7;
+    $[16] = t10;
+  } else {
+    t10 = $[16];
+  }
+  let t11;
+  if ($[17] !== onDone || $[18] !== t10) {
+    t11 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+      title: "Claude in Chrome (Beta)",
+      onCancel: onDone,
+      color: "chromeYellow",
+      children: t10
+    }, undefined, false, undefined, this);
+    $[17] = onDone;
+    $[18] = t10;
+    $[19] = t11;
+  } else {
+    t11 = $[19];
+  }
+  return t11;
+}
+function _temp(current) {
+  return {
+    ...current,
+    hasCompletedClaudeInChromeOnboarding: true
+  };
+}
+export {
+  ClaudeInChromeOnboarding
+};

package/dist/chunk-m4kphr9e.js

@@ -0,0 +1,71 @@
+// @bun
+import {
+  _baseEach_default,
+  init__baseEach
+} from "./chunk-1m68rrvt.js";
+import {
+  _baseIteratee_default,
+  init__baseIteratee,
+  init_isArray,
+  isArray_default
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/_arrayAggregator.js
+function arrayAggregator(array, setter, iteratee, accumulator) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    var value = array[index];
+    setter(accumulator, value, iteratee(value), array);
+  }
+  return accumulator;
+}
+var _arrayAggregator_default;
+var init__arrayAggregator = __esm(() => {
+  _arrayAggregator_default = arrayAggregator;
+});
+
+// node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/_baseAggregator.js
+function baseAggregator(collection, setter, iteratee, accumulator) {
+  _baseEach_default(collection, function(value, key, collection2) {
+    setter(accumulator, value, iteratee(value), collection2);
+  });
+  return accumulator;
+}
+var _baseAggregator_default;
+var init__baseAggregator = __esm(() => {
+  init__baseEach();
+  _baseAggregator_default = baseAggregator;
+});
+
+// node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/_createAggregator.js
+function createAggregator(setter, initializer) {
+  return function(collection, iteratee) {
+    var func = isArray_default(collection) ? _arrayAggregator_default : _baseAggregator_default, accumulator = initializer ? initializer() : {};
+    return func(collection, setter, _baseIteratee_default(iteratee, 2), accumulator);
+  };
+}
+var _createAggregator_default;
+var init__createAggregator = __esm(() => {
+  init__arrayAggregator();
+  init__baseAggregator();
+  init__baseIteratee();
+  init_isArray();
+  _createAggregator_default = createAggregator;
+});
+
+// node_modules/.bun/lodash-es@4.17.23/node_modules/lodash-es/partition.js
+var partition, partition_default;
+var init_partition = __esm(() => {
+  init__createAggregator();
+  partition = _createAggregator_default(function(result, value, key) {
+    result[key ? 0 : 1].push(value);
+  }, function() {
+    return [[], []];
+  });
+  partition_default = partition;
+});
+
+export { partition_default, init_partition };

package/dist/chunk-mbrkqdrq.js

@@ -0,0 +1,155 @@
+// @bun
+import {
+  init_pluginOperations,
+  updatePluginOp
+} from "./chunk-2sndq2nq.js";
+import {
+  getDeclaredMarketplaces,
+  init_installedPluginsManager,
+  init_marketplaceManager,
+  init_pluginIdentifier,
+  isInstallationRelevantToCurrentProject,
+  loadInstalledPluginsFromDisk,
+  loadKnownMarketplacesConfig,
+  parsePluginIdentifier,
+  refreshMarketplace
+} from "./chunk-1m68rrvt.js";
+import {
+  init_config1 as init_config,
+  init_schemas,
+  isMarketplaceAutoUpdate,
+  shouldSkipPluginAutoupdate
+} from "./chunk-3zzszjst.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 };