@robinmordasiewicz/f5xc-xcsh 2.0.41-2601192054 → 2.0.41-2601192346

package/dist/index.js

@@ -41229,8 +41229,8 @@ var init_logo_renderer = __esm({
 
 // src/branding/index.ts
 function getVersion() {
-  if ("v2.0.41-2601192054") {
-    return "v2.0.41-2601192054";
+  if ("v2.0.41-2601192346") {
+    return "v2.0.41-2601192346";
   }
   if (process.env.XCSH_VERSION) {
     return process.env.XCSH_VERSION;
@@ -152862,12 +152862,21 @@ var init_ai_services = __esm({
 });
 
 // src/domains/subscription/client.ts
+var client_exports = {};
+__export(client_exports, {
+  SubscriptionClient: () => SubscriptionClient,
+  getSubscriptionClient: () => getSubscriptionClient,
+  resetSubscriptionClient: () => resetSubscriptionClient
+});
 function getSubscriptionClient(apiClient) {
   if (!cachedClient2) {
     cachedClient2 = new SubscriptionClient(apiClient);
   }
   return cachedClient2;
 }
+function resetSubscriptionClient() {
+  cachedClient2 = null;
+}
 var SubscriptionClient, cachedClient2;
 var init_client3 = __esm({
   "src/domains/subscription/client.ts"() {
@@ -163290,6 +163299,294 @@ var init_creation_flags = __esm({
   }
 });
 
+// src/quota/cache.ts
+function getQuotaCache() {
+  if (!globalCache) {
+    globalCache = new QuotaCache();
+  }
+  return globalCache;
+}
+function resetQuotaCache() {
+  if (globalCache) {
+    globalCache.invalidate();
+  }
+  globalCache = null;
+}
+var CACHE_TTL_MS, QuotaCache, globalCache;
+var init_cache2 = __esm({
+  "src/quota/cache.ts"() {
+    "use strict";
+    CACHE_TTL_MS = 6e4;
+    QuotaCache = class {
+      cache = /* @__PURE__ */ new Map();
+      /**
+       * Get quota usage, using cache if available and fresh
+       *
+       * @param client - Subscription client for API calls
+       * @param namespace - Namespace to get quota for
+       * @returns Array of quota usage items
+       */
+      async getQuotaUsage(client, namespace) {
+        const cacheKey = this.getCacheKey(namespace);
+        const cached = this.cache.get(cacheKey);
+        if (cached && !this.isExpired(cached.fetchedAt)) {
+          return cached.usage;
+        }
+        const response = await client.getQuotaUsage(namespace);
+        const usage = [];
+        if (response.quota_usage) {
+          for (const [name, item] of Object.entries(response.quota_usage)) {
+            const current = item.usage?.current ?? 0;
+            const limit = item.limit?.maximum ?? 0;
+            const percentage = limit > 0 ? Math.round(current / limit * 100) : 0;
+            usage.push({
+              name,
+              display_name: item.display_name || name,
+              current,
+              limit,
+              percentage
+            });
+          }
+        }
+        this.cache.set(cacheKey, {
+          usage,
+          fetchedAt: Date.now(),
+          namespace
+        });
+        return usage;
+      }
+      /**
+       * Find quota usage for a specific quota name
+       *
+       * @param client - Subscription client for API calls
+       * @param namespace - Namespace to get quota for
+       * @param quotaName - API quota name to find
+       * @returns Quota usage item or undefined if not found
+       */
+      async findQuotaUsage(client, namespace, quotaName) {
+        const usage = await this.getQuotaUsage(client, namespace);
+        return usage.find((q) => q.name === quotaName);
+      }
+      /**
+       * Invalidate cache for a namespace or all namespaces
+       *
+       * @param namespace - Optional namespace to invalidate; if omitted, clears all
+       */
+      invalidate(namespace) {
+        if (namespace) {
+          this.cache.delete(this.getCacheKey(namespace));
+        } else {
+          this.cache.clear();
+        }
+      }
+      /**
+       * Generate cache key for a namespace
+       */
+      getCacheKey(namespace) {
+        return `quota:${namespace}`;
+      }
+      /**
+       * Check if cached data is expired
+       */
+      isExpired(fetchedAt) {
+        return Date.now() - fetchedAt > CACHE_TTL_MS;
+      }
+    };
+    globalCache = null;
+  }
+});
+
+// src/quota/mapping.ts
+var mapping_exports = {};
+__export(mapping_exports, {
+  getAllQuotaMappings: () => getAllQuotaMappings,
+  getQuotaMapping: () => getQuotaMapping,
+  getQuotaMappingByName: () => getQuotaMappingByName,
+  hasQuotaMapping: () => hasQuotaMapping
+});
+function getQuotaMapping(resourceType) {
+  return MAPPING_BY_RESOURCE_TYPE.get(resourceType);
+}
+function getQuotaMappingByName(quotaName) {
+  return MAPPING_BY_QUOTA_NAME.get(quotaName);
+}
+function getAllQuotaMappings() {
+  return QUOTA_MAPPINGS;
+}
+function hasQuotaMapping(resourceType) {
+  return MAPPING_BY_RESOURCE_TYPE.has(resourceType);
+}
+var QUOTA_MAPPINGS, MAPPING_BY_RESOURCE_TYPE, MAPPING_BY_QUOTA_NAME;
+var init_mapping = __esm({
+  "src/quota/mapping.ts"() {
+    "use strict";
+    QUOTA_MAPPINGS = [
+      // Load Balancing
+      // API returns: "HTTP Load Balancer", "TCP Load Balancer"
+      {
+        resourceType: "http_loadbalancer",
+        quotaName: "HTTP Load Balancer",
+        displayName: "HTTP Load Balancers"
+      },
+      {
+        resourceType: "tcp_loadbalancer",
+        quotaName: "TCP Load Balancer",
+        displayName: "TCP Load Balancers"
+      },
+      // Origin & Health
+      // API returns: "origin_pool" (snake_case), "Healthcheck" (title case)
+      {
+        resourceType: "origin_pool",
+        quotaName: "origin_pool",
+        displayName: "Origin Pools"
+      },
+      {
+        resourceType: "healthcheck",
+        quotaName: "Healthcheck",
+        displayName: "Health Checks"
+      },
+      // Sites
+      // API returns: "AWS VPC Site", "Azure VNET Site", "GCP VPC Site"
+      {
+        resourceType: "aws_vpc_site",
+        quotaName: "AWS VPC Site",
+        displayName: "AWS VPC Sites"
+      },
+      {
+        resourceType: "azure_vnet_site",
+        quotaName: "Azure VNET Site",
+        displayName: "Azure VNET Sites"
+      },
+      {
+        resourceType: "gcp_vpc_site",
+        quotaName: "GCP VPC Site",
+        displayName: "GCP VPC Sites"
+      },
+      // Networking
+      // API returns: "Virtual Network", "Network Connector"
+      {
+        resourceType: "virtual_network",
+        quotaName: "Virtual Network",
+        displayName: "Virtual Networks"
+      },
+      {
+        resourceType: "network_connector",
+        quotaName: "Network Connector",
+        displayName: "Network Connectors"
+      },
+      // Security
+      // API returns: "Application Firewall", "Service Policy", "Rate Limiter"
+      {
+        resourceType: "app_firewall",
+        quotaName: "Application Firewall",
+        displayName: "Application Firewalls"
+      },
+      {
+        resourceType: "service_policy",
+        quotaName: "Service Policy",
+        displayName: "Service Policies"
+      },
+      {
+        resourceType: "rate_limiter",
+        quotaName: "Rate Limiter",
+        displayName: "Rate Limiters"
+      },
+      // DNS
+      // API returns: "DNS Zone", "DNS Domain"
+      {
+        resourceType: "dns_zone",
+        quotaName: "DNS Zone",
+        displayName: "DNS Zones"
+      },
+      {
+        resourceType: "dns_domain",
+        quotaName: "DNS Domain",
+        displayName: "DNS Domains"
+      },
+      // API Security
+      // API returns: "API Definition"
+      {
+        resourceType: "api_definition",
+        quotaName: "API Definition",
+        displayName: "API Definitions"
+      },
+      // Namespaces
+      // API returns: "Namespace"
+      {
+        resourceType: "namespace",
+        quotaName: "Namespace",
+        displayName: "Namespaces"
+      }
+    ];
+    MAPPING_BY_RESOURCE_TYPE = new Map(
+      QUOTA_MAPPINGS.map((m) => [m.resourceType, m])
+    );
+    MAPPING_BY_QUOTA_NAME = new Map(
+      QUOTA_MAPPINGS.map((m) => [m.quotaName, m])
+    );
+  }
+});
+
+// src/repl/completion/quota-helper.ts
+var quota_helper_exports = {};
+__export(quota_helper_exports, {
+  getQuotaForResourceType: () => getQuotaForResourceType,
+  getQuotasForResourceTypes: () => getQuotasForResourceTypes
+});
+async function getQuotaForResourceType(apiClient, namespace, resourceType) {
+  const mapping = getQuotaMapping(resourceType);
+  if (!mapping) {
+    return null;
+  }
+  try {
+    const subscriptionClient = new SubscriptionClient(apiClient);
+    const cache3 = getQuotaCache();
+    const usage = await cache3.findQuotaUsage(
+      subscriptionClient,
+      namespace,
+      mapping.quotaName
+    );
+    if (!usage || usage.limit <= 0) {
+      return null;
+    }
+    const percentage = Math.round(usage.current / usage.limit * 100);
+    const level = percentage >= 100 ? "error" : percentage >= 90 ? "warning" : "none";
+    return {
+      current: usage.current,
+      limit: usage.limit,
+      percentage,
+      level,
+      display: `${usage.current}/${usage.limit}`
+    };
+  } catch {
+    return null;
+  }
+}
+async function getQuotasForResourceTypes(apiClient, namespace, resourceTypes) {
+  const results = /* @__PURE__ */ new Map();
+  await Promise.all(
+    resourceTypes.map(async (rt) => {
+      const info = await getQuotaForResourceType(
+        apiClient,
+        namespace,
+        rt
+      );
+      if (info) {
+        results.set(rt, info);
+      }
+    })
+  );
+  return results;
+}
+var init_quota_helper = __esm({
+  "src/repl/completion/quota-helper.ts"() {
+    "use strict";
+    init_cache2();
+    init_mapping();
+    init_client3();
+  }
+});
+
 // src/repl/completion/completer.ts
 function isResourceCompletionAppropriate(resource) {
   if (resource.isPrimary) {
@@ -163554,8 +163851,10 @@ var init_completer = __esm({
             }
             return suggestions2;
           }
-          const resourceTypes = this.getResourceTypeSuggestions(
-            resourceCtx.domain
+          const resourceTypes = await this.getResourceTypeSuggestionsWithQuota(
+            resourceCtx.domain,
+            this.session?.getNamespace() ?? null,
+            this.session?.getAPIClient() ?? null
           );
           if (resourceTypes.length > 0) {
             let suggestions2 = resourceTypes;
@@ -163624,6 +163923,50 @@ var init_completer = __esm({
         }
         return suggestions;
       }
+      /**
+       * Get suggestions with metadata (including resource quota info)
+       * Use this when you need quota info for the status line
+       */
+      async completeWithMeta(text) {
+        const trimmed = text.trimStart();
+        const parsed = parseInput(trimmed);
+        const resourceCtx = this.parseResourceContext(parsed);
+        const suggestions = await this.complete(text);
+        let resourceQuotaInfo;
+        if (resourceCtx.resourceType && resourceCtx.action && CREATION_ACTIONS.has(resourceCtx.action) && hasCreationFlags(resourceCtx.resourceType) && this.session) {
+          try {
+            const { getQuotaForResourceType: getQuotaForResourceType2 } = await Promise.resolve().then(() => (init_quota_helper(), quota_helper_exports));
+            const { getQuotaMapping: getQuotaMapping2 } = await Promise.resolve().then(() => (init_mapping(), mapping_exports));
+            const namespace = this.session.getNamespace();
+            const client = this.session.getAPIClient();
+            const mapping = getQuotaMapping2(resourceCtx.resourceType);
+            if (namespace && client && mapping) {
+              const quotaInfo = await getQuotaForResourceType2(
+                client,
+                namespace,
+                resourceCtx.resourceType
+              );
+              if (quotaInfo) {
+                resourceQuotaInfo = {
+                  resourceType: resourceCtx.resourceType,
+                  displayName: mapping.displayName,
+                  current: quotaInfo.current,
+                  limit: quotaInfo.limit,
+                  level: quotaInfo.level
+                };
+              }
+            }
+          } catch {
+          }
+        }
+        const result = {
+          suggestions
+        };
+        if (resourceQuotaInfo) {
+          result.resourceQuotaInfo = resourceQuotaInfo;
+        }
+        return result;
+      }
       /**
        * Get completions for custom domain commands
        * Uses unified completion registry for structure navigation,
@@ -163929,6 +164272,47 @@ var init_completer = __esm({
           };
         });
       }
+      /**
+       * Get resource type suggestions with quota information
+       *
+       * Enhanced version of getResourceTypeSuggestions that includes quota usage
+       * data for resources that have quota mappings. Quota info is displayed
+       * right-justified with color coding:
+       * - White: Normal usage (< 90%)
+       * - Yellow: Warning (90-99%)
+       * - Red: At quota limit (100%)
+       *
+       * @param domain - The domain to get resource types for
+       * @param namespace - The namespace to get quota for
+       * @param client - The API client for quota lookups
+       * @returns Promise of completion suggestions with quota info
+       */
+      async getResourceTypeSuggestionsWithQuota(domain, namespace, client) {
+        const baseSuggestions = this.getResourceTypeSuggestions(domain);
+        if (!client || !namespace) {
+          return baseSuggestions;
+        }
+        try {
+          const { getQuotasForResourceTypes: getQuotasForResourceTypes2 } = await Promise.resolve().then(() => (init_quota_helper(), quota_helper_exports));
+          const resourceTypes = baseSuggestions.map((s) => s.text);
+          const quotas = await getQuotasForResourceTypes2(
+            client,
+            namespace,
+            resourceTypes
+          );
+          return baseSuggestions.map((suggestion) => {
+            const quota = quotas.get(suggestion.text);
+            if (!quota) return suggestion;
+            return {
+              ...suggestion,
+              quotaLevel: quota.level,
+              quotaInfo: quota.display
+            };
+          });
+        } catch {
+          return baseSuggestions;
+        }
+      }
       /**
        * Get resource name suggestions from live API
        * Fetches actual resource names for a given resource type
@@ -165202,6 +165586,131 @@ var init_verb_handler = __esm({
   }
 });
 
+// src/quota/pre-check.ts
+async function checkQuotaBeforeCreate(client, options) {
+  const { resourceType, namespace, force = false } = options;
+  const mapping = getQuotaMapping(resourceType);
+  if (!mapping) {
+    return { proceed: true, level: "none" };
+  }
+  try {
+    const cache3 = getQuotaCache();
+    const quotaUsage = await cache3.findQuotaUsage(
+      client,
+      namespace,
+      mapping.quotaName
+    );
+    if (!quotaUsage) {
+      return { proceed: true, level: "none" };
+    }
+    const percentage = quotaUsage.percentage ?? (quotaUsage.limit > 0 ? Math.round(quotaUsage.current / quotaUsage.limit * 100) : 0);
+    const quotaInfo = {
+      name: quotaUsage.name,
+      displayName: mapping.displayName,
+      current: quotaUsage.current,
+      limit: quotaUsage.limit,
+      percentage
+    };
+    if (percentage >= ERROR_THRESHOLD) {
+      return {
+        proceed: force,
+        level: "error",
+        message: force ? `Quota limit reached for ${mapping.displayName}, proceeding due to --force` : `Quota limit reached for ${mapping.displayName}`,
+        quota: quotaInfo
+      };
+    }
+    if (percentage >= WARNING_THRESHOLD) {
+      return {
+        proceed: true,
+        level: "warning",
+        message: `Approaching quota limit for ${mapping.displayName}`,
+        quota: quotaInfo
+      };
+    }
+    return { proceed: true, level: "none" };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      proceed: true,
+      level: "none",
+      message: `Could not check quota: ${message}`
+    };
+  }
+}
+function formatQuotaWarning(result) {
+  if (result.level === "none" || !result.quota) {
+    return [];
+  }
+  const { quota, level } = result;
+  const lines = [];
+  const icon = level === "error" ? "\u274C" : "\u26A0\uFE0F";
+  const title = level === "error" ? "Quota Exceeded" : "Quota Warning";
+  lines.push(`${icon}  ${title}: ${quota.displayName}`);
+  lines.push(
+    `    Usage: ${quota.current}/${quota.limit} (${quota.percentage}%)`
+  );
+  const barWidth = 20;
+  const filledWidth = Math.round(quota.percentage / 100 * barWidth);
+  const emptyWidth = barWidth - filledWidth;
+  const filledChar = "\u2588";
+  const emptyChar = "\u2591";
+  const progressBar2 = filledChar.repeat(filledWidth) + emptyChar.repeat(emptyWidth);
+  lines.push(`    ${progressBar2}`);
+  lines.push("");
+  if (level === "error") {
+    lines.push("    Cannot create - quota limit reached.");
+    lines.push(
+      "    Use --force to attempt anyway, or delete existing resources."
+    );
+  } else {
+    lines.push(
+      "    Creating this resource will approach your quota limit."
+    );
+  }
+  return lines;
+}
+function formatQuotaStatusLine(result) {
+  if (result.level === "none" || !result.quota) {
+    return "";
+  }
+  const { quota, level } = result;
+  const icon = level === "error" ? "\u274C" : "\u26A0\uFE0F";
+  return `${icon} ${quota.displayName}: ${quota.current}/${quota.limit} (${quota.percentage}%)`;
+}
+var WARNING_THRESHOLD, ERROR_THRESHOLD;
+var init_pre_check = __esm({
+  "src/quota/pre-check.ts"() {
+    "use strict";
+    init_mapping();
+    init_cache2();
+    WARNING_THRESHOLD = 90;
+    ERROR_THRESHOLD = 100;
+  }
+});
+
+// src/quota/index.ts
+var quota_exports = {};
+__export(quota_exports, {
+  QuotaCache: () => QuotaCache,
+  checkQuotaBeforeCreate: () => checkQuotaBeforeCreate,
+  formatQuotaStatusLine: () => formatQuotaStatusLine,
+  formatQuotaWarning: () => formatQuotaWarning,
+  getAllQuotaMappings: () => getAllQuotaMappings,
+  getQuotaCache: () => getQuotaCache,
+  getQuotaMapping: () => getQuotaMapping,
+  getQuotaMappingByName: () => getQuotaMappingByName,
+  hasQuotaMapping: () => hasQuotaMapping,
+  resetQuotaCache: () => resetQuotaCache
+});
+var init_quota = __esm({
+  "src/quota/index.ts"() {
+    "use strict";
+    init_pre_check();
+    init_mapping();
+    init_cache2();
+  }
+});
+
 // src/profiling/profiler.ts
 var DEFAULT_THRESHOLDS = {
   slowPhaseMs: 100,
@@ -173273,6 +173782,16 @@ function getCategoryColor(category) {
       return "#ffffff";
   }
 }
+function getQuotaColor(quotaLevel) {
+  if (quotaLevel === "error") return "#CA260A";
+  if (quotaLevel === "warning") return "#ffc107";
+  return null;
+}
+function getQuotaIndicator(quotaLevel) {
+  if (quotaLevel === "error") return " \u274C";
+  if (quotaLevel === "warning") return " \u26A0\uFE0F";
+  return "";
+}
 function SuggestionItem({
   suggestion,
   isSelected,
@@ -173280,20 +173799,45 @@ function SuggestionItem({
   isContextOnly
 }) {
   const categoryColor = getCategoryColor(suggestion.category);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Box_default, { children: [
-    isContextOnly ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { children: "   " }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: isSelected ? "#CA260A" : "#333333", children: isSelected ? "\u25B6 " : "   " }),
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: categoryColor, bold: isSelected, inverse: isSelected, children: suggestion.label.padEnd(maxLabelWidth) }),
-    suggestion.description && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+  const quotaColor = getQuotaColor(suggestion.quotaLevel);
+  const quotaIndicator = getQuotaIndicator(suggestion.quotaLevel);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Box_default, { justifyContent: "space-between", width: "100%", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Box_default, { children: [
+      isContextOnly ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { children: "   " }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: isSelected ? "#CA260A" : "#333333", children: isSelected ? "\u25B6 " : "   " }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+        Text,
+        {
+          color: categoryColor,
+          bold: isSelected,
+          inverse: isSelected,
+          children: suggestion.label.padEnd(maxLabelWidth)
+        }
+      ),
+      suggestion.description && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+        Text,
+        {
+          color: suggestion.isPrimary ? "#ffffff" : "#666666",
+          bold: suggestion.isPrimary || false,
+          children: [
+            " - ",
+            suggestion.description
+          ]
+        }
+      )
+    ] }),
+    suggestion.quotaInfo && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Box_default, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
       Text,
       {
-        color: suggestion.isPrimary ? "#ffffff" : "#666666",
-        bold: suggestion.isPrimary || false,
+        color: quotaColor ?? "#666666",
+        bold: suggestion.quotaLevel === "error",
         children: [
-          " - ",
-          suggestion.description
+          "(",
+          suggestion.quotaInfo,
+          quotaIndicator,
+          ")"
         ]
       }
-    )
+    ) })
   ] });
 }
 function Suggestions({
@@ -173303,7 +173847,8 @@ function Suggestions({
   onNavigate,
   onCancel,
   maxVisible = 20,
-  isActive = true
+  isActive = true,
+  resourceQuotaInfo
 }) {
   const isContextOnlyMode = suggestions.every(
     (s) => s.category === "context"
@@ -173387,7 +173932,25 @@ function Suggestions({
           totalCount - startIndex - maxVisible,
           " more below)"
         ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Box_default, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: "#666666", dimColor: true, children: isContextOnlyMode ? "\u2191\u2193: scroll | Esc: close" : "Tab/\u2192: select | Enter: execute | \u2191\u2193: navigate | Esc: cancel" }) })
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Box_default, { marginTop: 1, justifyContent: "space-between", width: "100%", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Text, { color: "#666666", dimColor: true, children: isContextOnlyMode ? "\u2191\u2193: scroll | Esc: close" : "Tab/\u2192: select | Enter: execute | \u2191\u2193: navigate | Esc: cancel" }),
+          resourceQuotaInfo && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+            Text,
+            {
+              color: getQuotaColor(resourceQuotaInfo.level) ?? "#666666",
+              bold: resourceQuotaInfo.level === "error",
+              children: [
+                resourceQuotaInfo.displayName,
+                ":",
+                " ",
+                resourceQuotaInfo.current,
+                "/",
+                resourceQuotaInfo.limit,
+                getQuotaIndicator(resourceQuotaInfo.level)
+              ]
+            }
+          )
+        ] })
       ]
     }
   );
@@ -174183,6 +174746,7 @@ function useCompletion(options) {
   const [suggestions, setSuggestions] = (0, import_react32.useState)([]);
   const [selectedIndex, setSelectedIndex] = (0, import_react32.useState)(0);
   const [isShowing, setIsShowing] = (0, import_react32.useState)(false);
+  const [resourceQuotaInfo, setResourceQuotaInfo] = (0, import_react32.useState)(null);
   (0, import_react32.useEffect)(() => {
     if (session) {
       completer.setSession(session);
@@ -174192,10 +174756,13 @@ function useCompletion(options) {
     setIsShowing(false);
     setSuggestions([]);
     setSelectedIndex(0);
+    setResourceQuotaInfo(null);
   }, []);
   const triggerCompletion = (0, import_react32.useCallback)(
     async (input) => {
-      const newSuggestions = await completer.complete(input);
+      const result = await completer.completeWithMeta(input);
+      const newSuggestions = result.suggestions;
+      setResourceQuotaInfo(result.resourceQuotaInfo ?? null);
       if (newSuggestions.length === 1) {
         const singleSuggestion = newSuggestions[0];
         if (singleSuggestion?.category === "context") {
@@ -174221,7 +174788,9 @@ function useCompletion(options) {
   const filterSuggestions = (0, import_react32.useCallback)(
     async (input) => {
       if (!isShowing) return;
-      const newSuggestions = await completer.complete(input);
+      const result = await completer.completeWithMeta(input);
+      const newSuggestions = result.suggestions;
+      setResourceQuotaInfo(result.resourceQuotaInfo ?? null);
       if (newSuggestions.length === 0) {
         hide();
       } else {
@@ -174256,6 +174825,7 @@ function useCompletion(options) {
     suggestions,
     selectedIndex,
     isShowing,
+    resourceQuotaInfo,
     triggerCompletion,
     navigateUp,
     navigateDown,
@@ -177078,6 +177648,35 @@ async function executeAPICommand(session, ctx, cmd) {
             contextChanged: false
           };
         }
+        if (action === "create" && effectiveResourceType) {
+          const { SubscriptionClient: SubscriptionClient2 } = await Promise.resolve().then(() => (init_client3(), client_exports));
+          const { checkQuotaBeforeCreate: checkQuotaBeforeCreate2, formatQuotaWarning: formatQuotaWarning2 } = await Promise.resolve().then(() => (init_quota(), quota_exports));
+          const subscriptionClient = new SubscriptionClient2(client);
+          const forceFlag = args.some(
+            (a) => a === "--force" || a === "-f"
+          );
+          const quotaResult = await checkQuotaBeforeCreate2(
+            subscriptionClient,
+            {
+              resourceType: effectiveResourceType,
+              namespace: effectiveNamespace,
+              force: forceFlag
+            }
+          );
+          if (quotaResult.level !== "none") {
+            const quotaWarningLines = formatQuotaWarning2(quotaResult);
+            if (!quotaResult.proceed) {
+              return {
+                output: quotaWarningLines,
+                shouldExit: false,
+                shouldClear: false,
+                contextChanged: false,
+                error: "Quota exceeded"
+              };
+            }
+            warningOutput.push(...quotaWarningLines, "");
+          }
+        }
         if (action === "create") {
           const response = await client.post(apiPath, requestBody);
           result = response.data ?? {
@@ -177429,13 +178028,25 @@ function isValidDomain2(word) {
   return false;
 }
 function toUISuggestions(suggestions) {
-  return suggestions.map((s) => ({
-    label: s.text,
-    value: s.text,
-    description: s.description,
-    category: s.category ?? "builtin"
-    // Provide default to avoid undefined
-  }));
+  return suggestions.map((s) => {
+    const suggestion = {
+      label: s.text,
+      value: s.text,
+      description: s.description,
+      category: s.category ?? "builtin"
+      // Provide default to avoid undefined
+    };
+    if (s.isPrimary !== void 0) {
+      suggestion.isPrimary = s.isPrimary;
+    }
+    if (s.quotaLevel !== void 0) {
+      suggestion.quotaLevel = s.quotaLevel;
+    }
+    if (s.quotaInfo !== void 0) {
+      suggestion.quotaInfo = s.quotaInfo;
+    }
+    return suggestion;
+  });
 }
 function App2({ initialSession } = {}) {
   const { exit } = use_app_default();
@@ -177910,7 +178521,10 @@ function App2({ initialSession } = {}) {
           onNavigate: handleSuggestionNavigate,
           onCancel: completion.hide,
           maxVisible: 20,
-          isActive: false
+          isActive: false,
+          ...completion.resourceQuotaInfo ? {
+            resourceQuotaInfo: completion.resourceQuotaInfo
+          } : {}
         }
       ) : /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
         StatusBar,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robinmordasiewicz/f5xc-xcsh",
-  "version": "2.0.41-2601192054",
+  "version": "2.0.41-2601192346",
   "description": "F5 Distributed Cloud Shell - Interactive CLI for F5 XC",
   "type": "module",
   "bin": {