@zyycn/claudex 1.0.3-fork.1453470

package/dist/chunk-raqgs410.js

@@ -0,0 +1,116 @@
+// @bun
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm,
+  __export,
+  __toCommonJS
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/protectedNamespace.ts
+var exports_protectedNamespace = {};
+__export(exports_protectedNamespace, {
+  checkProtectedNamespace: () => checkProtectedNamespace
+});
+var checkProtectedNamespace = () => false;
+var init_protectedNamespace = () => {};
+
+// src/utils/envUtils.ts
+import { homedir } from "os";
+import { join } from "path";
+function getLegacyClaudeConfigHomeDir() {
+  return join(homedir(), ".claude").normalize("NFC");
+}
+function getTeamsDir() {
+  return join(getClaudeConfigHomeDir(), "teams");
+}
+function hasNodeOption(flag) {
+  const nodeOptions = process.env.NODE_OPTIONS;
+  if (!nodeOptions) {
+    return false;
+  }
+  return nodeOptions.split(/\s+/).includes(flag);
+}
+function isEnvTruthy(envVar) {
+  if (!envVar)
+    return false;
+  if (typeof envVar === "boolean")
+    return envVar;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["1", "true", "yes", "on"].includes(normalizedValue);
+}
+function isEnvDefinedFalsy(envVar) {
+  if (envVar === undefined)
+    return false;
+  if (typeof envVar === "boolean")
+    return !envVar;
+  if (!envVar)
+    return false;
+  const normalizedValue = envVar.toLowerCase().trim();
+  return ["0", "false", "no", "off"].includes(normalizedValue);
+}
+function isBareMode() {
+  return isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE) || process.argv.includes("--bare");
+}
+function parseEnvVars(rawEnvArgs) {
+  const parsedEnv = {};
+  if (rawEnvArgs) {
+    for (const envStr of rawEnvArgs) {
+      const [key, ...valueParts] = envStr.split("=");
+      if (!key || valueParts.length === 0) {
+        throw new Error(`Invalid environment variable format: ${envStr}, environment variables should be added as: -e KEY1=value1 -e KEY2=value2`);
+      }
+      parsedEnv[key] = valueParts.join("=");
+    }
+  }
+  return parsedEnv;
+}
+function getAWSRegion() {
+  return process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
+}
+function getDefaultVertexRegion() {
+  return process.env.CLOUD_ML_REGION || "us-east5";
+}
+function shouldMaintainProjectWorkingDir() {
+  return isEnvTruthy(process.env.CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR);
+}
+function isRunningOnHomespace() {
+  return process.env.USER_TYPE === "ant" && isEnvTruthy(process.env.COO_RUNNING_ON_HOMESPACE);
+}
+function isInProtectedNamespace() {
+  if (process.env.USER_TYPE === "ant") {
+    return (init_protectedNamespace(), __toCommonJS(exports_protectedNamespace)).checkProtectedNamespace();
+  }
+  return false;
+}
+function getVertexRegionForModel(model) {
+  if (model) {
+    const match = VERTEX_REGION_OVERRIDES.find(([prefix]) => model.startsWith(prefix));
+    if (match) {
+      return process.env[match[1]] || getDefaultVertexRegion();
+    }
+  }
+  return getDefaultVertexRegion();
+}
+var getClaudeConfigHomeDir, VERTEX_REGION_OVERRIDES;
+var init_envUtils = __esm(() => {
+  init_memoize();
+  getClaudeConfigHomeDir = memoize_default(() => {
+    return (process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claudex")).normalize("NFC");
+  }, () => process.env.CLAUDE_CONFIG_DIR);
+  VERTEX_REGION_OVERRIDES = [
+    ["claude-haiku-4-5", "VERTEX_REGION_CLAUDE_HAIKU_4_5"],
+    ["claude-3-5-haiku", "VERTEX_REGION_CLAUDE_3_5_HAIKU"],
+    ["claude-3-5-sonnet", "VERTEX_REGION_CLAUDE_3_5_SONNET"],
+    ["claude-3-7-sonnet", "VERTEX_REGION_CLAUDE_3_7_SONNET"],
+    ["claude-opus-4-1", "VERTEX_REGION_CLAUDE_4_1_OPUS"],
+    ["claude-opus-4", "VERTEX_REGION_CLAUDE_4_0_OPUS"],
+    ["claude-sonnet-4-6", "VERTEX_REGION_CLAUDE_4_6_SONNET"],
+    ["claude-sonnet-4-5", "VERTEX_REGION_CLAUDE_4_5_SONNET"],
+    ["claude-sonnet-4", "VERTEX_REGION_CLAUDE_4_0_SONNET"]
+  ];
+});
+
+export { getClaudeConfigHomeDir, getLegacyClaudeConfigHomeDir, getTeamsDir, hasNodeOption, isEnvTruthy, isEnvDefinedFalsy, isBareMode, parseEnvVars, getAWSRegion, getDefaultVertexRegion, shouldMaintainProjectWorkingDir, isRunningOnHomespace, isInProtectedNamespace, getVertexRegionForModel, init_envUtils };

package/dist/chunk-re8evv5h.js

@@ -0,0 +1,216 @@
+// @bun
+import {
+  getOAuthHeaders,
+  init_api,
+  prepareApiRequest
+} from "./chunk-14as9yqj.js";
+import {
+  getGlobalConfig,
+  getOauthAccountInfo,
+  getSubscriptionType,
+  init_auth,
+  init_config1 as init_config,
+  isClaudeAISubscriber,
+  saveGlobalConfig
+} from "./chunk-3tqnjgfx.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-vqvd3qz0.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/api/referral.ts
+async function fetchReferralEligibility(campaign = "claude_code_guest_pass") {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/referral/eligibility`;
+  const response = await axios_default.get(url, {
+    headers,
+    params: { campaign },
+    timeout: 5000
+  });
+  return response.data;
+}
+async function fetchReferralRedemptions(campaign = "claude_code_guest_pass") {
+  const { accessToken, orgUUID } = await prepareApiRequest();
+  const headers = {
+    ...getOAuthHeaders(accessToken),
+    "x-organization-uuid": orgUUID
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/referral/redemptions`;
+  const response = await axios_default.get(url, {
+    headers,
+    params: { campaign },
+    timeout: 1e4
+  });
+  return response.data;
+}
+function shouldCheckForPasses() {
+  return !!(getOauthAccountInfo()?.organizationUuid && isClaudeAISubscriber() && getSubscriptionType() === "max");
+}
+function checkCachedPassesEligibility() {
+  if (!shouldCheckForPasses()) {
+    return {
+      eligible: false,
+      needsRefresh: false,
+      hasCache: false
+    };
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return {
+      eligible: false,
+      needsRefresh: false,
+      hasCache: false
+    };
+  }
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  if (!cachedEntry) {
+    return {
+      eligible: false,
+      needsRefresh: true,
+      hasCache: false
+    };
+  }
+  const { eligible, timestamp } = cachedEntry;
+  const now = Date.now();
+  const needsRefresh = now - timestamp > CACHE_EXPIRATION_MS;
+  return {
+    eligible,
+    needsRefresh,
+    hasCache: true
+  };
+}
+function formatCreditAmount(reward) {
+  const symbol = CURRENCY_SYMBOLS[reward.currency] ?? `${reward.currency} `;
+  const amount = reward.amount_minor_units / 100;
+  const formatted = amount % 1 === 0 ? amount.toString() : amount.toFixed(2);
+  return `${symbol}${formatted}`;
+}
+function getCachedReferrerReward() {
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return null;
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  return cachedEntry?.referrer_reward ?? null;
+}
+function getCachedRemainingPasses() {
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return null;
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  return cachedEntry?.remaining_passes ?? null;
+}
+async function fetchAndStorePassesEligibility() {
+  if (fetchInProgress) {
+    logForDebugging("Passes: Reusing in-flight eligibility fetch");
+    return fetchInProgress;
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return null;
+  }
+  fetchInProgress = (async () => {
+    try {
+      const response = await fetchReferralEligibility();
+      const cacheEntry = {
+        ...response,
+        timestamp: Date.now()
+      };
+      saveGlobalConfig((current) => ({
+        ...current,
+        passesEligibilityCache: {
+          ...current.passesEligibilityCache,
+          [orgId]: cacheEntry
+        }
+      }));
+      logForDebugging(`Passes eligibility cached for org ${orgId}: ${response.eligible}`);
+      return response;
+    } catch (error) {
+      logForDebugging("Failed to fetch and cache passes eligibility");
+      logError(error);
+      return null;
+    } finally {
+      fetchInProgress = null;
+    }
+  })();
+  return fetchInProgress;
+}
+async function getCachedOrFetchPassesEligibility() {
+  if (!shouldCheckForPasses()) {
+    return null;
+  }
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId) {
+    return null;
+  }
+  const config = getGlobalConfig();
+  const cachedEntry = config.passesEligibilityCache?.[orgId];
+  const now = Date.now();
+  if (!cachedEntry) {
+    logForDebugging("Passes: No cache, fetching eligibility in background (command unavailable this session)");
+    fetchAndStorePassesEligibility();
+    return null;
+  }
+  if (now - cachedEntry.timestamp > CACHE_EXPIRATION_MS) {
+    logForDebugging("Passes: Cache stale, returning cached data and refreshing in background");
+    fetchAndStorePassesEligibility();
+    const { timestamp: timestamp2, ...response2 } = cachedEntry;
+    return response2;
+  }
+  logForDebugging("Passes: Using fresh cached eligibility data");
+  const { timestamp, ...response } = cachedEntry;
+  return response;
+}
+async function prefetchPassesEligibility() {
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  getCachedOrFetchPassesEligibility();
+}
+var CACHE_EXPIRATION_MS, fetchInProgress = null, CURRENCY_SYMBOLS;
+var init_referral = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_auth();
+  init_config();
+  init_debug();
+  init_log();
+  init_privacyLevel();
+  init_api();
+  CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000;
+  CURRENCY_SYMBOLS = {
+    USD: "$",
+    EUR: "\u20AC",
+    GBP: "\xA3",
+    BRL: "R$",
+    CAD: "CA$",
+    AUD: "A$",
+    NZD: "NZ$",
+    SGD: "S$"
+  };
+});
+
+export { fetchReferralRedemptions, checkCachedPassesEligibility, formatCreditAmount, getCachedReferrerReward, getCachedRemainingPasses, getCachedOrFetchPassesEligibility, prefetchPassesEligibility, init_referral };

