@robinmordasiewicz/f5xc-xcsh 6.42.0 → 6.44.0

package/dist/index.js

@@ -45354,8 +45354,8 @@ function getLogoModeFromEnv(envPrefix) {
 var CLI_NAME = "xcsh";
 var CLI_FULL_NAME = "F5 Distributed Cloud Shell";
 function getVersion() {
-  if ("6.42.0") {
-    return "6.42.0";
+  if ("6.44.0") {
+    return "6.44.0";
   }
   if (process.env.XCSH_VERSION) {
     return process.env.XCSH_VERSION;
@@ -45830,21 +45830,35 @@ var APIClient = class {
       this._validationError = null;
       return { valid: true };
     } catch (error) {
-      this._isValidated = false;
       if (error instanceof APIError) {
         if (error.statusCode === 401) {
+          this._isValidated = false;
           this._validationError = "Invalid or expired API token";
+          return { valid: false, error: this._validationError };
         } else if (error.statusCode === 403) {
+          this._isValidated = false;
           this._validationError = "Token lacks required permissions";
-        } else if (error.statusCode === 0) {
-          this._validationError = "Network error - could not reach server";
+          return { valid: false, error: this._validationError };
         } else {
-          this._validationError = `Validation failed: HTTP ${error.statusCode}`;
+          if (this.debug) {
+            console.error(
+              `DEBUG: Validation endpoint returned ${error.statusCode}, assuming token is valid`
+            );
+          }
+          this._isValidated = true;
+          this._validationError = null;
+          return { valid: true };
         }
       } else {
-        this._validationError = `Validation failed: ${error instanceof Error ? error.message : "Unknown error"}`;
+        if (this.debug) {
+          console.error(
+            `DEBUG: Validation error: ${error instanceof Error ? error.message : "Unknown"}, assuming token is valid`
+          );
+        }
+        this._isValidated = true;
+        this._validationError = null;
+        return { valid: true };
       }
-      return { valid: false, error: this._validationError };
     }
   }
   /**
@@ -46805,6 +46819,135 @@ function getCommandSpec(commandPath) {
   return void 0;
 }
 
+// src/debug/protocol.ts
+function getDebugFormat() {
+  const envValue = process.env[`${ENV_PREFIX}_DEBUG_EVENTS`];
+  if (envValue === "jsonl" || envValue === "human") {
+    return envValue;
+  }
+  if (process.env[`${ENV_PREFIX}_DEBUG`] === "true") {
+    return "human";
+  }
+  return "none";
+}
+var DebugProtocolImpl = class {
+  format;
+  events = [];
+  startTime;
+  constructor() {
+    this.format = getDebugFormat();
+    this.startTime = Date.now();
+  }
+  /**
+   * Check if debug events are enabled
+   */
+  isEnabled() {
+    return this.format !== "none";
+  }
+  /**
+   * Check if JSONL format is enabled
+   */
+  isJsonl() {
+    return this.format === "jsonl";
+  }
+  /**
+   * Emit a debug event
+   */
+  emit(type, event, data = {}) {
+    if (!this.isEnabled()) return;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      event,
+      data: {
+        ...data,
+        elapsedMs: Date.now() - this.startTime
+      }
+    };
+    this.events.push(entry);
+    if (this.format === "jsonl") {
+      console.error(JSON.stringify(entry));
+    } else if (this.format === "human") {
+      const prefix = `DEBUG [${type}:${event}]`;
+      const dataStr = Object.keys(data).length > 0 ? ` ${JSON.stringify(data)}` : "";
+      console.error(`${prefix}${dataStr}`);
+    }
+  }
+  /**
+   * Emit session-related event
+   */
+  session(event, data = {}) {
+    this.emit("session", event, data);
+  }
+  /**
+   * Emit API-related event
+   */
+  api(event, data = {}) {
+    this.emit("api", event, data);
+  }
+  /**
+   * Emit authentication-related event
+   */
+  auth(event, data = {}) {
+    this.emit("auth", event, data);
+  }
+  /**
+   * Emit profile-related event
+   */
+  profile(event, data = {}) {
+    this.emit("profile", event, data);
+  }
+  /**
+   * Emit UI-related event
+   */
+  ui(event, data = {}) {
+    this.emit("ui", event, data);
+  }
+  /**
+   * Emit error event
+   */
+  error(event, error, data = {}) {
+    this.emit("error", event, {
+      ...data,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : void 0
+    });
+  }
+  /**
+   * Get all captured events
+   */
+  getEvents() {
+    return [...this.events];
+  }
+  /**
+   * Dump session state on exit (for --dump-state-on-exit)
+   */
+  dumpState(state) {
+    if (!this.isEnabled()) return;
+    console.error("\n=== Session State Dump ===");
+    console.error(JSON.stringify(state, null, 2));
+    console.error("=== End Session State ===\n");
+  }
+};
+var debugProtocol = new DebugProtocolImpl();
+function emitSessionState(session) {
+  debugProtocol.auth("session_state", {
+    isAuthenticated: session.isAuthenticated(),
+    isTokenValidated: session.isTokenValidated(),
+    validationError: session.getValidationError(),
+    serverUrl: session.getServerUrl(),
+    activeProfile: session.getActiveProfileName(),
+    hasApiClient: session.getAPIClient() !== null
+  });
+  const showsWarning = session.isAuthenticated() && !session.isTokenValidated() && session.getValidationError();
+  debugProtocol.auth("warning_check", {
+    shouldShowWarning: !!showsWarning,
+    isAuthenticated: session.isAuthenticated(),
+    isTokenValidated: session.isTokenValidated(),
+    hasValidationError: !!session.getValidationError()
+  });
+}
+
 // src/repl/session.ts
 var NAMESPACE_CACHE_TTL = 5 * 60 * 1e3;
 var REPLSession = class {
@@ -46863,9 +47006,19 @@ var REPLSession = class {
     }
     await this.loadActiveProfile();
     if (this._apiClient?.isAuthenticated()) {
+      debugProtocol.auth("token_validation_start", {
+        serverUrl: this._serverUrl,
+        hasApiClient: true
+      });
       const result = await this._apiClient.validateToken();
       this._tokenValidated = result.valid;
       this._validationError = result.error ?? null;
+      debugProtocol.auth("token_validation_complete", {
+        valid: result.valid,
+        error: result.error,
+        tokenValidated: this._tokenValidated,
+        validationError: this._validationError
+      });
       if (result.valid) {
         await this.fetchUserInfo();
       }
@@ -46927,7 +47080,10 @@ var REPLSession = class {
           }
         }
       }
-    } catch {
+    } catch (error) {
+      debugProtocol.error("profile_load_failed", error, {
+        activeProfile: this._activeProfileName
+      });
     }
   }
   /**
@@ -53187,6 +53343,8 @@ program2.name(CLI_NAME).description("F5 Distributed Cloud Shell - Interactive CL
       process.stdout.write("Initializing...");
       const session = new REPLSession();
       await session.initialize();
+      debugProtocol.session("init", { mode: "repl" });
+      emitSessionState(session);
       process.stdout.write("\r\x1B[K");
       renderBanner(cliLogoMode, "startup");
       if (session.isAuthenticated() && !session.isTokenValidated() && session.getValidationError()) {
@@ -53232,6 +53390,11 @@ program2.name(CLI_NAME).description("F5 Distributed Cloud Shell - Interactive CL
 async function executeNonInteractive(args) {
   const session = new REPLSession();
   await session.initialize();
+  debugProtocol.session("init", {
+    mode: "non-interactive",
+    command: args.join(" ")
+  });
+  emitSessionState(session);
   if (session.isAuthenticated() && !session.isTokenValidated() && session.getValidationError()) {
     console.error(
       `${colors.yellow}Warning: ${session.getValidationError()}${colors.reset}`

package/package.json

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