@robinmordasiewicz/f5xc-xcsh 2.0.27-2601161624 → 2.0.27-2601161808

package/dist/index.js

@@ -2022,14 +2022,14 @@ var require_react_development = __commonJS({
               var thenableResult = result;
               var wasAwaited = false;
               var thenable = {
-                then: function(resolve2, reject) {
+                then: function(resolve3, reject) {
                   wasAwaited = true;
                   thenableResult.then(function(returnValue2) {
                     popActScope(prevActScopeDepth);
                     if (actScopeDepth === 0) {
-                      recursivelyFlushAsyncActWork(returnValue2, resolve2, reject);
+                      recursivelyFlushAsyncActWork(returnValue2, resolve3, reject);
                     } else {
-                      resolve2(returnValue2);
+                      resolve3(returnValue2);
                     }
                   }, function(error2) {
                     popActScope(prevActScopeDepth);
@@ -2059,20 +2059,20 @@ var require_react_development = __commonJS({
                   ReactCurrentActQueue.current = null;
                 }
                 var _thenable = {
-                  then: function(resolve2, reject) {
+                  then: function(resolve3, reject) {
                     if (ReactCurrentActQueue.current === null) {
                       ReactCurrentActQueue.current = [];
-                      recursivelyFlushAsyncActWork(returnValue, resolve2, reject);
+                      recursivelyFlushAsyncActWork(returnValue, resolve3, reject);
                     } else {
-                      resolve2(returnValue);
+                      resolve3(returnValue);
                     }
                   }
                 };
                 return _thenable;
               } else {
                 var _thenable2 = {
-                  then: function(resolve2, reject) {
-                    resolve2(returnValue);
+                  then: function(resolve3, reject) {
+                    resolve3(returnValue);
                   }
                 };
                 return _thenable2;
@@ -2088,7 +2088,7 @@ var require_react_development = __commonJS({
             actScopeDepth = prevActScopeDepth;
           }
         }
-        function recursivelyFlushAsyncActWork(returnValue, resolve2, reject) {
+        function recursivelyFlushAsyncActWork(returnValue, resolve3, reject) {
           {
             var queue = ReactCurrentActQueue.current;
             if (queue !== null) {
@@ -2097,16 +2097,16 @@ var require_react_development = __commonJS({
                 enqueueTask(function() {
                   if (queue.length === 0) {
                     ReactCurrentActQueue.current = null;
-                    resolve2(returnValue);
+                    resolve3(returnValue);
                   } else {
-                    recursivelyFlushAsyncActWork(returnValue, resolve2, reject);
+                    recursivelyFlushAsyncActWork(returnValue, resolve3, reject);
                   }
                 });
               } catch (error2) {
                 reject(error2);
               }
             } else {
-              resolve2(returnValue);
+              resolve3(returnValue);
             }
           }
         }
@@ -28134,7 +28134,7 @@ var require_command = __commonJS({
     var EventEmitter3 = __require("events").EventEmitter;
     var childProcess = __require("child_process");
     var path = __require("path");
-    var fs4 = __require("fs");
+    var fs5 = __require("fs");
     var process13 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -29067,10 +29067,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path.resolve(baseDir, baseName);
-          if (fs4.existsSync(localBin)) return localBin;
+          if (fs5.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs4.existsSync(`${localBin}${ext}`)
+            (ext) => fs5.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -29082,7 +29082,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs4.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -41228,8 +41228,8 @@ var init_logo_renderer = __esm({
 
 // src/branding/index.ts
 function getVersion() {
-  if ("v2.0.27-2601161624") {
-    return "v2.0.27-2601161624";
+  if ("v2.0.27-2601161808") {
+    return "v2.0.27-2601161808";
   }
   if (process.env.XCSH_VERSION) {
     return process.env.XCSH_VERSION;
@@ -48151,14 +48151,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs4 = this.flowScalar(this.type);
+              const fs5 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs4, sep: [] });
+                map.items.push({ start, key: fs5, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs4);
+                this.stack.push(fs5);
               } else {
-                Object.assign(it, { key: fs4, sep: [] });
+                Object.assign(it, { key: fs5, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -48286,13 +48286,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs4 = this.flowScalar(this.type);
+              const fs5 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs4, sep: [] });
+                fc.items.push({ start: [], key: fs5, sep: [] });
               else if (it.sep)
-                this.stack.push(fs4);
+                this.stack.push(fs5);
               else
-                Object.assign(it, { key: fs4, sep: [] });
+                Object.assign(it, { key: fs5, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -77889,17 +77889,47 @@ var init_flag_aliases = __esm({
   "src/repl/completion/flag-aliases.ts"() {
     "use strict";
     FLAG_ALIAS_GROUPS = [
+      // Common flags
       ["--namespace", "-ns"],
       ["--output", "-o"],
       ["--name", "-n"],
       ["--file", "-f"],
       ["--url", "-u"],
-      ["--token", "-t"],
       ["--limit"],
       ["--label"],
       ["--show-labels"],
       ["--force"],
-      ["--cascade"]
+      ["--cascade"],
+      // Creation flags for healthcheck
+      ["--type", "-t"],
+      ["--interval"],
+      ["--timeout"],
+      ["--healthy-threshold"],
+      ["--unhealthy-threshold"],
+      ["--path"],
+      ["--expected-status"],
+      ["--host-header"],
+      ["--use-origin-server-name"],
+      ["--use-http2"],
+      // Creation flags for origin_pool
+      ["--port"],
+      ["--automatic-port"],
+      ["--lb-port"],
+      ["--public-ip"],
+      ["--public-name"],
+      ["--private-ip"],
+      ["--private-name"],
+      ["--k8s-service"],
+      ["--consul-service"],
+      ["--custom-endpoint"],
+      ["--vn-private-ip"],
+      ["--vn-private-name"],
+      ["--cbip-service"],
+      ["--algorithm"],
+      ["--health-check"],
+      ["--no-tls"],
+      ["--use-tls"],
+      ["--site"]
     ];
     FLAG_ALIAS_LOOKUP = buildFlagAliasLookup();
   }
@@ -77933,6 +77963,21 @@ function filterUsedFlagsFromStrings(flags, args) {
   const usedFlags = extractUsedFlags(args);
   return flags.filter((flag) => !usedFlags.has(flag));
 }
+function countFlagUsage(args) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const arg of args) {
+    let flagPart = arg;
+    if (arg.includes("=")) {
+      flagPart = arg.split("=")[0] ?? arg;
+    }
+    if (!flagPart.startsWith("-")) {
+      continue;
+    }
+    const current = counts.get(flagPart) || 0;
+    counts.set(flagPart, current + 1);
+  }
+  return counts;
+}
 var init_flag_utils = __esm({
   "src/repl/completion/flag-utils.ts"() {
     "use strict";
@@ -84659,6 +84704,275 @@ var init_resource_fetcher = __esm({
   }
 });
 
+// src/repl/completion/creation-flags.ts
+function getCreationFlags(resourceType) {
+  return CREATION_FLAGS_REGISTRY.get(resourceType) ?? [];
+}
+function hasCreationFlags(resourceType) {
+  return CREATION_FLAGS_REGISTRY.has(resourceType);
+}
+var HEALTHCHECK_CREATION_FLAGS, ORIGIN_POOL_CREATION_FLAGS, CREATION_FLAGS_REGISTRY;
+var init_creation_flags = __esm({
+  "src/repl/completion/creation-flags.ts"() {
+    "use strict";
+    HEALTHCHECK_CREATION_FLAGS = [
+      // Required flags
+      {
+        name: "--name",
+        shortName: "-n",
+        description: "Resource name",
+        required: true,
+        hasValue: true,
+        valueType: "string"
+      },
+      {
+        name: "--type",
+        shortName: "-t",
+        description: "Health check type",
+        required: true,
+        hasValue: true,
+        valueType: "enum",
+        enumValues: ["http", "tcp", "dns", "udp-icmp"]
+      },
+      {
+        name: "--interval",
+        description: "Interval between checks (1-600 sec)",
+        required: true,
+        hasValue: true,
+        valueType: "integer"
+      },
+      {
+        name: "--timeout",
+        description: "Timeout for each check (1-600 sec)",
+        required: true,
+        hasValue: true,
+        valueType: "integer"
+      },
+      {
+        name: "--healthy-threshold",
+        description: "Successes before healthy (1-16)",
+        required: true,
+        hasValue: true,
+        valueType: "integer"
+      },
+      {
+        name: "--unhealthy-threshold",
+        description: "Failures before unhealthy (1-16)",
+        required: true,
+        hasValue: true,
+        valueType: "integer"
+      },
+      // HTTP-specific (conditionally required when type=http)
+      {
+        name: "--path",
+        description: "HTTP path to check",
+        required: false,
+        hasValue: true,
+        valueType: "string"
+      },
+      {
+        name: "--expected-status",
+        description: "Expected HTTP status codes",
+        required: false,
+        hasValue: true,
+        valueType: "string"
+      },
+      {
+        name: "--host-header",
+        description: "Host header value",
+        required: false,
+        hasValue: true,
+        valueType: "string"
+      },
+      {
+        name: "--use-origin-server-name",
+        description: "Use origin server hostname",
+        required: false,
+        hasValue: false
+      },
+      {
+        name: "--use-http2",
+        description: "Use HTTP/2",
+        required: false,
+        hasValue: false
+      }
+    ];
+    ORIGIN_POOL_CREATION_FLAGS = [
+      // Required - Name
+      {
+        name: "--name",
+        shortName: "-n",
+        description: "Origin pool name",
+        required: true,
+        hasValue: true,
+        valueType: "string"
+      },
+      // Port configuration (mutually exclusive group)
+      {
+        name: "--port",
+        description: "Backend port (1-65535)",
+        required: false,
+        hasValue: true,
+        valueType: "integer"
+      },
+      {
+        name: "--automatic-port",
+        description: "Use automatic port selection",
+        required: false,
+        hasValue: false
+      },
+      {
+        name: "--lb-port",
+        description: "Use load balancer port",
+        required: false,
+        hasValue: false
+      },
+      // Origin Server Types (ALL 10 - REPEATABLE)
+      {
+        name: "--public-ip",
+        description: "Public IP origin server (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--public-name",
+        description: "Public DNS name origin (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--private-ip",
+        description: "Private IP origin (site required) (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--private-name",
+        description: "Private DNS name origin (site required) (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--k8s-service",
+        description: "Kubernetes service origin (format: namespace/service) (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--consul-service",
+        description: "Consul service origin (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--custom-endpoint",
+        description: "Custom endpoint object reference (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--vn-private-ip",
+        description: "Virtual network private IP (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--vn-private-name",
+        description: "Virtual network private DNS name (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      {
+        name: "--cbip-service",
+        description: "Cloud-based IP service (repeatable)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 32
+      },
+      // Load Balancing Algorithm
+      {
+        name: "--algorithm",
+        description: "Load balancing algorithm",
+        required: false,
+        hasValue: true,
+        valueType: "enum",
+        enumValues: [
+          "ROUND_ROBIN",
+          "LEAST_ACTIVE",
+          "RANDOM",
+          "SOURCE_IP_STICKINESS",
+          "COOKIE_STICKINESS",
+          "RING_HASH"
+        ]
+      },
+      // Health Checks (repeatable, max 4)
+      {
+        name: "--health-check",
+        description: "Health check reference (repeatable, max 4)",
+        required: false,
+        hasValue: true,
+        valueType: "string",
+        isRepeatable: true,
+        maxOccurrences: 4
+      },
+      // TLS Configuration
+      {
+        name: "--no-tls",
+        description: "Disable TLS for origin connections",
+        required: false,
+        hasValue: false
+      },
+      {
+        name: "--use-tls",
+        description: "Enable TLS for origin connections",
+        required: false,
+        hasValue: false
+      },
+      // Site reference (for private origins)
+      {
+        name: "--site",
+        description: "Site reference for private origins",
+        required: false,
+        hasValue: true,
+        valueType: "string"
+      }
+    ];
+    CREATION_FLAGS_REGISTRY = /* @__PURE__ */ new Map([
+      ["healthcheck", HEALTHCHECK_CREATION_FLAGS],
+      ["origin_pool", ORIGIN_POOL_CREATION_FLAGS]
+    ]);
+  }
+});
+
 // src/repl/completion/completer.ts
 function isResourceCompletionAppropriate(resource) {
   if (resource.isPrimary) {
@@ -84731,7 +85045,32 @@ function parseInput(text) {
     "--file",
     "-f",
     "--limit",
-    "--label"
+    "--label",
+    // Creation flags for healthcheck
+    "--type",
+    "-t",
+    "--interval",
+    "--timeout",
+    "--healthy-threshold",
+    "--unhealthy-threshold",
+    "--path",
+    "--expected-status",
+    "--host-header",
+    // Creation flags for origin_pool
+    "--port",
+    "--public-ip",
+    "--public-name",
+    "--private-ip",
+    "--private-name",
+    "--k8s-service",
+    "--consul-service",
+    "--custom-endpoint",
+    "--vn-private-ip",
+    "--vn-private-name",
+    "--cbip-service",
+    "--algorithm",
+    "--health-check",
+    "--site"
   ];
   if (args.length >= 1 && !currentWord.startsWith("-")) {
     const flagIndex = endsWithSpace ? args.length - 1 : args.length - 2;
@@ -84760,7 +85099,7 @@ function parseInput(text) {
     currentFlag
   };
 }
-var RESOURCE_ACTIONS, GENERIC_RESOURCE_DESCRIPTIONS, EXCLUDED_RESOURCE_CATEGORIES, Completer;
+var RESOURCE_ACTIONS, CREATION_ACTIONS, GENERIC_RESOURCE_DESCRIPTIONS, EXCLUDED_RESOURCE_CATEGORIES, Completer;
 var init_completer = __esm({
   "src/repl/completion/completer.ts"() {
     "use strict";
@@ -84773,6 +85112,7 @@ var init_completer = __esm({
     init_resource_fetcher();
     init_settings();
     init_flag_utils();
+    init_creation_flags();
     RESOURCE_ACTIONS = /* @__PURE__ */ new Set([
       "list",
       "get",
@@ -84785,6 +85125,7 @@ var init_completer = __esm({
       "add-labels",
       "remove-labels"
     ]);
+    CREATION_ACTIONS = /* @__PURE__ */ new Set(["create", "apply"]);
     GENERIC_RESOURCE_DESCRIPTIONS = /* @__PURE__ */ new Set([
       "Resource retrieval operation",
       "Resource creation operation",
@@ -84857,6 +85198,12 @@ var init_completer = __esm({
           );
         }
         if (resourceCtx.resourceType) {
+          if (resourceCtx.action && CREATION_ACTIONS.has(resourceCtx.action) && hasCreationFlags(resourceCtx.resourceType)) {
+            return this.getCreationFlagSuggestions(
+              resourceCtx.resourceType,
+              parsed.args
+            );
+          }
           const resourceNames = await this.getResourceNameSuggestions(
             resourceCtx.resourceType,
             resourceCtx.resourceNamePartial
@@ -85418,6 +85765,60 @@ var init_completer = __esm({
         }
         return actionFlags;
       }
+      /**
+       * Get creation flag suggestions for a resource type
+       * Shows flags needed to create a new resource (--name, --type, etc.)
+       * instead of existing resource names
+       *
+       * Handles repeatable flags (e.g., --public-ip can be specified multiple times)
+       * by checking maxOccurrences instead of simply filtering out used flags.
+       *
+       * @param resourceType - The resource type being created
+       * @param args - Current command arguments to filter out used flags
+       * @returns Array of flag suggestions for resource creation
+       */
+      getCreationFlagSuggestions(resourceType, args) {
+        const creationFlags = getCreationFlags(resourceType);
+        const usedFlags = extractUsedFlags(args);
+        const flagUsageCounts = countFlagUsage(args);
+        const suggestions = [];
+        if (!usedFlags.has("--file") && !usedFlags.has("-f")) {
+          suggestions.push({
+            text: "--file",
+            description: "Configuration file (YAML/JSON)",
+            category: "flag"
+          });
+        }
+        for (const flag of creationFlags) {
+          if (flag.isRepeatable) {
+            const count = flagUsageCounts.get(flag.name) || 0;
+            const max = flag.maxOccurrences || Infinity;
+            if (count >= max) continue;
+            const marker = " (repeatable)";
+            suggestions.push({
+              text: flag.name,
+              description: flag.description + marker,
+              category: "flag"
+            });
+          } else {
+            if (usedFlags.has(flag.name)) continue;
+            if (flag.shortName && usedFlags.has(flag.shortName)) continue;
+            const marker = flag.required ? " (required)" : "";
+            suggestions.push({
+              text: flag.name,
+              description: flag.description + marker,
+              category: "flag"
+            });
+          }
+        }
+        const commonFlags = this.getCommonFlagSuggestions();
+        for (const flag of commonFlags) {
+          if (!usedFlags.has(flag.text)) {
+            suggestions.push(flag);
+          }
+        }
+        return suggestions;
+      }
       /**
        * Get flag completions filtered by prefix
        * @param prefix - The prefix to filter by
@@ -85522,6 +85923,159 @@ var init_completer = __esm({
                 category: "value"
               }
             ].filter((s) => s.text.startsWith(valuePartial));
+          // Creation flag value completions for healthcheck
+          case "--type":
+          case "-t":
+            return [
+              {
+                text: "http",
+                description: "HTTP health check",
+                category: "value"
+              },
+              {
+                text: "tcp",
+                description: "TCP health check",
+                category: "value"
+              },
+              {
+                text: "dns",
+                description: "DNS health check",
+                category: "value"
+              },
+              {
+                text: "udp-icmp",
+                description: "UDP ICMP health check",
+                category: "value"
+              }
+            ].filter((s) => s.text.startsWith(lowerPartial));
+          case "--interval":
+          case "--timeout":
+            return [
+              {
+                text: "5",
+                description: "5 seconds",
+                category: "value"
+              },
+              {
+                text: "10",
+                description: "10 seconds",
+                category: "value"
+              },
+              {
+                text: "30",
+                description: "30 seconds",
+                category: "value"
+              },
+              {
+                text: "60",
+                description: "1 minute",
+                category: "value"
+              }
+            ].filter((s) => s.text.startsWith(valuePartial));
+          case "--healthy-threshold":
+          case "--unhealthy-threshold":
+            return [
+              {
+                text: "2",
+                description: "2 checks",
+                category: "value"
+              },
+              {
+                text: "3",
+                description: "3 checks",
+                category: "value"
+              },
+              {
+                text: "5",
+                description: "5 checks",
+                category: "value"
+              }
+            ].filter((s) => s.text.startsWith(valuePartial));
+          case "--path":
+            return [
+              {
+                text: "/health",
+                description: "Common health endpoint",
+                category: "value"
+              },
+              {
+                text: "/healthz",
+                description: "Kubernetes-style",
+                category: "value"
+              },
+              {
+                text: "/ready",
+                description: "Readiness endpoint",
+                category: "value"
+              },
+              {
+                text: "/",
+                description: "Root path",
+                category: "value"
+              }
+            ].filter((s) => s.text.toLowerCase().startsWith(lowerPartial));
+          // Origin pool flag value completions
+          case "--algorithm":
+            return [
+              {
+                text: "ROUND_ROBIN",
+                description: "Round robin distribution",
+                category: "value"
+              },
+              {
+                text: "LEAST_ACTIVE",
+                description: "Least active connections",
+                category: "value"
+              },
+              {
+                text: "RANDOM",
+                description: "Random selection",
+                category: "value"
+              },
+              {
+                text: "SOURCE_IP_STICKINESS",
+                description: "Sticky by source IP",
+                category: "value"
+              },
+              {
+                text: "COOKIE_STICKINESS",
+                description: "Sticky by cookie",
+                category: "value"
+              },
+              {
+                text: "RING_HASH",
+                description: "Consistent ring hash",
+                category: "value"
+              }
+            ].filter((s) => s.text.toLowerCase().startsWith(lowerPartial));
+          case "--port":
+            return [
+              {
+                text: "80",
+                description: "HTTP port",
+                category: "value"
+              },
+              {
+                text: "443",
+                description: "HTTPS port",
+                category: "value"
+              },
+              {
+                text: "8080",
+                description: "Alt HTTP port",
+                category: "value"
+              },
+              {
+                text: "8443",
+                description: "Alt HTTPS port",
+                category: "value"
+              }
+            ].filter((s) => s.text.startsWith(valuePartial));
+          case "--health-check":
+            return this.getResourceNameSuggestions(
+              "healthcheck",
+              valuePartial
+            );
           default:
             return [];
         }
@@ -91714,8 +92268,8 @@ var Ink = class {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve2, reject) => {
-      this.resolveExitPromise = resolve2;
+    this.exitPromise ||= new Promise((resolve3, reject) => {
+      this.resolveExitPromise = resolve3;
       this.rejectExitPromise = reject;
     });
     return this.exitPromise;
@@ -92477,7 +93031,7 @@ function calculateBackoffDelay(attempt, config) {
   return cappedDelay;
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 var APIClient = class {
   serverUrl;
@@ -95377,9 +95931,9 @@ async function detectWithAllDomainScan(resourceName, namespace, client) {
 }
 async function detectDependencies(resourceType, resourceName, namespace, client) {
   const startTime = Date.now();
-  const timeoutPromise = new Promise((resolve2) => {
+  const timeoutPromise = new Promise((resolve3) => {
     setTimeout(() => {
-      resolve2({
+      resolve3({
         found: false,
         references: [],
         searchedDomains: [],
@@ -95531,6 +96085,540 @@ function hasUnsubstitutedParams(path) {
   return /\{[^}]+\}/.test(path);
 }
 
+// src/repl/executor.ts
+var import_yaml4 = __toESM(require_dist(), 1);
+import { promises as fs4 } from "fs";
+import { resolve } from "path";
+
+// src/repl/creation/flag-parser.ts
+init_creation_flags();
+function hasCreationFlagsInArgs(args, resourceType) {
+  const flagDefs = getCreationFlags(resourceType);
+  if (flagDefs.length === 0) return false;
+  const flagNames = /* @__PURE__ */ new Set();
+  for (const def of flagDefs) {
+    flagNames.add(def.name);
+    if (def.shortName) {
+      flagNames.add(def.shortName);
+    }
+  }
+  for (const arg of args) {
+    if (!arg) continue;
+    const flagPart = arg.includes("=") ? arg.split("=")[0] ?? arg : arg;
+    if (flagNames.has(flagPart)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasFileFlag(args) {
+  return args.some((arg) => arg === "--file" || arg.startsWith("--file="));
+}
+function getFilePath(args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    if (arg === "--file" && i + 1 < args.length) {
+      const nextArg = args[i + 1];
+      return nextArg ?? null;
+    }
+    if (arg.startsWith("--file=")) {
+      return arg.substring("--file=".length);
+    }
+  }
+  return null;
+}
+function parseCreationFlags(args, resourceType) {
+  const flagDefs = getCreationFlags(resourceType);
+  const result = {
+    values: /* @__PURE__ */ new Map(),
+    errors: [],
+    hasFlags: false
+  };
+  if (flagDefs.length === 0) {
+    result.errors.push(
+      `No creation flags defined for resource type: ${resourceType}`
+    );
+    return result;
+  }
+  const flagByName = /* @__PURE__ */ new Map();
+  const flagByShortName = /* @__PURE__ */ new Map();
+  for (const def of flagDefs) {
+    flagByName.set(def.name, def);
+    if (def.shortName) {
+      flagByShortName.set(def.shortName, def);
+    }
+  }
+  const usageCounts = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (!arg || !arg.startsWith("-")) {
+      i++;
+      continue;
+    }
+    let flagName;
+    let inlineValue;
+    if (arg.includes("=")) {
+      const eqIndex = arg.indexOf("=");
+      flagName = arg.substring(0, eqIndex);
+      inlineValue = arg.substring(eqIndex + 1);
+    } else {
+      flagName = arg;
+    }
+    if (flagName === "--file") {
+      i += inlineValue !== void 0 ? 1 : 2;
+      continue;
+    }
+    if (flagName === "--namespace" || flagName === "-ns") {
+      i += inlineValue !== void 0 ? 1 : 2;
+      continue;
+    }
+    const def = flagByName.get(flagName) ?? flagByShortName.get(flagName);
+    if (!def) {
+      i++;
+      continue;
+    }
+    result.hasFlags = true;
+    const currentCount = usageCounts.get(def.name) ?? 0;
+    usageCounts.set(def.name, currentCount + 1);
+    if (def.isRepeatable && def.maxOccurrences) {
+      if (currentCount + 1 > def.maxOccurrences) {
+        result.errors.push(
+          `Flag ${def.name} can only be used ${def.maxOccurrences} times`
+        );
+        i++;
+        continue;
+      }
+    } else if (!def.isRepeatable && currentCount > 0) {
+      result.errors.push(
+        `Flag ${def.name} cannot be specified multiple times`
+      );
+      i++;
+      continue;
+    }
+    if (!def.hasValue) {
+      result.values.set(def.name, "true");
+      i++;
+      continue;
+    }
+    let value;
+    if (inlineValue !== void 0) {
+      value = inlineValue;
+      i++;
+    } else {
+      const nextArg = args[i + 1];
+      if (nextArg && !nextArg.startsWith("-")) {
+        value = nextArg;
+        i += 2;
+      } else {
+        result.errors.push(`Flag ${def.name} requires a value`);
+        i++;
+        continue;
+      }
+    }
+    if (def.valueType === "enum" && def.enumValues) {
+      if (!def.enumValues.includes(value)) {
+        result.errors.push(
+          `Invalid value '${value}' for ${def.name}. Allowed: ${def.enumValues.join(", ")}`
+        );
+        continue;
+      }
+    }
+    if (def.valueType === "integer") {
+      const num = parseInt(value, 10);
+      if (isNaN(num)) {
+        result.errors.push(
+          `Invalid integer value '${value}' for ${def.name}`
+        );
+        continue;
+      }
+    }
+    if (def.isRepeatable) {
+      const existing = result.values.get(def.name);
+      if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        result.values.set(def.name, [value]);
+      }
+    } else {
+      result.values.set(def.name, value);
+    }
+  }
+  for (const def of flagDefs) {
+    if (def.required && !result.values.has(def.name)) {
+      if (result.hasFlags) {
+        result.errors.push(`Required flag ${def.name} is missing`);
+      }
+    }
+  }
+  return result;
+}
+function getFlagValue(parsed, flagName) {
+  const value = parsed.values.get(flagName);
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+function getFlagValues(parsed, flagName) {
+  const value = parsed.values.get(flagName);
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value !== void 0) {
+    return [value];
+  }
+  return [];
+}
+function getFlagIntValue(parsed, flagName) {
+  const value = getFlagValue(parsed, flagName);
+  if (value !== void 0) {
+    const num = parseInt(value, 10);
+    return isNaN(num) ? void 0 : num;
+  }
+  return void 0;
+}
+function isFlagSet(parsed, flagName) {
+  return parsed.values.has(flagName);
+}
+
+// src/repl/creation/builders/healthcheck-builder.ts
+function buildHealthcheckRequest(flags, namespace) {
+  const name = getFlagValue(flags, "--name");
+  const type = getFlagValue(flags, "--type");
+  const interval = getFlagIntValue(flags, "--interval");
+  const timeout = getFlagIntValue(flags, "--timeout");
+  const healthyThreshold = getFlagIntValue(flags, "--healthy-threshold");
+  const unhealthyThreshold = getFlagIntValue(flags, "--unhealthy-threshold");
+  const request = {
+    metadata: {
+      name: name || "",
+      namespace
+    },
+    spec: {
+      timeout: timeout || 5,
+      interval: interval || 10,
+      healthy_threshold: healthyThreshold || 2,
+      unhealthy_threshold: unhealthyThreshold || 3
+    }
+  };
+  switch (type) {
+    case "http": {
+      const path = getFlagValue(flags, "--path") || "/";
+      const useOriginServerName = isFlagSet(
+        flags,
+        "--use-origin-server-name"
+      );
+      const useHttp2 = isFlagSet(flags, "--use-http2");
+      const expectedStatus = getFlagValue(flags, "--expected-status");
+      const hostHeader = getFlagValue(flags, "--host-header");
+      request.spec.http_health_check = {
+        path,
+        use_origin_server_name: useOriginServerName,
+        use_http2: useHttp2
+      };
+      if (expectedStatus) {
+        request.spec.http_health_check.expected_status_codes = expectedStatus.split(",").map((s) => s.trim());
+      }
+      if (hostHeader) {
+        request.spec.http_health_check.headers = {
+          Host: hostHeader
+        };
+      }
+      break;
+    }
+    case "tcp": {
+      request.spec.tcp_health_check = {};
+      break;
+    }
+    case "dns": {
+      request.spec.dns_health_check = {};
+      break;
+    }
+    case "udp-icmp": {
+      break;
+    }
+  }
+  return request;
+}
+function validateHealthcheckFlags(flags) {
+  const errors = [];
+  const name = getFlagValue(flags, "--name");
+  if (!name) {
+    errors.push("--name is required");
+  } else if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(name) && name.length > 1) {
+    errors.push(
+      "--name must contain only lowercase alphanumeric characters and hyphens"
+    );
+  }
+  const type = getFlagValue(flags, "--type");
+  if (!type) {
+    errors.push("--type is required (http, tcp, dns, or udp-icmp)");
+  }
+  const interval = getFlagIntValue(flags, "--interval");
+  if (interval === void 0) {
+    errors.push("--interval is required");
+  } else if (interval < 1 || interval > 600) {
+    errors.push("--interval must be between 1 and 600 seconds");
+  }
+  const timeout = getFlagIntValue(flags, "--timeout");
+  if (timeout === void 0) {
+    errors.push("--timeout is required");
+  } else if (timeout < 1 || timeout > 600) {
+    errors.push("--timeout must be between 1 and 600 seconds");
+  }
+  const healthyThreshold = getFlagIntValue(flags, "--healthy-threshold");
+  if (healthyThreshold === void 0) {
+    errors.push("--healthy-threshold is required");
+  } else if (healthyThreshold < 1 || healthyThreshold > 16) {
+    errors.push("--healthy-threshold must be between 1 and 16");
+  }
+  const unhealthyThreshold = getFlagIntValue(flags, "--unhealthy-threshold");
+  if (unhealthyThreshold === void 0) {
+    errors.push("--unhealthy-threshold is required");
+  } else if (unhealthyThreshold < 1 || unhealthyThreshold > 16) {
+    errors.push("--unhealthy-threshold must be between 1 and 16");
+  }
+  if (type === "http") {
+    const path = getFlagValue(flags, "--path");
+    if (path && !path.startsWith("/")) {
+      errors.push("--path must start with /");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/repl/creation/builders/origin-pool-builder.ts
+function buildOriginPoolRequest(flags, namespace) {
+  const name = getFlagValue(flags, "--name");
+  const port = getFlagIntValue(flags, "--port");
+  const algorithm = getFlagValue(flags, "--algorithm");
+  const site = getFlagValue(flags, "--site");
+  const originServers = [];
+  const publicIps = getFlagValues(flags, "--public-ip");
+  for (const ip of publicIps) {
+    originServers.push({ public_ip: { ip } });
+  }
+  const publicNames = getFlagValues(flags, "--public-name");
+  for (const dnsName of publicNames) {
+    originServers.push({ public_name: { dns_name: dnsName } });
+  }
+  const privateIps = getFlagValues(flags, "--private-ip");
+  for (const ip of privateIps) {
+    const origin = {
+      private_ip: { ip }
+    };
+    if (site) {
+      origin.private_ip.site_locator = {
+        site: { name: site, namespace: "system" }
+      };
+    }
+    originServers.push(origin);
+  }
+  const privateNames = getFlagValues(flags, "--private-name");
+  for (const dnsName of privateNames) {
+    const origin = {
+      private_name: { dns_name: dnsName }
+    };
+    if (site) {
+      origin.private_name.site_locator = {
+        site: { name: site, namespace: "system" }
+      };
+    }
+    originServers.push(origin);
+  }
+  const k8sServices = getFlagValues(flags, "--k8s-service");
+  for (const svc of k8sServices) {
+    const origin = {
+      k8s_service: { service_name: svc }
+    };
+    if (site) {
+      origin.k8s_service.site_locator = {
+        site: { name: site, namespace: "system" }
+      };
+    }
+    originServers.push(origin);
+  }
+  const consulServices = getFlagValues(flags, "--consul-service");
+  for (const svc of consulServices) {
+    const origin = {
+      consul_service: { service_name: svc }
+    };
+    if (site) {
+      origin.consul_service.site_locator = {
+        site: { name: site, namespace: "system" }
+      };
+    }
+    originServers.push(origin);
+  }
+  const customEndpoints = getFlagValues(flags, "--custom-endpoint");
+  for (const endpoint of customEndpoints) {
+    originServers.push({
+      custom_endpoint_object: {
+        endpoint: { name: endpoint, namespace }
+      }
+    });
+  }
+  const vnPrivateIps = getFlagValues(flags, "--vn-private-ip");
+  for (const ip of vnPrivateIps) {
+    originServers.push({
+      vn_private_ip: { ip }
+    });
+  }
+  const vnPrivateNames = getFlagValues(flags, "--vn-private-name");
+  for (const dnsName of vnPrivateNames) {
+    originServers.push({
+      vn_private_name: { dns_name: dnsName }
+    });
+  }
+  const request = {
+    metadata: {
+      name: name || "",
+      namespace
+    },
+    spec: {
+      origin_servers: originServers
+    }
+  };
+  if (port !== void 0) {
+    request.spec.port = port;
+  } else if (isFlagSet(flags, "--automatic-port")) {
+    request.spec.automatic_port = {};
+  } else if (isFlagSet(flags, "--lb-port")) {
+    request.spec.lb_port = {};
+  }
+  if (algorithm) {
+    request.spec.loadbalancer_algorithm = algorithm;
+  }
+  if (isFlagSet(flags, "--no-tls")) {
+    request.spec.no_tls = {};
+  } else if (isFlagSet(flags, "--use-tls")) {
+    request.spec.use_tls = {
+      use_host_header_as_sni: {},
+      tls_config: {
+        default_security: {}
+      },
+      skip_server_verification: {}
+    };
+  }
+  const healthChecks = getFlagValues(flags, "--health-check");
+  if (healthChecks.length > 0) {
+    request.spec.healthcheck = healthChecks.map((hc) => ({
+      name: hc,
+      namespace
+    }));
+  }
+  return request;
+}
+function validateOriginPoolFlags(flags) {
+  const errors = [];
+  const name = getFlagValue(flags, "--name");
+  if (!name) {
+    errors.push("--name is required");
+  } else if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$/.test(name) && name.length > 1) {
+    errors.push(
+      "--name must contain only lowercase alphanumeric characters and hyphens"
+    );
+  }
+  const originFlagNames = [
+    "--public-ip",
+    "--public-name",
+    "--private-ip",
+    "--private-name",
+    "--k8s-service",
+    "--consul-service",
+    "--custom-endpoint",
+    "--vn-private-ip",
+    "--vn-private-name",
+    "--cbip-service"
+  ];
+  let hasOrigin = false;
+  for (const flagName of originFlagNames) {
+    if (getFlagValues(flags, flagName).length > 0) {
+      hasOrigin = true;
+      break;
+    }
+  }
+  if (!hasOrigin) {
+    errors.push(
+      "At least one origin server is required (e.g., --public-ip, --public-name)"
+    );
+  }
+  const port = getFlagIntValue(flags, "--port");
+  if (port !== void 0 && (port < 1 || port > 65535)) {
+    errors.push("--port must be between 1 and 65535");
+  }
+  const portOptions = [
+    isFlagSet(flags, "--port") || port !== void 0,
+    isFlagSet(flags, "--automatic-port"),
+    isFlagSet(flags, "--lb-port")
+  ].filter(Boolean).length;
+  if (portOptions > 1) {
+    errors.push(
+      "--port, --automatic-port, and --lb-port are mutually exclusive"
+    );
+  }
+  if (isFlagSet(flags, "--no-tls") && isFlagSet(flags, "--use-tls")) {
+    errors.push("--no-tls and --use-tls are mutually exclusive");
+  }
+  const privateIps = getFlagValues(flags, "--private-ip");
+  const privateNames = getFlagValues(flags, "--private-name");
+  const k8sServices = getFlagValues(flags, "--k8s-service");
+  const consulServices = getFlagValues(flags, "--consul-service");
+  if ((privateIps.length > 0 || privateNames.length > 0 || k8sServices.length > 0 || consulServices.length > 0) && !getFlagValue(flags, "--site")) {
+    errors.push(
+      "--site is required when using private origins (--private-ip, --private-name, --k8s-service, --consul-service)"
+    );
+  }
+  const healthChecks = getFlagValues(flags, "--health-check");
+  if (healthChecks.length > 4) {
+    errors.push("Maximum of 4 health checks allowed");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/repl/creation/builders/index.ts
+var BUILDERS_REGISTRY = {
+  healthcheck: {
+    build: (flags, namespace) => buildHealthcheckRequest(flags, namespace),
+    validate: validateHealthcheckFlags
+  },
+  origin_pool: {
+    build: (flags, namespace) => buildOriginPoolRequest(flags, namespace),
+    validate: validateOriginPoolFlags
+  }
+};
+function getResourceBuilder(resourceType) {
+  return BUILDERS_REGISTRY[resourceType];
+}
+function hasResourceBuilder(resourceType) {
+  return resourceType in BUILDERS_REGISTRY;
+}
+function buildResource(resourceType, flags, namespace) {
+  const builder = getResourceBuilder(resourceType);
+  if (!builder) {
+    return null;
+  }
+  return builder.build(flags, namespace);
+}
+function validateResourceFlags(resourceType, flags) {
+  const builder = getResourceBuilder(resourceType);
+  if (!builder) {
+    return {
+      valid: false,
+      errors: [`No builder found for resource type: ${resourceType}`]
+    };
+  }
+  return builder.validate(flags);
+}
+
 // src/repl/executor.ts
 var WRITE_OPERATIONS = /* @__PURE__ */ new Set([
   "create",
@@ -96508,15 +97596,153 @@ async function executeAPICommand(session, ctx, cmd) {
       case "create":
       case "replace":
       case "apply": {
-        return {
-          output: [
+        let requestBody = null;
+        if (hasFileFlag(args)) {
+          const filePath = getFilePath(args);
+          if (!filePath) {
+            return {
+              output: ["Error: --file requires a file path"],
+              shouldExit: false,
+              shouldClear: false,
+              contextChanged: false
+            };
+          }
+          try {
+            const absolutePath = resolve(filePath);
+            const fileContent = await fs4.readFile(
+              absolutePath,
+              "utf-8"
+            );
+            requestBody = import_yaml4.default.parse(fileContent);
+            if (!requestBody || typeof requestBody !== "object") {
+              return {
+                output: [
+                  "Error: File must contain a valid YAML/JSON object"
+                ],
+                shouldExit: false,
+                shouldClear: false,
+                contextChanged: false
+              };
+            }
+          } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return {
+              output: [`Error reading file: ${errMsg}`],
+              shouldExit: false,
+              shouldClear: false,
+              contextChanged: false
+            };
+          }
+        } else if (effectiveResourceType && hasResourceBuilder(effectiveResourceType) && hasCreationFlagsInArgs(args, effectiveResourceType)) {
+          const parsed = parseCreationFlags(
+            args,
+            effectiveResourceType
+          );
+          if (parsed.errors.length > 0) {
+            return {
+              output: [
+                "Error parsing creation flags:",
+                ...parsed.errors.map((e) => `  - ${e}`)
+              ],
+              shouldExit: false,
+              shouldClear: false,
+              contextChanged: false
+            };
+          }
+          const validation = validateResourceFlags(
+            effectiveResourceType,
+            parsed
+          );
+          if (!validation.valid) {
+            return {
+              output: [
+                "Validation errors:",
+                ...validation.errors.map((e) => `  - ${e}`)
+              ],
+              shouldExit: false,
+              shouldClear: false,
+              contextChanged: false
+            };
+          }
+          requestBody = buildResource(
+            effectiveResourceType,
+            parsed,
+            effectiveNamespace
+          );
+        } else {
+          const supportsFlagCreation = effectiveResourceType && hasResourceBuilder(effectiveResourceType);
+          const hints = [
             `Action '${action}' requires a resource specification.`,
-            "Use --file <path> to provide resource YAML/JSON."
-          ],
-          shouldExit: false,
-          shouldClear: false,
-          contextChanged: false
-        };
+            "",
+            "Options:",
+            "  1. Use --file <path> to provide resource YAML/JSON"
+          ];
+          if (supportsFlagCreation) {
+            hints.push(
+              `  2. Use creation flags (e.g., --name, --type, etc.)`,
+              "",
+              `Example with flags:`,
+              `  create ${effectiveResourceType} --name my-resource ...`
+            );
+          }
+          return {
+            output: hints,
+            shouldExit: false,
+            shouldClear: false,
+            contextChanged: false
+          };
+        }
+        if (!requestBody) {
+          return {
+            output: ["Error: Failed to build request body"],
+            shouldExit: false,
+            shouldClear: false,
+            contextChanged: false
+          };
+        }
+        if (action === "create") {
+          const response = await client.post(apiPath, requestBody);
+          result = response.data ?? {
+            message: `Created ${canonicalDomain}`
+          };
+        } else if (action === "replace") {
+          const resourceName = requestBody.metadata?.name ?? name;
+          if (resourceName && !usedOperationPath) {
+            apiPath += `/${resourceName}`;
+          }
+          const response = await client.put(apiPath, requestBody);
+          result = response.data ?? {
+            message: `Replaced ${canonicalDomain}`
+          };
+        } else {
+          try {
+            const response = await client.post(
+              apiPath,
+              requestBody
+            );
+            result = response.data ?? {
+              message: `Applied ${canonicalDomain}`
+            };
+          } catch (postError) {
+            if (postError instanceof APIError && postError.statusCode === 409) {
+              const resourceName = requestBody.metadata?.name ?? name;
+              let putPath = apiPath;
+              if (resourceName && !usedOperationPath) {
+                putPath += `/${resourceName}`;
+              }
+              const response = await client.put(
+                putPath,
+                requestBody
+              );
+              result = response.data ?? {
+                message: `Updated ${canonicalDomain}`
+              };
+            } else {
+              throw postError;
+            }
+          }
+        }
+        break;
       }
       case "status": {
         if (!name) {
@@ -96747,11 +97973,11 @@ init_terminal2();
 
 // src/debug/logger.ts
 import { appendFileSync, writeFileSync as writeFileSync2 } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 var DEBUG_ENABLED = process.env.XCSH_DEBUG === "1" || process.env.DEBUG === "xcsh" || process.env.DEBUG === "*";
 var DEBUG_FILE = process.env.XCSH_DEBUG_FILE || "./xcsh-debug.log";
 if (DEBUG_ENABLED) {
-  const logPath = resolve(DEBUG_FILE);
+  const logPath = resolve2(DEBUG_FILE);
   try {
     writeFileSync2(
       logPath,