package/dist/chunk-res15ktd.js

@@ -0,0 +1,18 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/cliBranding.ts
+function getMacroPackageBin() {
+  return typeof MACRO !== "undefined" ? "claudex" : undefined;
+}
+function getCliBin() {
+  return process.env.CLAUDE_CODE_BIN_NAME?.trim() || getMacroPackageBin() || "claude";
+}
+function getCliDisplayName(cliBin = getCliBin()) {
+  return cliBin === "claude" ? "Claude Code" : `${cliBin.charAt(0).toUpperCase()}${cliBin.slice(1)} Code`;
+}
+var init_cliBranding = () => {};
+
+export { getCliBin, getCliDisplayName, init_cliBranding };

package/dist/chunk-rhxgs39k.js

@@ -0,0 +1,208 @@
+// @bun
+import {
+  SETTING_SOURCE_TO_SCOPE,
+  cacheAndRegisterPlugin,
+  getAddDirEnabledPlugins,
+  getInMemoryInstalledPlugins,
+  getPluginById,
+  init_addDirPluginSettings,
+  init_installedPluginsManager,
+  init_marketplaceManager,
+  init_pluginIdentifier,
+  init_pluginInstallationHelpers,
+  migrateFromEnabledPlugins,
+  registerPluginInstallation,
+  scopeToSettingSource
+} from "./chunk-730qrdey.js";
+import {
+  getInitialSettings,
+  getSettingsForSource,
+  init_schemas,
+  init_settings1 as init_settings,
+  isLocalPluginSource,
+  updateSettingsForSource
+} from "./chunk-3tqnjgfx.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-sbbj6ta3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/plugins/pluginStartupCheck.ts
+import { join } from "path";
+async function checkEnabledPlugins() {
+  const settings = getInitialSettings();
+  const enabledPlugins = [];
+  const addDirPlugins = getAddDirEnabledPlugins();
+  for (const [pluginId, value] of Object.entries(addDirPlugins)) {
+    if (pluginId.includes("@") && value) {
+      enabledPlugins.push(pluginId);
+    }
+  }
+  if (settings.enabledPlugins) {
+    for (const [pluginId, value] of Object.entries(settings.enabledPlugins)) {
+      if (!pluginId.includes("@")) {
+        continue;
+      }
+      const idx = enabledPlugins.indexOf(pluginId);
+      if (value) {
+        if (idx === -1) {
+          enabledPlugins.push(pluginId);
+        }
+      } else {
+        if (idx !== -1) {
+          enabledPlugins.splice(idx, 1);
+        }
+      }
+    }
+  }
+  return enabledPlugins;
+}
+function getPluginEditableScopes() {
+  const result = new Map;
+  const addDirPlugins = getAddDirEnabledPlugins();
+  for (const [pluginId, value] of Object.entries(addDirPlugins)) {
+    if (!pluginId.includes("@")) {
+      continue;
+    }
+    if (value === true) {
+      result.set(pluginId, "flag");
+    } else if (value === false) {
+      result.delete(pluginId);
+    }
+  }
+  const scopeSources = [
+    { scope: "managed", source: "policySettings" },
+    { scope: "user", source: "userSettings" },
+    { scope: "project", source: "projectSettings" },
+    { scope: "local", source: "localSettings" },
+    { scope: "flag", source: "flagSettings" }
+  ];
+  for (const { scope, source } of scopeSources) {
+    const settings = getSettingsForSource(source);
+    if (!settings?.enabledPlugins) {
+      continue;
+    }
+    for (const [pluginId, value] of Object.entries(settings.enabledPlugins)) {
+      if (!pluginId.includes("@")) {
+        continue;
+      }
+      if (pluginId in addDirPlugins && addDirPlugins[pluginId] !== value) {
+        logForDebugging(`Plugin ${pluginId} from --add-dir (${addDirPlugins[pluginId]}) overridden by ${source} (${value})`);
+      }
+      if (value === true) {
+        result.set(pluginId, scope);
+      } else if (value === false) {
+        result.delete(pluginId);
+      }
+    }
+  }
+  logForDebugging(`Found ${result.size} enabled plugins with scopes: ${Array.from(result.entries()).map(([id, scope]) => `${id}(${scope})`).join(", ")}`);
+  return result;
+}
+function isPersistableScope(scope) {
+  return scope !== "flag";
+}
+function settingSourceToScope(source) {
+  return SETTING_SOURCE_TO_SCOPE[source];
+}
+async function getInstalledPlugins() {
+  migrateFromEnabledPlugins().catch((error) => {
+    logError(error);
+  });
+  const v2Data = getInMemoryInstalledPlugins();
+  const installed = Object.keys(v2Data.plugins);
+  logForDebugging(`Found ${installed.length} installed plugins`);
+  return installed;
+}
+async function findMissingPlugins(enabledPlugins) {
+  try {
+    const installedPlugins = await getInstalledPlugins();
+    const notInstalled = enabledPlugins.filter((id) => !installedPlugins.includes(id));
+    const lookups = await Promise.all(notInstalled.map(async (pluginId) => {
+      try {
+        const plugin = await getPluginById(pluginId);
+        return { pluginId, found: plugin !== null && plugin !== undefined };
+      } catch (error) {
+        logForDebugging(`Failed to check plugin ${pluginId} in marketplace: ${error}`);
+        return { pluginId, found: false };
+      }
+    }));
+    const missing = lookups.filter(({ found }) => found).map(({ pluginId }) => pluginId);
+    return missing;
+  } catch (error) {
+    logError(error);
+    return [];
+  }
+}
+async function installSelectedPlugins(pluginsToInstall, onProgress, scope = "user") {
+  const projectPath = scope !== "user" ? getCwd() : undefined;
+  const settingSource = scopeToSettingSource(scope);
+  const settings = getSettingsForSource(settingSource);
+  const updatedEnabledPlugins = { ...settings?.enabledPlugins };
+  const installed = [];
+  const failed = [];
+  for (let i = 0;i < pluginsToInstall.length; i++) {
+    const pluginId = pluginsToInstall[i];
+    if (!pluginId)
+      continue;
+    if (onProgress) {
+      onProgress(pluginId, i + 1, pluginsToInstall.length);
+    }
+    try {
+      const pluginInfo = await getPluginById(pluginId);
+      if (!pluginInfo) {
+        failed.push({
+          name: pluginId,
+          error: "Plugin not found in any marketplace"
+        });
+        continue;
+      }
+      const { entry, marketplaceInstallLocation } = pluginInfo;
+      if (!isLocalPluginSource(entry.source)) {
+        await cacheAndRegisterPlugin(pluginId, entry, scope, projectPath);
+      } else {
+        registerPluginInstallation({
+          pluginId,
+          installPath: join(marketplaceInstallLocation, entry.source),
+          version: entry.version
+        }, scope, projectPath);
+      }
+      updatedEnabledPlugins[pluginId] = true;
+      installed.push(pluginId);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      failed.push({ name: pluginId, error: errorMessage });
+      logError(error);
+    }
+  }
+  updateSettingsForSource(settingSource, {
+    ...settings,
+    enabledPlugins: updatedEnabledPlugins
+  });
+  return { installed, failed };
+}
+var init_pluginStartupCheck = __esm(() => {
+  init_cwd();
+  init_debug();
+  init_log();
+  init_settings();
+  init_addDirPluginSettings();
+  init_installedPluginsManager();
+  init_marketplaceManager();
+  init_pluginIdentifier();
+  init_pluginInstallationHelpers();
+  init_schemas();
+});
+
+export { checkEnabledPlugins, getPluginEditableScopes, isPersistableScope, settingSourceToScope, getInstalledPlugins, findMissingPlugins, installSelectedPlugins, init_pluginStartupCheck };

package/dist/chunk-rn0v1hk8.js

@@ -0,0 +1,34 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/slashCommandParsing.ts
+function parseSlashCommand(input) {
+  const trimmedInput = input.trim();
+  if (!trimmedInput.startsWith("/")) {
+    return null;
+  }
+  const withoutSlash = trimmedInput.slice(1);
+  const words = withoutSlash.split(" ");
+  if (!words[0]) {
+    return null;
+  }
+  let commandName = words[0];
+  let isMcp = false;
+  let argsStartIndex = 1;
+  if (words.length > 1 && words[1] === "(MCP)") {
+    commandName = commandName + " (MCP)";
+    isMcp = true;
+    argsStartIndex = 2;
+  }
+  const args = words.slice(argsStartIndex).join(" ");
+  return {
+    commandName,
+    args,
+    isMcp
+  };
+}
+var init_slashCommandParsing = () => {};
+
+export { parseSlashCommand, init_slashCommandParsing };

package/dist/chunk-rtgznsee.js

@@ -0,0 +1,43 @@
+// @bun
+import {
+  require_src as require_src2
+} from "./chunk-6tq2v3rk.js";
+import {
+  require_src as require_src3
+} from "./chunk-00xcm9ma.js";
+import {
+  require_src1 as require_src
+} from "./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-grpc/build/src/OTLPMetricExporter.js
+var require_OTLPMetricExporter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var exporter_metrics_otlp_http_1 = require_src2();
+  var otlp_grpc_exporter_base_1 = require_src3();
+  var otlp_transformer_1 = require_src();
+
+  class OTLPMetricExporter extends exporter_metrics_otlp_http_1.OTLPMetricExporterBase {
+    constructor(config) {
+      super((0, otlp_grpc_exporter_base_1.createOtlpGrpcExportDelegate)((0, otlp_grpc_exporter_base_1.convertLegacyOtlpGrpcOptions)(config ?? {}, "METRICS"), otlp_transformer_1.ProtobufMetricsSerializer, "MetricsExportService", "/opentelemetry.proto.collector.metrics.v1.MetricsService/Export"), config);
+    }
+  }
+  exports.OTLPMetricExporter = OTLPMetricExporter;
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-grpc/build/src/index.js
+var require_src4 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var OTLPMetricExporter_1 = require_OTLPMetricExporter();
+  Object.defineProperty(exports, "OTLPMetricExporter", { enumerable: true, get: function() {
+    return OTLPMetricExporter_1.OTLPMetricExporter;
+  } });
+});
+export default require_src4();